lael-labs/linux

.mailmap+1−0

@@ -377,6 +377,7 @@ Matthew Wilcox <willy@infradead.org> <willy@debian.org> · 376 unmodified lines
377	Matthew Wilcox <willy@infradead.org> <willy@linux.intel.com>	377	Matthew Wilcox <willy@infradead.org> <willy@linux.intel.com>
378	Matthew Wilcox <willy@infradead.org> <willy@parisc-linux.org>	378	Matthew Wilcox <willy@infradead.org> <willy@parisc-linux.org>
379	Matthias Fuchs <socketcan@esd.eu> <matthias.fuchs@esd.eu>	379	Matthias Fuchs <socketcan@esd.eu> <matthias.fuchs@esd.eu>
		380	Matthieu Baerts <matttbe@kernel.org> <matthieu.baerts@tessares.net>
380	Matthieu CASTET <castet.matthieu@free.fr>	381	Matthieu CASTET <castet.matthieu@free.fr>
381	Matti Vaittinen <mazziesaccount@gmail.com> <matti.vaittinen@fi.rohmeurope.com>	382	Matti Vaittinen <mazziesaccount@gmail.com> <matti.vaittinen@fi.rohmeurope.com>
382	Matt Ranostay <matt.ranostay@konsulko.com> <matt@ranostay.consulting>	383	Matt Ranostay <matt.ranostay@konsulko.com> <matt@ranostay.consulting>

Documentation/admin-guide/cgroup-v1/memory.rst+7−0

@@ -92,6 +92,13 @@ Brief summary of control files. · 91 unmodified lines
92	memory.oom_control set/show oom controls.	92	memory.oom_control set/show oom controls.
93	memory.numa_stat show the number of memory usage per numa	93	memory.numa_stat show the number of memory usage per numa
94	node	94	node
		95	memory.kmem.limit_in_bytes Deprecated knob to set and read the kernel
		96	memory hard limit. Kernel hard limit is not
		97	supported since 5.16. Writing any value to
		98	do file will not have any effect same as if
		99	nokmem kernel parameter was specified.
		100	Kernel memory is still charged and reported
		101	by memory.kmem.usage_in_bytes.
95	memory.kmem.usage_in_bytes show current kernel memory allocation	102	memory.kmem.usage_in_bytes show current kernel memory allocation
96	memory.kmem.failcnt show the number of kernel memory usage	103	memory.kmem.failcnt show the number of kernel memory usage
97	hits limits	104	hits limits

Documentation/arch/arm64/cpu-feature-registers.rst+12−0

      +------------------------------+---------+---------+
      | Name                         |  bits   | visible |
      +------------------------------+---------+---------+
+     | SME                          | [27-24] |    y    |
+     +------------------------------+---------+---------+
      | MTE                          | [11-8]  |    y    |
      +------------------------------+---------+---------+
      | SSBS                         | [7-4]   |    y    |
      +------------------------------+---------+---------+
      | Name                         |  bits   | visible |
      +------------------------------+---------+---------+
+     | CSSC                         | [55-52] |    y    |
+     +------------------------------+---------+---------+
+     | RPRFM                        | [51-48] |    y    |
+     +------------------------------+---------+---------+
+     | BC                           | [23-20] |    y    |
+     +------------------------------+---------+---------+
      | MOPS                         | [19-16] |    y    |
      +------------------------------+---------+---------+
+     | APA3                         | [15-12] |    y    |
+     +------------------------------+---------+---------+
+     | GPA3                         | [11-8]  |    y    |
+     +------------------------------+---------+---------+
      | RPRES                        | [7-4]   |    y    |
      +------------------------------+---------+---------+
      | WFXT                         | [3-0]   |    y    |

Documentation/arch/arm64/elf_hwcaps.rst+3−0

@@ -305,6 +305,9 @@ HWCAP2_SMEF16F16 · 304 unmodified lines
305	HWCAP2_MOPS	305	HWCAP2_MOPS
306	Functionality implied by ID_AA64ISAR2_EL1.MOPS == 0b0001.	306	Functionality implied by ID_AA64ISAR2_EL1.MOPS == 0b0001.
307		307
		308	HWCAP2_HBC
		309	Functionality implied by ID_AA64ISAR2_EL1.BC == 0b0001.
		310
308	4. Unused AT_HWCAP bits	311	4. Unused AT_HWCAP bits
309	-----------------------	312	-----------------------
310		313

Documentation/arch/loongarch/introduction.rst+2−2

@@ -381,9 +381,9 @@ Documentation of LoongArch ISA: · 380 unmodified lines
381		381
382	Documentation of LoongArch ELF psABI:	382	Documentation of LoongArch ELF psABI:
383		383
384	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-CN.pdf (in Chinese)	384	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-CN.pdf (in Chinese)
385		385
386	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-EN.pdf (in English)	386	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-EN.pdf (in English)
387		387
388	Linux kernel repository of Loongson and LoongArch:	388	Linux kernel repository of Loongson and LoongArch:
389		389

Documentation/devicetree/bindings/ata/pata-common.yaml+1−0

@@ -38,6 +38,7 @@ patternProperties: · 37 unmodified lines
38	ID number 0 and the slave drive will have ID number 1. The PATA port	38	ID number 0 and the slave drive will have ID number 1. The PATA port
39	nodes will be named "ide-port".	39	nodes will be named "ide-port".
40	type: object	40	type: object
		41	additionalProperties: false
41		42
42	properties:	43	properties:
43	reg:	44	reg:

Documentation/devicetree/bindings/clock/renesas,5p35023.yaml+7−4

     maxItems: 1
   '#clock-cells':
+    description:
+      The index in the assigned-clocks is mapped to the output clock as below
+      0 - REF, 1 - SE1, 2 - SE2, 3 - SE3, 4 - DIFF1, 5 - DIFF2.
     const: 1
   clocks:
             reg = <0x68>;
             #clock-cells = <1>;
-            clocks = <&x1_x2>;
+            clocks = <&x1>;
             renesas,settings = [
                 80 00 11 19 4c 02 23 7f 83 19 08 a9 5f 25 24 bf
             assigned-clocks = <&versa3 0>, <&versa3 1>,
                               <&versa3 2>, <&versa3 3>,
                               <&versa3 4>, <&versa3 5>;
-            assigned-clock-rates = <12288000>, <25000000>,
+            assigned-clock-rates = <24000000>, <11289600>,
-                                   <12000000>, <11289600>,
+                                   <11289600>, <12000000>,
-                                   <11289600>, <24000000>;
+                                   <25000000>, <12288000>;
         };
     };

Documentation/devicetree/bindings/i2c/i2c-mxs.yaml+4−1

 maintainers:
   - Shawn Guo <shawnguo@kernel.org>
+allOf:
+  - $ref: /schemas/i2c/i2c-controller.yaml#
 properties:
   compatible:
     enum:
   - dmas
   - dma-names
-additionalProperties: false
+unevaluatedProperties: false
 examples:
   - |

Documentation/devicetree/bindings/iommu/arm,smmu.yaml+1−1

           contains:
             enum:
               - qcom,msm8998-smmu-v2
+              - qcom,sdm630-smmu-v2
     then:
       anyOf:
         - properties:
         compatible:
           contains:
             enum:
-              - qcom,sdm630-smmu-v2
               - qcom,sm6375-smmu-v2
     then:
       anyOf:

Documentation/devicetree/bindings/mfd/maxim,max77693.yaml+0−4

@@ -31,10 +31,6 @@ properties: · 30 unmodified lines
31	charger:	31	charger:
32	$ref: /schemas/power/supply/maxim,max77693.yaml	32	$ref: /schemas/power/supply/maxim,max77693.yaml
33		33
34	connector:
35	$ref: /schemas/connector/usb-connector.yaml#
36	unevaluatedProperties: false
37
38	led:	34	led:
39	$ref: /schemas/leds/maxim,max77693.yaml	35	$ref: /schemas/leds/maxim,max77693.yaml
40		36

Documentation/devicetree/bindings/soc/loongson/loongson,ls2k-pmc.yaml+37−6

@@ -11,11 +11,16 @@ maintainers: · 10 unmodified lines
11		11
12	properties:	12	properties:
13	compatible:	13	compatible:
14	items:	14	oneOf:
15	- enum:	15	- items:
16	- loongson,ls2k0500-pmc	16	- const: loongson,ls2k0500-pmc
17	- loongson,ls2k1000-pmc	17	- const: syscon
18	- const: syscon	18	- items:
		19	- enum:
		20	- loongson,ls2k1000-pmc
		21	- loongson,ls2k2000-pmc
		22	- const: loongson,ls2k0500-pmc
		23	- const: syscon
19		24
20	reg:	25	reg:
21	maxItems: 1	26	maxItems: 1
@@ -32,6 +37,18 @@ properties: · 10 unmodified lines
32	addition, the PM need according to it to indicate that current	37	addition, the PM need according to it to indicate that current
33	SoC whether support Suspend To RAM.	38	SoC whether support Suspend To RAM.
34		39
		40	syscon-poweroff:
		41	$ref: /schemas/power/reset/syscon-poweroff.yaml#
		42	type: object
		43	description:
		44	Node for power off method
		45
		46	syscon-reboot:
		47	$ref: /schemas/power/reset/syscon-reboot.yaml#
		48	type: object
		49	description:
		50	Node for reboot method
		51
35	required:	52	required:
36	- compatible	53	- compatible
37	- reg	54	- reg
@@ -44,9 +61,23 @@ examples: · 6 unmodified lines
44	#include <dt-bindings/interrupt-controller/irq.h>	61	#include <dt-bindings/interrupt-controller/irq.h>
45		62
46	power-management@1fe27000 {	63	power-management@1fe27000 {
47	compatible = "loongson,ls2k1000-pmc", "syscon";	64	compatible = "loongson,ls2k1000-pmc", "loongson,ls2k0500-pmc", "syscon";
48	reg = <0x1fe27000 0x58>;	65	reg = <0x1fe27000 0x58>;
49	interrupt-parent = <&liointc1>;	66	interrupt-parent = <&liointc1>;
50	interrupts = <11 IRQ_TYPE_LEVEL_LOW>;	67	interrupts = <11 IRQ_TYPE_LEVEL_LOW>;
51	loongson,suspend-address = <0x0 0x1c000500>;	68	loongson,suspend-address = <0x0 0x1c000500>;
		69
		70	syscon-reboot {
		71	compatible = "syscon-reboot";
		72	offset = <0x30>;
		73	mask = <0x1>;
		74	};
		75
		76	syscon-poweroff {
		77	compatible = "syscon-poweroff";
		78	regmap = <&pmc>;
		79	offset = <0x14>;
		80	mask = <0x3c00>;
		81	value = <0x3c00>;
		82	};
52	};	83	};

Documentation/devicetree/bindings/spi/fsl-imx-cspi.yaml+7−0

@@ -22,6 +22,13 @@ properties: · 21 unmodified lines
22	- const: fsl,imx35-cspi	22	- const: fsl,imx35-cspi
23	- const: fsl,imx51-ecspi	23	- const: fsl,imx51-ecspi
24	- const: fsl,imx53-ecspi	24	- const: fsl,imx53-ecspi
		25	- items:
		26	- enum:
		27	- fsl,imx25-cspi
		28	- fsl,imx50-cspi
		29	- fsl,imx51-cspi
		30	- fsl,imx53-cspi
		31	- const: fsl,imx35-cspi
25	- items:	32	- items:
26	- const: fsl,imx8mp-ecspi	33	- const: fsl,imx8mp-ecspi
27	- const: fsl,imx6ul-ecspi	34	- const: fsl,imx6ul-ecspi

Documentation/filesystems/porting.rst+96−0

@@ -949,3 +949,99 @@ mmap_lock held. All in-tree users have been audited and do not seem to · 948 unmodified lines
949	depend on the mmap_lock being held, but out of tree users should verify	949	depend on the mmap_lock being held, but out of tree users should verify
950	for themselves. If they do need it, they can return VM_FAULT_RETRY to	950	for themselves. If they do need it, they can return VM_FAULT_RETRY to
951	be called with the mmap_lock held.	951	be called with the mmap_lock held.
		952
		953	---
		954
		955	mandatory
		956
		957	The order of opening block devices and matching or creating superblocks has
		958	changed.
		959
		960	The old logic opened block devices first and then tried to find a
		961	suitable superblock to reuse based on the block device pointer.
		962
		963	The new logic tries to find a suitable superblock first based on the device
		964	number, and opening the block device afterwards.
		965
		966	Since opening block devices cannot happen under s_umount because of lock
		967	ordering requirements s_umount is now dropped while opening block devices and
		968	reacquired before calling fill_super().
		969
		970	In the old logic concurrent mounters would find the superblock on the list of
		971	superblocks for the filesystem type. Since the first opener of the block device
		972	would hold s_umount they would wait until the superblock became either born or
		973	was discarded due to initialization failure.
		974
		975	Since the new logic drops s_umount concurrent mounters could grab s_umount and
		976	would spin. Instead they are now made to wait using an explicit wait-wake
		977	mechanism without having to hold s_umount.
		978
		979	---
		980
		981	mandatory
		982
		983	The holder of a block device is now the superblock.
		984
		985	The holder of a block device used to be the file_system_type which wasn't
		986	particularly useful. It wasn't possible to go from block device to owning
		987	superblock without matching on the device pointer stored in the superblock.
		988	This mechanism would only work for a single device so the block layer couldn't
		989	find the owning superblock of any additional devices.
		990
		991	In the old mechanism reusing or creating a superblock for a racing mount(2) and
		992	umount(2) relied on the file_system_type as the holder. This was severly
		993	underdocumented however:
		994
		995	(1) Any concurrent mounter that managed to grab an active reference on an
		996	existing superblock was made to wait until the superblock either became
		997	ready or until the superblock was removed from the list of superblocks of
		998	the filesystem type. If the superblock is ready the caller would simple
		999	reuse it.
		1000
		1001	(2) If the mounter came after deactivate_locked_super() but before
		1002	the superblock had been removed from the list of superblocks of the
		1003	filesystem type the mounter would wait until the superblock was shutdown,
		1004	reuse the block device and allocate a new superblock.
		1005
		1006	(3) If the mounter came after deactivate_locked_super() and after
		1007	the superblock had been removed from the list of superblocks of the
		1008	filesystem type the mounter would reuse the block device and allocate a new
		1009	superblock (the bd_holder point may still be set to the filesystem type).
		1010
		1011	Because the holder of the block device was the file_system_type any concurrent
		1012	mounter could open the block devices of any superblock of the same
		1013	file_system_type without risking seeing EBUSY because the block device was
		1014	still in use by another superblock.
		1015
		1016	Making the superblock the owner of the block device changes this as the holder
		1017	is now a unique superblock and thus block devices associated with it cannot be
		1018	reused by concurrent mounters. So a concurrent mounter in (2) could suddenly
		1019	see EBUSY when trying to open a block device whose holder was a different
		1020	superblock.
		1021
		1022	The new logic thus waits until the superblock and the devices are shutdown in
		1023	->kill_sb(). Removal of the superblock from the list of superblocks of the
		1024	filesystem type is now moved to a later point when the devices are closed:
		1025
		1026	(1) Any concurrent mounter managing to grab an active reference on an existing
		1027	superblock is made to wait until the superblock is either ready or until
		1028	the superblock and all devices are shutdown in ->kill_sb(). If the
		1029	superblock is ready the caller will simply reuse it.
		1030
		1031	(2) If the mounter comes after deactivate_locked_super() but before
		1032	the superblock has been removed from the list of superblocks of the
		1033	filesystem type the mounter is made to wait until the superblock and the
		1034	devices are shut down in ->kill_sb() and the superblock is removed from the
		1035	list of superblocks of the filesystem type. The mounter will allocate a new
		1036	superblock and grab ownership of the block device (the bd_holder pointer of
		1037	the block device will be set to the newly allocated superblock).
		1038
		1039	(3) This case is now collapsed into (2) as the superblock is left on the list
		1040	of superblocks of the filesystem type until all devices are shutdown in
		1041	->kill_sb(). In other words, if the superblock isn't on the list of
		1042	superblock of the filesystem type anymore then it has given up ownership of
		1043	all associated block devices (the bd_holder pointer is NULL).
		1044
		1045	As this is a VFS level change it has no practical consequences for filesystems
		1046	other than that all of them must use one of the provided kill_litter_super(),
		1047	kill_anon_super(), or kill_block_super() helpers.

Documentation/kbuild/kconfig-language.rst+26−0

@@ -573,6 +573,32 @@ above, leading to: · 572 unmodified lines
573	bool "Support for foo hardware"	573	bool "Support for foo hardware"
574	depends on ARCH_FOO_VENDOR \|\| COMPILE_TEST	574	depends on ARCH_FOO_VENDOR \|\| COMPILE_TEST
575		575
		576	Optional dependencies
		577	~~~~~~~~~~~~~~~~~~~~~
		578
		579	Some drivers are able to optionally use a feature from another module
		580	or build cleanly with that module disabled, but cause a link failure
		581	when trying to use that loadable module from a built-in driver.
		582
		583	The most common way to express this optional dependency in Kconfig logic
		584	uses the slightly counterintuitive::
		585
		586	config FOO
		587	tristate "Support for foo hardware"
		588	depends on BAR \|\| !BAR
		589
		590	This means that there is either a dependency on BAR that disallows
		591	the combination of FOO=y with BAR=m, or BAR is completely disabled.
		592	For a more formalized approach if there are multiple drivers that have
		593	the same dependency, a helper symbol can be used, like::
		594
		595	config FOO
		596	tristate "Support for foo hardware"
		597	depends on BAR_OPTIONAL
		598
		599	config BAR_OPTIONAL
		600	def_tristate BAR \|\| !BAR
		601
576	Kconfig recursive dependency limitations	602	Kconfig recursive dependency limitations
577	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	603	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
578		604

Documentation/tools/rtla/rtla-timerlat-hist.rst+2−2

@@ -36,11 +36,11 @@ EXAMPLE · 35 unmodified lines
36	In the example below, rtla timerlat hist is set to run for 10 minutes,	36	In the example below, rtla timerlat hist is set to run for 10 minutes,
37	in the cpus 0-4, skipping zero only lines. Moreover, **rtla timerlat	37	in the cpus 0-4, skipping zero only lines. Moreover, **rtla timerlat
38	hist** will change the priority of the timerlat threads to run under	38	hist** will change the priority of the timerlat threads to run under
39	SCHED_DEADLINE priority, with a 10us runtime every 1ms period. The	39	SCHED_DEADLINE priority, with a 100us runtime every 1ms period. The
40	1ms period is also passed to the timerlat tracer. Auto-analysis is disabled	40	1ms period is also passed to the timerlat tracer. Auto-analysis is disabled
41	to reduce overhead ::	41	to reduce overhead ::
42		42
43	[root@alien ~]# timerlat hist -d 10m -c 0-4 -P d:100us:1ms -p 1ms --no-aa	43	[root@alien ~]# timerlat hist -d 10m -c 0-4 -P d:100us:1ms -p 1000 --no-aa
44	# RTLA timerlat histogram	44	# RTLA timerlat histogram
45	# Time unit is microseconds (us)	45	# Time unit is microseconds (us)
46	# Duration: 0 00:10:00	46	# Duration: 0 00:10:00

Documentation/translations/zh_CN/arch/loongarch/introduction.rst+2−2

@@ -344,9 +344,9 @@ LoongArch指令集架构的文档： · 343 unmodified lines
344		344
345	LoongArch的ELF psABI文档：	345	LoongArch的ELF psABI文档：
346		346
347	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-CN.pdf （中文版）	347	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-CN.pdf （中文版）
348		348
349	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-EN.pdf （英文版）	349	https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-EN.pdf （英文版）
350		350
351	Loongson与LoongArch的Linux内核源码仓库：	351	Loongson与LoongArch的Linux内核源码仓库：
352		352

MAINTAINERS+14−18

 ADM8211 WIRELESS DRIVER
 L:	linux-wireless@vger.kernel.org
 S:	Orphan
-W:	https://wireless.wiki.kernel.org/
 F:	drivers/net/wireless/admtek/adm8211.*
 ADP1653 FLASH CONTROLLER DRIVER
 F:	arch/arm*/kernel/hw_breakpoint.c
 F:	arch/arm*/kernel/perf_*
 F:	drivers/perf/
-F:	include/linux/perf/arm_pmu.h
+F:	include/linux/perf/arm_pmu*.h
 ARM PORT
 M:	Russell King <linux@armlinux.org.uk>
 ARM/ASPEED MACHINE SUPPORT
 M:	Joel Stanley <joel@jms.id.au>
-R:	Andrew Jeffery <andrew@aj.id.au>
+R:	Andrew Jeffery <andrew@codeconstruct.com.au>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
 S:	Supported
 Q:	https://patchwork.ozlabs.org/project/linux-aspeed/list/
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joel/aspeed.git
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joel/bmc.git
 F:	Documentation/devicetree/bindings/arm/aspeed/
 F:	arch/arm/boot/dts/aspeed/
 F:	arch/arm/mach-aspeed/
 F:	drivers/peci/controller/peci-aspeed.c
 ASPEED PINCTRL DRIVERS
-M:	Andrew Jeffery <andrew@aj.id.au>
+M:	Andrew Jeffery <andrew@codeconstruct.com.au>
 L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
 L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
 L:	linux-gpio@vger.kernel.org
 F:	include/dt-bindings/interrupt-controller/aspeed-scu-ic.h
 ASPEED SD/MMC DRIVER
-M:	Andrew Jeffery <andrew@aj.id.au>
+M:	Andrew Jeffery <andrew@codeconstruct.com.au>
 L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
 L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
 L:	linux-mmc@vger.kernel.org
 BROADCOM BRCMSTB GPIO DRIVER
 M:	Doug Berger <opendmb@gmail.com>
-M:	Florian Fainelli <florian.fainelli@broadcom>
+M:	Florian Fainelli <florian.fainelli@broadcom.com>
 R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
 S:	Supported
 F:	Documentation/devicetree/bindings/gpio/brcm,brcmstb-gpio.yaml
 F:	drivers/gpu/drm/panel/panel-novatek-nt36672a.c
 DRM DRIVER FOR NVIDIA GEFORCE/QUADRO GPUS
-M:	Ben Skeggs <bskeggs@redhat.com>
 M:	Karol Herbst <kherbst@redhat.com>
 M:	Lyude Paul <lyude@redhat.com>
+M:	Danilo Krummrich <dakr@redhat.com>
 L:	dri-devel@lists.freedesktop.org
 L:	nouveau@lists.freedesktop.org
 S:	Supported
 F:	tools/testing/selftests/gpio/
 GPIO REGMAP
-R:	Michael Walle <michael@walle.cc>
+M:	Michael Walle <michael@walle.cc>
 S:	Maintained
 F:	drivers/gpio/gpio-regmap.c
 F:	include/linux/gpio/regmap.h
 F:	drivers/iio/pressure/mprls0025pa.c
 HOST AP DRIVER
-M:	Jouni Malinen <j@w1.fi>
 L:	linux-wireless@vger.kernel.org
 S:	Obsolete
-W:	http://w1.fi/hostap-driver.html
 F:	drivers/net/wireless/intersil/hostap/
 HP BIOSCFG DRIVER
 MELLANOX HARDWARE PLATFORM SUPPORT
 M:	Hans de Goede <hdegoede@redhat.com>
+M:	Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
 M:	Mark Gross <markgross@kernel.org>
 M:	Vadim Pasternak <vadimp@nvidia.com>
 L:	platform-driver-x86@vger.kernel.org
 MICROSOFT SURFACE HARDWARE PLATFORM SUPPORT
 M:	Hans de Goede <hdegoede@redhat.com>
+M:	Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
 M:	Mark Gross <markgross@kernel.org>
 M:	Maximilian Luz <luzmaximilian@gmail.com>
 L:	platform-driver-x86@vger.kernel.org
 K:	\bmdo_
 NETWORKING [MPTCP]
-M:	Matthieu Baerts <matthieu.baerts@tessares.net>
+M:	Matthieu Baerts <matttbe@kernel.org>
 M:	Mat Martineau <martineau@kernel.org>
 L:	netdev@vger.kernel.org
 L:	mptcp@lists.linux.dev
 M:	Jeff Johnson <quic_jjohnson@quicinc.com>
 L:	ath12k@lists.infradead.org
 S:	Supported
+W:	https://wireless.wiki.kernel.org/en/users/Drivers/ath12k
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
 F:	drivers/net/wireless/ath/ath12k/
 M:	Ping-Ke Shih <pkshih@realtek.com>
 L:	linux-wireless@vger.kernel.org
 S:	Maintained
-W:	https://wireless.wiki.kernel.org/
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-testing.git
 F:	drivers/net/wireless/realtek/rtlwifi/
 REALTEK WIRELESS DRIVER (rtw88)
 RTL8180 WIRELESS DRIVER
 L:	linux-wireless@vger.kernel.org
 S:	Orphan
-W:	https://wireless.wiki.kernel.org/
 F:	drivers/net/wireless/realtek/rtl818x/rtl8180/
 RTL8187 WIRELESS DRIVER
 M:	Larry Finger <Larry.Finger@lwfinger.net>
 L:	linux-wireless@vger.kernel.org
 S:	Maintained
-W:	https://wireless.wiki.kernel.org/
 F:	drivers/net/wireless/realtek/rtl818x/rtl8187/
 RTL8XXXU WIRELESS DRIVER (rtl8xxxu)
 M:	Jes Sorensen <Jes.Sorensen@gmail.com>
 L:	linux-wireless@vger.kernel.org
 S:	Maintained
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jes/linux.git rtl8xxxu-devel
 F:	drivers/net/wireless/realtek/rtl8xxxu/
 RTRS TRANSPORT DRIVERS
 S:	Orphan
 W:	https://wireless.wiki.kernel.org/en/users/Drivers/wl12xx
 W:	https://wireless.wiki.kernel.org/en/users/Drivers/wl1251
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/luca/wl12xx.git
 F:	drivers/net/wireless/ti/
 TIMEKEEPING, CLOCKSOURCE CORE, NTP, ALARMTIMER
 X86 PLATFORM DRIVERS
 M:	Hans de Goede <hdegoede@redhat.com>
+M:	Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
 M:	Mark Gross <markgross@kernel.org>
 L:	platform-driver-x86@vger.kernel.org
 S:	Maintained
+Q:	https://patchwork.kernel.org/project/platform-driver-x86/list/
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git
 F:	drivers/platform/olpc/
 F:	drivers/platform/x86/

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 6	2	VERSION = 6
3	PATCHLEVEL = 6	3	PATCHLEVEL = 6
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc2	5	EXTRAVERSION = -rc4
6	NAME = Hurr durr I'ma ninja sloth	6	NAME = Hurr durr I'ma ninja sloth
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/boot/dts/ti/omap/motorola-mapphone-common.dtsi+3−2

 /* Configure pwm clock source for timers 8 & 9 */
 &timer8 {
 	assigned-clocks = <&abe_clkctrl OMAP4_TIMER8_CLKCTRL 24>;
-	assigned-clock-parents = <&sys_clkin_ck>;
+	assigned-clock-parents = <&sys_32k_ck>;
 };
 &timer9 {
 	assigned-clocks = <&l4_per_clkctrl OMAP4_TIMER9_CLKCTRL 24>;
-	assigned-clock-parents = <&sys_clkin_ck>;
+	assigned-clock-parents = <&sys_32k_ck>;
 };
 /*
 &uart3 {
 	interrupts-extended = <&wakeupgen GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH
 			       &omap4_pmx_core 0x17c>;
+	overrun-throttle-ms = <500>;
 };
 &uart4 {

arch/arm/boot/dts/ti/omap/omap3-cpu-thermal.dtsi+1−2

@@ -12,8 +12,7 @@ cpu_thermal: cpu-thermal { · 11 unmodified lines
12	polling-delay = <1000>; /* milliseconds */	12	polling-delay = <1000>; /* milliseconds */
13	coefficients = <0 20000>;	13	coefficients = <0 20000>;
14		14
15	/* sensor ID */	15	thermal-sensors = <&bandgap>;
16	thermal-sensors = <&bandgap 0>;
17		16
18	cpu_trips: trips {	17	cpu_trips: trips {
19	cpu_alert0: cpu_alert {	18	cpu_alert0: cpu_alert {

arch/arm/boot/dts/ti/omap/omap4-cpu-thermal.dtsi+4−1

 	polling-delay-passive = <250>; /* milliseconds */
 	polling-delay = <1000>; /* milliseconds */
-			/* sensor       ID */
+	/*
+	 * See 44xx files for single sensor addressing, omap5 and dra7 need
+	 * also sensor ID for addressing.
+	 */
 	thermal-sensors = <&bandgap     0>;
 	cpu_trips: trips {

arch/arm/boot/dts/ti/omap/omap443x.dtsi+1−0

@@ -69,6 +69,7 @@ · 68 unmodified lines
69	};	69	};
70		70
71	&cpu_thermal {	71	&cpu_thermal {
		72	thermal-sensors = <&bandgap>;
72	coefficients = <0 20000>;	73	coefficients = <0 20000>;
73	};	74	};
74		75

arch/arm/boot/dts/ti/omap/omap4460.dtsi+1−0

@@ -79,6 +79,7 @@ · 78 unmodified lines
79	};	79	};
80		80
81	&cpu_thermal {	81	&cpu_thermal {
		82	thermal-sensors = <&bandgap>;
82	coefficients = <348 (-9301)>;	83	coefficients = <348 (-9301)>;
83	};	84	};
84		85

arch/arm/include/asm/hardware/locomo.h+1−1

@@ -195,7 +195,7 @@ struct locomo_driver { · 194 unmodified lines
195		195
196	#define LOCOMO_DRIVER_NAME(_ldev) ((_ldev)->dev.driver->name)	196	#define LOCOMO_DRIVER_NAME(_ldev) ((_ldev)->dev.driver->name)
197		197
198	void locomo_lcd_power(struct locomo_dev *, int, unsigned int);	198	extern void locomolcd_power(int on);
199		199
200	int locomo_driver_register(struct locomo_driver *);	200	int locomo_driver_register(struct locomo_driver *);
201	void locomo_driver_unregister(struct locomo_driver *);	201	void locomo_driver_unregister(struct locomo_driver *);

arch/arm/mach-omap2/pm44xx.c+2−2

@@ -99,7 +99,7 @@ static int omap4_pm_suspend(void) · 98 unmodified lines
99	* possible causes.	99	* possible causes.
100	* http://www.spinics.net/lists/arm-kernel/msg218641.html	100	* http://www.spinics.net/lists/arm-kernel/msg218641.html
101	*/	101	*/
102	pr_warn("A possible cause could be an old bootloader - try u-boot >= v2012.07\n");	102	pr_debug("A possible cause could be an old bootloader - try u-boot >= v2012.07\n");
103	} else {	103	} else {
104	pr_info("Successfully put all powerdomains to target state\n");	104	pr_info("Successfully put all powerdomains to target state\n");
105	}	105	}
@@ -257,7 +257,7 @@ int __init omap4_pm_init(void) · 151 unmodified lines
257	* http://www.spinics.net/lists/arm-kernel/msg218641.html	257	* http://www.spinics.net/lists/arm-kernel/msg218641.html
258	*/	258	*/
259	if (cpu_is_omap44xx())	259	if (cpu_is_omap44xx())
260	pr_warn("OMAP4 PM: u-boot >= v2012.07 is required for full PM support\n");	260	pr_debug("OMAP4 PM: u-boot >= v2012.07 is required for full PM support\n");
261		261
262	ret = pwrdm_for_each(pwrdms_setup, NULL);	262	ret = pwrdm_for_each(pwrdms_setup, NULL);
263	if (ret) {	263	if (ret) {

arch/arm/mach-sa1100/include/mach/collie.h+0−2

@@ -16,8 +16,6 @@ · 15 unmodified lines
16		16
17	#include "hardware.h" /* Gives GPIO_MAX */	17	#include "hardware.h" /* Gives GPIO_MAX */
18		18
19	extern void locomolcd_power(int on);
20
21	#define COLLIE_SCOOP_GPIO_BASE (GPIO_MAX + 1)	19	#define COLLIE_SCOOP_GPIO_BASE (GPIO_MAX + 1)
22	#define COLLIE_GPIO_CHARGE_ON (COLLIE_SCOOP_GPIO_BASE + 0)	20	#define COLLIE_GPIO_CHARGE_ON (COLLIE_SCOOP_GPIO_BASE + 0)
23	#define COLLIE_SCP_DIAG_BOOT1 SCOOP_GPCR_PA12	21	#define COLLIE_SCP_DIAG_BOOT1 SCOOP_GPCR_PA12

arch/arm/mm/cache-uniphier.c+3−1

 		((op & UNIPHIER_SSCOQM_S_MASK) == UNIPHIER_SSCOQM_S_RANGE)
 /**
- * uniphier_cache_data - UniPhier outer cache specific data
+ * struct uniphier_cache_data - UniPhier outer cache specific data
  *
  * @ctrl_base: virtual base address of control registers
  * @rev_base: virtual base address of revision registers
  * @op_base: virtual base address of operation registers
+ * @way_ctrl_base: virtual address of the way control registers for this
+ *	SoC revision
  * @way_mask: each bit specifies if the way is present
  * @nsets: number of associativity sets
  * @line_size: line size in bytes

arch/arm64/boot/dts/freescale/Makefile+1−0

@@ -66,6 +66,7 @@ dtb-$(CONFIG_ARCH_MXC) += imx8mm-mx8menlo.dtb · 65 unmodified lines
66	dtb-$(CONFIG_ARCH_MXC) += imx8mm-nitrogen-r2.dtb	66	dtb-$(CONFIG_ARCH_MXC) += imx8mm-nitrogen-r2.dtb
67	dtb-$(CONFIG_ARCH_MXC) += imx8mm-phg.dtb	67	dtb-$(CONFIG_ARCH_MXC) += imx8mm-phg.dtb
68	dtb-$(CONFIG_ARCH_MXC) += imx8mm-phyboard-polis-rdk.dtb	68	dtb-$(CONFIG_ARCH_MXC) += imx8mm-phyboard-polis-rdk.dtb
		69	dtb-$(CONFIG_ARCH_MXC) += imx8mm-prt8mm.dtb
69	dtb-$(CONFIG_ARCH_MXC) += imx8mm-tqma8mqml-mba8mx.dtb	70	dtb-$(CONFIG_ARCH_MXC) += imx8mm-tqma8mqml-mba8mx.dtb
70	dtb-$(CONFIG_ARCH_MXC) += imx8mm-var-som-symphony.dtb	71	dtb-$(CONFIG_ARCH_MXC) += imx8mm-var-som-symphony.dtb
71	dtb-$(CONFIG_ARCH_MXC) += imx8mm-venice-gw71xx-0x.dtb	72	dtb-$(CONFIG_ARCH_MXC) += imx8mm-venice-gw71xx-0x.dtb

arch/arm64/boot/dts/freescale/imx8mm-evk.dtsi+20−12

@@ -26,7 +26,7 @@ · 25 unmodified lines
26		26
27	port {	27	port {
28	hdmi_connector_in: endpoint {	28	hdmi_connector_in: endpoint {
29	remote-endpoint = <&adv7533_out>;	29	remote-endpoint = <&adv7535_out>;
30	};	30	};
31	};	31	};
32	};	32	};
@@ -72,6 +72,13 @@ · 39 unmodified lines
72	enable-active-high;	72	enable-active-high;
73	};	73	};
74		74
		75	reg_vddext_3v3: regulator-vddext-3v3 {
		76	compatible = "regulator-fixed";
		77	regulator-name = "VDDEXT_3V3";
		78	regulator-min-microvolt = <3300000>;
		79	regulator-max-microvolt = <3300000>;
		80	};
		81
75	backlight: backlight {	82	backlight: backlight {
76	compatible = "pwm-backlight";	83	compatible = "pwm-backlight";
77	pwms = <&pwm1 0 5000000 0>;	84	pwms = <&pwm1 0 5000000 0>;
@@ -317,15 +324,16 @@ · 239 unmodified lines
317		324
318	hdmi@3d {	325	hdmi@3d {
319	compatible = "adi,adv7535";	326	compatible = "adi,adv7535";
320	reg = <0x3d>, <0x3c>, <0x3e>, <0x3f>;	327	reg = <0x3d>;
321	reg-names = "main", "cec", "edid", "packet";	328	interrupt-parent = <&gpio1>;
		329	interrupts = <9 IRQ_TYPE_EDGE_FALLING>;
322	adi,dsi-lanes = <4>;	330	adi,dsi-lanes = <4>;
323		331	avdd-supply = <&buck5_reg>;
324	adi,input-depth = <8>;	332	dvdd-supply = <&buck5_reg>;
325	adi,input-colorspace = "rgb";	333	pvdd-supply = <&buck5_reg>;
326	adi,input-clock = "1x";	334	a2vdd-supply = <&buck5_reg>;
327	adi,input-style = <1>;	335	v3p3-supply = <&reg_vddext_3v3>;
328	adi,input-justification = "evenly";	336	v1p2-supply = <&buck5_reg>;
329		337
330	ports {	338	ports {
331	#address-cells = <1>;	339	#address-cells = <1>;
@@ -334,7 +342,7 @@ · 2 unmodified lines
334	port@0 {	342	port@0 {
335	reg = <0>;	343	reg = <0>;
336		344
337	adv7533_in: endpoint {	345	adv7535_in: endpoint {
338	remote-endpoint = <&dsi_out>;	346	remote-endpoint = <&dsi_out>;
339	};	347	};
340	};	348	};
@@ -342,7 +350,7 @@ · 1 unmodified line
342	port@1 {	350	port@1 {
343	reg = <1>;	351	reg = <1>;
344		352
345	adv7533_out: endpoint {	353	adv7535_out: endpoint {
346	remote-endpoint = <&hdmi_connector_in>;	354	remote-endpoint = <&hdmi_connector_in>;
347	};	355	};
348	};	356	};
@@ -448,7 +456,7 @@ · 99 unmodified lines
448	reg = <1>;	456	reg = <1>;
449		457
450	dsi_out: endpoint {	458	dsi_out: endpoint {
451	remote-endpoint = <&adv7533_in>;	459	remote-endpoint = <&adv7535_in>;
452	data-lanes = <1 2 3 4>;	460	data-lanes = <1 2 3 4>;
453	};	461	};
454	};	462	};

arch/arm64/boot/dts/freescale/imx8mp-beacon-kit.dts+3−2

 &sai3 {
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_sai3>;
-	assigned-clocks = <&clk IMX8MP_CLK_SAI3>;
+	assigned-clocks = <&clk IMX8MP_CLK_SAI3>,
+			  <&clk IMX8MP_AUDIO_PLL2> ;
 	assigned-clock-parents = <&clk IMX8MP_AUDIO_PLL2_OUT>;
-	assigned-clock-rates = <12288000>;
+	assigned-clock-rates = <12288000>, <361267200>;
 	fsl,sai-mclk-direction-output;
 	status = "okay";
 };

arch/arm64/boot/dts/freescale/imx8mp.dtsi+6−0

 						reg = <IMX8MP_POWER_DOMAIN_AUDIOMIX>;
 						clocks = <&clk IMX8MP_CLK_AUDIO_ROOT>,
 							 <&clk IMX8MP_CLK_AUDIO_AXI>;
+						assigned-clocks = <&clk IMX8MP_CLK_AUDIO_AHB>,
+								  <&clk IMX8MP_CLK_AUDIO_AXI_SRC>;
+						assigned-clock-parents =  <&clk IMX8MP_SYS_PLL1_800M>,
+									  <&clk IMX8MP_SYS_PLL1_800M>;
+						assigned-clock-rates = <400000000>,
+								       <600000000>;
 					};
 					pgc_gpu2d: power-domain@6 {

arch/arm64/boot/dts/freescale/imx93-tqma9352.dtsi+1−1

@@ -81,7 +81,7 @@ · 80 unmodified lines
81	&gpio1 {	81	&gpio1 {
82	pmic-irq-hog {	82	pmic-irq-hog {
83	gpio-hog;	83	gpio-hog;
84	gpios = <2 GPIO_ACTIVE_LOW>;	84	gpios = <3 GPIO_ACTIVE_LOW>;
85	input;	85	input;
86	line-name = "PMIC_IRQ#";	86	line-name = "PMIC_IRQ#";
87	};	87	};

arch/arm64/boot/dts/mediatek/mt8195.dtsi+5−5

arch/arm64/configs/defconfig+1−1

 CONFIG_POWER_RESET_QCOM_PON=m
 CONFIG_POWER_RESET_XGENE=y
 CONFIG_POWER_RESET_SYSCON=y
+CONFIG_POWER_RESET_SYSCON_POWEROFF=y
 CONFIG_SYSCON_REBOOT_MODE=y
 CONFIG_NVMEM_REBOOT_MODE=m
 CONFIG_BATTERY_SBS=m
 CONFIG_COMMON_CLK_PWM=y
 CONFIG_COMMON_CLK_RS9_PCIE=y
 CONFIG_COMMON_CLK_VC5=y
-CONFIG_COMMON_CLK_NPCM8XX=y
 CONFIG_COMMON_CLK_BD718XX=m
 CONFIG_CLK_RASPBERRYPI=m
 CONFIG_CLK_IMX8MM=y

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

@@ -663,7 +663,7 @@ static inline bool supports_clearbhb(int scope) · 662 unmodified lines
663	isar2 = read_sanitised_ftr_reg(SYS_ID_AA64ISAR2_EL1);	663	isar2 = read_sanitised_ftr_reg(SYS_ID_AA64ISAR2_EL1);
664		664
665	return cpuid_feature_extract_unsigned_field(isar2,	665	return cpuid_feature_extract_unsigned_field(isar2,
666	ID_AA64ISAR2_EL1_BC_SHIFT);	666	ID_AA64ISAR2_EL1_CLRBHB_SHIFT);
667	}	667	}
668		668
669	const struct cpumask *system_32bit_el0_cpumask(void);	669	const struct cpumask *system_32bit_el0_cpumask(void);

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

@@ -28,7 +28,7 @@ pte_t arch_make_huge_pte(pte_t entry, unsigned int shift, vm_flags_t flags); · 27 unmodified lines
28	#define arch_make_huge_pte arch_make_huge_pte	28	#define arch_make_huge_pte arch_make_huge_pte
29	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT	29	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT
30	extern void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,	30	extern void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
31	pte_t *ptep, pte_t pte);	31	pte_t *ptep, pte_t pte, unsigned long sz);
32	#define __HAVE_ARCH_HUGE_PTEP_SET_ACCESS_FLAGS	32	#define __HAVE_ARCH_HUGE_PTEP_SET_ACCESS_FLAGS
33	extern int huge_ptep_set_access_flags(struct vm_area_struct *vma,	33	extern int huge_ptep_set_access_flags(struct vm_area_struct *vma,
34	unsigned long addr, pte_t *ptep,	34	unsigned long addr, pte_t *ptep,

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

@@ -118,7 +118,7 @@ void deactivate_traps_vhe_put(struct kvm_vcpu *vcpu); · 117 unmodified lines
118		118
119	u64 __guest_enter(struct kvm_vcpu *vcpu);	119	u64 __guest_enter(struct kvm_vcpu *vcpu);
120		120
121	bool kvm_host_psci_handler(struct kvm_cpu_context *host_ctxt);	121	bool kvm_host_psci_handler(struct kvm_cpu_context *host_ctxt, u32 func_id);
122		122
123	#ifdef __KVM_NVHE_HYPERVISOR__	123	#ifdef __KVM_NVHE_HYPERVISOR__
124	void __noreturn __hyp_do_panic(struct kvm_cpu_context *host_ctxt, u64 spsr,	124	void __noreturn __hyp_do_panic(struct kvm_cpu_context *host_ctxt, u64 spsr,

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

 static const struct arm64_ftr_bits ftr_id_aa64isar2[] = {
 	ARM64_FTR_BITS(FTR_VISIBLE, FTR_NONSTRICT, FTR_LOWER_SAFE, ID_AA64ISAR2_EL1_CSSC_SHIFT, 4, 0),
 	ARM64_FTR_BITS(FTR_VISIBLE, FTR_NONSTRICT, FTR_LOWER_SAFE, ID_AA64ISAR2_EL1_RPRFM_SHIFT, 4, 0),
-	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_HIGHER_SAFE, ID_AA64ISAR2_EL1_BC_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_HIDDEN, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ISAR2_EL1_CLRBHB_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ISAR2_EL1_BC_SHIFT, 4, 0),
 	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ISAR2_EL1_MOPS_SHIFT, 4, 0),
 	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_PTR_AUTH),
 		       FTR_STRICT, FTR_EXACT, ID_AA64ISAR2_EL1_APA3_SHIFT, 4, 0),

arch/arm64/kvm/hyp/include/nvhe/ffa.h+1−1

@@ -12,6 +12,6 @@ · 11 unmodified lines
12	#define FFA_MAX_FUNC_NUM 0x7F	12	#define FFA_MAX_FUNC_NUM 0x7F
13		13
14	int hyp_ffa_init(void *pages);	14	int hyp_ffa_init(void *pages);
15	bool kvm_host_ffa_handler(struct kvm_cpu_context *host_ctxt);	15	bool kvm_host_ffa_handler(struct kvm_cpu_context *host_ctxt, u32 func_id);
16		16
17	#endif /* __KVM_HYP_FFA_H */	17	#endif /* __KVM_HYP_FFA_H */

arch/arm64/kvm/hyp/nvhe/ffa.c+1−2

@@ -634,9 +634,8 @@ out_handled: · 633 unmodified lines
634	return true;	634	return true;
635	}	635	}
636		636
637	bool kvm_host_ffa_handler(struct kvm_cpu_context *host_ctxt)	637	bool kvm_host_ffa_handler(struct kvm_cpu_context *host_ctxt, u32 func_id)
638	{	638	{
639	DECLARE_REG(u64, func_id, host_ctxt, 0);
640	struct arm_smccc_res res;	639	struct arm_smccc_res res;
641		640
642	/*	641	/*

arch/arm64/kvm/hyp/nvhe/hyp-init.S+1−0

@@ -57,6 +57,7 @@ __do_hyp_init: · 56 unmodified lines
57	cmp x0, #HVC_STUB_HCALL_NR	57	cmp x0, #HVC_STUB_HCALL_NR
58	b.lo __kvm_handle_stub_hvc	58	b.lo __kvm_handle_stub_hvc
59		59
		60	bic x0, x0, #ARM_SMCCC_CALL_HINTS
60	mov x3, #KVM_HOST_SMCCC_FUNC(__kvm_hyp_init)	61	mov x3, #KVM_HOST_SMCCC_FUNC(__kvm_hyp_init)
61	cmp x0, x3	62	cmp x0, x3
62	b.eq 1f	63	b.eq 1f

arch/arm64/kvm/hyp/nvhe/hyp-main.c+6−2

 	if (static_branch_unlikely(&kvm_protected_mode_initialized))
 		hcall_min = __KVM_HOST_SMCCC_FUNC___pkvm_prot_finalize;
+	id &= ~ARM_SMCCC_CALL_HINTS;
 	id -= KVM_HOST_SMCCC_ID(0);
 	if (unlikely(id < hcall_min || id >= ARRAY_SIZE(host_hcall)))
 static void handle_host_smc(struct kvm_cpu_context *host_ctxt)
 {
+	DECLARE_REG(u64, func_id, host_ctxt, 0);
 	bool handled;
-	handled = kvm_host_psci_handler(host_ctxt);
+	func_id &= ~ARM_SMCCC_CALL_HINTS;
+	handled = kvm_host_psci_handler(host_ctxt, func_id);
 	if (!handled)
-		handled = kvm_host_ffa_handler(host_ctxt);
+		handled = kvm_host_ffa_handler(host_ctxt, func_id);
 	if (!handled)
 		default_host_smc_handler(host_ctxt);

arch/arm64/kvm/hyp/nvhe/psci-relay.c+1−2

@@ -273,9 +273,8 @@ static unsigned long psci_1_0_handler(u64 func_id, struct kvm_cpu_context *host_ · 272 unmodified lines
273	}	273	}
274	}	274	}
275		275
276	bool kvm_host_psci_handler(struct kvm_cpu_context *host_ctxt)	276	bool kvm_host_psci_handler(struct kvm_cpu_context *host_ctxt, u32 func_id)
277	{	277	{
278	DECLARE_REG(u64, func_id, host_ctxt, 0);
279	unsigned long ret;	278	unsigned long ret;
280		279
281	switch (kvm_host_psci_config.version) {	280	switch (kvm_host_psci_config.version) {

arch/arm64/kvm/mmu.c+3−0

@@ -652,6 +652,9 @@ int hyp_alloc_private_va_range(size_t size, unsigned long *haddr) · 651 unmodified lines
652		652
653	mutex_unlock(&kvm_hyp_pgd_mutex);	653	mutex_unlock(&kvm_hyp_pgd_mutex);
654		654
		655	if (!ret)
		656	*haddr = base;
		657
655	return ret;	658	return ret;
656	}	659	}
657		660

arch/arm64/mm/hugetlbpage.c+7−16

 	flush_tlb_range(&vma, saddr, addr);
 }
-static inline struct folio *hugetlb_swap_entry_to_folio(swp_entry_t entry)
-{
-	VM_BUG_ON(!is_migration_entry(entry) && !is_hwpoison_entry(entry));
-	return page_folio(pfn_to_page(swp_offset_pfn(entry)));
-}
 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
-			    pte_t *ptep, pte_t pte)
+			    pte_t *ptep, pte_t pte, unsigned long sz)
 {
 	size_t pgsize;
 	int i;
 	unsigned long pfn, dpfn;
 	pgprot_t hugeprot;
-	if (!pte_present(pte)) {
+	ncontig = num_contig_ptes(sz, &pgsize);
-		struct folio *folio;
-		folio = hugetlb_swap_entry_to_folio(pte_to_swp_entry(pte));
-		ncontig = num_contig_ptes(folio_size(folio), &pgsize);
-		for (i = 0; i < ncontig; i++, ptep++)
+	if (!pte_present(pte)) {
+		for (i = 0; i < ncontig; i++, ptep++, addr += pgsize)
 			set_pte_at(mm, addr, ptep, pte);
 		return;
 	}
 		return;
 	}
-	ncontig = find_num_contig(mm, addr, ptep, &pgsize);
 	pfn = pte_pfn(pte);
 	dpfn = pgsize >> PAGE_SHIFT;
 	hugeprot = pte_pgprot(pte);
 void huge_ptep_modify_prot_commit(struct vm_area_struct *vma, unsigned long addr, pte_t *ptep,
 				  pte_t old_pte, pte_t pte)
 {
-	set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
+	unsigned long psize = huge_page_size(hstate_vma(vma));
+	set_huge_pte_at(vma->vm_mm, addr, ptep, pte, psize);
 }

arch/arm64/tools/sysreg+5−1

 	0b0000	NI
 	0b0001	IMP
 EndEnum
-Res0	47:28
+Res0	47:32
+UnsignedEnum	31:28	CLRBHB
+	0b0000	NI
+	0b0001	IMP
+EndEnum
 UnsignedEnum	27:24	PAC_frac
 	0b0000	NI
 	0b0001	IMP

arch/ia64/kernel/acpi.c+4−0

@@ -907,3 +907,7 @@ EXPORT_SYMBOL(acpi_unregister_ioapic); · 906 unmodified lines
907	* TBD when IA64 starts to support suspend...	907	* TBD when IA64 starts to support suspend...
908	*/	908	*/
909	int acpi_suspend_lowlevel(void) { return 0; }	909	int acpi_suspend_lowlevel(void) { return 0; }
		910
		911	void acpi_proc_quirk_mwait_check(void)
		912	{
		913	}

arch/loongarch/include/asm/addrspace.h+6−6

  */
 #ifndef __ASSEMBLY__
 #ifndef PHYS_OFFSET
-#define PHYS_OFFSET	_AC(0, UL)
+#define PHYS_OFFSET	_UL(0)
 #endif
 extern unsigned long vm_map_base;
 #endif /* __ASSEMBLY__ */
  * Memory above this physical address will be considered highmem.
  */
 #ifndef HIGHMEM_START
-#define HIGHMEM_START		(_AC(1, UL) << _AC(DMW_PABITS, UL))
+#define HIGHMEM_START		(_UL(1) << _UL(DMW_PABITS))
 #endif
 #define TO_PHYS(x)		(		((x) & TO_PHYS_MASK))
 #define _ATYPE_
 #define _ATYPE32_
 #define _ATYPE64_
-#define _CONST64_(x)	x
 #else
 #define _ATYPE_		__PTRDIFF_TYPE__
 #define _ATYPE32_	int
 #define _ATYPE64_	__s64
+#endif
 #ifdef CONFIG_64BIT
-#define _CONST64_(x)	x ## UL
+#define _CONST64_(x)	_UL(x)
 #else
-#define _CONST64_(x)	x ## ULL
+#define _CONST64_(x)	_ULL(x)
-#endif
 #endif
 /*

arch/loongarch/include/asm/elf.h+9−0

@@ -111,6 +111,15 @@ · 110 unmodified lines
111	#define R_LARCH_TLS_GD_HI20 98	111	#define R_LARCH_TLS_GD_HI20 98
112	#define R_LARCH_32_PCREL 99	112	#define R_LARCH_32_PCREL 99
113	#define R_LARCH_RELAX 100	113	#define R_LARCH_RELAX 100
		114	#define R_LARCH_DELETE 101
		115	#define R_LARCH_ALIGN 102
		116	#define R_LARCH_PCREL20_S2 103
		117	#define R_LARCH_CFA 104
		118	#define R_LARCH_ADD6 105
		119	#define R_LARCH_SUB6 106
		120	#define R_LARCH_ADD_ULEB128 107
		121	#define R_LARCH_SUB_ULEB128 108
		122	#define R_LARCH_64_PCREL 109
114		123
115	#ifndef ELF_ARCH	124	#ifndef ELF_ARCH
116		125

arch/loongarch/include/asm/exception.h+45−0

@@ -0,0 +1,45 @@
	1	/* SPDX-License-Identifier: GPL-2.0-only */
	2
	3	#ifndef __ASM_EXCEPTION_H
	4	#define __ASM_EXCEPTION_H
	5
	6	#include <asm/ptrace.h>
	7	#include <linux/kprobes.h>
	8
	9	void show_registers(struct pt_regs *regs);
	10
	11	asmlinkage void cache_parity_error(void);
	12	asmlinkage void noinstr do_ade(struct pt_regs *regs);
	13	asmlinkage void noinstr do_ale(struct pt_regs *regs);
	14	asmlinkage void noinstr do_bce(struct pt_regs *regs);
	15	asmlinkage void noinstr do_bp(struct pt_regs *regs);
	16	asmlinkage void noinstr do_ri(struct pt_regs *regs);
	17	asmlinkage void noinstr do_fpu(struct pt_regs *regs);
	18	asmlinkage void noinstr do_fpe(struct pt_regs *regs, unsigned long fcsr);
	19	asmlinkage void noinstr do_lsx(struct pt_regs *regs);
	20	asmlinkage void noinstr do_lasx(struct pt_regs *regs);
	21	asmlinkage void noinstr do_lbt(struct pt_regs *regs);
	22	asmlinkage void noinstr do_watch(struct pt_regs *regs);
	23	asmlinkage void noinstr do_syscall(struct pt_regs *regs);
	24	asmlinkage void noinstr do_reserved(struct pt_regs *regs);
	25	asmlinkage void noinstr do_vint(struct pt_regs *regs, unsigned long sp);
	26	asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
	27	unsigned long write, unsigned long address);
	28
	29	asmlinkage void handle_ade(void);
	30	asmlinkage void handle_ale(void);
	31	asmlinkage void handle_bce(void);
	32	asmlinkage void handle_sys(void);
	33	asmlinkage void handle_bp(void);
	34	asmlinkage void handle_ri(void);
	35	asmlinkage void handle_fpu(void);
	36	asmlinkage void handle_fpe(void);
	37	asmlinkage void handle_lsx(void);
	38	asmlinkage void handle_lasx(void);
	39	asmlinkage void handle_lbt(void);
	40	asmlinkage void handle_watch(void);
	41	asmlinkage void handle_reserved(void);
	42	asmlinkage void handle_vint(void);
	43	asmlinkage void noinstr handle_loongarch_irq(struct pt_regs *regs);
	44
	45	#endif /* __ASM_EXCEPTION_H */

arch/loongarch/include/asm/kasan.h+9−50

@@ -10,8 +10,6 @@ · 9 unmodified lines
10	#include <asm/io.h>	10	#include <asm/io.h>
11	#include <asm/pgtable.h>	11	#include <asm/pgtable.h>
12		12
13	#define __HAVE_ARCH_SHADOW_MAP
14
15	#define KASAN_SHADOW_SCALE_SHIFT 3	13	#define KASAN_SHADOW_SCALE_SHIFT 3
16	#define KASAN_SHADOW_OFFSET _AC(CONFIG_KASAN_SHADOW_OFFSET, UL)	14	#define KASAN_SHADOW_OFFSET _AC(CONFIG_KASAN_SHADOW_OFFSET, UL)
17		15
@@ -62,61 +60,22 @@ · 44 unmodified lines
62	extern bool kasan_early_stage;	60	extern bool kasan_early_stage;
63	extern unsigned char kasan_early_shadow_page[PAGE_SIZE];	61	extern unsigned char kasan_early_shadow_page[PAGE_SIZE];
64		62
		63	#define kasan_mem_to_shadow kasan_mem_to_shadow
		64	void kasan_mem_to_shadow(const void addr);
		65
		66	#define kasan_shadow_to_mem kasan_shadow_to_mem
		67	const void kasan_shadow_to_mem(const void shadow_addr);
		68
65	#define kasan_arch_is_ready kasan_arch_is_ready	69	#define kasan_arch_is_ready kasan_arch_is_ready
66	static __always_inline bool kasan_arch_is_ready(void)	70	static __always_inline bool kasan_arch_is_ready(void)
67	{	71	{
68	return !kasan_early_stage;	72	return !kasan_early_stage;
69	}	73	}
70		74
71	static inline void kasan_mem_to_shadow(const void addr)	75	#define addr_has_metadata addr_has_metadata
72	{	76	static __always_inline bool addr_has_metadata(const void *addr)
73	if (!kasan_arch_is_ready()) {
74	return (void *)(kasan_early_shadow_page);
75	} else {
76	unsigned long maddr = (unsigned long)addr;
77	unsigned long xrange = (maddr >> XRANGE_SHIFT) & 0xffff;
78	unsigned long offset = 0;
79
80	maddr &= XRANGE_SHADOW_MASK;
81	switch (xrange) {
82	case XKPRANGE_CC_SEG:
83	offset = XKPRANGE_CC_SHADOW_OFFSET;
84	break;
85	case XKPRANGE_UC_SEG:
86	offset = XKPRANGE_UC_SHADOW_OFFSET;
87	break;
88	case XKVRANGE_VC_SEG:
89	offset = XKVRANGE_VC_SHADOW_OFFSET;
90	break;
91	default:
92	WARN_ON(1);
93	return NULL;
94	}
95
96	return (void *)((maddr >> KASAN_SHADOW_SCALE_SHIFT) + offset);
97	}
98	}
99
100	static inline const void kasan_shadow_to_mem(const void shadow_addr)
101	{	77	{
102	unsigned long addr = (unsigned long)shadow_addr;	78	return (kasan_mem_to_shadow((void *)addr) != NULL);
103
104	if (unlikely(addr > KASAN_SHADOW_END) \|\|
105	unlikely(addr < KASAN_SHADOW_START)) {
106	WARN_ON(1);
107	return NULL;
108	}
109
110	if (addr >= XKVRANGE_VC_SHADOW_OFFSET)
111	return (void *)(((addr - XKVRANGE_VC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKVRANGE_VC_START);
112	else if (addr >= XKPRANGE_UC_SHADOW_OFFSET)
113	return (void *)(((addr - XKPRANGE_UC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_UC_START);
114	else if (addr >= XKPRANGE_CC_SHADOW_OFFSET)
115	return (void *)(((addr - XKPRANGE_CC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_CC_START);
116	else {
117	WARN_ON(1);
118	return NULL;
119	}
120	}	79	}
121		80
122	void kasan_init(void);	81	void kasan_init(void);

arch/loongarch/include/asm/smp.h+1−0

@@ -70,6 +70,7 @@ struct secondary_data { · 69 unmodified lines
70	extern struct secondary_data cpuboot_data;	70	extern struct secondary_data cpuboot_data;
71		71
72	extern asmlinkage void smpboot_entry(void);	72	extern asmlinkage void smpboot_entry(void);
		73	extern asmlinkage void start_secondary(void);
73		74
74	extern void calculate_cpu_foreign_map(void);	75	extern void calculate_cpu_foreign_map(void);
75		76

arch/loongarch/kernel/Makefile+4−0

@@ -19,6 +19,10 @@ obj-$(CONFIG_CPU_HAS_LBT) += lbt.o · 18 unmodified lines
19		19
20	obj-$(CONFIG_ARCH_STRICT_ALIGN) += unaligned.o	20	obj-$(CONFIG_ARCH_STRICT_ALIGN) += unaligned.o
21		21
		22	CFLAGS_module.o += $(call cc-option,-Wno-override-init,)
		23	CFLAGS_syscall.o += $(call cc-option,-Wno-override-init,)
		24	CFLAGS_perf_event.o += $(call cc-option,-Wno-override-init,)
		25
22	ifdef CONFIG_FUNCTION_TRACER	26	ifdef CONFIG_FUNCTION_TRACER
23	ifndef CONFIG_DYNAMIC_FTRACE	27	ifndef CONFIG_DYNAMIC_FTRACE
24	obj-y += mcount.o ftrace.o	28	obj-y += mcount.o ftrace.o

arch/loongarch/kernel/acpi.c+0−1

@@ -281,7 +281,6 @@ acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa) · 280 unmodified lines
281	pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u\n", pxm, pa->apic_id, node);	281	pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u\n", pxm, pa->apic_id, node);
282	}	282	}
283		283
284	void __init acpi_numa_arch_fixup(void) {}
285	#endif	284	#endif
286		285
287	void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)	286	void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)

arch/loongarch/kernel/mem.c+3−1

 	}
 	memblock_set_current_limit(PFN_PHYS(max_low_pfn));
-	memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0);
 	/* Reserve the first 2MB */
 	memblock_reserve(PHYS_OFFSET, 0x200000);
 	/* Reserve the kernel text/data/bss */
 	memblock_reserve(__pa_symbol(&_text),
 			 __pa_symbol(&_end) - __pa_symbol(&_text));
+	memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0);
+	memblock_set_node(0, PHYS_ADDR_MAX, &memblock.reserved, 0);
 }

arch/loongarch/kernel/module-sections.c+1−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	#include <linux/elf.h>	6	#include <linux/elf.h>
7	#include <linux/kernel.h>	7	#include <linux/kernel.h>
8	#include <linux/module.h>	8	#include <linux/module.h>
		9	#include <linux/moduleloader.h>
9	#include <linux/ftrace.h>	10	#include <linux/ftrace.h>
10		11
11	Elf_Addr module_emit_got_entry(struct module mod, Elf_Shdr sechdrs, Elf_Addr val)	12	Elf_Addr module_emit_got_entry(struct module mod, Elf_Shdr sechdrs, Elf_Addr val)

arch/loongarch/kernel/module.c+21−1

@@ -367,6 +367,24 @@ static int apply_r_larch_got_pc(struct module *mod, · 366 unmodified lines
367	return apply_r_larch_pcala(mod, location, got, rela_stack, rela_stack_top, type);	367	return apply_r_larch_pcala(mod, location, got, rela_stack, rela_stack_top, type);
368	}	368	}
369		369
		370	static int apply_r_larch_32_pcrel(struct module mod, u32 location, Elf_Addr v,
		371	s64 rela_stack, size_t rela_stack_top, unsigned int type)
		372	{
		373	ptrdiff_t offset = (void )v - (void )location;
		374
		375	(u32 )location = offset;
		376	return 0;
		377	}
		378
		379	static int apply_r_larch_64_pcrel(struct module mod, u32 location, Elf_Addr v,
		380	s64 rela_stack, size_t rela_stack_top, unsigned int type)
		381	{
		382	ptrdiff_t offset = (void )v - (void )location;
		383
		384	(u64 )location = offset;
		385	return 0;
		386	}
		387
370	/*	388	/*
371	* reloc_handlers_rela() - Apply a particular relocation to a module	389	* reloc_handlers_rela() - Apply a particular relocation to a module
372	* @mod: the module to apply the reloc to	390	* @mod: the module to apply the reloc to
@@ -382,7 +400,7 @@ typedef int (reloc_rela_handler)(struct module mod, u32 *location, Elf_Addr v, · 9 unmodified lines
382		400
383	/* The handlers for known reloc types */	401	/* The handlers for known reloc types */
384	static reloc_rela_handler reloc_rela_handlers[] = {	402	static reloc_rela_handler reloc_rela_handlers[] = {
385	[R_LARCH_NONE ... R_LARCH_RELAX] = apply_r_larch_error,	403	[R_LARCH_NONE ... R_LARCH_64_PCREL] = apply_r_larch_error,
386		404
387	[R_LARCH_NONE] = apply_r_larch_none,	405	[R_LARCH_NONE] = apply_r_larch_none,
388	[R_LARCH_32] = apply_r_larch_32,	406	[R_LARCH_32] = apply_r_larch_32,
@@ -396,6 +414,8 @@ static reloc_rela_handler reloc_rela_handlers[] = { · 7 unmodified lines
396	[R_LARCH_SOP_POP_32_S_10_5 ... R_LARCH_SOP_POP_32_U] = apply_r_larch_sop_imm_field,	414	[R_LARCH_SOP_POP_32_S_10_5 ... R_LARCH_SOP_POP_32_U] = apply_r_larch_sop_imm_field,
397	[R_LARCH_ADD32 ... R_LARCH_SUB64] = apply_r_larch_add_sub,	415	[R_LARCH_ADD32 ... R_LARCH_SUB64] = apply_r_larch_add_sub,
398	[R_LARCH_PCALA_HI20...R_LARCH_PCALA64_HI12] = apply_r_larch_pcala,	416	[R_LARCH_PCALA_HI20...R_LARCH_PCALA64_HI12] = apply_r_larch_pcala,
		417	[R_LARCH_32_PCREL] = apply_r_larch_32_pcrel,
		418	[R_LARCH_64_PCREL] = apply_r_larch_64_pcrel,
399	};	419	};
400		420
401	int apply_relocate_add(Elf_Shdr sechdrs, const char strtab,	421	int apply_relocate_add(Elf_Shdr sechdrs, const char strtab,

arch/loongarch/kernel/numa.c+1−1

@@ -436,7 +436,7 @@ void __init paging_init(void) · 435 unmodified lines
436		436
437	void __init mem_init(void)	437	void __init mem_init(void)
438	{	438	{
439	high_memory = (void *) __va(get_num_physpages() << PAGE_SHIFT);	439	high_memory = (void *) __va(max_low_pfn << PAGE_SHIFT);
440	memblock_free_all();	440	memblock_free_all();
441	}	441	}
442		442

arch/loongarch/kernel/process.c+1−0

@@ -37,6 +37,7 @@ · 36 unmodified lines
37	#include <asm/bootinfo.h>	37	#include <asm/bootinfo.h>
38	#include <asm/cpu.h>	38	#include <asm/cpu.h>
39	#include <asm/elf.h>	39	#include <asm/elf.h>
		40	#include <asm/exec.h>
40	#include <asm/fpu.h>	41	#include <asm/fpu.h>
41	#include <asm/lbt.h>	42	#include <asm/lbt.h>
42	#include <asm/io.h>	43	#include <asm/io.h>

arch/loongarch/kernel/relocate_kernel.S+0−1

@@ -72,7 +72,6 @@ copy_word: · 71 unmodified lines
72	LONG_ADDI s5, s5, -1	72	LONG_ADDI s5, s5, -1
73	beqz s5, process_entry	73	beqz s5, process_entry
74	b copy_word	74	b copy_word
75	b process_entry
76		75
77	done:	76	done:
78	ibar 0	77	ibar 0

arch/loongarch/kernel/signal.c+4−3

 #include <linux/audit.h>
 #include <linux/cache.h>
 #include <linux/context_tracking.h>
+#include <linux/entry-common.h>
 #include <linux/irqflags.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
 	return new_sp;
 }
-void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
+static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
-			  struct extctx_layout *extctx)
+				 struct extctx_layout *extctx)
 {
 	unsigned long sp;
  * Atomically swap in the new signal mask, and wait for a signal.
  */
-asmlinkage long sys_rt_sigreturn(void)
+SYSCALL_DEFINE0(rt_sigreturn)
 {
 	int sig;
 	sigset_t set;

arch/loongarch/kernel/smp.c+3−0

 #include <linux/cpumask.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/profile.h>
 #include <linux/seq_file.h>
 #include <linux/smp.h>
 #include <linux/threads.h>
 	smp_call_function(stop_this_cpu, NULL, 0);
 }
+#ifdef CONFIG_PROFILING
 int setup_profiling_timer(unsigned int multiplier)
 {
 	return 0;
 }
+#endif
 static void flush_tlb_all_ipi(void *info)
 {

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

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	#include <linux/unistd.h>	13	#include <linux/unistd.h>
14		14
15	#include <asm/asm.h>	15	#include <asm/asm.h>
		16	#include <asm/exception.h>
16	#include <asm/signal.h>	17	#include <asm/signal.h>
17	#include <asm/switch_to.h>	18	#include <asm/switch_to.h>
18	#include <asm-generic/syscalls.h>	19	#include <asm-generic/syscalls.h>

arch/loongarch/kernel/time.c+1−1

@@ -29,7 +29,7 @@ static void constant_event_handler(struct clock_event_device *dev) · 28 unmodified lines
29	{	29	{
30	}	30	}
31		31
32	irqreturn_t constant_timer_interrupt(int irq, void *data)	32	static irqreturn_t constant_timer_interrupt(int irq, void *data)
33	{	33	{
34	int cpu = smp_processor_id();	34	int cpu = smp_processor_id();
35	struct clock_event_device *cd;	35	struct clock_event_device *cd;

arch/loongarch/kernel/topology.c+3−0

 // SPDX-License-Identifier: GPL-2.0
+#include <linux/acpi.h>
 #include <linux/cpu.h>
 #include <linux/cpumask.h>
 #include <linux/init.h>
 #include <linux/percpu.h>
 #include <asm/bootinfo.h>
+#include <acpi/processor.h>
 static DEFINE_PER_CPU(struct cpu, cpu_devices);
 #ifdef CONFIG_HOTPLUG_CPU

arch/loongarch/kernel/traps.c+5−20

 #include <linux/ptrace.h>
 #include <linux/kgdb.h>
 #include <linux/kdebug.h>
-#include <linux/kprobes.h>
 #include <linux/notifier.h>
 #include <linux/irq.h>
 #include <linux/perf_event.h>
 #include <asm/branch.h>
 #include <asm/break.h>
 #include <asm/cpu.h>
+#include <asm/exception.h>
 #include <asm/fpu.h>
 #include <asm/lbt.h>
 #include <asm/inst.h>
 #include "access-helper.h"
-extern asmlinkage void handle_ade(void);
-extern asmlinkage void handle_ale(void);
-extern asmlinkage void handle_bce(void);
-extern asmlinkage void handle_sys(void);
-extern asmlinkage void handle_bp(void);
-extern asmlinkage void handle_ri(void);
-extern asmlinkage void handle_fpu(void);
-extern asmlinkage void handle_fpe(void);
-extern asmlinkage void handle_lbt(void);
-extern asmlinkage void handle_lsx(void);
-extern asmlinkage void handle_lasx(void);
-extern asmlinkage void handle_reserved(void);
-extern asmlinkage void handle_watch(void);
-extern asmlinkage void handle_vint(void);
 static void show_backtrace(struct task_struct *task, const struct pt_regs *regs,
 			   const char *loglvl, bool user)
 {
  * happen together with Overflow or Underflow, and `ptrace' can set
  * any bits.
  */
-void force_fcsr_sig(unsigned long fcsr, void __user *fault_addr,
+static void force_fcsr_sig(unsigned long fcsr,
-		     struct task_struct *tsk)
+			void __user *fault_addr, struct task_struct *tsk)
 {
 	int si_code = FPE_FLTUNK;
 	force_sig_fault(SIGFPE, si_code, fault_addr);
 }
-int process_fpemu_return(int sig, void __user *fault_addr, unsigned long fcsr)
+static int process_fpemu_return(int sig, void __user *fault_addr, unsigned long fcsr)
 {
 	int si_code;
 asmlinkage void noinstr do_ri(struct pt_regs *regs)
 {
 	int status = SIGILL;
-	unsigned int opcode = 0;
+	unsigned int __maybe_unused opcode;
 	unsigned int __user *era = (unsigned int __user *)exception_era(regs);
 	irqentry_state_t state = irqentry_enter(regs);

arch/loongarch/kernel/vmlinux.lds.S+28−27

 	. = ALIGN(PECOFF_SEGMENT_ALIGN);
 	_etext = .;
-	/*
-	 * struct alt_inst entries. From the header (alternative.h):
-	 * "Alternative instructions for different CPU types or capabilities"
-	 * Think locking instructions on spinlocks.
-	 */
-	. = ALIGN(4);
-	.altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) {
-		__alt_instructions = .;
-		*(.altinstructions)
-		__alt_instructions_end = .;
-	}
-#ifdef CONFIG_RELOCATABLE
-	. = ALIGN(8);
-	.la_abs : AT(ADDR(.la_abs) - LOAD_OFFSET) {
-		__la_abs_begin = .;
-		*(.la_abs)
-		__la_abs_end = .;
-	}
-#endif
-	.got : ALIGN(16) { *(.got) }
-	.plt : ALIGN(16) { *(.plt) }
-	.got.plt : ALIGN(16) { *(.got.plt) }
-	.data.rel : { *(.data.rel*) }
 	. = ALIGN(PECOFF_SEGMENT_ALIGN);
 	__init_begin = .;
 	__inittext_begin = .;
 	__initdata_begin = .;
+	/*
+	 * struct alt_inst entries. From the header (alternative.h):
+	 * "Alternative instructions for different CPU types or capabilities"
+	 * Think locking instructions on spinlocks.
+	 */
+	. = ALIGN(4);
+	.altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) {
+		__alt_instructions = .;
+		*(.altinstructions)
+		__alt_instructions_end = .;
+	}
 	INIT_DATA_SECTION(16)
 	.exit.data : {
 		EXIT_DATA
 	_sdata = .;
 	RO_DATA(4096)
+	.got : ALIGN(16) { *(.got) }
+	.plt : ALIGN(16) { *(.plt) }
+	.got.plt : ALIGN(16) { *(.got.plt) }
 	RW_DATA(1 << CONFIG_L1_CACHE_SHIFT, PAGE_SIZE, THREAD_SIZE)
 	.rela.dyn : ALIGN(8) {
 		__rela_dyn_end = .;
 	}
+	.data.rel : { *(.data.rel*) }
+#ifdef CONFIG_RELOCATABLE
+	. = ALIGN(8);
+	.la_abs : AT(ADDR(.la_abs) - LOAD_OFFSET) {
+		__la_abs_begin = .;
+		*(.la_abs)
+		__la_abs_end = .;
+	}
+#endif
 	.sdata : {
 		*(.sdata)
 	}

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

 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/kdebug.h>
-#include <linux/kprobes.h>
 #include <linux/perf_event.h>
 #include <linux/uaccess.h>
 #include <linux/kfence.h>
 #include <asm/branch.h>
+#include <asm/exception.h>
 #include <asm/mmu_context.h>
 #include <asm/ptrace.h>

arch/loongarch/mm/hugetlbpage.c+0−12

@@ -50,18 +50,6 @@ pte_t huge_pte_offset(struct mm_struct mm, unsigned long addr, · 49 unmodified lines
50	return (pte_t *) pmd;	50	return (pte_t *) pmd;
51	}	51	}
52		52
53	/*
54	* This function checks for proper alignment of input addr and len parameters.
55	*/
56	int is_aligned_hugepage_range(unsigned long addr, unsigned long len)
57	{
58	if (len & ~HPAGE_MASK)
59	return -EINVAL;
60	if (addr & ~HPAGE_MASK)
61	return -EINVAL;
62	return 0;
63	}
64
65	int pmd_huge(pmd_t pmd)	53	int pmd_huge(pmd_t pmd)
66	{	54	{
67	return (pmd_val(pmd) & _PAGE_HUGE) != 0;	55	return (pmd_val(pmd) & _PAGE_HUGE) != 0;

arch/loongarch/mm/ioremap.c+1−0

@@ -4,6 +4,7 @@ · 3 unmodified lines
4	*/	4	*/
5		5
6	#include <asm/io.h>	6	#include <asm/io.h>
		7	#include <asm-generic/early_ioremap.h>
7		8
8	void __init __iomem *early_ioremap(u64 phys_addr, unsigned long size)	9	void __init __iomem *early_ioremap(u64 phys_addr, unsigned long size)
9	{	10	{

arch/loongarch/mm/kasan_init.c+51−0

@@ -35,6 +35,57 @@ static pgd_t kasan_pg_dir[PTRS_PER_PGD] __initdata __aligned(PAGE_SIZE); · 34 unmodified lines
35		35
36	bool kasan_early_stage = true;	36	bool kasan_early_stage = true;
37		37
		38	void kasan_mem_to_shadow(const void addr)
		39	{
		40	if (!kasan_arch_is_ready()) {
		41	return (void *)(kasan_early_shadow_page);
		42	} else {
		43	unsigned long maddr = (unsigned long)addr;
		44	unsigned long xrange = (maddr >> XRANGE_SHIFT) & 0xffff;
		45	unsigned long offset = 0;
		46
		47	maddr &= XRANGE_SHADOW_MASK;
		48	switch (xrange) {
		49	case XKPRANGE_CC_SEG:
		50	offset = XKPRANGE_CC_SHADOW_OFFSET;
		51	break;
		52	case XKPRANGE_UC_SEG:
		53	offset = XKPRANGE_UC_SHADOW_OFFSET;
		54	break;
		55	case XKVRANGE_VC_SEG:
		56	offset = XKVRANGE_VC_SHADOW_OFFSET;
		57	break;
		58	default:
		59	WARN_ON(1);
		60	return NULL;
		61	}
		62
		63	return (void *)((maddr >> KASAN_SHADOW_SCALE_SHIFT) + offset);
		64	}
		65	}
		66
		67	const void kasan_shadow_to_mem(const void shadow_addr)
		68	{
		69	unsigned long addr = (unsigned long)shadow_addr;
		70
		71	if (unlikely(addr > KASAN_SHADOW_END) \|\|
		72	unlikely(addr < KASAN_SHADOW_START)) {
		73	WARN_ON(1);
		74	return NULL;
		75	}
		76
		77	if (addr >= XKVRANGE_VC_SHADOW_OFFSET)
		78	return (void *)(((addr - XKVRANGE_VC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKVRANGE_VC_START);
		79	else if (addr >= XKPRANGE_UC_SHADOW_OFFSET)
		80	return (void *)(((addr - XKPRANGE_UC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_UC_START);
		81	else if (addr >= XKPRANGE_CC_SHADOW_OFFSET)
		82	return (void *)(((addr - XKPRANGE_CC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_CC_START);
		83	else {
		84	WARN_ON(1);
		85	return NULL;
		86	}
		87	}
		88
38	/*	89	/*
39	* Alloc memory for shadow memory page table.	90	* Alloc memory for shadow memory page table.
40	*/	91	*/

arch/loongarch/mm/tlb.c+1−1

@@ -261,7 +261,7 @@ unsigned long pcpu_handlers[NR_CPUS]; · 260 unmodified lines
261	#endif	261	#endif
262	extern long exception_handlers[VECSIZE * 128 / sizeof(long)];	262	extern long exception_handlers[VECSIZE * 128 / sizeof(long)];
263		263
264	void setup_tlb_handler(int cpu)	264	static void setup_tlb_handler(int cpu)
265	{	265	{
266	setup_ptwalker();	266	setup_ptwalker();
267	local_flush_tlb_all();	267	local_flush_tlb_all();

arch/mips/alchemy/devboards/db1000.c+4−0

 /******************************************************************************/
+#ifdef CONFIG_MMC_AU1X
 static irqreturn_t db1100_mmc_cd(int irq, void *ptr)
 {
 	mmc_detect_change(ptr, msecs_to_jiffies(500));
 	.num_resources	= ARRAY_SIZE(au1100_mmc1_res),
 	.resource	= au1100_mmc1_res,
 };
+#endif /* CONFIG_MMC_AU1X */
 /******************************************************************************/
 static struct platform_device *db1100_devs[] = {
 	&au1100_lcd_device,
+#ifdef CONFIG_MMC_AU1X
 	&db1100_mmc0_dev,
 	&db1100_mmc1_dev,
+#endif
 };
 int __init db1000_dev_setup(void)

arch/mips/alchemy/devboards/db1200.c+6−0

 /**********************************************************************/
+#ifdef CONFIG_MMC_AU1X
 /* SD carddetects:  they're supposed to be edge-triggered, but ack
  * doesn't seem to work (CPLD Rev 2).  Instead, the screaming one
  * is disabled and its counterpart enabled.  The 200ms timeout is
 	.num_resources	= ARRAY_SIZE(au1200_mmc1_res),
 	.resource	= au1200_mmc1_res,
 };
+#endif /* CONFIG_MMC_AU1X */
 /**********************************************************************/
 static struct platform_device *db1200_devs[] __initdata = {
 	NULL,		/* PSC0, selected by S6.8 */
 	&db1200_ide_dev,
+#ifdef CONFIG_MMC_AU1X
 	&db1200_mmc0_dev,
+#endif
 	&au1200_lcd_dev,
 	&db1200_eth_dev,
 	&db1200_nand_dev,
 };
 static struct platform_device *pb1200_devs[] __initdata = {
+#ifdef CONFIG_MMC_AU1X
 	&pb1200_mmc1_dev,
+#endif
 };
 /* Some peripheral base addresses differ on the PB1200 */

arch/mips/alchemy/devboards/db1300.c+4−0

 /**********************************************************************/
+#ifdef CONFIG_MMC_AU1X
 static irqreturn_t db1300_mmc_cd(int irq, void *ptr)
 {
 	disable_irq_nosync(irq);
 	.resource	= au1300_sd0_res,
 	.num_resources	= ARRAY_SIZE(au1300_sd0_res),
 };
+#endif /* CONFIG_MMC_AU1X */
 /**********************************************************************/
 	&db1300_5waysw_dev,
 	&db1300_nand_dev,
 	&db1300_ide_dev,
+#ifdef CONFIG_MMC_AU1X
 	&db1300_sd0_dev,
 	&db1300_sd1_dev,
+#endif
 	&db1300_lcd_dev,
 	&db1300_ac97_dev,
 	&db1300_i2s_dev,

arch/parisc/include/asm/hugetlb.h+1−1

@@ -6,7 +6,7 @@ · 5 unmodified lines
6		6
7	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT	7	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT
8	void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,	8	void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
9	pte_t *ptep, pte_t pte);	9	pte_t *ptep, pte_t pte, unsigned long sz);
10		10
11	#define __HAVE_ARCH_HUGE_PTEP_GET_AND_CLEAR	11	#define __HAVE_ARCH_HUGE_PTEP_GET_AND_CLEAR
12	pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,	12	pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,

arch/parisc/mm/hugetlbpage.c+1−1

@@ -140,7 +140,7 @@ static void __set_huge_pte_at(struct mm_struct *mm, unsigned long addr, · 139 unmodified lines
140	}	140	}
141		141
142	void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,	142	void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
143	pte_t *ptep, pte_t entry)	143	pte_t *ptep, pte_t entry, unsigned long sz)
144	{	144	{
145	__set_huge_pte_at(mm, addr, ptep, entry);	145	__set_huge_pte_at(mm, addr, ptep, entry);
146	}	146	}

arch/powerpc/include/asm/nohash/32/hugetlb-8xx.h+2−1

@@ -46,7 +46,8 @@ static inline int check_and_get_huge_psize(int shift) · 45 unmodified lines
46	}	46	}
47		47
48	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT	48	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT
49	void set_huge_pte_at(struct mm_struct mm, unsigned long addr, pte_t ptep, pte_t pte);	49	void set_huge_pte_at(struct mm_struct mm, unsigned long addr, pte_t ptep,
		50	pte_t pte, unsigned long sz);
50		51
51	#define __HAVE_ARCH_HUGE_PTE_CLEAR	52	#define __HAVE_ARCH_HUGE_PTE_CLEAR
52	static inline void huge_pte_clear(struct mm_struct *mm, unsigned long addr,	53	static inline void huge_pte_clear(struct mm_struct *mm, unsigned long addr,

arch/powerpc/kernel/stacktrace.c+5−22

@@ -73,29 +73,12 @@ int __no_sanitize_address arch_stack_walk_reliable(stack_trace_consume_fn consum · 72 unmodified lines
73	bool firstframe;	73	bool firstframe;
74		74
75	stack_end = stack_page + THREAD_SIZE;	75	stack_end = stack_page + THREAD_SIZE;
76	if (!is_idle_task(task)) {	76
77	/*	77	// See copy_thread() for details.
78	* For user tasks, this is the SP value loaded on	78	if (task->flags & PF_KTHREAD)
79	* kernel entry, see "PACAKSAVE(r13)" in _switch() and
80	* system_call_common().
81	*
82	* Likewise for non-swapper kernel threads,
83	* this also happens to be the top of the stack
84	* as setup by copy_thread().
85	*
86	* Note that stack backlinks are not properly setup by
87	* copy_thread() and thus, a forked task() will have
88	* an unreliable stack trace until it's been
89	* _switch()'ed to for the first time.
90	*/
91	stack_end -= STACK_USER_INT_FRAME_SIZE;
92	} else {
93	/*
94	* idle tasks have a custom stack layout,
95	* c.f. cpu_idle_thread_init().
96	*/
97	stack_end -= STACK_FRAME_MIN_SIZE;	79	stack_end -= STACK_FRAME_MIN_SIZE;
98	}	80	else
		81	stack_end -= STACK_USER_INT_FRAME_SIZE;
99		82
100	if (task == current)	83	if (task == current)
101	sp = current_stack_frame();	84	sp = current_stack_frame();

arch/powerpc/mm/book3s64/hugetlbpage.c+4−1

@@ -143,11 +143,14 @@ pte_t huge_ptep_modify_prot_start(struct vm_area_struct *vma, · 142 unmodified lines
143	void huge_ptep_modify_prot_commit(struct vm_area_struct *vma, unsigned long addr,	143	void huge_ptep_modify_prot_commit(struct vm_area_struct *vma, unsigned long addr,
144	pte_t *ptep, pte_t old_pte, pte_t pte)	144	pte_t *ptep, pte_t old_pte, pte_t pte)
145	{	145	{
		146	unsigned long psize;
146		147
147	if (radix_enabled())	148	if (radix_enabled())
148	return radix__huge_ptep_modify_prot_commit(vma, addr, ptep,	149	return radix__huge_ptep_modify_prot_commit(vma, addr, ptep,
149	old_pte, pte);	150	old_pte, pte);
150	set_huge_pte_at(vma->vm_mm, addr, ptep, pte);	151
		152	psize = huge_page_size(hstate_vma(vma));
		153	set_huge_pte_at(vma->vm_mm, addr, ptep, pte, psize);
151	}	154	}
152		155
153	void __init hugetlbpage_init_defaultsize(void)	156	void __init hugetlbpage_init_defaultsize(void)

arch/powerpc/mm/book3s64/radix_hugetlbpage.c+2−1

 					 pte_t old_pte, pte_t pte)
 {
 	struct mm_struct *mm = vma->vm_mm;
+	unsigned long psize = huge_page_size(hstate_vma(vma));
 	/*
 	 * POWER9 NMMU must flush the TLB after clearing the PTE before
 	    atomic_read(&mm->context.copros) > 0)
 		radix__flush_hugetlb_page(vma, addr);
-	set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
+	set_huge_pte_at(vma->vm_mm, addr, ptep, pte, psize);
 }

arch/powerpc/mm/nohash/8xx.c+2−1

@@ -91,7 +91,8 @@ static int __ref __early_map_kernel_hugepage(unsigned long va, phys_addr_t pa, · 90 unmodified lines
91	if (new && WARN_ON(pte_present(*ptep) && pgprot_val(prot)))	91	if (new && WARN_ON(pte_present(*ptep) && pgprot_val(prot)))
92	return -EINVAL;	92	return -EINVAL;
93		93
94	set_huge_pte_at(&init_mm, va, ptep, pte_mkhuge(pfn_pte(pa >> PAGE_SHIFT, prot)));	94	set_huge_pte_at(&init_mm, va, ptep,
		95	pte_mkhuge(pfn_pte(pa >> PAGE_SHIFT, prot)), psize);
95		96
96	return 0;	97	return 0;
97	}	98	}

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

@@ -288,7 +288,8 @@ int huge_ptep_set_access_flags(struct vm_area_struct *vma, · 287 unmodified lines
288	}	288	}
289		289
290	#if defined(CONFIG_PPC_8xx)	290	#if defined(CONFIG_PPC_8xx)
291	void set_huge_pte_at(struct mm_struct mm, unsigned long addr, pte_t ptep, pte_t pte)	291	void set_huge_pte_at(struct mm_struct mm, unsigned long addr, pte_t ptep,
		292	pte_t pte, unsigned long sz)
292	{	293	{
293	pmd_t *pmd = pmd_off(mm, addr);	294	pmd_t *pmd = pmd_off(mm, addr);
294	pte_basic_t val;	295	pte_basic_t val;

arch/riscv/boot/dts/starfive/jh7110-starfive-visionfive-2.dtsi+26−25

 				reg = <0x100000 0x400000>;
 			};
 			reserved-data@600000 {
-				reg = <0x600000 0x1000000>;
+				reg = <0x600000 0xa00000>;
 			};
 		};
 	};
 		};
 	};
-	uart0_pins: uart0-0 {
-		tx-pins {
-			pinmux = <GPIOMUX(5, GPOUT_SYS_UART0_TX,
-					     GPOEN_ENABLE,
-					     GPI_NONE)>;
-			bias-disable;
-			drive-strength = <12>;
-			input-disable;
-			input-schmitt-disable;
-			slew-rate = <0>;
-		};
-		rx-pins {
-			pinmux = <GPIOMUX(6, GPOUT_LOW,
-					     GPOEN_DISABLE,
-					     GPI_SYS_UART0_RX)>;
-			bias-disable; /* external pull-up */
-			drive-strength = <2>;
-			input-enable;
-			input-schmitt-enable;
-			slew-rate = <0>;
-		};
-	};
 	tdm_pins: tdm-0 {
 		tx-pins {
 			pinmux = <GPIOMUX(44, GPOUT_SYS_TDM_TXD,
 			input-enable;
 		};
 	};
+	uart0_pins: uart0-0 {
+		tx-pins {
+			pinmux = <GPIOMUX(5, GPOUT_SYS_UART0_TX,
+					     GPOEN_ENABLE,
+					     GPI_NONE)>;
+			bias-disable;
+			drive-strength = <12>;
+			input-disable;
+			input-schmitt-disable;
+			slew-rate = <0>;
+		};
+		rx-pins {
+			pinmux = <GPIOMUX(6, GPOUT_LOW,
+					     GPOEN_DISABLE,
+					     GPI_SYS_UART0_RX)>;
+			bias-disable; /* external pull-up */
+			drive-strength = <2>;
+			input-enable;
+			input-schmitt-enable;
+			slew-rate = <0>;
+		};
+	};
 };
 &tdm {
 &usb0 {
 	dr_mode = "peripheral";
+	status = "okay";
 };
 &U74_1 {

arch/riscv/include/asm/hugetlb.h+2−1

@@ -18,7 +18,8 @@ void huge_pte_clear(struct mm_struct *mm, unsigned long addr, · 17 unmodified lines
18		18
19	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT	19	#define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT
20	void set_huge_pte_at(struct mm_struct *mm,	20	void set_huge_pte_at(struct mm_struct *mm,
21	unsigned long addr, pte_t *ptep, pte_t pte);	21	unsigned long addr, pte_t *ptep, pte_t pte,
		22	unsigned long sz);
22		23
23	#define __HAVE_ARCH_HUGE_PTEP_GET_AND_CLEAR	24	#define __HAVE_ARCH_HUGE_PTEP_GET_AND_CLEAR
24	pte_t huge_ptep_get_and_clear(struct mm_struct *mm,	25	pte_t huge_ptep_get_and_clear(struct mm_struct *mm,

arch/riscv/kvm/vcpu_onereg.c+5−2

 	    reg_num >= ARRAY_SIZE(kvm_isa_ext_arr))
 		return -ENOENT;
-	*reg_val = 0;
 	host_isa_ext = kvm_isa_ext_arr[reg_num];
+	if (!__riscv_isa_extension_available(NULL, host_isa_ext))
+		return -ENOENT;
+	*reg_val = 0;
 	if (__riscv_isa_extension_available(vcpu->arch.isa, host_isa_ext))
 		*reg_val = 1; /* Mark the given extension as available */
 		u64 reg = KVM_REG_RISCV | size | KVM_REG_RISCV_ISA_EXT | i;
 		isa_ext = kvm_isa_ext_arr[i];
-		if (!__riscv_isa_extension_available(vcpu->arch.isa, isa_ext))
+		if (!__riscv_isa_extension_available(NULL, isa_ext))
 			continue;
 		if (uindices) {

arch/riscv/mm/hugetlbpage.c+2−1

@@ -180,7 +180,8 @@ pte_t arch_make_huge_pte(pte_t entry, unsigned int shift, vm_flags_t flags) · 179 unmodified lines
180	void set_huge_pte_at(struct mm_struct *mm,	180	void set_huge_pte_at(struct mm_struct *mm,
181	unsigned long addr,	181	unsigned long addr,
182	pte_t *ptep,	182	pte_t *ptep,
183	pte_t pte)	183	pte_t pte,
		184	unsigned long sz)
184	{	185	{
185	int i, pte_num;	186	int i, pte_num;
186		187

arch/s390/configs/debug_defconfig+10−4

 CONFIG_EXPERT=y
 # CONFIG_SYSFS_SYSCALL is not set
 CONFIG_PROFILING=y
+CONFIG_KEXEC_FILE=y
+CONFIG_KEXEC_SIG=y
+CONFIG_CRASH_DUMP=y
 CONFIG_LIVEPATCH=y
 CONFIG_MARCH_ZEC12=y
 CONFIG_TUNE_ZEC12=y
 CONFIG_NR_CPUS=512
 CONFIG_NUMA=y
 CONFIG_HZ_100=y
-CONFIG_KEXEC_FILE=y
+CONFIG_CERT_STORE=y
-CONFIG_KEXEC_SIG=y
 CONFIG_EXPOLINE=y
 CONFIG_EXPOLINE_AUTO=y
 CONFIG_CHSC_SCH=y
 CONFIG_VFIO_CCW=m
 CONFIG_VFIO_AP=m
-CONFIG_CRASH_DUMP=y
 CONFIG_PROTECTED_VIRTUALIZATION_GUEST=y
 CONFIG_CMM=m
 CONFIG_APPLDATA_BASE=y
+CONFIG_S390_HYPFS_FS=y
 CONFIG_KVM=m
 CONFIG_S390_UNWIND_SELFTEST=m
 CONFIG_S390_KPROBES_SANITY_TEST=m
 CONFIG_SCSI_DH_ALUA=m
 CONFIG_MD=y
 CONFIG_BLK_DEV_MD=y
+# CONFIG_MD_BITMAP_FILE is not set
 CONFIG_MD_LINEAR=m
 CONFIG_MD_MULTIPATH=m
 CONFIG_MD_FAULTY=m
 CONFIG_DIAG288_WATCHDOG=m
 # CONFIG_DRM_DEBUG_MODESET_LOCK is not set
 CONFIG_FB=y
+# CONFIG_FB_DEVICE is not set
 CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_HID_SUPPORT is not set
 CONFIG_TMPFS=y
 CONFIG_TMPFS_POSIX_ACL=y
 CONFIG_TMPFS_INODE64=y
+CONFIG_TMPFS_QUOTA=y
 CONFIG_HUGETLBFS=y
 CONFIG_ECRYPT_FS=m
 CONFIG_CRAMFS=m
 CONFIG_IMA_APPRAISE=y
 CONFIG_LSM="yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
 CONFIG_INIT_STACK_NONE=y
+CONFIG_BUG_ON_DATA_CORRUPTION=y
 CONFIG_CRYPTO_USER=m
 # CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is not set
 CONFIG_CRYPTO_PCRYPT=m
 CONFIG_DEBUG_ATOMIC_SLEEP=y
 CONFIG_DEBUG_LOCKING_API_SELFTESTS=y
 CONFIG_DEBUG_IRQFLAGS=y
+CONFIG_DEBUG_LIST=y
 CONFIG_DEBUG_SG=y
 CONFIG_DEBUG_NOTIFIERS=y
-CONFIG_BUG_ON_DATA_CORRUPTION=y
 CONFIG_DEBUG_CREDENTIALS=y
 CONFIG_RCU_TORTURE_TEST=m
 CONFIG_RCU_REF_SCALE_TEST=m

arch/s390/configs/defconfig+9−4

 CONFIG_EXPERT=y
 # CONFIG_SYSFS_SYSCALL is not set
 CONFIG_PROFILING=y
+CONFIG_KEXEC_FILE=y
+CONFIG_KEXEC_SIG=y
+CONFIG_CRASH_DUMP=y
 CONFIG_LIVEPATCH=y
 CONFIG_MARCH_ZEC12=y
 CONFIG_TUNE_ZEC12=y
 CONFIG_NR_CPUS=512
 CONFIG_NUMA=y
 CONFIG_HZ_100=y
-CONFIG_KEXEC_FILE=y
+CONFIG_CERT_STORE=y
-CONFIG_KEXEC_SIG=y
 CONFIG_EXPOLINE=y
 CONFIG_EXPOLINE_AUTO=y
 CONFIG_CHSC_SCH=y
 CONFIG_VFIO_CCW=m
 CONFIG_VFIO_AP=m
-CONFIG_CRASH_DUMP=y
 CONFIG_PROTECTED_VIRTUALIZATION_GUEST=y
 CONFIG_CMM=m
 CONFIG_APPLDATA_BASE=y
+CONFIG_S390_HYPFS_FS=y
 CONFIG_KVM=m
 CONFIG_S390_UNWIND_SELFTEST=m
 CONFIG_S390_KPROBES_SANITY_TEST=m
 CONFIG_SCSI_DH_ALUA=m
 CONFIG_MD=y
 CONFIG_BLK_DEV_MD=y
+# CONFIG_MD_BITMAP_FILE is not set
 CONFIG_MD_LINEAR=m
 CONFIG_MD_MULTIPATH=m
 CONFIG_MD_FAULTY=m
 CONFIG_SOFT_WATCHDOG=m
 CONFIG_DIAG288_WATCHDOG=m
 CONFIG_FB=y
+# CONFIG_FB_DEVICE is not set
 CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_HID_SUPPORT is not set
 CONFIG_TMPFS=y
 CONFIG_TMPFS_POSIX_ACL=y
 CONFIG_TMPFS_INODE64=y
+CONFIG_TMPFS_QUOTA=y
 CONFIG_HUGETLBFS=y
 CONFIG_CONFIGFS_FS=m
 CONFIG_ECRYPT_FS=m
 CONFIG_IMA_APPRAISE=y
 CONFIG_LSM="yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
 CONFIG_INIT_STACK_NONE=y
+CONFIG_BUG_ON_DATA_CORRUPTION=y
 CONFIG_CRYPTO_FIPS=y
 CONFIG_CRYPTO_USER=m
 # CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is not set
 CONFIG_DEBUG_MEMORY_INIT=y
 CONFIG_PANIC_ON_OOPS=y
 CONFIG_TEST_LOCKUP=m
-CONFIG_BUG_ON_DATA_CORRUPTION=y
 CONFIG_RCU_TORTURE_TEST=m
 CONFIG_RCU_REF_SCALE_TEST=m
 CONFIG_RCU_CPU_STALL_TIMEOUT=60

arch/s390/configs/zfcpdump_defconfig+2−2

 # CONFIG_NET_NS is not set
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_CRASH_DUMP=y
 CONFIG_MARCH_ZEC12=y
 CONFIG_TUNE_ZEC12=y
 # CONFIG_COMPAT is not set
 CONFIG_HZ_100=y
 # CONFIG_CHSC_SCH is not set
 # CONFIG_SCM_BUS is not set
-CONFIG_CRASH_DUMP=y
 # CONFIG_PFAULT is not set
-# CONFIG_S390_HYPFS_FS is not set
+# CONFIG_S390_HYPFS is not set
 # CONFIG_VIRTUALIZATION is not set
 # CONFIG_S390_GUEST is not set
 # CONFIG_SECCOMP is not set

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

 #define hugepages_supported()			(MACHINE_HAS_EDAT1)
 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
+		     pte_t *ptep, pte_t pte, unsigned long sz);
+void __set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
 		     pte_t *ptep, pte_t pte);
 pte_t huge_ptep_get(pte_t *ptep);
 pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
 	int changed = !pte_same(huge_ptep_get(ptep), pte);
 	if (changed) {
 		huge_ptep_get_and_clear(vma->vm_mm, addr, ptep);
-		set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
+		__set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
 	}
 	return changed;
 }
 					   unsigned long addr, pte_t *ptep)
 {
 	pte_t pte = huge_ptep_get_and_clear(mm, addr, ptep);
-	set_huge_pte_at(mm, addr, ptep, pte_wrprotect(pte));
+	__set_huge_pte_at(mm, addr, ptep, pte_wrprotect(pte));
 }
 static inline pte_t mk_huge_pte(struct page *page, pgprot_t pgprot)

arch/s390/kernel/cert_store.c+4−3

 	char *desc;
 	cs_token = vcssb->cs_token;
-	/* Description string contains "%64s:%04u:%08u\0". */
+	/* Description string contains "%64s:%05u:%010u\0". */
 	name_len = sizeof(vce->vce_hdr.vc_name);
-	len = name_len + 1 + 4 + 1 + 8 + 1;
+	len = name_len + 1 + 5 + 1 + 10 + 1;
 	desc = kmalloc(len, GFP_KERNEL);
 	if (!desc)
 		return NULL;
 	memcpy(desc, vce->vce_hdr.vc_name, name_len);
-	sprintf(desc + name_len, ":%04u:%08u", vce->vce_hdr.vc_index, cs_token);
+	snprintf(desc + name_len, len - name_len, ":%05u:%010u",
+		 vce->vce_hdr.vc_index, cs_token);
 	return desc;
 }

arch/s390/mm/hugetlbpage.c+7−1

 		__storage_key_init_range(paddr, paddr + size - 1);
 }
-void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
+void __set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
 		     pte_t *ptep, pte_t pte)
 {
 	unsigned long rste;
 	set_pte(ptep, __pte(rste));
 }
+void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
+		     pte_t *ptep, pte_t pte, unsigned long sz)
+{
+	__set_huge_pte_at(mm, addr, ptep, pte);
+}
 pte_t huge_ptep_get(pte_t *ptep)
 {
 	return __rste_to_pte(pte_val(*ptep));

arch/s390/net/bpf_jit_comp.c+1−1

@@ -2513,7 +2513,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image im, void image, · 2512 unmodified lines
2513	return -E2BIG;	2513	return -E2BIG;
2514	}	2514	}
2515		2515
2516	return ret;	2516	return tjit.common.prg;
2517	}	2517	}
2518		2518
2519	bool bpf_jit_supports_subprog_tailcalls(void)	2519	bool bpf_jit_supports_subprog_tailcalls(void)

arch/sh/mm/ioremap.c+2−2

@@ -72,8 +72,8 @@ __ioremap_29bit(phys_addr_t offset, unsigned long size, pgprot_t prot) · 71 unmodified lines
72	#define __ioremap_29bit(offset, size, prot) NULL	72	#define __ioremap_29bit(offset, size, prot) NULL
73	#endif /* CONFIG_29BIT */	73	#endif /* CONFIG_29BIT */
74		74
75	void __iomem *ioremap_prot(phys_addr_t phys_addr, size_t size,	75	void __iomem __ref *ioremap_prot(phys_addr_t phys_addr, size_t size,
76	unsigned long prot)	76	unsigned long prot)
77	{	77	{
78	void __iomem *mapped;	78	void __iomem *mapped;
79	pgprot_t pgprot = __pgprot(prot);	79	pgprot_t pgprot = __pgprot(prot);

arch/sparc/include/asm/hugetlb.h+4−2

 #define __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT
 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
+		     pte_t *ptep, pte_t pte, unsigned long sz);
+void __set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
 		     pte_t *ptep, pte_t pte);
 #define __HAVE_ARCH_HUGE_PTEP_GET_AND_CLEAR
 					   unsigned long addr, pte_t *ptep)
 {
 	pte_t old_pte = *ptep;
-	set_huge_pte_at(mm, addr, ptep, pte_wrprotect(old_pte));
+	__set_huge_pte_at(mm, addr, ptep, pte_wrprotect(old_pte));
 }
 #define __HAVE_ARCH_HUGE_PTEP_SET_ACCESS_FLAGS
 {
 	int changed = !pte_same(*ptep, pte);
 	if (changed) {
-		set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
+		__set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
 		flush_tlb_page(vma, addr);
 	}
 	return changed;

arch/sparc/mm/hugetlbpage.c+7−1

 	return pte_offset_huge(pmd, addr);
 }
-void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
+void __set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
 		     pte_t *ptep, pte_t entry)
 {
 	unsigned int nptes, orig_shift, shift;
 				    orig_shift);
 }
+void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
+		     pte_t *ptep, pte_t entry, unsigned long sz)
+{
+	__set_huge_pte_at(mm, addr, ptep, entry);
+}
 pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
 			      pte_t *ptep)
 {

arch/x86/events/amd/core.c+17−7

 	/* Clear enable bits i.e. PerfCntrGlobalCtl.PerfCntrEn */
 	wrmsrl(MSR_AMD64_PERF_CNTR_GLOBAL_CTL, 0);
-	/* Clear overflow bits i.e. PerfCntrGLobalStatus.PerfCntrOvfl */
+	/*
-	wrmsrl(MSR_AMD64_PERF_CNTR_GLOBAL_STATUS_CLR, amd_pmu_global_cntr_mask);
+	 * Clear freeze and overflow bits i.e. PerfCntrGLobalStatus.LbrFreeze
+	 * and PerfCntrGLobalStatus.PerfCntrOvfl
+	 */
+	wrmsrl(MSR_AMD64_PERF_CNTR_GLOBAL_STATUS_CLR,
+	       GLOBAL_STATUS_LBRS_FROZEN | amd_pmu_global_cntr_mask);
 }
 static int amd_pmu_cpu_prepare(int cpu)
 	int i, nb_id;
 	cpuc->perf_ctr_virt_mask = AMD64_EVENTSEL_HOSTONLY;
+	amd_pmu_cpu_reset(cpu);
 	if (!x86_pmu.amd_nb_constraints)
 		return;
 	cpuc->amd_nb->nb_id = nb_id;
 	cpuc->amd_nb->refcnt++;
-	amd_pmu_cpu_reset(cpu);
 }
 static void amd_pmu_cpu_dead(int cpu)
 	kfree(cpuhw->lbr_sel);
 	cpuhw->lbr_sel = NULL;
+	amd_pmu_cpu_reset(cpu);
 	if (!x86_pmu.amd_nb_constraints)
 		return;
 		cpuhw->amd_nb = NULL;
 	}
-	amd_pmu_cpu_reset(cpu);
 }
 static inline void amd_pmu_set_global_ctl(u64 ctl)
 	struct hw_perf_event *hwc;
 	struct perf_event *event;
 	int handled = 0, idx;
-	u64 status, mask;
+	u64 reserved, status, mask;
 	bool pmu_enabled;
 	/*
 		status &= ~GLOBAL_STATUS_LBRS_FROZEN;
 	}
+	reserved = status & ~amd_pmu_global_cntr_mask;
+	if (reserved)
+		pr_warn_once("Reserved PerfCntrGlobalStatus bits are set (0x%llx), please consider updating microcode\n",
+			     reserved);
+	/* Clear any reserved bits set by buggy microcode */
+	status &= amd_pmu_global_cntr_mask;
 	for (idx = 0; idx < x86_pmu.num_counters; idx++) {
 		if (!test_bit(idx, cpuc->active_mask))
 			continue;

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

 	 * the thread holds the MMU lock in write mode.
 	 */
 	spinlock_t tdp_mmu_pages_lock;
-	struct workqueue_struct *tdp_mmu_zap_wq;
 #endif /* CONFIG_X86_64 */
 	/*
 void kvm_mmu_destroy(struct kvm_vcpu *vcpu);
 int kvm_mmu_create(struct kvm_vcpu *vcpu);
-int kvm_mmu_init_vm(struct kvm *kvm);
+void kvm_mmu_init_vm(struct kvm *kvm);
 void kvm_mmu_uninit_vm(struct kvm *kvm);
 void kvm_mmu_after_set_cpuid(struct kvm_vcpu *vcpu);

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

@@ -105,6 +105,13 @@ · 104 unmodified lines
105	CFI_POST_PADDING \	105	CFI_POST_PADDING \
106	SYM_FUNC_END(__cfi_##name)	106	SYM_FUNC_END(__cfi_##name)
107		107
		108	/* UML needs to be able to override memcpy() and friends for KASAN. */
		109	#ifdef CONFIG_UML
		110	# define SYM_FUNC_ALIAS_MEMFUNC SYM_FUNC_ALIAS_WEAK
		111	#else
		112	# define SYM_FUNC_ALIAS_MEMFUNC SYM_FUNC_ALIAS
		113	#endif
		114
108	/* SYM_TYPED_FUNC_START -- use for indirectly called globals, w/ CFI type */	115	/* SYM_TYPED_FUNC_START -- use for indirectly called globals, w/ CFI type */
109	#define SYM_TYPED_FUNC_START(name) \	116	#define SYM_TYPED_FUNC_START(name) \
110	SYM_TYPED_START(name, SYM_L_GLOBAL, SYM_F_ALIGN) \	117	SYM_TYPED_START(name, SYM_L_GLOBAL, SYM_F_ALIGN) \

arch/x86/include/asm/mmu_context.h+1−2

 #else
 #define deactivate_mm(tsk, mm)			\
 do {						\
-	if (!tsk->vfork_done)			\
+	shstk_free(tsk);			\
-		shstk_free(tsk);		\
 	load_gs_index(0);			\
 	loadsegment(fs, 0);			\
 } while (0)

arch/x86/include/asm/pgtable.h+8−0

@@ -955,6 +955,14 @@ static inline int pte_same(pte_t a, pte_t b) · 954 unmodified lines
955	return a.pte == b.pte;	955	return a.pte == b.pte;
956	}	956	}
957		957
		958	static inline pte_t pte_next_pfn(pte_t pte)
		959	{
		960	if (__pte_needs_invert(pte_val(pte)))
		961	return __pte(pte_val(pte) - (1UL << PFN_PTE_SHIFT));
		962	return __pte(pte_val(pte) + (1UL << PFN_PTE_SHIFT));
		963	}
		964	#define pte_next_pfn pte_next_pfn
		965
958	static inline int pte_present(pte_t a)	966	static inline int pte_present(pte_t a)
959	{	967	{
960	return pte_flags(a) & (_PAGE_PRESENT \| _PAGE_PROTNONE);	968	return pte_flags(a) & (_PAGE_PRESENT \| _PAGE_PROTNONE);

arch/x86/include/asm/processor.h+0−2

 #ifdef CONFIG_CPU_SUP_AMD
 extern u32 amd_get_nodes_per_socket(void);
 extern u32 amd_get_highest_perf(void);
-extern bool cpu_has_ibpb_brtype_microcode(void);
 extern void amd_clear_divider(void);
 extern void amd_check_microcode(void);
 #else
 static inline u32 amd_get_nodes_per_socket(void)	{ return 0; }
 static inline u32 amd_get_highest_perf(void)		{ return 0; }
-static inline bool cpu_has_ibpb_brtype_microcode(void)	{ return false; }
 static inline void amd_clear_divider(void)		{ }
 static inline void amd_check_microcode(void)		{ }
 #endif

arch/x86/kernel/alternative.c+2−7

 {
 	s32 *s;
-	/*
+	if (cpu_feature_enabled(X86_FEATURE_RETHUNK))
-	 * Do not patch out the default return thunks if those needed are the
+		static_call_force_reinit();
-	 * ones generated by the compiler.
-	 */
-	if (cpu_feature_enabled(X86_FEATURE_RETHUNK) &&
-	    (x86_return_thunk == __x86_return_thunk))
-		return;
 	for (s = start; s < end; s++) {
 		void *dest = NULL, *addr = (void *)s + *s;

arch/x86/kernel/callthunks.c+0−1

@@ -272,7 +272,6 @@ void __init callthunks_patch_builtin_calls(void) · 271 unmodified lines
272	pr_info("Setting up call depth tracking\n");	272	pr_info("Setting up call depth tracking\n");
273	mutex_lock(&text_mutex);	273	mutex_lock(&text_mutex);
274	callthunks_setup(&cs, &builtin_coretext);	274	callthunks_setup(&cs, &builtin_coretext);
275	static_call_force_reinit();
276	thunks_initialized = true;	275	thunks_initialized = true;
277	mutex_unlock(&text_mutex);	276	mutex_unlock(&text_mutex);
278	}	277	}

arch/x86/kernel/cpu/amd.c+9−19

 	if (cpu_has(c, X86_FEATURE_TOPOEXT))
 		smp_num_siblings = ((cpuid_ebx(0x8000001e) >> 8) & 0xff) + 1;
+	if (!cpu_has(c, X86_FEATURE_HYPERVISOR) && !cpu_has(c, X86_FEATURE_IBPB_BRTYPE)) {
+		if (c->x86 == 0x17 && boot_cpu_has(X86_FEATURE_AMD_IBPB))
+			setup_force_cpu_cap(X86_FEATURE_IBPB_BRTYPE);
+		else if (c->x86 >= 0x19 && !wrmsrl_safe(MSR_IA32_PRED_CMD, PRED_CMD_SBPB)) {
+			setup_force_cpu_cap(X86_FEATURE_IBPB_BRTYPE);
+			setup_force_cpu_cap(X86_FEATURE_SBPB);
+		}
+	}
 }
 static void init_amd_k8(struct cpuinfo_x86 *c)
 	on_each_cpu(zenbleed_check_cpu, NULL, 1);
 }
-bool cpu_has_ibpb_brtype_microcode(void)
-{
-	switch (boot_cpu_data.x86) {
-	/* Zen1/2 IBPB flushes branch type predictions too. */
-	case 0x17:
-		return boot_cpu_has(X86_FEATURE_AMD_IBPB);
-	case 0x19:
-		/* Poke the MSR bit on Zen3/4 to check its presence. */
-		if (!wrmsrl_safe(MSR_IA32_PRED_CMD, PRED_CMD_SBPB)) {
-			setup_force_cpu_cap(X86_FEATURE_SBPB);
-			return true;
-		} else {
-			return false;
-		}
-	default:
-		return false;
-	}
-}
 /*
  * Issue a DIV 0/1 insn to clear any division data from previous DIV
  * operations.

arch/x86/kernel/cpu/bugs.c+3−14

 static void __init srso_select_mitigation(void)
 {
-	bool has_microcode;
+	bool has_microcode = boot_cpu_has(X86_FEATURE_IBPB_BRTYPE);
 	if (!boot_cpu_has_bug(X86_BUG_SRSO) || cpu_mitigations_off())
 		goto pred_cmd;
-	/*
-	 * The first check is for the kernel running as a guest in order
-	 * for guests to verify whether IBPB is a viable mitigation.
-	 */
-	has_microcode = boot_cpu_has(X86_FEATURE_IBPB_BRTYPE) || cpu_has_ibpb_brtype_microcode();
 	if (!has_microcode) {
 		pr_warn("IBPB-extending microcode not applied!\n");
 		pr_warn(SRSO_NOTICE);
 	} else {
-		/*
-		 * Enable the synthetic (even if in a real CPUID leaf)
-		 * flags for guests.
-		 */
-		setup_force_cpu_cap(X86_FEATURE_IBPB_BRTYPE);
 		/*
 		 * Zen1/2 with SMT off aren't vulnerable after the right
 		 * IBPB microcode has been applied.
 	switch (srso_cmd) {
 	case SRSO_CMD_OFF:
-		return;
+		goto pred_cmd;
 	case SRSO_CMD_MICROCODE:
 		if (has_microcode) {
 	return sysfs_emit(buf, "%s%s\n",
 			  srso_strings[srso_mitigation],
-			  (cpu_has_ibpb_brtype_microcode() ? "" : ", no microcode"));
+			  boot_cpu_has(X86_FEATURE_IBPB_BRTYPE) ? "" : ", no microcode");
 }
 static ssize_t gds_show_state(char *buf)

arch/x86/kernel/cpu/common.c+1−1

@@ -1303,7 +1303,7 @@ static const struct x86_cpu_id cpu_vuln_blacklist[] __initconst = { · 1302 unmodified lines
1303	VULNBL_AMD(0x15, RETBLEED),	1303	VULNBL_AMD(0x15, RETBLEED),
1304	VULNBL_AMD(0x16, RETBLEED),	1304	VULNBL_AMD(0x16, RETBLEED),
1305	VULNBL_AMD(0x17, RETBLEED \| SMT_RSB \| SRSO),	1305	VULNBL_AMD(0x17, RETBLEED \| SMT_RSB \| SRSO),
1306	VULNBL_HYGON(0x18, RETBLEED \| SMT_RSB),	1306	VULNBL_HYGON(0x18, RETBLEED \| SMT_RSB \| SRSO),
1307	VULNBL_AMD(0x19, SRSO),	1307	VULNBL_AMD(0x19, SRSO),
1308	{}	1308	{}
1309	};	1309	};

arch/x86/kernel/cpu/sgx/encl.c+25−5

 	return epc_page;
 }
+/*
+ * Ensure the SECS page is not swapped out.  Must be called with encl->lock
+ * to protect the enclave states including SECS and ensure the SECS page is
+ * not swapped out again while being used.
+ */
+static struct sgx_epc_page *sgx_encl_load_secs(struct sgx_encl *encl)
+{
+	struct sgx_epc_page *epc_page = encl->secs.epc_page;
+	if (!epc_page)
+		epc_page = sgx_encl_eldu(&encl->secs, NULL);
+	return epc_page;
+}
 static struct sgx_encl_page *__sgx_encl_load_page(struct sgx_encl *encl,
 						  struct sgx_encl_page *entry)
 {
 		return entry;
 	}
-	if (!(encl->secs.epc_page)) {
+	epc_page = sgx_encl_load_secs(encl);
-		epc_page = sgx_encl_eldu(&encl->secs, NULL);
+	if (IS_ERR(epc_page))
-		if (IS_ERR(epc_page))
+		return ERR_CAST(epc_page);
-			return ERR_CAST(epc_page);
-	}
 	epc_page = sgx_encl_eldu(entry, encl->secs.epc_page);
 	if (IS_ERR(epc_page))
 	mutex_lock(&encl->lock);
+	epc_page = sgx_encl_load_secs(encl);
+	if (IS_ERR(epc_page)) {
+		if (PTR_ERR(epc_page) == -EBUSY)
+			vmret = VM_FAULT_NOPAGE;
+		goto err_out_unlock;
+	}
 	epc_page = sgx_alloc_epc_page(encl_page, false);
 	if (IS_ERR(epc_page)) {
 		if (PTR_ERR(epc_page) == -EBUSY)

arch/x86/kernel/kgdb.c+0−1

@@ -695,7 +695,6 @@ void kgdb_arch_exit(void) · 694 unmodified lines
695	}	695	}
696		696
697	/**	697	/**
698	*
699	* kgdb_skipexception - Bail out of KGDB when we've been triggered.	698	* kgdb_skipexception - Bail out of KGDB when we've been triggered.
700	* @exception: Exception vector number	699	* @exception: Exception vector number
701	* @regs: Current &struct pt_regs.	700	* @regs: Current &struct pt_regs.

arch/x86/kernel/process.c+0−7

@@ -257,13 +257,6 @@ int copy_thread(struct task_struct p, const struct kernel_clone_args args) · 256 unmodified lines
257	if (!ret && unlikely(test_tsk_thread_flag(current, TIF_IO_BITMAP)))	257	if (!ret && unlikely(test_tsk_thread_flag(current, TIF_IO_BITMAP)))
258	io_bitmap_share(p);	258	io_bitmap_share(p);
259		259
260	/*
261	* If copy_thread() if failing, don't leak the shadow stack possibly
262	* allocated in shstk_alloc_thread_stack() above.
263	*/
264	if (ret)
265	shstk_free(p);
266
267	return ret;	260	return ret;
268	}	261	}
269		262

arch/x86/kernel/setup.c+2−6

 #if defined(CONFIG_HAVE_IMA_KEXEC) && !defined(CONFIG_OF_FLATTREE)
 int __init ima_free_kexec_buffer(void)
 {
-	int rc;
 	if (!ima_kexec_buffer_size)
 		return -ENOENT;
-	rc = memblock_phys_free(ima_kexec_buffer_phys,
+	memblock_free_late(ima_kexec_buffer_phys,
-				ima_kexec_buffer_size);
+			   ima_kexec_buffer_size);
-	if (rc)
-		return rc;
 	ima_kexec_buffer_phys = 0;
 	ima_kexec_buffer_size = 0;

arch/x86/kernel/shstk.c+31−2

@@ -205,10 +205,21 @@ unsigned long shstk_alloc_thread_stack(struct task_struct *tsk, unsigned long cl · 204 unmodified lines
205	return 0;	205	return 0;
206		206
207	/*	207	/*
208	* For CLONE_VM, except vfork, the child needs a separate shadow	208	* For CLONE_VFORK the child will share the parents shadow stack.
		209	* Make sure to clear the internal tracking of the thread shadow
		210	* stack so the freeing logic run for child knows to leave it alone.
		211	*/
		212	if (clone_flags & CLONE_VFORK) {
		213	shstk->base = 0;
		214	shstk->size = 0;
		215	return 0;
		216	}
		217
		218	/*
		219	* For !CLONE_VM the child will use a copy of the parents shadow
209	* stack.	220	* stack.
210	*/	221	*/
211	if ((clone_flags & (CLONE_VFORK \| CLONE_VM)) != CLONE_VM)	222	if (!(clone_flags & CLONE_VM))
212	return 0;	223	return 0;
213		224
214	size = adjust_shstk_size(stack_size);	225	size = adjust_shstk_size(stack_size);
@@ -408,7 +419,25 @@ void shstk_free(struct task_struct *tsk) · 193 unmodified lines
408	if (!tsk->mm \|\| tsk->mm != current->mm)	419	if (!tsk->mm \|\| tsk->mm != current->mm)
409	return;	420	return;
410		421
		422	/*
		423	* If shstk->base is NULL, then this task is not managing its
		424	* own shadow stack (CLONE_VFORK). So skip freeing it.
		425	*/
		426	if (!shstk->base)
		427	return;
		428
		429	/*
		430	* shstk->base is NULL for CLONE_VFORK child tasks, and so is
		431	* normal. But size = 0 on a shstk->base is not normal and
		432	* indicated an attempt to free the thread shadow stack twice.
		433	* Warn about it.
		434	*/
		435	if (WARN_ON(!shstk->size))
		436	return;
		437
411	unmap_shadow_stack(shstk->base, shstk->size);	438	unmap_shadow_stack(shstk->base, shstk->size);
		439
		440	shstk->size = 0;
412	}	441	}
413		442
414	static int wrss_control(bool enable)	443	static int wrss_control(bool enable)

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

 	return unlikely(!list_empty_careful(&kvm->arch.zapped_obsolete_pages));
 }
-int kvm_mmu_init_vm(struct kvm *kvm)
+void kvm_mmu_init_vm(struct kvm *kvm)
 {
-	int r;
 	INIT_LIST_HEAD(&kvm->arch.active_mmu_pages);
 	INIT_LIST_HEAD(&kvm->arch.zapped_obsolete_pages);
 	INIT_LIST_HEAD(&kvm->arch.possible_nx_huge_pages);
 	spin_lock_init(&kvm->arch.mmu_unsync_pages_lock);
-	if (tdp_mmu_enabled) {
+	if (tdp_mmu_enabled)
-		r = kvm_mmu_init_tdp_mmu(kvm);
+		kvm_mmu_init_tdp_mmu(kvm);
-		if (r < 0)
-			return r;
-	}
 	kvm->arch.split_page_header_cache.kmem_cache = mmu_page_header_cache;
 	kvm->arch.split_page_header_cache.gfp_zero = __GFP_ZERO;
 	kvm->arch.split_desc_cache.kmem_cache = pte_list_desc_cache;
 	kvm->arch.split_desc_cache.gfp_zero = __GFP_ZERO;
-	return 0;
 }
 static void mmu_free_vm_memory_caches(struct kvm *kvm)
 void kvm_zap_gfn_range(struct kvm *kvm, gfn_t gfn_start, gfn_t gfn_end)
 {
 	bool flush;
-	int i;
 	if (WARN_ON_ONCE(gfn_end <= gfn_start))
 		return;
 	flush = kvm_rmap_zap_gfn_range(kvm, gfn_start, gfn_end);
-	if (tdp_mmu_enabled) {
+	if (tdp_mmu_enabled)
-		for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++)
+		flush = kvm_tdp_mmu_zap_leafs(kvm, gfn_start, gfn_end, flush);
-			flush = kvm_tdp_mmu_zap_leafs(kvm, i, gfn_start,
-						      gfn_end, true, flush);
-	}
 	if (flush)
 		kvm_flush_remote_tlbs_range(kvm, gfn_start, gfn_end - gfn_start);

arch/x86/kvm/mmu/mmu_internal.h+7−8

 	bool tdp_mmu_page;
 	bool unsync;
-	u8 mmu_valid_gen;
+	union {
+		u8 mmu_valid_gen;
+		/* Only accessed under slots_lock.  */
+		bool tdp_mmu_scheduled_root_to_zap;
+	};
 	 /*
 	  * The shadow page can't be replaced by an equivalent huge page
 		struct kvm_rmap_head parent_ptes; /* rmap pointers to parent sptes */
 		tdp_ptep_t ptep;
 	};
-	union {
+	DECLARE_BITMAP(unsync_child_bitmap, 512);
-		DECLARE_BITMAP(unsync_child_bitmap, 512);
-		struct {
-			struct work_struct tdp_mmu_async_work;
-			void *tdp_mmu_async_data;
-		};
-	};
 	/*
 	 * Tracks shadow pages that, if zapped, would allow KVM to create an NX

arch/x86/kvm/mmu/tdp_mmu.c+67−85

@@ -12,18 +12,10 @@ · 11 unmodified lines
12	#include <trace/events/kvm.h>	12	#include <trace/events/kvm.h>
13		13
14	/* Initializes the TDP MMU for the VM, if enabled. */	14	/* Initializes the TDP MMU for the VM, if enabled. */
15	int kvm_mmu_init_tdp_mmu(struct kvm *kvm)	15	void kvm_mmu_init_tdp_mmu(struct kvm *kvm)
16	{	16	{
17	struct workqueue_struct *wq;
18
19	wq = alloc_workqueue("kvm", WQ_UNBOUND\|WQ_MEM_RECLAIM\|WQ_CPU_INTENSIVE, 0);
20	if (!wq)
21	return -ENOMEM;
22
23	INIT_LIST_HEAD(&kvm->arch.tdp_mmu_roots);	17	INIT_LIST_HEAD(&kvm->arch.tdp_mmu_roots);
24	spin_lock_init(&kvm->arch.tdp_mmu_pages_lock);	18	spin_lock_init(&kvm->arch.tdp_mmu_pages_lock);
25	kvm->arch.tdp_mmu_zap_wq = wq;
26	return 1;
27	}	19	}
28		20
29	/* Arbitrarily returns true so that this may be used in if statements. */	21	/* Arbitrarily returns true so that this may be used in if statements. */
@@ -46,20 +38,15 @@ void kvm_mmu_uninit_tdp_mmu(struct kvm *kvm) · 16 unmodified lines
46	* ultimately frees all roots.	38	* ultimately frees all roots.
47	*/	39	*/
48	kvm_tdp_mmu_invalidate_all_roots(kvm);	40	kvm_tdp_mmu_invalidate_all_roots(kvm);
49		41	kvm_tdp_mmu_zap_invalidated_roots(kvm);
50	/*
51	* Destroying a workqueue also first flushes the workqueue, i.e. no
52	* need to invoke kvm_tdp_mmu_zap_invalidated_roots().
53	*/
54	destroy_workqueue(kvm->arch.tdp_mmu_zap_wq);
55		42
56	WARN_ON(atomic64_read(&kvm->arch.tdp_mmu_pages));	43	WARN_ON(atomic64_read(&kvm->arch.tdp_mmu_pages));
57	WARN_ON(!list_empty(&kvm->arch.tdp_mmu_roots));	44	WARN_ON(!list_empty(&kvm->arch.tdp_mmu_roots));
58		45
59	/*	46	/*
60	* Ensure that all the outstanding RCU callbacks to free shadow pages	47	* Ensure that all the outstanding RCU callbacks to free shadow pages
61	* can run before the VM is torn down. Work items on tdp_mmu_zap_wq	48	* can run before the VM is torn down. Putting the last reference to
62	* can call kvm_tdp_mmu_put_root and create new callbacks.	49	* zapped roots will create new callbacks.
63	*/	50	*/
64	rcu_barrier();	51	rcu_barrier();
65	}	52	}
@@ -86,46 +73,6 @@ static void tdp_mmu_free_sp_rcu_callback(struct rcu_head *head) · 20 unmodified lines
86	tdp_mmu_free_sp(sp);	73	tdp_mmu_free_sp(sp);
87	}	74	}
88		75
89	static void tdp_mmu_zap_root(struct kvm kvm, struct kvm_mmu_page root,
90	bool shared);
91
92	static void tdp_mmu_zap_root_work(struct work_struct *work)
93	{
94	struct kvm_mmu_page *root = container_of(work, struct kvm_mmu_page,
95	tdp_mmu_async_work);
96	struct kvm *kvm = root->tdp_mmu_async_data;
97
98	read_lock(&kvm->mmu_lock);
99
100	/*
101	* A TLB flush is not necessary as KVM performs a local TLB flush when
102	* allocating a new root (see kvm_mmu_load()), and when migrating vCPU
103	* to a different pCPU. Note, the local TLB flush on reuse also
104	* invalidates any paging-structure-cache entries, i.e. TLB entries for
105	* intermediate paging structures, that may be zapped, as such entries
106	* are associated with the ASID on both VMX and SVM.
107	*/
108	tdp_mmu_zap_root(kvm, root, true);
109
110	/*
111	* Drop the refcount using kvm_tdp_mmu_put_root() to test its logic for
112	* avoiding an infinite loop. By design, the root is reachable while
113	* it's being asynchronously zapped, thus a different task can put its
114	* last reference, i.e. flowing through kvm_tdp_mmu_put_root() for an
115	* asynchronously zapped root is unavoidable.
116	*/
117	kvm_tdp_mmu_put_root(kvm, root, true);
118
119	read_unlock(&kvm->mmu_lock);
120	}
121
122	static void tdp_mmu_schedule_zap_root(struct kvm kvm, struct kvm_mmu_page root)
123	{
124	root->tdp_mmu_async_data = kvm;
125	INIT_WORK(&root->tdp_mmu_async_work, tdp_mmu_zap_root_work);
126	queue_work(kvm->arch.tdp_mmu_zap_wq, &root->tdp_mmu_async_work);
127	}
128
129	void kvm_tdp_mmu_put_root(struct kvm kvm, struct kvm_mmu_page root,	76	void kvm_tdp_mmu_put_root(struct kvm kvm, struct kvm_mmu_page root,
130	bool shared)	77	bool shared)
131	{	78	{
@@ -211,8 +158,12 @@ static struct kvm_mmu_page tdp_mmu_next_root(struct kvm kvm, · 79 unmodified lines
211	#define for_each_valid_tdp_mmu_root_yield_safe(_kvm, _root, _as_id, _shared) \	158	#define for_each_valid_tdp_mmu_root_yield_safe(_kvm, _root, _as_id, _shared) \
212	__for_each_tdp_mmu_root_yield_safe(_kvm, _root, _as_id, _shared, true)	159	__for_each_tdp_mmu_root_yield_safe(_kvm, _root, _as_id, _shared, true)
213		160
214	#define for_each_tdp_mmu_root_yield_safe(_kvm, _root, _as_id) \	161	#define for_each_tdp_mmu_root_yield_safe(_kvm, _root, _shared) \
215	__for_each_tdp_mmu_root_yield_safe(_kvm, _root, _as_id, false, false)	162	for (_root = tdp_mmu_next_root(_kvm, NULL, _shared, false); \
		163	_root; \
		164	_root = tdp_mmu_next_root(_kvm, _root, _shared, false)) \
		165	if (!kvm_lockdep_assert_mmu_lock_held(_kvm, _shared)) { \
		166	} else
216		167
217	/*	168	/*
218	* Iterate over all TDP MMU roots. Requires that mmu_lock be held for write,	169	* Iterate over all TDP MMU roots. Requires that mmu_lock be held for write,
@@ -292,7 +243,7 @@ hpa_t kvm_tdp_mmu_get_vcpu_root_hpa(struct kvm_vcpu *vcpu) · 73 unmodified lines
292	* by a memslot update or by the destruction of the VM. Initialize the	243	* by a memslot update or by the destruction of the VM. Initialize the
293	* refcount to two; one reference for the vCPU, and one reference for	244	* refcount to two; one reference for the vCPU, and one reference for
294	* the TDP MMU itself, which is held until the root is invalidated and	245	* the TDP MMU itself, which is held until the root is invalidated and
295	* is ultimately put by tdp_mmu_zap_root_work().	246	* is ultimately put by kvm_tdp_mmu_zap_invalidated_roots().
296	*/	247	*/
297	refcount_set(&root->tdp_mmu_root_count, 2);	248	refcount_set(&root->tdp_mmu_root_count, 2);
298		249
@@ -877,13 +828,12 @@ static bool tdp_mmu_zap_leafs(struct kvm kvm, struct kvm_mmu_page root, · 578 unmodified lines
877	* true if a TLB flush is needed before releasing the MMU lock, i.e. if one or	828	* true if a TLB flush is needed before releasing the MMU lock, i.e. if one or
878	* more SPTEs were zapped since the MMU lock was last acquired.	829	* more SPTEs were zapped since the MMU lock was last acquired.
879	*/	830	*/
880	bool kvm_tdp_mmu_zap_leafs(struct kvm *kvm, int as_id, gfn_t start, gfn_t end,	831	bool kvm_tdp_mmu_zap_leafs(struct kvm *kvm, gfn_t start, gfn_t end, bool flush)
881	bool can_yield, bool flush)
882	{	832	{
883	struct kvm_mmu_page *root;	833	struct kvm_mmu_page *root;
884		834
885	for_each_tdp_mmu_root_yield_safe(kvm, root, as_id)	835	for_each_tdp_mmu_root_yield_safe(kvm, root, false)
886	flush = tdp_mmu_zap_leafs(kvm, root, start, end, can_yield, flush);	836	flush = tdp_mmu_zap_leafs(kvm, root, start, end, true, flush);
887		837
888	return flush;	838	return flush;
889	}	839	}
@@ -891,7 +841,6 @@ bool kvm_tdp_mmu_zap_leafs(struct kvm *kvm, int as_id, gfn_t start, gfn_t end, · 1 unmodified line
891	void kvm_tdp_mmu_zap_all(struct kvm *kvm)	841	void kvm_tdp_mmu_zap_all(struct kvm *kvm)
892	{	842	{
893	struct kvm_mmu_page *root;	843	struct kvm_mmu_page *root;
894	int i;
895		844
896	/*	845	/*
897	* Zap all roots, including invalid roots, as all SPTEs must be dropped	846	* Zap all roots, including invalid roots, as all SPTEs must be dropped
@@ -905,10 +854,8 @@ void kvm_tdp_mmu_zap_all(struct kvm *kvm) · 7 unmodified lines
905	* is being destroyed or the userspace VMM has exited. In both cases,	854	* is being destroyed or the userspace VMM has exited. In both cases,
906	* KVM_RUN is unreachable, i.e. no vCPUs will ever service the request.	855	* KVM_RUN is unreachable, i.e. no vCPUs will ever service the request.
907	*/	856	*/
908	for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {	857	for_each_tdp_mmu_root_yield_safe(kvm, root, false)
909	for_each_tdp_mmu_root_yield_safe(kvm, root, i)	858	tdp_mmu_zap_root(kvm, root, false);
910	tdp_mmu_zap_root(kvm, root, false);
911	}
912	}	859	}
913		860
914	/*	861	/*
@@ -917,18 +864,47 @@ void kvm_tdp_mmu_zap_all(struct kvm *kvm) · 2 unmodified lines
917	*/	864	*/
918	void kvm_tdp_mmu_zap_invalidated_roots(struct kvm *kvm)	865	void kvm_tdp_mmu_zap_invalidated_roots(struct kvm *kvm)
919	{	866	{
920	flush_workqueue(kvm->arch.tdp_mmu_zap_wq);	867	struct kvm_mmu_page *root;
		868
		869	read_lock(&kvm->mmu_lock);
		870
		871	for_each_tdp_mmu_root_yield_safe(kvm, root, true) {
		872	if (!root->tdp_mmu_scheduled_root_to_zap)
		873	continue;
		874
		875	root->tdp_mmu_scheduled_root_to_zap = false;
		876	KVM_BUG_ON(!root->role.invalid, kvm);
		877
		878	/*
		879	* A TLB flush is not necessary as KVM performs a local TLB
		880	* flush when allocating a new root (see kvm_mmu_load()), and
		881	* when migrating a vCPU to a different pCPU. Note, the local
		882	* TLB flush on reuse also invalidates paging-structure-cache
		883	* entries, i.e. TLB entries for intermediate paging structures,
		884	* that may be zapped, as such entries are associated with the
		885	* ASID on both VMX and SVM.
		886	*/
		887	tdp_mmu_zap_root(kvm, root, true);
		888
		889	/*
		890	* The referenced needs to be put after zapping the root, as
		891	* the root must be reachable by mmu_notifiers while it's being
		892	* zapped
		893	*/
		894	kvm_tdp_mmu_put_root(kvm, root, true);
		895	}
		896
		897	read_unlock(&kvm->mmu_lock);
921	}	898	}
922		899
923	/*	900	/*
924	* Mark each TDP MMU root as invalid to prevent vCPUs from reusing a root that	901	* Mark each TDP MMU root as invalid to prevent vCPUs from reusing a root that
925	* is about to be zapped, e.g. in response to a memslots update. The actual	902	* is about to be zapped, e.g. in response to a memslots update. The actual
926	* zapping is performed asynchronously. Using a separate workqueue makes it	903	* zapping is done separately so that it happens with mmu_lock with read,
927	* easy to ensure that the destruction is performed before the "fast zap"	904	* whereas invalidating roots must be done with mmu_lock held for write (unless
928	* completes, without keeping a separate list of invalidated roots; the list is	905	* the VM is being destroyed).
929	* effectively the list of work items in the workqueue.
930	*	906	*
931	* Note, the asynchronous worker is gifted the TDP MMU's reference.	907	* Note, kvm_tdp_mmu_zap_invalidated_roots() is gifted the TDP MMU's reference.
932	* See kvm_tdp_mmu_get_vcpu_root_hpa().	908	* See kvm_tdp_mmu_get_vcpu_root_hpa().
933	*/	909	*/
934	void kvm_tdp_mmu_invalidate_all_roots(struct kvm *kvm)	910	void kvm_tdp_mmu_invalidate_all_roots(struct kvm *kvm)
@@ -953,19 +929,20 @@ void kvm_tdp_mmu_invalidate_all_roots(struct kvm *kvm) · 18 unmodified lines
953	/*	929	/*
954	* As above, mmu_lock isn't held when destroying the VM! There can't	930	* As above, mmu_lock isn't held when destroying the VM! There can't
955	* be other references to @kvm, i.e. nothing else can invalidate roots	931	* be other references to @kvm, i.e. nothing else can invalidate roots
956	* or be consuming roots, but walking the list of roots does need to be	932	* or get/put references to roots.
957	* guarded against roots being deleted by the asynchronous zap worker.
958	*/	933	*/
959	rcu_read_lock();	934	list_for_each_entry(root, &kvm->arch.tdp_mmu_roots, link) {
960		935	/*
961	list_for_each_entry_rcu(root, &kvm->arch.tdp_mmu_roots, link) {	936	* Note, invalid roots can outlive a memslot update! Invalid
		937	* roots must be zapped before the memslot update completes,
		938	* but a different task can acquire a reference and keep the
		939	* root alive after its been zapped.
		940	*/
962	if (!root->role.invalid) {	941	if (!root->role.invalid) {
		942	root->tdp_mmu_scheduled_root_to_zap = true;
963	root->role.invalid = true;	943	root->role.invalid = true;
964	tdp_mmu_schedule_zap_root(kvm, root);
965	}	944	}
966	}	945	}
967
968	rcu_read_unlock();
969	}	946	}
970		947
971	/*	948	/*
@@ -1146,8 +1123,13 @@ retry: · 174 unmodified lines
1146	bool kvm_tdp_mmu_unmap_gfn_range(struct kvm kvm, struct kvm_gfn_range range,	1123	bool kvm_tdp_mmu_unmap_gfn_range(struct kvm kvm, struct kvm_gfn_range range,
1147	bool flush)	1124	bool flush)
1148	{	1125	{
1149	return kvm_tdp_mmu_zap_leafs(kvm, range->slot->as_id, range->start,	1126	struct kvm_mmu_page *root;
1150	range->end, range->may_block, flush);	1127
		1128	__for_each_tdp_mmu_root_yield_safe(kvm, root, range->slot->as_id, false, false)
		1129	flush = tdp_mmu_zap_leafs(kvm, root, range->start, range->end,
		1130	range->may_block, flush);
		1131
		1132	return flush;
1151	}	1133	}
1152		1134
1153	typedef bool (tdp_handler_t)(struct kvm kvm, struct tdp_iter *iter,	1135	typedef bool (tdp_handler_t)(struct kvm kvm, struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.h+2−3

 #include "spte.h"
-int kvm_mmu_init_tdp_mmu(struct kvm *kvm);
+void kvm_mmu_init_tdp_mmu(struct kvm *kvm);
 void kvm_mmu_uninit_tdp_mmu(struct kvm *kvm);
 hpa_t kvm_tdp_mmu_get_vcpu_root_hpa(struct kvm_vcpu *vcpu);
 void kvm_tdp_mmu_put_root(struct kvm *kvm, struct kvm_mmu_page *root,
 			  bool shared);
-bool kvm_tdp_mmu_zap_leafs(struct kvm *kvm, int as_id, gfn_t start,
+bool kvm_tdp_mmu_zap_leafs(struct kvm *kvm, gfn_t start, gfn_t end, bool flush);
-				 gfn_t end, bool can_yield, bool flush);
 bool kvm_tdp_mmu_zap_sp(struct kvm *kvm, struct kvm_mmu_page *sp);
 void kvm_tdp_mmu_zap_all(struct kvm *kvm);
 void kvm_tdp_mmu_invalidate_all_roots(struct kvm *kvm);

arch/x86/kvm/svm/sev.c+26−8

@@ -2962,6 +2962,32 @@ int sev_es_string_io(struct vcpu_svm *svm, int size, unsigned int port, int in) · 2961 unmodified lines
2962	count, in);	2962	count, in);
2963	}	2963	}
2964		2964
		2965	static void sev_es_vcpu_after_set_cpuid(struct vcpu_svm *svm)
		2966	{
		2967	struct kvm_vcpu *vcpu = &svm->vcpu;
		2968
		2969	if (boot_cpu_has(X86_FEATURE_V_TSC_AUX)) {
		2970	bool v_tsc_aux = guest_cpuid_has(vcpu, X86_FEATURE_RDTSCP) \|\|
		2971	guest_cpuid_has(vcpu, X86_FEATURE_RDPID);
		2972
		2973	set_msr_interception(vcpu, svm->msrpm, MSR_TSC_AUX, v_tsc_aux, v_tsc_aux);
		2974	}
		2975	}
		2976
		2977	void sev_vcpu_after_set_cpuid(struct vcpu_svm *svm)
		2978	{
		2979	struct kvm_vcpu *vcpu = &svm->vcpu;
		2980	struct kvm_cpuid_entry2 *best;
		2981
		2982	/* For sev guests, the memory encryption bit is not reserved in CR3. */
		2983	best = kvm_find_cpuid_entry(vcpu, 0x8000001F);
		2984	if (best)
		2985	vcpu->arch.reserved_gpa_bits &= ~(1UL << (best->ebx & 0x3f));
		2986
		2987	if (sev_es_guest(svm->vcpu.kvm))
		2988	sev_es_vcpu_after_set_cpuid(svm);
		2989	}
		2990
2965	static void sev_es_init_vmcb(struct vcpu_svm *svm)	2991	static void sev_es_init_vmcb(struct vcpu_svm *svm)
2966	{	2992	{
2967	struct vmcb *vmcb = svm->vmcb01.ptr;	2993	struct vmcb *vmcb = svm->vmcb01.ptr;
@@ -3024,14 +3050,6 @@ static void sev_es_init_vmcb(struct vcpu_svm *svm) · 56 unmodified lines
3024	set_msr_interception(vcpu, svm->msrpm, MSR_IA32_LASTBRANCHTOIP, 1, 1);	3050	set_msr_interception(vcpu, svm->msrpm, MSR_IA32_LASTBRANCHTOIP, 1, 1);
3025	set_msr_interception(vcpu, svm->msrpm, MSR_IA32_LASTINTFROMIP, 1, 1);	3051	set_msr_interception(vcpu, svm->msrpm, MSR_IA32_LASTINTFROMIP, 1, 1);
3026	set_msr_interception(vcpu, svm->msrpm, MSR_IA32_LASTINTTOIP, 1, 1);	3052	set_msr_interception(vcpu, svm->msrpm, MSR_IA32_LASTINTTOIP, 1, 1);
3027
3028	if (boot_cpu_has(X86_FEATURE_V_TSC_AUX) &&
3029	(guest_cpuid_has(&svm->vcpu, X86_FEATURE_RDTSCP) \|\|
3030	guest_cpuid_has(&svm->vcpu, X86_FEATURE_RDPID))) {
3031	set_msr_interception(vcpu, svm->msrpm, MSR_TSC_AUX, 1, 1);
3032	if (guest_cpuid_has(&svm->vcpu, X86_FEATURE_RDTSCP))
3033	svm_clr_intercept(svm, INTERCEPT_RDTSCP);
3034	}
3035	}	3053	}
3036		3054
3037	void sev_init_vmcb(struct vcpu_svm *svm)	3055	void sev_init_vmcb(struct vcpu_svm *svm)

arch/x86/kvm/svm/svm.c+35−8

 	amd_pmu_enable_virt();
+	/*
+	 * If TSC_AUX virtualization is supported, TSC_AUX becomes a swap type
+	 * "B" field (see sev_es_prepare_switch_to_guest()) for SEV-ES guests.
+	 * Since Linux does not change the value of TSC_AUX once set, prime the
+	 * TSC_AUX field now to avoid a RDMSR on every vCPU run.
+	 */
+	if (boot_cpu_has(X86_FEATURE_V_TSC_AUX)) {
+		struct sev_es_save_area *hostsa;
+		u32 msr_hi;
+		hostsa = (struct sev_es_save_area *)(page_address(sd->save_area) + 0x400);
+		rdmsr(MSR_TSC_AUX, hostsa->tsc_aux, msr_hi);
+	}
 	return 0;
 }
 	if (tsc_scaling)
 		__svm_write_tsc_multiplier(vcpu->arch.tsc_scaling_ratio);
-	if (likely(tsc_aux_uret_slot >= 0))
+	/*
+	 * TSC_AUX is always virtualized for SEV-ES guests when the feature is
+	 * available. The user return MSR support is not required in this case
+	 * because TSC_AUX is restored on #VMEXIT from the host save area
+	 * (which has been initialized in svm_hardware_enable()).
+	 */
+	if (likely(tsc_aux_uret_slot >= 0) &&
+	    (!boot_cpu_has(X86_FEATURE_V_TSC_AUX) || !sev_es_guest(vcpu->kvm)))
 		kvm_set_user_return_msr(tsc_aux_uret_slot, svm->tsc_aux, -1ull);
 	svm->guest_state_loaded = true;
 		svm->sysenter_esp_hi = guest_cpuid_is_intel(vcpu) ? (data >> 32) : 0;
 		break;
 	case MSR_TSC_AUX:
+		/*
+		 * TSC_AUX is always virtualized for SEV-ES guests when the
+		 * feature is available. The user return MSR support is not
+		 * required in this case because TSC_AUX is restored on #VMEXIT
+		 * from the host save area (which has been initialized in
+		 * svm_hardware_enable()).
+		 */
+		if (boot_cpu_has(X86_FEATURE_V_TSC_AUX) && sev_es_guest(vcpu->kvm))
+			break;
 		/*
 		 * TSC_AUX is usually changed only during boot and never read
 		 * directly.  Intercept TSC_AUX instead of exposing it to the
 static void svm_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu)
 {
 	struct vcpu_svm *svm = to_svm(vcpu);
-	struct kvm_cpuid_entry2 *best;
 	/*
 	 * SVM doesn't provide a way to disable just XSAVES in the guest, KVM
 		set_msr_interception(vcpu, svm->msrpm, MSR_IA32_FLUSH_CMD, 0,
 				     !!guest_cpuid_has(vcpu, X86_FEATURE_FLUSH_L1D));
-	/* For sev guests, the memory encryption bit is not reserved in CR3.  */
+	if (sev_guest(vcpu->kvm))
-	if (sev_guest(vcpu->kvm)) {
+		sev_vcpu_after_set_cpuid(svm);
-		best = kvm_find_cpuid_entry(vcpu, 0x8000001F);
-		if (best)
-			vcpu->arch.reserved_gpa_bits &= ~(1UL << (best->ebx & 0x3f));
-	}
 	init_vmcb_after_set_cpuid(vcpu);
 }

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

@@ -684,6 +684,7 @@ void __init sev_hardware_setup(void); · 683 unmodified lines
684	void sev_hardware_unsetup(void);	684	void sev_hardware_unsetup(void);
685	int sev_cpu_init(struct svm_cpu_data *sd);	685	int sev_cpu_init(struct svm_cpu_data *sd);
686	void sev_init_vmcb(struct vcpu_svm *svm);	686	void sev_init_vmcb(struct vcpu_svm *svm);
		687	void sev_vcpu_after_set_cpuid(struct vcpu_svm *svm);
687	void sev_free_vcpu(struct kvm_vcpu *vcpu);	688	void sev_free_vcpu(struct kvm_vcpu *vcpu);
688	int sev_handle_vmgexit(struct kvm_vcpu *vcpu);	689	int sev_handle_vmgexit(struct kvm_vcpu *vcpu);
689	int sev_es_string_io(struct vcpu_svm *svm, int size, unsigned int port, int in);	690	int sev_es_string_io(struct vcpu_svm *svm, int size, unsigned int port, int in);

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

 	if (ret)
 		goto out;
-	ret = kvm_mmu_init_vm(kvm);
+	kvm_mmu_init_vm(kvm);
-	if (ret)
-		goto out_page_track;
 	ret = static_call(kvm_x86_vm_init)(kvm);
 	if (ret)
 out_uninit_mmu:
 	kvm_mmu_uninit_vm(kvm);
-out_page_track:
 	kvm_page_track_cleanup(kvm);
 out:
 	return ret;

arch/x86/lib/memcpy_64.S+1−1

@@ -40,7 +40,7 @@ SYM_TYPED_FUNC_START(__memcpy) · 39 unmodified lines
40	SYM_FUNC_END(__memcpy)	40	SYM_FUNC_END(__memcpy)
41	EXPORT_SYMBOL(__memcpy)	41	EXPORT_SYMBOL(__memcpy)
42		42
43	SYM_FUNC_ALIAS(memcpy, __memcpy)	43	SYM_FUNC_ALIAS_MEMFUNC(memcpy, __memcpy)
44	EXPORT_SYMBOL(memcpy)	44	EXPORT_SYMBOL(memcpy)
45		45
46	SYM_FUNC_START_LOCAL(memcpy_orig)	46	SYM_FUNC_START_LOCAL(memcpy_orig)

arch/x86/lib/memmove_64.S+1−1

@@ -212,5 +212,5 @@ SYM_FUNC_START(__memmove) · 211 unmodified lines
212	SYM_FUNC_END(__memmove)	212	SYM_FUNC_END(__memmove)
213	EXPORT_SYMBOL(__memmove)	213	EXPORT_SYMBOL(__memmove)
214		214
215	SYM_FUNC_ALIAS(memmove, __memmove)	215	SYM_FUNC_ALIAS_MEMFUNC(memmove, __memmove)
216	EXPORT_SYMBOL(memmove)	216	EXPORT_SYMBOL(memmove)

arch/x86/lib/memset_64.S+1−1

@@ -40,7 +40,7 @@ SYM_FUNC_START(__memset) · 39 unmodified lines
40	SYM_FUNC_END(__memset)	40	SYM_FUNC_END(__memset)
41	EXPORT_SYMBOL(__memset)	41	EXPORT_SYMBOL(__memset)
42		42
43	SYM_FUNC_ALIAS(memset, __memset)	43	SYM_FUNC_ALIAS_MEMFUNC(memset, __memset)
44	EXPORT_SYMBOL(memset)	44	EXPORT_SYMBOL(memset)
45		45
46	SYM_FUNC_START_LOCAL(memset_orig)	46	SYM_FUNC_START_LOCAL(memset_orig)

arch/xtensa/boot/Makefile+1−2

@@ -9,8 +9,7 @@ · 8 unmodified lines
9		9
10		10
11	# KBUILD_CFLAGS used when building rest of boot (takes effect recursively)	11	# KBUILD_CFLAGS used when building rest of boot (takes effect recursively)
12	KBUILD_CFLAGS += -fno-builtin -Iarch/$(ARCH)/boot/include	12	KBUILD_CFLAGS += -fno-builtin
13	HOSTFLAGS += -Iarch/$(ARCH)/boot/include
14		13
15	subdir-y := lib	14	subdir-y := lib
16	targets += vmlinux.bin vmlinux.bin.gz	15	targets += vmlinux.bin vmlinux.bin.gz

arch/xtensa/boot/lib/zmem.c+3−2

 /* bits taken from ppc */
 extern void *avail_ram, *end_avail;
+void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp);
-void exit (void)
+static void exit(void)
 {
   for (;;);
 }
-void *zalloc(unsigned size)
+static void *zalloc(unsigned int size)
 {
         void *p = avail_ram;

arch/xtensa/include/asm/core.h+4−0

@@ -6,6 +6,10 @@ · 5 unmodified lines
6		6
7	#include <variant/core.h>	7	#include <variant/core.h>
8		8
		9	#ifndef XCHAL_HAVE_DIV32
		10	#define XCHAL_HAVE_DIV32 0
		11	#endif
		12
9	#ifndef XCHAL_HAVE_EXCLUSIVE	13	#ifndef XCHAL_HAVE_EXCLUSIVE
10	#define XCHAL_HAVE_EXCLUSIVE 0	14	#define XCHAL_HAVE_EXCLUSIVE 0
11	#endif	15	#endif

arch/xtensa/include/asm/hw_breakpoint.h+1−0

@@ -48,6 +48,7 @@ void arch_uninstall_hw_breakpoint(struct perf_event *bp); · 47 unmodified lines
48	void hw_breakpoint_pmu_read(struct perf_event *bp);	48	void hw_breakpoint_pmu_read(struct perf_event *bp);
49	int check_hw_breakpoint(struct pt_regs *regs);	49	int check_hw_breakpoint(struct pt_regs *regs);
50	void clear_ptrace_hw_breakpoint(struct task_struct *tsk);	50	void clear_ptrace_hw_breakpoint(struct task_struct *tsk);
		51	void restore_dbreak(void);
51		52
52	#else	53	#else
53		54

arch/xtensa/include/asm/processor.h+5−0

 #include <linux/compiler.h>
 #include <linux/stringify.h>
+#include <asm/bootparam.h>
 #include <asm/ptrace.h>
 #include <asm/types.h>
 #include <asm/regs.h>
 extern unsigned long __get_wchan(struct task_struct *p);
+void init_arch(bp_tag_t *bp_start);
+void do_notify_resume(struct pt_regs *regs);
 #define KSTK_EIP(tsk)		(task_pt_regs(tsk)->pc)
 #define KSTK_ESP(tsk)		(task_pt_regs(tsk)->areg[1])

arch/xtensa/include/asm/ptrace.h+3−0

@@ -106,6 +106,9 @@ static inline unsigned long regs_return_value(struct pt_regs *regs) · 105 unmodified lines
106	return regs->areg[2];	106	return regs->areg[2];
107	}	107	}
108		108
		109	int do_syscall_trace_enter(struct pt_regs *regs);
		110	void do_syscall_trace_leave(struct pt_regs *regs);
		111
109	#else /* __ASSEMBLY__ */	112	#else /* __ASSEMBLY__ */
110		113
111	# include <asm/asm-offsets.h>	114	# include <asm/asm-offsets.h>

arch/xtensa/include/asm/smp.h+1−0

@@ -23,6 +23,7 @@ struct cpumask; · 22 unmodified lines
23	void arch_send_call_function_ipi_mask(const struct cpumask *mask);	23	void arch_send_call_function_ipi_mask(const struct cpumask *mask);
24	void arch_send_call_function_single_ipi(int cpu);	24	void arch_send_call_function_single_ipi(int cpu);
25		25
		26	void secondary_start_kernel(void);
26	void smp_init_cpus(void);	27	void smp_init_cpus(void);
27	void secondary_init_irq(void);	28	void secondary_init_irq(void);
28	void ipi_init(void);	29	void ipi_init(void);

arch/xtensa/include/asm/tlb.h+2−0

@@ -18,4 +18,6 @@ · 17 unmodified lines
18		18
19	#define __pte_free_tlb(tlb, pte, address) pte_free((tlb)->mm, pte)	19	#define __pte_free_tlb(tlb, pte, address) pte_free((tlb)->mm, pte)
20		20
		21	void check_tlb_sanity(void);
		22
21	#endif /* _XTENSA_TLB_H */	23	#endif /* _XTENSA_TLB_H */

arch/xtensa/kernel/hw_breakpoint.c+1−0

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	#include <linux/percpu.h>	13	#include <linux/percpu.h>
14	#include <linux/perf_event.h>	14	#include <linux/perf_event.h>
15	#include <asm/core.h>	15	#include <asm/core.h>
		16	#include <asm/hw_breakpoint.h>
16		17
17	/* Breakpoint currently in use for each IBREAKA. */	18	/* Breakpoint currently in use for each IBREAKA. */
18	static DEFINE_PER_CPU(struct perf_event *, bp_on_reg[XCHAL_NUM_IBREAK]);	19	static DEFINE_PER_CPU(struct perf_event *, bp_on_reg[XCHAL_NUM_IBREAK]);

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

@@ -28,6 +28,7 @@ · 27 unmodified lines
28	#include <asm/mxregs.h>	28	#include <asm/mxregs.h>
29	#include <linux/uaccess.h>	29	#include <linux/uaccess.h>
30	#include <asm/platform.h>	30	#include <asm/platform.h>
		31	#include <asm/traps.h>
31		32
32	DECLARE_PER_CPU(unsigned long, nmi_count);	33	DECLARE_PER_CPU(unsigned long, nmi_count);
33		34

arch/xtensa/kernel/ptrace.c+0−1

@@ -541,7 +541,6 @@ long arch_ptrace(struct task_struct *child, long request, · 540 unmodified lines
541	return ret;	541	return ret;
542	}	542	}
543		543
544	void do_syscall_trace_leave(struct pt_regs *regs);
545	int do_syscall_trace_enter(struct pt_regs *regs)	544	int do_syscall_trace_enter(struct pt_regs *regs)
546	{	545	{
547	if (regs->syscall == NO_SYSCALL)	546	if (regs->syscall == NO_SYSCALL)

arch/xtensa/kernel/signal.c+2−0

@@ -26,6 +26,8 @@ · 25 unmodified lines
26	#include <linux/uaccess.h>	26	#include <linux/uaccess.h>
27	#include <asm/cacheflush.h>	27	#include <asm/cacheflush.h>
28	#include <asm/coprocessor.h>	28	#include <asm/coprocessor.h>
		29	#include <asm/processor.h>
		30	#include <asm/syscall.h>
29	#include <asm/unistd.h>	31	#include <asm/unistd.h>
30		32
31	extern struct task_struct *coproc_owners[];	33	extern struct task_struct *coproc_owners[];

arch/xtensa/kernel/smp.c+1−0

@@ -21,6 +21,7 @@ · 20 unmodified lines
21	#include <linux/irq.h>	21	#include <linux/irq.h>
22	#include <linux/kdebug.h>	22	#include <linux/kdebug.h>
23	#include <linux/module.h>	23	#include <linux/module.h>
		24	#include <linux/profile.h>
24	#include <linux/sched/mm.h>	25	#include <linux/sched/mm.h>
25	#include <linux/sched/hotplug.h>	26	#include <linux/sched/hotplug.h>
26	#include <linux/sched/task_stack.h>	27	#include <linux/sched/task_stack.h>

arch/xtensa/kernel/stacktrace.c+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/sched.h>	12	#include <linux/sched.h>
13	#include <linux/stacktrace.h>	13	#include <linux/stacktrace.h>
14		14
		15	#include <asm/ftrace.h>
15	#include <asm/stacktrace.h>	16	#include <asm/stacktrace.h>
16	#include <asm/traps.h>	17	#include <asm/traps.h>
17	#include <linux/uaccess.h>	18	#include <linux/uaccess.h>

arch/xtensa/kernel/traps.c+1−0

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	* for more details.	23	* for more details.
24	*/	24	*/
25		25
		26	#include <linux/cpu.h>
26	#include <linux/kernel.h>	27	#include <linux/kernel.h>
27	#include <linux/sched/signal.h>	28	#include <linux/sched/signal.h>
28	#include <linux/sched/debug.h>	29	#include <linux/sched/debug.h>

arch/xtensa/lib/umulsidi3.S+3−1

@@ -3,7 +3,9 @@ · 2 unmodified lines
3	#include <asm/asmmacro.h>	3	#include <asm/asmmacro.h>
4	#include <asm/core.h>	4	#include <asm/core.h>
5		5
6	#if !XCHAL_HAVE_MUL16 && !XCHAL_HAVE_MUL32 && !XCHAL_HAVE_MAC16	6	#if XCHAL_HAVE_MUL16 \|\| XCHAL_HAVE_MUL32 \|\| XCHAL_HAVE_MAC16
		7	#define XCHAL_NO_MUL 0
		8	#else
7	#define XCHAL_NO_MUL 1	9	#define XCHAL_NO_MUL 1
8	#endif	10	#endif
9		11

arch/xtensa/mm/fault.c+1−0

@@ -20,6 +20,7 @@ · 19 unmodified lines
20	#include <asm/mmu_context.h>	20	#include <asm/mmu_context.h>
21	#include <asm/cacheflush.h>	21	#include <asm/cacheflush.h>
22	#include <asm/hardirq.h>	22	#include <asm/hardirq.h>
		23	#include <asm/traps.h>
23		24
24	void bad_page_fault(struct pt_regs*, unsigned long, int);	25	void bad_page_fault(struct pt_regs*, unsigned long, int);
25		26

arch/xtensa/mm/tlb.c+1−0

@@ -17,6 +17,7 @@ · 16 unmodified lines
17	#include <linux/mm.h>	17	#include <linux/mm.h>
18	#include <asm/processor.h>	18	#include <asm/processor.h>
19	#include <asm/mmu_context.h>	19	#include <asm/mmu_context.h>
		20	#include <asm/tlb.h>
20	#include <asm/tlbflush.h>	21	#include <asm/tlbflush.h>
21	#include <asm/cacheflush.h>	22	#include <asm/cacheflush.h>
22		23

arch/xtensa/platforms/iss/network.c+2−2

@@ -201,7 +201,7 @@ static int tuntap_write(struct iss_net_private lp, struct sk_buff *skb) · 200 unmodified lines
201	return simc_write(lp->tp.info.tuntap.fd, (skb)->data, (skb)->len);	201	return simc_write(lp->tp.info.tuntap.fd, (skb)->data, (skb)->len);
202	}	202	}
203		203
204	unsigned short tuntap_protocol(struct sk_buff *skb)	204	static unsigned short tuntap_protocol(struct sk_buff *skb)
205	{	205	{
206	return eth_type_trans(skb, skb->dev);	206	return eth_type_trans(skb, skb->dev);
207	}	207	}
@@ -441,7 +441,7 @@ static int iss_net_change_mtu(struct net_device *dev, int new_mtu) · 233 unmodified lines
441	return -EINVAL;	441	return -EINVAL;
442	}	442	}
443		443
444	void iss_net_user_timer_expire(struct timer_list *unused)	444	static void iss_net_user_timer_expire(struct timer_list *unused)
445	{	445	{
446	}	446	}
447		447

block/blk-rq-qos.c+1−1

@@ -270,7 +270,7 @@ void rq_qos_wait(struct rq_wait rqw, void private_data, · 269 unmodified lines
270	finish_wait(&rqw->wait, &data.wq);	270	finish_wait(&rqw->wait, &data.wq);
271		271
272	/*	272	/*
273	* We raced with wbt_wake_function() getting a token,	273	* We raced with rq_qos_wake_function() getting a token,
274	* which means we now have two. Put our local token	274	* which means we now have two. Put our local token
275	* and wake anyone else potentially waiting for one.	275	* and wake anyone else potentially waiting for one.
276	*/	276	*/

block/disk-events.c+0−1

@@ -290,7 +290,6 @@ EXPORT_SYMBOL(disk_check_media_change); · 289 unmodified lines
290	/**	290	/**
291	* disk_force_media_change - force a media change event	291	* disk_force_media_change - force a media change event
292	* @disk: the disk which will raise the event	292	* @disk: the disk which will raise the event
293	* @events: the events to raise
294	*	293	*
295	* Should be called when the media changes for @disk. Generates a uevent	294	* Should be called when the media changes for @disk. Generates a uevent
296	* and attempts to free all dentries and inodes and invalidates all block	295	* and attempts to free all dentries and inodes and invalidates all block

crypto/sm2.c+5−1

 	if (!ec)
 		return -ENOMEM;
-	err = __sm2_set_pub_key(ec, key, keylen);
+	err = sm2_ec_ctx_init(ec);
 	if (err)
 		goto out_free_ec;
+	err = __sm2_set_pub_key(ec, key, keylen);
+	if (err)
+		goto out_deinit_ec;
 	bits_len = SM2_DEFAULT_USERID_LEN * 8;
 	entl[0] = bits_len >> 8;
 	entl[1] = bits_len & 0xff;

drivers/accel/ivpu/ivpu_drv.c+2−1

 	}
 	if (!ret)
-		ivpu_info(vdev, "VPU ready message received successfully\n");
+		ivpu_dbg(vdev, PM, "VPU ready message received successfully\n");
 	else
 		ivpu_hw_diagnose_failure(vdev);
 static struct pci_device_id ivpu_pci_ids[] = {
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_MTL) },
+	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_ARL) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_LNL) },
 	{ }
 };

drivers/accel/ivpu/ivpu_drv.h+2−0

 #define DRIVER_DATE "20230117"
 #define PCI_DEVICE_ID_MTL   0x7d1d
+#define PCI_DEVICE_ID_ARL   0xad1d
 #define PCI_DEVICE_ID_LNL   0x643e
 #define IVPU_HW_37XX	37
 {
 	switch (ivpu_device_id(vdev)) {
 	case PCI_DEVICE_ID_MTL:
+	case PCI_DEVICE_ID_ARL:
 		return IVPU_HW_37XX;
 	case PCI_DEVICE_ID_LNL:
 		return IVPU_HW_40XX;

drivers/accel/ivpu/ivpu_fw.c+5−3

 	if (ret)
 		return ret;
-	fw->mem = ivpu_bo_alloc_internal(vdev, fw->runtime_addr, fw->runtime_size, DRM_IVPU_BO_WC);
+	fw->mem = ivpu_bo_alloc_internal(vdev, fw->runtime_addr, fw->runtime_size,
+					 DRM_IVPU_BO_CACHED | DRM_IVPU_BO_NOSNOOP);
 	if (!fw->mem) {
 		ivpu_err(vdev, "Failed to allocate firmware runtime memory\n");
 		return -ENOMEM;
 		memset(start, 0, size);
 	}
-	wmb(); /* Flush WC buffers after writing fw->mem */
+	clflush_cache_range(fw->mem->kvaddr, fw->mem->base.size);
 	return 0;
 }
 	if (!ivpu_fw_is_cold_boot(vdev)) {
 		boot_params->save_restore_ret_address = 0;
 		vdev->pm->is_warmboot = true;
+		clflush_cache_range(vdev->fw->mem->kvaddr, SZ_4K);
 		return;
 	}
 	boot_params->punit_telemetry_sram_size = ivpu_hw_reg_telemetry_size_get(vdev);
 	boot_params->vpu_telemetry_enable = ivpu_hw_reg_telemetry_enable_get(vdev);
-	wmb(); /* Flush WC buffers after writing bootparams */
+	clflush_cache_range(vdev->fw->mem->kvaddr, SZ_4K);
 	ivpu_fw_boot_params_print(vdev, boot_params);
 }

drivers/accel/ivpu/ivpu_gem.h+5−0

 #include <drm/drm_gem.h>
 #include <drm/drm_mm.h>
+#define DRM_IVPU_BO_NOSNOOP       0x10000000
 struct dma_buf;
 struct ivpu_bo_ops;
 struct ivpu_file_priv;
 static inline bool ivpu_bo_is_snooped(struct ivpu_bo *bo)
 {
+	if (bo->flags & DRM_IVPU_BO_NOSNOOP)
+		return false;
 	return ivpu_bo_cache_mode(bo) == DRM_IVPU_BO_CACHED;
 }

drivers/accel/ivpu/ivpu_hw_40xx.c+23−4

 #define ICB_0_1_IRQ_MASK ((((u64)ICB_1_IRQ_MASK) << 32) | ICB_0_IRQ_MASK)
-#define BUTTRESS_IRQ_MASK ((REG_FLD(VPU_40XX_BUTTRESS_INTERRUPT_STAT, FREQ_CHANGE)) | \
+#define BUTTRESS_IRQ_MASK ((REG_FLD(VPU_40XX_BUTTRESS_INTERRUPT_STAT, ATS_ERR)) | \
-			   (REG_FLD(VPU_40XX_BUTTRESS_INTERRUPT_STAT, ATS_ERR)) | \
 			   (REG_FLD(VPU_40XX_BUTTRESS_INTERRUPT_STAT, CFI0_ERR)) | \
 			   (REG_FLD(VPU_40XX_BUTTRESS_INTERRUPT_STAT, CFI1_ERR)) | \
 			   (REG_FLD(VPU_40XX_BUTTRESS_INTERRUPT_STAT, IMR0_ERR)) | \
 	return REGB_POLL_FLD(VPU_40XX_BUTTRESS_VPU_STATUS, READY, 1, PLL_TIMEOUT_US);
 }
+static int ivpu_wait_for_clock_own_resource_ack(struct ivpu_device *vdev)
+{
+	if (ivpu_is_simics(vdev))
+		return 0;
+	return REGB_POLL_FLD(VPU_40XX_BUTTRESS_VPU_STATUS, CLOCK_RESOURCE_OWN_ACK, 1, TIMEOUT_US);
+}
 static void ivpu_pll_init_frequency_ratios(struct ivpu_device *vdev)
 {
 	struct ivpu_hw_info *hw = vdev->hw;
 {
 	int ret;
+	ret = ivpu_wait_for_clock_own_resource_ack(vdev);
+	if (ret) {
+		ivpu_err(vdev, "Timed out waiting for clock own resource ACK\n");
+		return ret;
+	}
 	ivpu_boot_pwr_island_trickle_drive(vdev, true);
 	ivpu_boot_pwr_island_drive(vdev, true);
 	if (status == 0)
 		return IRQ_NONE;
-	REGB_WR32(VPU_40XX_BUTTRESS_INTERRUPT_STAT, status);
 	if (REG_TEST_FLD(VPU_40XX_BUTTRESS_INTERRUPT_STAT, FREQ_CHANGE, status))
 		ivpu_dbg(vdev, IRQ, "FREQ_CHANGE");
 		schedule_recovery = true;
 	}
+	/* This must be done after interrupts are cleared at the source. */
+	REGB_WR32(VPU_40XX_BUTTRESS_INTERRUPT_STAT, status);
 	if (schedule_recovery)
 		ivpu_pm_schedule_recovery(vdev);
 	struct ivpu_device *vdev = ptr;
 	irqreturn_t ret = IRQ_NONE;
+	REGB_WR32(VPU_40XX_BUTTRESS_GLOBAL_INT_MASK, 0x1);
 	ret |= ivpu_hw_40xx_irqv_handler(vdev, irq);
 	ret |= ivpu_hw_40xx_irqb_handler(vdev, irq);
+	/* Re-enable global interrupts to re-trigger MSI for pending interrupts */
+	REGB_WR32(VPU_40XX_BUTTRESS_GLOBAL_INT_MASK, 0x0);
 	if (ret & IRQ_WAKE_THREAD)
 		return IRQ_WAKE_THREAD;

drivers/accel/ivpu/ivpu_hw_40xx_reg.h+2−0

@@ -70,6 +70,8 @@ · 69 unmodified lines
70	#define VPU_40XX_BUTTRESS_VPU_STATUS_READY_MASK BIT_MASK(0)	70	#define VPU_40XX_BUTTRESS_VPU_STATUS_READY_MASK BIT_MASK(0)
71	#define VPU_40XX_BUTTRESS_VPU_STATUS_IDLE_MASK BIT_MASK(1)	71	#define VPU_40XX_BUTTRESS_VPU_STATUS_IDLE_MASK BIT_MASK(1)
72	#define VPU_40XX_BUTTRESS_VPU_STATUS_DUP_IDLE_MASK BIT_MASK(2)	72	#define VPU_40XX_BUTTRESS_VPU_STATUS_DUP_IDLE_MASK BIT_MASK(2)
		73	#define VPU_40XX_BUTTRESS_VPU_STATUS_CLOCK_RESOURCE_OWN_ACK_MASK BIT_MASK(6)
		74	#define VPU_40XX_BUTTRESS_VPU_STATUS_POWER_RESOURCE_OWN_ACK_MASK BIT_MASK(7)
73	#define VPU_40XX_BUTTRESS_VPU_STATUS_PERF_CLK_MASK BIT_MASK(11)	75	#define VPU_40XX_BUTTRESS_VPU_STATUS_PERF_CLK_MASK BIT_MASK(11)
74	#define VPU_40XX_BUTTRESS_VPU_STATUS_DISABLE_CLK_RELINQUISH_MASK BIT_MASK(12)	76	#define VPU_40XX_BUTTRESS_VPU_STATUS_DISABLE_CLK_RELINQUISH_MASK BIT_MASK(12)
75		77

drivers/accel/ivpu/ivpu_ipc.c+4−7

 	struct ivpu_ipc_rx_msg *rx_msg;
 	int wait_ret, ret = 0;
-	wait_ret = wait_event_interruptible_timeout(cons->rx_msg_wq,
+	wait_ret = wait_event_timeout(cons->rx_msg_wq,
-						    (IS_KTHREAD() && kthread_should_stop()) ||
+				      (IS_KTHREAD() && kthread_should_stop()) ||
-						    !list_empty(&cons->rx_msg_list),
+				      !list_empty(&cons->rx_msg_list),
-						    msecs_to_jiffies(timeout_ms));
+				      msecs_to_jiffies(timeout_ms));
 	if (IS_KTHREAD() && kthread_should_stop())
 		return -EINTR;
 	if (wait_ret == 0)
 		return -ETIMEDOUT;
-	if (wait_ret < 0)
-		return -ERESTARTSYS;
 	spin_lock_irq(&cons->rx_msg_lock);
 	rx_msg = list_first_entry_or_null(&cons->rx_msg_list, struct ivpu_ipc_rx_msg, link);
 	if (!rx_msg) {

drivers/acpi/acpi_video.c+5−2

 	    !auto_detect)
 		acpi_video_bus_register_backlight(video);
-	acpi_video_bus_add_notify_handler(video);
+	error = acpi_video_bus_add_notify_handler(video);
+	if (error)
+		goto err_del;
 	error = acpi_dev_install_notify_handler(device, ACPI_DEVICE_NOTIFY,
 						acpi_video_bus_notify);
 	return 0;
 err_remove:
+	acpi_video_bus_remove_notify_handler(video);
+err_del:
 	mutex_lock(&video_list_lock);
 	list_del(&video->entry);
 	mutex_unlock(&video_list_lock);
-	acpi_video_bus_remove_notify_handler(video);
 	acpi_video_bus_unregister_backlight(video);
 err_put_video:
 	acpi_video_bus_put_devices(video);

drivers/acpi/nfit/core.c+1−1

@@ -855,7 +855,7 @@ static size_t sizeof_idt(struct acpi_nfit_interleave *idt) · 854 unmodified lines
855	{	855	{
856	if (idt->header.length < sizeof(*idt))	856	if (idt->header.length < sizeof(*idt))
857	return 0;	857	return 0;
858	return sizeof(idt) + sizeof(u32) (idt->line_count - 1);	858	return sizeof(idt) + sizeof(u32) idt->line_count;
859	}	859	}
860		860
861	static bool add_idt(struct acpi_nfit_desc *acpi_desc,	861	static bool add_idt(struct acpi_nfit_desc *acpi_desc,

drivers/acpi/processor_pdc.c+1−0

@@ -19,6 +19,7 @@ static void acpi_set_pdc_bits(u32 *buf) · 18 unmodified lines
19	{	19	{
20	buf[0] = ACPI_PDC_REVISION_ID;	20	buf[0] = ACPI_PDC_REVISION_ID;
21	buf[1] = 1;	21	buf[1] = 1;
		22	buf[2] = 0;
22		23
23	/* Twiddle arch-specific bits needed for _PDC */	24	/* Twiddle arch-specific bits needed for _PDC */
24	arch_acpi_set_proc_cap_bits(&buf[2]);	25	arch_acpi_set_proc_cap_bits(&buf[2]);

drivers/ata/libata-core.c+137−12

@@ -1972,6 +1972,96 @@ retry: · 1971 unmodified lines
1972	return rc;	1972	return rc;
1973	}	1973	}
1974		1974
		1975	/**
		1976	* ata_dev_power_set_standby - Set a device power mode to standby
		1977	* @dev: target device
		1978	*
		1979	* Issue a STANDBY IMMEDIATE command to set a device power mode to standby.
		1980	* For an HDD device, this spins down the disks.
		1981	*
		1982	* LOCKING:
		1983	* Kernel thread context (may sleep).
		1984	*/
		1985	void ata_dev_power_set_standby(struct ata_device *dev)
		1986	{
		1987	unsigned long ap_flags = dev->link->ap->flags;
		1988	struct ata_taskfile tf;
		1989	unsigned int err_mask;
		1990
		1991	/* Issue STANDBY IMMEDIATE command only if supported by the device */
		1992	if (dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC)
		1993	return;
		1994
		1995	/*
		1996	* Some odd clown BIOSes issue spindown on power off (ACPI S4 or S5)
		1997	* causing some drives to spin up and down again. For these, do nothing
		1998	* if we are being called on shutdown.
		1999	*/
		2000	if ((ap_flags & ATA_FLAG_NO_POWEROFF_SPINDOWN) &&
		2001	system_state == SYSTEM_POWER_OFF)
		2002	return;
		2003
		2004	if ((ap_flags & ATA_FLAG_NO_HIBERNATE_SPINDOWN) &&
		2005	system_entering_hibernation())
		2006	return;
		2007
		2008	ata_tf_init(dev, &tf);
		2009	tf.flags \|= ATA_TFLAG_DEVICE \| ATA_TFLAG_ISADDR;
		2010	tf.protocol = ATA_PROT_NODATA;
		2011	tf.command = ATA_CMD_STANDBYNOW1;
		2012
		2013	ata_dev_notice(dev, "Entering standby power mode\n");
		2014
		2015	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
		2016	if (err_mask)
		2017	ata_dev_err(dev, "STANDBY IMMEDIATE failed (err_mask=0x%x)\n",
		2018	err_mask);
		2019	}
		2020
		2021	/**
		2022	* ata_dev_power_set_active - Set a device power mode to active
		2023	* @dev: target device
		2024	*
		2025	* Issue a VERIFY command to enter to ensure that the device is in the
		2026	* active power mode. For a spun-down HDD (standby or idle power mode),
		2027	* the VERIFY command will complete after the disk spins up.
		2028	*
		2029	* LOCKING:
		2030	* Kernel thread context (may sleep).
		2031	*/
		2032	void ata_dev_power_set_active(struct ata_device *dev)
		2033	{
		2034	struct ata_taskfile tf;
		2035	unsigned int err_mask;
		2036
		2037	/*
		2038	* Issue READ VERIFY SECTORS command for 1 sector at lba=0 only
		2039	* if supported by the device.
		2040	*/
		2041	if (dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC)
		2042	return;
		2043
		2044	ata_tf_init(dev, &tf);
		2045	tf.flags \|= ATA_TFLAG_DEVICE \| ATA_TFLAG_ISADDR;
		2046	tf.protocol = ATA_PROT_NODATA;
		2047	tf.command = ATA_CMD_VERIFY;
		2048	tf.nsect = 1;
		2049	if (dev->flags & ATA_DFLAG_LBA) {
		2050	tf.flags \|= ATA_TFLAG_LBA;
		2051	tf.device \|= ATA_LBA;
		2052	} else {
		2053	/* CHS */
		2054	tf.lbal = 0x1; /* sect */
		2055	}
		2056
		2057	ata_dev_notice(dev, "Entering active power mode\n");
		2058
		2059	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
		2060	if (err_mask)
		2061	ata_dev_err(dev, "VERIFY failed (err_mask=0x%x)\n",
		2062	err_mask);
		2063	}
		2064
1975	/**	2065	/**
1976	* ata_read_log_page - read a specific log page	2066	* ata_read_log_page - read a specific log page
1977	* @dev: target device	2067	* @dev: target device
@@ -2529,7 +2619,7 @@ static int ata_dev_config_lba(struct ata_device *dev) · 551 unmodified lines
2529	{	2619	{
2530	const u16 *id = dev->id;	2620	const u16 *id = dev->id;
2531	const char *lba_desc;	2621	const char *lba_desc;
2532	char ncq_desc[24];	2622	char ncq_desc[32];
2533	int ret;	2623	int ret;
2534		2624
2535	dev->flags \|= ATA_DFLAG_LBA;	2625	dev->flags \|= ATA_DFLAG_LBA;
@@ -5037,17 +5127,19 @@ static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg, · 2501 unmodified lines
5037	struct ata_link *link;	5127	struct ata_link *link;
5038	unsigned long flags;	5128	unsigned long flags;
5039		5129
5040	/* Previous resume operation might still be in	5130	spin_lock_irqsave(ap->lock, flags);
5041	* progress. Wait for PM_PENDING to clear.	5131
		5132	/*
		5133	* A previous PM operation might still be in progress. Wait for
		5134	* ATA_PFLAG_PM_PENDING to clear.
5042	*/	5135	*/
5043	if (ap->pflags & ATA_PFLAG_PM_PENDING) {	5136	if (ap->pflags & ATA_PFLAG_PM_PENDING) {
		5137	spin_unlock_irqrestore(ap->lock, flags);
5044	ata_port_wait_eh(ap);	5138	ata_port_wait_eh(ap);
5045	WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);	5139	spin_lock_irqsave(ap->lock, flags);
5046	}	5140	}
5047		5141
5048	/* request PM ops to EH */	5142	/* Request PM operation to EH */
5049	spin_lock_irqsave(ap->lock, flags);
5050
5051	ap->pm_mesg = mesg;	5143	ap->pm_mesg = mesg;
5052	ap->pflags \|= ATA_PFLAG_PM_PENDING;	5144	ap->pflags \|= ATA_PFLAG_PM_PENDING;
5053	ata_for_each_link(link, ap, HOST_FIRST) {	5145	ata_for_each_link(link, ap, HOST_FIRST) {
@@ -5059,10 +5151,8 @@ static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg, · 5 unmodified lines
5059		5151
5060	spin_unlock_irqrestore(ap->lock, flags);	5152	spin_unlock_irqrestore(ap->lock, flags);
5061		5153
5062	if (!async) {	5154	if (!async)
5063	ata_port_wait_eh(ap);	5155	ata_port_wait_eh(ap);
5064	WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5065	}
5066	}	5156	}
5067		5157
5068	/*	5158	/*
@@ -5078,11 +5168,27 @@ static const unsigned int ata_port_suspend_ehi = ATA_EHI_QUIET · 9 unmodified lines
5078		5168
5079	static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg)	5169	static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg)
5080	{	5170	{
		5171	/*
		5172	* We are about to suspend the port, so we do not care about
		5173	* scsi_rescan_device() calls scheduled by previous resume operations.
		5174	* The next resume will schedule the rescan again. So cancel any rescan
		5175	* that is not done yet.
		5176	*/
		5177	cancel_delayed_work_sync(&ap->scsi_rescan_task);
		5178
5081	ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, false);	5179	ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, false);
5082	}	5180	}
5083		5181
5084	static void ata_port_suspend_async(struct ata_port *ap, pm_message_t mesg)	5182	static void ata_port_suspend_async(struct ata_port *ap, pm_message_t mesg)
5085	{	5183	{
		5184	/*
		5185	* We are about to suspend the port, so we do not care about
		5186	* scsi_rescan_device() calls scheduled by previous resume operations.
		5187	* The next resume will schedule the rescan again. So cancel any rescan
		5188	* that is not done yet.
		5189	*/
		5190	cancel_delayed_work_sync(&ap->scsi_rescan_task);
		5191
5086	ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, true);	5192	ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, true);
5087	}	5193	}
5088		5194
@@ -5229,7 +5335,7 @@ EXPORT_SYMBOL_GPL(ata_host_resume); · 140 unmodified lines
5229	#endif	5335	#endif
5230		5336
5231	const struct device_type ata_port_type = {	5337	const struct device_type ata_port_type = {
5232	.name = "ata_port",	5338	.name = ATA_PORT_TYPE_NAME,
5233	#ifdef CONFIG_PM	5339	#ifdef CONFIG_PM
5234	.pm = &ata_port_pm_ops,	5340	.pm = &ata_port_pm_ops,
5235	#endif	5341	#endif
@@ -5948,11 +6054,30 @@ static void ata_port_detach(struct ata_port *ap) · 712 unmodified lines
5948	struct ata_link *link;	6054	struct ata_link *link;
5949	struct ata_device *dev;	6055	struct ata_device *dev;
5950		6056
5951	/* tell EH we're leaving & flush EH */	6057	/* Wait for any ongoing EH */
		6058	ata_port_wait_eh(ap);
		6059
		6060	mutex_lock(&ap->scsi_scan_mutex);
5952	spin_lock_irqsave(ap->lock, flags);	6061	spin_lock_irqsave(ap->lock, flags);
		6062
		6063	/* Remove scsi devices */
		6064	ata_for_each_link(link, ap, HOST_FIRST) {
		6065	ata_for_each_dev(dev, link, ALL) {
		6066	if (dev->sdev) {
		6067	spin_unlock_irqrestore(ap->lock, flags);
		6068	scsi_remove_device(dev->sdev);
		6069	spin_lock_irqsave(ap->lock, flags);
		6070	dev->sdev = NULL;
		6071	}
		6072	}
		6073	}
		6074
		6075	/* Tell EH to disable all devices */
5953	ap->pflags \|= ATA_PFLAG_UNLOADING;	6076	ap->pflags \|= ATA_PFLAG_UNLOADING;
5954	ata_port_schedule_eh(ap);	6077	ata_port_schedule_eh(ap);
		6078
5955	spin_unlock_irqrestore(ap->lock, flags);	6079	spin_unlock_irqrestore(ap->lock, flags);
		6080	mutex_unlock(&ap->scsi_scan_mutex);
5956		6081
5957	/* wait till EH commits suicide */	6082	/* wait till EH commits suicide */
5958	ata_port_wait_eh(ap);	6083	ata_port_wait_eh(ap);

drivers/ata/libata-eh.c+46−2

 	  .timeouts = ata_eh_other_timeouts, },
 	{ .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT),
 	  .timeouts = ata_eh_flush_timeouts },
+	{ .commands = CMDS(ATA_CMD_VERIFY),
+	  .timeouts = ata_eh_reset_timeouts },
 };
 #undef CMDS
 	struct ata_device *dev;
 	unsigned long flags;
-	/* Restore SControl IPM and SPD for the next driver and
+	/*
+	 * Unless we are restarting, transition all enabled devices to
+	 * standby power mode.
+	 */
+	if (system_state != SYSTEM_RESTART) {
+		ata_for_each_link(link, ap, PMP_FIRST) {
+			ata_for_each_dev(dev, link, ENABLED)
+				ata_dev_power_set_standby(dev);
+		}
+	}
+	/*
+	 * Restore SControl IPM and SPD for the next driver and
 	 * disable attached devices.
 	 */
 	ata_for_each_link(link, ap, PMP_FIRST) {
 			ehc->saved_xfer_mode[devno] = dev->xfer_mode;
 			if (ata_ncq_enabled(dev))
 				ehc->saved_ncq_enabled |= 1 << devno;
+			/* If we are resuming, wake up the device */
+			if (ap->pflags & ATA_PFLAG_RESUMING)
+				ehc->i.dev_action[devno] |= ATA_EH_SET_ACTIVE;
 		}
 	}
 	/* clean up */
 	spin_lock_irqsave(ap->lock, flags);
+	ap->pflags &= ~ATA_PFLAG_RESUMING;
 	if (ap->pflags & ATA_PFLAG_LOADING)
 		ap->pflags &= ~ATA_PFLAG_LOADING;
 	else if ((ap->pflags & ATA_PFLAG_SCSI_HOTPLUG) &&
 	struct ata_eh_context *ehc = &link->eh_context;
 	unsigned long flags;
+	/*
+	 * If the device is still enabled, transition it to standby power mode
+	 * (i.e. spin down HDDs).
+	 */
+	if (ata_dev_enabled(dev))
+		ata_dev_power_set_standby(dev);
 	ata_dev_disable(dev);
 	spin_lock_irqsave(ap->lock, flags);
 	struct ata_eh_context *ehc = &link->eh_context;
 	struct ata_queued_cmd *qc;
 	const char *frozen, *desc;
-	char tries_buf[6] = "";
+	char tries_buf[16] = "";
 	int tag, nr_failed = 0;
 	if (ehc->i.flags & ATA_EHI_QUIET)
 		if (ehc->i.flags & ATA_EHI_DID_RESET)
 			readid_flags |= ATA_READID_POSTRESET;
+		/*
+		 * When resuming, before executing any command, make sure to
+		 * transition the device to the active power mode.
+		 */
+		if ((action & ATA_EH_SET_ACTIVE) && ata_dev_enabled(dev)) {
+			ata_dev_power_set_active(dev);
+			ata_eh_done(link, dev, ATA_EH_SET_ACTIVE);
+		}
 		if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
 			WARN_ON(dev->class == ATA_DEV_PMP);
 	unsigned long flags;
 	int rc = 0;
 	struct ata_device *dev;
+	struct ata_link *link;
 	/* are we suspending? */
 	spin_lock_irqsave(ap->lock, flags);
 	WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
+	/* Set all devices attached to the port in standby mode */
+	ata_for_each_link(link, ap, HOST_FIRST) {
+		ata_for_each_dev(dev, link, ENABLED)
+			ata_dev_power_set_standby(dev);
+	}
 	/*
 	 * If we have a ZPODD attached, check its zero
 	 * power ready status before the port is frozen.
 	/* update the flags */
 	spin_lock_irqsave(ap->lock, flags);
 	ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
+	ap->pflags |= ATA_PFLAG_RESUMING;
 	spin_unlock_irqrestore(ap->lock, flags);
 }
 #endif /* CONFIG_PM */

drivers/ata/libata-scsi.c+67−33

 		}
 	} else {
 		sdev->sector_size = ata_id_logical_sector_size(dev->id);
 		/*
-		 * Stop the drive on suspend but do not issue START STOP UNIT
+		 * Ask the sd driver to issue START STOP UNIT on runtime suspend
-		 * on resume as this is not necessary and may fail: the device
+		 * and resume only. For system level suspend/resume, devices
-		 * will be woken up by ata_port_pm_resume() with a port reset
+		 * power state is handled directly by libata EH.
-		 * and device revalidation.
 		 */
-		sdev->manage_start_stop = 1;
+		sdev->manage_runtime_start_stop = true;
-		sdev->no_start_on_resume = 1;
 	}
 	/*
 	return 0;
 }
+/**
+ *	ata_scsi_slave_alloc - Early setup of SCSI device
+ *	@sdev: SCSI device to examine
+ *
+ *	This is called from scsi_alloc_sdev() when the scsi device
+ *	associated with an ATA device is scanned on a port.
+ *
+ *	LOCKING:
+ *	Defined by SCSI layer.  We don't really care.
+ */
+int ata_scsi_slave_alloc(struct scsi_device *sdev)
+{
+	struct ata_port *ap = ata_shost_to_port(sdev->host);
+	struct device_link *link;
+	ata_scsi_sdev_config(sdev);
+	/*
+	 * Create a link from the ata_port device to the scsi device to ensure
+	 * that PM does suspend/resume in the correct order: the scsi device is
+	 * consumer (child) and the ata port the supplier (parent).
+	 */
+	link = device_link_add(&sdev->sdev_gendev, &ap->tdev,
+			       DL_FLAG_STATELESS |
+			       DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE);
+	if (!link) {
+		ata_port_err(ap, "Failed to create link to scsi device %s\n",
+			     dev_name(&sdev->sdev_gendev));
+		return -ENODEV;
+	}
+	return 0;
+}
+EXPORT_SYMBOL_GPL(ata_scsi_slave_alloc);
 /**
  *	ata_scsi_slave_config - Set SCSI device attributes
  *	@sdev: SCSI device to examine
 {
 	struct ata_port *ap = ata_shost_to_port(sdev->host);
 	struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
-	int rc = 0;
-	ata_scsi_sdev_config(sdev);
 	if (dev)
-		rc = ata_scsi_dev_config(sdev, dev);
+		return ata_scsi_dev_config(sdev, dev);
-	return rc;
+	return 0;
 }
 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
 	unsigned long flags;
 	struct ata_device *dev;
+	device_link_remove(&sdev->sdev_gendev, &ap->tdev);
 	spin_lock_irqsave(ap->lock, flags);
 	dev = __ata_scsi_find_dev(ap, sdev);
 	if (dev && dev->sdev) {
 	}
 	if (cdb[4] & 0x1) {
-		tf->nsect = 1;	/* 1 sector, lba=0 */
+		tf->nsect = 1;  /* 1 sector, lba=0 */
 		if (qc->dev->flags & ATA_DFLAG_LBA) {
 			tf->flags |= ATA_TFLAG_LBA;
 			tf->lbah = 0x0; /* cyl high */
 		}
-		tf->command = ATA_CMD_VERIFY;	/* READ VERIFY */
+		tf->command = ATA_CMD_VERIFY;   /* READ VERIFY */
 	} else {
 		/* Some odd clown BIOSen issue spindown on power off (ACPI S4
 		 * or S5) causing some drives to spin up and down again.
 			goto skip;
 		if ((qc->ap->flags & ATA_FLAG_NO_HIBERNATE_SPINDOWN) &&
-		     system_entering_hibernation())
+		    system_entering_hibernation())
 			goto skip;
 		/* Issue ATA STANDBY IMMEDIATE command */
 		hdr[2] = 0x7; /* claim SPC-5 version compatibility */
 	}
+	if (args->dev->flags & ATA_DFLAG_CDL)
+		hdr[2] = 0xd; /* claim SPC-6 version compatibility */
 	memcpy(rbuf, hdr, sizeof(hdr));
 	memcpy(&rbuf[8], "ATA     ", 8);
 	ata_id_string(args->id, &rbuf[16], ATA_ID_PROD, 16);
 		break;
 	case MAINTENANCE_IN:
-		if (scsicmd[1] == MI_REPORT_SUPPORTED_OPERATION_CODES)
+		if ((scsicmd[1] & 0x1f) == MI_REPORT_SUPPORTED_OPERATION_CODES)
 			ata_scsi_rbuf_fill(&args, ata_scsiop_maint_in);
 		else
 			ata_scsi_set_invalid_field(dev, cmd, 1, 0xff);
 	struct ata_link *link;
 	struct ata_device *dev;
 	unsigned long flags;
-	bool delay_rescan = false;
+	int ret = 0;
 	mutex_lock(&ap->scsi_scan_mutex);
 	spin_lock_irqsave(ap->lock, flags);
 		ata_for_each_dev(dev, link, ENABLED) {
 			struct scsi_device *sdev = dev->sdev;
+			/*
+			 * If the port was suspended before this was scheduled,
+			 * bail out.
+			 */
+			if (ap->pflags & ATA_PFLAG_SUSPENDED)
+				goto unlock;
 			if (!sdev)
 				continue;
 			if (scsi_device_get(sdev))
 				continue;
-			/*
-			 * If the rescan work was scheduled because of a resume
-			 * event, the port is already fully resumed, but the
-			 * SCSI device may not yet be fully resumed. In such
-			 * case, executing scsi_rescan_device() may cause a
-			 * deadlock with the PM code on device_lock(). Prevent
-			 * this by giving up and retrying rescan after a short
-			 * delay.
-			 */
-			delay_rescan = sdev->sdev_gendev.power.is_suspended;
-			if (delay_rescan) {
-				scsi_device_put(sdev);
-				break;
-			}
 			spin_unlock_irqrestore(ap->lock, flags);
-			scsi_rescan_device(sdev);
+			ret = scsi_rescan_device(sdev);
 			scsi_device_put(sdev);
 			spin_lock_irqsave(ap->lock, flags);
+			if (ret)
+				goto unlock;
 		}
 	}
+unlock:
 	spin_unlock_irqrestore(ap->lock, flags);
 	mutex_unlock(&ap->scsi_scan_mutex);
-	if (delay_rescan)
+	/* Reschedule with a delay if scsi_rescan_device() returned an error */
+	if (ret)
 		schedule_delayed_work(&ap->scsi_rescan_task,
 				      msecs_to_jiffies(5));
 }

drivers/ata/libata-transport.c+8−1

 	put_device(dev);
 }
+static const struct device_type ata_port_sas_type = {
+	.name = ATA_PORT_TYPE_NAME,
+};
 /** ata_tport_add - initialize a transport ATA port structure
  *
  * @parent:	parent device
 	struct device *dev = &ap->tdev;
 	device_initialize(dev);
-	dev->type = &ata_port_type;
+	if (ap->flags & ATA_FLAG_SAS_HOST)
+		dev->type = &ata_port_sas_type;
+	else
+		dev->type = &ata_port_type;
 	dev->parent = parent;
 	ata_host_get(ap->host);

drivers/ata/libata.h+4−0

 	ATA_DNXFER_QUIET	= (1 << 31),
 };
+#define ATA_PORT_TYPE_NAME	"ata_port"
 extern atomic_t ata_print_id;
 extern int atapi_passthru16;
 extern int libata_fua;
 extern int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
 			      unsigned int readid_flags);
 extern int ata_dev_configure(struct ata_device *dev);
+extern void ata_dev_power_set_standby(struct ata_device *dev);
+extern void ata_dev_power_set_active(struct ata_device *dev);
 extern int sata_down_spd_limit(struct ata_link *link, u32 spd_limit);
 extern int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel);
 extern unsigned int ata_dev_set_feature(struct ata_device *dev,

drivers/base/regmap/regcache-rbtree.c+2−1

 		if (!rbnode)
 			return -ENOMEM;
 		regcache_rbtree_set_register(map, rbnode,
-					     reg - rbnode->base_reg, value);
+					     (reg - rbnode->base_reg) / map->reg_stride,
+					     value);
 		regcache_rbtree_insert(map, &rbtree_ctx->root, rbnode);
 		rbtree_ctx->cached_rbnode = rbnode;
 	}

drivers/block/rbd.c+225−187

 static void rbd_dev_remove_parent(struct rbd_device *rbd_dev);
 static int rbd_dev_refresh(struct rbd_device *rbd_dev);
-static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev);
+static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev,
-static int rbd_dev_header_info(struct rbd_device *rbd_dev);
+				     struct rbd_image_header *header);
-static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev);
 static const char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev,
 					u64 snap_id);
 static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
 	RCU_INIT_POINTER(rbd_dev->layout.pool_ns, NULL);
 }
+static void rbd_image_header_cleanup(struct rbd_image_header *header)
+{
+	kfree(header->object_prefix);
+	ceph_put_snap_context(header->snapc);
+	kfree(header->snap_sizes);
+	kfree(header->snap_names);
+	memset(header, 0, sizeof(*header));
+}
 /*
  * Fill an rbd image header with information from the given format 1
  * on-disk header.
  */
-static int rbd_header_from_disk(struct rbd_device *rbd_dev,
+static int rbd_header_from_disk(struct rbd_image_header *header,
-				 struct rbd_image_header_ondisk *ondisk)
+				struct rbd_image_header_ondisk *ondisk,
+				bool first_time)
 {
-	struct rbd_image_header *header = &rbd_dev->header;
-	bool first_time = header->object_prefix == NULL;
 	struct ceph_snap_context *snapc;
 	char *object_prefix = NULL;
 	char *snap_names = NULL;
 	if (first_time) {
 		header->object_prefix = object_prefix;
 		header->obj_order = ondisk->options.order;
-		rbd_init_layout(rbd_dev);
-	} else {
-		ceph_put_snap_context(header->snapc);
-		kfree(header->snap_names);
-		kfree(header->snap_sizes);
 	}
 	/* The remaining fields always get updated (when we refresh) */
  * return, the rbd_dev->header field will contain up-to-date
  * information about the image.
  */
-static int rbd_dev_v1_header_info(struct rbd_device *rbd_dev)
+static int rbd_dev_v1_header_info(struct rbd_device *rbd_dev,
+				  struct rbd_image_header *header,
+				  bool first_time)
 {
 	struct rbd_image_header_ondisk *ondisk = NULL;
 	u32 snap_count = 0;
 		snap_count = le32_to_cpu(ondisk->snap_count);
 	} while (snap_count != want_count);
-	ret = rbd_header_from_disk(rbd_dev, ondisk);
+	ret = rbd_header_from_disk(header, ondisk, first_time);
 out:
 	kfree(ondisk);
 	}
 }
-static int rbd_dev_refresh(struct rbd_device *rbd_dev)
-{
-	u64 mapping_size;
-	int ret;
-	down_write(&rbd_dev->header_rwsem);
-	mapping_size = rbd_dev->mapping.size;
-	ret = rbd_dev_header_info(rbd_dev);
-	if (ret)
-		goto out;
-	/*
-	 * If there is a parent, see if it has disappeared due to the
-	 * mapped image getting flattened.
-	 */
-	if (rbd_dev->parent) {
-		ret = rbd_dev_v2_parent_info(rbd_dev);
-		if (ret)
-			goto out;
-	}
-	rbd_assert(!rbd_is_snap(rbd_dev));
-	rbd_dev->mapping.size = rbd_dev->header.image_size;
-out:
-	up_write(&rbd_dev->header_rwsem);
-	if (!ret && mapping_size != rbd_dev->mapping.size)
-		rbd_dev_update_size(rbd_dev);
-	return ret;
-}
 static const struct blk_mq_ops rbd_mq_ops = {
 	.queue_rq	= rbd_queue_rq,
 };
 	return 0;
 }
-static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
+static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev,
-{
+				    char **pobject_prefix)
-	return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
-					&rbd_dev->header.obj_order,
-					&rbd_dev->header.image_size);
-}
-static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
 {
 	size_t size;
 	void *reply_buf;
+	char *object_prefix;
 	int ret;
 	void *p;
 		goto out;
 	p = reply_buf;
-	rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
+	object_prefix = ceph_extract_encoded_string(&p, p + ret, NULL,
-						p + ret, NULL, GFP_NOIO);
+						    GFP_NOIO);
+	if (IS_ERR(object_prefix)) {
+		ret = PTR_ERR(object_prefix);
+		goto out;
+	}
 	ret = 0;
-	if (IS_ERR(rbd_dev->header.object_prefix)) {
+	*pobject_prefix = object_prefix;
-		ret = PTR_ERR(rbd_dev->header.object_prefix);
+	dout("  object_prefix = %s\n", object_prefix);
-		rbd_dev->header.object_prefix = NULL;
-	} else {
-		dout("  object_prefix = %s\n", rbd_dev->header.object_prefix);
-	}
 out:
 	kfree(reply_buf);
 	return 0;
 }
-static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
-{
-	return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
-					 rbd_is_ro(rbd_dev),
-					 &rbd_dev->header.features);
-}
 /*
  * These are generic image flags, but since they are used only for
  * object map, store them in rbd_dev->object_map_flags.
 	u64		overlap;
 };
+static void rbd_parent_info_cleanup(struct parent_image_info *pii)
+{
+	kfree(pii->pool_ns);
+	kfree(pii->image_id);
+	memset(pii, 0, sizeof(*pii));
+}
 /*
  * The caller is responsible for @pii.
  */
 	if (pii->has_overlap)
 		ceph_decode_64_safe(&p, end, pii->overlap, e_inval);
+	dout("%s pool_id %llu pool_ns %s image_id %s snap_id %llu has_overlap %d overlap %llu\n",
+	     __func__, pii->pool_id, pii->pool_ns, pii->image_id, pii->snap_id,
+	     pii->has_overlap, pii->overlap);
 	return 0;
 e_inval:
 	pii->has_overlap = true;
 	ceph_decode_64_safe(&p, end, pii->overlap, e_inval);
+	dout("%s pool_id %llu pool_ns %s image_id %s snap_id %llu has_overlap %d overlap %llu\n",
+	     __func__, pii->pool_id, pii->pool_ns, pii->image_id, pii->snap_id,
+	     pii->has_overlap, pii->overlap);
 	return 0;
 e_inval:
 	return -EINVAL;
 }
-static int get_parent_info(struct rbd_device *rbd_dev,
+static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev,
-			   struct parent_image_info *pii)
+				  struct parent_image_info *pii)
 {
 	struct page *req_page, *reply_page;
 	void *p;
 	return ret;
 }
-static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
+static int rbd_dev_setup_parent(struct rbd_device *rbd_dev)
 {
 	struct rbd_spec *parent_spec;
 	struct parent_image_info pii = { 0 };
 	if (!parent_spec)
 		return -ENOMEM;
-	ret = get_parent_info(rbd_dev, &pii);
+	ret = rbd_dev_v2_parent_info(rbd_dev, &pii);
 	if (ret)
 		goto out_err;
-	dout("%s pool_id %llu pool_ns %s image_id %s snap_id %llu has_overlap %d overlap %llu\n",
+	if (pii.pool_id == CEPH_NOPOOL || !pii.has_overlap)
-	     __func__, pii.pool_id, pii.pool_ns, pii.image_id, pii.snap_id,
-	     pii.has_overlap, pii.overlap);
-	if (pii.pool_id == CEPH_NOPOOL || !pii.has_overlap) {
-		/*
-		 * Either the parent never existed, or we have
-		 * record of it but the image got flattened so it no
-		 * longer has a parent.  When the parent of a
-		 * layered image disappears we immediately set the
-		 * overlap to 0.  The effect of this is that all new
-		 * requests will be treated as if the image had no
-		 * parent.
-		 *
-		 * If !pii.has_overlap, the parent image spec is not
-		 * applicable.  It's there to avoid duplication in each
-		 * snapshot record.
-		 */
-		if (rbd_dev->parent_overlap) {
-			rbd_dev->parent_overlap = 0;
-			rbd_dev_parent_put(rbd_dev);
-			pr_info("%s: clone image has been flattened\n",
-				rbd_dev->disk->disk_name);
-		}
 		goto out;	/* No parent?  No problem. */
-	}
 	/* The ceph file layout needs to fit pool id in 32 bits */
 	}
 	/*
-	 * The parent won't change (except when the clone is
+	 * The parent won't change except when the clone is flattened,
-	 * flattened, already handled that).  So we only need to
+	 * so we only need to record the parent image spec once.
-	 * record the parent spec we have not already done so.
 	 */
-	if (!rbd_dev->parent_spec) {
+	parent_spec->pool_id = pii.pool_id;
-		parent_spec->pool_id = pii.pool_id;
+	if (pii.pool_ns && *pii.pool_ns) {
-		if (pii.pool_ns && *pii.pool_ns) {
+		parent_spec->pool_ns = pii.pool_ns;
-			parent_spec->pool_ns = pii.pool_ns;
+		pii.pool_ns = NULL;
-			pii.pool_ns = NULL;
-		}
-		parent_spec->image_id = pii.image_id;
-		pii.image_id = NULL;
-		parent_spec->snap_id = pii.snap_id;
-		rbd_dev->parent_spec = parent_spec;
-		parent_spec = NULL;	/* rbd_dev now owns this */
 	}
+	parent_spec->image_id = pii.image_id;
+	pii.image_id = NULL;
+	parent_spec->snap_id = pii.snap_id;
+	rbd_assert(!rbd_dev->parent_spec);
+	rbd_dev->parent_spec = parent_spec;
+	parent_spec = NULL;	/* rbd_dev now owns this */
 	/*
-	 * We always update the parent overlap.  If it's zero we issue
+	 * Record the parent overlap.  If it's zero, issue a warning as
-	 * a warning, as we will proceed as if there was no parent.
+	 * we will proceed as if there is no parent.
 	 */
-	if (!pii.overlap) {
+	if (!pii.overlap)
-		if (parent_spec) {
+		rbd_warn(rbd_dev, "clone is standalone (overlap 0)");
-			/* refresh, careful to warn just once */
-			if (rbd_dev->parent_overlap)
-				rbd_warn(rbd_dev,
-				    "clone now standalone (overlap became 0)");
-		} else {
-			/* initial probe */
-			rbd_warn(rbd_dev, "clone is standalone (overlap 0)");
-		}
-	}
 	rbd_dev->parent_overlap = pii.overlap;
 out:
 	ret = 0;
 out_err:
-	kfree(pii.pool_ns);
+	rbd_parent_info_cleanup(&pii);
-	kfree(pii.image_id);
 	rbd_spec_put(parent_spec);
 	return ret;
 }
-static int rbd_dev_v2_striping_info(struct rbd_device *rbd_dev)
+static int rbd_dev_v2_striping_info(struct rbd_device *rbd_dev,
+				    u64 *stripe_unit, u64 *stripe_count)
 {
 	struct {
 		__le64 stripe_unit;
 		__le64 stripe_count;
 	} __attribute__ ((packed)) striping_info_buf = { 0 };
 	size_t size = sizeof (striping_info_buf);
-	void *p;
 	int ret;
 	ret = rbd_obj_method_sync(rbd_dev, &rbd_dev->header_oid,
 	if (ret < size)
 		return -ERANGE;
-	p = &striping_info_buf;
+	*stripe_unit = le64_to_cpu(striping_info_buf.stripe_unit);
-	rbd_dev->header.stripe_unit = ceph_decode_64(&p);
+	*stripe_count = le64_to_cpu(striping_info_buf.stripe_count);
-	rbd_dev->header.stripe_count = ceph_decode_64(&p);
+	dout("  stripe_unit = %llu stripe_count = %llu\n", *stripe_unit,
+	     *stripe_count);
 	return 0;
 }
-static int rbd_dev_v2_data_pool(struct rbd_device *rbd_dev)
+static int rbd_dev_v2_data_pool(struct rbd_device *rbd_dev, s64 *data_pool_id)
 {
-	__le64 data_pool_id;
+	__le64 data_pool_buf;
 	int ret;
 	ret = rbd_obj_method_sync(rbd_dev, &rbd_dev->header_oid,
 				  &rbd_dev->header_oloc, "get_data_pool",
-				  NULL, 0, &data_pool_id, sizeof(data_pool_id));
+				  NULL, 0, &data_pool_buf,
+				  sizeof(data_pool_buf));
+	dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
 	if (ret < 0)
 		return ret;
-	if (ret < sizeof(data_pool_id))
+	if (ret < sizeof(data_pool_buf))
 		return -EBADMSG;
-	rbd_dev->header.data_pool_id = le64_to_cpu(data_pool_id);
+	*data_pool_id = le64_to_cpu(data_pool_buf);
-	WARN_ON(rbd_dev->header.data_pool_id == CEPH_NOPOOL);
+	dout("  data_pool_id = %lld\n", *data_pool_id);
+	WARN_ON(*data_pool_id == CEPH_NOPOOL);
 	return 0;
 }
 	return ret;
 }
-static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev)
+static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev,
+				   struct ceph_snap_context **psnapc)
 {
 	size_t size;
 	int ret;
 	for (i = 0; i < snap_count; i++)
 		snapc->snaps[i] = ceph_decode_64(&p);
-	ceph_put_snap_context(rbd_dev->header.snapc);
+	*psnapc = snapc;
-	rbd_dev->header.snapc = snapc;
 	dout("  snap context seq = %llu, snap_count = %u\n",
 		(unsigned long long)seq, (unsigned int)snap_count);
 out:
 	return snap_name;
 }
-static int rbd_dev_v2_header_info(struct rbd_device *rbd_dev)
+static int rbd_dev_v2_header_info(struct rbd_device *rbd_dev,
+				  struct rbd_image_header *header,
+				  bool first_time)
 {
-	bool first_time = rbd_dev->header.object_prefix == NULL;
 	int ret;
-	ret = rbd_dev_v2_image_size(rbd_dev);
+	ret = _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
+				    first_time ? &header->obj_order : NULL,
+				    &header->image_size);
 	if (ret)
 		return ret;
 	if (first_time) {
-		ret = rbd_dev_v2_header_onetime(rbd_dev);
+		ret = rbd_dev_v2_header_onetime(rbd_dev, header);
 		if (ret)
 			return ret;
 	}
-	ret = rbd_dev_v2_snap_context(rbd_dev);
+	ret = rbd_dev_v2_snap_context(rbd_dev, &header->snapc);
-	if (ret && first_time) {
+	if (ret)
-		kfree(rbd_dev->header.object_prefix);
+		return ret;
-		rbd_dev->header.object_prefix = NULL;
-	}
-	return ret;
+	return 0;
 }
-static int rbd_dev_header_info(struct rbd_device *rbd_dev)
+static int rbd_dev_header_info(struct rbd_device *rbd_dev,
+			       struct rbd_image_header *header,
+			       bool first_time)
 {
 	rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
+	rbd_assert(!header->object_prefix && !header->snapc);
 	if (rbd_dev->image_format == 1)
-		return rbd_dev_v1_header_info(rbd_dev);
+		return rbd_dev_v1_header_info(rbd_dev, header, first_time);
-	return rbd_dev_v2_header_info(rbd_dev);
+	return rbd_dev_v2_header_info(rbd_dev, header, first_time);
 }
 /*
  */
 static void rbd_dev_unprobe(struct rbd_device *rbd_dev)
 {
-	struct rbd_image_header	*header;
 	rbd_dev_parent_put(rbd_dev);
 	rbd_object_map_free(rbd_dev);
 	rbd_dev_mapping_clear(rbd_dev);
 	/* Free dynamic fields from the header, then zero it out */
-	header = &rbd_dev->header;
+	rbd_image_header_cleanup(&rbd_dev->header);
-	ceph_put_snap_context(header->snapc);
-	kfree(header->snap_sizes);
-	kfree(header->snap_names);
-	kfree(header->object_prefix);
-	memset(header, 0, sizeof (*header));
 }
-static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev)
+static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev,
+				     struct rbd_image_header *header)
 {
 	int ret;
-	ret = rbd_dev_v2_object_prefix(rbd_dev);
+	ret = rbd_dev_v2_object_prefix(rbd_dev, &header->object_prefix);
 	if (ret)
-		goto out_err;
+		return ret;
 	/*
 	 * Get the and check features for the image.  Currently the
 	 * features are assumed to never change.
 	 */
-	ret = rbd_dev_v2_features(rbd_dev);
+	ret = _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
+					rbd_is_ro(rbd_dev), &header->features);
 	if (ret)
-		goto out_err;
+		return ret;
 	/* If the image supports fancy striping, get its parameters */
-	if (rbd_dev->header.features & RBD_FEATURE_STRIPINGV2) {
+	if (header->features & RBD_FEATURE_STRIPINGV2) {
-		ret = rbd_dev_v2_striping_info(rbd_dev);
+		ret = rbd_dev_v2_striping_info(rbd_dev, &header->stripe_unit,
-		if (ret < 0)
+					       &header->stripe_count);
-			goto out_err;
+		if (ret)
+			return ret;
 	}
-	if (rbd_dev->header.features & RBD_FEATURE_DATA_POOL) {
+	if (header->features & RBD_FEATURE_DATA_POOL) {
-		ret = rbd_dev_v2_data_pool(rbd_dev);
+		ret = rbd_dev_v2_data_pool(rbd_dev, &header->data_pool_id);
 		if (ret)
-			goto out_err;
+			return ret;
 	}
-	rbd_init_layout(rbd_dev);
 	return 0;
-out_err:
-	rbd_dev->header.features = 0;
-	kfree(rbd_dev->header.object_prefix);
-	rbd_dev->header.object_prefix = NULL;
-	return ret;
 }
 /*
 	if (!depth)
 		down_write(&rbd_dev->header_rwsem);
-	ret = rbd_dev_header_info(rbd_dev);
+	ret = rbd_dev_header_info(rbd_dev, &rbd_dev->header, true);
 	if (ret) {
 		if (ret == -ENOENT && !need_watch)
 			rbd_print_dne(rbd_dev, false);
 		goto err_out_probe;
 	}
+	rbd_init_layout(rbd_dev);
 	/*
 	 * If this image is the one being mapped, we have pool name and
 	 * id, image name and id, and snap name - need to fill snap id.
 	}
 	if (rbd_dev->header.features & RBD_FEATURE_LAYERING) {
-		ret = rbd_dev_v2_parent_info(rbd_dev);
+		ret = rbd_dev_setup_parent(rbd_dev);
 		if (ret)
 			goto err_out_probe;
 	}
 	return ret;
 }
+static void rbd_dev_update_header(struct rbd_device *rbd_dev,
+				  struct rbd_image_header *header)
+{
+	rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
+	rbd_assert(rbd_dev->header.object_prefix); /* !first_time */
+	if (rbd_dev->header.image_size != header->image_size) {
+		rbd_dev->header.image_size = header->image_size;
+		if (!rbd_is_snap(rbd_dev)) {
+			rbd_dev->mapping.size = header->image_size;
+			rbd_dev_update_size(rbd_dev);
+		}
+	}
+	ceph_put_snap_context(rbd_dev->header.snapc);
+	rbd_dev->header.snapc = header->snapc;
+	header->snapc = NULL;
+	if (rbd_dev->image_format == 1) {
+		kfree(rbd_dev->header.snap_names);
+		rbd_dev->header.snap_names = header->snap_names;
+		header->snap_names = NULL;
+		kfree(rbd_dev->header.snap_sizes);
+		rbd_dev->header.snap_sizes = header->snap_sizes;
+		header->snap_sizes = NULL;
+	}
+}
+static void rbd_dev_update_parent(struct rbd_device *rbd_dev,
+				  struct parent_image_info *pii)
+{
+	if (pii->pool_id == CEPH_NOPOOL || !pii->has_overlap) {
+		/*
+		 * Either the parent never existed, or we have
+		 * record of it but the image got flattened so it no
+		 * longer has a parent.  When the parent of a
+		 * layered image disappears we immediately set the
+		 * overlap to 0.  The effect of this is that all new
+		 * requests will be treated as if the image had no
+		 * parent.
+		 *
+		 * If !pii.has_overlap, the parent image spec is not
+		 * applicable.  It's there to avoid duplication in each
+		 * snapshot record.
+		 */
+		if (rbd_dev->parent_overlap) {
+			rbd_dev->parent_overlap = 0;
+			rbd_dev_parent_put(rbd_dev);
+			pr_info("%s: clone has been flattened\n",
+				rbd_dev->disk->disk_name);
+		}
+	} else {
+		rbd_assert(rbd_dev->parent_spec);
+		/*
+		 * Update the parent overlap.  If it became zero, issue
+		 * a warning as we will proceed as if there is no parent.
+		 */
+		if (!pii->overlap && rbd_dev->parent_overlap)
+			rbd_warn(rbd_dev,
+				 "clone has become standalone (overlap 0)");
+		rbd_dev->parent_overlap = pii->overlap;
+	}
+}
+static int rbd_dev_refresh(struct rbd_device *rbd_dev)
+{
+	struct rbd_image_header	header = { 0 };
+	struct parent_image_info pii = { 0 };
+	int ret;
+	dout("%s rbd_dev %p\n", __func__, rbd_dev);
+	ret = rbd_dev_header_info(rbd_dev, &header, false);
+	if (ret)
+		goto out;
+	/*
+	 * If there is a parent, see if it has disappeared due to the
+	 * mapped image getting flattened.
+	 */
+	if (rbd_dev->parent) {
+		ret = rbd_dev_v2_parent_info(rbd_dev, &pii);
+		if (ret)
+			goto out;
+	}
+	down_write(&rbd_dev->header_rwsem);
+	rbd_dev_update_header(rbd_dev, &header);
+	if (rbd_dev->parent)
+		rbd_dev_update_parent(rbd_dev, &pii);
+	up_write(&rbd_dev->header_rwsem);
+out:
+	rbd_parent_info_cleanup(&pii);
+	rbd_image_header_cleanup(&header);
+	return ret;
+}
 static ssize_t do_rbd_add(const char *buf, size_t count)
 {
 	struct rbd_device *rbd_dev = NULL;

drivers/bluetooth/btusb.c+1−0

@@ -4419,6 +4419,7 @@ static int btusb_probe(struct usb_interface *intf, · 4418 unmodified lines
4419		4419
4420	if (id->driver_info & BTUSB_QCA_ROME) {	4420	if (id->driver_info & BTUSB_QCA_ROME) {
4421	data->setup_on_usb = btusb_setup_qca;	4421	data->setup_on_usb = btusb_setup_qca;
		4422	hdev->shutdown = btusb_shutdown_qca;
4422	hdev->set_bdaddr = btusb_set_bdaddr_ath3012;	4423	hdev->set_bdaddr = btusb_set_bdaddr_ath3012;
4423	hdev->cmd_timeout = btusb_qca_cmd_timeout;	4424	hdev->cmd_timeout = btusb_qca_cmd_timeout;
4424	set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);	4425	set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);

drivers/bus/ti-sysc.c+22−9

 	SOC_2420,
 	SOC_2430,
 	SOC_3430,
+	SOC_AM35,
 	SOC_3630,
 	SOC_4430,
 	SOC_4460,
 	if (ddata->cfg.quirks & (SYSC_QUIRK_SWSUP_SIDLE |
 				 SYSC_QUIRK_SWSUP_SIDLE_ACT)) {
 		best_mode = SYSC_IDLE_NO;
+		/* Clear WAKEUP */
+		if (regbits->enwkup_shift >= 0 &&
+		    ddata->cfg.sysc_val & BIT(regbits->enwkup_shift))
+			reg &= ~BIT(regbits->enwkup_shift);
 	} else {
 		best_mode = fls(ddata->cfg.sidlemodes) - 1;
 		if (best_mode > SYSC_IDLE_MASK) {
 		}
 	}
+	if (ddata->cfg.quirks & SYSC_QUIRK_SWSUP_SIDLE_ACT) {
+		/* Set WAKEUP */
+		if (regbits->enwkup_shift >= 0 &&
+		    ddata->cfg.sysc_val & BIT(regbits->enwkup_shift))
+			reg |= BIT(regbits->enwkup_shift);
+	}
 	reg &= ~(SYSC_IDLE_MASK << regbits->sidle_shift);
 	reg |= best_mode << regbits->sidle_shift;
 	if (regbits->autoidle_shift >= 0 &&
 static const struct sysc_revision_quirk sysc_revision_quirks[] = {
 	/* These drivers need to be fixed to not use pm_runtime_irq_safe() */
 	SYSC_QUIRK("uart", 0, 0x50, 0x54, 0x58, 0x00000046, 0xffffffff,
-		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
+		   SYSC_QUIRK_SWSUP_SIDLE_ACT | SYSC_QUIRK_LEGACY_IDLE),
 	SYSC_QUIRK("uart", 0, 0x50, 0x54, 0x58, 0x00000052, 0xffffffff,
-		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
+		   SYSC_QUIRK_SWSUP_SIDLE_ACT | SYSC_QUIRK_LEGACY_IDLE),
 	/* Uarts on omap4 and later */
 	SYSC_QUIRK("uart", 0, 0x50, 0x54, 0x58, 0x50411e03, 0xffff00ff,
-		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
+		   SYSC_QUIRK_SWSUP_SIDLE_ACT | SYSC_QUIRK_LEGACY_IDLE),
 	SYSC_QUIRK("uart", 0, 0x50, 0x54, 0x58, 0x47422e03, 0xffffffff,
-		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
+		   SYSC_QUIRK_SWSUP_SIDLE_ACT | SYSC_QUIRK_LEGACY_IDLE),
 	SYSC_QUIRK("uart", 0, 0x50, 0x54, 0x58, 0x47424e03, 0xffffffff,
-		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
+		   SYSC_QUIRK_SWSUP_SIDLE_ACT | SYSC_QUIRK_LEGACY_IDLE),
 	/* Quirks that need to be set based on the module address */
 	SYSC_QUIRK("mcpdm", 0x40132000, 0, 0x10, -ENODEV, 0x50000800, 0xffffffff,
 		dev_warn(ddata->dev, "%s: timed out %08x !+ %08x\n",
 			 __func__, val, irq_mask);
-	if (sysc_soc->soc == SOC_3430) {
+	if (sysc_soc->soc == SOC_3430 || sysc_soc->soc == SOC_AM35) {
 		/* Clear DSS_SDI_CONTROL */
 		sysc_write(ddata, 0x44, 0);
 	}
 	if (ddata->cfg.srst_udelay)
-		usleep_range(ddata->cfg.srst_udelay,
+		fsleep(ddata->cfg.srst_udelay);
-			     ddata->cfg.srst_udelay * 2);
 	if (ddata->post_reset_quirk)
 		ddata->post_reset_quirk(ddata);
 static const struct soc_device_attribute sysc_soc_match[] = {
 	SOC_FLAG("OMAP242*", SOC_2420),
 	SOC_FLAG("OMAP243*", SOC_2430),
+	SOC_FLAG("AM35*", SOC_AM35),
 	SOC_FLAG("OMAP3[45]*", SOC_3430),
 	SOC_FLAG("OMAP3[67]*", SOC_3630),
 	SOC_FLAG("OMAP443*", SOC_4430),
 	 * can be dropped if we stop supporting old beagleboard revisions
 	 * A to B4 at some point.
 	 */
-	if (sysc_soc->soc == SOC_3430)
+	if (sysc_soc->soc == SOC_3430 || sysc_soc->soc == SOC_AM35)
 		error = -ENXIO;
 	else
 		error = -EBUSY;

drivers/clk/clk-si521xx.c+5−4

 				    unsigned int val)
 {
 	struct i2c_client *i2c = context;
-	const u8 data[3] = { reg, 1, val };
+	const u8 data[2] = { reg, val };
 	const int count = ARRAY_SIZE(data);
 	int ret;
 static const struct regmap_config si521xx_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
-	.cache_type = REGCACHE_NONE,
+	.cache_type = REGCACHE_FLAT,
 	.max_register = SI521XX_REG_DA,
 	.rd_table = &si521xx_readable_table,
 	.wr_table = &si521xx_writeable_table,
 {
 	const u16 chip_info = (u16)(uintptr_t)device_get_match_data(&client->dev);
 	const struct clk_parent_data clk_parent_data = { .index = 0 };
-	struct si521xx *si;
+	const u8 data[3] = { SI521XX_REG_BC, 1, 1 };
 	unsigned char name[6] = "DIFF0";
 	struct clk_init_data init = {};
+	struct si521xx *si;
 	int i, ret;
 	if (!chip_info)
 				     "Failed to allocate register map\n");
 	/* Always read back 1 Byte via I2C */
-	ret = regmap_write(si->regmap, SI521XX_REG_BC, 1);
+	ret = i2c_master_send(client, data, ARRAY_SIZE(data));
 	if (ret < 0)
 		return ret;

drivers/clk/clk-versaclock3.c+40−41

 	VC3_DIV5,
 };
-enum vc3_clk_mux {
-	VC3_DIFF2_MUX,
-	VC3_DIFF1_MUX,
-	VC3_SE3_MUX,
-	VC3_SE2_MUX,
-	VC3_SE1_MUX,
-};
 enum vc3_clk {
-	VC3_DIFF2,
-	VC3_DIFF1,
-	VC3_SE3,
-	VC3_SE2,
-	VC3_SE1,
 	VC3_REF,
+	VC3_SE1,
+	VC3_SE2,
+	VC3_SE3,
+	VC3_DIFF1,
+	VC3_DIFF2,
+};
+enum vc3_clk_mux {
+	VC3_SE1_MUX = VC3_SE1 - 1,
+	VC3_SE2_MUX = VC3_SE2 - 1,
+	VC3_SE3_MUX = VC3_SE3 - 1,
+	VC3_DIFF1_MUX = VC3_DIFF1 - 1,
+	VC3_DIFF2_MUX = VC3_DIFF2 - 1,
 };
 struct vc3_clk_data {
 		/* Determine best fractional part, which is 16 bit wide */
 		div_frc = rate % *parent_rate;
 		div_frc *= BIT(16) - 1;
-		do_div(div_frc, *parent_rate);
-		vc3->div_frc = (u32)div_frc;
+		vc3->div_frc = min_t(u64, div64_ul(div_frc, *parent_rate), U16_MAX);
 		rate = (*parent_rate *
-			(vc3->div_int * VC3_2_POW_16 + div_frc) / VC3_2_POW_16);
+			(vc3->div_int * VC3_2_POW_16 + vc3->div_frc) / VC3_2_POW_16);
 	} else {
 		rate = *parent_rate * vc3->div_int;
 	}
 };
 static struct vc3_hw_data clk_mux[] = {
-	[VC3_DIFF2_MUX] = {
+	[VC3_SE1_MUX] = {
 		.data = &(struct vc3_clk_data) {
-			.offs = VC3_DIFF2_CTRL_REG,
+			.offs = VC3_SE1_DIV4_CTRL,
-			.bitmsk = VC3_DIFF2_CTRL_REG_DIFF2_CLK_SEL
+			.bitmsk = VC3_SE1_DIV4_CTRL_SE1_CLK_SEL
 		},
 		.hw.init = &(struct clk_init_data){
-			.name = "diff2_mux",
+			.name = "se1_mux",
 			.ops = &vc3_clk_mux_ops,
 			.parent_hws = (const struct clk_hw *[]) {
-				&clk_div[VC3_DIV1].hw,
+				&clk_div[VC3_DIV5].hw,
-				&clk_div[VC3_DIV3].hw
+				&clk_div[VC3_DIV4].hw
 			},
 			.num_parents = 2,
 			.flags = CLK_SET_RATE_PARENT
 		}
 	},
-	[VC3_DIFF1_MUX] = {
+	[VC3_SE2_MUX] = {
 		.data = &(struct vc3_clk_data) {
-			.offs = VC3_DIFF1_CTRL_REG,
+			.offs = VC3_SE2_CTRL_REG0,
-			.bitmsk = VC3_DIFF1_CTRL_REG_DIFF1_CLK_SEL
+			.bitmsk = VC3_SE2_CTRL_REG0_SE2_CLK_SEL
 		},
 		.hw.init = &(struct clk_init_data){
-			.name = "diff1_mux",
+			.name = "se2_mux",
 			.ops = &vc3_clk_mux_ops,
 			.parent_hws = (const struct clk_hw *[]) {
-				&clk_div[VC3_DIV1].hw,
+				&clk_div[VC3_DIV5].hw,
-				&clk_div[VC3_DIV3].hw
+				&clk_div[VC3_DIV4].hw
 			},
 			.num_parents = 2,
 			.flags = CLK_SET_RATE_PARENT
 			.flags = CLK_SET_RATE_PARENT
 		}
 	},
-	[VC3_SE2_MUX] = {
+	[VC3_DIFF1_MUX] = {
 		.data = &(struct vc3_clk_data) {
-			.offs = VC3_SE2_CTRL_REG0,
+			.offs = VC3_DIFF1_CTRL_REG,
-			.bitmsk = VC3_SE2_CTRL_REG0_SE2_CLK_SEL
+			.bitmsk = VC3_DIFF1_CTRL_REG_DIFF1_CLK_SEL
 		},
 		.hw.init = &(struct clk_init_data){
-			.name = "se2_mux",
+			.name = "diff1_mux",
 			.ops = &vc3_clk_mux_ops,
 			.parent_hws = (const struct clk_hw *[]) {
-				&clk_div[VC3_DIV5].hw,
+				&clk_div[VC3_DIV1].hw,
-				&clk_div[VC3_DIV4].hw
+				&clk_div[VC3_DIV3].hw
 			},
 			.num_parents = 2,
 			.flags = CLK_SET_RATE_PARENT
 		}
 	},
-	[VC3_SE1_MUX] = {
+	[VC3_DIFF2_MUX] = {
 		.data = &(struct vc3_clk_data) {
-			.offs = VC3_SE1_DIV4_CTRL,
+			.offs = VC3_DIFF2_CTRL_REG,
-			.bitmsk = VC3_SE1_DIV4_CTRL_SE1_CLK_SEL
+			.bitmsk = VC3_DIFF2_CTRL_REG_DIFF2_CLK_SEL
 		},
 		.hw.init = &(struct clk_init_data){
-			.name = "se1_mux",
+			.name = "diff2_mux",
 			.ops = &vc3_clk_mux_ops,
 			.parent_hws = (const struct clk_hw *[]) {
-				&clk_div[VC3_DIV5].hw,
+				&clk_div[VC3_DIV1].hw,
-				&clk_div[VC3_DIV4].hw
+				&clk_div[VC3_DIV3].hw
 			},
 			.num_parents = 2,
 			.flags = CLK_SET_RATE_PARENT
 				name, 0, CLK_SET_RATE_PARENT, 1, 1);
 		else
 			clk_out[i] = devm_clk_hw_register_fixed_factor_parent_hw(dev,
-				name, &clk_mux[i].hw, CLK_SET_RATE_PARENT, 1, 1);
+				name, &clk_mux[i - 1].hw, CLK_SET_RATE_PARENT, 1, 1);
 		if (IS_ERR(clk_out[i]))
 			return PTR_ERR(clk_out[i]);

drivers/clk/sprd/ums512-clk.c+1−1

@@ -800,7 +800,7 @@ static SPRD_MUX_CLK_DATA(uart1_clk, "uart1-clk", uart_parents, · 799 unmodified lines
800	0x250, 0, 3, UMS512_MUX_FLAG);	800	0x250, 0, 3, UMS512_MUX_FLAG);
801		801
802	static const struct clk_parent_data thm_parents[] = {	802	static const struct clk_parent_data thm_parents[] = {
803	{ .fw_name = "ext-32m" },	803	{ .fw_name = "ext-32k" },
804	{ .hw = &clk_250k.hw },	804	{ .hw = &clk_250k.hw },
805	};	805	};
806	static SPRD_MUX_CLK_DATA(thm0_clk, "thm0-clk", thm_parents,	806	static SPRD_MUX_CLK_DATA(thm0_clk, "thm0-clk", thm_parents,

drivers/clk/tegra/clk-bpmp.c+1−1

@@ -159,7 +159,7 @@ static unsigned long tegra_bpmp_clk_recalc_rate(struct clk_hw *hw, · 158 unmodified lines
159		159
160	err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);	160	err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
161	if (err < 0)	161	if (err < 0)
162	return err;	162	return 0;
163		163
164	return response.rate;	164	return response.rate;
165	}	165	}

drivers/cxl/acpi.c+2−2

 struct cxl_cxims_data {
 	int nr_maps;
-	u64 xormaps[];
+	u64 xormaps[] __counted_by(nr_maps);
 };
 /*
 			      GFP_KERNEL);
 	if (!cximsd)
 		return -ENOMEM;
+	cximsd->nr_maps = nr_maps;
 	memcpy(cximsd->xormaps, cxims->xormap_list,
 	       nr_maps * sizeof(*cximsd->xormaps));
-	cximsd->nr_maps = nr_maps;
 	cxlrd->platform_data = cximsd;
 	return 0;

drivers/cxl/core/mbox.c+12−11

 	for (i = 0; i < cel_entries; i++) {
 		u16 opcode = le16_to_cpu(cel_entry[i].opcode);
 		struct cxl_mem_command *cmd = cxl_mem_find_command(opcode);
+		int enabled = 0;
-		if (!cmd && (!cxl_is_poison_command(opcode) ||
+		if (cmd) {
-			     !cxl_is_security_command(opcode))) {
-			dev_dbg(dev,
-				"Opcode 0x%04x unsupported by driver\n", opcode);
-			continue;
-		}
-		if (cmd)
 			set_bit(cmd->info.id, mds->enabled_cmds);
+			enabled++;
+		}
-		if (cxl_is_poison_command(opcode))
+		if (cxl_is_poison_command(opcode)) {
 			cxl_set_poison_cmd_enabled(&mds->poison, opcode);
+			enabled++;
+		}
-		if (cxl_is_security_command(opcode))
+		if (cxl_is_security_command(opcode)) {
 			cxl_set_security_cmd_enabled(&mds->security, opcode);
+			enabled++;
+		}
-		dev_dbg(dev, "Opcode 0x%04x enabled\n", opcode);
+		dev_dbg(dev, "Opcode 0x%04x %s\n", opcode,
+			enabled ? "enabled" : "unsupported by driver");
 	}
 }

drivers/cxl/core/port.c+9−4

 // SPDX-License-Identifier: GPL-2.0-only
 /* Copyright(c) 2020 Intel Corporation. All rights reserved. */
+#include <linux/platform_device.h>
 #include <linux/memregion.h>
 #include <linux/workqueue.h>
 #include <linux/debugfs.h>
 	return cxl_setup_regs(map);
 }
-static inline int cxl_port_setup_regs(struct cxl_port *port,
+static int cxl_port_setup_regs(struct cxl_port *port,
-				      resource_size_t component_reg_phys)
+			resource_size_t component_reg_phys)
 {
+	if (dev_is_platform(port->uport_dev))
+		return 0;
 	return cxl_setup_comp_regs(&port->dev, &port->comp_map,
 				   component_reg_phys);
 }
-static inline int cxl_dport_setup_regs(struct cxl_dport *dport,
+static int cxl_dport_setup_regs(struct cxl_dport *dport,
-				       resource_size_t component_reg_phys)
+				resource_size_t component_reg_phys)
 {
+	if (dev_is_platform(dport->dport_dev))
+		return 0;
 	return cxl_setup_comp_regs(dport->dport_dev, &dport->comp_map,
 				   component_reg_phys);
 }

drivers/cxl/core/region.c+31−10

@@ -717,13 +717,35 @@ static int match_free_decoder(struct device dev, void data) · 716 unmodified lines
717	return 0;	717	return 0;
718	}	718	}
719		719
		720	static int match_auto_decoder(struct device dev, void data)
		721	{
		722	struct cxl_region_params *p = data;
		723	struct cxl_decoder *cxld;
		724	struct range *r;
		725
		726	if (!is_switch_decoder(dev))
		727	return 0;
		728
		729	cxld = to_cxl_decoder(dev);
		730	r = &cxld->hpa_range;
		731
		732	if (p->res && p->res->start == r->start && p->res->end == r->end)
		733	return 1;
		734
		735	return 0;
		736	}
		737
720	static struct cxl_decoder cxl_region_find_decoder(struct cxl_port port,	738	static struct cxl_decoder cxl_region_find_decoder(struct cxl_port port,
721	struct cxl_region *cxlr)	739	struct cxl_region *cxlr)
722	{	740	{
723	struct device *dev;	741	struct device *dev;
724	int id = 0;	742	int id = 0;
725		743
726	dev = device_find_child(&port->dev, &id, match_free_decoder);	744	if (test_bit(CXL_REGION_F_AUTO, &cxlr->flags))
		745	dev = device_find_child(&port->dev, &cxlr->params,
		746	match_auto_decoder);
		747	else
		748	dev = device_find_child(&port->dev, &id, match_free_decoder);
727	if (!dev)	749	if (!dev)
728	return NULL;	750	return NULL;
729	/*	751	/*
@@ -1154,16 +1176,15 @@ static int cxl_port_setup_targets(struct cxl_port *port, · 424 unmodified lines
1154	}	1176	}
1155		1177
1156	/*	1178	/*
1157	* If @parent_port is masking address bits, pick the next unused address	1179	* Interleave granularity is a multiple of @parent_port granularity.
1158	* bit to route @port's targets.	1180	* Multiplier is the parent port interleave ways.
1159	*/	1181	*/
1160	if (parent_iw > 1 && cxl_rr->nr_targets > 1) {	1182	rc = granularity_to_eig(parent_ig * parent_iw, &eig);
1161	u32 address_bit = max(peig + peiw, eiw + peig);	1183	if (rc) {
1162		1184	dev_dbg(&cxlr->dev,
1163	eig = address_bit - eiw + 1;	1185	"%s: invalid granularity calculation (%d * %d)\n",
1164	} else {	1186	dev_name(&parent_port->dev), parent_ig, parent_iw);
1165	eiw = peiw;	1187	return rc;
1166	eig = peig;
1167	}	1188	}
1168		1189
1169	rc = eig_to_granularity(eig, &ig);	1190	rc = eig_to_granularity(eig, &ig);

drivers/cxl/pci.c+3−4

 static int cxl_pci_ras_unmask(struct pci_dev *pdev)
 {
-	struct pci_host_bridge *host_bridge = pci_find_host_bridge(pdev->bus);
 	struct cxl_dev_state *cxlds = pci_get_drvdata(pdev);
 	void __iomem *addr;
 	u32 orig_val, val, mask;
 		return 0;
 	}
-	/* BIOS has CXL error control */
+	/* BIOS has PCIe AER error control */
-	if (!host_bridge->native_cxl_error)
+	if (!pcie_aer_is_native(pdev))
-		return -ENXIO;
+		return 0;
 	rc = pcie_capability_read_word(pdev, PCI_EXP_DEVCTL, &cap);
 	if (rc)

drivers/dma/ti/k3-udma-glue.c+3−0

@@ -558,6 +558,9 @@ int k3_udma_glue_tx_get_irq(struct k3_udma_glue_tx_channel *tx_chn) · 557 unmodified lines
558	tx_chn->virq = k3_ringacc_get_ring_irq_num(tx_chn->ringtxcq);	558	tx_chn->virq = k3_ringacc_get_ring_irq_num(tx_chn->ringtxcq);
559	}	559	}
560		560
		561	if (!tx_chn->virq)
		562	return -ENXIO;
		563
561	return tx_chn->virq;	564	return tx_chn->virq;
562	}	565	}
563	EXPORT_SYMBOL_GPL(k3_udma_glue_tx_get_irq);	566	EXPORT_SYMBOL_GPL(k3_udma_glue_tx_get_irq);

drivers/firewire/sbp2.c+6−3

  *
  * - power condition
  *   Set the power condition field in the START STOP UNIT commands sent by
- *   sd_mod on suspend, resume, and shutdown (if manage_start_stop is on).
+ *   sd_mod on suspend, resume, and shutdown (if manage_system_start_stop or
+ *   manage_runtime_start_stop is on).
  *   Some disks need this to spin down or to resume properly.
  *
  * - override internal blacklist
 	sdev->use_10_for_rw = 1;
-	if (sbp2_param_exclusive_login)
+	if (sbp2_param_exclusive_login) {
-		sdev->manage_start_stop = 1;
+		sdev->manage_system_start_stop = true;
+		sdev->manage_runtime_start_stop = true;
+	}
 	if (sdev->type == TYPE_ROM)
 		sdev->use_10_for_ms = 1;

drivers/firmware/arm_ffa/driver.c+14−2

 	return num_pages;
 }
+static u8 ffa_memory_attributes_get(u32 func_id)
+{
+	/*
+	 * For the memory lend or donate operation, if the receiver is a PE or
+	 * a proxy endpoint, the owner/sender must not specify the attributes
+	 */
+	if (func_id == FFA_FN_NATIVE(MEM_LEND) ||
+	    func_id == FFA_MEM_LEND)
+		return 0;
+	return FFA_MEM_NORMAL | FFA_MEM_WRITE_BACK | FFA_MEM_INNER_SHAREABLE;
+}
 static int
 ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize,
 		       struct ffa_mem_ops_args *args)
 	mem_region->tag = args->tag;
 	mem_region->flags = args->flags;
 	mem_region->sender_id = drv_info->vm_id;
-	mem_region->attributes = FFA_MEM_NORMAL | FFA_MEM_WRITE_BACK |
+	mem_region->attributes = ffa_memory_attributes_get(func_id);
-				 FFA_MEM_INNER_SHAREABLE;
 	ep_mem_access = &mem_region->ep_mem_access[0];
 	for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) {

drivers/firmware/arm_scmi/perf.c+2−2

 	if (!pinfo)
 		return -ENOMEM;
+	pinfo->version = version;
 	ret = scmi_perf_attributes_get(ph, pinfo);
 	if (ret)
 		return ret;
 	if (ret)
 		return ret;
-	pinfo->version = version;
 	return ph->set_priv(ph, pinfo);
 }

drivers/firmware/efi/efi.c+29−3

@@ -623,6 +623,34 @@ static __init int match_config_table(const efi_guid_t *guid, · 622 unmodified lines
623	return 0;	623	return 0;
624	}	624	}
625		625
		626	/**
		627	* reserve_unaccepted - Map and reserve unaccepted configuration table
		628	* @unaccepted: Pointer to unaccepted memory table
		629	*
		630	* memblock_add() makes sure that the table is mapped in direct mapping. During
		631	* normal boot it happens automatically because the table is allocated from
		632	* usable memory. But during crashkernel boot only memory specifically reserved
		633	* for crash scenario is mapped. memblock_add() forces the table to be mapped
		634	* in crashkernel case.
		635	*
		636	* Align the range to the nearest page borders. Ranges smaller than page size
		637	* are not going to be mapped.
		638	*
		639	* memblock_reserve() makes sure that future allocations will not touch the
		640	* table.
		641	*/
		642
		643	static __init void reserve_unaccepted(struct efi_unaccepted_memory *unaccepted)
		644	{
		645	phys_addr_t start, size;
		646
		647	start = PAGE_ALIGN_DOWN(efi.unaccepted);
		648	size = PAGE_ALIGN(sizeof(*unaccepted) + unaccepted->size);
		649
		650	memblock_add(start, size);
		651	memblock_reserve(start, size);
		652	}
		653
626	int __init efi_config_parse_tables(const efi_config_table_t *config_tables,	654	int __init efi_config_parse_tables(const efi_config_table_t *config_tables,
627	int count,	655	int count,
628	const efi_config_table_type_t *arch_tables)	656	const efi_config_table_type_t *arch_tables)
@@ -751,11 +779,9 @@ int __init efi_config_parse_tables(const efi_config_table_t *config_tables, · 122 unmodified lines
751		779
752	unaccepted = early_memremap(efi.unaccepted, sizeof(*unaccepted));	780	unaccepted = early_memremap(efi.unaccepted, sizeof(*unaccepted));
753	if (unaccepted) {	781	if (unaccepted) {
754	unsigned long size;
755		782
756	if (unaccepted->version == 1) {	783	if (unaccepted->version == 1) {
757	size = sizeof(*unaccepted) + unaccepted->size;	784	reserve_unaccepted(unaccepted);
758	memblock_reserve(efi.unaccepted, size);
759	} else {	785	} else {
760	efi.unaccepted = EFI_INVALID_TABLE_ADDR;	786	efi.unaccepted = EFI_INVALID_TABLE_ADDR;
761	}	787	}

drivers/firmware/imx/imx-dsp.c+1−0

@@ -114,6 +114,7 @@ static int imx_dsp_setup_channels(struct imx_dsp_ipc *dsp_ipc) · 113 unmodified lines
114	dsp_chan->idx = i % 2;	114	dsp_chan->idx = i % 2;
115	dsp_chan->ch = mbox_request_channel_byname(cl, chan_name);	115	dsp_chan->ch = mbox_request_channel_byname(cl, chan_name);
116	if (IS_ERR(dsp_chan->ch)) {	116	if (IS_ERR(dsp_chan->ch)) {
		117	kfree(dsp_chan->name);
117	ret = PTR_ERR(dsp_chan->ch);	118	ret = PTR_ERR(dsp_chan->ch);
118	if (ret != -EPROBE_DEFER)	119	if (ret != -EPROBE_DEFER)
119	dev_err(dev, "Failed to request mbox chan %s ret %d\n",	120	dev_err(dev, "Failed to request mbox chan %s ret %d\n",

drivers/gpio/gpio-pmic-eic-sprd.c+1−0

@@ -352,6 +352,7 @@ static int sprd_pmic_eic_probe(struct platform_device *pdev) · 351 unmodified lines
352	pmic_eic->chip.set_config = sprd_pmic_eic_set_config;	352	pmic_eic->chip.set_config = sprd_pmic_eic_set_config;
353	pmic_eic->chip.set = sprd_pmic_eic_set;	353	pmic_eic->chip.set = sprd_pmic_eic_set;
354	pmic_eic->chip.get = sprd_pmic_eic_get;	354	pmic_eic->chip.get = sprd_pmic_eic_get;
		355	pmic_eic->chip.can_sleep = true;
355		356
356	irq = &pmic_eic->chip.irq;	357	irq = &pmic_eic->chip.irq;
357	gpio_irq_chip_set_chip(irq, &pmic_eic_irq_chip);	358	gpio_irq_chip_set_chip(irq, &pmic_eic_irq_chip);

drivers/gpio/gpio-sim.c+23−37

 #include <linux/irq.h>
 #include <linux/irq_sim.h>
 #include <linux/list.h>
+#include <linux/minmax.h>
 #include <linux/mod_devicetable.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 	return sprintf(page, "%c\n", live ? '1' : '0');
 }
-static char **gpio_sim_make_line_names(struct gpio_sim_bank *bank,
+static unsigned int gpio_sim_get_line_names_size(struct gpio_sim_bank *bank)
-				       unsigned int *line_names_size)
 {
-	unsigned int max_offset = 0;
-	bool has_line_names = false;
 	struct gpio_sim_line *line;
-	char **line_names;
+	unsigned int size = 0;
 	list_for_each_entry(line, &bank->line_list, siblings) {
-		if (line->offset >= bank->num_lines)
+		if (!line->name || (line->offset >= bank->num_lines))
 			continue;
-		if (line->name) {
+		size = max(size, line->offset + 1);
-			if (line->offset > max_offset)
-				max_offset = line->offset;
-			/*
-			 * max_offset can stay at 0 so it's not an indicator
-			 * of whether line names were configured at all.
-			 */
-			has_line_names = true;
-		}
 	}
-	if (!has_line_names)
+	return size;
-		/*
+}
-		 * This is not an error - NULL means, there are no line
-		 * names configured.
-		 */
-		return NULL;
-	*line_names_size = max_offset + 1;
-	line_names = kcalloc(*line_names_size, sizeof(*line_names), GFP_KERNEL);
+static void
-	if (!line_names)
+gpio_sim_set_line_names(struct gpio_sim_bank *bank, char **line_names)
-		return ERR_PTR(-ENOMEM);
+{
+	struct gpio_sim_line *line;
 	list_for_each_entry(line, &bank->line_list, siblings) {
-		if (line->offset >= bank->num_lines)
+		if (!line->name || (line->offset >= bank->num_lines))
 			continue;
-		if (line->name && (line->offset <= max_offset))
+		line_names[line->offset] = line->name;
-			line_names[line->offset] = line->name;
 	}
-	return line_names;
 }
 static void gpio_sim_remove_hogs(struct gpio_sim_device *dev)
 			  struct fwnode_handle *parent)
 {
 	struct property_entry properties[GPIO_SIM_PROP_MAX];
-	unsigned int prop_idx = 0, line_names_size = 0;
+	unsigned int prop_idx = 0, line_names_size;
 	char **line_names __free(kfree) = NULL;
 	memset(properties, 0, sizeof(properties));
 		properties[prop_idx++] = PROPERTY_ENTRY_STRING("gpio-sim,label",
 							       bank->label);
-	line_names = gpio_sim_make_line_names(bank, &line_names_size);
+	line_names_size = gpio_sim_get_line_names_size(bank);
-	if (IS_ERR(line_names))
+	if (line_names_size) {
-		return ERR_CAST(line_names);
+		line_names = kcalloc(line_names_size, sizeof(*line_names),
+				     GFP_KERNEL);
+		if (!line_names)
+			return ERR_PTR(-ENOMEM);
+		gpio_sim_set_line_names(bank, line_names);
-	if (line_names)
 		properties[prop_idx++] = PROPERTY_ENTRY_STRING_ARRAY_LEN(
 						"gpio-line-names",
 						line_names, line_names_size);
+	}
 	return fwnode_create_software_node(properties, parent);
 }

drivers/gpio/gpio-tb10x.c+5−1

 				handle_edge_irq, IRQ_NOREQUEST, IRQ_NOPROBE,
 				IRQ_GC_INIT_MASK_CACHE);
 		if (ret)
-			return ret;
+			goto err_remove_domain;
 		gc = tb10x_gpio->domain->gc->gc[0];
 		gc->reg_base                         = tb10x_gpio->base;
 	}
 	return 0;
+err_remove_domain:
+	irq_domain_remove(tb10x_gpio->domain);
+	return ret;
 }
 static int tb10x_gpio_remove(struct platform_device *pdev)

drivers/gpio/gpio-timberdale.c+3−2

 	unsigned offset, bool enabled)
 {
 	struct timbgpio *tgpio = gpiochip_get_data(gpio);
+	unsigned long flags;
 	u32 reg;
-	spin_lock(&tgpio->lock);
+	spin_lock_irqsave(&tgpio->lock, flags);
 	reg = ioread32(tgpio->membase + offset);
 	if (enabled)
 		reg &= ~(1 << index);
 	iowrite32(reg, tgpio->membase + offset);
-	spin_unlock(&tgpio->lock);
+	spin_unlock_irqrestore(&tgpio->lock, flags);
 	return 0;
 }

drivers/gpu/drm/Kconfig+1−1

@@ -136,7 +136,7 @@ config DRM_FBDEV_EMULATION · 135 unmodified lines
136	bool "Enable legacy fbdev support for your modesetting driver"	136	bool "Enable legacy fbdev support for your modesetting driver"
137	depends on DRM	137	depends on DRM
138	select FRAMEBUFFER_CONSOLE_DETECT_PRIMARY if FRAMEBUFFER_CONSOLE	138	select FRAMEBUFFER_CONSOLE_DETECT_PRIMARY if FRAMEBUFFER_CONSOLE
139	default y	139	default FB
140	help	140	help
141	Choose this option if you have a need for the legacy fbdev	141	Choose this option if you have a need for the legacy fbdev
142	support. Note that this support also provides the linux console	142	support. Note that this support also provides the linux console

drivers/gpu/drm/amd/amdgpu/amdgpu_atombios.c+1−1

@@ -1776,7 +1776,7 @@ static ssize_t amdgpu_atombios_get_vbios_version(struct device *dev, · 1775 unmodified lines
1776	struct amdgpu_device *adev = drm_to_adev(ddev);	1776	struct amdgpu_device *adev = drm_to_adev(ddev);
1777	struct atom_context *ctx = adev->mode_info.atom_context;	1777	struct atom_context *ctx = adev->mode_info.atom_context;
1778		1778
1779	return sysfs_emit(buf, "%s\n", ctx->vbios_ver_str);	1779	return sysfs_emit(buf, "%s\n", ctx->vbios_pn);
1780	}	1780	}
1781		1781
1782	static DEVICE_ATTR(vbios_version, 0444, amdgpu_atombios_get_vbios_version,	1782	static DEVICE_ATTR(vbios_version, 0444, amdgpu_atombios_get_vbios_version,

drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c+1−0

@@ -801,6 +801,7 @@ int amdgpu_ras_feature_enable(struct amdgpu_device *adev, · 800 unmodified lines
801	enable ? "enable":"disable",	801	enable ? "enable":"disable",
802	get_ras_block_str(head),	802	get_ras_block_str(head),
803	amdgpu_ras_is_poison_mode_supported(adev), ret);	803	amdgpu_ras_is_poison_mode_supported(adev), ret);
		804	kfree(info);
804	return ret;	805	return ret;
805	}	806	}
806		807

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c+1−1

@@ -216,7 +216,7 @@ static int add_queue_mes(struct device_queue_manager dqm, struct queue q, · 215 unmodified lines
216		216
217	if (q->wptr_bo) {	217	if (q->wptr_bo) {
218	wptr_addr_off = (uint64_t)q->properties.write_ptr & (PAGE_SIZE - 1);	218	wptr_addr_off = (uint64_t)q->properties.write_ptr & (PAGE_SIZE - 1);
219	queue_input.wptr_mc_addr = ((uint64_t)q->wptr_bo->tbo.resource->start << PAGE_SHIFT) + wptr_addr_off;	219	queue_input.wptr_mc_addr = amdgpu_bo_gpu_offset(q->wptr_bo) + wptr_addr_off;
220	}	220	}
221		221
222	queue_input.is_kfd_process = 1;	222	queue_input.is_kfd_process = 1;

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

 	if (recalculate_timing)
 		drm_mode_set_crtcinfo(&saved_mode, 0);
-	else if (!old_stream)
-		drm_mode_set_crtcinfo(&mode, 0);
 	/*
 	 * If scaling is enabled and refresh rate didn't change
 		goto fail;
 	}
+	drm_mode_set_crtcinfo(mode, 0);
 	stream = create_validate_stream_for_sink(aconnector, mode,
 						 to_dm_connector_state(connector->state),
 						 NULL);

drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c+17−13

@@ -1178,12 +1178,15 @@ void dce110_disable_stream(struct pipe_ctx *pipe_ctx) · 1177 unmodified lines
1178	dto_params.otg_inst = tg->inst;	1178	dto_params.otg_inst = tg->inst;
1179	dto_params.timing = &pipe_ctx->stream->timing;	1179	dto_params.timing = &pipe_ctx->stream->timing;
1180	dp_hpo_inst = pipe_ctx->stream_res.hpo_dp_stream_enc->inst;	1180	dp_hpo_inst = pipe_ctx->stream_res.hpo_dp_stream_enc->inst;
1181	dccg->funcs->set_dtbclk_dto(dccg, &dto_params);	1181	if (dccg) {
1182	dccg->funcs->disable_symclk32_se(dccg, dp_hpo_inst);	1182	dccg->funcs->set_dtbclk_dto(dccg, &dto_params);
1183	dccg->funcs->set_dpstreamclk(dccg, REFCLK, tg->inst, dp_hpo_inst);	1183	dccg->funcs->disable_symclk32_se(dccg, dp_hpo_inst);
1184	} else if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST && dccg->funcs->disable_symclk_se)	1184	dccg->funcs->set_dpstreamclk(dccg, REFCLK, tg->inst, dp_hpo_inst);
		1185	}
		1186	} else if (dccg && dccg->funcs->disable_symclk_se) {
1185	dccg->funcs->disable_symclk_se(dccg, stream_enc->stream_enc_inst,	1187	dccg->funcs->disable_symclk_se(dccg, stream_enc->stream_enc_inst,
1186	link_enc->transmitter - TRANSMITTER_UNIPHY_A);	1188	link_enc->transmitter - TRANSMITTER_UNIPHY_A);
		1189	}
1187		1190
1188	if (dc->link_srv->dp_is_128b_132b_signal(pipe_ctx)) {	1191	if (dc->link_srv->dp_is_128b_132b_signal(pipe_ctx)) {
1189	/* TODO: This looks like a bug to me as we are disabling HPO IO when	1192	/* TODO: This looks like a bug to me as we are disabling HPO IO when
@@ -2658,11 +2661,11 @@ void dce110_prepare_bandwidth( · 1468 unmodified lines
2658	struct clk_mgr *dccg = dc->clk_mgr;	2661	struct clk_mgr *dccg = dc->clk_mgr;
2659		2662
2660	dce110_set_safe_displaymarks(&context->res_ctx, dc->res_pool);	2663	dce110_set_safe_displaymarks(&context->res_ctx, dc->res_pool);
2661		2664	if (dccg)
2662	dccg->funcs->update_clocks(	2665	dccg->funcs->update_clocks(
2663	dccg,	2666	dccg,
2664	context,	2667	context,
2665	false);	2668	false);
2666	}	2669	}
2667		2670
2668	void dce110_optimize_bandwidth(	2671	void dce110_optimize_bandwidth(
@@ -2673,10 +2676,11 @@ void dce110_optimize_bandwidth( · 4 unmodified lines
2673		2676
2674	dce110_set_displaymarks(dc, context);	2677	dce110_set_displaymarks(dc, context);
2675		2678
2676	dccg->funcs->update_clocks(	2679	if (dccg)
2677	dccg,	2680	dccg->funcs->update_clocks(
2678	context,	2681	dccg,
2679	true);	2682	context,
		2683	true);
2680	}	2684	}
2681		2685
2682	static void dce110_program_front_end_for_pipe(	2686	static void dce110_program_front_end_for_pipe(

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hwseq.c+2−6

 	struct dce_hwseq *hws = dc->hwseq;
 	unsigned int k1_div = PIXEL_RATE_DIV_NA;
 	unsigned int k2_div = PIXEL_RATE_DIV_NA;
-	struct link_encoder *link_enc = link_enc_cfg_get_link_enc(pipe_ctx->stream->link);
-	struct stream_encoder *stream_enc = pipe_ctx->stream_res.stream_enc;
 	if (dc->link_srv->dp_is_128b_132b_signal(pipe_ctx)) {
 		if (dc->hwseq->funcs.setup_hpo_hw_control)
 		dto_params.timing = &pipe_ctx->stream->timing;
 		dto_params.ref_dtbclk_khz = dc->clk_mgr->funcs->get_dtb_ref_clk_frequency(dc->clk_mgr);
 		dccg->funcs->set_dtbclk_dto(dccg, &dto_params);
-	} else if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST && dccg->funcs->enable_symclk_se)
+	} else {
-		dccg->funcs->enable_symclk_se(dccg,
+		}
-			stream_enc->stream_enc_inst, link_enc->transmitter - TRANSMITTER_UNIPHY_A);
 	if (hws->funcs.calculate_dccg_k1_k2_values && dc->res_pool->dccg->funcs->set_pixel_rate_div) {
 		hws->funcs.calculate_dccg_k1_k2_values(pipe_ctx, &k1_div, &k2_div);

drivers/gpu/drm/amd/display/dc/dcn32/dcn32_mpc.c+1−1

@@ -75,7 +75,7 @@ void mpc32_power_on_blnd_lut( · 74 unmodified lines
75	if (power_on) {	75	if (power_on) {
76	REG_UPDATE(MPCC_MCM_MEM_PWR_CTRL[mpcc_id], MPCC_MCM_1DLUT_MEM_PWR_FORCE, 0);	76	REG_UPDATE(MPCC_MCM_MEM_PWR_CTRL[mpcc_id], MPCC_MCM_1DLUT_MEM_PWR_FORCE, 0);
77	REG_WAIT(MPCC_MCM_MEM_PWR_CTRL[mpcc_id], MPCC_MCM_1DLUT_MEM_PWR_STATE, 0, 1, 5);	77	REG_WAIT(MPCC_MCM_MEM_PWR_CTRL[mpcc_id], MPCC_MCM_1DLUT_MEM_PWR_STATE, 0, 1, 5);
78	} else {	78	} else if (!mpc->ctx->dc->debug.disable_mem_low_power) {
79	ASSERT(false);	79	ASSERT(false);
80	/* TODO: change to mpc	80	/* TODO: change to mpc
81	* dpp_base->ctx->dc->optimized_required = true;	81	* dpp_base->ctx->dc->optimized_required = true;

drivers/gpu/drm/i915/gem/i915_gem_shmem.c+7−4

 	st->nents = 0;
 	for (i = 0; i < page_count; i++) {
 		struct folio *folio;
+		unsigned long nr_pages;
 		const unsigned int shrink[] = {
 			I915_SHRINK_BOUND | I915_SHRINK_UNBOUND,
 			0,
 			}
 		} while (1);
+		nr_pages = min_t(unsigned long,
+				folio_nr_pages(folio), page_count - i);
 		if (!i ||
 		    sg->length >= max_segment ||
 		    folio_pfn(folio) != next_pfn) {
 				sg = sg_next(sg);
 			st->nents++;
-			sg_set_folio(sg, folio, folio_size(folio), 0);
+			sg_set_folio(sg, folio, nr_pages * PAGE_SIZE, 0);
 		} else {
 			/* XXX: could overflow? */
-			sg->length += folio_size(folio);
+			sg->length += nr_pages * PAGE_SIZE;
 		}
-		next_pfn = folio_pfn(folio) + folio_nr_pages(folio);
+		next_pfn = folio_pfn(folio) + nr_pages;
-		i += folio_nr_pages(folio) - 1;
+		i += nr_pages - 1;
 		/* Check that the i965g/gm workaround works. */
 		GEM_BUG_ON(gfp & __GFP_DMA32 && next_pfn >= 0x00100000UL);

drivers/gpu/drm/i915/gt/intel_engine_cs.c+0−1

@@ -558,7 +558,6 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id, · 557 unmodified lines
558	DRIVER_CAPS(i915)->has_logical_contexts = true;	558	DRIVER_CAPS(i915)->has_logical_contexts = true;
559		559
560	ewma__engine_latency_init(&engine->latency);	560	ewma__engine_latency_init(&engine->latency);
561	seqcount_init(&engine->stats.execlists.lock);
562		561
563	ATOMIC_INIT_NOTIFIER_HEAD(&engine->context_status_notifier);	562	ATOMIC_INIT_NOTIFIER_HEAD(&engine->context_status_notifier);
564		563

drivers/gpu/drm/i915/gt/intel_execlists_submission.c+2−0

@@ -3550,6 +3550,8 @@ int intel_execlists_submission_setup(struct intel_engine_cs *engine) · 3549 unmodified lines
3550	logical_ring_default_vfuncs(engine);	3550	logical_ring_default_vfuncs(engine);
3551	logical_ring_default_irqs(engine);	3551	logical_ring_default_irqs(engine);
3552		3552
		3553	seqcount_init(&engine->stats.execlists.lock);
		3554
3553	if (engine->flags & I915_ENGINE_HAS_RCS_REG_STATE)	3555	if (engine->flags & I915_ENGINE_HAS_RCS_REG_STATE)
3554	rcs_submission_override(engine);	3556	rcs_submission_override(engine);
3555		3557

drivers/gpu/drm/i915/gt/intel_ggtt.c+17−6

 	vm->clear_range(vm, vma_res->start, vma_res->vma_size);
 }
+/*
+ * Reserve the top of the GuC address space for firmware images. Addresses
+ * beyond GUC_GGTT_TOP in the GuC address space are inaccessible by GuC,
+ * which makes for a suitable range to hold GuC/HuC firmware images if the
+ * size of the GGTT is 4G. However, on a 32-bit platform the size of the GGTT
+ * is limited to 2G, which is less than GUC_GGTT_TOP, but we reserve a chunk
+ * of the same size anyway, which is far more than needed, to keep the logic
+ * in uc_fw_ggtt_offset() simple.
+ */
+#define GUC_TOP_RESERVE_SIZE (SZ_4G - GUC_GGTT_TOP)
 static int ggtt_reserve_guc_top(struct i915_ggtt *ggtt)
 {
-	u64 size;
+	u64 offset;
 	int ret;
 	if (!intel_uc_uses_guc(&ggtt->vm.gt->uc))
 		return 0;
-	GEM_BUG_ON(ggtt->vm.total <= GUC_GGTT_TOP);
+	GEM_BUG_ON(ggtt->vm.total <= GUC_TOP_RESERVE_SIZE);
-	size = ggtt->vm.total - GUC_GGTT_TOP;
+	offset = ggtt->vm.total - GUC_TOP_RESERVE_SIZE;
-	ret = i915_gem_gtt_reserve(&ggtt->vm, NULL, &ggtt->uc_fw, size,
+	ret = i915_gem_gtt_reserve(&ggtt->vm, NULL, &ggtt->uc_fw,
-				   GUC_GGTT_TOP, I915_COLOR_UNEVICTABLE,
+				   GUC_TOP_RESERVE_SIZE, offset,
-				   PIN_NOEVICT);
+				   I915_COLOR_UNEVICTABLE, PIN_NOEVICT);
 	if (ret)
 		drm_dbg(&ggtt->vm.i915->drm,
 			"Failed to reserve top of GGTT for GuC\n");

drivers/gpu/drm/i915/gt/intel_lrc.c+3−2

 					  I915_BO_ALLOC_PM_VOLATILE);
 	if (IS_ERR(obj)) {
 		obj = i915_gem_object_create_shmem(engine->i915, context_size);
+		if (IS_ERR(obj))
+			return ERR_CAST(obj);
 		/*
 		 * Wa_22016122933: For Media version 13.0, all Media GT shared
 		 * memory needs to be mapped as WC on CPU side and UC (PAT
 		if (intel_gt_needs_wa_22016122933(engine->gt))
 			i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE);
 	}
-	if (IS_ERR(obj))
-		return ERR_CAST(obj);
 	vma = i915_vma_instance(obj, &engine->gt->ggtt->vm, NULL);
 	if (IS_ERR(vma)) {

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c+35−3

@@ -1432,6 +1432,36 @@ static void guc_timestamp_ping(struct work_struct *wrk) · 1431 unmodified lines
1432	unsigned long index;	1432	unsigned long index;
1433	int srcu, ret;	1433	int srcu, ret;
1434		1434
		1435	/*
		1436	* Ideally the busyness worker should take a gt pm wakeref because the
		1437	* worker only needs to be active while gt is awake. However, the
		1438	* gt_park path cancels the worker synchronously and this complicates
		1439	* the flow if the worker is also running at the same time. The cancel
		1440	* waits for the worker and when the worker releases the wakeref, that
		1441	* would call gt_park and would lead to a deadlock.
		1442	*
		1443	* The resolution is to take the global pm wakeref if runtime pm is
		1444	* already active. If not, we don't need to update the busyness stats as
		1445	* the stats would already be updated when the gt was parked.
		1446	*
		1447	* Note:
		1448	* - We do not requeue the worker if we cannot take a reference to runtime
		1449	* pm since intel_guc_busyness_unpark would requeue the worker in the
		1450	* resume path.
		1451	*
		1452	* - If the gt was parked longer than time taken for GT timestamp to roll
		1453	* over, we ignore those rollovers since we don't care about tracking
		1454	* the exact GT time. We only care about roll overs when the gt is
		1455	* active and running workloads.
		1456	*
		1457	* - There is a window of time between gt_park and runtime suspend,
		1458	* where the worker may run. This is acceptable since the worker will
		1459	* not find any new data to update busyness.
		1460	*/
		1461	wakeref = intel_runtime_pm_get_if_active(&gt->i915->runtime_pm);
		1462	if (!wakeref)
		1463	return;
		1464
1435	/*	1465	/*
1436	* Synchronize with gt reset to make sure the worker does not	1466	* Synchronize with gt reset to make sure the worker does not
1437	* corrupt the engine/guc stats. NB: can't actually block waiting	1467	* corrupt the engine/guc stats. NB: can't actually block waiting
@@ -1440,10 +1470,9 @@ static void guc_timestamp_ping(struct work_struct *wrk) · 2 unmodified lines
1440	*/	1470	*/
1441	ret = intel_gt_reset_trylock(gt, &srcu);	1471	ret = intel_gt_reset_trylock(gt, &srcu);
1442	if (ret)	1472	if (ret)
1443	return;	1473	goto err_trylock;
1444		1474
1445	with_intel_runtime_pm(&gt->i915->runtime_pm, wakeref)	1475	__update_guc_busyness_stats(guc);
1446	__update_guc_busyness_stats(guc);
1447		1476
1448	/* adjust context stats for overflow */	1477	/* adjust context stats for overflow */
1449	xa_for_each(&guc->context_lookup, index, ce)	1478	xa_for_each(&guc->context_lookup, index, ce)
@@ -1452,6 +1481,9 @@ static void guc_timestamp_ping(struct work_struct *wrk) · 2 unmodified lines
1452	intel_gt_reset_unlock(gt, srcu);	1481	intel_gt_reset_unlock(gt, srcu);
1453		1482
1454	guc_enable_busyness_worker(guc);	1483	guc_enable_busyness_worker(guc);
		1484
		1485	err_trylock:
		1486	intel_runtime_pm_put(&gt->i915->runtime_pm, wakeref);
1455	}	1487	}
1456		1488
1457	static int guc_action_enable_usage_stats(struct intel_guc *guc)	1489	static int guc_action_enable_usage_stats(struct intel_guc *guc)

drivers/gpu/drm/meson/meson_encoder_hdmi.c+2−0

@@ -334,6 +334,8 @@ static void meson_encoder_hdmi_hpd_notify(struct drm_bridge *bridge, · 333 unmodified lines
334	return;	334	return;
335		335
336	cec_notifier_set_phys_addr_from_edid(encoder_hdmi->cec_notifier, edid);	336	cec_notifier_set_phys_addr_from_edid(encoder_hdmi->cec_notifier, edid);
		337
		338	kfree(edid);
337	} else	339	} else
338	cec_notifier_phys_addr_invalidate(encoder_hdmi->cec_notifier);	340	cec_notifier_phys_addr_invalidate(encoder_hdmi->cec_notifier);
339	}	341	}

drivers/gpu/drm/nouveau/nouveau_drv.h+5−14

@@ -189,21 +189,12 @@ u_free(void *addr) · 188 unmodified lines
189	static inline void *	189	static inline void *
190	u_memcpya(uint64_t user, unsigned int nmemb, unsigned int size)	190	u_memcpya(uint64_t user, unsigned int nmemb, unsigned int size)
191	{	191	{
192	void *mem;	192	void __user *userptr = u64_to_user_ptr(user);
193	void __user userptr = (void __force __user )(uintptr_t)user;	193	size_t bytes;
194		194
195	size *= nmemb;	195	if (unlikely(check_mul_overflow(nmemb, size, &bytes)))
196		196	return ERR_PTR(-EOVERFLOW);
197	mem = kvmalloc(size, GFP_KERNEL);	197	return vmemdup_user(userptr, bytes);
198	if (!mem)
199	return ERR_PTR(-ENOMEM);
200
201	if (copy_from_user(mem, userptr, size)) {
202	u_free(mem);
203	return ERR_PTR(-EFAULT);
204	}
205
206	return mem;
207	}	198	}
208		199
209	#include <nvif/object.h>	200	#include <nvif/object.h>

drivers/gpu/drm/nouveau/nouveau_exec.c+1−1

@@ -213,7 +213,7 @@ nouveau_exec_job_timeout(struct nouveau_job *job) · 212 unmodified lines
213		213
214	nouveau_sched_entity_fini(job->entity);	214	nouveau_sched_entity_fini(job->entity);
215		215
216	return DRM_GPU_SCHED_STAT_ENODEV;	216	return DRM_GPU_SCHED_STAT_NOMINAL;
217	}	217	}
218		218
219	static struct nouveau_job_ops nouveau_exec_job_ops = {	219	static struct nouveau_job_ops nouveau_exec_job_ops = {

drivers/gpu/drm/nouveau/nouveau_fence.c+1−1

@@ -207,7 +207,7 @@ nouveau_fence_context_new(struct nouveau_channel *chan, struct nouveau_fence_cha · 206 unmodified lines
207	int	207	int
208	nouveau_fence_emit(struct nouveau_fence *fence)	208	nouveau_fence_emit(struct nouveau_fence *fence)
209	{	209	{
210	struct nouveau_channel *chan = fence->channel;	210	struct nouveau_channel *chan = unrcu_pointer(fence->channel);
211	struct nouveau_fence_chan *fctx = chan->fence;	211	struct nouveau_fence_chan *fctx = chan->fence;
212	struct nouveau_fence_priv priv = (void)chan->drm->fence;	212	struct nouveau_fence_priv priv = (void)chan->drm->fence;
213	int ret;	213	int ret;

drivers/gpu/drm/nouveau/nouveau_sched.c+9−3

 static enum drm_gpu_sched_stat
 nouveau_sched_timedout_job(struct drm_sched_job *sched_job)
 {
+	struct drm_gpu_scheduler *sched = sched_job->sched;
 	struct nouveau_job *job = to_nouveau_job(sched_job);
+	enum drm_gpu_sched_stat stat = DRM_GPU_SCHED_STAT_NOMINAL;
-	NV_PRINTK(warn, job->cli, "Job timed out.\n");
+	drm_sched_stop(sched, sched_job);
 	if (job->ops->timeout)
-		return job->ops->timeout(job);
+		stat = job->ops->timeout(job);
+	else
+		NV_PRINTK(warn, job->cli, "Generic job timeout.\n");
+	drm_sched_start(sched, true);
-	return DRM_GPU_SCHED_STAT_ENODEV;
+	return stat;
 }
 static void

drivers/gpu/drm/tests/drm_mm_test.c+1−1

@@ -939,7 +939,7 @@ static void drm_test_mm_insert_range(struct kunit *test) · 938 unmodified lines
939	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max - 1));	939	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max - 1));
940	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max / 2));	940	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max / 2));
941	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,	941	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,
942	max / 2, max / 2));	942	max / 2, max));
943	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,	943	KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,
944	max / 4 + 1, 3 * max / 4 - 1));	944	max / 4 + 1, 3 * max / 4 - 1));
945		945

drivers/gpu/drm/virtio/virtgpu_submit.c+0−1

@@ -361,7 +361,6 @@ static void virtio_gpu_complete_submit(struct virtio_gpu_submit *submit) · 360 unmodified lines
361	submit->buf = NULL;	361	submit->buf = NULL;
362	submit->buflist = NULL;	362	submit->buflist = NULL;
363	submit->sync_file = NULL;	363	submit->sync_file = NULL;
364	submit->out_fence = NULL;
365	submit->out_fence_fd = -1;	364	submit->out_fence_fd = -1;
366	}	365	}
367		366

drivers/i2c/busses/i2c-designware-common.c+17−0

@@ -441,8 +441,25 @@ err_release_lock: · 440 unmodified lines
441		441
442	void __i2c_dw_disable(struct dw_i2c_dev *dev)	442	void __i2c_dw_disable(struct dw_i2c_dev *dev)
443	{	443	{
		444	unsigned int raw_intr_stats;
		445	unsigned int enable;
444	int timeout = 100;	446	int timeout = 100;
		447	bool abort_needed;
445	unsigned int status;	448	unsigned int status;
		449	int ret;
		450
		451	regmap_read(dev->map, DW_IC_RAW_INTR_STAT, &raw_intr_stats);
		452	regmap_read(dev->map, DW_IC_ENABLE, &enable);
		453
		454	abort_needed = raw_intr_stats & DW_IC_INTR_MST_ON_HOLD;
		455	if (abort_needed) {
		456	regmap_write(dev->map, DW_IC_ENABLE, enable \| DW_IC_ENABLE_ABORT);
		457	ret = regmap_read_poll_timeout(dev->map, DW_IC_ENABLE, enable,
		458	!(enable & DW_IC_ENABLE_ABORT), 10,
		459	100);
		460	if (ret)
		461	dev_err(dev->dev, "timeout while trying to abort current transfer\n");
		462	}
446		463
447	do {	464	do {
448	__i2c_dw_disable_nowait(dev);	465	__i2c_dw_disable_nowait(dev);

drivers/i2c/busses/i2c-designware-core.h+3−0

 #define DW_IC_INTR_START_DET			BIT(10)
 #define DW_IC_INTR_GEN_CALL			BIT(11)
 #define DW_IC_INTR_RESTART_DET			BIT(12)
+#define DW_IC_INTR_MST_ON_HOLD			BIT(13)
 #define DW_IC_INTR_DEFAULT_MASK			(DW_IC_INTR_RX_FULL | \
 						 DW_IC_INTR_TX_ABRT | \
 						 DW_IC_INTR_RX_UNDER | \
 						 DW_IC_INTR_RD_REQ)
+#define DW_IC_ENABLE_ABORT			BIT(1)
 #define DW_IC_STATUS_ACTIVITY			BIT(0)
 #define DW_IC_STATUS_TFE			BIT(2)
 #define DW_IC_STATUS_RFNE			BIT(3)

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

@@ -1754,6 +1754,7 @@ static int i801_probe(struct pci_dev dev, const struct pci_device_id id) · 1753 unmodified lines
1754	"SMBus I801 adapter at %04lx", priv->smba);	1754	"SMBus I801 adapter at %04lx", priv->smba);
1755	err = i2c_add_adapter(&priv->adapter);	1755	err = i2c_add_adapter(&priv->adapter);
1756	if (err) {	1756	if (err) {
		1757	platform_device_unregister(priv->tco_pdev);
1757	i801_acpi_remove(priv);	1758	i801_acpi_remove(priv);
1758	return err;	1759	return err;
1759	}	1760	}

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

 {
 	struct i2c_msg *msgs;
 	int msgs_num;
+	bool do_complete = false;
 	msgs = bus->msgs;
 	msgs_num = bus->msgs_num;
 				 msgs[1].flags & I2C_M_RD)
 				msgs[1].len = info;
 		}
-		if (completion_done(&bus->cmd_complete) == false)
+		do_complete = true;
-			complete(&bus->cmd_complete);
+		break;
-	break;
 	case I2C_NACK_IND:
 		/* MASTER transmit got a NACK before tx all bytes */
 		bus->cmd_err = -ENXIO;
-		if (bus->master_or_slave == I2C_MASTER)
+		do_complete = true;
-			complete(&bus->cmd_complete);
 		break;
 	case I2C_BUS_ERR_IND:
 		/* Bus error */
 		bus->cmd_err = -EAGAIN;
-		if (bus->master_or_slave == I2C_MASTER)
+		do_complete = true;
-			complete(&bus->cmd_complete);
 		break;
 	case I2C_WAKE_UP_IND:
 		/* I2C wake up */
 	if (bus->slave)
 		bus->master_or_slave = I2C_SLAVE;
 #endif
+	if (do_complete)
+		complete(&bus->cmd_complete);
 }
 static u8 npcm_i2c_fifo_usage(struct npcm_i2c *bus)

drivers/i2c/busses/i2c-xiic.c+1−1

@@ -710,7 +710,7 @@ static irqreturn_t xiic_process(int irq, void *dev_id) · 709 unmodified lines
710	* reset the IP instead of just flush fifos	710	* reset the IP instead of just flush fifos
711	*/	711	*/
712	ret = xiic_reinit(i2c);	712	ret = xiic_reinit(i2c);
713	if (!ret)	713	if (ret < 0)
714	dev_dbg(i2c->adap.dev.parent, "reinit failed\n");	714	dev_dbg(i2c->adap.dev.parent, "reinit failed\n");
715		715
716	if (i2c->rx_msg) {	716	if (i2c->rx_msg) {

drivers/i2c/i2c-mux.c+1−1

@@ -341,7 +341,7 @@ int i2c_mux_add_adapter(struct i2c_mux_core *muxc, · 340 unmodified lines
341	priv->adap.lock_ops = &i2c_parent_lock_ops;	341	priv->adap.lock_ops = &i2c_parent_lock_ops;
342		342
343	/* Sanity check on class */	343	/* Sanity check on class */
344	if (i2c_mux_parent_classes(parent) & class)	344	if (i2c_mux_parent_classes(parent) & class & ~I2C_CLASS_DEPRECATED)
345	dev_err(&parent->dev,	345	dev_err(&parent->dev,
346	"Segment %d behind mux can't share classes with ancestors\n",	346	"Segment %d behind mux can't share classes with ancestors\n",
347	chan_id);	347	chan_id);

drivers/i2c/muxes/i2c-demux-pinctrl.c+4−0

 		props[i].name = devm_kstrdup(&pdev->dev, "status", GFP_KERNEL);
 		props[i].value = devm_kstrdup(&pdev->dev, "ok", GFP_KERNEL);
+		if (!props[i].name || !props[i].value) {
+			err = -ENOMEM;
+			goto err_rollback;
+		}
 		props[i].length = 3;
 		of_changeset_init(&priv->chan[i].chgset);

drivers/i2c/muxes/i2c-mux-gpio.c+3−1

 		} else if (is_acpi_node(child)) {
 			rc = acpi_get_local_address(ACPI_HANDLE_FWNODE(child), values + i);
-			if (rc)
+			if (rc) {
+				fwnode_handle_put(child);
 				return dev_err_probe(dev, rc, "Cannot get address\n");
+			}
 		}
 		i++;

drivers/iommu/apple-dart.c+1−2

@@ -671,8 +671,7 @@ static int apple_dart_attach_dev(struct iommu_domain *domain, · 670 unmodified lines
671	return ret;	671	return ret;
672		672
673	switch (domain->type) {	673	switch (domain->type) {
674	case IOMMU_DOMAIN_DMA:	674	default:
675	case IOMMU_DOMAIN_UNMANAGED:
676	ret = apple_dart_domain_add_streams(dart_domain, cfg);	675	ret = apple_dart_domain_add_streams(dart_domain, cfg);
677	if (ret)	676	if (ret)
678	return ret;	677	return ret;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c+16−2

 	}
 }
+/*
+ * Cloned from the MAX_TLBI_OPS in arch/arm64/include/asm/tlbflush.h, this
+ * is used as a threshold to replace per-page TLBI commands to issue in the
+ * command queue with an address-space TLBI command, when SMMU w/o a range
+ * invalidation feature handles too many per-page TLBI commands, which will
+ * otherwise result in a soft lockup.
+ */
+#define CMDQ_MAX_TLBI_OPS		(1 << (PAGE_SHIFT - 3))
 static void arm_smmu_mm_arch_invalidate_secondary_tlbs(struct mmu_notifier *mn,
 						struct mm_struct *mm,
 						unsigned long start,
 	 * range. So do a simple translation here by calculating size correctly.
 	 */
 	size = end - start;
-	if (size == ULONG_MAX)
+	if (!(smmu_domain->smmu->features & ARM_SMMU_FEAT_RANGE_INV)) {
-		size = 0;
+		if (size >= CMDQ_MAX_TLBI_OPS * PAGE_SIZE)
+			size = 0;
+	} else {
+		if (size == ULONG_MAX)
+			size = 0;
+	}
 	if (!(smmu_domain->smmu->features & ARM_SMMU_FEAT_BTM)) {
 		if (!size)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c+10−5

@@ -1895,18 +1895,23 @@ static void __arm_smmu_tlb_inv_range(struct arm_smmu_cmdq_ent *cmd, · 1894 unmodified lines
1895	/* Get the leaf page size */	1895	/* Get the leaf page size */
1896	tg = __ffs(smmu_domain->domain.pgsize_bitmap);	1896	tg = __ffs(smmu_domain->domain.pgsize_bitmap);
1897		1897
		1898	num_pages = size >> tg;
		1899
1898	/* Convert page size of 12,14,16 (log2) to 1,2,3 */	1900	/* Convert page size of 12,14,16 (log2) to 1,2,3 */
1899	cmd->tlbi.tg = (tg - 10) / 2;	1901	cmd->tlbi.tg = (tg - 10) / 2;
1900		1902
1901	/*	1903	/*
1902	* Determine what level the granule is at. For non-leaf, io-pgtable	1904	* Determine what level the granule is at. For non-leaf, both
1903	* assumes .tlb_flush_walk can invalidate multiple levels at once,	1905	* io-pgtable and SVA pass a nominal last-level granule because
1904	* so ignore the nominal last-level granule and leave TTL=0.	1906	* they don't know what level(s) actually apply, so ignore that
		1907	* and leave TTL=0. However for various errata reasons we still
		1908	* want to use a range command, so avoid the SVA corner case
		1909	* where both scale and num could be 0 as well.
1905	*/	1910	*/
1906	if (cmd->tlbi.leaf)	1911	if (cmd->tlbi.leaf)
1907	cmd->tlbi.ttl = 4 - ((ilog2(granule) - 3) / (tg - 3));	1912	cmd->tlbi.ttl = 4 - ((ilog2(granule) - 3) / (tg - 3));
1908		1913	else if ((num_pages & CMDQ_TLBI_RANGE_NUM_MAX) == 1)
1909	num_pages = size >> tg;	1914	num_pages++;
1910	}	1915	}
1911		1916
1912	cmds.num = 0;	1917	cmds.num = 0;

drivers/iommu/intel/iommu.c+0−16

 	struct intel_iommu *iommu = NULL;
 	unsigned long flag;
-	for_each_active_iommu(iommu, drhd) {
-		iommu->iommu_state = kcalloc(MAX_SR_DMAR_REGS, sizeof(u32),
-					     GFP_KERNEL);
-		if (!iommu->iommu_state)
-			goto nomem;
-	}
 	iommu_flush_all();
 	for_each_active_iommu(iommu, drhd) {
 		raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
 	}
 	return 0;
-nomem:
-	for_each_active_iommu(iommu, drhd)
-		kfree(iommu->iommu_state);
-	return -ENOMEM;
 }
 static void iommu_resume(void)
 		raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
 	}
-	for_each_active_iommu(iommu, drhd)
-		kfree(iommu->iommu_state);
 }
 static struct syscore_ops iommu_syscore_ops = {

drivers/iommu/intel/iommu.h+1−1

@@ -681,7 +681,7 @@ struct intel_iommu { · 680 unmodified lines
681	struct iopf_queue *iopf_queue;	681	struct iopf_queue *iopf_queue;
682	unsigned char iopfq_name[16];	682	unsigned char iopfq_name[16];
683	struct q_inval qi; / Queued invalidation info */	683	struct q_inval qi; / Queued invalidation info */
684	u32 iommu_state; / Store iommu states between suspend and resume.*/	684	u32 iommu_state[MAX_SR_DMAR_REGS]; /* Store iommu states between suspend and resume.*/
685		685
686	#ifdef CONFIG_IRQ_REMAP	686	#ifdef CONFIG_IRQ_REMAP
687	struct ir_table ir_table; / Interrupt remapping info */	687	struct ir_table ir_table; / Interrupt remapping info */

drivers/iommu/mtk_iommu.c+4−5

 	struct device			*smicomm_dev;
 	struct mtk_iommu_bank_data	*bank;
-	struct mtk_iommu_domain		*share_dom; /* For 2 HWs share pgtable */
+	struct mtk_iommu_domain		*share_dom;
 	struct regmap			*pericfg;
 	struct mutex			mutex; /* Protect m4u_group/m4u_dom above */
 	struct mtk_iommu_domain	*share_dom = data->share_dom;
 	const struct mtk_iommu_iova_region *region;
-	/* Always use share domain in sharing pgtable case */
+	/* Share pgtable when 2 MM IOMMU share the pgtable or one IOMMU use multiple iova ranges */
-	if (MTK_IOMMU_HAS_FLAG(data->plat_data, SHARE_PGTABLE) && share_dom) {
+	if (share_dom) {
 		dom->iop = share_dom->iop;
 		dom->cfg = share_dom->cfg;
 		dom->domain.pgsize_bitmap = share_dom->cfg.pgsize_bitmap;
 	/* Update our support page sizes bitmap */
 	dom->domain.pgsize_bitmap = dom->cfg.pgsize_bitmap;
-	if (MTK_IOMMU_HAS_FLAG(data->plat_data, SHARE_PGTABLE))
+	data->share_dom = dom;
-		data->share_dom = dom;
 update_iova_region:
 	/* Update the iova region for this domain */

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

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/irqdomain.h>	12	#include <linux/irqdomain.h>
13	#include <linux/irq.h>	13	#include <linux/irq.h>
14	#include <linux/irqchip.h>	14	#include <linux/irqchip.h>
		15	#include <linux/irqchip/xtensa-mx.h>
15	#include <linux/of.h>	16	#include <linux/of.h>
16		17
17	#include <asm/mxregs.h>	18	#include <asm/mxregs.h>

drivers/leds/led-core.c+0−4

@@ -479,10 +479,6 @@ int led_compose_name(struct device dev, struct led_init_data init_data, · 478 unmodified lines
479		479
480	led_parse_fwnode_props(dev, fwnode, &props);	480	led_parse_fwnode_props(dev, fwnode, &props);
481		481
482	/* We want to label LEDs that can produce full range of colors
483	* as RGB, not multicolor */
484	BUG_ON(props.color == LED_COLOR_ID_MULTI);
485
486	if (props.label) {	482	if (props.label) {
487	/*	483	/*
488	* If init_data.devicename is NULL, then it indicates that	484	* If init_data.devicename is NULL, then it indicates that

drivers/mfd/Kconfig+1−0

@@ -241,6 +241,7 @@ config MFD_CS42L43 · 240 unmodified lines
241	tristate	241	tristate
242	select MFD_CORE	242	select MFD_CORE
243	select REGMAP	243	select REGMAP
		244	select REGMAP_IRQ
244		245
245	config MFD_CS42L43_I2C	246	config MFD_CS42L43_I2C
246	tristate "Cirrus Logic CS42L43 (I2C)"	247	tristate "Cirrus Logic CS42L43 (I2C)"

drivers/mfd/cs42l43.c+2−2

@@ -1178,8 +1178,8 @@ err: · 1177 unmodified lines
1178	}	1178	}
1179		1179
1180	EXPORT_NS_GPL_DEV_PM_OPS(cs42l43_pm_ops, MFD_CS42L43) = {	1180	EXPORT_NS_GPL_DEV_PM_OPS(cs42l43_pm_ops, MFD_CS42L43) = {
1181	SET_SYSTEM_SLEEP_PM_OPS(cs42l43_suspend, cs42l43_resume)	1181	SYSTEM_SLEEP_PM_OPS(cs42l43_suspend, cs42l43_resume)
1182	SET_RUNTIME_PM_OPS(cs42l43_runtime_suspend, cs42l43_runtime_resume, NULL)	1182	RUNTIME_PM_OPS(cs42l43_runtime_suspend, cs42l43_runtime_resume, NULL)
1183	};	1183	};
1184		1184
1185	MODULE_DESCRIPTION("CS42L43 Core Driver");	1185	MODULE_DESCRIPTION("CS42L43 Core Driver");

drivers/misc/cardreader/rts5227.c+6−49

@@ -83,63 +83,20 @@ static void rts5227_fetch_vendor_settings(struct rtsx_pcr *pcr) · 82 unmodified lines
83		83
84	static void rts5227_init_from_cfg(struct rtsx_pcr *pcr)	84	static void rts5227_init_from_cfg(struct rtsx_pcr *pcr)
85	{	85	{
86	struct pci_dev *pdev = pcr->pci;
87	int l1ss;
88	u32 lval;
89	struct rtsx_cr_option *option = &pcr->option;	86	struct rtsx_cr_option *option = &pcr->option;
90		87
91	l1ss = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
92	if (!l1ss)
93	return;
94
95	pci_read_config_dword(pdev, l1ss + PCI_L1SS_CTL1, &lval);
96
97	if (CHK_PCI_PID(pcr, 0x522A)) {	88	if (CHK_PCI_PID(pcr, 0x522A)) {
98	if (0 == (lval & 0x0F))	89	if (rtsx_check_dev_flag(pcr, ASPM_L1_1_EN \| ASPM_L1_2_EN
99	rtsx_pci_enable_oobs_polling(pcr);	90	\| PM_L1_1_EN \| PM_L1_2_EN))
100	else
101	rtsx_pci_disable_oobs_polling(pcr);	91	rtsx_pci_disable_oobs_polling(pcr);
		92	else
		93	rtsx_pci_enable_oobs_polling(pcr);
102	}	94	}
103		95
104	if (lval & PCI_L1SS_CTL1_ASPM_L1_1)
105	rtsx_set_dev_flag(pcr, ASPM_L1_1_EN);
106	else
107	rtsx_clear_dev_flag(pcr, ASPM_L1_1_EN);
108
109	if (lval & PCI_L1SS_CTL1_ASPM_L1_2)
110	rtsx_set_dev_flag(pcr, ASPM_L1_2_EN);
111	else
112	rtsx_clear_dev_flag(pcr, ASPM_L1_2_EN);
113
114	if (lval & PCI_L1SS_CTL1_PCIPM_L1_1)
115	rtsx_set_dev_flag(pcr, PM_L1_1_EN);
116	else
117	rtsx_clear_dev_flag(pcr, PM_L1_1_EN);
118
119	if (lval & PCI_L1SS_CTL1_PCIPM_L1_2)
120	rtsx_set_dev_flag(pcr, PM_L1_2_EN);
121	else
122	rtsx_clear_dev_flag(pcr, PM_L1_2_EN);
123
124	if (option->ltr_en) {	96	if (option->ltr_en) {
125	u16 val;	97	if (option->ltr_enabled)
126
127	pcie_capability_read_word(pcr->pci, PCI_EXP_DEVCTL2, &val);
128	if (val & PCI_EXP_DEVCTL2_LTR_EN) {
129	option->ltr_enabled = true;
130	option->ltr_active = true;
131	rtsx_set_ltr_latency(pcr, option->ltr_active_latency);	98	rtsx_set_ltr_latency(pcr, option->ltr_active_latency);
132	} else {
133	option->ltr_enabled = false;
134	}
135	}	99	}
136
137	if (rtsx_check_dev_flag(pcr, ASPM_L1_1_EN \| ASPM_L1_2_EN
138	\| PM_L1_1_EN \| PM_L1_2_EN))
139	option->force_clkreq_0 = false;
140	else
141	option->force_clkreq_0 = true;
142
143	}	100	}
144		101
145	static int rts5227_extra_init_hw(struct rtsx_pcr *pcr)	102	static int rts5227_extra_init_hw(struct rtsx_pcr *pcr)
@@ -195,7 +152,7 @@ static int rts5227_extra_init_hw(struct rtsx_pcr *pcr) · 49 unmodified lines
195	}	152	}
196	}	153	}
197		154
198	if (option->force_clkreq_0 && pcr->aspm_mode == ASPM_MODE_CFG)	155	if (option->force_clkreq_0)
199	rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, PETXCFG,	156	rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, PETXCFG,
200	FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_LOW);	157	FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_LOW);
201	else	158	else

drivers/misc/cardreader/rts5228.c+17−40

 static void rts5228_init_from_cfg(struct rtsx_pcr *pcr)
 {
-	struct pci_dev *pdev = pcr->pci;
-	int l1ss;
-	u32 lval;
 	struct rtsx_cr_option *option = &pcr->option;
-	l1ss = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
+	if (rtsx_check_dev_flag(pcr, ASPM_L1_1_EN | ASPM_L1_2_EN
-	if (!l1ss)
+				| PM_L1_1_EN | PM_L1_2_EN))
-		return;
-	pci_read_config_dword(pdev, l1ss + PCI_L1SS_CTL1, &lval);
-	if (0 == (lval & 0x0F))
-		rtsx_pci_enable_oobs_polling(pcr);
-	else
 		rtsx_pci_disable_oobs_polling(pcr);
-	if (lval & PCI_L1SS_CTL1_ASPM_L1_1)
-		rtsx_set_dev_flag(pcr, ASPM_L1_1_EN);
-	else
-		rtsx_clear_dev_flag(pcr, ASPM_L1_1_EN);
-	if (lval & PCI_L1SS_CTL1_ASPM_L1_2)
-		rtsx_set_dev_flag(pcr, ASPM_L1_2_EN);
-	else
-		rtsx_clear_dev_flag(pcr, ASPM_L1_2_EN);
-	if (lval & PCI_L1SS_CTL1_PCIPM_L1_1)
-		rtsx_set_dev_flag(pcr, PM_L1_1_EN);
 	else
-		rtsx_clear_dev_flag(pcr, PM_L1_1_EN);
+		rtsx_pci_enable_oobs_polling(pcr);
-	if (lval & PCI_L1SS_CTL1_PCIPM_L1_2)
-		rtsx_set_dev_flag(pcr, PM_L1_2_EN);
-	else
-		rtsx_clear_dev_flag(pcr, PM_L1_2_EN);
 	rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0xFF, 0);
-	if (option->ltr_en) {
-		u16 val;
-		pcie_capability_read_word(pcr->pci, PCI_EXP_DEVCTL2, &val);
+	if (option->ltr_en) {
-		if (val & PCI_EXP_DEVCTL2_LTR_EN) {
+		if (option->ltr_enabled)
-			option->ltr_enabled = true;
-			option->ltr_active = true;
 			rtsx_set_ltr_latency(pcr, option->ltr_active_latency);
-		} else {
-			option->ltr_enabled = false;
-		}
 	}
 }
 static int rts5228_extra_init_hw(struct rtsx_pcr *pcr)
 {
+	struct rtsx_cr_option *option = &pcr->option;
 	rtsx_pci_write_register(pcr, RTS5228_AUTOLOAD_CFG1,
 			CD_RESUME_EN_MASK, CD_RESUME_EN_MASK);
 	else
 		rtsx_pci_write_register(pcr, PETXCFG, 0x30, 0x00);
+	/*
+	 * If u_force_clkreq_0 is enabled, CLKREQ# PIN will be forced
+	 * to drive low, and we forcibly request clock.
+	 */
+	if (option->force_clkreq_0)
+		rtsx_pci_write_register(pcr, PETXCFG,
+				 FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_LOW);
+	else
+		rtsx_pci_write_register(pcr, PETXCFG,
+				 FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_HIGH);
 	rtsx_pci_write_register(pcr, PWD_SUSPEND_EN, 0xFF, 0xFB);
 	if (pcr->rtd3_en) {

drivers/misc/cardreader/rts5249.c+7−49

@@ -86,64 +86,22 @@ static void rtsx_base_fetch_vendor_settings(struct rtsx_pcr *pcr) · 85 unmodified lines
86		86
87	static void rts5249_init_from_cfg(struct rtsx_pcr *pcr)	87	static void rts5249_init_from_cfg(struct rtsx_pcr *pcr)
88	{	88	{
89	struct pci_dev *pdev = pcr->pci;
90	int l1ss;
91	struct rtsx_cr_option *option = &(pcr->option);	89	struct rtsx_cr_option *option = &(pcr->option);
92	u32 lval;
93
94	l1ss = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
95	if (!l1ss)
96	return;
97
98	pci_read_config_dword(pdev, l1ss + PCI_L1SS_CTL1, &lval);
99		90
100	if (CHK_PCI_PID(pcr, PID_524A) \|\| CHK_PCI_PID(pcr, PID_525A)) {	91	if (CHK_PCI_PID(pcr, PID_524A) \|\| CHK_PCI_PID(pcr, PID_525A)) {
101	if (0 == (lval & 0x0F))	92	if (rtsx_check_dev_flag(pcr, ASPM_L1_1_EN \| ASPM_L1_2_EN
102	rtsx_pci_enable_oobs_polling(pcr);	93	\| PM_L1_1_EN \| PM_L1_2_EN))
103	else
104	rtsx_pci_disable_oobs_polling(pcr);	94	rtsx_pci_disable_oobs_polling(pcr);
		95	else
		96	rtsx_pci_enable_oobs_polling(pcr);
105	}	97	}
106		98
107
108	if (lval & PCI_L1SS_CTL1_ASPM_L1_1)
109	rtsx_set_dev_flag(pcr, ASPM_L1_1_EN);
110
111	if (lval & PCI_L1SS_CTL1_ASPM_L1_2)
112	rtsx_set_dev_flag(pcr, ASPM_L1_2_EN);
113
114	if (lval & PCI_L1SS_CTL1_PCIPM_L1_1)
115	rtsx_set_dev_flag(pcr, PM_L1_1_EN);
116
117	if (lval & PCI_L1SS_CTL1_PCIPM_L1_2)
118	rtsx_set_dev_flag(pcr, PM_L1_2_EN);
119
120	if (option->ltr_en) {	99	if (option->ltr_en) {
121	u16 val;	100	if (option->ltr_enabled)
122
123	pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &val);
124	if (val & PCI_EXP_DEVCTL2_LTR_EN) {
125	option->ltr_enabled = true;
126	option->ltr_active = true;
127	rtsx_set_ltr_latency(pcr, option->ltr_active_latency);	101	rtsx_set_ltr_latency(pcr, option->ltr_active_latency);
128	} else {
129	option->ltr_enabled = false;
130	}
131	}	102	}
132	}	103	}
133		104
134	static int rts5249_init_from_hw(struct rtsx_pcr *pcr)
135	{
136	struct rtsx_cr_option *option = &(pcr->option);
137
138	if (rtsx_check_dev_flag(pcr, ASPM_L1_1_EN \| ASPM_L1_2_EN
139	\| PM_L1_1_EN \| PM_L1_2_EN))
140	option->force_clkreq_0 = false;
141	else
142	option->force_clkreq_0 = true;
143
144	return 0;
145	}
146
147	static void rts52xa_force_power_down(struct rtsx_pcr *pcr, u8 pm_state, bool runtime)	105	static void rts52xa_force_power_down(struct rtsx_pcr *pcr, u8 pm_state, bool runtime)
148	{	106	{
149	/* Set relink_time to 0 */	107	/* Set relink_time to 0 */
@@ -276,7 +234,6 @@ static int rts5249_extra_init_hw(struct rtsx_pcr *pcr) · 126 unmodified lines
276	struct rtsx_cr_option *option = &(pcr->option);	234	struct rtsx_cr_option *option = &(pcr->option);
277		235
278	rts5249_init_from_cfg(pcr);	236	rts5249_init_from_cfg(pcr);
279	rts5249_init_from_hw(pcr);
280		237
281	rtsx_pci_init_cmd(pcr);	238	rtsx_pci_init_cmd(pcr);
282		239
@@ -327,11 +284,12 @@ static int rts5249_extra_init_hw(struct rtsx_pcr *pcr) · 44 unmodified lines
327	}	284	}
328	}	285	}
329		286
		287
330	/*	288	/*
331	* If u_force_clkreq_0 is enabled, CLKREQ# PIN will be forced	289	* If u_force_clkreq_0 is enabled, CLKREQ# PIN will be forced
332	* to drive low, and we forcibly request clock.	290	* to drive low, and we forcibly request clock.
333	*/	291	*/
334	if (option->force_clkreq_0 && pcr->aspm_mode == ASPM_MODE_CFG)	292	if (option->force_clkreq_0)
335	rtsx_pci_write_register(pcr, PETXCFG,	293	rtsx_pci_write_register(pcr, PETXCFG,
336	FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_LOW);	294	FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_LOW);
337	else	295	else

drivers/misc/cardreader/rts5260.c+13−30

 static void rts5260_init_from_cfg(struct rtsx_pcr *pcr)
 {
-	struct pci_dev *pdev = pcr->pci;
-	int l1ss;
 	struct rtsx_cr_option *option = &pcr->option;
-	u32 lval;
-	l1ss = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
-	if (!l1ss)
-		return;
-	pci_read_config_dword(pdev, l1ss + PCI_L1SS_CTL1, &lval);
-	if (lval & PCI_L1SS_CTL1_ASPM_L1_1)
-		rtsx_set_dev_flag(pcr, ASPM_L1_1_EN);
-	if (lval & PCI_L1SS_CTL1_ASPM_L1_2)
-		rtsx_set_dev_flag(pcr, ASPM_L1_2_EN);
-	if (lval & PCI_L1SS_CTL1_PCIPM_L1_1)
-		rtsx_set_dev_flag(pcr, PM_L1_1_EN);
-	if (lval & PCI_L1SS_CTL1_PCIPM_L1_2)
-		rtsx_set_dev_flag(pcr, PM_L1_2_EN);
 	rts5260_pwr_saving_setting(pcr);
 	if (option->ltr_en) {
-		u16 val;
+		if (option->ltr_enabled)
-		pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &val);
-		if (val & PCI_EXP_DEVCTL2_LTR_EN) {
-			option->ltr_enabled = true;
-			option->ltr_active = true;
 			rtsx_set_ltr_latency(pcr, option->ltr_active_latency);
-		} else {
-			option->ltr_enabled = false;
-		}
 	}
 }
 static int rts5260_extra_init_hw(struct rtsx_pcr *pcr)
 {
+	struct rtsx_cr_option *option = &pcr->option;
 	/* Set mcu_cnt to 7 to ensure data can be sampled properly */
 	rtsx_pci_write_register(pcr, 0xFC03, 0x7F, 0x07);
 	rts5260_init_hw(pcr);
+	/*
+	 * If u_force_clkreq_0 is enabled, CLKREQ# PIN will be forced
+	 * to drive low, and we forcibly request clock.
+	 */
+	if (option->force_clkreq_0)
+		rtsx_pci_write_register(pcr, PETXCFG,
+				 FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_LOW);
+	else
+		rtsx_pci_write_register(pcr, PETXCFG,
+				 FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_HIGH);
 	rtsx_pci_write_register(pcr, pcr->reg_pm_ctrl3, 0x10, 0x00);
 	return 0;

drivers/misc/cardreader/rts5261.c+13−39

@@ -454,54 +454,17 @@ static void rts5261_init_from_hw(struct rtsx_pcr *pcr) · 453 unmodified lines
454		454
455	static void rts5261_init_from_cfg(struct rtsx_pcr *pcr)	455	static void rts5261_init_from_cfg(struct rtsx_pcr *pcr)
456	{	456	{
457	struct pci_dev *pdev = pcr->pci;
458	int l1ss;
459	u32 lval;
460	struct rtsx_cr_option *option = &pcr->option;	457	struct rtsx_cr_option *option = &pcr->option;
461		458
462	l1ss = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
463	if (!l1ss)
464	return;
465
466	pci_read_config_dword(pdev, l1ss + PCI_L1SS_CTL1, &lval);
467
468	if (lval & PCI_L1SS_CTL1_ASPM_L1_1)
469	rtsx_set_dev_flag(pcr, ASPM_L1_1_EN);
470	else
471	rtsx_clear_dev_flag(pcr, ASPM_L1_1_EN);
472
473	if (lval & PCI_L1SS_CTL1_ASPM_L1_2)
474	rtsx_set_dev_flag(pcr, ASPM_L1_2_EN);
475	else
476	rtsx_clear_dev_flag(pcr, ASPM_L1_2_EN);
477
478	if (lval & PCI_L1SS_CTL1_PCIPM_L1_1)
479	rtsx_set_dev_flag(pcr, PM_L1_1_EN);
480	else
481	rtsx_clear_dev_flag(pcr, PM_L1_1_EN);
482
483	if (lval & PCI_L1SS_CTL1_PCIPM_L1_2)
484	rtsx_set_dev_flag(pcr, PM_L1_2_EN);
485	else
486	rtsx_clear_dev_flag(pcr, PM_L1_2_EN);
487
488	rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0xFF, 0);
489	if (option->ltr_en) {	459	if (option->ltr_en) {
490	u16 val;	460	if (option->ltr_enabled)
491
492	pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &val);
493	if (val & PCI_EXP_DEVCTL2_LTR_EN) {
494	option->ltr_enabled = true;
495	option->ltr_active = true;
496	rtsx_set_ltr_latency(pcr, option->ltr_active_latency);	461	rtsx_set_ltr_latency(pcr, option->ltr_active_latency);
497	} else {
498	option->ltr_enabled = false;
499	}
500	}	462	}
501	}	463	}
502		464
503	static int rts5261_extra_init_hw(struct rtsx_pcr *pcr)	465	static int rts5261_extra_init_hw(struct rtsx_pcr *pcr)
504	{	466	{
		467	struct rtsx_cr_option *option = &pcr->option;
505	u32 val;	468	u32 val;
506		469
507	rtsx_pci_write_register(pcr, RTS5261_AUTOLOAD_CFG1,	470	rtsx_pci_write_register(pcr, RTS5261_AUTOLOAD_CFG1,
@@ -547,6 +510,17 @@ static int rts5261_extra_init_hw(struct rtsx_pcr *pcr) · 39 unmodified lines
547	else	510	else
548	rtsx_pci_write_register(pcr, PETXCFG, 0x30, 0x00);	511	rtsx_pci_write_register(pcr, PETXCFG, 0x30, 0x00);
549		512
		513	/*
		514	* If u_force_clkreq_0 is enabled, CLKREQ# PIN will be forced
		515	* to drive low, and we forcibly request clock.
		516	*/
		517	if (option->force_clkreq_0)
		518	rtsx_pci_write_register(pcr, PETXCFG,
		519	FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_LOW);
		520	else
		521	rtsx_pci_write_register(pcr, PETXCFG,
		522	FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_HIGH);
		523
550	rtsx_pci_write_register(pcr, PWD_SUSPEND_EN, 0xFF, 0xFB);	524	rtsx_pci_write_register(pcr, PWD_SUSPEND_EN, 0xFF, 0xFB);
551		525
552	if (pcr->rtd3_en) {	526	if (pcr->rtd3_en) {

drivers/misc/cardreader/rtsx_pcr.c+46−5

@@ -1326,11 +1326,8 @@ static int rtsx_pci_init_hw(struct rtsx_pcr *pcr) · 1325 unmodified lines
1326	return err;	1326	return err;
1327	}	1327	}
1328		1328
1329	if (pcr->aspm_mode == ASPM_MODE_REG) {	1329	if (pcr->aspm_mode == ASPM_MODE_REG)
1330	rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0x30, 0x30);	1330	rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0x30, 0x30);
1331	rtsx_pci_write_register(pcr, PETXCFG,
1332	FORCE_CLKREQ_DELINK_MASK, FORCE_CLKREQ_HIGH);
1333	}
1334		1331
1335	/* No CD interrupt if probing driver with card inserted.	1332	/* No CD interrupt if probing driver with card inserted.
1336	* So we need to initialize pcr->card_exist here.	1333	* So we need to initialize pcr->card_exist here.
@@ -1345,7 +1342,9 @@ static int rtsx_pci_init_hw(struct rtsx_pcr *pcr) · 8 unmodified lines
1345		1342
1346	static int rtsx_pci_init_chip(struct rtsx_pcr *pcr)	1343	static int rtsx_pci_init_chip(struct rtsx_pcr *pcr)
1347	{	1344	{
1348	int err;	1345	struct rtsx_cr_option *option = &(pcr->option);
		1346	int err, l1ss;
		1347	u32 lval;
1349	u16 cfg_val;	1348	u16 cfg_val;
1350	u8 val;	1349	u8 val;
1351		1350
@@ -1430,6 +1429,48 @@ static int rtsx_pci_init_chip(struct rtsx_pcr *pcr) · 78 unmodified lines
1430	pcr->aspm_enabled = true;	1429	pcr->aspm_enabled = true;
1431	}	1430	}
1432		1431
		1432	l1ss = pci_find_ext_capability(pcr->pci, PCI_EXT_CAP_ID_L1SS);
		1433	if (l1ss) {
		1434	pci_read_config_dword(pcr->pci, l1ss + PCI_L1SS_CTL1, &lval);
		1435
		1436	if (lval & PCI_L1SS_CTL1_ASPM_L1_1)
		1437	rtsx_set_dev_flag(pcr, ASPM_L1_1_EN);
		1438	else
		1439	rtsx_clear_dev_flag(pcr, ASPM_L1_1_EN);
		1440
		1441	if (lval & PCI_L1SS_CTL1_ASPM_L1_2)
		1442	rtsx_set_dev_flag(pcr, ASPM_L1_2_EN);
		1443	else
		1444	rtsx_clear_dev_flag(pcr, ASPM_L1_2_EN);
		1445
		1446	if (lval & PCI_L1SS_CTL1_PCIPM_L1_1)
		1447	rtsx_set_dev_flag(pcr, PM_L1_1_EN);
		1448	else
		1449	rtsx_clear_dev_flag(pcr, PM_L1_1_EN);
		1450
		1451	if (lval & PCI_L1SS_CTL1_PCIPM_L1_2)
		1452	rtsx_set_dev_flag(pcr, PM_L1_2_EN);
		1453	else
		1454	rtsx_clear_dev_flag(pcr, PM_L1_2_EN);
		1455
		1456	pcie_capability_read_word(pcr->pci, PCI_EXP_DEVCTL2, &cfg_val);
		1457	if (cfg_val & PCI_EXP_DEVCTL2_LTR_EN) {
		1458	option->ltr_enabled = true;
		1459	option->ltr_active = true;
		1460	} else {
		1461	option->ltr_enabled = false;
		1462	}
		1463
		1464	if (rtsx_check_dev_flag(pcr, ASPM_L1_1_EN \| ASPM_L1_2_EN
		1465	\| PM_L1_1_EN \| PM_L1_2_EN))
		1466	option->force_clkreq_0 = false;
		1467	else
		1468	option->force_clkreq_0 = true;
		1469	} else {
		1470	option->ltr_enabled = false;
		1471	option->force_clkreq_0 = true;
		1472	}
		1473
1433	if (pcr->ops->fetch_vendor_settings)	1474	if (pcr->ops->fetch_vendor_settings)
1434	pcr->ops->fetch_vendor_settings(pcr);	1475	pcr->ops->fetch_vendor_settings(pcr);
1435		1476

drivers/mtd/ubi/build.c+7−0

@@ -894,6 +894,13 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, · 893 unmodified lines
894	return -EINVAL;	894	return -EINVAL;
895	}	895	}
896		896
		897	/* UBI cannot work on flashes with zero erasesize. */
		898	if (!mtd->erasesize) {
		899	pr_err("ubi: refuse attaching mtd%d - zero erasesize flash is not supported\n",
		900	mtd->index);
		901	return -EINVAL;
		902	}
		903
897	if (ubi_num == UBI_DEV_NUM_AUTO) {	904	if (ubi_num == UBI_DEV_NUM_AUTO) {
898	/* Search for an empty slot in the @ubi_devices array */	905	/* Search for an empty slot in the @ubi_devices array */
899	for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)	906	for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)

drivers/net/dsa/mv88e6xxx/chip.c+4−2

 		 * from the wrong location resulting in the switch booting
 		 * to wrong mode and inoperable.
 		 */
-		mv88e6xxx_g1_wait_eeprom_done(chip);
+		if (chip->info->ops->get_eeprom)
+			mv88e6xxx_g2_eeprom_wait(chip);
 		gpiod_set_value_cansleep(gpiod, 1);
 		usleep_range(10000, 20000);
 		gpiod_set_value_cansleep(gpiod, 0);
 		usleep_range(10000, 20000);
-		mv88e6xxx_g1_wait_eeprom_done(chip);
+		if (chip->info->ops->get_eeprom)
+			mv88e6xxx_g2_eeprom_wait(chip);
 	}
 }

drivers/net/dsa/mv88e6xxx/global1.c+0−31

@@ -75,37 +75,6 @@ static int mv88e6xxx_g1_wait_init_ready(struct mv88e6xxx_chip *chip) · 74 unmodified lines
75	return mv88e6xxx_g1_wait_bit(chip, MV88E6XXX_G1_STS, bit, 1);	75	return mv88e6xxx_g1_wait_bit(chip, MV88E6XXX_G1_STS, bit, 1);
76	}	76	}
77		77
78	void mv88e6xxx_g1_wait_eeprom_done(struct mv88e6xxx_chip *chip)
79	{
80	const unsigned long timeout = jiffies + 1 * HZ;
81	u16 val;
82	int err;
83
84	/* Wait up to 1 second for the switch to finish reading the
85	* EEPROM.
86	*/
87	while (time_before(jiffies, timeout)) {
88	err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_STS, &val);
89	if (err) {
90	dev_err(chip->dev, "Error reading status");
91	return;
92	}
93
94	/* If the switch is still resetting, it may not
95	* respond on the bus, and so MDIO read returns
96	* 0xffff. Differentiate between that, and waiting for
97	* the EEPROM to be done by bit 0 being set.
98	*/
99	if (val != 0xffff &&
100	val & BIT(MV88E6XXX_G1_STS_IRQ_EEPROM_DONE))
101	return;
102
103	usleep_range(1000, 2000);
104	}
105
106	dev_err(chip->dev, "Timeout waiting for EEPROM done");
107	}
108
109	/* Offset 0x01: Switch MAC Address Register Bytes 0 & 1	78	/* Offset 0x01: Switch MAC Address Register Bytes 0 & 1
110	* Offset 0x02: Switch MAC Address Register Bytes 2 & 3	79	* Offset 0x02: Switch MAC Address Register Bytes 2 & 3
111	* Offset 0x03: Switch MAC Address Register Bytes 4 & 5	80	* Offset 0x03: Switch MAC Address Register Bytes 4 & 5

drivers/net/dsa/mv88e6xxx/global1.h+0−1

@@ -282,7 +282,6 @@ int mv88e6xxx_g1_set_switch_mac(struct mv88e6xxx_chip chip, u8 addr); · 281 unmodified lines
282	int mv88e6185_g1_reset(struct mv88e6xxx_chip *chip);	282	int mv88e6185_g1_reset(struct mv88e6xxx_chip *chip);
283	int mv88e6352_g1_reset(struct mv88e6xxx_chip *chip);	283	int mv88e6352_g1_reset(struct mv88e6xxx_chip *chip);
284	int mv88e6250_g1_reset(struct mv88e6xxx_chip *chip);	284	int mv88e6250_g1_reset(struct mv88e6xxx_chip *chip);
285	void mv88e6xxx_g1_wait_eeprom_done(struct mv88e6xxx_chip *chip);
286		285
287	int mv88e6185_g1_ppu_enable(struct mv88e6xxx_chip *chip);	286	int mv88e6185_g1_ppu_enable(struct mv88e6xxx_chip *chip);
288	int mv88e6185_g1_ppu_disable(struct mv88e6xxx_chip *chip);	287	int mv88e6185_g1_ppu_disable(struct mv88e6xxx_chip *chip);

drivers/net/dsa/mv88e6xxx/global2.c+1−1

@@ -340,7 +340,7 @@ int mv88e6xxx_g2_pot_clear(struct mv88e6xxx_chip *chip) · 339 unmodified lines
340	* Offset 0x15: EEPROM Addr (for 8-bit data access)	340	* Offset 0x15: EEPROM Addr (for 8-bit data access)
341	*/	341	*/
342		342
343	static int mv88e6xxx_g2_eeprom_wait(struct mv88e6xxx_chip *chip)	343	int mv88e6xxx_g2_eeprom_wait(struct mv88e6xxx_chip *chip)
344	{	344	{
345	int bit = __bf_shf(MV88E6XXX_G2_EEPROM_CMD_BUSY);	345	int bit = __bf_shf(MV88E6XXX_G2_EEPROM_CMD_BUSY);
346	int err;	346	int err;

drivers/net/dsa/mv88e6xxx/global2.h+1−0

@@ -365,6 +365,7 @@ int mv88e6xxx_g2_trunk_clear(struct mv88e6xxx_chip *chip); · 364 unmodified lines
365		365
366	int mv88e6xxx_g2_device_mapping_write(struct mv88e6xxx_chip *chip, int target,	366	int mv88e6xxx_g2_device_mapping_write(struct mv88e6xxx_chip *chip, int target,
367	int port);	367	int port);
		368	int mv88e6xxx_g2_eeprom_wait(struct mv88e6xxx_chip *chip);
368		369
369	extern const struct mv88e6xxx_irq_ops mv88e6097_watchdog_ops;	370	extern const struct mv88e6xxx_irq_ops mv88e6097_watchdog_ops;
370	extern const struct mv88e6xxx_irq_ops mv88e6250_watchdog_ops;	371	extern const struct mv88e6xxx_irq_ops mv88e6250_watchdog_ops;

drivers/net/ethernet/ibm/ibmveth.c+12−13

@@ -1303,24 +1303,23 @@ static void ibmveth_rx_csum_helper(struct sk_buff *skb, · 1302 unmodified lines
1303	* the user space for finding a flow. During this process, OVS computes	1303	* the user space for finding a flow. During this process, OVS computes
1304	* checksum on the first packet when CHECKSUM_PARTIAL flag is set.	1304	* checksum on the first packet when CHECKSUM_PARTIAL flag is set.
1305	*	1305	*
1306	* So, re-compute TCP pseudo header checksum when configured for	1306	* So, re-compute TCP pseudo header checksum.
1307	* trunk mode.
1308	*/	1307	*/
		1308
1309	if (iph_proto == IPPROTO_TCP) {	1309	if (iph_proto == IPPROTO_TCP) {
1310	struct tcphdr tcph = (struct tcphdr )(skb->data + iphlen);	1310	struct tcphdr tcph = (struct tcphdr )(skb->data + iphlen);
		1311
1311	if (tcph->check == 0x0000) {	1312	if (tcph->check == 0x0000) {
1312	/* Recompute TCP pseudo header checksum */	1313	/* Recompute TCP pseudo header checksum */
1313	if (adapter->is_active_trunk) {	1314	tcphdrlen = skb->len - iphlen;
1314	tcphdrlen = skb->len - iphlen;	1315	if (skb_proto == ETH_P_IP)
1315	if (skb_proto == ETH_P_IP)	1316	tcph->check =
1316	tcph->check =	1317	~csum_tcpudp_magic(iph->saddr,
1317	~csum_tcpudp_magic(iph->saddr,	1318	iph->daddr, tcphdrlen, iph_proto, 0);
1318	iph->daddr, tcphdrlen, iph_proto, 0);	1319	else if (skb_proto == ETH_P_IPV6)
1319	else if (skb_proto == ETH_P_IPV6)	1320	tcph->check =
1320	tcph->check =	1321	~csum_ipv6_magic(&iph6->saddr,
1321	~csum_ipv6_magic(&iph6->saddr,	1322	&iph6->daddr, tcphdrlen, iph_proto, 0);
1322	&iph6->daddr, tcphdrlen, iph_proto, 0);
1323	}
1324	/* Setup SKB fields for checksum offload */	1323	/* Setup SKB fields for checksum offload */
1325	skb_partial_csum_set(skb, iphlen,	1324	skb_partial_csum_set(skb, iphlen,
1326	offsetof(struct tcphdr, check));	1325	offsetof(struct tcphdr, check));

drivers/net/ethernet/intel/ice/ice_virtchnl.c+7−5

@@ -2655,12 +2655,14 @@ static int ice_vc_query_rxdid(struct ice_vf *vf) · 2654 unmodified lines
2655	goto err;	2655	goto err;
2656	}	2656	}
2657		2657
2658	/* Read flexiflag registers to determine whether the	2658	/* RXDIDs supported by DDP package can be read from the register
2659	* corresponding RXDID is configured and supported or not.	2659	* to get the supported RXDID bitmap. But the legacy 32byte RXDID
2660	* Since Legacy 16byte descriptor format is not supported,	2660	* is not listed in DDP package, add it in the bitmap manually.
2661	* start from Legacy 32byte descriptor.	2661	* Legacy 16byte descriptor is not supported.
2662	*/	2662	*/
2663	for (i = ICE_RXDID_LEGACY_1; i < ICE_FLEX_DESC_RXDID_MAX_NUM; i++) {	2663	rxdid->supported_rxdids \|= BIT(ICE_RXDID_LEGACY_1);
		2664
		2665	for (i = ICE_RXDID_FLEX_NIC; i < ICE_FLEX_DESC_RXDID_MAX_NUM; i++) {
2664	regval = rd32(hw, GLFLXP_RXDID_FLAGS(i, 0));	2666	regval = rd32(hw, GLFLXP_RXDID_FLAGS(i, 0));
2665	if ((regval >> GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_S)	2667	if ((regval >> GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_S)
2666	& GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_M)	2668	& GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_M)

drivers/net/ethernet/marvell/sky2.h+1−1

@@ -2195,7 +2195,7 @@ struct rx_ring_info { · 2194 unmodified lines
2195	struct sk_buff *skb;	2195	struct sk_buff *skb;
2196	dma_addr_t data_addr;	2196	dma_addr_t data_addr;
2197	DEFINE_DMA_UNMAP_LEN(data_size);	2197	DEFINE_DMA_UNMAP_LEN(data_size);
2198	dma_addr_t frag_addr[ETH_JUMBO_MTU >> PAGE_SHIFT];	2198	dma_addr_t frag_addr[ETH_JUMBO_MTU >> PAGE_SHIFT ?: 1];
2199	};	2199	};
2200		2200
2201	enum flow_control {	2201	enum flow_control {

drivers/net/ethernet/mediatek/mtk_eth_soc.c+2−2

 	eth->rx_events++;
 	if (likely(napi_schedule_prep(&eth->rx_napi))) {
-		__napi_schedule(&eth->rx_napi);
 		mtk_rx_irq_disable(eth, eth->soc->txrx.rx_irq_done_mask);
+		__napi_schedule(&eth->rx_napi);
 	}
 	return IRQ_HANDLED;
 	eth->tx_events++;
 	if (likely(napi_schedule_prep(&eth->tx_napi))) {
-		__napi_schedule(&eth->tx_napi);
 		mtk_tx_irq_disable(eth, MTK_TX_DONE_INT);
+		__napi_schedule(&eth->tx_napi);
 	}
 	return IRQ_HANDLED;

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

@@ -46,6 +46,7 @@ config LAN743X · 45 unmodified lines
46	tristate "LAN743x support"	46	tristate "LAN743x support"
47	depends on PCI	47	depends on PCI
48	depends on PTP_1588_CLOCK_OPTIONAL	48	depends on PTP_1588_CLOCK_OPTIONAL
		49	select PHYLIB
49	select FIXED_PHY	50	select FIXED_PHY
50	select CRC16	51	select CRC16
51	select CRC32	52	select CRC32

drivers/net/ethernet/microsoft/mana/mana_en.c+146−65

 	return 0;
 }
+static void mana_add_sge(struct mana_tx_package *tp, struct mana_skb_head *ash,
+			 int sg_i, dma_addr_t da, int sge_len, u32 gpa_mkey)
+{
+	ash->dma_handle[sg_i] = da;
+	ash->size[sg_i] = sge_len;
+	tp->wqe_req.sgl[sg_i].address = da;
+	tp->wqe_req.sgl[sg_i].mem_key = gpa_mkey;
+	tp->wqe_req.sgl[sg_i].size = sge_len;
+}
 static int mana_map_skb(struct sk_buff *skb, struct mana_port_context *apc,
-			struct mana_tx_package *tp)
+			struct mana_tx_package *tp, int gso_hs)
 {
 	struct mana_skb_head *ash = (struct mana_skb_head *)skb->head;
+	int hsg = 1; /* num of SGEs of linear part */
 	struct gdma_dev *gd = apc->ac->gdma_dev;
+	int skb_hlen = skb_headlen(skb);
+	int sge0_len, sge1_len = 0;
 	struct gdma_context *gc;
 	struct device *dev;
 	skb_frag_t *frag;
 	dma_addr_t da;
+	int sg_i;
 	int i;
 	gc = gd->gdma_context;
 	dev = gc->dev;
-	da = dma_map_single(dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
+	if (gso_hs && gso_hs < skb_hlen) {
+		sge0_len = gso_hs;
+		sge1_len = skb_hlen - gso_hs;
+	} else {
+		sge0_len = skb_hlen;
+	}
+	da = dma_map_single(dev, skb->data, sge0_len, DMA_TO_DEVICE);
 	if (dma_mapping_error(dev, da))
 		return -ENOMEM;
-	ash->dma_handle[0] = da;
+	mana_add_sge(tp, ash, 0, da, sge0_len, gd->gpa_mkey);
-	ash->size[0] = skb_headlen(skb);
-	tp->wqe_req.sgl[0].address = ash->dma_handle[0];
+	if (sge1_len) {
-	tp->wqe_req.sgl[0].mem_key = gd->gpa_mkey;
+		sg_i = 1;
-	tp->wqe_req.sgl[0].size = ash->size[0];
+		da = dma_map_single(dev, skb->data + sge0_len, sge1_len,
+				    DMA_TO_DEVICE);
+		if (dma_mapping_error(dev, da))
+			goto frag_err;
+		mana_add_sge(tp, ash, sg_i, da, sge1_len, gd->gpa_mkey);
+		hsg = 2;
+	}
 	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+		sg_i = hsg + i;
 		frag = &skb_shinfo(skb)->frags[i];
 		da = skb_frag_dma_map(dev, frag, 0, skb_frag_size(frag),
 				      DMA_TO_DEVICE);
 		if (dma_mapping_error(dev, da))
 			goto frag_err;
-		ash->dma_handle[i + 1] = da;
+		mana_add_sge(tp, ash, sg_i, da, skb_frag_size(frag),
-		ash->size[i + 1] = skb_frag_size(frag);
+			     gd->gpa_mkey);
-		tp->wqe_req.sgl[i + 1].address = ash->dma_handle[i + 1];
-		tp->wqe_req.sgl[i + 1].mem_key = gd->gpa_mkey;
-		tp->wqe_req.sgl[i + 1].size = ash->size[i + 1];
 	}
 	return 0;
 frag_err:
-	for (i = i - 1; i >= 0; i--)
+	for (i = sg_i - 1; i >= hsg; i--)
-		dma_unmap_page(dev, ash->dma_handle[i + 1], ash->size[i + 1],
+		dma_unmap_page(dev, ash->dma_handle[i], ash->size[i],
 			       DMA_TO_DEVICE);
-	dma_unmap_single(dev, ash->dma_handle[0], ash->size[0], DMA_TO_DEVICE);
+	for (i = hsg - 1; i >= 0; i--)
+		dma_unmap_single(dev, ash->dma_handle[i], ash->size[i],
+				 DMA_TO_DEVICE);
 	return -ENOMEM;
 }
+/* Handle the case when GSO SKB linear length is too large.
+ * MANA NIC requires GSO packets to put only the packet header to SGE0.
+ * So, we need 2 SGEs for the skb linear part which contains more than the
+ * header.
+ * Return a positive value for the number of SGEs, or a negative value
+ * for an error.
+ */
+static int mana_fix_skb_head(struct net_device *ndev, struct sk_buff *skb,
+			     int gso_hs)
+{
+	int num_sge = 1 + skb_shinfo(skb)->nr_frags;
+	int skb_hlen = skb_headlen(skb);
+	if (gso_hs < skb_hlen) {
+		num_sge++;
+	} else if (gso_hs > skb_hlen) {
+		if (net_ratelimit())
+			netdev_err(ndev,
+				   "TX nonlinear head: hs:%d, skb_hlen:%d\n",
+				   gso_hs, skb_hlen);
+		return -EINVAL;
+	}
+	return num_sge;
+}
+/* Get the GSO packet's header size */
+static int mana_get_gso_hs(struct sk_buff *skb)
+{
+	int gso_hs;
+	if (skb->encapsulation) {
+		gso_hs = skb_inner_tcp_all_headers(skb);
+	} else {
+		if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4) {
+			gso_hs = skb_transport_offset(skb) +
+				 sizeof(struct udphdr);
+		} else {
+			gso_hs = skb_tcp_all_headers(skb);
+		}
+	}
+	return gso_hs;
+}
 netdev_tx_t mana_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 {
 	enum mana_tx_pkt_format pkt_fmt = MANA_SHORT_PKT_FMT;
 	struct mana_port_context *apc = netdev_priv(ndev);
+	int gso_hs = 0; /* zero for non-GSO pkts */
 	u16 txq_idx = skb_get_queue_mapping(skb);
 	struct gdma_dev *gd = apc->ac->gdma_dev;
 	bool ipv4 = false, ipv6 = false;
 	struct mana_txq *txq;
 	struct mana_cq *cq;
 	int err, len;
-	u16 ihs;
 	if (unlikely(!apc->port_is_up))
 		goto tx_drop;
 	pkg.wqe_req.client_data_unit = 0;
 	pkg.wqe_req.num_sge = 1 + skb_shinfo(skb)->nr_frags;
-	WARN_ON_ONCE(pkg.wqe_req.num_sge > MAX_TX_WQE_SGL_ENTRIES);
-	if (pkg.wqe_req.num_sge <= ARRAY_SIZE(pkg.sgl_array)) {
-		pkg.wqe_req.sgl = pkg.sgl_array;
-	} else {
-		pkg.sgl_ptr = kmalloc_array(pkg.wqe_req.num_sge,
-					    sizeof(struct gdma_sge),
-					    GFP_ATOMIC);
-		if (!pkg.sgl_ptr)
-			goto tx_drop_count;
-		pkg.wqe_req.sgl = pkg.sgl_ptr;
-	}
 	if (skb->protocol == htons(ETH_P_IP))
 		ipv4 = true;
 		ipv6 = true;
 	if (skb_is_gso(skb)) {
+		int num_sge;
+		gso_hs = mana_get_gso_hs(skb);
+		num_sge = mana_fix_skb_head(ndev, skb, gso_hs);
+		if (num_sge > 0)
+			pkg.wqe_req.num_sge = num_sge;
+		else
+			goto tx_drop_count;
+		u64_stats_update_begin(&tx_stats->syncp);
+		if (skb->encapsulation) {
+			tx_stats->tso_inner_packets++;
+			tx_stats->tso_inner_bytes += skb->len - gso_hs;
+		} else {
+			tx_stats->tso_packets++;
+			tx_stats->tso_bytes += skb->len - gso_hs;
+		}
+		u64_stats_update_end(&tx_stats->syncp);
 		pkg.tx_oob.s_oob.is_outer_ipv4 = ipv4;
 		pkg.tx_oob.s_oob.is_outer_ipv6 = ipv6;
 						 &ipv6_hdr(skb)->daddr, 0,
 						 IPPROTO_TCP, 0);
 		}
-		if (skb->encapsulation) {
-			ihs = skb_inner_tcp_all_headers(skb);
-			u64_stats_update_begin(&tx_stats->syncp);
-			tx_stats->tso_inner_packets++;
-			tx_stats->tso_inner_bytes += skb->len - ihs;
-			u64_stats_update_end(&tx_stats->syncp);
-		} else {
-			if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4) {
-				ihs = skb_transport_offset(skb) + sizeof(struct udphdr);
-			} else {
-				ihs = skb_tcp_all_headers(skb);
-				if (ipv6_has_hopopt_jumbo(skb))
-					ihs -= sizeof(struct hop_jumbo_hdr);
-			}
-			u64_stats_update_begin(&tx_stats->syncp);
-			tx_stats->tso_packets++;
-			tx_stats->tso_bytes += skb->len - ihs;
-			u64_stats_update_end(&tx_stats->syncp);
-		}
 	} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
 		csum_type = mana_checksum_info(skb);
 		} else {
 			/* Can't do offload of this type of checksum */
 			if (skb_checksum_help(skb))
-				goto free_sgl_ptr;
+				goto tx_drop_count;
 		}
 	}
-	if (mana_map_skb(skb, apc, &pkg)) {
+	WARN_ON_ONCE(pkg.wqe_req.num_sge > MAX_TX_WQE_SGL_ENTRIES);
+	if (pkg.wqe_req.num_sge <= ARRAY_SIZE(pkg.sgl_array)) {
+		pkg.wqe_req.sgl = pkg.sgl_array;
+	} else {
+		pkg.sgl_ptr = kmalloc_array(pkg.wqe_req.num_sge,
+					    sizeof(struct gdma_sge),
+					    GFP_ATOMIC);
+		if (!pkg.sgl_ptr)
+			goto tx_drop_count;
+		pkg.wqe_req.sgl = pkg.sgl_ptr;
+	}
+	if (mana_map_skb(skb, apc, &pkg, gso_hs)) {
 		u64_stats_update_begin(&tx_stats->syncp);
 		tx_stats->mana_map_err++;
 		u64_stats_update_end(&tx_stats->syncp);
 	struct mana_skb_head *ash = (struct mana_skb_head *)skb->head;
 	struct gdma_context *gc = apc->ac->gdma_dev->gdma_context;
 	struct device *dev = gc->dev;
-	int i;
+	int hsg, i;
-	dma_unmap_single(dev, ash->dma_handle[0], ash->size[0], DMA_TO_DEVICE);
+	/* Number of SGEs of linear part */
+	hsg = (skb_is_gso(skb) && skb_headlen(skb) > ash->size[0]) ? 2 : 1;
-	for (i = 1; i < skb_shinfo(skb)->nr_frags + 1; i++)
+	for (i = 0; i < hsg; i++)
+		dma_unmap_single(dev, ash->dma_handle[i], ash->size[i],
+				 DMA_TO_DEVICE);
+	for (i = hsg; i < skb_shinfo(skb)->nr_frags + hsg; i++)
 		dma_unmap_page(dev, ash->dma_handle[i], ash->size[i],
 			       DMA_TO_DEVICE);
 }
 		case CQE_TX_VPORT_IDX_OUT_OF_RANGE:
 		case CQE_TX_VPORT_DISABLED:
 		case CQE_TX_VLAN_TAGGING_VIOLATION:
-			WARN_ONCE(1, "TX: CQE error %d: ignored.\n",
+			if (net_ratelimit())
-				  cqe_oob->cqe_hdr.cqe_type);
+				netdev_err(ndev, "TX: CQE error %d\n",
+					   cqe_oob->cqe_hdr.cqe_type);
 			apc->eth_stats.tx_cqe_err++;
 			break;
 		default:
-			/* If the CQE type is unexpected, log an error, assert,
+			/* If the CQE type is unknown, log an error,
-			 * and go through the error path.
+			 * and still free the SKB, update tail, etc.
 			 */
-			WARN_ONCE(1, "TX: Unexpected CQE type %d: HW BUG?\n",
+			if (net_ratelimit())
-				  cqe_oob->cqe_hdr.cqe_type);
+				netdev_err(ndev, "TX: unknown CQE type %d\n",
+					   cqe_oob->cqe_hdr.cqe_type);
 			apc->eth_stats.tx_cqe_unknown_type++;
-			return;
+			break;
 		}
 		if (WARN_ON_ONCE(txq->gdma_txq_id != completions[i].wq_num))

drivers/net/ethernet/qlogic/qed/qed_ll2.h+1−1

 	enum core_tx_dest tx_dest;
 	u8 tx_stats_en;
 	bool main_func_queue;
+	struct qed_ll2_cbs cbs;
 	struct qed_ll2_rx_queue rx_queue;
 	struct qed_ll2_tx_queue tx_queue;
-	struct qed_ll2_cbs cbs;
 };
 extern const struct qed_ll2_ops qed_ll2_ops_pass;

drivers/net/ethernet/renesas/rswitch.c+12−1

  * Copyright (C) 2022 Renesas Electronics Corporation
  */
+#include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/err.h>
 #include <linux/etherdevice.h>
 static void rswitch_etha_enable_mii(struct rswitch_etha *etha)
 {
 	rswitch_modify(etha->addr, MPIC, MPIC_PSMCS_MASK | MPIC_PSMHT_MASK,
-		       MPIC_PSMCS(0x05) | MPIC_PSMHT(0x06));
+		       MPIC_PSMCS(etha->psmcs) | MPIC_PSMHT(0x06));
 	rswitch_modify(etha->addr, MPSM, 0, MPSM_MFF_C45);
 }
 	etha->index = index;
 	etha->addr = priv->addr + RSWITCH_ETHA_OFFSET + index * RSWITCH_ETHA_SIZE;
 	etha->coma_addr = priv->addr;
+	/* MPIC.PSMCS = (clk [MHz] / (MDC frequency [MHz] * 2) - 1.
+	 * Calculating PSMCS value as MDC frequency = 2.5MHz. So, multiply
+	 * both the numerator and the denominator by 10.
+	 */
+	etha->psmcs = clk_get_rate(priv->clk) / 100000 / (25 * 2) - 1;
 }
 static int rswitch_device_alloc(struct rswitch_private *priv, int index)
 		return -ENOMEM;
 	spin_lock_init(&priv->lock);
+	priv->clk = devm_clk_get(&pdev->dev, NULL);
+	if (IS_ERR(priv->clk))
+		return PTR_ERR(priv->clk);
 	attr = soc_device_match(rswitch_soc_no_speed_change);
 	if (attr)
 		priv->etha_no_runtime_change = true;

drivers/net/ethernet/renesas/rswitch.h+2−0

 	bool external_phy;
 	struct mii_bus *mii;
 	phy_interface_t phy_interface;
+	u32 psmcs;
 	u8 mac_addr[MAX_ADDR_LEN];
 	int link;
 	int speed;
 	struct rswitch_mfwd mfwd;
 	spinlock_t lock;	/* lock interrupt registers' control */
+	struct clk *clk;
 	bool etha_no_runtime_change;
 	bool gwca_halt;

drivers/net/ethernet/stmicro/stmmac/dwmac-stm32.c+5−2

 	int (*parse_data)(struct stm32_dwmac *dwmac,
 			  struct device *dev);
 	u32 syscfg_eth_mask;
+	bool clk_rx_enable_in_suspend;
 };
 static int stm32_dwmac_init(struct plat_stmmacenet_data *plat_dat)
 	if (ret)
 		return ret;
-	if (!dwmac->dev->power.is_suspended) {
+	if (!dwmac->ops->clk_rx_enable_in_suspend ||
+	    !dwmac->dev->power.is_suspended) {
 		ret = clk_prepare_enable(dwmac->clk_rx);
 		if (ret) {
 			clk_disable_unprepare(dwmac->clk_tx);
 	.suspend = stm32mp1_suspend,
 	.resume = stm32mp1_resume,
 	.parse_data = stm32mp1_parse_data,
-	.syscfg_eth_mask = SYSCFG_MP1_ETH_MASK
+	.syscfg_eth_mask = SYSCFG_MP1_ETH_MASK,
+	.clk_rx_enable_in_suspend = true
 };
 static const struct of_device_id stm32_dwmac_match[] = {

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+0−30

@@ -6012,33 +6012,6 @@ static irqreturn_t stmmac_msi_intr_rx(int irq, void *data) · 6011 unmodified lines
6012	return IRQ_HANDLED;	6012	return IRQ_HANDLED;
6013	}	6013	}
6014		6014
6015	#ifdef CONFIG_NET_POLL_CONTROLLER
6016	/* Polling receive - used by NETCONSOLE and other diagnostic tools
6017	* to allow network I/O with interrupts disabled.
6018	*/
6019	static void stmmac_poll_controller(struct net_device *dev)
6020	{
6021	struct stmmac_priv *priv = netdev_priv(dev);
6022	int i;
6023
6024	/* If adapter is down, do nothing */
6025	if (test_bit(STMMAC_DOWN, &priv->state))
6026	return;
6027
6028	if (priv->plat->flags & STMMAC_FLAG_MULTI_MSI_EN) {
6029	for (i = 0; i < priv->plat->rx_queues_to_use; i++)
6030	stmmac_msi_intr_rx(0, &priv->dma_conf.rx_queue[i]);
6031
6032	for (i = 0; i < priv->plat->tx_queues_to_use; i++)
6033	stmmac_msi_intr_tx(0, &priv->dma_conf.tx_queue[i]);
6034	} else {
6035	disable_irq(dev->irq);
6036	stmmac_interrupt(dev->irq, dev);
6037	enable_irq(dev->irq);
6038	}
6039	}
6040	#endif
6041
6042	/**	6015	/**
6043	* stmmac_ioctl - Entry point for the Ioctl	6016	* stmmac_ioctl - Entry point for the Ioctl
6044	* @dev: Device pointer.	6017	* @dev: Device pointer.
@@ -6999,9 +6972,6 @@ static const struct net_device_ops stmmac_netdev_ops = { · 954 unmodified lines
6999	.ndo_get_stats64 = stmmac_get_stats64,	6972	.ndo_get_stats64 = stmmac_get_stats64,
7000	.ndo_setup_tc = stmmac_setup_tc,	6973	.ndo_setup_tc = stmmac_setup_tc,
7001	.ndo_select_queue = stmmac_select_queue,	6974	.ndo_select_queue = stmmac_select_queue,
7002	#ifdef CONFIG_NET_POLL_CONTROLLER
7003	.ndo_poll_controller = stmmac_poll_controller,
7004	#endif
7005	.ndo_set_mac_address = stmmac_set_mac_address,	6975	.ndo_set_mac_address = stmmac_set_mac_address,
7006	.ndo_vlan_rx_add_vid = stmmac_vlan_rx_add_vid,	6976	.ndo_vlan_rx_add_vid = stmmac_vlan_rx_add_vid,
7007	.ndo_vlan_rx_kill_vid = stmmac_vlan_rx_kill_vid,	6977	.ndo_vlan_rx_kill_vid = stmmac_vlan_rx_kill_vid,

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

@@ -874,7 +874,7 @@ static int __maybe_unused stmmac_pltfr_resume(struct device *dev) · 873 unmodified lines
874	struct platform_device *pdev = to_platform_device(dev);	874	struct platform_device *pdev = to_platform_device(dev);
875	int ret;	875	int ret;
876		876
877	ret = stmmac_pltfr_init(pdev, priv->plat->bsp_priv);	877	ret = stmmac_pltfr_init(pdev, priv->plat);
878	if (ret)	878	if (ret)
879	return ret;	879	return ret;
880		880

drivers/net/ethernet/ti/am65-cpsw-nuss.c+2−1

 		}
 		tx_chn->irq = k3_udma_glue_tx_get_irq(tx_chn->tx_chn);
-		if (tx_chn->irq <= 0) {
+		if (tx_chn->irq < 0) {
 			dev_err(dev, "Failed to get tx dma irq %d\n",
 				tx_chn->irq);
+			ret = tx_chn->irq;
 			goto err;
 		}

drivers/net/ethernet/ti/icssg/icssg_prueth.c+3−3

 			goto fail;
 		}
-		tx_chn->irq = k3_udma_glue_tx_get_irq(tx_chn->tx_chn);
+		ret = k3_udma_glue_tx_get_irq(tx_chn->tx_chn);
-		if (tx_chn->irq <= 0) {
+		if (ret < 0) {
-			ret = -EINVAL;
 			netdev_err(ndev, "failed to get tx irq\n");
 			goto fail;
 		}
+		tx_chn->irq = ret;
 		snprintf(tx_chn->name, sizeof(tx_chn->name), "%s-tx%d",
 			 dev_name(dev), tx_chn->id);

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

 	ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
 		 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 		 0, index, &buf, 4);
-	if (unlikely(ret < 0)) {
+	if (unlikely(ret < 4)) {
+		ret = ret < 0 ? ret : -ENODATA;
 		netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
 			    index, ret);
 		return ret;

drivers/net/wan/fsl_ucc_hdlc.c+10−2

@@ -34,6 +34,8 @@ · 33 unmodified lines
34	#define TDM_PPPOHT_SLIC_MAXIN	34	#define TDM_PPPOHT_SLIC_MAXIN
35	#define RX_BD_ERRORS (R_CD_S \| R_OV_S \| R_CR_S \| R_AB_S \| R_NO_S \| R_LG_S)	35	#define RX_BD_ERRORS (R_CD_S \| R_OV_S \| R_CR_S \| R_AB_S \| R_NO_S \| R_LG_S)
36		36
		37	static int uhdlc_close(struct net_device *dev);
		38
37	static struct ucc_tdm_info utdm_primary_info = {	39	static struct ucc_tdm_info utdm_primary_info = {
38	.uf_info = {	40	.uf_info = {
39	.tsa = 0,	41	.tsa = 0,
@@ -708,6 +710,7 @@ static int uhdlc_open(struct net_device *dev) · 668 unmodified lines
708	hdlc_device *hdlc = dev_to_hdlc(dev);	710	hdlc_device *hdlc = dev_to_hdlc(dev);
709	struct ucc_hdlc_private *priv = hdlc->priv;	711	struct ucc_hdlc_private *priv = hdlc->priv;
710	struct ucc_tdm *utdm = priv->utdm;	712	struct ucc_tdm *utdm = priv->utdm;
		713	int rc = 0;
711		714
712	if (priv->hdlc_busy != 1) {	715	if (priv->hdlc_busy != 1) {
713	if (request_irq(priv->ut_info->uf_info.irq,	716	if (request_irq(priv->ut_info->uf_info.irq,
@@ -731,10 +734,13 @@ static int uhdlc_open(struct net_device *dev) · 17 unmodified lines
731	napi_enable(&priv->napi);	734	napi_enable(&priv->napi);
732	netdev_reset_queue(dev);	735	netdev_reset_queue(dev);
733	netif_start_queue(dev);	736	netif_start_queue(dev);
734	hdlc_open(dev);	737
		738	rc = hdlc_open(dev);
		739	if (rc)
		740	uhdlc_close(dev);
735	}	741	}
736		742
737	return 0;	743	return rc;
738	}	744	}
739		745
740	static void uhdlc_memclean(struct ucc_hdlc_private *priv)	746	static void uhdlc_memclean(struct ucc_hdlc_private *priv)
@@ -824,6 +830,8 @@ static int uhdlc_close(struct net_device *dev) · 83 unmodified lines
824	netdev_reset_queue(dev);	830	netdev_reset_queue(dev);
825	priv->hdlc_busy = 0;	831	priv->hdlc_busy = 0;
826		832
		833	hdlc_close(dev);
		834
827	return 0;	835	return 0;
828	}	836	}
829		837

drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwil_types.h+7−2

 				 * fixed parameter portion is assumed, otherwise
 				 * ssid in the fixed portion is ignored
 				 */
-	__le16 channel_list[1];	/* list of chanspecs */
+	union {
+		__le16 padding;	/* Reserve space for at least 1 entry for abort
+				 * which uses an on stack brcmf_scan_params_v2_le
+				 */
+		DECLARE_FLEX_ARRAY(__le16, channel_list);	/* chanspecs */
+	};
 };
 struct brcmf_scan_results {
 struct brcmf_chanspec_list {
 	__le32	count;		/* # of entries */
-	__le32	element[1];	/* variable length uint32 list */
+	__le32  element[];	/* variable length uint32 list */
 };
 /*

drivers/net/wireless/intel/iwlwifi/fw/error-dump.h+3−3

@@ -310,9 +310,9 @@ struct iwl_fw_ini_fifo_hdr { · 309 unmodified lines
310	struct iwl_fw_ini_error_dump_range {	310	struct iwl_fw_ini_error_dump_range {
311	__le32 range_data_size;	311	__le32 range_data_size;
312	union {	312	union {
313	__le32 internal_base_addr;	313	__le32 internal_base_addr __packed;
314	__le64 dram_base_addr;	314	__le64 dram_base_addr __packed;
315	__le32 page_num;	315	__le32 page_num __packed;
316	struct iwl_fw_ini_fifo_hdr fifo_hdr;	316	struct iwl_fw_ini_fifo_hdr fifo_hdr;
317	struct iwl_cmd_header fw_pkt_hdr;	317	struct iwl_cmd_header fw_pkt_hdr;
318	};	318	};

drivers/net/wireless/intel/iwlwifi/mvm/fw.c+1−1

@@ -802,7 +802,7 @@ out: · 801 unmodified lines
802	mvm->nvm_data->bands[0].n_channels = 1;	802	mvm->nvm_data->bands[0].n_channels = 1;
803	mvm->nvm_data->bands[0].n_bitrates = 1;	803	mvm->nvm_data->bands[0].n_bitrates = 1;
804	mvm->nvm_data->bands[0].bitrates =	804	mvm->nvm_data->bands[0].bitrates =
805	(void )((u8 )mvm->nvm_data->channels + 1);	805	(void *)(mvm->nvm_data->channels + 1);
806	mvm->nvm_data->bands[0].bitrates->hw_value = 10;	806	mvm->nvm_data->bands[0].bitrates->hw_value = 10;
807	}	807	}
808		808

drivers/net/wireless/intel/iwlwifi/mvm/mld-mac80211.c+63−58

@@ -731,73 +731,78 @@ static void iwl_mvm_mld_vif_cfg_changed_station(struct iwl_mvm *mvm, · 730 unmodified lines
731		731
732	mvmvif->associated = vif->cfg.assoc;	732	mvmvif->associated = vif->cfg.assoc;
733		733
734	if (!(changes & BSS_CHANGED_ASSOC))	734	if (changes & BSS_CHANGED_ASSOC) {
735	return;	735	if (vif->cfg.assoc) {
736		736	/* clear statistics to get clean beacon counter */
737	if (vif->cfg.assoc) {	737	iwl_mvm_request_statistics(mvm, true);
738	/* clear statistics to get clean beacon counter */	738	iwl_mvm_sf_update(mvm, vif, false);
739	iwl_mvm_request_statistics(mvm, true);	739	iwl_mvm_power_vif_assoc(mvm, vif);
740	iwl_mvm_sf_update(mvm, vif, false);	740
741	iwl_mvm_power_vif_assoc(mvm, vif);	741	for_each_mvm_vif_valid_link(mvmvif, i) {
742		742	memset(&mvmvif->link[i]->beacon_stats, 0,
743	for_each_mvm_vif_valid_link(mvmvif, i) {	743	sizeof(mvmvif->link[i]->beacon_stats));
744	memset(&mvmvif->link[i]->beacon_stats, 0,	744
745	sizeof(mvmvif->link[i]->beacon_stats));	745	if (vif->p2p) {
		746	iwl_mvm_update_smps(mvm, vif,
		747	IWL_MVM_SMPS_REQ_PROT,
		748	IEEE80211_SMPS_DYNAMIC, i);
		749	}
		750
		751	rcu_read_lock();
		752	link_conf = rcu_dereference(vif->link_conf[i]);
		753	if (link_conf && !link_conf->dtim_period)
		754	protect = true;
		755	rcu_read_unlock();
		756	}
746		757
747	if (vif->p2p) {	758	if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
748	iwl_mvm_update_smps(mvm, vif,	759	protect) {
749	IWL_MVM_SMPS_REQ_PROT,	760	/* If we're not restarting and still haven't
750	IEEE80211_SMPS_DYNAMIC, i);	761	* heard a beacon (dtim period unknown) then
		762	* make sure we still have enough minimum time
		763	* remaining in the time event, since the auth
		764	* might actually have taken quite a while
		765	* (especially for SAE) and so the remaining
		766	* time could be small without us having heard
		767	* a beacon yet.
		768	*/
		769	iwl_mvm_protect_assoc(mvm, vif, 0);
751	}	770	}
752		771
753	rcu_read_lock();	772	iwl_mvm_sf_update(mvm, vif, false);
754	link_conf = rcu_dereference(vif->link_conf[i]);	773
755	if (link_conf && !link_conf->dtim_period)	774	/* FIXME: need to decide about misbehaving AP handling */
756	protect = true;	775	iwl_mvm_power_vif_assoc(mvm, vif);
757	rcu_read_unlock();	776	} else if (iwl_mvm_mld_vif_have_valid_ap_sta(mvmvif)) {
758	}	777	iwl_mvm_mei_host_disassociated(mvm);
759		778
760	if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&	779	/* If update fails - SF might be running in associated
761	protect) {	780	* mode while disassociated - which is forbidden.
762	/* If we're not restarting and still haven't
763	* heard a beacon (dtim period unknown) then
764	* make sure we still have enough minimum time
765	* remaining in the time event, since the auth
766	* might actually have taken quite a while
767	* (especially for SAE) and so the remaining
768	* time could be small without us having heard
769	* a beacon yet.
770	*/	781	*/
771	iwl_mvm_protect_assoc(mvm, vif, 0);	782	ret = iwl_mvm_sf_update(mvm, vif, false);
		783	WARN_ONCE(ret &&
		784	!test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
		785	&mvm->status),
		786	"Failed to update SF upon disassociation\n");
		787
		788	/* If we get an assert during the connection (after the
		789	* station has been added, but before the vif is set
		790	* to associated), mac80211 will re-add the station and
		791	* then configure the vif. Since the vif is not
		792	* associated, we would remove the station here and
		793	* this would fail the recovery.
		794	*/
		795	iwl_mvm_mld_vif_delete_all_stas(mvm, vif);
772	}	796	}
773		797
774	iwl_mvm_sf_update(mvm, vif, false);	798	iwl_mvm_bss_info_changed_station_assoc(mvm, vif, changes);
775
776	/* FIXME: need to decide about misbehaving AP handling */
777	iwl_mvm_power_vif_assoc(mvm, vif);
778	} else if (iwl_mvm_mld_vif_have_valid_ap_sta(mvmvif)) {
779	iwl_mvm_mei_host_disassociated(mvm);
780
781	/* If update fails - SF might be running in associated
782	* mode while disassociated - which is forbidden.
783	*/
784	ret = iwl_mvm_sf_update(mvm, vif, false);
785	WARN_ONCE(ret &&
786	!test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
787	&mvm->status),
788	"Failed to update SF upon disassociation\n");
789
790	/* If we get an assert during the connection (after the
791	* station has been added, but before the vif is set
792	* to associated), mac80211 will re-add the station and
793	* then configure the vif. Since the vif is not
794	* associated, we would remove the station here and
795	* this would fail the recovery.
796	*/
797	iwl_mvm_mld_vif_delete_all_stas(mvm, vif);
798	}	799	}
799		800
800	iwl_mvm_bss_info_changed_station_assoc(mvm, vif, changes);	801	if (changes & BSS_CHANGED_PS) {
		802	ret = iwl_mvm_power_update_mac(mvm);
		803	if (ret)
		804	IWL_ERR(mvm, "failed to update power mode\n");
		805	}
801	}	806	}
802		807
803	static void	808	static void

drivers/net/wireless/intel/iwlwifi/mvm/scan.c+1−1

@@ -2342,7 +2342,7 @@ iwl_mvm_scan_umac_fill_general_p_v12(struct iwl_mvm *mvm, · 2341 unmodified lines
2342	if (gen_flags & IWL_UMAC_SCAN_GEN_FLAGS_V2_FRAGMENTED_LMAC2)	2342	if (gen_flags & IWL_UMAC_SCAN_GEN_FLAGS_V2_FRAGMENTED_LMAC2)
2343	gp->num_of_fragments[SCAN_HB_LMAC_IDX] = IWL_SCAN_NUM_OF_FRAGS;	2343	gp->num_of_fragments[SCAN_HB_LMAC_IDX] = IWL_SCAN_NUM_OF_FRAGS;
2344		2344
2345	if (version < 12) {	2345	if (version < 16) {
2346	gp->scan_start_mac_or_link_id = scan_vif->id;	2346	gp->scan_start_mac_or_link_id = scan_vif->id;
2347	} else {	2347	} else {
2348	struct iwl_mvm_vif_link_info *link_info;	2348	struct iwl_mvm_vif_link_info *link_info;

drivers/net/wireless/intel/iwlwifi/mvm/tx.c+3−0

 		iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
 		memset(&info->status, 0, sizeof(info->status));
+		info->flags &= ~(IEEE80211_TX_STAT_ACK | IEEE80211_TX_STAT_TX_FILTERED);
 		/* inform mac80211 about what happened with the frame */
 		switch (status & TX_STATUS_MSK) {
 		 */
 		if (!is_flush)
 			info->flags |= IEEE80211_TX_STAT_ACK;
+		else
+			info->flags &= ~IEEE80211_TX_STAT_ACK;
 	}
 	/*

drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c+19−3

 	mwifiex_dbg_dump(priv->adapter, EVT_D, "RXBA_SYNC event:",
 			 event_buf, len);
-	while (tlv_buf_left >= sizeof(*tlv_rxba)) {
+	while (tlv_buf_left > sizeof(*tlv_rxba)) {
 		tlv_type = le16_to_cpu(tlv_rxba->header.type);
 		tlv_len  = le16_to_cpu(tlv_rxba->header.len);
+		if (size_add(sizeof(tlv_rxba->header), tlv_len) > tlv_buf_left) {
+			mwifiex_dbg(priv->adapter, WARN,
+				    "TLV size (%zu) overflows event_buf buf_left=%d\n",
+				    size_add(sizeof(tlv_rxba->header), tlv_len),
+				    tlv_buf_left);
+			return;
+		}
 		if (tlv_type != TLV_TYPE_RXBA_SYNC) {
 			mwifiex_dbg(priv->adapter, ERROR,
 				    "Wrong TLV id=0x%x\n", tlv_type);
 		tlv_seq_num = le16_to_cpu(tlv_rxba->seq_num);
 		tlv_bitmap_len = le16_to_cpu(tlv_rxba->bitmap_len);
+		if (size_add(sizeof(*tlv_rxba), tlv_bitmap_len) > tlv_buf_left) {
+			mwifiex_dbg(priv->adapter, WARN,
+				    "TLV size (%zu) overflows event_buf buf_left=%d\n",
+				    size_add(sizeof(*tlv_rxba), tlv_bitmap_len),
+				    tlv_buf_left);
+			return;
+		}
 		mwifiex_dbg(priv->adapter, INFO,
 			    "%pM tid=%d seq_num=%d bitmap_len=%d\n",
 			    tlv_rxba->mac, tlv_rxba->tid, tlv_seq_num,
 			}
 		}
-		tlv_buf_left -= (sizeof(*tlv_rxba) + tlv_len);
+		tlv_buf_left -= (sizeof(tlv_rxba->header) + tlv_len);
-		tmp = (u8 *)tlv_rxba + tlv_len + sizeof(*tlv_rxba);
+		tmp = (u8 *)tlv_rxba  + sizeof(tlv_rxba->header) + tlv_len;
 		tlv_rxba = (struct mwifiex_ie_types_rxba_sync *)tmp;
 	}
 }

drivers/net/wireless/marvell/mwifiex/fw.h+1−1

@@ -779,7 +779,7 @@ struct mwifiex_ie_types_rxba_sync { · 778 unmodified lines
779	u8 reserved;	779	u8 reserved;
780	__le16 seq_num;	780	__le16 seq_num;
781	__le16 bitmap_len;	781	__le16 bitmap_len;
782	u8 bitmap[1];	782	u8 bitmap[];
783	} __packed;	783	} __packed;
784		784
785	struct chan_band_param_set {	785	struct chan_band_param_set {

drivers/net/wireless/marvell/mwifiex/sta_rx.c+9−7

 	rx_pkt_len = le16_to_cpu(local_rx_pd->rx_pkt_length);
 	rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_off;
-	if (sizeof(*rx_pkt_hdr) + rx_pkt_off > skb->len) {
+	if (sizeof(rx_pkt_hdr->eth803_hdr) + sizeof(rfc1042_header) +
+	    rx_pkt_off > skb->len) {
 		mwifiex_dbg(priv->adapter, ERROR,
 			    "wrong rx packet offset: len=%d, rx_pkt_off=%d\n",
 			    skb->len, rx_pkt_off);
 		return -1;
 	}
-	if ((!memcmp(&rx_pkt_hdr->rfc1042_hdr, bridge_tunnel_header,
+	if (sizeof(*rx_pkt_hdr) + rx_pkt_off <= skb->len &&
-		     sizeof(bridge_tunnel_header))) ||
+	    ((!memcmp(&rx_pkt_hdr->rfc1042_hdr, bridge_tunnel_header,
-	    (!memcmp(&rx_pkt_hdr->rfc1042_hdr, rfc1042_header,
+		      sizeof(bridge_tunnel_header))) ||
-		     sizeof(rfc1042_header)) &&
+	     (!memcmp(&rx_pkt_hdr->rfc1042_hdr, rfc1042_header,
-	     ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_AARP &&
+		      sizeof(rfc1042_header)) &&
-	     ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_IPX)) {
+	      ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_AARP &&
+	      ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_IPX))) {
 		/*
 		 *  Replace the 803 header and rfc1042 header (llc/snap) with an
 		 *    EthernetII header, keep the src/dst and snap_type

drivers/net/wireless/mediatek/mt76/dma.c+4−4

@@ -93,13 +93,13 @@ __mt76_get_rxwi(struct mt76_dev *dev) · 92 unmodified lines
93	{	93	{
94	struct mt76_txwi_cache *t = NULL;	94	struct mt76_txwi_cache *t = NULL;
95		95
96	spin_lock(&dev->wed_lock);	96	spin_lock_bh(&dev->wed_lock);
97	if (!list_empty(&dev->rxwi_cache)) {	97	if (!list_empty(&dev->rxwi_cache)) {
98	t = list_first_entry(&dev->rxwi_cache, struct mt76_txwi_cache,	98	t = list_first_entry(&dev->rxwi_cache, struct mt76_txwi_cache,
99	list);	99	list);
100	list_del(&t->list);	100	list_del(&t->list);
101	}	101	}
102	spin_unlock(&dev->wed_lock);	102	spin_unlock_bh(&dev->wed_lock);
103		103
104	return t;	104	return t;
105	}	105	}
@@ -145,9 +145,9 @@ mt76_put_rxwi(struct mt76_dev dev, struct mt76_txwi_cache t) · 39 unmodified lines
145	if (!t)	145	if (!t)
146	return;	146	return;
147		147
148	spin_lock(&dev->wed_lock);	148	spin_lock_bh(&dev->wed_lock);
149	list_add(&t->list, &dev->rxwi_cache);	149	list_add(&t->list, &dev->rxwi_cache);
150	spin_unlock(&dev->wed_lock);	150	spin_unlock_bh(&dev->wed_lock);
151	}	151	}
152	EXPORT_SYMBOL_GPL(mt76_put_rxwi);	152	EXPORT_SYMBOL_GPL(mt76_put_rxwi);
153		153

drivers/net/wireless/mediatek/mt76/mt76x02_eeprom.c+0−7

 			s8 *lna_2g, s8 *lna_5g,
 			struct ieee80211_channel *chan)
 {
-	u16 val;
 	u8 lna;
-	val = mt76x02_eeprom_get(dev, MT_EE_NIC_CONF_1);
-	if (val & MT_EE_NIC_CONF_1_LNA_EXT_2G)
-		*lna_2g = 0;
-	if (val & MT_EE_NIC_CONF_1_LNA_EXT_5G)
-		memset(lna_5g, 0, sizeof(s8) * 3);
 	if (chan->band == NL80211_BAND_2GHZ)
 		lna = *lna_2g;
 	else if (chan->hw_value <= 64)

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c+11−2

 	struct ieee80211_channel *chan = dev->mphy.chandef.chan;
 	int channel = chan->hw_value;
 	s8 lna_5g[3], lna_2g;
-	u8 lna;
+	bool use_lna;
+	u8 lna = 0;
 	u16 val;
 	if (chan->band == NL80211_BAND_2GHZ)
 	dev->cal.rx.mcu_gain |= (lna_5g[1] & 0xff) << 16;
 	dev->cal.rx.mcu_gain |= (lna_5g[2] & 0xff) << 24;
-	lna = mt76x02_get_lna_gain(dev, &lna_2g, lna_5g, chan);
+	val = mt76x02_eeprom_get(dev, MT_EE_NIC_CONF_1);
+	if (chan->band == NL80211_BAND_2GHZ)
+		use_lna = !(val & MT_EE_NIC_CONF_1_LNA_EXT_2G);
+	else
+		use_lna = !(val & MT_EE_NIC_CONF_1_LNA_EXT_5G);
+	if (use_lna)
+		lna = mt76x02_get_lna_gain(dev, &lna_2g, lna_5g, chan);
 	dev->cal.rx.lna_gain = mt76x02_sign_extend(lna, 8);
 }
 EXPORT_SYMBOL_GPL(mt76x2_read_rx_gain);

drivers/net/wireless/realtek/rtw88/rtw8723d.h+1−0

@@ -46,6 +46,7 @@ struct rtw8723du_efuse { · 45 unmodified lines
46	u8 vender_id[2]; /* 0x100 */	46	u8 vender_id[2]; /* 0x100 */
47	u8 product_id[2]; /* 0x102 */	47	u8 product_id[2]; /* 0x102 */
48	u8 usb_option; /* 0x104 */	48	u8 usb_option; /* 0x104 */
		49	u8 res5[2]; /* 0x105 */
49	u8 mac_addr[ETH_ALEN]; /* 0x107 */	50	u8 mac_addr[ETH_ALEN]; /* 0x107 */
50	};	51	};
51		52

drivers/pci/pcie/aer.c+1−0

@@ -229,6 +229,7 @@ int pcie_aer_is_native(struct pci_dev *dev) · 228 unmodified lines
229		229
230	return pcie_ports_native \|\| host->native_aer;	230	return pcie_ports_native \|\| host->native_aer;
231	}	231	}
		232	EXPORT_SYMBOL_NS_GPL(pcie_aer_is_native, CXL);
232		233
233	static int pci_enable_pcie_error_reporting(struct pci_dev *dev)	234	static int pci_enable_pcie_error_reporting(struct pci_dev *dev)
234	{	235	{

drivers/pci/pcie/portdrv.h+0−2

 #ifdef CONFIG_PCIEAER
 int pcie_aer_init(void);
-int pcie_aer_is_native(struct pci_dev *dev);
 #else
 static inline int pcie_aer_init(void) { return 0; }
-static inline int pcie_aer_is_native(struct pci_dev *dev) { return 0; }
 #endif
 #ifdef CONFIG_HOTPLUG_PCI_PCIE

drivers/platform/x86/intel_scu_ipc.c+40−26

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	#include <linux/init.h>	19	#include <linux/init.h>
20	#include <linux/interrupt.h>	20	#include <linux/interrupt.h>
21	#include <linux/io.h>	21	#include <linux/io.h>
		22	#include <linux/iopoll.h>
22	#include <linux/module.h>	23	#include <linux/module.h>
23	#include <linux/slab.h>	24	#include <linux/slab.h>
24		25
@@ -231,19 +232,15 @@ static inline u32 ipc_data_readl(struct intel_scu_ipc_dev *scu, u32 offset) · 206 unmodified lines
231	/* Wait till scu status is busy */	232	/* Wait till scu status is busy */
232	static inline int busy_loop(struct intel_scu_ipc_dev *scu)	233	static inline int busy_loop(struct intel_scu_ipc_dev *scu)
233	{	234	{
234	unsigned long end = jiffies + IPC_TIMEOUT;	235	u8 status;
235		236	int err;
236	do {
237	u32 status;
238
239	status = ipc_read_status(scu);
240	if (!(status & IPC_STATUS_BUSY))
241	return (status & IPC_STATUS_ERR) ? -EIO : 0;
242		237
243	usleep_range(50, 100);	238	err = readx_poll_timeout(ipc_read_status, scu, status, !(status & IPC_STATUS_BUSY),
244	} while (time_before(jiffies, end));	239	100, jiffies_to_usecs(IPC_TIMEOUT));
		240	if (err)
		241	return err;
245		242
246	return -ETIMEDOUT;	243	return (status & IPC_STATUS_ERR) ? -EIO : 0;
247	}	244	}
248		245
249	/* Wait till ipc ioc interrupt is received or timeout in 10 HZ */	246	/* Wait till ipc ioc interrupt is received or timeout in 10 HZ */
@@ -251,10 +248,12 @@ static inline int ipc_wait_for_interrupt(struct intel_scu_ipc_dev *scu) · 1 unmodified line
251	{	248	{
252	int status;	249	int status;
253		250
254	if (!wait_for_completion_timeout(&scu->cmd_complete, IPC_TIMEOUT))	251	wait_for_completion_timeout(&scu->cmd_complete, IPC_TIMEOUT);
255	return -ETIMEDOUT;
256		252
257	status = ipc_read_status(scu);	253	status = ipc_read_status(scu);
		254	if (status & IPC_STATUS_BUSY)
		255	return -ETIMEDOUT;
		256
258	if (status & IPC_STATUS_ERR)	257	if (status & IPC_STATUS_ERR)
259	return -EIO;	258	return -EIO;
260		259
@@ -266,6 +265,24 @@ static int intel_scu_ipc_check_status(struct intel_scu_ipc_dev *scu) · 5 unmodified lines
266	return scu->irq > 0 ? ipc_wait_for_interrupt(scu) : busy_loop(scu);	265	return scu->irq > 0 ? ipc_wait_for_interrupt(scu) : busy_loop(scu);
267	}	266	}
268		267
		268	static struct intel_scu_ipc_dev intel_scu_ipc_get(struct intel_scu_ipc_dev scu)
		269	{
		270	u8 status;
		271
		272	if (!scu)
		273	scu = ipcdev;
		274	if (!scu)
		275	return ERR_PTR(-ENODEV);
		276
		277	status = ipc_read_status(scu);
		278	if (status & IPC_STATUS_BUSY) {
		279	dev_dbg(&scu->dev, "device is busy\n");
		280	return ERR_PTR(-EBUSY);
		281	}
		282
		283	return scu;
		284	}
		285
269	/* Read/Write power control(PMIC in Langwell, MSIC in PenWell) registers */	286	/* Read/Write power control(PMIC in Langwell, MSIC in PenWell) registers */
270	static int pwr_reg_rdwr(struct intel_scu_ipc_dev scu, u16 addr, u8 *data,	287	static int pwr_reg_rdwr(struct intel_scu_ipc_dev scu, u16 addr, u8 *data,
271	u32 count, u32 op, u32 id)	288	u32 count, u32 op, u32 id)
@@ -279,11 +296,10 @@ static int pwr_reg_rdwr(struct intel_scu_ipc_dev scu, u16 addr, u8 *data, · 7 unmodified lines
279	memset(cbuf, 0, sizeof(cbuf));	296	memset(cbuf, 0, sizeof(cbuf));
280		297
281	mutex_lock(&ipclock);	298	mutex_lock(&ipclock);
282	if (!scu)	299	scu = intel_scu_ipc_get(scu);
283	scu = ipcdev;	300	if (IS_ERR(scu)) {
284	if (!scu) {
285	mutex_unlock(&ipclock);	301	mutex_unlock(&ipclock);
286	return -ENODEV;	302	return PTR_ERR(scu);
287	}	303	}
288		304
289	for (nc = 0; nc < count; nc++, offset += 2) {	305	for (nc = 0; nc < count; nc++, offset += 2) {
@@ -438,13 +454,12 @@ int intel_scu_ipc_dev_simple_command(struct intel_scu_ipc_dev *scu, int cmd, · 148 unmodified lines
438	int err;	454	int err;
439		455
440	mutex_lock(&ipclock);	456	mutex_lock(&ipclock);
441	if (!scu)	457	scu = intel_scu_ipc_get(scu);
442	scu = ipcdev;	458	if (IS_ERR(scu)) {
443	if (!scu) {
444	mutex_unlock(&ipclock);	459	mutex_unlock(&ipclock);
445	return -ENODEV;	460	return PTR_ERR(scu);
446	}	461	}
447	scu = ipcdev;	462
448	cmdval = sub << 12 \| cmd;	463	cmdval = sub << 12 \| cmd;
449	ipc_command(scu, cmdval);	464	ipc_command(scu, cmdval);
450	err = intel_scu_ipc_check_status(scu);	465	err = intel_scu_ipc_check_status(scu);
@@ -484,11 +499,10 @@ int intel_scu_ipc_dev_command_with_size(struct intel_scu_ipc_dev *scu, int cmd, · 33 unmodified lines
484	return -EINVAL;	499	return -EINVAL;
485		500
486	mutex_lock(&ipclock);	501	mutex_lock(&ipclock);
487	if (!scu)	502	scu = intel_scu_ipc_get(scu);
488	scu = ipcdev;	503	if (IS_ERR(scu)) {
489	if (!scu) {
490	mutex_unlock(&ipclock);	504	mutex_unlock(&ipclock);
491	return -ENODEV;	505	return PTR_ERR(scu);
492	}	506	}
493		507
494	memcpy(inbuf, in, inlen);	508	memcpy(inbuf, in, inlen);

drivers/platform/x86/thinkpad_acpi.c+2−0

 {
 	tpacpi_disable_brightness_delay();
+	mutex_lock(&hotkey_mutex);
 	if (hotkey_status_set(true) < 0 ||
 	    hotkey_mask_set(hotkey_acpi_mask) < 0)
 		pr_err("error while attempting to reset the event firmware interface\n");
+	mutex_unlock(&hotkey_mutex);
 	tpacpi_send_radiosw_update();
 	tpacpi_input_send_tabletsw();

drivers/power/reset/Kconfig+1−1

@@ -300,7 +300,7 @@ config NVMEM_REBOOT_MODE · 299 unmodified lines
300		300
301	config POWER_MLXBF	301	config POWER_MLXBF
302	tristate "Mellanox BlueField power handling driver"	302	tristate "Mellanox BlueField power handling driver"
303	depends on (GPIO_MLXBF2 && ACPI)	303	depends on (GPIO_MLXBF2 \|\| GPIO_MLXBF3) && ACPI
304	help	304	help
305	This driver supports reset or low power mode handling for Mellanox BlueField.	305	This driver supports reset or low power mode handling for Mellanox BlueField.
306		306

drivers/power/reset/pwr-mlxbf.c+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0-only or BSD-3-Clause	1	// SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
2		2
3	/*	3	/*
4	* Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES.	4	* Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES.

drivers/power/reset/vexpress-poweroff.c+1−1

@@ -121,7 +121,7 @@ static int vexpress_reset_probe(struct platform_device *pdev) · 120 unmodified lines
121	return PTR_ERR(regmap);	121	return PTR_ERR(regmap);
122	dev_set_drvdata(&pdev->dev, regmap);	122	dev_set_drvdata(&pdev->dev, regmap);
123		123
124	switch ((enum vexpress_reset_func)match->data) {	124	switch ((uintptr_t)match->data) {
125	case FUNC_SHUTDOWN:	125	case FUNC_SHUTDOWN:
126	vexpress_power_off_device = &pdev->dev;	126	vexpress_power_off_device = &pdev->dev;
127	pm_power_off = vexpress_power_off;	127	pm_power_off = vexpress_power_off;

drivers/power/supply/Kconfig+1−0

@@ -769,6 +769,7 @@ config BATTERY_RT5033 · 768 unmodified lines
769	config CHARGER_RT5033	769	config CHARGER_RT5033
770	tristate "RT5033 battery charger support"	770	tristate "RT5033 battery charger support"
771	depends on MFD_RT5033	771	depends on MFD_RT5033
		772	depends on EXTCON \|\| !EXTCON
772	help	773	help
773	This adds support for battery charger in Richtek RT5033 PMIC.	774	This adds support for battery charger in Richtek RT5033 PMIC.
774	The device supports pre-charge mode, fast charge mode and	775	The device supports pre-charge mode, fast charge mode and

drivers/power/supply/ab8500_btemp.c+1−8

 static enum power_supply_property ab8500_btemp_props[] = {
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_ONLINE,
-	POWER_SUPPLY_PROP_TECHNOLOGY,
 	POWER_SUPPLY_PROP_TEMP,
 };
 		else
 			val->intval = 1;
 		break;
-	case POWER_SUPPLY_PROP_TECHNOLOGY:
-		if (di->bm->bi)
-			val->intval = di->bm->bi->technology;
-		else
-			val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
-		break;
 	case POWER_SUPPLY_PROP_TEMP:
 		val->intval = ab8500_btemp_get_temp(di);
 		break;
 static const struct power_supply_desc ab8500_btemp_desc = {
 	.name			= "ab8500_btemp",
-	.type			= POWER_SUPPLY_TYPE_BATTERY,
+	.type			= POWER_SUPPLY_TYPE_UNKNOWN,
 	.properties		= ab8500_btemp_props,
 	.num_properties		= ARRAY_SIZE(ab8500_btemp_props),
 	.get_property		= ab8500_btemp_get_property,

drivers/power/supply/ab8500_chargalg.c+1−1

@@ -1720,7 +1720,7 @@ static char *supply_interface[] = { · 1719 unmodified lines
1720		1720
1721	static const struct power_supply_desc ab8500_chargalg_desc = {	1721	static const struct power_supply_desc ab8500_chargalg_desc = {
1722	.name = "ab8500_chargalg",	1722	.name = "ab8500_chargalg",
1723	.type = POWER_SUPPLY_TYPE_BATTERY,	1723	.type = POWER_SUPPLY_TYPE_UNKNOWN,
1724	.properties = ab8500_chargalg_props,	1724	.properties = ab8500_chargalg_props,
1725	.num_properties = ARRAY_SIZE(ab8500_chargalg_props),	1725	.num_properties = ARRAY_SIZE(ab8500_chargalg_props),
1726	.get_property = ab8500_chargalg_get_property,	1726	.get_property = ab8500_chargalg_get_property,

drivers/power/supply/mt6370-charger.c+1−1

@@ -324,7 +324,7 @@ static int mt6370_chg_toggle_cfo(struct mt6370_priv *priv) · 323 unmodified lines
324		324
325	if (fl_strobe) {	325	if (fl_strobe) {
326	dev_err(priv->dev, "Flash led is still in strobe mode\n");	326	dev_err(priv->dev, "Flash led is still in strobe mode\n");
327	return ret;	327	return -EINVAL;
328	}	328	}
329		329
330	/* cfo off */	330	/* cfo off */

drivers/power/supply/power_supply_sysfs.c+7−0

@@ -482,6 +482,13 @@ int power_supply_uevent(const struct device dev, struct kobj_uevent_env env) · 481 unmodified lines
482	if (ret)	482	if (ret)
483	return ret;	483	return ret;
484		484
		485	/*
		486	* Kernel generates KOBJ_REMOVE uevent in device removal path, after
		487	* resources have been freed. Exit early to avoid use-after-free.
		488	*/
		489	if (psy->removing)
		490	return 0;
		491
485	prop_buf = (char *)get_zeroed_page(GFP_KERNEL);	492	prop_buf = (char *)get_zeroed_page(GFP_KERNEL);
486	if (!prop_buf)	493	if (!prop_buf)
487	return -ENOMEM;	494	return -ENOMEM;

drivers/power/supply/rk817_charger.c+13−3

 	queue_delayed_work(system_wq, &charger->work, msecs_to_jiffies(8000));
 }
+static void rk817_cleanup_node(void *data)
+{
+	struct device_node *node = data;
+	of_node_put(node);
+}
 static int rk817_charger_probe(struct platform_device *pdev)
 {
 	struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
 	if (!node)
 		return -ENODEV;
+	ret = devm_add_action_or_reset(&pdev->dev, rk817_cleanup_node, node);
+	if (ret)
+		return ret;
 	charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL);
-	if (!charger) {
+	if (!charger)
-		of_node_put(node);
 		return -ENOMEM;
-	}
 	charger->rk808 = rk808;
 MODULE_AUTHOR("Maya Matuszczyk <maccraft123mc@gmail.com>");
 MODULE_AUTHOR("Chris Morgan <macromorgan@hotmail.com>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:rk817-charger");

drivers/power/supply/rt9467-charger.c+2−2

@@ -598,8 +598,8 @@ static int rt9467_run_aicl(struct rt9467_chg_data *data) · 597 unmodified lines
598		598
599	reinit_completion(&data->aicl_done);	599	reinit_completion(&data->aicl_done);
600	ret = wait_for_completion_timeout(&data->aicl_done, msecs_to_jiffies(3500));	600	ret = wait_for_completion_timeout(&data->aicl_done, msecs_to_jiffies(3500));
601	if (ret)	601	if (ret == 0)
602	return ret;	602	return -ETIMEDOUT;
603		603
604	ret = rt9467_get_value_from_ranges(data, F_IAICR, RT9467_RANGE_IAICR, &aicr_get);	604	ret = rt9467_get_value_from_ranges(data, F_IAICR, RT9467_RANGE_IAICR, &aicr_get);
605	if (ret) {	605	if (ret) {

drivers/power/supply/ucs1002_power.c+2−1

 	case POWER_SUPPLY_PROP_USB_TYPE:
 		return ucs1002_get_usb_type(info, val);
 	case POWER_SUPPLY_PROP_HEALTH:
-		return val->intval = info->health;
+		val->intval = info->health;
+		return 0;
 	case POWER_SUPPLY_PROP_PRESENT:
 		val->intval = info->present;
 		return 0;

drivers/ptp/ptp_ocp.c+0−1

@@ -4046,7 +4046,6 @@ ptp_ocp_device_init(struct ptp_ocp bp, struct pci_dev pdev) · 4045 unmodified lines
4046	return 0;	4046	return 0;
4047		4047
4048	out:	4048	out:
4049	ptp_ocp_dev_release(&bp->dev);
4050	put_device(&bp->dev);	4049	put_device(&bp->dev);
4051	return err;	4050	return err;
4052	}	4051	}

drivers/regulator/core.c+3−7

 		goto rinse;
 	}
 	device_initialize(&rdev->dev);
+	dev_set_drvdata(&rdev->dev, rdev);
+	rdev->dev.class = &regulator_class;
 	spin_lock_init(&rdev->err_lock);
 	/*
 		rdev->supply_name = regulator_desc->supply_name;
 	/* register with sysfs */
-	rdev->dev.class = &regulator_class;
 	rdev->dev.parent = config->dev;
 	dev_set_name(&rdev->dev, "regulator.%lu",
 		    (unsigned long) atomic_inc_return(&regulator_no));
-	dev_set_drvdata(&rdev->dev, rdev);
 	/* set regulator constraints */
 	if (init_data)
 	mutex_lock(&regulator_list_mutex);
 	regulator_ena_gpio_free(rdev);
 	mutex_unlock(&regulator_list_mutex);
-	put_device(&rdev->dev);
-	rdev = NULL;
 clean:
 	if (dangling_of_gpiod)
 		gpiod_put(config->ena_gpiod);
-	if (rdev && rdev->dev.of_node)
-		of_node_put(rdev->dev.of_node);
-	kfree(rdev);
 	kfree(config);
+	put_device(&rdev->dev);
 rinse:
 	if (dangling_cfg_gpiod)
 		gpiod_put(cfg->ena_gpiod);

drivers/regulator/mt6358-regulator.c+15−3

 	.desc = {	\
 		.name = #vreg,	\
 		.of_match = of_match_ptr(match),	\
-		.ops = &mt6358_volt_range_ops,	\
+		.ops = &mt6358_buck_ops,	\
 		.type = REGULATOR_VOLTAGE,	\
 		.id = MT6358_ID_##vreg,		\
 		.owner = THIS_MODULE,		\
 	.desc = {	\
 		.name = #vreg,	\
 		.of_match = of_match_ptr(match),	\
-		.ops = &mt6358_volt_range_ops,	\
+		.ops = &mt6358_buck_ops,	\
 		.type = REGULATOR_VOLTAGE,	\
 		.id = MT6366_ID_##vreg,		\
 		.owner = THIS_MODULE,		\
 	}
 }
-static const struct regulator_ops mt6358_volt_range_ops = {
+static const struct regulator_ops mt6358_buck_ops = {
 	.list_voltage = regulator_list_voltage_linear,
 	.map_voltage = regulator_map_voltage_linear,
 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
 	.get_mode = mt6358_regulator_get_mode,
 };
+static const struct regulator_ops mt6358_volt_range_ops = {
+	.list_voltage = regulator_list_voltage_linear,
+	.map_voltage = regulator_map_voltage_linear,
+	.set_voltage_sel = regulator_set_voltage_sel_regmap,
+	.get_voltage_sel = mt6358_get_buck_voltage_sel,
+	.set_voltage_time_sel = regulator_set_voltage_time_sel,
+	.enable = regulator_enable_regmap,
+	.disable = regulator_disable_regmap,
+	.is_enabled = regulator_is_enabled_regmap,
+	.get_status = mt6358_get_status,
+};
 static const struct regulator_ops mt6358_volt_table_ops = {
 	.list_voltage = regulator_list_voltage_table,
 	.map_voltage = regulator_map_voltage_iterate,

drivers/s390/scsi/zfcp_aux.c+5−4

 	if (port) {
 		put_device(&port->dev);
 		retval = -EEXIST;
-		goto err_out;
+		goto err_put;
 	}
 	port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
 	if (!port)
-		goto err_out;
+		goto err_put;
 	rwlock_init(&port->unit_list_lock);
 	INIT_LIST_HEAD(&port->unit_list);
 	if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) {
 		kfree(port);
-		goto err_out;
+		goto err_put;
 	}
 	retval = -EINVAL;
 	return port;
-err_out:
+err_put:
 	zfcp_ccw_adapter_put(adapter);
+err_out:
 	return ERR_PTR(retval);
 }

drivers/scsi/fnic/fnic.h+3−1

 #define DRV_NAME		"fnic"
 #define DRV_DESCRIPTION		"Cisco FCoE HBA Driver"
-#define DRV_VERSION		"1.6.0.56"
+#define DRV_VERSION		"1.6.0.57"
 #define PFX			DRV_NAME ": "
 #define DFX                     DRV_NAME "%d: "
 	unsigned int cq_count;
 	struct mutex sgreset_mutex;
+	spinlock_t sgreset_lock; /* lock for sgreset */
+	struct scsi_cmnd *sgreset_sc;
 	struct dentry *fnic_stats_debugfs_host;
 	struct dentry *fnic_stats_debugfs_file;
 	struct dentry *fnic_reset_debugfs_file;

drivers/scsi/fnic/fnic_io.h+2−0

@@ -52,6 +52,8 @@ struct fnic_io_req { · 51 unmodified lines
52	unsigned long start_time; /* in jiffies */	52	unsigned long start_time; /* in jiffies */
53	struct completion abts_done; / completion for abts */	53	struct completion abts_done; / completion for abts */
54	struct completion dr_done; / completion for device reset */	54	struct completion dr_done; / completion for device reset */
		55	unsigned int tag;
		56	struct scsi_cmnd sc; / midlayer's cmd pointer */
55	};	57	};
56		58
57	enum fnic_port_speeds {	59	enum fnic_port_speeds {

drivers/scsi/fnic/fnic_main.c+2−0

@@ -754,6 +754,8 @@ static int fnic_probe(struct pci_dev pdev, const struct pci_device_id ent) · 753 unmodified lines
754	for (i = 0; i < FNIC_IO_LOCKS; i++)	754	for (i = 0; i < FNIC_IO_LOCKS; i++)
755	spin_lock_init(&fnic->io_req_lock[i]);	755	spin_lock_init(&fnic->io_req_lock[i]);
756		756
		757	spin_lock_init(&fnic->sgreset_lock);
		758
757	err = -ENOMEM;	759	err = -ENOMEM;
758	fnic->io_req_pool = mempool_create_slab_pool(2, fnic_io_req_cache);	760	fnic->io_req_pool = mempool_create_slab_pool(2, fnic_io_req_cache);
759	if (!fnic->io_req_pool)	761	if (!fnic->io_req_pool)

drivers/scsi/fnic/fnic_scsi.c+47−17

@@ -1047,9 +1047,9 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic, · 1046 unmodified lines
1047	{	1047	{
1048	u8 type;	1048	u8 type;
1049	u8 hdr_status;	1049	u8 hdr_status;
1050	struct fcpio_tag tag;	1050	struct fcpio_tag ftag;
1051	u32 id;	1051	u32 id;
1052	struct scsi_cmnd *sc;	1052	struct scsi_cmnd *sc = NULL;
1053	struct fnic_io_req *io_req;	1053	struct fnic_io_req *io_req;
1054	struct fnic_stats *fnic_stats = &fnic->fnic_stats;	1054	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
1055	struct abort_stats *abts_stats = &fnic->fnic_stats.abts_stats;	1055	struct abort_stats *abts_stats = &fnic->fnic_stats.abts_stats;
@@ -1058,27 +1058,43 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic, · 2 unmodified lines
1058	unsigned long flags;	1058	unsigned long flags;
1059	spinlock_t *io_lock;	1059	spinlock_t *io_lock;
1060	unsigned long start_time;	1060	unsigned long start_time;
		1061	unsigned int tag;
1061		1062
1062	fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);	1063	fcpio_header_dec(&desc->hdr, &type, &hdr_status, &ftag);
1063	fcpio_tag_id_dec(&tag, &id);	1064	fcpio_tag_id_dec(&ftag, &id);
1064		1065
1065	if ((id & FNIC_TAG_MASK) >= fnic->fnic_max_tag_id) {	1066	tag = id & FNIC_TAG_MASK;
		1067	if (tag == fnic->fnic_max_tag_id) {
		1068	if (!(id & FNIC_TAG_DEV_RST)) {
		1069	shost_printk(KERN_ERR, fnic->lport->host,
		1070	"Tag out of range id 0x%x hdr status = %s\n",
		1071	id, fnic_fcpio_status_to_str(hdr_status));
		1072	return;
		1073	}
		1074	} else if (tag > fnic->fnic_max_tag_id) {
1066	shost_printk(KERN_ERR, fnic->lport->host,	1075	shost_printk(KERN_ERR, fnic->lport->host,
1067	"Tag out of range tag %x hdr status = %s\n",	1076	"Tag out of range tag 0x%x hdr status = %s\n",
1068	id, fnic_fcpio_status_to_str(hdr_status));	1077	tag, fnic_fcpio_status_to_str(hdr_status));
1069	return;	1078	return;
1070	}	1079	}
1071		1080
1072	sc = scsi_host_find_tag(fnic->lport->host, id & FNIC_TAG_MASK);	1081	if ((tag == fnic->fnic_max_tag_id) && (id & FNIC_TAG_DEV_RST)) {
		1082	sc = fnic->sgreset_sc;
		1083	io_lock = &fnic->sgreset_lock;
		1084	} else {
		1085	sc = scsi_host_find_tag(fnic->lport->host, id & FNIC_TAG_MASK);
		1086	io_lock = fnic_io_lock_hash(fnic, sc);
		1087	}
		1088
1073	WARN_ON_ONCE(!sc);	1089	WARN_ON_ONCE(!sc);
1074	if (!sc) {	1090	if (!sc) {
1075	atomic64_inc(&fnic_stats->io_stats.sc_null);	1091	atomic64_inc(&fnic_stats->io_stats.sc_null);
1076	shost_printk(KERN_ERR, fnic->lport->host,	1092	shost_printk(KERN_ERR, fnic->lport->host,
1077	"itmf_cmpl sc is null - hdr status = %s tag = 0x%x\n",	1093	"itmf_cmpl sc is null - hdr status = %s tag = 0x%x\n",
1078	fnic_fcpio_status_to_str(hdr_status), id);	1094	fnic_fcpio_status_to_str(hdr_status), tag);
1079	return;	1095	return;
1080	}	1096	}
1081	io_lock = fnic_io_lock_hash(fnic, sc);	1097
1082	spin_lock_irqsave(io_lock, flags);	1098	spin_lock_irqsave(io_lock, flags);
1083	io_req = fnic_priv(sc)->io_req;	1099	io_req = fnic_priv(sc)->io_req;
1084	WARN_ON_ONCE(!io_req);	1100	WARN_ON_ONCE(!io_req);
@@ -1089,7 +1105,7 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic, · 4 unmodified lines
1089	shost_printk(KERN_ERR, fnic->lport->host,	1105	shost_printk(KERN_ERR, fnic->lport->host,
1090	"itmf_cmpl io_req is null - "	1106	"itmf_cmpl io_req is null - "
1091	"hdr status = %s tag = 0x%x sc 0x%p\n",	1107	"hdr status = %s tag = 0x%x sc 0x%p\n",
1092	fnic_fcpio_status_to_str(hdr_status), id, sc);	1108	fnic_fcpio_status_to_str(hdr_status), tag, sc);
1093	return;	1109	return;
1094	}	1110	}
1095	start_time = io_req->start_time;	1111	start_time = io_req->start_time;
@@ -1938,6 +1954,10 @@ static inline int fnic_queue_dr_io_req(struct fnic *fnic, · 842 unmodified lines
1938	struct scsi_lun fc_lun;	1954	struct scsi_lun fc_lun;
1939	int ret = 0;	1955	int ret = 0;
1940	unsigned long intr_flags;	1956	unsigned long intr_flags;
		1957	unsigned int tag = scsi_cmd_to_rq(sc)->tag;
		1958
		1959	if (tag == SCSI_NO_TAG)
		1960	tag = io_req->tag;
1941		1961
1942	spin_lock_irqsave(host->host_lock, intr_flags);	1962	spin_lock_irqsave(host->host_lock, intr_flags);
1943	if (unlikely(fnic_chk_state_flags_locked(fnic,	1963	if (unlikely(fnic_chk_state_flags_locked(fnic,
@@ -1964,7 +1984,8 @@ static inline int fnic_queue_dr_io_req(struct fnic *fnic, · 20 unmodified lines
1964	/* fill in the lun info */	1984	/* fill in the lun info */
1965	int_to_scsilun(sc->device->lun, &fc_lun);	1985	int_to_scsilun(sc->device->lun, &fc_lun);
1966		1986
1967	fnic_queue_wq_copy_desc_itmf(wq, scsi_cmd_to_rq(sc)->tag \| FNIC_TAG_DEV_RST,	1987	tag \|= FNIC_TAG_DEV_RST;
		1988	fnic_queue_wq_copy_desc_itmf(wq, tag,
1968	0, FCPIO_ITMF_LUN_RESET, SCSI_NO_TAG,	1989	0, FCPIO_ITMF_LUN_RESET, SCSI_NO_TAG,
1969	fc_lun.scsi_lun, io_req->port_id,	1990	fc_lun.scsi_lun, io_req->port_id,
1970	fnic->config.ra_tov, fnic->config.ed_tov);	1991	fnic->config.ra_tov, fnic->config.ed_tov);
@@ -2146,8 +2167,7 @@ static int fnic_clean_pending_aborts(struct fnic *fnic, · 175 unmodified lines
2146	.ret = SUCCESS,	2167	.ret = SUCCESS,
2147	};	2168	};
2148		2169
2149	if (new_sc)	2170	iter_data.lr_sc = lr_sc;
2150	iter_data.lr_sc = lr_sc;
2151		2171
2152	scsi_host_busy_iter(fnic->lport->host,	2172	scsi_host_busy_iter(fnic->lport->host,
2153	fnic_pending_aborts_iter, &iter_data);	2173	fnic_pending_aborts_iter, &iter_data);
@@ -2230,8 +2250,14 @@ int fnic_device_reset(struct scsi_cmnd *sc) · 76 unmodified lines
2230	mutex_lock(&fnic->sgreset_mutex);	2250	mutex_lock(&fnic->sgreset_mutex);
2231	tag = fnic->fnic_max_tag_id;	2251	tag = fnic->fnic_max_tag_id;
2232	new_sc = 1;	2252	new_sc = 1;
2233	}	2253	fnic->sgreset_sc = sc;
2234	io_lock = fnic_io_lock_hash(fnic, sc);	2254	io_lock = &fnic->sgreset_lock;
		2255	FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
		2256	"fcid: 0x%x lun: 0x%llx flags: 0x%x tag: 0x%x Issuing sgreset\n",
		2257	rport->port_id, sc->device->lun, fnic_priv(sc)->flags, tag);
		2258	} else
		2259	io_lock = fnic_io_lock_hash(fnic, sc);
		2260
2235	spin_lock_irqsave(io_lock, flags);	2261	spin_lock_irqsave(io_lock, flags);
2236	io_req = fnic_priv(sc)->io_req;	2262	io_req = fnic_priv(sc)->io_req;
2237		2263
@@ -2247,6 +2273,8 @@ int fnic_device_reset(struct scsi_cmnd *sc) · 9 unmodified lines
2247	}	2273	}
2248	memset(io_req, 0, sizeof(*io_req));	2274	memset(io_req, 0, sizeof(*io_req));
2249	io_req->port_id = rport->port_id;	2275	io_req->port_id = rport->port_id;
		2276	io_req->tag = tag;
		2277	io_req->sc = sc;
2250	fnic_priv(sc)->io_req = io_req;	2278	fnic_priv(sc)->io_req = io_req;
2251	}	2279	}
2252	io_req->dr_done = &tm_done;	2280	io_req->dr_done = &tm_done;
@@ -2400,8 +2428,10 @@ fnic_device_reset_end: · 147 unmodified lines
2400	(u64)sc->cmnd[4] << 8 \| sc->cmnd[5]),	2428	(u64)sc->cmnd[4] << 8 \| sc->cmnd[5]),
2401	fnic_flags_and_state(sc));	2429	fnic_flags_and_state(sc));
2402		2430
2403	if (new_sc)	2431	if (new_sc) {
		2432	fnic->sgreset_sc = NULL;
2404	mutex_unlock(&fnic->sgreset_mutex);	2433	mutex_unlock(&fnic->sgreset_mutex);
		2434	}
2405		2435
2406	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,	2436	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2407	"Returning from device reset %s\n",	2437	"Returning from device reset %s\n",

drivers/scsi/scsi.c+11−0

@@ -613,6 +613,17 @@ void scsi_cdl_check(struct scsi_device *sdev) · 612 unmodified lines
613	bool cdl_supported;	613	bool cdl_supported;
614	unsigned char *buf;	614	unsigned char *buf;
615		615
		616	/*
		617	* Support for CDL was defined in SPC-5. Ignore devices reporting an
		618	* lower SPC version. This also avoids problems with old drives choking
		619	* on MAINTENANCE_IN / MI_REPORT_SUPPORTED_OPERATION_CODES with a
		620	* service action specified, as done in scsi_cdl_check_cmd().
		621	*/
		622	if (sdev->scsi_level < SCSI_SPC_5) {
		623	sdev->cdl_supported = 0;
		624	return;
		625	}
		626
616	buf = kmalloc(SCSI_CDL_CHECK_BUF_LEN, GFP_KERNEL);	627	buf = kmalloc(SCSI_CDL_CHECK_BUF_LEN, GFP_KERNEL);
617	if (!buf) {	628	if (!buf) {
618	sdev->cdl_supported = 0;	629	sdev->cdl_supported = 0;

drivers/scsi/scsi_scan.c+18−2

 	 * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so
 	 * non-zero LUNs can be scanned.
 	 */
-	sdev->scsi_level = inq_result[2] & 0x07;
+	sdev->scsi_level = inq_result[2] & 0x0f;
 	if (sdev->scsi_level >= 2 ||
 	    (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
 		sdev->scsi_level++;
 }
 EXPORT_SYMBOL(scsi_add_device);
-void scsi_rescan_device(struct scsi_device *sdev)
+int scsi_rescan_device(struct scsi_device *sdev)
 {
 	struct device *dev = &sdev->sdev_gendev;
+	int ret = 0;
 	device_lock(dev);
+	/*
+	 * Bail out if the device is not running. Otherwise, the rescan may
+	 * block waiting for commands to be executed, with us holding the
+	 * device lock. This can result in a potential deadlock in the power
+	 * management core code when system resume is on-going.
+	 */
+	if (sdev->sdev_state != SDEV_RUNNING) {
+		ret = -EWOULDBLOCK;
+		goto unlock;
+	}
 	scsi_attach_vpd(sdev);
 	scsi_cdl_check(sdev);
 			drv->rescan(dev);
 		module_put(dev->driver->owner);
 	}
+unlock:
 	device_unlock(dev);
+	return ret;
 }
 EXPORT_SYMBOL(scsi_rescan_device);

drivers/scsi/sd.c+82−19

 }
 static ssize_t
-manage_start_stop_show(struct device *dev, struct device_attribute *attr,
+manage_start_stop_show(struct device *dev,
-		       char *buf)
+		       struct device_attribute *attr, char *buf)
 {
 	struct scsi_disk *sdkp = to_scsi_disk(dev);
 	struct scsi_device *sdp = sdkp->device;
-	return sprintf(buf, "%u\n", sdp->manage_start_stop);
+	return sysfs_emit(buf, "%u\n",
+			  sdp->manage_system_start_stop &&
+			  sdp->manage_runtime_start_stop);
 }
+static DEVICE_ATTR_RO(manage_start_stop);
 static ssize_t
-manage_start_stop_store(struct device *dev, struct device_attribute *attr,
+manage_system_start_stop_show(struct device *dev,
-			const char *buf, size_t count)
+			      struct device_attribute *attr, char *buf)
+{
+	struct scsi_disk *sdkp = to_scsi_disk(dev);
+	struct scsi_device *sdp = sdkp->device;
+	return sysfs_emit(buf, "%u\n", sdp->manage_system_start_stop);
+}
+static ssize_t
+manage_system_start_stop_store(struct device *dev,
+			       struct device_attribute *attr,
+			       const char *buf, size_t count)
 {
 	struct scsi_disk *sdkp = to_scsi_disk(dev);
 	struct scsi_device *sdp = sdkp->device;
 	if (kstrtobool(buf, &v))
 		return -EINVAL;
-	sdp->manage_start_stop = v;
+	sdp->manage_system_start_stop = v;
 	return count;
 }
-static DEVICE_ATTR_RW(manage_start_stop);
+static DEVICE_ATTR_RW(manage_system_start_stop);
+static ssize_t
+manage_runtime_start_stop_show(struct device *dev,
+			       struct device_attribute *attr, char *buf)
+{
+	struct scsi_disk *sdkp = to_scsi_disk(dev);
+	struct scsi_device *sdp = sdkp->device;
+	return sysfs_emit(buf, "%u\n", sdp->manage_runtime_start_stop);
+}
+static ssize_t
+manage_runtime_start_stop_store(struct device *dev,
+				struct device_attribute *attr,
+				const char *buf, size_t count)
+{
+	struct scsi_disk *sdkp = to_scsi_disk(dev);
+	struct scsi_device *sdp = sdkp->device;
+	bool v;
+	if (!capable(CAP_SYS_ADMIN))
+		return -EACCES;
+	if (kstrtobool(buf, &v))
+		return -EINVAL;
+	sdp->manage_runtime_start_stop = v;
+	return count;
+}
+static DEVICE_ATTR_RW(manage_runtime_start_stop);
 static ssize_t
 allow_restart_show(struct device *dev, struct device_attribute *attr, char *buf)
 	&dev_attr_FUA.attr,
 	&dev_attr_allow_restart.attr,
 	&dev_attr_manage_start_stop.attr,
+	&dev_attr_manage_system_start_stop.attr,
+	&dev_attr_manage_runtime_start_stop.attr,
 	&dev_attr_protection_type.attr,
 	&dev_attr_protection_mode.attr,
 	&dev_attr_app_tag_own.attr,
 	device_del(&sdkp->disk_dev);
 	del_gendisk(sdkp->disk);
-	sd_shutdown(dev);
+	if (!sdkp->suspended)
+		sd_shutdown(dev);
 	put_disk(sdkp->disk);
 	return 0;
 		sd_sync_cache(sdkp, NULL);
 	}
-	if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
+	if (system_state != SYSTEM_RESTART &&
+	    sdkp->device->manage_system_start_stop) {
 		sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
 		sd_start_stop_device(sdkp, 0);
 	}
 }
-static int sd_suspend_common(struct device *dev, bool ignore_stop_errors)
+static inline bool sd_do_start_stop(struct scsi_device *sdev, bool runtime)
+{
+	return (sdev->manage_system_start_stop && !runtime) ||
+		(sdev->manage_runtime_start_stop && runtime);
+}
+static int sd_suspend_common(struct device *dev, bool runtime)
 {
 	struct scsi_disk *sdkp = dev_get_drvdata(dev);
 	struct scsi_sense_hdr sshdr;
 		}
 	}
-	if (sdkp->device->manage_start_stop) {
+	if (sd_do_start_stop(sdkp->device, runtime)) {
 		if (!sdkp->device->silence_suspend)
 			sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
 		/* an error is not worth aborting a system sleep */
 		ret = sd_start_stop_device(sdkp, 0);
-		if (ignore_stop_errors)
+		if (!runtime)
 			ret = 0;
 	}
+	if (!ret)
+		sdkp->suspended = true;
 	return ret;
 }
 	if (pm_runtime_suspended(dev))
 		return 0;
-	return sd_suspend_common(dev, true);
+	return sd_suspend_common(dev, false);
 }
 static int sd_suspend_runtime(struct device *dev)
 {
-	return sd_suspend_common(dev, false);
+	return sd_suspend_common(dev, true);
 }
-static int sd_resume(struct device *dev)
+static int sd_resume(struct device *dev, bool runtime)
 {
 	struct scsi_disk *sdkp = dev_get_drvdata(dev);
 	int ret = 0;
 	if (!sdkp)	/* E.g.: runtime resume at the start of sd_probe() */
 		return 0;
-	if (!sdkp->device->manage_start_stop)
+	if (!sd_do_start_stop(sdkp->device, runtime)) {
+		sdkp->suspended = false;
 		return 0;
+	}
 	if (!sdkp->device->no_start_on_resume) {
 		sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
 		ret = sd_start_stop_device(sdkp, 1);
 	}
-	if (!ret)
+	if (!ret) {
 		opal_unlock_from_suspend(sdkp->opal_dev);
+		sdkp->suspended = false;
+	}
 	return ret;
 }
 	if (pm_runtime_suspended(dev))
 		return 0;
-	return sd_resume(dev);
+	return sd_resume(dev, false);
 }
 static int sd_resume_runtime(struct device *dev)
 				  "Failed to clear sense data\n");
 	}
-	return sd_resume(dev);
+	return sd_resume(dev, true);
 }
 static const struct dev_pm_ops sd_pm_ops = {

drivers/scsi/sd.h+1−0

@@ -131,6 +131,7 @@ struct scsi_disk { · 130 unmodified lines
131	u8 provisioning_mode;	131	u8 provisioning_mode;
132	u8 zeroing_mode;	132	u8 zeroing_mode;
133	u8 nr_actuators; /* Number of actuators */	133	u8 nr_actuators; /* Number of actuators */
		134	bool suspended; /* Disk is suspended (stopped) */
134	unsigned ATO : 1; /* state of disk ATO bit */	135	unsigned ATO : 1; /* state of disk ATO bit */
135	unsigned cache_override : 1; /* temp override of WCE,RCD */	136	unsigned cache_override : 1; /* temp override of WCE,RCD */
136	unsigned WCE : 1; /* state of disk WCE bit */	137	unsigned WCE : 1; /* state of disk WCE bit */

drivers/soc/imx/soc-imx8m.c+10−0

 {
 	void __iomem *ocotp_base;
 	struct device_node *np;
+	struct clk *clk;
 	u32 offset = of_machine_is_compatible("fsl,imx8mp") ?
 		     IMX8MP_OCOTP_UID_OFFSET : 0;
 	ocotp_base = of_iomap(np, 0);
 	WARN_ON(!ocotp_base);
+	clk = of_clk_get_by_name(np, NULL);
+	if (IS_ERR(clk)) {
+		WARN_ON(IS_ERR(clk));
+		return;
+	}
+	clk_prepare_enable(clk);
 	soc_uid = readl_relaxed(ocotp_base + OCOTP_UID_HIGH + offset);
 	soc_uid <<= 32;
 	soc_uid |= readl_relaxed(ocotp_base + OCOTP_UID_LOW + offset);
+	clk_disable_unprepare(clk);
+	clk_put(clk);
 	iounmap(ocotp_base);
 	of_node_put(np);
 }

drivers/soc/loongson/Kconfig+1−0

@@ -20,6 +20,7 @@ config LOONGSON2_GUTS · 19 unmodified lines
20	config LOONGSON2_PM	20	config LOONGSON2_PM
21	bool "Loongson-2 SoC Power Management Controller Driver"	21	bool "Loongson-2 SoC Power Management Controller Driver"
22	depends on LOONGARCH && OF	22	depends on LOONGARCH && OF
		23	depends on INPUT=y
23	help	24	help
24	The Loongson-2's power management controller was ACPI, supports ACPI	25	The Loongson-2's power management controller was ACPI, supports ACPI
25	S2Idle (Suspend To Idle), ACPI S3 (Suspend To RAM), ACPI S4 (Suspend To	26	S2Idle (Suspend To Idle), ACPI S3 (Suspend To RAM), ACPI S4 (Suspend To

drivers/soc/loongson/loongson2_guts.c+2−4

 		if (matches->svr == (svr & matches->mask))
 			return matches;
 		matches++;
-	};
+	}
 	return NULL;
 }
 {
 	struct device_node *root, *np = pdev->dev.of_node;
 	struct device *dev = &pdev->dev;
-	struct resource *res;
 	const struct loongson2_soc_die_attr *soc_die;
 	const char *machine;
 	u32 svr;
 	guts->little_endian = of_property_read_bool(np, "little-endian");
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	guts->regs = devm_platform_ioremap_resource(pdev, 0);
-	guts->regs = ioremap(res->start, res->end - res->start + 1);
 	if (IS_ERR(guts->regs))
 		return PTR_ERR(guts->regs);

drivers/soc/loongson/loongson2_pm.c+6−1

 #include <linux/input.h>
 #include <linux/suspend.h>
 #include <linux/interrupt.h>
+#include <linux/of_platform.h>
 #include <linux/pm_wakeirq.h>
 #include <linux/platform_device.h>
 #include <asm/bootinfo.h>
 	if (loongson_sysconf.suspend_addr)
 		suspend_set_ops(&loongson2_suspend_ops);
+	/* Populate children */
+	retval = devm_of_platform_populate(dev);
+	if (retval)
+		dev_err(dev, "Error populating children, reboot and poweroff might not work properly\n");
 	return 0;
 }
 static const struct of_device_id loongson2_pm_match[] = {
 	{ .compatible = "loongson,ls2k0500-pmc", },
-	{ .compatible = "loongson,ls2k1000-pmc", },
 	{},
 };

drivers/spi/spi-cs42l43.c+0−1

@@ -256,7 +256,6 @@ static int cs42l43_spi_probe(struct platform_device *pdev) · 255 unmodified lines
256		256
257	ret = devm_spi_register_controller(priv->dev, priv->ctlr);	257	ret = devm_spi_register_controller(priv->dev, priv->ctlr);
258	if (ret) {	258	if (ret) {
259	pm_runtime_disable(priv->dev);
260	dev_err(priv->dev, "Failed to register SPI controller: %d\n", ret);	259	dev_err(priv->dev, "Failed to register SPI controller: %d\n", ret);
261	}	260	}
262		261

drivers/spi/spi-gxp.c+1−1

@@ -194,7 +194,7 @@ static ssize_t gxp_spi_write(struct gxp_spi_chip *chip, const struct spi_mem_op · 193 unmodified lines
194	return ret;	194	return ret;
195	}	195	}
196		196
197	return write_len;	197	return 0;
198	}	198	}
199		199
200	static int do_gxp_exec_mem_op(struct spi_mem mem, const struct spi_mem_op op)	200	static int do_gxp_exec_mem_op(struct spi_mem mem, const struct spi_mem_op op)

drivers/target/target_core_device.c+4−7

 EXPORT_SYMBOL(target_to_linux_sector);
 struct devices_idr_iter {
-	struct config_item *prev_item;
 	int (*fn)(struct se_device *dev, void *data);
 	void *data;
 };
 {
 	struct devices_idr_iter *iter = data;
 	struct se_device *dev = p;
+	struct config_item *item;
 	int ret;
-	config_item_put(iter->prev_item);
-	iter->prev_item = NULL;
 	/*
 	 * We add the device early to the idr, so it can be used
 	 * by backend modules during configuration. We do not want
 	if (!target_dev_configured(dev))
 		return 0;
-	iter->prev_item = config_item_get_unless_zero(&dev->dev_group.cg_item);
+	item = config_item_get_unless_zero(&dev->dev_group.cg_item);
-	if (!iter->prev_item)
+	if (!item)
 		return 0;
 	mutex_unlock(&device_mutex);
 	ret = iter->fn(dev, iter->data);
+	config_item_put(item);
 	mutex_lock(&device_mutex);
 	return ret;
 	mutex_lock(&device_mutex);
 	ret = idr_for_each(&devices_idr, target_devices_idr_iter, &iter);
 	mutex_unlock(&device_mutex);
-	config_item_put(iter.prev_item);
 	return ret;
 }

drivers/tee/optee/optee_private.h+0−2

@@ -238,8 +238,6 @@ int optee_notif_send(struct optee *optee, u_int key); · 237 unmodified lines
238	u32 optee_supp_thrd_req(struct tee_context *ctx, u32 func, size_t num_params,	238	u32 optee_supp_thrd_req(struct tee_context *ctx, u32 func, size_t num_params,
239	struct tee_param *param);	239	struct tee_param *param);
240		240
241	int optee_supp_read(struct tee_context ctx, void __user buf, size_t len);
242	int optee_supp_write(struct tee_context ctx, void __user buf, size_t len);
243	void optee_supp_init(struct optee_supp *supp);	241	void optee_supp_init(struct optee_supp *supp);
244	void optee_supp_uninit(struct optee_supp *supp);	242	void optee_supp_uninit(struct optee_supp *supp);
245	void optee_supp_release(struct optee_supp *supp);	243	void optee_supp_release(struct optee_supp *supp);

drivers/tee/tee_private.h+0−2

@@ -47,8 +47,6 @@ struct tee_device { · 46 unmodified lines
47	struct tee_shm_pool *pool;	47	struct tee_shm_pool *pool;
48	};	48	};
49		49
50	int tee_shm_init(void);
51
52	int tee_shm_get_fd(struct tee_shm *shm);	50	int tee_shm_get_fd(struct tee_shm *shm);
53		51
54	bool tee_device_get(struct tee_device *teedev);	52	bool tee_device_get(struct tee_device *teedev);

drivers/thermal/thermal_sysfs.c+5−4

 	if (sscanf(attr->attr.name, "trip_point_%d_hyst", &trip_id) != 1)
 		return -EINVAL;
-	if (kstrtoint(buf, 10, &trip.hysteresis))
-		return -EINVAL;
 	mutex_lock(&tz->lock);
 	if (!device_is_registered(dev)) {
 	ret = __thermal_zone_get_trip(tz, trip_id, &trip);
 	if (ret)
 		goto unlock;
+	ret = kstrtoint(buf, 10, &trip.hysteresis);
+	if (ret)
+		goto unlock;
 	ret = thermal_zone_set_trip(tz, trip_id, &trip);
 unlock:
 	mutex_unlock(&tz->lock);

drivers/tty/n_gsm.c+1−3

 		gsm->has_devices = false;
 	}
 	for (i = NUM_DLCI - 1; i >= 0; i--)
-		if (gsm->dlci[i]) {
+		if (gsm->dlci[i])
 			gsm_dlci_release(gsm->dlci[i]);
-			gsm->dlci[i] = NULL;
-		}
 	mutex_unlock(&gsm->mutex);
 	/* Now wipe the queues */
 	tty_ldisc_flush(gsm->tty);

drivers/tty/serial/8250/8250_port.c+4−1

 		skip_rx = true;
 	if (status & (UART_LSR_DR | UART_LSR_BI) && !skip_rx) {
-		if (irqd_is_wakeup_set(irq_get_irq_data(port->irq)))
+		struct irq_data *d;
+		d = irq_get_irq_data(port->irq);
+		if (d && irqd_is_wakeup_set(d))
 			pm_wakeup_event(tport->tty->dev, 0);
 		if (!up->dma || handle_rx_dma(up, iir))
 			status = serial8250_rx_chars(up, status);

drivers/vfio/mdev/mdev_sysfs.c+2−1

@@ -233,7 +233,8 @@ int parent_create_sysfs_files(struct mdev_parent *parent) · 232 unmodified lines
233	out_err:	233	out_err:
234	while (--i >= 0)	234	while (--i >= 0)
235	mdev_type_remove(parent->types[i]);	235	mdev_type_remove(parent->types[i]);
236	return 0;	236	kset_unregister(parent->mdev_types_kset);
		237	return ret;
237	}	238	}
238		239
239	static ssize_t remove_store(struct device dev, struct device_attribute attr,	240	static ssize_t remove_store(struct device dev, struct device_attribute attr,

drivers/vfio/pci/pds/Kconfig+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3		3
4	config PDS_VFIO_PCI	4	config PDS_VFIO_PCI
5	tristate "VFIO support for PDS PCI devices"	5	tristate "VFIO support for PDS PCI devices"
6	depends on PDS_CORE	6	depends on PDS_CORE && PCI_IOV
7	select VFIO_PCI_CORE	7	select VFIO_PCI_CORE
8	help	8	help
9	This provides generic PCI support for PDS devices using the VFIO	9	This provides generic PCI support for PDS devices using the VFIO

drivers/vfio/pci/pds/vfio_dev.c+1−1

@@ -162,7 +162,7 @@ static int pds_vfio_init_device(struct vfio_device *vdev) · 161 unmodified lines
162	pci_id = PCI_DEVID(pdev->bus->number, pdev->devfn);	162	pci_id = PCI_DEVID(pdev->bus->number, pdev->devfn);
163	dev_dbg(&pdev->dev,	163	dev_dbg(&pdev->dev,
164	"%s: PF %#04x VF %#04x vf_id %d domain %d pds_vfio %p\n",	164	"%s: PF %#04x VF %#04x vf_id %d domain %d pds_vfio %p\n",
165	__func__, pci_dev_id(pdev->physfn), pci_id, vf_id,	165	__func__, pci_dev_id(pci_physfn(pdev)), pci_id, vf_id,
166	pci_domain_nr(pdev->bus), pds_vfio);	166	pci_domain_nr(pdev->bus), pds_vfio);
167		167
168	return 0;	168	return 0;

drivers/vhost/vringh.c+11−1

@@ -123,8 +123,18 @@ static inline ssize_t vringh_iov_xfer(struct vringh *vrh, · 122 unmodified lines
123	done += partlen;	123	done += partlen;
124	len -= partlen;	124	len -= partlen;
125	ptr += partlen;	125	ptr += partlen;
		126	iov->consumed += partlen;
		127	iov->iov[iov->i].iov_len -= partlen;
		128	iov->iov[iov->i].iov_base += partlen;
126		129
127	vringh_kiov_advance(iov, partlen);	130	if (!iov->iov[iov->i].iov_len) {
		131	/* Fix up old iov element then increment. */
		132	iov->iov[iov->i].iov_len = iov->consumed;
		133	iov->iov[iov->i].iov_base -= iov->consumed;
		134
		135	iov->consumed = 0;
		136	iov->i++;
		137	}
128	}	138	}
129	return done;	139	return done;
130	}	140	}

drivers/video/console/Kconfig+1−0

@@ -73,6 +73,7 @@ config DUMMY_CONSOLE_ROWS · 72 unmodified lines
73	config FRAMEBUFFER_CONSOLE	73	config FRAMEBUFFER_CONSOLE
74	bool "Framebuffer Console support"	74	bool "Framebuffer Console support"
75	depends on FB_CORE && !UML	75	depends on FB_CORE && !UML
		76	default DRM_FBDEV_EMULATION
76	select VT_HW_CONSOLE_BINDING	77	select VT_HW_CONSOLE_BINDING
77	select CRC32	78	select CRC32
78	select FONT_SUPPORT	79	select FONT_SUPPORT

drivers/video/fbdev/Kconfig+1−1

@@ -1762,7 +1762,7 @@ config FB_COBALT · 1761 unmodified lines
1762		1762
1763	config FB_SH7760	1763	config FB_SH7760
1764	bool "SH7760/SH7763/SH7720/SH7721 LCDC support"	1764	bool "SH7760/SH7763/SH7720/SH7721 LCDC support"
1765	depends on FB && (CPU_SUBTYPE_SH7760 \|\| CPU_SUBTYPE_SH7763 \	1765	depends on FB=y && (CPU_SUBTYPE_SH7760 \|\| CPU_SUBTYPE_SH7763 \
1766	\|\| CPU_SUBTYPE_SH7720 \|\| CPU_SUBTYPE_SH7721)	1766	\|\| CPU_SUBTYPE_SH7720 \|\| CPU_SUBTYPE_SH7721)
1767	select FB_IOMEM_HELPERS	1767	select FB_IOMEM_HELPERS
1768	help	1768	help

drivers/video/fbdev/core/Kconfig+1−1

@@ -28,7 +28,7 @@ config FIRMWARE_EDID · 27 unmodified lines
28	config FB_DEVICE	28	config FB_DEVICE
29	bool "Provide legacy /dev/fb* device"	29	bool "Provide legacy /dev/fb* device"
30	depends on FB_CORE	30	depends on FB_CORE
31	default y	31	default FB
32	help	32	help
33	Say Y here if you want the legacy /dev/fb* device file and	33	Say Y here if you want the legacy /dev/fb* device file and
34	interfaces within sysfs anc procfs. It is only required if you	34	interfaces within sysfs anc procfs. It is only required if you

fs/aio.c+1−1

@@ -80,7 +80,7 @@ struct aio_ring { · 79 unmodified lines
80	struct kioctx_table {	80	struct kioctx_table {
81	struct rcu_head rcu;	81	struct rcu_head rcu;
82	unsigned nr;	82	unsigned nr;
83	struct kioctx __rcu *table[];	83	struct kioctx __rcu *table[] __counted_by(nr);
84	};	84	};
85		85
86	struct kioctx_cpu {	86	struct kioctx_cpu {

fs/binfmt_elf_fdpic.c+2−3

 	/* there's now no turning back... the old userspace image is dead,
 	 * defunct, deceased, etc.
 	 */
+	SET_PERSONALITY(exec_params.hdr);
 	if (elf_check_fdpic(&exec_params.hdr))
-		set_personality(PER_LINUX_FDPIC);
+		current->personality |= PER_LINUX_FDPIC;
-	else
-		set_personality(PER_LINUX);
 	if (elf_read_implies_exec(&exec_params.hdr, executable_stack))
 		current->personality |= READ_IMPLIES_EXEC;

fs/btrfs/delayed-ref.c+35−11

@@ -103,24 +103,17 @@ void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans) · 102 unmodified lines
103	* Transfer bytes to our delayed refs rsv.	103	* Transfer bytes to our delayed refs rsv.
104	*	104	*
105	* @fs_info: the filesystem	105	* @fs_info: the filesystem
106	* @src: source block rsv to transfer from
107	* @num_bytes: number of bytes to transfer	106	* @num_bytes: number of bytes to transfer
108	*	107	*
109	* This transfers up to the num_bytes amount from the src rsv to the	108	* This transfers up to the num_bytes amount, previously reserved, to the
110	* delayed_refs_rsv. Any extra bytes are returned to the space info.	109	* delayed_refs_rsv. Any extra bytes are returned to the space info.
111	*/	110	*/
112	void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,	111	void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,
113	struct btrfs_block_rsv *src,
114	u64 num_bytes)	112	u64 num_bytes)
115	{	113	{
116	struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;	114	struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
117	u64 to_free = 0;	115	u64 to_free = 0;
118		116
119	spin_lock(&src->lock);
120	src->reserved -= num_bytes;
121	src->size -= num_bytes;
122	spin_unlock(&src->lock);
123
124	spin_lock(&delayed_refs_rsv->lock);	117	spin_lock(&delayed_refs_rsv->lock);
125	if (delayed_refs_rsv->size > delayed_refs_rsv->reserved) {	118	if (delayed_refs_rsv->size > delayed_refs_rsv->reserved) {
126	u64 delta = delayed_refs_rsv->size -	119	u64 delta = delayed_refs_rsv->size -
@@ -163,6 +156,8 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info, · 36 unmodified lines
163	struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;	156	struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;
164	u64 limit = btrfs_calc_delayed_ref_bytes(fs_info, 1);	157	u64 limit = btrfs_calc_delayed_ref_bytes(fs_info, 1);
165	u64 num_bytes = 0;	158	u64 num_bytes = 0;
		159	u64 refilled_bytes;
		160	u64 to_free;
166	int ret = -ENOSPC;	161	int ret = -ENOSPC;
167		162
168	spin_lock(&block_rsv->lock);	163	spin_lock(&block_rsv->lock);
@@ -178,9 +173,38 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info, · 9 unmodified lines
178	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);	173	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);
179	if (ret)	174	if (ret)
180	return ret;	175	return ret;
181	btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);	176
182	trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",	177	/*
183	0, num_bytes, 1);	178	* We may have raced with someone else, so check again if we the block
		179	* reserve is still not full and release any excess space.
		180	*/
		181	spin_lock(&block_rsv->lock);
		182	if (block_rsv->reserved < block_rsv->size) {
		183	u64 needed = block_rsv->size - block_rsv->reserved;
		184
		185	if (num_bytes >= needed) {
		186	block_rsv->reserved += needed;
		187	block_rsv->full = true;
		188	to_free = num_bytes - needed;
		189	refilled_bytes = needed;
		190	} else {
		191	block_rsv->reserved += num_bytes;
		192	to_free = 0;
		193	refilled_bytes = num_bytes;
		194	}
		195	} else {
		196	to_free = num_bytes;
		197	refilled_bytes = 0;
		198	}
		199	spin_unlock(&block_rsv->lock);
		200
		201	if (to_free > 0)
		202	btrfs_space_info_free_bytes_may_use(fs_info, block_rsv->space_info,
		203	to_free);
		204
		205	if (refilled_bytes > 0)
		206	trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv", 0,
		207	refilled_bytes, 1);
184	return 0;	208	return 0;
185	}	209	}
186		210

fs/btrfs/delayed-ref.h+0−1

@@ -407,7 +407,6 @@ void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans); · 406 unmodified lines
407	int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,	407	int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
408	enum btrfs_reserve_flush_enum flush);	408	enum btrfs_reserve_flush_enum flush);
409	void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,	409	void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,
410	struct btrfs_block_rsv *src,
411	u64 num_bytes);	410	u64 num_bytes);
412	bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info);	411	bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info);
413		412

fs/btrfs/extent-tree.c+10−8

@@ -1514,15 +1514,14 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, · 1513 unmodified lines
1514	btrfs_release_path(path);	1514	btrfs_release_path(path);
1515		1515
1516	/* now insert the actual backref */	1516	/* now insert the actual backref */
1517	if (owner < BTRFS_FIRST_FREE_OBJECTID) {	1517	if (owner < BTRFS_FIRST_FREE_OBJECTID)
1518	BUG_ON(refs_to_add != 1);
1519	ret = insert_tree_block_ref(trans, path, bytenr, parent,	1518	ret = insert_tree_block_ref(trans, path, bytenr, parent,
1520	root_objectid);	1519	root_objectid);
1521	} else {	1520	else
1522	ret = insert_extent_data_ref(trans, path, bytenr, parent,	1521	ret = insert_extent_data_ref(trans, path, bytenr, parent,
1523	root_objectid, owner, offset,	1522	root_objectid, owner, offset,
1524	refs_to_add);	1523	refs_to_add);
1525	}	1524
1526	if (ret)	1525	if (ret)
1527	btrfs_abort_transaction(trans, ret);	1526	btrfs_abort_transaction(trans, ret);
1528	out:	1527	out:
@@ -1656,7 +1655,10 @@ again: · 127 unmodified lines
1656	goto again;	1655	goto again;
1657	}	1656	}
1658	} else {	1657	} else {
1659	err = -EIO;	1658	err = -EUCLEAN;
		1659	btrfs_err(fs_info,
		1660	"missing extent item for extent %llu num_bytes %llu level %d",
		1661	head->bytenr, head->num_bytes, extent_op->level);
1660	goto out;	1662	goto out;
1661	}	1663	}
1662	}	1664	}
@@ -1699,12 +1701,12 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans, · 36 unmodified lines
1699	parent = ref->parent;	1701	parent = ref->parent;
1700	ref_root = ref->root;	1702	ref_root = ref->root;
1701		1703
1702	if (node->ref_mod != 1) {	1704	if (unlikely(node->ref_mod != 1)) {
1703	btrfs_err(trans->fs_info,	1705	btrfs_err(trans->fs_info,
1704	"btree block(%llu) has %d references rather than 1: action %d ref_root %llu parent %llu",	1706	"btree block %llu has %d references rather than 1: action %d ref_root %llu parent %llu",
1705	node->bytenr, node->ref_mod, node->action, ref_root,	1707	node->bytenr, node->ref_mod, node->action, ref_root,
1706	parent);	1708	parent);
1707	return -EIO;	1709	return -EUCLEAN;
1708	}	1710	}
1709	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {	1711	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1710	BUG_ON(!extent_op \|\| !extent_op->update_flags);	1712	BUG_ON(!extent_op \|\| !extent_op->update_flags);

fs/btrfs/extent_io.c+7−1

 	char *dst = (char *)dstv;
 	unsigned long i = get_eb_page_index(start);
-	if (check_eb_range(eb, start, len))
+	if (check_eb_range(eb, start, len)) {
+		/*
+		 * Invalid range hit, reset the memory, so callers won't get
+		 * some random garbage for their uninitialzed memory.
+		 */
+		memset(dstv, 0, len);
 		return;
+	}
 	offset = get_eb_offset_in_page(eb, start);

fs/btrfs/super.c+1−1

@@ -2117,7 +2117,7 @@ static int btrfs_statfs(struct dentry dentry, struct kstatfs buf) · 2116 unmodified lines
2117	* calculated f_bavail.	2117	* calculated f_bavail.
2118	*/	2118	*/
2119	if (!mixed && block_rsv->space_info->full &&	2119	if (!mixed && block_rsv->space_info->full &&
2120	total_free_meta - thresh < block_rsv->size)	2120	(total_free_meta < thresh \|\| total_free_meta - thresh < block_rsv->size))
2121	buf->f_bavail = 0;	2121	buf->f_bavail = 0;
2122		2122
2123	buf->f_type = BTRFS_SUPER_MAGIC;	2123	buf->f_type = BTRFS_SUPER_MAGIC;

fs/btrfs/transaction.c+3−3

 			reloc_reserved = true;
 		}
-		ret = btrfs_block_rsv_add(fs_info, rsv, num_bytes, flush);
+		ret = btrfs_reserve_metadata_bytes(fs_info, rsv, num_bytes, flush);
 		if (ret)
 			goto reserve_fail;
 		if (delayed_refs_bytes) {
-			btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv,
+			btrfs_migrate_to_delayed_refs_rsv(fs_info, delayed_refs_bytes);
-							  delayed_refs_bytes);
 			num_bytes -= delayed_refs_bytes;
 		}
+		btrfs_block_rsv_add_bytes(rsv, num_bytes, true);
 		if (rsv->space_info->force_alloc)
 			do_chunk_alloc = true;

fs/btrfs/tree-log.c+1−1

@@ -4722,7 +4722,7 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 4721 unmodified lines
4722	struct extent_buffer *leaf;	4722	struct extent_buffer *leaf;
4723	int slot;	4723	int slot;
4724	int ins_nr = 0;	4724	int ins_nr = 0;
4725	int start_slot;	4725	int start_slot = 0;
4726	int ret;	4726	int ret;
4727		4727
4728	if (!(inode->flags & BTRFS_INODE_PREALLOC))	4728	if (!(inode->flags & BTRFS_INODE_PREALLOC))

fs/btrfs/volumes.c+6−7

@@ -1594,7 +1594,7 @@ static int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes, · 1593 unmodified lines
1594	u64 search_start;	1594	u64 search_start;
1595	u64 hole_size;	1595	u64 hole_size;
1596	u64 max_hole_start;	1596	u64 max_hole_start;
1597	u64 max_hole_size;	1597	u64 max_hole_size = 0;
1598	u64 extent_end;	1598	u64 extent_end;
1599	u64 search_end = device->total_bytes;	1599	u64 search_end = device->total_bytes;
1600	int ret;	1600	int ret;
@@ -1602,17 +1602,16 @@ static int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes, · 1 unmodified line
1602	struct extent_buffer *l;	1602	struct extent_buffer *l;
1603		1603
1604	search_start = dev_extent_search_start(device);	1604	search_start = dev_extent_search_start(device);
		1605	max_hole_start = search_start;
1605		1606
1606	WARN_ON(device->zone_info &&	1607	WARN_ON(device->zone_info &&
1607	!IS_ALIGNED(num_bytes, device->zone_info->zone_size));	1608	!IS_ALIGNED(num_bytes, device->zone_info->zone_size));
1608		1609
1609	path = btrfs_alloc_path();	1610	path = btrfs_alloc_path();
1610	if (!path)	1611	if (!path) {
1611	return -ENOMEM;	1612	ret = -ENOMEM;
1612		1613	goto out;
1613	max_hole_start = search_start;	1614	}
1614	max_hole_size = 0;
1615
1616	again:	1615	again:
1617	if (search_start >= search_end \|\|	1616	if (search_start >= search_end \|\|
1618	test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) {	1617	test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) {

fs/buffer.c+24−12

 }
 EXPORT_SYMBOL(folio_zero_new_buffers);
-static void
+static int
 iomap_to_bh(struct inode *inode, sector_t block, struct buffer_head *bh,
 		const struct iomap *iomap)
 {
 	 * current block, then do not map the buffer and let the caller
 	 * handle it.
 	 */
-	BUG_ON(offset >= iomap->offset + iomap->length);
+	if (offset >= iomap->offset + iomap->length)
+		return -EIO;
 	switch (iomap->type) {
 	case IOMAP_HOLE:
 		if (!buffer_uptodate(bh) ||
 		    (offset >= i_size_read(inode)))
 			set_buffer_new(bh);
-		break;
+		return 0;
 	case IOMAP_DELALLOC:
 		if (!buffer_uptodate(bh) ||
 		    (offset >= i_size_read(inode)))
 		set_buffer_uptodate(bh);
 		set_buffer_mapped(bh);
 		set_buffer_delay(bh);
-		break;
+		return 0;
 	case IOMAP_UNWRITTEN:
 		/*
 		 * For unwritten regions, we always need to ensure that regions
 		fallthrough;
 	case IOMAP_MAPPED:
 		if ((iomap->flags & IOMAP_F_NEW) ||
-		    offset >= i_size_read(inode))
+		    offset >= i_size_read(inode)) {
+			/*
+			 * This can happen if truncating the block device races
+			 * with the check in the caller as i_size updates on
+			 * block devices aren't synchronized by i_rwsem for
+			 * block devices.
+			 */
+			if (S_ISBLK(inode->i_mode))
+				return -EIO;
 			set_buffer_new(bh);
+		}
 		bh->b_blocknr = (iomap->addr + offset - iomap->offset) >>
 				inode->i_blkbits;
 		set_buffer_mapped(bh);
-		break;
+		return 0;
+	default:
+		WARN_ON_ONCE(1);
+		return -EIO;
 	}
 }
 			clear_buffer_new(bh);
 		if (!buffer_mapped(bh)) {
 			WARN_ON(bh->b_size != blocksize);
-			if (get_block) {
+			if (get_block)
 				err = get_block(inode, block, bh, 1);
-				if (err)
+			else
-					break;
+				err = iomap_to_bh(inode, block, bh, iomap);
-			} else {
+			if (err)
-				iomap_to_bh(inode, block, bh, iomap);
+				break;
-			}
 			if (buffer_new(bh)) {
 				clean_bdev_bh_alias(bh);

fs/ceph/crypto.c+2−4

 	if (!dir) {
 		/* This can happen if we're not mounting cephfs on the root */
 		dir = ceph_get_inode(parent->i_sb, vino, NULL);
-		if (!dir)
+		if (IS_ERR(dir))
-			dir = ERR_PTR(-ENOENT);
+			dout("Can't find inode %s (%s)\n", inode_number, name);
 	}
-	if (IS_ERR(dir))
-		dout("Can't find inode %s (%s)\n", inode_number, name);
 out:
 	kfree(inode_number);

fs/fs-writeback.c+8−3

 	if (wbc->pages_skipped) {
 		/*
-		 * writeback is not making progress due to locked
+		 * Writeback is not making progress due to locked buffers.
-		 * buffers. Skip this inode for now.
+		 * Skip this inode for now. Although having skipped pages
+		 * is odd for clean inodes, it can happen for some
+		 * filesystems so handle that gracefully.
 		 */
-		redirty_tail_locked(inode, wb);
+		if (inode->i_state & I_DIRTY_ALL)
+			redirty_tail_locked(inode, wb);
+		else
+			inode_cgwb_move_to_attached(inode, wb);
 		return;
 	}

fs/iomap/buffered-io.c+19−13

 	size_t poff, plen;
 	/*
-	 * If the write completely overlaps the current folio, then
+	 * If the write or zeroing completely overlaps the current folio, then
 	 * entire folio will be dirtied so there is no need for
 	 * per-block state tracking structures to be attached to this folio.
+	 * For the unshare case, we must read in the ondisk contents because we
+	 * are not changing pagecache contents.
 	 */
-	if (pos <= folio_pos(folio) &&
+	if (!(iter->flags & IOMAP_UNSHARE) && pos <= folio_pos(folio) &&
 	    pos + len >= folio_pos(folio) + folio_size(folio))
 		return 0;
 /*
  * Scan the data range passed to us for dirty page cache folios. If we find a
- * dirty folio, punch out the preceeding range and update the offset from which
+ * dirty folio, punch out the preceding range and update the offset from which
  * the next punch will start from.
  *
  * We can punch out storage reservations under clean pages because they either
 	const struct iomap *srcmap = iomap_iter_srcmap(iter);
 	loff_t pos = iter->pos;
 	loff_t length = iomap_length(iter);
-	long status = 0;
 	loff_t written = 0;
 	/* don't bother with blocks that are not shared to start with */
 		return length;
 	do {
-		unsigned long offset = offset_in_page(pos);
-		unsigned long bytes = min_t(loff_t, PAGE_SIZE - offset, length);
 		struct folio *folio;
+		int status;
+		size_t offset;
+		size_t bytes = min_t(u64, SIZE_MAX, length);
 		status = iomap_write_begin(iter, pos, bytes, &folio);
 		if (unlikely(status))
 			return status;
-		if (iter->iomap.flags & IOMAP_F_STALE)
+		if (iomap->flags & IOMAP_F_STALE)
 			break;
-		status = iomap_write_end(iter, pos, bytes, bytes, folio);
+		offset = offset_in_folio(folio, pos);
-		if (WARN_ON_ONCE(status == 0))
+		if (bytes > folio_size(folio) - offset)
+			bytes = folio_size(folio) - offset;
+		bytes = iomap_write_end(iter, pos, bytes, bytes, folio);
+		if (WARN_ON_ONCE(bytes == 0))
 			return -EIO;
 		cond_resched();
-		pos += status;
+		pos += bytes;
-		written += status;
+		written += bytes;
-		length -= status;
+		length -= bytes;
 		balance_dirty_pages_ratelimited(iter->inode->i_mapping);
-	} while (length);
+	} while (length > 0);
 	return written;
 }

fs/libfs.c+1−0

@@ -1903,6 +1903,7 @@ ssize_t direct_write_fallback(struct kiocb iocb, struct iov_iter iter, · 1902 unmodified lines
1903	* We don't know how much we wrote, so just return the number of	1903	* We don't know how much we wrote, so just return the number of
1904	* bytes which were direct-written	1904	* bytes which were direct-written
1905	*/	1905	*/
		1906	iocb->ki_pos -= buffered_written;
1906	if (direct_written)	1907	if (direct_written)
1907	return direct_written;	1908	return direct_written;
1908	return err;	1909	return err;

fs/nfs/nfs4proc.c+3−1

@@ -10622,7 +10622,9 @@ static void nfs4_disable_swap(struct inode *inode) · 10621 unmodified lines
10622	*/	10622	*/
10623	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;	10623	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
10624		10624
10625	nfs4_schedule_state_manager(clp);	10625	set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
		10626	clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
		10627	wake_up_var(&clp->cl_state);
10626	}	10628	}
10627		10629
10628	static const struct inode_operations nfs4_dir_inode_operations = {	10630	static const struct inode_operations nfs4_dir_inode_operations = {

fs/nfs/nfs4state.c+33−12

@@ -1209,16 +1209,26 @@ void nfs4_schedule_state_manager(struct nfs_client *clp) · 1208 unmodified lines
1209	{	1209	{
1210	struct task_struct *task;	1210	struct task_struct *task;
1211	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];	1211	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
		1212	struct rpc_clnt *clnt = clp->cl_rpcclient;
		1213	bool swapon = false;
1212		1214
1213	if (clp->cl_rpcclient->cl_shutdown)	1215	if (clnt->cl_shutdown)
1214	return;	1216	return;
1215		1217
1216	set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);	1218	set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
1217	if (test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) != 0) {	1219
1218	wake_up_var(&clp->cl_state);	1220	if (atomic_read(&clnt->cl_swapper)) {
1219	return;	1221	swapon = !test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE,
		1222	&clp->cl_state);
		1223	if (!swapon) {
		1224	wake_up_var(&clp->cl_state);
		1225	return;
		1226	}
1220	}	1227	}
1221	set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);	1228
		1229	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		1230	return;
		1231
1222	__module_get(THIS_MODULE);	1232	__module_get(THIS_MODULE);
1223	refcount_inc(&clp->cl_count);	1233	refcount_inc(&clp->cl_count);
1224		1234
@@ -1235,8 +1245,9 @@ void nfs4_schedule_state_manager(struct nfs_client *clp) · 10 unmodified lines
1235	__func__, PTR_ERR(task));	1245	__func__, PTR_ERR(task));
1236	if (!nfs_client_init_is_complete(clp))	1246	if (!nfs_client_init_is_complete(clp))
1237	nfs_mark_client_ready(clp, PTR_ERR(task));	1247	nfs_mark_client_ready(clp, PTR_ERR(task));
		1248	if (swapon)
		1249	clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
1238	nfs4_clear_state_manager_bit(clp);	1250	nfs4_clear_state_manager_bit(clp);
1239	clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
1240	nfs_put_client(clp);	1251	nfs_put_client(clp);
1241	module_put(THIS_MODULE);	1252	module_put(THIS_MODULE);
1242	}	1253	}
@@ -2703,6 +2714,13 @@ static void nfs4_state_manager(struct nfs_client *clp) · 1460 unmodified lines
2703	nfs4_end_drain_session(clp);	2714	nfs4_end_drain_session(clp);
2704	nfs4_clear_state_manager_bit(clp);	2715	nfs4_clear_state_manager_bit(clp);
2705		2716
		2717	if (test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
		2718	!test_and_set_bit(NFS4CLNT_MANAGER_RUNNING,
		2719	&clp->cl_state)) {
		2720	memflags = memalloc_nofs_save();
		2721	continue;
		2722	}
		2723
2706	if (!test_and_set_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state)) {	2724	if (!test_and_set_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state)) {
2707	if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {	2725	if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2708	nfs_client_return_marked_delegations(clp);	2726	nfs_client_return_marked_delegations(clp);
@@ -2741,22 +2759,25 @@ static int nfs4_run_state_manager(void *ptr) · 32 unmodified lines
2741		2759
2742	allow_signal(SIGKILL);	2760	allow_signal(SIGKILL);
2743	again:	2761	again:
2744	set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
2745	nfs4_state_manager(clp);	2762	nfs4_state_manager(clp);
2746	if (atomic_read(&cl->cl_swapper)) {	2763
		2764	if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) &&
		2765	!test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) {
2747	wait_var_event_interruptible(&clp->cl_state,	2766	wait_var_event_interruptible(&clp->cl_state,
2748	test_bit(NFS4CLNT_RUN_MANAGER,	2767	test_bit(NFS4CLNT_RUN_MANAGER,
2749	&clp->cl_state));	2768	&clp->cl_state));
2750	if (atomic_read(&cl->cl_swapper) &&	2769	if (!atomic_read(&cl->cl_swapper))
2751	test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state))	2770	clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
		2771	if (refcount_read(&clp->cl_count) > 1 && !signalled() &&
		2772	!test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state))
2752	goto again;	2773	goto again;
2753	/* Either no longer a swapper, or were signalled */	2774	/* Either no longer a swapper, or were signalled */
		2775	clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
2754	}	2776	}
2755	clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
2756		2777
2757	if (refcount_read(&clp->cl_count) > 1 && !signalled() &&	2778	if (refcount_read(&clp->cl_count) > 1 && !signalled() &&
2758	test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&	2779	test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2759	!test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state))	2780	!test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state))
2760	goto again;	2781	goto again;
2761		2782
2762	nfs_put_client(clp);	2783	nfs_put_client(clp);

fs/nfs/write.c+1−1

@@ -802,8 +802,8 @@ static void nfs_inode_remove_request(struct nfs_page *req) · 801 unmodified lines
802	}	802	}
803		803
804	if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags)) {	804	if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags)) {
805	nfs_release_request(req);
806	atomic_long_dec(&NFS_I(nfs_page_to_inode(req))->nrequests);	805	atomic_long_dec(&NFS_I(nfs_page_to_inode(req))->nrequests);
		806	nfs_release_request(req);
807	}	807	}
808	}	808	}
809		809

fs/nfsd/nfs4xdr.c+2−2

 				 struct file *file, unsigned long maxcount)
 {
 	struct xdr_stream *xdr = resp->xdr;
+	unsigned int base = xdr->buf->page_len & ~PAGE_MASK;
 	unsigned int starting_len = xdr->buf->len;
 	__be32 zero = xdr_zero;
 	__be32 nfserr;
 		return nfserr_resource;
 	nfserr = nfsd_iter_read(resp->rqstp, read->rd_fhp, file,
-				read->rd_offset, &maxcount,
+				read->rd_offset, &maxcount, base,
-				xdr->buf->page_len & ~PAGE_MASK,
 				&read->rd_eof);
 	read->rd_length = maxcount;
 	if (nfserr)

fs/nilfs2/gcinode.c+3−3

 		struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
 		err = nilfs_dat_translate(nilfs->ns_dat, vbn, &pbn);
-		if (unlikely(err)) { /* -EIO, -ENOMEM, -ENOENT */
+		if (unlikely(err)) /* -EIO, -ENOMEM, -ENOENT */
-			brelse(bh);
 			goto failed;
-		}
 	}
 	lock_buffer(bh);
  failed:
 	unlock_page(bh->b_page);
 	put_page(bh->b_page);
+	if (unlikely(err))
+		brelse(bh);
 	return err;
 }

fs/ntfs3/super.c+1−0

@@ -1562,6 +1562,7 @@ load_root: · 1561 unmodified lines
1562	put_inode_out:	1562	put_inode_out:
1563	iput(inode);	1563	iput(inode);
1564	out:	1564	out:
		1565	ntfs3_put_sbi(sbi);
1565	kfree(boot2);	1566	kfree(boot2);
1566	return err;	1567	return err;
1567	}	1568	}

fs/overlayfs/copy_up.c+1−1

@@ -337,7 +337,7 @@ static int ovl_set_timestamps(struct ovl_fs ofs, struct dentry upperdentry, · 336 unmodified lines
337	{	337	{
338	struct iattr attr = {	338	struct iattr attr = {
339	.ia_valid =	339	.ia_valid =
340	ATTR_ATIME \| ATTR_MTIME \| ATTR_ATIME_SET \| ATTR_MTIME_SET,	340	ATTR_ATIME \| ATTR_MTIME \| ATTR_ATIME_SET \| ATTR_MTIME_SET \| ATTR_CTIME,
341	.ia_atime = stat->atime,	341	.ia_atime = stat->atime,
342	.ia_mtime = stat->mtime,	342	.ia_mtime = stat->mtime,
343	};	343	};

fs/overlayfs/export.c+1−1

@@ -188,7 +188,7 @@ static int ovl_check_encode_origin(struct dentry *dentry) · 187 unmodified lines
188		188
189	/* Lower file handle for non-upper non-decodable */	189	/* Lower file handle for non-upper non-decodable */
190	if (!ovl_dentry_upper(dentry) && !decodable)	190	if (!ovl_dentry_upper(dentry) && !decodable)
191	return 0;	191	return 1;
192		192
193	/* Upper file handle for pure upper */	193	/* Upper file handle for pure upper */
194	if (!ovl_dentry_lower(dentry))	194	if (!ovl_dentry_lower(dentry))

fs/overlayfs/file.c+6−2

 		if (!aio_req)
 			goto out;
-		real.flags = 0;
 		aio_req->orig_iocb = iocb;
 		kiocb_clone(&aio_req->iocb, iocb, get_file(real.file));
 		aio_req->iocb.ki_complete = ovl_aio_rw_complete;
 	if (!ovl_should_sync(OVL_FS(inode->i_sb)))
 		ifl &= ~(IOCB_DSYNC | IOCB_SYNC);
+	/*
+	 * Overlayfs doesn't support deferred completions, don't copy
+	 * this property in case it is set by the issuer.
+	 */
+	ifl &= ~IOCB_DIO_CALLER_COMP;
 	old_cred = ovl_override_creds(file_inode(file)->i_sb);
 	if (is_sync_kiocb(iocb)) {
 		file_start_write(real.file);
 		if (!aio_req)
 			goto out;
-		real.flags = 0;
 		aio_req->orig_iocb = iocb;
 		kiocb_clone(&aio_req->iocb, iocb, get_file(real.file));
 		aio_req->iocb.ki_flags = ifl;

fs/overlayfs/ovl_entry.h+1−9

 struct ovl_config {
 	char *upperdir;
 	char *workdir;
+	char **lowerdirs;
 	bool default_permissions;
 	int redirect_mode;
 	int verity_mode;
 	int idx;
 	/* One fsid per unique underlying sb (upper fsid == 0) */
 	int fsid;
-	char *name;
 };
-/*
- * ovl_free_fs() relies on @mnt being the first member when unmounting
- * the private mounts created for each layer. Let's check both the
- * offset and type.
- */
-static_assert(offsetof(struct ovl_layer, mnt) == 0);
-static_assert(__same_type(typeof_member(struct ovl_layer, mnt), struct vfsmount *));
 struct ovl_path {
 	const struct ovl_layer *layer;
 	struct dentry *dentry;

fs/overlayfs/params.c+9−8

 	if (ofs->upperdir_locked)
 		ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root);
-	/* Hack!  Reuse ofs->layers as a vfsmount array before freeing it */
+	/* Reuse ofs->config.lowerdirs as a vfsmount array before freeing it */
-	mounts = (struct vfsmount **) ofs->layers;
+	mounts = (struct vfsmount **) ofs->config.lowerdirs;
 	for (i = 0; i < ofs->numlayer; i++) {
 		iput(ofs->layers[i].trap);
+		kfree(ofs->config.lowerdirs[i]);
 		mounts[i] = ofs->layers[i].mnt;
-		kfree(ofs->layers[i].name);
 	}
 	kern_unmount_array(mounts, ofs->numlayer);
 	kfree(ofs->layers);
 		free_anon_bdev(ofs->fs[i].pseudo_dev);
 	kfree(ofs->fs);
+	kfree(ofs->config.lowerdirs);
 	kfree(ofs->config.upperdir);
 	kfree(ofs->config.workdir);
 	if (ofs->creator_cred)
 	struct super_block *sb = dentry->d_sb;
 	struct ovl_fs *ofs = OVL_FS(sb);
 	size_t nr, nr_merged_lower = ofs->numlayer - ofs->numdatalayer;
-	const struct ovl_layer *data_layers = &ofs->layers[nr_merged_lower];
+	char **lowerdatadirs = &ofs->config.lowerdirs[nr_merged_lower];
-	/* ofs->layers[0] is the upper layer */
+	/* lowerdirs[] starts from offset 1 */
-	seq_printf(m, ",lowerdir=%s", ofs->layers[1].name);
+	seq_printf(m, ",lowerdir=%s", ofs->config.lowerdirs[1]);
 	/* dump regular lower layers */
 	for (nr = 2; nr < nr_merged_lower; nr++)
-		seq_printf(m, ":%s", ofs->layers[nr].name);
+		seq_printf(m, ":%s", ofs->config.lowerdirs[nr]);
 	/* dump data lower layers */
 	for (nr = 0; nr < ofs->numdatalayer; nr++)
-		seq_printf(m, "::%s", data_layers[nr].name);
+		seq_printf(m, "::%s", lowerdatadirs[nr]);
 	if (ofs->config.upperdir) {
 		seq_show_option(m, "upperdir", ofs->config.upperdir);
 		seq_show_option(m, "workdir", ofs->config.workdir);

fs/overlayfs/super.c+17−10

 static int ovl_dentry_revalidate_common(struct dentry *dentry,
 					unsigned int flags, bool weak)
 {
-	struct ovl_entry *oe = OVL_E(dentry);
+	struct ovl_entry *oe;
-	struct ovl_path *lowerstack = ovl_lowerstack(oe);
+	struct ovl_path *lowerstack;
 	struct inode *inode = d_inode_rcu(dentry);
 	struct dentry *upper;
 	unsigned int i;
 	if (!inode)
 		return -ECHILD;
+	oe = OVL_I_E(inode);
+	lowerstack = ovl_lowerstack(oe);
 	upper = ovl_i_dentry_upper(inode);
 	if (upper)
 		ret = ovl_revalidate_real(upper, flags, weak);
 	struct ovl_inode *oi = OVL_I(inode);
 	kfree(oi->redirect);
+	kfree(oi->oe);
 	mutex_destroy(&oi->lock);
 	kmem_cache_free(ovl_inode_cachep, oi);
 }
 	struct ovl_inode *oi = OVL_I(inode);
 	dput(oi->__upperdentry);
-	ovl_free_entry(oi->oe);
+	ovl_stack_put(ovl_lowerstack(oi->oe), ovl_numlower(oi->oe));
 	if (S_ISDIR(inode->i_mode))
 		ovl_dir_cache_free(inode);
 	else
 	upper_layer->idx = 0;
 	upper_layer->fsid = 0;
-	err = -ENOMEM;
-	upper_layer->name = kstrdup(ofs->config.upperdir, GFP_KERNEL);
-	if (!upper_layer->name)
-		goto out;
 	/*
 	 * Inherit SB_NOSEC flag from upperdir.
 	 *
 		layers[ofs->numlayer].idx = ofs->numlayer;
 		layers[ofs->numlayer].fsid = fsid;
 		layers[ofs->numlayer].fs = &ofs->fs[fsid];
-		layers[ofs->numlayer].name = l->name;
+		/* Store for printing lowerdir=... in ovl_show_options() */
+		ofs->config.lowerdirs[ofs->numlayer] = l->name;
 		l->name = NULL;
 		ofs->numlayer++;
 		ofs->fs[fsid].is_lower = true;
 	if (!layers)
 		goto out_err;
+	ofs->config.lowerdirs = kcalloc(ctx->nr + 1, sizeof(char *), GFP_KERNEL);
+	if (!ofs->config.lowerdirs) {
+		kfree(layers);
+		goto out_err;
+	}
 	ofs->layers = layers;
-	/* Layer 0 is reserved for upper even if there's no upper */
+	/*
+	 * Layer 0 is reserved for upper even if there's no upper.
+	 * For consistency, config.lowerdirs[0] is NULL.
+	 */
 	ofs->numlayer = 1;
 	sb->s_stack_depth = 0;

fs/pipe.c+0−1

@@ -537,7 +537,6 @@ pipe_write(struct kiocb iocb, struct iov_iter from) · 536 unmodified lines
537	break;	537	break;
538	}	538	}
539	ret += copied;	539	ret += copied;
540	buf->offset = 0;
541	buf->len = copied;	540	buf->len = copied;
542		541
543	if (!iov_iter_count(from))	542	if (!iov_iter_count(from))

fs/proc/internal.h+0−2

 	struct inode *inode;
 	struct task_struct *task;
 	struct mm_struct *mm;
-#ifdef CONFIG_MMU
 	struct vma_iterator iter;
-#endif
 #ifdef CONFIG_NUMA
 	struct mempolicy *task_mempolicy;
 #endif

fs/proc/task_nommu.c+37−27

@@ -175,15 +175,28 @@ static int show_map(struct seq_file m, void _p) · 174 unmodified lines
175	return nommu_vma_show(m, _p);	175	return nommu_vma_show(m, _p);
176	}	176	}
177		177
178	static void m_start(struct seq_file m, loff_t *pos)	178	static struct vm_area_struct proc_get_vma(struct proc_maps_private priv,
		179	loff_t *ppos)
		180	{
		181	struct vm_area_struct *vma = vma_next(&priv->iter);
		182
		183	if (vma) {
		184	*ppos = vma->vm_start;
		185	} else {
		186	*ppos = -1UL;
		187	}
		188
		189	return vma;
		190	}
		191
		192	static void m_start(struct seq_file m, loff_t *ppos)
179	{	193	{
180	struct proc_maps_private *priv = m->private;	194	struct proc_maps_private *priv = m->private;
		195	unsigned long last_addr = *ppos;
181	struct mm_struct *mm;	196	struct mm_struct *mm;
182	struct vm_area_struct *vma;
183	unsigned long addr = *pos;
184		197
185	/* See m_next(). Zero at the start or after lseek. */	198	/* See proc_get_vma(). Zero at the start or after lseek. */
186	if (addr == -1UL)	199	if (last_addr == -1UL)
187	return NULL;	200	return NULL;
188		201
189	/* pin the task and mm whilst we play with them */	202	/* pin the task and mm whilst we play with them */
@@ -192,44 +205,41 @@ static void m_start(struct seq_file m, loff_t *pos) · 2 unmodified lines
192	return ERR_PTR(-ESRCH);	205	return ERR_PTR(-ESRCH);
193		206
194	mm = priv->mm;	207	mm = priv->mm;
195	if (!mm \|\| !mmget_not_zero(mm))	208	if (!mm \|\| !mmget_not_zero(mm)) {
		209	put_task_struct(priv->task);
		210	priv->task = NULL;
196	return NULL;	211	return NULL;
		212	}
197		213
198	if (mmap_read_lock_killable(mm)) {	214	if (mmap_read_lock_killable(mm)) {
199	mmput(mm);	215	mmput(mm);
		216	put_task_struct(priv->task);
		217	priv->task = NULL;
200	return ERR_PTR(-EINTR);	218	return ERR_PTR(-EINTR);
201	}	219	}
202		220
203	/* start the next element from addr */	221	vma_iter_init(&priv->iter, mm, last_addr);
204	vma = find_vma(mm, addr);
205	if (vma)
206	return vma;
207		222
208	mmap_read_unlock(mm);	223	return proc_get_vma(priv, ppos);
209	mmput(mm);
210	return NULL;
211	}	224	}
212		225
213	static void m_stop(struct seq_file m, void _vml)	226	static void m_stop(struct seq_file m, void v)
214	{	227	{
215	struct proc_maps_private *priv = m->private;	228	struct proc_maps_private *priv = m->private;
		229	struct mm_struct *mm = priv->mm;
216		230
217	if (!IS_ERR_OR_NULL(_vml)) {	231	if (!priv->task)
218	mmap_read_unlock(priv->mm);	232	return;
219	mmput(priv->mm);	233
220	}	234	mmap_read_unlock(mm);
221	if (priv->task) {	235	mmput(mm);
222	put_task_struct(priv->task);	236	put_task_struct(priv->task);
223	priv->task = NULL;	237	priv->task = NULL;
224	}
225	}	238	}
226		239
227	static void m_next(struct seq_file m, void _p, loff_t pos)	240	static void m_next(struct seq_file m, void _p, loff_t ppos)
228	{	241	{
229	struct vm_area_struct *vma = _p;	242	return proc_get_vma(m->private, ppos);
230
231	*pos = vma->vm_end;
232	return find_vma(vma->vm_mm, vma->vm_end);
233	}	243	}
234		244
235	static const struct seq_operations proc_pid_maps_ops = {	245	static const struct seq_operations proc_pid_maps_ops = {

fs/reiserfs/reiserfs.h+3−3

@@ -2699,7 +2699,7 @@ struct reiserfs_iget_args { · 2698 unmodified lines
2699	#define get_journal_desc_magic(bh) (bh->b_data + bh->b_size - 12)	2699	#define get_journal_desc_magic(bh) (bh->b_data + bh->b_size - 12)
2700		2700
2701	#define journal_trans_half(blocksize) \	2701	#define journal_trans_half(blocksize) \
2702	((blocksize - sizeof (struct reiserfs_journal_desc) + sizeof (__u32) - 12) / sizeof (__u32))	2702	((blocksize - sizeof(struct reiserfs_journal_desc) - 12) / sizeof(__u32))
2703		2703
2704	/* journal.c see journal.c for all the comments here */	2704	/* journal.c see journal.c for all the comments here */
2705		2705
@@ -2711,7 +2711,7 @@ struct reiserfs_journal_desc { · 5 unmodified lines
2711	__le32 j_len;	2711	__le32 j_len;
2712		2712
2713	__le32 j_mount_id; /* mount id of this trans */	2713	__le32 j_mount_id; /* mount id of this trans */
2714	__le32 j_realblock[1]; /* real locations for each block */	2714	__le32 j_realblock[]; /* real locations for each block */
2715	};	2715	};
2716		2716
2717	#define get_desc_trans_id(d) le32_to_cpu((d)->j_trans_id)	2717	#define get_desc_trans_id(d) le32_to_cpu((d)->j_trans_id)
@@ -2726,7 +2726,7 @@ struct reiserfs_journal_desc { · 8 unmodified lines
2726	struct reiserfs_journal_commit {	2726	struct reiserfs_journal_commit {
2727	__le32 j_trans_id; /* must match j_trans_id from the desc block */	2727	__le32 j_trans_id; /* must match j_trans_id from the desc block */
2728	__le32 j_len; /* ditto */	2728	__le32 j_len; /* ditto */
2729	__le32 j_realblock[1]; /* real locations for each block */	2729	__le32 j_realblock[]; /* real locations for each block */
2730	};	2730	};
2731		2731
2732	#define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id)	2732	#define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id)

fs/smb/client/cached_dir.c+6−0

 	struct cached_fid *cfid, *q;
 	LIST_HEAD(entry);
+	if (cfids == NULL)
+		return;
 	spin_lock(&cfids->cfid_list_lock);
 	list_for_each_entry_safe(cfid, q, &cfids->entries, entry) {
 		list_move(&cfid->entry, &entry);
 	struct cached_fid *cfid, *q;
 	LIST_HEAD(entry);
+	if (cfids == NULL)
+		return;
 	if (cfids->laundromat) {
 		kthread_stop(cfids->laundromat);
 		cfids->laundromat = NULL;

fs/smb/client/cifsglob.h+2−1

 #define   MID_RETRY_NEEDED      8 /* session closed while this request out */
 #define   MID_RESPONSE_MALFORMED 0x10
 #define   MID_SHUTDOWN		 0x20
+#define   MID_RESPONSE_READY 0x40 /* ready for other process handle the rsp */
 /* Flags */
 #define   MID_WAIT_CANCELLED	 1 /* Cancelled while waiting for response */
  * cifsInodeInfo->lock_sem	cifsInodeInfo->llist		cifs_init_once
  *				->can_cache_brlcks
  * cifsInodeInfo->deferred_lock	cifsInodeInfo->deferred_closes	cifsInodeInfo_alloc
- * cached_fid->fid_mutex		cifs_tcon->crfid		tconInfoAlloc
+ * cached_fid->fid_mutex		cifs_tcon->crfid		tcon_info_alloc
  * cifsFileInfo->fh_mutex		cifsFileInfo			cifs_new_fileinfo
  * cifsFileInfo->file_info_lock	cifsFileInfo->count		cifs_new_fileinfo
  *				->invalidHandle			initiate_cifs_search

fs/smb/client/cifsproto.h+1−1

@@ -512,7 +512,7 @@ extern int CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses); · 511 unmodified lines
512		512
513	extern struct cifs_ses *sesInfoAlloc(void);	513	extern struct cifs_ses *sesInfoAlloc(void);
514	extern void sesInfoFree(struct cifs_ses *);	514	extern void sesInfoFree(struct cifs_ses *);
515	extern struct cifs_tcon *tconInfoAlloc(void);	515	extern struct cifs_tcon *tcon_info_alloc(bool dir_leases_enabled);
516	extern void tconInfoFree(struct cifs_tcon *);	516	extern void tconInfoFree(struct cifs_tcon *);
517		517
518	extern int cifs_sign_rqst(struct smb_rqst rqst, struct TCP_Server_Info server,	518	extern int cifs_sign_rqst(struct smb_rqst rqst, struct TCP_Server_Info server,

fs/smb/client/connect.c+6−2

 		}
 	}
-	tcon = tconInfoAlloc();
+	/* no need to setup directory caching on IPC share, so pass in false */
+	tcon = tcon_info_alloc(false);
 	if (tcon == NULL)
 		return -ENOMEM;
 		goto out_fail;
 	}
-	tcon = tconInfoAlloc();
+	if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
+		tcon = tcon_info_alloc(true);
+	else
+		tcon = tcon_info_alloc(false);
 	if (tcon == NULL) {
 		rc = -ENOMEM;
 		goto out_fail;

fs/smb/client/fs_context.c+1−0

@@ -1541,6 +1541,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc, · 1540 unmodified lines
1541		1541
1542	cifs_parse_mount_err:	1542	cifs_parse_mount_err:
1543	kfree_sensitive(ctx->password);	1543	kfree_sensitive(ctx->password);
		1544	ctx->password = NULL;
1544	return -EINVAL;	1545	return -EINVAL;
1545	}	1546	}
1546		1547

fs/smb/client/misc.c+9−5

@@ -113,18 +113,22 @@ sesInfoFree(struct cifs_ses *buf_to_free) · 112 unmodified lines
113	}	113	}
114		114
115	struct cifs_tcon *	115	struct cifs_tcon *
116	tconInfoAlloc(void)	116	tcon_info_alloc(bool dir_leases_enabled)
117	{	117	{
118	struct cifs_tcon *ret_buf;	118	struct cifs_tcon *ret_buf;
119		119
120	ret_buf = kzalloc(sizeof(*ret_buf), GFP_KERNEL);	120	ret_buf = kzalloc(sizeof(*ret_buf), GFP_KERNEL);
121	if (!ret_buf)	121	if (!ret_buf)
122	return NULL;	122	return NULL;
123	ret_buf->cfids = init_cached_dirs();	123
124	if (!ret_buf->cfids) {	124	if (dir_leases_enabled == true) {
125	kfree(ret_buf);	125	ret_buf->cfids = init_cached_dirs();
126	return NULL;	126	if (!ret_buf->cfids) {
		127	kfree(ret_buf);
		128	return NULL;
		129	}
127	}	130	}
		131	/* else ret_buf->cfids is already set to NULL above */
128		132
129	atomic_inc(&tconInfoAllocCount);	133	atomic_inc(&tconInfoAllocCount);
130	ret_buf->status = TID_NEW;	134	ret_buf->status = TID_NEW;

fs/smb/client/smb2inode.c+3−0

 	int rc = 0;
 	switch (rsp->hdr.Status) {
+	case STATUS_IO_REPARSE_TAG_NOT_HANDLED:
+		reparse_point = true;
+		break;
 	case STATUS_STOPPED_ON_SYMLINK:
 		rc = smb2_parse_symlink_response(cifs_sb, iov,
 						 &data->symlink_target);

fs/smb/client/smb2maperror.c+0−2

 	"STATUS_IO_REPARSE_TAG_MISMATCH"},
 	{STATUS_IO_REPARSE_DATA_INVALID, -EIO,
 	"STATUS_IO_REPARSE_DATA_INVALID"},
-	{STATUS_IO_REPARSE_TAG_NOT_HANDLED, -EIO,
-	"STATUS_IO_REPARSE_TAG_NOT_HANDLED"},
 	{STATUS_REPARSE_POINT_NOT_RESOLVED, -EIO,
 	"STATUS_REPARSE_POINT_NOT_RESOLVED"},
 	{STATUS_DIRECTORY_IS_A_REPARSE_POINT, -EIO,

fs/smb/client/smb2pdu.c+2−2

@@ -848,7 +848,7 @@ add_posix_context(struct kvec iov, unsigned int num_iovec, umode_t mode) · 847 unmodified lines
848		848
849	iov[num].iov_base = create_posix_buf(mode);	849	iov[num].iov_base = create_posix_buf(mode);
850	if (mode == ACL_NO_MODE)	850	if (mode == ACL_NO_MODE)
851	cifs_dbg(FYI, "Invalid mode\n");	851	cifs_dbg(FYI, "%s: no mode\n", __func__);
852	if (iov[num].iov_base == NULL)	852	if (iov[num].iov_base == NULL)
853	return -ENOMEM;	853	return -ENOMEM;
854	iov[num].iov_len = sizeof(struct create_posix);	854	iov[num].iov_len = sizeof(struct create_posix);
@@ -3878,7 +3878,7 @@ void smb2_reconnect_server(struct work_struct *work) · 3023 unmodified lines
3878	goto done;	3878	goto done;
3879		3879
3880	/* allocate a dummy tcon struct used for reconnect */	3880	/* allocate a dummy tcon struct used for reconnect */
3881	tcon = tconInfoAlloc();	3881	tcon = tcon_info_alloc(false);
3882	if (!tcon) {	3882	if (!tcon) {
3883	resched = true;	3883	resched = true;
3884	list_for_each_entry_safe(ses, ses2, &tmp_ses_list, rlist) {	3884	list_for_each_entry_safe(ses, ses2, &tmp_ses_list, rlist) {

fs/smb/client/smbdirect.c+6−3

@@ -1401,10 +1401,13 @@ create_conn: · 1400 unmodified lines
1401	server->smbd_conn = smbd_get_connection(	1401	server->smbd_conn = smbd_get_connection(
1402	server, (struct sockaddr *) &server->dstaddr);	1402	server, (struct sockaddr *) &server->dstaddr);
1403		1403
1404	if (server->smbd_conn)	1404	if (server->smbd_conn) {
1405	cifs_dbg(VFS, "RDMA transport re-established\n");	1405	cifs_dbg(VFS, "RDMA transport re-established\n");
1406		1406	trace_smb3_smbd_connect_done(server->hostname, server->conn_id, &server->dstaddr);
1407	return server->smbd_conn ? 0 : -ENOENT;	1407	return 0;
		1408	}
		1409	trace_smb3_smbd_connect_err(server->hostname, server->conn_id, &server->dstaddr);
		1410	return -ENOENT;
1408	}	1411	}
1409		1412
1410	static void destroy_caches_and_workqueue(struct smbd_connection *info)	1413	static void destroy_caches_and_workqueue(struct smbd_connection *info)

fs/smb/client/trace.h+2−0

@@ -935,6 +935,8 @@ DEFINE_EVENT(smb3_connect_class, smb3_##name, \ · 934 unmodified lines
935	TP_ARGS(hostname, conn_id, addr))	935	TP_ARGS(hostname, conn_id, addr))
936		936
937	DEFINE_SMB3_CONNECT_EVENT(connect_done);	937	DEFINE_SMB3_CONNECT_EVENT(connect_done);
		938	DEFINE_SMB3_CONNECT_EVENT(smbd_connect_done);
		939	DEFINE_SMB3_CONNECT_EVENT(smbd_connect_err);
938		940
939	DECLARE_EVENT_CLASS(smb3_connect_err_class,	941	DECLARE_EVENT_CLASS(smb3_connect_err_class,
940	TP_PROTO(char *hostname, __u64 conn_id,	942	TP_PROTO(char *hostname, __u64 conn_id,

fs/smb/client/transport.c+23−11

 void
 cifs_wake_up_task(struct mid_q_entry *mid)
 {
+	if (mid->mid_state == MID_RESPONSE_RECEIVED)
+		mid->mid_state = MID_RESPONSE_READY;
 	wake_up_process(mid->callback_data);
 }
 	struct TCP_Server_Info *server = midEntry->server;
 	if (midEntry->resp_buf && (midEntry->mid_flags & MID_WAIT_CANCELLED) &&
-	    midEntry->mid_state == MID_RESPONSE_RECEIVED &&
+	    (midEntry->mid_state == MID_RESPONSE_RECEIVED ||
+	     midEntry->mid_state == MID_RESPONSE_READY) &&
 	    server->ops->handle_cancelled_mid)
 		server->ops->handle_cancelled_mid(midEntry, server);
 	int error;
 	error = wait_event_state(server->response_q,
-				 midQ->mid_state != MID_REQUEST_SUBMITTED,
+				 midQ->mid_state != MID_REQUEST_SUBMITTED &&
+				 midQ->mid_state != MID_RESPONSE_RECEIVED,
 				 (TASK_KILLABLE|TASK_FREEZABLE_UNSAFE));
 	if (error < 0)
 		return -ERESTARTSYS;
 	spin_lock(&server->mid_lock);
 	switch (mid->mid_state) {
-	case MID_RESPONSE_RECEIVED:
+	case MID_RESPONSE_READY:
 		spin_unlock(&server->mid_lock);
 		return rc;
 	case MID_RETRY_NEEDED:
 	credits.instance = server->reconnect_instance;
 	add_credits(server, &credits, mid->optype);
+	if (mid->mid_state == MID_RESPONSE_RECEIVED)
+		mid->mid_state = MID_RESPONSE_READY;
 }
 static void
 			send_cancel(server, &rqst[i], midQ[i]);
 			spin_lock(&server->mid_lock);
 			midQ[i]->mid_flags |= MID_WAIT_CANCELLED;
-			if (midQ[i]->mid_state == MID_REQUEST_SUBMITTED) {
+			if (midQ[i]->mid_state == MID_REQUEST_SUBMITTED ||
+			    midQ[i]->mid_state == MID_RESPONSE_RECEIVED) {
 				midQ[i]->callback = cifs_cancelled_callback;
 				cancelled_mid[i] = true;
 				credits[i].value = 0;
 		}
 		if (!midQ[i]->resp_buf ||
-		    midQ[i]->mid_state != MID_RESPONSE_RECEIVED) {
+		    midQ[i]->mid_state != MID_RESPONSE_READY) {
 			rc = -EIO;
 			cifs_dbg(FYI, "Bad MID state?\n");
 			goto out;
 	if (rc != 0) {
 		send_cancel(server, &rqst, midQ);
 		spin_lock(&server->mid_lock);
-		if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
+		if (midQ->mid_state == MID_REQUEST_SUBMITTED ||
+		    midQ->mid_state == MID_RESPONSE_RECEIVED) {
 			/* no longer considered to be "in-flight" */
 			midQ->callback = release_mid;
 			spin_unlock(&server->mid_lock);
 	}
 	if (!midQ->resp_buf || !out_buf ||
-	    midQ->mid_state != MID_RESPONSE_RECEIVED) {
+	    midQ->mid_state != MID_RESPONSE_READY) {
 		rc = -EIO;
 		cifs_server_dbg(VFS, "Bad MID state?\n");
 		goto out;
 	/* Wait for a reply - allow signals to interrupt. */
 	rc = wait_event_interruptible(server->response_q,
-		(!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
+		(!(midQ->mid_state == MID_REQUEST_SUBMITTED ||
+		   midQ->mid_state == MID_RESPONSE_RECEIVED)) ||
 		((server->tcpStatus != CifsGood) &&
 		 (server->tcpStatus != CifsNew)));
 	/* Were we interrupted by a signal ? */
 	spin_lock(&server->srv_lock);
 	if ((rc == -ERESTARTSYS) &&
-		(midQ->mid_state == MID_REQUEST_SUBMITTED) &&
+		(midQ->mid_state == MID_REQUEST_SUBMITTED ||
+		 midQ->mid_state == MID_RESPONSE_RECEIVED) &&
 		((server->tcpStatus == CifsGood) ||
 		 (server->tcpStatus == CifsNew))) {
 		spin_unlock(&server->srv_lock);
 		if (rc) {
 			send_cancel(server, &rqst, midQ);
 			spin_lock(&server->mid_lock);
-			if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
+			if (midQ->mid_state == MID_REQUEST_SUBMITTED ||
+			    midQ->mid_state == MID_RESPONSE_RECEIVED) {
 				/* no longer considered to be "in-flight" */
 				midQ->callback = release_mid;
 				spin_unlock(&server->mid_lock);
 		return rc;
 	/* rcvd frame is ok */
-	if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
+	if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_READY) {
 		rc = -EIO;
 		cifs_tcon_dbg(VFS, "Bad MID state?\n");
 		goto out;

fs/smb/server/connection.c+3−0

@@ -197,6 +197,9 @@ int ksmbd_conn_write(struct ksmbd_work *work) · 196 unmodified lines
197	if (work->send_no_response)	197	if (work->send_no_response)
198	return 0;	198	return 0;
199		199
		200	if (!work->iov_idx)
		201	return -EINVAL;
		202
200	ksmbd_conn_lock(conn);	203	ksmbd_conn_lock(conn);
201	sent = conn->transport->ops->writev(conn->transport, work->iov,	204	sent = conn->transport->ops->writev(conn->transport, work->iov,
202	work->iov_cnt,	205	work->iov_cnt,

fs/smb/server/server.c+3−1

 	if (check_conn_state(work))
 		return SERVER_HANDLER_CONTINUE;
-	if (ksmbd_verify_smb_message(work))
+	if (ksmbd_verify_smb_message(work)) {
+		conn->ops->set_rsp_status(work, STATUS_INVALID_PARAMETER);
 		return SERVER_HANDLER_ABORT;
+	}
 	command = conn->ops->get_cmd_val(work);
 	*cmd = command;

fs/smb/server/smb2misc.c+1−3

 validate_credit:
 	if ((work->conn->vals->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU) &&
-	    smb2_validate_credit_charge(work->conn, hdr)) {
+	    smb2_validate_credit_charge(work->conn, hdr))
-		work->conn->ops->set_rsp_status(work, STATUS_INVALID_PARAMETER);
 		return 1;
-	}
 	return 0;
 }

fs/tracefs/event_inode.c+70−17

@@ -70,6 +70,7 @@ static struct dentry eventfs_root_lookup(struct inode dir, · 69 unmodified lines
70	struct dentry *dentry,	70	struct dentry *dentry,
71	unsigned int flags);	71	unsigned int flags);
72	static int dcache_dir_open_wrapper(struct inode inode, struct file file);	72	static int dcache_dir_open_wrapper(struct inode inode, struct file file);
		73	static int dcache_readdir_wrapper(struct file file, struct dir_context ctx);
73	static int eventfs_release(struct inode inode, struct file file);	74	static int eventfs_release(struct inode inode, struct file file);
74		75
75	static const struct inode_operations eventfs_root_dir_inode_operations = {	76	static const struct inode_operations eventfs_root_dir_inode_operations = {
@@ -79,7 +80,7 @@ static const struct inode_operations eventfs_root_dir_inode_operations = { · 3 unmodified lines
79	static const struct file_operations eventfs_file_operations = {	80	static const struct file_operations eventfs_file_operations = {
80	.open = dcache_dir_open_wrapper,	81	.open = dcache_dir_open_wrapper,
81	.read = generic_read_dir,	82	.read = generic_read_dir,
82	.iterate_shared = dcache_readdir,	83	.iterate_shared = dcache_readdir_wrapper,
83	.llseek = generic_file_llseek,	84	.llseek = generic_file_llseek,
84	.release = eventfs_release,	85	.release = eventfs_release,
85	};	86	};
@@ -396,6 +397,11 @@ static struct dentry eventfs_root_lookup(struct inode dir, · 310 unmodified lines
396	return ret;	397	return ret;
397	}	398	}
398		399
		400	struct dentry_list {
		401	void *cursor;
		402	struct dentry **dentries;
		403	};
		404
399	/**	405	/**
400	* eventfs_release - called to release eventfs file/dir	406	* eventfs_release - called to release eventfs file/dir
401	* @inode: inode to be released	407	* @inode: inode to be released
@@ -404,26 +410,25 @@ static struct dentry eventfs_root_lookup(struct inode dir, · 2 unmodified lines
404	static int eventfs_release(struct inode inode, struct file file)	410	static int eventfs_release(struct inode inode, struct file file)
405	{	411	{
406	struct tracefs_inode *ti;	412	struct tracefs_inode *ti;
407	struct eventfs_inode *ei;	413	struct dentry_list *dlist = file->private_data;
408	struct eventfs_file *ef;	414	void *cursor;
409	struct dentry *dentry;	415	int i;
410	int idx;
411		416
412	ti = get_tracefs(inode);	417	ti = get_tracefs(inode);
413	if (!(ti->flags & TRACEFS_EVENT_INODE))	418	if (!(ti->flags & TRACEFS_EVENT_INODE))
414	return -EINVAL;	419	return -EINVAL;
415		420
416	ei = ti->private;	421	if (WARN_ON_ONCE(!dlist))
417	idx = srcu_read_lock(&eventfs_srcu);	422	return -EINVAL;
418	list_for_each_entry_srcu(ef, &ei->e_top_files, list,	423
419	srcu_read_lock_held(&eventfs_srcu)) {	424	for (i = 0; dlist->dentries && dlist->dentries[i]; i++) {
420	mutex_lock(&eventfs_mutex);	425	dput(dlist->dentries[i]);
421	dentry = ef->dentry;
422	mutex_unlock(&eventfs_mutex);
423	if (dentry)
424	dput(dentry);
425	}	426	}
426	srcu_read_unlock(&eventfs_srcu, idx);	427
		428	cursor = dlist->cursor;
		429	kfree(dlist->dentries);
		430	kfree(dlist);
		431	file->private_data = cursor;
427	return dcache_dir_close(inode, file);	432	return dcache_dir_close(inode, file);
428	}	433	}
429		434
@@ -442,22 +447,70 @@ static int dcache_dir_open_wrapper(struct inode inode, struct file file) · 12 unmodified lines
442	struct tracefs_inode *ti;	447	struct tracefs_inode *ti;
443	struct eventfs_inode *ei;	448	struct eventfs_inode *ei;
444	struct eventfs_file *ef;	449	struct eventfs_file *ef;
		450	struct dentry_list *dlist;
		451	struct dentry **dentries = NULL;
445	struct dentry *dentry = file_dentry(file);	452	struct dentry *dentry = file_dentry(file);
		453	struct dentry *d;
446	struct inode *f_inode = file_inode(file);	454	struct inode *f_inode = file_inode(file);
		455	int cnt = 0;
447	int idx;	456	int idx;
		457	int ret;
448		458
449	ti = get_tracefs(f_inode);	459	ti = get_tracefs(f_inode);
450	if (!(ti->flags & TRACEFS_EVENT_INODE))	460	if (!(ti->flags & TRACEFS_EVENT_INODE))
451	return -EINVAL;	461	return -EINVAL;
452		462
		463	if (WARN_ON_ONCE(file->private_data))
		464	return -EINVAL;
		465
		466	dlist = kmalloc(sizeof(*dlist), GFP_KERNEL);
		467	if (!dlist)
		468	return -ENOMEM;
		469
453	ei = ti->private;	470	ei = ti->private;
454	idx = srcu_read_lock(&eventfs_srcu);	471	idx = srcu_read_lock(&eventfs_srcu);
455	list_for_each_entry_srcu(ef, &ei->e_top_files, list,	472	list_for_each_entry_srcu(ef, &ei->e_top_files, list,
456	srcu_read_lock_held(&eventfs_srcu)) {	473	srcu_read_lock_held(&eventfs_srcu)) {
457	create_dentry(ef, dentry, false);	474	d = create_dentry(ef, dentry, false);
		475	if (d) {
		476	struct dentry **tmp;
		477
		478	tmp = krealloc(dentries, sizeof(d) * (cnt + 2), GFP_KERNEL);
		479	if (!tmp)
		480	break;
		481	tmp[cnt] = d;
		482	tmp[cnt + 1] = NULL;
		483	cnt++;
		484	dentries = tmp;
		485	}
458	}	486	}
459	srcu_read_unlock(&eventfs_srcu, idx);	487	srcu_read_unlock(&eventfs_srcu, idx);
460	return dcache_dir_open(inode, file);	488	ret = dcache_dir_open(inode, file);
		489
		490	/*
		491	* dcache_dir_open() sets file->private_data to a dentry cursor.
		492	* Need to save that but also save all the dentries that were
		493	* opened by this function.
		494	*/
		495	dlist->cursor = file->private_data;
		496	dlist->dentries = dentries;
		497	file->private_data = dlist;
		498	return ret;
		499	}
		500
		501	/*
		502	* This just sets the file->private_data back to the cursor and back.
		503	*/
		504	static int dcache_readdir_wrapper(struct file file, struct dir_context ctx)
		505	{
		506	struct dentry_list *dlist = file->private_data;
		507	int ret;
		508
		509	file->private_data = dlist->cursor;
		510	ret = dcache_readdir(file, ctx);
		511	dlist->cursor = file->private_data;
		512	file->private_data = dlist;
		513	return ret;
461	}	514	}
462		515
463	/**	516	/**

fs/xfs/Kconfig+1−1

@@ -147,7 +147,7 @@ config XFS_ONLINE_SCRUB_STATS · 146 unmodified lines
147	bool "XFS online metadata check usage data collection"	147	bool "XFS online metadata check usage data collection"
148	default y	148	default y
149	depends on XFS_ONLINE_SCRUB	149	depends on XFS_ONLINE_SCRUB
150	select FS_DEBUG	150	select XFS_DEBUG
151	help	151	help
152	If you say Y here, the kernel will gather usage data about	152	If you say Y here, the kernel will gather usage data about
153	the online metadata check subsystem. This includes the number	153	the online metadata check subsystem. This includes the number

fs/xfs/libxfs/xfs_log_recover.h+22−0

@@ -131,4 +131,26 @@ void xlog_check_buf_cancel_table(struct xlog *log); · 130 unmodified lines
131	#define xlog_check_buf_cancel_table(log) do { } while (0)	131	#define xlog_check_buf_cancel_table(log) do { } while (0)
132	#endif	132	#endif
133		133
		134	/*
		135	* Transform a regular reservation into one suitable for recovery of a log
		136	* intent item.
		137	*
		138	* Intent recovery only runs a single step of the transaction chain and defers
		139	* the rest to a separate transaction. Therefore, we reduce logcount to 1 here
		140	* to avoid livelocks if the log grant space is nearly exhausted due to the
		141	* recovered intent pinning the tail. Keep the same logflags to avoid tripping
		142	* asserts elsewhere. Struct copies abound below.
		143	*/
		144	static inline struct xfs_trans_res
		145	xlog_recover_resv(const struct xfs_trans_res *r)
		146	{
		147	struct xfs_trans_res ret = {
		148	.tr_logres = r->tr_logres,
		149	.tr_logcount = 1,
		150	.tr_logflags = r->tr_logflags,
		151	};
		152
		153	return ret;
		154	}
		155
134	#endif /* __XFS_LOG_RECOVER_H__ */	156	#endif /* __XFS_LOG_RECOVER_H__ */

fs/xfs/libxfs/xfs_sb.c+2−1

@@ -266,7 +266,8 @@ xfs_validate_sb_write( · 265 unmodified lines
266	return -EFSCORRUPTED;	266	return -EFSCORRUPTED;
267	}	267	}
268		268
269	if (xfs_sb_has_ro_compat_feature(sbp, XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) {	269	if (!xfs_is_readonly(mp) &&
		270	xfs_sb_has_ro_compat_feature(sbp, XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) {
270	xfs_alert(mp,	271	xfs_alert(mp,
271	"Corruption detected in superblock read-only compatible features (0x%x)!",	272	"Corruption detected in superblock read-only compatible features (0x%x)!",
272	(sbp->sb_features_ro_compat &	273	(sbp->sb_features_ro_compat &

fs/xfs/scrub/scrub.c+2−2

 out_teardown:
 	error = xchk_teardown(sc, error);
 out_sc:
+	if (error != -ENOENT)
+		xchk_stats_merge(mp, sm, &run);
 	kfree(sc);
 out:
 	trace_xchk_done(XFS_I(file_inode(file)), sm, error);
 		sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
 		error = 0;
 	}
-	if (error != -ENOENT)
-		xchk_stats_merge(mp, sm, &run);
 	return error;
 need_drain:
 	error = xchk_teardown(sc, 0);

fs/xfs/scrub/stats.c+4−1

 {
 	struct xchk_scrub_stats		*css;
-	ASSERT(sm->sm_type < XFS_SCRUB_TYPE_NR);
+	if (sm->sm_type >= XFS_SCRUB_TYPE_NR) {
+		ASSERT(sm->sm_type < XFS_SCRUB_TYPE_NR);
+		return;
+	}
 	css = &cs->cs_stats[sm->sm_type];
 	spin_lock(&css->css_lock);

fs/xfs/xfs_attr_inactive.c+0−1

@@ -333,7 +333,6 @@ xfs_attr_inactive( · 332 unmodified lines
333	int error = 0;	333	int error = 0;
334		334
335	mp = dp->i_mount;	335	mp = dp->i_mount;
336	ASSERT(! XFS_NOT_DQATTACHED(mp, dp));
337		336
338	xfs_ilock(dp, lock_mode);	337	xfs_ilock(dp, lock_mode);
339	if (!xfs_inode_has_attr_fork(dp))	338	if (!xfs_inode_has_attr_fork(dp))

fs/xfs/xfs_attr_item.c+4−3

 	struct xfs_inode		*ip;
 	struct xfs_da_args		*args;
 	struct xfs_trans		*tp;
-	struct xfs_trans_res		tres;
+	struct xfs_trans_res		resv;
 	struct xfs_attri_log_format	*attrp;
 	struct xfs_attri_log_nameval	*nv = attrip->attri_nameval;
 	int				error;
 		goto out;
 	}
-	xfs_init_attr_trans(args, &tres, &total);
+	xfs_init_attr_trans(args, &resv, &total);
-	error = xfs_trans_alloc(mp, &tres, total, 0, XFS_TRANS_RESERVE, &tp);
+	resv = xlog_recover_resv(&resv);
+	error = xfs_trans_alloc(mp, &resv, total, 0, XFS_TRANS_RESERVE, &tp);
 	if (error)
 		goto out;

fs/xfs/xfs_bmap_item.c+3−1

 	struct list_head		*capture_list)
 {
 	struct xfs_bmap_intent		fake = { };
+	struct xfs_trans_res		resv;
 	struct xfs_bui_log_item		*buip = BUI_ITEM(lip);
 	struct xfs_trans		*tp;
 	struct xfs_inode		*ip = NULL;
 		return error;
 	/* Allocate transaction and do the work. */
-	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
+	resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
+	error = xfs_trans_alloc(mp, &resv,
 			XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK), 0, 0, &tp);
 	if (error)
 		goto err_rele;

fs/xfs/xfs_export.c+14−0

@@ -146,6 +146,20 @@ xfs_nfs_get_inode( · 145 unmodified lines
146	return ERR_PTR(error);	146	return ERR_PTR(error);
147	}	147	}
148		148
		149	/*
		150	* Reload the incore unlinked list to avoid failure in inodegc.
		151	* Use an unlocked check here because unrecovered unlinked inodes
		152	* should be somewhat rare.
		153	*/
		154	if (xfs_inode_unlinked_incomplete(ip)) {
		155	error = xfs_inode_reload_unlinked(ip);
		156	if (error) {
		157	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
		158	xfs_irele(ip);
		159	return ERR_PTR(error);
		160	}
		161	}
		162
149	if (VFS_I(ip)->i_generation != generation) {	163	if (VFS_I(ip)->i_generation != generation) {
150	xfs_irele(ip);	164	xfs_irele(ip);
151	return ERR_PTR(-ESTALE);	165	return ERR_PTR(-ESTALE);

fs/xfs/xfs_extfree_item.c+3−1

 	struct xfs_log_item		*lip,
 	struct list_head		*capture_list)
 {
+	struct xfs_trans_res		resv;
 	struct xfs_efi_log_item		*efip = EFI_ITEM(lip);
 	struct xfs_mount		*mp = lip->li_log->l_mp;
 	struct xfs_efd_log_item		*efdp;
 		}
 	}
-	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
+	resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
+	error = xfs_trans_alloc(mp, &resv, 0, 0, 0, &tp);
 	if (error)
 		return error;
 	efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);

fs/xfs/xfs_fsmap.c+18−7

 }
 #endif /* CONFIG_XFS_RT */
+static inline bool
+rmap_not_shareable(struct xfs_mount *mp, const struct xfs_rmap_irec *r)
+{
+	if (!xfs_has_reflink(mp))
+		return true;
+	if (XFS_RMAP_NON_INODE_OWNER(r->rm_owner))
+		return true;
+	if (r->rm_flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK |
+			   XFS_RMAP_UNWRITTEN))
+		return true;
+	return false;
+}
 /* Execute a getfsmap query against the regular data device. */
 STATIC int
 __xfs_getfsmap_datadev(
 	 * low to the fsmap low key and max out the high key to the end
 	 * of the AG.
 	 */
-	info->low.rm_startblock = XFS_FSB_TO_AGBNO(mp, start_fsb);
 	info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
 	error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
 	if (error)
 	/* Adjust the low key if we are continuing from where we left off. */
 	if (info->low.rm_blockcount == 0) {
-		/* empty */
+		/* No previous record from which to continue */
-	} else if (XFS_RMAP_NON_INODE_OWNER(info->low.rm_owner) ||
+	} else if (rmap_not_shareable(mp, &info->low)) {
-		   (info->low.rm_flags & (XFS_RMAP_ATTR_FORK |
+		/* Last record seen was an unshareable extent */
-					  XFS_RMAP_BMBT_BLOCK |
-					  XFS_RMAP_UNWRITTEN))) {
-		info->low.rm_startblock += info->low.rm_blockcount;
 		info->low.rm_owner = 0;
 		info->low.rm_offset = 0;
 		if (XFS_FSB_TO_DADDR(mp, start_fsb) >= eofs)
 			return 0;
 	} else {
+		/* Last record seen was a shareable file data extent */
 		info->low.rm_offset += info->low.rm_blockcount;
 	}
+	info->low.rm_startblock = XFS_FSB_TO_AGBNO(mp, start_fsb);
 	info->high.rm_startblock = -1U;
 	info->high.rm_owner = ULLONG_MAX;

fs/xfs/xfs_icache.c+29−51

 	INIT_LIST_HEAD(&ip->i_ioend_list);
 	spin_lock_init(&ip->i_ioend_lock);
 	ip->i_next_unlinked = NULLAGINO;
-	ip->i_prev_unlinked = NULLAGINO;
+	ip->i_prev_unlinked = 0;
 	return ip;
 }
 	int			cpu;
 	bool			ret = false;
-	for_each_online_cpu(cpu) {
+	for_each_cpu(cpu, &mp->m_inodegc_cpumask) {
 		gc = per_cpu_ptr(mp->m_inodegc, cpu);
 		if (!llist_empty(&gc->list)) {
 			mod_delayed_work_on(cpu, mp->m_inodegc_wq, &gc->work, 0);
 	int			error = 0;
 	flush_workqueue(mp->m_inodegc_wq);
-	for_each_online_cpu(cpu) {
+	for_each_cpu(cpu, &mp->m_inodegc_cpumask) {
 		struct xfs_inodegc	*gc;
 		gc = per_cpu_ptr(mp->m_inodegc, cpu);
 						struct xfs_inodegc, work);
 	struct llist_node	*node = llist_del_all(&gc->list);
 	struct xfs_inode	*ip, *n;
+	struct xfs_mount	*mp = gc->mp;
 	unsigned int		nofs_flag;
-	ASSERT(gc->cpu == smp_processor_id());
+	/*
+	 * Clear the cpu mask bit and ensure that we have seen the latest
+	 * update of the gc structure associated with this CPU. This matches
+	 * with the release semantics used when setting the cpumask bit in
+	 * xfs_inodegc_queue.
+	 */
+	cpumask_clear_cpu(gc->cpu, &mp->m_inodegc_cpumask);
+	smp_mb__after_atomic();
 	WRITE_ONCE(gc->items, 0);
 	nofs_flag = memalloc_nofs_save();
 	ip = llist_entry(node, struct xfs_inode, i_gclist);
-	trace_xfs_inodegc_worker(ip->i_mount, READ_ONCE(gc->shrinker_hits));
+	trace_xfs_inodegc_worker(mp, READ_ONCE(gc->shrinker_hits));
 	WRITE_ONCE(gc->shrinker_hits, 0);
 	llist_for_each_entry_safe(ip, n, node, i_gclist) {
 	struct xfs_inodegc	*gc;
 	int			items;
 	unsigned int		shrinker_hits;
+	unsigned int		cpu_nr;
 	unsigned long		queue_delay = 1;
 	trace_xfs_inode_set_need_inactive(ip);
 	ip->i_flags |= XFS_NEED_INACTIVE;
 	spin_unlock(&ip->i_flags_lock);
-	gc = get_cpu_ptr(mp->m_inodegc);
+	cpu_nr = get_cpu();
+	gc = this_cpu_ptr(mp->m_inodegc);
 	llist_add(&ip->i_gclist, &gc->list);
 	items = READ_ONCE(gc->items);
 	WRITE_ONCE(gc->items, items + 1);
 	shrinker_hits = READ_ONCE(gc->shrinker_hits);
+	/*
+	 * Ensure the list add is always seen by anyone who finds the cpumask
+	 * bit set. This effectively gives the cpumask bit set operation
+	 * release ordering semantics.
+	 */
+	smp_mb__before_atomic();
+	if (!cpumask_test_cpu(cpu_nr, &mp->m_inodegc_cpumask))
+		cpumask_test_and_set_cpu(cpu_nr, &mp->m_inodegc_cpumask);
 	/*
 	 * We queue the work while holding the current CPU so that the work
 	 * is scheduled to run on this CPU.
 	 */
 	if (!xfs_is_inodegc_enabled(mp)) {
-		put_cpu_ptr(gc);
+		put_cpu();
 		return;
 	}
 	trace_xfs_inodegc_queue(mp, __return_address);
 	mod_delayed_work_on(current_cpu(), mp->m_inodegc_wq, &gc->work,
 			queue_delay);
-	put_cpu_ptr(gc);
+	put_cpu();
 	if (xfs_inodegc_want_flush_work(ip, items, shrinker_hits)) {
 		trace_xfs_inodegc_throttle(mp, __return_address);
 	}
 }
-/*
- * Fold the dead CPU inodegc queue into the current CPUs queue.
- */
-void
-xfs_inodegc_cpu_dead(
-	struct xfs_mount	*mp,
-	unsigned int		dead_cpu)
-{
-	struct xfs_inodegc	*dead_gc, *gc;
-	struct llist_node	*first, *last;
-	unsigned int		count = 0;
-	dead_gc = per_cpu_ptr(mp->m_inodegc, dead_cpu);
-	cancel_delayed_work_sync(&dead_gc->work);
-	if (llist_empty(&dead_gc->list))
-		return;
-	first = dead_gc->list.first;
-	last = first;
-	while (last->next) {
-		last = last->next;
-		count++;
-	}
-	dead_gc->list.first = NULL;
-	dead_gc->items = 0;
-	/* Add pending work to current CPU */
-	gc = get_cpu_ptr(mp->m_inodegc);
-	llist_add_batch(first, last, &gc->list);
-	count += READ_ONCE(gc->items);
-	WRITE_ONCE(gc->items, count);
-	if (xfs_is_inodegc_enabled(mp)) {
-		trace_xfs_inodegc_queue(mp, __return_address);
-		mod_delayed_work_on(current_cpu(), mp->m_inodegc_wq, &gc->work,
-				0);
-	}
-	put_cpu_ptr(gc);
-}
 /*
  * We set the inode flag atomically with the radix tree tag.  Once we get tag
  * lookups on the radix tree, this inode flag can go away.
 	if (!xfs_is_inodegc_enabled(mp))
 		return 0;
-	for_each_online_cpu(cpu) {
+	for_each_cpu(cpu, &mp->m_inodegc_cpumask) {
 		gc = per_cpu_ptr(mp->m_inodegc, cpu);
 		if (!llist_empty(&gc->list))
 			return XFS_INODEGC_SHRINKER_COUNT;
 	trace_xfs_inodegc_shrinker_scan(mp, sc, __return_address);
-	for_each_online_cpu(cpu) {
+	for_each_cpu(cpu, &mp->m_inodegc_cpumask) {
 		gc = per_cpu_ptr(mp->m_inodegc, cpu);
 		if (!llist_empty(&gc->list)) {
 			unsigned int	h = READ_ONCE(gc->shrinker_hits);

fs/xfs/xfs_icache.h+0−1

@@ -79,7 +79,6 @@ void xfs_inodegc_push(struct xfs_mount *mp); · 78 unmodified lines
79	int xfs_inodegc_flush(struct xfs_mount *mp);	79	int xfs_inodegc_flush(struct xfs_mount *mp);
80	void xfs_inodegc_stop(struct xfs_mount *mp);	80	void xfs_inodegc_stop(struct xfs_mount *mp);
81	void xfs_inodegc_start(struct xfs_mount *mp);	81	void xfs_inodegc_start(struct xfs_mount *mp);
82	void xfs_inodegc_cpu_dead(struct xfs_mount *mp, unsigned int cpu);
83	int xfs_inodegc_register_shrinker(struct xfs_mount *mp);	82	int xfs_inodegc_register_shrinker(struct xfs_mount *mp);
84		83
85	#endif	84	#endif

fs/xfs/xfs_inode.c+218−13

@@ -1642,8 +1642,11 @@ xfs_inode_needs_inactive( · 1641 unmodified lines
1642	if (VFS_I(ip)->i_mode == 0)	1642	if (VFS_I(ip)->i_mode == 0)
1643	return false;	1643	return false;
1644		1644
1645	/* If this is a read-only mount, don't do this (would generate I/O) */	1645	/*
1646	if (xfs_is_readonly(mp))	1646	* If this is a read-only mount, don't do this (would generate I/O)
		1647	* unless we're in log recovery and cleaning the iunlinked list.
		1648	*/
		1649	if (xfs_is_readonly(mp) && !xlog_recovery_needed(mp->m_log))
1647	return false;	1650	return false;
1648		1651
1649	/* If the log isn't running, push inodes straight to reclaim. */	1652	/* If the log isn't running, push inodes straight to reclaim. */
@@ -1703,8 +1706,11 @@ xfs_inactive( · 53 unmodified lines
1703	mp = ip->i_mount;	1706	mp = ip->i_mount;
1704	ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));	1707	ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
1705		1708
1706	/* If this is a read-only mount, don't do this (would generate I/O) */	1709	/*
1707	if (xfs_is_readonly(mp))	1710	* If this is a read-only mount, don't do this (would generate I/O)
		1711	* unless we're in log recovery and cleaning the iunlinked list.
		1712	*/
		1713	if (xfs_is_readonly(mp) && !xlog_recovery_needed(mp->m_log))
1708	goto out;	1714	goto out;
1709		1715
1710	/* Metadata inodes require explicit resource cleanup. */	1716	/* Metadata inodes require explicit resource cleanup. */
@@ -1736,9 +1742,21 @@ xfs_inactive( · 25 unmodified lines
1736	ip->i_df.if_nextents > 0 \|\| ip->i_delayed_blks > 0))	1742	ip->i_df.if_nextents > 0 \|\| ip->i_delayed_blks > 0))
1737	truncate = 1;	1743	truncate = 1;
1738		1744
1739	error = xfs_qm_dqattach(ip);	1745	if (xfs_iflags_test(ip, XFS_IQUOTAUNCHECKED)) {
1740	if (error)	1746	/*
1741	goto out;	1747	* If this inode is being inactivated during a quotacheck and
		1748	* has not yet been scanned by quotacheck, we /must/ remove
		1749	* the dquots from the inode before inactivation changes the
		1750	* block and inode counts. Most probably this is a result of
		1751	* reloading the incore iunlinked list to purge unrecovered
		1752	* unlinked inodes.
		1753	*/
		1754	xfs_qm_dqdetach(ip);
		1755	} else {
		1756	error = xfs_qm_dqattach(ip);
		1757	if (error)
		1758	goto out;
		1759	}
1742		1760
1743	if (S_ISLNK(VFS_I(ip)->i_mode))	1761	if (S_ISLNK(VFS_I(ip)->i_mode))
1744	error = xfs_inactive_symlink(ip);	1762	error = xfs_inactive_symlink(ip);
@@ -1822,12 +1840,17 @@ xfs_iunlink_lookup( · 77 unmodified lines
1822		1840
1823	rcu_read_lock();	1841	rcu_read_lock();
1824	ip = radix_tree_lookup(&pag->pag_ici_root, agino);	1842	ip = radix_tree_lookup(&pag->pag_ici_root, agino);
		1843	if (!ip) {
		1844	/* Caller can handle inode not being in memory. */
		1845	rcu_read_unlock();
		1846	return NULL;
		1847	}
1825		1848
1826	/*	1849	/*
1827	* Inode not in memory or in RCU freeing limbo should not happen.	1850	* Inode in RCU freeing limbo should not happen. Warn about this and
1828	* Warn about this and let the caller handle the failure.	1851	* let the caller handle the failure.
1829	*/	1852	*/
1830	if (WARN_ON_ONCE(!ip \|\| !ip->i_ino)) {	1853	if (WARN_ON_ONCE(!ip->i_ino)) {
1831	rcu_read_unlock();	1854	rcu_read_unlock();
1832	return NULL;	1855	return NULL;
1833	}	1856	}
@@ -1836,7 +1859,10 @@ xfs_iunlink_lookup( · 2 unmodified lines
1836	return ip;	1859	return ip;
1837	}	1860	}
1838		1861
1839	/* Update the prev pointer of the next agino. */	1862	/*
		1863	* Update the prev pointer of the next agino. Returns -ENOLINK if the inode
		1864	* is not in cache.
		1865	*/
1840	static int	1866	static int
1841	xfs_iunlink_update_backref(	1867	xfs_iunlink_update_backref(
1842	struct xfs_perag *pag,	1868	struct xfs_perag *pag,
@@ -1851,7 +1877,8 @@ xfs_iunlink_update_backref( · 8 unmodified lines
1851		1877
1852	ip = xfs_iunlink_lookup(pag, next_agino);	1878	ip = xfs_iunlink_lookup(pag, next_agino);
1853	if (!ip)	1879	if (!ip)
1854	return -EFSCORRUPTED;	1880	return -ENOLINK;
		1881
1855	ip->i_prev_unlinked = prev_agino;	1882	ip->i_prev_unlinked = prev_agino;
1856	return 0;	1883	return 0;
1857	}	1884	}
@@ -1895,6 +1922,64 @@ xfs_iunlink_update_bucket( · 37 unmodified lines
1895	return 0;	1922	return 0;
1896	}	1923	}
1897		1924
		1925	/*
		1926	* Load the inode @next_agino into the cache and set its prev_unlinked pointer
		1927	* to @prev_agino. Caller must hold the AGI to synchronize with other changes
		1928	* to the unlinked list.
		1929	*/
		1930	STATIC int
		1931	xfs_iunlink_reload_next(
		1932	struct xfs_trans *tp,
		1933	struct xfs_buf *agibp,
		1934	xfs_agino_t prev_agino,
		1935	xfs_agino_t next_agino)
		1936	{
		1937	struct xfs_perag *pag = agibp->b_pag;
		1938	struct xfs_mount *mp = pag->pag_mount;
		1939	struct xfs_inode *next_ip = NULL;
		1940	xfs_ino_t ino;
		1941	int error;
		1942
		1943	ASSERT(next_agino != NULLAGINO);
		1944
		1945	#ifdef DEBUG
		1946	rcu_read_lock();
		1947	next_ip = radix_tree_lookup(&pag->pag_ici_root, next_agino);
		1948	ASSERT(next_ip == NULL);
		1949	rcu_read_unlock();
		1950	#endif
		1951
		1952	xfs_info_ratelimited(mp,
		1953	"Found unrecovered unlinked inode 0x%x in AG 0x%x. Initiating recovery.",
		1954	next_agino, pag->pag_agno);
		1955
		1956	/*
		1957	* Use an untrusted lookup just to be cautious in case the AGI has been
		1958	* corrupted and now points at a free inode. That shouldn't happen,
		1959	* but we'd rather shut down now since we're already running in a weird
		1960	* situation.
		1961	*/
		1962	ino = XFS_AGINO_TO_INO(mp, pag->pag_agno, next_agino);
		1963	error = xfs_iget(mp, tp, ino, XFS_IGET_UNTRUSTED, 0, &next_ip);
		1964	if (error)
		1965	return error;
		1966
		1967	/* If this is not an unlinked inode, something is very wrong. */
		1968	if (VFS_I(next_ip)->i_nlink != 0) {
		1969	error = -EFSCORRUPTED;
		1970	goto rele;
		1971	}
		1972
		1973	next_ip->i_prev_unlinked = prev_agino;
		1974	trace_xfs_iunlink_reload_next(next_ip);
		1975	rele:
		1976	ASSERT(!(VFS_I(next_ip)->i_state & I_DONTCACHE));
		1977	if (xfs_is_quotacheck_running(mp) && next_ip)
		1978	xfs_iflags_set(next_ip, XFS_IQUOTAUNCHECKED);
		1979	xfs_irele(next_ip);
		1980	return error;
		1981	}
		1982
1898	static int	1983	static int
1899	xfs_iunlink_insert_inode(	1984	xfs_iunlink_insert_inode(
1900	struct xfs_trans *tp,	1985	struct xfs_trans *tp,
@@ -1926,6 +2011,8 @@ xfs_iunlink_insert_inode( · 25 unmodified lines
1926	* inode.	2011	* inode.
1927	*/	2012	*/
1928	error = xfs_iunlink_update_backref(pag, agino, next_agino);	2013	error = xfs_iunlink_update_backref(pag, agino, next_agino);
		2014	if (error == -ENOLINK)
		2015	error = xfs_iunlink_reload_next(tp, agibp, agino, next_agino);
1929	if (error)	2016	if (error)
1930	return error;	2017	return error;
1931		2018
@@ -1941,6 +2028,7 @@ xfs_iunlink_insert_inode( · 9 unmodified lines
1941	}	2028	}
1942		2029
1943	/* Point the head of the list to point to this inode. */	2030	/* Point the head of the list to point to this inode. */
		2031	ip->i_prev_unlinked = NULLAGINO;
1944	return xfs_iunlink_update_bucket(tp, pag, agibp, bucket_index, agino);	2032	return xfs_iunlink_update_bucket(tp, pag, agibp, bucket_index, agino);
1945	}	2033	}
1946		2034
@@ -2020,6 +2108,9 @@ xfs_iunlink_remove_inode( · 73 unmodified lines
2020	*/	2108	*/
2021	error = xfs_iunlink_update_backref(pag, ip->i_prev_unlinked,	2109	error = xfs_iunlink_update_backref(pag, ip->i_prev_unlinked,
2022	ip->i_next_unlinked);	2110	ip->i_next_unlinked);
		2111	if (error == -ENOLINK)
		2112	error = xfs_iunlink_reload_next(tp, agibp, ip->i_prev_unlinked,
		2113	ip->i_next_unlinked);
2023	if (error)	2114	if (error)
2024	return error;	2115	return error;
2025		2116
@@ -2040,7 +2131,7 @@ xfs_iunlink_remove_inode( · 14 unmodified lines
2040	}	2131	}
2041		2132
2042	ip->i_next_unlinked = NULLAGINO;	2133	ip->i_next_unlinked = NULLAGINO;
2043	ip->i_prev_unlinked = NULLAGINO;	2134	ip->i_prev_unlinked = 0;
2044	return error;	2135	return error;
2045	}	2136	}
2046		2137
@@ -3529,3 +3620,117 @@ xfs_iunlock2_io_mmap( · 1482 unmodified lines
3529	if (ip1 != ip2)	3620	if (ip1 != ip2)
3530	inode_unlock(VFS_I(ip1));	3621	inode_unlock(VFS_I(ip1));
3531	}	3622	}
		3623
		3624	/*
		3625	* Reload the incore inode list for this inode. Caller should ensure that
		3626	* the link count cannot change, either by taking ILOCK_SHARED or otherwise
		3627	* preventing other threads from executing.
		3628	*/
		3629	int
		3630	xfs_inode_reload_unlinked_bucket(
		3631	struct xfs_trans *tp,
		3632	struct xfs_inode *ip)
		3633	{
		3634	struct xfs_mount *mp = tp->t_mountp;
		3635	struct xfs_buf *agibp;
		3636	struct xfs_agi *agi;
		3637	struct xfs_perag *pag;
		3638	xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
		3639	xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
		3640	xfs_agino_t prev_agino, next_agino;
		3641	unsigned int bucket;
		3642	bool foundit = false;
		3643	int error;
		3644
		3645	/* Grab the first inode in the list */
		3646	pag = xfs_perag_get(mp, agno);
		3647	error = xfs_ialloc_read_agi(pag, tp, &agibp);
		3648	xfs_perag_put(pag);
		3649	if (error)
		3650	return error;
		3651
		3652	/*
		3653	* We've taken ILOCK_SHARED and the AGI buffer lock to stabilize the
		3654	* incore unlinked list pointers for this inode. Check once more to
		3655	* see if we raced with anyone else to reload the unlinked list.
		3656	*/
		3657	if (!xfs_inode_unlinked_incomplete(ip)) {
		3658	foundit = true;
		3659	goto out_agibp;
		3660	}
		3661
		3662	bucket = agino % XFS_AGI_UNLINKED_BUCKETS;
		3663	agi = agibp->b_addr;
		3664
		3665	trace_xfs_inode_reload_unlinked_bucket(ip);
		3666
		3667	xfs_info_ratelimited(mp,
		3668	"Found unrecovered unlinked inode 0x%x in AG 0x%x. Initiating list recovery.",
		3669	agino, agno);
		3670
		3671	prev_agino = NULLAGINO;
		3672	next_agino = be32_to_cpu(agi->agi_unlinked[bucket]);
		3673	while (next_agino != NULLAGINO) {
		3674	struct xfs_inode *next_ip = NULL;
		3675
		3676	/* Found this caller's inode, set its backlink. */
		3677	if (next_agino == agino) {
		3678	next_ip = ip;
		3679	next_ip->i_prev_unlinked = prev_agino;
		3680	foundit = true;
		3681	goto next_inode;
		3682	}
		3683
		3684	/* Try in-memory lookup first. */
		3685	next_ip = xfs_iunlink_lookup(pag, next_agino);
		3686	if (next_ip)
		3687	goto next_inode;
		3688
		3689	/* Inode not in memory, try reloading it. */
		3690	error = xfs_iunlink_reload_next(tp, agibp, prev_agino,
		3691	next_agino);
		3692	if (error)
		3693	break;
		3694
		3695	/* Grab the reloaded inode. */
		3696	next_ip = xfs_iunlink_lookup(pag, next_agino);
		3697	if (!next_ip) {
		3698	/* No incore inode at all? We reloaded it... */
		3699	ASSERT(next_ip != NULL);
		3700	error = -EFSCORRUPTED;
		3701	break;
		3702	}
		3703
		3704	next_inode:
		3705	prev_agino = next_agino;
		3706	next_agino = next_ip->i_next_unlinked;
		3707	}
		3708
		3709	out_agibp:
		3710	xfs_trans_brelse(tp, agibp);
		3711	/* Should have found this inode somewhere in the iunlinked bucket. */
		3712	if (!error && !foundit)
		3713	error = -EFSCORRUPTED;
		3714	return error;
		3715	}
		3716
		3717	/* Decide if this inode is missing its unlinked list and reload it. */
		3718	int
		3719	xfs_inode_reload_unlinked(
		3720	struct xfs_inode *ip)
		3721	{
		3722	struct xfs_trans *tp;
		3723	int error;
		3724
		3725	error = xfs_trans_alloc_empty(ip->i_mount, &tp);
		3726	if (error)
		3727	return error;
		3728
		3729	xfs_ilock(ip, XFS_ILOCK_SHARED);
		3730	if (xfs_inode_unlinked_incomplete(ip))
		3731	error = xfs_inode_reload_unlinked_bucket(tp, ip);
		3732	xfs_iunlock(ip, XFS_ILOCK_SHARED);
		3733	xfs_trans_cancel(tp);
		3734
		3735	return error;
		3736	}

fs/xfs/xfs_inode.h+32−2

 	uint64_t		i_diflags2;	/* XFS_DIFLAG2_... */
 	struct timespec64	i_crtime;	/* time created */
-	/* unlinked list pointers */
+	/*
+	 * Unlinked list pointers.  These point to the next and previous inodes
+	 * in the AGI unlinked bucket list, respectively.  These fields can
+	 * only be updated with the AGI locked.
+	 *
+	 * i_next_unlinked caches di_next_unlinked.
+	 */
 	xfs_agino_t		i_next_unlinked;
+	/*
+	 * If the inode is not on an unlinked list, this field is zero.  If the
+	 * inode is the first element in an unlinked list, this field is
+	 * NULLAGINO.  Otherwise, i_prev_unlinked points to the previous inode
+	 * in the unlinked list.
+	 */
 	xfs_agino_t		i_prev_unlinked;
 	/* VFS inode */
 	struct list_head	i_ioend_list;
 } xfs_inode_t;
+static inline bool xfs_inode_on_unlinked_list(const struct xfs_inode *ip)
+{
+	return ip->i_prev_unlinked != 0;
+}
 static inline bool xfs_inode_has_attr_fork(struct xfs_inode *ip)
 {
 	return ip->i_forkoff > 0;
  */
 #define XFS_INACTIVATING	(1 << 13)
+/* Quotacheck is running but inode has not been added to quota counts. */
+#define XFS_IQUOTAUNCHECKED	(1 << 14)
 /* All inode state flags related to inode reclaim. */
 #define XFS_ALL_IRECLAIM_FLAGS	(XFS_IRECLAIMABLE | \
 				 XFS_IRECLAIM | \
 #define XFS_IRECLAIM_RESET_FLAGS	\
 	(XFS_IRECLAIMABLE | XFS_IRECLAIM | \
 	 XFS_IDIRTY_RELEASE | XFS_ITRUNCATED | XFS_NEED_INACTIVE | \
-	 XFS_INACTIVATING)
+	 XFS_INACTIVATING | XFS_IQUOTAUNCHECKED)
 /*
  * Flags for inode locking.
 int xfs_ilock2_io_mmap(struct xfs_inode *ip1, struct xfs_inode *ip2);
 void xfs_iunlock2_io_mmap(struct xfs_inode *ip1, struct xfs_inode *ip2);
+static inline bool
+xfs_inode_unlinked_incomplete(
+	struct xfs_inode	*ip)
+{
+	return VFS_I(ip)->i_nlink == 0 && !xfs_inode_on_unlinked_list(ip);
+}
+int xfs_inode_reload_unlinked_bucket(struct xfs_trans *tp, struct xfs_inode *ip);
+int xfs_inode_reload_unlinked(struct xfs_inode *ip);
 #endif	/* __XFS_INODE_H__ */

fs/xfs/xfs_itable.c+11−0

@@ -80,6 +80,17 @@ xfs_bulkstat_one_int( · 79 unmodified lines
80	if (error)	80	if (error)
81	goto out;	81	goto out;
82		82
		83	/* Reload the incore unlinked list to avoid failure in inodegc. */
		84	if (xfs_inode_unlinked_incomplete(ip)) {
		85	error = xfs_inode_reload_unlinked_bucket(tp, ip);
		86	if (error) {
		87	xfs_iunlock(ip, XFS_ILOCK_SHARED);
		88	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
		89	xfs_irele(ip);
		90	return error;
		91	}
		92	}
		93
83	ASSERT(ip != NULL);	94	ASSERT(ip != NULL);
84	ASSERT(ip->i_imap.im_blkno != 0);	95	ASSERT(ip->i_imap.im_blkno != 0);
85	inode = VFS_I(ip);	96	inode = VFS_I(ip);

fs/xfs/xfs_log.c+0−17

 	 * just worked.
 	 */
 	if (!xfs_has_norecovery(mp)) {
-		/*
-		 * log recovery ignores readonly state and so we need to clear
-		 * mount-based read only state so it can write to disk.
-		 */
-		bool	readonly = test_and_clear_bit(XFS_OPSTATE_READONLY,
-						&mp->m_opstate);
 		error = xlog_recover(log);
-		if (readonly)
-			set_bit(XFS_OPSTATE_READONLY, &mp->m_opstate);
 		if (error) {
 			xfs_warn(mp, "log mount/recovery failed: error %d",
 				error);
 	struct xfs_mount	*mp)
 {
 	struct xlog		*log = mp->m_log;
-	bool			readonly;
 	int			error = 0;
 	if (xfs_has_norecovery(mp)) {
 		return 0;
 	}
-	/*
-	 * log recovery ignores readonly state and so we need to clear
-	 * mount-based read only state so it can write to disk.
-	 */
-	readonly = test_and_clear_bit(XFS_OPSTATE_READONLY, &mp->m_opstate);
 	/*
 	 * During the second phase of log recovery, we need iget and
 	 * iput to behave like they do for an active filesystem.
 	xfs_buftarg_drain(mp->m_ddev_targp);
 	clear_bit(XLOG_RECOVERY_NEEDED, &log->l_opstate);
-	if (readonly)
-		set_bit(XFS_OPSTATE_READONLY, &mp->m_opstate);
 	/* Make sure the log is dead if we're returning failure. */
 	ASSERT(!error || xlog_is_shutdown(log));

fs/xfs/xfs_log_cil.c+16−36

 	struct xlog_cil_pcp	*cilpcp;
 	int			cpu;
-	for_each_online_cpu(cpu) {
+	for_each_cpu(cpu, &ctx->cil_pcpmask) {
 		cilpcp = per_cpu_ptr(cil->xc_pcp, cpu);
 		ctx->ticket->t_curr_res += cilpcp->space_reserved;
 	if (!test_and_clear_bit(XLOG_CIL_PCP_SPACE, &cil->xc_flags))
 		return;
-	for_each_online_cpu(cpu) {
+	/*
+	 * We can race with other cpus setting cil_pcpmask.  However, we've
+	 * atomically cleared PCP_SPACE which forces other threads to add to
+	 * the global space used count.  cil_pcpmask is a superset of cilpcp
+	 * structures that could have a nonzero space_used.
+	 */
+	for_each_cpu(cpu, &ctx->cil_pcpmask) {
 		int	old, prev;
 		cilpcp = per_cpu_ptr(cil->xc_pcp, cpu);
 	int			iovhdr_res = 0, split_res = 0, ctx_res = 0;
 	int			space_used;
 	int			order;
+	unsigned int		cpu_nr;
 	struct xlog_cil_pcp	*cilpcp;
 	ASSERT(tp);
 	 * can't be scheduled away between split sample/update operations that
 	 * are done without outside locking to serialise them.
 	 */
-	cilpcp = get_cpu_ptr(cil->xc_pcp);
+	cpu_nr = get_cpu();
+	cilpcp = this_cpu_ptr(cil->xc_pcp);
+	/* Tell the future push that there was work added by this CPU. */
+	if (!cpumask_test_cpu(cpu_nr, &ctx->cil_pcpmask))
+		cpumask_test_and_set_cpu(cpu_nr, &ctx->cil_pcpmask);
 	/*
 	 * We need to take the CIL checkpoint unit reservation on the first
 			continue;
 		list_add_tail(&lip->li_cil, &cilpcp->log_items);
 	}
-	put_cpu_ptr(cilpcp);
+	put_cpu();
 	/*
 	 * If we've overrun the reservation, dump the tx details before we move
 	return 0;
 }
-/*
- * Move dead percpu state to the relevant CIL context structures.
- *
- * We have to lock the CIL context here to ensure that nothing is modifying
- * the percpu state, either addition or removal. Both of these are done under
- * the CIL context lock, so grabbing that exclusively here will ensure we can
- * safely drain the cilpcp for the CPU that is dying.
- */
-void
-xlog_cil_pcp_dead(
-	struct xlog		*log,
-	unsigned int		cpu)
-{
-	struct xfs_cil		*cil = log->l_cilp;
-	struct xlog_cil_pcp	*cilpcp = per_cpu_ptr(cil->xc_pcp, cpu);
-	struct xfs_cil_ctx	*ctx;
-	down_write(&cil->xc_ctx_lock);
-	ctx = cil->xc_ctx;
-	if (ctx->ticket)
-		ctx->ticket->t_curr_res += cilpcp->space_reserved;
-	cilpcp->space_reserved = 0;
-	if (!list_empty(&cilpcp->log_items))
-		list_splice_init(&cilpcp->log_items, &ctx->log_items);
-	if (!list_empty(&cilpcp->busy_extents))
-		list_splice_init(&cilpcp->busy_extents, &ctx->busy_extents);
-	atomic_add(cilpcp->space_used, &ctx->space_used);
-	cilpcp->space_used = 0;
-	up_write(&cil->xc_ctx_lock);
-}
 /*
  * Perform initial CIL structure initialisation.
  */

fs/xfs/xfs_log_priv.h+6−8

 	struct work_struct	discard_endio_work;
 	struct work_struct	push_work;
 	atomic_t		order_id;
+	/*
+	 * CPUs that could have added items to the percpu CIL data.  Access is
+	 * coordinated with xc_ctx_lock.
+	 */
+	struct cpumask		cil_pcpmask;
 };
 /*
 	wait_queue_head_t	xc_push_wait;	/* background push throttle */
 	void __percpu		*xc_pcp;	/* percpu CIL structures */
-#ifdef CONFIG_HOTPLUG_CPU
-	struct list_head	xc_pcp_list;
-#endif
 } ____cacheline_aligned_in_smp;
 /* xc_flags bit values */
 	return p;
 }
-/*
- * CIL CPU dead notifier
- */
-void xlog_cil_pcp_dead(struct xlog *log, unsigned int cpu);
 #endif	/* __XFS_LOG_PRIV_H__ */

fs/xfs/xfs_log_recover.c+2−2

@@ -329,7 +329,7 @@ xlog_find_verify_cycle( · 328 unmodified lines
329	* try a smaller size. We need to be able to read at least	329	* try a smaller size. We need to be able to read at least
330	* a log sector, or we're out of luck.	330	* a log sector, or we're out of luck.
331	*/	331	*/
332	bufblks = 1 << ffs(nbblks);	332	bufblks = roundup_pow_of_two(nbblks);
333	while (bufblks > log->l_logBBsize)	333	while (bufblks > log->l_logBBsize)
334	bufblks >>= 1;	334	bufblks >>= 1;
335	while (!(buffer = xlog_alloc_buffer(log, bufblks))) {	335	while (!(buffer = xlog_alloc_buffer(log, bufblks))) {
@@ -1528,7 +1528,7 @@ xlog_write_log_records( · 1192 unmodified lines
1528	* a smaller size. We need to be able to write at least a	1528	* a smaller size. We need to be able to write at least a
1529	* log sector, or we're out of luck.	1529	* log sector, or we're out of luck.
1530	*/	1530	*/
1531	bufblks = 1 << ffs(blocks);	1531	bufblks = roundup_pow_of_two(blocks);
1532	while (bufblks > log->l_logBBsize)	1532	while (bufblks > log->l_logBBsize)
1533	bufblks >>= 1;	1533	bufblks >>= 1;
1534	while (!(buffer = xlog_alloc_buffer(log, bufblks))) {	1534	while (!(buffer = xlog_alloc_buffer(log, bufblks))) {

fs/xfs/xfs_mount.h+13−4

  * Per-cpu deferred inode inactivation GC lists.
  */
 struct xfs_inodegc {
+	struct xfs_mount	*mp;
 	struct llist_head	list;
 	struct delayed_work	work;
 	int			error;
 	/* approximate count of inodes in the list */
 	unsigned int		items;
 	unsigned int		shrinker_hits;
-#if defined(DEBUG) || defined(XFS_WARN)
 	unsigned int		cpu;
-#endif
 };
 /*
 	xfs_buftarg_t		*m_ddev_targp;	/* saves taking the address */
 	xfs_buftarg_t		*m_logdev_targp;/* ptr to log device */
 	xfs_buftarg_t		*m_rtdev_targp;	/* ptr to rt device */
-	struct list_head	m_mount_list;	/* global mount list */
 	void __percpu		*m_inodegc;	/* percpu inodegc structures */
 	/*
 	unsigned int		*m_errortag;
 	struct xfs_kobj		m_errortag_kobj;
 #endif
+	/* cpus that have inodes queued for inactivation */
+	struct cpumask		m_inodegc_cpumask;
 } xfs_mount_t;
 #define M_IGEO(mp)		(&(mp)->m_ino_geo)
 #define XFS_OPSTATE_WARNED_SHRINK	8
 /* Kernel has logged a warning about logged xattr updates being used. */
 #define XFS_OPSTATE_WARNED_LARP		9
+/* Mount time quotacheck is running */
+#define XFS_OPSTATE_QUOTACHECK_RUNNING	10
 #define __XFS_IS_OPSTATE(name, NAME) \
 static inline bool xfs_is_ ## name (struct xfs_mount *mp) \
 __XFS_IS_OPSTATE(readonly, READONLY)
 __XFS_IS_OPSTATE(inodegc_enabled, INODEGC_ENABLED)
 __XFS_IS_OPSTATE(blockgc_enabled, BLOCKGC_ENABLED)
+#ifdef CONFIG_XFS_QUOTA
+__XFS_IS_OPSTATE(quotacheck_running, QUOTACHECK_RUNNING)
+#else
+# define xfs_is_quotacheck_running(mp)	(false)
+#endif
 static inline bool
 xfs_should_warn(struct xfs_mount *mp, long nr)
 	{ (1UL << XFS_OPSTATE_BLOCKGC_ENABLED),		"blockgc" }, \
 	{ (1UL << XFS_OPSTATE_WARNED_SCRUB),		"wscrub" }, \
 	{ (1UL << XFS_OPSTATE_WARNED_SHRINK),		"wshrink" }, \
-	{ (1UL << XFS_OPSTATE_WARNED_LARP),		"wlarp" }
+	{ (1UL << XFS_OPSTATE_WARNED_LARP),		"wlarp" }, \
+	{ (1UL << XFS_OPSTATE_QUOTACHECK_RUNNING),	"quotacheck" }
 /*
  * Max and min values for mount-option defined I/O

fs/xfs/xfs_qm.c+16−0

 	if (error)
 		return error;
+	/*
+	 * Reload the incore unlinked list to avoid failure in inodegc.
+	 * Use an unlocked check here because unrecovered unlinked inodes
+	 * should be somewhat rare.
+	 */
+	if (xfs_inode_unlinked_incomplete(ip)) {
+		error = xfs_inode_reload_unlinked(ip);
+		if (error) {
+			xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
+			goto error0;
+		}
+	}
 	ASSERT(ip->i_delayed_blks == 0);
 	if (XFS_IS_REALTIME_INODE(ip)) {
 	}
 	nblks = (xfs_qcnt_t)ip->i_nblocks - rtblks;
+	xfs_iflags_clear(ip, XFS_IQUOTAUNCHECKED);
 	/*
 	 * Add the (disk blocks and inode) resources occupied by this
 		flags |= XFS_PQUOTA_CHKD;
 	}
+	xfs_set_quotacheck_running(mp);
 	error = xfs_iwalk_threaded(mp, 0, 0, xfs_qm_dqusage_adjust, 0, true,
 			NULL);
+	xfs_clear_quotacheck_running(mp);
 	/*
 	 * On error, the inode walk may have partially populated the dquot

fs/xfs/xfs_refcount_item.c+4−2

 	struct xfs_log_item		*lip,
 	struct list_head		*capture_list)
 {
+	struct xfs_trans_res		resv;
 	struct xfs_cui_log_item		*cuip = CUI_ITEM(lip);
 	struct xfs_cud_log_item		*cudp;
 	struct xfs_trans		*tp;
 	 * doesn't fit.  We need to reserve enough blocks to handle a
 	 * full btree split on either end of the refcount range.
 	 */
-	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
+	resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
-			mp->m_refc_maxlevels * 2, 0, XFS_TRANS_RESERVE, &tp);
+	error = xfs_trans_alloc(mp, &resv, mp->m_refc_maxlevels * 2, 0,
+			XFS_TRANS_RESERVE, &tp);
 	if (error)
 		return error;

fs/xfs/xfs_rmap_item.c+4−2

 	struct xfs_log_item		*lip,
 	struct list_head		*capture_list)
 {
+	struct xfs_trans_res		resv;
 	struct xfs_rui_log_item		*ruip = RUI_ITEM(lip);
 	struct xfs_rud_log_item		*rudp;
 	struct xfs_trans		*tp;
 		}
 	}
-	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
+	resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
-			mp->m_rmap_maxlevels, 0, XFS_TRANS_RESERVE, &tp);
+	error = xfs_trans_alloc(mp, &resv, mp->m_rmap_maxlevels, 0,
+			XFS_TRANS_RESERVE, &tp);
 	if (error)
 		return error;
 	rudp = xfs_trans_get_rud(tp, ruip);

fs/xfs/xfs_super.c+2−84

@@ -56,28 +56,6 @@ static struct kset xfs_kset; / top-level xfs sysfs dir */ · 55 unmodified lines
56	static struct xfs_kobj xfs_dbg_kobj; /* global debug sysfs attrs */	56	static struct xfs_kobj xfs_dbg_kobj; /* global debug sysfs attrs */
57	#endif	57	#endif
58		58
59	#ifdef CONFIG_HOTPLUG_CPU
60	static LIST_HEAD(xfs_mount_list);
61	static DEFINE_SPINLOCK(xfs_mount_list_lock);
62
63	static inline void xfs_mount_list_add(struct xfs_mount *mp)
64	{
65	spin_lock(&xfs_mount_list_lock);
66	list_add(&mp->m_mount_list, &xfs_mount_list);
67	spin_unlock(&xfs_mount_list_lock);
68	}
69
70	static inline void xfs_mount_list_del(struct xfs_mount *mp)
71	{
72	spin_lock(&xfs_mount_list_lock);
73	list_del(&mp->m_mount_list);
74	spin_unlock(&xfs_mount_list_lock);
75	}
76	#else /* !CONFIG_HOTPLUG_CPU */
77	static inline void xfs_mount_list_add(struct xfs_mount *mp) {}
78	static inline void xfs_mount_list_del(struct xfs_mount *mp) {}
79	#endif
80
81	enum xfs_dax_mode {	59	enum xfs_dax_mode {
82	XFS_DAX_INODE = 0,	60	XFS_DAX_INODE = 0,
83	XFS_DAX_ALWAYS = 1,	61	XFS_DAX_ALWAYS = 1,
@@ -1135,9 +1113,8 @@ xfs_inodegc_init_percpu( · 1051 unmodified lines
1135		1113
1136	for_each_possible_cpu(cpu) {	1114	for_each_possible_cpu(cpu) {
1137	gc = per_cpu_ptr(mp->m_inodegc, cpu);	1115	gc = per_cpu_ptr(mp->m_inodegc, cpu);
1138	#if defined(DEBUG) \|\| defined(XFS_WARN)
1139	gc->cpu = cpu;	1116	gc->cpu = cpu;
1140	#endif	1117	gc->mp = mp;
1141	init_llist_head(&gc->list);	1118	init_llist_head(&gc->list);
1142	gc->items = 0;	1119	gc->items = 0;
1143	gc->error = 0;	1120	gc->error = 0;
@@ -1168,7 +1145,6 @@ xfs_fs_put_super( · 24 unmodified lines
1168	xfs_freesb(mp);	1145	xfs_freesb(mp);
1169	xchk_mount_stats_free(mp);	1146	xchk_mount_stats_free(mp);
1170	free_percpu(mp->m_stats.xs_stats);	1147	free_percpu(mp->m_stats.xs_stats);
1171	xfs_mount_list_del(mp);
1172	xfs_inodegc_free_percpu(mp);	1148	xfs_inodegc_free_percpu(mp);
1173	xfs_destroy_percpu_counters(mp);	1149	xfs_destroy_percpu_counters(mp);
1174	xfs_destroy_mount_workqueues(mp);	1150	xfs_destroy_mount_workqueues(mp);
@@ -1577,13 +1553,6 @@ xfs_fs_fill_super( · 402 unmodified lines
1577	if (error)	1553	if (error)
1578	goto out_destroy_counters;	1554	goto out_destroy_counters;
1579		1555
1580	/*
1581	* All percpu data structures requiring cleanup when a cpu goes offline
1582	* must be allocated before adding this @mp to the cpu-dead handler's
1583	* mount list.
1584	*/
1585	xfs_mount_list_add(mp);
1586
1587	/* Allocate stats memory before we do operations that might use it */	1556	/* Allocate stats memory before we do operations that might use it */
1588	mp->m_stats.xs_stats = alloc_percpu(struct xfsstats);	1557	mp->m_stats.xs_stats = alloc_percpu(struct xfsstats);
1589	if (!mp->m_stats.xs_stats) {	1558	if (!mp->m_stats.xs_stats) {
@@ -1781,7 +1750,6 @@ xfs_fs_fill_super( · 191 unmodified lines
1781	out_free_stats:	1750	out_free_stats:
1782	free_percpu(mp->m_stats.xs_stats);	1751	free_percpu(mp->m_stats.xs_stats);
1783	out_destroy_inodegc:	1752	out_destroy_inodegc:
1784	xfs_mount_list_del(mp);
1785	xfs_inodegc_free_percpu(mp);	1753	xfs_inodegc_free_percpu(mp);
1786	out_destroy_counters:	1754	out_destroy_counters:
1787	xfs_destroy_percpu_counters(mp);	1755	xfs_destroy_percpu_counters(mp);
@@ -2326,49 +2294,6 @@ xfs_destroy_workqueues(void) · 538 unmodified lines
2326	destroy_workqueue(xfs_alloc_wq);	2294	destroy_workqueue(xfs_alloc_wq);
2327	}	2295	}
2328		2296
2329	#ifdef CONFIG_HOTPLUG_CPU
2330	static int
2331	xfs_cpu_dead(
2332	unsigned int cpu)
2333	{
2334	struct xfs_mount mp, n;
2335
2336	spin_lock(&xfs_mount_list_lock);
2337	list_for_each_entry_safe(mp, n, &xfs_mount_list, m_mount_list) {
2338	spin_unlock(&xfs_mount_list_lock);
2339	xfs_inodegc_cpu_dead(mp, cpu);
2340	xlog_cil_pcp_dead(mp->m_log, cpu);
2341	spin_lock(&xfs_mount_list_lock);
2342	}
2343	spin_unlock(&xfs_mount_list_lock);
2344	return 0;
2345	}
2346
2347	static int __init
2348	xfs_cpu_hotplug_init(void)
2349	{
2350	int error;
2351
2352	error = cpuhp_setup_state_nocalls(CPUHP_XFS_DEAD, "xfs:dead", NULL,
2353	xfs_cpu_dead);
2354	if (error < 0)
2355	xfs_alert(NULL,
2356	"Failed to initialise CPU hotplug, error %d. XFS is non-functional.",
2357	error);
2358	return error;
2359	}
2360
2361	static void
2362	xfs_cpu_hotplug_destroy(void)
2363	{
2364	cpuhp_remove_state_nocalls(CPUHP_XFS_DEAD);
2365	}
2366
2367	#else /* !CONFIG_HOTPLUG_CPU */
2368	static inline int xfs_cpu_hotplug_init(void) { return 0; }
2369	static inline void xfs_cpu_hotplug_destroy(void) {}
2370	#endif
2371
2372	STATIC int __init	2297	STATIC int __init
2373	init_xfs_fs(void)	2298	init_xfs_fs(void)
2374	{	2299	{
@@ -2385,13 +2310,9 @@ init_xfs_fs(void) · 10 unmodified lines
2385		2310
2386	xfs_dir_startup();	2311	xfs_dir_startup();
2387		2312
2388	error = xfs_cpu_hotplug_init();
2389	if (error)
2390	goto out;
2391
2392	error = xfs_init_caches();	2313	error = xfs_init_caches();
2393	if (error)	2314	if (error)
2394	goto out_destroy_hp;	2315	goto out;
2395		2316
2396	error = xfs_init_workqueues();	2317	error = xfs_init_workqueues();
2397	if (error)	2318	if (error)
@@ -2475,8 +2396,6 @@ init_xfs_fs(void) · 77 unmodified lines
2475	xfs_destroy_workqueues();	2396	xfs_destroy_workqueues();
2476	out_destroy_caches:	2397	out_destroy_caches:
2477	xfs_destroy_caches();	2398	xfs_destroy_caches();
2478	out_destroy_hp:
2479	xfs_cpu_hotplug_destroy();
2480	out:	2399	out:
2481	return error;	2400	return error;
2482	}	2401	}
@@ -2500,7 +2419,6 @@ exit_xfs_fs(void) · 17 unmodified lines
2500	xfs_destroy_workqueues();	2419	xfs_destroy_workqueues();
2501	xfs_destroy_caches();	2420	xfs_destroy_caches();
2502	xfs_uuid_table_free();	2421	xfs_uuid_table_free();
2503	xfs_cpu_hotplug_destroy();
2504	}	2422	}
2505		2423
2506	module_init(init_xfs_fs);	2424	module_init(init_xfs_fs);

fs/xfs/xfs_trace.h+45−0

@@ -3824,6 +3824,51 @@ TRACE_EVENT(xfs_iunlink_update_dinode, · 3823 unmodified lines
3824	__entry->new_ptr)	3824	__entry->new_ptr)
3825	);	3825	);
3826		3826
		3827	TRACE_EVENT(xfs_iunlink_reload_next,
		3828	TP_PROTO(struct xfs_inode *ip),
		3829	TP_ARGS(ip),
		3830	TP_STRUCT__entry(
		3831	__field(dev_t, dev)
		3832	__field(xfs_agnumber_t, agno)
		3833	__field(xfs_agino_t, agino)
		3834	__field(xfs_agino_t, prev_agino)
		3835	__field(xfs_agino_t, next_agino)
		3836	),
		3837	TP_fast_assign(
		3838	__entry->dev = ip->i_mount->m_super->s_dev;
		3839	__entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
		3840	__entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
		3841	__entry->prev_agino = ip->i_prev_unlinked;
		3842	__entry->next_agino = ip->i_next_unlinked;
		3843	),
		3844	TP_printk("dev %d:%d agno 0x%x agino 0x%x prev_unlinked 0x%x next_unlinked 0x%x",
		3845	MAJOR(__entry->dev), MINOR(__entry->dev),
		3846	__entry->agno,
		3847	__entry->agino,
		3848	__entry->prev_agino,
		3849	__entry->next_agino)
		3850	);
		3851
		3852	TRACE_EVENT(xfs_inode_reload_unlinked_bucket,
		3853	TP_PROTO(struct xfs_inode *ip),
		3854	TP_ARGS(ip),
		3855	TP_STRUCT__entry(
		3856	__field(dev_t, dev)
		3857	__field(xfs_agnumber_t, agno)
		3858	__field(xfs_agino_t, agino)
		3859	),
		3860	TP_fast_assign(
		3861	__entry->dev = ip->i_mount->m_super->s_dev;
		3862	__entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
		3863	__entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
		3864	),
		3865	TP_printk("dev %d:%d agno 0x%x agino 0x%x bucket %u",
		3866	MAJOR(__entry->dev), MINOR(__entry->dev),
		3867	__entry->agno,
		3868	__entry->agino,
		3869	__entry->agino % XFS_AGI_UNLINKED_BUCKETS)
		3870	);
		3871
3827	DECLARE_EVENT_CLASS(xfs_ag_inode_class,	3872	DECLARE_EVENT_CLASS(xfs_ag_inode_class,
3828	TP_PROTO(struct xfs_inode *ip),	3873	TP_PROTO(struct xfs_inode *ip),
3829	TP_ARGS(ip),	3874	TP_ARGS(ip),

fs/xfs/xfs_xattr.c+11−0

@@ -46,6 +46,17 @@ xfs_attr_grab_log_assist( · 45 unmodified lines
46	if (xfs_sb_version_haslogxattrs(&mp->m_sb))	46	if (xfs_sb_version_haslogxattrs(&mp->m_sb))
47	return 0;	47	return 0;
48		48
		49	/*
		50	* Check if the filesystem featureset is new enough to set this log
		51	* incompat feature bit. Strictly speaking, the minimum requirement is
		52	* a V5 filesystem for the superblock field, but we'll require rmap
		53	* or reflink to avoid having to deal with really old kernels.
		54	*/
		55	if (!xfs_has_reflink(mp) && !xfs_has_rmapbt(mp)) {
		56	error = -EOPNOTSUPP;
		57	goto drop_incompat;
		58	}
		59
49	/* Enable log-assisted xattrs. */	60	/* Enable log-assisted xattrs. */
50	error = xfs_add_incompat_log_feature(mp,	61	error = xfs_add_incompat_log_feature(mp,
51	XFS_SB_FEAT_INCOMPAT_LOG_XATTRS);	62	XFS_SB_FEAT_INCOMPAT_LOG_XATTRS);

include/asm-generic/hugetlb.h+1−1

@@ -76,7 +76,7 @@ static inline void hugetlb_free_pgd_range(struct mmu_gather *tlb, · 75 unmodified lines
76		76
77	#ifndef __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT	77	#ifndef __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT
78	static inline void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,	78	static inline void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
79	pte_t *ptep, pte_t pte)	79	pte_t *ptep, pte_t pte, unsigned long sz)
80	{	80	{
81	set_pte_at(mm, addr, ptep, pte);	81	set_pte_at(mm, addr, ptep, pte);
82	}	82	}

include/asm-generic/vmlinux.lds.h+0−7

@@ -138,13 +138,6 @@ · 137 unmodified lines
138	* are handled as text/data or they can be discarded (which	138	* are handled as text/data or they can be discarded (which
139	* often happens at runtime)	139	* often happens at runtime)
140	*/	140	*/
141	#ifdef CONFIG_HOTPLUG_CPU
142	#define CPU_KEEP(sec) *(.cpu##sec)
143	#define CPU_DISCARD(sec)
144	#else
145	#define CPU_KEEP(sec)
146	#define CPU_DISCARD(sec) *(.cpu##sec)
147	#endif
148		141
149	#if defined(CONFIG_MEMORY_HOTPLUG)	142	#if defined(CONFIG_MEMORY_HOTPLUG)
150	#define MEM_KEEP(sec) *(.mem##sec)	143	#define MEM_KEEP(sec) *(.mem##sec)

include/linux/aer.h+2−0

 #if defined(CONFIG_PCIEAER)
 int pci_aer_clear_nonfatal_status(struct pci_dev *dev);
+int pcie_aer_is_native(struct pci_dev *dev);
 #else
 static inline int pci_aer_clear_nonfatal_status(struct pci_dev *dev)
 {
 	return -EINVAL;
 }
+static inline int pcie_aer_is_native(struct pci_dev *dev) { return 0; }
 #endif
 void cper_print_aer(struct pci_dev *dev, int aer_severity,

include/linux/arm-smccc.h+2−0

@@ -67,6 +67,8 @@ · 66 unmodified lines
67	#define ARM_SMCCC_VERSION_1_3 0x10003	67	#define ARM_SMCCC_VERSION_1_3 0x10003
68		68
69	#define ARM_SMCCC_1_3_SVE_HINT 0x10000	69	#define ARM_SMCCC_1_3_SVE_HINT 0x10000
		70	#define ARM_SMCCC_CALL_HINTS ARM_SMCCC_1_3_SVE_HINT
		71
70		72
71	#define ARM_SMCCC_VERSION_FUNC_ID \	73	#define ARM_SMCCC_VERSION_FUNC_ID \
72	ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \	74	ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \

include/linux/atomic/atomic-arch-fallback.h+1−9

 {
 #if defined(arch_atomic_read_acquire)
 	return arch_atomic_read_acquire(v);
-#elif defined(arch_atomic_read)
-	return arch_atomic_read(v);
 #else
 	int ret;
 {
 #if defined(arch_atomic_set_release)
 	arch_atomic_set_release(v, i);
-#elif defined(arch_atomic_set)
-	arch_atomic_set(v, i);
 #else
 	if (__native_word(atomic_t)) {
 		smp_store_release(&(v)->counter, i);
 {
 #if defined(arch_atomic64_read_acquire)
 	return arch_atomic64_read_acquire(v);
-#elif defined(arch_atomic64_read)
-	return arch_atomic64_read(v);
 #else
 	s64 ret;
 {
 #if defined(arch_atomic64_set_release)
 	arch_atomic64_set_release(v, i);
-#elif defined(arch_atomic64_set)
-	arch_atomic64_set(v, i);
 #else
 	if (__native_word(atomic64_t)) {
 		smp_store_release(&(v)->counter, i);
 }
 #endif /* _LINUX_ATOMIC_FALLBACK_H */
-// 202b45c7db600ce36198eb1f1fc2c2d5268ace2d
+// 2fdd6702823fa842f9cea57a002e6e4476ae780c

include/linux/bpf.h+1−1

@@ -1318,7 +1318,7 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, · 1317 unmodified lines
1318	static inline struct bpf_trampoline *bpf_trampoline_get(u64 key,	1318	static inline struct bpf_trampoline *bpf_trampoline_get(u64 key,
1319	struct bpf_attach_target_info *tgt_info)	1319	struct bpf_attach_target_info *tgt_info)
1320	{	1320	{
1321	return ERR_PTR(-EOPNOTSUPP);	1321	return NULL;
1322	}	1322	}
1323	static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}	1323	static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}
1324	#define DEFINE_BPF_DISPATCHER(name)	1324	#define DEFINE_BPF_DISPATCHER(name)

include/linux/ceph/ceph_fs.h+11−13

@@ -467,19 +467,17 @@ union ceph_mds_request_args { · 466 unmodified lines
467	} __attribute__ ((packed));	467	} __attribute__ ((packed));
468		468
469	union ceph_mds_request_args_ext {	469	union ceph_mds_request_args_ext {
470	union {	470	union ceph_mds_request_args old;
471	union ceph_mds_request_args old;	471	struct {
472	struct {	472	__le32 mode;
473	__le32 mode;	473	__le32 uid;
474	__le32 uid;	474	__le32 gid;
475	__le32 gid;	475	struct ceph_timespec mtime;
476	struct ceph_timespec mtime;	476	struct ceph_timespec atime;
477	struct ceph_timespec atime;	477	__le64 size, old_size; /* old_size needed by truncate */
478	__le64 size, old_size; /* old_size needed by truncate */	478	__le32 mask; /* CEPH_SETATTR_* */
479	__le32 mask; /* CEPH_SETATTR_* */	479	struct ceph_timespec btime;
480	struct ceph_timespec btime;	480	} __attribute__ ((packed)) setattr_ext;
481	} __attribute__ ((packed)) setattr_ext;
482	};
483	};	481	};
484		482
485	#define CEPH_MDS_FLAG_REPLAY 1 /* this is a replayed op */	483	#define CEPH_MDS_FLAG_REPLAY 1 /* this is a replayed op */

include/linux/cpuhotplug.h+0−1

@@ -90,7 +90,6 @@ enum cpuhp_state { · 89 unmodified lines
90	CPUHP_FS_BUFF_DEAD,	90	CPUHP_FS_BUFF_DEAD,
91	CPUHP_PRINTK_DEAD,	91	CPUHP_PRINTK_DEAD,
92	CPUHP_MM_MEMCQ_DEAD,	92	CPUHP_MM_MEMCQ_DEAD,
93	CPUHP_XFS_DEAD,
94	CPUHP_PERCPU_CNT_DEAD,	93	CPUHP_PERCPU_CNT_DEAD,
95	CPUHP_RADIX_DEAD,	94	CPUHP_RADIX_DEAD,
96	CPUHP_PAGE_ALLOC,	95	CPUHP_PAGE_ALLOC,

include/linux/hugetlb.h+4−2

 						unsigned long addr, pte_t *ptep,
 						pte_t old_pte, pte_t pte)
 {
-	set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
+	unsigned long psize = huge_page_size(hstate_vma(vma));
+	set_huge_pte_at(vma->vm_mm, addr, ptep, pte, psize);
 }
 #endif
 }
 static inline void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
-				   pte_t *ptep, pte_t pte)
+				   pte_t *ptep, pte_t pte, unsigned long sz)
 {
 }

include/linux/interrupt.h+5−1

  * 	2) rcu_report_dead() reports the final quiescent states.
  *
  * _ IRQ_POLL: irq_poll_cpu_dead() migrates the queue
+ *
+ * _ (HR)TIMER_SOFTIRQ: (hr)timers_dead_cpu() migrates the queue
  */
-#define SOFTIRQ_HOTPLUG_SAFE_MASK (BIT(RCU_SOFTIRQ) | BIT(IRQ_POLL_SOFTIRQ))
+#define SOFTIRQ_HOTPLUG_SAFE_MASK (BIT(TIMER_SOFTIRQ) | BIT(IRQ_POLL_SOFTIRQ) |\
+				   BIT(HRTIMER_SOFTIRQ) | BIT(RCU_SOFTIRQ))
 /* map softirq index to softirq name. update 'softirq_to_name' in
  * kernel/softirq.c when adding a new softirq.

include/linux/kasan.h+1−1

@@ -54,7 +54,7 @@ extern p4d_t kasan_early_shadow_p4d[MAX_PTRS_PER_P4D]; · 53 unmodified lines
54	int kasan_populate_early_shadow(const void *shadow_start,	54	int kasan_populate_early_shadow(const void *shadow_start,
55	const void *shadow_end);	55	const void *shadow_end);
56		56
57	#ifndef __HAVE_ARCH_SHADOW_MAP	57	#ifndef kasan_mem_to_shadow
58	static inline void kasan_mem_to_shadow(const void addr)	58	static inline void kasan_mem_to_shadow(const void addr)
59	{	59	{
60	return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT)	60	return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT)

include/linux/libata.h+7−3

 	ATA_PFLAG_UNLOADING	= (1 << 9), /* driver is being unloaded */
 	ATA_PFLAG_UNLOADED	= (1 << 10), /* driver is unloaded */
+	ATA_PFLAG_RESUMING	= (1 << 16),  /* port is being resumed */
 	ATA_PFLAG_SUSPENDED	= (1 << 17), /* port is suspended (power) */
 	ATA_PFLAG_PM_PENDING	= (1 << 18), /* PM operation pending */
 	ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
 	 * advised to wait only for the following duration before
 	 * doing SRST.
 	 */
-	ATA_TMOUT_PMP_SRST_WAIT	= 5000,
+	ATA_TMOUT_PMP_SRST_WAIT	= 10000,
 	/* When the LPM policy is set to ATA_LPM_MAX_POWER, there might
 	 * be a spurious PHY event, so ignore the first PHY event that
 	ATA_EH_ENABLE_LINK	= (1 << 3),
 	ATA_EH_PARK		= (1 << 5), /* unload heads and stop I/O */
 	ATA_EH_GET_SUCCESS_SENSE = (1 << 6), /* Get sense data for successful cmd */
+	ATA_EH_SET_ACTIVE	= (1 << 7), /* Set a device to active power mode */
 	ATA_EH_PERDEV_MASK	= ATA_EH_REVALIDATE | ATA_EH_PARK |
-				  ATA_EH_GET_SUCCESS_SENSE,
+				  ATA_EH_GET_SUCCESS_SENSE | ATA_EH_SET_ACTIVE,
 	ATA_EH_ALL_ACTIONS	= ATA_EH_REVALIDATE | ATA_EH_RESET |
 				  ATA_EH_ENABLE_LINK,
 	/* This should match the actual table size of
 	 * ata_eh_cmd_timeout_table in libata-eh.c.
 	 */
-	ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 7,
+	ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 8,
 	/* Horkage types. May be set by libata or controller on drives
 	   (some horkage may be drive/controller pair dependent */
 			      struct block_device *bdev,
 			      sector_t capacity, int geom[]);
 extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);
+extern int ata_scsi_slave_alloc(struct scsi_device *sdev);
 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
 extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
 	.this_id		= ATA_SHT_THIS_ID,		\
 	.emulated		= ATA_SHT_EMULATED,		\
 	.proc_name		= drv_name,			\
+	.slave_alloc		= ata_scsi_slave_alloc,		\
 	.slave_destroy		= ata_scsi_slave_destroy,	\
 	.bios_param		= ata_std_bios_param,		\
 	.unlock_native_capacity	= ata_scsi_unlock_native_capacity,\

include/linux/maple_tree.h+11−0

 #define MAS_ROOT	((struct maple_enode *)5UL)
 #define MAS_NONE	((struct maple_enode *)9UL)
 #define MAS_PAUSE	((struct maple_enode *)17UL)
+#define MAS_OVERFLOW	((struct maple_enode *)33UL)
+#define MAS_UNDERFLOW	((struct maple_enode *)65UL)
 #define MA_ERROR(err) \
 		((struct maple_enode *)(((unsigned long)err << 2) | 2UL))
 	return mas->node == MAS_PAUSE;
 }
+/* Check if the mas is pointing to a node or not */
+static inline bool mas_is_active(struct ma_state *mas)
+{
+	if ((unsigned long)mas->node >= MAPLE_RESERVED_RANGE)
+		return true;
+	return false;
+}
 /**
  * mas_reset() - Reset a Maple Tree operation state.
  * @mas: Maple Tree operation state.

include/linux/memcontrol.h+2−2

@@ -920,7 +920,7 @@ unsigned long mem_cgroup_get_zone_lru_size(struct lruvec *lruvec, · 919 unmodified lines
920	return READ_ONCE(mz->lru_zone_size[zone_idx][lru]);	920	return READ_ONCE(mz->lru_zone_size[zone_idx][lru]);
921	}	921	}
922		922
923	void mem_cgroup_handle_over_high(void);	923	void mem_cgroup_handle_over_high(gfp_t gfp_mask);
924		924
925	unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);	925	unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);
926		926
@@ -1458,7 +1458,7 @@ static inline void mem_cgroup_unlock_pages(void) · 531 unmodified lines
1458	rcu_read_unlock();	1458	rcu_read_unlock();
1459	}	1459	}
1460		1460
1461	static inline void mem_cgroup_handle_over_high(void)	1461	static inline void mem_cgroup_handle_over_high(gfp_t gfp_mask)
1462	{	1462	{
1463	}	1463	}
1464		1464

include/linux/netfilter/nf_conntrack_sctp.h+1−0

@@ -9,6 +9,7 @@ struct ip_ct_sctp { · 8 unmodified lines
9	enum sctp_conntrack state;	9	enum sctp_conntrack state;
10		10
11	__be32 vtag[IP_CT_DIR_MAX];	11	__be32 vtag[IP_CT_DIR_MAX];
		12	u8 init[IP_CT_DIR_MAX];
12	u8 last_dir;	13	u8 last_dir;
13	u8 flags;	14	u8 flags;
14	};	15	};

include/linux/pgtable.h+9−1

 #endif
 #ifndef set_ptes
+#ifndef pte_next_pfn
+static inline pte_t pte_next_pfn(pte_t pte)
+{
+	return __pte(pte_val(pte) + (1UL << PFN_PTE_SHIFT));
+}
+#endif
 /**
  * set_ptes - Map consecutive pages to a contiguous range of addresses.
  * @mm: Address space to map the pages into.
 		if (--nr == 0)
 			break;
 		ptep++;
-		pte = __pte(pte_val(pte) + (1UL << PFN_PTE_SHIFT));
+		pte = pte_next_pfn(pte);
 	}
 	arch_leave_lazy_mmu_mode();
 }

include/linux/resume_user_mode.h+1−1

@@ -55,7 +55,7 @@ static inline void resume_user_mode_work(struct pt_regs *regs) · 54 unmodified lines
55	}	55	}
56	#endif	56	#endif
57		57
58	mem_cgroup_handle_over_high();	58	mem_cgroup_handle_over_high(GFP_KERNEL);
59	blkcg_maybe_throttle_current();	59	blkcg_maybe_throttle_current();
60		60
61	rseq_handle_notify_resume(NULL, regs);	61	rseq_handle_notify_resume(NULL, regs);

include/linux/seqlock.h+1−1

@@ -512,8 +512,8 @@ do { \ · 511 unmodified lines
512		512
513	static inline void do_write_seqcount_begin_nested(seqcount_t *s, int subclass)	513	static inline void do_write_seqcount_begin_nested(seqcount_t *s, int subclass)
514	{	514	{
515	do_raw_write_seqcount_begin(s);
516	seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);	515	seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);
		516	do_raw_write_seqcount_begin(s);
517	}	517	}
518		518
519	/**	519	/**

include/linux/swiotlb.h+16−7

 	if (!mem)
 		return false;
-	if (IS_ENABLED(CONFIG_SWIOTLB_DYNAMIC)) {
+#ifdef CONFIG_SWIOTLB_DYNAMIC
-		/* Pairs with smp_wmb() in swiotlb_find_slots() and
+	/*
-		 * swiotlb_dyn_alloc(), which modify the RCU lists.
+	 * All SWIOTLB buffer addresses must have been returned by
-		 */
+	 * swiotlb_tbl_map_single() and passed to a device driver.
-		smp_rmb();
+	 * If a SWIOTLB address is checked on another CPU, then it was
-		return swiotlb_find_pool(dev, paddr);
+	 * presumably loaded by the device driver from an unspecified private
-	}
+	 * data structure. Make sure that this load is ordered before reading
+	 * dev->dma_uses_io_tlb here and mem->pools in swiotlb_find_pool().
+	 *
+	 * This barrier pairs with smp_mb() in swiotlb_find_slots().
+	 */
+	smp_rmb();
+	return READ_ONCE(dev->dma_uses_io_tlb) &&
+		swiotlb_find_pool(dev, paddr);
+#else
 	return paddr >= mem->defpool.start && paddr < mem->defpool.end;
+#endif
 }
 static inline bool is_swiotlb_force_bounce(struct device *dev)

include/net/bluetooth/hci_core.h+1−1

@@ -350,7 +350,7 @@ struct hci_dev { · 349 unmodified lines
350	struct list_head list;	350	struct list_head list;
351	struct mutex lock;	351	struct mutex lock;
352		352
353	char name[8];	353	const char *name;
354	unsigned long flags;	354	unsigned long flags;
355	__u16 id;	355	__u16 id;
356	__u8 bus;	356	__u8 bus;

include/net/cfg80211.h+4−2

  * @event_lock: (private) lock for event list
  * @owner_nlportid: (private) owner socket port ID
  * @nl_owner_dead: (private) owner socket went away
+ * @cqm_rssi_work: (private) CQM RSSI reporting work
  * @cqm_config: (private) nl80211 RSSI monitor state
  * @pmsr_list: (private) peer measurement requests
  * @pmsr_lock: (private) peer measurements requests/results lock
 	} wext;
 #endif
-	struct cfg80211_cqm_config *cqm_config;
+	struct wiphy_work cqm_rssi_work;
+	struct cfg80211_cqm_config __rcu *cqm_config;
 	struct list_head pmsr_list;
 	spinlock_t pmsr_lock;
 	int uapsd_queues;
 	const u8 *ap_mld_addr;
 	struct {
-		const u8 *addr;
+		u8 addr[ETH_ALEN] __aligned(2);
 		struct cfg80211_bss *bss;
 		u16 status;
 	} links[IEEE80211_MLD_MAX_NUM_LINKS];

include/net/ip_fib.h+1−0

@@ -154,6 +154,7 @@ struct fib_info { · 153 unmodified lines
154	int fib_nhs;	154	int fib_nhs;
155	bool fib_nh_is_v6;	155	bool fib_nh_is_v6;
156	bool nh_updated;	156	bool nh_updated;
		157	bool pfsrc_removed;
157	struct nexthop *nh;	158	struct nexthop *nh;
158	struct rcu_head rcu;	159	struct rcu_head rcu;
159	struct fib_nh fib_nh[] __counted_by(fib_nhs);	160	struct fib_nh fib_nh[] __counted_by(fib_nhs);

include/net/mana/mana.h+3−2

@@ -103,9 +103,10 @@ struct mana_txq { · 102 unmodified lines
103		103
104	/* skb data and frags dma mappings */	104	/* skb data and frags dma mappings */
105	struct mana_skb_head {	105	struct mana_skb_head {
106	dma_addr_t dma_handle[MAX_SKB_FRAGS + 1];	106	/* GSO pkts may have 2 SGEs for the linear part*/
		107	dma_addr_t dma_handle[MAX_SKB_FRAGS + 2];
107		108
108	u32 size[MAX_SKB_FRAGS + 1];	109	u32 size[MAX_SKB_FRAGS + 2];
109	};	110	};
110		111
111	#define MANA_HEADROOM sizeof(struct mana_skb_head)	112	#define MANA_HEADROOM sizeof(struct mana_skb_head)

include/net/neighbour.h+1−1

@@ -539,7 +539,7 @@ static inline int neigh_output(struct neighbour n, struct sk_buff skb, · 538 unmodified lines
539	READ_ONCE(hh->hh_len))	539	READ_ONCE(hh->hh_len))
540	return neigh_hh_output(hh, skb);	540	return neigh_hh_output(hh, skb);
541		541
542	return n->output(n, skb);	542	return READ_ONCE(n->output)(n, skb);
543	}	543	}
544		544
545	static inline struct neighbour *	545	static inline struct neighbour *

include/net/page_pool/helpers.h+3−3

@@ -16,13 +16,13 @@ · 15 unmodified lines
16	* page_pool_alloc_pages() call. Drivers should use	16	* page_pool_alloc_pages() call. Drivers should use
17	* page_pool_dev_alloc_pages() replacing dev_alloc_pages().	17	* page_pool_dev_alloc_pages() replacing dev_alloc_pages().
18	*	18	*
19	* API keeps track of in-flight pages, in order to let API user know	19	* The API keeps track of in-flight pages, in order to let API users know
20	* when it is safe to free a page_pool object. Thus, API users	20	* when it is safe to free a page_pool object. Thus, API users
21	* must call page_pool_put_page() to free the page, or attach	21	* must call page_pool_put_page() to free the page, or attach
22	* the page to a page_pool-aware objects like skbs marked with	22	* the page to a page_pool-aware object like skbs marked with
23	* skb_mark_for_recycle().	23	* skb_mark_for_recycle().
24	*	24	*
25	* API user must call page_pool_put_page() once on a page, as it	25	* API users must call page_pool_put_page() once on a page, as it
26	* will either recycle the page, or in case of refcnt > 1, it will	26	* will either recycle the page, or in case of refcnt > 1, it will
27	* release the DMA mapping and in-flight state accounting.	27	* release the DMA mapping and in-flight state accounting.
28	*/	28	*/

include/net/tcp.h+4−2

 struct sk_buff *tcp_stream_alloc_skb(struct sock *sk, gfp_t gfp,
 				     bool force_schedule);
-static inline void tcp_dec_quickack_mode(struct sock *sk,
+static inline void tcp_dec_quickack_mode(struct sock *sk)
-					 const unsigned int pkts)
 {
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	if (icsk->icsk_ack.quick) {
+		/* How many ACKs S/ACKing new data have we sent? */
+		const unsigned int pkts = inet_csk_ack_scheduled(sk) ? 1 : 0;
 		if (pkts >= icsk->icsk_ack.quick) {
 			icsk->icsk_ack.quick = 0;
 			/* Leaving quickack mode we deflate ATO. */

include/scsi/scsi.h+3−0

 #define SCSI_3          4        /* SPC */
 #define SCSI_SPC_2      5
 #define SCSI_SPC_3      6
+#define SCSI_SPC_4	7
+#define SCSI_SPC_5	8
+#define SCSI_SPC_6	14
 /*
  * INQ PERIPHERAL QUALIFIERS

include/scsi/scsi_device.h+4−1

 				 * pass settings from slave_alloc to scsi
 				 * core. */
 	unsigned int eh_timeout; /* Error handling timeout */
+	bool manage_system_start_stop; /* Let HLD (sd) manage system start/stop */
+	bool manage_runtime_start_stop; /* Let HLD (sd) manage runtime start/stop */
 	unsigned removable:1;
 	unsigned changed:1;	/* Data invalid due to media change */
 	unsigned busy:1;	/* Used to prevent races */
 	unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
 	unsigned no_start_on_add:1;	/* do not issue start on add */
 	unsigned allow_restart:1; /* issue START_UNIT in error handler */
-	unsigned manage_start_stop:1;	/* Let HLD (sd) manage start/stop */
 	unsigned no_start_on_resume:1; /* Do not issue START_STOP_UNIT on resume */
 	unsigned start_stop_pwr_cond:1;	/* Set power cond. in START_STOP_UNIT */
 	unsigned no_uld_attach:1; /* disable connecting to upper level drivers */

include/scsi/scsi_host.h+1−1

@@ -764,7 +764,7 @@ scsi_template_proc_dir(const struct scsi_host_template *sht); · 763 unmodified lines
764	#define scsi_template_proc_dir(sht) NULL	764	#define scsi_template_proc_dir(sht) NULL
765	#endif	765	#endif
766	extern void scsi_scan_host(struct Scsi_Host *);	766	extern void scsi_scan_host(struct Scsi_Host *);
767	extern void scsi_rescan_device(struct scsi_device *);	767	extern int scsi_rescan_device(struct scsi_device *sdev);
768	extern void scsi_remove_host(struct Scsi_Host *);	768	extern void scsi_remove_host(struct Scsi_Host *);
769	extern struct Scsi_Host scsi_host_get(struct Scsi_Host );	769	extern struct Scsi_Host scsi_host_get(struct Scsi_Host );
770	extern int scsi_host_busy(struct Scsi_Host *shost);	770	extern int scsi_host_busy(struct Scsi_Host *shost);

include/uapi/linux/stddef.h+7−0

 		struct TAG { MEMBERS } ATTRS NAME; \
 	}
+#ifdef __cplusplus
+/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */
+#define __DECLARE_FLEX_ARRAY(T, member)	\
+	T member[0]
+#else
 /**
  * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union
  *
 #ifndef __counted_by
 #define __counted_by(m)
 #endif
+#endif /* _UAPI_LINUX_STDDEF_H */

io_uring/fs.c+1−1

@@ -243,7 +243,7 @@ int io_linkat_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 242 unmodified lines
243	struct io_link *lnk = io_kiocb_to_cmd(req, struct io_link);	243	struct io_link *lnk = io_kiocb_to_cmd(req, struct io_link);
244	const char __user oldf, newf;	244	const char __user oldf, newf;
245		245
246	if (sqe->rw_flags \|\| sqe->buf_index \|\| sqe->splice_fd_in)	246	if (sqe->buf_index \|\| sqe->splice_fd_in)
247	return -EINVAL;	247	return -EINVAL;
248	if (unlikely(req->flags & REQ_F_FIXED_FILE))	248	if (unlikely(req->flags & REQ_F_FIXED_FILE))
249	return -EBADF;	249	return -EBADF;

kernel/bpf/memalloc.c+19−25

 	return !ret ? NULL : ret + LLIST_NODE_SZ;
 }
-/* Most of the logic is taken from setup_kmalloc_cache_index_table() */
 static __init int bpf_mem_cache_adjust_size(void)
 {
-	unsigned int size, index;
+	unsigned int size;
-	/* Normally KMALLOC_MIN_SIZE is 8-bytes, but it can be
+	/* Adjusting the indexes in size_index() according to the object_size
-	 * up-to 256-bytes.
+	 * of underlying slab cache, so bpf_mem_alloc() will select a
+	 * bpf_mem_cache with unit_size equal to the object_size of
+	 * the underlying slab cache.
+	 *
+	 * The maximal value of KMALLOC_MIN_SIZE and __kmalloc_minalign() is
+	 * 256-bytes, so only do adjustment for [8-bytes, 192-bytes].
 	 */
-	size = KMALLOC_MIN_SIZE;
+	for (size = 192; size >= 8; size -= 8) {
-	if (size <= 192)
+		unsigned int kmalloc_size, index;
-		index = size_index[(size - 1) / 8];
-	else
-		index = fls(size - 1) - 1;
-	for (size = 8; size < KMALLOC_MIN_SIZE && size <= 192; size += 8)
-		size_index[(size - 1) / 8] = index;
-	/* The minimal alignment is 64-bytes, so disable 96-bytes cache and
+		kmalloc_size = kmalloc_size_roundup(size);
-	 * use 128-bytes cache instead.
+		if (kmalloc_size == size)
-	 */
+			continue;
-	if (KMALLOC_MIN_SIZE >= 64) {
-		index = size_index[(128 - 1) / 8];
-		for (size = 64 + 8; size <= 96; size += 8)
-			size_index[(size - 1) / 8] = index;
-	}
-	/* The minimal alignment is 128-bytes, so disable 192-bytes cache and
+		if (kmalloc_size <= 192)
-	 * use 256-bytes cache instead.
+			index = size_index[(kmalloc_size - 1) / 8];
-	 */
+		else
-	if (KMALLOC_MIN_SIZE >= 128) {
+			index = fls(kmalloc_size - 1) - 1;
-		index = fls(256 - 1) - 1;
+		/* Only overwrite if necessary */
-		for (size = 128 + 8; size <= 192; size += 8)
+		if (size_index[(size - 1) / 8] != index)
 			size_index[(size - 1) / 8] = index;
 	}

kernel/bpf/mprog.c+3−0

 			goto out;
 		}
 		idx = tidx;
+	} else if (bpf_mprog_total(entry) == bpf_mprog_max()) {
+		ret = -ERANGE;
+		goto out;
 	}
 	if (flags & BPF_F_BEFORE) {
 		tidx = bpf_mprog_pos_before(entry, &rtuple);

kernel/bpf/verifier.c+3−5

 				bitmap_from_u64(mask, bt_reg_mask(bt));
 				for_each_set_bit(i, mask, 32) {
 					reg = &st->frame[0]->regs[i];
-					if (reg->type != SCALAR_VALUE) {
+					bt_clear_reg(bt, i);
-						bt_clear_reg(bt, i);
+					if (reg->type == SCALAR_VALUE)
-						continue;
+						reg->precise = true;
-					}
-					reg->precise = true;
 				}
 				return 0;
 			}

kernel/crash_core.c+17−0

 #undef pr_fmt
 #define pr_fmt(fmt) "crash hp: " fmt
+/*
+ * Different than kexec/kdump loading/unloading/jumping/shrinking which
+ * usually rarely happen, there will be many crash hotplug events notified
+ * during one short period, e.g one memory board is hot added and memory
+ * regions are online. So mutex lock  __crash_hotplug_lock is used to
+ * serialize the crash hotplug handling specifically.
+ */
+DEFINE_MUTEX(__crash_hotplug_lock);
+#define crash_hotplug_lock() mutex_lock(&__crash_hotplug_lock)
+#define crash_hotplug_unlock() mutex_unlock(&__crash_hotplug_lock)
 /*
  * This routine utilized when the crash_hotplug sysfs node is read.
  * It reflects the kernel's ability/permission to update the crash
 {
 	int rc = 0;
+	crash_hotplug_lock();
 	/* Obtain lock while reading crash information */
 	if (!kexec_trylock()) {
 		pr_info("kexec_trylock() failed, elfcorehdr may be inaccurate\n");
+		crash_hotplug_unlock();
 		return 0;
 	}
 	if (kexec_crash_image) {
 	}
 	/* Release lock now that update complete */
 	kexec_unlock();
+	crash_hotplug_unlock();
 	return rc;
 }
 {
 	struct kimage *image;
+	crash_hotplug_lock();
 	/* Obtain lock while changing crash information */
 	if (!kexec_trylock()) {
 		pr_info("kexec_trylock() failed, elfcorehdr may be inaccurate\n");
+		crash_hotplug_unlock();
 		return;
 	}
 out:
 	/* Release lock now that update complete */
 	kexec_unlock();
+	crash_hotplug_unlock();
 }
 static int crash_memhp_notifier(struct notifier_block *nb, unsigned long val, void *v)

kernel/dma/swiotlb.c+22−9

@@ -399,14 +399,13 @@ void __init swiotlb_init_remap(bool addressing_limit, unsigned int flags, · 398 unmodified lines
399	}	399	}
400		400
401	mem->areas = memblock_alloc(array_size(sizeof(struct io_tlb_area),	401	mem->areas = memblock_alloc(array_size(sizeof(struct io_tlb_area),
402	default_nareas), SMP_CACHE_BYTES);	402	nareas), SMP_CACHE_BYTES);
403	if (!mem->areas) {	403	if (!mem->areas) {
404	pr_warn("%s: Failed to allocate mem->areas.\n", __func__);	404	pr_warn("%s: Failed to allocate mem->areas.\n", __func__);
405	return;	405	return;
406	}	406	}
407		407
408	swiotlb_init_io_tlb_pool(mem, __pa(tlb), nslabs, false,	408	swiotlb_init_io_tlb_pool(mem, __pa(tlb), nslabs, false, nareas);
409	default_nareas);
410	add_mem_pool(&io_tlb_default_mem, mem);	409	add_mem_pool(&io_tlb_default_mem, mem);
411		410
412	if (flags & SWIOTLB_VERBOSE)	411	if (flags & SWIOTLB_VERBOSE)
@@ -729,9 +728,6 @@ static void swiotlb_dyn_alloc(struct work_struct *work) · 316 unmodified lines
729	}	728	}
730		729
731	add_mem_pool(mem, pool);	730	add_mem_pool(mem, pool);
732
733	/* Pairs with smp_rmb() in is_swiotlb_buffer(). */
734	smp_wmb();
735	}	731	}
736		732
737	/**	733	/**
@@ -1152,9 +1148,26 @@ static int swiotlb_find_slots(struct device *dev, phys_addr_t orig_addr, · 414 unmodified lines
1152	spin_unlock_irqrestore(&dev->dma_io_tlb_lock, flags);	1148	spin_unlock_irqrestore(&dev->dma_io_tlb_lock, flags);
1153		1149
1154	found:	1150	found:
1155	dev->dma_uses_io_tlb = true;	1151	WRITE_ONCE(dev->dma_uses_io_tlb, true);
1156	/* Pairs with smp_rmb() in is_swiotlb_buffer() */	1152
1157	smp_wmb();	1153	/*
		1154	* The general barrier orders reads and writes against a presumed store
		1155	* of the SWIOTLB buffer address by a device driver (to a driver private
		1156	* data structure). It serves two purposes.
		1157	*
		1158	* First, the store to dev->dma_uses_io_tlb must be ordered before the
		1159	* presumed store. This guarantees that the returned buffer address
		1160	* cannot be passed to another CPU before updating dev->dma_uses_io_tlb.
		1161	*
		1162	* Second, the load from mem->pools must be ordered before the same
		1163	* presumed store. This guarantees that the returned buffer address
		1164	* cannot be observed by another CPU before an update of the RCU list
		1165	* that was made by swiotlb_dyn_alloc() on a third CPU (cf. multicopy
		1166	* atomicity).
		1167	*
		1168	* See also the comment in is_swiotlb_buffer().
		1169	*/
		1170	smp_mb();
1158		1171
1159	*retpool = pool;	1172	*retpool = pool;
1160	return index;	1173	return index;

kernel/pid.c+1−1

@@ -609,7 +609,7 @@ int pidfd_create(struct pid *pid, unsigned int flags) · 608 unmodified lines
609	}	609	}
610		610
611	/**	611	/**
612	* pidfd_open() - Open new pid file descriptor.	612	* sys_pidfd_open() - Open new pid file descriptor.
613	*	613	*
614	* @pid: pid for which to retrieve a pidfd	614	* @pid: pid for which to retrieve a pidfd
615	* @flags: flags to pass	615	* @flags: flags to pass

kernel/sched/core.c+1−1

@@ -9269,7 +9269,7 @@ void __init init_idle(struct task_struct *idle, int cpu) · 9268 unmodified lines
9269	* PF_KTHREAD should already be set at this point; regardless, make it	9269	* PF_KTHREAD should already be set at this point; regardless, make it
9270	* look like a proper per-CPU kthread.	9270	* look like a proper per-CPU kthread.
9271	*/	9271	*/
9272	idle->flags \|= PF_IDLE \| PF_KTHREAD \| PF_NO_SETAFFINITY;	9272	idle->flags \|= PF_KTHREAD \| PF_NO_SETAFFINITY;
9273	kthread_set_per_cpu(idle, cpu);	9273	kthread_set_per_cpu(idle, cpu);
9274		9274
9275	#ifdef CONFIG_SMP	9275	#ifdef CONFIG_SMP

kernel/sched/cpupri.c+1−0

@@ -101,6 +101,7 @@ static inline int __cpupri_find(struct cpupri cp, struct task_struct p, · 100 unmodified lines
101		101
102	if (lowest_mask) {	102	if (lowest_mask) {
103	cpumask_and(lowest_mask, &p->cpus_mask, vec->mask);	103	cpumask_and(lowest_mask, &p->cpus_mask, vec->mask);
		104	cpumask_and(lowest_mask, lowest_mask, cpu_active_mask);
104		105
105	/*	106	/*
106	* We have to ensure that we have at least one bit	107	* We have to ensure that we have at least one bit

kernel/sched/idle.c+1−0

@@ -373,6 +373,7 @@ EXPORT_SYMBOL_GPL(play_idle_precise); · 372 unmodified lines
373		373
374	void cpu_startup_entry(enum cpuhp_state state)	374	void cpu_startup_entry(enum cpuhp_state state)
375	{	375	{
		376	current->flags \|= PF_IDLE;
376	arch_cpu_idle_prepare();	377	arch_cpu_idle_prepare();
377	cpuhp_online_idle(state);	378	cpuhp_online_idle(state);
378	while (1)	379	while (1)

kernel/task_work.c+1−0

@@ -78,6 +78,7 @@ int task_work_add(struct task_struct task, struct callback_head work, · 77 unmodified lines
78	* task_work_cancel_match - cancel a pending work added by task_work_add()	78	* task_work_cancel_match - cancel a pending work added by task_work_add()
79	* @task: the task which should execute the work	79	* @task: the task which should execute the work
80	* @match: match function to call	80	* @match: match function to call
		81	* @data: data to be passed in to match function
81	*	82	*
82	* RETURNS:	83	* RETURNS:
83	* The found work or NULL if not found.	84	* The found work or NULL if not found.

kernel/trace/ring_buffer.c+18−13

 	local_set(&bpage->commit, 0);
 }
+static __always_inline unsigned int rb_page_commit(struct buffer_page *bpage)
+{
+	return local_read(&bpage->page->commit);
+}
 static void free_buffer_page(struct buffer_page *bpage)
 {
 	free_page((unsigned long)bpage->page);
 	if (full) {
 		poll_wait(filp, &work->full_waiters, poll_table);
 		work->full_waiters_pending = true;
+		if (!cpu_buffer->shortest_full ||
+		    cpu_buffer->shortest_full > full)
+			cpu_buffer->shortest_full = full;
 	} else {
 		poll_wait(filp, &work->waiters, poll_table);
 		work->waiters_pending = true;
 			 * Increment overrun to account for the lost events.
 			 */
 			local_add(page_entries, &cpu_buffer->overrun);
-			local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
+			local_sub(rb_page_commit(to_remove_page), &cpu_buffer->entries_bytes);
 			local_inc(&cpu_buffer->pages_lost);
 		}
 			       cpu_buffer->reader_page->read);
 }
-static __always_inline unsigned rb_page_commit(struct buffer_page *bpage)
-{
-	return local_read(&bpage->page->commit);
-}
 static struct ring_buffer_event *
 rb_iter_head_event(struct ring_buffer_iter *iter)
 {
 		 * the counters.
 		 */
 		local_add(entries, &cpu_buffer->overrun);
-		local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
+		local_sub(rb_page_commit(next_page), &cpu_buffer->entries_bytes);
 		local_inc(&cpu_buffer->pages_lost);
 		/*
 	event = __rb_page_index(tail_page, tail);
-	/* account for padding bytes */
-	local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes);
 	/*
 	 * Save the original length to the meta data.
 	 * This will be used by the reader to add lost event
 	 * write counter enough to allow another writer to slip
 	 * in on this page.
 	 * We put in a discarded commit instead, to make sure
-	 * that this space is not used again.
+	 * that this space is not used again, and this space will
+	 * not be accounted into 'entries_bytes'.
 	 *
 	 * If we are less than the minimum size, we don't need to
 	 * worry about it.
 	/* time delta must be non zero */
 	event->time_delta = 1;
+	/* account for padding bytes */
+	local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes);
 	/* Make sure the padding is visible before the tail_page->write update */
 	smp_wmb();
 EXPORT_SYMBOL_GPL(ring_buffer_oldest_event_ts);
 /**
- * ring_buffer_bytes_cpu - get the number of bytes consumed in a cpu buffer
+ * ring_buffer_bytes_cpu - get the number of bytes unconsumed in a cpu buffer
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to read from.
  */
 	length = rb_event_length(event);
 	cpu_buffer->reader_page->read += length;
+	cpu_buffer->read_bytes += length;
 }
 static void rb_advance_iter(struct ring_buffer_iter *iter)
 	} else {
 		/* update the entry counter */
 		cpu_buffer->read += rb_page_entries(reader);
-		cpu_buffer->read_bytes += BUF_PAGE_SIZE;
+		cpu_buffer->read_bytes += rb_page_commit(reader);
 		/* swap the pages */
 		rb_init_page(bpage);

kernel/trace/trace_events.c+1−0

@@ -2770,6 +2770,7 @@ void trace_event_eval_update(struct trace_eval_map **map, int len) · 2769 unmodified lines
2770	update_event_fields(call, map[i]);	2770	update_event_fields(call, map[i]);
2771	}	2771	}
2772	}	2772	}
		2773	cond_resched();
2773	}	2774	}
2774	up_write(&trace_event_sem);	2775	up_write(&trace_event_sem);
2775	}	2776	}

kernel/trace/trace_events_user.c+51−7

 /* Bit 7 is for freeing status of enablement */
 #define ENABLE_VAL_FREEING_BIT 7
-/* Only duplicate the bit value */
+/* Bit 8 is for marking 32-bit on 64-bit */
-#define ENABLE_VAL_DUP_MASK ENABLE_VAL_BIT_MASK
+#define ENABLE_VAL_32_ON_64_BIT 8
+#define ENABLE_VAL_COMPAT_MASK (1 << ENABLE_VAL_32_ON_64_BIT)
+/* Only duplicate the bit and compat values */
+#define ENABLE_VAL_DUP_MASK (ENABLE_VAL_BIT_MASK | ENABLE_VAL_COMPAT_MASK)
 #define ENABLE_BITOPS(e) (&(e)->values)
 	int			flags;
 };
+static inline void align_addr_bit(unsigned long *addr, int *bit,
+				  unsigned long *flags)
+{
+	if (IS_ALIGNED(*addr, sizeof(long))) {
+#ifdef __BIG_ENDIAN
+		/* 32 bit on BE 64 bit requires a 32 bit offset when aligned. */
+		if (test_bit(ENABLE_VAL_32_ON_64_BIT, flags))
+			*bit += 32;
+#endif
+		return;
+	}
+	*addr = ALIGN_DOWN(*addr, sizeof(long));
+	/*
+	 * We only support 32 and 64 bit values. The only time we need
+	 * to align is a 32 bit value on a 64 bit kernel, which on LE
+	 * is always 32 bits, and on BE requires no change when unaligned.
+	 */
+#ifdef __LITTLE_ENDIAN
+	*bit += 32;
+#endif
+}
 typedef void (*user_event_func_t) (struct user_event *user, struct iov_iter *i,
 				   void *tpdata, bool *faulted);
 	unsigned long *ptr;
 	struct page *page;
 	void *kaddr;
+	int bit = ENABLE_BIT(enabler);
 	int ret;
 	lockdep_assert_held(&event_mutex);
 		     test_bit(ENABLE_VAL_FREEING_BIT, ENABLE_BITOPS(enabler))))
 		return -EBUSY;
+	align_addr_bit(&uaddr, &bit, ENABLE_BITOPS(enabler));
 	ret = pin_user_pages_remote(mm->mm, uaddr, 1, FOLL_WRITE | FOLL_NOFAULT,
 				    &page, NULL);
 	/* Update bit atomically, user tracers must be atomic as well */
 	if (enabler->event && enabler->event->status)
-		set_bit(ENABLE_BIT(enabler), ptr);
+		set_bit(bit, ptr);
 	else
-		clear_bit(ENABLE_BIT(enabler), ptr);
+		clear_bit(bit, ptr);
 	kunmap_local(kaddr);
 	unpin_user_pages_dirty_lock(&page, 1, true);
 	enabler->event = user;
 	enabler->addr = uaddr;
 	enabler->values = reg->enable_bit;
+#if BITS_PER_LONG >= 64
+	if (reg->enable_size == 4)
+		set_bit(ENABLE_VAL_32_ON_64_BIT, ENABLE_BITOPS(enabler));
+#endif
 retry:
 	/* Prevents state changes from racing with new enablers */
 	mutex_lock(&event_mutex);
 }
 static int user_event_mm_clear_bit(struct user_event_mm *user_mm,
-				   unsigned long uaddr, unsigned char bit)
+				   unsigned long uaddr, unsigned char bit,
+				   unsigned long flags)
 {
 	struct user_event_enabler enabler;
 	int result;
 	memset(&enabler, 0, sizeof(enabler));
 	enabler.addr = uaddr;
-	enabler.values = bit;
+	enabler.values = bit | flags;
 retry:
 	/* Prevents state changes from racing with new enablers */
 	mutex_lock(&event_mutex);
 	struct user_event_mm *mm = current->user_event_mm;
 	struct user_event_enabler *enabler, *next;
 	struct user_unreg reg;
+	unsigned long flags;
 	long ret;
 	ret = user_unreg_get(ureg, &reg);
 	if (!mm)
 		return -ENOENT;
+	flags = 0;
 	ret = -ENOENT;
 	/*
 		    ENABLE_BIT(enabler) == reg.disable_bit) {
 			set_bit(ENABLE_VAL_FREEING_BIT, ENABLE_BITOPS(enabler));
+			/* We must keep compat flags for the clear */
+			flags |= enabler->values & ENABLE_VAL_COMPAT_MASK;
 			if (!test_bit(ENABLE_VAL_FAULTING_BIT, ENABLE_BITOPS(enabler)))
 				user_event_enabler_destroy(enabler, true);
 	/* Ensure bit is now cleared for user, regardless of event status */
 	if (!ret)
 		ret = user_event_mm_clear_bit(mm, reg.disable_addr,
-					      reg.disable_bit);
+					      reg.disable_bit, flags);
 	return ret;
 }

kernel/workqueue.c+3−6

 	BUG_ON(!zalloc_cpumask_var_node(&pt->pod_cpus[0], GFP_KERNEL, NUMA_NO_NODE));
-	wq_update_pod_attrs_buf = alloc_workqueue_attrs();
-	BUG_ON(!wq_update_pod_attrs_buf);
 	pt->nr_pods = 1;
 	cpumask_copy(pt->pod_cpus[0], cpu_possible_mask);
 	pt->pod_node[0] = NUMA_NO_NODE;
 	unsigned long thresh;
 	unsigned long bogo;
+	pwq_release_worker = kthread_create_worker(0, "pool_workqueue_release");
+	BUG_ON(IS_ERR(pwq_release_worker));
 	/* if the user set it to a specific value, keep it */
 	if (wq_cpu_intensive_thresh_us != ULONG_MAX)
 		return;
-	pwq_release_worker = kthread_create_worker(0, "pool_workqueue_release");
-	BUG_ON(IS_ERR(pwq_release_worker));
 	/*
 	 * The default of 10ms is derived from the fact that most modern (as of
 	 * 2023) processors can do a lot in 10ms and that it's just below what

lib/argv_split.c+2−2

@@ -28,7 +28,7 @@ static int count_argc(const char *str) · 27 unmodified lines
28		28
29	/**	29	/**
30	* argv_free - free an argv	30	* argv_free - free an argv
31	* @argv - the argument vector to be freed	31	* @argv: the argument vector to be freed
32	*	32	*
33	* Frees an argv and the strings it points to.	33	* Frees an argv and the strings it points to.
34	*/	34	*/
@@ -46,7 +46,7 @@ EXPORT_SYMBOL(argv_free); · 11 unmodified lines
46	* @str: the string to be split	46	* @str: the string to be split
47	* @argcp: returned argument count	47	* @argcp: returned argument count
48	*	48	*
49	* Returns an array of pointers to strings which are split out from	49	* Returns: an array of pointers to strings which are split out from
50	* @str. This is performed by strictly splitting on white-space; no	50	* @str. This is performed by strictly splitting on white-space; no
51	* quote processing is performed. Multiple whitespace characters are	51	* quote processing is performed. Multiple whitespace characters are
52	* considered to be a single argument separator. The returned array	52	* considered to be a single argument separator. The returned array

lib/maple_tree.c+163−58

@@ -256,6 +256,22 @@ bool mas_is_err(struct ma_state *mas) · 255 unmodified lines
256	return xa_is_err(mas->node);	256	return xa_is_err(mas->node);
257	}	257	}
258		258
		259	static __always_inline bool mas_is_overflow(struct ma_state *mas)
		260	{
		261	if (unlikely(mas->node == MAS_OVERFLOW))
		262	return true;
		263
		264	return false;
		265	}
		266
		267	static __always_inline bool mas_is_underflow(struct ma_state *mas)
		268	{
		269	if (unlikely(mas->node == MAS_UNDERFLOW))
		270	return true;
		271
		272	return false;
		273	}
		274
259	static inline bool mas_searchable(struct ma_state *mas)	275	static inline bool mas_searchable(struct ma_state *mas)
260	{	276	{
261	if (mas_is_none(mas))	277	if (mas_is_none(mas))
@@ -4415,10 +4431,13 @@ no_entry: · 4153 unmodified lines
4415	*	4431	*
4416	* @mas: The maple state	4432	* @mas: The maple state
4417	* @max: The minimum starting range	4433	* @max: The minimum starting range
		4434	* @empty: Can be empty
		4435	* @set_underflow: Set the @mas->node to underflow state on limit.
4418	*	4436	*
4419	* Return: The entry in the previous slot which is possibly NULL	4437	* Return: The entry in the previous slot which is possibly NULL
4420	*/	4438	*/
4421	static void mas_prev_slot(struct ma_state mas, unsigned long min, bool empty)	4439	static void mas_prev_slot(struct ma_state mas, unsigned long min, bool empty,
		4440	bool set_underflow)
4422	{	4441	{
4423	void *entry;	4442	void *entry;
4424	void __rcu **slots;	4443	void __rcu **slots;
@@ -4435,7 +4454,6 @@ retry: · 10 unmodified lines
4435	if (unlikely(mas_rewalk_if_dead(mas, node, save_point)))	4454	if (unlikely(mas_rewalk_if_dead(mas, node, save_point)))
4436	goto retry;	4455	goto retry;
4437		4456
4438	again:
4439	if (mas->min <= min) {	4457	if (mas->min <= min) {
4440	pivot = mas_safe_min(mas, pivots, mas->offset);	4458	pivot = mas_safe_min(mas, pivots, mas->offset);
4441		4459
@@ -4443,9 +4461,10 @@ again: · 1 unmodified line
4443	goto retry;	4461	goto retry;
4444		4462
4445	if (pivot <= min)	4463	if (pivot <= min)
4446	return NULL;	4464	goto underflow;
4447	}	4465	}
4448		4466
		4467	again:
4449	if (likely(mas->offset)) {	4468	if (likely(mas->offset)) {
4450	mas->offset--;	4469	mas->offset--;
4451	mas->last = mas->index - 1;	4470	mas->last = mas->index - 1;
@@ -4457,7 +4476,7 @@ again: · 5 unmodified lines
4457	}	4476	}
4458		4477
4459	if (mas_is_none(mas))	4478	if (mas_is_none(mas))
4460	return NULL;	4479	goto underflow;
4461		4480
4462	mas->last = mas->max;	4481	mas->last = mas->max;
4463	node = mas_mn(mas);	4482	node = mas_mn(mas);
@@ -4474,10 +4493,19 @@ again: · 10 unmodified lines
4474	if (likely(entry))	4493	if (likely(entry))
4475	return entry;	4494	return entry;
4476		4495
4477	if (!empty)	4496	if (!empty) {
		4497	if (mas->index <= min)
		4498	goto underflow;
		4499
4478	goto again;	4500	goto again;
		4501	}
4479		4502
4480	return entry;	4503	return entry;
		4504
		4505	underflow:
		4506	if (set_underflow)
		4507	mas->node = MAS_UNDERFLOW;
		4508	return NULL;
4481	}	4509	}
4482		4510
4483	/*	4511	/*
@@ -4567,10 +4595,13 @@ no_entry: · 83 unmodified lines
4567	* @mas: The maple state	4595	* @mas: The maple state
4568	* @max: The maximum starting range	4596	* @max: The maximum starting range
4569	* @empty: Can be empty	4597	* @empty: Can be empty
		4598	* @set_overflow: Should @mas->node be set to overflow when the limit is
		4599	* reached.
4570	*	4600	*
4571	* Return: The entry in the next slot which is possibly NULL	4601	* Return: The entry in the next slot which is possibly NULL
4572	*/	4602	*/
4573	static void mas_next_slot(struct ma_state mas, unsigned long max, bool empty)	4603	static void mas_next_slot(struct ma_state mas, unsigned long max, bool empty,
		4604	bool set_overflow)
4574	{	4605	{
4575	void __rcu **slots;	4606	void __rcu **slots;
4576	unsigned long *pivots;	4607	unsigned long *pivots;
@@ -4589,22 +4620,22 @@ retry: · 12 unmodified lines
4589	if (unlikely(mas_rewalk_if_dead(mas, node, save_point)))	4620	if (unlikely(mas_rewalk_if_dead(mas, node, save_point)))
4590	goto retry;	4621	goto retry;
4591		4622
4592	again:
4593	if (mas->max >= max) {	4623	if (mas->max >= max) {
4594	if (likely(mas->offset < data_end))	4624	if (likely(mas->offset < data_end))
4595	pivot = pivots[mas->offset];	4625	pivot = pivots[mas->offset];
4596	else	4626	else
4597	return NULL; /* must be mas->max */	4627	goto overflow;
4598		4628
4599	if (unlikely(mas_rewalk_if_dead(mas, node, save_point)))	4629	if (unlikely(mas_rewalk_if_dead(mas, node, save_point)))
4600	goto retry;	4630	goto retry;
4601		4631
4602	if (pivot >= max)	4632	if (pivot >= max)
4603	return NULL;	4633	goto overflow;
4604	}	4634	}
4605		4635
4606	if (likely(mas->offset < data_end)) {	4636	if (likely(mas->offset < data_end)) {
4607	mas->index = pivots[mas->offset] + 1;	4637	mas->index = pivots[mas->offset] + 1;
		4638	again:
4608	mas->offset++;	4639	mas->offset++;
4609	if (likely(mas->offset < data_end))	4640	if (likely(mas->offset < data_end))
4610	mas->last = pivots[mas->offset];	4641	mas->last = pivots[mas->offset];
@@ -4616,8 +4647,11 @@ again: · 5 unmodified lines
4616	goto retry;	4647	goto retry;
4617	}	4648	}
4618		4649
4619	if (mas_is_none(mas))	4650	if (WARN_ON_ONCE(mas_is_none(mas))) {
		4651	mas->node = MAS_OVERFLOW;
4620	return NULL;	4652	return NULL;
		4653	goto overflow;
		4654	}
4621		4655
4622	mas->offset = 0;	4656	mas->offset = 0;
4623	mas->index = mas->min;	4657	mas->index = mas->min;
@@ -4636,12 +4670,20 @@ again: · 12 unmodified lines
4636	return entry;	4670	return entry;
4637		4671
4638	if (!empty) {	4672	if (!empty) {
4639	if (!mas->offset)	4673	if (mas->last >= max)
4640	data_end = 2;	4674	goto overflow;
		4675
		4676	mas->index = mas->last + 1;
		4677	/* Node cannot end on NULL, so it's safe to short-cut here */
4641	goto again;	4678	goto again;
4642	}	4679	}
4643		4680
4644	return entry;	4681	return entry;
		4682
		4683	overflow:
		4684	if (set_overflow)
		4685	mas->node = MAS_OVERFLOW;
		4686	return NULL;
4645	}	4687	}
4646		4688
4647	/*	4689	/*
@@ -4651,17 +4693,20 @@ again: · 3 unmodified lines
4651	*	4693	*
4652	* Set the @mas->node to the next entry and the range_start to	4694	* Set the @mas->node to the next entry and the range_start to
4653	* the beginning value for the entry. Does not check beyond @limit.	4695	* the beginning value for the entry. Does not check beyond @limit.
4654	* Sets @mas->index and @mas->last to the limit if it is hit.	4696	* Sets @mas->index and @mas->last to the range, Does not update @mas->index and
		4697	* @mas->last on overflow.
4655	* Restarts on dead nodes.	4698	* Restarts on dead nodes.
4656	*	4699	*
4657	* Return: the next entry or %NULL.	4700	* Return: the next entry or %NULL.
4658	*/	4701	*/
4659	static inline void mas_next_entry(struct ma_state mas, unsigned long limit)	4702	static inline void mas_next_entry(struct ma_state mas, unsigned long limit)
4660	{	4703	{
4661	if (mas->last >= limit)	4704	if (mas->last >= limit) {
		4705	mas->node = MAS_OVERFLOW;
4662	return NULL;	4706	return NULL;
		4707	}
4663		4708
4664	return mas_next_slot(mas, limit, false);	4709	return mas_next_slot(mas, limit, false, true);
4665	}	4710	}
4666		4711
4667	/*	4712	/*
@@ -4837,7 +4882,7 @@ void mas_walk(struct ma_state mas) · 169 unmodified lines
4837	{	4882	{
4838	void *entry;	4883	void *entry;
4839		4884
4840	if (mas_is_none(mas) \|\| mas_is_paused(mas) \|\| mas_is_ptr(mas))	4885	if (!mas_is_active(mas) \|\| !mas_is_start(mas))
4841	mas->node = MAS_START;	4886	mas->node = MAS_START;
4842	retry:	4887	retry:
4843	entry = mas_state_walk(mas);	4888	entry = mas_state_walk(mas);
@@ -5294,14 +5339,22 @@ static inline void mte_destroy_walk(struct maple_enode *enode, · 450 unmodified lines
5294		5339
5295	static void mas_wr_store_setup(struct ma_wr_state *wr_mas)	5340	static void mas_wr_store_setup(struct ma_wr_state *wr_mas)
5296	{	5341	{
5297	if (mas_is_start(wr_mas->mas))	5342	if (!mas_is_active(wr_mas->mas)) {
5298	return;	5343	if (mas_is_start(wr_mas->mas))
		5344	return;
5299		5345
5300	if (unlikely(mas_is_paused(wr_mas->mas)))	5346	if (unlikely(mas_is_paused(wr_mas->mas)))
5301	goto reset;	5347	goto reset;
5302		5348
5303	if (unlikely(mas_is_none(wr_mas->mas)))	5349	if (unlikely(mas_is_none(wr_mas->mas)))
5304	goto reset;	5350	goto reset;
		5351
		5352	if (unlikely(mas_is_overflow(wr_mas->mas)))
		5353	goto reset;
		5354
		5355	if (unlikely(mas_is_underflow(wr_mas->mas)))
		5356	goto reset;
		5357	}
5305		5358
5306	/*	5359	/*
5307	* A less strict version of mas_is_span_wr() where we allow spanning	5360	* A less strict version of mas_is_span_wr() where we allow spanning
@@ -5595,8 +5648,25 @@ static inline bool mas_next_setup(struct ma_state *mas, unsigned long max, · 287 unmodified lines
5595	{	5648	{
5596	bool was_none = mas_is_none(mas);	5649	bool was_none = mas_is_none(mas);
5597		5650
5598	if (mas_is_none(mas) \|\| mas_is_paused(mas))	5651	if (unlikely(mas->last >= max)) {
		5652	mas->node = MAS_OVERFLOW;
		5653	return true;
		5654	}
		5655
		5656	if (mas_is_active(mas))
		5657	return false;
		5658
		5659	if (mas_is_none(mas) \|\| mas_is_paused(mas)) {
		5660	mas->node = MAS_START;
		5661	} else if (mas_is_overflow(mas)) {
		5662	/* Overflowed before, but the max changed */
5599	mas->node = MAS_START;	5663	mas->node = MAS_START;
		5664	} else if (mas_is_underflow(mas)) {
		5665	mas->node = MAS_START;
		5666	*entry = mas_walk(mas);
		5667	if (*entry)
		5668	return true;
		5669	}
5600		5670
5601	if (mas_is_start(mas))	5671	if (mas_is_start(mas))
5602	entry = mas_walk(mas); / Retries on dead nodes handled by mas_walk */	5672	entry = mas_walk(mas); / Retries on dead nodes handled by mas_walk */
@@ -5615,6 +5685,7 @@ static inline bool mas_next_setup(struct ma_state *mas, unsigned long max, · 12 unmodified lines
5615		5685
5616	if (mas_is_none(mas))	5686	if (mas_is_none(mas))
5617	return true;	5687	return true;
		5688
5618	return false;	5689	return false;
5619	}	5690	}
5620		5691
@@ -5637,7 +5708,7 @@ void mas_next(struct ma_state mas, unsigned long max) · 16 unmodified lines
5637	return entry;	5708	return entry;
5638		5709
5639	/* Retries on dead nodes handled by mas_next_slot */	5710	/* Retries on dead nodes handled by mas_next_slot */
5640	return mas_next_slot(mas, max, false);	5711	return mas_next_slot(mas, max, false, true);
5641	}	5712	}
5642	EXPORT_SYMBOL_GPL(mas_next);	5713	EXPORT_SYMBOL_GPL(mas_next);
5643		5714
@@ -5660,7 +5731,7 @@ void mas_next_range(struct ma_state mas, unsigned long max) · 16 unmodified lines
5660	return entry;	5731	return entry;
5661		5732
5662	/* Retries on dead nodes handled by mas_next_slot */	5733	/* Retries on dead nodes handled by mas_next_slot */
5663	return mas_next_slot(mas, max, true);	5734	return mas_next_slot(mas, max, true, true);
5664	}	5735	}
5665	EXPORT_SYMBOL_GPL(mas_next_range);	5736	EXPORT_SYMBOL_GPL(mas_next_range);
5666		5737
@@ -5691,18 +5762,31 @@ EXPORT_SYMBOL_GPL(mt_next); · 24 unmodified lines
5691	static inline bool mas_prev_setup(struct ma_state *mas, unsigned long min,	5762	static inline bool mas_prev_setup(struct ma_state *mas, unsigned long min,
5692	void **entry)	5763	void **entry)
5693	{	5764	{
5694	if (mas->index <= min)	5765	if (unlikely(mas->index <= min)) {
5695	goto none;	5766	mas->node = MAS_UNDERFLOW;
		5767	return true;
		5768	}
5696		5769
5697	if (mas_is_none(mas) \|\| mas_is_paused(mas))	5770	if (mas_is_active(mas))
		5771	return false;
		5772
		5773	if (mas_is_overflow(mas)) {
5698	mas->node = MAS_START;	5774	mas->node = MAS_START;
		5775	*entry = mas_walk(mas);
		5776	if (*entry)
		5777	return true;
		5778	}
5699		5779
5700	if (mas_is_start(mas)) {	5780	if (mas_is_none(mas) \|\| mas_is_paused(mas)) {
5701	mas_walk(mas);	5781	mas->node = MAS_START;
5702	if (!mas->index)	5782	} else if (mas_is_underflow(mas)) {
5703	goto none;	5783	/* underflowed before but the min changed */
		5784	mas->node = MAS_START;
5704	}	5785	}
5705		5786
		5787	if (mas_is_start(mas))
		5788	mas_walk(mas);
		5789
5706	if (unlikely(mas_is_ptr(mas))) {	5790	if (unlikely(mas_is_ptr(mas))) {
5707	if (!mas->index)	5791	if (!mas->index)
5708	goto none;	5792	goto none;
@@ -5747,7 +5831,7 @@ void mas_prev(struct ma_state mas, unsigned long min) · 38 unmodified lines
5747	if (mas_prev_setup(mas, min, &entry))	5831	if (mas_prev_setup(mas, min, &entry))
5748	return entry;	5832	return entry;
5749		5833
5750	return mas_prev_slot(mas, min, false);	5834	return mas_prev_slot(mas, min, false, true);
5751	}	5835	}
5752	EXPORT_SYMBOL_GPL(mas_prev);	5836	EXPORT_SYMBOL_GPL(mas_prev);
5753		5837
@@ -5770,7 +5854,7 @@ void mas_prev_range(struct ma_state mas, unsigned long min) · 16 unmodified lines
5770	if (mas_prev_setup(mas, min, &entry))	5854	if (mas_prev_setup(mas, min, &entry))
5771	return entry;	5855	return entry;
5772		5856
5773	return mas_prev_slot(mas, min, true);	5857	return mas_prev_slot(mas, min, true, true);
5774	}	5858	}
5775	EXPORT_SYMBOL_GPL(mas_prev_range);	5859	EXPORT_SYMBOL_GPL(mas_prev_range);
5776		5860
@@ -5828,24 +5912,35 @@ EXPORT_SYMBOL_GPL(mas_pause); · 51 unmodified lines
5828	static inline bool mas_find_setup(struct ma_state *mas, unsigned long max,	5912	static inline bool mas_find_setup(struct ma_state *mas, unsigned long max,
5829	void **entry)	5913	void **entry)
5830	{	5914	{
5831	*entry = NULL;	5915	if (mas_is_active(mas)) {
		5916	if (mas->last < max)
		5917	return false;
5832		5918
5833	if (unlikely(mas_is_none(mas))) {	5919	return true;
		5920	}
		5921
		5922	if (mas_is_paused(mas)) {
5834	if (unlikely(mas->last >= max))	5923	if (unlikely(mas->last >= max))
5835	return true;	5924	return true;
5836		5925
5837	mas->index = mas->last;	5926	mas->index = ++mas->last;
5838	mas->node = MAS_START;	5927	mas->node = MAS_START;
5839	} else if (unlikely(mas_is_paused(mas))) {	5928	} else if (mas_is_none(mas)) {
5840	if (unlikely(mas->last >= max))	5929	if (unlikely(mas->last >= max))
5841	return true;	5930	return true;
5842		5931
		5932	mas->index = mas->last;
5843	mas->node = MAS_START;	5933	mas->node = MAS_START;
5844	mas->index = ++mas->last;	5934	} else if (mas_is_overflow(mas) \|\| mas_is_underflow(mas)) {
5845	} else if (unlikely(mas_is_ptr(mas)))	5935	if (mas->index > max) {
5846	goto ptr_out_of_range;	5936	mas->node = MAS_OVERFLOW;
		5937	return true;
		5938	}
		5939
		5940	mas->node = MAS_START;
		5941	}
5847		5942
5848	if (unlikely(mas_is_start(mas))) {	5943	if (mas_is_start(mas)) {
5849	/* First run or continue */	5944	/* First run or continue */
5850	if (mas->index > max)	5945	if (mas->index > max)
5851	return true;	5946	return true;
@@ -5895,7 +5990,7 @@ void mas_find(struct ma_state mas, unsigned long max) · 43 unmodified lines
5895	return entry;	5990	return entry;
5896		5991
5897	/* Retries on dead nodes handled by mas_next_slot */	5992	/* Retries on dead nodes handled by mas_next_slot */
5898	return mas_next_slot(mas, max, false);	5993	return mas_next_slot(mas, max, false, false);
5899	}	5994	}
5900	EXPORT_SYMBOL_GPL(mas_find);	5995	EXPORT_SYMBOL_GPL(mas_find);
5901		5996
@@ -5913,13 +6008,13 @@ EXPORT_SYMBOL_GPL(mas_find); · 11 unmodified lines
5913	*/	6008	*/
5914	void mas_find_range(struct ma_state mas, unsigned long max)	6009	void mas_find_range(struct ma_state mas, unsigned long max)
5915	{	6010	{
5916	void *entry;	6011	void *entry = NULL;
5917		6012
5918	if (mas_find_setup(mas, max, &entry))	6013	if (mas_find_setup(mas, max, &entry))
5919	return entry;	6014	return entry;
5920		6015
5921	/* Retries on dead nodes handled by mas_next_slot */	6016	/* Retries on dead nodes handled by mas_next_slot */
5922	return mas_next_slot(mas, max, true);	6017	return mas_next_slot(mas, max, true, false);
5923	}	6018	}
5924	EXPORT_SYMBOL_GPL(mas_find_range);	6019	EXPORT_SYMBOL_GPL(mas_find_range);
5925		6020
@@ -5934,26 +6029,36 @@ EXPORT_SYMBOL_GPL(mas_find_range); · 8 unmodified lines
5934	static inline bool mas_find_rev_setup(struct ma_state *mas, unsigned long min,	6029	static inline bool mas_find_rev_setup(struct ma_state *mas, unsigned long min,
5935	void **entry)	6030	void **entry)
5936	{	6031	{
5937	*entry = NULL;	6032	if (mas_is_active(mas)) {
5938		6033	if (mas->index > min)
5939	if (unlikely(mas_is_none(mas))) {	6034	return false;
5940	if (mas->index <= min)
5941	goto none;
5942		6035
5943	mas->last = mas->index;	6036	return true;
5944	mas->node = MAS_START;
5945	}	6037	}
5946		6038
5947	if (unlikely(mas_is_paused(mas))) {	6039	if (mas_is_paused(mas)) {
5948	if (unlikely(mas->index <= min)) {	6040	if (unlikely(mas->index <= min)) {
5949	mas->node = MAS_NONE;	6041	mas->node = MAS_NONE;
5950	return true;	6042	return true;
5951	}	6043	}
5952	mas->node = MAS_START;	6044	mas->node = MAS_START;
5953	mas->last = --mas->index;	6045	mas->last = --mas->index;
		6046	} else if (mas_is_none(mas)) {
		6047	if (mas->index <= min)
		6048	goto none;
		6049
		6050	mas->last = mas->index;
		6051	mas->node = MAS_START;
		6052	} else if (mas_is_underflow(mas) \|\| mas_is_overflow(mas)) {
		6053	if (mas->last <= min) {
		6054	mas->node = MAS_UNDERFLOW;
		6055	return true;
		6056	}
		6057
		6058	mas->node = MAS_START;
5954	}	6059	}
5955		6060
5956	if (unlikely(mas_is_start(mas))) {	6061	if (mas_is_start(mas)) {
5957	/* First run or continue */	6062	/* First run or continue */
5958	if (mas->index < min)	6063	if (mas->index < min)
5959	return true;	6064	return true;
@@ -6004,13 +6109,13 @@ none: · 44 unmodified lines
6004	*/	6109	*/
6005	void mas_find_rev(struct ma_state mas, unsigned long min)	6110	void mas_find_rev(struct ma_state mas, unsigned long min)
6006	{	6111	{
6007	void *entry;	6112	void *entry = NULL;
6008		6113
6009	if (mas_find_rev_setup(mas, min, &entry))	6114	if (mas_find_rev_setup(mas, min, &entry))
6010	return entry;	6115	return entry;
6011		6116
6012	/* Retries on dead nodes handled by mas_prev_slot */	6117	/* Retries on dead nodes handled by mas_prev_slot */
6013	return mas_prev_slot(mas, min, false);	6118	return mas_prev_slot(mas, min, false, false);
6014		6119
6015	}	6120	}
6016	EXPORT_SYMBOL_GPL(mas_find_rev);	6121	EXPORT_SYMBOL_GPL(mas_find_rev);
@@ -6030,13 +6135,13 @@ EXPORT_SYMBOL_GPL(mas_find_rev); · 13 unmodified lines
6030	*/	6135	*/
6031	void mas_find_range_rev(struct ma_state mas, unsigned long min)	6136	void mas_find_range_rev(struct ma_state mas, unsigned long min)
6032	{	6137	{
6033	void *entry;	6138	void *entry = NULL;
6034		6139
6035	if (mas_find_rev_setup(mas, min, &entry))	6140	if (mas_find_rev_setup(mas, min, &entry))
6036	return entry;	6141	return entry;
6037		6142
6038	/* Retries on dead nodes handled by mas_prev_slot */	6143	/* Retries on dead nodes handled by mas_prev_slot */
6039	return mas_prev_slot(mas, min, true);	6144	return mas_prev_slot(mas, min, true, false);
6040	}	6145	}
6041	EXPORT_SYMBOL_GPL(mas_find_range_rev);	6146	EXPORT_SYMBOL_GPL(mas_find_range_rev);
6042		6147

lib/scatterlist.c+3−1

  * @table:	The sg table header to use
  * @nents:	Number of entries in sg list
  * @max_ents:	The maximum number of entries the allocator returns per call
- * @nents_first_chunk: Number of entries int the (preallocated) first
+ * @first_chunk: first SGL if preallocated (may be %NULL)
+ * @nents_first_chunk: Number of entries in the (preallocated) first
  * 	scatterlist chunk, 0 means no such preallocated chunk provided by user
  * @gfp_mask:	GFP allocation mask
  * @alloc_fn:	Allocator to use
  * @miter: sg mapping iter to be started
  * @sgl: sg list to iterate over
  * @nents: number of sg entries
+ * @flags: sg iterator flags
  *
  * Description:
  *   Starts mapping iterator @miter.

lib/test_maple_tree.c+72−15

 	MT_BUG_ON(mt, val != NULL);
 	MT_BUG_ON(mt, mas.index != 0);
 	MT_BUG_ON(mt, mas.last != 5);
-	MT_BUG_ON(mt, mas.node != MAS_NONE);
+	MT_BUG_ON(mt, mas.node != MAS_UNDERFLOW);
 	mas.index = 0;
 	mas.last = 5;
  *		exists	MAS_NONE	active		range
  *		exists	active		active		range
  *		DNE	active		active		set to last range
+ *		ERANGE	active		MAS_OVERFLOW	last range
  *
  * Function	ENTRY	Start		Result		index & last
  * mas_prev()
  *		any	MAS_ROOT	MAS_NONE	0
  *		exists	active		active		range
  *		DNE	active		active		last range
+ *		ERANGE	active		MAS_UNDERFLOW	last range
  *
  * Function	ENTRY	Start		Result		index & last
  * mas_find()
  *		DNE	MAS_START	MAS_NONE	0
  *		DNE	MAS_PAUSE	MAS_NONE	0
  *		DNE	MAS_ROOT	MAS_NONE	0
- *		DNE	MAS_NONE	MAS_NONE	0
+ *		DNE	MAS_NONE	MAS_NONE	1
  *				if index ==  0
  *		exists	MAS_START	MAS_ROOT	0
  *		exists	MAS_PAUSE	MAS_ROOT	0
  *		DNE	MAS_START	active		set to max
  *		exists	MAS_PAUSE	active		range
  *		DNE	MAS_PAUSE	active		set to max
- *		exists	MAS_NONE	active		range
+ *		exists	MAS_NONE	active		range (start at last)
  *		exists	active		active		range
  *		DNE	active		active		last range (max < last)
  *
  *		DNE	MAS_START	active		set to min
  *		exists	MAS_PAUSE	active		range
  *		DNE	MAS_PAUSE	active		set to min
- *		exists	MAS_NONE	active		range
+ *		exists	MAS_NONE	active		range (start at index)
  *		exists	active		active		range
  *		DNE	active		active		last range (min > index)
  *
 	mtree_store_range(mt, 0, 0, ptr, GFP_KERNEL);
 	mas_lock(&mas);
-	/* prev: Start -> none */
+	/* prev: Start -> underflow*/
 	entry = mas_prev(&mas, 0);
 	MT_BUG_ON(mt, entry != NULL);
-	MT_BUG_ON(mt, mas.node != MAS_NONE);
+	MT_BUG_ON(mt, mas.node != MAS_UNDERFLOW);
 	/* prev: Start -> root */
 	mas_set(&mas, 10);
 	MT_BUG_ON(mt, entry != NULL);
 	MT_BUG_ON(mt, mas.node != MAS_NONE);
-	/* next: start -> none */
+	/* next: start -> none*/
 	mas_set(&mas, 10);
 	entry = mas_next(&mas, ULONG_MAX);
 	MT_BUG_ON(mt, mas.index != 1);
 	MT_BUG_ON(mt, mas.last != 0x2500);
 	MT_BUG_ON(mt, !mas_active(mas));
-	/* next:active -> active out of range*/
+	/* next:active -> active beyond data */
 	entry = mas_next(&mas, 0x2999);
 	MT_BUG_ON(mt, entry != NULL);
 	MT_BUG_ON(mt, mas.index != 0x2501);
 	MT_BUG_ON(mt, mas.last != 0x2fff);
 	MT_BUG_ON(mt, !mas_active(mas));
-	/* Continue after out of range*/
+	/* Continue after last range ends after max */
 	entry = mas_next(&mas, ULONG_MAX);
 	MT_BUG_ON(mt, entry != ptr3);
 	MT_BUG_ON(mt, mas.index != 0x3000);
 	MT_BUG_ON(mt, mas.last != 0x3500);
 	MT_BUG_ON(mt, !mas_active(mas));
-	/* next:active -> active out of range*/
+	/* next:active -> active continued */
+	entry = mas_next(&mas, ULONG_MAX);
+	MT_BUG_ON(mt, entry != NULL);
+	MT_BUG_ON(mt, mas.index != 0x3501);
+	MT_BUG_ON(mt, mas.last != ULONG_MAX);
+	MT_BUG_ON(mt, !mas_active(mas));
+	/* next:active -> overflow  */
 	entry = mas_next(&mas, ULONG_MAX);
 	MT_BUG_ON(mt, entry != NULL);
 	MT_BUG_ON(mt, mas.index != 0x3501);
 	MT_BUG_ON(mt, mas.last != ULONG_MAX);
+	MT_BUG_ON(mt, mas.node != MAS_OVERFLOW);
+	/* next:overflow -> overflow  */
+	entry = mas_next(&mas, ULONG_MAX);
+	MT_BUG_ON(mt, entry != NULL);
+	MT_BUG_ON(mt, mas.index != 0x3501);
+	MT_BUG_ON(mt, mas.last != ULONG_MAX);
+	MT_BUG_ON(mt, mas.node != MAS_OVERFLOW);
+	/* prev:overflow -> active  */
+	entry = mas_prev(&mas, 0);
+	MT_BUG_ON(mt, entry != ptr3);
+	MT_BUG_ON(mt, mas.index != 0x3000);
+	MT_BUG_ON(mt, mas.last != 0x3500);
 	MT_BUG_ON(mt, !mas_active(mas));
 	/* next: none -> active, skip value at location */
 	MT_BUG_ON(mt, mas.last != 0x1500);
 	MT_BUG_ON(mt, !mas_active(mas));
-	/* prev:active -> active out of range*/
+	/* prev:active -> active spanning end range */
+	entry = mas_prev(&mas, 0x0100);
+	MT_BUG_ON(mt, entry != NULL);
+	MT_BUG_ON(mt, mas.index != 0);
+	MT_BUG_ON(mt, mas.last != 0x0FFF);
+	MT_BUG_ON(mt, !mas_active(mas));
+	/* prev:active -> underflow */
+	entry = mas_prev(&mas, 0);
+	MT_BUG_ON(mt, entry != NULL);
+	MT_BUG_ON(mt, mas.index != 0);
+	MT_BUG_ON(mt, mas.last != 0x0FFF);
+	MT_BUG_ON(mt, mas.node != MAS_UNDERFLOW);
+	/* prev:underflow -> underflow */
 	entry = mas_prev(&mas, 0);
 	MT_BUG_ON(mt, entry != NULL);
 	MT_BUG_ON(mt, mas.index != 0);
 	MT_BUG_ON(mt, mas.last != 0x0FFF);
+	MT_BUG_ON(mt, mas.node != MAS_UNDERFLOW);
+	/* next:underflow -> active */
+	entry = mas_next(&mas, ULONG_MAX);
+	MT_BUG_ON(mt, entry != ptr);
+	MT_BUG_ON(mt, mas.index != 0x1000);
+	MT_BUG_ON(mt, mas.last != 0x1500);
+	MT_BUG_ON(mt, !mas_active(mas));
+	/* prev:first value -> underflow */
+	entry = mas_prev(&mas, 0x1000);
+	MT_BUG_ON(mt, entry != NULL);
+	MT_BUG_ON(mt, mas.index != 0x1000);
+	MT_BUG_ON(mt, mas.last != 0x1500);
+	MT_BUG_ON(mt, mas.node != MAS_UNDERFLOW);
+	/* find:underflow -> first value */
+	entry = mas_find(&mas, ULONG_MAX);
+	MT_BUG_ON(mt, entry != ptr);
+	MT_BUG_ON(mt, mas.index != 0x1000);
+	MT_BUG_ON(mt, mas.last != 0x1500);
 	MT_BUG_ON(mt, !mas_active(mas));
 	/* prev: pause ->active */
 	MT_BUG_ON(mt, mas.last != 0x2500);
 	MT_BUG_ON(mt, !mas_active(mas));
-	/* prev:active -> active out of range*/
+	/* prev:active -> active spanning min */
 	entry = mas_prev(&mas, 0x1600);
 	MT_BUG_ON(mt, entry != NULL);
 	MT_BUG_ON(mt, mas.index != 0x1501);
 	MT_BUG_ON(mt, mas.last != 0x1FFF);
 	MT_BUG_ON(mt, !mas_active(mas));
-	/* prev: active ->active, continue*/
+	/* prev: active ->active, continue */
 	entry = mas_prev(&mas, 0);
 	MT_BUG_ON(mt, entry != ptr);
 	MT_BUG_ON(mt, mas.index != 0x1000);
 	MT_BUG_ON(mt, mas.last != 0x2FFF);
 	MT_BUG_ON(mt, !mas_active(mas));
-	/* find: none ->active */
+	/* find: overflow ->active */
 	entry = mas_find(&mas, 0x5000);
 	MT_BUG_ON(mt, entry != ptr3);
 	MT_BUG_ON(mt, mas.index != 0x3000);
 	check_empty_area_fill(&tree);
 	mtree_destroy(&tree);
 	mt_init_flags(&tree, MT_FLAGS_ALLOC_RANGE);
 	check_state_handling(&tree);
 	mtree_destroy(&tree);

mm/damon/vaddr-test.h+2−0

@@ -148,6 +148,8 @@ static void damon_do_test_apply_three_regions(struct kunit *test, · 147 unmodified lines
148	KUNIT_EXPECT_EQ(test, r->ar.start, expected[i * 2]);	148	KUNIT_EXPECT_EQ(test, r->ar.start, expected[i * 2]);
149	KUNIT_EXPECT_EQ(test, r->ar.end, expected[i * 2 + 1]);	149	KUNIT_EXPECT_EQ(test, r->ar.end, expected[i * 2 + 1]);
150	}	150	}
		151
		152	damon_destroy_target(t);
151	}	153	}
152		154
153	/*	155	/*

mm/damon/vaddr.c+2−1

 	bool referenced = false;
 	pte_t entry = huge_ptep_get(pte);
 	struct folio *folio = pfn_folio(pte_pfn(entry));
+	unsigned long psize = huge_page_size(hstate_vma(vma));
 	folio_get(folio);
 	if (pte_young(entry)) {
 		referenced = true;
 		entry = pte_mkold(entry);
-		set_huge_pte_at(mm, addr, pte, entry);
+		set_huge_pte_at(mm, addr, pte, entry, psize);
 	}
 #ifdef CONFIG_MMU_NOTIFIER

mm/filemap.c+50−23

@@ -3475,13 +3475,11 @@ skip: · 3474 unmodified lines
3475	*/	3475	*/
3476	static vm_fault_t filemap_map_folio_range(struct vm_fault *vmf,	3476	static vm_fault_t filemap_map_folio_range(struct vm_fault *vmf,
3477	struct folio *folio, unsigned long start,	3477	struct folio *folio, unsigned long start,
3478	unsigned long addr, unsigned int nr_pages)	3478	unsigned long addr, unsigned int nr_pages,
		3479	unsigned int *mmap_miss)
3479	{	3480	{
3480	vm_fault_t ret = 0;	3481	vm_fault_t ret = 0;
3481	struct vm_area_struct *vma = vmf->vma;
3482	struct file *file = vma->vm_file;
3483	struct page *page = folio_page(folio, start);	3482	struct page *page = folio_page(folio, start);
3484	unsigned int mmap_miss = READ_ONCE(file->f_ra.mmap_miss);
3485	unsigned int count = 0;	3483	unsigned int count = 0;
3486	pte_t *old_ptep = vmf->pte;	3484	pte_t *old_ptep = vmf->pte;
3487		3485
@@ -3489,8 +3487,7 @@ static vm_fault_t filemap_map_folio_range(struct vm_fault *vmf, · 1 unmodified line
3489	if (PageHWPoison(page + count))	3487	if (PageHWPoison(page + count))
3490	goto skip;	3488	goto skip;
3491		3489
3492	if (mmap_miss > 0)	3490	(*mmap_miss)++;
3493	mmap_miss--;
3494		3491
3495	/*	3492	/*
3496	* NOTE: If there're PTE markers, we'll leave them to be	3493	* NOTE: If there're PTE markers, we'll leave them to be
@@ -3506,7 +3503,7 @@ skip: · 9 unmodified lines
3506	if (count) {	3503	if (count) {
3507	set_pte_range(vmf, folio, page, count, addr);	3504	set_pte_range(vmf, folio, page, count, addr);
3508	folio_ref_add(folio, count);	3505	folio_ref_add(folio, count);
3509	if (in_range(vmf->address, addr, count))	3506	if (in_range(vmf->address, addr, count * PAGE_SIZE))
3510	ret = VM_FAULT_NOPAGE;	3507	ret = VM_FAULT_NOPAGE;
3511	}	3508	}
3512		3509
@@ -3520,12 +3517,40 @@ skip: · 7 unmodified lines
3520	if (count) {	3517	if (count) {
3521	set_pte_range(vmf, folio, page, count, addr);	3518	set_pte_range(vmf, folio, page, count, addr);
3522	folio_ref_add(folio, count);	3519	folio_ref_add(folio, count);
3523	if (in_range(vmf->address, addr, count))	3520	if (in_range(vmf->address, addr, count * PAGE_SIZE))
3524	ret = VM_FAULT_NOPAGE;	3521	ret = VM_FAULT_NOPAGE;
3525	}	3522	}
3526		3523
3527	vmf->pte = old_ptep;	3524	vmf->pte = old_ptep;
3528	WRITE_ONCE(file->f_ra.mmap_miss, mmap_miss);	3525
		3526	return ret;
		3527	}
		3528
		3529	static vm_fault_t filemap_map_order0_folio(struct vm_fault *vmf,
		3530	struct folio *folio, unsigned long addr,
		3531	unsigned int *mmap_miss)
		3532	{
		3533	vm_fault_t ret = 0;
		3534	struct page *page = &folio->page;
		3535
		3536	if (PageHWPoison(page))
		3537	return ret;
		3538
		3539	(*mmap_miss)++;
		3540
		3541	/*
		3542	* NOTE: If there're PTE markers, we'll leave them to be
		3543	* handled in the specific fault path, and it'll prohibit
		3544	* the fault-around logic.
		3545	*/
		3546	if (!pte_none(ptep_get(vmf->pte)))
		3547	return ret;
		3548
		3549	if (vmf->address == addr)
		3550	ret = VM_FAULT_NOPAGE;
		3551
		3552	set_pte_range(vmf, folio, page, 1, addr);
		3553	folio_ref_inc(folio);
3529		3554
3530	return ret;	3555	return ret;
3531	}	3556	}
@@ -3541,7 +3566,7 @@ vm_fault_t filemap_map_pages(struct vm_fault *vmf, · 9 unmodified lines
3541	XA_STATE(xas, &mapping->i_pages, start_pgoff);	3566	XA_STATE(xas, &mapping->i_pages, start_pgoff);
3542	struct folio *folio;	3567	struct folio *folio;
3543	vm_fault_t ret = 0;	3568	vm_fault_t ret = 0;
3544	int nr_pages = 0;	3569	unsigned int nr_pages = 0, mmap_miss = 0, mmap_miss_saved;
3545		3570
3546	rcu_read_lock();	3571	rcu_read_lock();
3547	folio = next_uptodate_folio(&xas, mapping, end_pgoff);	3572	folio = next_uptodate_folio(&xas, mapping, end_pgoff);
@@ -3569,25 +3594,27 @@ vm_fault_t filemap_map_pages(struct vm_fault *vmf, · 21 unmodified lines
3569	end = folio->index + folio_nr_pages(folio) - 1;	3594	end = folio->index + folio_nr_pages(folio) - 1;
3570	nr_pages = min(end, end_pgoff) - xas.xa_index + 1;	3595	nr_pages = min(end, end_pgoff) - xas.xa_index + 1;
3571		3596
3572	/*	3597	if (!folio_test_large(folio))
3573	* NOTE: If there're PTE markers, we'll leave them to be	3598	ret \|= filemap_map_order0_folio(vmf,
3574	* handled in the specific fault path, and it'll prohibit the	3599	folio, addr, &mmap_miss);
3575	* fault-around logic.	3600	else
3576	*/	3601	ret \|= filemap_map_folio_range(vmf, folio,
3577	if (!pte_none(ptep_get(vmf->pte)))	3602	xas.xa_index - folio->index, addr,
3578	goto unlock;	3603	nr_pages, &mmap_miss);
3579
3580	ret \|= filemap_map_folio_range(vmf, folio,
3581	xas.xa_index - folio->index, addr, nr_pages);
3582		3604
3583	unlock:
3584	folio_unlock(folio);	3605	folio_unlock(folio);
3585	folio_put(folio);	3606	folio_put(folio);
3586	folio = next_uptodate_folio(&xas, mapping, end_pgoff);	3607	} while ((folio = next_uptodate_folio(&xas, mapping, end_pgoff)) != NULL);
3587	} while (folio);
3588	pte_unmap_unlock(vmf->pte, vmf->ptl);	3608	pte_unmap_unlock(vmf->pte, vmf->ptl);
3589	out:	3609	out:
3590	rcu_read_unlock();	3610	rcu_read_unlock();
		3611
		3612	mmap_miss_saved = READ_ONCE(file->f_ra.mmap_miss);
		3613	if (mmap_miss >= mmap_miss_saved)
		3614	WRITE_ONCE(file->f_ra.mmap_miss, 0);
		3615	else
		3616	WRITE_ONCE(file->f_ra.mmap_miss, mmap_miss_saved - mmap_miss);
		3617
3591	return ret;	3618	return ret;
3592	}	3619	}
3593	EXPORT_SYMBOL(filemap_map_pages);	3620	EXPORT_SYMBOL(filemap_map_pages);

mm/hugetlb.c+24−19

 static void
 hugetlb_install_folio(struct vm_area_struct *vma, pte_t *ptep, unsigned long addr,
-		      struct folio *new_folio, pte_t old)
+		      struct folio *new_folio, pte_t old, unsigned long sz)
 {
 	pte_t newpte = make_huge_pte(vma, &new_folio->page, 1);
 	hugepage_add_new_anon_rmap(new_folio, vma, addr);
 	if (userfaultfd_wp(vma) && huge_pte_uffd_wp(old))
 		newpte = huge_pte_mkuffd_wp(newpte);
-	set_huge_pte_at(vma->vm_mm, addr, ptep, newpte);
+	set_huge_pte_at(vma->vm_mm, addr, ptep, newpte, sz);
 	hugetlb_count_add(pages_per_huge_page(hstate_vma(vma)), vma->vm_mm);
 	folio_set_hugetlb_migratable(new_folio);
 }
 		} else if (unlikely(is_hugetlb_entry_hwpoisoned(entry))) {
 			if (!userfaultfd_wp(dst_vma))
 				entry = huge_pte_clear_uffd_wp(entry);
-			set_huge_pte_at(dst, addr, dst_pte, entry);
+			set_huge_pte_at(dst, addr, dst_pte, entry, sz);
 		} else if (unlikely(is_hugetlb_entry_migration(entry))) {
 			swp_entry_t swp_entry = pte_to_swp_entry(entry);
 			bool uffd_wp = pte_swp_uffd_wp(entry);
 				entry = swp_entry_to_pte(swp_entry);
 				if (userfaultfd_wp(src_vma) && uffd_wp)
 					entry = pte_swp_mkuffd_wp(entry);
-				set_huge_pte_at(src, addr, src_pte, entry);
+				set_huge_pte_at(src, addr, src_pte, entry, sz);
 			}
 			if (!userfaultfd_wp(dst_vma))
 				entry = huge_pte_clear_uffd_wp(entry);
-			set_huge_pte_at(dst, addr, dst_pte, entry);
+			set_huge_pte_at(dst, addr, dst_pte, entry, sz);
 		} else if (unlikely(is_pte_marker(entry))) {
 			pte_marker marker = copy_pte_marker(
 				pte_to_swp_entry(entry), dst_vma);
 			if (marker)
 				set_huge_pte_at(dst, addr, dst_pte,
-						make_pte_marker(marker));
+						make_pte_marker(marker), sz);
 		} else {
 			entry = huge_ptep_get(src_pte);
 			pte_folio = page_folio(pte_page(entry));
 					goto again;
 				}
 				hugetlb_install_folio(dst_vma, dst_pte, addr,
-						      new_folio, src_pte_old);
+						      new_folio, src_pte_old, sz);
 				spin_unlock(src_ptl);
 				spin_unlock(dst_ptl);
 				continue;
 			if (!userfaultfd_wp(dst_vma))
 				entry = huge_pte_clear_uffd_wp(entry);
-			set_huge_pte_at(dst, addr, dst_pte, entry);
+			set_huge_pte_at(dst, addr, dst_pte, entry, sz);
 			hugetlb_count_add(npages, dst);
 		}
 		spin_unlock(src_ptl);
 }
 static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr,
-			  unsigned long new_addr, pte_t *src_pte, pte_t *dst_pte)
+			  unsigned long new_addr, pte_t *src_pte, pte_t *dst_pte,
+			  unsigned long sz)
 {
 	struct hstate *h = hstate_vma(vma);
 	struct mm_struct *mm = vma->vm_mm;
 		spin_lock_nested(src_ptl, SINGLE_DEPTH_NESTING);
 	pte = huge_ptep_get_and_clear(mm, old_addr, src_pte);
-	set_huge_pte_at(mm, new_addr, dst_pte, pte);
+	set_huge_pte_at(mm, new_addr, dst_pte, pte, sz);
 	if (src_ptl != dst_ptl)
 		spin_unlock(src_ptl);
 		if (!dst_pte)
 			break;
-		move_huge_pte(vma, old_addr, new_addr, src_pte, dst_pte);
+		move_huge_pte(vma, old_addr, new_addr, src_pte, dst_pte, sz);
 	}
 	if (shared_pmd)
 			if (pte_swp_uffd_wp_any(pte) &&
 			    !(zap_flags & ZAP_FLAG_DROP_MARKER))
 				set_huge_pte_at(mm, address, ptep,
-						make_pte_marker(PTE_MARKER_UFFD_WP));
+						make_pte_marker(PTE_MARKER_UFFD_WP),
+						sz);
 			else
 				huge_pte_clear(mm, address, ptep, sz);
 			spin_unlock(ptl);
 		if (huge_pte_uffd_wp(pte) &&
 		    !(zap_flags & ZAP_FLAG_DROP_MARKER))
 			set_huge_pte_at(mm, address, ptep,
-					make_pte_marker(PTE_MARKER_UFFD_WP));
+					make_pte_marker(PTE_MARKER_UFFD_WP),
+					sz);
 		hugetlb_count_sub(pages_per_huge_page(h), mm);
 		page_remove_rmap(page, vma, true);
 		hugepage_add_new_anon_rmap(new_folio, vma, haddr);
 		if (huge_pte_uffd_wp(pte))
 			newpte = huge_pte_mkuffd_wp(newpte);
-		set_huge_pte_at(mm, haddr, ptep, newpte);
+		set_huge_pte_at(mm, haddr, ptep, newpte, huge_page_size(h));
 		folio_set_hugetlb_migratable(new_folio);
 		/* Make the old page be freed below */
 		new_folio = old_folio;
 	 */
 	if (unlikely(pte_marker_uffd_wp(old_pte)))
 		new_pte = huge_pte_mkuffd_wp(new_pte);
-	set_huge_pte_at(mm, haddr, ptep, new_pte);
+	set_huge_pte_at(mm, haddr, ptep, new_pte, huge_page_size(h));
 	hugetlb_count_add(pages_per_huge_page(h), mm);
 	if ((flags & FAULT_FLAG_WRITE) && !(vma->vm_flags & VM_SHARED)) {
 		}
 		_dst_pte = make_pte_marker(PTE_MARKER_POISONED);
-		set_huge_pte_at(dst_mm, dst_addr, dst_pte, _dst_pte);
+		set_huge_pte_at(dst_mm, dst_addr, dst_pte, _dst_pte,
+				huge_page_size(h));
 		/* No need to invalidate - it was non-present before */
 		update_mmu_cache(dst_vma, dst_addr, dst_pte);
 	if (wp_enabled)
 		_dst_pte = huge_pte_mkuffd_wp(_dst_pte);
-	set_huge_pte_at(dst_mm, dst_addr, dst_pte, _dst_pte);
+	set_huge_pte_at(dst_mm, dst_addr, dst_pte, _dst_pte, huge_page_size(h));
 	hugetlb_count_add(pages_per_huge_page(h), dst_mm);
 			else if (uffd_wp_resolve)
 				newpte = pte_swp_clear_uffd_wp(newpte);
 			if (!pte_same(pte, newpte))
-				set_huge_pte_at(mm, address, ptep, newpte);
+				set_huge_pte_at(mm, address, ptep, newpte, psize);
 		} else if (unlikely(is_pte_marker(pte))) {
 			/* No other markers apply for now. */
 			WARN_ON_ONCE(!pte_marker_uffd_wp(pte));
 			if (unlikely(uffd_wp))
 				/* Safe to modify directly (none->non-present). */
 				set_huge_pte_at(mm, address, ptep,
-						make_pte_marker(PTE_MARKER_UFFD_WP));
+						make_pte_marker(PTE_MARKER_UFFD_WP),
+						psize);
 		}
 		spin_unlock(ptl);
 	}

mm/kasan/kasan.h+3−5

 #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)
-#ifndef __HAVE_ARCH_SHADOW_MAP
+#ifndef kasan_shadow_to_mem
 static inline const void *kasan_shadow_to_mem(const void *shadow_addr)
 {
 	return (void *)(((unsigned long)shadow_addr - KASAN_SHADOW_OFFSET)
 }
 #endif
+#ifndef addr_has_metadata
 static __always_inline bool addr_has_metadata(const void *addr)
 {
-#ifdef __HAVE_ARCH_SHADOW_MAP
-	return (kasan_mem_to_shadow((void *)addr) != NULL);
-#else
 	return (kasan_reset_tag(addr) >=
 		kasan_shadow_to_mem((void *)KASAN_SHADOW_START));
-#endif
 }
+#endif
 /**
  * kasan_check_range - Check memory region, and report if invalid access.

mm/memcontrol.c+16−3

  * Scheduled by try_charge() to be executed from the userland return path
  * and reclaims memory over the high limit.
  */
-void mem_cgroup_handle_over_high(void)
+void mem_cgroup_handle_over_high(gfp_t gfp_mask)
 {
 	unsigned long penalty_jiffies;
 	unsigned long pflags;
 	 */
 	nr_reclaimed = reclaim_high(memcg,
 				    in_retry ? SWAP_CLUSTER_MAX : nr_pages,
-				    GFP_KERNEL);
+				    gfp_mask);
 	/*
 	 * memory.high is breached and reclaim is unable to keep up. Throttle
 	if (current->memcg_nr_pages_over_high > MEMCG_CHARGE_BATCH &&
 	    !(current->flags & PF_MEMALLOC) &&
 	    gfpflags_allow_blocking(gfp_mask)) {
-		mem_cgroup_handle_over_high();
+		mem_cgroup_handle_over_high(gfp_mask);
 	}
 	return 0;
 }
 		case _MEMSWAP:
 			ret = mem_cgroup_resize_max(memcg, nr_pages, true);
 			break;
+		case _KMEM:
+			pr_warn_once("kmem.limit_in_bytes is deprecated and will be removed. "
+				     "Writing any value to this file has no effect. "
+				     "Please report your usecase to linux-mm@kvack.org if you "
+				     "depend on this functionality.\n");
+			ret = 0;
+			break;
 		case _TCP:
 			ret = memcg_update_tcp_max(memcg, nr_pages);
 			break;
 		.seq_show = memcg_numa_stat_show,
 	},
 #endif
+	{
+		.name = "kmem.limit_in_bytes",
+		.private = MEMFILE_PRIVATE(_KMEM, RES_LIMIT),
+		.write = mem_cgroup_write,
+		.read_u64 = mem_cgroup_read_u64,
+	},
 	{
 		.name = "kmem.usage_in_bytes",
 		.private = MEMFILE_PRIVATE(_KMEM, RES_USAGE),

mm/mempolicy.c+19−20

 	unsigned long start;
 	unsigned long end;
 	struct vm_area_struct *first;
+	bool has_unmovable;
 };
 /*
 /*
  * queue_folios_pmd() has three possible return values:
  * 0 - folios are placed on the right node or queued successfully, or
- *     special page is met, i.e. huge zero page.
+ *     special page is met, i.e. zero page, or unmovable page is found
- * 1 - there is unmovable folio, and MPOL_MF_MOVE* & MPOL_MF_STRICT were
+ *     but continue walking (indicated by queue_pages.has_unmovable).
- *     specified.
  * -EIO - is migration entry or only MPOL_MF_STRICT was specified and an
  *        existing folio was already on a node that does not follow the
  *        policy.
 	if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
 		if (!vma_migratable(walk->vma) ||
 		    migrate_folio_add(folio, qp->pagelist, flags)) {
-			ret = 1;
+			qp->has_unmovable = true;
 			goto unlock;
 		}
 	} else
  *
  * queue_folios_pte_range() has three possible return values:
  * 0 - folios are placed on the right node or queued successfully, or
- *     special page is met, i.e. zero page.
+ *     special page is met, i.e. zero page, or unmovable page is found
- * 1 - there is unmovable folio, and MPOL_MF_MOVE* & MPOL_MF_STRICT were
+ *     but continue walking (indicated by queue_pages.has_unmovable).
- *     specified.
  * -EIO - only MPOL_MF_STRICT was specified and an existing folio was already
  *        on a node that does not follow the policy.
  */
 	struct folio *folio;
 	struct queue_pages *qp = walk->private;
 	unsigned long flags = qp->flags;
-	bool has_unmovable = false;
 	pte_t *pte, *mapped_pte;
 	pte_t ptent;
 	spinlock_t *ptl;
 		if (!queue_folio_required(folio, qp))
 			continue;
 		if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
-			/* MPOL_MF_STRICT must be specified if we get here */
+			/*
-			if (!vma_migratable(vma)) {
+			 * MPOL_MF_STRICT must be specified if we get here.
-				has_unmovable = true;
+			 * Continue walking vmas due to MPOL_MF_MOVE* flags.
-				break;
+			 */
-			}
+			if (!vma_migratable(vma))
+				qp->has_unmovable = true;
 			/*
 			 * Do not abort immediately since there may be
 			 * need migrate other LRU pages.
 			 */
 			if (migrate_folio_add(folio, qp->pagelist, flags))
-				has_unmovable = true;
+				qp->has_unmovable = true;
 		} else
 			break;
 	}
 	pte_unmap_unlock(mapped_pte, ptl);
 	cond_resched();
-	if (has_unmovable)
-		return 1;
 	return addr != end ? -EIO : 0;
 }
 		 * Detecting misplaced folio but allow migrating folios which
 		 * have been queued.
 		 */
-		ret = 1;
+		qp->has_unmovable = true;
 		goto unlock;
 	}
 			 * Failed to isolate folio but allow migrating pages
 			 * which have been queued.
 			 */
-			ret = 1;
+			qp->has_unmovable = true;
 	}
 unlock:
 	spin_unlock(ptl);
 		.start = start,
 		.end = end,
 		.first = NULL,
+		.has_unmovable = false,
 	};
 	const struct mm_walk_ops *ops = lock_vma ?
 			&queue_pages_lock_vma_walk_ops : &queue_pages_walk_ops;
 	err = walk_page_range(mm, start, end, ops, &qp);
+	if (qp.has_unmovable)
+		err = 1;
 	if (!qp.first)
 		/* whole range in hole */
 		err = -EFAULT;
 				putback_movable_pages(&pagelist);
 		}
-		if ((ret > 0) || (nr_failed && (flags & MPOL_MF_STRICT)))
+		if (((ret > 0) || nr_failed) && (flags & MPOL_MF_STRICT))
 			err = -EIO;
 	} else {
 up_out:

mm/migrate.c+5−2

 #ifdef CONFIG_HUGETLB_PAGE
 		if (folio_test_hugetlb(folio)) {
-			unsigned int shift = huge_page_shift(hstate_vma(vma));
+			struct hstate *h = hstate_vma(vma);
+			unsigned int shift = huge_page_shift(h);
+			unsigned long psize = huge_page_size(h);
 			pte = arch_make_huge_pte(pte, shift, vma->vm_flags);
 			if (folio_test_anon(folio))
 						       rmap_flags);
 			else
 				page_dup_file_rmap(new, true);
-			set_huge_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
+			set_huge_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte,
+					psize);
 		} else
 #endif
 		{

mm/page_alloc.c+6−6

@@ -2400,7 +2400,7 @@ void free_unref_page(struct page *page, unsigned int order) · 2399 unmodified lines
2400	struct per_cpu_pages *pcp;	2400	struct per_cpu_pages *pcp;
2401	struct zone *zone;	2401	struct zone *zone;
2402	unsigned long pfn = page_to_pfn(page);	2402	unsigned long pfn = page_to_pfn(page);
2403	int migratetype;	2403	int migratetype, pcpmigratetype;
2404		2404
2405	if (!free_unref_page_prepare(page, pfn, order))	2405	if (!free_unref_page_prepare(page, pfn, order))
2406	return;	2406	return;
@@ -2408,24 +2408,24 @@ void free_unref_page(struct page *page, unsigned int order) · 1 unmodified line
2408	/*	2408	/*
2409	* We only track unmovable, reclaimable and movable on pcp lists.	2409	* We only track unmovable, reclaimable and movable on pcp lists.
2410	* Place ISOLATE pages on the isolated list because they are being	2410	* Place ISOLATE pages on the isolated list because they are being
2411	* offlined but treat HIGHATOMIC as movable pages so we can get those	2411	* offlined but treat HIGHATOMIC and CMA as movable pages so we can
2412	* areas back if necessary. Otherwise, we may have to free	2412	* get those areas back if necessary. Otherwise, we may have to free
2413	* excessively into the page allocator	2413	* excessively into the page allocator
2414	*/	2414	*/
2415	migratetype = get_pcppage_migratetype(page);	2415	migratetype = pcpmigratetype = get_pcppage_migratetype(page);
2416	if (unlikely(migratetype >= MIGRATE_PCPTYPES)) {	2416	if (unlikely(migratetype >= MIGRATE_PCPTYPES)) {
2417	if (unlikely(is_migrate_isolate(migratetype))) {	2417	if (unlikely(is_migrate_isolate(migratetype))) {
2418	free_one_page(page_zone(page), page, pfn, order, migratetype, FPI_NONE);	2418	free_one_page(page_zone(page), page, pfn, order, migratetype, FPI_NONE);
2419	return;	2419	return;
2420	}	2420	}
2421	migratetype = MIGRATE_MOVABLE;	2421	pcpmigratetype = MIGRATE_MOVABLE;
2422	}	2422	}
2423		2423
2424	zone = page_zone(page);	2424	zone = page_zone(page);
2425	pcp_trylock_prepare(UP_flags);	2425	pcp_trylock_prepare(UP_flags);
2426	pcp = pcp_spin_trylock(zone->per_cpu_pageset);	2426	pcp = pcp_spin_trylock(zone->per_cpu_pageset);
2427	if (pcp) {	2427	if (pcp) {
2428	free_unref_page_commit(zone, pcp, page, migratetype, order);	2428	free_unref_page_commit(zone, pcp, page, pcpmigratetype, order);
2429	pcp_spin_unlock(pcp);	2429	pcp_spin_unlock(pcp);
2430	} else {	2430	} else {
2431	free_one_page(zone, page, pfn, order, migratetype, FPI_NONE);	2431	free_one_page(zone, page, pfn, order, migratetype, FPI_NONE);

mm/rmap.c+18−5

 	struct mmu_notifier_range range;
 	enum ttu_flags flags = (enum ttu_flags)(long)arg;
 	unsigned long pfn;
+	unsigned long hsz = 0;
 	/*
 	 * When racing against e.g. zap_pte_range() on another cpu,
 		 */
 		adjust_range_if_pmd_sharing_possible(vma, &range.start,
 						     &range.end);
+		/* We need the huge page size for set_huge_pte_at() */
+		hsz = huge_page_size(hstate_vma(vma));
 	}
 	mmu_notifier_invalidate_range_start(&range);
 			pteval = swp_entry_to_pte(make_hwpoison_entry(subpage));
 			if (folio_test_hugetlb(folio)) {
 				hugetlb_count_sub(folio_nr_pages(folio), mm);
-				set_huge_pte_at(mm, address, pvmw.pte, pteval);
+				set_huge_pte_at(mm, address, pvmw.pte, pteval,
+						hsz);
 			} else {
 				dec_mm_counter(mm, mm_counter(&folio->page));
 				set_pte_at(mm, address, pvmw.pte, pteval);
 	struct mmu_notifier_range range;
 	enum ttu_flags flags = (enum ttu_flags)(long)arg;
 	unsigned long pfn;
+	unsigned long hsz = 0;
 	/*
 	 * When racing against e.g. zap_pte_range() on another cpu,
 		 */
 		adjust_range_if_pmd_sharing_possible(vma, &range.start,
 						     &range.end);
+		/* We need the huge page size for set_huge_pte_at() */
+		hsz = huge_page_size(hstate_vma(vma));
 	}
 	mmu_notifier_invalidate_range_start(&range);
 			pteval = swp_entry_to_pte(make_hwpoison_entry(subpage));
 			if (folio_test_hugetlb(folio)) {
 				hugetlb_count_sub(folio_nr_pages(folio), mm);
-				set_huge_pte_at(mm, address, pvmw.pte, pteval);
+				set_huge_pte_at(mm, address, pvmw.pte, pteval,
+						hsz);
 			} else {
 				dec_mm_counter(mm, mm_counter(&folio->page));
 				set_pte_at(mm, address, pvmw.pte, pteval);
 			if (arch_unmap_one(mm, vma, address, pteval) < 0) {
 				if (folio_test_hugetlb(folio))
-					set_huge_pte_at(mm, address, pvmw.pte, pteval);
+					set_huge_pte_at(mm, address, pvmw.pte,
+							pteval, hsz);
 				else
 					set_pte_at(mm, address, pvmw.pte, pteval);
 				ret = false;
 			if (anon_exclusive &&
 			    page_try_share_anon_rmap(subpage)) {
 				if (folio_test_hugetlb(folio))
-					set_huge_pte_at(mm, address, pvmw.pte, pteval);
+					set_huge_pte_at(mm, address, pvmw.pte,
+							pteval, hsz);
 				else
 					set_pte_at(mm, address, pvmw.pte, pteval);
 				ret = false;
 			if (pte_uffd_wp(pteval))
 				swp_pte = pte_swp_mkuffd_wp(swp_pte);
 			if (folio_test_hugetlb(folio))
-				set_huge_pte_at(mm, address, pvmw.pte, swp_pte);
+				set_huge_pte_at(mm, address, pvmw.pte, swp_pte,
+						hsz);
 			else
 				set_pte_at(mm, address, pvmw.pte, swp_pte);
 			trace_set_migration_pte(address, pte_val(swp_pte),

mm/slab_common.c+18−18

@@ -479,7 +479,7 @@ void slab_kmem_cache_release(struct kmem_cache *s) · 478 unmodified lines
479		479
480	void kmem_cache_destroy(struct kmem_cache *s)	480	void kmem_cache_destroy(struct kmem_cache *s)
481	{	481	{
482	int refcnt;	482	int err = -EBUSY;
483	bool rcu_set;	483	bool rcu_set;
484		484
485	if (unlikely(!s) \|\| !kasan_check_byte(s))	485	if (unlikely(!s) \|\| !kasan_check_byte(s))
@@ -490,17 +490,17 @@ void kmem_cache_destroy(struct kmem_cache *s) · 4 unmodified lines
490		490
491	rcu_set = s->flags & SLAB_TYPESAFE_BY_RCU;	491	rcu_set = s->flags & SLAB_TYPESAFE_BY_RCU;
492		492
493	refcnt = --s->refcount;	493	s->refcount--;
494	if (refcnt)	494	if (s->refcount)
495	goto out_unlock;	495	goto out_unlock;
496		496
497	WARN(shutdown_cache(s),	497	err = shutdown_cache(s);
498	"%s %s: Slab cache still has objects when called from %pS",	498	WARN(err, "%s %s: Slab cache still has objects when called from %pS",
499	__func__, s->name, (void *)_RET_IP_);	499	__func__, s->name, (void *)_RET_IP_);
500	out_unlock:	500	out_unlock:
501	mutex_unlock(&slab_mutex);	501	mutex_unlock(&slab_mutex);
502	cpus_read_unlock();	502	cpus_read_unlock();
503	if (!refcnt && !rcu_set)	503	if (!err && !rcu_set)
504	kmem_cache_release(s);	504	kmem_cache_release(s);
505	}	505	}
506	EXPORT_SYMBOL(kmem_cache_destroy);	506	EXPORT_SYMBOL(kmem_cache_destroy);
@@ -745,24 +745,24 @@ struct kmem_cache *kmalloc_slab(size_t size, gfp_t flags, unsigned long caller) · 238 unmodified lines
745		745
746	size_t kmalloc_size_roundup(size_t size)	746	size_t kmalloc_size_roundup(size_t size)
747	{	747	{
748	struct kmem_cache *c;	748	if (size && size <= KMALLOC_MAX_CACHE_SIZE) {
		749	/*
		750	* The flags don't matter since size_index is common to all.
		751	* Neither does the caller for just getting ->object_size.
		752	*/
		753	return kmalloc_slab(size, GFP_KERNEL, 0)->object_size;
		754	}
749		755
750	/* Short-circuit the 0 size case. */
751	if (unlikely(size == 0))
752	return 0;
753	/* Short-circuit saturated "too-large" case. */
754	if (unlikely(size == SIZE_MAX))
755	return SIZE_MAX;
756	/* Above the smaller buckets, size is a multiple of page size. */	756	/* Above the smaller buckets, size is a multiple of page size. */
757	if (size > KMALLOC_MAX_CACHE_SIZE)	757	if (size && size <= KMALLOC_MAX_SIZE)
758	return PAGE_SIZE << get_order(size);	758	return PAGE_SIZE << get_order(size);
759		759
760	/*	760	/*
761	* The flags don't matter since size_index is common to all.	761	* Return 'size' for 0 - kmalloc() returns ZERO_SIZE_PTR
762	* Neither does the caller for just getting ->object_size.	762	* and very large size - kmalloc() may fail.
763	*/	763	*/
764	c = kmalloc_slab(size, GFP_KERNEL, 0);	764	return size;
765	return c ? c->object_size : 0;	765
766	}	766	}
767	EXPORT_SYMBOL(kmalloc_size_roundup);	767	EXPORT_SYMBOL(kmalloc_size_roundup);
768		768

mm/vmalloc.c+1−1

@@ -111,7 +111,7 @@ static int vmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end, · 110 unmodified lines
111	pte_t entry = pfn_pte(pfn, prot);	111	pte_t entry = pfn_pte(pfn, prot);
112		112
113	entry = arch_make_huge_pte(entry, ilog2(size), 0);	113	entry = arch_make_huge_pte(entry, ilog2(size), 0);
114	set_huge_pte_at(&init_mm, addr, pte, entry);	114	set_huge_pte_at(&init_mm, addr, pte, entry, size);
115	pfn += PFN_DOWN(size);	115	pfn += PFN_DOWN(size);
116	continue;	116	continue;
117	}	117	}

mm/zswap.c+20−0

@@ -1218,6 +1218,19 @@ bool zswap_store(struct folio *folio) · 1217 unmodified lines
1218	if (!zswap_enabled \|\| !tree)	1218	if (!zswap_enabled \|\| !tree)
1219	return false;	1219	return false;
1220		1220
		1221	/*
		1222	* If this is a duplicate, it must be removed before attempting to store
		1223	* it, otherwise, if the store fails the old page won't be removed from
		1224	* the tree, and it might be written back overriding the new data.
		1225	*/
		1226	spin_lock(&tree->lock);
		1227	dupentry = zswap_rb_search(&tree->rbroot, offset);
		1228	if (dupentry) {
		1229	zswap_duplicate_entry++;
		1230	zswap_invalidate_entry(tree, dupentry);
		1231	}
		1232	spin_unlock(&tree->lock);
		1233
1221	/*	1234	/*
1222	* XXX: zswap reclaim does not work with cgroups yet. Without a	1235	* XXX: zswap reclaim does not work with cgroups yet. Without a
1223	* cgroup-aware entry LRU, we will push out entries system-wide based on	1236	* cgroup-aware entry LRU, we will push out entries system-wide based on
@@ -1333,7 +1346,14 @@ insert_entry: · 109 unmodified lines
1333		1346
1334	/* map */	1347	/* map */
1335	spin_lock(&tree->lock);	1348	spin_lock(&tree->lock);
		1349	/*
		1350	* A duplicate entry should have been removed at the beginning of this
		1351	* function. Since the swap entry should be pinned, if a duplicate is
		1352	* found again here it means that something went wrong in the swap
		1353	* cache.
		1354	*/
1336	while (zswap_rb_insert(&tree->rbroot, entry, &dupentry) == -EEXIST) {	1355	while (zswap_rb_insert(&tree->rbroot, entry, &dupentry) == -EEXIST) {
		1356	WARN_ON(1);
1337	zswap_duplicate_entry++;	1357	zswap_duplicate_entry++;
1338	zswap_invalidate_entry(tree, dupentry);	1358	zswap_invalidate_entry(tree, dupentry);
1339	}	1359	}

net/bluetooth/hci_conn.c+35−28

@@ -2413,34 +2413,41 @@ int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type, · 2412 unmodified lines
2413	if (!test_bit(HCI_CONN_AUTH, &conn->flags))	2413	if (!test_bit(HCI_CONN_AUTH, &conn->flags))
2414	goto auth;	2414	goto auth;
2415		2415
2416	/* An authenticated FIPS approved combination key has sufficient	2416	switch (conn->key_type) {
2417	* security for security level 4. */	2417	case HCI_LK_AUTH_COMBINATION_P256:
2418	if (conn->key_type == HCI_LK_AUTH_COMBINATION_P256 &&	2418	/* An authenticated FIPS approved combination key has
2419	sec_level == BT_SECURITY_FIPS)	2419	* sufficient security for security level 4 or lower.
2420	goto encrypt;	2420	*/
2421		2421	if (sec_level <= BT_SECURITY_FIPS)
2422	/* An authenticated combination key has sufficient security for	2422	goto encrypt;
2423	security level 3. */	2423	break;
2424	if ((conn->key_type == HCI_LK_AUTH_COMBINATION_P192 \|\|	2424	case HCI_LK_AUTH_COMBINATION_P192:
2425	conn->key_type == HCI_LK_AUTH_COMBINATION_P256) &&	2425	/* An authenticated combination key has sufficient security for
2426	sec_level == BT_SECURITY_HIGH)	2426	* security level 3 or lower.
2427	goto encrypt;	2427	*/
2428		2428	if (sec_level <= BT_SECURITY_HIGH)
2429	/* An unauthenticated combination key has sufficient security for	2429	goto encrypt;
2430	security level 1 and 2. */	2430	break;
2431	if ((conn->key_type == HCI_LK_UNAUTH_COMBINATION_P192 \|\|	2431	case HCI_LK_UNAUTH_COMBINATION_P192:
2432	conn->key_type == HCI_LK_UNAUTH_COMBINATION_P256) &&	2432	case HCI_LK_UNAUTH_COMBINATION_P256:
2433	(sec_level == BT_SECURITY_MEDIUM \|\| sec_level == BT_SECURITY_LOW))	2433	/* An unauthenticated combination key has sufficient security
2434	goto encrypt;	2434	* for security level 2 or lower.
2435		2435	*/
2436	/* A combination key has always sufficient security for the security	2436	if (sec_level <= BT_SECURITY_MEDIUM)
2437	levels 1 or 2. High security level requires the combination key	2437	goto encrypt;
2438	is generated using maximum PIN code length (16).	2438	break;
2439	For pre 2.1 units. */	2439	case HCI_LK_COMBINATION:
2440	if (conn->key_type == HCI_LK_COMBINATION &&	2440	/* A combination key has always sufficient security for the
2441	(sec_level == BT_SECURITY_MEDIUM \|\| sec_level == BT_SECURITY_LOW \|\|	2441	* security levels 2 or lower. High security level requires the
2442	conn->pin_length == 16))	2442	* combination key is generated using maximum PIN code length
2443	goto encrypt;	2443	* (16). For pre 2.1 units.
		2444	*/
		2445	if (sec_level <= BT_SECURITY_MEDIUM \|\| conn->pin_length == 16)
		2446	goto encrypt;
		2447	break;
		2448	default:
		2449	break;
		2450	}
2444		2451
2445	auth:	2452	auth:
2446	if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))	2453	if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))

net/bluetooth/hci_core.c+11−3

 	if (id < 0)
 		return id;
-	snprintf(hdev->name, sizeof(hdev->name), "hci%d", id);
+	error = dev_set_name(&hdev->dev, "hci%u", id);
+	if (error)
+		return error;
+	hdev->name = dev_name(&hdev->dev);
 	hdev->id = id;
 	BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
 	if (!IS_ERR_OR_NULL(bt_debugfs))
 		hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs);
-	dev_set_name(&hdev->dev, "%s", hdev->name);
 	error = device_add(&hdev->dev);
 	if (error < 0)
 		goto err_wqueue;
 	hci_conn_params_clear_all(hdev);
 	hci_discovery_filter_clear(hdev);
 	hci_blocked_keys_clear(hdev);
+	hci_codec_list_clear(&hdev->local_codecs);
 	hci_dev_unlock(hdev);
 	ida_simple_remove(&hci_index_ida, hdev->id);
 		if (c->type == type && c->sent) {
 			bt_dev_err(hdev, "killing stalled connection %pMR",
 				   &c->dst);
+			/* hci_disconnect might sleep, so, we have to release
+			 * the RCU read lock before calling it.
+			 */
+			rcu_read_unlock();
 			hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM);
+			rcu_read_lock();
 		}
 	}

net/bluetooth/hci_event.c+1−0

@@ -33,6 +33,7 @@ · 32 unmodified lines
33		33
34	#include "hci_request.h"	34	#include "hci_request.h"
35	#include "hci_debugfs.h"	35	#include "hci_debugfs.h"
		36	#include "hci_codec.h"
36	#include "a2mp.h"	37	#include "a2mp.h"
37	#include "amp.h"	38	#include "amp.h"
38	#include "smp.h"	39	#include "smp.h"

net/bluetooth/hci_request.h+0−2

@@ -71,7 +71,5 @@ struct sk_buff hci_prepare_cmd(struct hci_dev hdev, u16 opcode, u32 plen, · 70 unmodified lines
71	void hci_req_add_le_scan_disable(struct hci_request *req, bool rpa_le_conn);	71	void hci_req_add_le_scan_disable(struct hci_request *req, bool rpa_le_conn);
72	void hci_req_add_le_passive_scan(struct hci_request *req);	72	void hci_req_add_le_passive_scan(struct hci_request *req);
73		73
74	void hci_req_prepare_suspend(struct hci_dev *hdev, enum suspended_state next);
75
76	void hci_request_setup(struct hci_dev *hdev);	74	void hci_request_setup(struct hci_dev *hdev);
77	void hci_request_cancel_all(struct hci_dev *hdev);	75	void hci_request_cancel_all(struct hci_dev *hdev);

net/bluetooth/hci_sync.c+5−9

 					   LE_SCAN_FILTER_DUP_ENABLE);
 }
-static int le_scan_restart_sync(struct hci_dev *hdev, void *data)
-{
-	return hci_le_scan_restart_sync(hdev);
-}
 static void le_scan_restart(struct work_struct *work)
 {
 	struct hci_dev *hdev = container_of(work, struct hci_dev,
 	bt_dev_dbg(hdev, "");
-	hci_dev_lock(hdev);
+	status = hci_le_scan_restart_sync(hdev);
-	status = hci_cmd_sync_queue(hdev, le_scan_restart_sync, NULL, NULL);
 	if (status) {
 		bt_dev_err(hdev, "failed to restart LE scan: status %d",
 			   status);
-		goto unlock;
+		return;
 	}
+	hci_dev_lock(hdev);
 	if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) ||
 	    !hdev->discovery.scan_start)
 		goto unlock;
 	memset(hdev->eir, 0, sizeof(hdev->eir));
 	memset(hdev->dev_class, 0, sizeof(hdev->dev_class));
 	bacpy(&hdev->random_addr, BDADDR_ANY);
+	hci_codec_list_clear(&hdev->local_codecs);
 	hci_dev_put(hdev);
 	return err;

net/bluetooth/iso.c+6−3

 }
 /* -------- Socket interface ---------- */
-static struct sock *__iso_get_sock_listen_by_addr(bdaddr_t *ba)
+static struct sock *__iso_get_sock_listen_by_addr(bdaddr_t *src, bdaddr_t *dst)
 {
 	struct sock *sk;
 		if (sk->sk_state != BT_LISTEN)
 			continue;
-		if (!bacmp(&iso_pi(sk)->src, ba))
+		if (bacmp(&iso_pi(sk)->dst, dst))
+			continue;
+		if (!bacmp(&iso_pi(sk)->src, src))
 			return sk;
 	}
 	write_lock(&iso_sk_list.lock);
-	if (__iso_get_sock_listen_by_addr(&iso_pi(sk)->src))
+	if (__iso_get_sock_listen_by_addr(&iso_pi(sk)->src, &iso_pi(sk)->dst))
 		err = -EADDRINUSE;
 	write_unlock(&iso_sk_list.lock);

net/bridge/br_netfilter_hooks.c+1−1

@@ -294,7 +294,7 @@ int br_nf_pre_routing_finish_bridge(struct net net, struct sock sk, struct sk_ · 293 unmodified lines
294	/* tell br_dev_xmit to continue with forwarding */	294	/* tell br_dev_xmit to continue with forwarding */
295	nf_bridge->bridged_dnat = 1;	295	nf_bridge->bridged_dnat = 1;
296	/* FIXME Need to refragment */	296	/* FIXME Need to refragment */
297	ret = neigh->output(neigh, skb);	297	ret = READ_ONCE(neigh->output)(neigh, skb);
298	}	298	}
299	neigh_release(neigh);	299	neigh_release(neigh);
300	return ret;	300	return ret;

net/core/neighbour.c+8−6

 				 */
 				__skb_queue_purge(&n->arp_queue);
 				n->arp_queue_len_bytes = 0;
-				n->output = neigh_blackhole;
+				WRITE_ONCE(n->output, neigh_blackhole);
 				if (n->nud_state & NUD_VALID)
 					n->nud_state = NUD_NOARP;
 				else
 {
 	neigh_dbg(2, "neigh %p is suspected\n", neigh);
-	neigh->output = neigh->ops->output;
+	WRITE_ONCE(neigh->output, neigh->ops->output);
 }
 /* Neighbour state is OK;
 {
 	neigh_dbg(2, "neigh %p is connected\n", neigh);
-	neigh->output = neigh->ops->connected_output;
+	WRITE_ONCE(neigh->output, neigh->ops->connected_output);
 }
 static void neigh_periodic_work(struct work_struct *work)
 			    (state == NUD_FAILED ||
 			     !time_in_range_open(jiffies, n->used,
 						 n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) {
-				*np = n->next;
+				rcu_assign_pointer(*np,
+					rcu_dereference_protected(n->next,
+						lockdep_is_held(&tbl->lock)));
 				neigh_mark_dead(n);
 				write_unlock(&n->lock);
 				neigh_cleanup_and_release(n);
 				if (n2)
 					n1 = n2;
 			}
-			n1->output(n1, skb);
+			READ_ONCE(n1->output)(n1, skb);
 			if (n2)
 				neigh_release(n2);
 			rcu_read_unlock();
 			rcu_read_unlock();
 			goto out_kfree_skb;
 		}
-		err = neigh->output(neigh, skb);
+		err = READ_ONCE(neigh->output)(neigh, skb);
 		rcu_read_unlock();
 	}
 	else if (index == NEIGH_LINK_TABLE) {

net/core/sock_map.c+4−0

 	sk = __sock_map_lookup_elem(map, key);
 	if (unlikely(!sk || !sock_map_redirect_allowed(sk)))
 		return SK_DROP;
+	if (!(flags & BPF_F_INGRESS) && !sk_is_tcp(sk))
+		return SK_DROP;
 	msg->flags = flags;
 	msg->sk_redir = sk;
 	sk = __sock_hash_lookup_elem(map, key);
 	if (unlikely(!sk || !sock_map_redirect_allowed(sk)))
 		return SK_DROP;
+	if (!(flags & BPF_F_INGRESS) && !sk_is_tcp(sk))
+		return SK_DROP;
 	msg->flags = flags;
 	msg->sk_redir = sk;

net/ethtool/plca.c+29−16

 #define PLCA_REPDATA(__reply_base) \
 	container_of(__reply_base, struct plca_reply_data, base)
-static void plca_update_sint(int *dst, const struct nlattr *attr,
-			     bool *mod)
-{
-	if (!attr)
-		return;
-	*dst = nla_get_u32(attr);
-	*mod = true;
-}
 // PLCA get configuration message ------------------------------------------- //
 const struct nla_policy ethnl_plca_get_cfg_policy[] = {
 		NLA_POLICY_NESTED(ethnl_header_policy),
 };
+static void plca_update_sint(int *dst, struct nlattr **tb, u32 attrid,
+			     bool *mod)
+{
+	const struct nlattr *attr = tb[attrid];
+	if (!attr ||
+	    WARN_ON_ONCE(attrid >= ARRAY_SIZE(ethnl_plca_set_cfg_policy)))
+		return;
+	switch (ethnl_plca_set_cfg_policy[attrid].type) {
+	case NLA_U8:
+		*dst = nla_get_u8(attr);
+		break;
+	case NLA_U32:
+		*dst = nla_get_u32(attr);
+		break;
+	default:
+		WARN_ON_ONCE(1);
+	}
+	*mod = true;
+}
 static int plca_get_cfg_prepare_data(const struct ethnl_req_info *req_base,
 				     struct ethnl_reply_data *reply_base,
 				     const struct genl_info *info)
 		return -EOPNOTSUPP;
 	memset(&plca_cfg, 0xff, sizeof(plca_cfg));
-	plca_update_sint(&plca_cfg.enabled, tb[ETHTOOL_A_PLCA_ENABLED], &mod);
+	plca_update_sint(&plca_cfg.enabled, tb, ETHTOOL_A_PLCA_ENABLED, &mod);
-	plca_update_sint(&plca_cfg.node_id, tb[ETHTOOL_A_PLCA_NODE_ID], &mod);
+	plca_update_sint(&plca_cfg.node_id, tb, ETHTOOL_A_PLCA_NODE_ID, &mod);
-	plca_update_sint(&plca_cfg.node_cnt, tb[ETHTOOL_A_PLCA_NODE_CNT], &mod);
+	plca_update_sint(&plca_cfg.node_cnt, tb, ETHTOOL_A_PLCA_NODE_CNT, &mod);
-	plca_update_sint(&plca_cfg.to_tmr, tb[ETHTOOL_A_PLCA_TO_TMR], &mod);
+	plca_update_sint(&plca_cfg.to_tmr, tb, ETHTOOL_A_PLCA_TO_TMR, &mod);
-	plca_update_sint(&plca_cfg.burst_cnt, tb[ETHTOOL_A_PLCA_BURST_CNT],
+	plca_update_sint(&plca_cfg.burst_cnt, tb, ETHTOOL_A_PLCA_BURST_CNT,
 			 &mod);
-	plca_update_sint(&plca_cfg.burst_tmr, tb[ETHTOOL_A_PLCA_BURST_TMR],
+	plca_update_sint(&plca_cfg.burst_tmr, tb, ETHTOOL_A_PLCA_BURST_TMR,
 			 &mod);
 	if (!mod)
 		return 0;

net/ipv4/fib_semantics.c+1−0

@@ -1887,6 +1887,7 @@ int fib_sync_down_addr(struct net_device *dev, __be32 local) · 1886 unmodified lines
1887	continue;	1887	continue;
1888	if (fi->fib_prefsrc == local) {	1888	if (fi->fib_prefsrc == local) {
1889	fi->fib_flags \|= RTNH_F_DEAD;	1889	fi->fib_flags \|= RTNH_F_DEAD;
		1890	fi->pfsrc_removed = true;
1890	ret++;	1891	ret++;
1891	}	1892	}
1892	}	1893	}

net/ipv4/fib_trie.c+4−0

 int fib_table_flush(struct net *net, struct fib_table *tb, bool flush_all)
 {
 	struct trie *t = (struct trie *)tb->tb_data;
+	struct nl_info info = { .nl_net = net };
 	struct key_vector *pn = t->kv;
 	unsigned long cindex = 1;
 	struct hlist_node *tmp;
 			fib_notify_alias_delete(net, n->key, &n->leaf, fa,
 						NULL);
+			if (fi->pfsrc_removed)
+				rtmsg_fib(RTM_DELROUTE, htonl(n->key), fa,
+					  KEYLENGTH - fa->fa_slen, tb->tb_id, &info, 0);
 			hlist_del_rcu(&fa->fa_list);
 			fib_release_info(fa->fa_info);
 			alias_free_mem_rcu(fa);

net/ipv4/route.c+2−0

 				    fa->fa_type == fri.type) {
 					fri.offload = READ_ONCE(fa->offload);
 					fri.trap = READ_ONCE(fa->trap);
+					fri.offload_failed =
+						READ_ONCE(fa->offload_failed);
 					break;
 				}
 			}

net/ipv4/tcp.c+2−8

 int tcp_read_skb(struct sock *sk, skb_read_actor_t recv_actor)
 {
-	struct tcp_sock *tp = tcp_sk(sk);
-	u32 seq = tp->copied_seq;
 	struct sk_buff *skb;
 	int copied = 0;
-	u32 offset;
 	if (sk->sk_state == TCP_LISTEN)
 		return -ENOTCONN;
-	while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
+	while ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) {
 		u8 tcp_flags;
 		int used;
 				copied = used;
 			break;
 		}
-		seq += used;
 		copied += used;
-		if (tcp_flags & TCPHDR_FIN) {
+		if (tcp_flags & TCPHDR_FIN)
-			++seq;
 			break;
-		}
 	}
 	return copied;
 }

net/ipv4/tcp_bpf.c+3−1

 				  int *addr_len)
 {
 	struct tcp_sock *tcp = tcp_sk(sk);
+	int peek = flags & MSG_PEEK;
 	u32 seq = tcp->copied_seq;
 	struct sk_psock *psock;
 	int copied = 0;
 		copied = -EAGAIN;
 	}
 out:
-	WRITE_ONCE(tcp->copied_seq, seq);
+	if (!peek)
+		WRITE_ONCE(tcp->copied_seq, seq);
 	tcp_rcv_space_adjust(sk);
 	if (copied > 0)
 		__tcp_cleanup_rbuf(sk, copied);

net/ipv4/tcp_input.c+13−0

@@ -253,6 +253,19 @@ static void tcp_measure_rcv_mss(struct sock sk, const struct sk_buff skb) · 252 unmodified lines
253	if (unlikely(len > icsk->icsk_ack.rcv_mss +	253	if (unlikely(len > icsk->icsk_ack.rcv_mss +
254	MAX_TCP_OPTION_SPACE))	254	MAX_TCP_OPTION_SPACE))
255	tcp_gro_dev_warn(sk, skb, len);	255	tcp_gro_dev_warn(sk, skb, len);
		256	/* If the skb has a len of exactly 1*MSS and has the PSH bit
		257	* set then it is likely the end of an application write. So
		258	* more data may not be arriving soon, and yet the data sender
		259	* may be waiting for an ACK if cwnd-bound or using TX zero
		260	* copy. So we set ICSK_ACK_PUSHED here so that
		261	* tcp_cleanup_rbuf() will send an ACK immediately if the app
		262	* reads all of the data and is not ping-pong. If len > MSS
		263	* then this logic does not matter (and does not hurt) because
		264	* tcp_cleanup_rbuf() will always ACK immediately if the app
		265	* reads data and there is more than an MSS of unACKed data.
		266	*/
		267	if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_PSH)
		268	icsk->icsk_ack.pending \|= ICSK_ACK_PUSHED;
256	} else {	269	} else {
257	/* Otherwise, we make more careful check taking into account,	270	/* Otherwise, we make more careful check taking into account,
258	* that SACKs block is variable.	271	* that SACKs block is variable.

net/ipv4/tcp_output.c+3−4

 }
 /* Account for an ACK we sent. */
-static inline void tcp_event_ack_sent(struct sock *sk, unsigned int pkts,
+static inline void tcp_event_ack_sent(struct sock *sk, u32 rcv_nxt)
-				      u32 rcv_nxt)
 {
 	struct tcp_sock *tp = tcp_sk(sk);
 	if (unlikely(rcv_nxt != tp->rcv_nxt))
 		return;  /* Special ACK sent by DCTCP to reflect ECN */
-	tcp_dec_quickack_mode(sk, pkts);
+	tcp_dec_quickack_mode(sk);
 	inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
 }
 			   sk, skb);
 	if (likely(tcb->tcp_flags & TCPHDR_ACK))
-		tcp_event_ack_sent(sk, tcp_skb_pcount(skb), rcv_nxt);
+		tcp_event_ack_sent(sk, rcv_nxt);
 	if (skb->len != tcp_header_size) {
 		tcp_event_data_sent(tp, sk);

net/ipv6/tcp_ipv6.c+7−3

 		struct sock *nsk;
 		sk = req->rsk_listener;
-		drop_reason = tcp_inbound_md5_hash(sk, skb,
+		if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
-						   &hdr->saddr, &hdr->daddr,
+			drop_reason = SKB_DROP_REASON_XFRM_POLICY;
-						   AF_INET6, dif, sdif);
+		else
+			drop_reason = tcp_inbound_md5_hash(sk, skb,
+							   &hdr->saddr, &hdr->daddr,
+							   AF_INET6, dif, sdif);
 		if (drop_reason) {
 			sk_drops_add(sk, skb);
 			reqsk_put(req);
 			}
 			goto discard_and_relse;
 		}
+		nf_reset_ct(skb);
 		if (nsk == sk) {
 			reqsk_put(req);
 			tcp_v6_restore_cb(skb);

net/l2tp/l2tp_ip6.c+1−1

 	 */
 	if (len > INT_MAX - transhdrlen)
 		return -EMSGSIZE;
-	ulen = len + transhdrlen;
 	/* Mirror BSD error message compatibility */
 	if (msg->msg_flags & MSG_OOB)
 back_from_confirm:
 	lock_sock(sk);
+	ulen = len + skb_queue_empty(&sk->sk_write_queue) ? transhdrlen : 0;
 	err = ip6_append_data(sk, ip_generic_getfrag, msg,
 			      ulen, transhdrlen, &ipc6,
 			      &fl6, (struct rt6_info *)dst,

net/mac80211/cfg.c+5−1

 	}
 	err = ieee80211_key_link(key, link, sta);
+	/* KRACK protection, shouldn't happen but just silently accept key */
+	if (err == -EALREADY)
+		err = 0;
  out_unlock:
 	mutex_unlock(&local->sta_mtx);
 	/* VHT can override some HT caps such as the A-MSDU max length */
 	if (params->vht_capa)
 		ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
-						    params->vht_capa, link_sta);
+						    params->vht_capa, NULL,
+						    link_sta);
 	if (params->he_capa)
 		ieee80211_he_cap_ie_to_sta_he_cap(sdata, sband,

net/mac80211/ibss.c+1−1

@@ -1072,7 +1072,7 @@ static void ieee80211_update_sta_info(struct ieee80211_sub_if_data *sdata, · 1071 unmodified lines
1072	&chandef);	1072	&chandef);
1073	memcpy(&cap_ie, elems->vht_cap_elem, sizeof(cap_ie));	1073	memcpy(&cap_ie, elems->vht_cap_elem, sizeof(cap_ie));
1074	ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,	1074	ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1075	&cap_ie,	1075	&cap_ie, NULL,
1076	&sta->deflink);	1076	&sta->deflink);
1077	if (memcmp(&cap, &sta->sta.deflink.vht_cap, sizeof(cap)))	1077	if (memcmp(&cap, &sta->sta.deflink.vht_cap, sizeof(cap)))
1078	rates_updated \|= true;	1078	rates_updated \|= true;

net/mac80211/ieee80211_i.h+2−1

 	struct timer_list mesh_path_root_timer;
 	unsigned long wrkq_flags;
-	unsigned long mbss_changed;
+	unsigned long mbss_changed[64 / BITS_PER_LONG];
 	bool userspace_handles_dfs;
 ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
 				    struct ieee80211_supported_band *sband,
 				    const struct ieee80211_vht_cap *vht_cap_ie,
+				    const struct ieee80211_vht_cap *vht_cap_ie2,
 				    struct link_sta_info *link_sta);
 enum ieee80211_sta_rx_bandwidth
 ieee80211_sta_cap_rx_bw(struct link_sta_info *link_sta);

net/mac80211/key.c+16−6

 void ieee80211_key_free_unused(struct ieee80211_key *key)
 {
+	if (!key)
+		return;
 	WARN_ON(key->sdata || key->local);
 	ieee80211_key_free_common(key);
 }
 	 * can cause warnings to appear.
 	 */
 	bool delay_tailroom = sdata->vif.type == NL80211_IFTYPE_STATION;
-	int ret = -EOPNOTSUPP;
+	int ret;
 	mutex_lock(&sdata->local->key_mtx);
 		 * the same cipher. Enforce the assumption for pairwise keys.
 		 */
 		if ((alt_key && alt_key->conf.cipher != key->conf.cipher) ||
-		    (old_key && old_key->conf.cipher != key->conf.cipher))
+		    (old_key && old_key->conf.cipher != key->conf.cipher)) {
+			ret = -EOPNOTSUPP;
 			goto out;
+		}
 	} else if (sta) {
 		struct link_sta_info *link_sta = &sta->deflink;
 		int link_id = key->conf.link_id;
 	/* Non-pairwise keys must also not switch the cipher on rekey */
 	if (!pairwise) {
-		if (old_key && old_key->conf.cipher != key->conf.cipher)
+		if (old_key && old_key->conf.cipher != key->conf.cipher) {
+			ret = -EOPNOTSUPP;
 			goto out;
+		}
 	}
 	/*
 	 * new version of the key to avoid nonce reuse or replay issues.
 	 */
 	if (ieee80211_key_identical(sdata, old_key, key)) {
-		ieee80211_key_free_unused(key);
+		ret = -EALREADY;
-		ret = 0;
+		goto unlock;
-		goto out;
 	}
 	key->local = sdata->local;
 		ieee80211_key_free(key, delay_tailroom);
 	}
+	key = NULL;
  out:
+	ieee80211_key_free_unused(key);
+ unlock:
 	mutex_unlock(&sdata->local->key_mtx);
 	return ret;

net/mac80211/mesh.c+4−4

@@ -1175,7 +1175,7 @@ void ieee80211_mbss_info_change_notify(struct ieee80211_sub_if_data *sdata, · 1174 unmodified lines
1175		1175
1176	/* if we race with running work, worst case this work becomes a noop */	1176	/* if we race with running work, worst case this work becomes a noop */
1177	for_each_set_bit(bit, &bits, sizeof(changed) * BITS_PER_BYTE)	1177	for_each_set_bit(bit, &bits, sizeof(changed) * BITS_PER_BYTE)
1178	set_bit(bit, &ifmsh->mbss_changed);	1178	set_bit(bit, ifmsh->mbss_changed);
1179	set_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags);	1179	set_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags);
1180	wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);	1180	wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
1181	}	1181	}
@@ -1257,7 +1257,7 @@ void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata) · 75 unmodified lines
1257		1257
1258	/* clear any mesh work (for next join) we may have accrued */	1258	/* clear any mesh work (for next join) we may have accrued */
1259	ifmsh->wrkq_flags = 0;	1259	ifmsh->wrkq_flags = 0;
1260	ifmsh->mbss_changed = 0;	1260	memset(ifmsh->mbss_changed, 0, sizeof(ifmsh->mbss_changed));
1261		1261
1262	local->fif_other_bss--;	1262	local->fif_other_bss--;
1263	atomic_dec(&local->iff_allmultis);	1263	atomic_dec(&local->iff_allmultis);
@@ -1724,9 +1724,9 @@ static void mesh_bss_info_changed(struct ieee80211_sub_if_data *sdata) · 460 unmodified lines
1724	u32 bit;	1724	u32 bit;
1725	u64 changed = 0;	1725	u64 changed = 0;
1726		1726
1727	for_each_set_bit(bit, &ifmsh->mbss_changed,	1727	for_each_set_bit(bit, ifmsh->mbss_changed,
1728	sizeof(changed) * BITS_PER_BYTE) {	1728	sizeof(changed) * BITS_PER_BYTE) {
1729	clear_bit(bit, &ifmsh->mbss_changed);	1729	clear_bit(bit, ifmsh->mbss_changed);
1730	changed \|= BIT(bit);	1730	changed \|= BIT(bit);
1731	}	1731	}
1732		1732

net/mac80211/mesh_plink.c+1−1

@@ -451,7 +451,7 @@ static void mesh_sta_info_init(struct ieee80211_sub_if_data *sdata, · 450 unmodified lines
451	changed \|= IEEE80211_RC_BW_CHANGED;	451	changed \|= IEEE80211_RC_BW_CHANGED;
452		452
453	ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,	453	ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
454	elems->vht_cap_elem,	454	elems->vht_cap_elem, NULL,
455	&sta->deflink);	455	&sta->deflink);
456		456
457	ieee80211_he_cap_ie_to_sta_he_cap(sdata, sband, elems->he_cap,	457	ieee80211_he_cap_ie_to_sta_he_cap(sdata, sband, elems->he_cap,

net/mac80211/mlme.c+35−10

@@ -4202,10 +4202,33 @@ static bool ieee80211_assoc_config_link(struct ieee80211_link_data *link, · 4201 unmodified lines
4202	elems->ht_cap_elem,	4202	elems->ht_cap_elem,
4203	link_sta);	4203	link_sta);
4204		4204
4205	if (elems->vht_cap_elem && !(link->u.mgd.conn_flags & IEEE80211_CONN_DISABLE_VHT))	4205	if (elems->vht_cap_elem &&
		4206	!(link->u.mgd.conn_flags & IEEE80211_CONN_DISABLE_VHT)) {
		4207	const struct ieee80211_vht_cap *bss_vht_cap = NULL;
		4208	const struct cfg80211_bss_ies *ies;
		4209
		4210	/*
		4211	* Cisco AP module 9115 with FW 17.3 has a bug and sends a
		4212	* too large maximum MPDU length in the association response
		4213	* (indicating 12k) that it cannot actually process ...
		4214	* Work around that.
		4215	*/
		4216	rcu_read_lock();
		4217	ies = rcu_dereference(cbss->ies);
		4218	if (ies) {
		4219	const struct element *elem;
		4220
		4221	elem = cfg80211_find_elem(WLAN_EID_VHT_CAPABILITY,
		4222	ies->data, ies->len);
		4223	if (elem && elem->datalen >= sizeof(*bss_vht_cap))
		4224	bss_vht_cap = (const void *)elem->data;
		4225	}
		4226
4206	ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,	4227	ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
4207	elems->vht_cap_elem,	4228	elems->vht_cap_elem,
4208	link_sta);	4229	bss_vht_cap, link_sta);
		4230	rcu_read_unlock();
		4231	}
4209		4232
4210	if (elems->he_operation && !(link->u.mgd.conn_flags & IEEE80211_CONN_DISABLE_HE) &&	4233	if (elems->he_operation && !(link->u.mgd.conn_flags & IEEE80211_CONN_DISABLE_HE) &&
4211	elems->he_cap) {	4234	elems->he_cap) {
@@ -5107,9 +5130,10 @@ static bool ieee80211_assoc_success(struct ieee80211_sub_if_data *sdata, · 895 unmodified lines
5107	continue;	5130	continue;
5108		5131
5109	valid_links \|= BIT(link_id);	5132	valid_links \|= BIT(link_id);
5110	if (assoc_data->link[link_id].disabled) {	5133	if (assoc_data->link[link_id].disabled)
5111	dormant_links \|= BIT(link_id);	5134	dormant_links \|= BIT(link_id);
5112	} else if (link_id != assoc_data->assoc_link_id) {	5135
		5136	if (link_id != assoc_data->assoc_link_id) {
5113	err = ieee80211_sta_allocate_link(sta, link_id);	5137	err = ieee80211_sta_allocate_link(sta, link_id);
5114	if (err)	5138	if (err)
5115	goto out_err;	5139	goto out_err;
@@ -5124,7 +5148,7 @@ static bool ieee80211_assoc_success(struct ieee80211_sub_if_data *sdata, · 8 unmodified lines
5124	struct ieee80211_link_data *link;	5148	struct ieee80211_link_data *link;
5125	struct link_sta_info *link_sta;	5149	struct link_sta_info *link_sta;
5126		5150
5127	if (!cbss \|\| assoc_data->link[link_id].disabled)	5151	if (!cbss)
5128	continue;	5152	continue;
5129		5153
5130	link = sdata_dereference(sdata->link[link_id], sdata);	5154	link = sdata_dereference(sdata->link[link_id], sdata);
@@ -5429,17 +5453,18 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata, · 298 unmodified lines
5429	for (link_id = 0; link_id < IEEE80211_MLD_MAX_NUM_LINKS; link_id++) {	5453	for (link_id = 0; link_id < IEEE80211_MLD_MAX_NUM_LINKS; link_id++) {
5430	struct ieee80211_link_data *link;	5454	struct ieee80211_link_data *link;
5431		5455
5432	link = sdata_dereference(sdata->link[link_id], sdata);
5433	if (!link)
5434	continue;
5435
5436	if (!assoc_data->link[link_id].bss)	5456	if (!assoc_data->link[link_id].bss)
5437	continue;	5457	continue;
5438		5458
5439	resp.links[link_id].bss = assoc_data->link[link_id].bss;	5459	resp.links[link_id].bss = assoc_data->link[link_id].bss;
5440	resp.links[link_id].addr = link->conf->addr;	5460	ether_addr_copy(resp.links[link_id].addr,
		5461	assoc_data->link[link_id].addr);
5441	resp.links[link_id].status = assoc_data->link[link_id].status;	5462	resp.links[link_id].status = assoc_data->link[link_id].status;
5442		5463
		5464	link = sdata_dereference(sdata->link[link_id], sdata);
		5465	if (!link)
		5466	continue;
		5467
5443	/* get uapsd queues configuration - same for all links */	5468	/* get uapsd queues configuration - same for all links */
5444	resp.uapsd_queues = 0;	5469	resp.uapsd_queues = 0;
5445	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)	5470	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)

net/mac80211/tx.c+2−1

@@ -665,7 +665,8 @@ ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx) · 664 unmodified lines
665	}	665	}
666		666
667	if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED &&	667	if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED &&
668	!ieee80211_is_deauth(hdr->frame_control)))	668	!ieee80211_is_deauth(hdr->frame_control)) &&
		669	tx->skb->protocol != tx->sdata->control_port_protocol)
669	return TX_DROP;	670	return TX_DROP;
670		671
671	if (!skip_hw && tx->key &&	672	if (!skip_hw && tx->key &&

net/mac80211/vht.c+14−2

  *
  * Portions of this file
  * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
- * Copyright (C) 2018 - 2022 Intel Corporation
+ * Copyright (C) 2018 - 2023 Intel Corporation
  */
 #include <linux/ieee80211.h>
 ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
 				    struct ieee80211_supported_band *sband,
 				    const struct ieee80211_vht_cap *vht_cap_ie,
+				    const struct ieee80211_vht_cap *vht_cap_ie2,
 				    struct link_sta_info *link_sta)
 {
 	struct ieee80211_sta_vht_cap *vht_cap = &link_sta->pub->vht_cap;
 	struct ieee80211_sta_vht_cap own_cap;
 	u32 cap_info, i;
 	bool have_80mhz;
+	u32 mpdu_len;
 	memset(vht_cap, 0, sizeof(*vht_cap));
 	link_sta->pub->bandwidth = ieee80211_sta_cur_vht_bw(link_sta);
+	/*
+	 * Work around the Cisco 9115 FW 17.3 bug by taking the min of
+	 * both reported MPDU lengths.
+	 */
+	mpdu_len = vht_cap->cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK;
+	if (vht_cap_ie2)
+		mpdu_len = min_t(u32, mpdu_len,
+				 le32_get_bits(vht_cap_ie2->vht_cap_info,
+					       IEEE80211_VHT_CAP_MAX_MPDU_MASK));
 	/*
 	 * FIXME - should the amsdu len be per link? store per link
 	 * and maintain a minimum?
 	 */
-	switch (vht_cap->cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK) {
+	switch (mpdu_len) {
 	case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454:
 		link_sta->pub->agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_11454;
 		break;

net/mptcp/pm_userspace.c+0−6

 		goto create_err;
 	}
-	if (addr_l.id == 0) {
-		NL_SET_ERR_MSG_ATTR(info->extack, laddr, "missing local addr id");
-		err = -EINVAL;
-		goto create_err;
-	}
 	err = mptcp_pm_parse_addr(raddr, info, &addr_r);
 	if (err < 0) {
 		NL_SET_ERR_MSG_ATTR(info->extack, raddr, "error parsing remote addr");

net/mptcp/protocol.c+14−14

 	sk_reset_timer(ssk, &icsk->icsk_delack_timer, timeout);
 }
-void mptcp_subflow_process_delegated(struct sock *ssk)
+void mptcp_subflow_process_delegated(struct sock *ssk, long status)
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
 	struct sock *sk = subflow->conn;
-	if (test_bit(MPTCP_DELEGATE_SEND, &subflow->delegated_status)) {
+	if (status & BIT(MPTCP_DELEGATE_SEND)) {
 		mptcp_data_lock(sk);
 		if (!sock_owned_by_user(sk))
 			__mptcp_subflow_push_pending(sk, ssk, true);
 		else
 			__set_bit(MPTCP_PUSH_PENDING, &mptcp_sk(sk)->cb_flags);
 		mptcp_data_unlock(sk);
-		mptcp_subflow_delegated_done(subflow, MPTCP_DELEGATE_SEND);
 	}
-	if (test_bit(MPTCP_DELEGATE_ACK, &subflow->delegated_status)) {
+	if (status & BIT(MPTCP_DELEGATE_ACK))
 		schedule_3rdack_retransmission(ssk);
-		mptcp_subflow_delegated_done(subflow, MPTCP_DELEGATE_ACK);
-	}
 }
 static int mptcp_hash(struct sock *sk)
 		struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
 		bh_lock_sock_nested(ssk);
-		if (!sock_owned_by_user(ssk) &&
+		if (!sock_owned_by_user(ssk)) {
-		    mptcp_subflow_has_delegated_action(subflow))
+			mptcp_subflow_process_delegated(ssk, xchg(&subflow->delegated_status, 0));
-			mptcp_subflow_process_delegated(ssk);
+		} else {
-		/* ... elsewhere tcp_release_cb_override already processed
+			/* tcp_release_cb_override already processed
-		 * the action or will do at next release_sock().
+			 * the action or will do at next release_sock().
-		 * In both case must dequeue the subflow here - on the same
+			 * In both case must dequeue the subflow here - on the same
-		 * CPU that scheduled it.
+			 * CPU that scheduled it.
-		 */
+			 */
+			smp_wmb();
+			clear_bit(MPTCP_DELEGATE_SCHEDULED, &subflow->delegated_status);
+		}
 		bh_unlock_sock(ssk);
 		sock_put(ssk);

net/mptcp/protocol.h+12−23

 DECLARE_PER_CPU(struct mptcp_delegated_action, mptcp_delegated_actions);
-#define MPTCP_DELEGATE_SEND		0
+#define MPTCP_DELEGATE_SCHEDULED	0
-#define MPTCP_DELEGATE_ACK		1
+#define MPTCP_DELEGATE_SEND		1
+#define MPTCP_DELEGATE_ACK		2
+#define MPTCP_DELEGATE_ACTIONS_MASK	(~BIT(MPTCP_DELEGATE_SCHEDULED))
 /* MPTCP subflow context */
 struct mptcp_subflow_context {
 	struct	list_head node;/* conn_list of subflows */
 	return subflow->map_seq + mptcp_subflow_get_map_offset(subflow);
 }
-void mptcp_subflow_process_delegated(struct sock *ssk);
+void mptcp_subflow_process_delegated(struct sock *ssk, long actions);
 static inline void mptcp_subflow_delegate(struct mptcp_subflow_context *subflow, int action)
 {
+	long old, set_bits = BIT(MPTCP_DELEGATE_SCHEDULED) | BIT(action);
 	struct mptcp_delegated_action *delegated;
 	bool schedule;
 	/* the caller held the subflow bh socket lock */
 	lockdep_assert_in_softirq();
-	/* The implied barrier pairs with mptcp_subflow_delegated_done(), and
+	/* The implied barrier pairs with tcp_release_cb_override()
-	 * ensures the below list check sees list updates done prior to status
+	 * mptcp_napi_poll(), and ensures the below list check sees list
-	 * bit changes
+	 * updates done prior to delegated status bits changes
 	 */
-	if (!test_and_set_bit(action, &subflow->delegated_status)) {
+	old = set_mask_bits(&subflow->delegated_status, 0, set_bits);
-		/* still on delegated list from previous scheduling */
+	if (!(old & BIT(MPTCP_DELEGATE_SCHEDULED))) {
-		if (!list_empty(&subflow->delegated_node))
+		if (WARN_ON_ONCE(!list_empty(&subflow->delegated_node)))
 			return;
 		delegated = this_cpu_ptr(&mptcp_delegated_actions);
 	return ret;
 }
-static inline bool mptcp_subflow_has_delegated_action(const struct mptcp_subflow_context *subflow)
-{
-	return !!READ_ONCE(subflow->delegated_status);
-}
-static inline void mptcp_subflow_delegated_done(struct mptcp_subflow_context *subflow, int action)
-{
-	/* pairs with mptcp_subflow_delegate, ensures delegate_node is updated before
-	 * touching the status bit
-	 */
-	smp_wmb();
-	clear_bit(action, &subflow->delegated_status);
-}
 int mptcp_is_enabled(const struct net *net);
 unsigned int mptcp_get_add_addr_timeout(const struct net *net);
 int mptcp_is_checksum_enabled(const struct net *net);

net/mptcp/subflow.c+8−2

 static void tcp_release_cb_override(struct sock *ssk)
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
+	long status;
-	if (mptcp_subflow_has_delegated_action(subflow))
+	/* process and clear all the pending actions, but leave the subflow into
-		mptcp_subflow_process_delegated(ssk);
+	 * the napi queue. To respect locking, only the same CPU that originated
+	 * the action can touch the list. mptcp_napi_poll will take care of it.
+	 */
+	status = set_mask_bits(&subflow->delegated_status, MPTCP_DELEGATE_ACTIONS_MASK, 0);
+	if (status)
+		mptcp_subflow_process_delegated(ssk, status);
 	tcp_release_cb(ssk);
 }

net/netfilter/ipvs/ip_vs_sync.c+4−4

@@ -1435,7 +1435,7 @@ static int bind_mcastif_addr(struct socket sock, struct net_device dev) · 1434 unmodified lines
1435	sin.sin_addr.s_addr = addr;	1435	sin.sin_addr.s_addr = addr;
1436	sin.sin_port = 0;	1436	sin.sin_port = 0;
1437		1437
1438	return sock->ops->bind(sock, (struct sockaddr*)&sin, sizeof(sin));	1438	return kernel_bind(sock, (struct sockaddr *)&sin, sizeof(sin));
1439	}	1439	}
1440		1440
1441	static void get_mcast_sockaddr(union ipvs_sockaddr sa, int salen,	1441	static void get_mcast_sockaddr(union ipvs_sockaddr sa, int salen,
@@ -1501,8 +1501,8 @@ static int make_send_sock(struct netns_ipvs *ipvs, int id, · 59 unmodified lines
1501	}	1501	}
1502		1502
1503	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->mcfg, id);	1503	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->mcfg, id);
1504	result = sock->ops->connect(sock, (struct sockaddr *) &mcast_addr,	1504	result = kernel_connect(sock, (struct sockaddr *)&mcast_addr,
1505	salen, 0);	1505	salen, 0);
1506	if (result < 0) {	1506	if (result < 0) {
1507	pr_err("Error connecting to the multicast addr\n");	1507	pr_err("Error connecting to the multicast addr\n");
1508	goto error;	1508	goto error;
@@ -1542,7 +1542,7 @@ static int make_receive_sock(struct netns_ipvs *ipvs, int id, · 33 unmodified lines
1542		1542
1543	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->bcfg, id);	1543	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->bcfg, id);
1544	sock->sk->sk_bound_dev_if = dev->ifindex;	1544	sock->sk->sk_bound_dev_if = dev->ifindex;
1545	result = sock->ops->bind(sock, (struct sockaddr *)&mcast_addr, salen);	1545	result = kernel_bind(sock, (struct sockaddr *)&mcast_addr, salen);
1546	if (result < 0) {	1546	if (result < 0) {
1547	pr_err("Error binding to the multicast addr\n");	1547	pr_err("Error binding to the multicast addr\n");
1548	goto error;	1548	goto error;

net/netfilter/nf_conntrack_proto_sctp.c+33−10

@@ -112,7 +112,7 @@ static const u8 sctp_conntracks[2][11][SCTP_CONNTRACK_MAX] = { · 111 unmodified lines
112	/* shutdown_ack */ {sSA, sCL, sCW, sCE, sES, sSA, sSA, sSA, sSA},	112	/* shutdown_ack */ {sSA, sCL, sCW, sCE, sES, sSA, sSA, sSA, sSA},
113	/* error / {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA, sCL},/ Can't have Stale cookie*/	113	/* error / {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA, sCL},/ Can't have Stale cookie*/
114	/* cookie_echo / {sCL, sCL, sCE, sCE, sES, sSS, sSR, sSA, sCL},/ 5.2.4 - Big TODO */	114	/* cookie_echo / {sCL, sCL, sCE, sCE, sES, sSS, sSR, sSA, sCL},/ 5.2.4 - Big TODO */
115	/* cookie_ack / {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA, sCL},/ Can't come in orig dir */	115	/* cookie_ack / {sCL, sCL, sCW, sES, sES, sSS, sSR, sSA, sCL},/ Can't come in orig dir */
116	/* shutdown_comp*/ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sCL, sCL},	116	/* shutdown_comp*/ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sCL, sCL},
117	/* heartbeat */ {sHS, sCL, sCW, sCE, sES, sSS, sSR, sSA, sHS},	117	/* heartbeat */ {sHS, sCL, sCW, sCE, sES, sSS, sSR, sSA, sHS},
118	/* heartbeat_ack*/ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA, sHS},	118	/* heartbeat_ack*/ {sCL, sCL, sCW, sCE, sES, sSS, sSR, sSA, sHS},
@@ -126,7 +126,7 @@ static const u8 sctp_conntracks[2][11][SCTP_CONNTRACK_MAX] = { · 7 unmodified lines
126	/* shutdown */ {sIV, sCL, sCW, sCE, sSR, sSS, sSR, sSA, sIV},	126	/* shutdown */ {sIV, sCL, sCW, sCE, sSR, sSS, sSR, sSA, sIV},
127	/* shutdown_ack */ {sIV, sCL, sCW, sCE, sES, sSA, sSA, sSA, sIV},	127	/* shutdown_ack */ {sIV, sCL, sCW, sCE, sES, sSA, sSA, sSA, sIV},
128	/* error */ {sIV, sCL, sCW, sCL, sES, sSS, sSR, sSA, sIV},	128	/* error */ {sIV, sCL, sCW, sCL, sES, sSS, sSR, sSA, sIV},
129	/* cookie_echo / {sIV, sCL, sCW, sCE, sES, sSS, sSR, sSA, sIV},/ Can't come in reply dir */	129	/* cookie_echo / {sIV, sCL, sCE, sCE, sES, sSS, sSR, sSA, sIV},/ Can't come in reply dir */
130	/* cookie_ack */ {sIV, sCL, sCW, sES, sES, sSS, sSR, sSA, sIV},	130	/* cookie_ack */ {sIV, sCL, sCW, sES, sES, sSS, sSR, sSA, sIV},
131	/* shutdown_comp*/ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sCL, sIV},	131	/* shutdown_comp*/ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sCL, sIV},
132	/* heartbeat */ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sSA, sHS},	132	/* heartbeat */ {sIV, sCL, sCW, sCE, sES, sSS, sSR, sSA, sHS},
@@ -412,6 +412,9 @@ int nf_conntrack_sctp_packet(struct nf_conn *ct, · 279 unmodified lines
412	/* (D) vtag must be same as init_vtag as found in INIT_ACK */	412	/* (D) vtag must be same as init_vtag as found in INIT_ACK */
413	if (sh->vtag != ct->proto.sctp.vtag[dir])	413	if (sh->vtag != ct->proto.sctp.vtag[dir])
414	goto out_unlock;	414	goto out_unlock;
		415	} else if (sch->type == SCTP_CID_COOKIE_ACK) {
		416	ct->proto.sctp.init[dir] = 0;
		417	ct->proto.sctp.init[!dir] = 0;
415	} else if (sch->type == SCTP_CID_HEARTBEAT) {	418	} else if (sch->type == SCTP_CID_HEARTBEAT) {
416	if (ct->proto.sctp.vtag[dir] == 0) {	419	if (ct->proto.sctp.vtag[dir] == 0) {
417	pr_debug("Setting %d vtag %x for dir %d\n", sch->type, sh->vtag, dir);	420	pr_debug("Setting %d vtag %x for dir %d\n", sch->type, sh->vtag, dir);
@@ -461,16 +464,18 @@ int nf_conntrack_sctp_packet(struct nf_conn *ct, · 43 unmodified lines
461	}	464	}
462		465
463	/* If it is an INIT or an INIT ACK note down the vtag */	466	/* If it is an INIT or an INIT ACK note down the vtag */
464	if (sch->type == SCTP_CID_INIT \|\|	467	if (sch->type == SCTP_CID_INIT) {
465	sch->type == SCTP_CID_INIT_ACK) {	468	struct sctp_inithdr _ih, *ih;
466	struct sctp_inithdr _inithdr, *ih;
467		469
468	ih = skb_header_pointer(skb, offset + sizeof(_sch),	470	ih = skb_header_pointer(skb, offset + sizeof(_sch), sizeof(*ih), &_ih);
469	sizeof(_inithdr), &_inithdr);	471	if (!ih)
470	if (ih == NULL)
471	goto out_unlock;	472	goto out_unlock;
472	pr_debug("Setting vtag %x for dir %d\n",	473
473	ih->init_tag, !dir);	474	if (ct->proto.sctp.init[dir] && ct->proto.sctp.init[!dir])
		475	ct->proto.sctp.init[!dir] = 0;
		476	ct->proto.sctp.init[dir] = 1;
		477
		478	pr_debug("Setting vtag %x for dir %d\n", ih->init_tag, !dir);
474	ct->proto.sctp.vtag[!dir] = ih->init_tag;	479	ct->proto.sctp.vtag[!dir] = ih->init_tag;
475		480
476	/* don't renew timeout on init retransmit so	481	/* don't renew timeout on init retransmit so
@@ -481,6 +486,24 @@ int nf_conntrack_sctp_packet(struct nf_conn *ct, · 4 unmodified lines
481	old_state == SCTP_CONNTRACK_CLOSED &&	486	old_state == SCTP_CONNTRACK_CLOSED &&
482	nf_ct_is_confirmed(ct))	487	nf_ct_is_confirmed(ct))
483	ignore = true;	488	ignore = true;
		489	} else if (sch->type == SCTP_CID_INIT_ACK) {
		490	struct sctp_inithdr _ih, *ih;
		491	__be32 vtag;
		492
		493	ih = skb_header_pointer(skb, offset + sizeof(_sch), sizeof(*ih), &_ih);
		494	if (!ih)
		495	goto out_unlock;
		496
		497	vtag = ct->proto.sctp.vtag[!dir];
		498	if (!ct->proto.sctp.init[!dir] && vtag && vtag != ih->init_tag)
		499	goto out_unlock;
		500	/* collision */
		501	if (ct->proto.sctp.init[dir] && ct->proto.sctp.init[!dir] &&
		502	vtag != ih->init_tag)
		503	goto out_unlock;
		504
		505	pr_debug("Setting vtag %x for dir %d\n", ih->init_tag, !dir);
		506	ct->proto.sctp.vtag[!dir] = ih->init_tag;
484	}	507	}
485		508
486	ct->proto.sctp.state = new_state;	509	ct->proto.sctp.state = new_state;

net/netfilter/nf_tables_api.c+28−16

 	return nft_delobj(&ctx, obj);
 }
-void nft_obj_notify(struct net *net, const struct nft_table *table,
+static void
-		    struct nft_object *obj, u32 portid, u32 seq, int event,
+__nft_obj_notify(struct net *net, const struct nft_table *table,
-		    u16 flags, int family, int report, gfp_t gfp)
+		 struct nft_object *obj, u32 portid, u32 seq, int event,
+		 u16 flags, int family, int report, gfp_t gfp)
 {
 	struct nftables_pernet *nft_net = nft_pernet(net);
 	struct sk_buff *skb;
 	int err;
-	char *buf = kasprintf(gfp, "%s:%u",
-			      table->name, nft_net->base_seq);
-	audit_log_nfcfg(buf,
-			family,
-			obj->handle,
-			event == NFT_MSG_NEWOBJ ?
-				 AUDIT_NFT_OP_OBJ_REGISTER :
-				 AUDIT_NFT_OP_OBJ_UNREGISTER,
-			gfp);
-	kfree(buf);
 	if (!report &&
 	    !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
 err:
 	nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
 }
+void nft_obj_notify(struct net *net, const struct nft_table *table,
+		    struct nft_object *obj, u32 portid, u32 seq, int event,
+		    u16 flags, int family, int report, gfp_t gfp)
+{
+	struct nftables_pernet *nft_net = nft_pernet(net);
+	char *buf = kasprintf(gfp, "%s:%u",
+			      table->name, nft_net->base_seq);
+	audit_log_nfcfg(buf,
+			family,
+			obj->handle,
+			event == NFT_MSG_NEWOBJ ?
+				 AUDIT_NFT_OP_OBJ_REGISTER :
+				 AUDIT_NFT_OP_OBJ_UNREGISTER,
+			gfp);
+	kfree(buf);
+	__nft_obj_notify(net, table, obj, portid, seq, event,
+			 flags, family, report, gfp);
+}
 EXPORT_SYMBOL_GPL(nft_obj_notify);
 static void nf_tables_obj_notify(const struct nft_ctx *ctx,
 				 struct nft_object *obj, int event)
 {
-	nft_obj_notify(ctx->net, ctx->table, obj, ctx->portid, ctx->seq, event,
+	__nft_obj_notify(ctx->net, ctx->table, obj, ctx->portid,
-		       ctx->flags, ctx->family, ctx->report, GFP_KERNEL);
+			 ctx->seq, event, ctx->flags, ctx->family,
+			 ctx->report, GFP_KERNEL);
 }
 /*

net/netfilter/nft_payload.c+12−1

 	return pkt->inneroff;
 }
+static bool nft_payload_need_vlan_copy(const struct nft_payload *priv)
+{
+	unsigned int len = priv->offset + priv->len;
+	/* data past ether src/dst requested, copy needed */
+	if (len > offsetof(struct ethhdr, h_proto))
+		return true;
+	return false;
+}
 void nft_payload_eval(const struct nft_expr *expr,
 		      struct nft_regs *regs,
 		      const struct nft_pktinfo *pkt)
 			goto err;
 		if (skb_vlan_tag_present(skb) &&
-		    priv->offset >= offsetof(struct ethhdr, h_proto)) {
+		    nft_payload_need_vlan_copy(priv)) {
 			if (!nft_payload_copy_vlan(dest, skb,
 						   priv->offset, priv->len))
 				goto err;

net/netfilter/nft_set_rbtree.c+29−17

@@ -233,10 +233,9 @@ static void nft_rbtree_gc_remove(struct net net, struct nft_set set, · 232 unmodified lines
233	rb_erase(&rbe->node, &priv->root);	233	rb_erase(&rbe->node, &priv->root);
234	}	234	}
235		235
236	static int nft_rbtree_gc_elem(const struct nft_set *__set,	236	static const struct nft_rbtree_elem *
237	struct nft_rbtree *priv,	237	nft_rbtree_gc_elem(const struct nft_set __set, struct nft_rbtree priv,
238	struct nft_rbtree_elem *rbe,	238	struct nft_rbtree_elem *rbe, u8 genmask)
239	u8 genmask)
240	{	239	{
241	struct nft_set set = (struct nft_set )__set;	240	struct nft_set set = (struct nft_set )__set;
242	struct rb_node *prev = rb_prev(&rbe->node);	241	struct rb_node *prev = rb_prev(&rbe->node);
@@ -246,7 +245,7 @@ static int nft_rbtree_gc_elem(const struct nft_set *__set, · 3 unmodified lines
246		245
247	gc = nft_trans_gc_alloc(set, 0, GFP_ATOMIC);	246	gc = nft_trans_gc_alloc(set, 0, GFP_ATOMIC);
248	if (!gc)	247	if (!gc)
249	return -ENOMEM;	248	return ERR_PTR(-ENOMEM);
250		249
251	/* search for end interval coming before this element.	250	/* search for end interval coming before this element.
252	* end intervals don't carry a timeout extension, they	251	* end intervals don't carry a timeout extension, they
@@ -261,6 +260,7 @@ static int nft_rbtree_gc_elem(const struct nft_set *__set, · 8 unmodified lines
261	prev = rb_prev(prev);	260	prev = rb_prev(prev);
262	}	261	}
263		262
		263	rbe_prev = NULL;
264	if (prev) {	264	if (prev) {
265	rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node);	265	rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node);
266	nft_rbtree_gc_remove(net, set, priv, rbe_prev);	266	nft_rbtree_gc_remove(net, set, priv, rbe_prev);
@@ -272,7 +272,7 @@ static int nft_rbtree_gc_elem(const struct nft_set *__set, · 5 unmodified lines
272	*/	272	*/
273	gc = nft_trans_gc_queue_sync(gc, GFP_ATOMIC);	273	gc = nft_trans_gc_queue_sync(gc, GFP_ATOMIC);
274	if (WARN_ON_ONCE(!gc))	274	if (WARN_ON_ONCE(!gc))
275	return -ENOMEM;	275	return ERR_PTR(-ENOMEM);
276		276
277	nft_trans_gc_elem_add(gc, rbe_prev);	277	nft_trans_gc_elem_add(gc, rbe_prev);
278	}	278	}
@@ -280,13 +280,13 @@ static int nft_rbtree_gc_elem(const struct nft_set *__set, · 1 unmodified line
280	nft_rbtree_gc_remove(net, set, priv, rbe);	280	nft_rbtree_gc_remove(net, set, priv, rbe);
281	gc = nft_trans_gc_queue_sync(gc, GFP_ATOMIC);	281	gc = nft_trans_gc_queue_sync(gc, GFP_ATOMIC);
282	if (WARN_ON_ONCE(!gc))	282	if (WARN_ON_ONCE(!gc))
283	return -ENOMEM;	283	return ERR_PTR(-ENOMEM);
284		284
285	nft_trans_gc_elem_add(gc, rbe);	285	nft_trans_gc_elem_add(gc, rbe);
286		286
287	nft_trans_gc_queue_sync_done(gc);	287	nft_trans_gc_queue_sync_done(gc);
288		288
289	return 0;	289	return rbe_prev;
290	}	290	}
291		291
292	static bool nft_rbtree_update_first(const struct nft_set *set,	292	static bool nft_rbtree_update_first(const struct nft_set *set,
@@ -314,7 +314,7 @@ static int __nft_rbtree_insert(const struct net net, const struct nft_set set, · 21 unmodified lines
314	struct nft_rbtree *priv = nft_set_priv(set);	314	struct nft_rbtree *priv = nft_set_priv(set);
315	u8 cur_genmask = nft_genmask_cur(net);	315	u8 cur_genmask = nft_genmask_cur(net);
316	u8 genmask = nft_genmask_next(net);	316	u8 genmask = nft_genmask_next(net);
317	int d, err;	317	int d;
318		318
319	/* Descend the tree to search for an existing element greater than the	319	/* Descend the tree to search for an existing element greater than the
320	* key value to insert that is greater than the new element. This is the	320	* key value to insert that is greater than the new element. This is the
@@ -363,9 +363,14 @@ static int __nft_rbtree_insert(const struct net net, const struct nft_set set, · 42 unmodified lines
363	*/	363	*/
364	if (nft_set_elem_expired(&rbe->ext) &&	364	if (nft_set_elem_expired(&rbe->ext) &&
365	nft_set_elem_active(&rbe->ext, cur_genmask)) {	365	nft_set_elem_active(&rbe->ext, cur_genmask)) {
366	err = nft_rbtree_gc_elem(set, priv, rbe, genmask);	366	const struct nft_rbtree_elem *removed_end;
367	if (err < 0)	367
368	return err;	368	removed_end = nft_rbtree_gc_elem(set, priv, rbe, genmask);
		369	if (IS_ERR(removed_end))
		370	return PTR_ERR(removed_end);
		371
		372	if (removed_end == rbe_le \|\| removed_end == rbe_ge)
		373	return -EAGAIN;
369		374
370	continue;	375	continue;
371	}	376	}
@@ -486,11 +491,18 @@ static int nft_rbtree_insert(const struct net net, const struct nft_set set, · 114 unmodified lines
486	struct nft_rbtree_elem *rbe = elem->priv;	491	struct nft_rbtree_elem *rbe = elem->priv;
487	int err;	492	int err;
488		493
489	write_lock_bh(&priv->lock);	494	do {
490	write_seqcount_begin(&priv->count);	495	if (fatal_signal_pending(current))
491	err = __nft_rbtree_insert(net, set, rbe, ext);	496	return -EINTR;
492	write_seqcount_end(&priv->count);	497
493	write_unlock_bh(&priv->lock);	498	cond_resched();
		499
		500	write_lock_bh(&priv->lock);
		501	write_seqcount_begin(&priv->count);
		502	err = __nft_rbtree_insert(net, set, rbe, ext);
		503	write_seqcount_end(&priv->count);
		504	write_unlock_bh(&priv->lock);
		505	} while (err == -EAGAIN);
494		506
495	return err;	507	return err;
496	}	508	}

net/netlink/af_netlink.c+4−4

@@ -352,7 +352,7 @@ static void netlink_overrun(struct sock *sk) · 351 unmodified lines
352	if (!nlk_test_bit(RECV_NO_ENOBUFS, sk)) {	352	if (!nlk_test_bit(RECV_NO_ENOBUFS, sk)) {
353	if (!test_and_set_bit(NETLINK_S_CONGESTED,	353	if (!test_and_set_bit(NETLINK_S_CONGESTED,
354	&nlk_sk(sk)->state)) {	354	&nlk_sk(sk)->state)) {
355	sk->sk_err = ENOBUFS;	355	WRITE_ONCE(sk->sk_err, ENOBUFS);
356	sk_error_report(sk);	356	sk_error_report(sk);
357	}	357	}
358	}	358	}
@@ -1605,7 +1605,7 @@ static int do_one_set_err(struct sock sk, struct netlink_set_err_data p) · 1246 unmodified lines
1605	goto out;	1605	goto out;
1606	}	1606	}
1607		1607
1608	sk->sk_err = p->code;	1608	WRITE_ONCE(sk->sk_err, p->code);
1609	sk_error_report(sk);	1609	sk_error_report(sk);
1610	out:	1610	out:
1611	return ret;	1611	return ret;
@@ -1991,7 +1991,7 @@ static int netlink_recvmsg(struct socket sock, struct msghdr msg, size_t len, · 379 unmodified lines
1991	atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) {	1991	atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) {
1992	ret = netlink_dump(sk);	1992	ret = netlink_dump(sk);
1993	if (ret) {	1993	if (ret) {
1994	sk->sk_err = -ret;	1994	WRITE_ONCE(sk->sk_err, -ret);
1995	sk_error_report(sk);	1995	sk_error_report(sk);
1996	}	1996	}
1997	}	1997	}
@@ -2511,7 +2511,7 @@ void netlink_ack(struct sk_buff in_skb, struct nlmsghdr nlh, int err, · 513 unmodified lines
2511	err_bad_put:	2511	err_bad_put:
2512	nlmsg_free(skb);	2512	nlmsg_free(skb);
2513	err_skb:	2513	err_skb:
2514	NETLINK_CB(in_skb).sk->sk_err = ENOBUFS;	2514	WRITE_ONCE(NETLINK_CB(in_skb).sk->sk_err, ENOBUFS);
2515	sk_error_report(NETLINK_CB(in_skb).sk);	2515	sk_error_report(NETLINK_CB(in_skb).sk);
2516	}	2516	}
2517	EXPORT_SYMBOL(netlink_ack);	2517	EXPORT_SYMBOL(netlink_ack);

net/nfc/llcp_core.c+2−0

@@ -1636,7 +1636,9 @@ int nfc_llcp_register_device(struct nfc_dev *ndev) · 1635 unmodified lines
1636	timer_setup(&local->sdreq_timer, nfc_llcp_sdreq_timer, 0);	1636	timer_setup(&local->sdreq_timer, nfc_llcp_sdreq_timer, 0);
1637	INIT_WORK(&local->sdreq_timeout_work, nfc_llcp_sdreq_timeout_work);	1637	INIT_WORK(&local->sdreq_timeout_work, nfc_llcp_sdreq_timeout_work);
1638		1638
		1639	spin_lock(&llcp_devices_lock);
1639	list_add(&local->list, &llcp_devices);	1640	list_add(&local->list, &llcp_devices);
		1641	spin_unlock(&llcp_devices_lock);
1640		1642
1641	return 0;	1643	return 0;
1642	}	1644	}

net/rds/tcp_connect.c+2−2

@@ -145,7 +145,7 @@ int rds_tcp_conn_path_connect(struct rds_conn_path *cp) · 144 unmodified lines
145	addrlen = sizeof(sin);	145	addrlen = sizeof(sin);
146	}	146	}
147		147
148	ret = sock->ops->bind(sock, addr, addrlen);	148	ret = kernel_bind(sock, addr, addrlen);
149	if (ret) {	149	if (ret) {
150	rdsdebug("bind failed with %d at address %pI6c\n",	150	rdsdebug("bind failed with %d at address %pI6c\n",
151	ret, &conn->c_laddr);	151	ret, &conn->c_laddr);
@@ -173,7 +173,7 @@ int rds_tcp_conn_path_connect(struct rds_conn_path *cp) · 21 unmodified lines
173	* own the socket	173	* own the socket
174	*/	174	*/
175	rds_tcp_set_callbacks(sock, cp);	175	rds_tcp_set_callbacks(sock, cp);
176	ret = sock->ops->connect(sock, addr, addrlen, O_NONBLOCK);	176	ret = kernel_connect(sock, addr, addrlen, O_NONBLOCK);
177		177
178	rdsdebug("connect to address %pI6c returned %d\n", &conn->c_faddr, ret);	178	rdsdebug("connect to address %pI6c returned %d\n", &conn->c_faddr, ret);
179	if (ret == -EINPROGRESS)	179	if (ret == -EINPROGRESS)

net/rds/tcp_listen.c+1−1

@@ -306,7 +306,7 @@ struct socket rds_tcp_listen_init(struct net net, bool isv6) · 305 unmodified lines
306	addr_len = sizeof(*sin);	306	addr_len = sizeof(*sin);
307	}	307	}
308		308
309	ret = sock->ops->bind(sock, (struct sockaddr *)&ss, addr_len);	309	ret = kernel_bind(sock, (struct sockaddr *)&ss, addr_len);
310	if (ret < 0) {	310	if (ret < 0) {
311	rdsdebug("could not bind %s listener socket: %d\n",	311	rdsdebug("could not bind %s listener socket: %d\n",
312	isv6 ? "IPv6" : "IPv4", ret);	312	isv6 ? "IPv6" : "IPv4", ret);

net/rfkill/core.c+26−6

 	bool			persistent;
 	bool			polling_paused;
 	bool			suspended;
+	bool			need_sync;
 	const struct rfkill_ops	*ops;
 	void			*data;
 		rfkill_event(rfkill);
 }
+static void rfkill_sync(struct rfkill *rfkill)
+{
+	lockdep_assert_held(&rfkill_global_mutex);
+	if (!rfkill->need_sync)
+		return;
+	rfkill_set_block(rfkill, rfkill_global_states[rfkill->type].cur);
+	rfkill->need_sync = false;
+}
 static void rfkill_update_global_state(enum rfkill_type type, bool blocked)
 {
 	int i;
 {
 	struct rfkill *rfkill = to_rfkill(dev);
+	mutex_lock(&rfkill_global_mutex);
+	rfkill_sync(rfkill);
+	mutex_unlock(&rfkill_global_mutex);
 	return sysfs_emit(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0);
 }
 		return -EINVAL;
 	mutex_lock(&rfkill_global_mutex);
+	rfkill_sync(rfkill);
 	rfkill_set_block(rfkill, state);
 	mutex_unlock(&rfkill_global_mutex);
 {
 	struct rfkill *rfkill = to_rfkill(dev);
+	mutex_lock(&rfkill_global_mutex);
+	rfkill_sync(rfkill);
+	mutex_unlock(&rfkill_global_mutex);
 	return sysfs_emit(buf, "%d\n", user_state_from_blocked(rfkill->state));
 }
 		return -EINVAL;
 	mutex_lock(&rfkill_global_mutex);
+	rfkill_sync(rfkill);
 	rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED);
 	mutex_unlock(&rfkill_global_mutex);
 static void rfkill_sync_work(struct work_struct *work)
 {
-	struct rfkill *rfkill;
+	struct rfkill *rfkill = container_of(work, struct rfkill, sync_work);
-	bool cur;
-	rfkill = container_of(work, struct rfkill, sync_work);
 	mutex_lock(&rfkill_global_mutex);
-	cur = rfkill_global_states[rfkill->type].cur;
+	rfkill_sync(rfkill);
-	rfkill_set_block(rfkill, cur);
 	mutex_unlock(&rfkill_global_mutex);
 }
 			round_jiffies_relative(POLL_INTERVAL));
 	if (!rfkill->persistent || rfkill_epo_lock_active) {
+		rfkill->need_sync = true;
 		schedule_work(&rfkill->sync_work);
 	} else {
 #ifdef CONFIG_RFKILL_INPUT
 		ev = kzalloc(sizeof(*ev), GFP_KERNEL);
 		if (!ev)
 			goto free;
+		rfkill_sync(rfkill);
 		rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD);
 		list_add_tail(&ev->list, &data->events);
 	}

net/sctp/associola.c+1−2

@@ -1159,8 +1159,7 @@ int sctp_assoc_update(struct sctp_association *asoc, · 1158 unmodified lines
1159	/* Add any peer addresses from the new association. */	1159	/* Add any peer addresses from the new association. */
1160	list_for_each_entry(trans, &new->peer.transport_addr_list,	1160	list_for_each_entry(trans, &new->peer.transport_addr_list,
1161	transports)	1161	transports)
1162	if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr) &&	1162	if (!sctp_assoc_add_peer(asoc, &trans->ipaddr,
1163	!sctp_assoc_add_peer(asoc, &trans->ipaddr,
1164	GFP_ATOMIC, trans->state))	1163	GFP_ATOMIC, trans->state))
1165	return -ENOMEM;	1164	return -ENOMEM;
1166		1165

net/sctp/socket.c+1−0

@@ -2450,6 +2450,7 @@ static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params, · 2449 unmodified lines
2450	if (trans) {	2450	if (trans) {
2451	trans->hbinterval =	2451	trans->hbinterval =
2452	msecs_to_jiffies(params->spp_hbinterval);	2452	msecs_to_jiffies(params->spp_hbinterval);
		2453	sctp_transport_reset_hb_timer(trans);
2453	} else if (asoc) {	2454	} else if (asoc) {
2454	asoc->hbinterval =	2455	asoc->hbinterval =
2455	msecs_to_jiffies(params->spp_hbinterval);	2456	msecs_to_jiffies(params->spp_hbinterval);

net/socket.c+29−7

 	return ret;
 }
+static int __sock_sendmsg(struct socket *sock, struct msghdr *msg)
+{
+	int err = security_socket_sendmsg(sock, msg,
+					  msg_data_left(msg));
+	return err ?: sock_sendmsg_nosec(sock, msg);
+}
 /**
  *	sock_sendmsg - send a message through @sock
  *	@sock: socket
  */
 int sock_sendmsg(struct socket *sock, struct msghdr *msg)
 {
-	int err = security_socket_sendmsg(sock, msg,
+	struct sockaddr_storage *save_addr = (struct sockaddr_storage *)msg->msg_name;
-					  msg_data_left(msg));
+	struct sockaddr_storage address;
+	int ret;
-	return err ?: sock_sendmsg_nosec(sock, msg);
+	if (msg->msg_name) {
+		memcpy(&address, msg->msg_name, msg->msg_namelen);
+		msg->msg_name = &address;
+	}
+	ret = __sock_sendmsg(sock, msg);
+	msg->msg_name = save_addr;
+	return ret;
 }
 EXPORT_SYMBOL(sock_sendmsg);
 	if (sock->type == SOCK_SEQPACKET)
 		msg.msg_flags |= MSG_EOR;
-	res = sock_sendmsg(sock, &msg);
+	res = __sock_sendmsg(sock, &msg);
 	*from = msg.msg_iter;
 	return res;
 }
 	if (sock->file->f_flags & O_NONBLOCK)
 		flags |= MSG_DONTWAIT;
 	msg.msg_flags = flags;
-	err = sock_sendmsg(sock, &msg);
+	err = __sock_sendmsg(sock, &msg);
 out_put:
 	fput_light(sock->file, fput_needed);
 		err = sock_sendmsg_nosec(sock, msg_sys);
 		goto out_freectl;
 	}
-	err = sock_sendmsg(sock, msg_sys);
+	err = __sock_sendmsg(sock, msg_sys);
 	/*
 	 * If this is sendmmsg() and sending to current destination address was
 	 * successful, remember it.
 int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
 {
-	return READ_ONCE(sock->ops)->bind(sock, addr, addrlen);
+	struct sockaddr_storage address;
+	memcpy(&address, addr, addrlen);
+	return READ_ONCE(sock->ops)->bind(sock, (struct sockaddr *)&address,
+					  addrlen);
 }
 EXPORT_SYMBOL(kernel_bind);

net/sunrpc/auth.c+8−3

  * @task: controlling RPC task
  * @xdr: xdr_stream containing RPC Reply header
  *
- * On success, @xdr is updated to point past the verifier and
+ * Return values:
- * zero is returned. Otherwise, @xdr is in an undefined state
+ *   %0: Verifier is valid. @xdr now points past the verifier.
- * and a negative errno is returned.
+ *   %-EIO: Verifier is corrupted or message ended early.
+ *   %-EACCES: Verifier is intact but not valid.
+ *   %-EPROTONOSUPPORT: Server does not support the requested auth type.
+ *
+ * When a negative errno is returned, @xdr is left in an undefined
+ * state.
  */
 int
 rpcauth_checkverf(struct rpc_task *task, struct xdr_stream *xdr)

net/sunrpc/auth_tls.c+2−2

@@ -129,9 +129,9 @@ static int tls_validate(struct rpc_task task, struct xdr_stream xdr) · 128 unmodified lines
129	if (*p != rpc_auth_null)	129	if (*p != rpc_auth_null)
130	return -EIO;	130	return -EIO;
131	if (xdr_stream_decode_opaque_inline(xdr, &str, starttls_len) != starttls_len)	131	if (xdr_stream_decode_opaque_inline(xdr, &str, starttls_len) != starttls_len)
132	return -EIO;	132	return -EPROTONOSUPPORT;
133	if (memcmp(str, starttls_token, starttls_len))	133	if (memcmp(str, starttls_token, starttls_len))
134	return -EIO;	134	return -EPROTONOSUPPORT;
135	return 0;	135	return 0;
136	}	136	}
137		137

net/sunrpc/clnt.c+10−3

 		goto out_exit;
 	}
 	task->tk_action = call_encode;
-	if (status != -ECONNRESET && status != -ECONNABORTED)
+	rpc_check_timeout(task);
-		rpc_check_timeout(task);
 	return;
 out_exit:
 	rpc_call_rpcerror(task, status);
 out_verifier:
 	trace_rpc_bad_verifier(task);
-	goto out_garbage;
+	switch (error) {
+	case -EPROTONOSUPPORT:
+		goto out_err;
+	case -EACCES:
+		/* Re-encode with a fresh cred */
+		fallthrough;
+	default:
+		goto out_garbage;
+	}
 out_msg_denied:
 	error = -EACCES;

net/sunrpc/xprtsock.c+6−0

 	rcu_read_lock();
 	lower_xprt = rcu_dereference(lower_clnt->cl_xprt);
 	rcu_read_unlock();
+	if (wait_on_bit_lock(&lower_xprt->state, XPRT_LOCKED, TASK_KILLABLE))
+		goto out_unlock;
 	status = xs_tls_handshake_sync(lower_xprt, &upper_xprt->xprtsec);
 	if (status) {
 		trace_rpc_tls_not_started(upper_clnt, upper_xprt);
 	status = xs_tcp_tls_finish_connecting(lower_xprt, upper_transport);
 	if (status)
 		goto out_close;
+	xprt_release_write(lower_xprt, NULL);
 	trace_rpc_socket_connect(upper_xprt, upper_transport->sock, 0);
 	if (!xprt_test_and_set_connected(upper_xprt)) {
 	return;
 out_close:
+	xprt_release_write(lower_xprt, NULL);
 	rpc_shutdown_client(lower_clnt);
 	/* xprt_force_disconnect() wakes tasks with a fixed tk_status code.

net/tipc/crypto.c+2−2

@@ -1441,14 +1441,14 @@ static int tipc_crypto_key_revoke(struct net *net, u8 tx_key) · 1440 unmodified lines
1441	struct tipc_crypto *tx = tipc_net(net)->crypto_tx;	1441	struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1442	struct tipc_key key;	1442	struct tipc_key key;
1443		1443
1444	spin_lock(&tx->lock);	1444	spin_lock_bh(&tx->lock);
1445	key = tx->key;	1445	key = tx->key;
1446	WARN_ON(!key.active \|\| tx_key != key.active);	1446	WARN_ON(!key.active \|\| tx_key != key.active);
1447		1447
1448	/* Free the active key */	1448	/* Free the active key */
1449	tipc_crypto_key_set_state(tx, key.passive, 0, key.pending);	1449	tipc_crypto_key_set_state(tx, key.passive, 0, key.pending);
1450	tipc_crypto_key_detach(tx->aead[key.active], &tx->lock);	1450	tipc_crypto_key_detach(tx->aead[key.active], &tx->lock);
1451	spin_unlock(&tx->lock);	1451	spin_unlock_bh(&tx->lock);
1452		1452
1453	pr_warn("%s: key is revoked\n", tx->name);	1453	pr_warn("%s: key is revoked\n", tx->name);
1454	return -EKEYREVOKED;	1454	return -EKEYREVOKED;

net/wireless/core.c+7−7

 }
 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state_reason);
-void cfg80211_cqm_config_free(struct wireless_dev *wdev)
-{
-	kfree(wdev->cqm_config);
-	wdev->cqm_config = NULL;
-}
 static void _cfg80211_unregister_wdev(struct wireless_dev *wdev,
 				      bool unregister_netdev)
 {
 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
+	struct cfg80211_cqm_config *cqm_config;
 	unsigned int link_id;
 	ASSERT_RTNL();
 	kfree_sensitive(wdev->wext.keys);
 	wdev->wext.keys = NULL;
 #endif
-	cfg80211_cqm_config_free(wdev);
+	wiphy_work_cancel(wdev->wiphy, &wdev->cqm_rssi_work);
+	/* deleted from the list, so can't be found from nl80211 any more */
+	cqm_config = rcu_access_pointer(wdev->cqm_config);
+	kfree_rcu(cqm_config, rcu_head);
 	/*
 	 * Ensure that all events have been processed and
 	wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
 #endif
+	wiphy_work_init(&wdev->cqm_rssi_work, cfg80211_cqm_rssi_notify_work);
 	if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
 		wdev->ps = true;
 	else

net/wireless/core.h+5−2

 };
 struct cfg80211_cqm_config {
+	struct rcu_head rcu_head;
 	u32 rssi_hyst;
 	s32 last_rssi_event_value;
+	enum nl80211_cqm_rssi_threshold_event last_rssi_event_type;
 	int n_rssi_thresholds;
 	s32 rssi_thresholds[] __counted_by(n_rssi_thresholds);
 };
+void cfg80211_cqm_rssi_notify_work(struct wiphy *wiphy,
+				   struct wiphy_work *work);
 void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev);
 /* free object */
 #define CFG80211_DEV_WARN_ON(cond)	({bool __r = (cond); __r; })
 #endif
-void cfg80211_cqm_config_free(struct wireless_dev *wdev);
 void cfg80211_release_pmsr(struct wireless_dev *wdev, u32 portid);
 void cfg80211_pmsr_wdev_down(struct wireless_dev *wdev);
 void cfg80211_pmsr_free_wk(struct work_struct *work);

net/wireless/mlme.c+2−1

@@ -52,7 +52,8 @@ void cfg80211_rx_assoc_resp(struct net_device *dev, · 51 unmodified lines
52	cr.links[link_id].bssid = data->links[link_id].bss->bssid;	52	cr.links[link_id].bssid = data->links[link_id].bss->bssid;
53	cr.links[link_id].addr = data->links[link_id].addr;	53	cr.links[link_id].addr = data->links[link_id].addr;
54	/* need to have local link addresses for MLO connections */	54	/* need to have local link addresses for MLO connections */
55	WARN_ON(cr.ap_mld_addr && !cr.links[link_id].addr);	55	WARN_ON(cr.ap_mld_addr &&
		56	!is_valid_ether_addr(cr.links[link_id].addr));
56		57
57	BUG_ON(!cr.links[link_id].bss->channel);	58	BUG_ON(!cr.links[link_id].bss->channel);
58		59

net/wireless/nl80211.c+81−33

@@ -5909,6 +5909,21 @@ out: · 5908 unmodified lines
5909	nlmsg_free(msg);	5909	nlmsg_free(msg);
5910	}	5910	}
5911		5911
		5912	static int nl80211_validate_ap_phy_operation(struct cfg80211_ap_settings *params)
		5913	{
		5914	struct ieee80211_channel *channel = params->chandef.chan;
		5915
		5916	if ((params->he_cap \|\| params->he_oper) &&
		5917	(channel->flags & IEEE80211_CHAN_NO_HE))
		5918	return -EOPNOTSUPP;
		5919
		5920	if ((params->eht_cap \|\| params->eht_oper) &&
		5921	(channel->flags & IEEE80211_CHAN_NO_EHT))
		5922	return -EOPNOTSUPP;
		5923
		5924	return 0;
		5925	}
		5926
5912	static int nl80211_start_ap(struct sk_buff skb, struct genl_info info)	5927	static int nl80211_start_ap(struct sk_buff skb, struct genl_info info)
5913	{	5928	{
5914	struct cfg80211_registered_device *rdev = info->user_ptr[0];	5929	struct cfg80211_registered_device *rdev = info->user_ptr[0];
@@ -6178,6 +6193,10 @@ static int nl80211_start_ap(struct sk_buff skb, struct genl_info info) · 263 unmodified lines
6178	if (err)	6193	if (err)
6179	goto out_unlock;	6194	goto out_unlock;
6180		6195
		6196	err = nl80211_validate_ap_phy_operation(params);
		6197	if (err)
		6198	goto out_unlock;
		6199
6181	if (info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS])	6200	if (info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS])
6182	params->flags = nla_get_u32(	6201	params->flags = nla_get_u32(
6183	info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS]);	6202	info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS]);
@@ -8482,7 +8501,7 @@ static int nl80211_update_mesh_config(struct sk_buff *skb, · 2298 unmodified lines
8482	struct cfg80211_registered_device *rdev = info->user_ptr[0];	8501	struct cfg80211_registered_device *rdev = info->user_ptr[0];
8483	struct net_device *dev = info->user_ptr[1];	8502	struct net_device *dev = info->user_ptr[1];
8484	struct wireless_dev *wdev = dev->ieee80211_ptr;	8503	struct wireless_dev *wdev = dev->ieee80211_ptr;
8485	struct mesh_config cfg;	8504	struct mesh_config cfg = {};
8486	u32 mask;	8505	u32 mask;
8487	int err;	8506	int err;
8488		8507
@@ -12796,7 +12815,8 @@ static int nl80211_set_cqm_txe(struct genl_info *info, · 4307 unmodified lines
12796	}	12815	}
12797		12816
12798	static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,	12817	static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
12799	struct net_device *dev)	12818	struct net_device *dev,
		12819	struct cfg80211_cqm_config *cqm_config)
12800	{	12820	{
12801	struct wireless_dev *wdev = dev->ieee80211_ptr;	12821	struct wireless_dev *wdev = dev->ieee80211_ptr;
12802	s32 last, low, high;	12822	s32 last, low, high;
@@ -12805,7 +12825,7 @@ static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev, · 2 unmodified lines
12805	int err;	12825	int err;
12806		12826
12807	/* RSSI reporting disabled? */	12827	/* RSSI reporting disabled? */
12808	if (!wdev->cqm_config)	12828	if (!cqm_config)
12809	return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);	12829	return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
12810		12830
12811	/*	12831	/*
@@ -12814,7 +12834,7 @@ static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev, · 2 unmodified lines
12814	* connection is established and enough beacons received to calculate	12834	* connection is established and enough beacons received to calculate
12815	* the average.	12835	* the average.
12816	*/	12836	*/
12817	if (!wdev->cqm_config->last_rssi_event_value &&	12837	if (!cqm_config->last_rssi_event_value &&
12818	wdev->links[0].client.current_bss &&	12838	wdev->links[0].client.current_bss &&
12819	rdev->ops->get_station) {	12839	rdev->ops->get_station) {
12820	struct station_info sinfo = {};	12840	struct station_info sinfo = {};
@@ -12828,30 +12848,30 @@ static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev, · 7 unmodified lines
12828		12848
12829	cfg80211_sinfo_release_content(&sinfo);	12849	cfg80211_sinfo_release_content(&sinfo);
12830	if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))	12850	if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
12831	wdev->cqm_config->last_rssi_event_value =	12851	cqm_config->last_rssi_event_value =
12832	(s8) sinfo.rx_beacon_signal_avg;	12852	(s8) sinfo.rx_beacon_signal_avg;
12833	}	12853	}
12834		12854
12835	last = wdev->cqm_config->last_rssi_event_value;	12855	last = cqm_config->last_rssi_event_value;
12836	hyst = wdev->cqm_config->rssi_hyst;	12856	hyst = cqm_config->rssi_hyst;
12837	n = wdev->cqm_config->n_rssi_thresholds;	12857	n = cqm_config->n_rssi_thresholds;
12838		12858
12839	for (i = 0; i < n; i++) {	12859	for (i = 0; i < n; i++) {
12840	i = array_index_nospec(i, n);	12860	i = array_index_nospec(i, n);
12841	if (last < wdev->cqm_config->rssi_thresholds[i])	12861	if (last < cqm_config->rssi_thresholds[i])
12842	break;	12862	break;
12843	}	12863	}
12844		12864
12845	low_index = i - 1;	12865	low_index = i - 1;
12846	if (low_index >= 0) {	12866	if (low_index >= 0) {
12847	low_index = array_index_nospec(low_index, n);	12867	low_index = array_index_nospec(low_index, n);
12848	low = wdev->cqm_config->rssi_thresholds[low_index] - hyst;	12868	low = cqm_config->rssi_thresholds[low_index] - hyst;
12849	} else {	12869	} else {
12850	low = S32_MIN;	12870	low = S32_MIN;
12851	}	12871	}
12852	if (i < n) {	12872	if (i < n) {
12853	i = array_index_nospec(i, n);	12873	i = array_index_nospec(i, n);
12854	high = wdev->cqm_config->rssi_thresholds[i] + hyst - 1;	12874	high = cqm_config->rssi_thresholds[i] + hyst - 1;
12855	} else {	12875	} else {
12856	high = S32_MAX;	12876	high = S32_MAX;
12857	}	12877	}
@@ -12864,6 +12884,7 @@ static int nl80211_set_cqm_rssi(struct genl_info *info, · 6 unmodified lines
12864	u32 hysteresis)	12884	u32 hysteresis)
12865	{	12885	{
12866	struct cfg80211_registered_device *rdev = info->user_ptr[0];	12886	struct cfg80211_registered_device *rdev = info->user_ptr[0];
		12887	struct cfg80211_cqm_config cqm_config = NULL, old;
12867	struct net_device *dev = info->user_ptr[1];	12888	struct net_device *dev = info->user_ptr[1];
12868	struct wireless_dev *wdev = dev->ieee80211_ptr;	12889	struct wireless_dev *wdev = dev->ieee80211_ptr;
12869	int i, err;	12890	int i, err;
@@ -12881,10 +12902,6 @@ static int nl80211_set_cqm_rssi(struct genl_info *info, · 11 unmodified lines
12881	wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)	12902	wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12882	return -EOPNOTSUPP;	12903	return -EOPNOTSUPP;
12883		12904
12884	wdev_lock(wdev);
12885	cfg80211_cqm_config_free(wdev);
12886	wdev_unlock(wdev);
12887
12888	if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {	12905	if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
12889	if (n_thresholds == 0 \|\| thresholds[0] == 0) /* Disabling */	12906	if (n_thresholds == 0 \|\| thresholds[0] == 0) /* Disabling */
12890	return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);	12907	return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
@@ -12901,9 +12918,10 @@ static int nl80211_set_cqm_rssi(struct genl_info *info, · 10 unmodified lines
12901	n_thresholds = 0;	12918	n_thresholds = 0;
12902		12919
12903	wdev_lock(wdev);	12920	wdev_lock(wdev);
12904	if (n_thresholds) {	12921	old = rcu_dereference_protected(wdev->cqm_config,
12905	struct cfg80211_cqm_config *cqm_config;	12922	lockdep_is_held(&wdev->mtx));
12906		12923
		12924	if (n_thresholds) {
12907	cqm_config = kzalloc(struct_size(cqm_config, rssi_thresholds,	12925	cqm_config = kzalloc(struct_size(cqm_config, rssi_thresholds,
12908	n_thresholds),	12926	n_thresholds),
12909	GFP_KERNEL);	12927	GFP_KERNEL);
@@ -12918,11 +12936,18 @@ static int nl80211_set_cqm_rssi(struct genl_info *info, · 8 unmodified lines
12918	flex_array_size(cqm_config, rssi_thresholds,	12936	flex_array_size(cqm_config, rssi_thresholds,
12919	n_thresholds));	12937	n_thresholds));
12920		12938
12921	wdev->cqm_config = cqm_config;	12939	rcu_assign_pointer(wdev->cqm_config, cqm_config);
		12940	} else {
		12941	RCU_INIT_POINTER(wdev->cqm_config, NULL);
12922	}	12942	}
12923		12943
12924	err = cfg80211_cqm_rssi_update(rdev, dev);	12944	err = cfg80211_cqm_rssi_update(rdev, dev, cqm_config);
12925		12945	if (err) {
		12946	rcu_assign_pointer(wdev->cqm_config, old);
		12947	kfree_rcu(cqm_config, rcu_head);
		12948	} else {
		12949	kfree_rcu(old, rcu_head);
		12950	}
12926	unlock:	12951	unlock:
12927	wdev_unlock(wdev);	12952	wdev_unlock(wdev);
12928		12953
@@ -19073,9 +19098,8 @@ void cfg80211_cqm_rssi_notify(struct net_device *dev, · 6144 unmodified lines
19073	enum nl80211_cqm_rssi_threshold_event rssi_event,	19098	enum nl80211_cqm_rssi_threshold_event rssi_event,
19074	s32 rssi_level, gfp_t gfp)	19099	s32 rssi_level, gfp_t gfp)
19075	{	19100	{
19076	struct sk_buff *msg;
19077	struct wireless_dev *wdev = dev->ieee80211_ptr;	19101	struct wireless_dev *wdev = dev->ieee80211_ptr;
19078	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	19102	struct cfg80211_cqm_config *cqm_config;
19079		19103
19080	trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);	19104	trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
19081		19105
@@ -19083,18 +19107,41 @@ void cfg80211_cqm_rssi_notify(struct net_device *dev, · 1 unmodified line
19083	rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))	19107	rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
19084	return;	19108	return;
19085		19109
19086	if (wdev->cqm_config) {	19110	rcu_read_lock();
19087	wdev->cqm_config->last_rssi_event_value = rssi_level;	19111	cqm_config = rcu_dereference(wdev->cqm_config);
		19112	if (cqm_config) {
		19113	cqm_config->last_rssi_event_value = rssi_level;
		19114	cqm_config->last_rssi_event_type = rssi_event;
		19115	wiphy_work_queue(wdev->wiphy, &wdev->cqm_rssi_work);
		19116	}
		19117	rcu_read_unlock();
		19118	}
		19119	EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
19088		19120
19089	cfg80211_cqm_rssi_update(rdev, dev);	19121	void cfg80211_cqm_rssi_notify_work(struct wiphy wiphy, struct wiphy_work work)
		19122	{
		19123	struct wireless_dev *wdev = container_of(work, struct wireless_dev,
		19124	cqm_rssi_work);
		19125	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
		19126	enum nl80211_cqm_rssi_threshold_event rssi_event;
		19127	struct cfg80211_cqm_config *cqm_config;
		19128	struct sk_buff *msg;
		19129	s32 rssi_level;
19090		19130
19091	if (rssi_level == 0)	19131	wdev_lock(wdev);
19092	rssi_level = wdev->cqm_config->last_rssi_event_value;	19132	cqm_config = rcu_dereference_protected(wdev->cqm_config,
19093	}	19133	lockdep_is_held(&wdev->mtx));
		19134	if (!wdev->cqm_config)
		19135	goto unlock;
19094		19136
19095	msg = cfg80211_prepare_cqm(dev, NULL, gfp);	19137	cfg80211_cqm_rssi_update(rdev, wdev->netdev, cqm_config);
		19138
		19139	rssi_level = cqm_config->last_rssi_event_value;
		19140	rssi_event = cqm_config->last_rssi_event_type;
		19141
		19142	msg = cfg80211_prepare_cqm(wdev->netdev, NULL, GFP_KERNEL);
19096	if (!msg)	19143	if (!msg)
19097	return;	19144	goto unlock;
19098		19145
19099	if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,	19146	if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
19100	rssi_event))	19147	rssi_event))
@@ -19104,14 +19151,15 @@ void cfg80211_cqm_rssi_notify(struct net_device *dev, · 3 unmodified lines
19104	rssi_level))	19151	rssi_level))
19105	goto nla_put_failure;	19152	goto nla_put_failure;
19106		19153
19107	cfg80211_send_cqm(msg, gfp);	19154	cfg80211_send_cqm(msg, GFP_KERNEL);
19108		19155
19109	return;	19156	goto unlock;
19110		19157
19111	nla_put_failure:	19158	nla_put_failure:
19112	nlmsg_free(msg);	19159	nlmsg_free(msg);
		19160	unlock:
		19161	wdev_unlock(wdev);
19113	}	19162	}
19114	EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
19115		19163
19116	void cfg80211_cqm_txe_notify(struct net_device *dev,	19164	void cfg80211_cqm_txe_notify(struct net_device *dev,
19117	const u8 *peer, u32 num_packets,	19165	const u8 *peer, u32 num_packets,

net/wireless/scan.c+4−0

@@ -908,6 +908,10 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev) · 907 unmodified lines
908	!cfg80211_find_ssid_match(ap, request))	908	!cfg80211_find_ssid_match(ap, request))
909	continue;	909	continue;
910		910
		911	if (!is_broadcast_ether_addr(request->bssid) &&
		912	!ether_addr_equal(request->bssid, ap->bssid))
		913	continue;
		914
911	if (!request->n_ssids && ap->multi_bss && !ap->transmitted_bssid)	915	if (!request->n_ssids && ap->multi_bss && !ap->transmitted_bssid)
912	continue;	916	continue;
913		917

scripts/Makefile.modinst+1−1

@@ -144,7 +144,7 @@ endif · 143 unmodified lines
144	quiet_cmd_gzip = GZIP $@	144	quiet_cmd_gzip = GZIP $@
145	cmd_gzip = $(KGZIP) -n -f $<	145	cmd_gzip = $(KGZIP) -n -f $<
146	quiet_cmd_xz = XZ $@	146	quiet_cmd_xz = XZ $@
147	cmd_xz = $(XZ) --lzma2=dict=2MiB -f $<	147	cmd_xz = $(XZ) --check=crc32 --lzma2=dict=1MiB -f $<
148	quiet_cmd_zstd = ZSTD $@	148	quiet_cmd_zstd = ZSTD $@
149	cmd_zstd = $(ZSTD) -T0 --rm -f -q $<	149	cmd_zstd = $(ZSTD) -T0 --rm -f -q $<
150		150

scripts/atomic/gen-atomic-fallback.sh+1−1

@@ -102,7 +102,7 @@ gen_proto_order_variant() · 101 unmodified lines
102	fi	102	fi
103		103
104	# Allow ACQUIRE/RELEASE/RELAXED ops to be defined in terms of FULL ops	104	# Allow ACQUIRE/RELEASE/RELAXED ops to be defined in terms of FULL ops
105	if [ ! -z "${order}" ]; then	105	if [ ! -z "${order}" ] && ! meta_is_implicitly_relaxed "${meta}"; then
106	printf "#elif defined(arch_${basename})\n"	106	printf "#elif defined(arch_${basename})\n"
107	printf "\t${retstmt}arch_${basename}(${args});\n"	107	printf "\t${retstmt}arch_${basename}(${args});\n"
108	fi	108	fi

scripts/gdb/linux/symbols.py+2−21

         return "{textaddr} {sections}".format(
             textaddr=textaddr, sections="".join(args))
-    def load_module_symbols(self, module, module_file=None):
+    def load_module_symbols(self, module):
         module_name = module['name'].string()
         module_addr = str(module['mem'][constants.LX_MOD_TEXT]['base']).split()[0]
-        if not module_file:
+        module_file = self._get_module_file(module_name)
-            module_file = self._get_module_file(module_name)
         if not module_file and not self.module_files_updated:
             self._update_module_files()
             module_file = self._get_module_file(module_name)
         else:
             gdb.write("no module object found for '{0}'\n".format(module_name))
-    def load_ko_symbols(self, mod_path):
-        self.loaded_modules = []
-        module_list = modules.module_list()
-        for module in module_list:
-            module_name = module['name'].string()
-            module_pattern = ".*/{0}\.ko(?:.debug)?$".format(
-                module_name.replace("_", r"[_\-]"))
-            if re.match(module_pattern, mod_path) and os.path.exists(mod_path):
-                self.load_module_symbols(module, mod_path)
-                return
-        raise gdb.GdbError("%s is not a valid .ko\n" % mod_path)
     def load_all_symbols(self):
         gdb.write("loading vmlinux\n")
         self.module_files = []
         self.module_files_updated = False
-        argv = gdb.string_to_argv(arg)
-        if len(argv) == 1:
-            self.load_ko_symbols(argv[0])
-            return
         self.load_all_symbols()
         if hasattr(gdb, 'Breakpoint'):

scripts/mod/file2alias.c+1−1

@@ -1604,7 +1604,7 @@ void handle_moddevtable(struct module mod, struct elf_info info, · 1603 unmodified lines
1604	/* First handle the "special" cases */	1604	/* First handle the "special" cases */
1605	if (sym_is(name, namelen, "usb"))	1605	if (sym_is(name, namelen, "usb"))
1606	do_usb_table(symval, sym->st_size, mod);	1606	do_usb_table(symval, sym->st_size, mod);
1607	if (sym_is(name, namelen, "of"))	1607	else if (sym_is(name, namelen, "of"))
1608	do_of_table(symval, sym->st_size, mod);	1608	do_of_table(symval, sym->st_size, mod);
1609	else if (sym_is(name, namelen, "pnp"))	1609	else if (sym_is(name, namelen, "pnp"))
1610	do_pnp_device_entry(symval, sym->st_size, mod);	1610	do_pnp_device_entry(symval, sym->st_size, mod);

scripts/mod/modpost.c+13−2

@@ -1015,9 +1015,20 @@ static int secref_whitelist(const char fromsec, const char fromsym, · 1014 unmodified lines
1015	"*_console")))	1015	"*_console")))
1016	return 0;	1016	return 0;
1017		1017
1018	/* symbols in data sections that may refer to meminit/exit sections */	1018	/* symbols in data sections that may refer to meminit sections */
1019	if (match(fromsec, PATTERNS(DATA_SECTIONS)) &&	1019	if (match(fromsec, PATTERNS(DATA_SECTIONS)) &&
1020	match(tosec, PATTERNS(ALL_XXXINIT_SECTIONS, ALL_EXIT_SECTIONS)) &&	1020	match(tosec, PATTERNS(ALL_XXXINIT_SECTIONS, ALL_XXXEXIT_SECTIONS)) &&
		1021	match(fromsym, PATTERNS("*driver")))
		1022	return 0;
		1023
		1024	/*
		1025	* symbols in data sections must not refer to .exit.*, but there are
		1026	* quite a few offenders, so hide these unless for W=1 builds until
		1027	* these are fixed.
		1028	*/
		1029	if (!extra_warn &&
		1030	match(fromsec, PATTERNS(DATA_SECTIONS)) &&
		1031	match(tosec, PATTERNS(EXIT_SECTIONS)) &&
1021	match(fromsym, PATTERNS("*driver")))	1032	match(fromsym, PATTERNS("*driver")))
1022	return 0;	1033	return 0;
1023		1034

scripts/package/builddeb+0−1

@@ -64,7 +64,6 @@ install_linux_image () { · 63 unmodified lines
64		64
65	${MAKE} -f ${srctree}/Makefile INSTALL_MOD_PATH="${pdir}" modules_install	65	${MAKE} -f ${srctree}/Makefile INSTALL_MOD_PATH="${pdir}" modules_install
66	rm -f "${pdir}/lib/modules/${KERNELRELEASE}/build"	66	rm -f "${pdir}/lib/modules/${KERNELRELEASE}/build"
67	rm -f "${pdir}/lib/modules/${KERNELRELEASE}/source"
68		67
69	# Install the kernel	68	# Install the kernel
70	if [ "${ARCH}" = um ] ; then	69	if [ "${ARCH}" = um ] ; then

scripts/package/kernel.spec+0−3

 cp System.map %{buildroot}/boot/System.map-%{KERNELRELEASE}
 cp .config %{buildroot}/boot/config-%{KERNELRELEASE}
 ln -fns /usr/src/kernels/%{KERNELRELEASE} %{buildroot}/lib/modules/%{KERNELRELEASE}/build
-ln -fns /usr/src/kernels/%{KERNELRELEASE} %{buildroot}/lib/modules/%{KERNELRELEASE}/source
 %if %{with_devel}
 %{make} %{makeflags} run-command KBUILD_RUN_COMMAND='${srctree}/scripts/package/install-extmod-build %{buildroot}/usr/src/kernels/%{KERNELRELEASE}'
 %endif
 %defattr (-, root, root)
 /lib/modules/%{KERNELRELEASE}
 %exclude /lib/modules/%{KERNELRELEASE}/build
-%exclude /lib/modules/%{KERNELRELEASE}/source
 /boot/*
 %files headers
 %defattr (-, root, root)
 /usr/src/kernels/%{KERNELRELEASE}
 /lib/modules/%{KERNELRELEASE}/build
-/lib/modules/%{KERNELRELEASE}/source
 %endif

security/integrity/ima/Kconfig+8−14

 	  to learn more about IMA.
 	  If unsure, say N.
+if IMA
 config IMA_KEXEC
 	bool "Enable carrying the IMA measurement list across a soft boot"
-	depends on IMA && TCG_TPM && HAVE_IMA_KEXEC
+	depends on TCG_TPM && HAVE_IMA_KEXEC
 	default n
 	help
 	   TPM PCRs are only reset on a hard reboot.  In order to validate
 config IMA_MEASURE_PCR_IDX
 	int
-	depends on IMA
 	range 8 14
 	default 10
 	help
 config IMA_LSM_RULES
 	bool
-	depends on IMA && AUDIT && (SECURITY_SELINUX || SECURITY_SMACK || SECURITY_APPARMOR)
+	depends on AUDIT && (SECURITY_SELINUX || SECURITY_SMACK || SECURITY_APPARMOR)
 	default y
 	help
 	  Disabling this option will disregard LSM based policy rules.
 choice
 	prompt "Default template"
 	default IMA_NG_TEMPLATE
-	depends on IMA
 	help
 	  Select the default IMA measurement template.
 config IMA_DEFAULT_TEMPLATE
 	string
-	depends on IMA
 	default "ima-ng" if IMA_NG_TEMPLATE
 	default "ima-sig" if IMA_SIG_TEMPLATE
 choice
 	prompt "Default integrity hash algorithm"
 	default IMA_DEFAULT_HASH_SHA1
-	depends on IMA
 	help
 	   Select the default hash algorithm used for the measurement
 	   list, integrity appraisal and audit log.  The compiled default
 config IMA_DEFAULT_HASH
 	string
-	depends on IMA
 	default "sha1" if IMA_DEFAULT_HASH_SHA1
 	default "sha256" if IMA_DEFAULT_HASH_SHA256
 	default "sha512" if IMA_DEFAULT_HASH_SHA512
 config IMA_WRITE_POLICY
 	bool "Enable multiple writes to the IMA policy"
-	depends on IMA
 	default n
 	help
 	  IMA policy can now be updated multiple times.  The new rules get
 config IMA_READ_POLICY
 	bool "Enable reading back the current IMA policy"
-	depends on IMA
 	default y if IMA_WRITE_POLICY
 	default n if !IMA_WRITE_POLICY
 	help
 config IMA_APPRAISE
 	bool "Appraise integrity measurements"
-	depends on IMA
 	default n
 	help
 	  This option enables local measurement integrity appraisal.
 config IMA_BLACKLIST_KEYRING
 	bool "Create IMA machine owner blacklist keyrings (EXPERIMENTAL)"
 	depends on SYSTEM_TRUSTED_KEYRING
-	depends on IMA_TRUSTED_KEYRING
+	depends on INTEGRITY_TRUSTED_KEYRING
 	default n
 	help
 	   This option creates an IMA blacklist keyring, which contains all
 config IMA_LOAD_X509
 	bool "Load X509 certificate onto the '.ima' trusted keyring"
-	depends on IMA_TRUSTED_KEYRING
+	depends on INTEGRITY_TRUSTED_KEYRING
 	default n
 	help
 	   File signature verification is based on the public keys
 config IMA_MEASURE_ASYMMETRIC_KEYS
 	bool
-	depends on IMA
 	depends on ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y
 	default y
 config IMA_DISABLE_HTABLE
 	bool "Disable htable to allow measurement of duplicate records"
-	depends on IMA
 	default n
 	help
 	   This option disables htable to allow measurement of duplicate records.
+endif

tools/arch/x86/include/asm/msr-index.h+12−0

 #define MSR_IA32_PRED_CMD		0x00000049 /* Prediction Command */
 #define PRED_CMD_IBPB			BIT(0)	   /* Indirect Branch Prediction Barrier */
+#define PRED_CMD_SBPB			BIT(7)	   /* Selective Branch Prediction Barrier */
 #define MSR_PPIN_CTL			0x0000004e
 #define MSR_PPIN			0x0000004f
 						 * Not susceptible to Post-Barrier
 						 * Return Stack Buffer Predictions.
 						 */
+#define ARCH_CAP_GDS_CTRL		BIT(25)	/*
+						 * CPU is vulnerable to Gather
+						 * Data Sampling (GDS) and
+						 * has controls for mitigation.
+						 */
+#define ARCH_CAP_GDS_NO			BIT(26)	/*
+						 * CPU is not vulnerable to Gather
+						 * Data Sampling (GDS).
+						 */
 #define ARCH_CAP_XAPIC_DISABLE		BIT(21)	/*
 						 * IA32_XAPIC_DISABLE_STATUS MSR
 #define RNGDS_MITG_DIS			BIT(0)	/* SRBDS support */
 #define RTM_ALLOW			BIT(1)	/* TSX development mode */
 #define FB_CLEAR_DIS			BIT(3)	/* CPU Fill buffer clear disable */
+#define GDS_MITG_DIS			BIT(4)	/* Disable GDS mitigation */
+#define GDS_MITG_LOCKED			BIT(5)	/* GDS mitigation locked */
 #define MSR_IA32_SYSENTER_CS		0x00000174
 #define MSR_IA32_SYSENTER_ESP		0x00000175

tools/include/uapi/asm-generic/unistd.h+4−1

 #define __NR_cachestat 451
 __SYSCALL(__NR_cachestat, sys_cachestat)
+#define __NR_fchmodat2 452
+__SYSCALL(__NR_fchmodat2, sys_fchmodat2)
 #undef __NR_syscalls
-#define __NR_syscalls 452
+#define __NR_syscalls 453
 /*
  * 32 bit systems traditionally used different

tools/include/uapi/drm/drm.h+69−15

  * Bitfield of supported PRIME sharing capabilities. See &DRM_PRIME_CAP_IMPORT
  * and &DRM_PRIME_CAP_EXPORT.
  *
- * PRIME buffers are exposed as dma-buf file descriptors. See
+ * Starting from kernel version 6.6, both &DRM_PRIME_CAP_IMPORT and
- * Documentation/gpu/drm-mm.rst, section "PRIME Buffer Sharing".
+ * &DRM_PRIME_CAP_EXPORT are always advertised.
+ *
+ * PRIME buffers are exposed as dma-buf file descriptors.
+ * See :ref:`prime_buffer_sharing`.
  */
 #define DRM_CAP_PRIME			0x5
 /**
  *
  * If this bit is set in &DRM_CAP_PRIME, the driver supports importing PRIME
  * buffers via the &DRM_IOCTL_PRIME_FD_TO_HANDLE ioctl.
+ *
+ * Starting from kernel version 6.6, this bit is always set in &DRM_CAP_PRIME.
  */
 #define  DRM_PRIME_CAP_IMPORT		0x1
 /**
  *
  * If this bit is set in &DRM_CAP_PRIME, the driver supports exporting PRIME
  * buffers via the &DRM_IOCTL_PRIME_HANDLE_TO_FD ioctl.
+ *
+ * Starting from kernel version 6.6, this bit is always set in &DRM_CAP_PRIME.
  */
 #define  DRM_PRIME_CAP_EXPORT		0x2
 /**
 /**
  * DRM_CAP_SYNCOBJ
  *
- * If set to 1, the driver supports sync objects. See
+ * If set to 1, the driver supports sync objects. See :ref:`drm_sync_objects`.
- * Documentation/gpu/drm-mm.rst, section "DRM Sync Objects".
  */
 #define DRM_CAP_SYNCOBJ		0x13
 /**
  * DRM_CAP_SYNCOBJ_TIMELINE
  *
  * If set to 1, the driver supports timeline operations on sync objects. See
- * Documentation/gpu/drm-mm.rst, section "DRM Sync Objects".
+ * :ref:`drm_sync_objects`.
  */
 #define DRM_CAP_SYNCOBJ_TIMELINE	0x14
 	__u32 pad;
 };
+/**
+ * struct drm_syncobj_eventfd
+ * @handle: syncobj handle.
+ * @flags: Zero to wait for the point to be signalled, or
+ *         &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE to wait for a fence to be
+ *         available for the point.
+ * @point: syncobj timeline point (set to zero for binary syncobjs).
+ * @fd: Existing eventfd to sent events to.
+ * @pad: Must be zero.
+ *
+ * Register an eventfd to be signalled by a syncobj. The eventfd counter will
+ * be incremented by one.
+ */
+struct drm_syncobj_eventfd {
+	__u32 handle;
+	__u32 flags;
+	__u64 point;
+	__s32 fd;
+	__u32 pad;
+};
 struct drm_syncobj_array {
 	__u64 handles;
  */
 #define DRM_IOCTL_MODE_GETFB2		DRM_IOWR(0xCE, struct drm_mode_fb_cmd2)
+#define DRM_IOCTL_SYNCOBJ_EVENTFD	DRM_IOWR(0xCF, struct drm_syncobj_eventfd)
 /*
  * Device specific ioctls should only be in their respective headers
  * The device specific ioctl range is from 0x40 to 0x9f.
 #define DRM_COMMAND_BASE                0x40
 #define DRM_COMMAND_END			0xA0
-/*
+/**
- * Header for events written back to userspace on the drm fd.  The
+ * struct drm_event - Header for DRM events
- * type defines the type of event, the length specifies the total
+ * @type: event type.
- * length of the event (including the header), and user_data is
+ * @length: total number of payload bytes (including header).
- * typically a 64 bit value passed with the ioctl that triggered the
- * event.  A read on the drm fd will always only return complete
- * events, that is, if for example the read buffer is 100 bytes, and
- * there are two 64 byte events pending, only one will be returned.
  *
- * Event types 0 - 0x7fffffff are generic drm events, 0x80000000 and
+ * This struct is a header for events written back to user-space on the DRM FD.
- * up are chipset specific.
+ * A read on the DRM FD will always only return complete events: e.g. if the
+ * read buffer is 100 bytes large and there are two 64 byte events pending,
+ * only one will be returned.
+ *
+ * Event types 0 - 0x7fffffff are generic DRM events, 0x80000000 and
+ * up are chipset specific. Generic DRM events include &DRM_EVENT_VBLANK,
+ * &DRM_EVENT_FLIP_COMPLETE and &DRM_EVENT_CRTC_SEQUENCE.
  */
 struct drm_event {
 	__u32 type;
 	__u32 length;
 };
+/**
+ * DRM_EVENT_VBLANK - vertical blanking event
+ *
+ * This event is sent in response to &DRM_IOCTL_WAIT_VBLANK with the
+ * &_DRM_VBLANK_EVENT flag set.
+ *
+ * The event payload is a struct drm_event_vblank.
+ */
 #define DRM_EVENT_VBLANK 0x01
+/**
+ * DRM_EVENT_FLIP_COMPLETE - page-flip completion event
+ *
+ * This event is sent in response to an atomic commit or legacy page-flip with
+ * the &DRM_MODE_PAGE_FLIP_EVENT flag set.
+ *
+ * The event payload is a struct drm_event_vblank.
+ */
 #define DRM_EVENT_FLIP_COMPLETE 0x02
+/**
+ * DRM_EVENT_CRTC_SEQUENCE - CRTC sequence event
+ *
+ * This event is sent in response to &DRM_IOCTL_CRTC_QUEUE_SEQUENCE.
+ *
+ * The event payload is a struct drm_event_crtc_sequence.
+ */
 #define DRM_EVENT_CRTC_SEQUENCE	0x03
 struct drm_event_vblank {

tools/include/uapi/linux/seccomp.h+157−0

@@ -0,0 +1,157 @@
	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
	2	#ifndef _UAPI_LINUX_SECCOMP_H
	3	#define _UAPI_LINUX_SECCOMP_H
	4
	5	#include <linux/compiler.h>
	6	#include <linux/types.h>
	7
	8
	9	/* Valid values for seccomp.mode and prctl(PR_SET_SECCOMP, <mode>) */
	10	#define SECCOMP_MODE_DISABLED 0 /* seccomp is not in use. */
	11	#define SECCOMP_MODE_STRICT 1 /* uses hard-coded filter. */
	12	#define SECCOMP_MODE_FILTER 2 /* uses user-supplied filter. */
	13
	14	/* Valid operations for seccomp syscall. */
	15	#define SECCOMP_SET_MODE_STRICT 0
	16	#define SECCOMP_SET_MODE_FILTER 1
	17	#define SECCOMP_GET_ACTION_AVAIL 2
	18	#define SECCOMP_GET_NOTIF_SIZES 3
	19
	20	/* Valid flags for SECCOMP_SET_MODE_FILTER */
	21	#define SECCOMP_FILTER_FLAG_TSYNC (1UL << 0)
	22	#define SECCOMP_FILTER_FLAG_LOG (1UL << 1)
	23	#define SECCOMP_FILTER_FLAG_SPEC_ALLOW (1UL << 2)
	24	#define SECCOMP_FILTER_FLAG_NEW_LISTENER (1UL << 3)
	25	#define SECCOMP_FILTER_FLAG_TSYNC_ESRCH (1UL << 4)
	26	/* Received notifications wait in killable state (only respond to fatal signals) */
	27	#define SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV (1UL << 5)
	28
	29	/*
	30	* All BPF programs must return a 32-bit value.
	31	* The bottom 16-bits are for optional return data.
	32	* The upper 16-bits are ordered from least permissive values to most,
	33	* as a signed value (so 0x8000000 is negative).
	34	*
	35	* The ordering ensures that a min_t() over composed return values always
	36	* selects the least permissive choice.
	37	*/
	38	#define SECCOMP_RET_KILL_PROCESS 0x80000000U /* kill the process */
	39	#define SECCOMP_RET_KILL_THREAD 0x00000000U /* kill the thread */
	40	#define SECCOMP_RET_KILL SECCOMP_RET_KILL_THREAD
	41	#define SECCOMP_RET_TRAP 0x00030000U /* disallow and force a SIGSYS */
	42	#define SECCOMP_RET_ERRNO 0x00050000U /* returns an errno */
	43	#define SECCOMP_RET_USER_NOTIF 0x7fc00000U /* notifies userspace */
	44	#define SECCOMP_RET_TRACE 0x7ff00000U /* pass to a tracer or disallow */
	45	#define SECCOMP_RET_LOG 0x7ffc0000U /* allow after logging */
	46	#define SECCOMP_RET_ALLOW 0x7fff0000U /* allow */
	47
	48	/* Masks for the return value sections. */
	49	#define SECCOMP_RET_ACTION_FULL 0xffff0000U
	50	#define SECCOMP_RET_ACTION 0x7fff0000U
	51	#define SECCOMP_RET_DATA 0x0000ffffU
	52
	53	/**
	54	* struct seccomp_data - the format the BPF program executes over.
	55	* @nr: the system call number
	56	* @arch: indicates system call convention as an AUDIT_ARCH_* value
	57	* as defined in <linux/audit.h>.
	58	* @instruction_pointer: at the time of the system call.
	59	* @args: up to 6 system call arguments always stored as 64-bit values
	60	* regardless of the architecture.
	61	*/
	62	struct seccomp_data {
	63	int nr;
	64	__u32 arch;
	65	__u64 instruction_pointer;
	66	__u64 args[6];
	67	};
	68
	69	struct seccomp_notif_sizes {
	70	__u16 seccomp_notif;
	71	__u16 seccomp_notif_resp;
	72	__u16 seccomp_data;
	73	};
	74
	75	struct seccomp_notif {
	76	__u64 id;
	77	__u32 pid;
	78	__u32 flags;
	79	struct seccomp_data data;
	80	};
	81
	82	/*
	83	* Valid flags for struct seccomp_notif_resp
	84	*
	85	* Note, the SECCOMP_USER_NOTIF_FLAG_CONTINUE flag must be used with caution!
	86	* If set by the process supervising the syscalls of another process the
	87	* syscall will continue. This is problematic because of an inherent TOCTOU.
	88	* An attacker can exploit the time while the supervised process is waiting on
	89	* a response from the supervising process to rewrite syscall arguments which
	90	* are passed as pointers of the intercepted syscall.
	91	* It should be absolutely clear that this means that the seccomp notifier
	92	* _cannot_ be used to implement a security policy! It should only ever be used
	93	* in scenarios where a more privileged process supervises the syscalls of a
	94	* lesser privileged process to get around kernel-enforced security
	95	* restrictions when the privileged process deems this safe. In other words,
	96	* in order to continue a syscall the supervising process should be sure that
	97	* another security mechanism or the kernel itself will sufficiently block
	98	* syscalls if arguments are rewritten to something unsafe.
	99	*
	100	* Similar precautions should be applied when stacking SECCOMP_RET_USER_NOTIF
	101	* or SECCOMP_RET_TRACE. For SECCOMP_RET_USER_NOTIF filters acting on the
	102	* same syscall, the most recently added filter takes precedence. This means
	103	* that the new SECCOMP_RET_USER_NOTIF filter can override any
	104	* SECCOMP_IOCTL_NOTIF_SEND from earlier filters, essentially allowing all
	105	* such filtered syscalls to be executed by sending the response
	106	* SECCOMP_USER_NOTIF_FLAG_CONTINUE. Note that SECCOMP_RET_TRACE can equally
	107	* be overriden by SECCOMP_USER_NOTIF_FLAG_CONTINUE.
	108	*/
	109	#define SECCOMP_USER_NOTIF_FLAG_CONTINUE (1UL << 0)
	110
	111	struct seccomp_notif_resp {
	112	__u64 id;
	113	__s64 val;
	114	__s32 error;
	115	__u32 flags;
	116	};
	117
	118	#define SECCOMP_USER_NOTIF_FD_SYNC_WAKE_UP (1UL << 0)
	119
	120	/* valid flags for seccomp_notif_addfd */
	121	#define SECCOMP_ADDFD_FLAG_SETFD (1UL << 0) /* Specify remote fd */
	122	#define SECCOMP_ADDFD_FLAG_SEND (1UL << 1) /* Addfd and return it, atomically */
	123
	124	/**
	125	* struct seccomp_notif_addfd
	126	* @id: The ID of the seccomp notification
	127	* @flags: SECCOMP_ADDFD_FLAG_*
	128	* @srcfd: The local fd number
	129	* @newfd: Optional remote FD number if SETFD option is set, otherwise 0.
	130	* @newfd_flags: The O_* flags the remote FD should have applied
	131	*/
	132	struct seccomp_notif_addfd {
	133	__u64 id;
	134	__u32 flags;
	135	__u32 srcfd;
	136	__u32 newfd;
	137	__u32 newfd_flags;
	138	};
	139
	140	#define SECCOMP_IOC_MAGIC '!'
	141	#define SECCOMP_IO(nr) _IO(SECCOMP_IOC_MAGIC, nr)
	142	#define SECCOMP_IOR(nr, type) _IOR(SECCOMP_IOC_MAGIC, nr, type)
	143	#define SECCOMP_IOW(nr, type) _IOW(SECCOMP_IOC_MAGIC, nr, type)
	144	#define SECCOMP_IOWR(nr, type) _IOWR(SECCOMP_IOC_MAGIC, nr, type)
	145
	146	/* Flags for seccomp notification fd ioctl. */
	147	#define SECCOMP_IOCTL_NOTIF_RECV SECCOMP_IOWR(0, struct seccomp_notif)
	148	#define SECCOMP_IOCTL_NOTIF_SEND SECCOMP_IOWR(1, \
	149	struct seccomp_notif_resp)
	150	#define SECCOMP_IOCTL_NOTIF_ID_VALID SECCOMP_IOW(2, __u64)
	151	/* On success, the return value is the remote process's added fd number */
	152	#define SECCOMP_IOCTL_NOTIF_ADDFD SECCOMP_IOW(3, \
	153	struct seccomp_notif_addfd)
	154
	155	#define SECCOMP_IOCTL_NOTIF_SET_FLAGS SECCOMP_IOW(4, __u64)
	156
	157	#endif /* _UAPI_LINUX_SECCOMP_H */

tools/perf/arch/mips/entry/syscalls/syscall_n64.tbl+1−0

@@ -366,3 +366,4 @@ · 365 unmodified lines
366	449 n64 futex_waitv sys_futex_waitv	366	449 n64 futex_waitv sys_futex_waitv
367	450 common set_mempolicy_home_node sys_set_mempolicy_home_node	367	450 common set_mempolicy_home_node sys_set_mempolicy_home_node
368	451 n64 cachestat sys_cachestat	368	451 n64 cachestat sys_cachestat
		369	452 n64 fchmodat2 sys_fchmodat2

tools/perf/arch/powerpc/entry/syscalls/syscall.tbl+1−0

@@ -538,3 +538,4 @@ · 537 unmodified lines
538	449 common futex_waitv sys_futex_waitv	538	449 common futex_waitv sys_futex_waitv
539	450 nospu set_mempolicy_home_node sys_set_mempolicy_home_node	539	450 nospu set_mempolicy_home_node sys_set_mempolicy_home_node
540	451 common cachestat sys_cachestat	540	451 common cachestat sys_cachestat
		541	452 common fchmodat2 sys_fchmodat2

tools/perf/arch/s390/entry/syscalls/syscall.tbl+1−0

@@ -454,3 +454,4 @@ · 453 unmodified lines
454	449 common futex_waitv sys_futex_waitv sys_futex_waitv	454	449 common futex_waitv sys_futex_waitv sys_futex_waitv
455	450 common set_mempolicy_home_node sys_set_mempolicy_home_node sys_set_mempolicy_home_node	455	450 common set_mempolicy_home_node sys_set_mempolicy_home_node sys_set_mempolicy_home_node
456	451 common cachestat sys_cachestat sys_cachestat	456	451 common cachestat sys_cachestat sys_cachestat
		457	452 common fchmodat2 sys_fchmodat2 sys_fchmodat2

tools/perf/arch/x86/entry/syscalls/syscall_64.tbl+2−0

@@ -373,6 +373,8 @@ · 372 unmodified lines
373	449 common futex_waitv sys_futex_waitv	373	449 common futex_waitv sys_futex_waitv
374	450 common set_mempolicy_home_node sys_set_mempolicy_home_node	374	450 common set_mempolicy_home_node sys_set_mempolicy_home_node
375	451 common cachestat sys_cachestat	375	451 common cachestat sys_cachestat
		376	452 common fchmodat2 sys_fchmodat2
		377	453 64 map_shadow_stack sys_map_shadow_stack
376		378
377	#	379	#
378	# Due to a historical design error, certain syscalls are numbered differently	380	# Due to a historical design error, certain syscalls are numbered differently

tools/perf/bench/sched-seccomp-notify.c+1−1

@@ -9,7 +9,7 @@ · 8 unmodified lines
9	#include <sys/syscall.h>	9	#include <sys/syscall.h>
10	#include <sys/ioctl.h>	10	#include <sys/ioctl.h>
11	#include <linux/time64.h>	11	#include <linux/time64.h>
12	#include <linux/seccomp.h>	12	#include <uapi/linux/seccomp.h>
13	#include <sys/prctl.h>	13	#include <sys/prctl.h>
14		14
15	#include <unistd.h>	15	#include <unistd.h>

tools/perf/check-headers.sh+1−0

@@ -21,6 +21,7 @@ FILES=( · 20 unmodified lines
21	"include/uapi/linux/perf_event.h"	21	"include/uapi/linux/perf_event.h"
22	"include/uapi/linux/prctl.h"	22	"include/uapi/linux/prctl.h"
23	"include/uapi/linux/sched.h"	23	"include/uapi/linux/sched.h"
		24	"include/uapi/linux/seccomp.h"
24	"include/uapi/linux/stat.h"	25	"include/uapi/linux/stat.h"
25	"include/uapi/linux/usbdevice_fs.h"	26	"include/uapi/linux/usbdevice_fs.h"
26	"include/uapi/linux/vhost.h"	27	"include/uapi/linux/vhost.h"

tools/perf/pmu-events/jevents.py+1−1

@@ -991,7 +991,7 @@ const struct pmu_events_table perf_pmu__find_events_table(struct perf_pmu pmu) · 990 unmodified lines
991	}	991	}
992	}	992	}
993	free(cpuid);	993	free(cpuid);
994	if (!pmu)	994	if (!pmu \|\| !table)
995	return table;	995	return table;
996		996
997	for (i = 0; i < table->num_pmus; i++) {	997	for (i = 0; i < table->num_pmus; i++) {

tools/perf/pmu-events/metric.py+2−2

@@ -413,10 +413,10 @@ def has_event(event: Event) -> Function: · 412 unmodified lines
413	# pylint: disable=invalid-name	413	# pylint: disable=invalid-name
414	return Function('has_event', event)	414	return Function('has_event', event)
415		415
416	def strcmp_cpuid_str(event: str) -> Function:	416	def strcmp_cpuid_str(cpuid: Event) -> Function:
417	# pylint: disable=redefined-builtin	417	# pylint: disable=redefined-builtin
418	# pylint: disable=invalid-name	418	# pylint: disable=invalid-name
419	return Function('strcmp_cpuid_str', event)	419	return Function('strcmp_cpuid_str', cpuid)
420		420
421	class Metric:	421	class Metric:
422	"""An individual metric that will specifiable on the perf command line."""	422	"""An individual metric that will specifiable on the perf command line."""

tools/perf/util/bpf-prologue.c+0−508

@@ -1,508 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* bpf-prologue.c
4	*
5	* Copyright (C) 2015 He Kuang <hekuang@huawei.com>
6	* Copyright (C) 2015 Wang Nan <wangnan0@huawei.com>
7	* Copyright (C) 2015 Huawei Inc.
8	*/
9
10	#include <bpf/libbpf.h>
11	#include "debug.h"
12	#include "bpf-loader.h"
13	#include "bpf-prologue.h"
14	#include "probe-finder.h"
15	#include <errno.h>
16	#include <stdlib.h>
17	#include <dwarf-regs.h>
18	#include <linux/filter.h>
19
20	#define BPF_REG_SIZE 8
21
22	#define JMP_TO_ERROR_CODE -1
23	#define JMP_TO_SUCCESS_CODE -2
24	#define JMP_TO_USER_CODE -3
25
26	struct bpf_insn_pos {
27	struct bpf_insn *begin;
28	struct bpf_insn *end;
29	struct bpf_insn *pos;
30	};
31
32	static inline int
33	pos_get_cnt(struct bpf_insn_pos *pos)
34	{
35	return pos->pos - pos->begin;
36	}
37
38	static int
39	append_insn(struct bpf_insn new_insn, struct bpf_insn_pos *pos)
40	{
41	if (!pos->pos)
42	return -BPF_LOADER_ERRNO__PROLOGUE2BIG;
43
44	if (pos->pos + 1 >= pos->end) {
45	pr_err("bpf prologue: prologue too long\n");
46	pos->pos = NULL;
47	return -BPF_LOADER_ERRNO__PROLOGUE2BIG;
48	}
49
50	*(pos->pos)++ = new_insn;
51	return 0;
52	}
53
54	static int
55	check_pos(struct bpf_insn_pos *pos)
56	{
57	if (!pos->pos \|\| pos->pos >= pos->end)
58	return -BPF_LOADER_ERRNO__PROLOGUE2BIG;
59	return 0;
60	}
61
62	/*
63	* Convert type string (u8/u16/u32/u64/s8/s16/s32/s64 ..., see
64	* Documentation/trace/kprobetrace.rst) to size field of BPF_LDX_MEM
65	* instruction (BPF_{B,H,W,DW}).
66	*/
67	static int
68	argtype_to_ldx_size(const char *type)
69	{
70	int arg_size = type ? atoi(&type[1]) : 64;
71
72	switch (arg_size) {
73	case 8:
74	return BPF_B;
75	case 16:
76	return BPF_H;
77	case 32:
78	return BPF_W;
79	case 64:
80	default:
81	return BPF_DW;
82	}
83	}
84
85	static const char *
86	insn_sz_to_str(int insn_sz)
87	{
88	switch (insn_sz) {
89	case BPF_B:
90	return "BPF_B";
91	case BPF_H:
92	return "BPF_H";
93	case BPF_W:
94	return "BPF_W";
95	case BPF_DW:
96	return "BPF_DW";
97	default:
98	return "UNKNOWN";
99	}
100	}
101
102	/* Give it a shorter name */
103	#define ins(i, p) append_insn((i), (p))
104
105	/*
106	* Give a register name (in 'reg'), generate instruction to
107	* load register into an eBPF register rd:
108	* 'ldd target_reg, offset(ctx_reg)', where:
109	* ctx_reg is pre initialized to pointer of 'struct pt_regs'.
110	*/
111	static int
112	gen_ldx_reg_from_ctx(struct bpf_insn_pos *pos, int ctx_reg,
113	const char *reg, int target_reg)
114	{
115	int offset = regs_query_register_offset(reg);
116
117	if (offset < 0) {
118	pr_err("bpf: prologue: failed to get register %s\n",
119	reg);
120	return offset;
121	}
122	ins(BPF_LDX_MEM(BPF_DW, target_reg, ctx_reg, offset), pos);
123
124	return check_pos(pos);
125	}
126
127	/*
128	* Generate a BPF_FUNC_probe_read function call.
129	*
130	* src_base_addr_reg is a register holding base address,
131	* dst_addr_reg is a register holding dest address (on stack),
132	* result is:
133	*
134	* [dst_addr_reg] = ([src_base_addr_reg] + offset)
135	*
136	* Arguments of BPF_FUNC_probe_read:
137	* ARG1: ptr to stack (dest)
138	* ARG2: size (8)
139	* ARG3: unsafe ptr (src)
140	*/
141	static int
142	gen_read_mem(struct bpf_insn_pos *pos,
143	int src_base_addr_reg,
144	int dst_addr_reg,
145	long offset,
146	int probeid)
147	{
148	/* mov arg3, src_base_addr_reg */
149	if (src_base_addr_reg != BPF_REG_ARG3)
150	ins(BPF_MOV64_REG(BPF_REG_ARG3, src_base_addr_reg), pos);
151	/* add arg3, #offset */
152	if (offset)
153	ins(BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG3, offset), pos);
154
155	/* mov arg2, #reg_size */
156	ins(BPF_ALU64_IMM(BPF_MOV, BPF_REG_ARG2, BPF_REG_SIZE), pos);
157
158	/* mov arg1, dst_addr_reg */
159	if (dst_addr_reg != BPF_REG_ARG1)
160	ins(BPF_MOV64_REG(BPF_REG_ARG1, dst_addr_reg), pos);
161
162	/* Call probe_read */
163	ins(BPF_EMIT_CALL(probeid), pos);
164	/*
165	* Error processing: if read fail, goto error code,
166	* will be relocated. Target should be the start of
167	* error processing code.
168	*/
169	ins(BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, JMP_TO_ERROR_CODE),
170	pos);
171
172	return check_pos(pos);
173	}
174
175	/*
176	* Each arg should be bare register. Fetch and save them into argument
177	* registers (r3 - r5).
178	*
179	* BPF_REG_1 should have been initialized with pointer to
180	* 'struct pt_regs'.
181	*/
182	static int
183	gen_prologue_fastpath(struct bpf_insn_pos *pos,
184	struct probe_trace_arg *args, int nargs)
185	{
186	int i, err = 0;
187
188	for (i = 0; i < nargs; i++) {
189	err = gen_ldx_reg_from_ctx(pos, BPF_REG_1, args[i].value,
190	BPF_PROLOGUE_START_ARG_REG + i);
191	if (err)
192	goto errout;
193	}
194
195	return check_pos(pos);
196	errout:
197	return err;
198	}
199
200	/*
201	* Slow path:
202	* At least one argument has the form of 'offset($rx)'.
203	*
204	* Following code first stores them into stack, then loads all of then
205	* to r2 - r5.
206	* Before final loading, the final result should be:
207	*
208	* low address
209	* BPF_REG_FP - 24 ARG3
210	* BPF_REG_FP - 16 ARG2
211	* BPF_REG_FP - 8 ARG1
212	* BPF_REG_FP
213	* high address
214	*
215	* For each argument (described as: offn(...off2(off1(reg)))),
216	* generates following code:
217	*
218	* r7 <- fp
219	* r7 <- r7 - stack_offset // Ideal code should initialize r7 using
220	* // fp before generating args. However,
221	* // eBPF won't regard r7 as stack pointer
222	* // if it is generated by minus 8 from
223	* // another stack pointer except fp.
224	* // This is why we have to set r7
225	* // to fp for each variable.
226	* r3 <- value of 'reg'-> generated using gen_ldx_reg_from_ctx()
227	* (r7) <- r3 // skip following instructions for bare reg
228	* r3 <- r3 + off1 . // skip if off1 == 0
229	* r2 <- 8 \
230	* r1 <- r7 \|-> generated by gen_read_mem()
231	* call probe_read /
232	* jnei r0, 0, err ./
233	* r3 <- (r7)
234	* r3 <- r3 + off2 . // skip if off2 == 0
235	* r2 <- 8 \ // r2 may be broken by probe_read, so set again
236	* r1 <- r7 \|-> generated by gen_read_mem()
237	* call probe_read /
238	* jnei r0, 0, err ./
239	* ...
240	*/
241	static int
242	gen_prologue_slowpath(struct bpf_insn_pos *pos,
243	struct probe_trace_arg *args, int nargs)
244	{
245	int err, i, probeid;
246
247	for (i = 0; i < nargs; i++) {
248	struct probe_trace_arg *arg = &args[i];
249	const char *reg = arg->value;
250	struct probe_trace_arg_ref *ref = NULL;
251	int stack_offset = (i + 1) * -8;
252
253	pr_debug("prologue: fetch arg %d, base reg is %s\n",
254	i, reg);
255
256	/* value of base register is stored into ARG3 */
257	err = gen_ldx_reg_from_ctx(pos, BPF_REG_CTX, reg,
258	BPF_REG_ARG3);
259	if (err) {
260	pr_err("prologue: failed to get offset of register %s\n",
261	reg);
262	goto errout;
263	}
264
265	/* Make r7 the stack pointer. */
266	ins(BPF_MOV64_REG(BPF_REG_7, BPF_REG_FP), pos);
267	/* r7 += -8 */
268	ins(BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, stack_offset), pos);
269	/*
270	* Store r3 (base register) onto stack
271	* Ensure fp[offset] is set.
272	* fp is the only valid base register when storing
273	* into stack. We are not allowed to use r7 as base
274	* register here.
275	*/
276	ins(BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_ARG3,
277	stack_offset), pos);
278
279	ref = arg->ref;
280	probeid = BPF_FUNC_probe_read_kernel;
281	while (ref) {
282	pr_debug("prologue: arg %d: offset %ld\n",
283	i, ref->offset);
284
285	if (ref->user_access)
286	probeid = BPF_FUNC_probe_read_user;
287
288	err = gen_read_mem(pos, BPF_REG_3, BPF_REG_7,
289	ref->offset, probeid);
290	if (err) {
291	pr_err("prologue: failed to generate probe_read function call\n");
292	goto errout;
293	}
294
295	ref = ref->next;
296	/*
297	* Load previous result into ARG3. Use
298	* BPF_REG_FP instead of r7 because verifier
299	* allows FP based addressing only.
300	*/
301	if (ref)
302	ins(BPF_LDX_MEM(BPF_DW, BPF_REG_ARG3,
303	BPF_REG_FP, stack_offset), pos);
304	}
305	}
306
307	/* Final pass: read to registers */
308	for (i = 0; i < nargs; i++) {
309	int insn_sz = (args[i].ref) ? argtype_to_ldx_size(args[i].type) : BPF_DW;
310
311	pr_debug("prologue: load arg %d, insn_sz is %s\n",
312	i, insn_sz_to_str(insn_sz));
313	ins(BPF_LDX_MEM(insn_sz, BPF_PROLOGUE_START_ARG_REG + i,
314	BPF_REG_FP, -BPF_REG_SIZE * (i + 1)), pos);
315	}
316
317	ins(BPF_JMP_IMM(BPF_JA, BPF_REG_0, 0, JMP_TO_SUCCESS_CODE), pos);
318
319	return check_pos(pos);
320	errout:
321	return err;
322	}
323
324	static int
325	prologue_relocate(struct bpf_insn_pos pos, struct bpf_insn error_code,
326	struct bpf_insn success_code, struct bpf_insn user_code)
327	{
328	struct bpf_insn *insn;
329
330	if (check_pos(pos))
331	return -BPF_LOADER_ERRNO__PROLOGUE2BIG;
332
333	for (insn = pos->begin; insn < pos->pos; insn++) {
334	struct bpf_insn *target;
335	u8 class = BPF_CLASS(insn->code);
336	u8 opcode;
337
338	if (class != BPF_JMP)
339	continue;
340	opcode = BPF_OP(insn->code);
341	if (opcode == BPF_CALL)
342	continue;
343
344	switch (insn->off) {
345	case JMP_TO_ERROR_CODE:
346	target = error_code;
347	break;
348	case JMP_TO_SUCCESS_CODE:
349	target = success_code;
350	break;
351	case JMP_TO_USER_CODE:
352	target = user_code;
353	break;
354	default:
355	pr_err("bpf prologue: internal error: relocation failed\n");
356	return -BPF_LOADER_ERRNO__PROLOGUE;
357	}
358
359	insn->off = target - (insn + 1);
360	}
361	return 0;
362	}
363
364	int bpf__gen_prologue(struct probe_trace_arg *args, int nargs,
365	struct bpf_insn new_prog, size_t new_cnt,
366	size_t cnt_space)
367	{
368	struct bpf_insn *success_code = NULL;
369	struct bpf_insn *error_code = NULL;
370	struct bpf_insn *user_code = NULL;
371	struct bpf_insn_pos pos;
372	bool fastpath = true;
373	int err = 0, i;
374
375	if (!new_prog \|\| !new_cnt)
376	return -EINVAL;
377
378	if (cnt_space > BPF_MAXINSNS)
379	cnt_space = BPF_MAXINSNS;
380
381	pos.begin = new_prog;
382	pos.end = new_prog + cnt_space;
383	pos.pos = new_prog;
384
385	if (!nargs) {
386	ins(BPF_ALU64_IMM(BPF_MOV, BPF_PROLOGUE_FETCH_RESULT_REG, 0),
387	&pos);
388
389	if (check_pos(&pos))
390	goto errout;
391
392	*new_cnt = pos_get_cnt(&pos);
393	return 0;
394	}
395
396	if (nargs > BPF_PROLOGUE_MAX_ARGS) {
397	pr_warning("bpf: prologue: %d arguments are dropped\n",
398	nargs - BPF_PROLOGUE_MAX_ARGS);
399	nargs = BPF_PROLOGUE_MAX_ARGS;
400	}
401
402	/* First pass: validation */
403	for (i = 0; i < nargs; i++) {
404	struct probe_trace_arg_ref *ref = args[i].ref;
405
406	if (args[i].value[0] == '@') {
407	/* TODO: fetch global variable */
408	pr_err("bpf: prologue: global %s%+ld not support\n",
409	args[i].value, ref ? ref->offset : 0);
410	return -ENOTSUP;
411	}
412
413	while (ref) {
414	/* fastpath is true if all args has ref == NULL */
415	fastpath = false;
416
417	/*
418	* Instruction encodes immediate value using
419	* s32, ref->offset is long. On systems which
420	* can't fill long in s32, refuse to process if
421	* ref->offset too large (or small).
422	*/
423	#ifdef __LP64__
424	#define OFFSET_MAX ((1LL << 31) - 1)
425	#define OFFSET_MIN ((1LL << 31) * -1)
426	if (ref->offset > OFFSET_MAX \|\|
427	ref->offset < OFFSET_MIN) {
428	pr_err("bpf: prologue: offset out of bound: %ld\n",
429	ref->offset);
430	return -BPF_LOADER_ERRNO__PROLOGUEOOB;
431	}
432	#endif
433	ref = ref->next;
434	}
435	}
436	pr_debug("prologue: pass validation\n");
437
438	if (fastpath) {
439	/* If all variables are registers... */
440	pr_debug("prologue: fast path\n");
441	err = gen_prologue_fastpath(&pos, args, nargs);
442	if (err)
443	goto errout;
444	} else {
445	pr_debug("prologue: slow path\n");
446
447	/* Initialization: move ctx to a callee saved register. */
448	ins(BPF_MOV64_REG(BPF_REG_CTX, BPF_REG_ARG1), &pos);
449
450	err = gen_prologue_slowpath(&pos, args, nargs);
451	if (err)
452	goto errout;
453	/*
454	* start of ERROR_CODE (only slow pass needs error code)
455	* mov r2 <- 1 // r2 is error number
456	* mov r3 <- 0 // r3, r4... should be touched or
457	* // verifier would complain
458	* mov r4 <- 0
459	* ...
460	* goto usercode
461	*/
462	error_code = pos.pos;
463	ins(BPF_ALU64_IMM(BPF_MOV, BPF_PROLOGUE_FETCH_RESULT_REG, 1),
464	&pos);
465
466	for (i = 0; i < nargs; i++)
467	ins(BPF_ALU64_IMM(BPF_MOV,
468	BPF_PROLOGUE_START_ARG_REG + i,
469	0),
470	&pos);
471	ins(BPF_JMP_IMM(BPF_JA, BPF_REG_0, 0, JMP_TO_USER_CODE),
472	&pos);
473	}
474
475	/*
476	* start of SUCCESS_CODE:
477	* mov r2 <- 0
478	* goto usercode // skip
479	*/
480	success_code = pos.pos;
481	ins(BPF_ALU64_IMM(BPF_MOV, BPF_PROLOGUE_FETCH_RESULT_REG, 0), &pos);
482
483	/*
484	* start of USER_CODE:
485	* Restore ctx to r1
486	*/
487	user_code = pos.pos;
488	if (!fastpath) {
489	/*
490	* Only slow path needs restoring of ctx. In fast path,
491	* register are loaded directly from r1.
492	*/
493	ins(BPF_MOV64_REG(BPF_REG_ARG1, BPF_REG_CTX), &pos);
494	err = prologue_relocate(&pos, error_code, success_code,
495	user_code);
496	if (err)
497	goto errout;
498	}
499
500	err = check_pos(&pos);
501	if (err)
502	goto errout;
503
504	*new_cnt = pos_get_cnt(&pos);
505	return 0;
506	errout:
507	return err;
508	}

tools/perf/util/bpf_skel/augmented_raw_syscalls.bpf.c+2−0

 #define MAX_CPUS  4096
 // FIXME: These should come from system headers
+#ifndef bool
 typedef char bool;
+#endif
 typedef int pid_t;
 typedef long long int __s64;
 typedef __s64 time64_t;

tools/perf/util/hashmap.h+0−10

@@ -80,16 +80,6 @@ struct hashmap { · 79 unmodified lines
80	size_t sz;	80	size_t sz;
81	};	81	};
82		82
83	#define HASHMAP_INIT(hash_fn, equal_fn, ctx) { \
84	.hash_fn = (hash_fn), \
85	.equal_fn = (equal_fn), \
86	.ctx = (ctx), \
87	.buckets = NULL, \
88	.cap = 0, \
89	.cap_bits = 0, \
90	.sz = 0, \
91	}
92
93	void hashmap__init(struct hashmap *map, hashmap_hash_fn hash_fn,	83	void hashmap__init(struct hashmap *map, hashmap_hash_fn hash_fn,
94	hashmap_equal_fn equal_fn, void *ctx);	84	hashmap_equal_fn equal_fn, void *ctx);
95	struct hashmap *hashmap__new(hashmap_hash_fn hash_fn,	85	struct hashmap *hashmap__new(hashmap_hash_fn hash_fn,

tools/perf/util/pmu.c+1−1

@@ -520,7 +520,7 @@ static int perf_pmu__new_alias(struct perf_pmu pmu, const char name, · 519 unmodified lines
520	pmu_name = pe->pmu;	520	pmu_name = pe->pmu;
521	}	521	}
522		522
523	alias = malloc(sizeof(*alias));	523	alias = zalloc(sizeof(*alias));
524	if (!alias)	524	if (!alias)
525	return -ENOMEM;	525	return -ENOMEM;
526		526

tools/testing/selftests/Makefile+1−1

@@ -92,7 +92,7 @@ endif · 91 unmodified lines
92	TARGETS += tmpfs	92	TARGETS += tmpfs
93	TARGETS += tpm2	93	TARGETS += tpm2
94	TARGETS += tty	94	TARGETS += tty
95	TARGETS += uevents	95	TARGETS += uevent
96	TARGETS += user	96	TARGETS += user
97	TARGETS += user_events	97	TARGETS += user_events
98	TARGETS += vDSO	98	TARGETS += vDSO

tools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c+2−0

@@ -185,6 +185,8 @@ static void test_cubic(void) · 184 unmodified lines
185		185
186	do_test("bpf_cubic", NULL);	186	do_test("bpf_cubic", NULL);
187		187
		188	ASSERT_EQ(cubic_skel->bss->bpf_cubic_acked_called, 1, "pkts_acked called");
		189
188	bpf_link__destroy(link);	190	bpf_link__destroy(link);
189	bpf_cubic__destroy(cubic_skel);	191	bpf_cubic__destroy(cubic_skel);
190	}	192	}

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c+51−0

@@ -475,6 +475,55 @@ out: · 474 unmodified lines
475	test_sockmap_drop_prog__destroy(drop);	475	test_sockmap_drop_prog__destroy(drop);
476	}	476	}
477		477
		478	static void test_sockmap_skb_verdict_peek(void)
		479	{
		480	int err, map, verdict, s, c1, p1, zero = 0, sent, recvd, avail;
		481	struct test_sockmap_pass_prog *pass;
		482	char snd[256] = "0123456789";
		483	char rcv[256] = "0";
		484
		485	pass = test_sockmap_pass_prog__open_and_load();
		486	if (!ASSERT_OK_PTR(pass, "open_and_load"))
		487	return;
		488	verdict = bpf_program__fd(pass->progs.prog_skb_verdict);
		489	map = bpf_map__fd(pass->maps.sock_map_rx);
		490
		491	err = bpf_prog_attach(verdict, map, BPF_SK_SKB_STREAM_VERDICT, 0);
		492	if (!ASSERT_OK(err, "bpf_prog_attach"))
		493	goto out;
		494
		495	s = socket_loopback(AF_INET, SOCK_STREAM);
		496	if (!ASSERT_GT(s, -1, "socket_loopback(s)"))
		497	goto out;
		498
		499	err = create_pair(s, AF_INET, SOCK_STREAM, &c1, &p1);
		500	if (!ASSERT_OK(err, "create_pairs(s)"))
		501	goto out;
		502
		503	err = bpf_map_update_elem(map, &zero, &c1, BPF_NOEXIST);
		504	if (!ASSERT_OK(err, "bpf_map_update_elem(c1)"))
		505	goto out_close;
		506
		507	sent = xsend(p1, snd, sizeof(snd), 0);
		508	ASSERT_EQ(sent, sizeof(snd), "xsend(p1)");
		509	recvd = recv(c1, rcv, sizeof(rcv), MSG_PEEK);
		510	ASSERT_EQ(recvd, sizeof(rcv), "recv(c1)");
		511	err = ioctl(c1, FIONREAD, &avail);
		512	ASSERT_OK(err, "ioctl(FIONREAD) error");
		513	ASSERT_EQ(avail, sizeof(snd), "after peek ioctl(FIONREAD)");
		514	recvd = recv(c1, rcv, sizeof(rcv), 0);
		515	ASSERT_EQ(recvd, sizeof(rcv), "recv(p0)");
		516	err = ioctl(c1, FIONREAD, &avail);
		517	ASSERT_OK(err, "ioctl(FIONREAD) error");
		518	ASSERT_EQ(avail, 0, "after read ioctl(FIONREAD)");
		519
		520	out_close:
		521	close(c1);
		522	close(p1);
		523	out:
		524	test_sockmap_pass_prog__destroy(pass);
		525	}
		526
478	void test_sockmap_basic(void)	527	void test_sockmap_basic(void)
479	{	528	{
480	if (test__start_subtest("sockmap create_update_free"))	529	if (test__start_subtest("sockmap create_update_free"))
@@ -515,4 +564,6 @@ void test_sockmap_basic(void) · 34 unmodified lines
515	test_sockmap_skb_verdict_fionread(true);	564	test_sockmap_skb_verdict_fionread(true);
516	if (test__start_subtest("sockmap skb_verdict fionread on drop"))	565	if (test__start_subtest("sockmap skb_verdict fionread on drop"))
517	test_sockmap_skb_verdict_fionread(false);	566	test_sockmap_skb_verdict_fionread(false);
		567	if (test__start_subtest("sockmap skb_verdict msg_f_peek"))
		568	test_sockmap_skb_verdict_peek();
518	}	569	}

tools/testing/selftests/bpf/prog_tests/tc_opts.c+84−0

@@ -2378,3 +2378,87 @@ void serial_test_tc_opts_chain_mixed(void) · 2377 unmodified lines
2378	test_tc_chain_mixed(BPF_TCX_INGRESS);	2378	test_tc_chain_mixed(BPF_TCX_INGRESS);
2379	test_tc_chain_mixed(BPF_TCX_EGRESS);	2379	test_tc_chain_mixed(BPF_TCX_EGRESS);
2380	}	2380	}
		2381
		2382	static int generate_dummy_prog(void)
		2383	{
		2384	const struct bpf_insn prog_insns[] = {
		2385	BPF_MOV64_IMM(BPF_REG_0, 0),
		2386	BPF_EXIT_INSN(),
		2387	};
		2388	const size_t prog_insn_cnt = sizeof(prog_insns) / sizeof(struct bpf_insn);
		2389	LIBBPF_OPTS(bpf_prog_load_opts, opts);
		2390	const size_t log_buf_sz = 256;
		2391	char *log_buf;
		2392	int fd = -1;
		2393
		2394	log_buf = malloc(log_buf_sz);
		2395	if (!ASSERT_OK_PTR(log_buf, "log_buf_alloc"))
		2396	return fd;
		2397	opts.log_buf = log_buf;
		2398	opts.log_size = log_buf_sz;
		2399
		2400	log_buf[0] = '\0';
		2401	opts.log_level = 0;
		2402	fd = bpf_prog_load(BPF_PROG_TYPE_SCHED_CLS, "tcx_prog", "GPL",
		2403	prog_insns, prog_insn_cnt, &opts);
		2404	ASSERT_STREQ(log_buf, "", "log_0");
		2405	ASSERT_GE(fd, 0, "prog_fd");
		2406	free(log_buf);
		2407	return fd;
		2408	}
		2409
		2410	static void test_tc_opts_max_target(int target, int flags, bool relative)
		2411	{
		2412	int err, ifindex, i, prog_fd, last_fd = -1;
		2413	LIBBPF_OPTS(bpf_prog_attach_opts, opta);
		2414	const int max_progs = 63;
		2415
		2416	ASSERT_OK(system("ip link add dev tcx_opts1 type veth peer name tcx_opts2"), "add veth");
		2417	ifindex = if_nametoindex("tcx_opts1");
		2418	ASSERT_NEQ(ifindex, 0, "non_zero_ifindex");
		2419
		2420	assert_mprog_count_ifindex(ifindex, target, 0);
		2421
		2422	for (i = 0; i < max_progs; i++) {
		2423	prog_fd = generate_dummy_prog();
		2424	if (!ASSERT_GE(prog_fd, 0, "dummy_prog"))
		2425	goto cleanup;
		2426	err = bpf_prog_attach_opts(prog_fd, ifindex, target, &opta);
		2427	if (!ASSERT_EQ(err, 0, "prog_attach"))
		2428	goto cleanup;
		2429	assert_mprog_count_ifindex(ifindex, target, i + 1);
		2430	if (i == max_progs - 1 && relative)
		2431	last_fd = prog_fd;
		2432	else
		2433	close(prog_fd);
		2434	}
		2435
		2436	prog_fd = generate_dummy_prog();
		2437	if (!ASSERT_GE(prog_fd, 0, "dummy_prog"))
		2438	goto cleanup;
		2439	opta.flags = flags;
		2440	if (last_fd > 0)
		2441	opta.relative_fd = last_fd;
		2442	err = bpf_prog_attach_opts(prog_fd, ifindex, target, &opta);
		2443	ASSERT_EQ(err, -ERANGE, "prog_64_attach");
		2444	assert_mprog_count_ifindex(ifindex, target, max_progs);
		2445	close(prog_fd);
		2446	cleanup:
		2447	if (last_fd > 0)
		2448	close(last_fd);
		2449	ASSERT_OK(system("ip link del dev tcx_opts1"), "del veth");
		2450	ASSERT_EQ(if_nametoindex("tcx_opts1"), 0, "dev1_removed");
		2451	ASSERT_EQ(if_nametoindex("tcx_opts2"), 0, "dev2_removed");
		2452	}
		2453
		2454	void serial_test_tc_opts_max(void)
		2455	{
		2456	test_tc_opts_max_target(BPF_TCX_INGRESS, 0, false);
		2457	test_tc_opts_max_target(BPF_TCX_EGRESS, 0, false);
		2458
		2459	test_tc_opts_max_target(BPF_TCX_INGRESS, BPF_F_BEFORE, false);
		2460	test_tc_opts_max_target(BPF_TCX_EGRESS, BPF_F_BEFORE, true);
		2461
		2462	test_tc_opts_max_target(BPF_TCX_INGRESS, BPF_F_AFTER, true);
		2463	test_tc_opts_max_target(BPF_TCX_EGRESS, BPF_F_AFTER, false);
		2464	}

tools/testing/selftests/bpf/progs/bpf_cubic.c+3−0

 	}
 }
+int bpf_cubic_acked_called = 0;
 void BPF_STRUCT_OPS(bpf_cubic_acked, struct sock *sk,
 		    const struct ack_sample *sample)
 {
 	struct bictcp *ca = inet_csk_ca(sk);
 	__u32 delay;
+	bpf_cubic_acked_called = 1;
 	/* Some calls are for duplicates without timetamps */
 	if (sample->rtt_us < 0)
 		return;

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

@@ -1,6 +1,6 @@
1	# SPDX-License-Identifier: GPL-2.0-or-later	1	# SPDX-License-Identifier: GPL-2.0-or-later
2		2
3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined $(KHDR_INCLUDES)	3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined -static-libasan $(KHDR_INCLUDES)
4	TEST_GEN_PROGS := fchmodat2_test	4	TEST_GEN_PROGS := fchmodat2_test
5		5
6	include ../lib.mk	6	include ../lib.mk

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

@@ -387,7 +387,7 @@ char strdup_printf(const char fmt, ...) · 386 unmodified lines
387	char *str;	387	char *str;
388		388
389	va_start(ap, fmt);	389	va_start(ap, fmt);
390	vasprintf(&str, fmt, ap);	390	TEST_ASSERT(vasprintf(&str, fmt, ap) >= 0, "vasprintf() failed");
391	va_end(ap);	391	va_end(ap);
392		392
393	return str;	393	return str;

tools/testing/selftests/kvm/riscv/get-reg-list.c+42−16

 #define REG_MASK (KVM_REG_ARCH_MASK | KVM_REG_SIZE_MASK)
+static bool isa_ext_cant_disable[KVM_RISCV_ISA_EXT_MAX];
 bool filter_reg(__u64 reg)
 {
+	switch (reg & ~REG_MASK) {
 	/*
-	 * Some ISA extensions are optional and not present on all host,
+	 * Same set of ISA_EXT registers are not present on all host because
-	 * but they can't be disabled through ISA_EXT registers when present.
+	 * ISA_EXT registers are visible to the KVM user space based on the
-	 * So, to make life easy, just filtering out these kind of registers.
+	 * ISA extensions available on the host. Also, disabling an ISA
+	 * extension using corresponding ISA_EXT register does not affect
+	 * the visibility of the ISA_EXT register itself.
+	 *
+	 * Based on above, we should filter-out all ISA_EXT registers.
 	 */
-	switch (reg & ~REG_MASK) {
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_A:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_C:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_D:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_F:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_H:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_I:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_M:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_SVPBMT:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_SSTC:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_SVINVAL:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZIHINTPAUSE:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZICBOM:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZICBOZ:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZBB:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_SSAIA:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_V:
+	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_SVNAPOT:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZBA:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZBS:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZICNTR:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZIFENCEI:
 	case KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_ZIHPM:
 		return true;
+	/* AIA registers are always available when Ssaia can't be disabled */
+	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(siselect):
+	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio1):
+	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio2):
+	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(sieh):
+	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(siph):
+	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio1h):
+	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio2h):
+		return isa_ext_cant_disable[KVM_RISCV_ISA_EXT_SSAIA];
 	default:
 		break;
 	}
 	unsigned long value;
 	ret = __vcpu_get_reg(vcpu, RISCV_ISA_EXT_REG(ext), &value);
-	if (ret) {
+	return (ret) ? false : !!value;
-		printf("Failed to get ext %d", ext);
-		return false;
-	}
-	return !!value;
 }
 void finalize_vcpu(struct kvm_vcpu *vcpu, struct vcpu_reg_list *c)
 {
+	unsigned long isa_ext_state[KVM_RISCV_ISA_EXT_MAX] = { 0 };
 	struct vcpu_reg_sublist *s;
+	int rc;
+	for (int i = 0; i < KVM_RISCV_ISA_EXT_MAX; i++)
+		__vcpu_get_reg(vcpu, RISCV_ISA_EXT_REG(i), &isa_ext_state[i]);
 	/*
 	 * Disable all extensions which were enabled by default
 	 * if they were available in the risc-v host.
 	 */
-	for (int i = 0; i < KVM_RISCV_ISA_EXT_MAX; i++)
+	for (int i = 0; i < KVM_RISCV_ISA_EXT_MAX; i++) {
-		__vcpu_set_reg(vcpu, RISCV_ISA_EXT_REG(i), 0);
+		rc = __vcpu_set_reg(vcpu, RISCV_ISA_EXT_REG(i), 0);
+		if (rc && isa_ext_state[i])
+			isa_ext_cant_disable[i] = true;
+	}
 	for_each_sublist(c, s) {
 		if (!s->feature)
 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(time),
 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(compare),
 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(state),
-	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_A,
-	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_C,
-	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_I,
-	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_RISCV_ISA_EXT_M,
 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_V01,
 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_TIME,
 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_IPI,

tools/testing/selftests/mm/charge_reserved_hugetlb.sh+2−2

@@ -25,7 +25,7 @@ if [[ "$1" == "-cgroup-v2" ]]; then · 24 unmodified lines
25	fi	25	fi
26		26
27	if [[ $cgroup2 ]]; then	27	if [[ $cgroup2 ]]; then
28	cgroup_path=$(mount -t cgroup2 \| head -1 \| awk -e '{print $3}')	28	cgroup_path=$(mount -t cgroup2 \| head -1 \| awk '{print $3}')
29	if [[ -z "$cgroup_path" ]]; then	29	if [[ -z "$cgroup_path" ]]; then
30	cgroup_path=/dev/cgroup/memory	30	cgroup_path=/dev/cgroup/memory
31	mount -t cgroup2 none $cgroup_path	31	mount -t cgroup2 none $cgroup_path
@@ -33,7 +33,7 @@ if [[ $cgroup2 ]]; then · 1 unmodified line
33	fi	33	fi
34	echo "+hugetlb" >$cgroup_path/cgroup.subtree_control	34	echo "+hugetlb" >$cgroup_path/cgroup.subtree_control
35	else	35	else
36	cgroup_path=$(mount -t cgroup \| grep ",hugetlb" \| awk -e '{print $3}')	36	cgroup_path=$(mount -t cgroup \| grep ",hugetlb" \| awk '{print $3}')
37	if [[ -z "$cgroup_path" ]]; then	37	if [[ -z "$cgroup_path" ]]; then
38	cgroup_path=/dev/cgroup/memory	38	cgroup_path=/dev/cgroup/memory
39	mount -t cgroup memory,hugetlb $cgroup_path	39	mount -t cgroup memory,hugetlb $cgroup_path

tools/testing/selftests/mm/hugetlb_reparenting_test.sh+2−2

@@ -20,7 +20,7 @@ fi · 19 unmodified lines
20		20
21		21
22	if [[ $cgroup2 ]]; then	22	if [[ $cgroup2 ]]; then
23	CGROUP_ROOT=$(mount -t cgroup2 \| head -1 \| awk -e '{print $3}')	23	CGROUP_ROOT=$(mount -t cgroup2 \| head -1 \| awk '{print $3}')
24	if [[ -z "$CGROUP_ROOT" ]]; then	24	if [[ -z "$CGROUP_ROOT" ]]; then
25	CGROUP_ROOT=/dev/cgroup/memory	25	CGROUP_ROOT=/dev/cgroup/memory
26	mount -t cgroup2 none $CGROUP_ROOT	26	mount -t cgroup2 none $CGROUP_ROOT
@@ -28,7 +28,7 @@ if [[ $cgroup2 ]]; then · 1 unmodified line
28	fi	28	fi
29	echo "+hugetlb +memory" >$CGROUP_ROOT/cgroup.subtree_control	29	echo "+hugetlb +memory" >$CGROUP_ROOT/cgroup.subtree_control
30	else	30	else
31	CGROUP_ROOT=$(mount -t cgroup \| grep ",hugetlb" \| awk -e '{print $3}')	31	CGROUP_ROOT=$(mount -t cgroup \| grep ",hugetlb" \| awk '{print $3}')
32	if [[ -z "$CGROUP_ROOT" ]]; then	32	if [[ -z "$CGROUP_ROOT" ]]; then
33	CGROUP_ROOT=/dev/cgroup/memory	33	CGROUP_ROOT=/dev/cgroup/memory
34	mount -t cgroup memory,hugetlb $CGROUP_ROOT	34	mount -t cgroup memory,hugetlb $CGROUP_ROOT

tools/testing/selftests/netfilter/Makefile+3−2

 	nft_concat_range.sh nft_conntrack_helper.sh \
 	nft_queue.sh nft_meta.sh nf_nat_edemux.sh \
 	ipip-conntrack-mtu.sh conntrack_tcp_unreplied.sh \
-	conntrack_vrf.sh nft_synproxy.sh rpath.sh nft_audit.sh
+	conntrack_vrf.sh nft_synproxy.sh rpath.sh nft_audit.sh \
+	conntrack_sctp_collision.sh
 HOSTPKG_CONFIG := pkg-config
 CFLAGS += $(shell $(HOSTPKG_CONFIG) --cflags libmnl 2>/dev/null)
 LDLIBS += $(shell $(HOSTPKG_CONFIG) --libs libmnl 2>/dev/null || echo -lmnl)
-TEST_GEN_FILES =  nf-queue connect_close audit_logread
+TEST_GEN_FILES =  nf-queue connect_close audit_logread sctp_collision
 include ../lib.mk

tools/testing/selftests/netfilter/conntrack_sctp_collision.sh+89−0

@@ -0,0 +1,89 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3	#
	4	# Testing For SCTP COLLISION SCENARIO as Below:
	5	#
	6	# 14:35:47.655279 IP CLIENT_IP.PORT > SERVER_IP.PORT: sctp (1) [INIT] [init tag: 2017837359]
	7	# 14:35:48.353250 IP SERVER_IP.PORT > CLIENT_IP.PORT: sctp (1) [INIT] [init tag: 1187206187]
	8	# 14:35:48.353275 IP CLIENT_IP.PORT > SERVER_IP.PORT: sctp (1) [INIT ACK] [init tag: 2017837359]
	9	# 14:35:48.353283 IP SERVER_IP.PORT > CLIENT_IP.PORT: sctp (1) [COOKIE ECHO]
	10	# 14:35:48.353977 IP CLIENT_IP.PORT > SERVER_IP.PORT: sctp (1) [COOKIE ACK]
	11	# 14:35:48.855335 IP SERVER_IP.PORT > CLIENT_IP.PORT: sctp (1) [INIT ACK] [init tag: 164579970]
	12	#
	13	# TOPO: SERVER_NS (link0)<--->(link1) ROUTER_NS (link2)<--->(link3) CLIENT_NS
	14
	15	CLIENT_NS=$(mktemp -u client-XXXXXXXX)
	16	CLIENT_IP="198.51.200.1"
	17	CLIENT_PORT=1234
	18
	19	SERVER_NS=$(mktemp -u server-XXXXXXXX)
	20	SERVER_IP="198.51.100.1"
	21	SERVER_PORT=1234
	22
	23	ROUTER_NS=$(mktemp -u router-XXXXXXXX)
	24	CLIENT_GW="198.51.200.2"
	25	SERVER_GW="198.51.100.2"
	26
	27	# setup the topo
	28	setup() {
	29	ip net add $CLIENT_NS
	30	ip net add $SERVER_NS
	31	ip net add $ROUTER_NS
	32	ip -n $SERVER_NS link add link0 type veth peer name link1 netns $ROUTER_NS
	33	ip -n $CLIENT_NS link add link3 type veth peer name link2 netns $ROUTER_NS
	34
	35	ip -n $SERVER_NS link set link0 up
	36	ip -n $SERVER_NS addr add $SERVER_IP/24 dev link0
	37	ip -n $SERVER_NS route add $CLIENT_IP dev link0 via $SERVER_GW
	38
	39	ip -n $ROUTER_NS link set link1 up
	40	ip -n $ROUTER_NS link set link2 up
	41	ip -n $ROUTER_NS addr add $SERVER_GW/24 dev link1
	42	ip -n $ROUTER_NS addr add $CLIENT_GW/24 dev link2
	43	ip net exec $ROUTER_NS sysctl -wq net.ipv4.ip_forward=1
	44
	45	ip -n $CLIENT_NS link set link3 up
	46	ip -n $CLIENT_NS addr add $CLIENT_IP/24 dev link3
	47	ip -n $CLIENT_NS route add $SERVER_IP dev link3 via $CLIENT_GW
	48
	49	# simulate the delay on OVS upcall by setting up a delay for INIT_ACK with
	50	# tc on $SERVER_NS side
	51	tc -n $SERVER_NS qdisc add dev link0 root handle 1: htb
	52	tc -n $SERVER_NS class add dev link0 parent 1: classid 1:1 htb rate 100mbit
	53	tc -n $SERVER_NS filter add dev link0 parent 1: protocol ip u32 match ip protocol 132 \
	54	0xff match u8 2 0xff at 32 flowid 1:1
	55	tc -n $SERVER_NS qdisc add dev link0 parent 1:1 handle 10: netem delay 1200ms
	56
	57	# simulate the ctstate check on OVS nf_conntrack
	58	ip net exec $ROUTER_NS iptables -A FORWARD -m state --state INVALID,UNTRACKED -j DROP
	59	ip net exec $ROUTER_NS iptables -A INPUT -p sctp -j DROP
	60
	61	# use a smaller number for assoc's max_retrans to reproduce the issue
	62	modprobe sctp
	63	ip net exec $CLIENT_NS sysctl -wq net.sctp.association_max_retrans=3
	64	}
	65
	66	cleanup() {
	67	ip net exec $CLIENT_NS pkill sctp_collision 2>&1 >/dev/null
	68	ip net exec $SERVER_NS pkill sctp_collision 2>&1 >/dev/null
	69	ip net del "$CLIENT_NS"
	70	ip net del "$SERVER_NS"
	71	ip net del "$ROUTER_NS"
	72	}
	73
	74	do_test() {
	75	ip net exec $SERVER_NS ./sctp_collision server \
	76	$SERVER_IP $SERVER_PORT $CLIENT_IP $CLIENT_PORT &
	77	ip net exec $CLIENT_NS ./sctp_collision client \
	78	$CLIENT_IP $CLIENT_PORT $SERVER_IP $SERVER_PORT
	79	}
	80
	81	# NOTE: one way to work around the issue is set a smaller hb_interval
	82	# ip net exec $CLIENT_NS sysctl -wq net.sctp.hb_interval=3500
	83
	84	# run the test case
	85	trap cleanup EXIT
	86	setup && \
	87	echo "Test for SCTP Collision in nf_conntrack:" && \
	88	do_test && echo "PASS!"
	89	exit $?

tools/testing/selftests/netfilter/nft_audit.sh+101−16

@@ -12,10 +12,11 @@ nft --version >/dev/null 2>&1 \|\| { · 11 unmodified lines
12	}	12	}
13		13
14	logfile=$(mktemp)	14	logfile=$(mktemp)
		15	rulefile=$(mktemp)
15	echo "logging into $logfile"	16	echo "logging into $logfile"
16	./audit_logread >"$logfile" &	17	./audit_logread >"$logfile" &
17	logread_pid=$!	18	logread_pid=$!
18	trap 'kill $logread_pid; rm -f $logfile' EXIT	19	trap 'kill $logread_pid; rm -f $logfile $rulefile' EXIT
19	exec 3<"$logfile"	20	exec 3<"$logfile"
20		21
21	do_test() { # (cmd, log)	22	do_test() { # (cmd, log)
@@ -26,12 +27,14 @@ do_test() { # (cmd, log) · 4 unmodified lines
26	res=$(diff -a -u <(echo "$2") - <&3)	27	res=$(diff -a -u <(echo "$2") - <&3)
27	[ $? -eq 0 ] && { echo "OK"; return; }	28	[ $? -eq 0 ] && { echo "OK"; return; }
28	echo "FAIL"	29	echo "FAIL"
29	echo "$res"	30	grep -v '^$---\\|+++\\|@@$' <<< "$res"
30	((RC++))	31	((RC--))
31	}	32	}
32		33
33	nft flush ruleset	34	nft flush ruleset
34		35
		36	# adding tables, chains and rules
		37
35	for table in t1 t2; do	38	for table in t1 t2; do
36	do_test "nft add table $table" \	39	do_test "nft add table $table" \
37	"table=$table family=2 entries=1 op=nft_register_table"	40	"table=$table family=2 entries=1 op=nft_register_table"
@@ -62,6 +65,48 @@ for table in t1 t2; do · 24 unmodified lines
62	"table=$table family=2 entries=6 op=nft_register_rule"	65	"table=$table family=2 entries=6 op=nft_register_rule"
63	done	66	done
64		67
		68	for ((i = 0; i < 500; i++)); do
		69	echo "add rule t2 c3 counter accept comment \"rule $i\""
		70	done >$rulefile
		71	do_test "nft -f $rulefile" \
		72	'table=t2 family=2 entries=500 op=nft_register_rule'
		73
		74	# adding sets and elements
		75
		76	settype='type inet_service; counter'
		77	setelem='{ 22, 80, 443 }'
		78	setblock="{ $settype; elements = $setelem; }"
		79	do_test "nft add set t1 s $setblock" \
		80	"table=t1 family=2 entries=4 op=nft_register_set"
		81
		82	do_test "nft add set t1 s2 $setblock; add set t1 s3 { $settype; }" \
		83	"table=t1 family=2 entries=5 op=nft_register_set"
		84
		85	do_test "nft add element t1 s3 $setelem" \
		86	"table=t1 family=2 entries=3 op=nft_register_setelem"
		87
		88	# adding counters
		89
		90	do_test 'nft add counter t1 c1' \
		91	'table=t1 family=2 entries=1 op=nft_register_obj'
		92
		93	do_test 'nft add counter t2 c1; add counter t2 c2' \
		94	'table=t2 family=2 entries=2 op=nft_register_obj'
		95
		96	# adding/updating quotas
		97
		98	do_test 'nft add quota t1 q1 { 10 bytes }' \
		99	'table=t1 family=2 entries=1 op=nft_register_obj'
		100
		101	do_test 'nft add quota t2 q1 { 10 bytes }; add quota t2 q2 { 10 bytes }' \
		102	'table=t2 family=2 entries=2 op=nft_register_obj'
		103
		104	# changing the quota value triggers obj update path
		105	do_test 'nft add quota t1 q1 { 20 bytes }' \
		106	'table=t1 family=2 entries=1 op=nft_register_obj'
		107
		108	# resetting rules
		109
65	do_test 'nft reset rules t1 c2' \	110	do_test 'nft reset rules t1 c2' \
66	'table=t1 family=2 entries=3 op=nft_reset_rule'	111	'table=t1 family=2 entries=3 op=nft_reset_rule'
67		112
@@ -70,19 +115,6 @@ do_test 'nft reset rules table t1' \ · 2 unmodified lines
70	table=t1 family=2 entries=3 op=nft_reset_rule	115	table=t1 family=2 entries=3 op=nft_reset_rule
71	table=t1 family=2 entries=3 op=nft_reset_rule'	116	table=t1 family=2 entries=3 op=nft_reset_rule'
72		117
73	do_test 'nft reset rules' \
74	'table=t1 family=2 entries=3 op=nft_reset_rule
75	table=t1 family=2 entries=3 op=nft_reset_rule
76	table=t1 family=2 entries=3 op=nft_reset_rule
77	table=t2 family=2 entries=3 op=nft_reset_rule
78	table=t2 family=2 entries=3 op=nft_reset_rule
79	table=t2 family=2 entries=3 op=nft_reset_rule'
80
81	for ((i = 0; i < 500; i++)); do
82	echo "add rule t2 c3 counter accept comment \"rule $i\""
83	done \| do_test 'nft -f -' \
84	'table=t2 family=2 entries=500 op=nft_register_rule'
85
86	do_test 'nft reset rules t2 c3' \	118	do_test 'nft reset rules t2 c3' \
87	'table=t2 family=2 entries=189 op=nft_reset_rule	119	'table=t2 family=2 entries=189 op=nft_reset_rule
88	table=t2 family=2 entries=188 op=nft_reset_rule	120	table=t2 family=2 entries=188 op=nft_reset_rule
@@ -105,4 +137,57 @@ table=t2 family=2 entries=180 op=nft_reset_rule · 16 unmodified lines
105	table=t2 family=2 entries=188 op=nft_reset_rule	137	table=t2 family=2 entries=188 op=nft_reset_rule
106	table=t2 family=2 entries=135 op=nft_reset_rule'	138	table=t2 family=2 entries=135 op=nft_reset_rule'
107		139
		140	# resetting sets and elements
		141
		142	elem=(22 ,80 ,443)
		143	relem=""
		144	for i in {1..3}; do
		145	relem+="${elem[((i - 1))]}"
		146	do_test "nft reset element t1 s { $relem }" \
		147	"table=t1 family=2 entries=$i op=nft_reset_setelem"
		148	done
		149
		150	do_test 'nft reset set t1 s' \
		151	'table=t1 family=2 entries=3 op=nft_reset_setelem'
		152
		153	# deleting rules
		154
		155	readarray -t handles < <(nft -a list chain t1 c1 \| \
		156	sed -n 's/.counter. handle $.*$$/\1/p')
		157
		158	do_test "nft delete rule t1 c1 handle ${handles[0]}" \
		159	'table=t1 family=2 entries=1 op=nft_unregister_rule'
		160
		161	cmd='delete rule t1 c1 handle'
		162	do_test "nft $cmd ${handles[1]}; $cmd ${handles[2]}" \
		163	'table=t1 family=2 entries=2 op=nft_unregister_rule'
		164
		165	do_test 'nft flush chain t1 c2' \
		166	'table=t1 family=2 entries=3 op=nft_unregister_rule'
		167
		168	do_test 'nft flush table t2' \
		169	'table=t2 family=2 entries=509 op=nft_unregister_rule'
		170
		171	# deleting chains
		172
		173	do_test 'nft delete chain t2 c2' \
		174	'table=t2 family=2 entries=1 op=nft_unregister_chain'
		175
		176	# deleting sets and elements
		177
		178	do_test 'nft delete element t1 s { 22 }' \
		179	'table=t1 family=2 entries=1 op=nft_unregister_setelem'
		180
		181	do_test 'nft delete element t1 s { 80, 443 }' \
		182	'table=t1 family=2 entries=2 op=nft_unregister_setelem'
		183
		184	do_test 'nft flush set t1 s2' \
		185	'table=t1 family=2 entries=3 op=nft_unregister_setelem'
		186
		187	do_test 'nft delete set t1 s2' \
		188	'table=t1 family=2 entries=1 op=nft_unregister_set'
		189
		190	do_test 'nft delete set t1 s3' \
		191	'table=t1 family=2 entries=1 op=nft_unregister_set'
		192
108	exit $RC	193	exit $RC

tools/testing/selftests/netfilter/sctp_collision.c+99−0

@@ -0,0 +1,99 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#include <stdio.h>
	4	#include <stdlib.h>
	5	#include <string.h>
	6	#include <unistd.h>
	7	#include <arpa/inet.h>
	8
	9	int main(int argc, char *argv[])
	10	{
	11	struct sockaddr_in saddr = {}, daddr = {};
	12	int sd, ret, len = sizeof(daddr);
	13	struct timeval tv = {25, 0};
	14	char buf[] = "hello";
	15
	16	if (argc != 6 \|\| (strcmp(argv[1], "server") && strcmp(argv[1], "client"))) {
	17	printf("%s <server\|client> <LOCAL_IP> <LOCAL_PORT> <REMOTE_IP> <REMOTE_PORT>\n",
	18	argv[0]);
	19	return -1;
	20	}
	21
	22	sd = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
	23	if (sd < 0) {
	24	printf("Failed to create sd\n");
	25	return -1;
	26	}
	27
	28	saddr.sin_family = AF_INET;
	29	saddr.sin_addr.s_addr = inet_addr(argv[2]);
	30	saddr.sin_port = htons(atoi(argv[3]));
	31
	32	ret = bind(sd, (struct sockaddr *)&saddr, sizeof(saddr));
	33	if (ret < 0) {
	34	printf("Failed to bind to address\n");
	35	goto out;
	36	}
	37
	38	ret = listen(sd, 5);
	39	if (ret < 0) {
	40	printf("Failed to listen on port\n");
	41	goto out;
	42	}
	43
	44	daddr.sin_family = AF_INET;
	45	daddr.sin_addr.s_addr = inet_addr(argv[4]);
	46	daddr.sin_port = htons(atoi(argv[5]));
	47
	48	/* make test shorter than 25s */
	49	ret = setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
	50	if (ret < 0) {
	51	printf("Failed to setsockopt SO_RCVTIMEO\n");
	52	goto out;
	53	}
	54
	55	if (!strcmp(argv[1], "server")) {
	56	sleep(1); /* wait a bit for client's INIT */
	57	ret = connect(sd, (struct sockaddr *)&daddr, len);
	58	if (ret < 0) {
	59	printf("Failed to connect to peer\n");
	60	goto out;
	61	}
	62	ret = recvfrom(sd, buf, sizeof(buf), 0, (struct sockaddr *)&daddr, &len);
	63	if (ret < 0) {
	64	printf("Failed to recv msg %d\n", ret);
	65	goto out;
	66	}
	67	ret = sendto(sd, buf, strlen(buf) + 1, 0, (struct sockaddr *)&daddr, len);
	68	if (ret < 0) {
	69	printf("Failed to send msg %d\n", ret);
	70	goto out;
	71	}
	72	printf("Server: sent! %d\n", ret);
	73	}
	74
	75	if (!strcmp(argv[1], "client")) {
	76	usleep(300000); /* wait a bit for server's listening */
	77	ret = connect(sd, (struct sockaddr *)&daddr, len);
	78	if (ret < 0) {
	79	printf("Failed to connect to peer\n");
	80	goto out;
	81	}
	82	sleep(1); /* wait a bit for server's delayed INIT_ACK to reproduce the issue */
	83	ret = sendto(sd, buf, strlen(buf) + 1, 0, (struct sockaddr *)&daddr, len);
	84	if (ret < 0) {
	85	printf("Failed to send msg %d\n", ret);
	86	goto out;
	87	}
	88	ret = recvfrom(sd, buf, sizeof(buf), 0, (struct sockaddr *)&daddr, &len);
	89	if (ret < 0) {
	90	printf("Failed to recv msg %d\n", ret);
	91	goto out;
	92	}
	93	printf("Client: rcvd! %d\n", ret);
	94	}
	95	ret = 0;
	96	out:
	97	close(sd);
	98	return ret;
	99	}

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

@@ -1,6 +1,6 @@
1	# SPDX-License-Identifier: GPL-2.0-or-later	1	# SPDX-License-Identifier: GPL-2.0-or-later
2		2
3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined	3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined -static-libasan
4	TEST_GEN_PROGS := openat2_test resolve_test rename_attack_test	4	TEST_GEN_PROGS := openat2_test resolve_test rename_attack_test
5		5
6	include ../lib.mk	6	include ../lib.mk

tools/testing/selftests/powerpc/Makefile+3−4

 	done;
 endef
-override define EMIT_TESTS
+emit_tests:
 	+@for TARGET in $(SUB_DIRS); do \
 		BUILD_TARGET=$(OUTPUT)/$$TARGET;	\
-		$(MAKE) OUTPUT=$$BUILD_TARGET -s -C $$TARGET emit_tests;\
+		$(MAKE) OUTPUT=$$BUILD_TARGET -s -C $$TARGET $@;\
 	done;
-endef
 override define CLEAN
 	+@for TARGET in $(SUB_DIRS); do \
 tags:
 	find . -name '*.c' -o -name '*.h' | xargs ctags
-.PHONY: tags $(SUB_DIRS)
+.PHONY: tags $(SUB_DIRS) emit_tests

tools/testing/selftests/powerpc/pmu/Makefile+6−5

 	+TARGET=event_code_tests; BUILD_TARGET=$$OUTPUT/$$TARGET; $(MAKE) OUTPUT=$$BUILD_TARGET -C $$TARGET run_tests
 endef
-DEFAULT_EMIT_TESTS := $(EMIT_TESTS)
+emit_tests:
-override define EMIT_TESTS
+	for TEST in $(TEST_GEN_PROGS); do \
-	$(DEFAULT_EMIT_TESTS)
+		BASENAME_TEST=`basename $$TEST`;	\
+		echo "$(COLLECTION):$$BASENAME_TEST";	\
+	done
 	+TARGET=ebb; BUILD_TARGET=$$OUTPUT/$$TARGET; $(MAKE) OUTPUT=$$BUILD_TARGET -s -C $$TARGET emit_tests
 	+TARGET=sampling_tests; BUILD_TARGET=$$OUTPUT/$$TARGET; $(MAKE) OUTPUT=$$BUILD_TARGET -s -C $$TARGET emit_tests
 	+TARGET=event_code_tests; BUILD_TARGET=$$OUTPUT/$$TARGET; $(MAKE) OUTPUT=$$BUILD_TARGET -s -C $$TARGET emit_tests
-endef
 DEFAULT_INSTALL_RULE := $(INSTALL_RULE)
 override define INSTALL_RULE
 event_code_tests:
 	TARGET=$@; BUILD_TARGET=$$OUTPUT/$$TARGET; mkdir -p $$BUILD_TARGET; $(MAKE) OUTPUT=$$BUILD_TARGET -k -C $$TARGET all
-.PHONY: all run_tests ebb sampling_tests event_code_tests
+.PHONY: all run_tests ebb sampling_tests event_code_tests emit_tests

tools/testing/selftests/proc/proc-empty-vm.c+1−0

@@ -267,6 +267,7 @@ static const char g_smaps_rollup[] = · 266 unmodified lines
267	"Private_Dirty: 0 kB\n"	267	"Private_Dirty: 0 kB\n"
268	"Referenced: 0 kB\n"	268	"Referenced: 0 kB\n"
269	"Anonymous: 0 kB\n"	269	"Anonymous: 0 kB\n"
		270	"KSM: 0 kB\n"
270	"LazyFree: 0 kB\n"	271	"LazyFree: 0 kB\n"
271	"AnonHugePages: 0 kB\n"	272	"AnonHugePages: 0 kB\n"
272	"ShmemPmdMapped: 0 kB\n"	273	"ShmemPmdMapped: 0 kB\n"

tools/testing/selftests/user_events/abi_test.c+3−1

 FIXTURE(user) {
 	long check;
+	bool umount;
 };
 FIXTURE_SETUP(user) {
-	USER_EVENT_FIXTURE_SETUP(return);
+	USER_EVENT_FIXTURE_SETUP(return, self->umount);
 	change_event(false);
 	self->check = 0;
 }
 FIXTURE_TEARDOWN(user) {
+	USER_EVENT_FIXTURE_TEARDOWN(self->umount);
 }
 TEST_F(user, enablement) {

tools/testing/selftests/user_events/dyn_test.c+4−1

 FIXTURE(user) {
 	int check;
+	bool umount;
 };
 FIXTURE_SETUP(user) {
-	USER_EVENT_FIXTURE_SETUP(return);
+	USER_EVENT_FIXTURE_SETUP(return, self->umount);
 }
 FIXTURE_TEARDOWN(user) {
+	USER_EVENT_FIXTURE_TEARDOWN(self->umount);
 	wait_for_delete();
 }

tools/testing/selftests/user_events/ftrace_test.c+4−1

 	int data_fd;
 	int enable_fd;
 	int check;
+	bool umount;
 };
 FIXTURE_SETUP(user) {
-	USER_EVENT_FIXTURE_SETUP(return);
+	USER_EVENT_FIXTURE_SETUP(return, self->umount);
 	self->status_fd = open(status_file, O_RDONLY);
 	ASSERT_NE(-1, self->status_fd);
 }
 FIXTURE_TEARDOWN(user) {
+	USER_EVENT_FIXTURE_TEARDOWN(self->umount);
 	close(self->status_fd);
 	close(self->data_fd);

tools/testing/selftests/user_events/perf_test.c+4−1

 FIXTURE(user) {
 	int data_fd;
 	int check;
+	bool umount;
 };
 FIXTURE_SETUP(user) {
-	USER_EVENT_FIXTURE_SETUP(return);
+	USER_EVENT_FIXTURE_SETUP(return, self->umount);
 	self->data_fd = open(data_file, O_RDWR);
 	ASSERT_NE(-1, self->data_fd);
 }
 FIXTURE_TEARDOWN(user) {
+	USER_EVENT_FIXTURE_TEARDOWN(self->umount);
 	close(self->data_fd);
 	if (clear(&self->check) != 0)

tools/testing/selftests/user_events/user_events_selftests.h+19−5

 #include "../kselftest.h"
-static inline bool tracefs_enabled(char **message, bool *fail)
+static inline void tracefs_unmount(void)
+{
+	umount("/sys/kernel/tracing");
+}
+static inline bool tracefs_enabled(char **message, bool *fail, bool *umount)
 {
 	struct stat buf;
 	int ret;
 	*message = "";
 	*fail = false;
+	*umount = false;
 	/* Ensure tracefs is installed */
 	ret = stat("/sys/kernel/tracing", &buf);
 			return false;
 		}
+		*umount = true;
 		ret = stat("/sys/kernel/tracing/README", &buf);
 	}
 	return true;
 }
-static inline bool user_events_enabled(char **message, bool *fail)
+static inline bool user_events_enabled(char **message, bool *fail, bool *umount)
 {
 	struct stat buf;
 	int ret;
 	*message = "";
 	*fail = false;
+	*umount = false;
 	if (getuid() != 0) {
 		*message = "Must be run as root";
 		return false;
 	}
-	if (!tracefs_enabled(message, fail))
+	if (!tracefs_enabled(message, fail, umount))
 		return false;
 	/* Ensure user_events is installed */
 	return true;
 }
-#define USER_EVENT_FIXTURE_SETUP(statement) do { \
+#define USER_EVENT_FIXTURE_SETUP(statement, umount) do { \
 	char *message; \
 	bool fail; \
-	if (!user_events_enabled(&message, &fail)) { \
+	if (!user_events_enabled(&message, &fail, &(umount))) { \
 		if (fail) { \
 			TH_LOG("Setup failed due to: %s", message); \
 			ASSERT_FALSE(fail); \
 	} \
 } while (0)
+#define USER_EVENT_FIXTURE_TEARDOWN(umount) do { \
+	if ((umount))  \
+		tracefs_unmount(); \
+} while (0)
 #endif /* _USER_EVENTS_SELFTESTS_H */

tools/tracing/rtla/src/timerlat_aa.c+26−6

@@ -159,6 +159,7 @@ static int timerlat_aa_irq_latency(struct timerlat_aa_data *taa_data, · 158 unmodified lines
159	taa_data->thread_nmi_sum = 0;	159	taa_data->thread_nmi_sum = 0;
160	taa_data->thread_irq_sum = 0;	160	taa_data->thread_irq_sum = 0;
161	taa_data->thread_softirq_sum = 0;	161	taa_data->thread_softirq_sum = 0;
		162	taa_data->thread_thread_sum = 0;
162	taa_data->thread_blocking_duration = 0;	163	taa_data->thread_blocking_duration = 0;
163	taa_data->timer_irq_start_time = 0;	164	taa_data->timer_irq_start_time = 0;
164	taa_data->timer_irq_duration = 0;	165	taa_data->timer_irq_duration = 0;
@@ -337,7 +338,23 @@ static int timerlat_aa_irq_handler(struct trace_seq s, struct tep_record recor · 172 unmodified lines
337	taa_data->timer_irq_start_time = start;	338	taa_data->timer_irq_start_time = start;
338	taa_data->timer_irq_duration = duration;	339	taa_data->timer_irq_duration = duration;
339		340
340	taa_data->timer_irq_start_delay = taa_data->timer_irq_start_time - expected_start;	341	/*
		342	* We are dealing with two different clock sources: the
		343	* external clock source that timerlat uses as a reference
		344	* and the clock used by the tracer. There are also two
		345	* moments: the time reading the clock and the timer in
		346	* which the event is placed in the buffer (the trace
		347	* event timestamp). If the processor is slow or there
		348	* is some hardware noise, the difference between the
		349	* timestamp and the external clock read can be longer
		350	* than the IRQ handler delay, resulting in a negative
		351	* time. If so, set IRQ start delay as 0. In the end,
		352	* it is less relevant than the noise.
		353	*/
		354	if (expected_start < taa_data->timer_irq_start_time)
		355	taa_data->timer_irq_start_delay = taa_data->timer_irq_start_time - expected_start;
		356	else
		357	taa_data->timer_irq_start_delay = 0;
341		358
342	/*	359	/*
343	* not exit from idle.	360	* not exit from idle.
@@ -528,7 +545,7 @@ static int timerlat_aa_kworker_start_handler(struct trace_seq *s, struct tep_rec · 184 unmodified lines
528	static void timerlat_thread_analysis(struct timerlat_aa_data *taa_data, int cpu,	545	static void timerlat_thread_analysis(struct timerlat_aa_data *taa_data, int cpu,
529	int irq_thresh, int thread_thresh)	546	int irq_thresh, int thread_thresh)
530	{	547	{
531	unsigned long long exp_irq_ts;	548	long long exp_irq_ts;
532	int total;	549	int total;
533	int irq;	550	int irq;
534		551
@@ -545,12 +562,15 @@ static void timerlat_thread_analysis(struct timerlat_aa_data *taa_data, int cpu, · 10 unmodified lines
545		562
546	/*	563	/*
547	* Expected IRQ arrival time using the trace clock as the base.	564	* Expected IRQ arrival time using the trace clock as the base.
		565	*
		566	* TODO: Add a list of previous IRQ, and then run the list backwards.
548	*/	567	*/
549	exp_irq_ts = taa_data->timer_irq_start_time - taa_data->timer_irq_start_delay;	568	exp_irq_ts = taa_data->timer_irq_start_time - taa_data->timer_irq_start_delay;
550		569	if (exp_irq_ts < taa_data->prev_irq_timstamp + taa_data->prev_irq_duration) {
551	if (exp_irq_ts < taa_data->prev_irq_timstamp + taa_data->prev_irq_duration)	570	if (taa_data->prev_irq_timstamp < taa_data->timer_irq_start_time)
552	printf(" Previous IRQ interference: \t\t up to %9.2f us\n",	571	printf(" Previous IRQ interference: \t\t up to %9.2f us\n",
553	ns_to_usf(taa_data->prev_irq_duration));	572	ns_to_usf(taa_data->prev_irq_duration));
		573	}
554		574
555	/*	575	/*
556	* The delay that the IRQ suffered before starting.	576	* The delay that the IRQ suffered before starting.

tools/tracing/rtla/src/timerlat_u.c+4−2

@@ -45,7 +45,7 @@ static int timerlat_u_main(int cpu, struct timerlat_u_params *params) · 44 unmodified lines
45		45
46	retval = sched_setaffinity(gettid(), sizeof(set), &set);	46	retval = sched_setaffinity(gettid(), sizeof(set), &set);
47	if (retval == -1) {	47	if (retval == -1) {
48	err_msg("Error setting user thread affinity\n");	48	debug_msg("Error setting user thread affinity %d, is the CPU online?\n", cpu);
49	exit(1);	49	exit(1);
50	}	50	}
51		51
@@ -193,7 +193,9 @@ void timerlat_u_dispatcher(void data) · 141 unmodified lines
193	procs_count--;	193	procs_count--;
194	}	194	}
195	}	195	}
196	break;	196
		197	if (!procs_count)
		198	break;
197	}	199	}
198		200
199	sleep(1);	201	sleep(1);

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -2957,7 +2957,7 @@ · 2956 unmodified lines
2957	clock-names = "merge","merge_async";	2957	clock-names = "merge","merge_async";
2958	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;	2958	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;
2959	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xc000 0x1000>;	2959	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xc000 0x1000>;
2960	mediatek,merge-mute = <1>;	2960	mediatek,merge-mute;
2961	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE0_DL_ASYNC>;	2961	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE0_DL_ASYNC>;
2962	};	2962	};
2963		2963
@@ -2970,7 +2970,7 @@ · 6 unmodified lines
2970	clock-names = "merge","merge_async";	2970	clock-names = "merge","merge_async";
2971	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;	2971	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;
2972	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xd000 0x1000>;	2972	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xd000 0x1000>;
2973	mediatek,merge-mute = <1>;	2973	mediatek,merge-mute;
2974	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE1_DL_ASYNC>;	2974	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE1_DL_ASYNC>;
2975	};	2975	};
2976		2976
@@ -2983,7 +2983,7 @@ · 6 unmodified lines
2983	clock-names = "merge","merge_async";	2983	clock-names = "merge","merge_async";
2984	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;	2984	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;
2985	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xe000 0x1000>;	2985	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xe000 0x1000>;
2986	mediatek,merge-mute = <1>;	2986	mediatek,merge-mute;
2987	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE2_DL_ASYNC>;	2987	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE2_DL_ASYNC>;
2988	};	2988	};
2989		2989
@@ -2996,7 +2996,7 @@ · 6 unmodified lines
2996	clock-names = "merge","merge_async";	2996	clock-names = "merge","merge_async";
2997	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;	2997	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;
2998	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xf000 0x1000>;	2998	mediatek,gce-client-reg = <&gce0 SUBSYS_1c10XXXX 0xf000 0x1000>;
2999	mediatek,merge-mute = <1>;	2999	mediatek,merge-mute;
3000	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE3_DL_ASYNC>;	3000	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE3_DL_ASYNC>;
3001	};	3001	};
3002		3002
@@ -3009,7 +3009,7 @@ · 6 unmodified lines
3009	clock-names = "merge","merge_async";	3009	clock-names = "merge","merge_async";
3010	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;	3010	power-domains = <&spm MT8195_POWER_DOMAIN_VDOSYS1>;
3011	mediatek,gce-client-reg = <&gce0 SUBSYS_1c11XXXX 0x0000 0x1000>;	3011	mediatek,gce-client-reg = <&gce0 SUBSYS_1c11XXXX 0x0000 0x1000>;
3012	mediatek,merge-fifo-en = <1>;	3012	mediatek,merge-fifo-en;
3013	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE4_DL_ASYNC>;	3013	resets = <&vdosys1 MT8195_VDOSYS1_SW0_RST_B_MERGE4_DL_ASYNC>;
3014	};	3014	};
3015		3015