lael-labs/linux

Documentation/arm64/silicon-errata.rst+2−0

 +----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX2 SMMUv3| #126            | N/A                         |
 +----------------+-----------------+-----------------+-----------------------------+
+| Cavium         | ThunderX2 Core  | #219            | CAVIUM_TX2_ERRATUM_219      |
++----------------+-----------------+-----------------+-----------------------------+
 +----------------+-----------------+-----------------+-----------------------------+
 | Freescale/NXP  | LS2080A/LS1043A | A-008585        | FSL_ERRATUM_A008585         |
 +----------------+-----------------+-----------------+-----------------------------+

Documentation/devicetree/bindings/dsp/fsl,dsp.yaml+1−0

@@ -85,4 +85,5 @@ examples: · 84 unmodified lines
85	<&pd IMX_SC_R_DSP_RAM>;	85	<&pd IMX_SC_R_DSP_RAM>;
86	mbox-names = "txdb0", "txdb1", "rxdb0", "rxdb1";	86	mbox-names = "txdb0", "txdb1", "rxdb0", "rxdb1";
87	mboxes = <&lsio_mu13 2 0>, <&lsio_mu13 2 1>, <&lsio_mu13 3 0>, <&lsio_mu13 3 1>;	87	mboxes = <&lsio_mu13 2 0>, <&lsio_mu13 2 1>, <&lsio_mu13 3 0>, <&lsio_mu13 3 1>;
		88	memory-region = <&dsp_reserved>;
88	};	89	};

Documentation/devicetree/bindings/iio/adc/adi,ad7192.yaml+3−4

   dvdd-supply:
     description: DVdd voltage supply
-    items:
-      - const: dvdd
   avdd-supply:
     description: AVdd voltage supply
-    items:
-      - const: avdd
   adi,rejection-60-Hz-enable:
     description: |
 examples:
   - |
     spi0 {
+      #address-cells = <1>;
+      #size-cells = <0>;
       adc@0 {
         compatible = "adi,ad7192";
         reg = <0>;

Documentation/devicetree/bindings/media/rc.yaml+0−1

@@ -73,7 +73,6 @@ properties: · 72 unmodified lines
73	- rc-genius-tvgo-a11mce	73	- rc-genius-tvgo-a11mce
74	- rc-gotview7135	74	- rc-gotview7135
75	- rc-hauppauge	75	- rc-hauppauge
76	- rc-hauppauge
77	- rc-hisi-poplar	76	- rc-hisi-poplar
78	- rc-hisi-tv-demo	77	- rc-hisi-tv-demo
79	- rc-imon-mce	78	- rc-imon-mce

Documentation/devicetree/bindings/phy/lantiq,vrx200-pcie-phy.yaml+1−1

@@ -37,7 +37,7 @@ properties: · 36 unmodified lines
37	- description: exclusive PHY reset line	37	- description: exclusive PHY reset line
38	- description: shared reset line between the PCIe PHY and PCIe controller	38	- description: shared reset line between the PCIe PHY and PCIe controller
39		39
40	resets-names:	40	reset-names:
41	items:	41	items:
42	- const: phy	42	- const: phy
43	- const: pcie	43	- const: pcie

Documentation/kbuild/makefiles.rst+0−5

@@ -954,11 +954,6 @@ When kbuild executes, the following steps are followed (roughly): · 953 unmodified lines
954		954
955	From commandline LDFLAGS_MODULE shall be used (see kbuild.txt).	955	From commandline LDFLAGS_MODULE shall be used (see kbuild.txt).
956		956
957	KBUILD_ARFLAGS Options for $(AR) when creating archives
958
959	$(KBUILD_ARFLAGS) set by the top level Makefile to "D" (deterministic
960	mode) if this option is supported by $(AR).
961
962	KBUILD_LDS	957	KBUILD_LDS
963		958
964	The linker script with full path. Assigned by the top-level Makefile.	959	The linker script with full path. Assigned by the top-level Makefile.

Documentation/kbuild/modules.rst+4−3

 	will be written containing all exported symbols that were not
 	defined in the kernel.
---- 6.3 Symbols From Another External Module
+6.3 Symbols From Another External Module
+----------------------------------------
 	Sometimes, an external module uses exported symbols from
-	another external module. kbuild needs to have full knowledge of
+	another external module. Kbuild needs to have full knowledge of
 	all symbols to avoid spitting out warnings about undefined
 	symbols. Three solutions exist for this situation.
 		The top-level kbuild file would then look like::
 			#./Kbuild (or ./Makefile):
-				obj-y := foo/ bar/
+				obj-m := foo/ bar/
 		And executing::

Documentation/kbuild/reproducible-builds.rst+9−4

 Timestamps
 ----------
-The kernel embeds a timestamp in two places:
+The kernel embeds timestamps in three places:
 * The version string exposed by ``uname()`` and included in
   ``/proc/version``
 * File timestamps in the embedded initramfs
-By default the timestamp is the current time.  This must be overridden
+* If enabled via ``CONFIG_IKHEADERS``, file timestamps of kernel
-using the `KBUILD_BUILD_TIMESTAMP`_ variable.  If you are building
+  headers embedded in the kernel or respective module,
-from a git commit, you could use its commit date.
+  exposed via ``/sys/kernel/kheaders.tar.xz``
+By default the timestamp is the current time and in the case of
+``kheaders`` the various files' modification times. This must
+be overridden using the `KBUILD_BUILD_TIMESTAMP`_ variable.
+If you are building from a git commit, you could use its commit date.
 The kernel does *not* use the ``__DATE__`` and ``__TIME__`` macros,
 and enables warnings if they are used.  If you incorporate external

Documentation/networking/device_drivers/index.rst+1−0

@@ -23,6 +23,7 @@ Contents: · 22 unmodified lines
23	intel/ice	23	intel/ice
24	google/gve	24	google/gve
25	mellanox/mlx5	25	mellanox/mlx5
		26	netronome/nfp
26	pensando/ionic	27	pensando/ionic
27		28
28	.. only:: subproject and html	29	.. only:: subproject and html

Documentation/networking/j1939.rst+1−1

@@ -272,7 +272,7 @@ supported flags are: · 271 unmodified lines
272	* MSG_DONTWAIT, i.e. non-blocking operation.	272	* MSG_DONTWAIT, i.e. non-blocking operation.
273		273
274	recvmsg(2)	274	recvmsg(2)
275	^^^^^^^^^	275	^^^^^^^^^^
276		276
277	In most cases recvmsg(2) is needed if you want to extract more information than	277	In most cases recvmsg(2) is needed if you want to extract more information than
278	recvfrom(2) can provide. For example package priority and timestamp. The	278	recvfrom(2) can provide. For example package priority and timestamp. The

MAINTAINERS+4−0

 M:	Chao Yu <yuchao0@huawei.com>
 L:	linux-erofs@lists.ozlabs.org
 S:	Maintained
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/xiang/erofs.git
+F:	Documentation/filesystems/erofs.txt
 F:	fs/erofs/
+F:	include/trace/events/erofs.h
 ERRSEQ ERROR TRACKING INFRASTRUCTURE
 M:	Jeff Layton <jlayton@kernel.org>
 KGDB / KDB /debug_core
 M:	Jason Wessel <jason.wessel@windriver.com>
 M:	Daniel Thompson <daniel.thompson@linaro.org>
+R:	Douglas Anderson <dianders@chromium.org>
 W:	http://kgdb.wiki.kernel.org/
 L:	kgdb-bugreport@lists.sourceforge.net
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/kgdb.git

Makefile+4−24

 VERSION = 5
 PATCHLEVEL = 4
 SUBLEVEL = 0
-EXTRAVERSION = -rc1
+EXTRAVERSION = -rc2
-NAME = Bobtail Squid
+NAME = Nesting Opossum
 # *DOCUMENTATION*
 # To see a list of typical targets execute "make help"
   KBUILD_CHECKSRC = 0
 endif
-# Use make M=dir to specify directory of external module to build
+# Use make M=dir or set the environment variable KBUILD_EXTMOD to specify the
-# Old syntax make ... SUBDIRS=$PWD is still supported
+# directory of external module to build. Setting M= takes precedence.
-# Setting the environment variable KBUILD_EXTMOD take precedence
-ifdef SUBDIRS
-  $(warning ================= WARNING ================)
-  $(warning 'SUBDIRS' will be removed after Linux 5.3)
-  $(warning )
-  $(warning If you are building an individual subdirectory)
-  $(warning in the kernel tree, you can do like this:)
-  $(warning $$ make path/to/dir/you/want/to/build/)
-  $(warning (Do not forget the trailing slash))
-  $(warning )
-  $(warning If you are building an external module,)
-  $(warning Please use 'M=' or 'KBUILD_EXTMOD' instead)
-  $(warning ==========================================)
-  KBUILD_EXTMOD ?= $(SUBDIRS)
-endif
 ifeq ("$(origin M)", "command line")
   KBUILD_EXTMOD := $(M)
 endif
 export KBUILD_AFLAGS AFLAGS_KERNEL AFLAGS_MODULE
 export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_LDFLAGS_MODULE
 export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL
-export KBUILD_ARFLAGS
 # Files to ignore in find ... statements
 KBUILD_CFLAGS += $(call cc-option,-fcf-protection=none)
 endif
-# use the deterministic mode of AR if available
-KBUILD_ARFLAGS := $(call ar-option,D)
 include scripts/Makefile.kasan
 include scripts/Makefile.extrawarn
 include scripts/Makefile.ubsan

arch/arm/boot/dts/am335x-icev2.dts+1−1

@@ -432,7 +432,7 @@ · 431 unmodified lines
432	pinctrl-0 = <&mmc0_pins_default>;	432	pinctrl-0 = <&mmc0_pins_default>;
433	};	433	};
434		434
435	&gpio0 {	435	&gpio0_target {
436	/* Do not idle the GPIO used for holding the VTT regulator */	436	/* Do not idle the GPIO used for holding the VTT regulator */
437	ti,no-reset-on-init;	437	ti,no-reset-on-init;
438	ti,no-idle-on-init;	438	ti,no-idle-on-init;

arch/arm/boot/dts/am33xx-l4.dtsi+4−2

 			ranges = <0x0 0x5000 0x1000>;
 		};
-		target-module@7000 {			/* 0x44e07000, ap 14 20.0 */
+		gpio0_target: target-module@7000 {	/* 0x44e07000, ap 14 20.0 */
 			compatible = "ti,sysc-omap2", "ti,sysc";
 			ti,hwmods = "gpio1";
 			reg = <0x7000 0x4>,
 			reg = <0xe000 0x4>,
 			      <0xe054 0x4>;
 			reg-names = "rev", "sysc";
-			ti,sysc-midle ;
+			ti,sysc-midle = <SYSC_IDLE_FORCE>,
+					<SYSC_IDLE_NO>,
+					<SYSC_IDLE_SMART>;
 			ti,sysc-sidle = <SYSC_IDLE_FORCE>,
 					<SYSC_IDLE_NO>,
 					<SYSC_IDLE_SMART>;

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

@@ -337,6 +337,8 @@ · 336 unmodified lines
337	ti,hwmods = "dss_dispc";	337	ti,hwmods = "dss_dispc";
338	clocks = <&disp_clk>;	338	clocks = <&disp_clk>;
339	clock-names = "fck";	339	clock-names = "fck";
		340
		341	max-memory-bandwidth = <230000000>;
340	};	342	};
341		343
342	rfbi: rfbi@4832a800 {	344	rfbi: rfbi@4832a800 {

arch/arm/boot/dts/dra7-l4.dtsi+21−27

 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 129 1>, <&edma_xbar 128 1>;
 				dma-names = "tx", "rx";
-				clocks = <&ipu_clkctrl DRA7_IPU_MCASP1_CLKCTRL 22>,
+				clocks = <&ipu_clkctrl DRA7_IPU_MCASP1_CLKCTRL 0>,
 					 <&ipu_clkctrl DRA7_IPU_MCASP1_CLKCTRL 24>,
 					 <&ipu_clkctrl DRA7_IPU_MCASP1_CLKCTRL 28>;
 				clock-names = "fck", "ahclkx", "ahclkr";
 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 131 1>, <&edma_xbar 130 1>;
 				dma-names = "tx", "rx";
-				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP2_CLKCTRL 22>,
+				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP2_CLKCTRL 0>,
-					 <&l4per2_clkctrl DRA7_L4PER2_MCASP2_CLKCTRL 24>,
+					 <&ipu_clkctrl DRA7_IPU_MCASP1_CLKCTRL 24>,
 					 <&l4per2_clkctrl DRA7_L4PER2_MCASP2_CLKCTRL 28>;
 				clock-names = "fck", "ahclkx", "ahclkr";
 				status = "disabled";
 					<SYSC_IDLE_SMART>;
 			/* Domains (P, C): l4per_pwrdm, l4per2_clkdm */
 			clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 0>,
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 24>,
+				 <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 24>;
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 28>;
+			clock-names = "fck", "ahclkx";
-			clock-names = "fck", "ahclkx", "ahclkr";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			ranges = <0x0 0x68000 0x2000>,
 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 133 1>, <&edma_xbar 132 1>;
 				dma-names = "tx", "rx";
-				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 22>,
+				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 0>,
 					 <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 24>;
 				clock-names = "fck", "ahclkx";
 				status = "disabled";
 					<SYSC_IDLE_SMART>;
 			/* Domains (P, C): l4per_pwrdm, l4per2_clkdm */
 			clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP4_CLKCTRL 0>,
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP4_CLKCTRL 24>,
+				 <&l4per2_clkctrl DRA7_L4PER2_MCASP4_CLKCTRL 24>;
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP4_CLKCTRL 28>;
+			clock-names = "fck", "ahclkx";
-			clock-names = "fck", "ahclkx", "ahclkr";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			ranges = <0x0 0x6c000 0x2000>,
 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 135 1>, <&edma_xbar 134 1>;
 				dma-names = "tx", "rx";
-				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP4_CLKCTRL 22>,
+				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP4_CLKCTRL 0>,
 					 <&l4per2_clkctrl DRA7_L4PER2_MCASP4_CLKCTRL 24>;
 				clock-names = "fck", "ahclkx";
 				status = "disabled";
 					<SYSC_IDLE_SMART>;
 			/* Domains (P, C): l4per_pwrdm, l4per2_clkdm */
 			clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP5_CLKCTRL 0>,
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP5_CLKCTRL 24>,
+				 <&l4per2_clkctrl DRA7_L4PER2_MCASP5_CLKCTRL 24>;
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP5_CLKCTRL 28>;
+			clock-names = "fck", "ahclkx";
-			clock-names = "fck", "ahclkx", "ahclkr";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			ranges = <0x0 0x70000 0x2000>,
 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 137 1>, <&edma_xbar 136 1>;
 				dma-names = "tx", "rx";
-				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP5_CLKCTRL 22>,
+				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP5_CLKCTRL 0>,
 					 <&l4per2_clkctrl DRA7_L4PER2_MCASP5_CLKCTRL 24>;
 				clock-names = "fck", "ahclkx";
 				status = "disabled";
 					<SYSC_IDLE_SMART>;
 			/* Domains (P, C): l4per_pwrdm, l4per2_clkdm */
 			clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP6_CLKCTRL 0>,
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP6_CLKCTRL 24>,
+				 <&l4per2_clkctrl DRA7_L4PER2_MCASP6_CLKCTRL 24>;
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP6_CLKCTRL 28>;
+			clock-names = "fck", "ahclkx";
-			clock-names = "fck", "ahclkx", "ahclkr";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			ranges = <0x0 0x74000 0x2000>,
 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 139 1>, <&edma_xbar 138 1>;
 				dma-names = "tx", "rx";
-				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP6_CLKCTRL 22>,
+				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP6_CLKCTRL 0>,
 					 <&l4per2_clkctrl DRA7_L4PER2_MCASP6_CLKCTRL 24>;
 				clock-names = "fck", "ahclkx";
 				status = "disabled";
 					<SYSC_IDLE_SMART>;
 			/* Domains (P, C): l4per_pwrdm, l4per2_clkdm */
 			clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP7_CLKCTRL 0>,
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP7_CLKCTRL 24>,
+				 <&l4per2_clkctrl DRA7_L4PER2_MCASP7_CLKCTRL 24>;
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP7_CLKCTRL 28>;
+			clock-names = "fck", "ahclkx";
-			clock-names = "fck", "ahclkx", "ahclkr";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			ranges = <0x0 0x78000 0x2000>,
 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 141 1>, <&edma_xbar 140 1>;
 				dma-names = "tx", "rx";
-				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP7_CLKCTRL 22>,
+				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP7_CLKCTRL 0>,
 					 <&l4per2_clkctrl DRA7_L4PER2_MCASP7_CLKCTRL 24>;
 				clock-names = "fck", "ahclkx";
 				status = "disabled";
 					<SYSC_IDLE_SMART>;
 			/* Domains (P, C): l4per_pwrdm, l4per2_clkdm */
 			clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP8_CLKCTRL 0>,
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP8_CLKCTRL 24>,
+				 <&l4per2_clkctrl DRA7_L4PER2_MCASP8_CLKCTRL 24>;
-				 <&l4per2_clkctrl DRA7_L4PER2_MCASP8_CLKCTRL 28>;
+			clock-names = "fck", "ahclkx";
-			clock-names = "fck", "ahclkx", "ahclkr";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			ranges = <0x0 0x7c000 0x2000>,
 				interrupt-names = "tx", "rx";
 				dmas = <&edma_xbar 143 1>, <&edma_xbar 142 1>;
 				dma-names = "tx", "rx";
-				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP8_CLKCTRL 22>,
+				clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP8_CLKCTRL 0>,
 					 <&l4per2_clkctrl DRA7_L4PER2_MCASP8_CLKCTRL 24>;
 				clock-names = "fck", "ahclkx";
 				status = "disabled";

arch/arm/boot/dts/omap3-gta04.dtsi+1−0

@@ -124,6 +124,7 @@ · 123 unmodified lines
124	spi-max-frequency = <100000>;	124	spi-max-frequency = <100000>;
125	spi-cpol;	125	spi-cpol;
126	spi-cpha;	126	spi-cpha;
		127	spi-cs-high;
127		128
128	backlight= <&backlight>;	129	backlight= <&backlight>;
129	label = "lcd";	130	label = "lcd";

arch/arm/boot/dts/ste-dbx5x0.dtsi+8−3

 #include <dt-bindings/mfd/dbx500-prcmu.h>
 #include <dt-bindings/arm/ux500_pm_domains.h>
 #include <dt-bindings/gpio/gpio.h>
+#include <dt-bindings/thermal/thermal.h>
 / {
 	#address-cells = <1>;
 		 * cooling.
 		 */
 		cpu_thermal: cpu-thermal {
-			polling-delay-passive = <0>;
+			polling-delay-passive = <250>;
-			polling-delay = <1000>;
+			/*
+			 * This sensor fires interrupts to update the thermal
+			 * zone, so no polling is needed.
+			 */
+			polling-delay = <0>;
 			thermal-sensors = <&thermal>;
 			cooling-maps {
 				trip = <&cpu_alert>;
-				cooling-device = <&CPU0 0 2>;
+				cooling-device = <&CPU0 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>;
 				contribution = <100>;
 			};
 		};

arch/arm/configs/davinci_all_defconfig+1−1

@@ -228,7 +228,7 @@ CONFIG_RTC_DRV_OMAP=m · 227 unmodified lines
228	CONFIG_DMADEVICES=y	228	CONFIG_DMADEVICES=y
229	CONFIG_TI_EDMA=y	229	CONFIG_TI_EDMA=y
230	CONFIG_COMMON_CLK_PWM=m	230	CONFIG_COMMON_CLK_PWM=m
231	CONFIG_REMOTEPROC=m	231	CONFIG_REMOTEPROC=y
232	CONFIG_DA8XX_REMOTEPROC=m	232	CONFIG_DA8XX_REMOTEPROC=m
233	CONFIG_MEMORY=y	233	CONFIG_MEMORY=y
234	CONFIG_TI_AEMIF=m	234	CONFIG_TI_AEMIF=m

arch/arm/configs/multi_v7_defconfig+2−2

@@ -415,7 +415,7 @@ CONFIG_SPI_SH_MSIOF=m · 414 unmodified lines
415	CONFIG_SPI_SH_HSPI=y	415	CONFIG_SPI_SH_HSPI=y
416	CONFIG_SPI_SIRF=y	416	CONFIG_SPI_SIRF=y
417	CONFIG_SPI_STM32=m	417	CONFIG_SPI_STM32=m
418	CONFIG_SPI_STM32_QSPI=m	418	CONFIG_SPI_STM32_QSPI=y
419	CONFIG_SPI_SUN4I=y	419	CONFIG_SPI_SUN4I=y
420	CONFIG_SPI_SUN6I=y	420	CONFIG_SPI_SUN6I=y
421	CONFIG_SPI_TEGRA114=y	421	CONFIG_SPI_TEGRA114=y
@@ -933,7 +933,7 @@ CONFIG_BCM2835_MBOX=y · 511 unmodified lines
933	CONFIG_ROCKCHIP_IOMMU=y	933	CONFIG_ROCKCHIP_IOMMU=y
934	CONFIG_TEGRA_IOMMU_GART=y	934	CONFIG_TEGRA_IOMMU_GART=y
935	CONFIG_TEGRA_IOMMU_SMMU=y	935	CONFIG_TEGRA_IOMMU_SMMU=y
936	CONFIG_REMOTEPROC=m	936	CONFIG_REMOTEPROC=y
937	CONFIG_ST_REMOTEPROC=m	937	CONFIG_ST_REMOTEPROC=m
938	CONFIG_RPMSG_VIRTIO=m	938	CONFIG_RPMSG_VIRTIO=m
939	CONFIG_ASPEED_LPC_CTRL=m	939	CONFIG_ASPEED_LPC_CTRL=m

arch/arm/configs/omap2plus_defconfig+4−1

 CONFIG_DRM_OMAP_PANEL_NEC_NL8048HL11=m
 CONFIG_DRM_TILCDC=m
 CONFIG_DRM_PANEL_SIMPLE=m
+CONFIG_DRM_TI_TFP410=m
 CONFIG_FB=y
 CONFIG_FIRMWARE_EDID=y
 CONFIG_FB_MODE_HELPERS=y
 CONFIG_USB_SERIAL_SIMPLE=m
 CONFIG_USB_SERIAL_FTDI_SIO=m
 CONFIG_USB_SERIAL_PL2303=m
+CONFIG_USB_SERIAL_OPTION=m
 CONFIG_USB_TEST=m
 CONFIG_NOP_USB_XCEIV=m
 CONFIG_AM335X_PHY_USB=m
 CONFIG_NEW_LEDS=y
 CONFIG_LEDS_CLASS=m
 CONFIG_LEDS_CPCAP=m
+CONFIG_LEDS_LM3532=m
 CONFIG_LEDS_GPIO=m
 CONFIG_LEDS_PCA963X=m
 CONFIG_LEDS_PWM=m
 CONFIG_RTC_DRV_CPCAP=m
 CONFIG_DMADEVICES=y
 CONFIG_OMAP_IOMMU=y
-CONFIG_REMOTEPROC=m
+CONFIG_REMOTEPROC=y
 CONFIG_OMAP_REMOTEPROC=m
 CONFIG_WKUP_M3_RPROC=m
 CONFIG_SOC_TI=y

arch/arm/include/asm/xen/xen-ops.h+0−6

@@ -1,6 +0,0 @@
1	#ifndef _ASM_XEN_OPS_H
2	#define _ASM_XEN_OPS_H
3
4	void xen_efi_runtime_setup(void);
5
6	#endif /* _ASM_XEN_OPS_H */

arch/arm/mach-omap2/omap_hwmod_33xx_43xx_ipblock_data.c+2−1

 	.rev_offs	= 0x0000,
 	.sysc_offs	= 0x0010,
 	.syss_offs	= 0x0014,
-	.sysc_flags	= (SYSC_HAS_SIDLEMODE | SYSC_HAS_SOFTRESET),
+	.sysc_flags	= SYSC_HAS_SIDLEMODE | SYSC_HAS_SOFTRESET |
+			  SYSC_HAS_RESET_STATUS,
 	.idlemodes	= (SIDLE_FORCE | SIDLE_NO | SIDLE_SMART |
 			  SIDLE_SMART_WKUP),
 	.sysc_fields	= &omap_hwmod_sysc_type2,

arch/arm/mach-omap2/omap_hwmod_33xx_data.c+3−2

 static struct omap_hwmod_class_sysconfig lcdc_sysc = {
 	.rev_offs	= 0x0,
 	.sysc_offs	= 0x54,
-	.sysc_flags	= (SYSC_HAS_SIDLEMODE | SYSC_HAS_MIDLEMODE),
+	.sysc_flags	= SYSC_HAS_SIDLEMODE | SYSC_HAS_MIDLEMODE,
-	.idlemodes	= (SIDLE_FORCE | SIDLE_NO | SIDLE_SMART),
+	.idlemodes	= SIDLE_FORCE | SIDLE_NO | SIDLE_SMART |
+			  MSTANDBY_FORCE | MSTANDBY_NO | MSTANDBY_SMART,
 	.sysc_fields	= &omap_hwmod_sysc_type2,
 };

arch/arm/mach-omap2/pm.c+0−100

@@ -74,83 +74,6 @@ int omap_pm_clkdms_setup(struct clockdomain clkdm, void unused) · 73 unmodified lines
74	return 0;	74	return 0;
75	}	75	}
76		76
77	/*
78	* This API is to be called during init to set the various voltage
79	* domains to the voltage as per the opp table. Typically we boot up
80	* at the nominal voltage. So this function finds out the rate of
81	* the clock associated with the voltage domain, finds out the correct
82	* opp entry and sets the voltage domain to the voltage specified
83	* in the opp entry
84	*/
85	static int __init omap2_set_init_voltage(char vdd_name, char clk_name,
86	const char *oh_name)
87	{
88	struct voltagedomain *voltdm;
89	struct clk *clk;
90	struct dev_pm_opp *opp;
91	unsigned long freq, bootup_volt;
92	struct device *dev;
93
94	if (!vdd_name \|\| !clk_name \|\| !oh_name) {
95	pr_err("%s: invalid parameters\n", __func__);
96	goto exit;
97	}
98
99	if (!strncmp(oh_name, "mpu", 3))
100	/*
101	* All current OMAPs share voltage rail and clock
102	* source, so CPU0 is used to represent the MPU-SS.
103	*/
104	dev = get_cpu_device(0);
105	else
106	dev = omap_device_get_by_hwmod_name(oh_name);
107
108	if (IS_ERR(dev)) {
109	pr_err("%s: Unable to get dev pointer for hwmod %s\n",
110	__func__, oh_name);
111	goto exit;
112	}
113
114	voltdm = voltdm_lookup(vdd_name);
115	if (!voltdm) {
116	pr_err("%s: unable to get vdd pointer for vdd_%s\n",
117	__func__, vdd_name);
118	goto exit;
119	}
120
121	clk = clk_get(NULL, clk_name);
122	if (IS_ERR(clk)) {
123	pr_err("%s: unable to get clk %s\n", __func__, clk_name);
124	goto exit;
125	}
126
127	freq = clk_get_rate(clk);
128	clk_put(clk);
129
130	opp = dev_pm_opp_find_freq_ceil(dev, &freq);
131	if (IS_ERR(opp)) {
132	pr_err("%s: unable to find boot up OPP for vdd_%s\n",
133	__func__, vdd_name);
134	goto exit;
135	}
136
137	bootup_volt = dev_pm_opp_get_voltage(opp);
138	dev_pm_opp_put(opp);
139
140	if (!bootup_volt) {
141	pr_err("%s: unable to find voltage corresponding to the bootup OPP for vdd_%s\n",
142	__func__, vdd_name);
143	goto exit;
144	}
145
146	voltdm_scale(voltdm, bootup_volt);
147	return 0;
148
149	exit:
150	pr_err("%s: unable to set vdd_%s\n", __func__, vdd_name);
151	return -EINVAL;
152	}
153
154	#ifdef CONFIG_SUSPEND	77	#ifdef CONFIG_SUSPEND
155	static int omap_pm_enter(suspend_state_t suspend_state)	78	static int omap_pm_enter(suspend_state_t suspend_state)
156	{	79	{
@@ -208,25 +131,6 @@ void omap_common_suspend_init(void *pm_suspend) · 51 unmodified lines
208	}	131	}
209	#endif /* CONFIG_SUSPEND */	132	#endif /* CONFIG_SUSPEND */
210		133
211	static void __init omap3_init_voltages(void)
212	{
213	if (!soc_is_omap34xx())
214	return;
215
216	omap2_set_init_voltage("mpu_iva", "dpll1_ck", "mpu");
217	omap2_set_init_voltage("core", "l3_ick", "l3_main");
218	}
219
220	static void __init omap4_init_voltages(void)
221	{
222	if (!soc_is_omap44xx())
223	return;
224
225	omap2_set_init_voltage("mpu", "dpll_mpu_ck", "mpu");
226	omap2_set_init_voltage("core", "l3_div_ck", "l3_main_1");
227	omap2_set_init_voltage("iva", "dpll_iva_m5x2_ck", "iva");
228	}
229
230	int __maybe_unused omap_pm_nop_init(void)	134	int __maybe_unused omap_pm_nop_init(void)
231	{	135	{
232	return 0;	136	return 0;
@@ -246,10 +150,6 @@ int __init omap2_common_pm_late_init(void) · 13 unmodified lines
246	omap4_twl_init();	150	omap4_twl_init();
247	omap_voltage_late_init();	151	omap_voltage_late_init();
248		152
249	/* Initialize the voltages */
250	omap3_init_voltages();
251	omap4_init_voltages();
252
253	/* Smartreflex device init */	153	/* Smartreflex device init */
254	omap_devinit_smartreflex();	154	omap_devinit_smartreflex();
255		155

arch/arm/xen/Makefile+0−1

@@ -1,3 +1,2 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	obj-y := enlighten.o hypercall.o grant-table.o p2m.o mm.o	2	obj-y := enlighten.o hypercall.o grant-table.o p2m.o mm.o
3	obj-$(CONFIG_XEN_EFI) += efi.o

arch/arm/xen/efi.c+0−28

@@ -1,28 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Copyright (c) 2015, Linaro Limited, Shannon Zhao
4	*/
5
6	#include <linux/efi.h>
7	#include <xen/xen-ops.h>
8	#include <asm/xen/xen-ops.h>
9
10	/* Set XEN EFI runtime services function pointers. Other fields of struct efi,
11	* e.g. efi.systab, will be set like normal EFI.
12	*/
13	void __init xen_efi_runtime_setup(void)
14	{
15	efi.get_time = xen_efi_get_time;
16	efi.set_time = xen_efi_set_time;
17	efi.get_wakeup_time = xen_efi_get_wakeup_time;
18	efi.set_wakeup_time = xen_efi_set_wakeup_time;
19	efi.get_variable = xen_efi_get_variable;
20	efi.get_next_variable = xen_efi_get_next_variable;
21	efi.set_variable = xen_efi_set_variable;
22	efi.query_variable_info = xen_efi_query_variable_info;
23	efi.update_capsule = xen_efi_update_capsule;
24	efi.query_capsule_caps = xen_efi_query_capsule_caps;
25	efi.get_next_high_mono_count = xen_efi_get_next_high_mono_count;
26	efi.reset_system = xen_efi_reset_system;
27	}
28	EXPORT_SYMBOL_GPL(xen_efi_runtime_setup);

arch/arm/xen/enlighten.c+1−2

 #include <xen/xen-ops.h>
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
-#include <asm/xen/xen-ops.h>
 #include <asm/system_misc.h>
 #include <asm/efi.h>
 #include <linux/interrupt.h>
 EXPORT_SYMBOL_GPL(HYPERVISOR_physdev_op);
 EXPORT_SYMBOL_GPL(HYPERVISOR_vcpu_op);
 EXPORT_SYMBOL_GPL(HYPERVISOR_tmem_op);
-EXPORT_SYMBOL_GPL(HYPERVISOR_platform_op);
+EXPORT_SYMBOL_GPL(HYPERVISOR_platform_op_raw);
 EXPORT_SYMBOL_GPL(HYPERVISOR_multicall);
 EXPORT_SYMBOL_GPL(HYPERVISOR_vm_assist);
 EXPORT_SYMBOL_GPL(HYPERVISOR_dm_op);

arch/arm/xen/mm.c+4−1

 	for_each_memblock(memory, reg) {
 		if (reg->base < (phys_addr_t)0xffffffff) {
-			flags |= __GFP_DMA;
+			if (IS_ENABLED(CONFIG_ZONE_DMA32))
+				flags |= __GFP_DMA32;
+			else
+				flags |= __GFP_DMA;
 			break;
 		}
 	}

arch/arm64/Kconfig+17−0

@@ -616,6 +616,23 @@ config CAVIUM_ERRATUM_30115 · 615 unmodified lines
616		616
617	If unsure, say Y.	617	If unsure, say Y.
618		618
		619	config CAVIUM_TX2_ERRATUM_219
		620	bool "Cavium ThunderX2 erratum 219: PRFM between TTBR change and ISB fails"
		621	default y
		622	help
		623	On Cavium ThunderX2, a load, store or prefetch instruction between a
		624	TTBR update and the corresponding context synchronizing operation can
		625	cause a spurious Data Abort to be delivered to any hardware thread in
		626	the CPU core.
		627
		628	Work around the issue by avoiding the problematic code sequence and
		629	trapping KVM guest TTBRx_EL1 writes to EL2 when SMT is enabled. The
		630	trap handler performs the corresponding register access, skips the
		631	instruction and ensures context synchronization by virtue of the
		632	exception return.
		633
		634	If unsure, say Y.
		635
619	config QCOM_FALKOR_ERRATUM_1003	636	config QCOM_FALKOR_ERRATUM_1003
620	bool "Falkor E1003: Incorrect translation due to ASID change"	637	bool "Falkor E1003: Incorrect translation due to ASID change"
621	default y	638	default y

arch/arm64/configs/defconfig+1−1

@@ -723,7 +723,7 @@ CONFIG_TEGRA_IOMMU_SMMU=y · 722 unmodified lines
723	CONFIG_ARM_SMMU=y	723	CONFIG_ARM_SMMU=y
724	CONFIG_ARM_SMMU_V3=y	724	CONFIG_ARM_SMMU_V3=y
725	CONFIG_QCOM_IOMMU=y	725	CONFIG_QCOM_IOMMU=y
726	CONFIG_REMOTEPROC=m	726	CONFIG_REMOTEPROC=y
727	CONFIG_QCOM_Q6V5_MSS=m	727	CONFIG_QCOM_Q6V5_MSS=m
728	CONFIG_QCOM_Q6V5_PAS=m	728	CONFIG_QCOM_Q6V5_PAS=m
729	CONFIG_QCOM_SYSMON=m	729	CONFIG_QCOM_SYSMON=m

arch/arm64/include/asm/cpucaps.h+3−1

@@ -52,7 +52,9 @@ · 51 unmodified lines
52	#define ARM64_HAS_IRQ_PRIO_MASKING 42	52	#define ARM64_HAS_IRQ_PRIO_MASKING 42
53	#define ARM64_HAS_DCPODP 43	53	#define ARM64_HAS_DCPODP 43
54	#define ARM64_WORKAROUND_1463225 44	54	#define ARM64_WORKAROUND_1463225 44
		55	#define ARM64_WORKAROUND_CAVIUM_TX2_219_TVM 45
		56	#define ARM64_WORKAROUND_CAVIUM_TX2_219_PRFM 46
55		57
56	#define ARM64_NCAPS 45	58	#define ARM64_NCAPS 47
57		59
58	#endif /* __ASM_CPUCAPS_H */	60	#endif /* __ASM_CPUCAPS_H */

arch/arm64/include/asm/kvm_hyp.h+0−24

@@ -47,30 +47,6 @@ · 46 unmodified lines
47	#define read_sysreg_el2(r) read_sysreg_elx(r, _EL2, _EL1)	47	#define read_sysreg_el2(r) read_sysreg_elx(r, _EL2, _EL1)
48	#define write_sysreg_el2(v,r) write_sysreg_elx(v, r, _EL2, _EL1)	48	#define write_sysreg_el2(v,r) write_sysreg_elx(v, r, _EL2, _EL1)
49		49
50	/**
51	* hyp_alternate_select - Generates patchable code sequences that are
52	* used to switch between two implementations of a function, depending
53	* on the availability of a feature.
54	*
55	* @fname: a symbol name that will be defined as a function returning a
56	* function pointer whose type will match @orig and @alt
57	* @orig: A pointer to the default function, as returned by @fname when
58	* @cond doesn't hold
59	* @alt: A pointer to the alternate function, as returned by @fname
60	* when @cond holds
61	* @cond: a CPU feature (as described in asm/cpufeature.h)
62	*/
63	#define hyp_alternate_select(fname, orig, alt, cond) \
64	typeof(orig) * __hyp_text fname(void) \
65	{ \
66	typeof(alt) *val = orig; \
67	asm volatile(ALTERNATIVE("nop \n", \
68	"mov %0, %1 \n", \
69	cond) \
70	: "+r" (val) : "r" (alt)); \
71	return val; \
72	}
73
74	int __vgic_v2_perform_cpuif_access(struct kvm_vcpu *vcpu);	50	int __vgic_v2_perform_cpuif_access(struct kvm_vcpu *vcpu);
75		51
76	void __vgic_v3_save_state(struct kvm_vcpu *vcpu);	52	void __vgic_v3_save_state(struct kvm_vcpu *vcpu);

arch/arm64/include/asm/xen/xen-ops.h+0−7

@@ -1,7 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _ASM_XEN_OPS_H
3	#define _ASM_XEN_OPS_H
4
5	void xen_efi_runtime_setup(void);
6
7	#endif /* _ASM_XEN_OPS_H */

arch/arm64/kernel/cpu_errata.c+38−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <asm/cpu.h>	12	#include <asm/cpu.h>
13	#include <asm/cputype.h>	13	#include <asm/cputype.h>
14	#include <asm/cpufeature.h>	14	#include <asm/cpufeature.h>
		15	#include <asm/smp_plat.h>
15		16
16	static bool __maybe_unused	17	static bool __maybe_unused
17	is_affected_midr_range(const struct arm64_cpu_capabilities *entry, int scope)	18	is_affected_midr_range(const struct arm64_cpu_capabilities *entry, int scope)
@@ -623,6 +624,30 @@ check_branch_predictor(const struct arm64_cpu_capabilities *entry, int scope) · 605 unmodified lines
623	return (need_wa > 0);	624	return (need_wa > 0);
624	}	625	}
625		626
		627	static const __maybe_unused struct midr_range tx2_family_cpus[] = {
		628	MIDR_ALL_VERSIONS(MIDR_BRCM_VULCAN),
		629	MIDR_ALL_VERSIONS(MIDR_CAVIUM_THUNDERX2),
		630	{},
		631	};
		632
		633	static bool __maybe_unused
		634	needs_tx2_tvm_workaround(const struct arm64_cpu_capabilities *entry,
		635	int scope)
		636	{
		637	int i;
		638
		639	if (!is_affected_midr_range_list(entry, scope) \|\|
		640	!is_hyp_mode_available())
		641	return false;
		642
		643	for_each_possible_cpu(i) {
		644	if (MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 0) != 0)
		645	return true;
		646	}
		647
		648	return false;
		649	}
		650
626	#ifdef CONFIG_HARDEN_EL2_VECTORS	651	#ifdef CONFIG_HARDEN_EL2_VECTORS
627		652
628	static const struct midr_range arm64_harden_el2_vectors[] = {	653	static const struct midr_range arm64_harden_el2_vectors[] = {
@@ -851,6 +876,19 @@ const struct arm64_cpu_capabilities arm64_errata[] = { · 222 unmodified lines
851	.type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM,	876	.type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM,
852	.matches = has_cortex_a76_erratum_1463225,	877	.matches = has_cortex_a76_erratum_1463225,
853	},	878	},
		879	#endif
		880	#ifdef CONFIG_CAVIUM_TX2_ERRATUM_219
		881	{
		882	.desc = "Cavium ThunderX2 erratum 219 (KVM guest sysreg trapping)",
		883	.capability = ARM64_WORKAROUND_CAVIUM_TX2_219_TVM,
		884	ERRATA_MIDR_RANGE_LIST(tx2_family_cpus),
		885	.matches = needs_tx2_tvm_workaround,
		886	},
		887	{
		888	.desc = "Cavium ThunderX2 erratum 219 (PRFM removal)",
		889	.capability = ARM64_WORKAROUND_CAVIUM_TX2_219_PRFM,
		890	ERRATA_MIDR_RANGE_LIST(tx2_family_cpus),
		891	},
854	#endif	892	#endif
855	{	893	{
856	}	894	}

arch/arm64/kernel/entry.S+2−0

 #else
 	ldr	x30, =vectors
 #endif
+alternative_if_not ARM64_WORKAROUND_CAVIUM_TX2_219_PRFM
 	prfm	plil1strm, [x30, #(1b - tramp_vectors)]
+alternative_else_nop_endif
 	msr	vbar_el1, x30
 	add	x30, x30, #(1b - tramp_vectors)
 	isb

arch/arm64/kvm/hyp/switch.c+69−17

@@ -124,6 +124,9 @@ static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu) · 123 unmodified lines
124	{	124	{
125	u64 hcr = vcpu->arch.hcr_el2;	125	u64 hcr = vcpu->arch.hcr_el2;
126		126
		127	if (cpus_have_const_cap(ARM64_WORKAROUND_CAVIUM_TX2_219_TVM))
		128	hcr \|= HCR_TVM;
		129
127	write_sysreg(hcr, hcr_el2);	130	write_sysreg(hcr, hcr_el2);
128		131
129	if (cpus_have_const_cap(ARM64_HAS_RAS_EXTN) && (hcr & HCR_VSE))	132	if (cpus_have_const_cap(ARM64_HAS_RAS_EXTN) && (hcr & HCR_VSE))
@@ -174,8 +177,10 @@ static void __hyp_text __deactivate_traps(struct kvm_vcpu *vcpu) · 44 unmodified lines
174	* the crucial bit is "On taking a vSError interrupt,	177	* the crucial bit is "On taking a vSError interrupt,
175	* HCR_EL2.VSE is cleared to 0."	178	* HCR_EL2.VSE is cleared to 0."
176	*/	179	*/
177	if (vcpu->arch.hcr_el2 & HCR_VSE)	180	if (vcpu->arch.hcr_el2 & HCR_VSE) {
178	vcpu->arch.hcr_el2 = read_sysreg(hcr_el2);	181	vcpu->arch.hcr_el2 &= ~HCR_VSE;
		182	vcpu->arch.hcr_el2 \|= read_sysreg(hcr_el2) & HCR_VSE;
		183	}
179		184
180	if (has_vhe())	185	if (has_vhe())
181	deactivate_traps_vhe();	186	deactivate_traps_vhe();
@@ -229,20 +234,6 @@ static void __hyp_text __hyp_vgic_restore_state(struct kvm_vcpu *vcpu) · 47 unmodified lines
229	}	234	}
230	}	235	}
231		236
232	static bool __hyp_text __true_value(void)
233	{
234	return true;
235	}
236
237	static bool __hyp_text __false_value(void)
238	{
239	return false;
240	}
241
242	static hyp_alternate_select(__check_arm_834220,
243	__false_value, __true_value,
244	ARM64_WORKAROUND_834220);
245
246	static bool __hyp_text __translate_far_to_hpfar(u64 far, u64 *hpfar)	237	static bool __hyp_text __translate_far_to_hpfar(u64 far, u64 *hpfar)
247	{	238	{
248	u64 par, tmp;	239	u64 par, tmp;
@@ -298,7 +289,8 @@ static bool __hyp_text __populate_fault_info(struct kvm_vcpu *vcpu) · 49 unmodified lines
298	* resolve the IPA using the AT instruction.	289	* resolve the IPA using the AT instruction.
299	*/	290	*/
300	if (!(esr & ESR_ELx_S1PTW) &&	291	if (!(esr & ESR_ELx_S1PTW) &&
301	(__check_arm_834220()() \|\| (esr & ESR_ELx_FSC_TYPE) == FSC_PERM)) {	292	(cpus_have_const_cap(ARM64_WORKAROUND_834220) \|\|
		293	(esr & ESR_ELx_FSC_TYPE) == FSC_PERM)) {
302	if (!__translate_far_to_hpfar(far, &hpfar))	294	if (!__translate_far_to_hpfar(far, &hpfar))
303	return false;	295	return false;
304	} else {	296	} else {
@@ -393,6 +385,61 @@ static bool __hyp_text __hyp_handle_fpsimd(struct kvm_vcpu *vcpu) · 88 unmodified lines
393	return true;	385	return true;
394	}	386	}
395		387
		388	static bool __hyp_text handle_tx2_tvm(struct kvm_vcpu *vcpu)
		389	{
		390	u32 sysreg = esr_sys64_to_sysreg(kvm_vcpu_get_hsr(vcpu));
		391	int rt = kvm_vcpu_sys_get_rt(vcpu);
		392	u64 val = vcpu_get_reg(vcpu, rt);
		393
		394	/*
		395	* The normal sysreg handling code expects to see the traps,
		396	* let's not do anything here.
		397	*/
		398	if (vcpu->arch.hcr_el2 & HCR_TVM)
		399	return false;
		400
		401	switch (sysreg) {
		402	case SYS_SCTLR_EL1:
		403	write_sysreg_el1(val, SYS_SCTLR);
		404	break;
		405	case SYS_TTBR0_EL1:
		406	write_sysreg_el1(val, SYS_TTBR0);
		407	break;
		408	case SYS_TTBR1_EL1:
		409	write_sysreg_el1(val, SYS_TTBR1);
		410	break;
		411	case SYS_TCR_EL1:
		412	write_sysreg_el1(val, SYS_TCR);
		413	break;
		414	case SYS_ESR_EL1:
		415	write_sysreg_el1(val, SYS_ESR);
		416	break;
		417	case SYS_FAR_EL1:
		418	write_sysreg_el1(val, SYS_FAR);
		419	break;
		420	case SYS_AFSR0_EL1:
		421	write_sysreg_el1(val, SYS_AFSR0);
		422	break;
		423	case SYS_AFSR1_EL1:
		424	write_sysreg_el1(val, SYS_AFSR1);
		425	break;
		426	case SYS_MAIR_EL1:
		427	write_sysreg_el1(val, SYS_MAIR);
		428	break;
		429	case SYS_AMAIR_EL1:
		430	write_sysreg_el1(val, SYS_AMAIR);
		431	break;
		432	case SYS_CONTEXTIDR_EL1:
		433	write_sysreg_el1(val, SYS_CONTEXTIDR);
		434	break;
		435	default:
		436	return false;
		437	}
		438
		439	__kvm_skip_instr(vcpu);
		440	return true;
		441	}
		442
396	/*	443	/*
397	* Return true when we were able to fixup the guest exit and should return to	444	* Return true when we were able to fixup the guest exit and should return to
398	* the guest, false when we should restore the host state and return to the	445	* the guest, false when we should restore the host state and return to the
@@ -412,6 +459,11 @@ static bool __hyp_text fixup_guest_exit(struct kvm_vcpu vcpu, u64 exit_code) · 13 unmodified lines
412	if (*exit_code != ARM_EXCEPTION_TRAP)	459	if (*exit_code != ARM_EXCEPTION_TRAP)
413	goto exit;	460	goto exit;
414		461
		462	if (cpus_have_const_cap(ARM64_WORKAROUND_CAVIUM_TX2_219_TVM) &&
		463	kvm_vcpu_trap_get_class(vcpu) == ESR_ELx_EC_SYS64 &&
		464	handle_tx2_tvm(vcpu))
		465	return true;
		466
415	/*	467	/*
416	* We trap the first access to the FP/SIMD to save the host context	468	* We trap the first access to the FP/SIMD to save the host context
417	* and restore the guest context lazily.	469	* and restore the guest context lazily.

arch/arm64/kvm/hyp/tlb.c+22−14

 	isb();
 }
-static hyp_alternate_select(__tlb_switch_to_guest,
+static void __hyp_text __tlb_switch_to_guest(struct kvm *kvm,
-			    __tlb_switch_to_guest_nvhe,
+					     struct tlb_inv_context *cxt)
-			    __tlb_switch_to_guest_vhe,
+{
-			    ARM64_HAS_VIRT_HOST_EXTN);
+	if (has_vhe())
+		__tlb_switch_to_guest_vhe(kvm, cxt);
+	else
+		__tlb_switch_to_guest_nvhe(kvm, cxt);
+}
 static void __hyp_text __tlb_switch_to_host_vhe(struct kvm *kvm,
 						struct tlb_inv_context *cxt)
 	write_sysreg(0, vttbr_el2);
 }
-static hyp_alternate_select(__tlb_switch_to_host,
+static void __hyp_text __tlb_switch_to_host(struct kvm *kvm,
-			    __tlb_switch_to_host_nvhe,
+					    struct tlb_inv_context *cxt)
-			    __tlb_switch_to_host_vhe,
+{
-			    ARM64_HAS_VIRT_HOST_EXTN);
+	if (has_vhe())
+		__tlb_switch_to_host_vhe(kvm, cxt);
+	else
+		__tlb_switch_to_host_nvhe(kvm, cxt);
+}
 void __hyp_text __kvm_tlb_flush_vmid_ipa(struct kvm *kvm, phys_addr_t ipa)
 {
 	/* Switch to requested VMID */
 	kvm = kern_hyp_va(kvm);
-	__tlb_switch_to_guest()(kvm, &cxt);
+	__tlb_switch_to_guest(kvm, &cxt);
 	/*
 	 * We could do so much better if we had the VA as well.
 	if (!has_vhe() && icache_is_vpipt())
 		__flush_icache_all();
-	__tlb_switch_to_host()(kvm, &cxt);
+	__tlb_switch_to_host(kvm, &cxt);
 }
 void __hyp_text __kvm_tlb_flush_vmid(struct kvm *kvm)
 	/* Switch to requested VMID */
 	kvm = kern_hyp_va(kvm);
-	__tlb_switch_to_guest()(kvm, &cxt);
+	__tlb_switch_to_guest(kvm, &cxt);
 	__tlbi(vmalls12e1is);
 	dsb(ish);
 	isb();
-	__tlb_switch_to_host()(kvm, &cxt);
+	__tlb_switch_to_host(kvm, &cxt);
 }
 void __hyp_text __kvm_tlb_flush_local_vmid(struct kvm_vcpu *vcpu)
 	struct tlb_inv_context cxt;
 	/* Switch to requested VMID */
-	__tlb_switch_to_guest()(kvm, &cxt);
+	__tlb_switch_to_guest(kvm, &cxt);
 	__tlbi(vmalle1);
 	dsb(nsh);
 	isb();
-	__tlb_switch_to_host()(kvm, &cxt);
+	__tlb_switch_to_host(kvm, &cxt);
 }
 void __hyp_text __kvm_flush_vm_context(void)

arch/arm64/xen/Makefile+0−1

@@ -1,4 +1,3 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	xen-arm-y += $(addprefix ../../arm/xen/, enlighten.o grant-table.o p2m.o mm.o)	2	xen-arm-y += $(addprefix ../../arm/xen/, enlighten.o grant-table.o p2m.o mm.o)
3	obj-y := xen-arm.o hypercall.o	3	obj-y := xen-arm.o hypercall.o
4	obj-$(CONFIG_XEN_EFI) += $(addprefix ../../arm/xen/, efi.o)

arch/mips/boot/dts/qca/ar9331.dtsi+1−1

@@ -99,7 +99,7 @@ · 98 unmodified lines
99		99
100	miscintc: interrupt-controller@18060010 {	100	miscintc: interrupt-controller@18060010 {
101	compatible = "qca,ar7240-misc-intc";	101	compatible = "qca,ar7240-misc-intc";
102	reg = <0x18060010 0x4>;	102	reg = <0x18060010 0x8>;
103		103
104	interrupt-parent = <&cpuintc>;	104	interrupt-parent = <&cpuintc>;
105	interrupts = <6>;	105	interrupts = <6>;

arch/mips/fw/arc/memory.c+0−1

@@ -160,7 +160,6 @@ void __init prom_meminit(void) · 159 unmodified lines
160		160
161	void __init prom_free_prom_memory(void)	161	void __init prom_free_prom_memory(void)
162	{	162	{
163	unsigned long addr;
164	int i;	163	int i;
165		164
166	if (prom_flags & PROM_FLAG_DONT_FREE_TEMP)	165	if (prom_flags & PROM_FLAG_DONT_FREE_TEMP)

arch/mips/include/asm/octeon/cvmx-ipd.h+1−0

@@ -36,6 +36,7 @@ · 35 unmodified lines
36	#include <asm/octeon/octeon-feature.h>	36	#include <asm/octeon/octeon-feature.h>
37		37
38	#include <asm/octeon/cvmx-ipd-defs.h>	38	#include <asm/octeon/cvmx-ipd-defs.h>
		39	#include <asm/octeon/cvmx-pip-defs.h>
39		40
40	enum cvmx_ipd_mode {	41	enum cvmx_ipd_mode {
41	CVMX_IPD_OPC_MODE_STT = 0LL, /* All blocks DRAM, not cached in L2 */	42	CVMX_IPD_OPC_MODE_STT = 0LL, /* All blocks DRAM, not cached in L2 */

arch/mips/include/asm/unistd.h+1−0

@@ -52,6 +52,7 @@ · 51 unmodified lines
52	# endif	52	# endif
53	#define __ARCH_WANT_SYS_FORK	53	#define __ARCH_WANT_SYS_FORK
54	#define __ARCH_WANT_SYS_CLONE	54	#define __ARCH_WANT_SYS_CLONE
		55	#define __ARCH_WANT_SYS_CLONE3
55		56
56	/* whitelists for checksyscalls */	57	/* whitelists for checksyscalls */
57	#define __IGNORE_fadvise64_64	58	#define __IGNORE_fadvise64_64

arch/mips/kernel/cpu-bugs64.c+8−6

 static char daddiwar[] __initdata =
 	"Enable CPU_DADDI_WORKAROUNDS to rectify.";
-static inline void align_mod(const int align, const int mod)
+static __always_inline __init
+void align_mod(const int align, const int mod)
 {
 	asm volatile(
 		".set	push\n\t"
 		: "n"(align), "n"(mod));
 }
-static __always_inline void mult_sh_align_mod(long *v1, long *v2, long *w,
+static __always_inline __init
-					      const int align, const int mod)
+void mult_sh_align_mod(long *v1, long *v2, long *w,
+		       const int align, const int mod)
 {
 	unsigned long flags;
 	int m1, m2;
 	*w = lw;
 }
-static inline void check_mult_sh(void)
+static __always_inline __init void check_mult_sh(void)
 {
 	long v1[8], v2[8], w[8];
 	int bug, fix, i;
 	exception_exit(prev_state);
 }
-static inline void check_daddi(void)
+static __init void check_daddi(void)
 {
 	extern asmlinkage void handle_daddi_ov(void);
 	unsigned long flags;
 int daddiu_bug	= IS_ENABLED(CONFIG_CPU_MIPSR6) ? 0 : -1;
-static inline void check_daddiu(void)
+static __init void check_daddiu(void)
 {
 	long v, w, tmp;

arch/mips/kernel/setup.c+4−1

 		return;
 	}
+	if (start < PHYS_OFFSET)
+		return;
 	memblock_add(start, size);
 	/* Reserve any memory except the ordinary RAM ranges. */
 	switch (type) {
 	 * Reserve any memory between the start of RAM and PHYS_OFFSET
 	 */
 	if (ramstart > PHYS_OFFSET)
-		memblock_reserve(PHYS_OFFSET, PFN_UP(ramstart) - PHYS_OFFSET);
+		memblock_reserve(PHYS_OFFSET, ramstart - PHYS_OFFSET);
 	if (PFN_UP(ramstart) > ARCH_PFN_OFFSET) {
 		pr_info("Wasting %lu bytes for tracking %lu unused pages\n",

arch/mips/kernel/syscall.c+1−0

@@ -80,6 +80,7 @@ SYSCALL_DEFINE6(mips_mmap2, unsigned long, addr, unsigned long, len, · 79 unmodified lines
80		80
81	save_static_function(sys_fork);	81	save_static_function(sys_fork);
82	save_static_function(sys_clone);	82	save_static_function(sys_clone);
		83	save_static_function(sys_clone3);
83		84
84	SYSCALL_DEFINE1(set_thread_area, unsigned long, addr)	85	SYSCALL_DEFINE1(set_thread_area, unsigned long, addr)
85	{	86	{

arch/mips/kernel/syscalls/syscall_n32.tbl+1−1

@@ -373,4 +373,4 @@ · 372 unmodified lines
373	432 n32 fsmount sys_fsmount	373	432 n32 fsmount sys_fsmount
374	433 n32 fspick sys_fspick	374	433 n32 fspick sys_fspick
375	434 n32 pidfd_open sys_pidfd_open	375	434 n32 pidfd_open sys_pidfd_open
376	# 435 reserved for clone3	376	435 n32 clone3 __sys_clone3

arch/mips/kernel/syscalls/syscall_n64.tbl+1−1

@@ -349,4 +349,4 @@ · 348 unmodified lines
349	432 n64 fsmount sys_fsmount	349	432 n64 fsmount sys_fsmount
350	433 n64 fspick sys_fspick	350	433 n64 fspick sys_fspick
351	434 n64 pidfd_open sys_pidfd_open	351	434 n64 pidfd_open sys_pidfd_open
352	# 435 reserved for clone3	352	435 n64 clone3 __sys_clone3

arch/mips/kernel/syscalls/syscall_o32.tbl+1−1

@@ -422,4 +422,4 @@ · 421 unmodified lines
422	432 o32 fsmount sys_fsmount	422	432 o32 fsmount sys_fsmount
423	433 o32 fspick sys_fspick	423	433 o32 fspick sys_fspick
424	434 o32 pidfd_open sys_pidfd_open	424	434 o32 pidfd_open sys_pidfd_open
425	# 435 reserved for clone3	425	435 o32 clone3 __sys_clone3

arch/mips/loongson64/common/mem.c+17−18

@@ -3,6 +3,7 @@ · 2 unmodified lines
3	*/	3	*/
4	#include <linux/fs.h>	4	#include <linux/fs.h>
5	#include <linux/fcntl.h>	5	#include <linux/fcntl.h>
		6	#include <linux/memblock.h>
6	#include <linux/mm.h>	7	#include <linux/mm.h>
7		8
8	#include <asm/bootinfo.h>	9	#include <asm/bootinfo.h>
@@ -64,24 +65,22 @@ void __init prom_init_memory(void) · 55 unmodified lines
64	node_id = loongson_memmap->map[i].node_id;	65	node_id = loongson_memmap->map[i].node_id;
65	mem_type = loongson_memmap->map[i].mem_type;	66	mem_type = loongson_memmap->map[i].mem_type;
66		67
67	if (node_id == 0) {	68	if (node_id != 0)
68	switch (mem_type) {	69	continue;
69	case SYSTEM_RAM_LOW:	70
70	add_memory_region(loongson_memmap->map[i].mem_start,	71	switch (mem_type) {
71	(u64)loongson_memmap->map[i].mem_size << 20,	72	case SYSTEM_RAM_LOW:
72	BOOT_MEM_RAM);	73	memblock_add(loongson_memmap->map[i].mem_start,
73	break;	74	(u64)loongson_memmap->map[i].mem_size << 20);
74	case SYSTEM_RAM_HIGH:	75	break;
75	add_memory_region(loongson_memmap->map[i].mem_start,	76	case SYSTEM_RAM_HIGH:
76	(u64)loongson_memmap->map[i].mem_size << 20,	77	memblock_add(loongson_memmap->map[i].mem_start,
77	BOOT_MEM_RAM);	78	(u64)loongson_memmap->map[i].mem_size << 20);
78	break;	79	break;
79	case SYSTEM_RAM_RESERVED:	80	case SYSTEM_RAM_RESERVED:
80	add_memory_region(loongson_memmap->map[i].mem_start,	81	memblock_reserve(loongson_memmap->map[i].mem_start,
81	(u64)loongson_memmap->map[i].mem_size << 20,	82	(u64)loongson_memmap->map[i].mem_size << 20);
82	BOOT_MEM_RESERVED);	83	break;
83	break;
84	}
85	}	84	}
86	}	85	}
87	}	86	}

arch/mips/loongson64/common/serial.c+1−1

@@ -110,7 +110,7 @@ static int __init serial_init(void) · 109 unmodified lines
110	}	110	}
111	module_init(serial_init);	111	module_init(serial_init);
112		112
113	static void __init serial_exit(void)	113	static void __exit serial_exit(void)
114	{	114	{
115	platform_device_unregister(&uart8250_device);	115	platform_device_unregister(&uart8250_device);
116	}	116	}

arch/mips/loongson64/loongson-3/numa.c+1−10

 				(u32)node_id, mem_type, mem_start, mem_size);
 			pr_info("       start_pfn:0x%llx, end_pfn:0x%llx, num_physpages:0x%lx\n",
 				start_pfn, end_pfn, num_physpages);
-			add_memory_region((node_id << 44) + mem_start,
-				(u64)mem_size << 20, BOOT_MEM_RAM);
 			memblock_add_node(PFN_PHYS(start_pfn),
 				PFN_PHYS(end_pfn - start_pfn), node);
 			break;
 				(u32)node_id, mem_type, mem_start, mem_size);
 			pr_info("       start_pfn:0x%llx, end_pfn:0x%llx, num_physpages:0x%lx\n",
 				start_pfn, end_pfn, num_physpages);
-			add_memory_region((node_id << 44) + mem_start,
-				(u64)mem_size << 20, BOOT_MEM_RAM);
 			memblock_add_node(PFN_PHYS(start_pfn),
 				PFN_PHYS(end_pfn - start_pfn), node);
 			break;
 		case SYSTEM_RAM_RESERVED:
 			pr_info("Node%d: mem_type:%d, mem_start:0x%llx, mem_size:0x%llx MB\n",
 				(u32)node_id, mem_type, mem_start, mem_size);
-			add_memory_region((node_id << 44) + mem_start,
-				(u64)mem_size << 20, BOOT_MEM_RESERVED);
 			memblock_reserve(((node_id << 44) + mem_start),
 				mem_size << 20);
 			break;
 	NODE_DATA(node)->node_start_pfn = start_pfn;
 	NODE_DATA(node)->node_spanned_pages = end_pfn - start_pfn;
-	free_bootmem_with_active_regions(node, end_pfn);
 	if (node == 0) {
 		/* kernel end address */
 		unsigned long kernel_end_pfn = PFN_UP(__pa_symbol(&_end));
 			memblock_reserve((node_addrspace_offset | 0xfe000000),
 					 32 << 20);
 	}
-	sparse_memory_present_with_active_regions(node);
 }
 static __init void prom_meminit(void)
 			cpumask_clear(&__node_data[(node)]->cpumask);
 		}
 	}
+	memblocks_present();
 	max_low_pfn = PHYS_PFN(memblock_end_of_DRAM());
 	for (cpu = 0; cpu < loongson_sysconf.nr_cpus; cpu++) {

arch/mips/pmcs-msp71xx/msp_prom.c+2−2

 /* memory blocks */
 struct prom_pmemblock mdesc[PROM_MAX_PMEMBLOCKS];
+#define MAX_PROM_MEM 5
 static phys_addr_t prom_mem_base[MAX_PROM_MEM] __initdata;
 static phys_addr_t prom_mem_size[MAX_PROM_MEM] __initdata;
 static unsigned int nr_prom_mem __initdata;
 		p++;
 		if (type == BOOT_MEM_ROM_DATA) {
-			if (nr_prom_mem >= 5) {
+			if (nr_prom_mem >= MAX_PROM_MEM) {
 				pr_err("Too many ROM DATA regions");
 				continue;
 			}
 	char	*ptr;
 	int	len = 0;
 	int	i;
-	unsigned long addr;
 	/*
 	 * preserve environment variables and command line from pmon/bbload

arch/mips/vdso/Makefile+1−1

@@ -59,7 +59,7 @@ CFLAGS_REMOVE_vgettimeofday.o = -pg · 58 unmodified lines
59	ifndef CONFIG_CPU_MIPSR6	59	ifndef CONFIG_CPU_MIPSR6
60	ifeq ($(call ld-ifversion, -lt, 225000000, y),y)	60	ifeq ($(call ld-ifversion, -lt, 225000000, y),y)
61	$(warning MIPS VDSO requires binutils >= 2.25)	61	$(warning MIPS VDSO requires binutils >= 2.25)
62	obj-vdso-y := $(filter-out gettimeofday.o, $(obj-vdso-y))	62	obj-vdso-y := $(filter-out vgettimeofday.o, $(obj-vdso-y))
63	ccflags-vdso += -DDISABLE_MIPS_VDSO	63	ccflags-vdso += -DDISABLE_MIPS_VDSO
64	endif	64	endif
65	endif	65	endif

arch/mips/vdso/gettimeofday.c+0−269

@@ -1,269 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Copyright (C) 2015 Imagination Technologies
4	* Author: Alex Smith <alex.smith@imgtec.com>
5	*/
6
7	#include "vdso.h"
8
9	#include <linux/compiler.h>
10	#include <linux/time.h>
11
12	#include <asm/clocksource.h>
13	#include <asm/io.h>
14	#include <asm/unistd.h>
15	#include <asm/vdso.h>
16
17	#ifdef CONFIG_MIPS_CLOCK_VSYSCALL
18
19	static __always_inline long gettimeofday_fallback(struct timeval *_tv,
20	struct timezone *_tz)
21	{
22	register struct timezone *tz asm("a1") = _tz;
23	register struct timeval *tv asm("a0") = _tv;
24	register long ret asm("v0");
25	register long nr asm("v0") = __NR_gettimeofday;
26	register long error asm("a3");
27
28	asm volatile(
29	" syscall\n"
30	: "=r" (ret), "=r" (error)
31	: "r" (tv), "r" (tz), "r" (nr)
32	: "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13",
33	"$14", "$15", "$24", "$25", "hi", "lo", "memory");
34
35	return error ? -ret : ret;
36	}
37
38	#endif
39
40	static __always_inline long clock_gettime_fallback(clockid_t _clkid,
41	struct timespec *_ts)
42	{
43	register struct timespec *ts asm("a1") = _ts;
44	register clockid_t clkid asm("a0") = _clkid;
45	register long ret asm("v0");
46	register long nr asm("v0") = __NR_clock_gettime;
47	register long error asm("a3");
48
49	asm volatile(
50	" syscall\n"
51	: "=r" (ret), "=r" (error)
52	: "r" (clkid), "r" (ts), "r" (nr)
53	: "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13",
54	"$14", "$15", "$24", "$25", "hi", "lo", "memory");
55
56	return error ? -ret : ret;
57	}
58
59	static __always_inline int do_realtime_coarse(struct timespec *ts,
60	const union mips_vdso_data *data)
61	{
62	u32 start_seq;
63
64	do {
65	start_seq = vdso_data_read_begin(data);
66
67	ts->tv_sec = data->xtime_sec;
68	ts->tv_nsec = data->xtime_nsec >> data->cs_shift;
69	} while (vdso_data_read_retry(data, start_seq));
70
71	return 0;
72	}
73
74	static __always_inline int do_monotonic_coarse(struct timespec *ts,
75	const union mips_vdso_data *data)
76	{
77	u32 start_seq;
78	u64 to_mono_sec;
79	u64 to_mono_nsec;
80
81	do {
82	start_seq = vdso_data_read_begin(data);
83
84	ts->tv_sec = data->xtime_sec;
85	ts->tv_nsec = data->xtime_nsec >> data->cs_shift;
86
87	to_mono_sec = data->wall_to_mono_sec;
88	to_mono_nsec = data->wall_to_mono_nsec;
89	} while (vdso_data_read_retry(data, start_seq));
90
91	ts->tv_sec += to_mono_sec;
92	timespec_add_ns(ts, to_mono_nsec);
93
94	return 0;
95	}
96
97	#ifdef CONFIG_CSRC_R4K
98
99	static __always_inline u64 read_r4k_count(void)
100	{
101	unsigned int count;
102
103	__asm__ __volatile__(
104	" .set push\n"
105	" .set mips32r2\n"
106	" rdhwr %0, $2\n"
107	" .set pop\n"
108	: "=r" (count));
109
110	return count;
111	}
112
113	#endif
114
115	#ifdef CONFIG_CLKSRC_MIPS_GIC
116
117	static __always_inline u64 read_gic_count(const union mips_vdso_data *data)
118	{
119	void __iomem *gic = get_gic(data);
120	u32 hi, hi2, lo;
121
122	do {
123	hi = __raw_readl(gic + sizeof(lo));
124	lo = __raw_readl(gic);
125	hi2 = __raw_readl(gic + sizeof(lo));
126	} while (hi2 != hi);
127
128	return (((u64)hi) << 32) + lo;
129	}
130
131	#endif
132
133	static __always_inline u64 get_ns(const union mips_vdso_data *data)
134	{
135	u64 cycle_now, delta, nsec;
136
137	switch (data->clock_mode) {
138	#ifdef CONFIG_CSRC_R4K
139	case VDSO_CLOCK_R4K:
140	cycle_now = read_r4k_count();
141	break;
142	#endif
143	#ifdef CONFIG_CLKSRC_MIPS_GIC
144	case VDSO_CLOCK_GIC:
145	cycle_now = read_gic_count(data);
146	break;
147	#endif
148	default:
149	return 0;
150	}
151
152	delta = (cycle_now - data->cs_cycle_last) & data->cs_mask;
153
154	nsec = (delta * data->cs_mult) + data->xtime_nsec;
155	nsec >>= data->cs_shift;
156
157	return nsec;
158	}
159
160	static __always_inline int do_realtime(struct timespec *ts,
161	const union mips_vdso_data *data)
162	{
163	u32 start_seq;
164	u64 ns;
165
166	do {
167	start_seq = vdso_data_read_begin(data);
168
169	if (data->clock_mode == VDSO_CLOCK_NONE)
170	return -ENOSYS;
171
172	ts->tv_sec = data->xtime_sec;
173	ns = get_ns(data);
174	} while (vdso_data_read_retry(data, start_seq));
175
176	ts->tv_nsec = 0;
177	timespec_add_ns(ts, ns);
178
179	return 0;
180	}
181
182	static __always_inline int do_monotonic(struct timespec *ts,
183	const union mips_vdso_data *data)
184	{
185	u32 start_seq;
186	u64 ns;
187	u64 to_mono_sec;
188	u64 to_mono_nsec;
189
190	do {
191	start_seq = vdso_data_read_begin(data);
192
193	if (data->clock_mode == VDSO_CLOCK_NONE)
194	return -ENOSYS;
195
196	ts->tv_sec = data->xtime_sec;
197	ns = get_ns(data);
198
199	to_mono_sec = data->wall_to_mono_sec;
200	to_mono_nsec = data->wall_to_mono_nsec;
201	} while (vdso_data_read_retry(data, start_seq));
202
203	ts->tv_sec += to_mono_sec;
204	ts->tv_nsec = 0;
205	timespec_add_ns(ts, ns + to_mono_nsec);
206
207	return 0;
208	}
209
210	#ifdef CONFIG_MIPS_CLOCK_VSYSCALL
211
212	/*
213	* This is behind the ifdef so that we don't provide the symbol when there's no
214	* possibility of there being a usable clocksource, because there's nothing we
215	* can do without it. When libc fails the symbol lookup it should fall back on
216	* the standard syscall path.
217	*/
218	int __vdso_gettimeofday(struct timeval tv, struct timezone tz)
219	{
220	const union mips_vdso_data *data = get_vdso_data();
221	struct timespec ts;
222	int ret;
223
224	ret = do_realtime(&ts, data);
225	if (ret)
226	return gettimeofday_fallback(tv, tz);
227
228	if (tv) {
229	tv->tv_sec = ts.tv_sec;
230	tv->tv_usec = ts.tv_nsec / 1000;
231	}
232
233	if (tz) {
234	tz->tz_minuteswest = data->tz_minuteswest;
235	tz->tz_dsttime = data->tz_dsttime;
236	}
237
238	return 0;
239	}
240
241	#endif /* CONFIG_MIPS_CLOCK_VSYSCALL */
242
243	int __vdso_clock_gettime(clockid_t clkid, struct timespec *ts)
244	{
245	const union mips_vdso_data *data = get_vdso_data();
246	int ret = -1;
247
248	switch (clkid) {
249	case CLOCK_REALTIME_COARSE:
250	ret = do_realtime_coarse(ts, data);
251	break;
252	case CLOCK_MONOTONIC_COARSE:
253	ret = do_monotonic_coarse(ts, data);
254	break;
255	case CLOCK_REALTIME:
256	ret = do_realtime(ts, data);
257	break;
258	case CLOCK_MONOTONIC:
259	ret = do_monotonic(ts, data);
260	break;
261	default:
262	break;
263	}
264
265	if (ret)
266	ret = clock_gettime_fallback(clkid, ts);
267
268	return ret;
269	}

arch/powerpc/boot/Makefile+1−1

@@ -50,7 +50,7 @@ endif · 49 unmodified lines
50		50
51	BOOTAFLAGS := -D__ASSEMBLY__ $(BOOTCFLAGS) -nostdinc	51	BOOTAFLAGS := -D__ASSEMBLY__ $(BOOTCFLAGS) -nostdinc
52		52
53	BOOTARFLAGS := -cr$(KBUILD_ARFLAGS)	53	BOOTARFLAGS := -crD
54		54
55	ifdef CONFIG_CC_IS_CLANG	55	ifdef CONFIG_CC_IS_CLANG
56	BOOTCFLAGS += $(CLANG_FLAGS)	56	BOOTCFLAGS += $(CLANG_FLAGS)

arch/powerpc/kvm/book3s.c+4−4

@@ -36,8 +36,8 @@ · 35 unmodified lines
36	#include "book3s.h"	36	#include "book3s.h"
37	#include "trace.h"	37	#include "trace.h"
38		38
39	#define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM	39	#define VM_STAT(x, ...) offsetof(struct kvm, stat.x), KVM_STAT_VM, ## __VA_ARGS__
40	#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU	40	#define VCPU_STAT(x, ...) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU, ## __VA_ARGS__
41		41
42	/* #define EXIT_DEBUG */	42	/* #define EXIT_DEBUG */
43		43
@@ -69,8 +69,8 @@ struct kvm_stats_debugfs_item debugfs_entries[] = { · 25 unmodified lines
69	{ "pthru_all", VCPU_STAT(pthru_all) },	69	{ "pthru_all", VCPU_STAT(pthru_all) },
70	{ "pthru_host", VCPU_STAT(pthru_host) },	70	{ "pthru_host", VCPU_STAT(pthru_host) },
71	{ "pthru_bad_aff", VCPU_STAT(pthru_bad_aff) },	71	{ "pthru_bad_aff", VCPU_STAT(pthru_bad_aff) },
72	{ "largepages_2M", VM_STAT(num_2M_pages) },	72	{ "largepages_2M", VM_STAT(num_2M_pages, .mode = 0444) },
73	{ "largepages_1G", VM_STAT(num_1G_pages) },	73	{ "largepages_1G", VM_STAT(num_1G_pages, .mode = 0444) },
74	{ NULL }	74	{ NULL }
75	};	75	};
76		76

arch/riscv/include/asm/asm.h+1−0

@@ -22,6 +22,7 @@ · 21 unmodified lines
22		22
23	#define REG_L __REG_SEL(ld, lw)	23	#define REG_L __REG_SEL(ld, lw)
24	#define REG_S __REG_SEL(sd, sw)	24	#define REG_S __REG_SEL(sd, sw)
		25	#define REG_SC __REG_SEL(sc.d, sc.w)
25	#define SZREG __REG_SEL(8, 4)	26	#define SZREG __REG_SEL(8, 4)
26	#define LGREG __REG_SEL(3, 2)	27	#define LGREG __REG_SEL(3, 2)
27		28

arch/riscv/kernel/entry.S+20−1

@@ -98,7 +98,26 @@ _save_context: · 97 unmodified lines
98	*/	98	*/
99	.macro RESTORE_ALL	99	.macro RESTORE_ALL
100	REG_L a0, PT_SSTATUS(sp)	100	REG_L a0, PT_SSTATUS(sp)
101	REG_L a2, PT_SEPC(sp)	101	/*
		102	* The current load reservation is effectively part of the processor's
		103	* state, in the sense that load reservations cannot be shared between
		104	* different hart contexts. We can't actually save and restore a load
		105	* reservation, so instead here we clear any existing reservation --
		106	* it's always legal for implementations to clear load reservations at
		107	* any point (as long as the forward progress guarantee is kept, but
		108	* we'll ignore that here).
		109	*
		110	* Dangling load reservations can be the result of taking a trap in the
		111	* middle of an LR/SC sequence, but can also be the result of a taken
		112	* forward branch around an SC -- which is how we implement CAS. As a
		113	* result we need to clear reservations between the last CAS and the
		114	* jump back to the new context. While it is unlikely the store
		115	* completes, implementations are allowed to expand reservations to be
		116	* arbitrarily large.
		117	*/
		118	REG_L a2, PT_SEPC(sp)
		119	REG_SC x0, a2, PT_SEPC(sp)
		120
102	csrw CSR_SSTATUS, a0	121	csrw CSR_SSTATUS, a0
103	csrw CSR_SEPC, a2	122	csrw CSR_SEPC, a2
104		123

arch/riscv/mm/init.c+11−1

 #include <linux/swap.h>
 #include <linux/sizes.h>
 #include <linux/of_fdt.h>
+#include <linux/libfdt.h>
 #include <asm/fixmap.h>
 #include <asm/tlbflush.h>
 }
 #endif /* CONFIG_BLK_DEV_INITRD */
+static phys_addr_t dtb_early_pa __initdata;
 void __init setup_bootmem(void)
 {
 	struct memblock_region *reg;
 	setup_initrd();
 #endif /* CONFIG_BLK_DEV_INITRD */
-	early_init_fdt_reserve_self();
+	/*
+	 * Avoid using early_init_fdt_reserve_self() since __pa() does
+	 * not work for DTB pointers that are fixmap addresses
+	 */
+	memblock_reserve(dtb_early_pa, fdt_totalsize(dtb_early_va));
 	early_init_fdt_scan_reserved_mem();
 	memblock_allow_resize();
 	memblock_dump_all();
 	/* Save pointer to DTB for early FDT parsing */
 	dtb_early_va = (void *)fix_to_virt(FIX_FDT) + (dtb_pa & ~PAGE_MASK);
+	/* Save physical address for memblock reservation */
+	dtb_early_pa = dtb_pa;
 }
 static void __init setup_vm_final(void)

arch/s390/configs/debug_defconfig+16−8

 CONFIG_NUMA=y
 CONFIG_HZ_100=y
 CONFIG_KEXEC_FILE=y
+CONFIG_KEXEC_SIG=y
 CONFIG_EXPOLINE=y
 CONFIG_EXPOLINE_AUTO=y
 CONFIG_CHSC_SCH=y
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
-CONFIG_MODULE_SIG=y
 CONFIG_MODULE_SIG_SHA256=y
+CONFIG_UNUSED_SYMBOLS=y
 CONFIG_BLK_DEV_INTEGRITY=y
 CONFIG_BLK_DEV_THROTTLING=y
 CONFIG_BLK_WBT=y
 CONFIG_BLK_CGROUP_IOLATENCY=y
+CONFIG_BLK_CGROUP_IOCOST=y
 CONFIG_PARTITION_ADVANCED=y
 CONFIG_IBM_PARTITION=y
 CONFIG_BSD_DISKLABEL=y
 CONFIG_CGROUP_NET_PRIO=y
 CONFIG_BPF_JIT=y
 CONFIG_NET_PKTGEN=m
+# CONFIG_NET_DROP_MONITOR is not set
 CONFIG_PCI=y
 CONFIG_PCI_DEBUG=y
 CONFIG_HOTPLUG_PCI=y
 CONFIG_DM_SNAPSHOT=m
 CONFIG_DM_THIN_PROVISIONING=m
 CONFIG_DM_WRITECACHE=m
+CONFIG_DM_CLONE=m
 CONFIG_DM_MIRROR=m
 CONFIG_DM_LOG_USERSPACE=m
 CONFIG_DM_RAID=m
 CONFIG_DM_UEVENT=y
 CONFIG_DM_FLAKEY=m
 CONFIG_DM_VERITY=m
+CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG=y
 CONFIG_DM_SWITCH=m
 CONFIG_NETDEVICES=y
 CONFIG_BONDING=m
 # CONFIG_NET_VENDOR_NVIDIA is not set
 # CONFIG_NET_VENDOR_OKI is not set
 # CONFIG_NET_VENDOR_PACKET_ENGINES is not set
+# CONFIG_NET_VENDOR_PENSANDO is not set
 # CONFIG_NET_VENDOR_QLOGIC is not set
 # CONFIG_NET_VENDOR_QUALCOMM is not set
 # CONFIG_NET_VENDOR_RDC is not set
 CONFIG_WATCHDOG_NOWAYOUT=y
 CONFIG_SOFT_WATCHDOG=m
 CONFIG_DIAG288_WATCHDOG=m
-CONFIG_DRM=y
+CONFIG_FB=y
-CONFIG_DRM_VIRTIO_GPU=y
 CONFIG_FRAMEBUFFER_CONSOLE=y
+CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_HID is not set
 # CONFIG_USB_SUPPORT is not set
 CONFIG_INFINIBAND=m
 CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_MLX4_INFINIBAND=m
 CONFIG_MLX5_INFINIBAND=m
+CONFIG_SYNC_FILE=y
 CONFIG_VFIO=m
 CONFIG_VFIO_PCI=m
 CONFIG_VFIO_MDEV=m
 CONFIG_FS_DAX=y
 CONFIG_EXPORTFS_BLOCK_OPS=y
 CONFIG_FS_ENCRYPTION=y
+CONFIG_FS_VERITY=y
+CONFIG_FS_VERITY_BUILTIN_SIGNATURES=y
 CONFIG_FANOTIFY=y
 CONFIG_FANOTIFY_ACCESS_PERMISSIONS=y
 CONFIG_QUOTA_NETLINK_INTERFACE=y
 CONFIG_AUTOFS4_FS=m
 CONFIG_FUSE_FS=y
 CONFIG_CUSE=m
+CONFIG_VIRTIO_FS=m
 CONFIG_OVERLAY_FS=m
 CONFIG_FSCACHE=m
 CONFIG_CACHEFILES=m
 CONFIG_SECURITY_SELINUX=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM=y
 CONFIG_SECURITY_SELINUX_DISABLE=y
+CONFIG_SECURITY_LOCKDOWN_LSM=y
+CONFIG_SECURITY_LOCKDOWN_LSM_EARLY=y
 CONFIG_INTEGRITY_SIGNATURE=y
 CONFIG_INTEGRITY_ASYMMETRIC_KEYS=y
 CONFIG_IMA=y
 CONFIG_IMA_DEFAULT_HASH_SHA256=y
 CONFIG_IMA_WRITE_POLICY=y
 CONFIG_IMA_APPRAISE=y
+CONFIG_LSM="yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
 CONFIG_CRYPTO_USER=m
 # CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is not set
 CONFIG_CRYPTO_PCRYPT=m
 CONFIG_CRYPTO_ECRDSA=m
 CONFIG_CRYPTO_CHACHA20POLY1305=m
 CONFIG_CRYPTO_AEGIS128=m
-CONFIG_CRYPTO_AEGIS128L=m
-CONFIG_CRYPTO_AEGIS256=m
-CONFIG_CRYPTO_MORUS640=m
-CONFIG_CRYPTO_MORUS1280=m
 CONFIG_CRYPTO_CFB=m
 CONFIG_CRYPTO_LRW=m
 CONFIG_CRYPTO_PCBC=m
 CONFIG_DEBUG_INFO_DWARF4=y
 CONFIG_GDB_SCRIPTS=y
 CONFIG_FRAME_WARN=1024
-CONFIG_UNUSED_SYMBOLS=y
 CONFIG_HEADERS_INSTALL=y
 CONFIG_HEADERS_CHECK=y
 CONFIG_DEBUG_SECTION_MISMATCH=y

arch/s390/configs/defconfig+16−9

 # CONFIG_NUMA_EMU is not set
 CONFIG_HZ_100=y
 CONFIG_KEXEC_FILE=y
+CONFIG_KEXEC_SIG=y
 CONFIG_EXPOLINE=y
 CONFIG_EXPOLINE_AUTO=y
 CONFIG_CHSC_SCH=y
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
-CONFIG_MODULE_SIG=y
 CONFIG_MODULE_SIG_SHA256=y
+CONFIG_UNUSED_SYMBOLS=y
 CONFIG_BLK_DEV_THROTTLING=y
 CONFIG_BLK_WBT=y
 CONFIG_BLK_CGROUP_IOLATENCY=y
+CONFIG_BLK_CGROUP_IOCOST=y
 CONFIG_PARTITION_ADVANCED=y
 CONFIG_IBM_PARTITION=y
 CONFIG_BSD_DISKLABEL=y
 CONFIG_CGROUP_NET_PRIO=y
 CONFIG_BPF_JIT=y
 CONFIG_NET_PKTGEN=m
+# CONFIG_NET_DROP_MONITOR is not set
 CONFIG_PCI=y
 CONFIG_HOTPLUG_PCI=y
 CONFIG_HOTPLUG_PCI_S390=y
 CONFIG_DM_SNAPSHOT=m
 CONFIG_DM_THIN_PROVISIONING=m
 CONFIG_DM_WRITECACHE=m
+CONFIG_DM_CLONE=m
 CONFIG_DM_MIRROR=m
 CONFIG_DM_LOG_USERSPACE=m
 CONFIG_DM_RAID=m
 CONFIG_DM_UEVENT=y
 CONFIG_DM_FLAKEY=m
 CONFIG_DM_VERITY=m
+CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG=y
 CONFIG_DM_SWITCH=m
 CONFIG_DM_INTEGRITY=m
 CONFIG_NETDEVICES=y
 # CONFIG_NET_VENDOR_NVIDIA is not set
 # CONFIG_NET_VENDOR_OKI is not set
 # CONFIG_NET_VENDOR_PACKET_ENGINES is not set
+# CONFIG_NET_VENDOR_PENSANDO is not set
 # CONFIG_NET_VENDOR_QLOGIC is not set
 # CONFIG_NET_VENDOR_QUALCOMM is not set
 # CONFIG_NET_VENDOR_RDC is not set
 CONFIG_WATCHDOG_NOWAYOUT=y
 CONFIG_SOFT_WATCHDOG=m
 CONFIG_DIAG288_WATCHDOG=m
-CONFIG_DRM=y
+CONFIG_FB=y
-CONFIG_DRM_VIRTIO_GPU=y
-# CONFIG_BACKLIGHT_CLASS_DEVICE is not set
 CONFIG_FRAMEBUFFER_CONSOLE=y
+CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_HID is not set
 # CONFIG_USB_SUPPORT is not set
 CONFIG_INFINIBAND=m
 CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_MLX4_INFINIBAND=m
 CONFIG_MLX5_INFINIBAND=m
+CONFIG_SYNC_FILE=y
 CONFIG_VFIO=m
 CONFIG_VFIO_PCI=m
 CONFIG_VFIO_MDEV=m
 CONFIG_FS_DAX=y
 CONFIG_EXPORTFS_BLOCK_OPS=y
 CONFIG_FS_ENCRYPTION=y
+CONFIG_FS_VERITY=y
+CONFIG_FS_VERITY_BUILTIN_SIGNATURES=y
 CONFIG_FANOTIFY=y
 CONFIG_FANOTIFY_ACCESS_PERMISSIONS=y
 CONFIG_QUOTA_NETLINK_INTERFACE=y
 CONFIG_AUTOFS4_FS=m
 CONFIG_FUSE_FS=y
 CONFIG_CUSE=m
+CONFIG_VIRTIO_FS=m
 CONFIG_OVERLAY_FS=m
 CONFIG_FSCACHE=m
 CONFIG_CACHEFILES=m
 CONFIG_SECURITY_SELINUX=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM=y
 CONFIG_SECURITY_SELINUX_DISABLE=y
+CONFIG_SECURITY_LOCKDOWN_LSM=y
+CONFIG_SECURITY_LOCKDOWN_LSM_EARLY=y
 CONFIG_INTEGRITY_SIGNATURE=y
 CONFIG_INTEGRITY_ASYMMETRIC_KEYS=y
 CONFIG_IMA=y
 CONFIG_IMA_DEFAULT_HASH_SHA256=y
 CONFIG_IMA_WRITE_POLICY=y
 CONFIG_IMA_APPRAISE=y
+CONFIG_LSM="yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
 CONFIG_CRYPTO_FIPS=y
 CONFIG_CRYPTO_USER=m
 # CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is not set
 CONFIG_CRYPTO_ECRDSA=m
 CONFIG_CRYPTO_CHACHA20POLY1305=m
 CONFIG_CRYPTO_AEGIS128=m
-CONFIG_CRYPTO_AEGIS128L=m
-CONFIG_CRYPTO_AEGIS256=m
-CONFIG_CRYPTO_MORUS640=m
-CONFIG_CRYPTO_MORUS1280=m
 CONFIG_CRYPTO_CFB=m
 CONFIG_CRYPTO_LRW=m
 CONFIG_CRYPTO_OFB=m
 CONFIG_DEBUG_INFO_DWARF4=y
 CONFIG_GDB_SCRIPTS=y
 CONFIG_FRAME_WARN=1024
-CONFIG_UNUSED_SYMBOLS=y
 CONFIG_DEBUG_SECTION_MISMATCH=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_MEMORY_INIT=y

arch/s390/configs/zfcpdump_defconfig+1−1

@@ -61,7 +61,7 @@ CONFIG_RAW_DRIVER=y · 60 unmodified lines
61	CONFIG_CONFIGFS_FS=y	61	CONFIG_CONFIGFS_FS=y
62	# CONFIG_MISC_FILESYSTEMS is not set	62	# CONFIG_MISC_FILESYSTEMS is not set
63	# CONFIG_NETWORK_FILESYSTEMS is not set	63	# CONFIG_NETWORK_FILESYSTEMS is not set
64	# CONFIG_DIMLIB is not set	64	CONFIG_LSM="yama,loadpin,safesetid,integrity"
65	CONFIG_PRINTK_TIME=y	65	CONFIG_PRINTK_TIME=y
66	CONFIG_DEBUG_INFO=y	66	CONFIG_DEBUG_INFO=y
67	CONFIG_DEBUG_FS=y	67	CONFIG_DEBUG_FS=y

arch/s390/include/asm/atomic_ops.h+1−1

@@ -41,7 +41,7 @@ __ATOMIC_OPS(__atomic64_xor, long, "laxg") · 40 unmodified lines
41	#undef __ATOMIC_OP	41	#undef __ATOMIC_OP
42		42
43	#define __ATOMIC_CONST_OP(op_name, op_type, op_string, op_barrier) \	43	#define __ATOMIC_CONST_OP(op_name, op_type, op_string, op_barrier) \
44	static inline void op_name(op_type val, op_type *ptr) \	44	static __always_inline void op_name(op_type val, op_type *ptr) \
45	{ \	45	{ \
46	asm volatile( \	46	asm volatile( \
47	op_string " %[ptr],%[val]\n" \	47	op_string " %[ptr],%[val]\n" \

arch/s390/include/asm/bitops.h+4−4

@@ -56,7 +56,7 @@ __bitops_byte(unsigned long nr, volatile unsigned long *ptr) · 55 unmodified lines
56	return ((unsigned char *)ptr) + ((nr ^ (BITS_PER_LONG - 8)) >> 3);	56	return ((unsigned char *)ptr) + ((nr ^ (BITS_PER_LONG - 8)) >> 3);
57	}	57	}
58		58
59	static inline void arch_set_bit(unsigned long nr, volatile unsigned long *ptr)	59	static __always_inline void arch_set_bit(unsigned long nr, volatile unsigned long *ptr)
60	{	60	{
61	unsigned long *addr = __bitops_word(nr, ptr);	61	unsigned long *addr = __bitops_word(nr, ptr);
62	unsigned long mask;	62	unsigned long mask;
@@ -77,7 +77,7 @@ static inline void arch_set_bit(unsigned long nr, volatile unsigned long *ptr) · 14 unmodified lines
77	__atomic64_or(mask, (long *)addr);	77	__atomic64_or(mask, (long *)addr);
78	}	78	}
79		79
80	static inline void arch_clear_bit(unsigned long nr, volatile unsigned long *ptr)	80	static __always_inline void arch_clear_bit(unsigned long nr, volatile unsigned long *ptr)
81	{	81	{
82	unsigned long *addr = __bitops_word(nr, ptr);	82	unsigned long *addr = __bitops_word(nr, ptr);
83	unsigned long mask;	83	unsigned long mask;
@@ -98,8 +98,8 @@ static inline void arch_clear_bit(unsigned long nr, volatile unsigned long *ptr) · 14 unmodified lines
98	__atomic64_and(mask, (long *)addr);	98	__atomic64_and(mask, (long *)addr);
99	}	99	}
100		100
101	static inline void arch_change_bit(unsigned long nr,	101	static __always_inline void arch_change_bit(unsigned long nr,
102	volatile unsigned long *ptr)	102	volatile unsigned long *ptr)
103	{	103	{
104	unsigned long *addr = __bitops_word(nr, ptr);	104	unsigned long *addr = __bitops_word(nr, ptr);
105	unsigned long mask;	105	unsigned long mask;

arch/s390/include/asm/cpacf.h+1−1

@@ -171,7 +171,7 @@ typedef struct { unsigned char bytes[16]; } cpacf_mask_t; · 170 unmodified lines
171	*	171	*
172	* Returns 1 if @func is available for @opcode, 0 otherwise	172	* Returns 1 if @func is available for @opcode, 0 otherwise
173	*/	173	*/
174	static inline void __cpacf_query(unsigned int opcode, cpacf_mask_t *mask)	174	static __always_inline void __cpacf_query(unsigned int opcode, cpacf_mask_t *mask)
175	{	175	{
176	register unsigned long r0 asm("0") = 0; /* query function */	176	register unsigned long r0 asm("0") = 0; /* query function */
177	register unsigned long r1 asm("1") = (unsigned long) mask;	177	register unsigned long r1 asm("1") = (unsigned long) mask;

arch/s390/include/asm/cpu_mf.h+6−2

@@ -28,6 +28,8 @@ asm(".include \"asm/cpu_mf-insn.h\"\n"); · 27 unmodified lines
28	CPU_MF_INT_SF_PRA\|CPU_MF_INT_SF_SACA\| \	28	CPU_MF_INT_SF_PRA\|CPU_MF_INT_SF_SACA\| \
29	CPU_MF_INT_SF_LSDA)	29	CPU_MF_INT_SF_LSDA)
30		30
		31	#define CPU_MF_SF_RIBM_NOTAV 0x1 /* Sampling unavailable */
		32
31	/* CPU measurement facility support */	33	/* CPU measurement facility support */
32	static inline int cpum_cf_avail(void)	34	static inline int cpum_cf_avail(void)
33	{	35	{
@@ -69,7 +71,8 @@ struct hws_qsi_info_block { /* Bit(s) */ · 35 unmodified lines
69	unsigned long max_sampl_rate; /* 16-23: maximum sampling interval*/	71	unsigned long max_sampl_rate; /* 16-23: maximum sampling interval*/
70	unsigned long tear; /* 24-31: TEAR contents */	72	unsigned long tear; /* 24-31: TEAR contents */
71	unsigned long dear; /* 32-39: DEAR contents */	73	unsigned long dear; /* 32-39: DEAR contents */
72	unsigned int rsvrd0; /* 40-43: reserved */	74	unsigned int rsvrd0:24; /* 40-42: reserved */
		75	unsigned int ribm:8; /* 43: Reserved by IBM */
73	unsigned int cpu_speed; /* 44-47: CPU speed */	76	unsigned int cpu_speed; /* 44-47: CPU speed */
74	unsigned long long rsvrd1; /* 48-55: reserved */	77	unsigned long long rsvrd1; /* 48-55: reserved */
75	unsigned long long rsvrd2; /* 56-63: reserved */	78	unsigned long long rsvrd2; /* 56-63: reserved */
@@ -220,7 +223,8 @@ enum stcctm_ctr_set { · 144 unmodified lines
220	MT_DIAG = 5,	223	MT_DIAG = 5,
221	MT_DIAG_CLEARING = 9, /* clears loss-of-MT-ctr-data alert */	224	MT_DIAG_CLEARING = 9, /* clears loss-of-MT-ctr-data alert */
222	};	225	};
223	static inline int stcctm(enum stcctm_ctr_set set, u64 range, u64 *dest)	226
		227	static __always_inline int stcctm(enum stcctm_ctr_set set, u64 range, u64 *dest)
224	{	228	{
225	int cc;	229	int cc;
226		230

arch/s390/include/asm/hugetlb.h+7−2

 #include <asm/page.h>
 #include <asm/pgtable.h>
-#define is_hugepage_only_range(mm, addr, len)	0
 #define hugetlb_free_pgd_range			free_pgd_range
 #define hugepages_supported()			(MACHINE_HAS_EDAT1)
 pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
 			      unsigned long addr, pte_t *ptep);
+static inline bool is_hugepage_only_range(struct mm_struct *mm,
+					  unsigned long addr,
+					  unsigned long len)
+{
+	return false;
+}
 /*
  * If the arch doesn't supply something else, assume that hugepage
  * size aligned regions are ok without further preparation.

arch/s390/include/asm/jump_label.h+2−2

@@ -20,7 +20,7 @@ · 19 unmodified lines
20	* We use a brcl 0,2 instruction for jump labels at compile time so it	20	* We use a brcl 0,2 instruction for jump labels at compile time so it
21	* can be easily distinguished from a hotpatch generated instruction.	21	* can be easily distinguished from a hotpatch generated instruction.
22	*/	22	*/
23	static inline bool arch_static_branch(struct static_key *key, bool branch)	23	static __always_inline bool arch_static_branch(struct static_key *key, bool branch)
24	{	24	{
25	asm_volatile_goto("0: brcl 0,"__stringify(JUMP_LABEL_NOP_OFFSET)"\n"	25	asm_volatile_goto("0: brcl 0,"__stringify(JUMP_LABEL_NOP_OFFSET)"\n"
26	".pushsection __jump_table,\"aw\"\n"	26	".pushsection __jump_table,\"aw\"\n"
@@ -34,7 +34,7 @@ label: · 7 unmodified lines
34	return true;	34	return true;
35	}	35	}
36		36
37	static inline bool arch_static_branch_jump(struct static_key *key, bool branch)	37	static __always_inline bool arch_static_branch_jump(struct static_key *key, bool branch)
38	{	38	{
39	asm_volatile_goto("0: brcl 15,%l[label]\n"	39	asm_volatile_goto("0: brcl 15,%l[label]\n"
40	".pushsection __jump_table,\"aw\"\n"	40	".pushsection __jump_table,\"aw\"\n"

arch/s390/include/asm/pgtable.h+13−12

@@ -997,9 +997,9 @@ static inline pte_t pte_mkhuge(pte_t pte) · 996 unmodified lines
997	#define IPTE_NODAT 0x400	997	#define IPTE_NODAT 0x400
998	#define IPTE_GUEST_ASCE 0x800	998	#define IPTE_GUEST_ASCE 0x800
999		999
1000	static inline void __ptep_ipte(unsigned long address, pte_t *ptep,	1000	static __always_inline void __ptep_ipte(unsigned long address, pte_t *ptep,
1001	unsigned long opt, unsigned long asce,	1001	unsigned long opt, unsigned long asce,
1002	int local)	1002	int local)
1003	{	1003	{
1004	unsigned long pto = (unsigned long) ptep;	1004	unsigned long pto = (unsigned long) ptep;
1005		1005
@@ -1020,8 +1020,8 @@ static inline void __ptep_ipte(unsigned long address, pte_t *ptep, · 14 unmodified lines
1020	: [r1] "a" (pto), [m4] "i" (local) : "memory");	1020	: [r1] "a" (pto), [m4] "i" (local) : "memory");
1021	}	1021	}
1022		1022
1023	static inline void __ptep_ipte_range(unsigned long address, int nr,	1023	static __always_inline void __ptep_ipte_range(unsigned long address, int nr,
1024	pte_t *ptep, int local)	1024	pte_t *ptep, int local)
1025	{	1025	{
1026	unsigned long pto = (unsigned long) ptep;	1026	unsigned long pto = (unsigned long) ptep;
1027		1027
@@ -1269,7 +1269,8 @@ static inline pte_t pte_offset(pmd_t pmd, unsigned long address) · 241 unmodified lines
1269		1269
1270	#define pte_offset_kernel(pmd, address) pte_offset(pmd, address)	1270	#define pte_offset_kernel(pmd, address) pte_offset(pmd, address)
1271	#define pte_offset_map(pmd, address) pte_offset_kernel(pmd, address)	1271	#define pte_offset_map(pmd, address) pte_offset_kernel(pmd, address)
1272	#define pte_unmap(pte) do { } while (0)	1272
		1273	static inline void pte_unmap(pte_t *pte) { }
1273		1274
1274	static inline bool gup_fast_permitted(unsigned long start, unsigned long end)	1275	static inline bool gup_fast_permitted(unsigned long start, unsigned long end)
1275	{	1276	{
@@ -1435,9 +1436,9 @@ static inline void __pmdp_csp(pmd_t *pmdp) · 159 unmodified lines
1435	#define IDTE_NODAT 0x1000	1436	#define IDTE_NODAT 0x1000
1436	#define IDTE_GUEST_ASCE 0x2000	1437	#define IDTE_GUEST_ASCE 0x2000
1437		1438
1438	static inline void __pmdp_idte(unsigned long addr, pmd_t *pmdp,	1439	static __always_inline void __pmdp_idte(unsigned long addr, pmd_t *pmdp,
1439	unsigned long opt, unsigned long asce,	1440	unsigned long opt, unsigned long asce,
1440	int local)	1441	int local)
1441	{	1442	{
1442	unsigned long sto;	1443	unsigned long sto;
1443		1444
@@ -1461,9 +1462,9 @@ static inline void __pmdp_idte(unsigned long addr, pmd_t *pmdp, · 17 unmodified lines
1461	}	1462	}
1462	}	1463	}
1463		1464
1464	static inline void __pudp_idte(unsigned long addr, pud_t *pudp,	1465	static __always_inline void __pudp_idte(unsigned long addr, pud_t *pudp,
1465	unsigned long opt, unsigned long asce,	1466	unsigned long opt, unsigned long asce,
1466	int local)	1467	int local)
1467	{	1468	{
1468	unsigned long r3o;	1469	unsigned long r3o;
1469		1470

arch/s390/include/asm/qdio.h+1−1

@@ -111,7 +111,7 @@ struct qib { · 110 unmodified lines
111	/* private: */	111	/* private: */
112	u8 res[88];	112	u8 res[88];
113	/* public: */	113	/* public: */
114	u8 parm[QDIO_MAX_BUFFERS_PER_Q];	114	u8 parm[128];
115	} __attribute__ ((packed, aligned(256)));	115	} __attribute__ ((packed, aligned(256)));
116		116
117	/**	117	/**

arch/s390/kernel/perf_cpum_cf_diag.c+2−2

@@ -390,7 +390,7 @@ static size_t cf_diag_getctrset(struct cf_ctrset_entry *ctrdata, int ctrset, · 389 unmodified lines
390		390
391	debug_sprintf_event(cf_diag_dbg, 6,	391	debug_sprintf_event(cf_diag_dbg, 6,
392	"%s ctrset %d ctrset_size %zu cfvn %d csvn %d"	392	"%s ctrset %d ctrset_size %zu cfvn %d csvn %d"
393	" need %zd rc:%d\n",	393	" need %zd rc %d\n",
394	__func__, ctrset, ctrset_size, cpuhw->info.cfvn,	394	__func__, ctrset, ctrset_size, cpuhw->info.cfvn,
395	cpuhw->info.csvn, need, rc);	395	cpuhw->info.csvn, need, rc);
396	return need;	396	return need;
@@ -567,7 +567,7 @@ static int cf_diag_add(struct perf_event *event, int flags) · 170 unmodified lines
567	int err = 0;	567	int err = 0;
568		568
569	debug_sprintf_event(cf_diag_dbg, 5,	569	debug_sprintf_event(cf_diag_dbg, 5,
570	"%s event %p cpu %d flags %#x cpuhw:%p\n",	570	"%s event %p cpu %d flags %#x cpuhw %p\n",
571	__func__, event, event->cpu, flags, cpuhw);	571	__func__, event, event->cpu, flags, cpuhw);
572		572
573	if (cpuhw->flags & PMU_F_IN_USE) {	573	if (cpuhw->flags & PMU_F_IN_USE) {

arch/s390/kernel/perf_cpum_sf.c+7−1

 		goto out;
 	}
+	if (si.ribm & CPU_MF_SF_RIBM_NOTAV) {
+		pr_warn("CPU Measurement Facility sampling is temporarily not available\n");
+		err = -EBUSY;
+		goto out;
+	}
 	/* Always enable basic sampling */
 	SAMPL_FLAGS(hwc) = PERF_CPUM_SF_BASIC_MODE;
 	/* Check online status of the CPU to which the event is pinned */
 	if (event->cpu >= 0 && !cpu_online(event->cpu))
-			return -ENODEV;
+		return -ENODEV;
 	/* Force reset of idle/hv excludes regardless of what the
 	 * user requested.

arch/s390/kvm/kvm-s390.c+3−3

@@ -332,7 +332,7 @@ static inline int plo_test_bit(unsigned char nr) · 331 unmodified lines
332	return cc == 0;	332	return cc == 0;
333	}	333	}
334		334
335	static inline void __insn32_query(unsigned int opcode, u8 query[32])	335	static __always_inline void __insn32_query(unsigned int opcode, u8 *query)
336	{	336	{
337	register unsigned long r0 asm("0") = 0; /* query function */	337	register unsigned long r0 asm("0") = 0; /* query function */
338	register unsigned long r1 asm("1") = (unsigned long) query;	338	register unsigned long r1 asm("1") = (unsigned long) query;
@@ -340,9 +340,9 @@ static inline void __insn32_query(unsigned int opcode, u8 query[32]) · 1 unmodified line
340	asm volatile(	340	asm volatile(
341	/* Parameter regs are ignored */	341	/* Parameter regs are ignored */
342	" .insn rrf,%[opc] << 16,2,4,6,0\n"	342	" .insn rrf,%[opc] << 16,2,4,6,0\n"
343	: "=m" (*query)	343	:
344	: "d" (r0), "a" (r1), [opc] "i" (opcode)	344	: "d" (r0), "a" (r1), [opc] "i" (opcode)
345	: "cc");	345	: "cc", "memory");
346	}	346	}
347		347
348	#define INSN_SORTL 0xb938	348	#define INSN_SORTL 0xb938

arch/s390/pci/pci_clp.c+1−1

@@ -66,7 +66,7 @@ static inline int clp_get_ilp(unsigned long *ilp) · 65 unmodified lines
66	/*	66	/*
67	* Call Logical Processor with c=0, the give constant lps and an lpcb request.	67	* Call Logical Processor with c=0, the give constant lps and an lpcb request.
68	*/	68	*/
69	static inline int clp_req(void *data, unsigned int lps)	69	static __always_inline int clp_req(void *data, unsigned int lps)
70	{	70	{
71	struct { u8 _[CLP_BLK_SIZE]; } *req = data;	71	struct { u8 _[CLP_BLK_SIZE]; } *req = data;
72	u64 ignored;	72	u64 ignored;

arch/x86/include/asm/kvm_host.h+0−7

@@ -219,13 +219,6 @@ enum { · 218 unmodified lines
219	PFERR_WRITE_MASK \| \	219	PFERR_WRITE_MASK \| \
220	PFERR_PRESENT_MASK)	220	PFERR_PRESENT_MASK)
221		221
222	/*
223	* The mask used to denote special SPTEs, which can be either MMIO SPTEs or
224	* Access Tracking SPTEs. We use bit 62 instead of bit 63 to avoid conflicting
225	* with the SVE bit in EPT PTEs.
226	*/
227	#define SPTE_SPECIAL_MASK (1ULL << 62)
228
229	/* apic attention bits */	222	/* apic attention bits */
230	#define KVM_APIC_CHECK_VAPIC 0	223	#define KVM_APIC_CHECK_VAPIC 0
231	/*	224	/*

arch/x86/kvm/cpuid.c+60−42

@@ -485,6 +485,7 @@ static inline int __do_cpuid_func(struct kvm_cpuid_entry2 *entry, u32 function, · 484 unmodified lines
485		485
486	/* cpuid 0x80000008.ebx */	486	/* cpuid 0x80000008.ebx */
487	const u32 kvm_cpuid_8000_0008_ebx_x86_features =	487	const u32 kvm_cpuid_8000_0008_ebx_x86_features =
		488	F(CLZERO) \| F(XSAVEERPTR) \|
488	F(WBNOINVD) \| F(AMD_IBPB) \| F(AMD_IBRS) \| F(AMD_SSBD) \| F(VIRT_SSBD) \|	489	F(WBNOINVD) \| F(AMD_IBPB) \| F(AMD_IBRS) \| F(AMD_SSBD) \| F(VIRT_SSBD) \|
489	F(AMD_SSB_NO) \| F(AMD_STIBP) \| F(AMD_STIBP_ALWAYS_ON);	490	F(AMD_SSB_NO) \| F(AMD_STIBP) \| F(AMD_STIBP_ALWAYS_ON);
490		491
@@ -618,16 +619,20 @@ static inline int __do_cpuid_func(struct kvm_cpuid_entry2 *entry, u32 function, · 127 unmodified lines
618	*/	619	*/
619	case 0x1f:	620	case 0x1f:
620	case 0xb: {	621	case 0xb: {
621	int i, level_type;	622	int i;
622		623
623	/* read more entries until level_type is zero */	624	/*
624	for (i = 1; ; ++i) {	625	* We filled in entry[0] for CPUID(EAX=<function>,
		626	* ECX=00H) above. If its level type (ECX[15:8]) is
		627	* zero, then the leaf is unimplemented, and we're
		628	* done. Otherwise, continue to populate entries
		629	* until the level type (ECX[15:8]) of the previously
		630	* added entry is zero.
		631	*/
		632	for (i = 1; entry[i - 1].ecx & 0xff00; ++i) {
625	if (*nent >= maxnent)	633	if (*nent >= maxnent)
626	goto out;	634	goto out;
627		635
628	level_type = entry[i - 1].ecx & 0xff00;
629	if (!level_type)
630	break;
631	do_host_cpuid(&entry[i], function, i);	636	do_host_cpuid(&entry[i], function, i);
632	++*nent;	637	++*nent;
633	}	638	}
@@ -969,53 +974,66 @@ struct kvm_cpuid_entry2 kvm_find_cpuid_entry(struct kvm_vcpu vcpu, · 335 unmodified lines
969	EXPORT_SYMBOL_GPL(kvm_find_cpuid_entry);	974	EXPORT_SYMBOL_GPL(kvm_find_cpuid_entry);
970		975
971	/*	976	/*
972	* If no match is found, check whether we exceed the vCPU's limit	977	* If the basic or extended CPUID leaf requested is higher than the
973	* and return the content of the highest valid _standard_ leaf instead.	978	* maximum supported basic or extended leaf, respectively, then it is
974	* This is to satisfy the CPUID specification.	979	* out of range.
975	*/	980	*/
976	static struct kvm_cpuid_entry2* check_cpuid_limit(struct kvm_vcpu *vcpu,	981	static bool cpuid_function_in_range(struct kvm_vcpu *vcpu, u32 function)
977	u32 function, u32 index)
978	{	982	{
979	struct kvm_cpuid_entry2 *maxlevel;	983	struct kvm_cpuid_entry2 *max;
980		984
981	maxlevel = kvm_find_cpuid_entry(vcpu, function & 0x80000000, 0);	985	max = kvm_find_cpuid_entry(vcpu, function & 0x80000000, 0);
982	if (!maxlevel \|\| maxlevel->eax >= function)	986	return max && function <= max->eax;
983	return NULL;
984	if (function & 0x80000000) {
985	maxlevel = kvm_find_cpuid_entry(vcpu, 0, 0);
986	if (!maxlevel)
987	return NULL;
988	}
989	return kvm_find_cpuid_entry(vcpu, maxlevel->eax, index);
990	}	987	}
991		988
992	bool kvm_cpuid(struct kvm_vcpu vcpu, u32 eax, u32 *ebx,	989	bool kvm_cpuid(struct kvm_vcpu vcpu, u32 eax, u32 *ebx,
993	u32 ecx, u32 edx, bool check_limit)	990	u32 ecx, u32 edx, bool check_limit)
994	{	991	{
995	u32 function = eax, index = ecx;	992	u32 function = eax, index = ecx;
996	struct kvm_cpuid_entry2 *best;	993	struct kvm_cpuid_entry2 *entry;
997	bool entry_found = true;	994	struct kvm_cpuid_entry2 *max;
998		995	bool found;
999	best = kvm_find_cpuid_entry(vcpu, function, index);
1000
1001	if (!best) {
1002	entry_found = false;
1003	if (!check_limit)
1004	goto out;
1005		996
1006	best = check_cpuid_limit(vcpu, function, index);	997	entry = kvm_find_cpuid_entry(vcpu, function, index);
		998	found = entry;
		999	/*
		1000	* Intel CPUID semantics treats any query for an out-of-range
		1001	* leaf as if the highest basic leaf (i.e. CPUID.0H:EAX) were
		1002	* requested. AMD CPUID semantics returns all zeroes for any
		1003	* undefined leaf, whether or not the leaf is in range.
		1004	*/
		1005	if (!entry && check_limit && !guest_cpuid_is_amd(vcpu) &&
		1006	!cpuid_function_in_range(vcpu, function)) {
		1007	max = kvm_find_cpuid_entry(vcpu, 0, 0);
		1008	if (max) {
		1009	function = max->eax;
		1010	entry = kvm_find_cpuid_entry(vcpu, function, index);
		1011	}
1007	}	1012	}
1008		1013	if (entry) {
1009	out:	1014	*eax = entry->eax;
1010	if (best) {	1015	*ebx = entry->ebx;
1011	*eax = best->eax;	1016	*ecx = entry->ecx;
1012	*ebx = best->ebx;	1017	*edx = entry->edx;
1013	*ecx = best->ecx;	1018	} else {
1014	*edx = best->edx;
1015	} else
1016	eax = ebx = ecx = edx = 0;	1019	eax = ebx = ecx = edx = 0;
1017	trace_kvm_cpuid(function, eax, ebx, ecx, edx, entry_found);	1020	/*
1018	return entry_found;	1021	* When leaf 0BH or 1FH is defined, CL is pass-through
		1022	* and EDX is always the x2APIC ID, even for undefined
		1023	* subleaves. Index 1 will exist iff the leaf is
		1024	* implemented, so we pass through CL iff leaf 1
		1025	* exists. EDX can be copied from any existing index.
		1026	*/
		1027	if (function == 0xb \|\| function == 0x1f) {
		1028	entry = kvm_find_cpuid_entry(vcpu, function, 1);
		1029	if (entry) {
		1030	*ecx = index & 0xff;
		1031	*edx = entry->edx;
		1032	}
		1033	}
		1034	}
		1035	trace_kvm_cpuid(function, eax, ebx, ecx, edx, found);
		1036	return found;
1019	}	1037	}
1020	EXPORT_SYMBOL_GPL(kvm_cpuid);	1038	EXPORT_SYMBOL_GPL(kvm_cpuid);
1021		1039

arch/x86/kvm/lapic.c+7−6

 #define X2APIC_BROADCAST		0xFFFFFFFFul
 static bool lapic_timer_advance_dynamic __read_mostly;
-#define LAPIC_TIMER_ADVANCE_ADJUST_MIN 100
+#define LAPIC_TIMER_ADVANCE_ADJUST_MIN	100	/* clock cycles */
-#define LAPIC_TIMER_ADVANCE_ADJUST_MAX 5000
+#define LAPIC_TIMER_ADVANCE_ADJUST_MAX	10000	/* clock cycles */
-#define LAPIC_TIMER_ADVANCE_ADJUST_INIT 1000
+#define LAPIC_TIMER_ADVANCE_NS_INIT	1000
+#define LAPIC_TIMER_ADVANCE_NS_MAX     5000
 /* step-by-step approximation to mitigate fluctuation */
 #define LAPIC_TIMER_ADVANCE_ADJUST_STEP 8
 		timer_advance_ns += ns/LAPIC_TIMER_ADVANCE_ADJUST_STEP;
 	}
-	if (unlikely(timer_advance_ns > LAPIC_TIMER_ADVANCE_ADJUST_MAX))
+	if (unlikely(timer_advance_ns > LAPIC_TIMER_ADVANCE_NS_MAX))
-		timer_advance_ns = LAPIC_TIMER_ADVANCE_ADJUST_INIT;
+		timer_advance_ns = LAPIC_TIMER_ADVANCE_NS_INIT;
 	apic->lapic_timer.timer_advance_ns = timer_advance_ns;
 }
 		     HRTIMER_MODE_ABS_HARD);
 	apic->lapic_timer.timer.function = apic_timer_fn;
 	if (timer_advance_ns == -1) {
-		apic->lapic_timer.timer_advance_ns = LAPIC_TIMER_ADVANCE_ADJUST_INIT;
+		apic->lapic_timer.timer_advance_ns = LAPIC_TIMER_ADVANCE_NS_INIT;
 		lapic_timer_advance_dynamic = true;
 	} else {
 		apic->lapic_timer.timer_advance_ns = timer_advance_ns;

arch/x86/kvm/mmu.c+49−16

 #define PTE_PREFETCH_NUM		8
 #define PT_FIRST_AVAIL_BITS_SHIFT 10
-#define PT64_SECOND_AVAIL_BITS_SHIFT 52
+#define PT64_SECOND_AVAIL_BITS_SHIFT 54
+/*
+ * The mask used to denote special SPTEs, which can be either MMIO SPTEs or
+ * Access Tracking SPTEs.
+ */
+#define SPTE_SPECIAL_MASK (3ULL << 52)
+#define SPTE_AD_ENABLED_MASK (0ULL << 52)
+#define SPTE_AD_DISABLED_MASK (1ULL << 52)
+#define SPTE_AD_WRPROT_ONLY_MASK (2ULL << 52)
+#define SPTE_MMIO_MASK (3ULL << 52)
 #define PT64_LEVEL_BITS 9
 static u64 __read_mostly shadow_me_mask;
 /*
- * SPTEs used by MMUs without A/D bits are marked with shadow_acc_track_value.
+ * SPTEs used by MMUs without A/D bits are marked with SPTE_AD_DISABLED_MASK;
- * Non-present SPTEs with shadow_acc_track_value set are in place for access
+ * shadow_acc_track_mask is the set of bits to be cleared in non-accessed
- * tracking.
+ * pages.
  */
 static u64 __read_mostly shadow_acc_track_mask;
-static const u64 shadow_acc_track_value = SPTE_SPECIAL_MASK;
 /*
  * The mask/shift to use for saving the original R/X bits when marking the PTE
 {
 	BUG_ON((u64)(unsigned)access_mask != access_mask);
 	BUG_ON((mmio_mask & mmio_value) != mmio_value);
-	shadow_mmio_value = mmio_value | SPTE_SPECIAL_MASK;
+	shadow_mmio_value = mmio_value | SPTE_MMIO_MASK;
 	shadow_mmio_mask = mmio_mask | SPTE_SPECIAL_MASK;
 	shadow_mmio_access_mask = access_mask;
 }
 	return sp->role.ad_disabled;
 }
+static inline bool kvm_vcpu_ad_need_write_protect(struct kvm_vcpu *vcpu)
+{
+	/*
+	 * When using the EPT page-modification log, the GPAs in the log
+	 * would come from L2 rather than L1.  Therefore, we need to rely
+	 * on write protection to record dirty pages.  This also bypasses
+	 * PML, since writes now result in a vmexit.
+	 */
+	return vcpu->arch.mmu == &vcpu->arch.guest_mmu;
+}
 static inline bool spte_ad_enabled(u64 spte)
 {
 	MMU_WARN_ON(is_mmio_spte(spte));
-	return !(spte & shadow_acc_track_value);
+	return (spte & SPTE_SPECIAL_MASK) != SPTE_AD_DISABLED_MASK;
+}
+static inline bool spte_ad_need_write_protect(u64 spte)
+{
+	MMU_WARN_ON(is_mmio_spte(spte));
+	return (spte & SPTE_SPECIAL_MASK) != SPTE_AD_ENABLED_MASK;
 }
 static inline u64 spte_shadow_accessed_mask(u64 spte)
 {
 	BUG_ON(!dirty_mask != !accessed_mask);
 	BUG_ON(!accessed_mask && !acc_track_mask);
-	BUG_ON(acc_track_mask & shadow_acc_track_value);
+	BUG_ON(acc_track_mask & SPTE_SPECIAL_MASK);
 	shadow_user_mask = user_mask;
 	shadow_accessed_mask = accessed_mask;
 	rmap_printk("rmap_clear_dirty: spte %p %llx\n", sptep, *sptep);
+	MMU_WARN_ON(!spte_ad_enabled(spte));
 	spte &= ~shadow_dirty_mask;
 	return mmu_spte_update(sptep, spte);
 }
-static bool wrprot_ad_disabled_spte(u64 *sptep)
+static bool spte_wrprot_for_clear_dirty(u64 *sptep)
 {
 	bool was_writable = test_and_clear_bit(PT_WRITABLE_SHIFT,
 					       (unsigned long *)sptep);
-	if (was_writable)
+	if (was_writable && !spte_ad_enabled(*sptep))
 		kvm_set_pfn_dirty(spte_to_pfn(*sptep));
 	return was_writable;
 	bool flush = false;
 	for_each_rmap_spte(rmap_head, &iter, sptep)
-		if (spte_ad_enabled(*sptep))
+		if (spte_ad_need_write_protect(*sptep))
-			flush |= spte_clear_dirty(sptep);
+			flush |= spte_wrprot_for_clear_dirty(sptep);
 		else
-			flush |= wrprot_ad_disabled_spte(sptep);
+			flush |= spte_clear_dirty(sptep);
 	return flush;
 }
 	rmap_printk("rmap_set_dirty: spte %p %llx\n", sptep, *sptep);
+	/*
+	 * Similar to the !kvm_x86_ops->slot_disable_log_dirty case,
+	 * do not bother adding back write access to pages marked
+	 * SPTE_AD_WRPROT_ONLY_MASK.
+	 */
 	spte |= shadow_dirty_mask;
 	return mmu_spte_update(sptep, spte);
 	       shadow_user_mask | shadow_x_mask | shadow_me_mask;
 	if (sp_ad_disabled(sp))
-		spte |= shadow_acc_track_value;
+		spte |= SPTE_AD_DISABLED_MASK;
 	else
 		spte |= shadow_accessed_mask;
 	sp = page_header(__pa(sptep));
 	if (sp_ad_disabled(sp))
-		spte |= shadow_acc_track_value;
+		spte |= SPTE_AD_DISABLED_MASK;
+	else if (kvm_vcpu_ad_need_write_protect(vcpu))
+		spte |= SPTE_AD_WRPROT_ONLY_MASK;
 	/*
 	 * For the EPT case, shadow_present_mask is 0 if hardware

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

@@ -2610,7 +2610,7 @@ static int nested_check_vm_entry_controls(struct kvm_vcpu *vcpu, · 2609 unmodified lines
2610		2610
2611	/* VM-entry exception error code */	2611	/* VM-entry exception error code */
2612	if (CC(has_error_code &&	2612	if (CC(has_error_code &&
2613	vmcs12->vm_entry_exception_error_code & GENMASK(31, 15)))	2613	vmcs12->vm_entry_exception_error_code & GENMASK(31, 16)))
2614	return -EINVAL;	2614	return -EINVAL;
2615		2615
2616	/* VM-entry interruption-info field: reserved bits */	2616	/* VM-entry interruption-info field: reserved bits */

arch/x86/kvm/vmx/pmu_intel.c+5−2

 static void intel_pmu_refresh(struct kvm_vcpu *vcpu)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
+	struct x86_pmu_capability x86_pmu;
 	struct kvm_cpuid_entry2 *entry;
 	union cpuid10_eax eax;
 	union cpuid10_edx edx;
 	if (!pmu->version)
 		return;
+	perf_get_x86_pmu_capability(&x86_pmu);
 	pmu->nr_arch_gp_counters = min_t(int, eax.split.num_counters,
-					INTEL_PMC_MAX_GENERIC);
+					 x86_pmu.num_counters_gp);
 	pmu->counter_bitmask[KVM_PMC_GP] = ((u64)1 << eax.split.bit_width) - 1;
 	pmu->available_event_types = ~entry->ebx &
 					((1ull << eax.split.mask_length) - 1);
 	} else {
 		pmu->nr_arch_fixed_counters =
 			min_t(int, edx.split.num_counters_fixed,
-				INTEL_PMC_MAX_FIXED);
+			      x86_pmu.num_counters_fixed);
 		pmu->counter_bitmask[KVM_PMC_FIXED] =
 			((u64)1 << edx.split.bit_width_fixed) - 1;
 	}

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

 	struct page *page;
 	unsigned int i;
+	if (!boot_cpu_has_bug(X86_BUG_L1TF)) {
+		l1tf_vmx_mitigation = VMENTER_L1D_FLUSH_NOT_REQUIRED;
+		return 0;
+	}
 	if (!enable_ept) {
 		l1tf_vmx_mitigation = VMENTER_L1D_FLUSH_EPT_DISABLED;
 		return 0;
 	 * contain 'auto' which will be turned into the default 'cond'
 	 * mitigation mode.
 	 */
-	if (boot_cpu_has(X86_BUG_L1TF)) {
+	r = vmx_setup_l1d_flush(vmentry_l1d_flush_param);
-		r = vmx_setup_l1d_flush(vmentry_l1d_flush_param);
+	if (r) {
-		if (r) {
+		vmx_exit();
-			vmx_exit();
+		return r;
-			return r;
-		}
 	}
 #ifdef CONFIG_KEXEC_CORE

arch/x86/kvm/x86.c+36−36

@@ -92,8 +92,8 @@ u64 __read_mostly efer_reserved_bits = ~((u64)(EFER_SCE \| EFER_LME \| EFER_LMA)); · 91 unmodified lines
92	static u64 __read_mostly efer_reserved_bits = ~((u64)EFER_SCE);	92	static u64 __read_mostly efer_reserved_bits = ~((u64)EFER_SCE);
93	#endif	93	#endif
94		94
95	#define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM	95	#define VM_STAT(x, ...) offsetof(struct kvm, stat.x), KVM_STAT_VM, ## __VA_ARGS__
96	#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU	96	#define VCPU_STAT(x, ...) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU, ## __VA_ARGS__
97		97
98	#define KVM_X2APIC_API_VALID_FLAGS (KVM_X2APIC_API_USE_32BIT_IDS \| \	98	#define KVM_X2APIC_API_VALID_FLAGS (KVM_X2APIC_API_USE_32BIT_IDS \| \
99	KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK)	99	KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK)
@@ -212,7 +212,7 @@ struct kvm_stats_debugfs_item debugfs_entries[] = { · 112 unmodified lines
212	{ "mmu_cache_miss", VM_STAT(mmu_cache_miss) },	212	{ "mmu_cache_miss", VM_STAT(mmu_cache_miss) },
213	{ "mmu_unsync", VM_STAT(mmu_unsync) },	213	{ "mmu_unsync", VM_STAT(mmu_unsync) },
214	{ "remote_tlb_flush", VM_STAT(remote_tlb_flush) },	214	{ "remote_tlb_flush", VM_STAT(remote_tlb_flush) },
215	{ "largepages", VM_STAT(lpages) },	215	{ "largepages", VM_STAT(lpages, .mode = 0444) },
216	{ "max_mmu_page_hash_collisions",	216	{ "max_mmu_page_hash_collisions",
217	VM_STAT(max_mmu_page_hash_collisions) },	217	VM_STAT(max_mmu_page_hash_collisions) },
218	{ NULL }	218	{ NULL }
@@ -885,34 +885,42 @@ int kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr) · 666 unmodified lines
885	}	885	}
886	EXPORT_SYMBOL_GPL(kvm_set_xcr);	886	EXPORT_SYMBOL_GPL(kvm_set_xcr);
887		887
888	int kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)	888	static int kvm_valid_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
889	{	889	{
890	unsigned long old_cr4 = kvm_read_cr4(vcpu);
891	unsigned long pdptr_bits = X86_CR4_PGE \| X86_CR4_PSE \| X86_CR4_PAE \|
892	X86_CR4_SMEP \| X86_CR4_SMAP \| X86_CR4_PKE;
893
894	if (cr4 & CR4_RESERVED_BITS)	890	if (cr4 & CR4_RESERVED_BITS)
895	return 1;	891	return -EINVAL;
896		892
897	if (!guest_cpuid_has(vcpu, X86_FEATURE_XSAVE) && (cr4 & X86_CR4_OSXSAVE))	893	if (!guest_cpuid_has(vcpu, X86_FEATURE_XSAVE) && (cr4 & X86_CR4_OSXSAVE))
898	return 1;	894	return -EINVAL;
899		895
900	if (!guest_cpuid_has(vcpu, X86_FEATURE_SMEP) && (cr4 & X86_CR4_SMEP))	896	if (!guest_cpuid_has(vcpu, X86_FEATURE_SMEP) && (cr4 & X86_CR4_SMEP))
901	return 1;	897	return -EINVAL;
902		898
903	if (!guest_cpuid_has(vcpu, X86_FEATURE_SMAP) && (cr4 & X86_CR4_SMAP))	899	if (!guest_cpuid_has(vcpu, X86_FEATURE_SMAP) && (cr4 & X86_CR4_SMAP))
904	return 1;	900	return -EINVAL;
905		901
906	if (!guest_cpuid_has(vcpu, X86_FEATURE_FSGSBASE) && (cr4 & X86_CR4_FSGSBASE))	902	if (!guest_cpuid_has(vcpu, X86_FEATURE_FSGSBASE) && (cr4 & X86_CR4_FSGSBASE))
907	return 1;	903	return -EINVAL;
908		904
909	if (!guest_cpuid_has(vcpu, X86_FEATURE_PKU) && (cr4 & X86_CR4_PKE))	905	if (!guest_cpuid_has(vcpu, X86_FEATURE_PKU) && (cr4 & X86_CR4_PKE))
910	return 1;	906	return -EINVAL;
911		907
912	if (!guest_cpuid_has(vcpu, X86_FEATURE_LA57) && (cr4 & X86_CR4_LA57))	908	if (!guest_cpuid_has(vcpu, X86_FEATURE_LA57) && (cr4 & X86_CR4_LA57))
913	return 1;	909	return -EINVAL;
914		910
915	if (!guest_cpuid_has(vcpu, X86_FEATURE_UMIP) && (cr4 & X86_CR4_UMIP))	911	if (!guest_cpuid_has(vcpu, X86_FEATURE_UMIP) && (cr4 & X86_CR4_UMIP))
		912	return -EINVAL;
		913
		914	return 0;
		915	}
		916
		917	int kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
		918	{
		919	unsigned long old_cr4 = kvm_read_cr4(vcpu);
		920	unsigned long pdptr_bits = X86_CR4_PGE \| X86_CR4_PSE \| X86_CR4_PAE \|
		921	X86_CR4_SMEP \| X86_CR4_SMAP \| X86_CR4_PKE;
		922
		923	if (kvm_valid_cr4(vcpu, cr4))
916	return 1;	924	return 1;
917		925
918	if (is_long_mode(vcpu)) {	926	if (is_long_mode(vcpu)) {
@@ -1161,13 +1169,6 @@ static u32 msrs_to_save[] = { · 242 unmodified lines
1161	MSR_ARCH_PERFMON_PERFCTR0 + 12, MSR_ARCH_PERFMON_PERFCTR0 + 13,	1169	MSR_ARCH_PERFMON_PERFCTR0 + 12, MSR_ARCH_PERFMON_PERFCTR0 + 13,
1162	MSR_ARCH_PERFMON_PERFCTR0 + 14, MSR_ARCH_PERFMON_PERFCTR0 + 15,	1170	MSR_ARCH_PERFMON_PERFCTR0 + 14, MSR_ARCH_PERFMON_PERFCTR0 + 15,
1163	MSR_ARCH_PERFMON_PERFCTR0 + 16, MSR_ARCH_PERFMON_PERFCTR0 + 17,	1171	MSR_ARCH_PERFMON_PERFCTR0 + 16, MSR_ARCH_PERFMON_PERFCTR0 + 17,
1164	MSR_ARCH_PERFMON_PERFCTR0 + 18, MSR_ARCH_PERFMON_PERFCTR0 + 19,
1165	MSR_ARCH_PERFMON_PERFCTR0 + 20, MSR_ARCH_PERFMON_PERFCTR0 + 21,
1166	MSR_ARCH_PERFMON_PERFCTR0 + 22, MSR_ARCH_PERFMON_PERFCTR0 + 23,
1167	MSR_ARCH_PERFMON_PERFCTR0 + 24, MSR_ARCH_PERFMON_PERFCTR0 + 25,
1168	MSR_ARCH_PERFMON_PERFCTR0 + 26, MSR_ARCH_PERFMON_PERFCTR0 + 27,
1169	MSR_ARCH_PERFMON_PERFCTR0 + 28, MSR_ARCH_PERFMON_PERFCTR0 + 29,
1170	MSR_ARCH_PERFMON_PERFCTR0 + 30, MSR_ARCH_PERFMON_PERFCTR0 + 31,
1171	MSR_ARCH_PERFMON_EVENTSEL0, MSR_ARCH_PERFMON_EVENTSEL1,	1172	MSR_ARCH_PERFMON_EVENTSEL0, MSR_ARCH_PERFMON_EVENTSEL1,
1172	MSR_ARCH_PERFMON_EVENTSEL0 + 2, MSR_ARCH_PERFMON_EVENTSEL0 + 3,	1173	MSR_ARCH_PERFMON_EVENTSEL0 + 2, MSR_ARCH_PERFMON_EVENTSEL0 + 3,
1173	MSR_ARCH_PERFMON_EVENTSEL0 + 4, MSR_ARCH_PERFMON_EVENTSEL0 + 5,	1174	MSR_ARCH_PERFMON_EVENTSEL0 + 4, MSR_ARCH_PERFMON_EVENTSEL0 + 5,
@@ -1177,13 +1178,6 @@ static u32 msrs_to_save[] = { · 3 unmodified lines
1177	MSR_ARCH_PERFMON_EVENTSEL0 + 12, MSR_ARCH_PERFMON_EVENTSEL0 + 13,	1178	MSR_ARCH_PERFMON_EVENTSEL0 + 12, MSR_ARCH_PERFMON_EVENTSEL0 + 13,
1178	MSR_ARCH_PERFMON_EVENTSEL0 + 14, MSR_ARCH_PERFMON_EVENTSEL0 + 15,	1179	MSR_ARCH_PERFMON_EVENTSEL0 + 14, MSR_ARCH_PERFMON_EVENTSEL0 + 15,
1179	MSR_ARCH_PERFMON_EVENTSEL0 + 16, MSR_ARCH_PERFMON_EVENTSEL0 + 17,	1180	MSR_ARCH_PERFMON_EVENTSEL0 + 16, MSR_ARCH_PERFMON_EVENTSEL0 + 17,
1180	MSR_ARCH_PERFMON_EVENTSEL0 + 18, MSR_ARCH_PERFMON_EVENTSEL0 + 19,
1181	MSR_ARCH_PERFMON_EVENTSEL0 + 20, MSR_ARCH_PERFMON_EVENTSEL0 + 21,
1182	MSR_ARCH_PERFMON_EVENTSEL0 + 22, MSR_ARCH_PERFMON_EVENTSEL0 + 23,
1183	MSR_ARCH_PERFMON_EVENTSEL0 + 24, MSR_ARCH_PERFMON_EVENTSEL0 + 25,
1184	MSR_ARCH_PERFMON_EVENTSEL0 + 26, MSR_ARCH_PERFMON_EVENTSEL0 + 27,
1185	MSR_ARCH_PERFMON_EVENTSEL0 + 28, MSR_ARCH_PERFMON_EVENTSEL0 + 29,
1186	MSR_ARCH_PERFMON_EVENTSEL0 + 30, MSR_ARCH_PERFMON_EVENTSEL0 + 31,
1187	};	1181	};
1188		1182
1189	static unsigned num_msrs_to_save;	1183	static unsigned num_msrs_to_save;
@@ -5097,13 +5091,14 @@ out: · 3907 unmodified lines
5097		5091
5098	static void kvm_init_msr_list(void)	5092	static void kvm_init_msr_list(void)
5099	{	5093	{
		5094	struct x86_pmu_capability x86_pmu;
5100	u32 dummy[2];	5095	u32 dummy[2];
5101	unsigned i, j;	5096	unsigned i, j;
5102		5097
5103	BUILD_BUG_ON_MSG(INTEL_PMC_MAX_FIXED != 4,	5098	BUILD_BUG_ON_MSG(INTEL_PMC_MAX_FIXED != 4,
5104	"Please update the fixed PMCs in msrs_to_save[]");	5099	"Please update the fixed PMCs in msrs_to_save[]");
5105	BUILD_BUG_ON_MSG(INTEL_PMC_MAX_GENERIC != 32,	5100
5106	"Please update the generic perfctr/eventsel MSRs in msrs_to_save[]");	5101	perf_get_x86_pmu_capability(&x86_pmu);
5107		5102
5108	for (i = j = 0; i < ARRAY_SIZE(msrs_to_save); i++) {	5103	for (i = j = 0; i < ARRAY_SIZE(msrs_to_save); i++) {
5109	if (rdmsr_safe(msrs_to_save[i], &dummy[0], &dummy[1]) < 0)	5104	if (rdmsr_safe(msrs_to_save[i], &dummy[0], &dummy[1]) < 0)
@@ -5145,6 +5140,15 @@ static void kvm_init_msr_list(void) · 35 unmodified lines
5145	intel_pt_validate_hw_cap(PT_CAP_num_address_ranges) * 2)	5140	intel_pt_validate_hw_cap(PT_CAP_num_address_ranges) * 2)
5146	continue;	5141	continue;
5147	break;	5142	break;
		5143	case MSR_ARCH_PERFMON_PERFCTR0 ... MSR_ARCH_PERFMON_PERFCTR0 + 17:
		5144	if (msrs_to_save[i] - MSR_ARCH_PERFMON_PERFCTR0 >=
		5145	min(INTEL_PMC_MAX_GENERIC, x86_pmu.num_counters_gp))
		5146	continue;
		5147	break;
		5148	case MSR_ARCH_PERFMON_EVENTSEL0 ... MSR_ARCH_PERFMON_EVENTSEL0 + 17:
		5149	if (msrs_to_save[i] - MSR_ARCH_PERFMON_EVENTSEL0 >=
		5150	min(INTEL_PMC_MAX_GENERIC, x86_pmu.num_counters_gp))
		5151	continue;
5148	}	5152	}
5149	default:	5153	default:
5150	break;	5154	break;
@@ -8714,10 +8718,6 @@ EXPORT_SYMBOL_GPL(kvm_task_switch); · 3563 unmodified lines
8714		8718
8715	static int kvm_valid_sregs(struct kvm_vcpu vcpu, struct kvm_sregs sregs)	8719	static int kvm_valid_sregs(struct kvm_vcpu vcpu, struct kvm_sregs sregs)
8716	{	8720	{
8717	if (!guest_cpuid_has(vcpu, X86_FEATURE_XSAVE) &&
8718	(sregs->cr4 & X86_CR4_OSXSAVE))
8719	return -EINVAL;
8720
8721	if ((sregs->efer & EFER_LME) && (sregs->cr0 & X86_CR0_PG)) {	8721	if ((sregs->efer & EFER_LME) && (sregs->cr0 & X86_CR0_PG)) {
8722	/*	8722	/*
8723	* When EFER.LME and CR0.PG are set, the processor is in	8723	* When EFER.LME and CR0.PG are set, the processor is in
@@ -8736,7 +8736,7 @@ static int kvm_valid_sregs(struct kvm_vcpu vcpu, struct kvm_sregs sregs) · 12 unmodified lines
8736	return -EINVAL;	8736	return -EINVAL;
8737	}	8737	}
8738		8738
8739	return 0;	8739	return kvm_valid_cr4(vcpu, sregs->cr4);
8740	}	8740	}
8741		8741
8742	static int __set_sregs(struct kvm_vcpu vcpu, struct kvm_sregs sregs)	8742	static int __set_sregs(struct kvm_vcpu vcpu, struct kvm_sregs sregs)

arch/x86/xen/efi.c+1−13

@@ -57,19 +57,7 @@ static efi_system_table_t __init *xen_efi_probe(void) · 56 unmodified lines
57	return NULL;	57	return NULL;
58		58
59	/* Here we know that Xen runs on EFI platform. */	59	/* Here we know that Xen runs on EFI platform. */
60		60	xen_efi_runtime_setup();
61	efi.get_time = xen_efi_get_time;
62	efi.set_time = xen_efi_set_time;
63	efi.get_wakeup_time = xen_efi_get_wakeup_time;
64	efi.set_wakeup_time = xen_efi_set_wakeup_time;
65	efi.get_variable = xen_efi_get_variable;
66	efi.get_next_variable = xen_efi_get_next_variable;
67	efi.set_variable = xen_efi_set_variable;
68	efi.query_variable_info = xen_efi_query_variable_info;
69	efi.update_capsule = xen_efi_update_capsule;
70	efi.query_capsule_caps = xen_efi_query_capsule_caps;
71	efi.get_next_high_mono_count = xen_efi_get_next_high_mono_count;
72	efi.reset_system = xen_efi_reset_system;
73		61
74	efi_systab_xen.tables = info->cfg.addr;	62	efi_systab_xen.tables = info->cfg.addr;
75	efi_systab_xen.nr_tables = info->cfg.nent;	63	efi_systab_xen.nr_tables = info->cfg.nent;

block/blk-mq.c+9−3

 		/* bypass scheduler for flush rq */
 		blk_insert_flush(rq);
 		blk_mq_run_hw_queue(data.hctx, true);
-	} else if (plug && (q->nr_hw_queues == 1 || q->mq_ops->commit_rqs)) {
+	} else if (plug && (q->nr_hw_queues == 1 || q->mq_ops->commit_rqs ||
+				!blk_queue_nonrot(q))) {
 		/*
 		 * Use plugging if we have a ->commit_rqs() hook as well, as
 		 * we know the driver uses bd->last in a smart fashion.
+		 *
+		 * Use normal plugging if this disk is slow HDD, as sequential
+		 * IO may benefit a lot from plug merging.
 		 */
 		unsigned int request_count = plug->rq_count;
 		struct request *last = NULL;
 		}
 		blk_add_rq_to_plug(plug, rq);
+	} else if (q->elevator) {
+		blk_mq_sched_insert_request(rq, false, true, true);
 	} else if (plug && !blk_queue_nomerges(q)) {
 		/*
 		 * We do limited plugging. If the bio can be merged, do that.
 			blk_mq_try_issue_directly(data.hctx, same_queue_rq,
 					&cookie);
 		}
-	} else if ((q->nr_hw_queues > 1 && is_sync) || (!q->elevator &&
+	} else if ((q->nr_hw_queues > 1 && is_sync) ||
-			!data.hctx->dispatch_busy)) {
+			!data.hctx->dispatch_busy) {
 		blk_mq_try_issue_directly(data.hctx, rq, &cookie);
 	} else {
 		blk_mq_sched_insert_request(rq, false, true, true);

block/sed-opal.c+3−3

@@ -129,7 +129,7 @@ static const u8 opaluid[][OPAL_UID_LENGTH] = { · 128 unmodified lines
129	{ 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x84, 0x01 },	129	{ 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x84, 0x01 },
130		130
131	/* tables */	131	/* tables */
132	[OPAL_TABLE_TABLE]	132	[OPAL_TABLE_TABLE] =
133	{ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01 },	133	{ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01 },
134	[OPAL_LOCKINGRANGE_GLOBAL] =	134	[OPAL_LOCKINGRANGE_GLOBAL] =
135	{ 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x01 },	135	{ 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x01 },
@@ -372,8 +372,8 @@ static void check_geometry(struct opal_dev dev, const void data) · 236 unmodified lines
372	{	372	{
373	const struct d0_geometry_features *geo = data;	373	const struct d0_geometry_features *geo = data;
374		374
375	dev->align = geo->alignment_granularity;	375	dev->align = be64_to_cpu(geo->alignment_granularity);
376	dev->lowest_lba = geo->lowest_aligned_lba;	376	dev->lowest_lba = be64_to_cpu(geo->lowest_aligned_lba);
377	}	377	}
378		378
379	static int execute_step(struct opal_dev *dev,	379	static int execute_step(struct opal_dev *dev,

drivers/block/loop.c+10−0

@@ -994,6 +994,16 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode, · 993 unmodified lines
994	if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)	994	if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
995	blk_queue_write_cache(lo->lo_queue, true, false);	995	blk_queue_write_cache(lo->lo_queue, true, false);
996		996
		997	if (io_is_direct(lo->lo_backing_file) && inode->i_sb->s_bdev) {
		998	/* In case of direct I/O, match underlying block size */
		999	unsigned short bsize = bdev_logical_block_size(
		1000	inode->i_sb->s_bdev);
		1001
		1002	blk_queue_logical_block_size(lo->lo_queue, bsize);
		1003	blk_queue_physical_block_size(lo->lo_queue, bsize);
		1004	blk_queue_io_min(lo->lo_queue, bsize);
		1005	}
		1006
997	loop_update_rotational(lo);	1007	loop_update_rotational(lo);
998	loop_update_dio(lo);	1008	loop_update_dio(lo);
999	set_capacity(lo->lo_disk, size);	1009	set_capacity(lo->lo_disk, size);

drivers/char/random.c+1−1

@@ -2520,4 +2520,4 @@ void add_bootloader_randomness(const void *buf, unsigned int size) · 2519 unmodified lines
2520	else	2520	else
2521	add_device_randomness(buf, size);	2521	add_device_randomness(buf, size);
2522	}	2522	}
2523	EXPORT_SYMBOL_GPL(add_bootloader_randomness);	2523	EXPORT_SYMBOL_GPL(add_bootloader_randomness);

drivers/clk/ti/clk-7xx.c+3−3

drivers/clocksource/timer-of.c+3−1

@@ -25,7 +25,9 @@ static __init void timer_of_irq_exit(struct of_timer_irq *of_irq) · 24 unmodified lines
25		25
26	struct clock_event_device *clkevt = &to->clkevt;	26	struct clock_event_device *clkevt = &to->clkevt;
27		27
28	of_irq->percpu ? free_percpu_irq(of_irq->irq, clkevt) :	28	if (of_irq->percpu)
		29	free_percpu_irq(of_irq->irq, clkevt);
		30	else
29	free_irq(of_irq->irq, clkevt);	31	free_irq(of_irq->irq, clkevt);
30	}	32	}
31		33

drivers/gpu/drm/amd/amdgpu/Makefile+1−1

@@ -54,7 +54,7 @@ amdgpu-y += amdgpu_device.o amdgpu_kms.o \ · 53 unmodified lines
54	amdgpu_gtt_mgr.o amdgpu_vram_mgr.o amdgpu_virt.o amdgpu_atomfirmware.o \	54	amdgpu_gtt_mgr.o amdgpu_vram_mgr.o amdgpu_virt.o amdgpu_atomfirmware.o \
55	amdgpu_vf_error.o amdgpu_sched.o amdgpu_debugfs.o amdgpu_ids.o \	55	amdgpu_vf_error.o amdgpu_sched.o amdgpu_debugfs.o amdgpu_ids.o \
56	amdgpu_gmc.o amdgpu_xgmi.o amdgpu_csa.o amdgpu_ras.o amdgpu_vm_cpu.o \	56	amdgpu_gmc.o amdgpu_xgmi.o amdgpu_csa.o amdgpu_ras.o amdgpu_vm_cpu.o \
57	amdgpu_vm_sdma.o amdgpu_pmu.o amdgpu_discovery.o amdgpu_ras_eeprom.o smu_v11_0_i2c.o	57	amdgpu_vm_sdma.o amdgpu_discovery.o amdgpu_ras_eeprom.o smu_v11_0_i2c.o
58		58
59	amdgpu-$(CONFIG_PERF_EVENTS) += amdgpu_pmu.o	59	amdgpu-$(CONFIG_PERF_EVENTS) += amdgpu_pmu.o
60		60

drivers/gpu/drm/amd/amdgpu/amdgpu_acp.c+22−12

 	u32 val = 0;
 	u32 count = 0;
 	struct device *dev;
-	struct i2s_platform_data *i2s_pdata;
+	struct i2s_platform_data *i2s_pdata = NULL;
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 	adev->acp.acp_cell = kcalloc(ACP_DEVS, sizeof(struct mfd_cell),
 							GFP_KERNEL);
-	if (adev->acp.acp_cell == NULL)
+	if (adev->acp.acp_cell == NULL) {
-		return -ENOMEM;
+		r = -ENOMEM;
+		goto failure;
+	}
 	adev->acp.acp_res = kcalloc(5, sizeof(struct resource), GFP_KERNEL);
 	if (adev->acp.acp_res == NULL) {
-		kfree(adev->acp.acp_cell);
+		r = -ENOMEM;
-		return -ENOMEM;
+		goto failure;
 	}
 	i2s_pdata = kcalloc(3, sizeof(struct i2s_platform_data), GFP_KERNEL);
 	if (i2s_pdata == NULL) {
-		kfree(adev->acp.acp_res);
+		r = -ENOMEM;
-		kfree(adev->acp.acp_cell);
+		goto failure;
-		return -ENOMEM;
 	}
 	switch (adev->asic_type) {
 	r = mfd_add_hotplug_devices(adev->acp.parent, adev->acp.acp_cell,
 								ACP_DEVS);
 	if (r)
-		return r;
+		goto failure;
 	for (i = 0; i < ACP_DEVS ; i++) {
 		dev = get_mfd_cell_dev(adev->acp.acp_cell[i].name, i);
 		r = pm_genpd_add_device(&adev->acp.acp_genpd->gpd, dev);
 		if (r) {
 			dev_err(dev, "Failed to add dev to genpd\n");
-			return r;
+			goto failure;
 		}
 	}
 			break;
 		if (--count == 0) {
 			dev_err(&adev->pdev->dev, "Failed to reset ACP\n");
-			return -ETIMEDOUT;
+			r = -ETIMEDOUT;
+			goto failure;
 		}
 		udelay(100);
 	}
 			break;
 		if (--count == 0) {
 			dev_err(&adev->pdev->dev, "Failed to reset ACP\n");
-			return -ETIMEDOUT;
+			r = -ETIMEDOUT;
+			goto failure;
 		}
 		udelay(100);
 	}
 	val &= ~ACP_SOFT_RESET__SoftResetAud_MASK;
 	cgs_write_register(adev->acp.cgs_device, mmACP_SOFT_RESET, val);
 	return 0;
+failure:
+	kfree(i2s_pdata);
+	kfree(adev->acp.acp_res);
+	kfree(adev->acp.acp_cell);
+	kfree(adev->acp.acp_genpd);
+	return r;
 }
 /**

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

  * - 3.32.0 - Add syncobj timeline support to AMDGPU_CS.
  * - 3.33.0 - Fixes for GDS ENOMEM failures in AMDGPU_CS.
  * - 3.34.0 - Non-DC can flip correctly between buffers with different pitches
+ * - 3.35.0 - Add drm_amdgpu_info_device::tcc_disabled_mask
  */
 #define KMS_DRIVER_MAJOR	3
-#define KMS_DRIVER_MINOR	34
+#define KMS_DRIVER_MINOR	35
 #define KMS_DRIVER_PATCHLEVEL	0
 #define AMDGPU_MAX_TIMEOUT_PARAM_LENTH	256

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

@@ -165,6 +165,7 @@ struct amdgpu_gfx_config { · 164 unmodified lines
165	uint32_t num_sc_per_sh;	165	uint32_t num_sc_per_sh;
166	uint32_t num_packer_per_sc;	166	uint32_t num_packer_per_sc;
167	uint32_t pa_sc_tile_steering_override;	167	uint32_t pa_sc_tile_steering_override;
		168	uint64_t tcc_disabled_mask;
168	};	169	};
169		170
170	struct amdgpu_cu_info {	171	struct amdgpu_cu_info {

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

@@ -787,6 +787,8 @@ static int amdgpu_info_ioctl(struct drm_device dev, void data, struct drm_file · 786 unmodified lines
787	dev_info.pa_sc_tile_steering_override =	787	dev_info.pa_sc_tile_steering_override =
788	adev->gfx.config.pa_sc_tile_steering_override;	788	adev->gfx.config.pa_sc_tile_steering_override;
789		789
		790	dev_info.tcc_disabled_mask = adev->gfx.config.tcc_disabled_mask;
		791
790	return copy_to_user(out, &dev_info,	792	return copy_to_user(out, &dev_info,
791	min((size_t)size, sizeof(dev_info))) ? -EFAULT : 0;	793	min((size_t)size, sizeof(dev_info))) ? -EFAULT : 0;
792	}	794	}

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

 	struct ttm_bo_global *glob = adev->mman.bdev.glob;
 	struct amdgpu_vm_bo_base *bo_base;
-#if 0
 	if (vm->bulk_moveable) {
 		spin_lock(&glob->lru_lock);
 		ttm_bo_bulk_move_lru_tail(&vm->lru_bulk_move);
 		spin_unlock(&glob->lru_lock);
 		return;
 	}
-#endif
 	memset(&vm->lru_bulk_move, 0, sizeof(vm->lru_bulk_move));

drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c+12−0

 	}
 }
+static void gfx_v10_0_get_tcc_info(struct amdgpu_device *adev)
+{
+	/* TCCs are global (not instanced). */
+	uint32_t tcc_disable = RREG32_SOC15(GC, 0, mmCGTS_TCC_DISABLE) |
+			       RREG32_SOC15(GC, 0, mmCGTS_USER_TCC_DISABLE);
+	adev->gfx.config.tcc_disabled_mask =
+		REG_GET_FIELD(tcc_disable, CGTS_TCC_DISABLE, TCC_DISABLE) |
+		(REG_GET_FIELD(tcc_disable, CGTS_TCC_DISABLE, HI_TCC_DISABLE) << 16);
+}
 static void gfx_v10_0_constants_init(struct amdgpu_device *adev)
 {
 	u32 tmp;
 	gfx_v10_0_setup_rb(adev);
 	gfx_v10_0_get_cu_info(adev, &adev->gfx.cu_info);
+	gfx_v10_0_get_tcc_info(adev);
 	adev->gfx.config.pa_sc_tile_steering_override =
 		gfx_v10_0_init_pa_sc_tile_steering_override(adev);

drivers/gpu/drm/amd/amdgpu/nv.c+4−2

 	struct smu_context *smu = &adev->smu;
 	if (nv_asic_reset_method(adev) == AMD_RESET_METHOD_BACO) {
-		amdgpu_inc_vram_lost(adev);
+		if (!adev->in_suspend)
+			amdgpu_inc_vram_lost(adev);
 		ret = smu_baco_reset(smu);
 	} else {
-		amdgpu_inc_vram_lost(adev);
+		if (!adev->in_suspend)
+			amdgpu_inc_vram_lost(adev);
 		ret = nv_asic_mode1_reset(adev);
 	}

drivers/gpu/drm/amd/amdgpu/soc15.c+4−4

 {
 	switch (soc15_asic_reset_method(adev)) {
 		case AMD_RESET_METHOD_BACO:
-			amdgpu_inc_vram_lost(adev);
+			if (!adev->in_suspend)
+				amdgpu_inc_vram_lost(adev);
 			return soc15_asic_baco_reset(adev);
 		case AMD_RESET_METHOD_MODE2:
 			return soc15_mode2_reset(adev);
 		default:
-			amdgpu_inc_vram_lost(adev);
+			if (!adev->in_suspend)
+				amdgpu_inc_vram_lost(adev);
 			return soc15_asic_mode1_reset(adev);
 	}
 }
 #if defined(CONFIG_DRM_AMD_DC)
                 else if (amdgpu_device_has_dc_support(adev))
                         amdgpu_device_ip_block_add(adev, &dm_ip_block);
-#else
-#       warning "Enable CONFIG_DRM_AMD_DC for display support on SOC15."
 #endif
 		amdgpu_device_ip_block_add(adev, &vcn_v2_0_ip_block);
 		break;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+2−2

 	if (adev->asic_type != CHIP_CARRIZO && adev->asic_type != CHIP_STONEY)
 		dm->dc->debug.disable_stutter = amdgpu_pp_feature_mask & PP_STUTTER_MODE ? false : true;
-	if (adev->asic_type == CHIP_RENOIR)
-		dm->dc->debug.disable_stutter = true;
 	return 0;
 fail:
 	struct drm_crtc *crtc;
 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
 	int i;
+#ifdef CONFIG_DEBUG_FS
 	enum amdgpu_dm_pipe_crc_source source;
+#endif
 	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state,
 				      new_crtc_state, i) {

drivers/gpu/drm/amd/display/dc/dce100/dce100_resource.c+1−0

@@ -668,6 +668,7 @@ struct clock_source *dce100_clock_source_create( · 667 unmodified lines
668	return &clk_src->base;	668	return &clk_src->base;
669	}	669	}
670		670
		671	kfree(clk_src);
671	BREAK_TO_DEBUGGER();	672	BREAK_TO_DEBUGGER();
672	return NULL;	673	return NULL;
673	}	674	}

drivers/gpu/drm/amd/display/dc/dce110/dce110_resource.c+1−0

@@ -714,6 +714,7 @@ struct clock_source *dce110_clock_source_create( · 713 unmodified lines
714	return &clk_src->base;	714	return &clk_src->base;
715	}	715	}
716		716
		717	kfree(clk_src);
717	BREAK_TO_DEBUGGER();	718	BREAK_TO_DEBUGGER();
718	return NULL;	719	return NULL;
719	}	720	}

drivers/gpu/drm/amd/display/dc/dce112/dce112_resource.c+1−0

@@ -687,6 +687,7 @@ struct clock_source *dce112_clock_source_create( · 686 unmodified lines
687	return &clk_src->base;	687	return &clk_src->base;
688	}	688	}
689		689
		690	kfree(clk_src);
690	BREAK_TO_DEBUGGER();	691	BREAK_TO_DEBUGGER();
691	return NULL;	692	return NULL;
692	}	693	}

drivers/gpu/drm/amd/display/dc/dce120/dce120_resource.c+1−0

@@ -500,6 +500,7 @@ static struct clock_source *dce120_clock_source_create( · 499 unmodified lines
500	return &clk_src->base;	500	return &clk_src->base;
501	}	501	}
502		502
		503	kfree(clk_src);
503	BREAK_TO_DEBUGGER();	504	BREAK_TO_DEBUGGER();
504	return NULL;	505	return NULL;
505	}	506	}

drivers/gpu/drm/amd/display/dc/dce80/dce80_resource.c+1−0

@@ -701,6 +701,7 @@ struct clock_source *dce80_clock_source_create( · 700 unmodified lines
701	return &clk_src->base;	701	return &clk_src->base;
702	}	702	}
703		703
		704	kfree(clk_src);
704	BREAK_TO_DEBUGGER();	705	BREAK_TO_DEBUGGER();
705	return NULL;	706	return NULL;
706	}	707	}

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_resource.c+1−0

@@ -786,6 +786,7 @@ struct clock_source *dcn10_clock_source_create( · 785 unmodified lines
786	return &clk_src->base;	786	return &clk_src->base;
787	}	787	}
788		788
		789	kfree(clk_src);
789	BREAK_TO_DEBUGGER();	790	BREAK_TO_DEBUGGER();
790	return NULL;	791	return NULL;
791	}	792	}

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c+1−0

@@ -1077,6 +1077,7 @@ struct clock_source *dcn20_clock_source_create( · 1076 unmodified lines
1077	return &clk_src->base;	1077	return &clk_src->base;
1078	}	1078	}
1079		1079
		1080	kfree(clk_src);
1080	BREAK_TO_DEBUGGER();	1081	BREAK_TO_DEBUGGER();
1081	return NULL;	1082	return NULL;
1082	}	1083	}

drivers/gpu/drm/amd/display/dc/dcn21/Makefile+11−1

@@ -3,7 +3,17 @@ · 2 unmodified lines
3		3
4	DCN21 = dcn21_hubp.o dcn21_hubbub.o dcn21_resource.o	4	DCN21 = dcn21_hubp.o dcn21_hubbub.o dcn21_resource.o
5		5
6	CFLAGS_$(AMDDALPATH)/dc/dcn21/dcn21_resource.o := -mhard-float -msse -mpreferred-stack-boundary=4	6	ifneq ($(call cc-option, -mpreferred-stack-boundary=4),)
		7	cc_stack_align := -mpreferred-stack-boundary=4
		8	else ifneq ($(call cc-option, -mstack-alignment=16),)
		9	cc_stack_align := -mstack-alignment=16
		10	endif
		11
		12	CFLAGS_$(AMDDALPATH)/dc/dcn21/dcn21_resource.o := -mhard-float -msse $(cc_stack_align)
		13
		14	ifdef CONFIG_CC_IS_CLANG
		15	CFLAGS_$(AMDDALPATH)/dc/dcn21/dcn21_resource.o += -msse2
		16	endif
7		17
8	AMD_DAL_DCN21 = $(addprefix $(AMDDALPATH)/dc/dcn21/,$(DCN21))	18	AMD_DAL_DCN21 = $(addprefix $(AMDDALPATH)/dc/dcn21/,$(DCN21))
9		19

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_mode_vba_21.c+5−8

  * ways. Unless there is something clearly wrong with it the code should
  * remain as-is as it provides us with a guarantee from HW that it is correct.
  */
-typedef unsigned int uint;
 typedef struct {
 	double DPPCLK;
 	double DISPCLK;
 				mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = 0.0;
 				mode_lib->vba.MaximumReadBandwidthWithPrefetch = 0.0;
 				for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
-					uint m;
+					unsigned int m;
 					locals->cursor_bw[k] = 0;
 					locals->cursor_bw_pre[k] = 0;
 	double SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank;
 	double FullDETBufferingTimeYStutterCriticalPlane = 0;
 	double TimeToFinishSwathTransferStutterCriticalPlane = 0;
-	uint k, j;
+	unsigned int k, j;
 	mode_lib->vba.TotalActiveDPP = 0;
 	mode_lib->vba.TotalDCCActiveDPP = 0;
 		double DPPCLK[],
 		double *DCFCLKDeepSleep)
 {
-	uint k;
+	unsigned int k;
 	double DisplayPipeLineDeliveryTimeLuma;
 	double DisplayPipeLineDeliveryTimeChroma;
 	//double   DCFCLKDeepSleepPerPlane[DC__NUM_DPP__MAX];
 		double DisplayPipeRequestDeliveryTimeChromaPrefetch[])
 {
 	double req_per_swath_ub;
-	uint k;
+	unsigned int k;
 	for (k = 0; k < NumberOfActivePlanes; ++k) {
 		if (VRatio[k] <= 1) {
 	unsigned int dpte_groups_per_row_chroma_ub;
 	unsigned int num_group_per_lower_vm_stage;
 	unsigned int num_req_per_lower_vm_stage;
-	uint k;
+	unsigned int k;
 	for (k = 0; k < NumberOfActivePlanes; ++k) {
 		if (GPUVMEnable == true) {

drivers/gpu/drm/amd/powerplay/amdgpu_smu.c+2−0

@@ -843,6 +843,8 @@ static int smu_sw_init(void *handle) · 842 unmodified lines
843	smu->smu_baco.state = SMU_BACO_STATE_EXIT;	843	smu->smu_baco.state = SMU_BACO_STATE_EXIT;
844	smu->smu_baco.platform_support = false;	844	smu->smu_baco.platform_support = false;
845		845
		846	mutex_init(&smu->sensor_lock);
		847
846	smu->watermarks_bitmap = 0;	848	smu->watermarks_bitmap = 0;
847	smu->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;	849	smu->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;
848	smu->default_power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;	850	smu->default_power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;

drivers/gpu/drm/amd/powerplay/arcturus_ppt.c+2−0

 	if (!data || !size)
 		return -EINVAL;
+	mutex_lock(&smu->sensor_lock);
 	switch (sensor) {
 	case AMDGPU_PP_SENSOR_MAX_FAN_RPM:
 		*(uint32_t *)data = pptable->FanMaximumRpm;
 	default:
 		ret = smu_smc_read_sensor(smu, sensor, data, size);
 	}
+	mutex_unlock(&smu->sensor_lock);
 	return ret;
 }

drivers/gpu/drm/amd/powerplay/inc/amdgpu_smu.h+1−0

@@ -344,6 +344,7 @@ struct smu_context · 343 unmodified lines
344	const struct smu_funcs *funcs;	344	const struct smu_funcs *funcs;
345	const struct pptable_funcs *ppt_funcs;	345	const struct pptable_funcs *ppt_funcs;
346	struct mutex mutex;	346	struct mutex mutex;
		347	struct mutex sensor_lock;
347	uint64_t pool_size;	348	uint64_t pool_size;
348		349
349	struct smu_table_context smu_table;	350	struct smu_table_context smu_table;

drivers/gpu/drm/amd/powerplay/navi10_ppt.c+3−1

 	struct smu_table_context *smu_table= &smu->smu_table;
 	int ret = 0;
-	if (!smu_table->metrics_time || time_after(jiffies, smu_table->metrics_time + HZ / 1000)) {
+	if (!smu_table->metrics_time || time_after(jiffies, smu_table->metrics_time + msecs_to_jiffies(100))) {
 		ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0,
 				(void *)smu_table->metrics_table, false);
 		if (ret) {
 	if(!data || !size)
 		return -EINVAL;
+	mutex_lock(&smu->sensor_lock);
 	switch (sensor) {
 	case AMDGPU_PP_SENSOR_MAX_FAN_RPM:
 		*(uint32_t *)data = pptable->FanMaximumRpm;
 	default:
 		ret = smu_smc_read_sensor(smu, sensor, data, size);
 	}
+	mutex_unlock(&smu->sensor_lock);
 	return ret;
 }

drivers/gpu/drm/amd/powerplay/vega20_ppt.c+2−0

 	if(!data || !size)
 		return -EINVAL;
+	mutex_lock(&smu->sensor_lock);
 	switch (sensor) {
 	case AMDGPU_PP_SENSOR_MAX_FAN_RPM:
 		*(uint32_t *)data = pptable->FanMaximumRpm;
 	default:
 		ret = smu_smc_read_sensor(smu, sensor, data, size);
 	}
+	mutex_unlock(&smu->sensor_lock);
 	return ret;
 }

drivers/gpu/drm/arm/display/komeda/komeda_wb_connector.c+4−3

 	struct komeda_data_flow_cfg dflow;
 	int err;
-	if (!writeback_job || !writeback_job->fb) {
+	if (!writeback_job)
 		return 0;
-	}
 	if (!crtc_st->active) {
 		DRM_DEBUG_ATOMIC("Cannot write the composition result out on a inactive CRTC.\n");
 					   &komeda_wb_encoder_helper_funcs,
 					   formats, n_formats);
 	komeda_put_fourcc_list(formats);
-	if (err)
+	if (err) {
+		kfree(kwb_conn);
 		return err;
+	}
 	drm_connector_helper_add(&wb_conn->base, &komeda_wb_conn_helper_funcs);

drivers/gpu/drm/arm/malidp_mw.c+2−2

@@ -131,7 +131,7 @@ malidp_mw_encoder_atomic_check(struct drm_encoder *encoder, · 130 unmodified lines
131	struct drm_framebuffer *fb;	131	struct drm_framebuffer *fb;
132	int i, n_planes;	132	int i, n_planes;
133		133
134	if (!conn_state->writeback_job \|\| !conn_state->writeback_job->fb)	134	if (!conn_state->writeback_job)
135	return 0;	135	return 0;
136		136
137	fb = conn_state->writeback_job->fb;	137	fb = conn_state->writeback_job->fb;
@@ -248,7 +248,7 @@ void malidp_mw_atomic_commit(struct drm_device *drm, · 110 unmodified lines
248		248
249	mw_state = to_mw_state(conn_state);	249	mw_state = to_mw_state(conn_state);
250		250
251	if (conn_state->writeback_job && conn_state->writeback_job->fb) {	251	if (conn_state->writeback_job) {
252	struct drm_framebuffer *fb = conn_state->writeback_job->fb;	252	struct drm_framebuffer *fb = conn_state->writeback_job->fb;
253		253
254	DRM_DEV_DEBUG_DRIVER(drm->dev,	254	DRM_DEV_DEBUG_DRIVER(drm->dev,

drivers/gpu/drm/drm_atomic.c+9−4

 		return -EINVAL;
 	}
-	if (writeback_job->out_fence && !writeback_job->fb) {
+	if (!writeback_job->fb) {
-		DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n",
+		if (writeback_job->out_fence) {
-				 connector->base.id, connector->name);
+			DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n",
-		return -EINVAL;
+					 connector->base.id, connector->name);
+			return -EINVAL;
+		}
+		drm_writeback_cleanup_job(writeback_job);
+		state->writeback_job = NULL;
 	}
 	return 0;

drivers/gpu/drm/drm_writeback.c+15−8

@@ -324,6 +324,9 @@ void drm_writeback_cleanup_job(struct drm_writeback_job *job) · 323 unmodified lines
324	if (job->fb)	324	if (job->fb)
325	drm_framebuffer_put(job->fb);	325	drm_framebuffer_put(job->fb);
326		326
		327	if (job->out_fence)
		328	dma_fence_put(job->out_fence);
		329
327	kfree(job);	330	kfree(job);
328	}	331	}
329	EXPORT_SYMBOL(drm_writeback_cleanup_job);	332	EXPORT_SYMBOL(drm_writeback_cleanup_job);
@@ -366,25 +369,29 @@ drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector, · 36 unmodified lines
366	{	369	{
367	unsigned long flags;	370	unsigned long flags;
368	struct drm_writeback_job *job;	371	struct drm_writeback_job *job;
		372	struct dma_fence *out_fence;
369		373
370	spin_lock_irqsave(&wb_connector->job_lock, flags);	374	spin_lock_irqsave(&wb_connector->job_lock, flags);
371	job = list_first_entry_or_null(&wb_connector->job_queue,	375	job = list_first_entry_or_null(&wb_connector->job_queue,
372	struct drm_writeback_job,	376	struct drm_writeback_job,
373	list_entry);	377	list_entry);
374	if (job) {	378	if (job)
375	list_del(&job->list_entry);	379	list_del(&job->list_entry);
376	if (job->out_fence) {	380
377	if (status)
378	dma_fence_set_error(job->out_fence, status);
379	dma_fence_signal(job->out_fence);
380	dma_fence_put(job->out_fence);
381	}
382	}
383	spin_unlock_irqrestore(&wb_connector->job_lock, flags);	381	spin_unlock_irqrestore(&wb_connector->job_lock, flags);
384		382
385	if (WARN_ON(!job))	383	if (WARN_ON(!job))
386	return;	384	return;
387		385
		386	out_fence = job->out_fence;
		387	if (out_fence) {
		388	if (status)
		389	dma_fence_set_error(out_fence, status);
		390	dma_fence_signal(out_fence);
		391	dma_fence_put(out_fence);
		392	job->out_fence = NULL;
		393	}
		394
388	INIT_WORK(&job->cleanup_work, cleanup_work);	395	INIT_WORK(&job->cleanup_work, cleanup_work);
389	queue_work(system_long_wq, &job->cleanup_work);	396	queue_work(system_long_wq, &job->cleanup_work);
390	}	397	}

drivers/gpu/drm/i915/display/intel_display.c+8−4

 	pipe_config->fdi_lanes = lane;
 	intel_link_compute_m_n(pipe_config->pipe_bpp, lane, fdi_dotclock,
-			       link_bw, &pipe_config->fdi_m_n, false);
+			       link_bw, &pipe_config->fdi_m_n, false, false);
 	ret = ironlake_check_fdi_lanes(dev, intel_crtc->pipe, pipe_config);
 	if (ret == -EDEADLK)
 intel_link_compute_m_n(u16 bits_per_pixel, int nlanes,
 		       int pixel_clock, int link_clock,
 		       struct intel_link_m_n *m_n,
-		       bool constant_n)
+		       bool constant_n, bool fec_enable)
 {
-	m_n->tu = 64;
+	u32 data_clock = bits_per_pixel * pixel_clock;
+	if (fec_enable)
+		data_clock = intel_dp_mode_to_fec_clock(data_clock);
-	compute_m_n(bits_per_pixel * pixel_clock,
+	m_n->tu = 64;
+	compute_m_n(data_clock,
 		    link_clock * nlanes * 8,
 		    &m_n->gmch_m, &m_n->gmch_n,
 		    constant_n);

drivers/gpu/drm/i915/display/intel_display.h+1−1

@@ -414,7 +414,7 @@ enum phy_fia { · 413 unmodified lines
414	void intel_link_compute_m_n(u16 bpp, int nlanes,	414	void intel_link_compute_m_n(u16 bpp, int nlanes,
415	int pixel_clock, int link_clock,	415	int pixel_clock, int link_clock,
416	struct intel_link_m_n *m_n,	416	struct intel_link_m_n *m_n,
417	bool constant_n);	417	bool constant_n, bool fec_enable);
418	bool is_ccs_modifier(u64 modifier);	418	bool is_ccs_modifier(u64 modifier);
419	void lpt_disable_clkout_dp(struct drm_i915_private *dev_priv);	419	void lpt_disable_clkout_dp(struct drm_i915_private *dev_priv);
420	u32 intel_plane_fb_max_stride(struct drm_i915_private *dev_priv,	420	u32 intel_plane_fb_max_stride(struct drm_i915_private *dev_priv,

drivers/gpu/drm/i915/display/intel_dp.c+95−89

 #define DP_DSC_MAX_ENC_THROUGHPUT_0		340000
 #define DP_DSC_MAX_ENC_THROUGHPUT_1		400000
-/* DP DSC FEC Overhead factor = (100 - 2.4)/100 */
+/* DP DSC FEC Overhead factor = 1/(0.972261) */
-#define DP_DSC_FEC_OVERHEAD_FACTOR		976
+#define DP_DSC_FEC_OVERHEAD_FACTOR		972261
 /* Compliance test status bits  */
 #define INTEL_DP_RESOLUTION_SHIFT_MASK	0
 	return 0;
 }
+u32 intel_dp_mode_to_fec_clock(u32 mode_clock)
+{
+	return div_u64(mul_u32_u32(mode_clock, 1000000U),
+		       DP_DSC_FEC_OVERHEAD_FACTOR);
+}
+static u16 intel_dp_dsc_get_output_bpp(u32 link_clock, u32 lane_count,
+				       u32 mode_clock, u32 mode_hdisplay)
+{
+	u32 bits_per_pixel, max_bpp_small_joiner_ram;
+	int i;
+	/*
+	 * Available Link Bandwidth(Kbits/sec) = (NumberOfLanes)*
+	 * (LinkSymbolClock)* 8 * (TimeSlotsPerMTP)
+	 * for SST -> TimeSlotsPerMTP is 1,
+	 * for MST -> TimeSlotsPerMTP has to be calculated
+	 */
+	bits_per_pixel = (link_clock * lane_count * 8) /
+			 intel_dp_mode_to_fec_clock(mode_clock);
+	DRM_DEBUG_KMS("Max link bpp: %u\n", bits_per_pixel);
+	/* Small Joiner Check: output bpp <= joiner RAM (bits) / Horiz. width */
+	max_bpp_small_joiner_ram = DP_DSC_MAX_SMALL_JOINER_RAM_BUFFER / mode_hdisplay;
+	DRM_DEBUG_KMS("Max small joiner bpp: %u\n", max_bpp_small_joiner_ram);
+	/*
+	 * Greatest allowed DSC BPP = MIN (output BPP from available Link BW
+	 * check, output bpp from small joiner RAM check)
+	 */
+	bits_per_pixel = min(bits_per_pixel, max_bpp_small_joiner_ram);
+	/* Error out if the max bpp is less than smallest allowed valid bpp */
+	if (bits_per_pixel < valid_dsc_bpp[0]) {
+		DRM_DEBUG_KMS("Unsupported BPP %u, min %u\n",
+			      bits_per_pixel, valid_dsc_bpp[0]);
+		return 0;
+	}
+	/* Find the nearest match in the array of known BPPs from VESA */
+	for (i = 0; i < ARRAY_SIZE(valid_dsc_bpp) - 1; i++) {
+		if (bits_per_pixel < valid_dsc_bpp[i + 1])
+			break;
+	}
+	bits_per_pixel = valid_dsc_bpp[i];
+	/*
+	 * Compressed BPP in U6.4 format so multiply by 16, for Gen 11,
+	 * fractional part is 0
+	 */
+	return bits_per_pixel << 4;
+}
+static u8 intel_dp_dsc_get_slice_count(struct intel_dp *intel_dp,
+				       int mode_clock, int mode_hdisplay)
+{
+	u8 min_slice_count, i;
+	int max_slice_width;
+	if (mode_clock <= DP_DSC_PEAK_PIXEL_RATE)
+		min_slice_count = DIV_ROUND_UP(mode_clock,
+					       DP_DSC_MAX_ENC_THROUGHPUT_0);
+	else
+		min_slice_count = DIV_ROUND_UP(mode_clock,
+					       DP_DSC_MAX_ENC_THROUGHPUT_1);
+	max_slice_width = drm_dp_dsc_sink_max_slice_width(intel_dp->dsc_dpcd);
+	if (max_slice_width < DP_DSC_MIN_SLICE_WIDTH_VALUE) {
+		DRM_DEBUG_KMS("Unsupported slice width %d by DP DSC Sink device\n",
+			      max_slice_width);
+		return 0;
+	}
+	/* Also take into account max slice width */
+	min_slice_count = min_t(u8, min_slice_count,
+				DIV_ROUND_UP(mode_hdisplay,
+					     max_slice_width));
+	/* Find the closest match to the valid slice count values */
+	for (i = 0; i < ARRAY_SIZE(valid_dsc_slicecount); i++) {
+		if (valid_dsc_slicecount[i] >
+		    drm_dp_dsc_sink_max_slice_count(intel_dp->dsc_dpcd,
+						    false))
+			break;
+		if (min_slice_count  <= valid_dsc_slicecount[i])
+			return valid_dsc_slicecount[i];
+	}
+	DRM_DEBUG_KMS("Unsupported Slice Count %d\n", min_slice_count);
+	return 0;
+}
 static enum drm_mode_status
 intel_dp_mode_valid(struct drm_connector *connector,
 		    struct drm_display_mode *mode)
 			       adjusted_mode->crtc_clock,
 			       pipe_config->port_clock,
 			       &pipe_config->dp_m_n,
-			       constant_n);
+			       constant_n, pipe_config->fec_enable);
 	if (intel_connector->panel.downclock_mode != NULL &&
 		dev_priv->drrs.type == SEAMLESS_DRRS_SUPPORT) {
 					       intel_connector->panel.downclock_mode->clock,
 					       pipe_config->port_clock,
 					       &pipe_config->dp_m2_n2,
-					       constant_n);
+					       constant_n, pipe_config->fec_enable);
 	}
 	if (!HAS_DDI(dev_priv))
 		DP_DPRX_ESI_LEN;
 }
-u16 intel_dp_dsc_get_output_bpp(int link_clock, u8 lane_count,
-				int mode_clock, int mode_hdisplay)
-{
-	u16 bits_per_pixel, max_bpp_small_joiner_ram;
-	int i;
-	/*
-	 * Available Link Bandwidth(Kbits/sec) = (NumberOfLanes)*
-	 * (LinkSymbolClock)* 8 * ((100-FECOverhead)/100)*(TimeSlotsPerMTP)
-	 * FECOverhead = 2.4%, for SST -> TimeSlotsPerMTP is 1,
-	 * for MST -> TimeSlotsPerMTP has to be calculated
-	 */
-	bits_per_pixel = (link_clock * lane_count * 8 *
-			  DP_DSC_FEC_OVERHEAD_FACTOR) /
-		mode_clock;
-	/* Small Joiner Check: output bpp <= joiner RAM (bits) / Horiz. width */
-	max_bpp_small_joiner_ram = DP_DSC_MAX_SMALL_JOINER_RAM_BUFFER /
-		mode_hdisplay;
-	/*
-	 * Greatest allowed DSC BPP = MIN (output BPP from avaialble Link BW
-	 * check, output bpp from small joiner RAM check)
-	 */
-	bits_per_pixel = min(bits_per_pixel, max_bpp_small_joiner_ram);
-	/* Error out if the max bpp is less than smallest allowed valid bpp */
-	if (bits_per_pixel < valid_dsc_bpp[0]) {
-		DRM_DEBUG_KMS("Unsupported BPP %d\n", bits_per_pixel);
-		return 0;
-	}
-	/* Find the nearest match in the array of known BPPs from VESA */
-	for (i = 0; i < ARRAY_SIZE(valid_dsc_bpp) - 1; i++) {
-		if (bits_per_pixel < valid_dsc_bpp[i + 1])
-			break;
-	}
-	bits_per_pixel = valid_dsc_bpp[i];
-	/*
-	 * Compressed BPP in U6.4 format so multiply by 16, for Gen 11,
-	 * fractional part is 0
-	 */
-	return bits_per_pixel << 4;
-}
-u8 intel_dp_dsc_get_slice_count(struct intel_dp *intel_dp,
-				int mode_clock,
-				int mode_hdisplay)
-{
-	u8 min_slice_count, i;
-	int max_slice_width;
-	if (mode_clock <= DP_DSC_PEAK_PIXEL_RATE)
-		min_slice_count = DIV_ROUND_UP(mode_clock,
-					       DP_DSC_MAX_ENC_THROUGHPUT_0);
-	else
-		min_slice_count = DIV_ROUND_UP(mode_clock,
-					       DP_DSC_MAX_ENC_THROUGHPUT_1);
-	max_slice_width = drm_dp_dsc_sink_max_slice_width(intel_dp->dsc_dpcd);
-	if (max_slice_width < DP_DSC_MIN_SLICE_WIDTH_VALUE) {
-		DRM_DEBUG_KMS("Unsupported slice width %d by DP DSC Sink device\n",
-			      max_slice_width);
-		return 0;
-	}
-	/* Also take into account max slice width */
-	min_slice_count = min_t(u8, min_slice_count,
-				DIV_ROUND_UP(mode_hdisplay,
-					     max_slice_width));
-	/* Find the closest match to the valid slice count values */
-	for (i = 0; i < ARRAY_SIZE(valid_dsc_slicecount); i++) {
-		if (valid_dsc_slicecount[i] >
-		    drm_dp_dsc_sink_max_slice_count(intel_dp->dsc_dpcd,
-						    false))
-			break;
-		if (min_slice_count  <= valid_dsc_slicecount[i])
-			return valid_dsc_slicecount[i];
-	}
-	DRM_DEBUG_KMS("Unsupported Slice Count %d\n", min_slice_count);
-	return 0;
-}
 static void
 intel_pixel_encoding_setup_vsc(struct intel_dp *intel_dp,
 			       const struct intel_crtc_state *crtc_state)

drivers/gpu/drm/i915/display/intel_dp.h+2−4

 bool intel_dp_source_supports_hbr3(struct intel_dp *intel_dp);
 bool
 intel_dp_get_link_status(struct intel_dp *intel_dp, u8 *link_status);
-u16 intel_dp_dsc_get_output_bpp(int link_clock, u8 lane_count,
-				int mode_clock, int mode_hdisplay);
-u8 intel_dp_dsc_get_slice_count(struct intel_dp *intel_dp, int mode_clock,
-				int mode_hdisplay);
 bool intel_dp_read_dpcd(struct intel_dp *intel_dp);
 bool intel_dp_get_colorimetry_status(struct intel_dp *intel_dp);
 	return ~((1 << lane_count) - 1) & 0xf;
 }
+u32 intel_dp_mode_to_fec_clock(u32 mode_clock);
 #endif /* __INTEL_DP_H__ */

drivers/gpu/drm/i915/display/intel_dp_mst.c+2−2

@@ -81,7 +81,7 @@ static int intel_dp_mst_compute_link_config(struct intel_encoder *encoder, · 80 unmodified lines
81	adjusted_mode->crtc_clock,	81	adjusted_mode->crtc_clock,
82	crtc_state->port_clock,	82	crtc_state->port_clock,
83	&crtc_state->dp_m_n,	83	&crtc_state->dp_m_n,
84	constant_n);	84	constant_n, crtc_state->fec_enable);
85	crtc_state->dp_m_n.tu = slots;	85	crtc_state->dp_m_n.tu = slots;
86		86
87	return 0;	87	return 0;
@@ -615,7 +615,7 @@ intel_dp_create_fake_mst_encoder(struct intel_digital_port *intel_dig_port, enum · 527 unmodified lines
615	intel_encoder->type = INTEL_OUTPUT_DP_MST;	615	intel_encoder->type = INTEL_OUTPUT_DP_MST;
616	intel_encoder->power_domain = intel_dig_port->base.power_domain;	616	intel_encoder->power_domain = intel_dig_port->base.power_domain;
617	intel_encoder->port = intel_dig_port->base.port;	617	intel_encoder->port = intel_dig_port->base.port;
618	intel_encoder->crtc_mask = BIT(pipe);	618	intel_encoder->crtc_mask = 0x7;
619	intel_encoder->cloneable = 0;	619	intel_encoder->cloneable = 0;
620		620
621	intel_encoder->compute_config = intel_dp_mst_compute_config;	621	intel_encoder->compute_config = intel_dp_mst_compute_config;

drivers/gpu/drm/i915/display/intel_sprite.c+3−2

 	int src_x, src_w, src_h, crtc_w, crtc_h;
 	const struct drm_display_mode *adjusted_mode =
 		&crtc_state->base.adjusted_mode;
+	unsigned int stride = plane_state->color_plane[0].stride;
 	unsigned int cpp = fb->format->cpp[0];
 	unsigned int width_bytes;
 	int min_width, min_height;
 		return -EINVAL;
 	}
-	if (width_bytes > 4096 || fb->pitches[0] > 4096) {
+	if (stride > 4096) {
 		DRM_DEBUG_KMS("Stride (%u) exceeds hardware max with scaling (%u)\n",
-			      fb->pitches[0], 4096);
+			      stride, 4096);
 		return -EINVAL;
 	}

drivers/gpu/drm/omapdrm/dss/dss.c+1−1

@@ -1083,7 +1083,7 @@ static const struct dss_features omap34xx_dss_feats = { · 1082 unmodified lines
1083		1083
1084	static const struct dss_features omap3630_dss_feats = {	1084	static const struct dss_features omap3630_dss_feats = {
1085	.model = DSS_MODEL_OMAP3,	1085	.model = DSS_MODEL_OMAP3,
1086	.fck_div_max = 32,	1086	.fck_div_max = 31,
1087	.fck_freq_max = 173000000,	1087	.fck_freq_max = 173000000,
1088	.dss_fck_multiplier = 1,	1088	.dss_fck_multiplier = 1,
1089	.parent_clk_name = "dpll4_ck",	1089	.parent_clk_name = "dpll4_ck",

drivers/gpu/drm/rcar-du/rcar_du_writeback.c+2−2

@@ -147,7 +147,7 @@ static int rcar_du_wb_enc_atomic_check(struct drm_encoder *encoder, · 146 unmodified lines
147	struct drm_device *dev = encoder->dev;	147	struct drm_device *dev = encoder->dev;
148	struct drm_framebuffer *fb;	148	struct drm_framebuffer *fb;
149		149
150	if (!conn_state->writeback_job \|\| !conn_state->writeback_job->fb)	150	if (!conn_state->writeback_job)
151	return 0;	151	return 0;
152		152
153	fb = conn_state->writeback_job->fb;	153	fb = conn_state->writeback_job->fb;
@@ -221,7 +221,7 @@ void rcar_du_writeback_setup(struct rcar_du_crtc *rcrtc, · 67 unmodified lines
221	unsigned int i;	221	unsigned int i;
222		222
223	state = rcrtc->writeback.base.state;	223	state = rcrtc->writeback.base.state;
224	if (!state \|\| !state->writeback_job \|\| !state->writeback_job->fb)	224	if (!state \|\| !state->writeback_job)
225	return;	225	return;
226		226
227	fb = state->writeback_job->fb;	227	fb = state->writeback_job->fb;

drivers/gpu/drm/tilcdc/tilcdc_tfp410.c+1−0

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	#include <linux/gpio.h>	7	#include <linux/gpio.h>
8	#include <linux/mod_devicetable.h>	8	#include <linux/mod_devicetable.h>
9	#include <linux/of_gpio.h>	9	#include <linux/of_gpio.h>
		10	#include <linux/pinctrl/consumer.h>
10	#include <linux/platform_device.h>	11	#include <linux/platform_device.h>
11		12
12	#include <drm/drm_atomic_helper.h>	13	#include <drm/drm_atomic_helper.h>

drivers/gpu/drm/vc4/vc4_txp.c+2−3

 	int i;
 	conn_state = drm_atomic_get_new_connector_state(state, conn);
-	if (!conn_state->writeback_job || !conn_state->writeback_job->fb)
+	if (!conn_state->writeback_job)
 		return 0;
 	crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
 	u32 ctrl;
 	int i;
-	if (WARN_ON(!conn_state->writeback_job ||
+	if (WARN_ON(!conn_state->writeback_job))
-		    !conn_state->writeback_job->fb))
 		return;
 	mode = &conn_state->crtc->state->adjusted_mode;

drivers/net/dsa/qca8k.c+2−2

@@ -705,7 +705,7 @@ qca8k_setup(struct dsa_switch *ds) · 704 unmodified lines
705	BIT(0) << QCA8K_GLOBAL_FW_CTRL1_UC_DP_S);	705	BIT(0) << QCA8K_GLOBAL_FW_CTRL1_UC_DP_S);
706		706
707	/* Setup connection between CPU port & user ports */	707	/* Setup connection between CPU port & user ports */
708	for (i = 0; i < DSA_MAX_PORTS; i++) {	708	for (i = 0; i < QCA8K_NUM_PORTS; i++) {
709	/* CPU port gets connected to all user ports of the switch */	709	/* CPU port gets connected to all user ports of the switch */
710	if (dsa_is_cpu_port(ds, i)) {	710	if (dsa_is_cpu_port(ds, i)) {
711	qca8k_rmw(priv, QCA8K_PORT_LOOKUP_CTRL(QCA8K_CPU_PORT),	711	qca8k_rmw(priv, QCA8K_PORT_LOOKUP_CTRL(QCA8K_CPU_PORT),
@@ -1077,7 +1077,7 @@ qca8k_sw_probe(struct mdio_device *mdiodev) · 365 unmodified lines
1077	if (id != QCA8K_ID_QCA8337)	1077	if (id != QCA8K_ID_QCA8337)
1078	return -ENODEV;	1078	return -ENODEV;
1079		1079
1080	priv->ds = dsa_switch_alloc(&mdiodev->dev, DSA_MAX_PORTS);	1080	priv->ds = dsa_switch_alloc(&mdiodev->dev, QCA8K_NUM_PORTS);
1081	if (!priv->ds)	1081	if (!priv->ds)
1082	return -ENOMEM;	1082	return -ENOMEM;
1083		1083

drivers/net/dsa/rtl8366.c+7−4

 			 const struct switchdev_obj_port_vlan *vlan)
 {
 	struct realtek_smi *smi = ds->priv;
+	u16 vid;
 	int ret;
-	if (!smi->ops->is_vlan_valid(smi, port))
+	for (vid = vlan->vid_begin; vid < vlan->vid_end; vid++)
-		return -EINVAL;
+		if (!smi->ops->is_vlan_valid(smi, vid))
+			return -EINVAL;
 	dev_info(smi->dev, "prepare VLANs %04x..%04x\n",
 		 vlan->vid_begin, vlan->vid_end);
 	u16 vid;
 	int ret;
-	if (!smi->ops->is_vlan_valid(smi, port))
+	for (vid = vlan->vid_begin; vid < vlan->vid_end; vid++)
-		return;
+		if (!smi->ops->is_vlan_valid(smi, vid))
+			return;
 	dev_info(smi->dev, "add VLAN on port %d, %s, %s\n",
 		 port,

drivers/net/dsa/rtl8366rb.c+10−6

 	irq = of_irq_get(intc, 0);
 	if (irq <= 0) {
 		dev_err(smi->dev, "failed to get parent IRQ\n");
-		return irq ? irq : -EINVAL;
+		ret = irq ? irq : -EINVAL;
+		goto out_put_node;
 	}
 	/* This clears the IRQ status register */
 			  &val);
 	if (ret) {
 		dev_err(smi->dev, "can't read interrupt status\n");
-		return ret;
+		goto out_put_node;
 	}
 	/* Fetch IRQ edge information from the descriptor */
 				 val);
 	if (ret) {
 		dev_err(smi->dev, "could not configure IRQ polarity\n");
-		return ret;
+		goto out_put_node;
 	}
 	ret = devm_request_threaded_irq(smi->dev, irq, NULL,
 					"RTL8366RB", smi);
 	if (ret) {
 		dev_err(smi->dev, "unable to request irq: %d\n", ret);
-		return ret;
+		goto out_put_node;
 	}
 	smi->irqdomain = irq_domain_add_linear(intc,
 					       RTL8366RB_NUM_INTERRUPT,
 					       smi);
 	if (!smi->irqdomain) {
 		dev_err(smi->dev, "failed to create IRQ domain\n");
-		return -EINVAL;
+		ret = -EINVAL;
+		goto out_put_node;
 	}
 	for (i = 0; i < smi->num_ports; i++)
 		irq_set_parent(irq_create_mapping(smi->irqdomain, i), irq);
-	return 0;
+out_put_node:
+	of_node_put(intc);
+	return ret;
 }
 static int rtl8366rb_set_addr(struct realtek_smi *smi)

drivers/net/dsa/sja1105/sja1105_main.c+14−10

 	return sja1105_static_config_reload(priv);
 }
-/* Caller must hold priv->tagger_data.meta_lock */
+/* Must be called only with priv->tagger_data.state bit
+ * SJA1105_HWTS_RX_EN cleared
+ */
 static int sja1105_change_rxtstamping(struct sja1105_private *priv,
 				      bool on)
 {
 		break;
 	}
-	if (rx_on != priv->tagger_data.hwts_rx_en) {
+	if (rx_on != test_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state)) {
-		spin_lock(&priv->tagger_data.meta_lock);
+		clear_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state);
 		rc = sja1105_change_rxtstamping(priv, rx_on);
-		spin_unlock(&priv->tagger_data.meta_lock);
 		if (rc < 0) {
 			dev_err(ds->dev,
 				"Failed to change RX timestamping: %d\n", rc);
-			return -EFAULT;
+			return rc;
 		}
-		priv->tagger_data.hwts_rx_en = rx_on;
+		if (rx_on)
+			set_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state);
 	}
 	if (copy_to_user(ifr->ifr_data, &config, sizeof(config)))
 		config.tx_type = HWTSTAMP_TX_ON;
 	else
 		config.tx_type = HWTSTAMP_TX_OFF;
-	if (priv->tagger_data.hwts_rx_en)
+	if (test_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state))
 		config.rx_filter = HWTSTAMP_FILTER_PTP_V2_L2_EVENT;
 	else
 		config.rx_filter = HWTSTAMP_FILTER_NONE;
 	mutex_lock(&priv->ptp_lock);
-	now = priv->tstamp_cc.read(&priv->tstamp_cc);
 	while ((skb = skb_dequeue(&data->skb_rxtstamp_queue)) != NULL) {
 		struct skb_shared_hwtstamps *shwt = skb_hwtstamps(skb);
 		u64 ts;
+		now = priv->tstamp_cc.read(&priv->tstamp_cc);
 		*shwt = (struct skb_shared_hwtstamps) {0};
 		ts = SJA1105_SKB_CB(skb)->meta_tstamp;
 	struct sja1105_private *priv = ds->priv;
 	struct sja1105_tagger_data *data = &priv->tagger_data;
-	if (!data->hwts_rx_en)
+	if (!test_bit(SJA1105_HWTS_RX_EN, &data->state))
 		return false;
 	/* We need to read the full PTP clock to reconstruct the Rx
 	tagger_data = &priv->tagger_data;
 	skb_queue_head_init(&tagger_data->skb_rxtstamp_queue);
 	INIT_WORK(&tagger_data->rxtstamp_work, sja1105_rxtstamp_work);
+	spin_lock_init(&tagger_data->meta_lock);
 	/* Connections between dsa_port and sja1105_port */
 	for (i = 0; i < SJA1105_NUM_PORTS; i++) {

drivers/net/dsa/sja1105/sja1105_spi.c+4−2

 	rc = static_config_buf_prepare_for_upload(priv, config_buf, buf_len);
 	if (rc < 0) {
 		dev_err(dev, "Invalid config, cannot upload\n");
-		return -EINVAL;
+		rc = -EINVAL;
+		goto out;
 	}
 	/* Prevent PHY jabbering during switch reset by inhibiting
 	 * Tx on all ports and waiting for current packet to drain.
 	rc = sja1105_inhibit_tx(priv, port_bitmap, true);
 	if (rc < 0) {
 		dev_err(dev, "Failed to inhibit Tx on ports\n");
-		return -ENXIO;
+		rc = -ENXIO;
+		goto out;
 	}
 	/* Wait for an eventual egress packet to finish transmission
 	 * (reach IFG). It is guaranteed that a second one will not

drivers/net/ethernet/atheros/ag71xx.c+4−2

 	struct device *dev = &ag->pdev->dev;
 	struct net_device *ndev = ag->ndev;
 	static struct mii_bus *mii_bus;
-	struct device_node *np;
+	struct device_node *np, *mnp;
 	int err;
 	np = dev->of_node;
 		msleep(200);
 	}
-	err = of_mdiobus_register(mii_bus, np);
+	mnp = of_get_child_by_name(np, "mdio");
+	err = of_mdiobus_register(mii_bus, mnp);
+	of_node_put(mnp);
 	if (err)
 		goto mdio_err_put_clk;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c+6−3

 static int alloc_uld_rxqs(struct adapter *adap,
 			  struct sge_uld_rxq_info *rxq_info, bool lro)
 {
-	struct sge *s = &adap->sge;
 	unsigned int nq = rxq_info->nrxq + rxq_info->nciq;
+	int i, err, msi_idx, que_idx = 0, bmap_idx = 0;
 	struct sge_ofld_rxq *q = rxq_info->uldrxq;
 	unsigned short *ids = rxq_info->rspq_id;
-	unsigned int bmap_idx = 0;
+	struct sge *s = &adap->sge;
 	unsigned int per_chan;
-	int i, err, msi_idx, que_idx = 0;
 	per_chan = rxq_info->nrxq / adap->params.nports;
 		if (msi_idx >= 0) {
 			bmap_idx = get_msix_idx_from_bmap(adap);
+			if (bmap_idx < 0) {
+				err = -ENOSPC;
+				goto freeout;
+			}
 			msi_idx = adap->msix_info_ulds[bmap_idx].idx;
 		}
 		err = t4_sge_alloc_rxq(adap, &q->rspq, false,

drivers/net/ethernet/hisilicon/hns_mdio.c+5−1

 {
 	u32 time_cnt;
 	u32 reg_value;
+	int ret;
 	regmap_write(mdio_dev->subctrl_vbase, cfg_reg, set_val);
 	for (time_cnt = MDIO_TIMEOUT; time_cnt; time_cnt--) {
-		regmap_read(mdio_dev->subctrl_vbase, st_reg, &reg_value);
+		ret = regmap_read(mdio_dev->subctrl_vbase, st_reg, &reg_value);
+		if (ret)
+			return ret;
 		reg_value &= st_msk;
 		if ((!!check_st) == (!!reg_value))
 			break;

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

@@ -137,7 +137,8 @@ dr_icm_pool_mr_create(struct mlx5dr_icm_pool *pool, · 136 unmodified lines
137		137
138	icm_mr->icm_start_addr = icm_mr->dm.addr;	138	icm_mr->icm_start_addr = icm_mr->dm.addr;
139		139
140	align_diff = icm_mr->icm_start_addr % align_base;	140	/* align_base is always a power of 2 */
		141	align_diff = icm_mr->icm_start_addr & (align_base - 1);
141	if (align_diff)	142	if (align_diff)
142	icm_mr->used_length = align_base - align_diff;	143	icm_mr->used_length = align_base - align_diff;
143		144

drivers/net/ethernet/mscc/ocelot_board.c+8−6

@@ -388,13 +388,14 @@ static int mscc_ocelot_probe(struct platform_device *pdev) · 387 unmodified lines
388	continue;	388	continue;
389		389
390	phy = of_phy_find_device(phy_node);	390	phy = of_phy_find_device(phy_node);
		391	of_node_put(phy_node);
391	if (!phy)	392	if (!phy)
392	continue;	393	continue;
393		394
394	err = ocelot_probe_port(ocelot, port, regs, phy);	395	err = ocelot_probe_port(ocelot, port, regs, phy);
395	if (err) {	396	if (err) {
396	of_node_put(portnp);	397	of_node_put(portnp);
397	return err;	398	goto out_put_ports;
398	}	399	}
399		400
400	phy_mode = of_get_phy_mode(portnp);	401	phy_mode = of_get_phy_mode(portnp);
@@ -422,7 +423,8 @@ static int mscc_ocelot_probe(struct platform_device *pdev) · 21 unmodified lines
422	"invalid phy mode for port%d, (Q)SGMII only\n",	423	"invalid phy mode for port%d, (Q)SGMII only\n",
423	port);	424	port);
424	of_node_put(portnp);	425	of_node_put(portnp);
425	return -EINVAL;	426	err = -EINVAL;
		427	goto out_put_ports;
426	}	428	}
427		429
428	serdes = devm_of_phy_get(ocelot->dev, portnp, NULL);	430	serdes = devm_of_phy_get(ocelot->dev, portnp, NULL);
@@ -435,7 +437,8 @@ static int mscc_ocelot_probe(struct platform_device *pdev) · 6 unmodified lines
435	"missing SerDes phys for port%d\n",	437	"missing SerDes phys for port%d\n",
436	port);	438	port);
437		439
438	goto err_probe_ports;	440	of_node_put(portnp);
		441	goto out_put_ports;
439	}	442	}
440		443
441	ocelot->ports[port]->serdes = serdes;	444	ocelot->ports[port]->serdes = serdes;
@@ -447,9 +450,8 @@ static int mscc_ocelot_probe(struct platform_device *pdev) · 5 unmodified lines
447		450
448	dev_info(&pdev->dev, "Ocelot switch probed\n");	451	dev_info(&pdev->dev, "Ocelot switch probed\n");
449		452
450	return 0;	453	out_put_ports:
451		454	of_node_put(ports);
452	err_probe_ports:
453	return err;	455	return err;
454	}	456	}
455		457

drivers/net/ethernet/pensando/Kconfig+1−0

@@ -20,6 +20,7 @@ if NET_VENDOR_PENSANDO · 19 unmodified lines
20	config IONIC	20	config IONIC
21	tristate "Pensando Ethernet IONIC Support"	21	tristate "Pensando Ethernet IONIC Support"
22	depends on 64BIT && PCI	22	depends on 64BIT && PCI
		23	select NET_DEVLINK
23	help	24	help
24	This enables the support for the Pensando family of Ethernet	25	This enables the support for the Pensando family of Ethernet
25	adapters. More specific information on this driver can be	26	adapters. More specific information on this driver can be

drivers/net/ethernet/qlogic/qla3xxx.c+1−0

@@ -2787,6 +2787,7 @@ static int ql_alloc_large_buffers(struct ql3_adapter *qdev) · 2786 unmodified lines
2787	netdev_err(qdev->ndev,	2787	netdev_err(qdev->ndev,
2788	"PCI mapping failed with error: %d\n",	2788	"PCI mapping failed with error: %d\n",
2789	err);	2789	err);
		2790	dev_kfree_skb_irq(skb);
2790	ql_free_large_buffers(qdev);	2791	ql_free_large_buffers(qdev);
2791	return -ENOMEM;	2792	return -ENOMEM;
2792	}	2793	}

drivers/net/ethernet/socionext/netsec.c+7−23

@@ -282,7 +282,6 @@ struct netsec_desc_ring { · 281 unmodified lines
282	void *vaddr;	282	void *vaddr;
283	u16 head, tail;	283	u16 head, tail;
284	u16 xdp_xmit; /* netsec_xdp_xmit packets */	284	u16 xdp_xmit; /* netsec_xdp_xmit packets */
285	bool is_xdp;
286	struct page_pool *page_pool;	285	struct page_pool *page_pool;
287	struct xdp_rxq_info xdp_rxq;	286	struct xdp_rxq_info xdp_rxq;
288	spinlock_t lock; /* XDP tx queue locking */	287	spinlock_t lock; /* XDP tx queue locking */
@@ -634,8 +633,7 @@ static bool netsec_clean_tx_dring(struct netsec_priv *priv) · 345 unmodified lines
634	unsigned int bytes;	633	unsigned int bytes;
635	int cnt = 0;	634	int cnt = 0;
636		635
637	if (dring->is_xdp)	636	spin_lock(&dring->lock);
638	spin_lock(&dring->lock);
639		637
640	bytes = 0;	638	bytes = 0;
641	entry = dring->vaddr + DESC_SZ * tail;	639	entry = dring->vaddr + DESC_SZ * tail;
@@ -682,8 +680,8 @@ next: · 40 unmodified lines
682	entry = dring->vaddr + DESC_SZ * tail;	680	entry = dring->vaddr + DESC_SZ * tail;
683	cnt++;	681	cnt++;
684	}	682	}
685	if (dring->is_xdp)	683
686	spin_unlock(&dring->lock);	684	spin_unlock(&dring->lock);
687		685
688	if (!cnt)	686	if (!cnt)
689	return false;	687	return false;
@@ -799,9 +797,6 @@ static void netsec_set_tx_de(struct netsec_priv *priv, · 109 unmodified lines
799	de->data_buf_addr_lw = lower_32_bits(desc->dma_addr);	797	de->data_buf_addr_lw = lower_32_bits(desc->dma_addr);
800	de->buf_len_info = (tx_ctrl->tcp_seg_len << 16) \| desc->len;	798	de->buf_len_info = (tx_ctrl->tcp_seg_len << 16) \| desc->len;
801	de->attr = attr;	799	de->attr = attr;
802	/* under spin_lock if using XDP */
803	if (!dring->is_xdp)
804	dma_wmb();
805		800
806	dring->desc[idx] = *desc;	801	dring->desc[idx] = *desc;
807	if (desc->buf_type == TYPE_NETSEC_SKB)	802	if (desc->buf_type == TYPE_NETSEC_SKB)
@@ -1123,12 +1118,10 @@ static netdev_tx_t netsec_netdev_start_xmit(struct sk_buff *skb, · 315 unmodified lines
1123	u16 tso_seg_len = 0;	1118	u16 tso_seg_len = 0;
1124	int filled;	1119	int filled;
1125		1120
1126	if (dring->is_xdp)	1121	spin_lock_bh(&dring->lock);
1127	spin_lock_bh(&dring->lock);
1128	filled = netsec_desc_used(dring);	1122	filled = netsec_desc_used(dring);
1129	if (netsec_check_stop_tx(priv, filled)) {	1123	if (netsec_check_stop_tx(priv, filled)) {
1130	if (dring->is_xdp)	1124	spin_unlock_bh(&dring->lock);
1131	spin_unlock_bh(&dring->lock);
1132	net_warn_ratelimited("%s %s Tx queue full\n",	1125	net_warn_ratelimited("%s %s Tx queue full\n",
1133	dev_name(priv->dev), ndev->name);	1126	dev_name(priv->dev), ndev->name);
1134	return NETDEV_TX_BUSY;	1127	return NETDEV_TX_BUSY;
@@ -1161,8 +1154,7 @@ static netdev_tx_t netsec_netdev_start_xmit(struct sk_buff *skb, · 26 unmodified lines
1161	tx_desc.dma_addr = dma_map_single(priv->dev, skb->data,	1154	tx_desc.dma_addr = dma_map_single(priv->dev, skb->data,
1162	skb_headlen(skb), DMA_TO_DEVICE);	1155	skb_headlen(skb), DMA_TO_DEVICE);
1163	if (dma_mapping_error(priv->dev, tx_desc.dma_addr)) {	1156	if (dma_mapping_error(priv->dev, tx_desc.dma_addr)) {
1164	if (dring->is_xdp)	1157	spin_unlock_bh(&dring->lock);
1165	spin_unlock_bh(&dring->lock);
1166	netif_err(priv, drv, priv->ndev,	1158	netif_err(priv, drv, priv->ndev,
1167	"%s: DMA mapping failed\n", __func__);	1159	"%s: DMA mapping failed\n", __func__);
1168	ndev->stats.tx_dropped++;	1160	ndev->stats.tx_dropped++;
@@ -1177,8 +1169,7 @@ static netdev_tx_t netsec_netdev_start_xmit(struct sk_buff *skb, · 8 unmodified lines
1177	netdev_sent_queue(priv->ndev, skb->len);	1169	netdev_sent_queue(priv->ndev, skb->len);
1178		1170
1179	netsec_set_tx_de(priv, dring, &tx_ctrl, &tx_desc, skb);	1171	netsec_set_tx_de(priv, dring, &tx_ctrl, &tx_desc, skb);
1180	if (dring->is_xdp)	1172	spin_unlock_bh(&dring->lock);
1181	spin_unlock_bh(&dring->lock);
1182	netsec_write(priv, NETSEC_REG_NRM_TX_PKTCNT, 1); /* submit another tx */	1173	netsec_write(priv, NETSEC_REG_NRM_TX_PKTCNT, 1); /* submit another tx */
1183		1174
1184	return NETDEV_TX_OK;	1175	return NETDEV_TX_OK;
@@ -1262,7 +1253,6 @@ err: · 77 unmodified lines
1262	static void netsec_setup_tx_dring(struct netsec_priv *priv)	1253	static void netsec_setup_tx_dring(struct netsec_priv *priv)
1263	{	1254	{
1264	struct netsec_desc_ring *dring = &priv->desc_ring[NETSEC_RING_TX];	1255	struct netsec_desc_ring *dring = &priv->desc_ring[NETSEC_RING_TX];
1265	struct bpf_prog *xdp_prog = READ_ONCE(priv->xdp_prog);
1266	int i;	1256	int i;
1267		1257
1268	for (i = 0; i < DESC_NUM; i++) {	1258	for (i = 0; i < DESC_NUM; i++) {
@@ -1275,12 +1265,6 @@ static void netsec_setup_tx_dring(struct netsec_priv *priv) · 6 unmodified lines
1275	*/	1265	*/
1276	de->attr = 1U << NETSEC_TX_SHIFT_OWN_FIELD;	1266	de->attr = 1U << NETSEC_TX_SHIFT_OWN_FIELD;
1277	}	1267	}
1278
1279	if (xdp_prog)
1280	dring->is_xdp = true;
1281	else
1282	dring->is_xdp = false;
1283
1284	}	1268	}
1285		1269
1286	static int netsec_setup_rx_dring(struct netsec_priv *priv)	1270	static int netsec_setup_rx_dring(struct netsec_priv *priv)

drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c+7−6

 	int numhashregs = (hw->multicast_filter_bins >> 5);
 	int mcbitslog2 = hw->mcast_bits_log2;
 	unsigned int value;
+	u32 mc_filter[8];
 	int i;
+	memset(mc_filter, 0, sizeof(mc_filter));
 	value = readl(ioaddr + GMAC_PACKET_FILTER);
 	value &= ~GMAC_PACKET_FILTER_HMC;
 	value &= ~GMAC_PACKET_FILTER_HPF;
 		/* Pass all multi */
 		value |= GMAC_PACKET_FILTER_PM;
 		/* Set all the bits of the HASH tab */
-		for (i = 0; i < numhashregs; i++)
+		memset(mc_filter, 0xff, sizeof(mc_filter));
-			writel(0xffffffff, ioaddr + GMAC_HASH_TAB(i));
 	} else if (!netdev_mc_empty(dev)) {
 		struct netdev_hw_addr *ha;
-		u32 mc_filter[8];
 		/* Hash filter for multicast */
 		value |= GMAC_PACKET_FILTER_HMC;
-		memset(mc_filter, 0, sizeof(mc_filter));
 		netdev_for_each_mc_addr(ha, dev) {
 			/* The upper n bits of the calculated CRC are used to
 			 * index the contents of the hash table. The number of
 			 */
 			mc_filter[bit_nr >> 5] |= (1 << (bit_nr & 0x1f));
 		}
-		for (i = 0; i < numhashregs; i++)
-			writel(mc_filter[i], ioaddr + GMAC_HASH_TAB(i));
 	}
+	for (i = 0; i < numhashregs; i++)
+		writel(mc_filter[i], ioaddr + GMAC_HASH_TAB(i));
 	value |= GMAC_PACKET_FILTER_HPF;
 	/* Handle multiple unicast addresses */

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

 #define XGMAC_TSIE			BIT(12)
 #define XGMAC_LPIIE			BIT(5)
 #define XGMAC_PMTIE			BIT(4)
-#define XGMAC_INT_DEFAULT_EN		(XGMAC_LPIIE | XGMAC_PMTIE | XGMAC_TSIE)
+#define XGMAC_INT_DEFAULT_EN		(XGMAC_LPIIE | XGMAC_PMTIE)
 #define XGMAC_Qx_TX_FLOW_CTRL(x)	(0x00000070 + (x) * 4)
 #define XGMAC_PT			GENMASK(31, 16)
 #define XGMAC_PT_SHIFT			16
 #define XGMAC_HWFEAT_GMIISEL		BIT(1)
 #define XGMAC_HW_FEATURE1		0x00000120
 #define XGMAC_HWFEAT_L3L4FNUM		GENMASK(30, 27)
+#define XGMAC_HWFEAT_HASHTBLSZ		GENMASK(25, 24)
 #define XGMAC_HWFEAT_RSSEN		BIT(20)
 #define XGMAC_HWFEAT_TSOEN		BIT(18)
 #define XGMAC_HWFEAT_SPHEN		BIT(17)

drivers/net/ethernet/stmicro/stmmac/dwxgmac2_core.c+5−4

 	dwxgmac2_set_mchash(ioaddr, mc_filter, mcbitslog2);
 	/* Handle multiple unicast addresses */
-	if (netdev_uc_count(dev) > XGMAC_ADDR_MAX) {
+	if (netdev_uc_count(dev) > hw->unicast_filter_entries) {
 		value |= XGMAC_FILTER_PR;
 	} else {
 		struct netdev_hw_addr *ha;
 				  struct stmmac_rss *cfg, u32 num_rxq)
 {
 	void __iomem *ioaddr = hw->pcsr;
+	u32 value, *key;
 	int i, ret;
-	u32 value;
 	value = readl(ioaddr + XGMAC_RSS_CTRL);
 	if (!cfg || !cfg->enable) {
 		return 0;
 	}
-	for (i = 0; i < (sizeof(cfg->key) / sizeof(u32)); i++) {
+	key = (u32 *)cfg->key;
-		ret = dwxgmac2_rss_write_reg(ioaddr, true, i, cfg->key[i]);
+	for (i = 0; i < (ARRAY_SIZE(cfg->key) / sizeof(u32)); i++) {
+		ret = dwxgmac2_rss_write_reg(ioaddr, true, i, key[i]);
 		if (ret)
 			return ret;
 	}

drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c+1−0

@@ -380,6 +380,7 @@ static void dwxgmac2_get_hw_feature(void __iomem *ioaddr, · 379 unmodified lines
380	/* MAC HW feature 1 */	380	/* MAC HW feature 1 */
381	hw_cap = readl(ioaddr + XGMAC_HW_FEATURE1);	381	hw_cap = readl(ioaddr + XGMAC_HW_FEATURE1);
382	dma_cap->l3l4fnum = (hw_cap & XGMAC_HWFEAT_L3L4FNUM) >> 27;	382	dma_cap->l3l4fnum = (hw_cap & XGMAC_HWFEAT_L3L4FNUM) >> 27;
		383	dma_cap->hash_tb_sz = (hw_cap & XGMAC_HWFEAT_HASHTBLSZ) >> 24;
383	dma_cap->rssen = (hw_cap & XGMAC_HWFEAT_RSSEN) >> 20;	384	dma_cap->rssen = (hw_cap & XGMAC_HWFEAT_RSSEN) >> 20;
384	dma_cap->tsoen = (hw_cap & XGMAC_HWFEAT_TSOEN) >> 18;	385	dma_cap->tsoen = (hw_cap & XGMAC_HWFEAT_TSOEN) >> 18;
385	dma_cap->sphen = (hw_cap & XGMAC_HWFEAT_SPHEN) >> 17;	386	dma_cap->sphen = (hw_cap & XGMAC_HWFEAT_SPHEN) >> 17;

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

 			config.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
 			ptp_v2 = PTP_TCR_TSVER2ENA;
 			snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
+			ts_event_en = PTP_TCR_TSEVNTENA;
 			ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA;
 			ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA;
 			ptp_over_ethernet = PTP_TCR_TSIPENA;
 	if (!ndev || !netif_running(ndev))
 		return 0;
-	mutex_lock(&priv->lock);
+	phylink_mac_change(priv->phylink, false);
-	rtnl_lock();
+	mutex_lock(&priv->lock);
-	phylink_stop(priv->phylink);
-	rtnl_unlock();
 	netif_device_detach(ndev);
 	stmmac_stop_all_queues(priv);
 		stmmac_pmt(priv, priv->hw, priv->wolopts);
 		priv->irq_wake = 1;
 	} else {
+		mutex_unlock(&priv->lock);
+		rtnl_lock();
+		phylink_stop(priv->phylink);
+		rtnl_unlock();
+		mutex_lock(&priv->lock);
 		stmmac_mac_set(priv, priv->ioaddr, false);
 		pinctrl_pm_select_sleep_state(priv->device);
 		/* Disable clock in case of PWM is off */
 	stmmac_start_all_queues(priv);
-	rtnl_lock();
-	phylink_start(priv->phylink);
-	rtnl_unlock();
 	mutex_unlock(&priv->lock);
+	if (!device_may_wakeup(priv->device)) {
+		rtnl_lock();
+		phylink_start(priv->phylink);
+		rtnl_unlock();
+	}
+	phylink_mac_change(priv->phylink, true);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(stmmac_resume);

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c+0−4

 	struct stmmac_packet_attrs attr = { };
 	int size = priv->dma_buf_sz;
-	/* Only XGMAC has SW support for multiple RX descs in same packet */
-	if (priv->plat->has_xgmac)
-		size = priv->dev->max_mtu;
 	attr.dst = priv->dev->dev_addr;
 	attr.max_size = size - ETH_FCS_LEN;
 	attr.queue_mapping = queue;

drivers/net/ieee802154/atusb.c+2−1

@@ -1137,10 +1137,11 @@ static void atusb_disconnect(struct usb_interface *interface) · 1136 unmodified lines
1137		1137
1138	ieee802154_unregister_hw(atusb->hw);	1138	ieee802154_unregister_hw(atusb->hw);
1139		1139
		1140	usb_put_dev(atusb->usb_dev);
		1141
1140	ieee802154_free_hw(atusb->hw);	1142	ieee802154_free_hw(atusb->hw);
1141		1143
1142	usb_set_intfdata(interface, NULL);	1144	usb_set_intfdata(interface, NULL);
1143	usb_put_dev(atusb->usb_dev);
1144		1145
1145	pr_debug("%s done\n", __func__);	1146	pr_debug("%s done\n", __func__);
1146	}	1147	}

drivers/net/ieee802154/ca8210.c+1−1

 		goto error;
 	}
+	priv->spi->dev.platform_data = pdata;
 	ret = ca8210_get_platform_data(priv->spi, pdata);
 	if (ret) {
 		dev_crit(&spi_device->dev, "ca8210_get_platform_data failed\n");
 		goto error;
 	}
-	priv->spi->dev.platform_data = pdata;
 	ret = ca8210_dev_com_init(priv);
 	if (ret) {

drivers/net/ieee802154/mcr20a.c+1−1

@@ -800,7 +800,7 @@ mcr20a_handle_rx_read_buf_complete(void *context) · 799 unmodified lines
800	if (!skb)	800	if (!skb)
801	return;	801	return;
802		802
803	memcpy(skb_put(skb, len), lp->rx_buf, len);	803	__skb_put_data(skb, lp->rx_buf, len);
804	ieee802154_rx_irqsafe(lp->hw, skb, lp->rx_lqi[0]);	804	ieee802154_rx_irqsafe(lp->hw, skb, lp->rx_lqi[0]);
805		805
806	print_hex_dump_debug("mcr20a rx: ", DUMP_PREFIX_OFFSET, 16, 1,	806	print_hex_dump_debug("mcr20a rx: ", DUMP_PREFIX_OFFSET, 16, 1,

drivers/net/phy/at803x.c+69−0

@@ -15,6 +15,15 @@ · 14 unmodified lines
15	#include <linux/of_gpio.h>	15	#include <linux/of_gpio.h>
16	#include <linux/gpio/consumer.h>	16	#include <linux/gpio/consumer.h>
17		17
		18	#define AT803X_SPECIFIC_STATUS 0x11
		19	#define AT803X_SS_SPEED_MASK (3 << 14)
		20	#define AT803X_SS_SPEED_1000 (2 << 14)
		21	#define AT803X_SS_SPEED_100 (1 << 14)
		22	#define AT803X_SS_SPEED_10 (0 << 14)
		23	#define AT803X_SS_DUPLEX BIT(13)
		24	#define AT803X_SS_SPEED_DUPLEX_RESOLVED BIT(11)
		25	#define AT803X_SS_MDIX BIT(6)
		26
18	#define AT803X_INTR_ENABLE 0x12	27	#define AT803X_INTR_ENABLE 0x12
19	#define AT803X_INTR_ENABLE_AUTONEG_ERR BIT(15)	28	#define AT803X_INTR_ENABLE_AUTONEG_ERR BIT(15)
20	#define AT803X_INTR_ENABLE_SPEED_CHANGED BIT(14)	29	#define AT803X_INTR_ENABLE_SPEED_CHANGED BIT(14)
@@ -357,6 +366,64 @@ static int at803x_aneg_done(struct phy_device *phydev) · 336 unmodified lines
357	return aneg_done;	366	return aneg_done;
358	}	367	}
359		368
		369	static int at803x_read_status(struct phy_device *phydev)
		370	{
		371	int ss, err, old_link = phydev->link;
		372
		373	/* Update the link, but return if there was an error */
		374	err = genphy_update_link(phydev);
		375	if (err)
		376	return err;
		377
		378	/* why bother the PHY if nothing can have changed */
		379	if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
		380	return 0;
		381
		382	phydev->speed = SPEED_UNKNOWN;
		383	phydev->duplex = DUPLEX_UNKNOWN;
		384	phydev->pause = 0;
		385	phydev->asym_pause = 0;
		386
		387	err = genphy_read_lpa(phydev);
		388	if (err < 0)
		389	return err;
		390
		391	/* Read the AT8035 PHY-Specific Status register, which indicates the
		392	* speed and duplex that the PHY is actually using, irrespective of
		393	* whether we are in autoneg mode or not.
		394	*/
		395	ss = phy_read(phydev, AT803X_SPECIFIC_STATUS);
		396	if (ss < 0)
		397	return ss;
		398
		399	if (ss & AT803X_SS_SPEED_DUPLEX_RESOLVED) {
		400	switch (ss & AT803X_SS_SPEED_MASK) {
		401	case AT803X_SS_SPEED_10:
		402	phydev->speed = SPEED_10;
		403	break;
		404	case AT803X_SS_SPEED_100:
		405	phydev->speed = SPEED_100;
		406	break;
		407	case AT803X_SS_SPEED_1000:
		408	phydev->speed = SPEED_1000;
		409	break;
		410	}
		411	if (ss & AT803X_SS_DUPLEX)
		412	phydev->duplex = DUPLEX_FULL;
		413	else
		414	phydev->duplex = DUPLEX_HALF;
		415	if (ss & AT803X_SS_MDIX)
		416	phydev->mdix = ETH_TP_MDI_X;
		417	else
		418	phydev->mdix = ETH_TP_MDI;
		419	}
		420
		421	if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete)
		422	phy_resolve_aneg_pause(phydev);
		423
		424	return 0;
		425	}
		426
360	static struct phy_driver at803x_driver[] = {	427	static struct phy_driver at803x_driver[] = {
361	{	428	{
362	/* ATHEROS 8035 */	429	/* ATHEROS 8035 */
@@ -370,6 +437,7 @@ static struct phy_driver at803x_driver[] = { · 7 unmodified lines
370	.suspend = at803x_suspend,	437	.suspend = at803x_suspend,
371	.resume = at803x_resume,	438	.resume = at803x_resume,
372	/* PHY_GBIT_FEATURES */	439	/* PHY_GBIT_FEATURES */
		440	.read_status = at803x_read_status,
373	.ack_interrupt = at803x_ack_interrupt,	441	.ack_interrupt = at803x_ack_interrupt,
374	.config_intr = at803x_config_intr,	442	.config_intr = at803x_config_intr,
375	}, {	443	}, {
@@ -399,6 +467,7 @@ static struct phy_driver at803x_driver[] = { · 23 unmodified lines
399	.suspend = at803x_suspend,	467	.suspend = at803x_suspend,
400	.resume = at803x_resume,	468	.resume = at803x_resume,
401	/* PHY_GBIT_FEATURES */	469	/* PHY_GBIT_FEATURES */
		470	.read_status = at803x_read_status,
402	.aneg_done = at803x_aneg_done,	471	.aneg_done = at803x_aneg_done,
403	.ack_interrupt = &at803x_ack_interrupt,	472	.ack_interrupt = &at803x_ack_interrupt,
404	.config_intr = &at803x_config_intr,	473	.config_intr = &at803x_config_intr,

drivers/net/phy/mdio_device.c+1−1

@@ -121,7 +121,7 @@ void mdio_device_reset(struct mdio_device *mdiodev, int value) · 120 unmodified lines
121	return;	121	return;
122		122
123	if (mdiodev->reset_gpio)	123	if (mdiodev->reset_gpio)
124	gpiod_set_value(mdiodev->reset_gpio, value);	124	gpiod_set_value_cansleep(mdiodev->reset_gpio, value);
125		125
126	if (mdiodev->reset_ctrl) {	126	if (mdiodev->reset_ctrl) {
127	if (value)	127	if (value)

drivers/net/phy/phy-core.c+13−7

 	phydev->eee_broken_modes = broken;
 }
+void phy_resolve_aneg_pause(struct phy_device *phydev)
+{
+	if (phydev->duplex == DUPLEX_FULL) {
+		phydev->pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
+						  phydev->lp_advertising);
+		phydev->asym_pause = linkmode_test_bit(
+			ETHTOOL_LINK_MODE_Asym_Pause_BIT,
+			phydev->lp_advertising);
+	}
+}
+EXPORT_SYMBOL_GPL(phy_resolve_aneg_pause);
 /**
  * phy_resolve_aneg_linkmode - resolve the advertisements into phy settings
  * @phydev: The phy_device struct
 			break;
 		}
-	if (phydev->duplex == DUPLEX_FULL) {
+	phy_resolve_aneg_pause(phydev);
-		phydev->pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
-						  phydev->lp_advertising);
-		phydev->asym_pause = linkmode_test_bit(
-			ETHTOOL_LINK_MODE_Asym_Pause_BIT,
-			phydev->lp_advertising);
-	}
 }
 EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode);

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

 							   val);
 				change_autoneg = true;
 				break;
+			case MII_CTRL1000:
+				mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
+							        val);
+				change_autoneg = true;
+				break;
 			default:
 				/* do nothing */
 				break;

drivers/net/phy/phy_device.c+40−25

 }
 EXPORT_SYMBOL(genphy_update_link);
-/**
+int genphy_read_lpa(struct phy_device *phydev)
- * genphy_read_status - check the link status and update current link state
- * @phydev: target phy_device struct
- *
- * Description: Check the link, then figure out the current state
- *   by comparing what we advertise with what the link partner
- *   advertises.  Start by checking the gigabit possibilities,
- *   then move on to 10/100.
- */
-int genphy_read_status(struct phy_device *phydev)
 {
-	int lpa, lpagb, err, old_link = phydev->link;
+	int lpa, lpagb;
-	/* Update the link, but return if there was an error */
-	err = genphy_update_link(phydev);
-	if (err)
-		return err;
-	/* why bother the PHY if nothing can have changed */
-	if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
-		return 0;
-	phydev->speed = SPEED_UNKNOWN;
-	phydev->duplex = DUPLEX_UNKNOWN;
-	phydev->pause = 0;
-	phydev->asym_pause = 0;
 	if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
 		if (phydev->is_gigabit_capable) {
 			return lpa;
 		mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
+	}
+	return 0;
+}
+EXPORT_SYMBOL(genphy_read_lpa);
+/**
+ * genphy_read_status - check the link status and update current link state
+ * @phydev: target phy_device struct
+ *
+ * Description: Check the link, then figure out the current state
+ *   by comparing what we advertise with what the link partner
+ *   advertises.  Start by checking the gigabit possibilities,
+ *   then move on to 10/100.
+ */
+int genphy_read_status(struct phy_device *phydev)
+{
+	int err, old_link = phydev->link;
+	/* Update the link, but return if there was an error */
+	err = genphy_update_link(phydev);
+	if (err)
+		return err;
+	/* why bother the PHY if nothing can have changed */
+	if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
+		return 0;
+	phydev->speed = SPEED_UNKNOWN;
+	phydev->duplex = DUPLEX_UNKNOWN;
+	phydev->pause = 0;
+	phydev->asym_pause = 0;
+	err = genphy_read_lpa(phydev);
+	if (err < 0)
+		return err;
+	if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
 		phy_resolve_aneg_linkmode(phydev);
 	} else if (phydev->autoneg == AUTONEG_DISABLE) {
 		int bmcr = phy_read(phydev, MII_BMCR);

drivers/net/ppp/pptp.c+2−2

@@ -238,7 +238,7 @@ static int pptp_xmit(struct ppp_channel chan, struct sk_buff skb) · 237 unmodified lines
238	skb_dst_drop(skb);	238	skb_dst_drop(skb);
239	skb_dst_set(skb, &rt->dst);	239	skb_dst_set(skb, &rt->dst);
240		240
241	nf_reset(skb);	241	nf_reset_ct(skb);
242		242
243	skb->ip_summed = CHECKSUM_NONE;	243	skb->ip_summed = CHECKSUM_NONE;
244	ip_select_ident(net, skb, NULL);	244	ip_select_ident(net, skb, NULL);
@@ -358,7 +358,7 @@ static int pptp_rcv(struct sk_buff *skb) · 113 unmodified lines
358	po = lookup_chan(htons(header->call_id), iph->saddr);	358	po = lookup_chan(htons(header->call_id), iph->saddr);
359	if (po) {	359	if (po) {
360	skb_dst_drop(skb);	360	skb_dst_drop(skb);
361	nf_reset(skb);	361	nf_reset_ct(skb);
362	return sk_receive_skb(sk_pppox(po), skb, 0);	362	return sk_receive_skb(sk_pppox(po), skb, 0);
363	}	363	}
364	drop:	364	drop:

drivers/net/tun.c+1−1

@@ -1104,7 +1104,7 @@ static netdev_tx_t tun_net_xmit(struct sk_buff skb, struct net_device dev) · 1103 unmodified lines
1104	*/	1104	*/
1105	skb_orphan(skb);	1105	skb_orphan(skb);
1106		1106
1107	nf_reset(skb);	1107	nf_reset_ct(skb);
1108		1108
1109	if (ptr_ring_produce(&tfile->tx_ring, skb))	1109	if (ptr_ring_produce(&tfile->tx_ring, skb))
1110	goto drop;	1110	goto drop;

drivers/net/usb/hso.c+8−4

 		 */
 		if (serial->tiocmget) {
 			tiocmget = serial->tiocmget;
+			tiocmget->endp = hso_get_ep(interface,
+						    USB_ENDPOINT_XFER_INT,
+						    USB_DIR_IN);
+			if (!tiocmget->endp) {
+				dev_err(&interface->dev, "Failed to find INT IN ep\n");
+				goto exit;
+			}
 			tiocmget->urb = usb_alloc_urb(0, GFP_KERNEL);
 			if (tiocmget->urb) {
 				mutex_init(&tiocmget->mutex);
 				init_waitqueue_head(&tiocmget->waitq);
-				tiocmget->endp = hso_get_ep(
-					interface,
-					USB_ENDPOINT_XFER_INT,
-					USB_DIR_IN);
 			} else
 				hso_free_tiomget(serial);
 		}

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

@@ -1350,6 +1350,7 @@ static const struct usb_device_id products[] = { · 1349 unmodified lines
1350	{QMI_FIXED_INTF(0x1e2d, 0x0082, 4)}, /* Cinterion PHxx,PXxx (2 RmNet) */	1350	{QMI_FIXED_INTF(0x1e2d, 0x0082, 4)}, /* Cinterion PHxx,PXxx (2 RmNet) */
1351	{QMI_FIXED_INTF(0x1e2d, 0x0082, 5)}, /* Cinterion PHxx,PXxx (2 RmNet) */	1351	{QMI_FIXED_INTF(0x1e2d, 0x0082, 5)}, /* Cinterion PHxx,PXxx (2 RmNet) */
1352	{QMI_FIXED_INTF(0x1e2d, 0x0083, 4)}, /* Cinterion PHxx,PXxx (1 RmNet + USB Audio)*/	1352	{QMI_FIXED_INTF(0x1e2d, 0x0083, 4)}, /* Cinterion PHxx,PXxx (1 RmNet + USB Audio)*/
		1353	{QMI_QUIRK_SET_DTR(0x1e2d, 0x00b0, 4)}, /* Cinterion CLS8 */
1353	{QMI_FIXED_INTF(0x413c, 0x81a2, 8)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */	1354	{QMI_FIXED_INTF(0x413c, 0x81a2, 8)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */
1354	{QMI_FIXED_INTF(0x413c, 0x81a3, 8)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */	1355	{QMI_FIXED_INTF(0x413c, 0x81a3, 8)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */
1355	{QMI_FIXED_INTF(0x413c, 0x81a4, 8)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */	1356	{QMI_FIXED_INTF(0x413c, 0x81a4, 8)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */

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

 	struct r8152 *tp = usb_get_intfdata(intf);
 	clear_bit(SELECTIVE_SUSPEND, &tp->flags);
-	mutex_lock(&tp->control);
 	tp->rtl_ops.init(tp);
 	queue_delayed_work(system_long_wq, &tp->hw_phy_work, 0);
-	mutex_unlock(&tp->control);
+	set_ethernet_addr(tp);
 	return rtl8152_resume(intf);
 }

drivers/net/virtio_net.c+1−1

@@ -1585,7 +1585,7 @@ static netdev_tx_t start_xmit(struct sk_buff skb, struct net_device dev) · 1584 unmodified lines
1585	/* Don't wait up for transmitted skbs to be freed. */	1585	/* Don't wait up for transmitted skbs to be freed. */
1586	if (!use_napi) {	1586	if (!use_napi) {
1587	skb_orphan(skb);	1587	skb_orphan(skb);
1588	nf_reset(skb);	1588	nf_reset_ct(skb);
1589	}	1589	}
1590		1590
1591	/* If running out of space, stop queue to avoid getting packets that we	1591	/* If running out of space, stop queue to avoid getting packets that we

drivers/net/vrf.c+4−4

@@ -366,7 +366,7 @@ static int vrf_finish_output6(struct net net, struct sock sk, · 365 unmodified lines
366	struct neighbour *neigh;	366	struct neighbour *neigh;
367	int ret;	367	int ret;
368		368
369	nf_reset(skb);	369	nf_reset_ct(skb);
370		370
371	skb->protocol = htons(ETH_P_IPV6);	371	skb->protocol = htons(ETH_P_IPV6);
372	skb->dev = dev;	372	skb->dev = dev;
@@ -459,7 +459,7 @@ static struct sk_buff vrf_ip6_out_direct(struct net_device vrf_dev, · 86 unmodified lines
459		459
460	/* reset skb device */	460	/* reset skb device */
461	if (likely(err == 1))	461	if (likely(err == 1))
462	nf_reset(skb);	462	nf_reset_ct(skb);
463	else	463	else
464	skb = NULL;	464	skb = NULL;
465		465
@@ -560,7 +560,7 @@ static int vrf_finish_output(struct net net, struct sock sk, struct sk_buff *s · 94 unmodified lines
560	bool is_v6gw = false;	560	bool is_v6gw = false;
561	int ret = -EINVAL;	561	int ret = -EINVAL;
562		562
563	nf_reset(skb);	563	nf_reset_ct(skb);
564		564
565	/* Be paranoid, rather than too clever. */	565	/* Be paranoid, rather than too clever. */
566	if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {	566	if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
@@ -670,7 +670,7 @@ static struct sk_buff vrf_ip_out_direct(struct net_device vrf_dev, · 103 unmodified lines
670		670
671	/* reset skb device */	671	/* reset skb device */
672	if (likely(err == 1))	672	if (likely(err == 1))
673	nf_reset(skb);	673	nf_reset_ct(skb);
674	else	674	else
675	skb = NULL;	675	skb = NULL;
676		676

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

@@ -1261,8 +1261,8 @@ static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw, · 1260 unmodified lines
1261	skb_orphan(skb);	1261	skb_orphan(skb);
1262	skb_dst_drop(skb);	1262	skb_dst_drop(skb);
1263	skb->mark = 0;	1263	skb->mark = 0;
1264	secpath_reset(skb);	1264	skb_ext_reset(skb);
1265	nf_reset(skb);	1265	nf_reset_ct(skb);
1266		1266
1267	/*	1267	/*
1268	* Get absolute mactime here so all HWs RX at the "same time", and	1268	* Get absolute mactime here so all HWs RX at the "same time", and

drivers/net/xen-netfront.c+9−8

 	return 0;
 }
-static RING_IDX xennet_fill_frags(struct netfront_queue *queue,
+static int xennet_fill_frags(struct netfront_queue *queue,
-				  struct sk_buff *skb,
+			     struct sk_buff *skb,
-				  struct sk_buff_head *list)
+			     struct sk_buff_head *list)
 {
 	RING_IDX cons = queue->rx.rsp_cons;
 	struct sk_buff *nskb;
 		if (unlikely(skb_shinfo(skb)->nr_frags >= MAX_SKB_FRAGS)) {
 			queue->rx.rsp_cons = ++cons + skb_queue_len(list);
 			kfree_skb(nskb);
-			return ~0U;
+			return -ENOENT;
 		}
 		skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,
 		kfree_skb(nskb);
 	}
-	return cons;
+	queue->rx.rsp_cons = cons;
+	return 0;
 }
 static int checksum_setup(struct net_device *dev, struct sk_buff *skb)
 		skb->data_len = rx->status;
 		skb->len += rx->status;
-		i = xennet_fill_frags(queue, skb, &tmpq);
+		if (unlikely(xennet_fill_frags(queue, skb, &tmpq)))
-		if (unlikely(i == ~0U))
 			goto err;
 		if (rx->flags & XEN_NETRXF_csum_blank)
 		__skb_queue_tail(&rxq, skb);
-		queue->rx.rsp_cons = ++i;
+		i = ++queue->rx.rsp_cons;
 		work_done++;
 	}

drivers/nvme/host/core.c+113−19

@@ -102,10 +102,13 @@ static void nvme_set_queue_dying(struct nvme_ns *ns) · 101 unmodified lines
102	*/	102	*/
103	if (!ns->disk \|\| test_and_set_bit(NVME_NS_DEAD, &ns->flags))	103	if (!ns->disk \|\| test_and_set_bit(NVME_NS_DEAD, &ns->flags))
104	return;	104	return;
105	revalidate_disk(ns->disk);
106	blk_set_queue_dying(ns->queue);	105	blk_set_queue_dying(ns->queue);
107	/* Forcibly unquiesce queues to avoid blocking dispatch */	106	/* Forcibly unquiesce queues to avoid blocking dispatch */
108	blk_mq_unquiesce_queue(ns->queue);	107	blk_mq_unquiesce_queue(ns->queue);
		108	/*
		109	* Revalidate after unblocking dispatchers that may be holding bd_butex
		110	*/
		111	revalidate_disk(ns->disk);
109	}	112	}
110		113
111	static void nvme_queue_scan(struct nvme_ctrl *ctrl)	114	static void nvme_queue_scan(struct nvme_ctrl *ctrl)
@@ -847,7 +850,7 @@ out: · 735 unmodified lines
847	static int nvme_submit_user_cmd(struct request_queue *q,	850	static int nvme_submit_user_cmd(struct request_queue *q,
848	struct nvme_command cmd, void __user ubuffer,	851	struct nvme_command cmd, void __user ubuffer,
849	unsigned bufflen, void __user *meta_buffer, unsigned meta_len,	852	unsigned bufflen, void __user *meta_buffer, unsigned meta_len,
850	u32 meta_seed, u32 *result, unsigned timeout)	853	u32 meta_seed, u64 *result, unsigned timeout)
851	{	854	{
852	bool write = nvme_is_write(cmd);	855	bool write = nvme_is_write(cmd);
853	struct nvme_ns *ns = q->queuedata;	856	struct nvme_ns *ns = q->queuedata;
@@ -888,7 +891,7 @@ static int nvme_submit_user_cmd(struct request_queue *q, · 34 unmodified lines
888	else	891	else
889	ret = nvme_req(req)->status;	892	ret = nvme_req(req)->status;
890	if (result)	893	if (result)
891	*result = le32_to_cpu(nvme_req(req)->result.u32);	894	*result = le64_to_cpu(nvme_req(req)->result.u64);
892	if (meta && !ret && !write) {	895	if (meta && !ret && !write) {
893	if (copy_to_user(meta_buffer, meta, meta_len))	896	if (copy_to_user(meta_buffer, meta, meta_len))
894	ret = -EFAULT;	897	ret = -EFAULT;
@@ -1335,6 +1338,54 @@ static int nvme_user_cmd(struct nvme_ctrl ctrl, struct nvme_ns ns, · 440 unmodified lines
1335	struct nvme_command c;	1338	struct nvme_command c;
1336	unsigned timeout = 0;	1339	unsigned timeout = 0;
1337	u32 effects;	1340	u32 effects;
		1341	u64 result;
		1342	int status;
		1343
		1344	if (!capable(CAP_SYS_ADMIN))
		1345	return -EACCES;
		1346	if (copy_from_user(&cmd, ucmd, sizeof(cmd)))
		1347	return -EFAULT;
		1348	if (cmd.flags)
		1349	return -EINVAL;
		1350
		1351	memset(&c, 0, sizeof(c));
		1352	c.common.opcode = cmd.opcode;
		1353	c.common.flags = cmd.flags;
		1354	c.common.nsid = cpu_to_le32(cmd.nsid);
		1355	c.common.cdw2[0] = cpu_to_le32(cmd.cdw2);
		1356	c.common.cdw2[1] = cpu_to_le32(cmd.cdw3);
		1357	c.common.cdw10 = cpu_to_le32(cmd.cdw10);
		1358	c.common.cdw11 = cpu_to_le32(cmd.cdw11);
		1359	c.common.cdw12 = cpu_to_le32(cmd.cdw12);
		1360	c.common.cdw13 = cpu_to_le32(cmd.cdw13);
		1361	c.common.cdw14 = cpu_to_le32(cmd.cdw14);
		1362	c.common.cdw15 = cpu_to_le32(cmd.cdw15);
		1363
		1364	if (cmd.timeout_ms)
		1365	timeout = msecs_to_jiffies(cmd.timeout_ms);
		1366
		1367	effects = nvme_passthru_start(ctrl, ns, cmd.opcode);
		1368	status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,
		1369	(void __user *)(uintptr_t)cmd.addr, cmd.data_len,
		1370	(void __user *)(uintptr_t)cmd.metadata,
		1371	cmd.metadata_len, 0, &result, timeout);
		1372	nvme_passthru_end(ctrl, effects);
		1373
		1374	if (status >= 0) {
		1375	if (put_user(result, &ucmd->result))
		1376	return -EFAULT;
		1377	}
		1378
		1379	return status;
		1380	}
		1381
		1382	static int nvme_user_cmd64(struct nvme_ctrl ctrl, struct nvme_ns ns,
		1383	struct nvme_passthru_cmd64 __user *ucmd)
		1384	{
		1385	struct nvme_passthru_cmd64 cmd;
		1386	struct nvme_command c;
		1387	unsigned timeout = 0;
		1388	u32 effects;
1338	int status;	1389	int status;
1339		1390
1340	if (!capable(CAP_SYS_ADMIN))	1391	if (!capable(CAP_SYS_ADMIN))
@@ -1405,6 +1456,41 @@ static void nvme_put_ns_from_disk(struct nvme_ns_head *head, int idx) · 64 unmodified lines
1405	srcu_read_unlock(&head->srcu, idx);	1456	srcu_read_unlock(&head->srcu, idx);
1406	}	1457	}
1407		1458
		1459	static bool is_ctrl_ioctl(unsigned int cmd)
		1460	{
		1461	if (cmd == NVME_IOCTL_ADMIN_CMD \|\| cmd == NVME_IOCTL_ADMIN64_CMD)
		1462	return true;
		1463	if (is_sed_ioctl(cmd))
		1464	return true;
		1465	return false;
		1466	}
		1467
		1468	static int nvme_handle_ctrl_ioctl(struct nvme_ns *ns, unsigned int cmd,
		1469	void __user *argp,
		1470	struct nvme_ns_head *head,
		1471	int srcu_idx)
		1472	{
		1473	struct nvme_ctrl *ctrl = ns->ctrl;
		1474	int ret;
		1475
		1476	nvme_get_ctrl(ns->ctrl);
		1477	nvme_put_ns_from_disk(head, srcu_idx);
		1478
		1479	switch (cmd) {
		1480	case NVME_IOCTL_ADMIN_CMD:
		1481	ret = nvme_user_cmd(ctrl, NULL, argp);
		1482	break;
		1483	case NVME_IOCTL_ADMIN64_CMD:
		1484	ret = nvme_user_cmd64(ctrl, NULL, argp);
		1485	break;
		1486	default:
		1487	ret = sed_ioctl(ctrl->opal_dev, cmd, argp);
		1488	break;
		1489	}
		1490	nvme_put_ctrl(ctrl);
		1491	return ret;
		1492	}
		1493
1408	static int nvme_ioctl(struct block_device *bdev, fmode_t mode,	1494	static int nvme_ioctl(struct block_device *bdev, fmode_t mode,
1409	unsigned int cmd, unsigned long arg)	1495	unsigned int cmd, unsigned long arg)
1410	{	1496	{
@@ -1422,20 +1508,8 @@ static int nvme_ioctl(struct block_device *bdev, fmode_t mode, · 11 unmodified lines
1422	* seperately and drop the ns SRCU reference early. This avoids a	1508	* seperately and drop the ns SRCU reference early. This avoids a
1423	* deadlock when deleting namespaces using the passthrough interface.	1509	* deadlock when deleting namespaces using the passthrough interface.
1424	*/	1510	*/
1425	if (cmd == NVME_IOCTL_ADMIN_CMD \|\| is_sed_ioctl(cmd)) {	1511	if (is_ctrl_ioctl(cmd))
1426	struct nvme_ctrl *ctrl = ns->ctrl;	1512	return nvme_handle_ctrl_ioctl(ns, cmd, argp, head, srcu_idx);
1427
1428	nvme_get_ctrl(ns->ctrl);
1429	nvme_put_ns_from_disk(head, srcu_idx);
1430
1431	if (cmd == NVME_IOCTL_ADMIN_CMD)
1432	ret = nvme_user_cmd(ctrl, NULL, argp);
1433	else
1434	ret = sed_ioctl(ctrl->opal_dev, cmd, argp);
1435
1436	nvme_put_ctrl(ctrl);
1437	return ret;
1438	}
1439		1513
1440	switch (cmd) {	1514	switch (cmd) {
1441	case NVME_IOCTL_ID:	1515	case NVME_IOCTL_ID:
@@ -1448,6 +1522,9 @@ static int nvme_ioctl(struct block_device *bdev, fmode_t mode, · 6 unmodified lines
1448	case NVME_IOCTL_SUBMIT_IO:	1522	case NVME_IOCTL_SUBMIT_IO:
1449	ret = nvme_submit_io(ns, argp);	1523	ret = nvme_submit_io(ns, argp);
1450	break;	1524	break;
		1525	case NVME_IOCTL_IO64_CMD:
		1526	ret = nvme_user_cmd64(ns->ctrl, ns, argp);
		1527	break;
1451	default:	1528	default:
1452	if (ns->ndev)	1529	if (ns->ndev)
1453	ret = nvme_nvm_ioctl(ns, cmd, arg);	1530	ret = nvme_nvm_ioctl(ns, cmd, arg);
@@ -2289,6 +2366,16 @@ static const struct nvme_core_quirk_entry core_quirks[] = { · 835 unmodified lines
2289	.vid = 0x14a4,	2366	.vid = 0x14a4,
2290	.fr = "22301111",	2367	.fr = "22301111",
2291	.quirks = NVME_QUIRK_SIMPLE_SUSPEND,	2368	.quirks = NVME_QUIRK_SIMPLE_SUSPEND,
		2369	},
		2370	{
		2371	/*
		2372	* This Kingston E8FK11.T firmware version has no interrupt
		2373	* after resume with actions related to suspend to idle
		2374	* https://bugzilla.kernel.org/show_bug.cgi?id=204887
		2375	*/
		2376	.vid = 0x2646,
		2377	.fr = "E8FK11.T",
		2378	.quirks = NVME_QUIRK_SIMPLE_SUSPEND,
2292	}	2379	}
2293	};	2380	};
2294		2381
@@ -2540,8 +2627,9 @@ static int nvme_init_subsystem(struct nvme_ctrl ctrl, struct nvme_id_ctrl id) · 245 unmodified lines
2540	list_add_tail(&subsys->entry, &nvme_subsystems);	2627	list_add_tail(&subsys->entry, &nvme_subsystems);
2541	}	2628	}
2542		2629
2543	if (sysfs_create_link(&subsys->dev.kobj, &ctrl->device->kobj,	2630	ret = sysfs_create_link(&subsys->dev.kobj, &ctrl->device->kobj,
2544	dev_name(ctrl->device))) {	2631	dev_name(ctrl->device));
		2632	if (ret) {
2545	dev_err(ctrl->device,	2633	dev_err(ctrl->device,
2546	"failed to create sysfs link from subsystem.\n");	2634	"failed to create sysfs link from subsystem.\n");
2547	goto out_put_subsystem;	2635	goto out_put_subsystem;
@@ -2838,6 +2926,8 @@ static long nvme_dev_ioctl(struct file *file, unsigned int cmd, · 290 unmodified lines
2838	switch (cmd) {	2926	switch (cmd) {
2839	case NVME_IOCTL_ADMIN_CMD:	2927	case NVME_IOCTL_ADMIN_CMD:
2840	return nvme_user_cmd(ctrl, NULL, argp);	2928	return nvme_user_cmd(ctrl, NULL, argp);
		2929	case NVME_IOCTL_ADMIN64_CMD:
		2930	return nvme_user_cmd64(ctrl, NULL, argp);
2841	case NVME_IOCTL_IO_CMD:	2931	case NVME_IOCTL_IO_CMD:
2842	return nvme_dev_user_cmd(ctrl, argp);	2932	return nvme_dev_user_cmd(ctrl, argp);
2843	case NVME_IOCTL_RESET:	2933	case NVME_IOCTL_RESET:
@@ -3045,6 +3135,8 @@ static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL); · 201 unmodified lines
3045		3135
3046	nvme_show_int_function(cntlid);	3136	nvme_show_int_function(cntlid);
3047	nvme_show_int_function(numa_node);	3137	nvme_show_int_function(numa_node);
		3138	nvme_show_int_function(queue_count);
		3139	nvme_show_int_function(sqsize);
3048		3140
3049	static ssize_t nvme_sysfs_delete(struct device *dev,	3141	static ssize_t nvme_sysfs_delete(struct device *dev,
3050	struct device_attribute attr, const char buf,	3142	struct device_attribute attr, const char buf,
@@ -3125,6 +3217,8 @@ static struct attribute *nvme_dev_attrs[] = { · 74 unmodified lines
3125	&dev_attr_address.attr,	3217	&dev_attr_address.attr,
3126	&dev_attr_state.attr,	3218	&dev_attr_state.attr,
3127	&dev_attr_numa_node.attr,	3219	&dev_attr_numa_node.attr,
		3220	&dev_attr_queue_count.attr,
		3221	&dev_attr_sqsize.attr,
3128	NULL	3222	NULL
3129	};	3223	};
3130		3224

drivers/nvme/host/nvme.h+1−1

 	u16 oacs;
 	u16 nssa;
 	u16 nr_streams;
+	u16 sqsize;
 	u32 max_namespaces;
 	atomic_t abort_limit;
 	u8 vwc;
 	u16 hmmaxd;
 	/* Fabrics only */
-	u16 sqsize;
 	u32 ioccsz;
 	u32 iorcsz;
 	u16 icdoff;

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

 	if (ret < 0)
 		goto unfreeze;
+	/*
+	 * A saved state prevents pci pm from generically controlling the
+	 * device's power. If we're using protocol specific settings, we don't
+	 * want pci interfering.
+	 */
+	pci_save_state(pdev);
 	ret = nvme_set_power_state(ctrl, ctrl->npss);
 	if (ret < 0)
 		goto unfreeze;
 	if (ret) {
+		/* discard the saved state */
+		pci_load_saved_state(pdev, NULL);
 		/*
 		 * Clearing npss forces a controller reset on resume. The
 		 * correct value will be resdicovered then.
 		nvme_dev_disable(ndev, true);
 		ctrl->npss = 0;
 		ret = 0;
-		goto unfreeze;
 	}
-	/*
-	 * A saved state prevents pci pm from generically controlling the
-	 * device's power. If we're using protocol specific settings, we don't
-	 * want pci interfering.
-	 */
-	pci_save_state(pdev);
 unfreeze:
 	nvme_unfreeze(ctrl);
 	return ret;
 		.driver_data = NVME_QUIRK_LIGHTNVM, },
 	{ PCI_DEVICE(0x10ec, 0x5762),   /* ADATA SX6000LNP */
 		.driver_data = NVME_QUIRK_IGNORE_DEV_SUBNQN, },
+	{ PCI_DEVICE(0x1cc1, 0x8201),   /* ADATA SX8200PNP 512GB */
+		.driver_data = NVME_QUIRK_NO_DEEPEST_PS |
+				NVME_QUIRK_IGNORE_DEV_SUBNQN, },
 	{ PCI_DEVICE_CLASS(PCI_CLASS_STORAGE_EXPRESS, 0xffffff) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_APPLE, 0x2001) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_APPLE, 0x2003) },

drivers/nvme/host/rdma.c+13−6

 static int nvme_rdma_get_max_fr_pages(struct ib_device *ibdev)
 {
 	return min_t(u32, NVME_RDMA_MAX_SEGMENTS,
-		     ibdev->attrs.max_fast_reg_page_list_len);
+		     ibdev->attrs.max_fast_reg_page_list_len - 1);
 }
 static int nvme_rdma_create_queue_ib(struct nvme_rdma_queue *queue)
 	const int cq_factor = send_wr_factor + 1;	/* + RECV */
 	int comp_vector, idx = nvme_rdma_queue_idx(queue);
 	enum ib_poll_context poll_ctx;
-	int ret;
+	int ret, pages_per_mr;
 	queue->device = nvme_rdma_find_get_device(queue->cm_id);
 	if (!queue->device) {
 		goto out_destroy_qp;
 	}
+	/*
+	 * Currently we don't use SG_GAPS MR's so if the first entry is
+	 * misaligned we'll end up using two entries for a single data page,
+	 * so one additional entry is required.
+	 */
+	pages_per_mr = nvme_rdma_get_max_fr_pages(ibdev) + 1;
 	ret = ib_mr_pool_init(queue->qp, &queue->qp->rdma_mrs,
 			      queue->queue_size,
 			      IB_MR_TYPE_MEM_REG,
-			      nvme_rdma_get_max_fr_pages(ibdev), 0);
+			      pages_per_mr, 0);
 	if (ret) {
 		dev_err(queue->ctrl->ctrl.device,
 			"failed to initialize MR pool sized %d for QID %d\n",
 	if (!ret) {
 		set_bit(NVME_RDMA_Q_LIVE, &queue->flags);
 	} else {
-		__nvme_rdma_stop_queue(queue);
+		if (test_bit(NVME_RDMA_Q_ALLOCATED, &queue->flags))
+			__nvme_rdma_stop_queue(queue);
 		dev_info(ctrl->ctrl.device,
 			"failed to connect queue: %d ret=%d\n", idx, ret);
 	}
 	if (error)
 		goto out_stop_queue;
-	ctrl->ctrl.max_hw_sectors =
+	ctrl->ctrl.max_segments = ctrl->max_fr_pages;
-		(ctrl->max_fr_pages - 1) << (ilog2(SZ_4K) - 9);
+	ctrl->ctrl.max_hw_sectors = ctrl->max_fr_pages << (ilog2(SZ_4K) - 9);
 	blk_mq_unquiesce_queue(ctrl->ctrl.admin_q);

drivers/nvme/host/tcp.c+2−2

@@ -1042,7 +1042,7 @@ static void nvme_tcp_io_work(struct work_struct *w) · 1041 unmodified lines
1042	{	1042	{
1043	struct nvme_tcp_queue *queue =	1043	struct nvme_tcp_queue *queue =
1044	container_of(w, struct nvme_tcp_queue, io_work);	1044	container_of(w, struct nvme_tcp_queue, io_work);
1045	unsigned long start = jiffies + msecs_to_jiffies(1);	1045	unsigned long deadline = jiffies + msecs_to_jiffies(1);
1046		1046
1047	do {	1047	do {
1048	bool pending = false;	1048	bool pending = false;
@@ -1067,7 +1067,7 @@ static void nvme_tcp_io_work(struct work_struct *w) · 18 unmodified lines
1067	if (!pending)	1067	if (!pending)
1068	return;	1068	return;
1069		1069
1070	} while (time_after(jiffies, start)); /* quota is exhausted */	1070	} while (!time_after(jiffies, deadline)); /* quota is exhausted */
1071		1071
1072	queue_work_on(queue->io_cpu, nvme_tcp_wq, &queue->io_work);	1072	queue_work_on(queue->io_cpu, nvme_tcp_wq, &queue->io_work);
1073	}	1073	}

drivers/nvme/target/io-cmd-bdev.c+8−8

@@ -11,10 +11,10 @@ · 10 unmodified lines
11	void nvmet_bdev_set_limits(struct block_device bdev, struct nvme_id_ns id)	11	void nvmet_bdev_set_limits(struct block_device bdev, struct nvme_id_ns id)
12	{	12	{
13	const struct queue_limits *ql = &bdev_get_queue(bdev)->limits;	13	const struct queue_limits *ql = &bdev_get_queue(bdev)->limits;
14	/* Number of physical blocks per logical block. */	14	/* Number of logical blocks per physical block. */
15	const u32 ppl = ql->physical_block_size / ql->logical_block_size;	15	const u32 lpp = ql->physical_block_size / ql->logical_block_size;
16	/* Physical blocks per logical block, 0's based. */	16	/* Logical blocks per physical block, 0's based. */
17	const __le16 ppl0b = to0based(ppl);	17	const __le16 lpp0b = to0based(lpp);
18		18
19	/*	19	/*
20	* For NVMe 1.2 and later, bit 1 indicates that the fields NAWUN,	20	* For NVMe 1.2 and later, bit 1 indicates that the fields NAWUN,
@@ -25,9 +25,9 @@ void nvmet_bdev_set_limits(struct block_device bdev, struct nvme_id_ns id) · 4 unmodified lines
25	* field from the identify controller data structure should be used.	25	* field from the identify controller data structure should be used.
26	*/	26	*/
27	id->nsfeat \|= 1 << 1;	27	id->nsfeat \|= 1 << 1;
28	id->nawun = ppl0b;	28	id->nawun = lpp0b;
29	id->nawupf = ppl0b;	29	id->nawupf = lpp0b;
30	id->nacwu = ppl0b;	30	id->nacwu = lpp0b;
31		31
32	/*	32	/*
33	* Bit 4 indicates that the fields NPWG, NPWA, NPDG, NPDA, and	33	* Bit 4 indicates that the fields NPWG, NPWA, NPDG, NPDA, and
@@ -36,7 +36,7 @@ void nvmet_bdev_set_limits(struct block_device bdev, struct nvme_id_ns id) · 2 unmodified lines
36	*/	36	*/
37	id->nsfeat \|= 1 << 4;	37	id->nsfeat \|= 1 << 4;
38	/* NPWG = Namespace Preferred Write Granularity. 0's based */	38	/* NPWG = Namespace Preferred Write Granularity. 0's based */
39	id->npwg = ppl0b;	39	id->npwg = lpp0b;
40	/* NPWA = Namespace Preferred Write Alignment. 0's based */	40	/* NPWA = Namespace Preferred Write Alignment. 0's based */
41	id->npwa = id->npwg;	41	id->npwa = id->npwg;
42	/* NPDG = Namespace Preferred Deallocate Granularity. 0's based */	42	/* NPDG = Namespace Preferred Deallocate Granularity. 0's based */

drivers/nvme/target/tcp.c+4−8

 	return 0;
 err:
-	if (cmd->req.sg_cnt)
+	sgl_free(cmd->req.sg);
-		sgl_free(cmd->req.sg);
 	return NVME_SC_INTERNAL;
 }
 	if (queue->nvme_sq.sqhd_disabled) {
 		kfree(cmd->iov);
-		if (cmd->req.sg_cnt)
+		sgl_free(cmd->req.sg);
-			sgl_free(cmd->req.sg);
 	}
 	return 1;
 		return -EAGAIN;
 	kfree(cmd->iov);
-	if (cmd->req.sg_cnt)
+	sgl_free(cmd->req.sg);
-		sgl_free(cmd->req.sg);
 	cmd->queue->snd_cmd = NULL;
 	nvmet_tcp_put_cmd(cmd);
 	return 1;
 	nvmet_req_uninit(&cmd->req);
 	nvmet_tcp_unmap_pdu_iovec(cmd);
 	kfree(cmd->iov);
-	if (cmd->req.sg_cnt)
+	sgl_free(cmd->req.sg);
-		sgl_free(cmd->req.sg);
 }
 static void nvmet_tcp_uninit_data_in_cmds(struct nvmet_tcp_queue *queue)

drivers/ptp/ptp_qoriq.c+2−1

 		ptp_qoriq->regs.etts_regs = base + ETTS_REGS_OFFSET;
 	}
+	spin_lock_init(&ptp_qoriq->lock);
 	ktime_get_real_ts64(&now);
 	ptp_qoriq_settime(&ptp_qoriq->caps, &now);
 	  (ptp_qoriq->tclk_period & TCLK_PERIOD_MASK) << TCLK_PERIOD_SHIFT |
 	  (ptp_qoriq->cksel & CKSEL_MASK) << CKSEL_SHIFT;
-	spin_lock_init(&ptp_qoriq->lock);
 	spin_lock_irqsave(&ptp_qoriq->lock, flags);
 	regs = &ptp_qoriq->regs;

drivers/s390/block/dasd_eckd.c+11−70

 	if (rc == 0) {
 		memcpy(&private->vsq, vsq, sizeof(*vsq));
 	} else {
-		dev_warn(&device->cdev->dev,
+		DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
-			 "Reading the volume storage information failed with rc=%d\n", rc);
+				"Reading the volume storage information failed with rc=%d", rc);
 	}
 	if (useglobal)
 	if (rc == 0) {
 		dasd_eckd_cpy_ext_pool_data(device, lcq);
 	} else {
-		dev_warn(&device->cdev->dev,
+		DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
-			 "Reading the logical configuration failed with rc=%d\n", rc);
+				"Reading the logical configuration failed with rc=%d", rc);
 	}
 	dasd_sfree_request(cqr, cqr->memdev);
 	dasd_eckd_read_features(device);
 	/* Read Volume Information */
-	rc = dasd_eckd_read_vol_info(device);
+	dasd_eckd_read_vol_info(device);
-	if (rc)
-		goto out_err3;
 	/* Read Extent Pool Information */
-	rc = dasd_eckd_read_ext_pool_info(device);
+	dasd_eckd_read_ext_pool_info(device);
-	if (rc)
-		goto out_err3;
 	/* Read Device Characteristics */
 	rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
 	if (readonly)
 		set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
-	if (dasd_eckd_is_ese(device))
-		dasd_set_feature(device->cdev, DASD_FEATURE_DISCARD, 1);
 	dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) "
 		 "with %d cylinders, %d heads, %d sectors%s\n",
 		 private->rdc_data.dev_type,
 		return -EINVAL;
 }
-static struct dasd_ccw_req *
-dasd_eckd_build_cp_discard(struct dasd_device *device, struct dasd_block *block,
-			   struct request *req, sector_t first_trk,
-			   sector_t last_trk)
-{
-	return dasd_eckd_dso_ras(device, block, req, first_trk, last_trk, 1);
-}
 static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single(
 					       struct dasd_device *startdev,
 					       struct dasd_block *block,
 	cmdwtd = private->features.feature[12] & 0x40;
 	use_prefix = private->features.feature[8] & 0x01;
-	if (req_op(req) == REQ_OP_DISCARD)
-		return dasd_eckd_build_cp_discard(startdev, block, req,
-						  first_trk, last_trk);
 	cqr = NULL;
 	if (cdlspecial || dasd_page_cache) {
 		/* do nothing, just fall through to the cmd mode single case */
 						     struct dasd_block *block,
 						     struct request *req)
 {
-	struct dasd_device *startdev = NULL;
 	struct dasd_eckd_private *private;
-	struct dasd_ccw_req *cqr;
+	struct dasd_device *startdev;
 	unsigned long flags;
+	struct dasd_ccw_req *cqr;
-	/* Discard requests can only be processed on base devices */
+	startdev = dasd_alias_get_start_dev(base);
-	if (req_op(req) != REQ_OP_DISCARD)
-		startdev = dasd_alias_get_start_dev(base);
 	if (!startdev)
 		startdev = base;
 	private = startdev->private;
 	dasd_eckd_read_features(device);
 	/* Read Volume Information */
-	rc = dasd_eckd_read_vol_info(device);
+	dasd_eckd_read_vol_info(device);
-	if (rc)
-		goto out_err2;
 	/* Read Extent Pool Information */
-	rc = dasd_eckd_read_ext_pool_info(device);
+	dasd_eckd_read_ext_pool_info(device);
-	if (rc)
-		goto out_err2;
 	/* Read Device Characteristics */
 	rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
 	unsigned int logical_block_size = block->bp_block;
 	struct request_queue *q = block->request_queue;
 	struct dasd_device *device = block->base;
-	struct dasd_eckd_private *private;
-	unsigned int max_discard_sectors;
-	unsigned int max_bytes;
-	unsigned int ext_bytes; /* Extent Size in Bytes */
-	int recs_per_trk;
-	int trks_per_cyl;
-	int ext_limit;
-	int ext_size; /* Extent Size in Cylinders */
 	int max;
-	private = device->private;
-	trks_per_cyl = private->rdc_data.trk_per_cyl;
-	recs_per_trk = recs_per_track(&private->rdc_data, 0, logical_block_size);
 	if (device->features & DASD_FEATURE_USERAW) {
 		/*
 		 * the max_blocks value for raw_track access is 256
 	/* With page sized segments each segment can be translated into one idaw/tidaw */
 	blk_queue_max_segment_size(q, PAGE_SIZE);
 	blk_queue_segment_boundary(q, PAGE_SIZE - 1);
-	if (dasd_eckd_is_ese(device)) {
-		/*
-		 * Depending on the extent size, up to UINT_MAX bytes can be
-		 * accepted. However, neither DASD_ECKD_RAS_EXTS_MAX nor the
-		 * device limits should be exceeded.
-		 */
-		ext_size = dasd_eckd_ext_size(device);
-		ext_limit = min(private->real_cyl / ext_size, DASD_ECKD_RAS_EXTS_MAX);
-		ext_bytes = ext_size * trks_per_cyl * recs_per_trk *
-			logical_block_size;
-		max_bytes = UINT_MAX - (UINT_MAX % ext_bytes);
-		if (max_bytes / ext_bytes > ext_limit)
-			max_bytes = ext_bytes * ext_limit;
-		max_discard_sectors = max_bytes / 512;
-		blk_queue_max_discard_sectors(q, max_discard_sectors);
-		blk_queue_flag_set(QUEUE_FLAG_DISCARD, q);
-		q->limits.discard_granularity = ext_bytes;
-		q->limits.discard_alignment = ext_bytes;
-	}
 }
 static struct ccw_driver dasd_eckd_driver = {

drivers/s390/cio/qdio_setup.c+1−1

@@ -113,7 +113,7 @@ static void set_impl_params(struct qdio_irq *irq_ptr, · 112 unmodified lines
113	irq_ptr->qib.pfmt = qib_param_field_format;	113	irq_ptr->qib.pfmt = qib_param_field_format;
114	if (qib_param_field)	114	if (qib_param_field)
115	memcpy(irq_ptr->qib.parm, qib_param_field,	115	memcpy(irq_ptr->qib.parm, qib_param_field,
116	QDIO_MAX_BUFFERS_PER_Q);	116	sizeof(irq_ptr->qib.parm));
117		117
118	if (!input_slib_elements)	118	if (!input_slib_elements)
119	goto output;	119	goto output;

drivers/s390/net/qeth_core_main.c+1−2

@@ -4715,8 +4715,7 @@ static int qeth_qdio_establish(struct qeth_card *card) · 4714 unmodified lines
4715		4715
4716	QETH_CARD_TEXT(card, 2, "qdioest");	4716	QETH_CARD_TEXT(card, 2, "qdioest");
4717		4717
4718	qib_param_field = kzalloc(QDIO_MAX_BUFFERS_PER_Q,	4718	qib_param_field = kzalloc(FIELD_SIZEOF(struct qib, parm), GFP_KERNEL);
4719	GFP_KERNEL);
4720	if (!qib_param_field) {	4719	if (!qib_param_field) {
4721	rc = -ENOMEM;	4720	rc = -ENOMEM;
4722	goto out_free_nothing;	4721	goto out_free_nothing;

drivers/scsi/bnx2fc/bnx2fc_io.c+24−5

@@ -1923,6 +1923,7 @@ void bnx2fc_process_scsi_cmd_compl(struct bnx2fc_cmd *io_req, · 1922 unmodified lines
1923	struct fcoe_fcp_rsp_payload *fcp_rsp;	1923	struct fcoe_fcp_rsp_payload *fcp_rsp;
1924	struct bnx2fc_rport *tgt = io_req->tgt;	1924	struct bnx2fc_rport *tgt = io_req->tgt;
1925	struct scsi_cmnd *sc_cmd;	1925	struct scsi_cmnd *sc_cmd;
		1926	u16 scope = 0, qualifier = 0;
1926		1927
1927	/* scsi_cmd_cmpl is called with tgt lock held */	1928	/* scsi_cmd_cmpl is called with tgt lock held */
1928		1929
@@ -1990,12 +1991,30 @@ void bnx2fc_process_scsi_cmd_compl(struct bnx2fc_cmd *io_req, · 61 unmodified lines
1990		1991
1991	if (io_req->cdb_status == SAM_STAT_TASK_SET_FULL \|\|	1992	if (io_req->cdb_status == SAM_STAT_TASK_SET_FULL \|\|
1992	io_req->cdb_status == SAM_STAT_BUSY) {	1993	io_req->cdb_status == SAM_STAT_BUSY) {
1993	/* Set the jiffies + retry_delay_timer * 100ms	1994	/* Newer array firmware with BUSY or
1994	for the rport/tgt */	1995	* TASK_SET_FULL may return a status that needs
1995	tgt->retry_delay_timestamp = jiffies +	1996	* the scope bits masked.
1996	fcp_rsp->retry_delay_timer * HZ / 10;	1997	* Or a huge delay timestamp up to 27 minutes
		1998	* can result.
		1999	*/
		2000	if (fcp_rsp->retry_delay_timer) {
		2001	/* Upper 2 bits */
		2002	scope = fcp_rsp->retry_delay_timer
		2003	& 0xC000;
		2004	/* Lower 14 bits */
		2005	qualifier = fcp_rsp->retry_delay_timer
		2006	& 0x3FFF;
		2007	}
		2008	if (scope > 0 && qualifier > 0 &&
		2009	qualifier <= 0x3FEF) {
		2010	/* Set the jiffies +
		2011	* retry_delay_timer * 100ms
		2012	* for the rport/tgt
		2013	*/
		2014	tgt->retry_delay_timestamp = jiffies +
		2015	(qualifier * HZ / 10);
		2016	}
1997	}	2017	}
1998
1999	}	2018	}
2000	if (io_req->fcp_resid)	2019	if (io_req->fcp_resid)
2001	scsi_set_resid(sc_cmd, io_req->fcp_resid);	2020	scsi_set_resid(sc_cmd, io_req->fcp_resid);

drivers/scsi/hisi_sas/hisi_sas_main.c+3−3

drivers/scsi/megaraid.c+2−2

@@ -4183,11 +4183,11 @@ megaraid_probe_one(struct pci_dev pdev, const struct pci_device_id id) · 4182 unmodified lines
4183	*/	4183	*/
4184	if (pdev->subsystem_vendor == PCI_VENDOR_ID_COMPAQ &&	4184	if (pdev->subsystem_vendor == PCI_VENDOR_ID_COMPAQ &&
4185	pdev->subsystem_device == 0xC000)	4185	pdev->subsystem_device == 0xC000)
4186	return -ENODEV;	4186	goto out_disable_device;
4187	/* Now check the magic signature byte */	4187	/* Now check the magic signature byte */
4188	pci_read_config_word(pdev, PCI_CONF_AMISIG, &magic);	4188	pci_read_config_word(pdev, PCI_CONF_AMISIG, &magic);
4189	if (magic != HBA_SIGNATURE_471 && magic != HBA_SIGNATURE)	4189	if (magic != HBA_SIGNATURE_471 && magic != HBA_SIGNATURE)
4190	return -ENODEV;	4190	goto out_disable_device;
4191	/* Ok it is probably a megaraid */	4191	/* Ok it is probably a megaraid */
4192	}	4192	}
4193		4193

drivers/scsi/qedf/qedf_main.c+1−1

@@ -596,7 +596,7 @@ static void qedf_dcbx_handler(void dev, struct qed_dcbx_get get, u32 mib_type) · 595 unmodified lines
596	tmp_prio = get->operational.app_prio.fcoe;	596	tmp_prio = get->operational.app_prio.fcoe;
597	if (qedf_default_prio > -1)	597	if (qedf_default_prio > -1)
598	qedf->prio = qedf_default_prio;	598	qedf->prio = qedf_default_prio;
599	else if (tmp_prio < 0 \|\| tmp_prio > 7) {	599	else if (tmp_prio > 7) {
600	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,	600	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
601	"FIP/FCoE prio %d out of range, setting to %d.\n",	601	"FIP/FCoE prio %d out of range, setting to %d.\n",
602	tmp_prio, QEDF_DEFAULT_PRIO);	602	tmp_prio, QEDF_DEFAULT_PRIO);

drivers/scsi/qla2xxx/qla_attr.c+2−0

@@ -2920,6 +2920,8 @@ qla24xx_vport_delete(struct fc_vport *fc_vport) · 2919 unmodified lines
2920	struct qla_hw_data *ha = vha->hw;	2920	struct qla_hw_data *ha = vha->hw;
2921	uint16_t id = vha->vp_idx;	2921	uint16_t id = vha->vp_idx;
2922		2922
		2923	set_bit(VPORT_DELETE, &vha->dpc_flags);
		2924
2923	while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) \|\|	2925	while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) \|\|
2924	test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))	2926	test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
2925	msleep(1000);	2927	msleep(1000);

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

 	unsigned int query:1;
 	unsigned int id_changed:1;
 	unsigned int scan_needed:1;
+	unsigned int n2n_flag:1;
 	struct completion nvme_del_done;
 	uint32_t nvme_prli_service_param;
 	uint8_t fc4_type;
 	uint8_t	fc4f_nvme;
 	uint8_t scan_state;
-	uint8_t n2n_flag;
 	unsigned long last_queue_full;
 	unsigned long last_ramp_up;
 enum fc4type_t {
 	FS_FC4TYPE_FCP	= BIT_0,
 	FS_FC4TYPE_NVME	= BIT_1,
+	FS_FCP_IS_N2N = BIT_7,
 };
 struct fab_scan_rp {
 #define IOCB_WORK_ACTIVE	31
 #define SET_ZIO_THRESHOLD_NEEDED 32
 #define ISP_ABORT_TO_ROM	33
+#define VPORT_DELETE		34
 	unsigned long	pci_flags;
 #define PFLG_DISCONNECTED	0	/* PCI device removed */

drivers/scsi/qla2xxx/qla_gs.c+2−1

@@ -3102,7 +3102,8 @@ int qla24xx_post_gpnid_work(struct scsi_qla_host vha, port_id_t id) · 3101 unmodified lines
3102	{	3102	{
3103	struct qla_work_evt *e;	3103	struct qla_work_evt *e;
3104		3104
3105	if (test_bit(UNLOADING, &vha->dpc_flags))	3105	if (test_bit(UNLOADING, &vha->dpc_flags) \|\|
		3106	(vha->vp_idx && test_bit(VPORT_DELETE, &vha->dpc_flags)))
3106	return 0;	3107	return 0;
3107		3108
3108	e = qla2x00_alloc_work(vha, QLA_EVT_GPNID);	3109	e = qla2x00_alloc_work(vha, QLA_EVT_GPNID);

drivers/scsi/qla2xxx/qla_init.c+78−31

@@ -746,12 +746,15 @@ static void qla24xx_handle_gnl_done_event(scsi_qla_host_t *vha, · 745 unmodified lines
746	break;	746	break;
747	default:	747	default:
748	if ((id.b24 != fcport->d_id.b24 &&	748	if ((id.b24 != fcport->d_id.b24 &&
749	fcport->d_id.b24) \|\|	749	fcport->d_id.b24 &&
		750	fcport->loop_id != FC_NO_LOOP_ID) \|\|
750	(fcport->loop_id != FC_NO_LOOP_ID &&	751	(fcport->loop_id != FC_NO_LOOP_ID &&
751	fcport->loop_id != loop_id)) {	752	fcport->loop_id != loop_id)) {
752	ql_dbg(ql_dbg_disc, vha, 0x20e3,	753	ql_dbg(ql_dbg_disc, vha, 0x20e3,
753	"%s %d %8phC post del sess\n",	754	"%s %d %8phC post del sess\n",
754	__func__, __LINE__, fcport->port_name);	755	__func__, __LINE__, fcport->port_name);
		756	if (fcport->n2n_flag)
		757	fcport->d_id.b24 = 0;
755	qlt_schedule_sess_for_deletion(fcport);	758	qlt_schedule_sess_for_deletion(fcport);
756	return;	759	return;
757	}	760	}
@@ -759,6 +762,8 @@ static void qla24xx_handle_gnl_done_event(scsi_qla_host_t *vha, · 1 unmodified line
759	}	762	}
760		763
761	fcport->loop_id = loop_id;	764	fcport->loop_id = loop_id;
		765	if (fcport->n2n_flag)
		766	fcport->d_id.b24 = id.b24;
762		767
763	wwn = wwn_to_u64(fcport->port_name);	768	wwn = wwn_to_u64(fcport->port_name);
764	qlt_find_sess_invalidate_other(vha, wwn,	769	qlt_find_sess_invalidate_other(vha, wwn,
@@ -972,7 +977,7 @@ static void qla24xx_async_gnl_sp_done(srb_t *sp, int res) · 207 unmodified lines
972	wwn = wwn_to_u64(e->port_name);	977	wwn = wwn_to_u64(e->port_name);
973		978
974	ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x20e8,	979	ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x20e8,
975	"%s %8phC %02x:%02x:%02x state %d/%d lid %x \n",	980	"%s %8phC %02x:%02x:%02x CLS %x/%x lid %x \n",
976	__func__, (void *)&wwn, e->port_id[2], e->port_id[1],	981	__func__, (void *)&wwn, e->port_id[2], e->port_id[1],
977	e->port_id[0], e->current_login_state, e->last_login_state,	982	e->port_id[0], e->current_login_state, e->last_login_state,
978	(loop_id & 0x7fff));	983	(loop_id & 0x7fff));
@@ -1499,7 +1504,8 @@ int qla24xx_fcport_handle_login(struct scsi_qla_host vha, fc_port_t fcport) · 520 unmodified lines
1499	(fcport->fw_login_state == DSC_LS_PRLI_PEND)))	1504	(fcport->fw_login_state == DSC_LS_PRLI_PEND)))
1500	return 0;	1505	return 0;
1501		1506
1502	if (fcport->fw_login_state == DSC_LS_PLOGI_COMP) {	1507	if (fcport->fw_login_state == DSC_LS_PLOGI_COMP &&
		1508	!N2N_TOPO(vha->hw)) {
1503	if (time_before_eq(jiffies, fcport->plogi_nack_done_deadline)) {	1509	if (time_before_eq(jiffies, fcport->plogi_nack_done_deadline)) {
1504	set_bit(RELOGIN_NEEDED, &vha->dpc_flags);	1510	set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1505	return 0;	1511	return 0;
@@ -1570,8 +1576,9 @@ int qla24xx_fcport_handle_login(struct scsi_qla_host vha, fc_port_t fcport) · 64 unmodified lines
1570	qla24xx_post_gpdb_work(vha, fcport, 0);	1576	qla24xx_post_gpdb_work(vha, fcport, 0);
1571	} else {	1577	} else {
1572	ql_dbg(ql_dbg_disc, vha, 0x2118,	1578	ql_dbg(ql_dbg_disc, vha, 0x2118,
1573	"%s %d %8phC post NVMe PRLI\n",	1579	"%s %d %8phC post %s PRLI\n",
1574	__func__, __LINE__, fcport->port_name);	1580	__func__, __LINE__, fcport->port_name,
		1581	fcport->fc4f_nvme ? "NVME" : "FC");
1575	qla24xx_post_prli_work(vha, fcport);	1582	qla24xx_post_prli_work(vha, fcport);
1576	}	1583	}
1577	break;	1584	break;
@@ -1853,17 +1860,38 @@ qla24xx_handle_prli_done_event(struct scsi_qla_host vha, struct event_arg ea) · 275 unmodified lines
1853	break;	1860	break;
1854	}	1861	}
1855		1862
1856	if (ea->fcport->n2n_flag) {	1863	if (ea->fcport->fc4f_nvme) {
1857	ql_dbg(ql_dbg_disc, vha, 0x2118,	1864	ql_dbg(ql_dbg_disc, vha, 0x2118,
1858	"%s %d %8phC post fc4 prli\n",	1865	"%s %d %8phC post fc4 prli\n",
1859	__func__, __LINE__, ea->fcport->port_name);	1866	__func__, __LINE__, ea->fcport->port_name);
1860	ea->fcport->fc4f_nvme = 0;	1867	ea->fcport->fc4f_nvme = 0;
1861	ea->fcport->n2n_flag = 0;
1862	qla24xx_post_prli_work(vha, ea->fcport);	1868	qla24xx_post_prli_work(vha, ea->fcport);
		1869	return;
		1870	}
		1871
		1872	/* at this point both PRLI NVME & PRLI FCP failed */
		1873	if (N2N_TOPO(vha->hw)) {
		1874	if (ea->fcport->n2n_link_reset_cnt < 3) {
		1875	ea->fcport->n2n_link_reset_cnt++;
		1876	/*
		1877	* remote port is not sending Plogi. Reset
		1878	* link to kick start his state machine
		1879	*/
		1880	set_bit(N2N_LINK_RESET, &vha->dpc_flags);
		1881	} else {
		1882	ql_log(ql_log_warn, vha, 0x2119,
		1883	"%s %d %8phC Unable to reconnect\n",
		1884	__func__, __LINE__, ea->fcport->port_name);
		1885	}
		1886	} else {
		1887	/*
		1888	* switch connect. login failed. Take connection
		1889	* down and allow relogin to retrigger
		1890	*/
		1891	ea->fcport->flags &= ~FCF_ASYNC_SENT;
		1892	ea->fcport->keep_nport_handle = 0;
		1893	qlt_schedule_sess_for_deletion(ea->fcport);
1863	}	1894	}
1864	ql_dbg(ql_dbg_disc, vha, 0x2119,
1865	"%s %d %8phC unhandle event of %x\n",
1866	__func__, __LINE__, ea->fcport->port_name, ea->data[0]);
1867	break;	1895	break;
1868	}	1896	}
1869	}	1897	}
@@ -3190,7 +3218,7 @@ qla2x00_alloc_fw_dump(scsi_qla_host_t *vha) · 1320 unmodified lines
3190		3218
3191	for (j = 0; j < 2; j++, fwdt++) {	3219	for (j = 0; j < 2; j++, fwdt++) {
3192	if (!fwdt->template) {	3220	if (!fwdt->template) {
3193	ql_log(ql_log_warn, vha, 0x00ba,	3221	ql_dbg(ql_dbg_init, vha, 0x00ba,
3194	"-> fwdt%u no template\n", j);	3222	"-> fwdt%u no template\n", j);
3195	continue;	3223	continue;
3196	}	3224	}
@@ -4986,28 +5014,47 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha) · 1789 unmodified lines
4986	unsigned long flags;	5014	unsigned long flags;
4987		5015
4988	/* Inititae N2N login. */	5016	/* Inititae N2N login. */
4989	if (test_and_clear_bit(N2N_LOGIN_NEEDED, &vha->dpc_flags)) {	5017	if (N2N_TOPO(ha)) {
4990	/* borrowing */	5018	if (test_and_clear_bit(N2N_LOGIN_NEEDED, &vha->dpc_flags)) {
4991	u32 *bp, i, sz;	5019	/* borrowing */
4992		5020	u32 *bp, i, sz;
4993	memset(ha->init_cb, 0, ha->init_cb_size);	5021
4994	sz = min_t(int, sizeof(struct els_plogi_payload),	5022	memset(ha->init_cb, 0, ha->init_cb_size);
4995	ha->init_cb_size);	5023	sz = min_t(int, sizeof(struct els_plogi_payload),
4996	rval = qla24xx_get_port_login_templ(vha, ha->init_cb_dma,	5024	ha->init_cb_size);
4997	(void *)ha->init_cb, sz);	5025	rval = qla24xx_get_port_login_templ(vha,
4998	if (rval == QLA_SUCCESS) {	5026	ha->init_cb_dma, (void *)ha->init_cb, sz);
4999	bp = (uint32_t *)ha->init_cb;	5027	if (rval == QLA_SUCCESS) {
5000	for (i = 0; i < sz/4 ; i++, bp++)	5028	bp = (uint32_t *)ha->init_cb;
5001	bp = cpu_to_be32(bp);	5029	for (i = 0; i < sz/4 ; i++, bp++)
		5030	bp = cpu_to_be32(bp);
5002		5031
5003	memcpy(&ha->plogi_els_payld.data, (void *)ha->init_cb,	5032	memcpy(&ha->plogi_els_payld.data,
5004	sizeof(ha->plogi_els_payld.data));	5033	(void *)ha->init_cb,
5005	set_bit(RELOGIN_NEEDED, &vha->dpc_flags);	5034	sizeof(ha->plogi_els_payld.data));
5006	} else {	5035	set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
5007	ql_dbg(ql_dbg_init, vha, 0x00d1,	5036	} else {
5008	"PLOGI ELS param read fail.\n");	5037	ql_dbg(ql_dbg_init, vha, 0x00d1,
		5038	"PLOGI ELS param read fail.\n");
		5039	goto skip_login;
		5040	}
		5041	}
		5042
		5043	list_for_each_entry(fcport, &vha->vp_fcports, list) {
		5044	if (fcport->n2n_flag) {
		5045	qla24xx_fcport_handle_login(vha, fcport);
		5046	return QLA_SUCCESS;
		5047	}
		5048	}
		5049	skip_login:
		5050	spin_lock_irqsave(&vha->work_lock, flags);
		5051	vha->scan.scan_retry++;
		5052	spin_unlock_irqrestore(&vha->work_lock, flags);
		5053
		5054	if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
		5055	set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
		5056	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
5009	}	5057	}
5010	return QLA_SUCCESS;
5011	}	5058	}
5012		5059
5013	found_devs = 0;	5060	found_devs = 0;

drivers/scsi/qla2xxx/qla_iocb.c+4−3

 	els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa;
 	els_iocb->port_id[1] = sp->fcport->d_id.b.area;
 	els_iocb->port_id[2] = sp->fcport->d_id.b.domain;
-	els_iocb->s_id[0] = vha->d_id.b.al_pa;
+	/* For SID the byte order is different than DID */
-	els_iocb->s_id[1] = vha->d_id.b.area;
+	els_iocb->s_id[1] = vha->d_id.b.al_pa;
-	els_iocb->s_id[2] = vha->d_id.b.domain;
+	els_iocb->s_id[2] = vha->d_id.b.area;
+	els_iocb->s_id[0] = vha->d_id.b.domain;
 	if (elsio->u.els_logo.els_cmd == ELS_DCMD_PLOGI) {
 		els_iocb->control_flags = 0;

drivers/scsi/qla2xxx/qla_mbx.c+22−3

 	mbx_cmd_t mc;
 	mbx_cmd_t *mcp = &mc;
-	ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105a,
+	ql_dbg(ql_dbg_disc, vha, 0x105a,
 	    "Entered %s.\n", __func__);
 	if (IS_CNA_CAPABLE(vha->hw)) {
 		case TOPO_N2N:
 			ha->current_topology = ISP_CFG_N;
 			spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
+			list_for_each_entry(fcport, &vha->vp_fcports, list) {
+				fcport->scan_state = QLA_FCPORT_SCAN;
+				fcport->n2n_flag = 0;
+			}
 			fcport = qla2x00_find_fcport_by_wwpn(vha,
 			    rptid_entry->u.f1.port_name, 1);
 			spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
 			if (fcport) {
 				fcport->plogi_nack_done_deadline = jiffies + HZ;
-				fcport->dm_login_expire = jiffies + 3*HZ;
+				fcport->dm_login_expire = jiffies + 2*HZ;
 				fcport->scan_state = QLA_FCPORT_FOUND;
+				fcport->n2n_flag = 1;
+				fcport->keep_nport_handle = 1;
+				if (vha->flags.nvme_enabled)
+					fcport->fc4f_nvme = 1;
 				switch (fcport->disc_state) {
 				case DSC_DELETED:
 					set_bit(RELOGIN_NEEDED,
 				    rptid_entry->u.f1.port_name,
 				    rptid_entry->u.f1.node_name,
 				    NULL,
-				    FC4_TYPE_UNKNOWN);
+				    FS_FCP_IS_N2N);
 			}
 			/* if our portname is higher then initiate N2N login */
 		list_for_each_entry(fcport, &vha->vp_fcports, list) {
 			fcport->scan_state = QLA_FCPORT_SCAN;
+			fcport->n2n_flag = 0;
 		}
 		fcport = qla2x00_find_fcport_by_wwpn(vha,
 			fcport->login_retry = vha->hw->login_retry_count;
 			fcport->plogi_nack_done_deadline = jiffies + HZ;
 			fcport->scan_state = QLA_FCPORT_FOUND;
+			fcport->keep_nport_handle = 1;
+			fcport->n2n_flag = 1;
+			fcport->d_id.b.domain =
+				rptid_entry->u.f2.remote_nport_id[2];
+			fcport->d_id.b.area =
+				rptid_entry->u.f2.remote_nport_id[1];
+			fcport->d_id.b.al_pa =
+				rptid_entry->u.f2.remote_nport_id[0];
 		}
 	}
 }

drivers/scsi/qla2xxx/qla_mid.c+22−10

 	uint16_t vp_id;
 	struct qla_hw_data *ha = vha->hw;
 	unsigned long flags = 0;
+	u8 i;
 	mutex_lock(&ha->vport_lock);
 	/*
 	 * ensures no active vp_list traversal while the vport is removed
 	 * from the queue)
 	 */
-	wait_event_timeout(vha->vref_waitq, !atomic_read(&vha->vref_count),
+	for (i = 0; i < 10 && atomic_read(&vha->vref_count); i++)
-	    10*HZ);
+		wait_event_timeout(vha->vref_waitq,
+		    atomic_read(&vha->vref_count), HZ);
 	spin_lock_irqsave(&ha->vport_slock, flags);
 	if (atomic_read(&vha->vref_count)) {
 	spin_lock_irqsave(&ha->vport_slock, flags);
 	list_for_each_entry(vha, &ha->vp_list, list) {
 		if (vha->vp_idx) {
+			if (test_bit(VPORT_DELETE, &vha->dpc_flags))
+				continue;
 			atomic_inc(&vha->vref_count);
 			spin_unlock_irqrestore(&ha->vport_slock, flags);
 int
 qla2x00_vp_abort_isp(scsi_qla_host_t *vha)
 {
+	fc_port_t *fcport;
+	/*
+	 * To exclusively reset vport, we need to log it out first.
+	 * Note: This control_vp can fail if ISP reset is already
+	 * issued, this is expected, as the vp would be already
+	 * logged out due to ISP reset.
+	 */
+	if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
+		qla24xx_control_vp(vha, VCE_COMMAND_DISABLE_VPS_LOGO_ALL);
+		list_for_each_entry(fcport, &vha->vp_fcports, list)
+			fcport->logout_on_delete = 0;
+	}
 	/*
 	 * Physical port will do most of the abort and recovery work. We can
 	 * just treat it as a loop down
 			atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 	}
-	/*
-	 * To exclusively reset vport, we need to log it out first.  Note: this
-	 * control_vp can fail if ISP reset is already issued, this is
-	 * expected, as the vp would be already logged out due to ISP reset.
-	 */
-	if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
-		qla24xx_control_vp(vha, VCE_COMMAND_DISABLE_VPS_LOGO_ALL);
 	ql_dbg(ql_dbg_taskm, vha, 0x801d,
 	    "Scheduling enable of Vport %d.\n", vha->vp_idx);
 	return qla24xx_enable_vp(vha);
 }

drivers/scsi/qla2xxx/qla_os.c+13−5

 void
 qla2x00_wait_for_sess_deletion(scsi_qla_host_t *vha)
 {
+	u8 i;
 	qla2x00_mark_all_devices_lost(vha, 0);
-	wait_event_timeout(vha->fcport_waitQ, test_fcport_count(vha), 10*HZ);
+	for (i = 0; i < 10; i++)
+		wait_event_timeout(vha->fcport_waitQ, test_fcport_count(vha),
+		    HZ);
+	flush_workqueue(vha->hw->wq);
 }
 /*
 			memcpy(fcport->port_name, e->u.new_sess.port_name,
 			    WWN_SIZE);
+			if (e->u.new_sess.fc4_type & FS_FCP_IS_N2N)
+				fcport->n2n_flag = 1;
 		} else {
 			ql_dbg(ql_dbg_disc, vha, 0xffff,
 				   "%s %8phC mem alloc fail.\n",
 			if (dfcp)
 				qlt_schedule_sess_for_deletion(tfcp);
-			if (N2N_TOPO(vha->hw))
-				fcport->flags &= ~FCF_FABRIC_DEVICE;
 			if (N2N_TOPO(vha->hw)) {
+				fcport->flags &= ~FCF_FABRIC_DEVICE;
+				fcport->keep_nport_handle = 1;
 				if (vha->flags.nvme_enabled) {
 					fcport->fc4f_nvme = 1;
 					fcport->n2n_flag = 1;

drivers/scsi/qla2xxx/qla_target.c+13−13

@@ -953,7 +953,7 @@ void qlt_free_session_done(struct work_struct *work) · 952 unmodified lines
953	struct qla_hw_data *ha = vha->hw;	953	struct qla_hw_data *ha = vha->hw;
954	unsigned long flags;	954	unsigned long flags;
955	bool logout_started = false;	955	bool logout_started = false;
956	scsi_qla_host_t *base_vha;	956	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
957	struct qlt_plogi_ack_t *own =	957	struct qlt_plogi_ack_t *own =
958	sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN];	958	sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN];
959		959
@@ -1020,6 +1020,7 @@ void qlt_free_session_done(struct work_struct *work) · 60 unmodified lines
1020		1020
1021	if (logout_started) {	1021	if (logout_started) {
1022	bool traced = false;	1022	bool traced = false;
		1023	u16 cnt = 0;
1023		1024
1024	while (!READ_ONCE(sess->logout_completed)) {	1025	while (!READ_ONCE(sess->logout_completed)) {
1025	if (!traced) {	1026	if (!traced) {
@@ -1029,6 +1030,9 @@ void qlt_free_session_done(struct work_struct *work) · 3 unmodified lines
1029	traced = true;	1030	traced = true;
1030	}	1031	}
1031	msleep(100);	1032	msleep(100);
		1033	cnt++;
		1034	if (cnt > 200)
		1035	break;
1032	}	1036	}
1033		1037
1034	ql_dbg(ql_dbg_disc, vha, 0xf087,	1038	ql_dbg(ql_dbg_disc, vha, 0xf087,
@@ -1101,6 +1105,7 @@ void qlt_free_session_done(struct work_struct *work) · 66 unmodified lines
1101	}	1105	}
1102		1106
1103	spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);	1107	spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
		1108	sess->free_pending = 0;
1104		1109
1105	ql_dbg(ql_dbg_tgt_mgt, vha, 0xf001,	1110	ql_dbg(ql_dbg_tgt_mgt, vha, 0xf001,
1106	"Unregistration of sess %p %8phC finished fcp_cnt %d\n",	1111	"Unregistration of sess %p %8phC finished fcp_cnt %d\n",
@@ -1109,17 +1114,9 @@ void qlt_free_session_done(struct work_struct *work) · 2 unmodified lines
1109	if (tgt && (tgt->sess_count == 0))	1114	if (tgt && (tgt->sess_count == 0))
1110	wake_up_all(&tgt->waitQ);	1115	wake_up_all(&tgt->waitQ);
1111		1116
1112	if (vha->fcport_count == 0)	1117	if (!test_bit(PFLG_DRIVER_REMOVING, &base_vha->pci_flags) &&
1113	wake_up_all(&vha->fcport_waitQ);	1118	!(vha->vp_idx && test_bit(VPORT_DELETE, &vha->dpc_flags)) &&
1114		1119	(!tgt \|\| !tgt->tgt_stop) && !LOOP_TRANSITION(vha)) {
1115	base_vha = pci_get_drvdata(ha->pdev);
1116
1117	sess->free_pending = 0;
1118
1119	if (test_bit(PFLG_DRIVER_REMOVING, &base_vha->pci_flags))
1120	return;
1121
1122	if ((!tgt \|\| !tgt->tgt_stop) && !LOOP_TRANSITION(vha)) {
1123	switch (vha->host->active_mode) {	1120	switch (vha->host->active_mode) {
1124	case MODE_INITIATOR:	1121	case MODE_INITIATOR:
1125	case MODE_DUAL:	1122	case MODE_DUAL:
@@ -1132,6 +1129,9 @@ void qlt_free_session_done(struct work_struct *work) · 6 unmodified lines
1132	break;	1129	break;
1133	}	1130	}
1134	}	1131	}
		1132
		1133	if (vha->fcport_count == 0)
		1134	wake_up_all(&vha->fcport_waitQ);
1135	}	1135	}
1136		1136
1137	/* ha->tgt.sess_lock supposed to be held on entry */	1137	/* ha->tgt.sess_lock supposed to be held on entry */
@@ -1161,7 +1161,7 @@ void qlt_unreg_sess(struct fc_port *sess) · 23 unmodified lines
1161	sess->last_login_gen = sess->login_gen;	1161	sess->last_login_gen = sess->login_gen;
1162		1162
1163	INIT_WORK(&sess->free_work, qlt_free_session_done);	1163	INIT_WORK(&sess->free_work, qlt_free_session_done);
1164	schedule_work(&sess->free_work);	1164	queue_work(sess->vha->hw->wq, &sess->free_work);
1165	}	1165	}
1166	EXPORT_SYMBOL(qlt_unreg_sess);	1166	EXPORT_SYMBOL(qlt_unreg_sess);
1167		1167

drivers/scsi/storvsc_drv.c+1−2

@@ -1837,8 +1837,7 @@ static int storvsc_probe(struct hv_device *device, · 1836 unmodified lines
1837	/*	1837	/*
1838	* Set the number of HW queues we are supporting.	1838	* Set the number of HW queues we are supporting.
1839	*/	1839	*/
1840	if (stor_device->num_sc != 0)	1840	host->nr_hw_queues = num_present_cpus();
1841	host->nr_hw_queues = stor_device->num_sc + 1;
1842		1841
1843	/*	1842	/*
1844	* Set the error handler work queue.	1843	* Set the error handler work queue.

drivers/scsi/ufs/ufshcd.c+3−0

@@ -8143,6 +8143,9 @@ int ufshcd_shutdown(struct ufs_hba *hba) · 8142 unmodified lines
8143	{	8143	{
8144	int ret = 0;	8144	int ret = 0;
8145		8145
		8146	if (!hba->is_powered)
		8147	goto out;
		8148
8146	if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba))	8149	if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba))
8147	goto out;	8150	goto out;
8148		8151

drivers/staging/octeon/ethernet-tx.c+2−4

 	 */
 	dst_release(skb_dst(skb));
 	skb_dst_set(skb, NULL);
-#ifdef CONFIG_XFRM
+	skb_ext_reset(skb);
-	secpath_reset(skb);
+	nf_reset_ct(skb);
-#endif
-	nf_reset(skb);
 #ifdef CONFIG_NET_SCHED
 	skb->tc_index = 0;

drivers/video/logo/Makefile+2−19

@@ -18,23 +18,6 @@ obj-$(CONFIG_SPU_BASE) += logo_spe_clut224.o · 17 unmodified lines
18		18
19	# How to generate logo's	19	# How to generate logo's
20		20
21	# Use logo-cfiles to retrieve list of .c files to be built
22	logo-cfiles = $(notdir $(patsubst %.$(2), %.c, \
23	$(wildcard $(srctree)/$(src)/*$(1).$(2))))
24
25
26	# Mono logos
27	extra-y += $(call logo-cfiles,_mono,pbm)
28
29	# VGA16 logos
30	extra-y += $(call logo-cfiles,_vga16,ppm)
31
32	# 224 Logos
33	extra-y += $(call logo-cfiles,_clut224,ppm)
34
35	# Gray 256
36	extra-y += $(call logo-cfiles,_gray256,pgm)
37
38	pnmtologo := scripts/pnmtologo	21	pnmtologo := scripts/pnmtologo
39		22
40	# Create commands like "pnmtologo -t mono -n logo_mac_mono -o ..."	23	# Create commands like "pnmtologo -t mono -n logo_mac_mono -o ..."
@@ -55,5 +38,5 @@ $(obj)/%_clut224.c: $(src)/%_clut224.ppm $(pnmtologo) FORCE · 14 unmodified lines
55	$(obj)/%_gray256.c: $(src)/%_gray256.pgm $(pnmtologo) FORCE	38	$(obj)/%_gray256.c: $(src)/%_gray256.pgm $(pnmtologo) FORCE
56	$(call if_changed,logo)	39	$(call if_changed,logo)
57		40
58	# Files generated that shall be removed upon make clean	41	# generated C files
59	clean-files := .o _mono.c _vga16.c _clut224.c *_gray256.c	42	targets += _mono.c _vga16.c _clut224.c _gray256.c

drivers/xen/balloon.c+7−17

 	(GFP_HIGHUSER | __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC)
 /* balloon_append: add the given page to the balloon. */
-static void __balloon_append(struct page *page)
+static void balloon_append(struct page *page)
 {
+	__SetPageOffline(page);
 	/* Lowmem is re-populated first, so highmem pages go at list tail. */
 	if (PageHighMem(page)) {
 		list_add_tail(&page->lru, &ballooned_pages);
 	wake_up(&balloon_wq);
 }
-static void balloon_append(struct page *page)
-{
-	__balloon_append(page);
-}
 /* balloon_retrieve: rescue a page from the balloon, if it is not empty. */
 static struct page *balloon_retrieve(bool require_lowmem)
 {
 	else
 		balloon_stats.balloon_low--;
+	__ClearPageOffline(page);
 	return page;
 }
 	for (i = 0; i < size; i++) {
 		p = pfn_to_page(start_pfn + i);
 		__online_page_set_limits(p);
-		__SetPageOffline(p);
+		balloon_append(p);
-		__balloon_append(p);
 	}
 	mutex_unlock(&balloon_mutex);
 }
 		xenmem_reservation_va_mapping_update(1, &page, &frame_list[i]);
 		/* Relinquish the page back to the allocator. */
-		__ClearPageOffline(page);
 		free_reserved_page(page);
 	}
 			state = BP_EAGAIN;
 			break;
 		}
-		__SetPageOffline(page);
 		adjust_managed_page_count(page, -1);
 		xenmem_reservation_scrub_page(page);
 		list_add(&page->lru, &pages);
 	while (pgno < nr_pages) {
 		page = balloon_retrieve(true);
 		if (page) {
-			__ClearPageOffline(page);
 			pages[pgno++] = page;
 #ifdef CONFIG_XEN_HAVE_PVMMU
 			/*
 	mutex_lock(&balloon_mutex);
 	for (i = 0; i < nr_pages; i++) {
-		if (pages[i]) {
+		if (pages[i])
-			__SetPageOffline(pages[i]);
 			balloon_append(pages[i]);
-		}
 	}
 	balloon_stats.target_unpopulated -= nr_pages;
 				      unsigned long pages)
 {
 	unsigned long pfn, extra_pfn_end;
-	struct page *page;
 	/*
 	 * If the amount of usable memory has been limited (e.g., with
 	extra_pfn_end = min(max_pfn, start_pfn + pages);
 	for (pfn = start_pfn; pfn < extra_pfn_end; pfn++) {
-		page = pfn_to_page(pfn);
 		/* totalram_pages and totalhigh_pages do not
 		   include the boot-time balloon extension, so
 		   don't subtract from it. */
-		__balloon_append(page);
+		balloon_append(pfn_to_page(pfn));
 	}
 	balloon_stats.total_pages += extra_pfn_end - start_pfn;

drivers/xen/efi.c+47−37

@@ -40,7 +40,7 @@ · 39 unmodified lines
40		40
41	#define efi_data(op) (op.u.efi_runtime_call)	41	#define efi_data(op) (op.u.efi_runtime_call)
42		42
43	efi_status_t xen_efi_get_time(efi_time_t tm, efi_time_cap_t tc)	43	static efi_status_t xen_efi_get_time(efi_time_t tm, efi_time_cap_t tc)
44	{	44	{
45	struct xen_platform_op op = INIT_EFI_OP(get_time);	45	struct xen_platform_op op = INIT_EFI_OP(get_time);
46		46
@@ -61,9 +61,8 @@ efi_status_t xen_efi_get_time(efi_time_t tm, efi_time_cap_t tc) · 14 unmodified lines
61		61
62	return efi_data(op).status;	62	return efi_data(op).status;
63	}	63	}
64	EXPORT_SYMBOL_GPL(xen_efi_get_time);
65		64
66	efi_status_t xen_efi_set_time(efi_time_t *tm)	65	static efi_status_t xen_efi_set_time(efi_time_t *tm)
67	{	66	{
68	struct xen_platform_op op = INIT_EFI_OP(set_time);	67	struct xen_platform_op op = INIT_EFI_OP(set_time);
69		68
@@ -75,10 +74,10 @@ efi_status_t xen_efi_set_time(efi_time_t *tm) · 5 unmodified lines
75		74
76	return efi_data(op).status;	75	return efi_data(op).status;
77	}	76	}
78	EXPORT_SYMBOL_GPL(xen_efi_set_time);
79		77
80	efi_status_t xen_efi_get_wakeup_time(efi_bool_t enabled, efi_bool_t pending,	78	static efi_status_t xen_efi_get_wakeup_time(efi_bool_t *enabled,
81	efi_time_t *tm)	79	efi_bool_t *pending,
		80	efi_time_t *tm)
82	{	81	{
83	struct xen_platform_op op = INIT_EFI_OP(get_wakeup_time);	82	struct xen_platform_op op = INIT_EFI_OP(get_wakeup_time);
84		83
@@ -98,9 +97,8 @@ efi_status_t xen_efi_get_wakeup_time(efi_bool_t enabled, efi_bool_t pending, · 13 unmodified lines
98		97
99	return efi_data(op).status;	98	return efi_data(op).status;
100	}	99	}
101	EXPORT_SYMBOL_GPL(xen_efi_get_wakeup_time);
102		100
103	efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)	101	static efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
104	{	102	{
105	struct xen_platform_op op = INIT_EFI_OP(set_wakeup_time);	103	struct xen_platform_op op = INIT_EFI_OP(set_wakeup_time);
106		104
@@ -117,11 +115,10 @@ efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm) · 10 unmodified lines
117		115
118	return efi_data(op).status;	116	return efi_data(op).status;
119	}	117	}
120	EXPORT_SYMBOL_GPL(xen_efi_set_wakeup_time);
121		118
122	efi_status_t xen_efi_get_variable(efi_char16_t name, efi_guid_t vendor,	119	static efi_status_t xen_efi_get_variable(efi_char16_t name, efi_guid_t vendor,
123	u32 attr, unsigned long data_size,	120	u32 attr, unsigned long data_size,
124	void *data)	121	void *data)
125	{	122	{
126	struct xen_platform_op op = INIT_EFI_OP(get_variable);	123	struct xen_platform_op op = INIT_EFI_OP(get_variable);
127		124
@@ -141,11 +138,10 @@ efi_status_t xen_efi_get_variable(efi_char16_t name, efi_guid_t vendor, · 13 unmodified lines
141		138
142	return efi_data(op).status;	139	return efi_data(op).status;
143	}	140	}
144	EXPORT_SYMBOL_GPL(xen_efi_get_variable);
145		141
146	efi_status_t xen_efi_get_next_variable(unsigned long *name_size,	142	static efi_status_t xen_efi_get_next_variable(unsigned long *name_size,
147	efi_char16_t *name,	143	efi_char16_t *name,
148	efi_guid_t *vendor)	144	efi_guid_t *vendor)
149	{	145	{
150	struct xen_platform_op op = INIT_EFI_OP(get_next_variable_name);	146	struct xen_platform_op op = INIT_EFI_OP(get_next_variable_name);
151		147
@@ -165,11 +161,10 @@ efi_status_t xen_efi_get_next_variable(unsigned long *name_size, · 13 unmodified lines
165		161
166	return efi_data(op).status;	162	return efi_data(op).status;
167	}	163	}
168	EXPORT_SYMBOL_GPL(xen_efi_get_next_variable);
169		164
170	efi_status_t xen_efi_set_variable(efi_char16_t name, efi_guid_t vendor,	165	static efi_status_t xen_efi_set_variable(efi_char16_t name, efi_guid_t vendor,
171	u32 attr, unsigned long data_size,	166	u32 attr, unsigned long data_size,
172	void *data)	167	void *data)
173	{	168	{
174	struct xen_platform_op op = INIT_EFI_OP(set_variable);	169	struct xen_platform_op op = INIT_EFI_OP(set_variable);
175		170
@@ -186,11 +181,10 @@ efi_status_t xen_efi_set_variable(efi_char16_t name, efi_guid_t vendor, · 10 unmodified lines
186		181
187	return efi_data(op).status;	182	return efi_data(op).status;
188	}	183	}
189	EXPORT_SYMBOL_GPL(xen_efi_set_variable);
190		184
191	efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space,	185	static efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space,
192	u64 *remaining_space,	186	u64 *remaining_space,
193	u64 *max_variable_size)	187	u64 *max_variable_size)
194	{	188	{
195	struct xen_platform_op op = INIT_EFI_OP(query_variable_info);	189	struct xen_platform_op op = INIT_EFI_OP(query_variable_info);
196		190
@@ -208,9 +202,8 @@ efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space, · 11 unmodified lines
208		202
209	return efi_data(op).status;	203	return efi_data(op).status;
210	}	204	}
211	EXPORT_SYMBOL_GPL(xen_efi_query_variable_info);
212		205
213	efi_status_t xen_efi_get_next_high_mono_count(u32 *count)	206	static efi_status_t xen_efi_get_next_high_mono_count(u32 *count)
214	{	207	{
215	struct xen_platform_op op = INIT_EFI_OP(get_next_high_monotonic_count);	208	struct xen_platform_op op = INIT_EFI_OP(get_next_high_monotonic_count);
216		209
@@ -221,10 +214,9 @@ efi_status_t xen_efi_get_next_high_mono_count(u32 *count) · 4 unmodified lines
221		214
222	return efi_data(op).status;	215	return efi_data(op).status;
223	}	216	}
224	EXPORT_SYMBOL_GPL(xen_efi_get_next_high_mono_count);
225		217
226	efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules,	218	static efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules,
227	unsigned long count, unsigned long sg_list)	219	unsigned long count, unsigned long sg_list)
228	{	220	{
229	struct xen_platform_op op = INIT_EFI_OP(update_capsule);	221	struct xen_platform_op op = INIT_EFI_OP(update_capsule);
230		222
@@ -241,11 +233,9 @@ efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules, · 10 unmodified lines
241		233
242	return efi_data(op).status;	234	return efi_data(op).status;
243	}	235	}
244	EXPORT_SYMBOL_GPL(xen_efi_update_capsule);
245		236
246	efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules,	237	static efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules,
247	unsigned long count, u64 *max_size,	238	unsigned long count, u64 max_size, int reset_type)
248	int *reset_type)
249	{	239	{
250	struct xen_platform_op op = INIT_EFI_OP(query_capsule_capabilities);	240	struct xen_platform_op op = INIT_EFI_OP(query_capsule_capabilities);
251		241
@@ -264,10 +254,9 @@ efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules, · 12 unmodified lines
264		254
265	return efi_data(op).status;	255	return efi_data(op).status;
266	}	256	}
267	EXPORT_SYMBOL_GPL(xen_efi_query_capsule_caps);
268		257
269	void xen_efi_reset_system(int reset_type, efi_status_t status,	258	static void xen_efi_reset_system(int reset_type, efi_status_t status,
270	unsigned long data_size, efi_char16_t *data)	259	unsigned long data_size, efi_char16_t *data)
271	{	260	{
272	switch (reset_type) {	261	switch (reset_type) {
273	case EFI_RESET_COLD:	262	case EFI_RESET_COLD:
@@ -281,4 +270,25 @@ void xen_efi_reset_system(int reset_type, efi_status_t status, · 7 unmodified lines
281	BUG();	270	BUG();
282	}	271	}
283	}	272	}
284	EXPORT_SYMBOL_GPL(xen_efi_reset_system);	273
		274	/*
		275	* Set XEN EFI runtime services function pointers. Other fields of struct efi,
		276	* e.g. efi.systab, will be set like normal EFI.
		277	*/
		278	void __init xen_efi_runtime_setup(void)
		279	{
		280	efi.get_time = xen_efi_get_time;
		281	efi.set_time = xen_efi_set_time;
		282	efi.get_wakeup_time = xen_efi_get_wakeup_time;
		283	efi.set_wakeup_time = xen_efi_set_wakeup_time;
		284	efi.get_variable = xen_efi_get_variable;
		285	efi.get_next_variable = xen_efi_get_next_variable;
		286	efi.set_variable = xen_efi_set_variable;
		287	efi.set_variable_nonblocking = xen_efi_set_variable;
		288	efi.query_variable_info = xen_efi_query_variable_info;
		289	efi.query_variable_info_nonblocking = xen_efi_query_variable_info;
		290	efi.update_capsule = xen_efi_update_capsule;
		291	efi.query_capsule_caps = xen_efi_query_capsule_caps;
		292	efi.get_next_high_mono_count = xen_efi_get_next_high_mono_count;
		293	efi.reset_system = xen_efi_reset_system;
		294	}

drivers/xen/xenbus/xenbus_dev_frontend.c+18−2

 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/miscdevice.h>
+#include <linux/workqueue.h>
 #include <xen/xenbus.h>
 #include <xen/xen.h>
 	wait_queue_head_t read_waitq;
 	struct kref kref;
+	struct work_struct wq;
 };
 /* Read out any raw xenbus messages queued up. */
 	mutex_unlock(&adap->dev_data->reply_mutex);
 }
-static void xenbus_file_free(struct kref *kref)
+static void xenbus_worker(struct work_struct *wq)
 {
 	struct xenbus_file_priv *u;
 	struct xenbus_transaction_holder *trans, *tmp;
 	struct watch_adapter *watch, *tmp_watch;
 	struct read_buffer *rb, *tmp_rb;
-	u = container_of(kref, struct xenbus_file_priv, kref);
+	u = container_of(wq, struct xenbus_file_priv, wq);
 	/*
 	 * No need for locking here because there are no other users,
 	kfree(u);
 }
+static void xenbus_file_free(struct kref *kref)
+{
+	struct xenbus_file_priv *u;
+	/*
+	 * We might be called in xenbus_thread().
+	 * Use workqueue to avoid deadlock.
+	 */
+	u = container_of(kref, struct xenbus_file_priv, kref);
+	schedule_work(&u->wq);
+}
 static struct xenbus_transaction_holder *xenbus_get_transaction(
 	struct xenbus_file_priv *u, uint32_t tx_id)
 {
 	INIT_LIST_HEAD(&u->watches);
 	INIT_LIST_HEAD(&u->read_buffers);
 	init_waitqueue_head(&u->read_waitq);
+	INIT_WORK(&u->wq, xenbus_worker);
 	mutex_init(&u->reply_mutex);
 	mutex_init(&u->msgbuffer_mutex);

fs/binfmt_elf.c+3−10

 	   the correct location in memory. */
 	for(i = 0, elf_ppnt = elf_phdata;
 	    i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
-		int elf_prot, elf_flags, elf_fixed = MAP_FIXED_NOREPLACE;
+		int elf_prot, elf_flags;
 		unsigned long k, vaddr;
 		unsigned long total_size = 0;
 					 */
 				}
 			}
-			/*
-			 * Some binaries have overlapping elf segments and then
-			 * we have to forcefully map over an existing mapping
-			 * e.g. over this newly established brk mapping.
-			 */
-			elf_fixed = MAP_FIXED;
 		}
 		elf_prot = make_prot(elf_ppnt->p_flags);
 		 * the ET_DYN load_addr calculations, proceed normally.
 		 */
 		if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
-			elf_flags |= elf_fixed;
+			elf_flags |= MAP_FIXED;
 		} else if (loc->elf_ex.e_type == ET_DYN) {
 			/*
 			 * This logic is run once for the first LOAD Program
 				load_bias = ELF_ET_DYN_BASE;
 				if (current->flags & PF_RANDOMIZE)
 					load_bias += arch_mmap_rnd();
-				elf_flags |= elf_fixed;
+				elf_flags |= MAP_FIXED;
 			} else
 				load_bias = 0;

fs/erofs/data.c+7−3

 struct page *erofs_get_meta_page(struct super_block *sb, erofs_blk_t blkaddr)
 {
-	struct inode *const bd_inode = sb->s_bdev->bd_inode;
+	struct address_space *const mapping = sb->s_bdev->bd_inode->i_mapping;
-	struct address_space *const mapping = bd_inode->i_mapping;
+	struct page *page;
-	return read_cache_page_gfp(mapping, blkaddr,
+	page = read_cache_page_gfp(mapping, blkaddr,
 				   mapping_gfp_constraint(mapping, ~__GFP_FS));
+	/* should already be PageUptodate */
+	if (!IS_ERR(page))
+		lock_page(page);
+	return page;
 }
 static int erofs_map_blocks_flatmode(struct inode *inode,

fs/erofs/super.c+2−2

@@ -105,9 +105,9 @@ static int erofs_read_superblock(struct super_block *sb) · 104 unmodified lines
105	int ret;	105	int ret;
106		106
107	page = read_mapping_page(sb->s_bdev->bd_inode->i_mapping, 0, NULL);	107	page = read_mapping_page(sb->s_bdev->bd_inode->i_mapping, 0, NULL);
108	if (!page) {	108	if (IS_ERR(page)) {
109	erofs_err(sb, "cannot read erofs superblock");	109	erofs_err(sb, "cannot read erofs superblock");
110	return -EIO;	110	return PTR_ERR(page);
111	}	111	}
112		112
113	sbi = EROFS_SB(sb);	113	sbi = EROFS_SB(sb);

fs/erofs/zdata.c+10−2

 	struct erofs_map_blocks *const map = &fe->map;
 	struct z_erofs_collector *const clt = &fe->clt;
 	const loff_t offset = page_offset(page);
-	bool tight = (clt->mode >= COLLECT_PRIMARY_HOOKED);
+	bool tight = true;
 	enum z_erofs_cache_alloctype cache_strategy;
 	enum z_erofs_page_type page_type;
 	preload_compressed_pages(clt, MNGD_MAPPING(sbi),
 				 cache_strategy, pagepool);
-	tight &= (clt->mode >= COLLECT_PRIMARY_HOOKED);
 hitted:
+	/*
+	 * Ensure the current partial page belongs to this submit chain rather
+	 * than other concurrent submit chains or the noio(bypass) chain since
+	 * those chains are handled asynchronously thus the page cannot be used
+	 * for inplace I/O or pagevec (should be processed in strict order.)
+	 */
+	tight &= (clt->mode >= COLLECT_PRIMARY_HOOKED &&
+		  clt->mode != COLLECT_PRIMARY_FOLLOWED_NOINPLACE);
 	cur = end - min_t(unsigned int, offset + end - map->m_la, end);
 	if (!(map->m_flags & EROFS_MAP_MAPPED)) {
 		zero_user_segment(page, cur, end);

fs/io_uring.c+4−4

@@ -1892,15 +1892,15 @@ static int io_timeout(struct io_kiocb req, const struct io_uring_sqe sqe) · 1891 unmodified lines
1892	unsigned count, req_dist, tail_index;	1892	unsigned count, req_dist, tail_index;
1893	struct io_ring_ctx *ctx = req->ctx;	1893	struct io_ring_ctx *ctx = req->ctx;
1894	struct list_head *entry;	1894	struct list_head *entry;
1895	struct timespec ts;	1895	struct timespec64 ts;
1896		1896
1897	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))	1897	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
1898	return -EINVAL;	1898	return -EINVAL;
1899	if (sqe->flags \|\| sqe->ioprio \|\| sqe->buf_index \|\| sqe->timeout_flags \|\|	1899	if (sqe->flags \|\| sqe->ioprio \|\| sqe->buf_index \|\| sqe->timeout_flags \|\|
1900	sqe->len != 1)	1900	sqe->len != 1)
1901	return -EINVAL;	1901	return -EINVAL;
1902	if (copy_from_user(&ts, (void __user *) (unsigned long) sqe->addr,	1902
1903	sizeof(ts)))	1903	if (get_timespec64(&ts, u64_to_user_ptr(sqe->addr)))
1904	return -EFAULT;	1904	return -EFAULT;
1905		1905
1906	/*	1906	/*
@@ -1934,7 +1934,7 @@ static int io_timeout(struct io_kiocb req, const struct io_uring_sqe sqe) · 27 unmodified lines
1934		1934
1935	hrtimer_init(&req->timeout.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	1935	hrtimer_init(&req->timeout.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1936	req->timeout.timer.function = io_timeout_fn;	1936	req->timeout.timer.function = io_timeout_fn;
1937	hrtimer_start(&req->timeout.timer, timespec_to_ktime(ts),	1937	hrtimer_start(&req->timeout.timer, timespec64_to_ktime(ts),
1938	HRTIMER_MODE_REL);	1938	HRTIMER_MODE_REL);
1939	return 0;	1939	return 0;
1940	}	1940	}

fs/readdir.c+133−35

@@ -20,9 +20,63 @@ · 19 unmodified lines
20	#include <linux/syscalls.h>	20	#include <linux/syscalls.h>
21	#include <linux/unistd.h>	21	#include <linux/unistd.h>
22	#include <linux/compat.h>	22	#include <linux/compat.h>
23
24	#include <linux/uaccess.h>	23	#include <linux/uaccess.h>
25		24
		25	#include <asm/unaligned.h>
		26
		27	/*
		28	* Note the "unsafe_put_user() semantics: we goto a
		29	* label for errors.
		30	*
		31	* Also note how we use a "while()" loop here, even though
		32	* only the biggest size needs to loop. The compiler (well,
		33	* at least gcc) is smart enough to turn the smaller sizes
		34	* into just if-statements, and this way we don't need to
		35	* care whether 'u64' or 'u32' is the biggest size.
		36	*/
		37	#define unsafe_copy_loop(dst, src, len, type, label) \
		38	while (len >= sizeof(type)) { \
		39	unsafe_put_user(get_unaligned((type *)src), \
		40	(type __user *)dst, label); \
		41	dst += sizeof(type); \
		42	src += sizeof(type); \
		43	len -= sizeof(type); \
		44	}
		45
		46	/*
		47	* We avoid doing 64-bit copies on 32-bit architectures. They
		48	* might be better, but the component names are mostly small,
		49	* and the 64-bit cases can end up being much more complex and
		50	* put much more register pressure on the code, so it's likely
		51	* not worth the pain of unaligned accesses etc.
		52	*
		53	* So limit the copies to "unsigned long" size. I did verify
		54	* that at least the x86-32 case is ok without this limiting,
		55	* but I worry about random other legacy 32-bit cases that
		56	* might not do as well.
		57	*/
		58	#define unsafe_copy_type(dst, src, len, type, label) do { \
		59	if (sizeof(type) <= sizeof(unsigned long)) \
		60	unsafe_copy_loop(dst, src, len, type, label); \
		61	} while (0)
		62
		63	/*
		64	* Copy the dirent name to user space, and NUL-terminate
		65	* it. This should not be a function call, since we're doing
		66	* the copy inside a "user_access_begin/end()" section.
		67	*/
		68	#define unsafe_copy_dirent_name(_dst, _src, _len, label) do { \
		69	char __user *dst = (_dst); \
		70	const char *src = (_src); \
		71	size_t len = (_len); \
		72	unsafe_copy_type(dst, src, len, u64, label); \
		73	unsafe_copy_type(dst, src, len, u32, label); \
		74	unsafe_copy_type(dst, src, len, u16, label); \
		75	unsafe_copy_type(dst, src, len, u8, label); \
		76	unsafe_put_user(0, dst, label); \
		77	} while (0)
		78
		79
26	int iterate_dir(struct file file, struct dir_context ctx)	80	int iterate_dir(struct file file, struct dir_context ctx)
27	{	81	{
28	struct inode *inode = file_inode(file);	82	struct inode *inode = file_inode(file);
@@ -64,6 +118,40 @@ out: · 35 unmodified lines
64	}	118	}
65	EXPORT_SYMBOL(iterate_dir);	119	EXPORT_SYMBOL(iterate_dir);
66		120
		121	/*
		122	* POSIX says that a dirent name cannot contain NULL or a '/'.
		123	*
		124	* It's not 100% clear what we should really do in this case.
		125	* The filesystem is clearly corrupted, but returning a hard
		126	* error means that you now don't see any of the other names
		127	* either, so that isn't a perfect alternative.
		128	*
		129	* And if you return an error, what error do you use? Several
		130	* filesystems seem to have decided on EUCLEAN being the error
		131	* code for EFSCORRUPTED, and that may be the error to use. Or
		132	* just EIO, which is perhaps more obvious to users.
		133	*
		134	* In order to see the other file names in the directory, the
		135	* caller might want to make this a "soft" error: skip the
		136	* entry, and return the error at the end instead.
		137	*
		138	* Note that this should likely do a "memchr(name, 0, len)"
		139	* check too, since that would be filesystem corruption as
		140	* well. However, that case can't actually confuse user space,
		141	* which has to do a strlen() on the name anyway to find the
		142	* filename length, and the above "soft error" worry means
		143	* that it's probably better left alone until we have that
		144	* issue clarified.
		145	*/
		146	static int verify_dirent_name(const char *name, int len)
		147	{
		148	if (WARN_ON_ONCE(!len))
		149	return -EIO;
		150	if (WARN_ON_ONCE(memchr(name, '/', len)))
		151	return -EIO;
		152	return 0;
		153	}
		154
67	/*	155	/*
68	* Traditional linux readdir() handling..	156	* Traditional linux readdir() handling..
69	*	157	*
@@ -173,6 +261,9 @@ static int filldir(struct dir_context ctx, const char name, int namlen, · 103 unmodified lines
173	int reclen = ALIGN(offsetof(struct linux_dirent, d_name) + namlen + 2,	261	int reclen = ALIGN(offsetof(struct linux_dirent, d_name) + namlen + 2,
174	sizeof(long));	262	sizeof(long));
175		263
		264	buf->error = verify_dirent_name(name, namlen);
		265	if (unlikely(buf->error))
		266	return buf->error;
176	buf->error = -EINVAL; /* only used if we fail.. */	267	buf->error = -EINVAL; /* only used if we fail.. */
177	if (reclen > buf->count)	268	if (reclen > buf->count)
178	return -EINVAL;	269	return -EINVAL;
@@ -182,28 +273,31 @@ static int filldir(struct dir_context ctx, const char name, int namlen, · 3 unmodified lines
182	return -EOVERFLOW;	273	return -EOVERFLOW;
183	}	274	}
184	dirent = buf->previous;	275	dirent = buf->previous;
185	if (dirent) {	276	if (dirent && signal_pending(current))
186	if (signal_pending(current))	277	return -EINTR;
187	return -EINTR;	278
188	if (__put_user(offset, &dirent->d_off))	279	/*
189	goto efault;	280	* Note! This range-checks 'previous' (which may be NULL).
190	}	281	* The real range was checked in getdents
191	dirent = buf->current_dir;	282	*/
192	if (__put_user(d_ino, &dirent->d_ino))	283	if (!user_access_begin(dirent, sizeof(*dirent)))
193	goto efault;
194	if (__put_user(reclen, &dirent->d_reclen))
195	goto efault;
196	if (copy_to_user(dirent->d_name, name, namlen))
197	goto efault;
198	if (__put_user(0, dirent->d_name + namlen))
199	goto efault;
200	if (__put_user(d_type, (char __user *) dirent + reclen - 1))
201	goto efault;	284	goto efault;
		285	if (dirent)
		286	unsafe_put_user(offset, &dirent->d_off, efault_end);
		287	dirent = buf->current_dir;
		288	unsafe_put_user(d_ino, &dirent->d_ino, efault_end);
		289	unsafe_put_user(reclen, &dirent->d_reclen, efault_end);
		290	unsafe_put_user(d_type, (char __user *) dirent + reclen - 1, efault_end);
		291	unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
		292	user_access_end();
		293
202	buf->previous = dirent;	294	buf->previous = dirent;
203	dirent = (void __user *)dirent + reclen;	295	dirent = (void __user *)dirent + reclen;
204	buf->current_dir = dirent;	296	buf->current_dir = dirent;
205	buf->count -= reclen;	297	buf->count -= reclen;
206	return 0;	298	return 0;
		299	efault_end:
		300	user_access_end();
207	efault:	301	efault:
208	buf->error = -EFAULT;	302	buf->error = -EFAULT;
209	return -EFAULT;	303	return -EFAULT;
@@ -259,34 +353,38 @@ static int filldir64(struct dir_context ctx, const char name, int namlen, · 49 unmodified lines
259	int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,	353	int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
260	sizeof(u64));	354	sizeof(u64));
261		355
		356	buf->error = verify_dirent_name(name, namlen);
		357	if (unlikely(buf->error))
		358	return buf->error;
262	buf->error = -EINVAL; /* only used if we fail.. */	359	buf->error = -EINVAL; /* only used if we fail.. */
263	if (reclen > buf->count)	360	if (reclen > buf->count)
264	return -EINVAL;	361	return -EINVAL;
265	dirent = buf->previous;	362	dirent = buf->previous;
266	if (dirent) {	363	if (dirent && signal_pending(current))
267	if (signal_pending(current))	364	return -EINTR;
268	return -EINTR;	365
269	if (__put_user(offset, &dirent->d_off))	366	/*
270	goto efault;	367	* Note! This range-checks 'previous' (which may be NULL).
271	}	368	* The real range was checked in getdents
272	dirent = buf->current_dir;	369	*/
273	if (__put_user(ino, &dirent->d_ino))	370	if (!user_access_begin(dirent, sizeof(*dirent)))
274	goto efault;
275	if (__put_user(0, &dirent->d_off))
276	goto efault;
277	if (__put_user(reclen, &dirent->d_reclen))
278	goto efault;
279	if (__put_user(d_type, &dirent->d_type))
280	goto efault;
281	if (copy_to_user(dirent->d_name, name, namlen))
282	goto efault;
283	if (__put_user(0, dirent->d_name + namlen))
284	goto efault;	371	goto efault;
		372	if (dirent)
		373	unsafe_put_user(offset, &dirent->d_off, efault_end);
		374	dirent = buf->current_dir;
		375	unsafe_put_user(ino, &dirent->d_ino, efault_end);
		376	unsafe_put_user(reclen, &dirent->d_reclen, efault_end);
		377	unsafe_put_user(d_type, &dirent->d_type, efault_end);
		378	unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
		379	user_access_end();
		380
285	buf->previous = dirent;	381	buf->previous = dirent;
286	dirent = (void __user *)dirent + reclen;	382	dirent = (void __user *)dirent + reclen;
287	buf->current_dir = dirent;	383	buf->current_dir = dirent;
288	buf->count -= reclen;	384	buf->count -= reclen;
289	return 0;	385	return 0;
		386	efault_end:
		387	user_access_end();
290	efault:	388	efault:
291	buf->error = -EFAULT;	389	buf->error = -EFAULT;
292	return -EFAULT;	390	return -EFAULT;

fs/statfs.c+4−13

@@ -318,19 +318,10 @@ COMPAT_SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct compat_statfs __user *, · 317 unmodified lines
318	static int put_compat_statfs64(struct compat_statfs64 __user ubuf, struct kstatfs kbuf)	318	static int put_compat_statfs64(struct compat_statfs64 __user ubuf, struct kstatfs kbuf)
319	{	319	{
320	struct compat_statfs64 buf;	320	struct compat_statfs64 buf;
321	if (sizeof(ubuf->f_bsize) == 4) {	321
322	if ((kbuf->f_type \| kbuf->f_bsize \| kbuf->f_namelen \|	322	if ((kbuf->f_bsize \| kbuf->f_frsize) & 0xffffffff00000000ULL)
323	kbuf->f_frsize \| kbuf->f_flags) & 0xffffffff00000000ULL)	323	return -EOVERFLOW;
324	return -EOVERFLOW;	324
325	/* f_files and f_ffree may be -1; it's okay
326	* to stuff that into 32 bits */
327	if (kbuf->f_files != 0xffffffffffffffffULL
328	&& (kbuf->f_files & 0xffffffff00000000ULL))
329	return -EOVERFLOW;
330	if (kbuf->f_ffree != 0xffffffffffffffffULL
331	&& (kbuf->f_ffree & 0xffffffff00000000ULL))
332	return -EOVERFLOW;
333	}
334	memset(&buf, 0, sizeof(struct compat_statfs64));	325	memset(&buf, 0, sizeof(struct compat_statfs64));
335	buf.f_type = kbuf->f_type;	326	buf.f_type = kbuf->f_type;
336	buf.f_bsize = kbuf->f_bsize;	327	buf.f_bsize = kbuf->f_bsize;

include/linux/bitops.h+7−0

@@ -4,6 +4,13 @@ · 3 unmodified lines
4	#include <asm/types.h>	4	#include <asm/types.h>
5	#include <linux/bits.h>	5	#include <linux/bits.h>
6		6
		7	/* Set bits in the first 'n' bytes when loaded from memory */
		8	#ifdef __LITTLE_ENDIAN
		9	# define aligned_byte_mask(n) ((1UL << 8*(n))-1)
		10	#else
		11	# define aligned_byte_mask(n) (~0xffUL << (BITS_PER_LONG - 8 - 8*(n)))
		12	#endif
		13
7	#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)	14	#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)
8	#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(long))	15	#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(long))
9		16

include/linux/dsa/sja1105.h+3−1

 #define SJA1105_META_SMAC			0x222222222222ull
 #define SJA1105_META_DMAC			0x0180C200000Eull
+#define SJA1105_HWTS_RX_EN			0
 /* Global tagger data: each struct sja1105_port has a reference to
  * the structure defined in struct sja1105_private.
  */
 	 * from taggers running on multiple ports on SMP systems
 	 */
 	spinlock_t meta_lock;
-	bool hwts_rx_en;
+	unsigned long state;
 };
 struct sja1105_skb_cb {

include/linux/kvm_host.h+2−0

 struct kvm_stat_data {
 	int offset;
+	int mode;
 	struct kvm *kvm;
 };
 	const char *name;
 	int offset;
 	enum kvm_stat_kind kind;
+	int mode;
 };
 extern struct kvm_stats_debugfs_item debugfs_entries[];
 extern struct dentry *kvm_debugfs_dir;

include/linux/mii.h+9−0

@@ -455,6 +455,15 @@ static inline void mii_lpa_mod_linkmode_lpa_t(unsigned long *lp_advertising, · 454 unmodified lines
455	lp_advertising, lpa & LPA_LPACK);	455	lp_advertising, lpa & LPA_LPACK);
456	}	456	}
457		457
		458	static inline void mii_ctrl1000_mod_linkmode_adv_t(unsigned long *advertising,
		459	u32 ctrl1000)
		460	{
		461	linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, advertising,
		462	ctrl1000 & ADVERTISE_1000HALF);
		463	linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, advertising,
		464	ctrl1000 & ADVERTISE_1000FULL);
		465	}
		466
458	/**	467	/**
459	* linkmode_adv_to_lcl_adv_t	468	* linkmode_adv_to_lcl_adv_t
460	* @advertising:pointer to linkmode advertising	469	* @advertising:pointer to linkmode advertising

include/linux/phy.h+2−0

 	return phydev->state >= PHY_UP;
 }
+void phy_resolve_aneg_pause(struct phy_device *phydev);
 void phy_resolve_aneg_linkmode(struct phy_device *phydev);
 /**
 int __genphy_config_aneg(struct phy_device *phydev, bool changed);
 int genphy_aneg_done(struct phy_device *phydev);
 int genphy_update_link(struct phy_device *phydev);
+int genphy_read_lpa(struct phy_device *phydev);
 int genphy_read_status(struct phy_device *phydev);
 int genphy_suspend(struct phy_device *phydev);
 int genphy_resume(struct phy_device *phydev);

include/linux/skbuff.h+1−4

 static inline void skb_ext_copy(struct sk_buff *dst, const struct sk_buff *s) {}
 #endif /* CONFIG_SKB_EXTENSIONS */
-static inline void nf_reset(struct sk_buff *skb)
+static inline void nf_reset_ct(struct sk_buff *skb)
 {
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 	nf_conntrack_put(skb_nfct(skb));
 	skb->_nfct = 0;
 #endif
-#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
-	skb_ext_del(skb, SKB_EXT_BRIDGE_NF);
-#endif
 }
 static inline void nf_reset_trace(struct sk_buff *skb)

include/linux/uaccess.h+70−0

@@ -231,6 +231,76 @@ __copy_from_user_inatomic_nocache(void to, const void __user from, · 230 unmodified lines
231		231
232	#endif /* ARCH_HAS_NOCACHE_UACCESS */	232	#endif /* ARCH_HAS_NOCACHE_UACCESS */
233		233
		234	extern __must_check int check_zeroed_user(const void __user *from, size_t size);
		235
		236	/**
		237	* copy_struct_from_user: copy a struct from userspace
		238	* @dst: Destination address, in kernel space. This buffer must be @ksize
		239	* bytes long.
		240	* @ksize: Size of @dst struct.
		241	* @src: Source address, in userspace.
		242	* @usize: (Alleged) size of @src struct.
		243	*
		244	* Copies a struct from userspace to kernel space, in a way that guarantees
		245	* backwards-compatibility for struct syscall arguments (as long as future
		246	* struct extensions are made such that all new fields are appended to the
		247	* old struct, and zeroed-out new fields have the same meaning as the old
		248	* struct).
		249	*
		250	* @ksize is just sizeof(*dst), and @usize should've been passed by userspace.
		251	* The recommended usage is something like the following:
		252	*
		253	* SYSCALL_DEFINE2(foobar, const struct foo __user *, uarg, size_t, usize)
		254	* {
		255	* int err;
		256	* struct foo karg = {};
		257	*
		258	* if (usize > PAGE_SIZE)
		259	* return -E2BIG;
		260	* if (usize < FOO_SIZE_VER0)
		261	* return -EINVAL;
		262	*
		263	* err = copy_struct_from_user(&karg, sizeof(karg), uarg, usize);
		264	* if (err)
		265	* return err;
		266	*
		267	* // ...
		268	* }
		269	*
		270	* There are three cases to consider:
		271	* * If @usize == @ksize, then it's copied verbatim.
		272	* * If @usize < @ksize, then the userspace has passed an old struct to a
		273	* newer kernel. The rest of the trailing bytes in @dst (@ksize - @usize)
		274	* are to be zero-filled.
		275	* * If @usize > @ksize, then the userspace has passed a new struct to an
		276	* older kernel. The trailing bytes unknown to the kernel (@usize - @ksize)
		277	* are checked to ensure they are zeroed, otherwise -E2BIG is returned.
		278	*
		279	* Returns (in all cases, some data may have been copied):
		280	* * -E2BIG: (@usize > @ksize) and there are non-zero trailing bytes in @src.
		281	* * -EFAULT: access to userspace failed.
		282	*/
		283	static __always_inline __must_check int
		284	copy_struct_from_user(void dst, size_t ksize, const void __user src,
		285	size_t usize)
		286	{
		287	size_t size = min(ksize, usize);
		288	size_t rest = max(ksize, usize) - size;
		289
		290	/* Deal with trailing bytes. */
		291	if (usize < ksize) {
		292	memset(dst + size, 0, rest);
		293	} else if (usize > ksize) {
		294	int ret = check_zeroed_user(src + size, rest);
		295	if (ret <= 0)
		296	return ret ?: -E2BIG;
		297	}
		298	/* Copy the interoperable parts of the struct. */
		299	if (copy_from_user(dst, src, size))
		300	return -EFAULT;
		301	return 0;
		302	}
		303
234	/*	304	/*
235	* probe_kernel_read(): safely attempt to read from a location	305	* probe_kernel_read(): safely attempt to read from a location
236	* @dst: pointer to the buffer that shall take the data	306	* @dst: pointer to the buffer that shall take the data

include/trace/events/rxrpc.h+1−1

@@ -1068,7 +1068,7 @@ TRACE_EVENT(rxrpc_recvmsg, · 1067 unmodified lines
1068	),	1068	),
1069		1069
1070	TP_fast_assign(	1070	TP_fast_assign(
1071	__entry->call = call->debug_id;	1071	__entry->call = call ? call->debug_id : 0;
1072	__entry->why = why;	1072	__entry->why = why;
1073	__entry->seq = seq;	1073	__entry->seq = seq;
1074	__entry->offset = offset;	1074	__entry->offset = offset;

include/uapi/drm/amdgpu_drm.h+2−0

@@ -1003,6 +1003,8 @@ struct drm_amdgpu_info_device { · 1002 unmodified lines
1003	__u64 high_va_max;	1003	__u64 high_va_max;
1004	/* gfx10 pa_sc_tile_steering_override */	1004	/* gfx10 pa_sc_tile_steering_override */
1005	__u32 pa_sc_tile_steering_override;	1005	__u32 pa_sc_tile_steering_override;
		1006	/* disabled TCCs */
		1007	__u64 tcc_disabled_mask;
1006	};	1008	};
1007		1009
1008	struct drm_amdgpu_info_hw_ip {	1010	struct drm_amdgpu_info_hw_ip {

include/uapi/linux/nvme_ioctl.h+23−0

@@ -45,6 +45,27 @@ struct nvme_passthru_cmd { · 44 unmodified lines
45	__u32 result;	45	__u32 result;
46	};	46	};
47		47
		48	struct nvme_passthru_cmd64 {
		49	__u8 opcode;
		50	__u8 flags;
		51	__u16 rsvd1;
		52	__u32 nsid;
		53	__u32 cdw2;
		54	__u32 cdw3;
		55	__u64 metadata;
		56	__u64 addr;
		57	__u32 metadata_len;
		58	__u32 data_len;
		59	__u32 cdw10;
		60	__u32 cdw11;
		61	__u32 cdw12;
		62	__u32 cdw13;
		63	__u32 cdw14;
		64	__u32 cdw15;
		65	__u32 timeout_ms;
		66	__u64 result;
		67	};
		68
48	#define nvme_admin_cmd nvme_passthru_cmd	69	#define nvme_admin_cmd nvme_passthru_cmd
49		70
50	#define NVME_IOCTL_ID _IO('N', 0x40)	71	#define NVME_IOCTL_ID _IO('N', 0x40)
@@ -54,5 +75,7 @@ struct nvme_passthru_cmd { · 3 unmodified lines
54	#define NVME_IOCTL_RESET _IO('N', 0x44)	75	#define NVME_IOCTL_RESET _IO('N', 0x44)
55	#define NVME_IOCTL_SUBSYS_RESET _IO('N', 0x45)	76	#define NVME_IOCTL_SUBSYS_RESET _IO('N', 0x45)
56	#define NVME_IOCTL_RESCAN _IO('N', 0x46)	77	#define NVME_IOCTL_RESCAN _IO('N', 0x46)
		78	#define NVME_IOCTL_ADMIN64_CMD _IOWR('N', 0x47, struct nvme_passthru_cmd64)
		79	#define NVME_IOCTL_IO64_CMD _IOWR('N', 0x48, struct nvme_passthru_cmd64)
57		80
58	#endif /* _UAPI_LINUX_NVME_IOCTL_H */	81	#endif /* _UAPI_LINUX_NVME_IOCTL_H */

include/uapi/linux/pg.h+4−1

 */
+#ifndef _UAPI_LINUX_PG_H
+#define _UAPI_LINUX_PG_H
 #define PG_MAGIC	'P'
 #define PG_RESET	'Z'
 #define PG_COMMAND	'C'
 };
-/* end of pg.h */
+#endif /* _UAPI_LINUX_PG_H */

include/uapi/linux/sched.h+28−2

@@ -33,8 +33,31 @@ · 32 unmodified lines
33	#define CLONE_NEWNET 0x40000000 /* New network namespace */	33	#define CLONE_NEWNET 0x40000000 /* New network namespace */
34	#define CLONE_IO 0x80000000 /* Clone io context */	34	#define CLONE_IO 0x80000000 /* Clone io context */
35		35
36	/*	36	#ifndef __ASSEMBLY__
37	* Arguments for the clone3 syscall	37	/**
		38	* struct clone_args - arguments for the clone3 syscall
		39	* @flags: Flags for the new process as listed above.
		40	* All flags are valid except for CSIGNAL and
		41	* CLONE_DETACHED.
		42	* @pidfd: If CLONE_PIDFD is set, a pidfd will be
		43	* returned in this argument.
		44	* @child_tid: If CLONE_CHILD_SETTID is set, the TID of the
		45	* child process will be returned in the child's
		46	* memory.
		47	* @parent_tid: If CLONE_PARENT_SETTID is set, the TID of
		48	* the child process will be returned in the
		49	* parent's memory.
		50	* @exit_signal: The exit_signal the parent process will be
		51	* sent when the child exits.
		52	* @stack: Specify the location of the stack for the
		53	* child process.
		54	* @stack_size: The size of the stack for the child process.
		55	* @tls: If CLONE_SETTLS is set, the tls descriptor
		56	* is set to tls.
		57	*
		58	* The structure is versioned by size and thus extensible.
		59	* New struct members must go at the end of the struct and
		60	* must be properly 64bit aligned.
38	*/	61	*/
39	struct clone_args {	62	struct clone_args {
40	__aligned_u64 flags;	63	__aligned_u64 flags;
@@ -46,6 +69,9 @@ struct clone_args { · 5 unmodified lines
46	__aligned_u64 stack_size;	69	__aligned_u64 stack_size;
47	__aligned_u64 tls;	70	__aligned_u64 tls;
48	};	71	};
		72	#endif
		73
		74	#define CLONE_ARGS_SIZE_VER0 64 /* sizeof first published struct */
49		75
50	/*	76	/*
51	* Scheduling policies	77	* Scheduling policies

include/xen/xen-ops.h+1−24

@@ -212,30 +212,7 @@ int xen_xlate_map_ballooned_pages(xen_pfn_t pfns, void vaddr, · 211 unmodified lines
212		212
213	bool xen_running_on_version_or_later(unsigned int major, unsigned int minor);	213	bool xen_running_on_version_or_later(unsigned int major, unsigned int minor);
214		214
215	efi_status_t xen_efi_get_time(efi_time_t tm, efi_time_cap_t tc);	215	void xen_efi_runtime_setup(void);
216	efi_status_t xen_efi_set_time(efi_time_t *tm);
217	efi_status_t xen_efi_get_wakeup_time(efi_bool_t enabled, efi_bool_t pending,
218	efi_time_t *tm);
219	efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm);
220	efi_status_t xen_efi_get_variable(efi_char16_t name, efi_guid_t vendor,
221	u32 attr, unsigned long data_size,
222	void *data);
223	efi_status_t xen_efi_get_next_variable(unsigned long *name_size,
224	efi_char16_t name, efi_guid_t vendor);
225	efi_status_t xen_efi_set_variable(efi_char16_t name, efi_guid_t vendor,
226	u32 attr, unsigned long data_size,
227	void *data);
228	efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space,
229	u64 *remaining_space,
230	u64 *max_variable_size);
231	efi_status_t xen_efi_get_next_high_mono_count(u32 *count);
232	efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules,
233	unsigned long count, unsigned long sg_list);
234	efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules,
235	unsigned long count, u64 *max_size,
236	int *reset_type);
237	void xen_efi_reset_system(int reset_type, efi_status_t status,
238	unsigned long data_size, efi_char16_t *data);
239		216
240		217
241	#ifdef CONFIG_PREEMPT	218	#ifdef CONFIG_PREEMPT

kernel/dma/remap.c+2−2

@@ -87,9 +87,9 @@ void dma_common_contiguous_remap(struct page page, size_t size, · 86 unmodified lines
87	*/	87	*/
88	void dma_common_free_remap(void *cpu_addr, size_t size)	88	void dma_common_free_remap(void *cpu_addr, size_t size)
89	{	89	{
90	struct page **pages = dma_common_find_pages(cpu_addr);	90	struct vm_struct *area = find_vm_area(cpu_addr);
91		91
92	if (!pages) {	92	if (!area \|\| area->flags != VM_DMA_COHERENT) {
93	WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);	93	WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
94	return;	94	return;
95	}	95	}

kernel/events/core.c+9−38

@@ -10586,55 +10586,26 @@ static int perf_copy_attr(struct perf_event_attr __user *uattr, · 10585 unmodified lines
10586	u32 size;	10586	u32 size;
10587	int ret;	10587	int ret;
10588		10588
10589	if (!access_ok(uattr, PERF_ATTR_SIZE_VER0))	10589	/* Zero the full structure, so that a short copy will be nice. */
10590	return -EFAULT;
10591
10592	/*
10593	* zero the full structure, so that a short copy will be nice.
10594	*/
10595	memset(attr, 0, sizeof(*attr));	10590	memset(attr, 0, sizeof(*attr));
10596		10591
10597	ret = get_user(size, &uattr->size);	10592	ret = get_user(size, &uattr->size);
10598	if (ret)	10593	if (ret)
10599	return ret;	10594	return ret;
10600		10595
10601	if (size > PAGE_SIZE) /* silly large */	10596	/* ABI compatibility quirk: */
10602	goto err_size;	10597	if (!size)
10603
10604	if (!size) /* abi compat */
10605	size = PERF_ATTR_SIZE_VER0;	10598	size = PERF_ATTR_SIZE_VER0;
10606		10599	if (size < PERF_ATTR_SIZE_VER0 \|\| size > PAGE_SIZE)
10607	if (size < PERF_ATTR_SIZE_VER0)
10608	goto err_size;	10600	goto err_size;
10609		10601
10610	/*	10602	ret = copy_struct_from_user(attr, sizeof(*attr), uattr, size);
10611	* If we're handed a bigger struct than we know of,	10603	if (ret) {
10612	* ensure all the unknown bits are 0 - i.e. new	10604	if (ret == -E2BIG)
10613	* user-space does not rely on any kernel feature	10605	goto err_size;
10614	* extensions we dont know about yet.	10606	return ret;
10615	*/
10616	if (size > sizeof(*attr)) {
10617	unsigned char __user *addr;
10618	unsigned char __user *end;
10619	unsigned char val;
10620
10621	addr = (void __user )uattr + sizeof(attr);
10622	end = (void __user *)uattr + size;
10623
10624	for (; addr < end; addr++) {
10625	ret = get_user(val, addr);
10626	if (ret)
10627	return ret;
10628	if (val)
10629	goto err_size;
10630	}
10631	size = sizeof(*attr);
10632	}	10607	}
10633		10608
10634	ret = copy_from_user(attr, uattr, size);
10635	if (ret)
10636	return -EFAULT;
10637
10638	attr->size = size;	10609	attr->size = size;
10639		10610
10640	if (attr->__reserved_1)	10611	if (attr->__reserved_1)

kernel/fork.c+18−27

@@ -2525,39 +2525,19 @@ SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp, · 2524 unmodified lines
2525	#ifdef __ARCH_WANT_SYS_CLONE3	2525	#ifdef __ARCH_WANT_SYS_CLONE3
2526	noinline static int copy_clone_args_from_user(struct kernel_clone_args *kargs,	2526	noinline static int copy_clone_args_from_user(struct kernel_clone_args *kargs,
2527	struct clone_args __user *uargs,	2527	struct clone_args __user *uargs,
2528	size_t size)	2528	size_t usize)
2529	{	2529	{
		2530	int err;
2530	struct clone_args args;	2531	struct clone_args args;
2531		2532
2532	if (unlikely(size > PAGE_SIZE))	2533	if (unlikely(usize > PAGE_SIZE))
2533	return -E2BIG;	2534	return -E2BIG;
2534		2535	if (unlikely(usize < CLONE_ARGS_SIZE_VER0))
2535	if (unlikely(size < sizeof(struct clone_args)))
2536	return -EINVAL;	2536	return -EINVAL;
2537		2537
2538	if (unlikely(!access_ok(uargs, size)))	2538	err = copy_struct_from_user(&args, sizeof(args), uargs, usize);
2539	return -EFAULT;	2539	if (err)
2540		2540	return err;
2541	if (size > sizeof(struct clone_args)) {
2542	unsigned char __user *addr;
2543	unsigned char __user *end;
2544	unsigned char val;
2545
2546	addr = (void __user *)uargs + sizeof(struct clone_args);
2547	end = (void __user *)uargs + size;
2548
2549	for (; addr < end; addr++) {
2550	if (get_user(val, addr))
2551	return -EFAULT;
2552	if (val)
2553	return -E2BIG;
2554	}
2555
2556	size = sizeof(struct clone_args);
2557	}
2558
2559	if (copy_from_user(&args, uargs, size))
2560	return -EFAULT;
2561		2541
2562	/*	2542	/*
2563	* Verify that higher 32bits of exit_signal are unset and that	2543	* Verify that higher 32bits of exit_signal are unset and that
@@ -2604,6 +2584,17 @@ static bool clone3_args_valid(const struct kernel_clone_args *kargs) · 40 unmodified lines
2604	return true;	2584	return true;
2605	}	2585	}
2606		2586
		2587	/**
		2588	* clone3 - create a new process with specific properties
		2589	* @uargs: argument structure
		2590	* @size: size of @uargs
		2591	*
		2592	* clone3() is the extensible successor to clone()/clone2().
		2593	* It takes a struct as argument that is versioned by its size.
		2594	*
		2595	* Return: On success, a positive PID for the child process.
		2596	* On error, a negative errno number.
		2597	*/
2607	SYSCALL_DEFINE2(clone3, struct clone_args __user *, uargs, size_t, size)	2598	SYSCALL_DEFINE2(clone3, struct clone_args __user *, uargs, size_t, size)
2608	{	2599	{
2609	int err;	2600	int err;

kernel/gen_kheaders.sh+4−1

 find $cpio_dir -type f -print0 |
 	xargs -0 -P8 -n1 perl -pi -e 'BEGIN {undef $/;}; s/\/\*((?!SPDX).)*?\*\///smg;'
-tar -Jcf $tarfile -C $cpio_dir/ . > /dev/null
+# Create archive and try to normalize metadata for reproducibility
+tar "${KBUILD_BUILD_TIMESTAMP:+--mtime=$KBUILD_BUILD_TIMESTAMP}" \
+    --owner=0 --group=0 --sort=name --numeric-owner \
+    -Jcf $tarfile -C $cpio_dir/ . > /dev/null
 echo "$src_files_md5" >  kernel/kheaders.md5
 echo "$obj_files_md5" >> kernel/kheaders.md5

kernel/sched/core.c+7−36

@@ -5106,9 +5106,6 @@ static int sched_copy_attr(struct sched_attr __user uattr, struct sched_attr a · 5105 unmodified lines
5106	u32 size;	5106	u32 size;
5107	int ret;	5107	int ret;
5108		5108
5109	if (!access_ok(uattr, SCHED_ATTR_SIZE_VER0))
5110	return -EFAULT;
5111
5112	/* Zero the full structure, so that a short copy will be nice: */	5109	/* Zero the full structure, so that a short copy will be nice: */
5113	memset(attr, 0, sizeof(*attr));	5110	memset(attr, 0, sizeof(*attr));
5114		5111
@@ -5116,45 +5113,19 @@ static int sched_copy_attr(struct sched_attr __user uattr, struct sched_attr a · 1 unmodified line
5116	if (ret)	5113	if (ret)
5117	return ret;	5114	return ret;
5118		5115
5119	/* Bail out on silly large: */
5120	if (size > PAGE_SIZE)
5121	goto err_size;
5122
5123	/* ABI compatibility quirk: */	5116	/* ABI compatibility quirk: */
5124	if (!size)	5117	if (!size)
5125	size = SCHED_ATTR_SIZE_VER0;	5118	size = SCHED_ATTR_SIZE_VER0;
5126		5119	if (size < SCHED_ATTR_SIZE_VER0 \|\| size > PAGE_SIZE)
5127	if (size < SCHED_ATTR_SIZE_VER0)
5128	goto err_size;	5120	goto err_size;
5129		5121
5130	/*	5122	ret = copy_struct_from_user(attr, sizeof(*attr), uattr, size);
5131	* If we're handed a bigger struct than we know of,	5123	if (ret) {
5132	* ensure all the unknown bits are 0 - i.e. new	5124	if (ret == -E2BIG)
5133	* user-space does not rely on any kernel feature	5125	goto err_size;
5134	* extensions we dont know about yet.	5126	return ret;
5135	*/
5136	if (size > sizeof(*attr)) {
5137	unsigned char __user *addr;
5138	unsigned char __user *end;
5139	unsigned char val;
5140
5141	addr = (void __user )uattr + sizeof(attr);
5142	end = (void __user *)uattr + size;
5143
5144	for (; addr < end; addr++) {
5145	ret = get_user(val, addr);
5146	if (ret)
5147	return ret;
5148	if (val)
5149	goto err_size;
5150	}
5151	size = sizeof(*attr);
5152	}	5127	}
5153		5128
5154	ret = copy_from_user(attr, uattr, size);
5155	if (ret)
5156	return -EFAULT;
5157
5158	if ((attr->sched_flags & SCHED_FLAG_UTIL_CLAMP) &&	5129	if ((attr->sched_flags & SCHED_FLAG_UTIL_CLAMP) &&
5159	size < SCHED_ATTR_SIZE_VER1)	5130	size < SCHED_ATTR_SIZE_VER1)
5160	return -EINVAL;	5131	return -EINVAL;
@@ -5354,7 +5325,7 @@ sched_attr_copy_to_user(struct sched_attr __user *uattr, · 193 unmodified lines
5354	* sys_sched_getattr - similar to sched_getparam, but with sched_attr	5325	* sys_sched_getattr - similar to sched_getparam, but with sched_attr
5355	* @pid: the pid in question.	5326	* @pid: the pid in question.
5356	* @uattr: structure containing the extended parameters.	5327	* @uattr: structure containing the extended parameters.
5357	* @usize: sizeof(attr) that user-space knows about, for forwards and backwards compatibility.	5328	* @usize: sizeof(attr) for fwd/bwd comp.
5358	* @flags: for future extension.	5329	* @flags: for future extension.
5359	*/	5330	*/
5360	SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,	5331	SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,

kernel/sched/membarrier.c+0−1

@@ -174,7 +174,6 @@ static int membarrier_private_expedited(int flags) · 173 unmodified lines
174	*/	174	*/
175	if (cpu == raw_smp_processor_id())	175	if (cpu == raw_smp_processor_id())
176	continue;	176	continue;
177	rcu_read_lock();
178	p = rcu_dereference(cpu_rq(cpu)->curr);	177	p = rcu_dereference(cpu_rq(cpu)->curr);
179	if (p && p->mm == mm)	178	if (p && p->mm == mm)
180	__cpumask_set_cpu(cpu, tmpmask);	179	__cpumask_set_cpu(cpu, tmpmask);

kernel/time/tick-broadcast-hrtimer.c+29−33

@@ -42,39 +42,39 @@ static int bc_shutdown(struct clock_event_device *evt) · 41 unmodified lines
42	*/	42	*/
43	static int bc_set_next(ktime_t expires, struct clock_event_device *bc)	43	static int bc_set_next(ktime_t expires, struct clock_event_device *bc)
44	{	44	{
45	int bc_moved;
46	/*	45	/*
47	* We try to cancel the timer first. If the callback is on	46	* This is called either from enter/exit idle code or from the
48	* flight on some other cpu then we let it handle it. If we	47	* broadcast handler. In all cases tick_broadcast_lock is held.
49	* were able to cancel the timer nothing can rearm it as we
50	* own broadcast_lock.
51	*	48	*
52	* However we can also be called from the event handler of	49	* hrtimer_cancel() cannot be called here neither from the
53	* ce_broadcast_hrtimer itself when it expires. We cannot	50	* broadcast handler nor from the enter/exit idle code. The idle
54	* restart the timer because we are in the callback, but we	51	* code can run into the problem described in bc_shutdown() and the
55	* can set the expiry time and let the callback return	52	* broadcast handler cannot wait for itself to complete for obvious
56	* HRTIMER_RESTART.	53	* reasons.
57	*	54	*
58	* Since we are in the idle loop at this point and because	55	* Each caller tries to arm the hrtimer on its own CPU, but if the
59	* hrtimer_{start/cancel} functions call into tracing,	56	* hrtimer callbback function is currently running, then
60	* calls to these functions must be bound within RCU_NONIDLE.	57	* hrtimer_start() cannot move it and the timer stays on the CPU on
		58	* which it is assigned at the moment.
		59	*
		60	* As this can be called from idle code, the hrtimer_start()
		61	* invocation has to be wrapped with RCU_NONIDLE() as
		62	* hrtimer_start() can call into tracing.
61	*/	63	*/
62	RCU_NONIDLE(	64	RCU_NONIDLE( {
63	{	65	hrtimer_start(&bctimer, expires, HRTIMER_MODE_ABS_PINNED_HARD);
64	bc_moved = hrtimer_try_to_cancel(&bctimer) >= 0;	66	/*
65	if (bc_moved) {	67	* The core tick broadcast mode expects bc->bound_on to be set
66	hrtimer_start(&bctimer, expires,	68	* correctly to prevent a CPU which has the broadcast hrtimer
67	HRTIMER_MODE_ABS_PINNED_HARD);	69	* armed from going deep idle.
68	}	70	*
69	}	71	* As tick_broadcast_lock is held, nothing can change the cpu
70	);	72	* base which was just established in hrtimer_start() above. So
71		73	* the below access is safe even without holding the hrtimer
72	if (bc_moved) {	74	* base lock.
73	/* Bind the "device" to the cpu */	75	*/
74	bc->bound_on = smp_processor_id();	76	bc->bound_on = bctimer.base->cpu_base->cpu;
75	} else if (bc->bound_on == smp_processor_id()) {	77	} );
76	hrtimer_set_expires(&bctimer, expires);
77	}
78	return 0;	78	return 0;
79	}	79	}
80		80
@@ -100,10 +100,6 @@ static enum hrtimer_restart bc_handler(struct hrtimer *t) · 19 unmodified lines
100	{	100	{
101	ce_broadcast_hrtimer.event_handler(&ce_broadcast_hrtimer);	101	ce_broadcast_hrtimer.event_handler(&ce_broadcast_hrtimer);
102		102
103	if (clockevent_state_oneshot(&ce_broadcast_hrtimer))
104	if (ce_broadcast_hrtimer.next_event != KTIME_MAX)
105	return HRTIMER_RESTART;
106
107	return HRTIMER_NORESTART;	103	return HRTIMER_NORESTART;
108	}	104	}
109		105

lib/strnlen_user.c+1−7

 #include <linux/export.h>
 #include <linux/uaccess.h>
 #include <linux/mm.h>
+#include <linux/bitops.h>
 #include <asm/word-at-a-time.h>
-/* Set bits in the first 'n' bytes when loaded from memory */
-#ifdef __LITTLE_ENDIAN
-#  define aligned_byte_mask(n) ((1ul << 8*(n))-1)
-#else
-#  define aligned_byte_mask(n) (~0xfful << (BITS_PER_LONG - 8 - 8*(n)))
-#endif
 /*
  * Do a strnlen, return length of string *with* final '\0'.
  * 'count' is the user-supplied count, while 'max' is the

lib/test_user_copy.c+130−6

@@ -31,14 +31,133 @@ · 30 unmodified lines
31	# define TEST_U64	31	# define TEST_U64
32	#endif	32	#endif
33		33
34	#define test(condition, msg) \	34	#define test(condition, msg, ...) \
35	({ \	35	({ \
36	int cond = (condition); \	36	int cond = (condition); \
37	if (cond) \	37	if (cond) \
38	pr_warn("%s\n", msg); \	38	pr_warn("[%d] " msg "\n", __LINE__, ##__VA_ARGS__); \
39	cond; \	39	cond; \
40	})	40	})
41		41
		42	static bool is_zeroed(void *from, size_t size)
		43	{
		44	return memchr_inv(from, 0x0, size) == NULL;
		45	}
		46
		47	static int test_check_nonzero_user(char kmem, char __user umem, size_t size)
		48	{
		49	int ret = 0;
		50	size_t start, end, i;
		51	size_t zero_start = size / 4;
		52	size_t zero_end = size - zero_start;
		53
		54	/*
		55	* We conduct a series of check_nonzero_user() tests on a block of memory
		56	* with the following byte-pattern (trying every possible [start,end]
		57	* pair):
		58	*
		59	* [ 00 ff 00 ff ... 00 00 00 00 ... ff 00 ff 00 ]
		60	*
		61	* And we verify that check_nonzero_user() acts identically to memchr_inv().
		62	*/
		63
		64	memset(kmem, 0x0, size);
		65	for (i = 1; i < zero_start; i += 2)
		66	kmem[i] = 0xff;
		67	for (i = zero_end; i < size; i += 2)
		68	kmem[i] = 0xff;
		69
		70	ret \|= test(copy_to_user(umem, kmem, size),
		71	"legitimate copy_to_user failed");
		72
		73	for (start = 0; start <= size; start++) {
		74	for (end = start; end <= size; end++) {
		75	size_t len = end - start;
		76	int retval = check_zeroed_user(umem + start, len);
		77	int expected = is_zeroed(kmem + start, len);
		78
		79	ret \|= test(retval != expected,
		80	"check_nonzero_user(=%d) != memchr_inv(=%d) mismatch (start=%zu, end=%zu)",
		81	retval, expected, start, end);
		82	}
		83	}
		84
		85	return ret;
		86	}
		87
		88	static int test_copy_struct_from_user(char kmem, char __user umem,
		89	size_t size)
		90	{
		91	int ret = 0;
		92	char umem_src = NULL, expected = NULL;
		93	size_t ksize, usize;
		94
		95	umem_src = kmalloc(size, GFP_KERNEL);
		96	if ((ret \|= test(umem_src == NULL, "kmalloc failed")))
		97	goto out_free;
		98
		99	expected = kmalloc(size, GFP_KERNEL);
		100	if ((ret \|= test(expected == NULL, "kmalloc failed")))
		101	goto out_free;
		102
		103	/* Fill umem with a fixed byte pattern. */
		104	memset(umem_src, 0x3e, size);
		105	ret \|= test(copy_to_user(umem, umem_src, size),
		106	"legitimate copy_to_user failed");
		107
		108	/* Check basic case -- (usize == ksize). */
		109	ksize = size;
		110	usize = size;
		111
		112	memcpy(expected, umem_src, ksize);
		113
		114	memset(kmem, 0x0, size);
		115	ret \|= test(copy_struct_from_user(kmem, ksize, umem, usize),
		116	"copy_struct_from_user(usize == ksize) failed");
		117	ret \|= test(memcmp(kmem, expected, ksize),
		118	"copy_struct_from_user(usize == ksize) gives unexpected copy");
		119
		120	/* Old userspace case -- (usize < ksize). */
		121	ksize = size;
		122	usize = size / 2;
		123
		124	memcpy(expected, umem_src, usize);
		125	memset(expected + usize, 0x0, ksize - usize);
		126
		127	memset(kmem, 0x0, size);
		128	ret \|= test(copy_struct_from_user(kmem, ksize, umem, usize),
		129	"copy_struct_from_user(usize < ksize) failed");
		130	ret \|= test(memcmp(kmem, expected, ksize),
		131	"copy_struct_from_user(usize < ksize) gives unexpected copy");
		132
		133	/* New userspace (-E2BIG) case -- (usize > ksize). */
		134	ksize = size / 2;
		135	usize = size;
		136
		137	memset(kmem, 0x0, size);
		138	ret \|= test(copy_struct_from_user(kmem, ksize, umem, usize) != -E2BIG,
		139	"copy_struct_from_user(usize > ksize) didn't give E2BIG");
		140
		141	/* New userspace (success) case -- (usize > ksize). */
		142	ksize = size / 2;
		143	usize = size;
		144
		145	memcpy(expected, umem_src, ksize);
		146	ret \|= test(clear_user(umem + ksize, usize - ksize),
		147	"legitimate clear_user failed");
		148
		149	memset(kmem, 0x0, size);
		150	ret \|= test(copy_struct_from_user(kmem, ksize, umem, usize),
		151	"copy_struct_from_user(usize > ksize) failed");
		152	ret \|= test(memcmp(kmem, expected, ksize),
		153	"copy_struct_from_user(usize > ksize) gives unexpected copy");
		154
		155	out_free:
		156	kfree(expected);
		157	kfree(umem_src);
		158	return ret;
		159	}
		160
42	static int __init test_user_copy_init(void)	161	static int __init test_user_copy_init(void)
43	{	162	{
44	int ret = 0;	163	int ret = 0;
@@ -106,6 +225,11 @@ static int __init test_user_copy_init(void) · 61 unmodified lines
106	#endif	225	#endif
107	#undef test_legit	226	#undef test_legit
108		227
		228	/* Test usage of check_nonzero_user(). */
		229	ret \|= test_check_nonzero_user(kmem, usermem, 2 * PAGE_SIZE);
		230	/* Test usage of copy_struct_from_user(). */
		231	ret \|= test_copy_struct_from_user(kmem, usermem, 2 * PAGE_SIZE);
		232
109	/*	233	/*
110	* Invalid usage: none of these copies should succeed.	234	* Invalid usage: none of these copies should succeed.
111	*/	235	*/

lib/textsearch.c+2−2

@@ -89,9 +89,9 @@ · 88 unmodified lines
89	* goto errout;	89	* goto errout;
90	* }	90	* }
91	*	91	*
92	* pos = textsearch_find_continuous(conf, \&state, example, strlen(example));	92	* pos = textsearch_find_continuous(conf, &state, example, strlen(example));
93	* if (pos != UINT_MAX)	93	* if (pos != UINT_MAX)
94	* panic("Oh my god, dancing chickens at \%d\n", pos);	94	* panic("Oh my god, dancing chickens at %d\n", pos);
95	*	95	*
96	* textsearch_destroy(conf);	96	* textsearch_destroy(conf);
97	*/	97	*/

lib/usercopy.c+55−0

@@ -1,5 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	#include <linux/uaccess.h>	2	#include <linux/uaccess.h>
		3	#include <linux/bitops.h>
3		4
4	/* out-of-line parts */	5	/* out-of-line parts */
5		6
@@ -31,3 +32,57 @@ unsigned long _copy_to_user(void __user to, const void from, unsigned long n) · 25 unmodified lines
31	}	32	}
32	EXPORT_SYMBOL(_copy_to_user);	33	EXPORT_SYMBOL(_copy_to_user);
33	#endif	34	#endif
		35
		36	/**
		37	* check_zeroed_user: check if a userspace buffer only contains zero bytes
		38	* @from: Source address, in userspace.
		39	* @size: Size of buffer.
		40	*
		41	* This is effectively shorthand for "memchr_inv(from, 0, size) == NULL" for
		42	* userspace addresses (and is more efficient because we don't care where the
		43	* first non-zero byte is).
		44	*
		45	* Returns:
		46	* * 0: There were non-zero bytes present in the buffer.
		47	* * 1: The buffer was full of zero bytes.
		48	* * -EFAULT: access to userspace failed.
		49	*/
		50	int check_zeroed_user(const void __user *from, size_t size)
		51	{
		52	unsigned long val;
		53	uintptr_t align = (uintptr_t) from % sizeof(unsigned long);
		54
		55	if (unlikely(size == 0))
		56	return 1;
		57
		58	from -= align;
		59	size += align;
		60
		61	if (!user_access_begin(from, size))
		62	return -EFAULT;
		63
		64	unsafe_get_user(val, (unsigned long __user *) from, err_fault);
		65	if (align)
		66	val &= ~aligned_byte_mask(align);
		67
		68	while (size > sizeof(unsigned long)) {
		69	if (unlikely(val))
		70	goto done;
		71
		72	from += sizeof(unsigned long);
		73	size -= sizeof(unsigned long);
		74
		75	unsafe_get_user(val, (unsigned long __user *) from, err_fault);
		76	}
		77
		78	if (size < sizeof(unsigned long))
		79	val &= aligned_byte_mask(size);
		80
		81	done:
		82	user_access_end();
		83	return (val == 0);
		84	err_fault:
		85	user_access_end();
		86	return -EFAULT;
		87	}
		88	EXPORT_SYMBOL(check_zeroed_user);

net/batman-adv/soft-interface.c+1−1

@@ -436,7 +436,7 @@ void batadv_interface_rx(struct net_device *soft_iface, · 435 unmodified lines
436	/* clean the netfilter state now that the batman-adv header has been	436	/* clean the netfilter state now that the batman-adv header has been
437	* removed	437	* removed
438	*/	438	*/
439	nf_reset(skb);	439	nf_reset_ct(skb);
440		440
441	if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))	441	if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
442	goto dropped;	442	goto dropped;

net/core/devlink.c+3−3

@@ -3172,7 +3172,7 @@ static int devlink_nl_cmd_param_get_dumpit(struct sk_buff *msg, · 3171 unmodified lines
3172	NETLINK_CB(cb->skb).portid,	3172	NETLINK_CB(cb->skb).portid,
3173	cb->nlh->nlmsg_seq,	3173	cb->nlh->nlmsg_seq,
3174	NLM_F_MULTI);	3174	NLM_F_MULTI);
3175	if (err) {	3175	if (err && err != -EOPNOTSUPP) {
3176	mutex_unlock(&devlink->lock);	3176	mutex_unlock(&devlink->lock);
3177	goto out;	3177	goto out;
3178	}	3178	}
@@ -3432,7 +3432,7 @@ static int devlink_nl_cmd_port_param_get_dumpit(struct sk_buff *msg, · 253 unmodified lines
3432	NETLINK_CB(cb->skb).portid,	3432	NETLINK_CB(cb->skb).portid,
3433	cb->nlh->nlmsg_seq,	3433	cb->nlh->nlmsg_seq,
3434	NLM_F_MULTI);	3434	NLM_F_MULTI);
3435	if (err) {	3435	if (err && err != -EOPNOTSUPP) {
3436	mutex_unlock(&devlink->lock);	3436	mutex_unlock(&devlink->lock);
3437	goto out;	3437	goto out;
3438	}	3438	}
@@ -4088,7 +4088,7 @@ static int devlink_nl_cmd_info_get_dumpit(struct sk_buff *msg, · 649 unmodified lines
4088	cb->nlh->nlmsg_seq, NLM_F_MULTI,	4088	cb->nlh->nlmsg_seq, NLM_F_MULTI,
4089	cb->extack);	4089	cb->extack);
4090	mutex_unlock(&devlink->lock);	4090	mutex_unlock(&devlink->lock);
4091	if (err)	4091	if (err && err != -EOPNOTSUPP)
4092	break;	4092	break;
4093	idx++;	4093	idx++;
4094	}	4094	}

net/core/skbuff.c+1−1

@@ -5120,7 +5120,7 @@ void skb_scrub_packet(struct sk_buff *skb, bool xnet) · 5119 unmodified lines
5120	skb->ignore_df = 0;	5120	skb->ignore_df = 0;
5121	skb_dst_drop(skb);	5121	skb_dst_drop(skb);
5122	skb_ext_reset(skb);	5122	skb_ext_reset(skb);
5123	nf_reset(skb);	5123	nf_reset_ct(skb);
5124	nf_reset_trace(skb);	5124	nf_reset_trace(skb);
5125		5125
5126	#ifdef CONFIG_NET_SWITCHDEV	5126	#ifdef CONFIG_NET_SWITCHDEV

net/core/sock.c+9−4

 		sk_filter_uncharge(sk, filter);
 		RCU_INIT_POINTER(sk->sk_filter, NULL);
 	}
-	if (rcu_access_pointer(sk->sk_reuseport_cb))
-		reuseport_detach_sock(sk);
 	sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
 void sk_destruct(struct sock *sk)
 {
-	if (sock_flag(sk, SOCK_RCU_FREE))
+	bool use_call_rcu = sock_flag(sk, SOCK_RCU_FREE);
+	if (rcu_access_pointer(sk->sk_reuseport_cb)) {
+		reuseport_detach_sock(sk);
+		use_call_rcu = true;
+	}
+	if (use_call_rcu)
 		call_rcu(&sk->sk_rcu, __sk_destruct);
 	else
 		__sk_destruct(&sk->sk_rcu);
 	return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
 }
-static char *sock_prot_memory_pressure(struct proto *proto)
+static const char *sock_prot_memory_pressure(struct proto *proto)
 {
 	return proto->memory_pressure != NULL ?
 	proto_memory_pressure(proto) ? "yes" : "no" : "NI";

net/dccp/ipv4.c+1−1

@@ -871,7 +871,7 @@ lookup: · 870 unmodified lines
871		871
872	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))	872	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
873	goto discard_and_relse;	873	goto discard_and_relse;
874	nf_reset(skb);	874	nf_reset_ct(skb);
875		875
876	return __sk_receive_skb(sk, skb, 1, dh->dccph_doff * 4, refcounted);	876	return __sk_receive_skb(sk, skb, 1, dh->dccph_doff * 4, refcounted);
877		877

net/dsa/tag_sja1105.c+11−1

 	/* Step 1: A timestampable frame was received.
 	 * Buffer it until we get its meta frame.
 	 */
-	if (is_link_local && sp->data->hwts_rx_en) {
+	if (is_link_local) {
+		if (!test_bit(SJA1105_HWTS_RX_EN, &sp->data->state))
+			/* Do normal processing. */
+			return skb;
 		spin_lock(&sp->data->meta_lock);
 		/* Was this a link-local frame instead of the meta
 		 * that we were expecting?
 	} else if (is_meta) {
 		struct sk_buff *stampable_skb;
+		/* Drop the meta frame if we're not in the right state
+		 * to process it.
+		 */
+		if (!test_bit(SJA1105_HWTS_RX_EN, &sp->data->state))
+			return NULL;
 		spin_lock(&sp->data->meta_lock);
 		stampable_skb = sp->data->stampable_skb;

net/ipv4/ip_gre.c+1−0

@@ -1446,6 +1446,7 @@ static void erspan_setup(struct net_device *dev) · 1445 unmodified lines
1446	struct ip_tunnel *t = netdev_priv(dev);	1446	struct ip_tunnel *t = netdev_priv(dev);
1447		1447
1448	ether_setup(dev);	1448	ether_setup(dev);
		1449	dev->max_mtu = 0;
1449	dev->netdev_ops = &erspan_netdev_ops;	1450	dev->netdev_ops = &erspan_netdev_ops;
1450	dev->priv_flags &= ~IFF_TX_SKB_SHARING;	1451	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1451	dev->priv_flags \|= IFF_LIVE_ADDR_CHANGE;	1452	dev->priv_flags \|= IFF_LIVE_ADDR_CHANGE;

net/ipv4/ip_input.c+1−1

@@ -199,7 +199,7 @@ resubmit: · 198 unmodified lines
199	kfree_skb(skb);	199	kfree_skb(skb);
200	return;	200	return;
201	}	201	}
202	nf_reset(skb);	202	nf_reset_ct(skb);
203	}	203	}
204	ret = INDIRECT_CALL_2(ipprot->handler, tcp_v4_rcv, udp_rcv,	204	ret = INDIRECT_CALL_2(ipprot->handler, tcp_v4_rcv, udp_rcv,
205	skb);	205	skb);

net/ipv4/ipmr.c+2−2

@@ -1794,7 +1794,7 @@ static void ip_encap(struct net net, struct sk_buff skb, · 1793 unmodified lines
1794	ip_send_check(iph);	1794	ip_send_check(iph);
1795		1795
1796	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));	1796	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1797	nf_reset(skb);	1797	nf_reset_ct(skb);
1798	}	1798	}
1799		1799
1800	static inline int ipmr_forward_finish(struct net net, struct sock sk,	1800	static inline int ipmr_forward_finish(struct net net, struct sock sk,
@@ -2140,7 +2140,7 @@ int ip_mr_input(struct sk_buff *skb) · 339 unmodified lines
2140		2140
2141	mroute_sk = rcu_dereference(mrt->mroute_sk);	2141	mroute_sk = rcu_dereference(mrt->mroute_sk);
2142	if (mroute_sk) {	2142	if (mroute_sk) {
2143	nf_reset(skb);	2143	nf_reset_ct(skb);
2144	raw_rcv(mroute_sk, skb);	2144	raw_rcv(mroute_sk, skb);
2145	return 0;	2145	return 0;
2146	}	2146	}

net/ipv4/netfilter/nf_dup_ipv4.c+1−1

@@ -65,7 +65,7 @@ void nf_dup_ipv4(struct net net, struct sk_buff skb, unsigned int hooknum, · 64 unmodified lines
65		65
66	#if IS_ENABLED(CONFIG_NF_CONNTRACK)	66	#if IS_ENABLED(CONFIG_NF_CONNTRACK)
67	/* Avoid counting cloned packets towards the original connection. */	67	/* Avoid counting cloned packets towards the original connection. */
68	nf_reset(skb);	68	nf_reset_ct(skb);
69	nf_ct_set(skb, NULL, IP_CT_UNTRACKED);	69	nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
70	#endif	70	#endif
71	/*	71	/*

net/ipv4/raw.c+1−1

@@ -332,7 +332,7 @@ int raw_rcv(struct sock sk, struct sk_buff skb) · 331 unmodified lines
332	kfree_skb(skb);	332	kfree_skb(skb);
333	return NET_RX_DROP;	333	return NET_RX_DROP;
334	}	334	}
335	nf_reset(skb);	335	nf_reset_ct(skb);
336		336
337	skb_push(skb, skb->data - skb_network_header(skb));	337	skb_push(skb, skb->data - skb_network_header(skb));
338		338

net/ipv4/route.c+2−3

 	if (peer->rate_tokens == 0 ||
 	    time_after(jiffies,
 		       (peer->rate_last +
-			(ip_rt_redirect_load << peer->rate_tokens)))) {
+			(ip_rt_redirect_load << peer->n_redirects)))) {
 		__be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
 		icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
 		peer->rate_last = jiffies;
-		++peer->rate_tokens;
 		++peer->n_redirects;
 #ifdef CONFIG_IP_ROUTE_VERBOSE
 		if (log_martians &&
-		    peer->rate_tokens == ip_rt_redirect_number)
+		    peer->n_redirects == ip_rt_redirect_number)
 			net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
 					     &ip_hdr(skb)->saddr, inet_iif(skb),
 					     &ip_hdr(skb)->daddr, &gw);

net/ipv4/tcp.c+2−4

 		}
 		if (skb_frag_size(frags) != PAGE_SIZE || skb_frag_off(frags)) {
 			int remaining = zc->recv_skip_hint;
-			int size = skb_frag_size(frags);
-			while (remaining && (size != PAGE_SIZE ||
+			while (remaining && (skb_frag_size(frags) != PAGE_SIZE ||
 					     skb_frag_off(frags))) {
-				remaining -= size;
+				remaining -= skb_frag_size(frags);
 				frags++;
-				size = skb_frag_size(frags);
 			}
 			zc->recv_skip_hint -= remaining;
 			break;

net/ipv4/tcp_ipv4.c+1−1

@@ -1916,7 +1916,7 @@ process: · 1915 unmodified lines
1916	if (tcp_v4_inbound_md5_hash(sk, skb))	1916	if (tcp_v4_inbound_md5_hash(sk, skb))
1917	goto discard_and_relse;	1917	goto discard_and_relse;
1918		1918
1919	nf_reset(skb);	1919	nf_reset_ct(skb);
1920		1920
1921	if (tcp_filter(sk, skb))	1921	if (tcp_filter(sk, skb))
1922	goto discard_and_relse;	1922	goto discard_and_relse;

net/ipv4/tcp_timer.c+7−2

 		return false;
 	start_ts = tcp_sk(sk)->retrans_stamp;
-	if (likely(timeout == 0))
+	if (likely(timeout == 0)) {
-		timeout = tcp_model_timeout(sk, boundary, TCP_RTO_MIN);
+		unsigned int rto_base = TCP_RTO_MIN;
+		if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
+			rto_base = tcp_timeout_init(sk);
+		timeout = tcp_model_timeout(sk, boundary, rto_base);
+	}
 	return (s32)(tcp_time_stamp(tcp_sk(sk)) - start_ts - timeout) >= 0;
 }

net/ipv4/udp.c+9−6

 	int is_udplite = IS_UDPLITE(sk);
 	int offset = skb_transport_offset(skb);
 	int len = skb->len - offset;
+	int datalen = len - sizeof(*uh);
 	__wsum csum = 0;
 	/*
 			return -EIO;
 		}
-		skb_shinfo(skb)->gso_size = cork->gso_size;
+		if (datalen > cork->gso_size) {
-		skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
+			skb_shinfo(skb)->gso_size = cork->gso_size;
-		skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(len - sizeof(uh),
+			skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
-							 cork->gso_size);
+			skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen,
+								 cork->gso_size);
+		}
 		goto csum_partial;
 	}
 	 */
 	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
 		goto drop;
-	nf_reset(skb);
+	nf_reset_ct(skb);
 	if (static_branch_unlikely(&udp_encap_needed_key) && up->encap_type) {
 		int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);
 	if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
 		goto drop;
-	nf_reset(skb);
+	nf_reset_ct(skb);
 	/* No socket. Drop packet silently, if checksum is wrong */
 	if (udp_lib_checksum_complete(skb))

net/ipv6/addrconf.c+12−5

 	switch (event) {
 	case RTM_NEWADDR:
 		/*
-		 * If the address was optimistic
+		 * If the address was optimistic we inserted the route at the
-		 * we inserted the route at the start of
+		 * start of our DAD process, so we don't need to do it again.
-		 * our DAD process, so we don't need
+		 * If the device was taken down in the middle of the DAD
-		 * to do it again
+		 * cycle there is a race where we could get here without a
+		 * host route, so nothing to insert. That will be fixed when
+		 * the device is brought up.
 		 */
-		if (!rcu_access_pointer(ifp->rt->fib6_node))
+		if (ifp->rt && !rcu_access_pointer(ifp->rt->fib6_node)) {
 			ip6_ins_rt(net, ifp->rt);
+		} else if (!ifp->rt && (ifp->idev->dev->flags & IFF_UP)) {
+			pr_warn("BUG: Address %pI6c on device %s is missing its host route.\n",
+				&ifp->addr, ifp->idev->dev->name);
+		}
 		if (ifp->idev->cnf.forwarding)
 			addrconf_join_anycast(ifp);
 		if (!ipv6_addr_any(&ifp->peer_addr))

net/ipv6/ip6_input.c+11−1

 	if (ipv6_addr_is_multicast(&hdr->saddr))
 		goto err;
+	/* While RFC4291 is not explicit about v4mapped addresses
+	 * in IPv6 headers, it seems clear linux dual-stack
+	 * model can not deal properly with these.
+	 * Security models could be fooled by ::ffff:127.0.0.1 for example.
+	 *
+	 * https://tools.ietf.org/html/draft-itojun-v6ops-v4mapped-harmful-02
+	 */
+	if (ipv6_addr_v4mapped(&hdr->saddr))
+		goto err;
 	skb->transport_header = skb->network_header + sizeof(*hdr);
 	IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr);
 			/* Free reference early: we don't need it any more,
 			   and it may hold ip_conntrack module loaded
 			   indefinitely. */
-			nf_reset(skb);
+			nf_reset_ct(skb);
 			skb_postpull_rcsum(skb, skb_network_header(skb),
 					   skb_network_header_len(skb));

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

@@ -54,7 +54,7 @@ void nf_dup_ipv6(struct net net, struct sk_buff skb, unsigned int hooknum, · 53 unmodified lines
54	return;	54	return;
55		55
56	#if IS_ENABLED(CONFIG_NF_CONNTRACK)	56	#if IS_ENABLED(CONFIG_NF_CONNTRACK)
57	nf_reset(skb);	57	nf_reset_ct(skb);
58	nf_ct_set(skb, NULL, IP_CT_UNTRACKED);	58	nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
59	#endif	59	#endif
60	if (hooknum == NF_INET_PRE_ROUTING \|\|	60	if (hooknum == NF_INET_PRE_ROUTING \|\|

net/ipv6/raw.c+1−1

@@ -215,7 +215,7 @@ static bool ipv6_raw_deliver(struct sk_buff *skb, int nexthdr) · 214 unmodified lines
215		215
216	/* Not releasing hash table! */	216	/* Not releasing hash table! */
217	if (clone) {	217	if (clone) {
218	nf_reset(clone);	218	nf_reset_ct(clone);
219	rawv6_rcv(sk, clone);	219	rawv6_rcv(sk, clone);
220	}	220	}
221	}	221	}

net/ipv6/udp.c+7−2

 	__wsum csum = 0;
 	int offset = skb_transport_offset(skb);
 	int len = skb->len - offset;
+	int datalen = len - sizeof(*uh);
 	/*
 	 * Create a UDP header
 			return -EIO;
 		}
-		skb_shinfo(skb)->gso_size = cork->gso_size;
+		if (datalen > cork->gso_size) {
-		skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
+			skb_shinfo(skb)->gso_size = cork->gso_size;
+			skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
+			skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen,
+								 cork->gso_size);
+		}
 		goto csum_partial;
 	}

net/l2tp/l2tp_core.c+1−1

@@ -1078,7 +1078,7 @@ int l2tp_xmit_skb(struct l2tp_session session, struct sk_buff skb, int hdr_len · 1077 unmodified lines
1078	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));	1078	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1079	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE \| IPSKB_XFRM_TRANSFORMED \|	1079	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE \| IPSKB_XFRM_TRANSFORMED \|
1080	IPSKB_REROUTED);	1080	IPSKB_REROUTED);
1081	nf_reset(skb);	1081	nf_reset_ct(skb);
1082		1082
1083	bh_lock_sock(sk);	1083	bh_lock_sock(sk);
1084	if (sock_owned_by_user(sk)) {	1084	if (sock_owned_by_user(sk)) {

net/l2tp/l2tp_eth.c+1−1

@@ -151,7 +151,7 @@ static void l2tp_eth_dev_recv(struct l2tp_session session, struct sk_buff skb, · 150 unmodified lines
151	skb->ip_summed = CHECKSUM_NONE;	151	skb->ip_summed = CHECKSUM_NONE;
152		152
153	skb_dst_drop(skb);	153	skb_dst_drop(skb);
154	nf_reset(skb);	154	nf_reset_ct(skb);
155		155
156	rcu_read_lock();	156	rcu_read_lock();
157	dev = rcu_dereference(spriv->dev);	157	dev = rcu_dereference(spriv->dev);

net/l2tp/l2tp_ip.c+1−1

@@ -193,7 +193,7 @@ pass_up: · 192 unmodified lines
193	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))	193	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
194	goto discard_put;	194	goto discard_put;
195		195
196	nf_reset(skb);	196	nf_reset_ct(skb);
197		197
198	return sk_receive_skb(sk, skb, 1);	198	return sk_receive_skb(sk, skb, 1);
199		199

net/l2tp/l2tp_ip6.c+1−1

@@ -206,7 +206,7 @@ pass_up: · 205 unmodified lines
206	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))	206	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
207	goto discard_put;	207	goto discard_put;
208		208
209	nf_reset(skb);	209	nf_reset_ct(skb);
210		210
211	return sk_receive_skb(sk, skb, 1);	211	return sk_receive_skb(sk, skb, 1);
212		212

net/mac80211/debugfs_netdev.c+9−2

 	const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 {
 	struct ieee80211_local *local = sdata->local;
-	struct txq_info *txqi = to_txq_info(sdata->vif.txq);
+	struct txq_info *txqi;
 	int len;
+	if (!sdata->vif.txq)
+		return 0;
+	txqi = to_txq_info(sdata->vif.txq);
 	spin_lock_bh(&local->fq.lock);
 	rcu_read_lock();
 	DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_5ghz);
 	DEBUGFS_ADD(hw_queues);
-	if (sdata->local->ops->wake_tx_queue)
+	if (sdata->local->ops->wake_tx_queue &&
+	    sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
+	    sdata->vif.type != NL80211_IFTYPE_NAN)
 		DEBUGFS_ADD(aqm);
 }

net/mac80211/util.c+8−5

 	struct sta_info *sta;
 	int i;
-	spin_lock_bh(&fq->lock);
+	local_bh_disable();
+	spin_lock(&fq->lock);
 	if (sdata->vif.type == NL80211_IFTYPE_AP)
 		ps = &sdata->bss->ps;
 						&txqi->flags))
 				continue;
-			spin_unlock_bh(&fq->lock);
+			spin_unlock(&fq->lock);
 			drv_wake_tx_queue(local, txqi);
-			spin_lock_bh(&fq->lock);
+			spin_lock(&fq->lock);
 		}
 	}
 	    (ps && atomic_read(&ps->num_sta_ps)) || ac != vif->txq->ac)
 		goto out;
-	spin_unlock_bh(&fq->lock);
+	spin_unlock(&fq->lock);
 	drv_wake_tx_queue(local, txqi);
+	local_bh_enable();
 	return;
 out:
-	spin_unlock_bh(&fq->lock);
+	spin_unlock(&fq->lock);
+	local_bh_enable();
 }
 static void

net/netfilter/ipvs/ip_vs_xmit.c+1−1

@@ -613,7 +613,7 @@ static inline int ip_vs_tunnel_xmit_prepare(struct sk_buff *skb, · 612 unmodified lines
613	if (unlikely(cp->flags & IP_VS_CONN_F_NFCT))	613	if (unlikely(cp->flags & IP_VS_CONN_F_NFCT))
614	ret = ip_vs_confirm_conntrack(skb);	614	ret = ip_vs_confirm_conntrack(skb);
615	if (ret == NF_ACCEPT) {	615	if (ret == NF_ACCEPT) {
616	nf_reset(skb);	616	nf_reset_ct(skb);
617	skb_forward_csum(skb);	617	skb_forward_csum(skb);
618	}	618	}
619	return ret;	619	return ret;

net/netfilter/nft_connlimit.c+6−1

 static bool nft_connlimit_gc(struct net *net, const struct nft_expr *expr)
 {
 	struct nft_connlimit *priv = nft_expr_priv(expr);
+	bool ret;
-	return nf_conncount_gc_list(net, &priv->list);
+	local_bh_disable();
+	ret = nf_conncount_gc_list(net, &priv->list);
+	local_bh_enable();
+	return ret;
 }
 static struct nft_expr_type nft_connlimit_type;

net/nfc/llcp_sock.c+6−1

@@ -107,9 +107,14 @@ static int llcp_sock_bind(struct socket sock, struct sockaddr addr, int alen) · 106 unmodified lines
107	llcp_sock->service_name = kmemdup(llcp_addr.service_name,	107	llcp_sock->service_name = kmemdup(llcp_addr.service_name,
108	llcp_sock->service_name_len,	108	llcp_sock->service_name_len,
109	GFP_KERNEL);	109	GFP_KERNEL);
110		110	if (!llcp_sock->service_name) {
		111	ret = -ENOMEM;
		112	goto put_dev;
		113	}
111	llcp_sock->ssap = nfc_llcp_get_sdp_ssap(local, llcp_sock);	114	llcp_sock->ssap = nfc_llcp_get_sdp_ssap(local, llcp_sock);
112	if (llcp_sock->ssap == LLCP_SAP_MAX) {	115	if (llcp_sock->ssap == LLCP_SAP_MAX) {
		116	kfree(llcp_sock->service_name);
		117	llcp_sock->service_name = NULL;
113	ret = -EADDRINUSE;	118	ret = -EADDRINUSE;
114	goto put_dev;	119	goto put_dev;
115	}	120	}

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

@@ -237,7 +237,7 @@ static netdev_tx_t internal_dev_recv(struct sk_buff *skb) · 236 unmodified lines
237	}	237	}
238		238
239	skb_dst_drop(skb);	239	skb_dst_drop(skb);
240	nf_reset(skb);	240	nf_reset_ct(skb);
241	secpath_reset(skb);	241	secpath_reset(skb);
242		242
243	skb->pkt_type = PACKET_HOST;	243	skb->pkt_type = PACKET_HOST;

net/packet/af_packet.c+2−2

@@ -1821,7 +1821,7 @@ static int packet_rcv_spkt(struct sk_buff skb, struct net_device dev, · 1820 unmodified lines
1821	skb_dst_drop(skb);	1821	skb_dst_drop(skb);
1822		1822
1823	/* drop conntrack reference */	1823	/* drop conntrack reference */
1824	nf_reset(skb);	1824	nf_reset_ct(skb);
1825		1825
1826	spkt = &PACKET_SKB_CB(skb)->sa.pkt;	1826	spkt = &PACKET_SKB_CB(skb)->sa.pkt;
1827		1827
@@ -2121,7 +2121,7 @@ static int packet_rcv(struct sk_buff skb, struct net_device dev, · 293 unmodified lines
2121	skb_dst_drop(skb);	2121	skb_dst_drop(skb);
2122		2122
2123	/* drop conntrack reference */	2123	/* drop conntrack reference */
2124	nf_reset(skb);	2124	nf_reset_ct(skb);
2125		2125
2126	spin_lock(&sk->sk_receive_queue.lock);	2126	spin_lock(&sk->sk_receive_queue.lock);
2127	po->stats.stats1.tp_packets++;	2127	po->stats.stats1.tp_packets++;

net/rds/ib.c+3−3

 	refcount_set(&rds_ibdev->refcount, 1);
 	INIT_WORK(&rds_ibdev->free_work, rds_ib_dev_free);
+	INIT_LIST_HEAD(&rds_ibdev->ipaddr_list);
+	INIT_LIST_HEAD(&rds_ibdev->conn_list);
 	rds_ibdev->max_wrs = device->attrs.max_qp_wr;
 	rds_ibdev->max_sge = min(device->attrs.max_send_sge, RDS_IB_MAX_SGE);
 		device->name,
 		rds_ibdev->use_fastreg ? "FRMR" : "FMR");
-	INIT_LIST_HEAD(&rds_ibdev->ipaddr_list);
-	INIT_LIST_HEAD(&rds_ibdev->conn_list);
 	down_write(&rds_ib_devices_lock);
 	list_add_tail_rcu(&rds_ibdev->list, &rds_ib_devices);
 	up_write(&rds_ib_devices_lock);

net/sched/sch_cbq.c+29−14

 	[TCA_CBQ_POLICE]	= { .len = sizeof(struct tc_cbq_police) },
 };
+static int cbq_opt_parse(struct nlattr *tb[TCA_CBQ_MAX + 1],
+			 struct nlattr *opt,
+			 struct netlink_ext_ack *extack)
+{
+	int err;
+	if (!opt) {
+		NL_SET_ERR_MSG(extack, "CBQ options are required for this operation");
+		return -EINVAL;
+	}
+	err = nla_parse_nested_deprecated(tb, TCA_CBQ_MAX, opt,
+					  cbq_policy, extack);
+	if (err < 0)
+		return err;
+	if (tb[TCA_CBQ_WRROPT]) {
+		const struct tc_cbq_wrropt *wrr = nla_data(tb[TCA_CBQ_WRROPT]);
+		if (wrr->priority > TC_CBQ_MAXPRIO) {
+			NL_SET_ERR_MSG(extack, "priority is bigger than TC_CBQ_MAXPRIO");
+			err = -EINVAL;
+		}
+	}
+	return err;
+}
 static int cbq_init(struct Qdisc *sch, struct nlattr *opt,
 		    struct netlink_ext_ack *extack)
 {
 	hrtimer_init(&q->delay_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
 	q->delay_timer.function = cbq_undelay;
-	if (!opt) {
+	err = cbq_opt_parse(tb, opt, extack);
-		NL_SET_ERR_MSG(extack, "CBQ options are required for this operation");
-		return -EINVAL;
-	}
-	err = nla_parse_nested_deprecated(tb, TCA_CBQ_MAX, opt, cbq_policy,
-					  extack);
 	if (err < 0)
 		return err;
 	struct cbq_class *parent;
 	struct qdisc_rate_table *rtab = NULL;
-	if (!opt) {
+	err = cbq_opt_parse(tb, opt, extack);
-		NL_SET_ERR_MSG(extack, "Mandatory qdisc options missing");
-		return -EINVAL;
-	}
-	err = nla_parse_nested_deprecated(tb, TCA_CBQ_MAX, opt, cbq_policy,
-					  extack);
 	if (err < 0)
 		return err;

net/sched/sch_cbs.c+1−1

@@ -306,7 +306,7 @@ static void cbs_set_port_rate(struct net_device dev, struct cbs_sched_data q) · 305 unmodified lines
306	if (err < 0)	306	if (err < 0)
307	goto skip;	307	goto skip;
308		308
309	if (ecmd.base.speed != SPEED_UNKNOWN)	309	if (ecmd.base.speed && ecmd.base.speed != SPEED_UNKNOWN)
310	speed = ecmd.base.speed;	310	speed = ecmd.base.speed;
311		311
312	skip:	312	skip:

net/sched/sch_dsmark.c+2−0

@@ -361,6 +361,8 @@ static int dsmark_init(struct Qdisc sch, struct nlattr opt, · 360 unmodified lines
361	goto errout;	361	goto errout;
362		362
363	err = -EINVAL;	363	err = -EINVAL;
		364	if (!tb[TCA_DSMARK_INDICES])
		365	goto errout;
364	indices = nla_get_u16(tb[TCA_DSMARK_INDICES]);	366	indices = nla_get_u16(tb[TCA_DSMARK_INDICES]);
365		367
366	if (hweight32(indices) != 1)	368	if (hweight32(indices) != 1)

net/sched/sch_taprio.c+2−3

 	if (err < 0)
 		goto skip;
-	if (ecmd.base.speed != SPEED_UNKNOWN)
+	if (ecmd.base.speed && ecmd.base.speed != SPEED_UNKNOWN)
 		speed = ecmd.base.speed;
 skip:
-	picos_per_byte = div64_s64(NSEC_PER_SEC * 1000LL * 8,
+	picos_per_byte = (USEC_PER_SEC * 8) / speed;
-				   speed * 1000 * 1000);
 	atomic64_set(&q->picos_per_byte, picos_per_byte);
 	netdev_dbg(dev, "taprio: set %s's picos_per_byte to: %lld, linkspeed: %d\n",

net/sctp/input.c+1−1

@@ -201,7 +201,7 @@ int sctp_rcv(struct sk_buff *skb) · 200 unmodified lines
201		201
202	if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))	202	if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))
203	goto discard_release;	203	goto discard_release;
204	nf_reset(skb);	204	nf_reset_ct(skb);
205		205
206	if (sk_filter(sk, skb))	206	if (sk_filter(sk, skb))
207	goto discard_release;	207	goto discard_release;

net/tipc/link.c+18−11

 	struct {
 		u16 len;
 		u16 limit;
+		struct sk_buff *target_bskb;
 	} backlog[5];
 	u16 snd_nxt;
 	u16 window;
 void tipc_link_reset(struct tipc_link *l)
 {
 	struct sk_buff_head list;
+	u32 imp;
 	__skb_queue_head_init(&list);
 	__skb_queue_purge(&l->deferdq);
 	__skb_queue_purge(&l->backlogq);
 	__skb_queue_purge(&l->failover_deferdq);
-	l->backlog[TIPC_LOW_IMPORTANCE].len = 0;
+	for (imp = 0; imp <= TIPC_SYSTEM_IMPORTANCE; imp++) {
-	l->backlog[TIPC_MEDIUM_IMPORTANCE].len = 0;
+		l->backlog[imp].len = 0;
-	l->backlog[TIPC_HIGH_IMPORTANCE].len = 0;
+		l->backlog[imp].target_bskb = NULL;
-	l->backlog[TIPC_CRITICAL_IMPORTANCE].len = 0;
+	}
-	l->backlog[TIPC_SYSTEM_IMPORTANCE].len = 0;
 	kfree_skb(l->reasm_buf);
 	kfree_skb(l->reasm_tnlmsg);
 	kfree_skb(l->failover_reasm_skb);
 	u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
 	struct sk_buff_head *transmq = &l->transmq;
 	struct sk_buff_head *backlogq = &l->backlogq;
-	struct sk_buff *skb, *_skb, *bskb;
+	struct sk_buff *skb, *_skb, **tskb;
 	int pkt_cnt = skb_queue_len(list);
 	int rc = 0;
 			seqno++;
 			continue;
 		}
-		if (tipc_msg_bundle(skb_peek_tail(backlogq), hdr, mtu)) {
+		tskb = &l->backlog[imp].target_bskb;
+		if (tipc_msg_bundle(*tskb, hdr, mtu)) {
 			kfree_skb(__skb_dequeue(list));
 			l->stats.sent_bundled++;
 			continue;
 		}
-		if (tipc_msg_make_bundle(&bskb, hdr, mtu, l->addr)) {
+		if (tipc_msg_make_bundle(tskb, hdr, mtu, l->addr)) {
 			kfree_skb(__skb_dequeue(list));
-			__skb_queue_tail(backlogq, bskb);
+			__skb_queue_tail(backlogq, *tskb);
-			l->backlog[msg_importance(buf_msg(bskb))].len++;
+			l->backlog[imp].len++;
 			l->stats.sent_bundled++;
 			l->stats.sent_bundles++;
 			continue;
 		}
+		l->backlog[imp].target_bskb = NULL;
 		l->backlog[imp].len += skb_queue_len(list);
 		skb_queue_splice_tail_init(list, backlogq);
 	}
 	u16 seqno = l->snd_nxt;
 	u16 ack = l->rcv_nxt - 1;
 	u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
+	u32 imp;
 	while (skb_queue_len(&l->transmq) < l->window) {
 		skb = skb_peek(&l->backlogq);
 			break;
 		__skb_dequeue(&l->backlogq);
 		hdr = buf_msg(skb);
-		l->backlog[msg_importance(hdr)].len--;
+		imp = msg_importance(hdr);
+		l->backlog[imp].len--;
+		if (unlikely(skb == l->backlog[imp].target_bskb))
+			l->backlog[imp].target_bskb = NULL;
 		__skb_queue_tail(&l->transmq, skb);
 		/* next retransmit attempt */
 		if (link_is_bc_sndlink(l))

net/tipc/msg.c+1−4

 	bmsg = buf_msg(_skb);
 	tipc_msg_init(msg_prevnode(msg), bmsg, MSG_BUNDLER, 0,
 		      INT_H_SIZE, dnode);
-	if (msg_isdata(msg))
+	msg_set_importance(bmsg, msg_importance(msg));
-		msg_set_importance(bmsg, TIPC_CRITICAL_IMPORTANCE);
-	else
-		msg_set_importance(bmsg, TIPC_SYSTEM_IMPORTANCE);
 	msg_set_seqno(bmsg, msg_seqno(msg));
 	msg_set_ack(bmsg, msg_ack(msg));
 	msg_set_bcast_ack(bmsg, msg_bcast_ack(msg));

net/vmw_vsock/af_vsock.c+12−4

 }
 EXPORT_SYMBOL_GPL(__vsock_create);
-static void __vsock_release(struct sock *sk)
+static void __vsock_release(struct sock *sk, int level)
 {
 	if (sk) {
 		struct sk_buff *skb;
 		vsk = vsock_sk(sk);
 		pending = NULL;	/* Compiler warning. */
+		/* The release call is supposed to use lock_sock_nested()
+		 * rather than lock_sock(), if a sock lock should be acquired.
+		 */
 		transport->release(vsk);
-		lock_sock(sk);
+		/* When "level" is SINGLE_DEPTH_NESTING, use the nested
+		 * version to avoid the warning "possible recursive locking
+		 * detected". When "level" is 0, lock_sock_nested(sk, level)
+		 * is the same as lock_sock(sk).
+		 */
+		lock_sock_nested(sk, level);
 		sock_orphan(sk);
 		sk->sk_shutdown = SHUTDOWN_MASK;
 		/* Clean up any sockets that never were accepted. */
 		while ((pending = vsock_dequeue_accept(sk)) != NULL) {
-			__vsock_release(pending);
+			__vsock_release(pending, SINGLE_DEPTH_NESTING);
 			sock_put(pending);
 		}
 static int vsock_release(struct socket *sock)
 {
-	__vsock_release(sock->sk);
+	__vsock_release(sock->sk, 0);
 	sock->sk = NULL;
 	sock->state = SS_FREE;

net/vmw_vsock/hyperv_transport.c+1−1

@@ -559,7 +559,7 @@ static void hvs_release(struct vsock_sock *vsk) · 558 unmodified lines
559	struct sock *sk = sk_vsock(vsk);	559	struct sock *sk = sk_vsock(vsk);
560	bool remove_sock;	560	bool remove_sock;
561		561
562	lock_sock(sk);	562	lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
563	remove_sock = hvs_close_lock_held(vsk);	563	remove_sock = hvs_close_lock_held(vsk);
564	release_sock(sk);	564	release_sock(sk);
565	if (remove_sock)	565	if (remove_sock)

net/vmw_vsock/virtio_transport_common.c+1−1

@@ -820,7 +820,7 @@ void virtio_transport_release(struct vsock_sock *vsk) · 819 unmodified lines
820	struct sock *sk = &vsk->sk;	820	struct sock *sk = &vsk->sk;
821	bool remove_sock = true;	821	bool remove_sock = true;
822		822
823	lock_sock(sk);	823	lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
824	if (sk->sk_type == SOCK_STREAM)	824	if (sk->sk_type == SOCK_STREAM)
825	remove_sock = virtio_transport_close(vsk);	825	remove_sock = virtio_transport_close(vsk);
826		826

net/wireless/nl80211.c+41−3

@@ -201,6 +201,38 @@ cfg80211_get_dev_from_info(struct net netns, struct genl_info info) · 200 unmodified lines
201	return __cfg80211_rdev_from_attrs(netns, info->attrs);	201	return __cfg80211_rdev_from_attrs(netns, info->attrs);
202	}	202	}
203		203
		204	static int validate_beacon_head(const struct nlattr *attr,
		205	struct netlink_ext_ack *extack)
		206	{
		207	const u8 *data = nla_data(attr);
		208	unsigned int len = nla_len(attr);
		209	const struct element *elem;
		210	const struct ieee80211_mgmt mgmt = (void )data;
		211	unsigned int fixedlen = offsetof(struct ieee80211_mgmt,
		212	u.beacon.variable);
		213
		214	if (len < fixedlen)
		215	goto err;
		216
		217	if (ieee80211_hdrlen(mgmt->frame_control) !=
		218	offsetof(struct ieee80211_mgmt, u.beacon))
		219	goto err;
		220
		221	data += fixedlen;
		222	len -= fixedlen;
		223
		224	for_each_element(elem, data, len) {
		225	/* nothing */
		226	}
		227
		228	if (for_each_element_completed(elem, data, len))
		229	return 0;
		230
		231	err:
		232	NL_SET_ERR_MSG_ATTR(extack, attr, "malformed beacon head");
		233	return -EINVAL;
		234	}
		235
204	static int validate_ie_attr(const struct nlattr *attr,	236	static int validate_ie_attr(const struct nlattr *attr,
205	struct netlink_ext_ack *extack)	237	struct netlink_ext_ack *extack)
206	{	238	{
@@ -338,8 +370,9 @@ const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = { · 131 unmodified lines
338		370
339	[NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },	371	[NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
340	[NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },	372	[NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
341	[NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,	373	[NL80211_ATTR_BEACON_HEAD] =
342	.len = IEEE80211_MAX_DATA_LEN },	374	NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_beacon_head,
		375	IEEE80211_MAX_DATA_LEN),
343	[NL80211_ATTR_BEACON_TAIL] =	376	[NL80211_ATTR_BEACON_TAIL] =
344	NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,	377	NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
345	IEEE80211_MAX_DATA_LEN),	378	IEEE80211_MAX_DATA_LEN),
@@ -2636,6 +2669,8 @@ int nl80211_parse_chandef(struct cfg80211_registered_device *rdev, · 2290 unmodified lines
2636		2669
2637	control_freq = nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]);	2670	control_freq = nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]);
2638		2671
		2672	memset(chandef, 0, sizeof(*chandef));
		2673
2639	chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);	2674	chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
2640	chandef->width = NL80211_CHAN_WIDTH_20_NOHT;	2675	chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
2641	chandef->center_freq1 = control_freq;	2676	chandef->center_freq1 = control_freq;
@@ -3176,7 +3211,7 @@ static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flag · 534 unmodified lines
3176		3211
3177	if (rdev->ops->get_channel) {	3212	if (rdev->ops->get_channel) {
3178	int ret;	3213	int ret;
3179	struct cfg80211_chan_def chandef;	3214	struct cfg80211_chan_def chandef = {};
3180		3215
3181	ret = rdev_get_channel(rdev, wdev, &chandef);	3216	ret = rdev_get_channel(rdev, wdev, &chandef);
3182	if (ret == 0) {	3217	if (ret == 0) {
@@ -6270,6 +6305,9 @@ static int nl80211_del_mpath(struct sk_buff skb, struct genl_info info) · 3087 unmodified lines
6270	if (!rdev->ops->del_mpath)	6305	if (!rdev->ops->del_mpath)
6271	return -EOPNOTSUPP;	6306	return -EOPNOTSUPP;
6272		6307
		6308	if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
		6309	return -EOPNOTSUPP;
		6310
6273	return rdev_del_mpath(rdev, dev, dst);	6311	return rdev_del_mpath(rdev, dev, dst);
6274	}	6312	}
6275		6313

net/wireless/reg.c+1−1

@@ -2108,7 +2108,7 @@ static void reg_call_notifier(struct wiphy *wiphy, · 2107 unmodified lines
2108		2108
2109	static bool reg_wdev_chan_valid(struct wiphy wiphy, struct wireless_dev wdev)	2109	static bool reg_wdev_chan_valid(struct wiphy wiphy, struct wireless_dev wdev)
2110	{	2110	{
2111	struct cfg80211_chan_def chandef;	2111	struct cfg80211_chan_def chandef = {};
2112	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);	2112	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2113	enum nl80211_iftype iftype;	2113	enum nl80211_iftype iftype;
2114		2114

net/wireless/scan.c+6−1

 		return;
 	new_ie_len -= trans_ssid[1];
 	mbssid = cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, ie, ielen);
-	if (!mbssid)
+	/*
+	 * It's not valid to have the MBSSID element before SSID
+	 * ignore if that happens - the code below assumes it is
+	 * after (while copying things inbetween).
+	 */
+	if (!mbssid || mbssid < trans_ssid)
 		return;
 	new_ie_len -= mbssid[1];
 	rcu_read_lock();

net/wireless/wext-compat.c+1−1

@@ -798,7 +798,7 @@ static int cfg80211_wext_giwfreq(struct net_device *dev, · 797 unmodified lines
798	{	798	{
799	struct wireless_dev *wdev = dev->ieee80211_ptr;	799	struct wireless_dev *wdev = dev->ieee80211_ptr;
800	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	800	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
801	struct cfg80211_chan_def chandef;	801	struct cfg80211_chan_def chandef = {};
802	int ret;	802	int ret;
803		803
804	switch (wdev->iftype) {	804	switch (wdev->iftype) {

net/xfrm/xfrm_input.c+1−1

@@ -706,7 +706,7 @@ resume: · 705 unmodified lines
706	if (err)	706	if (err)
707	goto drop;	707	goto drop;
708		708
709	nf_reset(skb);	709	nf_reset_ct(skb);
710		710
711	if (decaps) {	711	if (decaps) {
712	sp = skb_sec_path(skb);	712	sp = skb_sec_path(skb);

net/xfrm/xfrm_interface.c+1−1

@@ -185,7 +185,7 @@ static void xfrmi_scrub_packet(struct sk_buff *skb, bool xnet) · 184 unmodified lines
185	skb->skb_iif = 0;	185	skb->skb_iif = 0;
186	skb->ignore_df = 0;	186	skb->ignore_df = 0;
187	skb_dst_drop(skb);	187	skb_dst_drop(skb);
188	nf_reset(skb);	188	nf_reset_ct(skb);
189	nf_reset_trace(skb);	189	nf_reset_trace(skb);
190		190
191	if (!xnet)	191	if (!xnet)

net/xfrm/xfrm_output.c+1−1

@@ -502,7 +502,7 @@ int xfrm_output_resume(struct sk_buff *skb, int err) · 501 unmodified lines
502	struct net *net = xs_net(skb_dst(skb)->xfrm);	502	struct net *net = xs_net(skb_dst(skb)->xfrm);
503		503
504	while (likely((err = xfrm_output_one(skb, err)) == 0)) {	504	while (likely((err = xfrm_output_one(skb, err)) == 0)) {
505	nf_reset(skb);	505	nf_reset_ct(skb);
506		506
507	err = skb_dst(skb)->ops->local_out(net, skb->sk, skb);	507	err = skb_dst(skb)->ops->local_out(net, skb->sk, skb);
508	if (unlikely(err != 1))	508	if (unlikely(err != 1))

net/xfrm/xfrm_policy.c+1−1

@@ -2808,7 +2808,7 @@ static void xfrm_policy_queue_process(struct timer_list *t) · 2807 unmodified lines
2808	continue;	2808	continue;
2809	}	2809	}
2810		2810
2811	nf_reset(skb);	2811	nf_reset_ct(skb);
2812	skb_dst_drop(skb);	2812	skb_dst_drop(skb);
2813	skb_dst_set(skb, dst);	2813	skb_dst_set(skb, dst);
2814		2814

scripts/Kbuild.include+0−5

 # Usage: KBUILD_LDFLAGS += $(call ld-option, -X, -Y)
 ld-option = $(call try-run, $(LD) $(KBUILD_LDFLAGS) $(1) -v,$(1),$(2),$(3))
-# ar-option
-# Usage: KBUILD_ARFLAGS := $(call ar-option,D)
-# Important: no spaces around options
-ar-option = $(call try-run, $(AR) rc$(1) "$$TMP",$(1),$(2))
 # ld-version
 # Note this is mainly for HJ Lu's 3 number binutil versions
 ld-version = $(shell $(LD) --version | $(srctree)/scripts/ld-version.sh)

scripts/Makefile.build+1−1

@@ -389,7 +389,7 @@ $(sort $(subdir-obj-y)): $(subdir-ym) ; · 388 unmodified lines
389	ifdef builtin-target	389	ifdef builtin-target
390		390
391	quiet_cmd_ar_builtin = AR $@	391	quiet_cmd_ar_builtin = AR $@
392	cmd_ar_builtin = rm -f $@; $(AR) rcSTP$(KBUILD_ARFLAGS) $@ $(real-prereqs)	392	cmd_ar_builtin = rm -f $@; $(AR) cDPrST $@ $(real-prereqs)
393		393
394	$(builtin-target): $(real-obj-y) FORCE	394	$(builtin-target): $(real-obj-y) FORCE
395	$(call if_changed,ar_builtin)	395	$(call if_changed,ar_builtin)

scripts/Makefile.lib+1−1

@@ -232,7 +232,7 @@ quiet_cmd_ld = LD $@ · 231 unmodified lines
232	# ---------------------------------------------------------------------------	232	# ---------------------------------------------------------------------------
233		233
234	quiet_cmd_ar = AR $@	234	quiet_cmd_ar = AR $@
235	cmd_ar = rm -f $@; $(AR) rcsTP$(KBUILD_ARFLAGS) $@ $(real-prereqs)	235	cmd_ar = rm -f $@; $(AR) cDPrsT $@ $(real-prereqs)
236		236
237	# Objcopy	237	# Objcopy
238	# ---------------------------------------------------------------------------	238	# ---------------------------------------------------------------------------

scripts/mod/modpost.c+9−4

 		fatal("modpost: Section mismatches detected.\n"
 		      "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
 	for (n = 0; n < SYMBOL_HASH_SIZE; n++) {
-		struct symbol *s = symbolhash[n];
+		struct symbol *s;
+		for (s = symbolhash[n]; s; s = s->next) {
+			/*
+			 * Do not check "vmlinux". This avoids the same warnings
+			 * shown twice, and false-positives for ARCH=um.
+			 */
+			if (is_vmlinux(s->module->name) && !s->module->is_dot_o)
+				continue;
-		while (s) {
 			if (s->is_static)
 				warn("\"%s\" [%s] is a static %s\n",
 				     s->name, s->module->name,
 				     export_str(s->export));
-			s = s->next;
 		}
 	}

scripts/namespace.pl+7−6

 use warnings;
 use strict;
 use File::Find;
+use File::Spec;
 my $nm = ($ENV{'NM'} || "nm") . " -p";
 my $objdump = ($ENV{'OBJDUMP'} || "objdump") . " -s -j .comment";
-my $srctree = "";
+my $srctree = File::Spec->curdir();
-my $objtree = "";
+my $objtree = File::Spec->curdir();
-$srctree = "$ENV{'srctree'}/" if (exists($ENV{'srctree'}));
+$srctree = File::Spec->rel2abs($ENV{'srctree'}) if (exists($ENV{'srctree'}));
-$objtree = "$ENV{'objtree'}/" if (exists($ENV{'objtree'}));
+$objtree = File::Spec->rel2abs($ENV{'objtree'}) if (exists($ENV{'objtree'}));
 if ($#ARGV != -1) {
 	print STDERR "usage: $0 takes no parameters\n";
 	}
 	($source = $basename) =~ s/\.o$//;
 	if (-e "$source.c" || -e "$source.S") {
-		$source = "$objtree$File::Find::dir/$source";
+		$source = File::Spec->catfile($objtree, $File::Find::dir, $source)
 	} else {
-		$source = "$srctree$File::Find::dir/$source";
+		$source = File::Spec->catfile($srctree, $File::Find::dir, $source)
 	}
 	if (! -e "$source.c" && ! -e "$source.S") {
 		# No obvious source, exclude the object if it is conglomerate

scripts/setlocalversion+1−1

@@ -126,7 +126,7 @@ scm_version() · 125 unmodified lines
126		126
127	collect_files()	127	collect_files()
128	{	128	{
129	local file res	129	local file res=
130		130
131	for file; do	131	for file; do
132	case "$file" in	132	case "$file" in

security/integrity/Makefile+0−3

 integrity-$(CONFIG_LOAD_UEFI_KEYS) += platform_certs/efi_parser.o \
 					platform_certs/load_uefi.o
 integrity-$(CONFIG_LOAD_IPL_KEYS) += platform_certs/load_ipl_s390.o
-$(obj)/load_uefi.o: KBUILD_CFLAGS += -fshort-wchar
-subdir-$(CONFIG_IMA)			+= ima
 obj-$(CONFIG_IMA)			+= ima/
-subdir-$(CONFIG_EVM)			+= evm
 obj-$(CONFIG_EVM)			+= evm/

tools/testing/selftests/kvm/Makefile+2−1

 TEST_GEN_PROGS_x86_64 += x86_64/state_test
 TEST_GEN_PROGS_x86_64 += x86_64/sync_regs_test
 TEST_GEN_PROGS_x86_64 += x86_64/vmx_close_while_nested_test
+TEST_GEN_PROGS_x86_64 += x86_64/vmx_dirty_log_test
 TEST_GEN_PROGS_x86_64 += x86_64/vmx_set_nested_state_test
 TEST_GEN_PROGS_x86_64 += x86_64/vmx_tsc_adjust_test
 TEST_GEN_PROGS_x86_64 += clear_dirty_log_test
 	-I$(LINUX_HDR_PATH) -Iinclude -I$(<D) -Iinclude/$(UNAME_M) -I..
 no-pie-option := $(call try-run, echo 'int main() { return 0; }' | \
-        $(CC) -Werror $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) -no-pie -x c - -o "$$TMP", -no-pie)
+        $(CC) -Werror -no-pie -x c - -o "$$TMP", -no-pie)
 # On s390, build the testcases KVM-enabled
 pgste-option = $(call try-run, echo 'int main() { return 0; }' | \

tools/testing/selftests/kvm/include/x86_64/processor.h+3−0

@@ -1083,6 +1083,9 @@ void kvm_get_cpu_address_width(unsigned int pa_bits, unsigned int va_bits); · 1082 unmodified lines
1083	#define VMX_BASIC_MEM_TYPE_WB 6LLU	1083	#define VMX_BASIC_MEM_TYPE_WB 6LLU
1084	#define VMX_BASIC_INOUT 0x0040000000000000LLU	1084	#define VMX_BASIC_INOUT 0x0040000000000000LLU
1085		1085
		1086	/* VMX_EPT_VPID_CAP bits */
		1087	#define VMX_EPT_VPID_CAP_AD_BITS (1ULL << 21)
		1088
1086	/* MSR_IA32_VMX_MISC bits */	1089	/* MSR_IA32_VMX_MISC bits */
1087	#define MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS (1ULL << 29)	1090	#define MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS (1ULL << 29)
1088	#define MSR_IA32_VMX_MISC_PREEMPTION_TIMER_SCALE 0x1F	1091	#define MSR_IA32_VMX_MISC_PREEMPTION_TIMER_SCALE 0x1F

tools/testing/selftests/kvm/include/x86_64/vmx.h+14−0

@@ -569,6 +569,10 @@ struct vmx_pages { · 568 unmodified lines
569	void *enlightened_vmcs_hva;	569	void *enlightened_vmcs_hva;
570	uint64_t enlightened_vmcs_gpa;	570	uint64_t enlightened_vmcs_gpa;
571	void *enlightened_vmcs;	571	void *enlightened_vmcs;
		572
		573	void *eptp_hva;
		574	uint64_t eptp_gpa;
		575	void *eptp;
572	};	576	};
573		577
574	struct vmx_pages vcpu_alloc_vmx(struct kvm_vm vm, vm_vaddr_t *p_vmx_gva);	578	struct vmx_pages vcpu_alloc_vmx(struct kvm_vm vm, vm_vaddr_t *p_vmx_gva);
@@ -576,4 +580,14 @@ bool prepare_for_vmx_operation(struct vmx_pages *vmx); · 1 unmodified line
576	void prepare_vmcs(struct vmx_pages vmx, void guest_rip, void *guest_rsp);	580	void prepare_vmcs(struct vmx_pages vmx, void guest_rip, void *guest_rsp);
577	bool load_vmcs(struct vmx_pages *vmx);	581	bool load_vmcs(struct vmx_pages *vmx);
578		582
		583	void nested_pg_map(struct vmx_pages vmx, struct kvm_vm vm,
		584	uint64_t nested_paddr, uint64_t paddr, uint32_t eptp_memslot);
		585	void nested_map(struct vmx_pages vmx, struct kvm_vm vm,
		586	uint64_t nested_paddr, uint64_t paddr, uint64_t size,
		587	uint32_t eptp_memslot);
		588	void nested_map_memslot(struct vmx_pages vmx, struct kvm_vm vm,
		589	uint32_t memslot, uint32_t eptp_memslot);
		590	void prepare_eptp(struct vmx_pages vmx, struct kvm_vm vm,
		591	uint32_t eptp_memslot);
		592
579	#endif /* SELFTEST_KVM_VMX_H */	593	#endif /* SELFTEST_KVM_VMX_H */

tools/testing/selftests/kvm/lib/kvm_util.c+1−1

@@ -705,7 +705,7 @@ void vm_userspace_mem_region_add(struct kvm_vm *vm, · 704 unmodified lines
705	* on error (e.g. currently no memory region using memslot as a KVM	705	* on error (e.g. currently no memory region using memslot as a KVM
706	* memory slot ID).	706	* memory slot ID).
707	*/	707	*/
708	static struct userspace_mem_region *	708	struct userspace_mem_region *
709	memslot2region(struct kvm_vm *vm, uint32_t memslot)	709	memslot2region(struct kvm_vm *vm, uint32_t memslot)
710	{	710	{
711	struct userspace_mem_region *region;	711	struct userspace_mem_region *region;

tools/testing/selftests/kvm/lib/kvm_util_internal.h+3−0

@@ -68,4 +68,7 @@ void virt_dump(FILE stream, struct kvm_vm vm, uint8_t indent); · 67 unmodified lines
68	void regs_dump(FILE stream, struct kvm_regs regs, uint8_t indent);	68	void regs_dump(FILE stream, struct kvm_regs regs, uint8_t indent);
69	void sregs_dump(FILE stream, struct kvm_sregs sregs, uint8_t indent);	69	void sregs_dump(FILE stream, struct kvm_sregs sregs, uint8_t indent);
70		70
		71	struct userspace_mem_region *
		72	memslot2region(struct kvm_vm *vm, uint32_t memslot);
		73
71	#endif /* SELFTEST_KVM_UTIL_INTERNAL_H */	74	#endif /* SELFTEST_KVM_UTIL_INTERNAL_H */

tools/testing/selftests/kvm/lib/x86_64/processor.c+1−1

@@ -1085,7 +1085,7 @@ struct kvm_x86_state vcpu_save_state(struct kvm_vm vm, uint32_t vcpuid) · 1084 unmodified lines
1085	for (i = 0; i < nmsrs; i++)	1085	for (i = 0; i < nmsrs; i++)
1086	state->msrs.entries[i].index = list->indices[i];	1086	state->msrs.entries[i].index = list->indices[i];
1087	r = ioctl(vcpu->fd, KVM_GET_MSRS, &state->msrs);	1087	r = ioctl(vcpu->fd, KVM_GET_MSRS, &state->msrs);
1088	TEST_ASSERT(r == nmsrs, "Unexpected result from KVM_GET_MSRS, r: %i (failed at %x)",	1088	TEST_ASSERT(r == nmsrs, "Unexpected result from KVM_GET_MSRS, r: %i (failed MSR was 0x%x)",
1089	r, r == nmsrs ? -1 : list->indices[r]);	1089	r, r == nmsrs ? -1 : list->indices[r]);
1090		1090
1091	r = ioctl(vcpu->fd, KVM_GET_DEBUGREGS, &state->debugregs);	1091	r = ioctl(vcpu->fd, KVM_GET_DEBUGREGS, &state->debugregs);

tools/testing/selftests/kvm/lib/x86_64/vmx.c+199−2

@@ -7,11 +7,39 @@ · 6 unmodified lines
7		7
8	#include "test_util.h"	8	#include "test_util.h"
9	#include "kvm_util.h"	9	#include "kvm_util.h"
		10	#include "../kvm_util_internal.h"
10	#include "processor.h"	11	#include "processor.h"
11	#include "vmx.h"	12	#include "vmx.h"
12		13
		14	#define PAGE_SHIFT_4K 12
		15
		16	#define KVM_EPT_PAGE_TABLE_MIN_PADDR 0x1c0000
		17
13	bool enable_evmcs;	18	bool enable_evmcs;
14		19
		20	struct eptPageTableEntry {
		21	uint64_t readable:1;
		22	uint64_t writable:1;
		23	uint64_t executable:1;
		24	uint64_t memory_type:3;
		25	uint64_t ignore_pat:1;
		26	uint64_t page_size:1;
		27	uint64_t accessed:1;
		28	uint64_t dirty:1;
		29	uint64_t ignored_11_10:2;
		30	uint64_t address:40;
		31	uint64_t ignored_62_52:11;
		32	uint64_t suppress_ve:1;
		33	};
		34
		35	struct eptPageTablePointer {
		36	uint64_t memory_type:3;
		37	uint64_t page_walk_length:3;
		38	uint64_t ad_enabled:1;
		39	uint64_t reserved_11_07:5;
		40	uint64_t address:40;
		41	uint64_t reserved_63_52:12;
		42	};
15	int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id)	43	int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id)
16	{	44	{
17	uint16_t evmcs_ver;	45	uint16_t evmcs_ver;
@@ -174,15 +202,35 @@ bool load_vmcs(struct vmx_pages *vmx) · 156 unmodified lines
174	*/	202	*/
175	static inline void init_vmcs_control_fields(struct vmx_pages *vmx)	203	static inline void init_vmcs_control_fields(struct vmx_pages *vmx)
176	{	204	{
		205	uint32_t sec_exec_ctl = 0;
		206
177	vmwrite(VIRTUAL_PROCESSOR_ID, 0);	207	vmwrite(VIRTUAL_PROCESSOR_ID, 0);
178	vmwrite(POSTED_INTR_NV, 0);	208	vmwrite(POSTED_INTR_NV, 0);
179		209
180	vmwrite(PIN_BASED_VM_EXEC_CONTROL, rdmsr(MSR_IA32_VMX_TRUE_PINBASED_CTLS));	210	vmwrite(PIN_BASED_VM_EXEC_CONTROL, rdmsr(MSR_IA32_VMX_TRUE_PINBASED_CTLS));
181	if (!vmwrite(SECONDARY_VM_EXEC_CONTROL, 0))	211
		212	if (vmx->eptp_gpa) {
		213	uint64_t ept_paddr;
		214	struct eptPageTablePointer eptp = {
		215	.memory_type = VMX_BASIC_MEM_TYPE_WB,
		216	.page_walk_length = 3, /* + 1 */
		217	.ad_enabled = !!(rdmsr(MSR_IA32_VMX_EPT_VPID_CAP) & VMX_EPT_VPID_CAP_AD_BITS),
		218	.address = vmx->eptp_gpa >> PAGE_SHIFT_4K,
		219	};
		220
		221	memcpy(&ept_paddr, &eptp, sizeof(ept_paddr));
		222	vmwrite(EPT_POINTER, ept_paddr);
		223	sec_exec_ctl \|= SECONDARY_EXEC_ENABLE_EPT;
		224	}
		225
		226	if (!vmwrite(SECONDARY_VM_EXEC_CONTROL, sec_exec_ctl))
182	vmwrite(CPU_BASED_VM_EXEC_CONTROL,	227	vmwrite(CPU_BASED_VM_EXEC_CONTROL,
183	rdmsr(MSR_IA32_VMX_TRUE_PROCBASED_CTLS) \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS);	228	rdmsr(MSR_IA32_VMX_TRUE_PROCBASED_CTLS) \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS);
184	else	229	else {
185	vmwrite(CPU_BASED_VM_EXEC_CONTROL, rdmsr(MSR_IA32_VMX_TRUE_PROCBASED_CTLS));	230	vmwrite(CPU_BASED_VM_EXEC_CONTROL, rdmsr(MSR_IA32_VMX_TRUE_PROCBASED_CTLS));
		231	GUEST_ASSERT(!sec_exec_ctl);
		232	}
		233
186	vmwrite(EXCEPTION_BITMAP, 0);	234	vmwrite(EXCEPTION_BITMAP, 0);
187	vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0);	235	vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0);
188	vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, -1); /* Never match */	236	vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, -1); /* Never match */
@@ -327,3 +375,152 @@ void prepare_vmcs(struct vmx_pages vmx, void guest_rip, void *guest_rsp) · 138 unmodified lines
327	init_vmcs_host_state();	375	init_vmcs_host_state();
328	init_vmcs_guest_state(guest_rip, guest_rsp);	376	init_vmcs_guest_state(guest_rip, guest_rsp);
329	}	377	}
		378
		379	void nested_pg_map(struct vmx_pages vmx, struct kvm_vm vm,
		380	uint64_t nested_paddr, uint64_t paddr, uint32_t eptp_memslot)
		381	{
		382	uint16_t index[4];
		383	struct eptPageTableEntry *pml4e;
		384
		385	TEST_ASSERT(vm->mode == VM_MODE_PXXV48_4K, "Attempt to use "
		386	"unknown or unsupported guest mode, mode: 0x%x", vm->mode);
		387
		388	TEST_ASSERT((nested_paddr % vm->page_size) == 0,
		389	"Nested physical address not on page boundary,\n"
		390	" nested_paddr: 0x%lx vm->page_size: 0x%x",
		391	nested_paddr, vm->page_size);
		392	TEST_ASSERT((nested_paddr >> vm->page_shift) <= vm->max_gfn,
		393	"Physical address beyond beyond maximum supported,\n"
		394	" nested_paddr: 0x%lx vm->max_gfn: 0x%lx vm->page_size: 0x%x",
		395	paddr, vm->max_gfn, vm->page_size);
		396	TEST_ASSERT((paddr % vm->page_size) == 0,
		397	"Physical address not on page boundary,\n"
		398	" paddr: 0x%lx vm->page_size: 0x%x",
		399	paddr, vm->page_size);
		400	TEST_ASSERT((paddr >> vm->page_shift) <= vm->max_gfn,
		401	"Physical address beyond beyond maximum supported,\n"
		402	" paddr: 0x%lx vm->max_gfn: 0x%lx vm->page_size: 0x%x",
		403	paddr, vm->max_gfn, vm->page_size);
		404
		405	index[0] = (nested_paddr >> 12) & 0x1ffu;
		406	index[1] = (nested_paddr >> 21) & 0x1ffu;
		407	index[2] = (nested_paddr >> 30) & 0x1ffu;
		408	index[3] = (nested_paddr >> 39) & 0x1ffu;
		409
		410	/* Allocate page directory pointer table if not present. */
		411	pml4e = vmx->eptp_hva;
		412	if (!pml4e[index[3]].readable) {
		413	pml4e[index[3]].address = vm_phy_page_alloc(vm,
		414	KVM_EPT_PAGE_TABLE_MIN_PADDR, eptp_memslot)
		415	>> vm->page_shift;
		416	pml4e[index[3]].writable = true;
		417	pml4e[index[3]].readable = true;
		418	pml4e[index[3]].executable = true;
		419	}
		420
		421	/* Allocate page directory table if not present. */
		422	struct eptPageTableEntry *pdpe;
		423	pdpe = addr_gpa2hva(vm, pml4e[index[3]].address * vm->page_size);
		424	if (!pdpe[index[2]].readable) {
		425	pdpe[index[2]].address = vm_phy_page_alloc(vm,
		426	KVM_EPT_PAGE_TABLE_MIN_PADDR, eptp_memslot)
		427	>> vm->page_shift;
		428	pdpe[index[2]].writable = true;
		429	pdpe[index[2]].readable = true;
		430	pdpe[index[2]].executable = true;
		431	}
		432
		433	/* Allocate page table if not present. */
		434	struct eptPageTableEntry *pde;
		435	pde = addr_gpa2hva(vm, pdpe[index[2]].address * vm->page_size);
		436	if (!pde[index[1]].readable) {
		437	pde[index[1]].address = vm_phy_page_alloc(vm,
		438	KVM_EPT_PAGE_TABLE_MIN_PADDR, eptp_memslot)
		439	>> vm->page_shift;
		440	pde[index[1]].writable = true;
		441	pde[index[1]].readable = true;
		442	pde[index[1]].executable = true;
		443	}
		444
		445	/* Fill in page table entry. */
		446	struct eptPageTableEntry *pte;
		447	pte = addr_gpa2hva(vm, pde[index[1]].address * vm->page_size);
		448	pte[index[0]].address = paddr >> vm->page_shift;
		449	pte[index[0]].writable = true;
		450	pte[index[0]].readable = true;
		451	pte[index[0]].executable = true;
		452
		453	/*
		454	* For now mark these as accessed and dirty because the only
		455	* testcase we have needs that. Can be reconsidered later.
		456	*/
		457	pte[index[0]].accessed = true;
		458	pte[index[0]].dirty = true;
		459	}
		460
		461	/*
		462	* Map a range of EPT guest physical addresses to the VM's physical address
		463	*
		464	* Input Args:
		465	* vm - Virtual Machine
		466	* nested_paddr - Nested guest physical address to map
		467	* paddr - VM Physical Address
		468	* size - The size of the range to map
		469	* eptp_memslot - Memory region slot for new virtual translation tables
		470	*
		471	* Output Args: None
		472	*
		473	* Return: None
		474	*
		475	* Within the VM given by vm, creates a nested guest translation for the
		476	* page range starting at nested_paddr to the page range starting at paddr.
		477	*/
		478	void nested_map(struct vmx_pages vmx, struct kvm_vm vm,
		479	uint64_t nested_paddr, uint64_t paddr, uint64_t size,
		480	uint32_t eptp_memslot)
		481	{
		482	size_t page_size = vm->page_size;
		483	size_t npages = size / page_size;
		484
		485	TEST_ASSERT(nested_paddr + size > nested_paddr, "Vaddr overflow");
		486	TEST_ASSERT(paddr + size > paddr, "Paddr overflow");
		487
		488	while (npages--) {
		489	nested_pg_map(vmx, vm, nested_paddr, paddr, eptp_memslot);
		490	nested_paddr += page_size;
		491	paddr += page_size;
		492	}
		493	}
		494
		495	/* Prepare an identity extended page table that maps all the
		496	* physical pages in VM.
		497	*/
		498	void nested_map_memslot(struct vmx_pages vmx, struct kvm_vm vm,
		499	uint32_t memslot, uint32_t eptp_memslot)
		500	{
		501	sparsebit_idx_t i, last;
		502	struct userspace_mem_region *region =
		503	memslot2region(vm, memslot);
		504
		505	i = (region->region.guest_phys_addr >> vm->page_shift) - 1;
		506	last = i + (region->region.memory_size >> vm->page_shift);
		507	for (;;) {
		508	i = sparsebit_next_clear(region->unused_phy_pages, i);
		509	if (i > last)
		510	break;
		511
		512	nested_map(vmx, vm,
		513	(uint64_t)i << vm->page_shift,
		514	(uint64_t)i << vm->page_shift,
		515	1 << vm->page_shift,
		516	eptp_memslot);
		517	}
		518	}
		519
		520	void prepare_eptp(struct vmx_pages vmx, struct kvm_vm vm,
		521	uint32_t eptp_memslot)
		522	{
		523	vmx->eptp = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
		524	vmx->eptp_hva = addr_gva2hva(vm, (uintptr_t)vmx->eptp);
		525	vmx->eptp_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->eptp);
		526	}

tools/testing/selftests/kvm/x86_64/vmx_dirty_log_test.c+156−0

@@ -0,0 +1,156 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* KVM dirty page logging test
	4	*
	5	* Copyright (C) 2018, Red Hat, Inc.
	6	*/
	7
	8	#define _GNU_SOURCE /* for program_invocation_name */
	9
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <linux/bitmap.h>
	13	#include <linux/bitops.h>
	14
	15	#include "test_util.h"
	16	#include "kvm_util.h"
	17	#include "processor.h"
	18	#include "vmx.h"
	19
	20	#define VCPU_ID 1
	21
	22	/* The memory slot index to track dirty pages */
	23	#define TEST_MEM_SLOT_INDEX 1
	24	#define TEST_MEM_SIZE 3
	25
	26	/* L1 guest test virtual memory offset */
	27	#define GUEST_TEST_MEM 0xc0000000
	28
	29	/* L2 guest test virtual memory offset */
	30	#define NESTED_TEST_MEM1 0xc0001000
	31	#define NESTED_TEST_MEM2 0xc0002000
	32
	33	static void l2_guest_code(void)
	34	{
	35	(volatile uint64_t )NESTED_TEST_MEM1;
	36	(volatile uint64_t )NESTED_TEST_MEM1 = 1;
	37	GUEST_SYNC(true);
	38	GUEST_SYNC(false);
	39
	40	(volatile uint64_t )NESTED_TEST_MEM2 = 1;
	41	GUEST_SYNC(true);
	42	(volatile uint64_t )NESTED_TEST_MEM2 = 1;
	43	GUEST_SYNC(true);
	44	GUEST_SYNC(false);
	45
	46	/* Exit to L1 and never come back. */
	47	vmcall();
	48	}
	49
	50	void l1_guest_code(struct vmx_pages *vmx)
	51	{
	52	#define L2_GUEST_STACK_SIZE 64
	53	unsigned long l2_guest_stack[L2_GUEST_STACK_SIZE];
	54
	55	GUEST_ASSERT(vmx->vmcs_gpa);
	56	GUEST_ASSERT(prepare_for_vmx_operation(vmx));
	57	GUEST_ASSERT(load_vmcs(vmx));
	58
	59	prepare_vmcs(vmx, l2_guest_code,
	60	&l2_guest_stack[L2_GUEST_STACK_SIZE]);
	61
	62	GUEST_SYNC(false);
	63	GUEST_ASSERT(!vmlaunch());
	64	GUEST_SYNC(false);
	65	GUEST_ASSERT(vmreadz(VM_EXIT_REASON) == EXIT_REASON_VMCALL);
	66	GUEST_DONE();
	67	}
	68
	69	int main(int argc, char *argv[])
	70	{
	71	vm_vaddr_t vmx_pages_gva = 0;
	72	struct vmx_pages *vmx;
	73	unsigned long *bmap;
	74	uint64_t *host_test_mem;
	75
	76	struct kvm_vm *vm;
	77	struct kvm_run *run;
	78	struct ucall uc;
	79	bool done = false;
	80
	81	/* Create VM */
	82	vm = vm_create_default(VCPU_ID, 0, l1_guest_code);
	83	vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
	84	vmx = vcpu_alloc_vmx(vm, &vmx_pages_gva);
	85	vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva);
	86	run = vcpu_state(vm, VCPU_ID);
	87
	88	/* Add an extra memory slot for testing dirty logging */
	89	vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
	90	GUEST_TEST_MEM,
	91	TEST_MEM_SLOT_INDEX,
	92	TEST_MEM_SIZE,
	93	KVM_MEM_LOG_DIRTY_PAGES);
	94
	95	/*
	96	* Add an identity map for GVA range [0xc0000000, 0xc0002000). This
	97	* affects both L1 and L2. However...
	98	*/
	99	virt_map(vm, GUEST_TEST_MEM, GUEST_TEST_MEM,
	100	TEST_MEM_SIZE * 4096, 0);
	101
	102	/*
	103	* ... pages in the L2 GPA range [0xc0001000, 0xc0003000) will map to
	104	* 0xc0000000.
	105	*
	106	* Note that prepare_eptp should be called only L1's GPA map is done,
	107	* meaning after the last call to virt_map.
	108	*/
	109	prepare_eptp(vmx, vm, 0);
	110	nested_map_memslot(vmx, vm, 0, 0);
	111	nested_map(vmx, vm, NESTED_TEST_MEM1, GUEST_TEST_MEM, 4096, 0);
	112	nested_map(vmx, vm, NESTED_TEST_MEM2, GUEST_TEST_MEM, 4096, 0);
	113
	114	bmap = bitmap_alloc(TEST_MEM_SIZE);
	115	host_test_mem = addr_gpa2hva(vm, GUEST_TEST_MEM);
	116
	117	while (!done) {
	118	memset(host_test_mem, 0xaa, TEST_MEM_SIZE * 4096);
	119	_vcpu_run(vm, VCPU_ID);
	120	TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
	121	"Unexpected exit reason: %u (%s),\n",
	122	run->exit_reason,
	123	exit_reason_str(run->exit_reason));
	124
	125	switch (get_ucall(vm, VCPU_ID, &uc)) {
	126	case UCALL_ABORT:
	127	TEST_ASSERT(false, "%s at %s:%d", (const char *)uc.args[0],
	128	__FILE__, uc.args[1]);
	129	/* NOT REACHED */
	130	case UCALL_SYNC:
	131	/*
	132	* The nested guest wrote at offset 0x1000 in the memslot, but the
	133	* dirty bitmap must be filled in according to L1 GPA, not L2.
	134	*/
	135	kvm_vm_get_dirty_log(vm, TEST_MEM_SLOT_INDEX, bmap);
	136	if (uc.args[1]) {
	137	TEST_ASSERT(test_bit(0, bmap), "Page 0 incorrectly reported clean\n");
	138	TEST_ASSERT(host_test_mem[0] == 1, "Page 0 not written by guest\n");
	139	} else {
	140	TEST_ASSERT(!test_bit(0, bmap), "Page 0 incorrectly reported dirty\n");
	141	TEST_ASSERT(host_test_mem[0] == 0xaaaaaaaaaaaaaaaaULL, "Page 0 written by guest\n");
	142	}
	143
	144	TEST_ASSERT(!test_bit(1, bmap), "Page 1 incorrectly reported dirty\n");
	145	TEST_ASSERT(host_test_mem[4096 / 8] == 0xaaaaaaaaaaaaaaaaULL, "Page 1 written by guest\n");
	146	TEST_ASSERT(!test_bit(2, bmap), "Page 2 incorrectly reported dirty\n");
	147	TEST_ASSERT(host_test_mem[8192 / 8] == 0xaaaaaaaaaaaaaaaaULL, "Page 2 written by guest\n");
	148	break;
	149	case UCALL_DONE:
	150	done = true;
	151	break;
	152	default:
	153	TEST_ASSERT(false, "Unknown ucall 0x%x.", uc.cmd);
	154	}
	155	}
	156	}

tools/testing/selftests/net/.gitignore+1−0

@@ -21,3 +21,4 @@ ipv6_flowlabel · 20 unmodified lines
21	ipv6_flowlabel_mgr	21	ipv6_flowlabel_mgr
22	so_txtime	22	so_txtime
23	tcp_fastopen_backup_key	23	tcp_fastopen_backup_key
		24	nettest

tools/testing/selftests/net/udpgso.c+4−12

 		.tfail = true,
 	},
 	{
-		/* send a single MSS: will fail with GSO, because the segment
+		/* send a single MSS: will fall back to no GSO */
-		 * logic in udp4_ufo_fragment demands a gso skb to be > MTU
-		 */
 		.tlen = CONST_MSS_V4,
 		.gso_len = CONST_MSS_V4,
-		.tfail = true,
 		.r_num_mss = 1,
 	},
 	{
 		.tfail = true,
 	},
 	{
-		/* send a single 1B MSS: will fail, see single MSS above */
+		/* send a single 1B MSS: will fall back to no GSO */
 		.tlen = 1,
 		.gso_len = 1,
-		.tfail = true,
 		.r_num_mss = 1,
 	},
 	{
 		.tfail = true,
 	},
 	{
-		/* send a single MSS: will fail with GSO, because the segment
+		/* send a single MSS: will fall back to no GSO */
-		 * logic in udp4_ufo_fragment demands a gso skb to be > MTU
-		 */
 		.tlen = CONST_MSS_V6,
 		.gso_len = CONST_MSS_V6,
-		.tfail = true,
 		.r_num_mss = 1,
 	},
 	{
 		.tfail = true,
 	},
 	{
-		/* send a single 1B MSS: will fail, see single MSS above */
+		/* send a single 1B MSS: will fall back to no GSO */
 		.tlen = 1,
 		.gso_len = 1,
-		.tfail = true,
 		.r_num_mss = 1,
 	},
 	{

tools/testing/selftests/pidfd/Makefile+1−1

@@ -1,5 +1,5 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	CFLAGS += -g -I../../../../usr/include/ -lpthread	2	CFLAGS += -g -I../../../../usr/include/ -pthread
3		3
4	TEST_GEN_PROGS := pidfd_test pidfd_open_test pidfd_poll_test pidfd_wait	4	TEST_GEN_PROGS := pidfd_test pidfd_open_test pidfd_poll_test pidfd_wait
5		5

usr/include/Makefile+0−10

 header-test-$(CONFIG_CPU_BIG_ENDIAN) += linux/byteorder/big_endian.h
 header-test-$(CONFIG_CPU_LITTLE_ENDIAN) += linux/byteorder/little_endian.h
 header-test- += linux/coda.h
-header-test- += linux/coda_psdev.h
 header-test- += linux/elfcore.h
 header-test- += linux/errqueue.h
 header-test- += linux/fsmap.h
 header-test- += linux/hdlc/ioctl.h
 header-test- += linux/ivtv.h
-header-test- += linux/jffs2.h
 header-test- += linux/kexec.h
 header-test- += linux/matroxfb.h
 header-test- += linux/netfilter_ipv4/ipt_LOG.h
 header-test- += linux/v4l2-subdev.h
 header-test- += linux/videodev2.h
 header-test- += linux/vm_sockets.h
-header-test- += scsi/scsi_bsg_fc.h
-header-test- += scsi/scsi_netlink.h
-header-test- += scsi/scsi_netlink_fc.h
 header-test- += sound/asequencer.h
 header-test- += sound/asoc.h
 header-test- += sound/asound.h
 header-test- += sound/compress_offload.h
 header-test- += sound/emu10k1.h
 header-test- += sound/sfnt_info.h
-header-test- += sound/sof/eq.h
-header-test- += sound/sof/fw.h
-header-test- += sound/sof/header.h
-header-test- += sound/sof/manifest.h
-header-test- += sound/sof/trace.h
 header-test- += xen/evtchn.h
 header-test- += xen/gntdev.h
 header-test- += xen/privcmd.h

virt/kvm/arm/vgic/trace.h+1−1

@@ -30,7 +30,7 @@ TRACE_EVENT(vgic_update_irq_pending, · 29 unmodified lines
30	#endif /* _TRACE_VGIC_H */	30	#endif /* _TRACE_VGIC_H */
31		31
32	#undef TRACE_INCLUDE_PATH	32	#undef TRACE_INCLUDE_PATH
33	#define TRACE_INCLUDE_PATH ../../../virt/kvm/arm/vgic	33	#define TRACE_INCLUDE_PATH ../../virt/kvm/arm/vgic
34	#undef TRACE_INCLUDE_FILE	34	#undef TRACE_INCLUDE_FILE
35	#define TRACE_INCLUDE_FILE trace	35	#define TRACE_INCLUDE_FILE trace
36		36

virt/kvm/kvm_main.c+7−3

 		stat_data->kvm = kvm;
 		stat_data->offset = p->offset;
+		stat_data->mode = p->mode ? p->mode : 0644;
 		kvm->debugfs_stat_data[p - debugfs_entries] = stat_data;
-		debugfs_create_file(p->name, 0644, kvm->debugfs_dentry,
+		debugfs_create_file(p->name, stat_data->mode, kvm->debugfs_dentry,
 				    stat_data, stat_fops_per_vm[p->kind]);
 	}
 	return 0;
 	if (!refcount_inc_not_zero(&stat_data->kvm->users_count))
 		return -ENOENT;
-	if (simple_attr_open(inode, file, get, set, fmt)) {
+	if (simple_attr_open(inode, file, get,
+			     stat_data->mode & S_IWUGO ? set : NULL,
+			     fmt)) {
 		kvm_put_kvm(stat_data->kvm);
 		return -ENOMEM;
 	}
 	kvm_debugfs_num_entries = 0;
 	for (p = debugfs_entries; p->name; ++p, kvm_debugfs_num_entries++) {
-		debugfs_create_file(p->name, 0644, kvm_debugfs_dir,
+		int mode = p->mode ? p->mode : 0644;
+		debugfs_create_file(p->name, mode, kvm_debugfs_dir,
 				    (void *)(long)p->offset,
 				    stat_fops[p->kind]);
 	}

Merge branch 'errata/tx2-219' into for-next/fixes

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -683,7 +683,7 @@ static const struct omap_clkctrl_reg_data dra7_l4per2_clkctrl_regs[] __initconst · 682 unmodified lines
683	{ DRA7_L4PER2_MCASP2_CLKCTRL, dra7_mcasp2_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:0154:22" },	683	{ DRA7_L4PER2_MCASP2_CLKCTRL, dra7_mcasp2_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:0154:22" },
684	{ DRA7_L4PER2_MCASP3_CLKCTRL, dra7_mcasp3_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:015c:22" },	684	{ DRA7_L4PER2_MCASP3_CLKCTRL, dra7_mcasp3_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:015c:22" },
685	{ DRA7_L4PER2_MCASP5_CLKCTRL, dra7_mcasp5_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:016c:22" },	685	{ DRA7_L4PER2_MCASP5_CLKCTRL, dra7_mcasp5_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:016c:22" },
686	{ DRA7_L4PER2_MCASP8_CLKCTRL, dra7_mcasp8_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:0184:24" },	686	{ DRA7_L4PER2_MCASP8_CLKCTRL, dra7_mcasp8_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:0184:22" },
687	{ DRA7_L4PER2_MCASP4_CLKCTRL, dra7_mcasp4_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:018c:22" },	687	{ DRA7_L4PER2_MCASP4_CLKCTRL, dra7_mcasp4_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:018c:22" },
688	{ DRA7_L4PER2_UART7_CLKCTRL, dra7_uart7_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:01c4:24" },	688	{ DRA7_L4PER2_UART7_CLKCTRL, dra7_uart7_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:01c4:24" },
689	{ DRA7_L4PER2_UART8_CLKCTRL, dra7_uart8_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:01d4:24" },	689	{ DRA7_L4PER2_UART8_CLKCTRL, dra7_uart8_bit_data, CLKF_SW_SUP, "l4per2-clkctrl:01d4:24" },
@@ -828,8 +828,8 @@ static struct ti_dt_clk dra7xx_clks[] = { · 138 unmodified lines
828	DT_CLK(NULL, "mcasp6_aux_gfclk_mux", "l4per2-clkctrl:01f8:22"),	828	DT_CLK(NULL, "mcasp6_aux_gfclk_mux", "l4per2-clkctrl:01f8:22"),
829	DT_CLK(NULL, "mcasp7_ahclkx_mux", "l4per2-clkctrl:01fc:24"),	829	DT_CLK(NULL, "mcasp7_ahclkx_mux", "l4per2-clkctrl:01fc:24"),
830	DT_CLK(NULL, "mcasp7_aux_gfclk_mux", "l4per2-clkctrl:01fc:22"),	830	DT_CLK(NULL, "mcasp7_aux_gfclk_mux", "l4per2-clkctrl:01fc:22"),
831	DT_CLK(NULL, "mcasp8_ahclkx_mux", "l4per2-clkctrl:0184:22"),	831	DT_CLK(NULL, "mcasp8_ahclkx_mux", "l4per2-clkctrl:0184:24"),
832	DT_CLK(NULL, "mcasp8_aux_gfclk_mux", "l4per2-clkctrl:0184:24"),	832	DT_CLK(NULL, "mcasp8_aux_gfclk_mux", "l4per2-clkctrl:0184:22"),
833	DT_CLK(NULL, "mmc1_clk32k", "l3init-clkctrl:0008:8"),	833	DT_CLK(NULL, "mmc1_clk32k", "l3init-clkctrl:0008:8"),
834	DT_CLK(NULL, "mmc1_fclk_div", "l3init-clkctrl:0008:25"),	834	DT_CLK(NULL, "mmc1_fclk_div", "l3init-clkctrl:0008:25"),
835	DT_CLK(NULL, "mmc1_fclk_mux", "l3init-clkctrl:0008:24"),	835	DT_CLK(NULL, "mmc1_fclk_mux", "l3init-clkctrl:0008:24"),

@@ -3683,7 +3683,7 @@ void hisi_sas_debugfs_work_handler(struct work_struct *work) · 3682 unmodified lines
3683	}	3683	}
3684	EXPORT_SYMBOL_GPL(hisi_sas_debugfs_work_handler);	3684	EXPORT_SYMBOL_GPL(hisi_sas_debugfs_work_handler);
3685		3685
3686	void hisi_sas_debugfs_release(struct hisi_hba *hisi_hba)	3686	static void hisi_sas_debugfs_release(struct hisi_hba *hisi_hba)
3687	{	3687	{
3688	struct device *dev = hisi_hba->dev;	3688	struct device *dev = hisi_hba->dev;
3689	int i;	3689	int i;
@@ -3705,7 +3705,7 @@ void hisi_sas_debugfs_release(struct hisi_hba *hisi_hba) · 15 unmodified lines
3705	devm_kfree(dev, hisi_hba->debugfs_port_reg[i]);	3705	devm_kfree(dev, hisi_hba->debugfs_port_reg[i]);
3706	}	3706	}
3707		3707
3708	int hisi_sas_debugfs_alloc(struct hisi_hba *hisi_hba)	3708	static int hisi_sas_debugfs_alloc(struct hisi_hba *hisi_hba)
3709	{	3709	{
3710	const struct hisi_sas_hw *hw = hisi_hba->hw;	3710	const struct hisi_sas_hw *hw = hisi_hba->hw;
3711	struct device *dev = hisi_hba->dev;	3711	struct device *dev = hisi_hba->dev;
@@ -3796,7 +3796,7 @@ fail: · 84 unmodified lines
3796	return -ENOMEM;	3796	return -ENOMEM;
3797	}	3797	}
3798		3798
3799	void hisi_sas_debugfs_bist_init(struct hisi_hba *hisi_hba)	3799	static void hisi_sas_debugfs_bist_init(struct hisi_hba *hisi_hba)
3800	{	3800	{
3801	hisi_hba->debugfs_bist_dentry =	3801	hisi_hba->debugfs_bist_dentry =
3802	debugfs_create_dir("bist", hisi_hba->debugfs_dir);	3802	debugfs_create_dir("bist", hisi_hba->debugfs_dir);