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/ABI/testing/sysfs-class-firmware+7−7

@@ -1,7 +1,7 @@
1	What: /sys/class/firmware/.../data	1	What: /sys/class/firmware/.../data
2	Date: July 2022	2	Date: July 2022
3	KernelVersion: 5.19	3	KernelVersion: 5.19
4	Contact: Russ Weight <russell.h.weight@intel.com>	4	Contact: Russ Weight <russ.weight@linux.dev>
5	Description: The data sysfs file is used for firmware-fallback and for	5	Description: The data sysfs file is used for firmware-fallback and for
6	firmware uploads. Cat a firmware image to this sysfs file	6	firmware uploads. Cat a firmware image to this sysfs file
7	after you echo 1 to the loading sysfs file. When the firmware	7	after you echo 1 to the loading sysfs file. When the firmware
@@ -13,7 +13,7 @@ Description: The data sysfs file is used for firmware-fallback and for · 5 unmodified lines
13	What: /sys/class/firmware/.../cancel	13	What: /sys/class/firmware/.../cancel
14	Date: July 2022	14	Date: July 2022
15	KernelVersion: 5.19	15	KernelVersion: 5.19
16	Contact: Russ Weight <russell.h.weight@intel.com>	16	Contact: Russ Weight <russ.weight@linux.dev>
17	Description: Write-only. For firmware uploads, write a "1" to this file to	17	Description: Write-only. For firmware uploads, write a "1" to this file to
18	request that the transfer of firmware data to the lower-level	18	request that the transfer of firmware data to the lower-level
19	device be canceled. This request will be rejected (EBUSY) if	19	device be canceled. This request will be rejected (EBUSY) if
@@ -23,7 +23,7 @@ Description: Write-only. For firmware uploads, write a "1" to this file to · 3 unmodified lines
23	What: /sys/class/firmware/.../error	23	What: /sys/class/firmware/.../error
24	Date: July 2022	24	Date: July 2022
25	KernelVersion: 5.19	25	KernelVersion: 5.19
26	Contact: Russ Weight <russell.h.weight@intel.com>	26	Contact: Russ Weight <russ.weight@linux.dev>
27	Description: Read-only. Returns a string describing a failed firmware	27	Description: Read-only. Returns a string describing a failed firmware
28	upload. This string will be in the form of <STATUS>:<ERROR>,	28	upload. This string will be in the form of <STATUS>:<ERROR>,
29	where <STATUS> will be one of the status strings described	29	where <STATUS> will be one of the status strings described
@@ -37,7 +37,7 @@ Description: Read-only. Returns a string describing a failed firmware · 7 unmodified lines
37	What: /sys/class/firmware/.../loading	37	What: /sys/class/firmware/.../loading
38	Date: July 2022	38	Date: July 2022
39	KernelVersion: 5.19	39	KernelVersion: 5.19
40	Contact: Russ Weight <russell.h.weight@intel.com>	40	Contact: Russ Weight <russ.weight@linux.dev>
41	Description: The loading sysfs file is used for both firmware-fallback and	41	Description: The loading sysfs file is used for both firmware-fallback and
42	for firmware uploads. Echo 1 onto the loading file to indicate	42	for firmware uploads. Echo 1 onto the loading file to indicate
43	you are writing a firmware file to the data sysfs node. Echo	43	you are writing a firmware file to the data sysfs node. Echo
@@ -49,7 +49,7 @@ Description: The loading sysfs file is used for both firmware-fallback and · 5 unmodified lines
49	What: /sys/class/firmware/.../remaining_size	49	What: /sys/class/firmware/.../remaining_size
50	Date: July 2022	50	Date: July 2022
51	KernelVersion: 5.19	51	KernelVersion: 5.19
52	Contact: Russ Weight <russell.h.weight@intel.com>	52	Contact: Russ Weight <russ.weight@linux.dev>
53	Description: Read-only. For firmware upload, this file contains the size	53	Description: Read-only. For firmware upload, this file contains the size
54	of the firmware data that remains to be transferred to the	54	of the firmware data that remains to be transferred to the
55	lower-level device driver. The size value is initialized to	55	lower-level device driver. The size value is initialized to
@@ -62,7 +62,7 @@ Description: Read-only. For firmware upload, this file contains the size · 6 unmodified lines
62	What: /sys/class/firmware/.../status	62	What: /sys/class/firmware/.../status
63	Date: July 2022	63	Date: July 2022
64	KernelVersion: 5.19	64	KernelVersion: 5.19
65	Contact: Russ Weight <russell.h.weight@intel.com>	65	Contact: Russ Weight <russ.weight@linux.dev>
66	Description: Read-only. Returns a string describing the current status of	66	Description: Read-only. Returns a string describing the current status of
67	a firmware upload. The string will be one of the following:	67	a firmware upload. The string will be one of the following:
68	idle, "receiving", "preparing", "transferring", "programming".	68	idle, "receiving", "preparing", "transferring", "programming".
@@ -70,7 +70,7 @@ Description: Read-only. Returns a string describing the current status of · 1 unmodified line
70	What: /sys/class/firmware/.../timeout	70	What: /sys/class/firmware/.../timeout
71	Date: July 2022	71	Date: July 2022
72	KernelVersion: 5.19	72	KernelVersion: 5.19
73	Contact: Russ Weight <russell.h.weight@intel.com>	73	Contact: Russ Weight <russ.weight@linux.dev>
74	Description: This file supports the timeout mechanism for firmware	74	Description: This file supports the timeout mechanism for firmware
75	fallback. This file has no affect on firmware uploads. For	75	fallback. This file has no affect on firmware uploads. For
76	more information on timeouts please see the documentation	76	more information on timeouts please see the documentation

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

 +----------------+-----------------+-----------------+-----------------------------+
 | ARM            | Cortex-A510     | #2658417        | ARM64_ERRATUM_2658417       |
 +----------------+-----------------+-----------------+-----------------------------+
+| ARM            | Cortex-A520     | #2966298        | ARM64_ERRATUM_2966298       |
++----------------+-----------------+-----------------+-----------------------------+
 | ARM            | Cortex-A53      | #826319         | ARM64_ERRATUM_826319        |
 +----------------+-----------------+-----------------+-----------------------------+
 | ARM            | Cortex-A53      | #827319         | ARM64_ERRATUM_827319        |

Documentation/core-api/workqueue.rst+2−2

@@ -244,7 +244,7 @@ unbound worker-pools and only one work item could be active at any given · 243 unmodified lines
244	time thus achieving the same ordering property as ST wq.	244	time thus achieving the same ordering property as ST wq.
245		245
246	In the current implementation the above configuration only guarantees	246	In the current implementation the above configuration only guarantees
247	ST behavior within a given NUMA node. Instead ``alloc_ordered_queue()`` should	247	ST behavior within a given NUMA node. Instead ``alloc_ordered_workqueue()`` should
248	be used to achieve system-wide ST behavior.	248	be used to achieve system-wide ST behavior.
249		249
250		250
@@ -390,7 +390,7 @@ The default affinity scope can be changed with the module parameter · 139 unmodified lines
390	scope can be changed using ``apply_workqueue_attrs()``.	390	scope can be changed using ``apply_workqueue_attrs()``.
391		391
392	If ``WQ_SYSFS`` is set, the workqueue will have the following affinity scope	392	If ``WQ_SYSFS`` is set, the workqueue will have the following affinity scope
393	related interface files under its ``/sys/devices/virtual/WQ_NAME/``	393	related interface files under its ``/sys/devices/virtual/workqueue/WQ_NAME/``
394	directory.	394	directory.
395		395
396	``affinity_scope``	396	``affinity_scope``

Documentation/devicetree/bindings/bus/fsl,imx8qxp-pixel-link-msi-bus.yaml+0−3

   "^.*@[0-9a-f]+$":
     description: Devices attached to the bus
     type: object
-    properties:
-      reg:
-        maxItems: 1
     required:
       - reg

Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml+1−1

@@ -69,7 +69,7 @@ examples: · 68 unmodified lines
69	- \|	69	- \|
70	#include <dt-bindings/interrupt-controller/irq.h>	70	#include <dt-bindings/interrupt-controller/irq.h>
71		71
72	cache-controller@2010000 {	72	cache-controller@13400000 {
73	compatible = "andestech,ax45mp-cache", "cache";	73	compatible = "andestech,ax45mp-cache", "cache";
74	reg = <0x13400000 0x100000>;	74	reg = <0x13400000 0x100000>;
75	interrupts = <508 IRQ_TYPE_LEVEL_HIGH>;	75	interrupts = <508 IRQ_TYPE_LEVEL_HIGH>;

Documentation/devicetree/bindings/display/imx/fsl,imx6-hdmi.yaml+1−1

@@ -87,7 +87,7 @@ required: · 86 unmodified lines
87	- interrupts	87	- interrupts
88	- ports	88	- ports
89		89
90	additionalProperties: false	90	unevaluatedProperties: false
91		91
92	examples:	92	examples:
93	- \|	93	- \|

Documentation/devicetree/bindings/dma/xilinx/xlnx,zynqmp-dma-1.0.yaml+3−0

 maintainers:
   - Michael Tretter <m.tretter@pengutronix.de>
+  - Harini Katakam <harini.katakam@amd.com>
+  - Radhey Shyam Pandey <radhey.shyam.pandey@amd.com>
 allOf:
   - $ref: ../dma-controller.yaml#
   - interrupts
   - clocks
   - clock-names
+  - xlnx,bus-width
 additionalProperties: false

Documentation/devicetree/bindings/iio/adc/adi,ad7292.yaml+1−1

@@ -61,7 +61,7 @@ patternProperties: · 60 unmodified lines
61	required:	61	required:
62	- reg	62	- reg
63		63
64	additionalProperties: true	64	additionalProperties: false
65		65
66	allOf:	66	allOf:
67	- $ref: /schemas/spi/spi-peripheral-props.yaml#	67	- $ref: /schemas/spi/spi-peripheral-props.yaml#

Documentation/devicetree/bindings/iio/light/rohm,bu27010.yaml+1−0

@@ -45,5 +45,6 @@ examples: · 44 unmodified lines
45	light-sensor@38 {	45	light-sensor@38 {
46	compatible = "rohm,bu27010";	46	compatible = "rohm,bu27010";
47	reg = <0x38>;	47	reg = <0x38>;
		48	vdd-supply = <&vdd>;
48	};	49	};
49	};	50	};

Documentation/devicetree/bindings/interrupt-controller/arm,gic-v3.yaml+12−0

     $ref: /schemas/types.yaml#/definitions/uint32
     maximum: 4096
+  dma-noncoherent:
+    description:
+      Present if the GIC redistributors permit programming shareability
+      and cacheability attributes but are connected to a non-coherent
+      downstream interconnect.
   msi-controller:
     description:
       Only present if the Message Based Interrupt functionality is
       compatible:
         const: arm,gic-v3-its
+      dma-noncoherent:
+        description:
+          Present if the GIC ITS permits programming shareability and
+          cacheability attributes but is connected to a non-coherent
+          downstream interconnect.
       msi-controller: true
       "#msi-cells":

Documentation/devicetree/bindings/interrupt-controller/renesas,irqc.yaml+1−0

@@ -37,6 +37,7 @@ properties: · 36 unmodified lines
37	- renesas,intc-ex-r8a77990 # R-Car E3	37	- renesas,intc-ex-r8a77990 # R-Car E3
38	- renesas,intc-ex-r8a77995 # R-Car D3	38	- renesas,intc-ex-r8a77995 # R-Car D3
39	- renesas,intc-ex-r8a779a0 # R-Car V3U	39	- renesas,intc-ex-r8a779a0 # R-Car V3U
		40	- renesas,intc-ex-r8a779f0 # R-Car S4-8
40	- renesas,intc-ex-r8a779g0 # R-Car V4H	41	- renesas,intc-ex-r8a779g0 # R-Car V4H
41	- const: renesas,irqc	42	- const: renesas,irqc
42		43

Documentation/devicetree/bindings/interrupt-controller/renesas,rzg2l-irqc.yaml+173−57

@@ -19,20 +19,19 @@ description: \| · 18 unmodified lines
19	- NMI edge select (NMI is not treated as NMI exception and supports fall edge and	19	- NMI edge select (NMI is not treated as NMI exception and supports fall edge and
20	stand-up edge detection interrupts)	20	stand-up edge detection interrupts)
21		21
22	allOf:
23	- $ref: /schemas/interrupt-controller.yaml#
24
25	properties:	22	properties:
26	compatible:	23	compatible:
27	items:	24	items:
28	- enum:	25	- enum:
		26	- renesas,r9a07g043u-irqc # RZ/G2UL
29	- renesas,r9a07g044-irqc # RZ/G2{L,LC}	27	- renesas,r9a07g044-irqc # RZ/G2{L,LC}
30	- renesas,r9a07g054-irqc # RZ/V2L	28	- renesas,r9a07g054-irqc # RZ/V2L
31	- const: renesas,rzg2l-irqc	29	- const: renesas,rzg2l-irqc
32		30
33	'#interrupt-cells':	31	'#interrupt-cells':
34	description: The first cell should contain external interrupt number (IRQ0-7) and the	32	description: The first cell should contain a macro RZG2L_{NMI,IRQX} included in the
35	second cell is used to specify the flag.	33	include/dt-bindings/interrupt-controller/irqc-rzg2l.h and the second
		34	cell is used to specify the flag.
36	const: 2	35	const: 2
37		36
38	'#address-cells':	37	'#address-cells':
@@ -44,7 +43,96 @@ properties: · 5 unmodified lines
44	maxItems: 1	43	maxItems: 1
45		44
46	interrupts:	45	interrupts:
47	maxItems: 41	46	minItems: 41
		47	items:
		48	- description: NMI interrupt
		49	- description: IRQ0 interrupt
		50	- description: IRQ1 interrupt
		51	- description: IRQ2 interrupt
		52	- description: IRQ3 interrupt
		53	- description: IRQ4 interrupt
		54	- description: IRQ5 interrupt
		55	- description: IRQ6 interrupt
		56	- description: IRQ7 interrupt
		57	- description: GPIO interrupt, TINT0
		58	- description: GPIO interrupt, TINT1
		59	- description: GPIO interrupt, TINT2
		60	- description: GPIO interrupt, TINT3
		61	- description: GPIO interrupt, TINT4
		62	- description: GPIO interrupt, TINT5
		63	- description: GPIO interrupt, TINT6
		64	- description: GPIO interrupt, TINT7
		65	- description: GPIO interrupt, TINT8
		66	- description: GPIO interrupt, TINT9
		67	- description: GPIO interrupt, TINT10
		68	- description: GPIO interrupt, TINT11
		69	- description: GPIO interrupt, TINT12
		70	- description: GPIO interrupt, TINT13
		71	- description: GPIO interrupt, TINT14
		72	- description: GPIO interrupt, TINT15
		73	- description: GPIO interrupt, TINT16
		74	- description: GPIO interrupt, TINT17
		75	- description: GPIO interrupt, TINT18
		76	- description: GPIO interrupt, TINT19
		77	- description: GPIO interrupt, TINT20
		78	- description: GPIO interrupt, TINT21
		79	- description: GPIO interrupt, TINT22
		80	- description: GPIO interrupt, TINT23
		81	- description: GPIO interrupt, TINT24
		82	- description: GPIO interrupt, TINT25
		83	- description: GPIO interrupt, TINT26
		84	- description: GPIO interrupt, TINT27
		85	- description: GPIO interrupt, TINT28
		86	- description: GPIO interrupt, TINT29
		87	- description: GPIO interrupt, TINT30
		88	- description: GPIO interrupt, TINT31
		89	- description: Bus error interrupt
		90
		91	interrupt-names:
		92	minItems: 41
		93	items:
		94	- const: nmi
		95	- const: irq0
		96	- const: irq1
		97	- const: irq2
		98	- const: irq3
		99	- const: irq4
		100	- const: irq5
		101	- const: irq6
		102	- const: irq7
		103	- const: tint0
		104	- const: tint1
		105	- const: tint2
		106	- const: tint3
		107	- const: tint4
		108	- const: tint5
		109	- const: tint6
		110	- const: tint7
		111	- const: tint8
		112	- const: tint9
		113	- const: tint10
		114	- const: tint11
		115	- const: tint12
		116	- const: tint13
		117	- const: tint14
		118	- const: tint15
		119	- const: tint16
		120	- const: tint17
		121	- const: tint18
		122	- const: tint19
		123	- const: tint20
		124	- const: tint21
		125	- const: tint22
		126	- const: tint23
		127	- const: tint24
		128	- const: tint25
		129	- const: tint26
		130	- const: tint27
		131	- const: tint28
		132	- const: tint29
		133	- const: tint30
		134	- const: tint31
		135	- const: bus-err
48		136
49	clocks:	137	clocks:
50	maxItems: 2	138	maxItems: 2
@@ -72,6 +160,23 @@ required: · 21 unmodified lines
72	- power-domains	160	- power-domains
73	- resets	161	- resets
74		162
		163	allOf:
		164	- $ref: /schemas/interrupt-controller.yaml#
		165
		166	- if:
		167	properties:
		168	compatible:
		169	contains:
		170	const: renesas,r9a07g043u-irqc
		171	then:
		172	properties:
		173	interrupts:
		174	minItems: 42
		175	interrupt-names:
		176	minItems: 42
		177	required:
		178	- interrupt-names
		179
75	unevaluatedProperties: false	180	unevaluatedProperties: false
76		181
77	examples:	182	examples:
@@ -80,55 +185,66 @@ examples: · 2 unmodified lines
80	#include <dt-bindings/clock/r9a07g044-cpg.h>	185	#include <dt-bindings/clock/r9a07g044-cpg.h>
81		186
82	irqc: interrupt-controller@110a0000 {	187	irqc: interrupt-controller@110a0000 {
83	compatible = "renesas,r9a07g044-irqc", "renesas,rzg2l-irqc";	188	compatible = "renesas,r9a07g044-irqc", "renesas,rzg2l-irqc";
84	reg = <0x110a0000 0x10000>;	189	reg = <0x110a0000 0x10000>;
85	#interrupt-cells = <2>;	190	#interrupt-cells = <2>;
86	#address-cells = <0>;	191	#address-cells = <0>;
87	interrupt-controller;	192	interrupt-controller;
88	interrupts = <GIC_SPI 0 IRQ_TYPE_LEVEL_HIGH>,	193	interrupts = <GIC_SPI 0 IRQ_TYPE_LEVEL_HIGH>,
89	<GIC_SPI 1 IRQ_TYPE_LEVEL_HIGH>,	194	<GIC_SPI 1 IRQ_TYPE_LEVEL_HIGH>,
90	<GIC_SPI 2 IRQ_TYPE_LEVEL_HIGH>,	195	<GIC_SPI 2 IRQ_TYPE_LEVEL_HIGH>,
91	<GIC_SPI 3 IRQ_TYPE_LEVEL_HIGH>,	196	<GIC_SPI 3 IRQ_TYPE_LEVEL_HIGH>,
92	<GIC_SPI 4 IRQ_TYPE_LEVEL_HIGH>,	197	<GIC_SPI 4 IRQ_TYPE_LEVEL_HIGH>,
93	<GIC_SPI 5 IRQ_TYPE_LEVEL_HIGH>,	198	<GIC_SPI 5 IRQ_TYPE_LEVEL_HIGH>,
94	<GIC_SPI 6 IRQ_TYPE_LEVEL_HIGH>,	199	<GIC_SPI 6 IRQ_TYPE_LEVEL_HIGH>,
95	<GIC_SPI 7 IRQ_TYPE_LEVEL_HIGH>,	200	<GIC_SPI 7 IRQ_TYPE_LEVEL_HIGH>,
96	<GIC_SPI 8 IRQ_TYPE_LEVEL_HIGH>,	201	<GIC_SPI 8 IRQ_TYPE_LEVEL_HIGH>,
97	<GIC_SPI 444 IRQ_TYPE_LEVEL_HIGH>,	202	<GIC_SPI 444 IRQ_TYPE_LEVEL_HIGH>,
98	<GIC_SPI 445 IRQ_TYPE_LEVEL_HIGH>,	203	<GIC_SPI 445 IRQ_TYPE_LEVEL_HIGH>,
99	<GIC_SPI 446 IRQ_TYPE_LEVEL_HIGH>,	204	<GIC_SPI 446 IRQ_TYPE_LEVEL_HIGH>,
100	<GIC_SPI 447 IRQ_TYPE_LEVEL_HIGH>,	205	<GIC_SPI 447 IRQ_TYPE_LEVEL_HIGH>,
101	<GIC_SPI 448 IRQ_TYPE_LEVEL_HIGH>,	206	<GIC_SPI 448 IRQ_TYPE_LEVEL_HIGH>,
102	<GIC_SPI 449 IRQ_TYPE_LEVEL_HIGH>,	207	<GIC_SPI 449 IRQ_TYPE_LEVEL_HIGH>,
103	<GIC_SPI 450 IRQ_TYPE_LEVEL_HIGH>,	208	<GIC_SPI 450 IRQ_TYPE_LEVEL_HIGH>,
104	<GIC_SPI 451 IRQ_TYPE_LEVEL_HIGH>,	209	<GIC_SPI 451 IRQ_TYPE_LEVEL_HIGH>,
105	<GIC_SPI 452 IRQ_TYPE_LEVEL_HIGH>,	210	<GIC_SPI 452 IRQ_TYPE_LEVEL_HIGH>,
106	<GIC_SPI 453 IRQ_TYPE_LEVEL_HIGH>,	211	<GIC_SPI 453 IRQ_TYPE_LEVEL_HIGH>,
107	<GIC_SPI 454 IRQ_TYPE_LEVEL_HIGH>,	212	<GIC_SPI 454 IRQ_TYPE_LEVEL_HIGH>,
108	<GIC_SPI 455 IRQ_TYPE_LEVEL_HIGH>,	213	<GIC_SPI 455 IRQ_TYPE_LEVEL_HIGH>,
109	<GIC_SPI 456 IRQ_TYPE_LEVEL_HIGH>,	214	<GIC_SPI 456 IRQ_TYPE_LEVEL_HIGH>,
110	<GIC_SPI 457 IRQ_TYPE_LEVEL_HIGH>,	215	<GIC_SPI 457 IRQ_TYPE_LEVEL_HIGH>,
111	<GIC_SPI 458 IRQ_TYPE_LEVEL_HIGH>,	216	<GIC_SPI 458 IRQ_TYPE_LEVEL_HIGH>,
112	<GIC_SPI 459 IRQ_TYPE_LEVEL_HIGH>,	217	<GIC_SPI 459 IRQ_TYPE_LEVEL_HIGH>,
113	<GIC_SPI 460 IRQ_TYPE_LEVEL_HIGH>,	218	<GIC_SPI 460 IRQ_TYPE_LEVEL_HIGH>,
114	<GIC_SPI 461 IRQ_TYPE_LEVEL_HIGH>,	219	<GIC_SPI 461 IRQ_TYPE_LEVEL_HIGH>,
115	<GIC_SPI 462 IRQ_TYPE_LEVEL_HIGH>,	220	<GIC_SPI 462 IRQ_TYPE_LEVEL_HIGH>,
116	<GIC_SPI 463 IRQ_TYPE_LEVEL_HIGH>,	221	<GIC_SPI 463 IRQ_TYPE_LEVEL_HIGH>,
117	<GIC_SPI 464 IRQ_TYPE_LEVEL_HIGH>,	222	<GIC_SPI 464 IRQ_TYPE_LEVEL_HIGH>,
118	<GIC_SPI 465 IRQ_TYPE_LEVEL_HIGH>,	223	<GIC_SPI 465 IRQ_TYPE_LEVEL_HIGH>,
119	<GIC_SPI 466 IRQ_TYPE_LEVEL_HIGH>,	224	<GIC_SPI 466 IRQ_TYPE_LEVEL_HIGH>,
120	<GIC_SPI 467 IRQ_TYPE_LEVEL_HIGH>,	225	<GIC_SPI 467 IRQ_TYPE_LEVEL_HIGH>,
121	<GIC_SPI 468 IRQ_TYPE_LEVEL_HIGH>,	226	<GIC_SPI 468 IRQ_TYPE_LEVEL_HIGH>,
122	<GIC_SPI 469 IRQ_TYPE_LEVEL_HIGH>,	227	<GIC_SPI 469 IRQ_TYPE_LEVEL_HIGH>,
123	<GIC_SPI 470 IRQ_TYPE_LEVEL_HIGH>,	228	<GIC_SPI 470 IRQ_TYPE_LEVEL_HIGH>,
124	<GIC_SPI 471 IRQ_TYPE_LEVEL_HIGH>,	229	<GIC_SPI 471 IRQ_TYPE_LEVEL_HIGH>,
125	<GIC_SPI 472 IRQ_TYPE_LEVEL_HIGH>,	230	<GIC_SPI 472 IRQ_TYPE_LEVEL_HIGH>,
126	<GIC_SPI 473 IRQ_TYPE_LEVEL_HIGH>,	231	<GIC_SPI 473 IRQ_TYPE_LEVEL_HIGH>,
127	<GIC_SPI 474 IRQ_TYPE_LEVEL_HIGH>,	232	<GIC_SPI 474 IRQ_TYPE_LEVEL_HIGH>,
128	<GIC_SPI 475 IRQ_TYPE_LEVEL_HIGH>;	233	<GIC_SPI 475 IRQ_TYPE_LEVEL_HIGH>;
129	clocks = <&cpg CPG_MOD R9A07G044_IA55_CLK>,	234	interrupt-names = "nmi",
130	<&cpg CPG_MOD R9A07G044_IA55_PCLK>;	235	"irq0", "irq1", "irq2", "irq3",
131	clock-names = "clk", "pclk";	236	"irq4", "irq5", "irq6", "irq7",
132	power-domains = <&cpg>;	237	"tint0", "tint1", "tint2", "tint3",
133	resets = <&cpg R9A07G044_IA55_RESETN>;	238	"tint4", "tint5", "tint6", "tint7",
		239	"tint8", "tint9", "tint10", "tint11",
		240	"tint12", "tint13", "tint14", "tint15",
		241	"tint16", "tint17", "tint18", "tint19",
		242	"tint20", "tint21", "tint22", "tint23",
		243	"tint24", "tint25", "tint26", "tint27",
		244	"tint28", "tint29", "tint30", "tint31";
		245	clocks = <&cpg CPG_MOD R9A07G044_IA55_CLK>,
		246	<&cpg CPG_MOD R9A07G044_IA55_PCLK>;
		247	clock-names = "clk", "pclk";
		248	power-domains = <&cpg>;
		249	resets = <&cpg R9A07G044_IA55_RESETN>;
134	};	250	};

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/media/i2c/sony,imx415.yaml+1−0

@@ -54,6 +54,7 @@ properties: · 53 unmodified lines
54		54
55	port:	55	port:
56	$ref: /schemas/graph.yaml#/$defs/port-base	56	$ref: /schemas/graph.yaml#/$defs/port-base
		57	unevaluatedProperties: false
57		58
58	properties:	59	properties:
59	endpoint:	60	endpoint:

Documentation/devicetree/bindings/media/i2c/toshiba,tc358746.yaml+2−0

     properties:
       port@0:
         $ref: /schemas/graph.yaml#/$defs/port-base
+        unevaluatedProperties: false
         description: Input port
         properties:
       port@1:
         $ref: /schemas/graph.yaml#/$defs/port-base
+        unevaluatedProperties: false
         description: Output port
         properties:

Documentation/devicetree/bindings/media/nxp,imx7-csi.yaml+0−1

@@ -59,7 +59,6 @@ allOf: · 58 unmodified lines
59	compatible:	59	compatible:
60	contains:	60	contains:
61	enum:	61	enum:
62	- fsl,imx8mq-csi
63	- fsl,imx8mm-csi	62	- fsl,imx8mm-csi
64	then:	63	then:
65	required:	64	required:

Documentation/devicetree/bindings/media/renesas,vin.yaml+2−2

@@ -95,7 +95,7 @@ properties: · 94 unmodified lines
95	synchronization is selected.	95	synchronization is selected.
96	default: 1	96	default: 1
97		97
98	field-active-even: true	98	field-even-active: true
99		99
100	bus-width: true	100	bus-width: true
101		101
@@ -144,7 +144,7 @@ properties: · 42 unmodified lines
144	synchronization is selected.	144	synchronization is selected.
145	default: 1	145	default: 1
146		146
147	field-active-even: true	147	field-even-active: true
148		148
149	bus-width: true	149	bus-width: true
150		150

Documentation/devicetree/bindings/media/samsung,fimc.yaml+1−0

@@ -57,6 +57,7 @@ properties: · 56 unmodified lines
57	patternProperties:	57	patternProperties:
58	"^port@[01]$":	58	"^port@[01]$":
59	$ref: /schemas/graph.yaml#/$defs/port-base	59	$ref: /schemas/graph.yaml#/$defs/port-base
		60	unevaluatedProperties: false
60	description:	61	description:
61	Camera A and camera B inputs.	62	Camera A and camera B inputs.
62		63

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/pci/brcm,iproc-pcie.yaml+76−87

@@ -12,7 +12,6 @@ maintainers: · 11 unmodified lines
12		12
13	allOf:	13	allOf:
14	- $ref: /schemas/pci/pci-bus.yaml#	14	- $ref: /schemas/pci/pci-bus.yaml#
15	- $ref: /schemas/interrupt-controller/msi-controller.yaml#
16		15
17	properties:	16	properties:
18	compatible:	17	compatible:
@@ -34,13 +33,6 @@ properties: · 15 unmodified lines
34	description: >	33	description: >
35	Base address and length of the PCIe controller I/O register space	34	Base address and length of the PCIe controller I/O register space
36		35
37	interrupt-map: true
38
39	interrupt-map-mask: true
40
41	"#interrupt-cells":
42	const: 1
43
44	ranges:	36	ranges:
45	minItems: 1	37	minItems: 1
46	maxItems: 2	38	maxItems: 2
@@ -54,16 +46,8 @@ properties: · 7 unmodified lines
54	items:	46	items:
55	- const: pcie-phy	47	- const: pcie-phy
56		48
57	bus-range: true
58
59	dma-coherent: true	49	dma-coherent: true
60		50
61	"#address-cells": true
62
63	"#size-cells": true
64
65	device_type: true
66
67	brcm,pcie-ob:	51	brcm,pcie-ob:
68	type: boolean	52	type: boolean
69	description: >	53	description: >
@@ -78,20 +62,24 @@ properties: · 8 unmodified lines
78		62
79	msi:	63	msi:
80	type: object	64	type: object
		65	$ref: /schemas/interrupt-controller/msi-controller.yaml#
		66	unevaluatedProperties: false
		67
81	properties:	68	properties:
82	compatible:	69	compatible:
83	items:	70	items:
84	- const: brcm,iproc-msi	71	- const: brcm,iproc-msi
85		72
86	msi-parent: true	73	interrupts:
		74	maxItems: 4
87		75
88	msi-controller: true	76	brcm,pcie-msi-inten:
		77	type: boolean
		78	description:
		79	Needs to be present for some older iProc platforms that require the
		80	interrupt enable registers to be set explicitly to enable MSI
89		81
90	brcm,pcie-msi-inten:	82	msi-parent: true
91	type: boolean
92	description: >
93	Needs to be present for some older iProc platforms that require the
94	interrupt enable registers to be set explicitly to enable MSI
95		83
96	dependencies:	84	dependencies:
97	brcm,pcie-ob-axi-offset: ["brcm,pcie-ob"]	85	brcm,pcie-ob-axi-offset: ["brcm,pcie-ob"]
@@ -117,68 +105,69 @@ unevaluatedProperties: false · 19 unmodified lines
117		105
118	examples:	106	examples:
119	- \|	107	- \|
120	#include <dt-bindings/interrupt-controller/arm-gic.h>	108	#include <dt-bindings/interrupt-controller/arm-gic.h>
121		109
122	bus {	110	gic: interrupt-controller {
123	#address-cells = <1>;	111	interrupt-controller;
124	#size-cells = <1>;	112	#interrupt-cells = <3>;
125	pcie0: pcie@18012000 {	113	};
126	compatible = "brcm,iproc-pcie";	114
127	reg = <0x18012000 0x1000>;	115	pcie@18012000 {
128		116	compatible = "brcm,iproc-pcie";
129	#interrupt-cells = <1>;	117	reg = <0x18012000 0x1000>;
130	interrupt-map-mask = <0 0 0 0>;	118
131	interrupt-map = <0 0 0 0 &gic GIC_SPI 100 IRQ_TYPE_NONE>;	119	#interrupt-cells = <1>;
132		120	interrupt-map-mask = <0 0 0 0>;
133	linux,pci-domain = <0>;	121	interrupt-map = <0 0 0 0 &gic GIC_SPI 100 IRQ_TYPE_NONE>;
134		122
135	bus-range = <0x00 0xff>;	123	linux,pci-domain = <0>;
136		124
137	#address-cells = <3>;	125	bus-range = <0x00 0xff>;
138	#size-cells = <2>;	126
139	device_type = "pci";	127	#address-cells = <3>;
140	ranges = <0x81000000 0 0 0x28000000 0 0x00010000>,	128	#size-cells = <2>;
141	<0x82000000 0 0x20000000 0x20000000 0 0x04000000>;	129	device_type = "pci";
142		130	ranges = <0x81000000 0 0 0x28000000 0 0x00010000>,
143	phys = <&phy 0 5>;	131	<0x82000000 0 0x20000000 0x20000000 0 0x04000000>;
144	phy-names = "pcie-phy";	132
145		133	phys = <&phy 0 5>;
146	brcm,pcie-ob;	134	phy-names = "pcie-phy";
147	brcm,pcie-ob-axi-offset = <0x00000000>;	135
148		136	brcm,pcie-ob;
149	msi-parent = <&msi0>;	137	brcm,pcie-ob-axi-offset = <0x00000000>;
150		138
151	/* iProc event queue based MSI */	139	msi-parent = <&msi0>;
152	msi0: msi {	140
153	compatible = "brcm,iproc-msi";	141	/* iProc event queue based MSI */
154	msi-controller;	142	msi0: msi {
155	interrupt-parent = <&gic>;	143	compatible = "brcm,iproc-msi";
156	interrupts = <GIC_SPI 96 IRQ_TYPE_NONE>,	144	msi-controller;
157	<GIC_SPI 97 IRQ_TYPE_NONE>,	145	interrupt-parent = <&gic>;
158	<GIC_SPI 98 IRQ_TYPE_NONE>,	146	interrupts = <GIC_SPI 96 IRQ_TYPE_NONE>,
159	<GIC_SPI 99 IRQ_TYPE_NONE>;	147	<GIC_SPI 97 IRQ_TYPE_NONE>,
160	};	148	<GIC_SPI 98 IRQ_TYPE_NONE>,
161	};	149	<GIC_SPI 99 IRQ_TYPE_NONE>;
162		150	};
163	pcie1: pcie@18013000 {	151	};
164	compatible = "brcm,iproc-pcie";	152	- \|
165	reg = <0x18013000 0x1000>;	153	pcie@18013000 {
166		154	compatible = "brcm,iproc-pcie";
167	#interrupt-cells = <1>;	155	reg = <0x18013000 0x1000>;
168	interrupt-map-mask = <0 0 0 0>;	156
169	interrupt-map = <0 0 0 0 &gic GIC_SPI 106 IRQ_TYPE_NONE>;	157	#interrupt-cells = <1>;
170		158	interrupt-map-mask = <0 0 0 0>;
171	linux,pci-domain = <1>;	159	interrupt-map = <0 0 0 0 &gic GIC_SPI 106 IRQ_TYPE_NONE>;
172		160
173	bus-range = <0x00 0xff>;	161	linux,pci-domain = <1>;
174		162
175	#address-cells = <3>;	163	bus-range = <0x00 0xff>;
176	#size-cells = <2>;	164
177	device_type = "pci";	165	#address-cells = <3>;
178	ranges = <0x81000000 0 0 0x48000000 0 0x00010000>,	166	#size-cells = <2>;
179	<0x82000000 0 0x40000000 0x40000000 0 0x04000000>;	167	device_type = "pci";
180		168	ranges = <0x81000000 0 0 0x48000000 0 0x00010000>,
181	phys = <&phy 1 6>;	169	<0x82000000 0 0x40000000 0x40000000 0 0x04000000>;
182	phy-names = "pcie-phy";	170
183	};	171	phys = <&phy 1 6>;
		172	phy-names = "pcie-phy";
184	};	173	};

Documentation/devicetree/bindings/riscv/cpus.yaml+1−0

@@ -91,6 +91,7 @@ properties: · 90 unmodified lines
91		91
92	interrupt-controller:	92	interrupt-controller:
93	type: object	93	type: object
		94	additionalProperties: false
94	description: Describes the CPU's local interrupt controller	95	description: Describes the CPU's local interrupt controller
95		96
96	properties:	97	properties:

Documentation/devicetree/bindings/sound/fsl,micfil.yaml+3−0

@@ -56,6 +56,9 @@ properties: · 55 unmodified lines
56	- const: clkext3	56	- const: clkext3
57	minItems: 2	57	minItems: 2
58		58
		59	"#sound-dai-cells":
		60	const: 0
		61
59	required:	62	required:
60	- compatible	63	- compatible
61	- reg	64	- reg

Documentation/devicetree/bindings/sound/rockchip-spdif.yaml+1−0

@@ -26,6 +26,7 @@ properties: · 25 unmodified lines
26	- const: rockchip,rk3568-spdif	26	- const: rockchip,rk3568-spdif
27	- items:	27	- items:
28	- enum:	28	- enum:
		29	- rockchip,rk3128-spdif
29	- rockchip,rk3188-spdif	30	- rockchip,rk3188-spdif
30	- rockchip,rk3288-spdif	31	- rockchip,rk3288-spdif
31	- rockchip,rk3308-spdif	32	- rockchip,rk3308-spdif

Documentation/devicetree/bindings/trivial-devices.yaml+1−1

@@ -232,7 +232,7 @@ properties: · 231 unmodified lines
232	# MEMSIC magnetometer	232	# MEMSIC magnetometer
233	- memsic,mmc35240	233	- memsic,mmc35240
234	# MEMSIC 3-axis accelerometer	234	# MEMSIC 3-axis accelerometer
235	- memsic,mx4005	235	- memsic,mxc4005
236	# MEMSIC 2-axis 8-bit digital accelerometer	236	# MEMSIC 2-axis 8-bit digital accelerometer
237	- memsic,mxc6225	237	- memsic,mxc6225
238	# MEMSIC 2-axis 8-bit digital accelerometer	238	# MEMSIC 2-axis 8-bit digital accelerometer

Documentation/filesystems/erofs.rst+37−3

@@ -58,12 +58,14 @@ Here are the main features of EROFS: · 57 unmodified lines
58		58
59	- Support extended attributes as an option;	59	- Support extended attributes as an option;
60		60
		61	- Support a bloom filter that speeds up negative extended attribute lookups;
		62
61	- Support POSIX.1e ACLs by using extended attributes;	63	- Support POSIX.1e ACLs by using extended attributes;
62		64
63	- Support transparent data compression as an option:	65	- Support transparent data compression as an option:
64	LZ4 and MicroLZMA algorithms can be used on a per-file basis; In addition,	66	LZ4, MicroLZMA and DEFLATE algorithms can be used on a per-file basis; In
65	inplace decompression is also supported to avoid bounce compressed buffers	67	addition, inplace decompression is also supported to avoid bounce compressed
66	and page cache thrashing.	68	buffers and unnecessary page cache thrashing.
67		69
68	- Support chunk-based data deduplication and rolling-hash compressed data	70	- Support chunk-based data deduplication and rolling-hash compressed data
69	deduplication;	71	deduplication;
@@ -268,6 +270,38 @@ details.) · 198 unmodified lines
268		270
269	By the way, chunk-based files are all uncompressed for now.	271	By the way, chunk-based files are all uncompressed for now.
270		272
		273	Long extended attribute name prefixes
		274	-------------------------------------
		275	There are use cases where extended attributes with different values can have
		276	only a few common prefixes (such as overlayfs xattrs). The predefined prefixes
		277	work inefficiently in both image size and runtime performance in such cases.
		278
		279	The long xattr name prefixes feature is introduced to address this issue. The
		280	overall idea is that, apart from the existing predefined prefixes, the xattr
		281	entry could also refer to user-specified long xattr name prefixes, e.g.
		282	"trusted.overlay.".
		283
		284	When referring to a long xattr name prefix, the highest bit (bit 7) of
		285	erofs_xattr_entry.e_name_index is set, while the lower bits (bit 0-6) as a whole
		286	represent the index of the referred long name prefix among all long name
		287	prefixes. Therefore, only the trailing part of the name apart from the long
		288	xattr name prefix is stored in erofs_xattr_entry.e_name, which could be empty if
		289	the full xattr name matches exactly as its long xattr name prefix.
		290
		291	All long xattr prefixes are stored one by one in the packed inode as long as
		292	the packed inode is valid, or in the meta inode otherwise. The
		293	xattr_prefix_count (of the on-disk superblock) indicates the total number of
		294	long xattr name prefixes, while (xattr_prefix_start * 4) indicates the start
		295	offset of long name prefixes in the packed/meta inode. Note that, long extended
		296	attribute name prefixes are disabled if xattr_prefix_count is 0.
		297
		298	Each long name prefix is stored in the format: ALIGN({__le16 len, data}, 4),
		299	where len represents the total size of the data part. The data part is actually
		300	represented by 'struct erofs_xattr_long_prefix', where base_index represents the
		301	index of the predefined xattr name prefix, e.g. EROFS_XATTR_INDEX_TRUSTED for
		302	"trusted.overlay." long name prefix, while the infix string keeps the string
		303	after stripping the short prefix, e.g. "overlay." for the example above.
		304
271	Data compression	305	Data compression
272	----------------	306	----------------
273	EROFS implements fixed-sized output compression which generates fixed-sized	307	EROFS implements fixed-sized output compression which generates fixed-sized

Documentation/filesystems/overlayfs.rst+12−0

@@ -339,6 +339,18 @@ The specified lower directories will be stacked beginning from the · 338 unmodified lines
339	rightmost one and going left. In the above example lower1 will be the	339	rightmost one and going left. In the above example lower1 will be the
340	top, lower2 the middle and lower3 the bottom layer.	340	top, lower2 the middle and lower3 the bottom layer.
341		341
		342	Note: directory names containing colons can be provided as lower layer by
		343	escaping the colons with a single backslash. For example:
		344
		345	mount -t overlay overlay -olowerdir=/a\:lower\:\:dir /merged
		346
		347	Since kernel version v6.5, directory names containing colons can also
		348	be provided as lower layer using the fsconfig syscall from new mount api:
		349
		350	fsconfig(fs_fd, FSCONFIG_SET_STRING, "lowerdir", "/a:lower::dir", 0);
		351
		352	In the latter case, colons in lower layer directory names will be escaped
		353	as an octal characters (\072) when displayed in /proc/self/mountinfo.
342		354
343	Metadata only copy up	355	Metadata only copy up
344	---------------------	356	---------------------

Documentation/process/embargoed-hardware-issues.rst+12−7

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/core-api/workqueue.rst+1−1

@@ -202,7 +202,7 @@ workqueue将自动创建与属性相匹配的后备工作者池。调节并发 · 201 unmodified lines
202	同的排序属性。	202	同的排序属性。
203		203
204	在目前的实现中，上述配置只保证了特定NUMA节点内的ST行为。相反，	204	在目前的实现中，上述配置只保证了特定NUMA节点内的ST行为。相反，
205	``alloc_ordered_queue()`` 应该被用来实现全系统的ST行为。	205	``alloc_ordered_workqueue()`` 应该被用来实现全系统的ST行为。
206		206
207		207
208	执行场景示例	208	执行场景示例

MAINTAINERS+27−33

 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/arm64/include/asm/arch_timer.h
 F:	drivers/clocksource/arm_arch_timer.c
+ARM GENERIC INTERRUPT CONTROLLER DRIVERS
+M:	Marc Zyngier <maz@kernel.org>
+L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
+S:	Maintained
+F:	Documentation/devicetree/bindings/interrupt-controller/arm,gic*
+F:	arch/arm/include/asm/arch_gicv3.h
+F:	arch/arm64/include/asm/arch_gicv3.h
+F:	drivers/irqchip/irq-gic*.[ch]
+F:	include/linux/irqchip/arm-gic*.h
+F:	include/linux/irqchip/arm-vgic-info.h
 ARM HDLCD DRM DRIVER
 M:	Liviu Dudau <liviu.dudau@arm.com>
 S:	Supported
 ARM/INTEL IXP4XX ARM ARCHITECTURE
 M:	Linus Walleij <linusw@kernel.org>
 M:	Imre Kaloz <kaloz@openwrt.org>
-M:	Krzysztof Halasa <khalasa@piap.pl>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:	Maintained
 F:	Documentation/devicetree/bindings/arm/intel-ixp4xx.yaml
 F:	Documentation/devicetree/bindings/gpio/intel,ixp4xx-gpio.txt
 F:	Documentation/devicetree/bindings/interrupt-controller/intel,ixp4xx-interrupt.yaml
 F:	Documentation/devicetree/bindings/memory-controllers/intel,ixp4xx-expansion*
+F:	Documentation/devicetree/bindings/rng/intel,ixp46x-rng.yaml
 F:	Documentation/devicetree/bindings/timer/intel,ixp4xx-timer.yaml
 F:	arch/arm/boot/dts/intel/ixp/
 F:	arch/arm/mach-ixp4xx/
 F:	drivers/bus/intel-ixp4xx-eb.c
+F:	drivers/char/hw_random/ixp4xx-rng.c
 F:	drivers/clocksource/timer-ixp4xx.c
 F:	drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c
 F:	drivers/gpio/gpio-ixp4xx.c
 F:	drivers/irqchip/irq-ixp4xx.c
+F:	drivers/net/ethernet/xscale/ixp4xx_eth.c
+F:	drivers/net/wan/ixp4xx_hss.c
+F:	drivers/soc/ixp4xx/ixp4xx-npe.c
+F:	drivers/soc/ixp4xx/ixp4xx-qmgr.c
+F:	include/linux/soc/ixp4xx/npe.h
+F:	include/linux/soc/ixp4xx/qmgr.h
 ARM/INTEL KEEMBAY ARCHITECTURE
 M:	Paul J. Murphy <paul.j.murphy@intel.com>
 ARM/Mediatek SoC support
 M:	Matthias Brugger <matthias.bgg@gmail.com>
-R:	AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
+M:	AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
 L:	linux-kernel@vger.kernel.org
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
 DEVICE-MAPPER  (LVM)
 M:	Alasdair Kergon <agk@redhat.com>
 M:	Mike Snitzer <snitzer@kernel.org>
-M:	dm-devel@redhat.com
+M:	dm-devel@lists.linux.dev
-L:	dm-devel@redhat.com
+L:	dm-devel@lists.linux.dev
 S:	Maintained
 W:	http://sources.redhat.com/dm
 Q:	http://patchwork.kernel.org/project/dm-devel/list/
 FIRMWARE LOADER (request_firmware)
 M:	Luis Chamberlain <mcgrof@kernel.org>
-M:	Russ Weight <russell.h.weight@intel.com>
+M:	Russ Weight <russ.weight@linux.dev>
 L:	linux-kernel@vger.kernel.org
 S:	Maintained
 F:	Documentation/firmware_class/
 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
 S:	Maintained
 F:	drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c
-INTEL IXP4XX QMGR, NPE, ETHERNET and HSS SUPPORT
-M:	Krzysztof Halasa <khalasa@piap.pl>
-S:	Maintained
-F:	drivers/net/ethernet/xscale/ixp4xx_eth.c
-F:	drivers/net/wan/ixp4xx_hss.c
-F:	drivers/soc/ixp4xx/ixp4xx-npe.c
-F:	drivers/soc/ixp4xx/ixp4xx-qmgr.c
-F:	include/linux/soc/ixp4xx/npe.h
-F:	include/linux/soc/ixp4xx/qmgr.h
-INTEL IXP4XX RANDOM NUMBER GENERATOR SUPPORT
-M:	Deepak Saxena <dsaxena@plexity.net>
-S:	Maintained
-F:	Documentation/devicetree/bindings/rng/intel,ixp46x-rng.yaml
-F:	drivers/char/hw_random/ixp4xx-rng.c
 INTEL KEEM BAY DRM DRIVER
 M:	Anitha Chrisanthus <anitha.chrisanthus@intel.com>
 M:	Edmund Dea <edmund.j.dea@intel.com>
 F:	sound/soc/codecs/sma*
 IRQ DOMAINS (IRQ NUMBER MAPPING LIBRARY)
-M:	Marc Zyngier <maz@kernel.org>
+M:	Thomas Gleixner <tglx@linutronix.de>
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git irq/core
 F:	Documentation/core-api/irq/irq-domain.rst
 IRQCHIP DRIVERS
 M:	Thomas Gleixner <tglx@linutronix.de>
-M:	Marc Zyngier <maz@kernel.org>
 L:	linux-kernel@vger.kernel.org
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git irq/core
 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
 STARFIVE JH71X0 PINCTRL DRIVERS
 M:	Emil Renner Berthing <kernel@esmil.dk>
 M:	Jianlong Huang <jianlong.huang@starfivetech.com>
+M:	Hal Feng <hal.feng@starfivetech.com>
 L:	linux-gpio@vger.kernel.org
 S:	Maintained
 F:	Documentation/devicetree/bindings/pinctrl/starfive,jh71*.yaml
 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

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 = -rc4	5	EXTRAVERSION = -rc6
6	NAME = Hurr durr I'ma ninja sloth	6	NAME = Hurr durr I'ma ninja sloth
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm64/Kconfig+13−0

@@ -1037,6 +1037,19 @@ config ARM64_ERRATUM_2645198 · 1036 unmodified lines
1037		1037
1038	If unsure, say Y.	1038	If unsure, say Y.
1039		1039
		1040	config ARM64_ERRATUM_2966298
		1041	bool "Cortex-A520: 2966298: workaround for speculatively executed unprivileged load"
		1042	default y
		1043	help
		1044	This option adds the workaround for ARM Cortex-A520 erratum 2966298.
		1045
		1046	On an affected Cortex-A520 core, a speculatively executed unprivileged
		1047	load might leak data from a privileged level via a cache side channel.
		1048
		1049	Work around this problem by executing a TLBI before returning to EL0.
		1050
		1051	If unsure, say Y.
		1052
1040	config CAVIUM_ERRATUM_22375	1053	config CAVIUM_ERRATUM_22375
1041	bool "Cavium erratum 22375, 24313"	1054	bool "Cavium erratum 22375, 24313"
1042	default y	1055	default y

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

 			#size-cells = <1>;
 			ranges;
-			anomix_ns_gpr: syscon@44210000 {
+			aonmix_ns_gpr: syscon@44210000 {
 				compatible = "fsl,imx93-aonmix-ns-syscfg", "syscon";
 				reg = <0x44210000 0x1000>;
 			};
 				assigned-clock-parents = <&clk IMX93_CLK_SYS_PLL_PFD1_DIV2>;
 				assigned-clock-rates = <40000000>;
 				fsl,clk-source = /bits/ 8 <0>;
+				fsl,stop-mode = <&aonmix_ns_gpr 0x14 0>;
 				status = "disabled";
 			};
 				assigned-clock-parents = <&clk IMX93_CLK_SYS_PLL_PFD1_DIV2>;
 				assigned-clock-rates = <40000000>;
 				fsl,clk-source = /bits/ 8 <0>;
+				fsl,stop-mode = <&wakeupmix_gpr 0x0c 2>;
 				status = "disabled";
 			};

arch/arm64/boot/dts/mediatek/mt7622.dtsi+1−1

@@ -905,7 +905,7 @@ · 904 unmodified lines
905	status = "disabled";	905	status = "disabled";
906	};	906	};
907		907
908	sata_phy: t-phy@1a243000 {	908	sata_phy: t-phy {
909	compatible = "mediatek,mt7622-tphy",	909	compatible = "mediatek,mt7622-tphy",
910	"mediatek,generic-tphy-v1";	910	"mediatek,generic-tphy-v1";
911	#address-cells = <2>;	911	#address-cells = <2>;

arch/arm64/boot/dts/mediatek/mt7986a.dtsi+1−1

@@ -434,7 +434,7 @@ · 433 unmodified lines
434	};	434	};
435	};	435	};
436		436
437	pcie_phy: t-phy@11c00000 {	437	pcie_phy: t-phy {
438	compatible = "mediatek,mt7986-tphy",	438	compatible = "mediatek,mt7986-tphy",
439	"mediatek,generic-tphy-v2";	439	"mediatek,generic-tphy-v2";
440	#address-cells = <2>;	440	#address-cells = <2>;

arch/arm64/boot/dts/mediatek/mt8195-demo.dts+31−8

@@ -48,7 +48,7 @@ · 47 unmodified lines
48		48
49	memory@40000000 {	49	memory@40000000 {
50	device_type = "memory";	50	device_type = "memory";
51	reg = <0 0x40000000 0 0x80000000>;	51	reg = <0 0x40000000 0x2 0x00000000>;
52	};	52	};
53		53
54	reserved-memory {	54	reserved-memory {
@@ -56,13 +56,8 @@ · 1 unmodified line
56	#size-cells = <2>;	56	#size-cells = <2>;
57	ranges;	57	ranges;
58		58
59	/* 2 MiB reserved for ARM Trusted Firmware (BL31) */	59	/*
60	bl31_secmon_reserved: secmon@54600000 {	60	* 12 MiB reserved for OP-TEE (BL32)
61	no-map;
62	reg = <0 0x54600000 0x0 0x200000>;
63	};
64
65	/* 12 MiB reserved for OP-TEE (BL32)
66	* +-----------------------+ 0x43e0_0000	61	* +-----------------------+ 0x43e0_0000
67	* \| SHMEM 2MiB \|	62	* \| SHMEM 2MiB \|
68	* +-----------------------+ 0x43c0_0000	63	* +-----------------------+ 0x43c0_0000
@@ -75,6 +70,34 @@ · 6 unmodified lines
75	no-map;	70	no-map;
76	reg = <0 0x43200000 0 0x00c00000>;	71	reg = <0 0x43200000 0 0x00c00000>;
77	};	72	};
		73
		74	scp_mem: memory@50000000 {
		75	compatible = "shared-dma-pool";
		76	reg = <0 0x50000000 0 0x2900000>;
		77	no-map;
		78	};
		79
		80	vpu_mem: memory@53000000 {
		81	compatible = "shared-dma-pool";
		82	reg = <0 0x53000000 0 0x1400000>; /* 20 MB */
		83	};
		84
		85	/* 2 MiB reserved for ARM Trusted Firmware (BL31) */
		86	bl31_secmon_mem: memory@54600000 {
		87	no-map;
		88	reg = <0 0x54600000 0x0 0x200000>;
		89	};
		90
		91	snd_dma_mem: memory@60000000 {
		92	compatible = "shared-dma-pool";
		93	reg = <0 0x60000000 0 0x1100000>;
		94	no-map;
		95	};
		96
		97	apu_mem: memory@62000000 {
		98	compatible = "shared-dma-pool";
		99	reg = <0 0x62000000 0 0x1400000>; /* 20 MB */
		100	};
78	};	101	};
79	};	102	};
80		103

arch/arm64/boot/dts/mediatek/mt8195.dtsi+1−0

@@ -313,6 +313,7 @@ · 312 unmodified lines
313	interrupts = <GIC_SPI 18 IRQ_TYPE_LEVEL_HIGH 0>;	313	interrupts = <GIC_SPI 18 IRQ_TYPE_LEVEL_HIGH 0>;
314	cpus = <&cpu0>, <&cpu1>, <&cpu2>, <&cpu3>,	314	cpus = <&cpu0>, <&cpu1>, <&cpu2>, <&cpu3>,
315	<&cpu4>, <&cpu5>, <&cpu6>, <&cpu7>;	315	<&cpu4>, <&cpu5>, <&cpu6>, <&cpu7>;
		316	status = "fail";
316	};	317	};
317		318
318	dmic_codec: dmic-codec {	319	dmic_codec: dmic-codec {

arch/arm64/boot/dts/qcom/sm8150.dtsi+1−1

@@ -3958,7 +3958,7 @@ · 3957 unmodified lines
3958		3958
3959	pdc: interrupt-controller@b220000 {	3959	pdc: interrupt-controller@b220000 {
3960	compatible = "qcom,sm8150-pdc", "qcom,pdc";	3960	compatible = "qcom,sm8150-pdc", "qcom,pdc";
3961	reg = <0 0x0b220000 0 0x400>;	3961	reg = <0 0x0b220000 0 0x30000>;
3962	qcom,pdc-ranges = <0 480 94>, <94 609 31>,	3962	qcom,pdc-ranges = <0 480 94>, <94 609 31>,
3963	<125 63 1>;	3963	<125 63 1>;
3964	#interrupt-cells = <2>;	3964	#interrupt-cells = <2>;

arch/arm64/include/asm/acpi.h+19−0

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#ifndef _ASM_ACPI_H	9	#ifndef _ASM_ACPI_H
10	#define _ASM_ACPI_H	10	#define _ASM_ACPI_H
11		11
		12	#include <linux/cpuidle.h>
12	#include <linux/efi.h>	13	#include <linux/efi.h>
13	#include <linux/memblock.h>	14	#include <linux/memblock.h>
14	#include <linux/psci.h>	15	#include <linux/psci.h>
@@ -44,6 +45,24 @@ · 29 unmodified lines
44		45
45	#define ACPI_MADT_GICC_TRBE (offsetof(struct acpi_madt_generic_interrupt, \	46	#define ACPI_MADT_GICC_TRBE (offsetof(struct acpi_madt_generic_interrupt, \
46	trbe_interrupt) + sizeof(u16))	47	trbe_interrupt) + sizeof(u16))
		48	/*
		49	* Arm® Functional Fixed Hardware Specification Version 1.2.
		50	* Table 2: Arm Architecture context loss flags
		51	*/
		52	#define CPUIDLE_CORE_CTXT BIT(0) /* Core context Lost */
		53
		54	static inline unsigned int arch_get_idle_state_flags(u32 arch_flags)
		55	{
		56	if (arch_flags & CPUIDLE_CORE_CTXT)
		57	return CPUIDLE_FLAG_TIMER_STOP;
		58
		59	return 0;
		60	}
		61	#define arch_get_idle_state_flags arch_get_idle_state_flags
		62
		63	#define CPUIDLE_TRACE_CTXT BIT(1) /* Trace context loss */
		64	#define CPUIDLE_GICR_CTXT BIT(2) /* GICR */
		65	#define CPUIDLE_GICD_CTXT BIT(3) /* GICD */
47		66
48	/* Basic configuration for ACPI */	67	/* Basic configuration for ACPI */
49	#ifdef CONFIG_ACPI	68	#ifdef CONFIG_ACPI

arch/arm64/include/asm/cputype.h+2−0

 #define ARM_CPU_PART_CORTEX_A78AE	0xD42
 #define ARM_CPU_PART_CORTEX_X1		0xD44
 #define ARM_CPU_PART_CORTEX_A510	0xD46
+#define ARM_CPU_PART_CORTEX_A520	0xD80
 #define ARM_CPU_PART_CORTEX_A710	0xD47
 #define ARM_CPU_PART_CORTEX_A715	0xD4D
 #define ARM_CPU_PART_CORTEX_X2		0xD48
 #define MIDR_CORTEX_A78AE	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A78AE)
 #define MIDR_CORTEX_X1	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_X1)
 #define MIDR_CORTEX_A510 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A510)
+#define MIDR_CORTEX_A520 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A520)
 #define MIDR_CORTEX_A710 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A710)
 #define MIDR_CORTEX_A715 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A715)
 #define MIDR_CORTEX_X2 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_X2)

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

@@ -730,6 +730,14 @@ const struct arm64_cpu_capabilities arm64_errata[] = { · 729 unmodified lines
730	.cpu_enable = cpu_clear_bf16_from_user_emulation,	730	.cpu_enable = cpu_clear_bf16_from_user_emulation,
731	},	731	},
732	#endif	732	#endif
		733	#ifdef CONFIG_ARM64_ERRATUM_2966298
		734	{
		735	.desc = "ARM erratum 2966298",
		736	.capability = ARM64_WORKAROUND_2966298,
		737	/* Cortex-A520 r0p0 - r0p1 */
		738	ERRATA_MIDR_REV_RANGE(MIDR_CORTEX_A520, 0, 0, 1),
		739	},
		740	#endif
733	#ifdef CONFIG_AMPERE_ERRATUM_AC03_CPU_38	741	#ifdef CONFIG_AMPERE_ERRATUM_AC03_CPU_38
734	{	742	{
735	.desc = "AmpereOne erratum AC03_CPU_38",	743	.desc = "AmpereOne erratum AC03_CPU_38",

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

 	ldp	x28, x29, [sp, #16 * 14]
 	.if	\el == 0
+alternative_if ARM64_WORKAROUND_2966298
+	tlbi	vale1, xzr
+	dsb	nsh
+alternative_else_nop_endif
 alternative_if_not ARM64_UNMAP_KERNEL_AT_EL0
 	ldr	lr, [sp, #S_LR]
 	add	sp, sp, #PT_REGS_SIZE		// restore sp

arch/arm64/tools/cpucaps+1−0

@@ -84,6 +84,7 @@ WORKAROUND_2077057 · 83 unmodified lines
84	WORKAROUND_2457168	84	WORKAROUND_2457168
85	WORKAROUND_2645198	85	WORKAROUND_2645198
86	WORKAROUND_2658417	86	WORKAROUND_2658417
		87	WORKAROUND_2966298
87	WORKAROUND_AMPERE_AC03_CPU_38	88	WORKAROUND_AMPERE_AC03_CPU_38
88	WORKAROUND_TRBE_OVERWRITE_FILL_MODE	89	WORKAROUND_TRBE_OVERWRITE_FILL_MODE
89	WORKAROUND_TSB_FLUSH_FAILURE	90	WORKAROUND_TSB_FLUSH_FAILURE

arch/ia64/include/asm/cpu.h+0−5

@@ -15,9 +15,4 @@ DECLARE_PER_CPU(struct ia64_cpu, cpu_devices); · 14 unmodified lines
15		15
16	DECLARE_PER_CPU(int, cpu_state);	16	DECLARE_PER_CPU(int, cpu_state);
17		17
18	#ifdef CONFIG_HOTPLUG_CPU
19	extern int arch_register_cpu(int num);
20	extern void arch_unregister_cpu(int);
21	#endif
22
23	#endif /* _ASM_IA64_CPU_H_ */	18	#endif /* _ASM_IA64_CPU_H_ */

arch/ia64/kernel/topology.c+1−1

@@ -59,7 +59,7 @@ void __ref arch_unregister_cpu(int num) · 58 unmodified lines
59	}	59	}
60	EXPORT_SYMBOL(arch_unregister_cpu);	60	EXPORT_SYMBOL(arch_unregister_cpu);
61	#else	61	#else
62	static int __init arch_register_cpu(int num)	62	int __init arch_register_cpu(int num)
63	{	63	{
64	return register_cpu(&sysfs_cpus[num].cpu, num);	64	return register_cpu(&sysfs_cpus[num].cpu, num);
65	}	65	}

arch/parisc/include/asm/ldcw.h+20−17

@@ -2,39 +2,42 @@ · 1 unmodified line
2	#ifndef __PARISC_LDCW_H	2	#ifndef __PARISC_LDCW_H
3	#define __PARISC_LDCW_H	3	#define __PARISC_LDCW_H
4		4
5	#ifndef CONFIG_PA20
6	/* Because kmalloc only guarantees 8-byte alignment for kmalloc'd data,	5	/* Because kmalloc only guarantees 8-byte alignment for kmalloc'd data,
7	and GCC only guarantees 8-byte alignment for stack locals, we can't	6	and GCC only guarantees 8-byte alignment for stack locals, we can't
8	be assured of 16-byte alignment for atomic lock data even if we	7	be assured of 16-byte alignment for atomic lock data even if we
9	specify "__attribute ((aligned(16)))" in the type declaration. So,	8	specify "__attribute ((aligned(16)))" in the type declaration. So,
10	we use a struct containing an array of four ints for the atomic lock	9	we use a struct containing an array of four ints for the atomic lock
11	type and dynamically select the 16-byte aligned int from the array	10	type and dynamically select the 16-byte aligned int from the array
12	for the semaphore. */	11	for the semaphore. */
		12
		13	/* From: "Jim Hull" <jim.hull of hp.com>
		14	I've attached a summary of the change, but basically, for PA 2.0, as
		15	long as the ",CO" (coherent operation) completer is implemented, then the
		16	16-byte alignment requirement for ldcw and ldcd is relaxed, and instead
		17	they only require "natural" alignment (4-byte for ldcw, 8-byte for
		18	ldcd).
		19
		20	Although the cache control hint is accepted by all PA 2.0 processors,
		21	it is only implemented on PA8800/PA8900 CPUs. Prior PA8X00 CPUs still
		22	require 16-byte alignment. If the address is unaligned, the operation
		23	of the instruction is undefined. The ldcw instruction does not generate
		24	unaligned data reference traps so misaligned accesses are not detected.
		25	This hid the problem for years. So, restore the 16-byte alignment dropped
		26	by Kyle McMartin in "Remove __ldcw_align for PA-RISC 2.0 processors". */
13		27
14	#define __PA_LDCW_ALIGNMENT 16	28	#define __PA_LDCW_ALIGNMENT 16
15	#define __PA_LDCW_ALIGN_ORDER 4
16	#define __ldcw_align(a) ({ \	29	#define __ldcw_align(a) ({ \
17	unsigned long __ret = (unsigned long) &(a)->lock[0]; \	30	unsigned long __ret = (unsigned long) &(a)->lock[0]; \
18	__ret = (__ret + __PA_LDCW_ALIGNMENT - 1) \	31	__ret = (__ret + __PA_LDCW_ALIGNMENT - 1) \
19	& ~(__PA_LDCW_ALIGNMENT - 1); \	32	& ~(__PA_LDCW_ALIGNMENT - 1); \
20	(volatile unsigned int *) __ret; \	33	(volatile unsigned int *) __ret; \
21	})	34	})
22	#define __LDCW "ldcw"
23		35
24	#else /CONFIG_PA20/	36	#ifdef CONFIG_PA20
25	/* From: "Jim Hull" <jim.hull of hp.com>
26	I've attached a summary of the change, but basically, for PA 2.0, as
27	long as the ",CO" (coherent operation) completer is specified, then the
28	16-byte alignment requirement for ldcw and ldcd is relaxed, and instead
29	they only require "natural" alignment (4-byte for ldcw, 8-byte for
30	ldcd). */
31
32	#define __PA_LDCW_ALIGNMENT 4
33	#define __PA_LDCW_ALIGN_ORDER 2
34	#define __ldcw_align(a) (&(a)->slock)
35	#define __LDCW "ldcw,co"	37	#define __LDCW "ldcw,co"
36		38	#else
37	#endif /!CONFIG_PA20/	39	#define __LDCW "ldcw"
		40	#endif
38		41
39	/* LDCW, the only atomic read-write operation PA-RISC has. sigh.	42	/* LDCW, the only atomic read-write operation PA-RISC has. sigh.
40	We don't explicitly expose that "*a" may be written as reload	43	We don't explicitly expose that "*a" may be written as reload

arch/parisc/include/asm/spinlock_types.h+0−5

 #ifndef __ASSEMBLY__
 typedef struct {
-#ifdef CONFIG_PA20
-	volatile unsigned int slock;
-# define __ARCH_SPIN_LOCK_UNLOCKED { __ARCH_SPIN_LOCK_UNLOCKED_VAL }
-#else
 	volatile unsigned int lock[4];
 # define __ARCH_SPIN_LOCK_UNLOCKED	\
 	{ { __ARCH_SPIN_LOCK_UNLOCKED_VAL, __ARCH_SPIN_LOCK_UNLOCKED_VAL, \
 	    __ARCH_SPIN_LOCK_UNLOCKED_VAL, __ARCH_SPIN_LOCK_UNLOCKED_VAL } }
-#endif
 } arch_spinlock_t;

arch/parisc/kernel/smp.c+3−1

@@ -440,7 +440,9 @@ int __cpu_up(unsigned int cpu, struct task_struct *tidle) · 439 unmodified lines
440	if (cpu_online(cpu))	440	if (cpu_online(cpu))
441	return 0;	441	return 0;
442		442
443	if (num_online_cpus() < setup_max_cpus && smp_boot_one_cpu(cpu, tidle))	443	if (num_online_cpus() < nr_cpu_ids &&
		444	num_online_cpus() < setup_max_cpus &&
		445	smp_boot_one_cpu(cpu, tidle))
444	return -EIO;	446	return -EIO;
445		447
446	return cpu_online(cpu) ? 0 : -EIO;	448	return cpu_online(cpu) ? 0 : -EIO;

arch/powerpc/include/asm/nohash/32/pte-8xx.h+7−0

@@ -94,6 +94,13 @@ static inline pte_t pte_wrprotect(pte_t pte) · 93 unmodified lines
94		94
95	#define pte_wrprotect pte_wrprotect	95	#define pte_wrprotect pte_wrprotect
96		96
		97	static inline int pte_read(pte_t pte)
		98	{
		99	return (pte_val(pte) & _PAGE_RO) != _PAGE_NA;
		100	}
		101
		102	#define pte_read pte_read
		103
97	static inline int pte_write(pte_t pte)	104	static inline int pte_write(pte_t pte)
98	{	105	{
99	return !(pte_val(pte) & _PAGE_RO);	106	return !(pte_val(pte) & _PAGE_RO);

arch/powerpc/include/asm/nohash/64/pgtable.h+1−1

@@ -197,7 +197,7 @@ static inline int __ptep_test_and_clear_young(struct mm_struct *mm, · 196 unmodified lines
197	{	197	{
198	unsigned long old;	198	unsigned long old;
199		199
200	if (pte_young(*ptep))	200	if (!pte_young(*ptep))
201	return 0;	201	return 0;
202	old = pte_update(mm, addr, ptep, _PAGE_ACCESSED, 0, 0);	202	old = pte_update(mm, addr, ptep, _PAGE_ACCESSED, 0, 0);
203	return (old & _PAGE_ACCESSED) != 0;	203	return (old & _PAGE_ACCESSED) != 0;

arch/powerpc/include/asm/nohash/pgtable.h+2−0

 	return pte_val(pte) & _PAGE_RW;
 }
 #endif
+#ifndef pte_read
 static inline int pte_read(pte_t pte)		{ return 1; }
+#endif
 static inline int pte_dirty(pte_t pte)		{ return pte_val(pte) & _PAGE_DIRTY; }
 static inline int pte_special(pte_t pte)	{ return pte_val(pte) & _PAGE_SPECIAL; }
 static inline int pte_none(pte_t pte)		{ return (pte_val(pte) & ~_PTE_NONE_MASK) == 0; }

arch/powerpc/kernel/entry_32.S+5−3

 	lis	r4,icache_44x_need_flush@ha
 	lwz	r5,icache_44x_need_flush@l(r4)
 	cmplwi	cr0,r5,0
-	bne-	2f
+	bne-	.L44x_icache_flush
 #endif /* CONFIG_PPC_47x */
+.L44x_icache_flush_return:
 	kuep_unlock
 	lwz	r4,_LINK(r1)
 	lwz	r5,_CCR(r1)
 	b	1b
 #ifdef CONFIG_44x
-2:	li	r7,0
+.L44x_icache_flush:
+	li	r7,0
 	iccci	r0,r0
 	stw	r7,icache_44x_need_flush@l(r4)
-	b	1b
+	b	.L44x_icache_flush_return
 #endif  /* CONFIG_44x */
 	.globl	ret_from_fork

arch/powerpc/kernel/head_85xx.S+1−1

@@ -395,7 +395,7 @@ interrupt_base: · 394 unmodified lines
395	#ifdef CONFIG_PPC_FPU	395	#ifdef CONFIG_PPC_FPU
396	FP_UNAVAILABLE_EXCEPTION	396	FP_UNAVAILABLE_EXCEPTION
397	#else	397	#else
398	EXCEPTION(0x0800, FP_UNAVAIL, FloatingPointUnavailable, unknown_exception)	398	EXCEPTION(0x0800, FP_UNAVAIL, FloatingPointUnavailable, emulation_assist_interrupt)
399	#endif	399	#endif
400		400
401	/* System Call Interrupt */	401	/* System Call Interrupt */

arch/powerpc/platforms/pseries/hvCall.S+1−7

 plpar_hcall_trace:
 	HCALL_INST_PRECALL(R5)
-	std	r4,STK_PARAM(R4)(r1)
-	mr	r0,r4
 	mr	r4,r5
 	mr	r5,r6
 	mr	r6,r7
 	HVSC
-	ld	r12,STK_PARAM(R4)(r1)
+	ld	r12,STACK_FRAME_MIN_SIZE+STK_PARAM(R4)(r1)
 	std	r4,0(r12)
 	std	r5,8(r12)
 	std	r6,16(r12)
 plpar_hcall9_trace:
 	HCALL_INST_PRECALL(R5)
-	std	r4,STK_PARAM(R4)(r1)
-	mr	r0,r4
 	mr	r4,r5
 	mr	r5,r6
 	mr	r6,r7

arch/riscv/Makefile+0−1

@@ -6,7 +6,6 @@ · 5 unmodified lines
6	# for more details.	6	# for more details.
7	#	7	#
8		8
9	OBJCOPYFLAGS := -O binary
10	LDFLAGS_vmlinux := -z norelro	9	LDFLAGS_vmlinux := -z norelro
11	ifeq ($(CONFIG_RELOCATABLE),y)	10	ifeq ($(CONFIG_RELOCATABLE),y)
12	LDFLAGS_vmlinux += -shared -Bsymbolic -z notext --emit-relocs	11	LDFLAGS_vmlinux += -shared -Bsymbolic -z notext --emit-relocs

arch/riscv/errata/andes/Makefile+4−0

@@ -1 +1,5 @@
		1	ifdef CONFIG_RISCV_ALTERNATIVE_EARLY
		2	CFLAGS_errata.o := -mcmodel=medany
		3	endif
		4
1	obj-y += errata.o	5	obj-y += errata.o

arch/riscv/include/asm/ftrace.h+21−0

@@ -31,6 +31,27 @@ static inline unsigned long ftrace_call_adjust(unsigned long addr) · 30 unmodified lines
31	return addr;	31	return addr;
32	}	32	}
33		33
		34	/*
		35	* Let's do like x86/arm64 and ignore the compat syscalls.
		36	*/
		37	#define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS
		38	static inline bool arch_trace_is_compat_syscall(struct pt_regs *regs)
		39	{
		40	return is_compat_task();
		41	}
		42
		43	#define ARCH_HAS_SYSCALL_MATCH_SYM_NAME
		44	static inline bool arch_syscall_match_sym_name(const char *sym,
		45	const char *name)
		46	{
		47	/*
		48	* Since all syscall functions have __riscv_ prefix, we must skip it.
		49	* However, as we described above, we decided to ignore compat
		50	* syscalls, so we don't care about __riscv_compat_ prefix here.
		51	*/
		52	return !strcmp(sym + 8, name);
		53	}
		54
34	struct dyn_arch_ftrace {	55	struct dyn_arch_ftrace {
35	};	56	};
36	#endif	57	#endif

arch/riscv/include/asm/kprobes.h+10−1

@@ -40,6 +40,15 @@ void arch_remove_kprobe(struct kprobe *p); · 39 unmodified lines
40	int kprobe_fault_handler(struct pt_regs *regs, unsigned int trapnr);	40	int kprobe_fault_handler(struct pt_regs *regs, unsigned int trapnr);
41	bool kprobe_breakpoint_handler(struct pt_regs *regs);	41	bool kprobe_breakpoint_handler(struct pt_regs *regs);
42	bool kprobe_single_step_handler(struct pt_regs *regs);	42	bool kprobe_single_step_handler(struct pt_regs *regs);
43		43	#else
		44	static inline bool kprobe_breakpoint_handler(struct pt_regs *regs)
		45	{
		46	return false;
		47	}
		48
		49	static inline bool kprobe_single_step_handler(struct pt_regs *regs)
		50	{
		51	return false;
		52	}
44	#endif /* CONFIG_KPROBES */	53	#endif /* CONFIG_KPROBES */
45	#endif /* _ASM_RISCV_KPROBES_H */	54	#endif /* _ASM_RISCV_KPROBES_H */

arch/riscv/include/asm/uprobes.h+12−1

@@ -34,7 +34,18 @@ struct arch_uprobe { · 33 unmodified lines
34	bool simulate;	34	bool simulate;
35	};	35	};
36		36
		37	#ifdef CONFIG_UPROBES
37	bool uprobe_breakpoint_handler(struct pt_regs *regs);	38	bool uprobe_breakpoint_handler(struct pt_regs *regs);
38	bool uprobe_single_step_handler(struct pt_regs *regs);	39	bool uprobe_single_step_handler(struct pt_regs *regs);
39		40	#else
		41	static inline bool uprobe_breakpoint_handler(struct pt_regs *regs)
		42	{
		43	return false;
		44	}
		45
		46	static inline bool uprobe_single_step_handler(struct pt_regs *regs)
		47	{
		48	return false;
		49	}
		50	#endif /* CONFIG_UPROBES */
40	#endif /* _ASM_RISCV_UPROBES_H */	51	#endif /* _ASM_RISCV_UPROBES_H */

arch/riscv/kernel/irq.c+2−2

@@ -60,7 +60,7 @@ static void init_irq_stacks(void) · 59 unmodified lines
60	}	60	}
61	#endif /* CONFIG_VMAP_STACK */	61	#endif /* CONFIG_VMAP_STACK */
62		62
63	#ifdef CONFIG_HAVE_SOFTIRQ_ON_OWN_STACK	63	#ifdef CONFIG_SOFTIRQ_ON_OWN_STACK
64	void do_softirq_own_stack(void)	64	void do_softirq_own_stack(void)
65	{	65	{
66	#ifdef CONFIG_IRQ_STACKS	66	#ifdef CONFIG_IRQ_STACKS
@@ -92,7 +92,7 @@ void do_softirq_own_stack(void) · 25 unmodified lines
92	#endif	92	#endif
93	__do_softirq();	93	__do_softirq();
94	}	94	}
95	#endif /* CONFIG_HAVE_SOFTIRQ_ON_OWN_STACK */	95	#endif /* CONFIG_SOFTIRQ_ON_OWN_STACK */
96		96
97	#else	97	#else
98	static void init_irq_stacks(void) {}	98	static void init_irq_stacks(void) {}

arch/riscv/kernel/setup.c+0−13

@@ -173,19 +173,6 @@ static void __init init_resources(void) · 172 unmodified lines
173	if (ret < 0)	173	if (ret < 0)
174	goto error;	174	goto error;
175		175
176	#ifdef CONFIG_KEXEC_CORE
177	if (crashk_res.start != crashk_res.end) {
178	ret = add_resource(&iomem_resource, &crashk_res);
179	if (ret < 0)
180	goto error;
181	}
182	if (crashk_low_res.start != crashk_low_res.end) {
183	ret = add_resource(&iomem_resource, &crashk_low_res);
184	if (ret < 0)
185	goto error;
186	}
187	#endif
188
189	#ifdef CONFIG_CRASH_DUMP	176	#ifdef CONFIG_CRASH_DUMP
190	if (elfcorehdr_size > 0) {	177	if (elfcorehdr_size > 0) {
191	elfcorehdr_res.start = elfcorehdr_addr;	178	elfcorehdr_res.start = elfcorehdr_addr;

arch/riscv/kernel/signal.c+0−7

@@ -311,13 +311,6 @@ static inline void __user get_sigframe(struct ksignal ksig, · 310 unmodified lines
311	/* Align the stack frame. */	311	/* Align the stack frame. */
312	sp &= ~0xfUL;	312	sp &= ~0xfUL;
313		313
314	/*
315	* Fail if the size of the altstack is not large enough for the
316	* sigframe construction.
317	*/
318	if (current->sas_ss_size && sp < current->sas_ss_sp)
319	return (void __user __force *)-1UL;
320
321	return (void __user *)sp;	314	return (void __user *)sp;
322	}	315	}
323		316

arch/riscv/kernel/traps.c+18−10

 #include <linux/kdebug.h>
 #include <linux/uaccess.h>
 #include <linux/kprobes.h>
+#include <linux/uprobes.h>
+#include <asm/uprobes.h>
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/irq.h>
 	return GET_INSN_LENGTH(insn);
 }
+static bool probe_single_step_handler(struct pt_regs *regs)
+{
+	bool user = user_mode(regs);
+	return user ? uprobe_single_step_handler(regs) : kprobe_single_step_handler(regs);
+}
+static bool probe_breakpoint_handler(struct pt_regs *regs)
+{
+	bool user = user_mode(regs);
+	return user ? uprobe_breakpoint_handler(regs) : kprobe_breakpoint_handler(regs);
+}
 void handle_break(struct pt_regs *regs)
 {
-#ifdef CONFIG_KPROBES
+	if (probe_single_step_handler(regs))
-	if (kprobe_single_step_handler(regs))
 		return;
-	if (kprobe_breakpoint_handler(regs))
+	if (probe_breakpoint_handler(regs))
-		return;
-#endif
-#ifdef CONFIG_UPROBES
-	if (uprobe_single_step_handler(regs))
 		return;
-	if (uprobe_breakpoint_handler(regs))
-		return;
-#endif
 	current->thread.bad_cause = regs->cause;
 	if (user_mode(regs))

arch/riscv/net/bpf_jit_comp64.c+12−6

 	emit_addi(RV_REG_SP, RV_REG_SP, stack_adjust, ctx);
 	/* Set return value. */
 	if (!is_tail_call)
-		emit_mv(RV_REG_A0, RV_REG_A5, ctx);
+		emit_addiw(RV_REG_A0, RV_REG_A5, 0, ctx);
 	emit_jalr(RV_REG_ZERO, is_tail_call ? RV_REG_T3 : RV_REG_RA,
 		  is_tail_call ? (RV_FENTRY_NINSNS + 1) * 4 : 0, /* skip reserved nops and TCC init */
 		  ctx);
 	if (ret)
 		return ret;
-	if (save_ret)
+	if (save_ret) {
-		emit_sd(RV_REG_FP, -retval_off, regmap[BPF_REG_0], ctx);
+		emit_sd(RV_REG_FP, -retval_off, RV_REG_A0, ctx);
+		emit_sd(RV_REG_FP, -(retval_off - 8), regmap[BPF_REG_0], ctx);
+	}
 	/* update branch with beqz */
 	if (ctx->insns) {
 	save_ret = flags & (BPF_TRAMP_F_CALL_ORIG | BPF_TRAMP_F_RET_FENTRY_RET);
 	if (save_ret) {
-		stack_size += 8;
+		stack_size += 16; /* Save both A5 (BPF R0) and A0 */
 		retval_off = stack_size;
 	}
 		if (ret)
 			goto out;
 		emit_sd(RV_REG_FP, -retval_off, RV_REG_A0, ctx);
+		emit_sd(RV_REG_FP, -(retval_off - 8), regmap[BPF_REG_0], ctx);
 		im->ip_after_call = ctx->insns + ctx->ninsns;
 		/* 2 nops reserved for auipc+jalr pair */
 		emit(rv_nop(), ctx);
 	if (flags & BPF_TRAMP_F_RESTORE_REGS)
 		restore_args(nregs, args_off, ctx);
-	if (save_ret)
+	if (save_ret) {
 		emit_ld(RV_REG_A0, -retval_off, RV_REG_FP, ctx);
+		emit_ld(regmap[BPF_REG_0], -(retval_off - 8), RV_REG_FP, ctx);
+	}
 	emit_ld(RV_REG_S1, -sreg_off, RV_REG_FP, ctx);
 		if (ret)
 			return ret;
-		emit_mv(bpf_to_rv_reg(BPF_REG_0, ctx), RV_REG_A0, ctx);
+		if (insn->src_reg != BPF_PSEUDO_CALL)
+			emit_mv(bpf_to_rv_reg(BPF_REG_0, ctx), RV_REG_A0, ctx);
 		break;
 	}
 	/* tail call */

arch/s390/net/bpf_jit_comp.c+21−6

 				 * func_addr's original caller
 				 */
 	int stack_size;		/* Trampoline stack size */
+	int backchain_off;	/* Offset of backchain */
 	int stack_args_off;	/* Offset of stack arguments for calling
 				 * func_addr, has to be at the top
 				 */
 				 * for __bpf_prog_enter() return value and
 				 * func_addr respectively
 				 */
-	int r14_off;		/* Offset of saved %r14 */
 	int run_ctx_off;	/* Offset of struct bpf_tramp_run_ctx */
 	int tccnt_off;		/* Offset of saved tailcall counter */
+	int r14_off;		/* Offset of saved %r14, has to be at the
+				 * bottom */
 	int do_fexit;		/* do_fexit: label */
 };
 	 * Calculate the stack layout.
 	 */
-	/* Reserve STACK_FRAME_OVERHEAD bytes for the callees. */
+	/*
+	 * Allocate STACK_FRAME_OVERHEAD bytes for the callees. As the s390x
+	 * ABI requires, put our backchain at the end of the allocated memory.
+	 */
 	tjit->stack_size = STACK_FRAME_OVERHEAD;
+	tjit->backchain_off = tjit->stack_size - sizeof(u64);
 	tjit->stack_args_off = alloc_stack(tjit, nr_stack_args * sizeof(u64));
 	tjit->reg_args_off = alloc_stack(tjit, nr_reg_args * sizeof(u64));
 	tjit->ip_off = alloc_stack(tjit, sizeof(u64));
 	tjit->bpf_args_off = alloc_stack(tjit, nr_bpf_args * sizeof(u64));
 	tjit->retval_off = alloc_stack(tjit, sizeof(u64));
 	tjit->r7_r8_off = alloc_stack(tjit, 2 * sizeof(u64));
-	tjit->r14_off = alloc_stack(tjit, sizeof(u64));
 	tjit->run_ctx_off = alloc_stack(tjit,
 					sizeof(struct bpf_tramp_run_ctx));
 	tjit->tccnt_off = alloc_stack(tjit, sizeof(u64));
-	/* The caller has already reserved STACK_FRAME_OVERHEAD bytes. */
+	tjit->r14_off = alloc_stack(tjit, sizeof(u64) * 2);
-	tjit->stack_size -= STACK_FRAME_OVERHEAD;
+	/*
+	 * In accordance with the s390x ABI, the caller has allocated
+	 * STACK_FRAME_OVERHEAD bytes for us. 8 of them contain the caller's
+	 * backchain, and the rest we can use.
+	 */
+	tjit->stack_size -= STACK_FRAME_OVERHEAD - sizeof(u64);
 	tjit->orig_stack_args_off = tjit->stack_size + STACK_FRAME_OVERHEAD;
+	/* lgr %r1,%r15 */
+	EMIT4(0xb9040000, REG_1, REG_15);
 	/* aghi %r15,-stack_size */
 	EMIT4_IMM(0xa70b0000, REG_15, -tjit->stack_size);
+	/* stg %r1,backchain_off(%r15) */
+	EMIT6_DISP_LH(0xe3000000, 0x0024, REG_1, REG_0, REG_15,
+		      tjit->backchain_off);
 	/* mvc tccnt_off(4,%r15),stack_size+STK_OFF_TCCNT(%r15) */
 	_EMIT6(0xd203f000 | tjit->tccnt_off,
 	       0xf000 | (tjit->stack_size + STK_OFF_TCCNT));
 			return -E2BIG;
 	}
-	return ret;
+	return tjit.common.prg;
 }
 bool bpf_jit_supports_subprog_tailcalls(void)

arch/x86/events/utils.c+3−2

 // SPDX-License-Identifier: GPL-2.0
 #include <asm/insn.h>
+#include <linux/mm.h>
 #include "perf_event.h"
 		 * The LBR logs any address in the IP, even if the IP just
 		 * faulted. This means userspace can control the from address.
 		 * Ensure we don't blindly read any address by validating it is
-		 * a known text address.
+		 * a known text address and not a vsyscall address.
 		 */
-		if (kernel_text_address(from)) {
+		if (kernel_text_address(from) && !in_gate_area_no_mm(from)) {
 			addr = (void *)from;
 			/*
 			 * Assume we can get the maximum possible size

arch/x86/hyperv/hv_init.c+14−6

@@ -7,6 +7,8 @@ · 6 unmodified lines
7	* Author : K. Y. Srinivasan <kys@microsoft.com>	7	* Author : K. Y. Srinivasan <kys@microsoft.com>
8	*/	8	*/
9		9
		10	#define pr_fmt(fmt) "Hyper-V: " fmt
		11
10	#include <linux/efi.h>	12	#include <linux/efi.h>
11	#include <linux/types.h>	13	#include <linux/types.h>
12	#include <linux/bitfield.h>	14	#include <linux/bitfield.h>
@@ -191,7 +193,7 @@ void set_hv_tscchange_cb(void (*cb)(void)) · 178 unmodified lines
191	struct hv_tsc_emulation_control emu_ctrl = {.enabled = 1};	193	struct hv_tsc_emulation_control emu_ctrl = {.enabled = 1};
192		194
193	if (!hv_reenlightenment_available()) {	195	if (!hv_reenlightenment_available()) {
194	pr_warn("Hyper-V: reenlightenment support is unavailable\n");	196	pr_warn("reenlightenment support is unavailable\n");
195	return;	197	return;
196	}	198	}
197		199
@@ -394,6 +396,7 @@ static void __init hv_get_partition_id(void) · 196 unmodified lines
394	local_irq_restore(flags);	396	local_irq_restore(flags);
395	}	397	}
396		398
		399	#if IS_ENABLED(CONFIG_HYPERV_VTL_MODE)
397	static u8 __init get_vtl(void)	400	static u8 __init get_vtl(void)
398	{	401	{
399	u64 control = HV_HYPERCALL_REP_COMP_1 \| HVCALL_GET_VP_REGISTERS;	402	u64 control = HV_HYPERCALL_REP_COMP_1 \| HVCALL_GET_VP_REGISTERS;
@@ -416,13 +419,16 @@ static u8 __init get_vtl(void) · 16 unmodified lines
416	if (hv_result_success(ret)) {	419	if (hv_result_success(ret)) {
417	ret = output->as64.low & HV_X64_VTL_MASK;	420	ret = output->as64.low & HV_X64_VTL_MASK;
418	} else {	421	} else {
419	pr_err("Failed to get VTL(%lld) and set VTL to zero by default.\n", ret);	422	pr_err("Failed to get VTL(error: %lld) exiting...\n", ret);
420	ret = 0;	423	BUG();
421	}	424	}
422		425
423	local_irq_restore(flags);	426	local_irq_restore(flags);
424	return ret;	427	return ret;
425	}	428	}
		429	#else
		430	static inline u8 get_vtl(void) { return 0; }
		431	#endif
426		432
427	/*	433	/*
428	* This function is to be invoked early in the boot sequence after the	434	* This function is to be invoked early in the boot sequence after the
@@ -564,7 +570,7 @@ skip_hypercall_pg_init: · 135 unmodified lines
564	if (cpu_feature_enabled(X86_FEATURE_IBT) &&	570	if (cpu_feature_enabled(X86_FEATURE_IBT) &&
565	(u32 )hv_hypercall_pg != gen_endbr()) {	571	(u32 )hv_hypercall_pg != gen_endbr()) {
566	setup_clear_cpu_cap(X86_FEATURE_IBT);	572	setup_clear_cpu_cap(X86_FEATURE_IBT);
567	pr_warn("Hyper-V: Disabling IBT because of Hyper-V bug\n");	573	pr_warn("Disabling IBT because of Hyper-V bug\n");
568	}	574	}
569	#endif	575	#endif
570		576
@@ -604,8 +610,10 @@ skip_hypercall_pg_init: · 33 unmodified lines
604	hv_query_ext_cap(0);	610	hv_query_ext_cap(0);
605		611
606	/* Find the VTL */	612	/* Find the VTL */
607	if (!ms_hyperv.paravisor_present && hv_isolation_type_snp())	613	ms_hyperv.vtl = get_vtl();
608	ms_hyperv.vtl = get_vtl();	614
		615	if (ms_hyperv.vtl > 0) /* non default VTL */
		616	hv_vtl_early_init();
609		617
610	return;	618	return;
611		619

arch/x86/hyperv/hv_vtl.c+1−2

 	return hv_vtl_bringup_vcpu(vp_id, start_eip);
 }
-static int __init hv_vtl_early_init(void)
+int __init hv_vtl_early_init(void)
 {
 	/*
 	 * `boot_cpu_has` returns the runtime feature support,
 	return 0;
 }
-early_initcall(hv_vtl_early_init);

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

@@ -28,8 +28,6 @@ struct x86_cpu { · 27 unmodified lines
28	};	28	};
29		29
30	#ifdef CONFIG_HOTPLUG_CPU	30	#ifdef CONFIG_HOTPLUG_CPU
31	extern int arch_register_cpu(int num);
32	extern void arch_unregister_cpu(int);
33	extern void soft_restart_cpu(void);	31	extern void soft_restart_cpu(void);
34	#endif	32	#endif
35		33

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

 #ifdef CONFIG_HYPERV_VTL_MODE
 void __init hv_vtl_init_platform(void);
+int __init hv_vtl_early_init(void);
 #else
 static inline void __init hv_vtl_init_platform(void) {}
+static inline int __init hv_vtl_early_init(void) { return 0; }
 #endif
 #include <asm-generic/mshyperv.h>

arch/x86/include/asm/msr-index.h+7−2

 /* AMD Last Branch Record MSRs */
 #define MSR_AMD64_LBR_SELECT			0xc000010e
-/* Fam 17h MSRs */
+/* Zen4 */
-#define MSR_F17H_IRPERF			0xc00000e9
+#define MSR_ZEN4_BP_CFG			0xc001102e
+#define MSR_ZEN4_BP_CFG_SHARED_BTB_FIX_BIT 5
+/* Zen 2 */
 #define MSR_ZEN2_SPECTRAL_CHICKEN	0xc00110e3
 #define MSR_ZEN2_SPECTRAL_CHICKEN_BIT	BIT_ULL(1)
+/* Fam 17h MSRs */
+#define MSR_F17H_IRPERF			0xc00000e9
 /* Fam 16h MSRs */
 #define MSR_F16H_L2I_PERF_CTL		0xc0010230
 #define MSR_F16H_L2I_PERF_CTR		0xc0010231

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

@@ -129,7 +129,6 @@ void native_smp_send_reschedule(int cpu); · 128 unmodified lines
129	void native_send_call_func_ipi(const struct cpumask *mask);	129	void native_send_call_func_ipi(const struct cpumask *mask);
130	void native_send_call_func_single_ipi(int cpu);	130	void native_send_call_func_single_ipi(int cpu);
131		131
132	bool smp_park_other_cpus_in_init(void);
133	void smp_store_cpu_info(int id);	132	void smp_store_cpu_info(int id);
134		133
135	asmlinkage __visible void smp_reboot_interrupt(void);	134	asmlinkage __visible void smp_reboot_interrupt(void);

arch/x86/kernel/alternative.c+13−0

@@ -403,6 +403,17 @@ void __init_or_module noinline apply_alternatives(struct alt_instr *start, · 402 unmodified lines
403	u8 insn_buff[MAX_PATCH_LEN];	403	u8 insn_buff[MAX_PATCH_LEN];
404		404
405	DPRINTK(ALT, "alt table %px, -> %px", start, end);	405	DPRINTK(ALT, "alt table %px, -> %px", start, end);
		406
		407	/*
		408	* In the case CONFIG_X86_5LEVEL=y, KASAN_SHADOW_START is defined using
		409	* cpu_feature_enabled(X86_FEATURE_LA57) and is therefore patched here.
		410	* During the process, KASAN becomes confused seeing partial LA57
		411	* conversion and triggers a false-positive out-of-bound report.
		412	*
		413	* Disable KASAN until the patching is complete.
		414	*/
		415	kasan_disable_current();
		416
406	/*	417	/*
407	* The scan order should be from start to end. A later scanned	418	* The scan order should be from start to end. A later scanned
408	* alternative code can overwrite previously scanned alternative code.	419	* alternative code can overwrite previously scanned alternative code.
@@ -452,6 +463,8 @@ void __init_or_module noinline apply_alternatives(struct alt_instr *start, · 43 unmodified lines
452		463
453	text_poke_early(instr, insn_buff, insn_buff_sz);	464	text_poke_early(instr, insn_buff, insn_buff_sz);
454	}	465	}
		466
		467	kasan_enable_current();
455	}	468	}
456		469
457	static inline bool is_jcc32(struct insn *insn)	470	static inline bool is_jcc32(struct insn *insn)

arch/x86/kernel/cpu/amd.c+8−0

 	AMD_LEGACY_ERRATUM(AMD_MODEL_RANGE(0x17, 0x00, 0x0, 0x2f, 0xf),
 			   AMD_MODEL_RANGE(0x17, 0x50, 0x0, 0x5f, 0xf));
+static const int amd_erratum_1485[] =
+	AMD_LEGACY_ERRATUM(AMD_MODEL_RANGE(0x19, 0x10, 0x0, 0x1f, 0xf),
+			   AMD_MODEL_RANGE(0x19, 0x60, 0x0, 0xaf, 0xf));
 static bool cpu_has_amd_erratum(struct cpuinfo_x86 *cpu, const int *erratum)
 {
 	int osvw_id = *erratum++;
 		pr_notice_once("AMD Zen1 DIV0 bug detected. Disable SMT for full protection.\n");
 		setup_force_cpu_bug(X86_BUG_DIV0);
 	}
+	if (!cpu_has(c, X86_FEATURE_HYPERVISOR) &&
+	     cpu_has_amd_erratum(c, amd_erratum_1485))
+		msr_set_bit(MSR_ZEN4_BP_CFG, MSR_ZEN4_BP_CFG_SHARED_BTB_FIX_BIT);
 }
 #ifdef CONFIG_X86_32

arch/x86/kernel/cpu/resctrl/monitor.c+5−5

@@ -30,15 +30,15 @@ struct rmid_entry { · 29 unmodified lines
30	struct list_head list;	30	struct list_head list;
31	};	31	};
32		32
33	/**	33	/*
34	* @rmid_free_lru A least recently used list of free RMIDs	34	* @rmid_free_lru - A least recently used list of free RMIDs
35	* These RMIDs are guaranteed to have an occupancy less than the	35	* These RMIDs are guaranteed to have an occupancy less than the
36	* threshold occupancy	36	* threshold occupancy
37	*/	37	*/
38	static LIST_HEAD(rmid_free_lru);	38	static LIST_HEAD(rmid_free_lru);
39		39
40	/**	40	/*
41	* @rmid_limbo_count count of currently unused but (potentially)	41	* @rmid_limbo_count - count of currently unused but (potentially)
42	* dirty RMIDs.	42	* dirty RMIDs.
43	* This counts RMIDs that no one is currently using but that	43	* This counts RMIDs that no one is currently using but that
44	* may have a occupancy value > resctrl_rmid_realloc_threshold. User can	44	* may have a occupancy value > resctrl_rmid_realloc_threshold. User can
@@ -46,7 +46,7 @@ static LIST_HEAD(rmid_free_lru); · 1 unmodified line
46	*/	46	*/
47	static unsigned int rmid_limbo_count;	47	static unsigned int rmid_limbo_count;
48		48
49	/**	49	/*
50	* @rmid_entry - The entry in the limbo and free lists.	50	* @rmid_entry - The entry in the limbo and free lists.
51	*/	51	*/
52	static struct rmid_entry *rmid_ptrs;	52	static struct rmid_entry *rmid_ptrs;

arch/x86/kernel/sev-shared.c+55−14

 	return 0;
 }
-static int sev_cpuid_hv(struct cpuid_leaf *leaf)
+static int __sev_cpuid_hv_msr(struct cpuid_leaf *leaf)
 {
 	int ret;
 	return ret;
 }
+static int __sev_cpuid_hv_ghcb(struct ghcb *ghcb, struct es_em_ctxt *ctxt, struct cpuid_leaf *leaf)
+{
+	u32 cr4 = native_read_cr4();
+	int ret;
+	ghcb_set_rax(ghcb, leaf->fn);
+	ghcb_set_rcx(ghcb, leaf->subfn);
+	if (cr4 & X86_CR4_OSXSAVE)
+		/* Safe to read xcr0 */
+		ghcb_set_xcr0(ghcb, xgetbv(XCR_XFEATURE_ENABLED_MASK));
+	else
+		/* xgetbv will cause #UD - use reset value for xcr0 */
+		ghcb_set_xcr0(ghcb, 1);
+	ret = sev_es_ghcb_hv_call(ghcb, ctxt, SVM_EXIT_CPUID, 0, 0);
+	if (ret != ES_OK)
+		return ret;
+	if (!(ghcb_rax_is_valid(ghcb) &&
+	      ghcb_rbx_is_valid(ghcb) &&
+	      ghcb_rcx_is_valid(ghcb) &&
+	      ghcb_rdx_is_valid(ghcb)))
+		return ES_VMM_ERROR;
+	leaf->eax = ghcb->save.rax;
+	leaf->ebx = ghcb->save.rbx;
+	leaf->ecx = ghcb->save.rcx;
+	leaf->edx = ghcb->save.rdx;
+	return ES_OK;
+}
+static int sev_cpuid_hv(struct ghcb *ghcb, struct es_em_ctxt *ctxt, struct cpuid_leaf *leaf)
+{
+	return ghcb ? __sev_cpuid_hv_ghcb(ghcb, ctxt, leaf)
+		    : __sev_cpuid_hv_msr(leaf);
+}
 /*
  * This may be called early while still running on the initial identity
  * mapping. Use RIP-relative addressing to obtain the correct address
 	return false;
 }
-static void snp_cpuid_hv(struct cpuid_leaf *leaf)
+static void snp_cpuid_hv(struct ghcb *ghcb, struct es_em_ctxt *ctxt, struct cpuid_leaf *leaf)
 {
-	if (sev_cpuid_hv(leaf))
+	if (sev_cpuid_hv(ghcb, ctxt, leaf))
 		sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_CPUID_HV);
 }
-static int snp_cpuid_postprocess(struct cpuid_leaf *leaf)
+static int snp_cpuid_postprocess(struct ghcb *ghcb, struct es_em_ctxt *ctxt,
+				 struct cpuid_leaf *leaf)
 {
 	struct cpuid_leaf leaf_hv = *leaf;
 	switch (leaf->fn) {
 	case 0x1:
-		snp_cpuid_hv(&leaf_hv);
+		snp_cpuid_hv(ghcb, ctxt, &leaf_hv);
 		/* initial APIC ID */
 		leaf->ebx = (leaf_hv.ebx & GENMASK(31, 24)) | (leaf->ebx & GENMASK(23, 0));
 		break;
 	case 0xB:
 		leaf_hv.subfn = 0;
-		snp_cpuid_hv(&leaf_hv);
+		snp_cpuid_hv(ghcb, ctxt, &leaf_hv);
 		/* extended APIC ID */
 		leaf->edx = leaf_hv.edx;
 		}
 		break;
 	case 0x8000001E:
-		snp_cpuid_hv(&leaf_hv);
+		snp_cpuid_hv(ghcb, ctxt, &leaf_hv);
 		/* extended APIC ID */
 		leaf->eax = leaf_hv.eax;
  * Returns -EOPNOTSUPP if feature not enabled. Any other non-zero return value
  * should be treated as fatal by caller.
  */
-static int snp_cpuid(struct cpuid_leaf *leaf)
+static int snp_cpuid(struct ghcb *ghcb, struct es_em_ctxt *ctxt, struct cpuid_leaf *leaf)
 {
 	const struct snp_cpuid_table *cpuid_table = snp_cpuid_get_table();
 			return 0;
 	}
-	return snp_cpuid_postprocess(leaf);
+	return snp_cpuid_postprocess(ghcb, ctxt, leaf);
 }
 /*
 	leaf.fn = fn;
 	leaf.subfn = subfn;
-	ret = snp_cpuid(&leaf);
+	ret = snp_cpuid(NULL, NULL, &leaf);
 	if (!ret)
 		goto cpuid_done;
 	if (ret != -EOPNOTSUPP)
 		goto fail;
-	if (sev_cpuid_hv(&leaf))
+	if (__sev_cpuid_hv_msr(&leaf))
 		goto fail;
 cpuid_done:
 	return ret;
 }
-static int vc_handle_cpuid_snp(struct pt_regs *regs)
+static int vc_handle_cpuid_snp(struct ghcb *ghcb, struct es_em_ctxt *ctxt)
 {
+	struct pt_regs *regs = ctxt->regs;
 	struct cpuid_leaf leaf;
 	int ret;
 	leaf.fn = regs->ax;
 	leaf.subfn = regs->cx;
-	ret = snp_cpuid(&leaf);
+	ret = snp_cpuid(ghcb, ctxt, &leaf);
 	if (!ret) {
 		regs->ax = leaf.eax;
 		regs->bx = leaf.ebx;
 	enum es_result ret;
 	int snp_cpuid_ret;
-	snp_cpuid_ret = vc_handle_cpuid_snp(regs);
+	snp_cpuid_ret = vc_handle_cpuid_snp(ghcb, ctxt);
 	if (!snp_cpuid_ret)
 		return ES_OK;
 	if (snp_cpuid_ret != -EOPNOTSUPP)

arch/x86/kernel/sev.c+1−2

@@ -868,8 +868,7 @@ void snp_set_memory_private(unsigned long vaddr, unsigned long npages) · 867 unmodified lines
868		868
869	void snp_accept_memory(phys_addr_t start, phys_addr_t end)	869	void snp_accept_memory(phys_addr_t start, phys_addr_t end)
870	{	870	{
871	unsigned long vaddr;	871	unsigned long vaddr, npages;
872	unsigned int npages;
873		872
874	if (!cc_platform_has(CC_ATTR_GUEST_SEV_SNP))	873	if (!cc_platform_has(CC_ATTR_GUEST_SEV_SNP))
875	return;	874	return;

arch/x86/kernel/smp.c+7−32

 }
 /*
- * Disable virtualization, APIC etc. and park the CPU in a HLT loop
+ * this function calls the 'stop' function on all other CPUs in the system.
  */
 DEFINE_IDTENTRY_SYSVEC(sysvec_reboot)
 {
 	 * 2) Wait for all other CPUs to report that they reached the
 	 *    HLT loop in stop_this_cpu()
 	 *
-	 * 3) If the system uses INIT/STARTUP for CPU bringup, then
+	 * 3) If #2 timed out send an NMI to the CPUs which did not
-	 *    send all present CPUs an INIT vector, which brings them
+	 *    yet report
-	 *    completely out of the way.
 	 *
-	 * 4) If #3 is not possible and #2 timed out send an NMI to the
+	 * 4) Wait for all other CPUs to report that they reached the
-	 *    CPUs which did not yet report
-	 *
-	 * 5) Wait for all other CPUs to report that they reached the
 	 *    HLT loop in stop_this_cpu()
 	 *
-	 * #4 can obviously race against a CPU reaching the HLT loop late.
+	 * #3 can obviously race against a CPU reaching the HLT loop late.
 	 * That CPU will have reported already and the "have all CPUs
 	 * reached HLT" condition will be true despite the fact that the
 	 * other CPU is still handling the NMI. Again, there is no
 		/*
 		 * Don't wait longer than a second for IPI completion. The
 		 * wait request is not checked here because that would
-		 * prevent an NMI/INIT shutdown in case that not all
+		 * prevent an NMI shutdown attempt in case that not all
 		 * CPUs reach shutdown state.
 		 */
 		timeout = USEC_PER_SEC;
 			udelay(1);
 	}
-	/*
+	/* if the REBOOT_VECTOR didn't work, try with the NMI */
-	 * Park all other CPUs in INIT including "offline" CPUs, if
-	 * possible. That's a safe place where they can't resume execution
-	 * of HLT and then execute the HLT loop from overwritten text or
-	 * page tables.
-	 *
-	 * The only downside is a broadcast MCE, but up to the point where
-	 * the kexec() kernel brought all APs online again an MCE will just
-	 * make HLT resume and handle the MCE. The machine crashes and burns
-	 * due to overwritten text, page tables and data. So there is a
-	 * choice between fire and frying pan. The result is pretty much
-	 * the same. Chose frying pan until x86 provides a sane mechanism
-	 * to park a CPU.
-	 */
-	if (smp_park_other_cpus_in_init())
-		goto done;
-	/*
-	 * If park with INIT was not possible and the REBOOT_VECTOR didn't
-	 * take all secondary CPUs offline, try with the NMI.
-	 */
 	if (!cpumask_empty(&cpus_stop_mask)) {
 		/*
 		 * If NMI IPI is enabled, try to register the stop handler
 			udelay(1);
 	}
-done:
 	local_irq_save(flags);
 	disable_local_APIC();
 	mcheck_cpu_clear(this_cpu_ptr(&cpu_info));

arch/x86/kernel/smpboot.c+0−27

@@ -1240,33 +1240,6 @@ void arch_thaw_secondary_cpus_end(void) · 1239 unmodified lines
1240	cache_aps_init();	1240	cache_aps_init();
1241	}	1241	}
1242		1242
1243	bool smp_park_other_cpus_in_init(void)
1244	{
1245	unsigned int cpu, this_cpu = smp_processor_id();
1246	unsigned int apicid;
1247
1248	if (apic->wakeup_secondary_cpu_64 \|\| apic->wakeup_secondary_cpu)
1249	return false;
1250
1251	/*
1252	* If this is a crash stop which does not execute on the boot CPU,
1253	* then this cannot use the INIT mechanism because INIT to the boot
1254	* CPU will reset the machine.
1255	*/
1256	if (this_cpu)
1257	return false;
1258
1259	for_each_cpu_and(cpu, &cpus_booted_once_mask, cpu_present_mask) {
1260	if (cpu == this_cpu)
1261	continue;
1262	apicid = apic->cpu_present_to_apicid(cpu);
1263	if (apicid == BAD_APICID)
1264	continue;
1265	send_init_sequence(apicid);
1266	}
1267	return true;
1268	}
1269
1270	/*	1243	/*
1271	* Early setup to make printk work.	1244	* Early setup to make printk work.
1272	*/	1245	*/

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

@@ -54,7 +54,7 @@ void arch_unregister_cpu(int num) · 53 unmodified lines
54	EXPORT_SYMBOL(arch_unregister_cpu);	54	EXPORT_SYMBOL(arch_unregister_cpu);
55	#else /* CONFIG_HOTPLUG_CPU */	55	#else /* CONFIG_HOTPLUG_CPU */
56		56
57	static int __init arch_register_cpu(int num)	57	int __init arch_register_cpu(int num)
58	{	58	{
59	return register_cpu(&per_cpu(cpu_devices, num).cpu, num);	59	return register_cpu(&per_cpu(cpu_devices, num).cpu, num);
60	}	60	}

block/fops.c+16−5

 	filemap_invalidate_lock(inode->i_mapping);
-	/* Invalidate the page cache, including dirty pages. */
+	/*
-	error = truncate_bdev_range(bdev, file_to_blk_mode(file), start, end);
+	 * Invalidate the page cache, including dirty pages, for valid
-	if (error)
+	 * de-allocate mode calls to fallocate().
-		goto fail;
+	 */
 	switch (mode) {
 	case FALLOC_FL_ZERO_RANGE:
 	case FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE:
+		error = truncate_bdev_range(bdev, file_to_blk_mode(file), start, end);
+		if (error)
+			goto fail;
 		error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,
 					     len >> SECTOR_SHIFT, GFP_KERNEL,
 					     BLKDEV_ZERO_NOUNMAP);
 		break;
 	case FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE:
+		error = truncate_bdev_range(bdev, file_to_blk_mode(file), start, end);
+		if (error)
+			goto fail;
 		error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,
 					     len >> SECTOR_SHIFT, GFP_KERNEL,
 					     BLKDEV_ZERO_NOFALLBACK);
 		break;
 	case FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE | FALLOC_FL_NO_HIDE_STALE:
+		error = truncate_bdev_range(bdev, file_to_blk_mode(file), start, end);
+		if (error)
+			goto fail;
 		error = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,
 					     len >> SECTOR_SHIFT, GFP_KERNEL);
 		break;

drivers/acpi/acpi_processor.c+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#define pr_fmt(fmt) "ACPI: " fmt	12	#define pr_fmt(fmt) "ACPI: " fmt
13		13
14	#include <linux/acpi.h>	14	#include <linux/acpi.h>
		15	#include <linux/cpu.h>
15	#include <linux/device.h>	16	#include <linux/device.h>
16	#include <linux/dmi.h>	17	#include <linux/dmi.h>
17	#include <linux/kernel.h>	18	#include <linux/kernel.h>

drivers/acpi/ec.c+11−0

@@ -1913,6 +1913,17 @@ static const struct dmi_system_id ec_dmi_table[] __initconst = { · 1912 unmodified lines
1913	DMI_MATCH(DMI_PRODUCT_NAME, "HP 15-cx0041ur"),	1913	DMI_MATCH(DMI_PRODUCT_NAME, "HP 15-cx0041ur"),
1914	},	1914	},
1915	},	1915	},
		1916	{
		1917	/*
		1918	* HP Pavilion Gaming Laptop 15-dk1xxx
		1919	* https://github.com/systemd/systemd/issues/28942
		1920	*/
		1921	.callback = ec_honor_dsdt_gpe,
		1922	.matches = {
		1923	DMI_MATCH(DMI_SYS_VENDOR, "HP"),
		1924	DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion Gaming Laptop 15-dk1xxx"),
		1925	},
		1926	},
1916	{	1927	{
1917	/*	1928	/*
1918	* Samsung hardware	1929	* Samsung hardware

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_idle.c+1−2

 		strscpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN);
 		state->exit_latency = lpi->wake_latency;
 		state->target_residency = lpi->min_residency;
-		if (lpi->arch_flags)
+		state->flags |= arch_get_idle_state_flags(lpi->arch_flags);
-			state->flags |= CPUIDLE_FLAG_TIMER_STOP;
 		if (i != 0 && lpi->entry_method == ACPI_CSTATE_FFH)
 			state->flags |= CPUIDLE_FLAG_RCU_IDLE;
 		state->enter = acpi_idle_lpi_enter;

drivers/acpi/resource.c+20−6

 			DMI_MATCH(DMI_BOARD_NAME, "S5602ZA"),
 		},
 	},
+	{
+		.ident = "Asus ExpertBook B1402CBA",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
+			DMI_MATCH(DMI_BOARD_NAME, "B1402CBA"),
+		},
+	},
 	{
 		.ident = "Asus ExpertBook B1502CBA",
 		.matches = {
 static const struct dmi_system_id pcspecialist_laptop[] = {
 	{
-		.ident = "PCSpecialist Elimina Pro 16 M",
+		/* TongFang GM6BGEQ / PCSpecialist Elimina Pro 16 M, RTX 3050 */
-		/*
-		 * Some models have product-name "Elimina Pro 16 M",
-		 * others "GM6BGEQ". Match on board-name to match both.
-		 */
 		.matches = {
-			DMI_MATCH(DMI_SYS_VENDOR, "PCSpecialist"),
 			DMI_MATCH(DMI_BOARD_NAME, "GM6BGEQ"),
 		},
 	},
+	{
+		/* TongFang GM6BG5Q, RTX 4050 */
+		.matches = {
+			DMI_MATCH(DMI_BOARD_NAME, "GM6BG5Q"),
+		},
+	},
+	{
+		/* TongFang GM6BG0Q / PCSpecialist Elimina Pro 16 M, RTX 4060 */
+		.matches = {
+			DMI_MATCH(DMI_BOARD_NAME, "GM6BG0Q"),
+		},
+	},
 	{ }
 };

drivers/android/binder.c+2−0

 				"undelivered TRANSACTION_ERROR: %u\n",
 				e->cmd);
 		} break;
+		case BINDER_WORK_TRANSACTION_PENDING:
+		case BINDER_WORK_TRANSACTION_ONEWAY_SPAM_SUSPECT:
 		case BINDER_WORK_TRANSACTION_COMPLETE: {
 			binder_debug(BINDER_DEBUG_DEAD_TRANSACTION,
 				"undelivered TRANSACTION_COMPLETE\n");

drivers/ata/pata_parport/fit3.c+2−12

  *
  * The TD-2000 and certain older devices use a different protocol.
  * Try the fit2 protocol module with them.
- *
- * NB:  The FIT adapters do not appear to support the control
- * registers.  So, we map ALT_STATUS to STATUS and NO-OP writes
- * to the device control register - this means that IDE reset
- * will not work on these devices.
  */
 #include <linux/module.h>
 static void fit3_write_regr(struct pi_adapter *pi, int cont, int regr, int val)
 {
-	if (cont == 1)
+	regr += cont << 3;
-		return;
 	switch (pi->mode) {
 	case 0:
 {
 	int  a, b;
-	if (cont) {
+	regr += cont << 3;
-		if (regr != 6)
-			return 0xff;
-		regr = 7;
-	}
 	switch (pi->mode) {
 	case 0:

drivers/ata/pata_parport/pata_parport.c+76−2

@@ -51,6 +51,13 @@ static void pata_parport_dev_select(struct ata_port *ap, unsigned int device) · 50 unmodified lines
51	ata_sff_pause(ap);	51	ata_sff_pause(ap);
52	}	52	}
53		53
		54	static void pata_parport_set_devctl(struct ata_port *ap, u8 ctl)
		55	{
		56	struct pi_adapter *pi = ap->host->private_data;
		57
		58	pi->proto->write_regr(pi, 1, 6, ctl);
		59	}
		60
54	static bool pata_parport_devchk(struct ata_port *ap, unsigned int device)	61	static bool pata_parport_devchk(struct ata_port *ap, unsigned int device)
55	{	62	{
56	struct pi_adapter *pi = ap->host->private_data;	63	struct pi_adapter *pi = ap->host->private_data;
@@ -64,7 +71,7 @@ static bool pata_parport_devchk(struct ata_port *ap, unsigned int device) · 7 unmodified lines
64	pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0xaa);	71	pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0xaa);
65	pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0x55);	72	pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0x55);
66		73
67	pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 055);	74	pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0x55);
68	pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0xaa);	75	pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0xaa);
69		76
70	nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT);	77	nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT);
@@ -73,6 +80,72 @@ static bool pata_parport_devchk(struct ata_port *ap, unsigned int device) · 2 unmodified lines
73	return (nsect == 0x55) && (lbal == 0xaa);	80	return (nsect == 0x55) && (lbal == 0xaa);
74	}	81	}
75		82
		83	static int pata_parport_wait_after_reset(struct ata_link *link,
		84	unsigned int devmask,
		85	unsigned long deadline)
		86	{
		87	struct ata_port *ap = link->ap;
		88	struct pi_adapter *pi = ap->host->private_data;
		89	unsigned int dev0 = devmask & (1 << 0);
		90	unsigned int dev1 = devmask & (1 << 1);
		91	int rc, ret = 0;
		92
		93	ata_msleep(ap, ATA_WAIT_AFTER_RESET);
		94
		95	/* always check readiness of the master device */
		96	rc = ata_sff_wait_ready(link, deadline);
		97	if (rc) {
		98	/*
		99	* some adapters return bogus values if master device is not
		100	* present, so don't abort now if a slave device is present
		101	*/
		102	if (!dev1)
		103	return rc;
		104	ret = -ENODEV;
		105	}
		106
		107	/*
		108	* if device 1 was found in ata_devchk, wait for register
		109	* access briefly, then wait for BSY to clear.
		110	*/
		111	if (dev1) {
		112	int i;
		113
		114	pata_parport_dev_select(ap, 1);
		115
		116	/*
		117	* Wait for register access. Some ATAPI devices fail
		118	* to set nsect/lbal after reset, so don't waste too
		119	* much time on it. We're gonna wait for !BSY anyway.
		120	*/
		121	for (i = 0; i < 2; i++) {
		122	u8 nsect, lbal;
		123
		124	nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT);
		125	lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL);
		126	if (nsect == 1 && lbal == 1)
		127	break;
		128	/* give drive a breather */
		129	ata_msleep(ap, 50);
		130	}
		131
		132	rc = ata_sff_wait_ready(link, deadline);
		133	if (rc) {
		134	if (rc != -ENODEV)
		135	return rc;
		136	ret = rc;
		137	}
		138	}
		139
		140	pata_parport_dev_select(ap, 0);
		141	if (dev1)
		142	pata_parport_dev_select(ap, 1);
		143	if (dev0)
		144	pata_parport_dev_select(ap, 0);
		145
		146	return ret;
		147	}
		148
76	static int pata_parport_bus_softreset(struct ata_port *ap, unsigned int devmask,	149	static int pata_parport_bus_softreset(struct ata_port *ap, unsigned int devmask,
77	unsigned long deadline)	150	unsigned long deadline)
78	{	151	{
@@ -87,7 +160,7 @@ static int pata_parport_bus_softreset(struct ata_port *ap, unsigned int devmask, · 8 unmodified lines
87	ap->last_ctl = ap->ctl;	160	ap->last_ctl = ap->ctl;
88		161
89	/* wait the port to become ready */	162	/* wait the port to become ready */
90	return ata_sff_wait_after_reset(&ap->link, devmask, deadline);	163	return pata_parport_wait_after_reset(&ap->link, devmask, deadline);
91	}	164	}
92		165
93	static int pata_parport_softreset(struct ata_link link, unsigned int classes,	166	static int pata_parport_softreset(struct ata_link link, unsigned int classes,
@@ -252,6 +325,7 @@ static struct ata_port_operations pata_parport_port_ops = { · 158 unmodified lines
252	.hardreset = NULL,	325	.hardreset = NULL,
253		326
254	.sff_dev_select = pata_parport_dev_select,	327	.sff_dev_select = pata_parport_dev_select,
		328	.sff_set_devctl = pata_parport_set_devctl,
255	.sff_check_status = pata_parport_check_status,	329	.sff_check_status = pata_parport_check_status,
256	.sff_check_altstatus = pata_parport_check_altstatus,	330	.sff_check_altstatus = pata_parport_check_altstatus,
257	.sff_tf_load = pata_parport_tf_load,	331	.sff_tf_load = pata_parport_tf_load,

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/nbd.c+2−1

 static void nbd_clear_sock_ioctl(struct nbd_device *nbd)
 {
-	blk_mark_disk_dead(nbd->disk);
 	nbd_clear_sock(nbd);
+	disk_force_media_change(nbd->disk);
+	nbd_bdev_reset(nbd);
 	if (test_and_clear_bit(NBD_RT_HAS_CONFIG_REF,
 			       &nbd->config->runtime_flags))
 		nbd_config_put(nbd);

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/counter/counter-chrdev.c+2−2

@@ -247,8 +247,8 @@ static int counter_get_ext(const struct counter_comp *const ext, · 246 unmodified lines
247	if (*id == component_id)	247	if (*id == component_id)
248	return 0;	248	return 0;
249		249
250	if (ext->type == COUNTER_COMP_ARRAY) {	250	if (ext[*ext_idx].type == COUNTER_COMP_ARRAY) {
251	element = ext->priv;	251	element = ext[*ext_idx].priv;
252		252
253	if (component_id - *id < element->length)	253	if (component_id - *id < element->length)
254	return 0;	254	return 0;

drivers/counter/microchip-tcb-capture.c+1−1

@@ -97,7 +97,7 @@ static int mchp_tc_count_function_write(struct counter_device *counter, · 96 unmodified lines
97	priv->qdec_mode = 0;	97	priv->qdec_mode = 0;
98	/* Set highest rate based on whether soc has gclk or not */	98	/* Set highest rate based on whether soc has gclk or not */
99	bmr &= ~(ATMEL_TC_QDEN \| ATMEL_TC_POSEN);	99	bmr &= ~(ATMEL_TC_QDEN \| ATMEL_TC_POSEN);
100	if (priv->tc_cfg->has_gclk)	100	if (!priv->tc_cfg->has_gclk)
101	cmr \|= ATMEL_TC_TIMER_CLOCK2;	101	cmr \|= ATMEL_TC_TIMER_CLOCK2;
102	else	102	else
103	cmr \|= ATMEL_TC_TIMER_CLOCK1;	103	cmr \|= ATMEL_TC_TIMER_CLOCK1;

drivers/dma-buf/dma-fence-unwrap.c+4−9

@@ -76,16 +76,11 @@ struct dma_fence *__dma_fence_unwrap_merge(unsigned int num_fences, · 75 unmodified lines
76	dma_fence_unwrap_for_each(tmp, &iter[i], fences[i]) {	76	dma_fence_unwrap_for_each(tmp, &iter[i], fences[i]) {
77	if (!dma_fence_is_signaled(tmp)) {	77	if (!dma_fence_is_signaled(tmp)) {
78	++count;	78	++count;
79	} else if (test_bit(DMA_FENCE_FLAG_TIMESTAMP_BIT,
80	&tmp->flags)) {
81	if (ktime_after(tmp->timestamp, timestamp))
82	timestamp = tmp->timestamp;
83	} else {	79	} else {
84	/*	80	ktime_t t = dma_fence_timestamp(tmp);
85	* Use the current time if the fence is	81
86	* currently signaling.	82	if (ktime_after(t, timestamp))
87	*/	83	timestamp = t;
88	timestamp = ktime_get();
89	}	84	}
90	}	85	}
91	}	86	}

drivers/dma-buf/sync_file.c+3−6

 		sizeof(info->driver_name));
 	info->status = dma_fence_get_status(fence);
-	while (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags) &&
-	       !test_bit(DMA_FENCE_FLAG_TIMESTAMP_BIT, &fence->flags))
-		cpu_relax();
 	info->timestamp_ns =
-		test_bit(DMA_FENCE_FLAG_TIMESTAMP_BIT, &fence->flags) ?
+		dma_fence_is_signaled(fence) ?
-		ktime_to_ns(fence->timestamp) :
+			ktime_to_ns(dma_fence_timestamp(fence)) :
-		ktime_set(0, 0);
+			ktime_set(0, 0);
 	return info->status;
 }

drivers/dma/fsl-edma-common.c+22−3

 	edma_writel_chreg(fsl_chan, val, ch_sbr);
-	if (flags & FSL_EDMA_DRV_HAS_CHMUX)
+	if (flags & FSL_EDMA_DRV_HAS_CHMUX) {
-		edma_writel_chreg(fsl_chan, fsl_chan->srcid, ch_mux);
+		/*
+		 * ch_mux: With the exception of 0, attempts to write a value
+		 * already in use will be forced to 0.
+		 */
+		if (!edma_readl_chreg(fsl_chan, ch_mux))
+			edma_writel_chreg(fsl_chan, fsl_chan->srcid, ch_mux);
+	}
 	val = edma_readl_chreg(fsl_chan, ch_csr);
 	val |= EDMA_V3_CH_CSR_ERQ;
 	edma_write_tcdreg(fsl_chan, tcd->dlast_sga, dlast_sga);
+	csr = le16_to_cpu(tcd->csr);
 	if (fsl_chan->is_sw) {
-		csr = le16_to_cpu(tcd->csr);
 		csr |= EDMA_TCD_CSR_START;
 		tcd->csr = cpu_to_le16(csr);
 	}
+	/*
+	 * Must clear CHn_CSR[DONE] bit before enable TCDn_CSR[ESG] at EDMAv3
+	 * eDMAv4 have not such requirement.
+	 * Change MLINK need clear CHn_CSR[DONE] for both eDMAv3 and eDMAv4.
+	 */
+	if (((fsl_edma_drvflags(fsl_chan) & FSL_EDMA_DRV_CLEAR_DONE_E_SG) &&
+		(csr & EDMA_TCD_CSR_E_SG)) ||
+	    ((fsl_edma_drvflags(fsl_chan) & FSL_EDMA_DRV_CLEAR_DONE_E_LINK) &&
+		(csr & EDMA_TCD_CSR_E_LINK)))
+		edma_writel_chreg(fsl_chan, edma_readl_chreg(fsl_chan, ch_csr), ch_csr);
 	edma_write_tcdreg(fsl_chan, tcd->csr, csr);
 }

drivers/dma/fsl-edma-common.h+13−1

@@ -183,11 +183,23 @@ struct fsl_edma_desc { · 182 unmodified lines
183	#define FSL_EDMA_DRV_BUS_8BYTE BIT(10)	183	#define FSL_EDMA_DRV_BUS_8BYTE BIT(10)
184	#define FSL_EDMA_DRV_DEV_TO_DEV BIT(11)	184	#define FSL_EDMA_DRV_DEV_TO_DEV BIT(11)
185	#define FSL_EDMA_DRV_ALIGN_64BYTE BIT(12)	185	#define FSL_EDMA_DRV_ALIGN_64BYTE BIT(12)
		186	/* Need clean CHn_CSR DONE before enable TCD's ESG */
		187	#define FSL_EDMA_DRV_CLEAR_DONE_E_SG BIT(13)
		188	/* Need clean CHn_CSR DONE before enable TCD's MAJORELINK */
		189	#define FSL_EDMA_DRV_CLEAR_DONE_E_LINK BIT(14)
186		190
187	#define FSL_EDMA_DRV_EDMA3 (FSL_EDMA_DRV_SPLIT_REG \| \	191	#define FSL_EDMA_DRV_EDMA3 (FSL_EDMA_DRV_SPLIT_REG \| \
188	FSL_EDMA_DRV_BUS_8BYTE \| \	192	FSL_EDMA_DRV_BUS_8BYTE \| \
189	FSL_EDMA_DRV_DEV_TO_DEV \| \	193	FSL_EDMA_DRV_DEV_TO_DEV \| \
190	FSL_EDMA_DRV_ALIGN_64BYTE)	194	FSL_EDMA_DRV_ALIGN_64BYTE \| \
		195	FSL_EDMA_DRV_CLEAR_DONE_E_SG \| \
		196	FSL_EDMA_DRV_CLEAR_DONE_E_LINK)
		197
		198	#define FSL_EDMA_DRV_EDMA4 (FSL_EDMA_DRV_SPLIT_REG \| \
		199	FSL_EDMA_DRV_BUS_8BYTE \| \
		200	FSL_EDMA_DRV_DEV_TO_DEV \| \
		201	FSL_EDMA_DRV_ALIGN_64BYTE \| \
		202	FSL_EDMA_DRV_CLEAR_DONE_E_LINK)
191		203
192	struct fsl_edma_drvdata {	204	struct fsl_edma_drvdata {
193	u32 dmamuxs; /* only used before v3 */	205	u32 dmamuxs; /* only used before v3 */

drivers/dma/fsl-edma-main.c+5−3

 		fsl_chan = to_fsl_edma_chan(chan);
 		i = fsl_chan - fsl_edma->chans;
-		chan = dma_get_slave_channel(chan);
-		chan->device->privatecnt++;
 		fsl_chan->priority = dma_spec->args[1];
 		fsl_chan->is_rxchan = dma_spec->args[2] & ARGS_RX;
 		fsl_chan->is_remote = dma_spec->args[2] & ARGS_REMOTE;
 		fsl_chan->is_multi_fifo = dma_spec->args[2] & ARGS_MULTI_FIFO;
 		if (!b_chmux && i == dma_spec->args[0]) {
+			chan = dma_get_slave_channel(chan);
+			chan->device->privatecnt++;
 			mutex_unlock(&fsl_edma->fsl_edma_mutex);
 			return chan;
 		} else if (b_chmux && !fsl_chan->srcid) {
 			/* if controller support channel mux, choose a free channel */
+			chan = dma_get_slave_channel(chan);
+			chan->device->privatecnt++;
 			fsl_chan->srcid = dma_spec->args[0];
 			mutex_unlock(&fsl_edma->fsl_edma_mutex);
 			return chan;
 };
 static struct fsl_edma_drvdata imx93_data4 = {
-	.flags = FSL_EDMA_DRV_HAS_CHMUX | FSL_EDMA_DRV_HAS_DMACLK | FSL_EDMA_DRV_EDMA3,
+	.flags = FSL_EDMA_DRV_HAS_CHMUX | FSL_EDMA_DRV_HAS_DMACLK | FSL_EDMA_DRV_EDMA4,
 	.chreg_space_sz = 0x8000,
 	.chreg_off = 0x10000,
 	.setup_irq = fsl_edma3_irq_init,

drivers/dma/idxd/device.c+3−2

 	union idxd_command_reg cmd;
 	DECLARE_COMPLETION_ONSTACK(done);
 	u32 stat;
+	unsigned long flags;
 	if (idxd_device_is_halted(idxd)) {
 		dev_warn(&idxd->pdev->dev, "Device is HALTED!\n");
 	cmd.operand = operand;
 	cmd.int_req = 1;
-	spin_lock(&idxd->cmd_lock);
+	spin_lock_irqsave(&idxd->cmd_lock, flags);
 	wait_event_lock_irq(idxd->cmd_waitq,
 			    !test_bit(IDXD_FLAG_CMD_RUNNING, &idxd->flags),
 			    idxd->cmd_lock);
 	 * After command submitted, release lock and go to sleep until
 	 * the command completes via interrupt.
 	 */
-	spin_unlock(&idxd->cmd_lock);
+	spin_unlock_irqrestore(&idxd->cmd_lock, flags);
 	wait_for_completion(&done);
 	stat = ioread32(idxd->reg_base + IDXD_CMDSTS_OFFSET);
 	spin_lock(&idxd->cmd_lock);

drivers/dma/mediatek/mtk-uart-apdma.c+1−2

@@ -450,9 +450,8 @@ static int mtk_uart_apdma_device_pause(struct dma_chan *chan) · 449 unmodified lines
450	mtk_uart_apdma_write(c, VFF_EN, VFF_EN_CLR_B);	450	mtk_uart_apdma_write(c, VFF_EN, VFF_EN_CLR_B);
451	mtk_uart_apdma_write(c, VFF_INT_EN, VFF_INT_EN_CLR_B);	451	mtk_uart_apdma_write(c, VFF_INT_EN, VFF_INT_EN_CLR_B);
452		452
453	synchronize_irq(c->irq);
454
455	spin_unlock_irqrestore(&c->vc.lock, flags);	453	spin_unlock_irqrestore(&c->vc.lock, flags);
		454	synchronize_irq(c->irq);
456		455
457	return 0;	456	return 0;
458	}	457	}

drivers/dma/ste_dma40.c+1−0

@@ -3668,6 +3668,7 @@ static int __init d40_probe(struct platform_device *pdev) · 3667 unmodified lines
3668	regulator_disable(base->lcpa_regulator);	3668	regulator_disable(base->lcpa_regulator);
3669	regulator_put(base->lcpa_regulator);	3669	regulator_put(base->lcpa_regulator);
3670	}	3670	}
		3671	pm_runtime_disable(base->dev);
3671		3672
3672	report_failure:	3673	report_failure:
3673	d40_err(dev, "probe failed\n");	3674	d40_err(dev, "probe failed\n");

drivers/dma/stm32-dma.c+7−4

 		chan->chan_reg.dma_scr &= ~STM32_DMA_SCR_PFCTRL;
 	/* Activate Double Buffer Mode if DMA triggers STM32 MDMA and more than 1 sg */
-	if (chan->trig_mdma && sg_len > 1)
+	if (chan->trig_mdma && sg_len > 1) {
 		chan->chan_reg.dma_scr |= STM32_DMA_SCR_DBM;
+		chan->chan_reg.dma_scr &= ~STM32_DMA_SCR_CT;
+	}
 	for_each_sg(sgl, sg, sg_len, i) {
 		ret = stm32_dma_set_xfer_param(chan, direction, &buswidth,
 	residue = stm32_dma_get_remaining_bytes(chan);
-	if (chan->desc->cyclic && !stm32_dma_is_current_sg(chan)) {
+	if ((chan->desc->cyclic || chan->trig_mdma) && !stm32_dma_is_current_sg(chan)) {
 		n_sg++;
 		if (n_sg == chan->desc->num_sgs)
 			n_sg = 0;
-		residue = sg_req->len;
+		if (!chan->trig_mdma)
+			residue = sg_req->len;
 	}
 	/*
 	 * residue = remaining bytes from NDTR + remaining
 	 * periods/sg to be transferred
 	 */
-	if (!chan->desc->cyclic || n_sg != 0)
+	if ((!chan->desc->cyclic && !chan->trig_mdma) || n_sg != 0)
 		for (i = n_sg; i < desc->num_sgs; i++)
 			residue += desc->sg_req[i].len;

drivers/dma/stm32-mdma.c+24−9

@@ -777,8 +777,6 @@ static int stm32_mdma_setup_xfer(struct stm32_mdma_chan *chan, · 776 unmodified lines
777	/* Enable interrupts */	777	/* Enable interrupts */
778	ccr &= ~STM32_MDMA_CCR_IRQ_MASK;	778	ccr &= ~STM32_MDMA_CCR_IRQ_MASK;
779	ccr \|= STM32_MDMA_CCR_TEIE \| STM32_MDMA_CCR_CTCIE;	779	ccr \|= STM32_MDMA_CCR_TEIE \| STM32_MDMA_CCR_CTCIE;
780	if (sg_len > 1)
781	ccr \|= STM32_MDMA_CCR_BTIE;
782	desc->ccr = ccr;	780	desc->ccr = ccr;
783		781
784	return 0;	782	return 0;
@@ -1236,6 +1234,10 @@ static int stm32_mdma_resume(struct dma_chan *c) · 451 unmodified lines
1236	unsigned long flags;	1234	unsigned long flags;
1237	u32 status, reg;	1235	u32 status, reg;
1238		1236
		1237	/* Transfer can be terminated */
		1238	if (!chan->desc \|\| (stm32_mdma_read(dmadev, STM32_MDMA_CCR(chan->id)) & STM32_MDMA_CCR_EN))
		1239	return -EPERM;
		1240
1239	hwdesc = chan->desc->node[chan->curr_hwdesc].hwdesc;	1241	hwdesc = chan->desc->node[chan->curr_hwdesc].hwdesc;
1240		1242
1241	spin_lock_irqsave(&chan->vchan.lock, flags);	1243	spin_lock_irqsave(&chan->vchan.lock, flags);
@@ -1316,21 +1318,35 @@ static int stm32_mdma_slave_config(struct dma_chan *c, · 74 unmodified lines
1316		1318
1317	static size_t stm32_mdma_desc_residue(struct stm32_mdma_chan *chan,	1319	static size_t stm32_mdma_desc_residue(struct stm32_mdma_chan *chan,
1318	struct stm32_mdma_desc *desc,	1320	struct stm32_mdma_desc *desc,
1319	u32 curr_hwdesc)	1321	u32 curr_hwdesc,
		1322	struct dma_tx_state *state)
1320	{	1323	{
1321	struct stm32_mdma_device *dmadev = stm32_mdma_get_dev(chan);	1324	struct stm32_mdma_device *dmadev = stm32_mdma_get_dev(chan);
1322	struct stm32_mdma_hwdesc *hwdesc;	1325	struct stm32_mdma_hwdesc *hwdesc;
1323	u32 cbndtr, residue, modulo, burst_size;	1326	u32 cisr, clar, cbndtr, residue, modulo, burst_size;
1324	int i;	1327	int i;
1325		1328
		1329	cisr = stm32_mdma_read(dmadev, STM32_MDMA_CISR(chan->id));
		1330
1326	residue = 0;	1331	residue = 0;
1327	for (i = curr_hwdesc + 1; i < desc->count; i++) {	1332	/* Get the next hw descriptor to process from current transfer */
		1333	clar = stm32_mdma_read(dmadev, STM32_MDMA_CLAR(chan->id));
		1334	for (i = desc->count - 1; i >= 0; i--) {
1328	hwdesc = desc->node[i].hwdesc;	1335	hwdesc = desc->node[i].hwdesc;
		1336
		1337	if (hwdesc->clar == clar)
		1338	break;/* Current transfer found, stop cumulating */
		1339
		1340	/* Cumulate residue of unprocessed hw descriptors */
1329	residue += STM32_MDMA_CBNDTR_BNDT(hwdesc->cbndtr);	1341	residue += STM32_MDMA_CBNDTR_BNDT(hwdesc->cbndtr);
1330	}	1342	}
1331	cbndtr = stm32_mdma_read(dmadev, STM32_MDMA_CBNDTR(chan->id));	1343	cbndtr = stm32_mdma_read(dmadev, STM32_MDMA_CBNDTR(chan->id));
1332	residue += cbndtr & STM32_MDMA_CBNDTR_BNDT_MASK;	1344	residue += cbndtr & STM32_MDMA_CBNDTR_BNDT_MASK;
1333		1345
		1346	state->in_flight_bytes = 0;
		1347	if (chan->chan_config.m2m_hw && (cisr & STM32_MDMA_CISR_CRQA))
		1348	state->in_flight_bytes = cbndtr & STM32_MDMA_CBNDTR_BNDT_MASK;
		1349
1334	if (!chan->mem_burst)	1350	if (!chan->mem_burst)
1335	return residue;	1351	return residue;
1336		1352
@@ -1360,11 +1376,10 @@ static enum dma_status stm32_mdma_tx_status(struct dma_chan *c, · 23 unmodified lines
1360		1376
1361	vdesc = vchan_find_desc(&chan->vchan, cookie);	1377	vdesc = vchan_find_desc(&chan->vchan, cookie);
1362	if (chan->desc && cookie == chan->desc->vdesc.tx.cookie)	1378	if (chan->desc && cookie == chan->desc->vdesc.tx.cookie)
1363	residue = stm32_mdma_desc_residue(chan, chan->desc,	1379	residue = stm32_mdma_desc_residue(chan, chan->desc, chan->curr_hwdesc, state);
1364	chan->curr_hwdesc);
1365	else if (vdesc)	1380	else if (vdesc)
1366	residue = stm32_mdma_desc_residue(chan,	1381	residue = stm32_mdma_desc_residue(chan, to_stm32_mdma_desc(vdesc), 0, state);
1367	to_stm32_mdma_desc(vdesc), 0);	1382
1368	dma_set_residue(state, residue);	1383	dma_set_residue(state, residue);
1369		1384
1370	spin_unlock_irqrestore(&chan->vchan.lock, flags);	1385	spin_unlock_irqrestore(&chan->vchan.lock, flags);

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/gpio/gpio-aspeed.c+1−1

@@ -973,7 +973,7 @@ static int aspeed_gpio_set_config(struct gpio_chip *chip, unsigned int offset, · 972 unmodified lines
973	else if (param == PIN_CONFIG_BIAS_DISABLE \|\|	973	else if (param == PIN_CONFIG_BIAS_DISABLE \|\|
974	param == PIN_CONFIG_BIAS_PULL_DOWN \|\|	974	param == PIN_CONFIG_BIAS_PULL_DOWN \|\|
975	param == PIN_CONFIG_DRIVE_STRENGTH)	975	param == PIN_CONFIG_DRIVE_STRENGTH)
976	return pinctrl_gpio_set_config(offset, config);	976	return pinctrl_gpio_set_config(chip->base + offset, config);
977	else if (param == PIN_CONFIG_DRIVE_OPEN_DRAIN \|\|	977	else if (param == PIN_CONFIG_DRIVE_OPEN_DRAIN \|\|
978	param == PIN_CONFIG_DRIVE_OPEN_SOURCE)	978	param == PIN_CONFIG_DRIVE_OPEN_SOURCE)
979	/* Return -ENOTSUPP to trigger emulation, as per datasheet */	979	/* Return -ENOTSUPP to trigger emulation, as per datasheet */

drivers/gpio/gpio-pxa.c+1−0

@@ -237,6 +237,7 @@ static bool pxa_gpio_has_pinctrl(void) · 236 unmodified lines
237	switch (gpio_type) {	237	switch (gpio_type) {
238	case PXA3XX_GPIO:	238	case PXA3XX_GPIO:
239	case MMP2_GPIO:	239	case MMP2_GPIO:
		240	case MMP_GPIO:
240	return false;	241	return false;
241		242
242	default:	243	default:

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

@@ -2093,7 +2093,7 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev) · 2092 unmodified lines
2093	adev->flags \|= AMD_IS_PX;	2093	adev->flags \|= AMD_IS_PX;
2094		2094
2095	if (!(adev->flags & AMD_IS_APU)) {	2095	if (!(adev->flags & AMD_IS_APU)) {
2096	parent = pci_upstream_bridge(adev->pdev);	2096	parent = pcie_find_root_port(adev->pdev);
2097	adev->has_pr3 = parent ? pci_pr3_present(parent) : false;	2097	adev->has_pr3 = parent ? pci_pr3_present(parent) : false;
2098	}	2098	}
2099		2099

drivers/gpu/drm/amd/amdgpu/amdgpu_doorbell_mgr.c+4−0

@@ -142,6 +142,10 @@ int amdgpu_doorbell_create_kernel_doorbells(struct amdgpu_device *adev) · 141 unmodified lines
142	int r;	142	int r;
143	int size;	143	int size;
144		144
		145	/* SI HW does not have doorbells, skip allocation */
		146	if (adev->doorbell.num_kernel_doorbells == 0)
		147	return 0;
		148
145	/* Reserve first num_kernel_doorbells (page-aligned) for kernel ops */	149	/* Reserve first num_kernel_doorbells (page-aligned) for kernel ops */
146	size = ALIGN(adev->doorbell.num_kernel_doorbells * sizeof(u32), PAGE_SIZE);	150	size = ALIGN(adev->doorbell.num_kernel_doorbells * sizeof(u32), PAGE_SIZE);
147		151

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

@@ -170,6 +170,7 @@ int amdgpu_fru_get_product_info(struct amdgpu_device *adev) · 169 unmodified lines
170	csum += pia[size - 1];	170	csum += pia[size - 1];
171	if (csum) {	171	if (csum) {
172	DRM_ERROR("Bad Product Info Area checksum: 0x%02x", csum);	172	DRM_ERROR("Bad Product Info Area checksum: 0x%02x", csum);
		173	kfree(pia);
173	return -EIO;	174	return -EIO;
174	}	175	}
175		176

drivers/gpu/drm/amd/amdgpu/amdgpu_object.h+1−1

@@ -252,7 +252,7 @@ static inline bool amdgpu_bo_in_cpu_visible_vram(struct amdgpu_bo *bo) · 251 unmodified lines
252	struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);	252	struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
253	struct amdgpu_res_cursor cursor;	253	struct amdgpu_res_cursor cursor;
254		254
255	if (bo->tbo.resource->mem_type != TTM_PL_VRAM)	255	if (!bo->tbo.resource \|\| bo->tbo.resource->mem_type != TTM_PL_VRAM)
256	return false;	256	return false;
257		257
258	amdgpu_res_first(bo->tbo.resource, 0, amdgpu_bo_size(bo), &cursor);	258	amdgpu_res_first(bo->tbo.resource, 0, amdgpu_bo_size(bo), &cursor);

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn20/dcn20_clk_mgr.c+2−2

@@ -157,7 +157,7 @@ void dcn20_update_clocks_update_dentist(struct clk_mgr_internal *clk_mgr, struct · 156 unmodified lines
157	int32_t N;	157	int32_t N;
158	int32_t j;	158	int32_t j;
159		159
160	if (!pipe_ctx->stream)	160	if (!resource_is_pipe_type(pipe_ctx, OTG_MASTER))
161	continue;	161	continue;
162	/* Virtual encoders don't have this function */	162	/* Virtual encoders don't have this function */
163	if (!stream_enc->funcs->get_fifo_cal_average_level)	163	if (!stream_enc->funcs->get_fifo_cal_average_level)
@@ -188,7 +188,7 @@ void dcn20_update_clocks_update_dentist(struct clk_mgr_internal *clk_mgr, struct · 24 unmodified lines
188	int32_t N;	188	int32_t N;
189	int32_t j;	189	int32_t j;
190		190
191	if (!pipe_ctx->stream)	191	if (!resource_is_pipe_type(pipe_ctx, OTG_MASTER))
192	continue;	192	continue;
193	/* Virtual encoders don't have this function */	193	/* Virtual encoders don't have this function */
194	if (!stream_enc->funcs->get_fifo_cal_average_level)	194	if (!stream_enc->funcs->get_fifo_cal_average_level)

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn32/dcn32_clk_mgr.c+2−2

@@ -355,7 +355,7 @@ static void dcn32_update_clocks_update_dentist( · 354 unmodified lines
355	int32_t N;	355	int32_t N;
356	int32_t j;	356	int32_t j;
357		357
358	if (!pipe_ctx->stream)	358	if (!resource_is_pipe_type(pipe_ctx, OTG_MASTER))
359	continue;	359	continue;
360	/* Virtual encoders don't have this function */	360	/* Virtual encoders don't have this function */
361	if (!stream_enc->funcs->get_fifo_cal_average_level)	361	if (!stream_enc->funcs->get_fifo_cal_average_level)
@@ -401,7 +401,7 @@ static void dcn32_update_clocks_update_dentist( · 39 unmodified lines
401	int32_t N;	401	int32_t N;
402	int32_t j;	402	int32_t j;
403		403
404	if (!pipe_ctx->stream)	404	if (!resource_is_pipe_type(pipe_ctx, OTG_MASTER))
405	continue;	405	continue;
406	/* Virtual encoders don't have this function */	406	/* Virtual encoders don't have this function */
407	if (!stream_enc->funcs->get_fifo_cal_average_level)	407	if (!stream_enc->funcs->get_fifo_cal_average_level)

drivers/gpu/drm/amd/display/dc/core/dc.c+3−0

@@ -1262,6 +1262,9 @@ static void disable_vbios_mode_if_required( · 1261 unmodified lines
1262	if (stream == NULL)	1262	if (stream == NULL)
1263	continue;	1263	continue;
1264		1264
		1265	if (stream->apply_seamless_boot_optimization)
		1266	continue;
		1267
1265	// only looking for first odm pipe	1268	// only looking for first odm pipe
1266	if (pipe->prev_odm_pipe)	1269	if (pipe->prev_odm_pipe)
1267	continue;	1270	continue;

drivers/gpu/drm/amd/pm/amdgpu_pm.c+1−0

@@ -2040,6 +2040,7 @@ static int default_attr_update(struct amdgpu_device *adev, struct amdgpu_device_ · 2039 unmodified lines
2040	case IP_VERSION(11, 0, 0):	2040	case IP_VERSION(11, 0, 0):
2041	case IP_VERSION(11, 0, 1):	2041	case IP_VERSION(11, 0, 1):
2042	case IP_VERSION(11, 0, 2):	2042	case IP_VERSION(11, 0, 2):
		2043	case IP_VERSION(11, 0, 3):
2043	*states = ATTR_STATE_SUPPORTED;	2044	*states = ATTR_STATE_SUPPORTED;
2044	break;	2045	break;
2045	default:	2046	default:

drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c+23−18

 	return ret;
 }
+#define MAX(a, b)	((a) > (b) ? (a) : (b))
 static int sienna_cichlid_update_pcie_parameters(struct smu_context *smu,
 					 uint32_t pcie_gen_cap,
 					 uint32_t pcie_width_cap)
 {
 	struct smu_11_0_dpm_context *dpm_context = smu->smu_dpm.dpm_context;
 	struct smu_11_0_pcie_table *pcie_table = &dpm_context->dpm_tables.pcie_table;
-	u32 smu_pcie_arg;
+	uint8_t *table_member1, *table_member2;
+	uint32_t min_gen_speed, max_gen_speed;
+	uint32_t min_lane_width, max_lane_width;
+	uint32_t smu_pcie_arg;
 	int ret, i;
-	/* PCIE gen speed and lane width override */
+	GET_PPTABLE_MEMBER(PcieGenSpeed, &table_member1);
-	if (!amdgpu_device_pcie_dynamic_switching_supported()) {
+	GET_PPTABLE_MEMBER(PcieLaneCount, &table_member2);
-		if (pcie_table->pcie_gen[NUM_LINK_LEVELS - 1] < pcie_gen_cap)
-			pcie_gen_cap = pcie_table->pcie_gen[NUM_LINK_LEVELS - 1];
-		if (pcie_table->pcie_lane[NUM_LINK_LEVELS - 1] < pcie_width_cap)
+	min_gen_speed = MAX(0, table_member1[0]);
-			pcie_width_cap = pcie_table->pcie_lane[NUM_LINK_LEVELS - 1];
+	max_gen_speed = MIN(pcie_gen_cap, table_member1[1]);
+	min_gen_speed = min_gen_speed > max_gen_speed ?
+			max_gen_speed : min_gen_speed;
+	min_lane_width = MAX(1, table_member2[0]);
+	max_lane_width = MIN(pcie_width_cap, table_member2[1]);
+	min_lane_width = min_lane_width > max_lane_width ?
+			 max_lane_width : min_lane_width;
-		/* Force all levels to use the same settings */
+	if (!amdgpu_device_pcie_dynamic_switching_supported()) {
-		for (i = 0; i < NUM_LINK_LEVELS; i++) {
+		pcie_table->pcie_gen[0] = max_gen_speed;
-			pcie_table->pcie_gen[i] = pcie_gen_cap;
+		pcie_table->pcie_lane[0] = max_lane_width;
-			pcie_table->pcie_lane[i] = pcie_width_cap;
-		}
 	} else {
-		for (i = 0; i < NUM_LINK_LEVELS; i++) {
+		pcie_table->pcie_gen[0] = min_gen_speed;
-			if (pcie_table->pcie_gen[i] > pcie_gen_cap)
+		pcie_table->pcie_lane[0] = min_lane_width;
-				pcie_table->pcie_gen[i] = pcie_gen_cap;
-			if (pcie_table->pcie_lane[i] > pcie_width_cap)
-				pcie_table->pcie_lane[i] = pcie_width_cap;
-		}
 	}
+	pcie_table->pcie_gen[1] = max_gen_speed;
+	pcie_table->pcie_lane[1] = max_lane_width;
 	for (i = 0; i < NUM_LINK_LEVELS; i++) {
 		smu_pcie_arg = (i << 16 |

drivers/gpu/drm/drm_atomic_helper.c+13−4

 update_connector_routing(struct drm_atomic_state *state,
 			 struct drm_connector *connector,
 			 struct drm_connector_state *old_connector_state,
-			 struct drm_connector_state *new_connector_state)
+			 struct drm_connector_state *new_connector_state,
+			 bool added_by_user)
 {
 	const struct drm_connector_helper_funcs *funcs;
 	struct drm_encoder *new_encoder;
 	 * there's a chance the connector may have been destroyed during the
 	 * process, but it's better to ignore that then cause
 	 * drm_atomic_helper_resume() to fail.
+	 *
+	 * Last, we want to ignore connector registration when the connector
+	 * was not pulled in the atomic state by user-space (ie, was pulled
+	 * in by the driver, e.g. when updating a DP-MST stream).
 	 */
 	if (!state->duplicated && drm_connector_is_unregistered(connector) &&
-	    crtc_state->active) {
+	    added_by_user && crtc_state->active) {
 		drm_dbg_atomic(connector->dev,
 			       "[CONNECTOR:%d:%s] is not registered\n",
 			       connector->base.id, connector->name);
 	struct drm_connector *connector;
 	struct drm_connector_state *old_connector_state, *new_connector_state;
 	int i, ret;
-	unsigned int connectors_mask = 0;
+	unsigned int connectors_mask = 0, user_connectors_mask = 0;
+	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i)
+		user_connectors_mask |= BIT(i);
 	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
 		bool has_connectors =
 		 */
 		ret = update_connector_routing(state, connector,
 					       old_connector_state,
-					       new_connector_state);
+					       new_connector_state,
+					       BIT(i) & user_connectors_mask);
 		if (ret)
 			return ret;
 		if (old_connector_state->crtc) {

drivers/gpu/drm/drm_gem.c+4−2

 	struct page **pages;
 	struct folio *folio;
 	struct folio_batch fbatch;
-	int i, j, npages;
+	long i, j, npages;
 	if (WARN_ON(!obj->filp))
 		return ERR_PTR(-EINVAL);
 	i = 0;
 	while (i < npages) {
+		long nr;
 		folio = shmem_read_folio_gfp(mapping, i,
 				mapping_gfp_mask(mapping));
 		if (IS_ERR(folio))
 			goto fail;
-		for (j = 0; j < folio_nr_pages(folio); j++, i++)
+		nr = min(npages - i, folio_nr_pages(folio));
+		for (j = 0; j < nr; j++, i++)
 			pages[i] = folio_file_page(folio, i);
 		/* Make sure shmem keeps __GFP_DMA32 allocated pages in the

drivers/gpu/drm/drm_panel_orientation_quirks.c+16−0

@@ -38,6 +38,14 @@ static const struct drm_dmi_panel_orientation_data gpd_micropc = { · 37 unmodified lines
38	.orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP,	38	.orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP,
39	};	39	};
40		40
		41	static const struct drm_dmi_panel_orientation_data gpd_onemix2s = {
		42	.width = 1200,
		43	.height = 1920,
		44	.bios_dates = (const char * const []){ "05/21/2018", "10/26/2018",
		45	"03/04/2019", NULL },
		46	.orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP,
		47	};
		48
41	static const struct drm_dmi_panel_orientation_data gpd_pocket = {	49	static const struct drm_dmi_panel_orientation_data gpd_pocket = {
42	.width = 1200,	50	.width = 1200,
43	.height = 1920,	51	.height = 1920,
@@ -401,6 +409,14 @@ static const struct dmi_system_id orientation_data[] = { · 357 unmodified lines
401	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "LTH17"),	409	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "LTH17"),
402	},	410	},
403	.driver_data = (void *)&lcd800x1280_rightside_up,	411	.driver_data = (void *)&lcd800x1280_rightside_up,
		412	}, { /* One Mix 2S (generic strings, also match on bios date) */
		413	.matches = {
		414	DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Default string"),
		415	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Default string"),
		416	DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "Default string"),
		417	DMI_EXACT_MATCH(DMI_BOARD_NAME, "Default string"),
		418	},
		419	.driver_data = (void *)&gpd_onemix2s,
404	},	420	},
405	{}	421	{}
406	};	422	};

drivers/gpu/drm/i915/gem/i915_gem_pages.c+1−1

@@ -198,7 +198,7 @@ static void flush_tlb_invalidate(struct drm_i915_gem_object *obj) · 197 unmodified lines
198		198
199	for_each_gt(gt, i915, id) {	199	for_each_gt(gt, i915, id) {
200	if (!obj->mm.tlb[id])	200	if (!obj->mm.tlb[id])
201	return;	201	continue;
202		202
203	intel_gt_invalidate_tlb_full(gt, obj->mm.tlb[id]);	203	intel_gt_invalidate_tlb_full(gt, obj->mm.tlb[id]);
204	obj->mm.tlb[id] = 0;	204	obj->mm.tlb[id] = 0;

drivers/gpu/drm/i915/gt/gen8_engine_cs.c+10−1

@@ -271,8 +271,17 @@ int gen12_emit_flush_rcs(struct i915_request *rq, u32 mode) · 270 unmodified lines
271	if (GRAPHICS_VER_FULL(rq->i915) >= IP_VER(12, 70))	271	if (GRAPHICS_VER_FULL(rq->i915) >= IP_VER(12, 70))
272	bit_group_0 \|= PIPE_CONTROL_CCS_FLUSH;	272	bit_group_0 \|= PIPE_CONTROL_CCS_FLUSH;
273		273
		274	/*
		275	* L3 fabric flush is needed for AUX CCS invalidation
		276	* which happens as part of pipe-control so we can
		277	* ignore PIPE_CONTROL_FLUSH_L3. Also PIPE_CONTROL_FLUSH_L3
		278	* deals with Protected Memory which is not needed for
		279	* AUX CCS invalidation and lead to unwanted side effects.
		280	*/
		281	if (mode & EMIT_FLUSH)
		282	bit_group_1 \|= PIPE_CONTROL_FLUSH_L3;
		283
274	bit_group_1 \|= PIPE_CONTROL_TILE_CACHE_FLUSH;	284	bit_group_1 \|= PIPE_CONTROL_TILE_CACHE_FLUSH;
275	bit_group_1 \|= PIPE_CONTROL_FLUSH_L3;
276	bit_group_1 \|= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;	285	bit_group_1 \|= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;
277	bit_group_1 \|= PIPE_CONTROL_DEPTH_CACHE_FLUSH;	286	bit_group_1 \|= PIPE_CONTROL_DEPTH_CACHE_FLUSH;
278	/* Wa_1409600907:tgl,adl-p */	287	/* Wa_1409600907:tgl,adl-p */

drivers/gpu/drm/i915/i915_gem.c+7−2

 			goto err_unlock;
 	}
+	/*
+	 * Register engines early to ensure the engine list is in its final
+	 * rb-tree form, lowering the amount of code that has to deal with
+	 * the intermediate llist state.
+	 */
+	intel_engines_driver_register(dev_priv);
 	return 0;
 	/*
 void i915_gem_driver_register(struct drm_i915_private *i915)
 {
 	i915_gem_driver_register__shrinker(i915);
-	intel_engines_driver_register(i915);
 }
 void i915_gem_driver_unregister(struct drm_i915_private *i915)

drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c+18−9

@@ -119,6 +119,7 @@ static u64 _dpu_plane_calc_bw(const struct dpu_mdss_cfg *catalog, · 118 unmodified lines
119	struct dpu_sw_pipe_cfg *pipe_cfg)	119	struct dpu_sw_pipe_cfg *pipe_cfg)
120	{	120	{
121	int src_width, src_height, dst_height, fps;	121	int src_width, src_height, dst_height, fps;
		122	u64 plane_pixel_rate, plane_bit_rate;
122	u64 plane_prefill_bw;	123	u64 plane_prefill_bw;
123	u64 plane_bw;	124	u64 plane_bw;
124	u32 hw_latency_lines;	125	u32 hw_latency_lines;
@@ -136,13 +137,12 @@ static u64 _dpu_plane_calc_bw(const struct dpu_mdss_cfg *catalog, · 11 unmodified lines
136	scale_factor = src_height > dst_height ?	137	scale_factor = src_height > dst_height ?
137	mult_frac(src_height, 1, dst_height) : 1;	138	mult_frac(src_height, 1, dst_height) : 1;
138		139
139	plane_bw =	140	plane_pixel_rate = src_width * mode->vtotal * fps;
140	src_width * mode->vtotal * fps * fmt->bpp *	141	plane_bit_rate = plane_pixel_rate * fmt->bpp;
141	scale_factor;
142		142
143	plane_prefill_bw =	143	plane_bw = plane_bit_rate * scale_factor;
144	src_width * hw_latency_lines * fps * fmt->bpp *	144
145	scale_factor * mode->vtotal;	145	plane_prefill_bw = plane_bw * hw_latency_lines;
146		146
147	if ((vbp+vpw) > hw_latency_lines)	147	if ((vbp+vpw) > hw_latency_lines)
148	do_div(plane_prefill_bw, (vbp+vpw));	148	do_div(plane_prefill_bw, (vbp+vpw));
@@ -733,9 +733,11 @@ static int dpu_plane_check_inline_rotation(struct dpu_plane *pdpu, · 584 unmodified lines
733	static int dpu_plane_atomic_check_pipe(struct dpu_plane *pdpu,	733	static int dpu_plane_atomic_check_pipe(struct dpu_plane *pdpu,
734	struct dpu_sw_pipe *pipe,	734	struct dpu_sw_pipe *pipe,
735	struct dpu_sw_pipe_cfg *pipe_cfg,	735	struct dpu_sw_pipe_cfg *pipe_cfg,
736	const struct dpu_format *fmt)	736	const struct dpu_format *fmt,
		737	const struct drm_display_mode *mode)
737	{	738	{
738	uint32_t min_src_size;	739	uint32_t min_src_size;
		740	struct dpu_kms *kms = _dpu_plane_get_kms(&pdpu->base);
739		741
740	min_src_size = DPU_FORMAT_IS_YUV(fmt) ? 2 : 1;	742	min_src_size = DPU_FORMAT_IS_YUV(fmt) ? 2 : 1;
741		743
@@ -774,6 +776,12 @@ static int dpu_plane_atomic_check_pipe(struct dpu_plane *pdpu, · 32 unmodified lines
774	return -EINVAL;	776	return -EINVAL;
775	}	777	}
776		778
		779	/* max clk check */
		780	if (_dpu_plane_calc_clk(mode, pipe_cfg) > kms->perf.max_core_clk_rate) {
		781	DPU_DEBUG_PLANE(pdpu, "plane exceeds max mdp core clk limits\n");
		782	return -E2BIG;
		783	}
		784
777	return 0;	785	return 0;
778	}	786	}
779		787
@@ -899,12 +907,13 @@ static int dpu_plane_atomic_check(struct drm_plane *plane, · 119 unmodified lines
899	r_pipe_cfg->dst_rect.x1 = pipe_cfg->dst_rect.x2;	907	r_pipe_cfg->dst_rect.x1 = pipe_cfg->dst_rect.x2;
900	}	908	}
901		909
902	ret = dpu_plane_atomic_check_pipe(pdpu, pipe, pipe_cfg, fmt);	910	ret = dpu_plane_atomic_check_pipe(pdpu, pipe, pipe_cfg, fmt, &crtc_state->adjusted_mode);
903	if (ret)	911	if (ret)
904	return ret;	912	return ret;
905		913
906	if (r_pipe->sspp) {	914	if (r_pipe->sspp) {
907	ret = dpu_plane_atomic_check_pipe(pdpu, r_pipe, r_pipe_cfg, fmt);	915	ret = dpu_plane_atomic_check_pipe(pdpu, r_pipe, r_pipe_cfg, fmt,
		916	&crtc_state->adjusted_mode);
908	if (ret)	917	if (ret)
909	return ret;	918	return ret;
910	}	919	}

drivers/gpu/drm/msm/dp/dp_ctrl.c+6−7

 		return rc;
 	while (--link_train_max_retries) {
-		rc = dp_ctrl_reinitialize_mainlink(ctrl);
-		if (rc) {
-			DRM_ERROR("Failed to reinitialize mainlink. rc=%d\n",
-					rc);
-			break;
-		}
 		training_step = DP_TRAINING_NONE;
 		rc = dp_ctrl_setup_main_link(ctrl, &training_step);
 		if (rc == 0) {
 			/* stop link training before start re training  */
 			dp_ctrl_clear_training_pattern(ctrl);
 		}
+		rc = dp_ctrl_reinitialize_mainlink(ctrl);
+		if (rc) {
+			DRM_ERROR("Failed to reinitialize mainlink. rc=%d\n", rc);
+			break;
+		}
 	}
 	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)

drivers/gpu/drm/msm/dp/dp_link.c+2−2

@@ -1090,7 +1090,7 @@ int dp_link_process_request(struct dp_link *dp_link) · 1089 unmodified lines
1090	} else if (dp_link_read_psr_error_status(link)) {	1090	} else if (dp_link_read_psr_error_status(link)) {
1091	DRM_ERROR("PSR IRQ_HPD received\n");	1091	DRM_ERROR("PSR IRQ_HPD received\n");
1092	} else if (dp_link_psr_capability_changed(link)) {	1092	} else if (dp_link_psr_capability_changed(link)) {
1093	drm_dbg_dp(link->drm_dev, "PSR Capability changed");	1093	drm_dbg_dp(link->drm_dev, "PSR Capability changed\n");
1094	} else {	1094	} else {
1095	ret = dp_link_process_link_status_update(link);	1095	ret = dp_link_process_link_status_update(link);
1096	if (!ret) {	1096	if (!ret) {
@@ -1107,7 +1107,7 @@ int dp_link_process_request(struct dp_link *dp_link) · 10 unmodified lines
1107	}	1107	}
1108	}	1108	}
1109		1109
1110	drm_dbg_dp(link->drm_dev, "sink request=%#x",	1110	drm_dbg_dp(link->drm_dev, "sink request=%#x\n",
1111	dp_link->sink_request);	1111	dp_link->sink_request);
1112	return ret;	1112	return ret;
1113	}	1113	}

drivers/gpu/drm/msm/dsi/dsi_host.c+15−4

 static void dsi_wait4video_eng_busy(struct msm_dsi_host *msm_host)
 {
+	u32 data;
 	if (!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO))
 		return;
+	data = dsi_read(msm_host, REG_DSI_STATUS0);
+	/* if video mode engine is not busy, its because
+	 * either timing engine was not turned on or the
+	 * DSI controller has finished transmitting the video
+	 * data already, so no need to wait in those cases
+	 */
+	if (!(data & DSI_STATUS0_VIDEO_MODE_ENGINE_BUSY))
+		return;
 	if (msm_host->power_on && msm_host->enabled) {
 		dsi_wait4video_done(msm_host);
 		/* delay 4 ms to skip BLLP */
 	}
 	msm_host->irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
-	if (msm_host->irq < 0) {
+	if (!msm_host->irq) {
-		ret = msm_host->irq;
+		dev_err(&pdev->dev, "failed to get irq\n");
-		dev_err(&pdev->dev, "failed to get irq: %d\n", ret);
+		return -EINVAL;
-		return ret;
 	}
 	/* do not autoenable, will be enabled later */

drivers/gpu/drm/msm/msm_mdss.c+1−1

@@ -511,7 +511,7 @@ static int mdss_remove(struct platform_device *pdev) · 510 unmodified lines
511	static const struct msm_mdss_data msm8998_data = {	511	static const struct msm_mdss_data msm8998_data = {
512	.ubwc_enc_version = UBWC_1_0,	512	.ubwc_enc_version = UBWC_1_0,
513	.ubwc_dec_version = UBWC_1_0,	513	.ubwc_dec_version = UBWC_1_0,
514	.highest_bank_bit = 1,	514	.highest_bank_bit = 2,
515	};	515	};
516		516
517	static const struct msm_mdss_data qcm2290_data = {	517	static const struct msm_mdss_data qcm2290_data = {

drivers/gpu/drm/nouveau/nouveau_abi16.c+21−0

@@ -31,6 +31,7 @@ · 30 unmodified lines
31		31
32	#include "nouveau_drv.h"	32	#include "nouveau_drv.h"
33	#include "nouveau_dma.h"	33	#include "nouveau_dma.h"
		34	#include "nouveau_exec.h"
34	#include "nouveau_gem.h"	35	#include "nouveau_gem.h"
35	#include "nouveau_chan.h"	36	#include "nouveau_chan.h"
36	#include "nouveau_abi16.h"	37	#include "nouveau_abi16.h"
@@ -183,6 +184,20 @@ nouveau_abi16_fini(struct nouveau_abi16 *abi16) · 146 unmodified lines
183	cli->abi16 = NULL;	184	cli->abi16 = NULL;
184	}	185	}
185		186
		187	static inline int
		188	getparam_dma_ib_max(struct nvif_device *device)
		189	{
		190	const struct nvif_mclass dmas[] = {
		191	{ NV03_CHANNEL_DMA, 0 },
		192	{ NV10_CHANNEL_DMA, 0 },
		193	{ NV17_CHANNEL_DMA, 0 },
		194	{ NV40_CHANNEL_DMA, 0 },
		195	{}
		196	};
		197
		198	return nvif_mclass(&device->object, dmas) < 0 ? NV50_DMA_IB_MAX : 0;
		199	}
		200
186	int	201	int
187	nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)	202	nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)
188	{	203	{
@@ -247,6 +262,12 @@ nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS) · 58 unmodified lines
247	case NOUVEAU_GETPARAM_GRAPH_UNITS:	262	case NOUVEAU_GETPARAM_GRAPH_UNITS:
248	getparam->value = nvkm_gr_units(gr);	263	getparam->value = nvkm_gr_units(gr);
249	break;	264	break;
		265	case NOUVEAU_GETPARAM_EXEC_PUSH_MAX: {
		266	int ib_max = getparam_dma_ib_max(device);
		267
		268	getparam->value = nouveau_exec_push_max_from_ib_max(ib_max);
		269	break;
		270	}
250	default:	271	default:
251	NV_PRINTK(dbg, cli, "unknown parameter %lld\n", getparam->param);	272	NV_PRINTK(dbg, cli, "unknown parameter %lld\n", getparam->param);
252	return -EINVAL;	273	return -EINVAL;

drivers/gpu/drm/nouveau/nouveau_chan.c+7−8

 nouveau_channel_ctor(struct nouveau_drm *drm, struct nvif_device *device, bool priv, u64 runm,
 		     struct nouveau_channel **pchan)
 {
-	static const struct {
+	const struct nvif_mclass hosts[] = {
-		s32 oclass;
-		int version;
-	} hosts[] = {
 		{  AMPERE_CHANNEL_GPFIFO_B, 0 },
 		{  AMPERE_CHANNEL_GPFIFO_A, 0 },
 		{  TURING_CHANNEL_GPFIFO_A, 0 },
 	}
 	/* initialise dma tracking parameters */
-	switch (chan->user.oclass & 0x00ff) {
+	switch (chan->user.oclass) {
-	case 0x006b:
+	case NV03_CHANNEL_DMA:
-	case 0x006e:
+	case NV10_CHANNEL_DMA:
+	case NV17_CHANNEL_DMA:
+	case NV40_CHANNEL_DMA:
 		chan->user_put = 0x40;
 		chan->user_get = 0x44;
 		chan->dma.max = (0x10000 / 4) - 2;
 		chan->user_get = 0x44;
 		chan->user_get_hi = 0x60;
 		chan->dma.ib_base =  0x10000 / 4;
-		chan->dma.ib_max  = (0x02000 / 8) - 1;
+		chan->dma.ib_max  = NV50_DMA_IB_MAX;
 		chan->dma.ib_put  = 0;
 		chan->dma.ib_free = chan->dma.ib_max - chan->dma.ib_put;
 		chan->dma.max = chan->dma.ib_base;

drivers/gpu/drm/nouveau/nouveau_dma.h+3−0

@@ -49,6 +49,9 @@ void nv50_dma_push(struct nouveau_channel *, u64 addr, u32 length, · 48 unmodified lines
49	/* Maximum push buffer size. */	49	/* Maximum push buffer size. */
50	#define NV50_DMA_PUSH_MAX_LENGTH 0x7fffff	50	#define NV50_DMA_PUSH_MAX_LENGTH 0x7fffff
51		51
		52	/* Maximum IBs per ring. */
		53	#define NV50_DMA_IB_MAX ((0x02000 / 8) - 1)
		54
52	/* Object handles - for stuff that's doesn't use handle == oclass. */	55	/* Object handles - for stuff that's doesn't use handle == oclass. */
53	enum {	56	enum {
54	NvDmaFB = 0x80000002,	57	NvDmaFB = 0x80000002,

drivers/gpu/drm/nouveau/nouveau_exec.c+4−3

 	struct nouveau_channel *chan = NULL;
 	struct nouveau_exec_job_args args = {};
 	struct drm_nouveau_exec *req = data;
-	int ret = 0;
+	int push_max, ret = 0;
 	if (unlikely(!abi16))
 		return -ENOMEM;
 	if (!chan->dma.ib_max)
 		return nouveau_abi16_put(abi16, -ENOSYS);
-	if (unlikely(req->push_count > NOUVEAU_GEM_MAX_PUSH)) {
+	push_max = nouveau_exec_push_max_from_ib_max(chan->dma.ib_max);
+	if (unlikely(req->push_count > push_max)) {
 		NV_PRINTK(err, cli, "pushbuf push count exceeds limit: %d max %d\n",
-			 req->push_count, NOUVEAU_GEM_MAX_PUSH);
+			  req->push_count, push_max);
 		return nouveau_abi16_put(abi16, -EINVAL);
 	}

drivers/gpu/drm/nouveau/nouveau_exec.h+10−0

@@ -51,4 +51,14 @@ int nouveau_exec_job_init(struct nouveau_exec_job **job, · 50 unmodified lines
51	int nouveau_exec_ioctl_exec(struct drm_device dev, void data,	51	int nouveau_exec_ioctl_exec(struct drm_device dev, void data,
52	struct drm_file *file_priv);	52	struct drm_file *file_priv);
53		53
		54	static inline unsigned int
		55	nouveau_exec_push_max_from_ib_max(int ib_max)
		56	{
		57	/* Limit the number of IBs per job to half the size of the ring in order
		58	* to avoid the ring running dry between submissions and preserve one
		59	* more slot for the job's HW fence.
		60	*/
		61	return ib_max > 1 ? ib_max / 2 - 1 : 0;
		62	}
		63
54	#endif	64	#endif

drivers/gpu/drm/panel/panel-boe-tv101wum-nl6.c+1−3

 	_INIT_DCS_CMD(0xB1, 0x01, 0xBF, 0x11),
 	_INIT_DCS_CMD(0xCB, 0x86),
 	_INIT_DCS_CMD(0xD2, 0x3C, 0xFA),
-	_INIT_DCS_CMD(0xE9, 0xC5),
+	_INIT_DCS_CMD(0xD3, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0C, 0x01),
-	_INIT_DCS_CMD(0xD3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0C, 0x01),
-	_INIT_DCS_CMD(0xE9, 0x3F),
 	_INIT_DCS_CMD(0xE7, 0x02, 0x00, 0x28, 0x01, 0x7E, 0x0F, 0x7E, 0x10, 0xA0, 0x00, 0x00, 0x20, 0x40, 0x50, 0x40),
 	_INIT_DCS_CMD(0xBD, 0x02),
 	_INIT_DCS_CMD(0xD8, 0xFF, 0xFF, 0xBF, 0xFE, 0xAA, 0xA0, 0xFF, 0xFF, 0xBF, 0xFE, 0xAA, 0xA0),

drivers/gpu/drm/scheduler/sched_main.c+1−1

@@ -929,7 +929,7 @@ drm_sched_get_cleanup_job(struct drm_gpu_scheduler *sched) · 928 unmodified lines
929		929
930	if (next) {	930	if (next) {
931	next->s_fence->scheduled.timestamp =	931	next->s_fence->scheduled.timestamp =
932	job->s_fence->finished.timestamp;	932	dma_fence_timestamp(&job->s_fence->finished);
933	/* start TO timer for next job */	933	/* start TO timer for next job */
934	drm_sched_start_timeout(sched);	934	drm_sched_start_timeout(sched);
935	}	935	}

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

@@ -118,7 +118,7 @@ void drm_kunit_helper_free_device(struct kunit test, struct device dev) · 117 unmodified lines
118		118
119	kunit_release_action(test,	119	kunit_release_action(test,
120	kunit_action_platform_driver_unregister,	120	kunit_action_platform_driver_unregister,
121	pdev);	121	&fake_platform_driver);
122	}	122	}
123	EXPORT_SYMBOL_GPL(drm_kunit_helper_free_device);	123	EXPORT_SYMBOL_GPL(drm_kunit_helper_free_device);
124		124

drivers/gpu/drm/tiny/simpledrm.c+1−1

@@ -745,7 +745,7 @@ static struct simpledrm_device simpledrm_device_create(struct drm_driver drv, · 744 unmodified lines
745		745
746	ret = devm_aperture_acquire_from_firmware(dev, res->start, resource_size(res));	746	ret = devm_aperture_acquire_from_firmware(dev, res->start, resource_size(res));
747	if (ret) {	747	if (ret) {
748	drm_err(dev, "could not acquire memory range %pr: %d\n", &res, ret);	748	drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret);
749	return ERR_PTR(ret);	749	return ERR_PTR(ret);
750	}	750	}
751		751

drivers/gpu/drm/vmwgfx/vmwgfx_bo.c+4−3

 static void vmw_bo_release(struct vmw_bo *vbo)
 {
+	WARN_ON(vbo->tbo.base.funcs &&
+		kref_read(&vbo->tbo.base.refcount) != 0);
 	vmw_bo_unmap(vbo);
 	drm_gem_object_release(&vbo->tbo.base);
 }
 		if (!(flags & drm_vmw_synccpu_allow_cs)) {
 			atomic_dec(&vmw_bo->cpu_writers);
 		}
-		vmw_user_bo_unref(vmw_bo);
+		vmw_user_bo_unref(&vmw_bo);
 	}
 	return ret;
 			return ret;
 		ret = vmw_user_bo_synccpu_grab(vbo, arg->flags);
-		vmw_user_bo_unref(vbo);
+		vmw_user_bo_unref(&vbo);
 		if (unlikely(ret != 0)) {
 			if (ret == -ERESTARTSYS || ret == -EBUSY)
 				return -EBUSY;
 	}
 	*out = to_vmw_bo(gobj);
-	ttm_bo_get(&(*out)->tbo);
 	return 0;
 }

drivers/gpu/drm/vmwgfx/vmwgfx_bo.h+12−5

@@ -195,12 +195,19 @@ static inline struct vmw_bo vmw_bo_reference(struct vmw_bo buf) · 194 unmodified lines
195	return buf;	195	return buf;
196	}	196	}
197		197
198	static inline void vmw_user_bo_unref(struct vmw_bo *vbo)	198	static inline struct vmw_bo vmw_user_bo_ref(struct vmw_bo vbo)
199	{	199	{
200	if (vbo) {	200	drm_gem_object_get(&vbo->tbo.base);
201	ttm_bo_put(&vbo->tbo);	201	return vbo;
202	drm_gem_object_put(&vbo->tbo.base);	202	}
203	}	203
		204	static inline void vmw_user_bo_unref(struct vmw_bo **buf)
		205	{
		206	struct vmw_bo tmp_buf = buf;
		207
		208	*buf = NULL;
		209	if (tmp_buf)
		210	drm_gem_object_put(&tmp_buf->tbo.base);
204	}	211	}
205		212
206	static inline struct vmw_bo to_vmw_bo(struct drm_gem_object gobj)	213	static inline struct vmw_bo to_vmw_bo(struct drm_gem_object gobj)

drivers/gpu/drm/vmwgfx/vmwgfx_cotable.c+3−3

@@ -432,7 +432,7 @@ static int vmw_cotable_resize(struct vmw_resource *res, size_t new_size) · 431 unmodified lines
432	* for the new COTable. Initially pin the buffer object to make sure	432	* for the new COTable. Initially pin the buffer object to make sure
433	* we can use tryreserve without failure.	433	* we can use tryreserve without failure.
434	*/	434	*/
435	ret = vmw_bo_create(dev_priv, &bo_params, &buf);	435	ret = vmw_gem_object_create(dev_priv, &bo_params, &buf);
436	if (ret) {	436	if (ret) {
437	DRM_ERROR("Failed initializing new cotable MOB.\n");	437	DRM_ERROR("Failed initializing new cotable MOB.\n");
438	goto out_done;	438	goto out_done;
@@ -502,7 +502,7 @@ static int vmw_cotable_resize(struct vmw_resource *res, size_t new_size) · 63 unmodified lines
502		502
503	vmw_resource_mob_attach(res);	503	vmw_resource_mob_attach(res);
504	/* Let go of the old mob. */	504	/* Let go of the old mob. */
505	vmw_bo_unreference(&old_buf);	505	vmw_user_bo_unref(&old_buf);
506	res->id = vcotbl->type;	506	res->id = vcotbl->type;
507		507
508	ret = dma_resv_reserve_fences(bo->base.resv, 1);	508	ret = dma_resv_reserve_fences(bo->base.resv, 1);
@@ -521,7 +521,7 @@ out_map_new: · 12 unmodified lines
521	out_wait:	521	out_wait:
522	ttm_bo_unpin(bo);	522	ttm_bo_unpin(bo);
523	ttm_bo_unreserve(bo);	523	ttm_bo_unreserve(bo);
524	vmw_bo_unreference(&buf);	524	vmw_user_bo_unref(&buf);
525		525
526	out_done:	526	out_done:
527	MKS_STAT_TIME_POP(MKSSTAT_KERN_COTABLE_RESIZE);	527	MKS_STAT_TIME_POP(MKSSTAT_KERN_COTABLE_RESIZE);

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h+4−0

 /**
  * GEM related functionality - vmwgfx_gem.c
  */
+struct vmw_bo_params;
+int vmw_gem_object_create(struct vmw_private *vmw,
+			  struct vmw_bo_params *params,
+			  struct vmw_bo **p_vbo);
 extern int vmw_gem_object_create_with_handle(struct vmw_private *dev_priv,
 					     struct drm_file *filp,
 					     uint32_t size,

drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c+7−5

 				 SVGAMobId *id,
 				 struct vmw_bo **vmw_bo_p)
 {
-	struct vmw_bo *vmw_bo;
+	struct vmw_bo *vmw_bo, *tmp_bo;
 	uint32_t handle = *id;
 	struct vmw_relocation *reloc;
 	int ret;
 	}
 	vmw_bo_placement_set(vmw_bo, VMW_BO_DOMAIN_MOB, VMW_BO_DOMAIN_MOB);
 	ret = vmw_validation_add_bo(sw_context->ctx, vmw_bo);
-	vmw_user_bo_unref(vmw_bo);
+	tmp_bo = vmw_bo;
+	vmw_user_bo_unref(&tmp_bo);
 	if (unlikely(ret != 0))
 		return ret;
 				   SVGAGuestPtr *ptr,
 				   struct vmw_bo **vmw_bo_p)
 {
-	struct vmw_bo *vmw_bo;
+	struct vmw_bo *vmw_bo, *tmp_bo;
 	uint32_t handle = ptr->gmrId;
 	struct vmw_relocation *reloc;
 	int ret;
 	vmw_bo_placement_set(vmw_bo, VMW_BO_DOMAIN_GMR | VMW_BO_DOMAIN_VRAM,
 			     VMW_BO_DOMAIN_GMR | VMW_BO_DOMAIN_VRAM);
 	ret = vmw_validation_add_bo(sw_context->ctx, vmw_bo);
-	vmw_user_bo_unref(vmw_bo);
+	tmp_bo = vmw_bo;
+	vmw_user_bo_unref(&tmp_bo);
 	if (unlikely(ret != 0))
 		return ret;
 {
 	VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdSetTextureState);
 	SVGA3dTextureState *last_state = (SVGA3dTextureState *)
-	  ((unsigned long) header + header->size + sizeof(header));
+	  ((unsigned long) header + header->size + sizeof(*header));
 	SVGA3dTextureState *cur_state = (SVGA3dTextureState *)
 		((unsigned long) header + sizeof(*cmd));
 	struct vmw_resource *ctx;

drivers/gpu/drm/vmwgfx/vmwgfx_gem.c+15−3

 	.vm_ops = &vmw_vm_ops,
 };
+int vmw_gem_object_create(struct vmw_private *vmw,
+			  struct vmw_bo_params *params,
+			  struct vmw_bo **p_vbo)
+{
+	int ret = vmw_bo_create(vmw, params, p_vbo);
+	if (ret != 0)
+		goto out_no_bo;
+	(*p_vbo)->tbo.base.funcs = &vmw_gem_object_funcs;
+out_no_bo:
+	return ret;
+}
 int vmw_gem_object_create_with_handle(struct vmw_private *dev_priv,
 				      struct drm_file *filp,
 				      uint32_t size,
 		.pin = false
 	};
-	ret = vmw_bo_create(dev_priv, &params, p_vbo);
+	ret = vmw_gem_object_create(dev_priv, &params, p_vbo);
 	if (ret != 0)
 		goto out_no_bo;
-	(*p_vbo)->tbo.base.funcs = &vmw_gem_object_funcs;
 	ret = drm_gem_handle_create(filp, &(*p_vbo)->tbo.base, handle);
 out_no_bo:
 	return ret;

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c+3−3

@@ -1471,8 +1471,8 @@ static int vmw_create_bo_proxy(struct drm_device *dev, · 1470 unmodified lines
1471	/* Reserve and switch the backing mob. */	1471	/* Reserve and switch the backing mob. */
1472	mutex_lock(&res->dev_priv->cmdbuf_mutex);	1472	mutex_lock(&res->dev_priv->cmdbuf_mutex);
1473	(void) vmw_resource_reserve(res, false, true);	1473	(void) vmw_resource_reserve(res, false, true);
1474	vmw_bo_unreference(&res->guest_memory_bo);	1474	vmw_user_bo_unref(&res->guest_memory_bo);
1475	res->guest_memory_bo = vmw_bo_reference(bo_mob);	1475	res->guest_memory_bo = vmw_user_bo_ref(bo_mob);
1476	res->guest_memory_offset = 0;	1476	res->guest_memory_offset = 0;
1477	vmw_resource_unreserve(res, false, false, false, NULL, 0);	1477	vmw_resource_unreserve(res, false, false, false, NULL, 0);
1478	mutex_unlock(&res->dev_priv->cmdbuf_mutex);	1478	mutex_unlock(&res->dev_priv->cmdbuf_mutex);
@@ -1666,7 +1666,7 @@ static struct drm_framebuffer vmw_kms_fb_create(struct drm_device dev, · 187 unmodified lines
1666	err_out:	1666	err_out:
1667	/* vmw_user_lookup_handle takes one ref so does new_fb */	1667	/* vmw_user_lookup_handle takes one ref so does new_fb */
1668	if (bo)	1668	if (bo)
1669	vmw_user_bo_unref(bo);	1669	vmw_user_bo_unref(&bo);
1670	if (surface)	1670	if (surface)
1671	vmw_surface_unreference(&surface);	1671	vmw_surface_unreference(&surface);
1672		1672

drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c+1−1

@@ -451,7 +451,7 @@ int vmw_overlay_ioctl(struct drm_device dev, void data, · 450 unmodified lines
451		451
452	ret = vmw_overlay_update_stream(dev_priv, buf, arg, true);	452	ret = vmw_overlay_update_stream(dev_priv, buf, arg, true);
453		453
454	vmw_user_bo_unref(buf);	454	vmw_user_bo_unref(&buf);
455		455
456	out_unlock:	456	out_unlock:
457	mutex_unlock(&overlay->mutex);	457	mutex_unlock(&overlay->mutex);

drivers/gpu/drm/vmwgfx/vmwgfx_resource.c+6−6

@@ -141,7 +141,7 @@ static void vmw_resource_release(struct kref *kref) · 140 unmodified lines
141	if (res->coherent)	141	if (res->coherent)
142	vmw_bo_dirty_release(res->guest_memory_bo);	142	vmw_bo_dirty_release(res->guest_memory_bo);
143	ttm_bo_unreserve(bo);	143	ttm_bo_unreserve(bo);
144	vmw_bo_unreference(&res->guest_memory_bo);	144	vmw_user_bo_unref(&res->guest_memory_bo);
145	}	145	}
146		146
147	if (likely(res->hw_destroy != NULL)) {	147	if (likely(res->hw_destroy != NULL)) {
@@ -338,7 +338,7 @@ static int vmw_resource_buf_alloc(struct vmw_resource *res, · 190 unmodified lines
338	return 0;	338	return 0;
339	}	339	}
340		340
341	ret = vmw_bo_create(res->dev_priv, &bo_params, &gbo);	341	ret = vmw_gem_object_create(res->dev_priv, &bo_params, &gbo);
342	if (unlikely(ret != 0))	342	if (unlikely(ret != 0))
343	goto out_no_bo;	343	goto out_no_bo;
344		344
@@ -457,11 +457,11 @@ void vmw_resource_unreserve(struct vmw_resource *res, · 112 unmodified lines
457	vmw_resource_mob_detach(res);	457	vmw_resource_mob_detach(res);
458	if (res->coherent)	458	if (res->coherent)
459	vmw_bo_dirty_release(res->guest_memory_bo);	459	vmw_bo_dirty_release(res->guest_memory_bo);
460	vmw_bo_unreference(&res->guest_memory_bo);	460	vmw_user_bo_unref(&res->guest_memory_bo);
461	}	461	}
462		462
463	if (new_guest_memory_bo) {	463	if (new_guest_memory_bo) {
464	res->guest_memory_bo = vmw_bo_reference(new_guest_memory_bo);	464	res->guest_memory_bo = vmw_user_bo_ref(new_guest_memory_bo);
465		465
466	/*	466	/*
467	* The validation code should already have added a	467	* The validation code should already have added a
@@ -551,7 +551,7 @@ out_no_reserve: · 83 unmodified lines
551	ttm_bo_put(val_buf->bo);	551	ttm_bo_put(val_buf->bo);
552	val_buf->bo = NULL;	552	val_buf->bo = NULL;
553	if (guest_memory_dirty)	553	if (guest_memory_dirty)
554	vmw_bo_unreference(&res->guest_memory_bo);	554	vmw_user_bo_unref(&res->guest_memory_bo);
555		555
556	return ret;	556	return ret;
557	}	557	}
@@ -727,7 +727,7 @@ int vmw_resource_validate(struct vmw_resource *res, bool intr, · 169 unmodified lines
727	goto out_no_validate;	727	goto out_no_validate;
728	else if (!res->func->needs_guest_memory && res->guest_memory_bo) {	728	else if (!res->func->needs_guest_memory && res->guest_memory_bo) {
729	WARN_ON_ONCE(vmw_resource_mob_attached(res));	729	WARN_ON_ONCE(vmw_resource_mob_attached(res));
730	vmw_bo_unreference(&res->guest_memory_bo);	730	vmw_user_bo_unref(&res->guest_memory_bo);
731	}	731	}
732		732
733	return 0;	733	return 0;

drivers/gpu/drm/vmwgfx/vmwgfx_shader.c+2−2

@@ -180,7 +180,7 @@ static int vmw_gb_shader_init(struct vmw_private *dev_priv, · 179 unmodified lines
180		180
181	res->guest_memory_size = size;	181	res->guest_memory_size = size;
182	if (byte_code) {	182	if (byte_code) {
183	res->guest_memory_bo = vmw_bo_reference(byte_code);	183	res->guest_memory_bo = vmw_user_bo_ref(byte_code);
184	res->guest_memory_offset = offset;	184	res->guest_memory_offset = offset;
185	}	185	}
186	shader->size = size;	186	shader->size = size;
@@ -809,7 +809,7 @@ static int vmw_shader_define(struct drm_device dev, struct drm_file file_priv, · 622 unmodified lines
809	shader_type, num_input_sig,	809	shader_type, num_input_sig,
810	num_output_sig, tfile, shader_handle);	810	num_output_sig, tfile, shader_handle);
811	out_bad_arg:	811	out_bad_arg:
812	vmw_user_bo_unref(buffer);	812	vmw_user_bo_unref(&buffer);
813	return ret;	813	return ret;
814	}	814	}
815		815

drivers/gpu/drm/vmwgfx/vmwgfx_surface.c+12−19

@@ -686,9 +686,6 @@ static void vmw_user_surface_base_release(struct ttm_base_object **p_base) · 685 unmodified lines
686	container_of(base, struct vmw_user_surface, prime.base);	686	container_of(base, struct vmw_user_surface, prime.base);
687	struct vmw_resource *res = &user_srf->srf.res;	687	struct vmw_resource *res = &user_srf->srf.res;
688		688
689	if (res->guest_memory_bo)
690	drm_gem_object_put(&res->guest_memory_bo->tbo.base);
691
692	*p_base = NULL;	689	*p_base = NULL;
693	vmw_resource_unreference(&res);	690	vmw_resource_unreference(&res);
694	}	691	}
@@ -855,23 +852,21 @@ int vmw_surface_define_ioctl(struct drm_device dev, void data, · 160 unmodified lines
855	* expect a backup buffer to be present.	852	* expect a backup buffer to be present.
856	*/	853	*/
857	if (dev_priv->has_mob && req->shareable) {	854	if (dev_priv->has_mob && req->shareable) {
858	uint32_t backup_handle;	855	struct vmw_bo_params params = {
859		856	.domain = VMW_BO_DOMAIN_SYS,
860	ret = vmw_gem_object_create_with_handle(dev_priv,	857	.busy_domain = VMW_BO_DOMAIN_SYS,
861	file_priv,	858	.bo_type = ttm_bo_type_device,
862	res->guest_memory_size,	859	.size = res->guest_memory_size,
863	&backup_handle,	860	.pin = false
864	&res->guest_memory_bo);	861	};
		862
		863	ret = vmw_gem_object_create(dev_priv,
		864	&params,
		865	&res->guest_memory_bo);
865	if (unlikely(ret != 0)) {	866	if (unlikely(ret != 0)) {
866	vmw_resource_unreference(&res);	867	vmw_resource_unreference(&res);
867	goto out_unlock;	868	goto out_unlock;
868	}	869	}
869	vmw_bo_reference(res->guest_memory_bo);
870	/*
871	* We don't expose the handle to the userspace and surface
872	* already holds a gem reference
873	*/
874	drm_gem_handle_delete(file_priv, backup_handle);
875	}	870	}
876		871
877	tmp = vmw_resource_reference(&srf->res);	872	tmp = vmw_resource_reference(&srf->res);
@@ -1512,7 +1507,7 @@ vmw_gb_surface_define_internal(struct drm_device *dev, · 634 unmodified lines
1512	if (ret == 0) {	1507	if (ret == 0) {
1513	if (res->guest_memory_bo->tbo.base.size < res->guest_memory_size) {	1508	if (res->guest_memory_bo->tbo.base.size < res->guest_memory_size) {
1514	VMW_DEBUG_USER("Surface backup buffer too small.\n");	1509	VMW_DEBUG_USER("Surface backup buffer too small.\n");
1515	vmw_bo_unreference(&res->guest_memory_bo);	1510	vmw_user_bo_unref(&res->guest_memory_bo);
1516	ret = -EINVAL;	1511	ret = -EINVAL;
1517	goto out_unlock;	1512	goto out_unlock;
1518	} else {	1513	} else {
@@ -1526,8 +1521,6 @@ vmw_gb_surface_define_internal(struct drm_device *dev, · 7 unmodified lines
1526	res->guest_memory_size,	1521	res->guest_memory_size,
1527	&backup_handle,	1522	&backup_handle,
1528	&res->guest_memory_bo);	1523	&res->guest_memory_bo);
1529	if (ret == 0)
1530	vmw_bo_reference(res->guest_memory_bo);
1531	}	1524	}
1532		1525
1533	if (unlikely(ret != 0)) {	1526	if (unlikely(ret != 0)) {

drivers/hid/Kconfig+2−0

@@ -799,6 +799,8 @@ config HID_NVIDIA_SHIELD · 798 unmodified lines
799	tristate "NVIDIA SHIELD devices"	799	tristate "NVIDIA SHIELD devices"
800	depends on USB_HID	800	depends on USB_HID
801	depends on BT_HIDP	801	depends on BT_HIDP
		802	depends on LEDS_CLASS
		803	select POWER_SUPPLY
802	help	804	help
803	Support for NVIDIA SHIELD accessories.	805	Support for NVIDIA SHIELD accessories.
804		806

drivers/hid/hid-holtek-kbd.c+4−0

 		return -ENODEV;
 	boot_hid = usb_get_intfdata(boot_interface);
+	if (list_empty(&boot_hid->inputs)) {
+		hid_err(hid, "no inputs found\n");
+		return -ENODEV;
+	}
 	boot_hid_input = list_first_entry(&boot_hid->inputs,
 		struct hid_input, list);

drivers/hid/hid-ids.h+1−0

@@ -425,6 +425,7 @@ · 424 unmodified lines
425	#define I2C_DEVICE_ID_HP_SPECTRE_X360_13T_AW100 0x29F5	425	#define I2C_DEVICE_ID_HP_SPECTRE_X360_13T_AW100 0x29F5
426	#define I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V1 0x2BED	426	#define I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V1 0x2BED
427	#define I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V2 0x2BEE	427	#define I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V2 0x2BEE
		428	#define I2C_DEVICE_ID_HP_ENVY_X360_15_EU0556NG 0x2D02
428		429
429	#define USB_VENDOR_ID_ELECOM 0x056e	430	#define USB_VENDOR_ID_ELECOM 0x056e
430	#define USB_DEVICE_ID_ELECOM_BM084 0x0061	431	#define USB_DEVICE_ID_ELECOM_BM084 0x0061

drivers/hid/hid-input.c+2−0

@@ -409,6 +409,8 @@ static const struct hid_device_id hid_battery_quirks[] = { · 408 unmodified lines
409	HID_BATTERY_QUIRK_IGNORE },	409	HID_BATTERY_QUIRK_IGNORE },
410	{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V2),	410	{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V2),
411	HID_BATTERY_QUIRK_IGNORE },	411	HID_BATTERY_QUIRK_IGNORE },
		412	{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_ENVY_X360_15_EU0556NG),
		413	HID_BATTERY_QUIRK_IGNORE },
412	{}	414	{}
413	};	415	};
414		416

drivers/hid/hid-logitech-hidpp.c+4−1

 			goto hid_hw_init_fail;
 	}
-	hidpp_connect_event(hidpp);
+	schedule_work(&hidpp->work);
+	flush_work(&hidpp->work);
 	if (will_restart) {
 		/* Reset the HID node state */
 	  HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb008) },
 	{ /* MX Master mouse over Bluetooth */
 	  HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb012) },
+	{ /* M720 Triathlon mouse over Bluetooth */
+	  HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb015) },
 	{ /* MX Ergo trackball over Bluetooth */
 	  HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01d) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01e) },

drivers/hid/hid-multitouch.c+4−0

 			USB_DEVICE_ID_MTP_STM)},
 	/* Synaptics devices */
+	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
+		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
+			USB_VENDOR_ID_SYNAPTICS, 0xcd7e) },
 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
 			USB_VENDOR_ID_SYNAPTICS, 0xce08) },

drivers/hid/hid-nintendo.c+103−72

 	struct joycon_input_report *report;
 	req.subcmd_id = JC_SUBCMD_REQ_DEV_INFO;
+	mutex_lock(&ctlr->output_mutex);
 	ret = joycon_send_subcmd(ctlr, &req, 0, HZ);
+	mutex_unlock(&ctlr->output_mutex);
 	if (ret) {
 		hid_err(ctlr->hdev, "Failed to get joycon info; ret=%d\n", ret);
 		return ret;
 	return 0;
 }
+static int joycon_init(struct hid_device *hdev)
+{
+	struct joycon_ctlr *ctlr = hid_get_drvdata(hdev);
+	int ret = 0;
+	mutex_lock(&ctlr->output_mutex);
+	/* if handshake command fails, assume ble pro controller */
+	if ((jc_type_is_procon(ctlr) || jc_type_is_chrggrip(ctlr)) &&
+	    !joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ)) {
+		hid_dbg(hdev, "detected USB controller\n");
+		/* set baudrate for improved latency */
+		ret = joycon_send_usb(ctlr, JC_USB_CMD_BAUDRATE_3M, HZ);
+		if (ret) {
+			hid_err(hdev, "Failed to set baudrate; ret=%d\n", ret);
+			goto out_unlock;
+		}
+		/* handshake */
+		ret = joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ);
+		if (ret) {
+			hid_err(hdev, "Failed handshake; ret=%d\n", ret);
+			goto out_unlock;
+		}
+		/*
+		 * Set no timeout (to keep controller in USB mode).
+		 * This doesn't send a response, so ignore the timeout.
+		 */
+		joycon_send_usb(ctlr, JC_USB_CMD_NO_TIMEOUT, HZ/10);
+	} else if (jc_type_is_chrggrip(ctlr)) {
+		hid_err(hdev, "Failed charging grip handshake\n");
+		ret = -ETIMEDOUT;
+		goto out_unlock;
+	}
+	/* get controller calibration data, and parse it */
+	ret = joycon_request_calibration(ctlr);
+	if (ret) {
+		/*
+		 * We can function with default calibration, but it may be
+		 * inaccurate. Provide a warning, and continue on.
+		 */
+		hid_warn(hdev, "Analog stick positions may be inaccurate\n");
+	}
+	/* get IMU calibration data, and parse it */
+	ret = joycon_request_imu_calibration(ctlr);
+	if (ret) {
+		/*
+		 * We can function with default calibration, but it may be
+		 * inaccurate. Provide a warning, and continue on.
+		 */
+		hid_warn(hdev, "Unable to read IMU calibration data\n");
+	}
+	/* Set the reporting mode to 0x30, which is the full report mode */
+	ret = joycon_set_report_mode(ctlr);
+	if (ret) {
+		hid_err(hdev, "Failed to set report mode; ret=%d\n", ret);
+		goto out_unlock;
+	}
+	/* Enable rumble */
+	ret = joycon_enable_rumble(ctlr);
+	if (ret) {
+		hid_err(hdev, "Failed to enable rumble; ret=%d\n", ret);
+		goto out_unlock;
+	}
+	/* Enable the IMU */
+	ret = joycon_enable_imu(ctlr);
+	if (ret) {
+		hid_err(hdev, "Failed to enable the IMU; ret=%d\n", ret);
+		goto out_unlock;
+	}
+out_unlock:
+	mutex_unlock(&ctlr->output_mutex);
+	return ret;
+}
 /* Common handler for parsing inputs */
 static int joycon_ctlr_read_handler(struct joycon_ctlr *ctlr, u8 *data,
 							      int size)
 	hid_device_io_start(hdev);
-	/* Initialize the controller */
+	ret = joycon_init(hdev);
-	mutex_lock(&ctlr->output_mutex);
-	/* if handshake command fails, assume ble pro controller */
-	if ((jc_type_is_procon(ctlr) || jc_type_is_chrggrip(ctlr)) &&
-	    !joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ)) {
-		hid_dbg(hdev, "detected USB controller\n");
-		/* set baudrate for improved latency */
-		ret = joycon_send_usb(ctlr, JC_USB_CMD_BAUDRATE_3M, HZ);
-		if (ret) {
-			hid_err(hdev, "Failed to set baudrate; ret=%d\n", ret);
-			goto err_mutex;
-		}
-		/* handshake */
-		ret = joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ);
-		if (ret) {
-			hid_err(hdev, "Failed handshake; ret=%d\n", ret);
-			goto err_mutex;
-		}
-		/*
-		 * Set no timeout (to keep controller in USB mode).
-		 * This doesn't send a response, so ignore the timeout.
-		 */
-		joycon_send_usb(ctlr, JC_USB_CMD_NO_TIMEOUT, HZ/10);
-	} else if (jc_type_is_chrggrip(ctlr)) {
-		hid_err(hdev, "Failed charging grip handshake\n");
-		ret = -ETIMEDOUT;
-		goto err_mutex;
-	}
-	/* get controller calibration data, and parse it */
-	ret = joycon_request_calibration(ctlr);
 	if (ret) {
-		/*
+		hid_err(hdev, "Failed to initialize controller; ret=%d\n", ret);
-		 * We can function with default calibration, but it may be
+		goto err_close;
-		 * inaccurate. Provide a warning, and continue on.
-		 */
-		hid_warn(hdev, "Analog stick positions may be inaccurate\n");
-	}
-	/* get IMU calibration data, and parse it */
-	ret = joycon_request_imu_calibration(ctlr);
-	if (ret) {
-		/*
-		 * We can function with default calibration, but it may be
-		 * inaccurate. Provide a warning, and continue on.
-		 */
-		hid_warn(hdev, "Unable to read IMU calibration data\n");
-	}
-	/* Set the reporting mode to 0x30, which is the full report mode */
-	ret = joycon_set_report_mode(ctlr);
-	if (ret) {
-		hid_err(hdev, "Failed to set report mode; ret=%d\n", ret);
-		goto err_mutex;
-	}
-	/* Enable rumble */
-	ret = joycon_enable_rumble(ctlr);
-	if (ret) {
-		hid_err(hdev, "Failed to enable rumble; ret=%d\n", ret);
-		goto err_mutex;
-	}
-	/* Enable the IMU */
-	ret = joycon_enable_imu(ctlr);
-	if (ret) {
-		hid_err(hdev, "Failed to enable the IMU; ret=%d\n", ret);
-		goto err_mutex;
 	}
 	ret = joycon_read_info(ctlr);
 	if (ret) {
 		hid_err(hdev, "Failed to retrieve controller info; ret=%d\n",
 			ret);
-		goto err_mutex;
+		goto err_close;
 	}
-	mutex_unlock(&ctlr->output_mutex);
 	/* Initialize the leds */
 	ret = joycon_leds_create(ctlr);
 	if (ret) {
 	hid_dbg(hdev, "probe - success\n");
 	return 0;
-err_mutex:
-	mutex_unlock(&ctlr->output_mutex);
 err_close:
 	hid_hw_close(hdev);
 err_stop:
 	hid_hw_stop(hdev);
 }
+#ifdef CONFIG_PM
+static int nintendo_hid_resume(struct hid_device *hdev)
+{
+	int ret = joycon_init(hdev);
+	if (ret)
+		hid_err(hdev, "Failed to restore controller after resume");
+	return ret;
+}
+#endif
 static const struct hid_device_id nintendo_hid_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO,
 			 USB_DEVICE_ID_NINTENDO_PROCON) },
 	.probe		= nintendo_hid_probe,
 	.remove		= nintendo_hid_remove,
 	.raw_event	= nintendo_hid_event,
+#ifdef CONFIG_PM
+	.resume		= nintendo_hid_resume,
+#endif
 };
 module_hid_driver(nintendo_hid_driver);

drivers/hid/hid-nvidia-shield.c+6−3

 	led->name = devm_kasprintf(&ts->base.hdev->dev, GFP_KERNEL,
 				   "thunderstrike%d:blue:led", ts->id);
 	led->max_brightness = 1;
-	led->flags = LED_CORE_SUSPENDRESUME;
+	led->flags = LED_CORE_SUSPENDRESUME | LED_RETAIN_AT_SHUTDOWN;
 	led->brightness_get = &thunderstrike_led_get_brightness;
 	led->brightness_set = &thunderstrike_led_set_brightness;
 	ret = hid_hw_start(hdev, HID_CONNECT_HIDINPUT);
 	if (ret) {
 		hid_err(hdev, "Failed to start HID device\n");
-		goto err_haptics;
+		goto err_ts_create;
 	}
 	ret = hid_hw_open(hdev);
 err_stop:
 	hid_hw_stop(hdev);
-err_haptics:
+err_ts_create:
+	power_supply_unregister(ts->base.battery_dev.psy);
 	if (ts->haptics_dev)
 		input_unregister_device(ts->haptics_dev);
+	led_classdev_unregister(&ts->led_dev);
+	ida_free(&thunderstrike_ida, ts->id);
 	return ret;
 }

drivers/hid/hid-sony.c+2−0

@@ -2155,6 +2155,8 @@ static int sony_probe(struct hid_device hdev, const struct hid_device_id id) · 2154 unmodified lines
2155	return ret;	2155	return ret;
2156		2156
2157	err:	2157	err:
		2158	usb_free_urb(sc->ghl_urb);
		2159
2158	hid_hw_stop(hdev);	2160	hid_hw_stop(hdev);
2159	return ret;	2161	return ret;
2160	}	2162	}

drivers/hid/hid-steelseries.c+1−1

@@ -390,7 +390,7 @@ static int steelseries_headset_arctis_1_fetch_battery(struct hid_device *hdev) · 389 unmodified lines
390	ret = hid_hw_raw_request(hdev, arctis_1_battery_request[0],	390	ret = hid_hw_raw_request(hdev, arctis_1_battery_request[0],
391	write_buf, sizeof(arctis_1_battery_request),	391	write_buf, sizeof(arctis_1_battery_request),
392	HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);	392	HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
393	if (ret < sizeof(arctis_1_battery_request)) {	393	if (ret < (int)sizeof(arctis_1_battery_request)) {
394	hid_err(hdev, "hid_hw_raw_request() failed with %d\n", ret);	394	hid_err(hdev, "hid_hw_raw_request() failed with %d\n", ret);
395	ret = -ENODATA;	395	ret = -ENODATA;
396	}	396	}

drivers/hid/i2c-hid/i2c-hid-core.c+81−63

@@ -998,45 +998,29 @@ static int i2c_hid_core_resume(struct i2c_hid *ihid) · 997 unmodified lines
998	return hid_driver_reset_resume(hid);	998	return hid_driver_reset_resume(hid);
999	}	999	}
1000		1000
1001	/**	1001	/*
1002	* __do_i2c_hid_core_initial_power_up() - First time power up of the i2c-hid device.	1002	* Check that the device exists and parse the HID descriptor.
1003	* @ihid: The ihid object created during probe.
1004	*
1005	* This function is called at probe time.
1006	*
1007	* The initial power on is where we do some basic validation that the device
1008	* exists, where we fetch the HID descriptor, and where we create the actual
1009	* HID devices.
1010	*
1011	* Return: 0 or error code.
1012	*/	1003	*/
1013	static int __do_i2c_hid_core_initial_power_up(struct i2c_hid *ihid)	1004	static int __i2c_hid_core_probe(struct i2c_hid *ihid)
1014	{	1005	{
1015	struct i2c_client *client = ihid->client;	1006	struct i2c_client *client = ihid->client;
1016	struct hid_device *hid = ihid->hid;	1007	struct hid_device *hid = ihid->hid;
1017	int ret;	1008	int ret;
1018		1009
1019	ret = i2c_hid_core_power_up(ihid);
1020	if (ret)
1021	return ret;
1022
1023	/* Make sure there is something at this address */	1010	/* Make sure there is something at this address */
1024	ret = i2c_smbus_read_byte(client);	1011	ret = i2c_smbus_read_byte(client);
1025	if (ret < 0) {	1012	if (ret < 0) {
1026	i2c_hid_dbg(ihid, "nothing at this address: %d\n", ret);	1013	i2c_hid_dbg(ihid, "nothing at this address: %d\n", ret);
1027	ret = -ENXIO;	1014	return -ENXIO;
1028	goto err;
1029	}	1015	}
1030		1016
1031	ret = i2c_hid_fetch_hid_descriptor(ihid);	1017	ret = i2c_hid_fetch_hid_descriptor(ihid);
1032	if (ret < 0) {	1018	if (ret < 0) {
1033	dev_err(&client->dev,	1019	dev_err(&client->dev,
1034	"Failed to fetch the HID Descriptor\n");	1020	"Failed to fetch the HID Descriptor\n");
1035	goto err;	1021	return ret;
1036	}	1022	}
1037		1023
1038	enable_irq(client->irq);
1039
1040	hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);	1024	hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);
1041	hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);	1025	hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
1042	hid->product = le16_to_cpu(ihid->hdesc.wProductID);	1026	hid->product = le16_to_cpu(ihid->hdesc.wProductID);
@@ -1050,17 +1034,49 @@ static int __do_i2c_hid_core_initial_power_up(struct i2c_hid *ihid) · 7 unmodified lines
1050		1034
1051	ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product);	1035	ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product);
1052		1036
		1037	return 0;
		1038	}
		1039
		1040	static int i2c_hid_core_register_hid(struct i2c_hid *ihid)
		1041	{
		1042	struct i2c_client *client = ihid->client;
		1043	struct hid_device *hid = ihid->hid;
		1044	int ret;
		1045
		1046	enable_irq(client->irq);
		1047
1053	ret = hid_add_device(hid);	1048	ret = hid_add_device(hid);
1054	if (ret) {	1049	if (ret) {
1055	if (ret != -ENODEV)	1050	if (ret != -ENODEV)
1056	hid_err(client, "can't add hid device: %d\n", ret);	1051	hid_err(client, "can't add hid device: %d\n", ret);
1057	goto err;	1052	disable_irq(client->irq);
		1053	return ret;
1058	}	1054	}
1059		1055
1060	return 0;	1056	return 0;
		1057	}
		1058
		1059	static int i2c_hid_core_probe_panel_follower(struct i2c_hid *ihid)
		1060	{
		1061	int ret;
		1062
		1063	ret = i2c_hid_core_power_up(ihid);
		1064	if (ret)
		1065	return ret;
1061		1066
1062	err:	1067	ret = __i2c_hid_core_probe(ihid);
		1068	if (ret)
		1069	goto err_power_down;
		1070
		1071	ret = i2c_hid_core_register_hid(ihid);
		1072	if (ret)
		1073	goto err_power_down;
		1074
		1075	return 0;
		1076
		1077	err_power_down:
1063	i2c_hid_core_power_down(ihid);	1078	i2c_hid_core_power_down(ihid);
		1079
1064	return ret;	1080	return ret;
1065	}	1081	}
1066		1082
@@ -1077,7 +1093,7 @@ static void ihid_core_panel_prepare_work(struct work_struct *work) · 10 unmodified lines
1077	* steps.	1093	* steps.
1078	*/	1094	*/
1079	if (!hid->version)	1095	if (!hid->version)
1080	ret = __do_i2c_hid_core_initial_power_up(ihid);	1096	ret = i2c_hid_core_probe_panel_follower(ihid);
1081	else	1097	else
1082	ret = i2c_hid_core_resume(ihid);	1098	ret = i2c_hid_core_resume(ihid);
1083		1099
@@ -1136,7 +1152,6 @@ static int i2c_hid_core_register_panel_follower(struct i2c_hid *ihid) · 52 unmodified lines
1136	struct device *dev = &ihid->client->dev;	1152	struct device *dev = &ihid->client->dev;
1137	int ret;	1153	int ret;
1138		1154
1139	ihid->is_panel_follower = true;
1140	ihid->panel_follower.funcs = &i2c_hid_core_panel_follower_funcs;	1155	ihid->panel_follower.funcs = &i2c_hid_core_panel_follower_funcs;
1141		1156
1142	/*	1157	/*
@@ -1156,30 +1171,6 @@ static int i2c_hid_core_register_panel_follower(struct i2c_hid *ihid) · 13 unmodified lines
1156	return 0;	1171	return 0;
1157	}	1172	}
1158		1173
1159	static int i2c_hid_core_initial_power_up(struct i2c_hid *ihid)
1160	{
1161	/*
1162	* If we're a panel follower, we'll register and do our initial power
1163	* up when the panel turns on; otherwise we do it right away.
1164	*/
1165	if (drm_is_panel_follower(&ihid->client->dev))
1166	return i2c_hid_core_register_panel_follower(ihid);
1167	else
1168	return __do_i2c_hid_core_initial_power_up(ihid);
1169	}
1170
1171	static void i2c_hid_core_final_power_down(struct i2c_hid *ihid)
1172	{
1173	/*
1174	* If we're a follower, the act of unfollowing will cause us to be
1175	* powered down. Otherwise we need to manually do it.
1176	*/
1177	if (ihid->is_panel_follower)
1178	drm_panel_remove_follower(&ihid->panel_follower);
1179	else
1180	i2c_hid_core_suspend(ihid, true);
1181	}
1182
1183	int i2c_hid_core_probe(struct i2c_client client, struct i2chid_ops ops,	1174	int i2c_hid_core_probe(struct i2c_client client, struct i2chid_ops ops,
1184	u16 hid_descriptor_address, u32 quirks)	1175	u16 hid_descriptor_address, u32 quirks)
1185	{	1176	{
@@ -1211,6 +1202,7 @@ int i2c_hid_core_probe(struct i2c_client client, struct i2chid_ops ops, · 25 unmodified lines
1211	ihid->ops = ops;	1202	ihid->ops = ops;
1212	ihid->client = client;	1203	ihid->client = client;
1213	ihid->wHIDDescRegister = cpu_to_le16(hid_descriptor_address);	1204	ihid->wHIDDescRegister = cpu_to_le16(hid_descriptor_address);
		1205	ihid->is_panel_follower = drm_is_panel_follower(&client->dev);
1214		1206
1215	init_waitqueue_head(&ihid->wait);	1207	init_waitqueue_head(&ihid->wait);
1216	mutex_init(&ihid->reset_lock);	1208	mutex_init(&ihid->reset_lock);
@@ -1224,14 +1216,10 @@ int i2c_hid_core_probe(struct i2c_client client, struct i2chid_ops ops, · 7 unmodified lines
1224	return ret;	1216	return ret;
1225	device_enable_async_suspend(&client->dev);	1217	device_enable_async_suspend(&client->dev);
1226		1218
1227	ret = i2c_hid_init_irq(client);
1228	if (ret < 0)
1229	goto err_buffers_allocated;
1230
1231	hid = hid_allocate_device();	1219	hid = hid_allocate_device();
1232	if (IS_ERR(hid)) {	1220	if (IS_ERR(hid)) {
1233	ret = PTR_ERR(hid);	1221	ret = PTR_ERR(hid);
1234	goto err_irq;	1222	goto err_free_buffers;
1235	}	1223	}
1236		1224
1237	ihid->hid = hid;	1225	ihid->hid = hid;
@@ -1242,19 +1230,42 @@ int i2c_hid_core_probe(struct i2c_client client, struct i2chid_ops ops, · 4 unmodified lines
1242	hid->bus = BUS_I2C;	1230	hid->bus = BUS_I2C;
1243	hid->initial_quirks = quirks;	1231	hid->initial_quirks = quirks;
1244		1232
1245	ret = i2c_hid_core_initial_power_up(ihid);	1233	/* Power on and probe unless device is a panel follower. */
		1234	if (!ihid->is_panel_follower) {
		1235	ret = i2c_hid_core_power_up(ihid);
		1236	if (ret < 0)
		1237	goto err_destroy_device;
		1238
		1239	ret = __i2c_hid_core_probe(ihid);
		1240	if (ret < 0)
		1241	goto err_power_down;
		1242	}
		1243
		1244	ret = i2c_hid_init_irq(client);
		1245	if (ret < 0)
		1246	goto err_power_down;
		1247
		1248	/*
		1249	* If we're a panel follower, we'll register when the panel turns on;
		1250	* otherwise we do it right away.
		1251	*/
		1252	if (ihid->is_panel_follower)
		1253	ret = i2c_hid_core_register_panel_follower(ihid);
		1254	else
		1255	ret = i2c_hid_core_register_hid(ihid);
1246	if (ret)	1256	if (ret)
1247	goto err_mem_free;	1257	goto err_free_irq;
1248		1258
1249	return 0;	1259	return 0;
1250		1260
1251	err_mem_free:	1261	err_free_irq:
1252	hid_destroy_device(hid);
1253
1254	err_irq:
1255	free_irq(client->irq, ihid);	1262	free_irq(client->irq, ihid);
1256		1263	err_power_down:
1257	err_buffers_allocated:	1264	if (!ihid->is_panel_follower)
		1265	i2c_hid_core_power_down(ihid);
		1266	err_destroy_device:
		1267	hid_destroy_device(hid);
		1268	err_free_buffers:
1258	i2c_hid_free_buffers(ihid);	1269	i2c_hid_free_buffers(ihid);
1259		1270
1260	return ret;	1271	return ret;
@@ -1266,7 +1277,14 @@ void i2c_hid_core_remove(struct i2c_client *client) · 5 unmodified lines
1266	struct i2c_hid *ihid = i2c_get_clientdata(client);	1277	struct i2c_hid *ihid = i2c_get_clientdata(client);
1267	struct hid_device *hid;	1278	struct hid_device *hid;
1268		1279
1269	i2c_hid_core_final_power_down(ihid);	1280	/*
		1281	* If we're a follower, the act of unfollowing will cause us to be
		1282	* powered down. Otherwise we need to manually do it.
		1283	*/
		1284	if (ihid->is_panel_follower)
		1285	drm_panel_remove_follower(&ihid->panel_follower);
		1286	else
		1287	i2c_hid_core_suspend(ihid, true);
1270		1288
1271	hid = ihid->hid;	1289	hid = ihid->hid;
1272	hid_destroy_device(hid);	1290	hid_destroy_device(hid);

drivers/hid/intel-ish-hid/ipc/pci-ish.c+8−0

@@ -133,6 +133,14 @@ static int enable_gpe(struct device *dev) · 132 unmodified lines
133	}	133	}
134	wakeup = &adev->wakeup;	134	wakeup = &adev->wakeup;
135		135
		136	/*
		137	* Call acpi_disable_gpe(), so that reference count
		138	* gpe_event_info->runtime_count doesn't overflow.
		139	* When gpe_event_info->runtime_count = 0, the call
		140	* to acpi_disable_gpe() simply return.
		141	*/
		142	acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
		143
136	acpi_sts = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);	144	acpi_sts = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
137	if (ACPI_FAILURE(acpi_sts)) {	145	if (ACPI_FAILURE(acpi_sts)) {
138	dev_err(dev, "enable ose_gpe failed\n");	146	dev_err(dev, "enable ose_gpe failed\n");

drivers/hwtracing/coresight/coresight-tmc-etr.c+15−12

 	flat_buf->vaddr = dma_alloc_noncoherent(real_dev, etr_buf->size,
 						&flat_buf->daddr,
-						DMA_FROM_DEVICE, GFP_KERNEL);
+						DMA_FROM_DEVICE,
+						GFP_KERNEL | __GFP_NOWARN);
 	if (!flat_buf->vaddr) {
 		kfree(flat_buf);
 		return -ENOMEM;
 		goto out;
 	}
-	/*
-	 * In sysFS mode we can have multiple writers per sink.  Since this
-	 * sink is already enabled no memory is needed and the HW need not be
-	 * touched, even if the buffer size has changed.
-	 */
-	if (drvdata->mode == CS_MODE_SYSFS) {
-		atomic_inc(&csdev->refcnt);
-		goto out;
-	}
 	/*
 	 * If we don't have a buffer or it doesn't match the requested size,
 	 * use the buffer allocated above. Otherwise reuse the existing buffer.
 static int tmc_enable_etr_sink_sysfs(struct coresight_device *csdev)
 {
-	int ret;
+	int ret = 0;
 	unsigned long flags;
 	struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 	struct etr_buf *sysfs_buf = tmc_etr_get_sysfs_buffer(csdev);
 		return PTR_ERR(sysfs_buf);
 	spin_lock_irqsave(&drvdata->spinlock, flags);
+	/*
+	 * In sysFS mode we can have multiple writers per sink.  Since this
+	 * sink is already enabled no memory is needed and the HW need not be
+	 * touched, even if the buffer size has changed.
+	 */
+	if (drvdata->mode == CS_MODE_SYSFS) {
+		atomic_inc(&csdev->refcnt);
+		goto out;
+	}
 	ret = tmc_etr_enable_hw(drvdata, sysfs_buf);
 	if (!ret) {
 		drvdata->mode = CS_MODE_SYSFS;
 		atomic_inc(&csdev->refcnt);
 	}
+out:
 	spin_unlock_irqrestore(&drvdata->spinlock, flags);
 	if (!ret)

drivers/iio/adc/ad7192.c+25−4

@@ -177,6 +177,7 @@ struct ad7192_chip_info { · 176 unmodified lines
177	struct ad7192_state {	177	struct ad7192_state {
178	const struct ad7192_chip_info *chip_info;	178	const struct ad7192_chip_info *chip_info;
179	struct regulator *avdd;	179	struct regulator *avdd;
		180	struct regulator *vref;
180	struct clk *mclk;	181	struct clk *mclk;
181	u16 int_vref_mv;	182	u16 int_vref_mv;
182	u32 fclk;	183	u32 fclk;
@@ -1008,10 +1009,30 @@ static int ad7192_probe(struct spi_device *spi) · 825 unmodified lines
1008	if (ret)	1009	if (ret)
1009	return dev_err_probe(&spi->dev, ret, "Failed to enable specified DVdd supply\n");	1010	return dev_err_probe(&spi->dev, ret, "Failed to enable specified DVdd supply\n");
1010		1011
1011	ret = regulator_get_voltage(st->avdd);	1012	st->vref = devm_regulator_get_optional(&spi->dev, "vref");
1012	if (ret < 0) {	1013	if (IS_ERR(st->vref)) {
1013	dev_err(&spi->dev, "Device tree error, reference voltage undefined\n");	1014	if (PTR_ERR(st->vref) != -ENODEV)
1014	return ret;	1015	return PTR_ERR(st->vref);
		1016
		1017	ret = regulator_get_voltage(st->avdd);
		1018	if (ret < 0)
		1019	return dev_err_probe(&spi->dev, ret,
		1020	"Device tree error, AVdd voltage undefined\n");
		1021	} else {
		1022	ret = regulator_enable(st->vref);
		1023	if (ret) {
		1024	dev_err(&spi->dev, "Failed to enable specified Vref supply\n");
		1025	return ret;
		1026	}
		1027
		1028	ret = devm_add_action_or_reset(&spi->dev, ad7192_reg_disable, st->vref);
		1029	if (ret)
		1030	return ret;
		1031
		1032	ret = regulator_get_voltage(st->vref);
		1033	if (ret < 0)
		1034	return dev_err_probe(&spi->dev, ret,
		1035	"Device tree error, Vref voltage undefined\n");
1015	}	1036	}
1016	st->int_vref_mv = ret / 1000;	1037	st->int_vref_mv = ret / 1000;
1017		1038

drivers/iio/adc/imx8qxp-adc.c+2−2

@@ -38,8 +38,8 @@ · 37 unmodified lines
38	#define IMX8QXP_ADR_ADC_FCTRL 0x30	38	#define IMX8QXP_ADR_ADC_FCTRL 0x30
39	#define IMX8QXP_ADR_ADC_SWTRIG 0x34	39	#define IMX8QXP_ADR_ADC_SWTRIG 0x34
40	#define IMX8QXP_ADR_ADC_TCTRL(tid) (0xc0 + (tid) * 4)	40	#define IMX8QXP_ADR_ADC_TCTRL(tid) (0xc0 + (tid) * 4)
41	#define IMX8QXP_ADR_ADC_CMDH(cid) (0x100 + (cid) * 8)	41	#define IMX8QXP_ADR_ADC_CMDL(cid) (0x100 + (cid) * 8)
42	#define IMX8QXP_ADR_ADC_CMDL(cid) (0x104 + (cid) * 8)	42	#define IMX8QXP_ADR_ADC_CMDH(cid) (0x104 + (cid) * 8)
43	#define IMX8QXP_ADR_ADC_RESFIFO 0x300	43	#define IMX8QXP_ADR_ADC_RESFIFO 0x300
44	#define IMX8QXP_ADR_ADC_TST 0xffc	44	#define IMX8QXP_ADR_ADC_TST 0xffc
45		45

drivers/iio/addac/Kconfig+2−0

 	depends on GPIOLIB && SPI
 	select REGMAP_SPI
 	select CRC8
+	select IIO_BUFFER
+	select IIO_TRIGGERED_BUFFER
 	help
 	  Say yes here to build support for Analog Devices AD74412R/AD74413R
 	  quad-channel software configurable input/output solution.

drivers/iio/common/cros_ec_sensors/cros_ec_sensors_core.c+5−1

 	/*
 	 * Ignore samples if the buffer is not set: it is needed if the ODR is
 	 * set but the buffer is not enabled yet.
+	 *
+	 * Note: iio_device_claim_buffer_mode() returns -EBUSY if the buffer
+	 * is not enabled.
 	 */
-	if (!iio_buffer_enabled(indio_dev))
+	if (iio_device_claim_buffer_mode(indio_dev) < 0)
 		return 0;
 	out = (s16 *)st->samples;
 	iio_push_to_buffers_with_timestamp(indio_dev, st->samples,
 					   timestamp + delta);
+	iio_device_release_buffer_mode(indio_dev);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(cros_ec_sensors_push_data);

drivers/iio/dac/ad3552r.c+2−2

@@ -140,8 +140,8 @@ enum ad3552r_ch_vref_select { · 139 unmodified lines
140	};	140	};
141		141
142	enum ad3542r_id {	142	enum ad3542r_id {
143	AD3542R_ID = 0x4008,	143	AD3542R_ID = 0x4009,
144	AD3552R_ID = 0x4009,	144	AD3552R_ID = 0x4008,
145	};	145	};
146		146
147	enum ad3552r_ch_output_range {	147	enum ad3552r_ch_output_range {

drivers/iio/frequency/admv1013.c+2−2

@@ -351,9 +351,9 @@ static int admv1013_update_mixer_vgate(struct admv1013_state *st) · 350 unmodified lines
351	if (vcm < 0)	351	if (vcm < 0)
352	return vcm;	352	return vcm;
353		353
354	if (vcm < 1800000)	354	if (vcm <= 1800000)
355	mixer_vgate = (2389 * vcm / 1000000 + 8100) / 100;	355	mixer_vgate = (2389 * vcm / 1000000 + 8100) / 100;
356	else if (vcm > 1800000 && vcm < 2600000)	356	else if (vcm > 1800000 && vcm <= 2600000)
357	mixer_vgate = (2375 * vcm / 1000000 + 125) / 100;	357	mixer_vgate = (2375 * vcm / 1000000 + 125) / 100;
358	else	358	else
359	return -EINVAL;	359	return -EINVAL;

drivers/iio/imu/bno055/Kconfig+2−0

@@ -2,6 +2,8 @@ · 1 unmodified line
2		2
3	config BOSCH_BNO055	3	config BOSCH_BNO055
4	tristate	4	tristate
		5	select IIO_BUFFER
		6	select IIO_TRIGGERED_BUFFER
5		7
6	config BOSCH_BNO055_SERIAL	8	config BOSCH_BNO055_SERIAL
7	tristate "Bosch BNO055 attached via UART"	9	tristate "Bosch BNO055 attached via UART"

drivers/iio/light/vcnl4000.c+0−1

@@ -1513,7 +1513,6 @@ static int vcnl4040_write_event_config(struct iio_dev *indio_dev, · 1512 unmodified lines
1513		1513
1514	out:	1514	out:
1515	mutex_unlock(&data->vcnl4000_lock);	1515	mutex_unlock(&data->vcnl4000_lock);
1516	data->chip_spec->set_power_state(data, data->ps_int \|\| data->als_int);
1517		1516
1518	return ret;	1517	return ret;
1519	}	1518	}

drivers/iio/pressure/bmp280-core.c+1−1

@@ -2179,7 +2179,7 @@ int bmp280_common_probe(struct device *dev, · 2178 unmodified lines
2179	* however as it happens, the BMP085 shares the chip ID of BMP180	2179	* however as it happens, the BMP085 shares the chip ID of BMP180
2180	* so we look for an IRQ if we have that.	2180	* so we look for an IRQ if we have that.
2181	*/	2181	*/
2182	if (irq > 0 \|\| (chip_id == BMP180_CHIP_ID)) {	2182	if (irq > 0 && (chip_id == BMP180_CHIP_ID)) {
2183	ret = bmp085_fetch_eoc_irq(dev, name, irq, data);	2183	ret = bmp085_fetch_eoc_irq(dev, name, irq, data);
2184	if (ret)	2184	if (ret)
2185	return ret;	2185	return ret;

drivers/iio/pressure/dps310.c+4−4

@@ -57,8 +57,8 @@ · 56 unmodified lines
57	#define DPS310_RESET_MAGIC 0x09	57	#define DPS310_RESET_MAGIC 0x09
58	#define DPS310_COEF_BASE 0x10	58	#define DPS310_COEF_BASE 0x10
59		59
60	/* Make sure sleep time is <= 20ms for usleep_range */	60	/* Make sure sleep time is <= 30ms for usleep_range */
61	#define DPS310_POLL_SLEEP_US(t) min(20000, (t) / 8)	61	#define DPS310_POLL_SLEEP_US(t) min(30000, (t) / 8)
62	/* Silently handle error in rate value here */	62	/* Silently handle error in rate value here */
63	#define DPS310_POLL_TIMEOUT_US(rc) ((rc) <= 0 ? 1000000 : 1000000 / (rc))	63	#define DPS310_POLL_TIMEOUT_US(rc) ((rc) <= 0 ? 1000000 : 1000000 / (rc))
64		64
@@ -402,8 +402,8 @@ static int dps310_reset_wait(struct dps310_data *data) · 337 unmodified lines
402	if (rc)	402	if (rc)
403	return rc;	403	return rc;
404		404
405	/* Wait for device chip access: 2.5ms in specification */	405	/* Wait for device chip access: 15ms in specification */
406	usleep_range(2500, 12000);	406	usleep_range(15000, 55000);
407	return 0;	407	return 0;
408	}	408	}
409		409

drivers/iio/pressure/ms5611_core.c+1−1

@@ -76,7 +76,7 @@ static bool ms5611_prom_is_valid(u16 *prom, size_t len) · 75 unmodified lines
76		76
77	crc = (crc >> 12) & 0x000F;	77	crc = (crc >> 12) & 0x000F;
78		78
79	return crc_orig != 0x0000 && crc == crc_orig;	79	return crc == crc_orig;
80	}	80	}
81		81
82	static int ms5611_read_prom(struct iio_dev *indio_dev)	82	static int ms5611_read_prom(struct iio_dev *indio_dev)

drivers/iio/proximity/irsd200.c+3−3

@@ -759,14 +759,14 @@ static irqreturn_t irsd200_trigger_handler(int irq, void *pollf) · 758 unmodified lines
759	{	759	{
760	struct iio_dev indio_dev = ((struct iio_poll_func )pollf)->indio_dev;	760	struct iio_dev indio_dev = ((struct iio_poll_func )pollf)->indio_dev;
761	struct irsd200_data *data = iio_priv(indio_dev);	761	struct irsd200_data *data = iio_priv(indio_dev);
762	s16 buf = 0;	762	s64 buf[2] = {};
763	int ret;	763	int ret;
764		764
765	ret = irsd200_read_data(data, &buf);	765	ret = irsd200_read_data(data, (s16 *)buf);
766	if (ret)	766	if (ret)
767	goto end;	767	goto end;
768		768
769	iio_push_to_buffers_with_timestamp(indio_dev, &buf,	769	iio_push_to_buffers_with_timestamp(indio_dev, buf,
770	iio_get_time_ns(indio_dev));	770	iio_get_time_ns(indio_dev));
771		771
772	end:	772	end:

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

@@ -4968,7 +4968,7 @@ static int cma_iboe_join_multicast(struct rdma_id_private *id_priv, · 4967 unmodified lines
4968	int err = 0;	4968	int err = 0;
4969	struct sockaddr addr = (struct sockaddr )&mc->addr;	4969	struct sockaddr addr = (struct sockaddr )&mc->addr;
4970	struct net_device *ndev = NULL;	4970	struct net_device *ndev = NULL;
4971	struct ib_sa_multicast ib;	4971	struct ib_sa_multicast ib = {};
4972	enum ib_gid_type gid_type;	4972	enum ib_gid_type gid_type;
4973	bool send_only;	4973	bool send_only;
4974		4974

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

@@ -217,7 +217,7 @@ static int make_cma_ports(struct cma_dev_group *cma_dev_group, · 216 unmodified lines
217	return -ENOMEM;	217	return -ENOMEM;
218		218
219	for (i = 0; i < ports_num; i++) {	219	for (i = 0; i < ports_num; i++) {
220	char port_str[10];	220	char port_str[11];
221		221
222	ports[i].port_num = i + 1;	222	ports[i].port_num = i + 1;
223	snprintf(port_str, sizeof(port_str), "%u", i + 1);	223	snprintf(port_str, sizeof(port_str), "%u", i + 1);

drivers/infiniband/core/nldev.c+1−0

@@ -2529,6 +2529,7 @@ static const struct rdma_nl_cbs nldev_cb_table[RDMA_NLDEV_NUM_OPS] = { · 2528 unmodified lines
2529	},	2529	},
2530	[RDMA_NLDEV_CMD_SYS_SET] = {	2530	[RDMA_NLDEV_CMD_SYS_SET] = {
2531	.doit = nldev_set_sys_set_doit,	2531	.doit = nldev_set_sys_set_doit,
		2532	.flags = RDMA_NL_ADMIN_PERM,
2532	},	2533	},
2533	[RDMA_NLDEV_CMD_STAT_SET] = {	2534	[RDMA_NLDEV_CMD_STAT_SET] = {
2534	.doit = nldev_stat_set_doit,	2535	.doit = nldev_stat_set_doit,

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

@@ -546,7 +546,7 @@ static ssize_t verify_hdr(struct ib_uverbs_cmd_hdr *hdr, · 545 unmodified lines
546	if (hdr->in_words * 4 != count)	546	if (hdr->in_words * 4 != count)
547	return -EINVAL;	547	return -EINVAL;
548		548
549	if (count < method_elm->req_size + sizeof(hdr)) {	549	if (count < method_elm->req_size + sizeof(*hdr)) {
550	/*	550	/*
551	* rdma-core v18 and v19 have a bug where they send DESTROY_CQ	551	* rdma-core v18 and v19 have a bug where they send DESTROY_CQ
552	* with a 16 byte write instead of 24. Old kernels didn't	552	* with a 16 byte write instead of 24. Old kernels didn't

drivers/infiniband/hw/bnxt_re/ib_verbs.c+4−0

 	list_del(&qp->list);
 	mutex_unlock(&rdev->qp_lock);
 	atomic_dec(&rdev->stats.res.qp_count);
+	if (qp->qplib_qp.type == CMDQ_CREATE_QP_TYPE_RC)
+		atomic_dec(&rdev->stats.res.rc_qp_count);
+	else if (qp->qplib_qp.type == CMDQ_CREATE_QP_TYPE_UD)
+		atomic_dec(&rdev->stats.res.ud_qp_count);
 	ib_umem_release(qp->rumem);
 	ib_umem_release(qp->sumem);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c+9−2

 		blocked = cookie & RCFW_CMD_IS_BLOCKING;
 		cookie &= RCFW_MAX_COOKIE_VALUE;
 		crsqe = &rcfw->crsqe_tbl[cookie];
-		crsqe->is_in_used = false;
 		if (WARN_ONCE(test_bit(FIRMWARE_STALL_DETECTED,
 				       &rcfw->cmdq.flags),
 			atomic_dec(&rcfw->timeout_send);
 		if (crsqe->is_waiter_alive) {
-			if (crsqe->resp)
+			if (crsqe->resp) {
 				memcpy(crsqe->resp, qp_event, sizeof(*qp_event));
+				/* Insert write memory barrier to ensure that
+				 * response data is copied before clearing the
+				 * flags
+				 */
+				smp_wmb();
+			}
 			if (!blocked)
 				wait_cmds++;
 		}
 		if (!is_waiter_alive)
 			crsqe->resp = NULL;
+		crsqe->is_in_used = false;
 		hwq->cons += req_size;
 		/* This is a case to handle below scenario -

drivers/infiniband/hw/cxgb4/cm.c+3−0

@@ -1965,6 +1965,9 @@ static int send_fw_act_open_req(struct c4iw_ep *ep, unsigned int atid) · 1964 unmodified lines
1965	int win;	1965	int win;
1966		1966
1967	skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);	1967	skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
		1968	if (!skb)
		1969	return -ENOMEM;
		1970
1968	req = __skb_put_zero(skb, sizeof(*req));	1971	req = __skb_put_zero(skb, sizeof(*req));
1969	req->op_compl = htonl(WR_OP_V(FW_OFLD_CONNECTION_WR));	1972	req->op_compl = htonl(WR_OP_V(FW_OFLD_CONNECTION_WR));
1970	req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));	1973	req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));

drivers/infiniband/hw/erdma/erdma_verbs.c+3−4

 static int regmr_cmd(struct erdma_dev *dev, struct erdma_mr *mr)
 {
 	struct erdma_pd *pd = to_epd(mr->ibmr.pd);
+	u32 mtt_level = ERDMA_MR_MTT_0LEVEL;
 	struct erdma_cmdq_reg_mr_req req;
-	u32 mtt_level;
 	erdma_cmdq_build_reqhdr(&req.hdr, CMDQ_SUBMOD_RDMA, CMDQ_OPCODE_REG_MR);
 			req.phy_addr[0] = sg_dma_address(mr->mem.mtt->sglist);
 			mtt_level = mr->mem.mtt->level;
 		}
-	} else {
+	} else if (mr->type != ERDMA_MR_TYPE_DMA) {
 		memcpy(req.phy_addr, mr->mem.mtt->buf,
 		       MTT_SIZE(mr->mem.page_cnt));
-		mtt_level = ERDMA_MR_MTT_0LEVEL;
 	}
 	req.cfg0 = FIELD_PREP(ERDMA_CMD_MR_VALID_MASK, mr->valid) |
 	mtt = kzalloc(sizeof(*mtt), GFP_KERNEL);
 	if (!mtt)
-		return NULL;
+		return ERR_PTR(-ENOMEM);
 	mtt->size = ALIGN(size, PAGE_SIZE);
 	mtt->buf = vzalloc(mtt->size);

drivers/infiniband/hw/mlx4/sysfs.c+1−1

@@ -223,7 +223,7 @@ void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num, · 222 unmodified lines
223	static int add_port_entries(struct mlx4_ib_dev *device, int port_num)	223	static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
224	{	224	{
225	int i;	225	int i;
226	char buff[11];	226	char buff[12];
227	struct mlx4_ib_iov_port *port = NULL;	227	struct mlx4_ib_iov_port *port = NULL;
228	int ret = 0 ;	228	int ret = 0 ;
229	struct ib_port_attr attr;	229	struct ib_port_attr attr;

drivers/infiniband/hw/mlx5/fs.c+1−1

 	mlx5_steering_anchor_destroy_res(ft_prio);
 put_flow_table:
 	put_flow_table(dev, ft_prio, true);
-	mutex_unlock(&dev->flow_db->lock);
 free_obj:
+	mutex_unlock(&dev->flow_db->lock);
 	kfree(obj);
 	return err;

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

@@ -2084,7 +2084,7 @@ static inline char *mmap_cmd2str(enum mlx5_ib_mmap_cmd cmd) · 2083 unmodified lines
2084	case MLX5_IB_MMAP_DEVICE_MEM:	2084	case MLX5_IB_MMAP_DEVICE_MEM:
2085	return "Device Memory";	2085	return "Device Memory";
2086	default:	2086	default:
2087	return NULL;	2087	return "Unknown";
2088	}	2088	}
2089	}	2089	}
2090		2090

drivers/infiniband/hw/mlx5/mr.c+11−3

 static void set_cache_mkc(struct mlx5_cache_ent *ent, void *mkc)
 {
-	set_mkc_access_pd_addr_fields(mkc, 0, 0, ent->dev->umrc.pd);
+	set_mkc_access_pd_addr_fields(mkc, ent->rb_key.access_flags, 0,
+				      ent->dev->umrc.pd);
 	MLX5_SET(mkc, mkc, free, 1);
 	MLX5_SET(mkc, mkc, umr_en, 1);
 	MLX5_SET(mkc, mkc, access_mode_1_0, ent->rb_key.access_mode & 0x3);
 	if (!dev->cache.wq)
 		return;
-	cancel_delayed_work_sync(&dev->cache.remove_ent_dwork);
 	mutex_lock(&dev->cache.rb_lock);
 	for (node = rb_first(root); node; node = rb_next(node)) {
 		ent = rb_entry(node, struct mlx5_cache_ent, node);
 		xa_lock_irq(&ent->mkeys);
 		ent->disabled = true;
 		xa_unlock_irq(&ent->mkeys);
-		cancel_delayed_work_sync(&ent->dwork);
 	}
+	mutex_unlock(&dev->cache.rb_lock);
+	/*
+	 * After all entries are disabled and will not reschedule on WQ,
+	 * flush it and all async commands.
+	 */
+	flush_workqueue(dev->cache.wq);
 	mlx5_mkey_cache_debugfs_cleanup(dev);
 	mlx5_cmd_cleanup_async_ctx(&dev->async_ctx);
+	/* At this point all entries are disabled and have no concurrent work. */
+	mutex_lock(&dev->cache.rb_lock);
 	node = rb_first(root);
 	while (node) {
 		ent = rb_entry(node, struct mlx5_cache_ent, node);

drivers/infiniband/sw/siw/siw_cm.c+12−4

 			siw_cep_put(cep);
 			new_cep->listen_cep = NULL;
 			if (rv) {
+				siw_cancel_mpatimer(new_cep);
 				siw_cep_set_free(new_cep);
 				goto error;
 			}
 				/*
 				 * Socket close before MPA request received.
 				 */
-				siw_dbg_cep(cep, "no mpareq: drop listener\n");
+				if (cep->listen_cep) {
-				siw_cep_put(cep->listen_cep);
+					siw_dbg_cep(cep,
-				cep->listen_cep = NULL;
+						"no mpareq: drop listener\n");
+					siw_cep_put(cep->listen_cep);
+					cep->listen_cep = NULL;
+				}
 			}
 		}
 		release_cep = 1;
 	if (!cep)
 		goto out;
-	siw_dbg_cep(cep, "state: %d\n", cep->state);
+	siw_dbg_cep(cep, "cep state: %d, socket state %d\n",
+		    cep->state, sk->sk_state);
+	if (sk->sk_state != TCP_ESTABLISHED)
+		goto out;
 	switch (cep->state) {
 	case SIW_EPSTATE_RDMA_MODE:

drivers/infiniband/ulp/srp/ib_srp.c+5−11

 	u32 tag;
 	u16 ch_idx;
 	struct srp_rdma_ch *ch;
-	int ret;
 	shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
 	shost_printk(KERN_ERR, target->scsi_host,
 		     "Sending SRP abort for tag %#x\n", tag);
 	if (srp_send_tsk_mgmt(ch, tag, scmnd->device->lun,
-			      SRP_TSK_ABORT_TASK, NULL) == 0)
+			      SRP_TSK_ABORT_TASK, NULL) == 0) {
-		ret = SUCCESS;
-	else if (target->rport->state == SRP_RPORT_LOST)
-		ret = FAST_IO_FAIL;
-	else
-		ret = FAILED;
-	if (ret == SUCCESS) {
 		srp_free_req(ch, req, scmnd, 0);
-		scmnd->result = DID_ABORT << 16;
+		return SUCCESS;
-		scsi_done(scmnd);
 	}
+	if (target->rport->state == SRP_RPORT_LOST)
+		return FAST_IO_FAIL;
-	return ret;
+	return FAILED;
 }
 static int srp_reset_device(struct scsi_cmnd *scmnd)

drivers/input/joystick/xpad.c+4−0

 	{ 0x0079, 0x18d4, "GPD Win 2 X-Box Controller", 0, XTYPE_XBOX360 },
 	{ 0x03eb, 0xff01, "Wooting One (Legacy)", 0, XTYPE_XBOX360 },
 	{ 0x03eb, 0xff02, "Wooting Two (Legacy)", 0, XTYPE_XBOX360 },
+	{ 0x03f0, 0x0495, "HyperX Clutch Gladiate", 0, XTYPE_XBOXONE },
 	{ 0x044f, 0x0f00, "Thrustmaster Wheel", 0, XTYPE_XBOX },
 	{ 0x044f, 0x0f03, "Thrustmaster Wheel", 0, XTYPE_XBOX },
 	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
 	{ 0x1038, 0x1430, "SteelSeries Stratus Duo", 0, XTYPE_XBOX360 },
 	{ 0x1038, 0x1431, "SteelSeries Stratus Duo", 0, XTYPE_XBOX360 },
 	{ 0x11c9, 0x55f0, "Nacon GC-100XF", 0, XTYPE_XBOX360 },
+	{ 0x11ff, 0x0511, "PXN V900", 0, XTYPE_XBOX360 },
 	{ 0x1209, 0x2882, "Ardwiino Controller", 0, XTYPE_XBOX360 },
 	{ 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 	{ 0x12ab, 0x0301, "PDP AFTERGLOW AX.1", 0, XTYPE_XBOX360 },
 	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* Xbox USB-IF not-approved class */
 	XPAD_XBOX360_VENDOR(0x0079),		/* GPD Win 2 controller */
 	XPAD_XBOX360_VENDOR(0x03eb),		/* Wooting Keyboards (Legacy) */
+	XPAD_XBOXONE_VENDOR(0x03f0),		/* HP HyperX Xbox One controllers */
 	XPAD_XBOX360_VENDOR(0x044f),		/* Thrustmaster Xbox 360 controllers */
 	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft Xbox 360 controllers */
 	XPAD_XBOXONE_VENDOR(0x045e),		/* Microsoft Xbox One controllers */
 	XPAD_XBOX360_VENDOR(0x1038),		/* SteelSeries controllers */
 	XPAD_XBOXONE_VENDOR(0x10f5),		/* Turtle Beach Controllers */
 	XPAD_XBOX360_VENDOR(0x11c9),		/* Nacon GC100XF */
+	XPAD_XBOX360_VENDOR(0x11ff),		/* PXN V900 */
 	XPAD_XBOX360_VENDOR(0x1209),		/* Ardwiino Controllers */
 	XPAD_XBOX360_VENDOR(0x12ab),		/* Xbox 360 dance pads */
 	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane Xbox 360 controllers */

drivers/input/misc/powermate.c+1−0

@@ -425,6 +425,7 @@ static void powermate_disconnect(struct usb_interface *intf) · 424 unmodified lines
425	pm->requires_update = 0;	425	pm->requires_update = 0;
426	usb_kill_urb(pm->irq);	426	usb_kill_urb(pm->irq);
427	input_unregister_device(pm->input);	427	input_unregister_device(pm->input);
		428	usb_kill_urb(pm->config);
428	usb_free_urb(pm->irq);	429	usb_free_urb(pm->irq);
429	usb_free_urb(pm->config);	430	usb_free_urb(pm->config);
430	powermate_free_buffers(interface_to_usbdev(intf), pm);	431	powermate_free_buffers(interface_to_usbdev(intf), pm);

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

@@ -2114,6 +2114,7 @@ static int elantech_setup_ps2(struct psmouse *psmouse, · 2113 unmodified lines
2114	psmouse->protocol_handler = elantech_process_byte;	2114	psmouse->protocol_handler = elantech_process_byte;
2115	psmouse->disconnect = elantech_disconnect;	2115	psmouse->disconnect = elantech_disconnect;
2116	psmouse->reconnect = elantech_reconnect;	2116	psmouse->reconnect = elantech_reconnect;
		2117	psmouse->fast_reconnect = NULL;
2117	psmouse->pktsize = info->hw_version > 1 ? 6 : 4;	2118	psmouse->pktsize = info->hw_version > 1 ? 6 : 4;
2118		2119
2119	return 0;	2120	return 0;

drivers/input/mouse/psmouse-smbus.c+7−12

 #define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
-#include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/libps2.h>
 	return PSMOUSE_FULL_PACKET;
 }
-static void psmouse_activate_smbus_mode(struct psmouse_smbus_dev *smbdev)
-{
-	if (smbdev->need_deactivate) {
-		psmouse_deactivate(smbdev->psmouse);
-		/* Give the device time to switch into SMBus mode */
-		msleep(30);
-	}
-}
 static int psmouse_smbus_reconnect(struct psmouse *psmouse)
 {
-	psmouse_activate_smbus_mode(psmouse->private);
+	struct psmouse_smbus_dev *smbdev = psmouse->private;
+	if (smbdev->need_deactivate)
+		psmouse_deactivate(psmouse);
 	return 0;
 }
 		}
 	}
-	psmouse_activate_smbus_mode(smbdev);
+	if (need_deactivate)
+		psmouse_deactivate(psmouse);
 	psmouse->private = smbdev;
 	psmouse->protocol_handler = psmouse_smbus_process_byte;

drivers/input/mouse/synaptics.c+2−0

 	psmouse->set_rate = synaptics_set_rate;
 	psmouse->disconnect = synaptics_disconnect;
 	psmouse->reconnect = synaptics_reconnect;
+	psmouse->fast_reconnect = NULL;
 	psmouse->cleanup = synaptics_reset;
 	/* Synaptics can usually stay in sync without extra help */
 	psmouse->resync_time = 0;
 		psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
 		!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10);
 	const struct rmi_device_platform_data pdata = {
+		.reset_delay_ms = 30,
 		.sensor_pdata = {
 			.sensor_type = rmi_sensor_touchpad,
 			.axis_align.flip_y = true,

drivers/input/rmi4/rmi_smbus.c+28−22

 static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
 {
-	int retval;
+	struct i2c_client *client = rmi_smb->client;
+	int smbus_version;
+	/*
+	 * psmouse driver resets the controller, we only need to wait
+	 * to give the firmware chance to fully reinitialize.
+	 */
+	if (rmi_smb->xport.pdata.reset_delay_ms)
+		msleep(rmi_smb->xport.pdata.reset_delay_ms);
 	/* we need to get the smbus version to activate the touchpad */
-	retval = rmi_smb_get_version(rmi_smb);
+	smbus_version = rmi_smb_get_version(rmi_smb);
-	if (retval < 0)
+	if (smbus_version < 0)
-		return retval;
+		return smbus_version;
+	rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
+		smbus_version);
+	if (smbus_version != 2 && smbus_version != 3) {
+		dev_err(&client->dev, "Unrecognized SMB version %d\n",
+				smbus_version);
+		return -ENODEV;
+	}
 	return 0;
 }
 	rmi_smb_clear_state(rmi_smb);
 	/*
-	 * we do not call the actual reset command, it has to be handled in
+	 * We do not call the actual reset command, it has to be handled in
-	 * PS/2 or there will be races between PS/2 and SMBus.
+	 * PS/2 or there will be races between PS/2 and SMBus. PS/2 should
-	 * PS/2 should ensure that a psmouse_reset is called before
+	 * ensure that a psmouse_reset is called before initializing the
-	 * intializing the device and after it has been removed to be in a known
+	 * device and after it has been removed to be in a known state.
-	 * state.
 	 */
 	return rmi_smb_enable_smbus_mode(rmi_smb);
 }
 {
 	struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
 	struct rmi_smb_xport *rmi_smb;
-	int smbus_version;
 	int error;
 	if (!pdata) {
 	rmi_smb->xport.proto_name = "smb";
 	rmi_smb->xport.ops = &rmi_smb_ops;
-	smbus_version = rmi_smb_get_version(rmi_smb);
+	error = rmi_smb_enable_smbus_mode(rmi_smb);
-	if (smbus_version < 0)
+	if (error)
-		return smbus_version;
+		return error;
-	rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
-		smbus_version);
-	if (smbus_version != 2 && smbus_version != 3) {
-		dev_err(&client->dev, "Unrecognized SMB version %d\n",
-				smbus_version);
-		return -ENODEV;
-	}
 	i2c_set_clientdata(client, rmi_smb);

drivers/input/serio/i8042-acpipnpio.h+8−0

@@ -618,6 +618,14 @@ static const struct dmi_system_id i8042_dmi_quirk_table[] __initconst = { · 617 unmodified lines
618	},	618	},
619	.driver_data = (void *)(SERIO_QUIRK_NOMUX)	619	.driver_data = (void *)(SERIO_QUIRK_NOMUX)
620	},	620	},
		621	{
		622	/* Fujitsu Lifebook E5411 */
		623	.matches = {
		624	DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU CLIENT COMPUTING LIMITED"),
		625	DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E5411"),
		626	},
		627	.driver_data = (void *)(SERIO_QUIRK_NOAUX)
		628	},
621	{	629	{
622	/* Gigabyte M912 */	630	/* Gigabyte M912 */
623	.matches = {	631	.matches = {

drivers/input/touchscreen/goodix.c+19−0

@@ -900,6 +900,25 @@ static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts) · 899 unmodified lines
900	dev_info(dev, "No ACPI GpioInt resource, assuming that the GPIO order is reset, int\n");	900	dev_info(dev, "No ACPI GpioInt resource, assuming that the GPIO order is reset, int\n");
901	ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;	901	ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
902	gpio_mapping = acpi_goodix_int_last_gpios;	902	gpio_mapping = acpi_goodix_int_last_gpios;
		903	} else if (ts->gpio_count == 1 && ts->gpio_int_idx == 0) {
		904	/*
		905	* On newer devices there is only 1 GpioInt resource and _PS0
		906	* does the whole reset sequence for us.
		907	*/
		908	acpi_device_fix_up_power(ACPI_COMPANION(dev));
		909
		910	/*
		911	* Before the _PS0 call the int GPIO may have been in output
		912	* mode and the call should have put the int GPIO in input mode,
		913	* but the GPIO subsys cached state may still think it is
		914	* in output mode, causing gpiochip_lock_as_irq() failure.
		915	*
		916	* Add a mapping for the int GPIO to make the
		917	* gpiod_int = gpiod_get(..., GPIOD_IN) call succeed,
		918	* which will explicitly set the direction to input.
		919	*/
		920	ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
		921	gpio_mapping = acpi_goodix_int_first_gpios;
903	} else {	922	} else {
904	dev_warn(dev, "Unexpected ACPI resources: gpio_count %d, gpio_int_idx %d\n",	923	dev_warn(dev, "Unexpected ACPI resources: gpio_count %d, gpio_int_idx %d\n",
905	ts->gpio_count, ts->gpio_int_idx);	924	ts->gpio_count, ts->gpio_int_idx);

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-gic-common.h+4−0

@@ -29,4 +29,8 @@ void gic_enable_quirks(u32 iidr, const struct gic_quirk *quirks, · 28 unmodified lines
29	void gic_enable_of_quirks(const struct device_node *np,	29	void gic_enable_of_quirks(const struct device_node *np,
30	const struct gic_quirk quirks, void data);	30	const struct gic_quirk quirks, void data);
31		31
		32	#define RDIST_FLAGS_PROPBASE_NEEDS_FLUSHING (1 << 0)
		33	#define RDIST_FLAGS_RD_TABLES_PREALLOCATED (1 << 1)
		34	#define RDIST_FLAGS_FORCE_NON_SHAREABLE (1 << 2)
		35
32	#endif /* _IRQ_GIC_COMMON_H */	36	#endif /* _IRQ_GIC_COMMON_H */

drivers/irqchip/irq-gic-v3-its.c+106−64

@@ -44,10 +44,6 @@ · 43 unmodified lines
44	#define ITS_FLAGS_WORKAROUND_CAVIUM_23144 (1ULL << 2)	44	#define ITS_FLAGS_WORKAROUND_CAVIUM_23144 (1ULL << 2)
45	#define ITS_FLAGS_FORCE_NON_SHAREABLE (1ULL << 3)	45	#define ITS_FLAGS_FORCE_NON_SHAREABLE (1ULL << 3)
46		46
47	#define RDIST_FLAGS_PROPBASE_NEEDS_FLUSHING (1 << 0)
48	#define RDIST_FLAGS_RD_TABLES_PREALLOCATED (1 << 1)
49	#define RDIST_FLAGS_FORCE_NON_SHAREABLE (1 << 2)
50
51	#define RD_LOCAL_LPI_ENABLED BIT(0)	47	#define RD_LOCAL_LPI_ENABLED BIT(0)
52	#define RD_LOCAL_PENDTABLE_PREALLOCATED BIT(1)	48	#define RD_LOCAL_PENDTABLE_PREALLOCATED BIT(1)
53	#define RD_LOCAL_MEMRESERVE_DONE BIT(2)	49	#define RD_LOCAL_MEMRESERVE_DONE BIT(2)
@@ -4754,6 +4750,14 @@ static bool __maybe_unused its_enable_rk3588001(void *data) · 4700 unmodified lines
4754	return true;	4750	return true;
4755	}	4751	}
4756		4752
		4753	static bool its_set_non_coherent(void *data)
		4754	{
		4755	struct its_node *its = data;
		4756
		4757	its->flags \|= ITS_FLAGS_FORCE_NON_SHAREABLE;
		4758	return true;
		4759	}
		4760
4757	static const struct gic_quirk its_quirks[] = {	4761	static const struct gic_quirk its_quirks[] = {
4758	#ifdef CONFIG_CAVIUM_ERRATUM_22375	4762	#ifdef CONFIG_CAVIUM_ERRATUM_22375
4759	{	4763	{
@@ -4808,6 +4812,11 @@ static const struct gic_quirk its_quirks[] = { · 48 unmodified lines
4808	.init = its_enable_rk3588001,	4812	.init = its_enable_rk3588001,
4809	},	4813	},
4810	#endif	4814	#endif
		4815	{
		4816	.desc = "ITS: non-coherent attribute",
		4817	.property = "dma-noncoherent",
		4818	.init = its_set_non_coherent,
		4819	},
4811	{	4820	{
4812	}	4821	}
4813	};	4822	};
@@ -4817,6 +4826,10 @@ static void its_enable_quirks(struct its_node *its) · 3 unmodified lines
4817	u32 iidr = readl_relaxed(its->base + GITS_IIDR);	4826	u32 iidr = readl_relaxed(its->base + GITS_IIDR);
4818		4827
4819	gic_enable_quirks(iidr, its_quirks, its);	4828	gic_enable_quirks(iidr, its_quirks, its);
		4829
		4830	if (is_of_node(its->fwnode_handle))
		4831	gic_enable_of_quirks(to_of_node(its->fwnode_handle),
		4832	its_quirks, its);
4820	}	4833	}
4821		4834
4822	static int its_save_disable(void)	4835	static int its_save_disable(void)
@@ -4952,7 +4965,7 @@ out_unmap: · 129 unmodified lines
4952	return NULL;	4965	return NULL;
4953	}	4966	}
4954		4967
4955	static int its_init_domain(struct fwnode_handle handle, struct its_node its)	4968	static int its_init_domain(struct its_node *its)
4956	{	4969	{
4957	struct irq_domain *inner_domain;	4970	struct irq_domain *inner_domain;
4958	struct msi_domain_info *info;	4971	struct msi_domain_info *info;
@@ -4966,7 +4979,7 @@ static int its_init_domain(struct fwnode_handle handle, struct its_node its) · 7 unmodified lines
4966		4979
4967	inner_domain = irq_domain_create_hierarchy(its_parent,	4980	inner_domain = irq_domain_create_hierarchy(its_parent,
4968	its->msi_domain_flags, 0,	4981	its->msi_domain_flags, 0,
4969	handle, &its_domain_ops,	4982	its->fwnode_handle, &its_domain_ops,
4970	info);	4983	info);
4971	if (!inner_domain) {	4984	if (!inner_domain) {
4972	kfree(info);	4985	kfree(info);
@@ -5017,8 +5030,7 @@ static int its_init_vpe_domain(void) · 44 unmodified lines
5017	return 0;	5030	return 0;
5018	}	5031	}
5019		5032
5020	static int __init its_compute_its_list_map(struct resource *res,	5033	static int __init its_compute_its_list_map(struct its_node *its)
5021	void __iomem *its_base)
5022	{	5034	{
5023	int its_number;	5035	int its_number;
5024	u32 ctlr;	5036	u32 ctlr;
@@ -5032,15 +5044,15 @@ static int __init its_compute_its_list_map(struct resource *res, · 7 unmodified lines
5032	its_number = find_first_zero_bit(&its_list_map, GICv4_ITS_LIST_MAX);	5044	its_number = find_first_zero_bit(&its_list_map, GICv4_ITS_LIST_MAX);
5033	if (its_number >= GICv4_ITS_LIST_MAX) {	5045	if (its_number >= GICv4_ITS_LIST_MAX) {
5034	pr_err("ITS@%pa: No ITSList entry available!\n",	5046	pr_err("ITS@%pa: No ITSList entry available!\n",
5035	&res->start);	5047	&its->phys_base);
5036	return -EINVAL;	5048	return -EINVAL;
5037	}	5049	}
5038		5050
5039	ctlr = readl_relaxed(its_base + GITS_CTLR);	5051	ctlr = readl_relaxed(its->base + GITS_CTLR);
5040	ctlr &= ~GITS_CTLR_ITS_NUMBER;	5052	ctlr &= ~GITS_CTLR_ITS_NUMBER;
5041	ctlr \|= its_number << GITS_CTLR_ITS_NUMBER_SHIFT;	5053	ctlr \|= its_number << GITS_CTLR_ITS_NUMBER_SHIFT;
5042	writel_relaxed(ctlr, its_base + GITS_CTLR);	5054	writel_relaxed(ctlr, its->base + GITS_CTLR);
5043	ctlr = readl_relaxed(its_base + GITS_CTLR);	5055	ctlr = readl_relaxed(its->base + GITS_CTLR);
5044	if ((ctlr & GITS_CTLR_ITS_NUMBER) != (its_number << GITS_CTLR_ITS_NUMBER_SHIFT)) {	5056	if ((ctlr & GITS_CTLR_ITS_NUMBER) != (its_number << GITS_CTLR_ITS_NUMBER_SHIFT)) {
5045	its_number = ctlr & GITS_CTLR_ITS_NUMBER;	5057	its_number = ctlr & GITS_CTLR_ITS_NUMBER;
5046	its_number >>= GITS_CTLR_ITS_NUMBER_SHIFT;	5058	its_number >>= GITS_CTLR_ITS_NUMBER_SHIFT;
@@ -5048,75 +5060,50 @@ static int __init its_compute_its_list_map(struct resource *res, · 1 unmodified line
5048		5060
5049	if (test_and_set_bit(its_number, &its_list_map)) {	5061	if (test_and_set_bit(its_number, &its_list_map)) {
5050	pr_err("ITS@%pa: Duplicate ITSList entry %d\n",	5062	pr_err("ITS@%pa: Duplicate ITSList entry %d\n",
5051	&res->start, its_number);	5063	&its->phys_base, its_number);
5052	return -EINVAL;	5064	return -EINVAL;
5053	}	5065	}
5054		5066
5055	return its_number;	5067	return its_number;
5056	}	5068	}
5057		5069
5058	static int __init its_probe_one(struct resource *res,	5070	static int __init its_probe_one(struct its_node *its)
5059	struct fwnode_handle *handle, int numa_node)
5060	{	5071	{
5061	struct its_node *its;	5072	u64 baser, tmp;
5062	void __iomem *its_base;
5063	u64 baser, tmp, typer;
5064	struct page *page;	5073	struct page *page;
5065	u32 ctlr;	5074	u32 ctlr;
5066	int err;	5075	int err;
5067		5076
5068	its_base = its_map_one(res, &err);
5069	if (!its_base)
5070	return err;
5071
5072	pr_info("ITS %pR\n", res);
5073
5074	its = kzalloc(sizeof(*its), GFP_KERNEL);
5075	if (!its) {
5076	err = -ENOMEM;
5077	goto out_unmap;
5078	}
5079
5080	raw_spin_lock_init(&its->lock);
5081	mutex_init(&its->dev_alloc_lock);
5082	INIT_LIST_HEAD(&its->entry);
5083	INIT_LIST_HEAD(&its->its_device_list);
5084	typer = gic_read_typer(its_base + GITS_TYPER);
5085	its->typer = typer;
5086	its->base = its_base;
5087	its->phys_base = res->start;
5088	if (is_v4(its)) {	5077	if (is_v4(its)) {
5089	if (!(typer & GITS_TYPER_VMOVP)) {	5078	if (!(its->typer & GITS_TYPER_VMOVP)) {
5090	err = its_compute_its_list_map(res, its_base);	5079	err = its_compute_its_list_map(its);
5091	if (err < 0)	5080	if (err < 0)
5092	goto out_free_its;	5081	goto out;
5093		5082
5094	its->list_nr = err;	5083	its->list_nr = err;
5095		5084
5096	pr_info("ITS@%pa: Using ITS number %d\n",	5085	pr_info("ITS@%pa: Using ITS number %d\n",
5097	&res->start, err);	5086	&its->phys_base, err);
5098	} else {	5087	} else {
5099	pr_info("ITS@%pa: Single VMOVP capable\n", &res->start);	5088	pr_info("ITS@%pa: Single VMOVP capable\n", &its->phys_base);
5100	}	5089	}
5101		5090
5102	if (is_v4_1(its)) {	5091	if (is_v4_1(its)) {
5103	u32 svpet = FIELD_GET(GITS_TYPER_SVPET, typer);	5092	u32 svpet = FIELD_GET(GITS_TYPER_SVPET, its->typer);
5104		5093
5105	its->sgir_base = ioremap(res->start + SZ_128K, SZ_64K);	5094	its->sgir_base = ioremap(its->phys_base + SZ_128K, SZ_64K);
5106	if (!its->sgir_base) {	5095	if (!its->sgir_base) {
5107	err = -ENOMEM;	5096	err = -ENOMEM;
5108	goto out_free_its;	5097	goto out;
5109	}	5098	}
5110		5099
5111	its->mpidr = readl_relaxed(its_base + GITS_MPIDR);	5100	its->mpidr = readl_relaxed(its->base + GITS_MPIDR);
5112		5101
5113	pr_info("ITS@%pa: Using GICv4.1 mode %08x %08x\n",	5102	pr_info("ITS@%pa: Using GICv4.1 mode %08x %08x\n",
5114	&res->start, its->mpidr, svpet);	5103	&its->phys_base, its->mpidr, svpet);
5115	}	5104	}
5116	}	5105	}
5117		5106
5118	its->numa_node = numa_node;
5119
5120	page = alloc_pages_node(its->numa_node, GFP_KERNEL \| __GFP_ZERO,	5107	page = alloc_pages_node(its->numa_node, GFP_KERNEL \| __GFP_ZERO,
5121	get_order(ITS_CMD_QUEUE_SZ));	5108	get_order(ITS_CMD_QUEUE_SZ));
5122	if (!page) {	5109	if (!page) {
@@ -5125,12 +5112,9 @@ static int __init its_probe_one(struct resource *res, · 2 unmodified lines
5125	}	5112	}
5126	its->cmd_base = (void *)page_address(page);	5113	its->cmd_base = (void *)page_address(page);
5127	its->cmd_write = its->cmd_base;	5114	its->cmd_write = its->cmd_base;
5128	its->fwnode_handle = handle;
5129	its->get_msi_base = its_irq_get_msi_base;	5115	its->get_msi_base = its_irq_get_msi_base;
5130	its->msi_domain_flags = IRQ_DOMAIN_FLAG_ISOLATED_MSI;	5116	its->msi_domain_flags = IRQ_DOMAIN_FLAG_ISOLATED_MSI;
5131		5117
5132	its_enable_quirks(its);
5133
5134	err = its_alloc_tables(its);	5118	err = its_alloc_tables(its);
5135	if (err)	5119	if (err)
5136	goto out_free_cmd;	5120	goto out_free_cmd;
@@ -5174,7 +5158,7 @@ static int __init its_probe_one(struct resource *res, · 37 unmodified lines
5174	ctlr \|= GITS_CTLR_ImDe;	5158	ctlr \|= GITS_CTLR_ImDe;
5175	writel_relaxed(ctlr, its->base + GITS_CTLR);	5159	writel_relaxed(ctlr, its->base + GITS_CTLR);
5176		5160
5177	err = its_init_domain(handle, its);	5161	err = its_init_domain(its);
5178	if (err)	5162	if (err)
5179	goto out_free_tables;	5163	goto out_free_tables;
5180		5164
@@ -5191,11 +5175,8 @@ out_free_cmd: · 10 unmodified lines
5191	out_unmap_sgir:	5175	out_unmap_sgir:
5192	if (its->sgir_base)	5176	if (its->sgir_base)
5193	iounmap(its->sgir_base);	5177	iounmap(its->sgir_base);
5194	out_free_its:	5178	out:
5195	kfree(its);	5179	pr_err("ITS@%pa: failed probing (%d)\n", &its->phys_base, err);
5196	out_unmap:
5197	iounmap(its_base);
5198	pr_err("ITS@%pa: failed probing (%d)\n", &res->start, err);
5199	return err;	5180	return err;
5200	}	5181	}
5201		5182
@@ -5356,10 +5337,53 @@ static const struct of_device_id its_device_id[] = { · 154 unmodified lines
5356	{},	5337	{},
5357	};	5338	};
5358		5339
		5340	static struct its_node __init its_node_init(struct resource res,
		5341	struct fwnode_handle *handle, int numa_node)
		5342	{
		5343	void __iomem *its_base;
		5344	struct its_node *its;
		5345	int err;
		5346
		5347	its_base = its_map_one(res, &err);
		5348	if (!its_base)
		5349	return NULL;
		5350
		5351	pr_info("ITS %pR\n", res);
		5352
		5353	its = kzalloc(sizeof(*its), GFP_KERNEL);
		5354	if (!its)
		5355	goto out_unmap;
		5356
		5357	raw_spin_lock_init(&its->lock);
		5358	mutex_init(&its->dev_alloc_lock);
		5359	INIT_LIST_HEAD(&its->entry);
		5360	INIT_LIST_HEAD(&its->its_device_list);
		5361
		5362	its->typer = gic_read_typer(its_base + GITS_TYPER);
		5363	its->base = its_base;
		5364	its->phys_base = res->start;
		5365
		5366	its->numa_node = numa_node;
		5367	its->fwnode_handle = handle;
		5368
		5369	return its;
		5370
		5371	out_unmap:
		5372	iounmap(its_base);
		5373	return NULL;
		5374	}
		5375
		5376	static void its_node_destroy(struct its_node *its)
		5377	{
		5378	iounmap(its->base);
		5379	kfree(its);
		5380	}
		5381
5359	static int __init its_of_probe(struct device_node *node)	5382	static int __init its_of_probe(struct device_node *node)
5360	{	5383	{
5361	struct device_node *np;	5384	struct device_node *np;
5362	struct resource res;	5385	struct resource res;
		5386	int err;
5363		5387
5364	/*	5388	/*
5365	* Make sure all the ITS are reset before we probe any, as	5389	* Make sure all the ITS are reset before we probe any, as
@@ -5369,8 +5393,6 @@ static int __init its_of_probe(struct device_node *node) · 3 unmodified lines
5369	*/	5393	*/
5370	for (np = of_find_matching_node(node, its_device_id); np;	5394	for (np = of_find_matching_node(node, its_device_id); np;
5371	np = of_find_matching_node(np, its_device_id)) {	5395	np = of_find_matching_node(np, its_device_id)) {
5372	int err;
5373
5374	if (!of_device_is_available(np) \|\|	5396	if (!of_device_is_available(np) \|\|
5375	!of_property_read_bool(np, "msi-controller") \|\|	5397	!of_property_read_bool(np, "msi-controller") \|\|
5376	of_address_to_resource(np, 0, &res))	5398	of_address_to_resource(np, 0, &res))
@@ -5383,6 +5405,8 @@ static int __init its_of_probe(struct device_node *node) · 6 unmodified lines
5383		5405
5384	for (np = of_find_matching_node(node, its_device_id); np;	5406	for (np = of_find_matching_node(node, its_device_id); np;
5385	np = of_find_matching_node(np, its_device_id)) {	5407	np = of_find_matching_node(np, its_device_id)) {
		5408	struct its_node *its;
		5409
5386	if (!of_device_is_available(np))	5410	if (!of_device_is_available(np))
5387	continue;	5411	continue;
5388	if (!of_property_read_bool(np, "msi-controller")) {	5412	if (!of_property_read_bool(np, "msi-controller")) {
@@ -5396,7 +5420,17 @@ static int __init its_of_probe(struct device_node *node) · 7 unmodified lines
5396	continue;	5420	continue;
5397	}	5421	}
5398		5422
5399	its_probe_one(&res, &np->fwnode, of_node_to_nid(np));	5423
		5424	its = its_node_init(&res, &np->fwnode, of_node_to_nid(np));
		5425	if (!its)
		5426	return -ENOMEM;
		5427
		5428	its_enable_quirks(its);
		5429	err = its_probe_one(its);
		5430	if (err) {
		5431	its_node_destroy(its);
		5432	return err;
		5433	}
5400	}	5434	}
5401	return 0;	5435	return 0;
5402	}	5436	}
@@ -5508,6 +5542,7 @@ static int __init gic_acpi_parse_madt_its(union acpi_subtable_headers *header, · 105 unmodified lines
5508	{	5542	{
5509	struct acpi_madt_generic_translator *its_entry;	5543	struct acpi_madt_generic_translator *its_entry;
5510	struct fwnode_handle *dom_handle;	5544	struct fwnode_handle *dom_handle;
		5545	struct its_node *its;
5511	struct resource res;	5546	struct resource res;
5512	int err;	5547	int err;
5513		5548
@@ -5532,11 +5567,18 @@ static int __init gic_acpi_parse_madt_its(union acpi_subtable_headers *header, · 18 unmodified lines
5532	goto dom_err;	5567	goto dom_err;
5533	}	5568	}
5534		5569
5535	err = its_probe_one(&res, dom_handle,	5570	its = its_node_init(&res, dom_handle,
5536	acpi_get_its_numa_node(its_entry->translation_id));	5571	acpi_get_its_numa_node(its_entry->translation_id));
		5572	if (!its) {
		5573	err = -ENOMEM;
		5574	goto node_err;
		5575	}
		5576
		5577	err = its_probe_one(its);
5537	if (!err)	5578	if (!err)
5538	return 0;	5579	return 0;
5539		5580
		5581	node_err:
5540	iort_deregister_domain_token(its_entry->translation_id);	5582	iort_deregister_domain_token(its_entry->translation_id);
5541	dom_err:	5583	dom_err:
5542	irq_domain_free_fwnode(dom_handle);	5584	irq_domain_free_fwnode(dom_handle);

drivers/irqchip/irq-gic-v3.c+13−0

@@ -1857,6 +1857,14 @@ static bool gic_enable_quirk_arm64_2941627(void *data) · 1856 unmodified lines
1857	return true;	1857	return true;
1858	}	1858	}
1859		1859
		1860	static bool rd_set_non_coherent(void *data)
		1861	{
		1862	struct gic_chip_data *d = data;
		1863
		1864	d->rdists.flags \|= RDIST_FLAGS_FORCE_NON_SHAREABLE;
		1865	return true;
		1866	}
		1867
1860	static const struct gic_quirk gic_quirks[] = {	1868	static const struct gic_quirk gic_quirks[] = {
1861	{	1869	{
1862	.desc = "GICv3: Qualcomm MSM8996 broken firmware",	1870	.desc = "GICv3: Qualcomm MSM8996 broken firmware",
@@ -1923,6 +1931,11 @@ static const struct gic_quirk gic_quirks[] = { · 60 unmodified lines
1923	.mask = 0xff0f0fff,	1931	.mask = 0xff0f0fff,
1924	.init = gic_enable_quirk_arm64_2941627,	1932	.init = gic_enable_quirk_arm64_2941627,
1925	},	1933	},
		1934	{
		1935	.desc = "GICv3: non-coherent attribute",
		1936	.property = "dma-noncoherent",
		1937	.init = rd_set_non_coherent,
		1938	},
1926	{	1939	{
1927	}	1940	}
1928	};	1941	};

drivers/irqchip/irq-renesas-rzg2l.c+2−2

 		raw_spin_lock(&priv->lock);
 		reg = readl_relaxed(priv->base + TSSR(tssr_index));
-		reg &= ~(TSSEL_MASK << tssr_offset);
+		reg &= ~(TSSEL_MASK << TSSEL_SHIFT(tssr_offset));
 		writel_relaxed(reg, priv->base + TSSR(tssr_index));
 		raw_spin_unlock(&priv->lock);
 	}
 	unsigned int hw_irq = irqd_to_hwirq(d);
 	if (hw_irq >= IRQC_TINT_START && hw_irq < IRQC_NUM_IRQ) {
+		unsigned long tint = (uintptr_t)irq_data_get_irq_chip_data(d);
 		struct rzg2l_irqc_priv *priv = irq_data_to_priv(d);
-		unsigned long tint = (uintptr_t)d->chip_data;
 		u32 offset = hw_irq - IRQC_TINT_START;
 		u32 tssr_offset = TSSR_OFFSET(offset);
 		u8 tssr_index = TSSR_INDEX(offset);

drivers/irqchip/irq-riscv-intc.c+9−1

 	 * for each INTC DT node. We only need to do INTC initialization
 	 * for the INTC DT node belonging to boot CPU (or boot HART).
 	 */
-	if (riscv_hartid_to_cpuid(hartid) != smp_processor_id())
+	if (riscv_hartid_to_cpuid(hartid) != smp_processor_id()) {
+		/*
+		 * The INTC nodes of each CPU are suppliers for downstream
+		 * interrupt controllers (such as PLIC, IMSIC and APLIC
+		 * direct-mode) so we should mark an INTC node as initialized
+		 * if we are not creating IRQ domain for it.
+		 */
+		fwnode_dev_initialized(of_fwnode_handle(node), true);
 		return 0;
+	}
 	return riscv_intc_init_common(of_node_to_fwnode(node));
 }

drivers/irqchip/irq-stm32-exti.c+1−0

@@ -460,6 +460,7 @@ static const struct irq_domain_ops irq_exti_domain_ops = { · 459 unmodified lines
460	.map = irq_map_generic_chip,	460	.map = irq_map_generic_chip,
461	.alloc = stm32_exti_alloc,	461	.alloc = stm32_exti_alloc,
462	.free = stm32_exti_free,	462	.free = stm32_exti_free,
		463	.xlate = irq_domain_xlate_twocell,
463	};	464	};
464		465
465	static void stm32_irq_ack(struct irq_data *d)	466	static void stm32_irq_ack(struct irq_data *d)

drivers/irqchip/qcom-pdc.c+51−18

 #define PDC_MAX_GPIO_IRQS	256
+/* Valid only on HW version < 3.2 */
 #define IRQ_ENABLE_BANK		0x10
 #define IRQ_i_CFG		0x110
+/* Valid only on HW version >= 3.2 */
+#define IRQ_i_CFG_IRQ_ENABLE	3
+#define IRQ_i_CFG_TYPE_MASK	GENMASK(2, 0)
+#define PDC_VERSION_REG		0x1000
+/* Notable PDC versions */
+#define PDC_VERSION_3_2		0x30200
 struct pdc_pin_region {
 	u32 pin_base;
 	u32 parent_base;
 static void __iomem *pdc_base;
 static struct pdc_pin_region *pdc_region;
 static int pdc_region_cnt;
+static unsigned int pdc_version;
 static void pdc_reg_write(int reg, u32 i, u32 val)
 {
 	return readl_relaxed(pdc_base + reg + i * sizeof(u32));
 }
-static void pdc_enable_intr(struct irq_data *d, bool on)
+static void __pdc_enable_intr(int pin_out, bool on)
 {
-	int pin_out = d->hwirq;
 	unsigned long enable;
-	unsigned long flags;
-	u32 index, mask;
-	index = pin_out / 32;
+	if (pdc_version < PDC_VERSION_3_2) {
-	mask = pin_out % 32;
+		u32 index, mask;
+		index = pin_out / 32;
+		mask = pin_out % 32;
+		enable = pdc_reg_read(IRQ_ENABLE_BANK, index);
+		__assign_bit(mask, &enable, on);
+		pdc_reg_write(IRQ_ENABLE_BANK, index, enable);
+	} else {
+		enable = pdc_reg_read(IRQ_i_CFG, pin_out);
+		__assign_bit(IRQ_i_CFG_IRQ_ENABLE, &enable, on);
+		pdc_reg_write(IRQ_i_CFG, pin_out, enable);
+	}
+}
+static void pdc_enable_intr(struct irq_data *d, bool on)
+{
+	unsigned long flags;
 	raw_spin_lock_irqsave(&pdc_lock, flags);
-	enable = pdc_reg_read(IRQ_ENABLE_BANK, index);
+	__pdc_enable_intr(d->hwirq, on);
-	__assign_bit(mask, &enable, on);
-	pdc_reg_write(IRQ_ENABLE_BANK, index, enable);
 	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 }
 	}
 	old_pdc_type = pdc_reg_read(IRQ_i_CFG, d->hwirq);
+	pdc_type |= (old_pdc_type & ~IRQ_i_CFG_TYPE_MASK);
 	pdc_reg_write(IRQ_i_CFG, d->hwirq, pdc_type);
 	ret = irq_chip_set_type_parent(d, type);
 static int pdc_setup_pin_mapping(struct device_node *np)
 {
 	int ret, n, i;
-	u32 irq_index, reg_index, val;
 	n = of_property_count_elems_of_size(np, "qcom,pdc-ranges", sizeof(u32));
 	if (n <= 0 || n % 3)
 		if (ret)
 			return ret;
-		for (i = 0; i < pdc_region[n].cnt; i++) {
+		for (i = 0; i < pdc_region[n].cnt; i++)
-			reg_index = (i + pdc_region[n].pin_base) >> 5;
+			__pdc_enable_intr(i + pdc_region[n].pin_base, 0);
-			irq_index = (i + pdc_region[n].pin_base) & 0x1f;
-			val = pdc_reg_read(IRQ_ENABLE_BANK, reg_index);
-			val &= ~BIT(irq_index);
-			pdc_reg_write(IRQ_ENABLE_BANK, reg_index, val);
-		}
 	}
 	return 0;
 }
+#define QCOM_PDC_SIZE 0x30000
 static int qcom_pdc_init(struct device_node *node, struct device_node *parent)
 {
 	struct irq_domain *parent_domain, *pdc_domain;
+	resource_size_t res_size;
+	struct resource res;
 	int ret;
-	pdc_base = of_iomap(node, 0);
+	/* compat with old sm8150 DT which had very small region for PDC */
+	if (of_address_to_resource(node, 0, &res))
+		return -EINVAL;
+	res_size = max_t(resource_size_t, resource_size(&res), QCOM_PDC_SIZE);
+	if (res_size > resource_size(&res))
+		pr_warn("%pOF: invalid reg size, please fix DT\n", node);
+	pdc_base = ioremap(res.start, res_size);
 	if (!pdc_base) {
 		pr_err("%pOF: unable to map PDC registers\n", node);
 		return -ENXIO;
 	}
+	pdc_version = pdc_reg_read(PDC_VERSION_REG, 0);
 	parent_domain = irq_find_host(parent);
 	if (!parent_domain) {
 		pr_err("%pOF: unable to find PDC's parent domain\n", node);

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/mcb/mcb-core.c+3−7

@@ -387,17 +387,13 @@ EXPORT_SYMBOL_NS_GPL(mcb_free_dev, MCB); · 386 unmodified lines
387		387
388	static int __mcb_bus_add_devices(struct device dev, void data)	388	static int __mcb_bus_add_devices(struct device dev, void data)
389	{	389	{
390	struct mcb_device *mdev = to_mcb_device(dev);
391	int retval;	390	int retval;
392		391
393	if (mdev->is_added)
394	return 0;
395
396	retval = device_attach(dev);	392	retval = device_attach(dev);
397	if (retval < 0)	393	if (retval < 0) {
398	dev_err(dev, "Error adding device (%d)\n", retval);	394	dev_err(dev, "Error adding device (%d)\n", retval);
399		395	return retval;
400	mdev->is_added = true;	396	}
401		397
402	return 0;	398	return 0;
403	}	399	}

drivers/mcb/mcb-parse.c+0−2

@@ -99,8 +99,6 @@ static int chameleon_parse_gdd(struct mcb_bus *bus, · 98 unmodified lines
99	mdev->mem.end = mdev->mem.start + size - 1;	99	mdev->mem.end = mdev->mem.start + size - 1;
100	mdev->mem.flags = IORESOURCE_MEM;	100	mdev->mem.flags = IORESOURCE_MEM;
101		101
102	mdev->is_added = false;
103
104	ret = mcb_device_register(bus, mdev);	102	ret = mcb_device_register(bus, mdev);
105	if (ret < 0)	103	if (ret < 0)
106	goto err;	104	goto err;

drivers/md/dm-crypt.c+2−1

@@ -753,7 +753,8 @@ static int crypt_iv_eboiv_gen(struct crypt_config cc, u8 iv, · 752 unmodified lines
753	int err;	753	int err;
754	u8 *buf;	754	u8 *buf;
755		755
756	reqsize = ALIGN(crypto_skcipher_reqsize(tfm), __alignof__(__le64));	756	reqsize = sizeof(*req) + crypto_skcipher_reqsize(tfm);
		757	reqsize = ALIGN(reqsize, __alignof__(__le64));
757		758
758	req = kmalloc(reqsize + cc->iv_size, GFP_NOIO);	759	req = kmalloc(reqsize + cc->iv_size, GFP_NOIO);
759	if (!req)	760	if (!req)

drivers/md/dm-zoned-target.c+7−8

@@ -748,17 +748,16 @@ err: · 747 unmodified lines
748	/*	748	/*
749	* Cleanup zoned device information.	749	* Cleanup zoned device information.
750	*/	750	*/
751	static void dmz_put_zoned_device(struct dm_target *ti)	751	static void dmz_put_zoned_devices(struct dm_target *ti)
752	{	752	{
753	struct dmz_target *dmz = ti->private;	753	struct dmz_target *dmz = ti->private;
754	int i;	754	int i;
755		755
756	for (i = 0; i < dmz->nr_ddevs; i++) {	756	for (i = 0; i < dmz->nr_ddevs; i++)
757	if (dmz->ddev[i]) {	757	if (dmz->ddev[i])
758	dm_put_device(ti, dmz->ddev[i]);	758	dm_put_device(ti, dmz->ddev[i]);
759	dmz->ddev[i] = NULL;	759
760	}	760	kfree(dmz->ddev);
761	}
762	}	761	}
763		762
764	static int dmz_fixup_devices(struct dm_target *ti)	763	static int dmz_fixup_devices(struct dm_target *ti)
@@ -948,7 +947,7 @@ err_bio: · 183 unmodified lines
948	err_meta:	947	err_meta:
949	dmz_dtr_metadata(dmz->metadata);	948	dmz_dtr_metadata(dmz->metadata);
950	err_dev:	949	err_dev:
951	dmz_put_zoned_device(ti);	950	dmz_put_zoned_devices(ti);
952	err:	951	err:
953	kfree(dmz->dev);	952	kfree(dmz->dev);
954	kfree(dmz);	953	kfree(dmz);
@@ -978,7 +977,7 @@ static void dmz_dtr(struct dm_target *ti) · 23 unmodified lines
978		977
979	bioset_exit(&dmz->bio_set);	978	bioset_exit(&dmz->bio_set);
980		979
981	dmz_put_zoned_device(ti);	980	dmz_put_zoned_devices(ti);
982		981
983	mutex_destroy(&dmz->chunk_lock);	982	mutex_destroy(&dmz->chunk_lock);
984		983

drivers/md/raid5.c+7−0

@@ -854,6 +854,13 @@ struct stripe_head raid5_get_active_stripe(struct r5conf conf, · 853 unmodified lines
854		854
855	set_bit(R5_INACTIVE_BLOCKED, &conf->cache_state);	855	set_bit(R5_INACTIVE_BLOCKED, &conf->cache_state);
856	r5l_wake_reclaim(conf->log, 0);	856	r5l_wake_reclaim(conf->log, 0);
		857
		858	/* release batch_last before wait to avoid risk of deadlock */
		859	if (ctx && ctx->batch_last) {
		860	raid5_release_stripe(ctx->batch_last);
		861	ctx->batch_last = NULL;
		862	}
		863
857	wait_event_lock_irq(conf->wait_for_stripe,	864	wait_event_lock_irq(conf->wait_for_stripe,
858	is_inactive_blocked(conf, hash),	865	is_inactive_blocked(conf, hash),
859	*(conf->hash_locks + hash));	866	*(conf->hash_locks + hash));

drivers/media/i2c/ov8858.c+2−8

 	}
 	ret = v4l2_fwnode_endpoint_parse(endpoint, &vep);
+	fwnode_handle_put(endpoint);
 	if (ret) {
 		dev_err(dev, "Failed to parse endpoint: %d\n", ret);
-		fwnode_handle_put(endpoint);
 		return ret;
 	}
 	default:
 		dev_err(dev, "Unsupported number of data lanes %u\n",
 			ov8858->num_lanes);
-		fwnode_handle_put(endpoint);
 		return -EINVAL;
 	}
-	ov8858->subdev.fwnode = endpoint;
 	return 0;
 }
 	ret = ov8858_init_ctrls(ov8858);
 	if (ret)
-		goto err_put_fwnode;
+		return ret;
 	sd = &ov8858->subdev;
 	sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;
 	media_entity_cleanup(&sd->entity);
 err_free_handler:
 	v4l2_ctrl_handler_free(&ov8858->ctrl_handler);
-err_put_fwnode:
-	fwnode_handle_put(ov8858->subdev.fwnode);
 	return ret;
 }
 	v4l2_async_unregister_subdev(sd);
 	media_entity_cleanup(&sd->entity);
 	v4l2_ctrl_handler_free(&ov8858->ctrl_handler);
-	fwnode_handle_put(ov8858->subdev.fwnode);
 	pm_runtime_disable(&client->dev);
 	if (!pm_runtime_status_suspended(&client->dev))

drivers/media/pci/intel/Kconfig+14−6

@@ -1,11 +1,19 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
		2
		3	source "drivers/media/pci/intel/ipu3/Kconfig"
		4	source "drivers/media/pci/intel/ivsc/Kconfig"
		5
2	config IPU_BRIDGE	6	config IPU_BRIDGE
3	tristate	7	tristate "Intel IPU Bridge"
4	depends on I2C && ACPI	8	depends on I2C && ACPI
5	help	9	help
6	This is a helper module for the IPU bridge, which can be	10	The IPU bridge is a helper library for Intel IPU drivers to
7	used by ipu3 and other drivers. In order to handle module	11	function on systems shipped with Windows.
8	dependencies, this is selected by each driver that needs it.
9		12
10	source "drivers/media/pci/intel/ipu3/Kconfig"	13	Currently used by the ipu3-cio2 and atomisp drivers.
11	source "drivers/media/pci/intel/ivsc/Kconfig"	14
		15	Supported systems include:
		16
		17	- Microsoft Surface models (except Surface Pro 3)
		18	- The Lenovo Miix line (for example the 510, 520, 710 and 720)
		19	- Dell 7285

drivers/media/pci/intel/ipu-bridge.c+3−1

 		for_each_acpi_dev_match(ivsc_adev, acpi_id->id, NULL, -1)
 			/* camera sensor depends on IVSC in DSDT if exist */
 			for_each_acpi_consumer_dev(ivsc_adev, consumer)
-				if (consumer->handle == handle)
+				if (consumer->handle == handle) {
+					acpi_dev_put(consumer);
 					return ivsc_adev;
+				}
 	}
 	return NULL;

drivers/media/pci/intel/ipu3/Kconfig+1−20

@@ -2,13 +2,13 @@ · 1 unmodified line
2	config VIDEO_IPU3_CIO2	2	config VIDEO_IPU3_CIO2
3	tristate "Intel ipu3-cio2 driver"	3	tristate "Intel ipu3-cio2 driver"
4	depends on VIDEO_DEV && PCI	4	depends on VIDEO_DEV && PCI
		5	depends on IPU_BRIDGE \|\| !IPU_BRIDGE
5	depends on ACPI \|\| COMPILE_TEST	6	depends on ACPI \|\| COMPILE_TEST
6	depends on X86	7	depends on X86
7	select MEDIA_CONTROLLER	8	select MEDIA_CONTROLLER
8	select VIDEO_V4L2_SUBDEV_API	9	select VIDEO_V4L2_SUBDEV_API
9	select V4L2_FWNODE	10	select V4L2_FWNODE
10	select VIDEOBUF2_DMA_SG	11	select VIDEOBUF2_DMA_SG
11	select IPU_BRIDGE if CIO2_BRIDGE
12		12
13	help	13	help
14	This is the Intel IPU3 CIO2 CSI-2 receiver unit, found in Intel	14	This is the Intel IPU3 CIO2 CSI-2 receiver unit, found in Intel
@@ -18,22 +18,3 @@ config VIDEO_IPU3_CIO2 · 3 unmodified lines
18	Say Y or M here if you have a Skylake/Kaby Lake SoC with MIPI CSI-2	18	Say Y or M here if you have a Skylake/Kaby Lake SoC with MIPI CSI-2
19	connected camera.	19	connected camera.
20	The module will be called ipu3-cio2.	20	The module will be called ipu3-cio2.
21
22	config CIO2_BRIDGE
23	bool "IPU3 CIO2 Sensors Bridge"
24	depends on VIDEO_IPU3_CIO2 && ACPI
25	depends on I2C
26	help
27	This extension provides an API for the ipu3-cio2 driver to create
28	connections to cameras that are hidden in the SSDB buffer in ACPI.
29	It can be used to enable support for cameras in detachable / hybrid
30	devices that ship with Windows.
31
32	Say Y here if your device is a detachable / hybrid laptop that comes
33	with Windows installed by the OEM, for example:
34
35	- Microsoft Surface models (except Surface Pro 3)
36	- The Lenovo Miix line (for example the 510, 520, 710 and 720)
37	- Dell 7285
38
39	If in doubt, say N here.

drivers/media/pci/intel/ivsc/Kconfig+1−1

@@ -6,7 +6,7 @@ config INTEL_VSC · 5 unmodified lines
6	depends on INTEL_MEI && ACPI && VIDEO_DEV	6	depends on INTEL_MEI && ACPI && VIDEO_DEV
7	select MEDIA_CONTROLLER	7	select MEDIA_CONTROLLER
8	select VIDEO_V4L2_SUBDEV_API	8	select VIDEO_V4L2_SUBDEV_API
9	select V4L2_ASYNC	9	select V4L2_FWNODE
10	help	10	help
11	This adds support for Intel Visual Sensing Controller (IVSC).	11	This adds support for Intel Visual Sensing Controller (IVSC).
12		12

drivers/media/platform/intel/pxa_camera.c+1−1

@@ -2398,7 +2398,7 @@ static int pxa_camera_probe(struct platform_device *pdev) · 2397 unmodified lines
2398	PXA_CAM_DRV_NAME, pcdev);	2398	PXA_CAM_DRV_NAME, pcdev);
2399	if (err) {	2399	if (err) {
2400	dev_err(&pdev->dev, "Camera interrupt register failed\n");	2400	dev_err(&pdev->dev, "Camera interrupt register failed\n");
2401	goto exit_v4l2_device_unregister;	2401	goto exit_deactivate;
2402	}	2402	}
2403		2403
2404	pcdev->notifier.ops = &pxa_camera_sensor_ops;	2404	pcdev->notifier.ops = &pxa_camera_sensor_ops;

drivers/media/platform/mediatek/vcodec/encoder/venc_vpu_if.c+2−1

@@ -138,7 +138,8 @@ int vpu_enc_init(struct venc_vpu_inst *vpu) · 137 unmodified lines
138	vpu->ctx->vpu_inst = vpu;	138	vpu->ctx->vpu_inst = vpu;
139		139
140	status = mtk_vcodec_fw_ipi_register(vpu->ctx->dev->fw_handler, vpu->id,	140	status = mtk_vcodec_fw_ipi_register(vpu->ctx->dev->fw_handler, vpu->id,
141	vpu_enc_ipi_handler, "venc", NULL);	141	vpu_enc_ipi_handler, "venc",
		142	vpu->ctx->dev);
142		143
143	if (status) {	144	if (status) {
144	mtk_venc_err(vpu->ctx, "vpu_ipi_register fail %d", status);	145	mtk_venc_err(vpu->ctx, "vpu_ipi_register fail %d", status);

drivers/media/platform/xilinx/xilinx-vipp.c+12−5

@@ -55,11 +55,18 @@ xvip_graph_find_entity(struct xvip_composite_device *xdev, · 54 unmodified lines
55	{	55	{
56	struct xvip_graph_entity *entity;	56	struct xvip_graph_entity *entity;
57	struct v4l2_async_connection *asd;	57	struct v4l2_async_connection *asd;
58		58	struct list_head *lists[] = {
59	list_for_each_entry(asd, &xdev->notifier.done_list, asc_entry) {	59	&xdev->notifier.done_list,
60	entity = to_xvip_entity(asd);	60	&xdev->notifier.waiting_list
61	if (entity->asd.match.fwnode == fwnode)	61	};
62	return entity;	62	unsigned int i;
		63
		64	for (i = 0; i < ARRAY_SIZE(lists); i++) {
		65	list_for_each_entry(asd, lists[i], asc_entry) {
		66	entity = to_xvip_entity(asd);
		67	if (entity->asd.match.fwnode == fwnode)
		68	return entity;
		69	}
63	}	70	}
64		71
65	return NULL;	72	return NULL;

drivers/media/v4l2-core/v4l2-subdev.c+7−0

@@ -502,6 +502,13 @@ static long subdev_do_ioctl(struct file file, unsigned int cmd, void arg, · 501 unmodified lines
502	V4L2_SUBDEV_CLIENT_CAP_STREAMS;	502	V4L2_SUBDEV_CLIENT_CAP_STREAMS;
503	int rval;	503	int rval;
504		504
		505	/*
		506	* If the streams API is not enabled, remove V4L2_SUBDEV_CAP_STREAMS.
		507	* Remove this when the API is no longer experimental.
		508	*/
		509	if (!v4l2_subdev_enable_streams_api)
		510	streams_subdev = false;
		511
505	switch (cmd) {	512	switch (cmd) {
506	case VIDIOC_SUBDEV_QUERYCAP: {	513	case VIDIOC_SUBDEV_QUERYCAP: {
507	struct v4l2_subdev_capability *cap = arg;	514	struct v4l2_subdev_capability *cap = arg;

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/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/can/Kconfig+1−1

@@ -190,7 +190,7 @@ config CAN_SLCAN · 189 unmodified lines
190		190
191	config CAN_SUN4I	191	config CAN_SUN4I
192	tristate "Allwinner A10 CAN controller"	192	tristate "Allwinner A10 CAN controller"
193	depends on MACH_SUN4I \|\| MACH_SUN7I \|\| RISCV \|\| COMPILE_TEST	193	depends on MACH_SUN4I \|\| MACH_SUN7I \|\| (RISCV && ARCH_SUNXI) \|\| COMPILE_TEST
194	help	194	help
195	Say Y here if you want to use CAN controller found on Allwinner	195	Say Y here if you want to use CAN controller found on Allwinner
196	A10/A20/D1 SoCs.	196	A10/A20/D1 SoCs.

drivers/net/can/flexcan/flexcan-core.c+13−33

 static struct flexcan_devtype_data fsl_imx93_devtype_data = {
 	.quirks = FLEXCAN_QUIRK_DISABLE_RXFG | FLEXCAN_QUIRK_ENABLE_EACEN_RRS |
 		FLEXCAN_QUIRK_DISABLE_MECR | FLEXCAN_QUIRK_USE_RX_MAILBOX |
-		FLEXCAN_QUIRK_BROKEN_PERR_STATE | FLEXCAN_QUIRK_AUTO_STOP_MODE |
+		FLEXCAN_QUIRK_BROKEN_PERR_STATE | FLEXCAN_QUIRK_SETUP_STOP_MODE_GPR |
 		FLEXCAN_QUIRK_SUPPORT_FD | FLEXCAN_QUIRK_SUPPORT_ECC |
 		FLEXCAN_QUIRK_SUPPORT_RX_MAILBOX |
 		FLEXCAN_QUIRK_SUPPORT_RX_MAILBOX_RTR,
 	} else if (priv->devtype_data.quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_GPR) {
 		regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr,
 				   1 << priv->stm.req_bit, 1 << priv->stm.req_bit);
-	} else if (priv->devtype_data.quirks & FLEXCAN_QUIRK_AUTO_STOP_MODE) {
-		/* For the auto stop mode, software do nothing, hardware will cover
-		 * all the operation automatically after system go into low power mode.
-		 */
-		return 0;
 	}
 	return flexcan_low_power_enter_ack(priv);
 	reg_mcr &= ~FLEXCAN_MCR_SLF_WAK;
 	priv->write(reg_mcr, &regs->mcr);
-	/* For the auto stop mode, hardware will exist stop mode
-	 * automatically after system go out of low power mode.
-	 */
-	if (priv->devtype_data.quirks & FLEXCAN_QUIRK_AUTO_STOP_MODE)
-		return 0;
 	return flexcan_low_power_exit_ack(priv);
 }
 		ret = flexcan_setup_stop_mode_scfw(pdev);
 	else if (priv->devtype_data.quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_GPR)
 		ret = flexcan_setup_stop_mode_gpr(pdev);
-	else if (priv->devtype_data.quirks & FLEXCAN_QUIRK_AUTO_STOP_MODE)
-		ret = 0;
 	else
 		/* return 0 directly if doesn't support stop mode feature */
 		return 0;
-	if (ret)
+	/* If ret is -EINVAL, this means SoC claim to support stop mode, but
+	 * dts file lack the stop mode property definition. For this case,
+	 * directly return 0, this will skip the wakeup capable setting and
+	 * will not block the driver probe.
+	 */
+	if (ret == -EINVAL)
+		return 0;
+	else if (ret)
 		return ret;
 	device_set_wakeup_capable(&pdev->dev, true);
 	if (netif_running(dev)) {
 		int err;
-		if (device_may_wakeup(device)) {
+		if (device_may_wakeup(device))
 			flexcan_enable_wakeup_irq(priv, true);
-			/* For auto stop mode, need to keep the clock on before
-			 * system go into low power mode. After system go into
-			 * low power mode, hardware will config the flexcan into
-			 * stop mode, and gate off the clock automatically.
-			 */
-			if (priv->devtype_data.quirks & FLEXCAN_QUIRK_AUTO_STOP_MODE)
-				return 0;
-		}
 		err = pm_runtime_force_suspend(device);
 		if (err)
 	if (netif_running(dev)) {
 		int err;
-		/* For the wakeup in auto stop mode, no need to gate on the
+		err = pm_runtime_force_resume(device);
-		 * clock here, hardware will do this automatically.
+		if (err)
-		 */
+			return err;
-		if (!(device_may_wakeup(device) &&
-		      priv->devtype_data.quirks & FLEXCAN_QUIRK_AUTO_STOP_MODE)) {
-			err = pm_runtime_force_resume(device);
-			if (err)
-				return err;
-		}
 		if (device_may_wakeup(device))
 			flexcan_enable_wakeup_irq(priv, false);

drivers/net/can/flexcan/flexcan.h+0−2

@@ -68,8 +68,6 @@ · 67 unmodified lines
68	#define FLEXCAN_QUIRK_SUPPORT_RX_MAILBOX_RTR BIT(15)	68	#define FLEXCAN_QUIRK_SUPPORT_RX_MAILBOX_RTR BIT(15)
69	/* Device supports RX via FIFO */	69	/* Device supports RX via FIFO */
70	#define FLEXCAN_QUIRK_SUPPORT_RX_FIFO BIT(16)	70	#define FLEXCAN_QUIRK_SUPPORT_RX_FIFO BIT(16)
71	/* auto enter stop mode to support wakeup */
72	#define FLEXCAN_QUIRK_AUTO_STOP_MODE BIT(17)
73		71
74	struct flexcan_devtype_data {	72	struct flexcan_devtype_data {
75	u32 quirks; /* quirks needed for different IP cores */	73	u32 quirks; /* quirks needed for different IP cores */

drivers/net/can/m_can/tcan4x5x-core.c+1−1

@@ -125,7 +125,7 @@ static const struct tcan4x5x_version_info tcan4x5x_versions[] = { · 124 unmodified lines
125	},	125	},
126	[TCAN4553] = {	126	[TCAN4553] = {
127	.name = "4553",	127	.name = "4553",
128	.id2_register = 0x32353534,	128	.id2_register = 0x33353534,
129	},	129	},
130	/* generic version with no id2_register at the end */	130	/* generic version with no id2_register at the end */
131	[TCAN4X5X] = {	131	[TCAN4X5X] = {

drivers/net/can/sja1000/sja1000.c+7−1

@@ -392,7 +392,13 @@ static irqreturn_t sja1000_reset_interrupt(int irq, void *dev_id) · 391 unmodified lines
392	struct net_device dev = (struct net_device )dev_id;	392	struct net_device dev = (struct net_device )dev_id;
393		393
394	netdev_dbg(dev, "performing a soft reset upon overrun\n");	394	netdev_dbg(dev, "performing a soft reset upon overrun\n");
395	sja1000_start(dev);	395
		396	netif_tx_lock(dev);
		397
		398	can_free_echo_skb(dev, 0, NULL);
		399	sja1000_set_mode(dev, CAN_MODE_START);
		400
		401	netif_tx_unlock(dev);
396		402
397	return IRQ_HANDLED;	403	return IRQ_HANDLED;
398	}	404	}

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/dsa/qca/qca8k-8xxx.c+13−2

 		void *val_buf, size_t val_len)
 {
 	int i, count = val_len / sizeof(u32), ret;
-	u32 reg = *(u32 *)reg_buf & U16_MAX;
 	struct qca8k_priv *priv = ctx;
+	u32 reg = *(u16 *)reg_buf;
 	if (priv->mgmt_master &&
 	    !qca8k_read_eth(priv, reg, val_buf, val_len))
 			const void *val_buf, size_t val_len)
 {
 	int i, count = val_len / sizeof(u32), ret;
-	u32 reg = *(u32 *)reg_buf & U16_MAX;
 	struct qca8k_priv *priv = ctx;
+	u32 reg = *(u16 *)reg_buf;
 	u32 *val = (u32 *)val_buf;
 	if (priv->mgmt_master &&
 		goto err_read_skb;
 	}
+	/* It seems that accessing the switch's internal PHYs via management
+	 * packets still uses the MDIO bus within the switch internally, and
+	 * these accesses can conflict with external MDIO accesses to other
+	 * devices on the MDIO bus.
+	 * We therefore need to lock the MDIO bus onto which the switch is
+	 * connected.
+	 */
+	mutex_lock(&priv->bus->mdio_lock);
 	/* Actually start the request:
 	 * 1. Send mdio master packet
 	 * 2. Busy Wait for mdio master command
 	mgmt_master = priv->mgmt_master;
 	if (!mgmt_master) {
 		mutex_unlock(&mgmt_eth_data->mutex);
+		mutex_unlock(&priv->bus->mdio_lock);
 		ret = -EINVAL;
 		goto err_mgmt_master;
 	}
 				    QCA8K_ETHERNET_TIMEOUT);
 	mutex_unlock(&mgmt_eth_data->mutex);
+	mutex_unlock(&priv->bus->mdio_lock);
 	return ret;

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_lag.c+32−0

@@ -2093,3 +2093,35 @@ lag_rebuild_out: · 2092 unmodified lines
2093	}	2093	}
2094	mutex_unlock(&pf->lag_mutex);	2094	mutex_unlock(&pf->lag_mutex);
2095	}	2095	}
		2096
		2097	/**
		2098	* ice_lag_is_switchdev_running
		2099	* @pf: pointer to PF structure
		2100	*
		2101	* Check if switchdev is running on any of the interfaces connected to lag.
		2102	*/
		2103	bool ice_lag_is_switchdev_running(struct ice_pf *pf)
		2104	{
		2105	struct ice_lag *lag = pf->lag;
		2106	struct net_device *tmp_nd;
		2107
		2108	if (!ice_is_feature_supported(pf, ICE_F_SRIOV_LAG) \|\| !lag)
		2109	return false;
		2110
		2111	rcu_read_lock();
		2112	for_each_netdev_in_bond_rcu(lag->upper_netdev, tmp_nd) {
		2113	struct ice_netdev_priv *priv = netdev_priv(tmp_nd);
		2114
		2115	if (!netif_is_ice(tmp_nd) \|\| !priv \|\| !priv->vsi \|\|
		2116	!priv->vsi->back)
		2117	continue;
		2118
		2119	if (ice_is_switchdev_running(priv->vsi->back)) {
		2120	rcu_read_unlock();
		2121	return true;
		2122	}
		2123	}
		2124	rcu_read_unlock();
		2125
		2126	return false;
		2127	}

drivers/net/ethernet/intel/ice/ice_lag.h+1−0

@@ -62,4 +62,5 @@ void ice_lag_move_new_vf_nodes(struct ice_vf *vf); · 61 unmodified lines
62	int ice_init_lag(struct ice_pf *pf);	62	int ice_init_lag(struct ice_pf *pf);
63	void ice_deinit_lag(struct ice_pf *pf);	63	void ice_deinit_lag(struct ice_pf *pf);
64	void ice_lag_rebuild(struct ice_pf *pf);	64	void ice_lag_rebuild(struct ice_pf *pf);
		65	bool ice_lag_is_switchdev_running(struct ice_pf *pf);
65	#endif /* _ICE_LAG_H_ */	66	#endif /* _ICE_LAG_H_ */

drivers/net/ethernet/intel/ice/ice_lib.c+6−0

 	dev = ice_pf_to_dev(vsi->back);
+	if (ice_lag_is_switchdev_running(vsi->back)) {
+		dev_dbg(dev, "VSI %d passed is a part of LAG containing interfaces in switchdev mode, nothing to do\n",
+			vsi->vsi_num);
+		return 0;
+	}
 	/* the VSI passed in is already the default VSI */
 	if (ice_is_vsi_dflt_vsi(vsi)) {
 		dev_dbg(dev, "VSI %d passed in is already the default forwarding VSI, nothing to do\n",

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

@@ -2617,12 +2617,14 @@ static int ice_vc_query_rxdid(struct ice_vf *vf) · 2616 unmodified lines
2617	goto err;	2617	goto err;
2618	}	2618	}
2619		2619
2620	/* Read flexiflag registers to determine whether the	2620	/* RXDIDs supported by DDP package can be read from the register
2621	* corresponding RXDID is configured and supported or not.	2621	* to get the supported RXDID bitmap. But the legacy 32byte RXDID
2622	* Since Legacy 16byte descriptor format is not supported,	2622	* is not listed in DDP package, add it in the bitmap manually.
2623	* start from Legacy 32byte descriptor.	2623	* Legacy 16byte descriptor is not supported.
2624	*/	2624	*/
2625	for (i = ICE_RXDID_LEGACY_1; i < ICE_FLEX_DESC_RXDID_MAX_NUM; i++) {	2625	rxdid->supported_rxdids \|= BIT(ICE_RXDID_LEGACY_1);
		2626
		2627	for (i = ICE_RXDID_FLEX_NIC; i < ICE_FLEX_DESC_RXDID_MAX_NUM; i++) {
2626	regval = rd32(hw, GLFLXP_RXDID_FLAGS(i, 0));	2628	regval = rd32(hw, GLFLXP_RXDID_FLAGS(i, 0));
2627	if ((regval >> GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_S)	2629	if ((regval >> GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_S)
2628	& GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_M)	2630	& GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_M)

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c+3−2

 	struct vf_macvlans *mv_list;
 	int num_vf_macvlans, i;
+	/* Initialize list of VF macvlans */
+	INIT_LIST_HEAD(&adapter->vf_mvs.l);
 	num_vf_macvlans = hw->mac.num_rar_entries -
 			  (IXGBE_MAX_PF_MACVLANS + 1 + num_vfs);
 	if (!num_vf_macvlans)
 	mv_list = kcalloc(num_vf_macvlans, sizeof(struct vf_macvlans),
 			  GFP_KERNEL);
 	if (mv_list) {
-		/* Initialize list of VF macvlans */
-		INIT_LIST_HEAD(&adapter->vf_mvs.l);
 		for (i = 0; i < num_vf_macvlans; i++) {
 			mv_list[i].vf = -1;
 			mv_list[i].free = true;

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c+9−4

 	if (netif_running(secy->netdev)) {
 		/* Keys cannot be changed after creation */
-		err = cn10k_write_tx_sa_pn(pfvf, txsc, sa_num,
+		if (ctx->sa.update_pn) {
-					   sw_tx_sa->next_pn);
+			err = cn10k_write_tx_sa_pn(pfvf, txsc, sa_num,
-		if (err)
+						   sw_tx_sa->next_pn);
-			return err;
+			if (err)
+				return err;
+		}
 		err = cn10k_mcs_link_tx_sa2sc(pfvf, secy, txsc,
 					      sa_num, sw_tx_sa->active);
 		if (err)
 			return err;
+		if (!ctx->sa.update_pn)
+			return 0;
 		err = cn10k_mcs_write_rx_sa_pn(pfvf, rxsc, sa_num,
 					       rx_sa->next_pn);
 		if (err)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.c+1−0

@@ -1403,6 +1403,7 @@ int otx2_pool_init(struct otx2_nic *pfvf, u16 pool_id, · 1402 unmodified lines
1403	return 0;	1403	return 0;
1404	}	1404	}
1405		1405
		1406	pp_params.order = get_order(buf_size);
1406	pp_params.flags = PP_FLAG_PAGE_FRAG \| PP_FLAG_DMA_MAP;	1407	pp_params.flags = PP_FLAG_PAGE_FRAG \| PP_FLAG_DMA_MAP;
1407	pp_params.pool_size = min(OTX2_PAGE_POOL_SZ, numptrs);	1408	pp_params.pool_size = min(OTX2_PAGE_POOL_SZ, numptrs);
1408	pp_params.nid = NUMA_NO_NODE;	1409	pp_params.nid = NUMA_NO_NODE;

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/mellanox/mlx5/core/en_accel/macsec.c+2−2

@@ -580,7 +580,7 @@ static int mlx5e_macsec_upd_txsa(struct macsec_context *ctx) · 579 unmodified lines
580	goto out;	580	goto out;
581	}	581	}
582		582
583	if (tx_sa->next_pn != ctx_tx_sa->next_pn_halves.lower) {	583	if (ctx->sa.update_pn) {
584	netdev_err(netdev, "MACsec offload: update TX sa %d PN isn't supported\n",	584	netdev_err(netdev, "MACsec offload: update TX sa %d PN isn't supported\n",
585	assoc_num);	585	assoc_num);
586	err = -EINVAL;	586	err = -EINVAL;
@@ -973,7 +973,7 @@ static int mlx5e_macsec_upd_rxsa(struct macsec_context *ctx) · 386 unmodified lines
973	goto out;	973	goto out;
974	}	974	}
975		975
976	if (rx_sa->next_pn != ctx_rx_sa->next_pn_halves.lower) {	976	if (ctx->sa.update_pn) {
977	netdev_err(ctx->netdev,	977	netdev_err(ctx->netdev,
978	"MACsec offload update RX sa %d PN isn't supported\n",	978	"MACsec offload update RX sa %d PN isn't supported\n",
979	assoc_num);	979	assoc_num);

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

 	struct mlx5e_channels *chs = &priv->channels;
 	struct mlx5e_params new_params;
 	int err;
+	bool rx_ts_over_crc = !enable;
 	mutex_lock(&priv->state_lock);
 	new_params = chs->params;
 	new_params.scatter_fcs_en = enable;
 	err = mlx5e_safe_switch_params(priv, &new_params, mlx5e_set_rx_port_ts_wrap,
-				       &new_params.scatter_fcs_en, true);
+				       &rx_ts_over_crc, true);
 	mutex_unlock(&priv->state_lock);
 	return err;
 }

drivers/net/ethernet/mellanox/mlxsw/spectrum_nve_vxlan.c+2−2

@@ -310,8 +310,8 @@ const struct mlxsw_sp_nve_ops mlxsw_sp1_nve_vxlan_ops = { · 309 unmodified lines
310	.fdb_clear_offload = mlxsw_sp_nve_vxlan_clear_offload,	310	.fdb_clear_offload = mlxsw_sp_nve_vxlan_clear_offload,
311	};	311	};
312		312
313	static bool mlxsw_sp2_nve_vxlan_learning_set(struct mlxsw_sp *mlxsw_sp,	313	static int mlxsw_sp2_nve_vxlan_learning_set(struct mlxsw_sp *mlxsw_sp,
314	bool learning_en)	314	bool learning_en)
315	{	315	{
316	char tnpc_pl[MLXSW_REG_TNPC_LEN];	316	char tnpc_pl[MLXSW_REG_TNPC_LEN];
317		317

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/netronome/nfp/flower/cmsg.c+6−4

 	unsigned int msg_len = nfp_flower_cmsg_get_data_len(skb);
 	struct nfp_flower_cmsg_merge_hint *msg;
 	struct nfp_fl_payload *sub_flows[2];
+	struct nfp_flower_priv *priv;
 	int err, i, flow_cnt;
 	msg = nfp_flower_cmsg_get_data(skb);
 		return;
 	}
-	rtnl_lock();
+	priv = app->priv;
+	mutex_lock(&priv->nfp_fl_lock);
 	for (i = 0; i < flow_cnt; i++) {
 		u32 ctx = be32_to_cpu(msg->flow[i].host_ctx);
 		sub_flows[i] = nfp_flower_get_fl_payload_from_ctx(app, ctx);
 		if (!sub_flows[i]) {
 			nfp_flower_cmsg_warn(app, "Invalid flow in merge hint\n");
-			goto err_rtnl_unlock;
+			goto err_mutex_unlock;
 		}
 	}
 	if (err == -ENOMEM)
 		nfp_flower_cmsg_warn(app, "Flow merge memory fail.\n");
-err_rtnl_unlock:
+err_mutex_unlock:
-	rtnl_unlock();
+	mutex_unlock(&priv->nfp_fl_lock);
 }
 static void

drivers/net/ethernet/netronome/nfp/flower/conntrack.c+13−6

 	struct nfp_fl_ct_flow_entry *ct_entry;
 	struct netlink_ext_ack *extack = NULL;
-	ASSERT_RTNL();
 	extack = flow->common.extack;
 	switch (flow->command) {
 	case FLOW_CLS_REPLACE:
 	switch (type) {
 	case TC_SETUP_CLSFLOWER:
-		rtnl_lock();
+		while (!mutex_trylock(&zt->priv->nfp_fl_lock)) {
+			if (!zt->nft) /* avoid deadlock */
+				return err;
+			msleep(20);
+		}
 		err = nfp_fl_ct_offload_nft_flow(zt, flow);
-		rtnl_unlock();
+		mutex_unlock(&zt->priv->nfp_fl_lock);
 		break;
 	default:
 		return -EOPNOTSUPP;
 	struct nfp_fl_ct_flow_entry *ct_entry;
 	struct nfp_fl_ct_zone_entry *zt;
 	struct rhashtable *m_table;
+	struct nf_flowtable *nft;
 	if (!ct_map_ent)
 		return -ENOENT;
 		if (ct_map_ent->cookie > 0)
 			kfree(ct_map_ent);
-		if (!zt->pre_ct_count) {
+		if (!zt->pre_ct_count && zt->nft) {
-			zt->nft = NULL;
+			nft = zt->nft;
+			zt->nft = NULL; /* avoid deadlock */
+			nf_flow_table_offload_del_cb(nft,
+						     nfp_fl_ct_handle_nft_flow,
+						     zt);
 			nfp_fl_ct_clean_nft_entries(zt);
 		}
 		break;

drivers/net/ethernet/netronome/nfp/flower/main.h+2−0

  * @predt_list:		List to keep track of decap pretun flows
  * @neigh_table:	Table to keep track of neighbor entries
  * @predt_lock:		Lock to serialise predt/neigh table updates
+ * @nfp_fl_lock:	Lock to protect the flow offload operation
  */
 struct nfp_flower_priv {
 	struct nfp_app *app;
 	struct list_head predt_list;
 	struct rhashtable neigh_table;
 	spinlock_t predt_lock; /* Lock to serialise predt/neigh table updates */
+	struct mutex nfp_fl_lock; /* Protect the flow operation */
 };
 /**

drivers/net/ethernet/netronome/nfp/flower/metadata.c+2−0

@@ -528,6 +528,8 @@ int nfp_flower_metadata_init(struct nfp_app *app, u64 host_ctx_count, · 527 unmodified lines
528	if (err)	528	if (err)
529	goto err_free_stats_ctx_table;	529	goto err_free_stats_ctx_table;
530		530
		531	mutex_init(&priv->nfp_fl_lock);
		532
531	err = rhashtable_init(&priv->ct_zone_table, &nfp_zone_table_params);	533	err = rhashtable_init(&priv->ct_zone_table, &nfp_zone_table_params);
532	if (err)	534	if (err)
533	goto err_free_merge_table;	535	goto err_free_merge_table;

drivers/net/ethernet/netronome/nfp/flower/offload.c+18−6

 	u64 parent_ctx = 0;
 	int err;
-	ASSERT_RTNL();
 	if (sub_flow1 == sub_flow2 ||
 	    nfp_flower_is_merge_flow(sub_flow1) ||
 	    nfp_flower_is_merge_flow(sub_flow2))
 nfp_flower_repr_offload(struct nfp_app *app, struct net_device *netdev,
 			struct flow_cls_offload *flower)
 {
+	struct nfp_flower_priv *priv = app->priv;
+	int ret;
 	if (!eth_proto_is_802_3(flower->common.protocol))
 		return -EOPNOTSUPP;
+	mutex_lock(&priv->nfp_fl_lock);
 	switch (flower->command) {
 	case FLOW_CLS_REPLACE:
-		return nfp_flower_add_offload(app, netdev, flower);
+		ret = nfp_flower_add_offload(app, netdev, flower);
+		break;
 	case FLOW_CLS_DESTROY:
-		return nfp_flower_del_offload(app, netdev, flower);
+		ret = nfp_flower_del_offload(app, netdev, flower);
+		break;
 	case FLOW_CLS_STATS:
-		return nfp_flower_get_stats(app, netdev, flower);
+		ret = nfp_flower_get_stats(app, netdev, flower);
+		break;
 	default:
-		return -EOPNOTSUPP;
+		ret = -EOPNOTSUPP;
+		break;
 	}
+	mutex_unlock(&priv->nfp_fl_lock);
+	return ret;
 }
 static int nfp_flower_setup_tc_block_cb(enum tc_setup_type type,
 	repr_priv = repr->app_priv;
 	repr_priv->block_shared = f->block_shared;
 	f->driver_block_list = &nfp_block_cb_list;
+	f->unlocked_driver_cb = true;
 	switch (f->command) {
 	case FLOW_BLOCK_BIND:
 	     nfp_flower_internal_port_can_offload(app, netdev)))
 		return -EOPNOTSUPP;
+	f->unlocked_driver_cb = true;
 	switch (f->command) {
 	case FLOW_BLOCK_BIND:
 		cb_priv = nfp_flower_indr_block_cb_priv_lookup(app, netdev);

drivers/net/ethernet/netronome/nfp/flower/qos_conf.c+13−7

 {
 	struct netlink_ext_ack *extack = flow->common.extack;
 	struct nfp_flower_priv *fl_priv = app->priv;
+	int ret;
 	if (!(fl_priv->flower_ext_feats & NFP_FL_FEATS_VF_RLIM)) {
 		NL_SET_ERR_MSG_MOD(extack, "unsupported offload: loaded firmware does not support qos rate limit offload");
 		return -EOPNOTSUPP;
 	}
+	mutex_lock(&fl_priv->nfp_fl_lock);
 	switch (flow->command) {
 	case TC_CLSMATCHALL_REPLACE:
-		return nfp_flower_install_rate_limiter(app, netdev, flow,
+		ret = nfp_flower_install_rate_limiter(app, netdev, flow, extack);
-						       extack);
+		break;
 	case TC_CLSMATCHALL_DESTROY:
-		return nfp_flower_remove_rate_limiter(app, netdev, flow,
+		ret = nfp_flower_remove_rate_limiter(app, netdev, flow, extack);
-						      extack);
+		break;
 	case TC_CLSMATCHALL_STATS:
-		return nfp_flower_stats_rate_limiter(app, netdev, flow,
+		ret = nfp_flower_stats_rate_limiter(app, netdev, flow, extack);
-						     extack);
+		break;
 	default:
-		return -EOPNOTSUPP;
+		ret = -EOPNOTSUPP;
+		break;
 	}
+	mutex_unlock(&fl_priv->nfp_fl_lock);
+	return ret;
 }
 /* Offload tc action, currently only for tc police */

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/ravb_main.c+4−2

 			of_phy_deregister_fixed_link(np);
 	}
+	cancel_work_sync(&priv->work);
 	if (info->multi_irqs) {
 		free_irq(priv->tx_irqs[RAVB_NC], ndev);
 		free_irq(priv->rx_irqs[RAVB_NC], ndev);
 	clk_disable_unprepare(priv->gptp_clk);
 	clk_disable_unprepare(priv->refclk);
-	dma_free_coherent(ndev->dev.parent, priv->desc_bat_size, priv->desc_bat,
-			  priv->desc_bat_dma);
 	/* Set reset mode */
 	ravb_write(ndev, CCC_OPC_RESET, CCC);
 	unregister_netdev(ndev);
 		netif_napi_del(&priv->napi[RAVB_NC]);
 	netif_napi_del(&priv->napi[RAVB_BE]);
 	ravb_mdio_release(priv);
+	dma_free_coherent(ndev->dev.parent, priv->desc_bat_size, priv->desc_bat,
+			  priv->desc_bat_dma);
 	pm_runtime_put_sync(&pdev->dev);
 	pm_runtime_disable(&pdev->dev);
 	reset_control_assert(priv->rstc);

drivers/net/ethernet/renesas/rswitch.c+19−6

  * 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);
 }
 		phy_print_status(phydev);
 		if (phydev->link)
 			phy_power_on(rdev->serdes);
-		else
+		else if (rdev->serdes->power_count)
 			phy_power_off(rdev->serdes);
 		rdev->etha->link = phydev->link;
 	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;
 	rswitch_gwca_hw_deinit(priv);
 	rcar_gen4_ptp_unregister(priv->ptp_priv);
-	for (i = 0; i < RSWITCH_NUM_PORTS; i++) {
+	rswitch_for_each_enabled_port(priv, i) {
 		struct rswitch_device *rdev = priv->rdev[i];
-		phy_exit(priv->rdev[i]->serdes);
-		rswitch_ether_port_deinit_one(rdev);
 		unregister_netdev(rdev->ndev);
-		rswitch_device_free(priv, i);
+		rswitch_ether_port_deinit_one(rdev);
+		phy_exit(priv->rdev[i]->serdes);
 	}
+	for (i = 0; i < RSWITCH_NUM_PORTS; i++)
+		rswitch_device_free(priv, i);
 	rswitch_gwca_ts_queue_free(priv);
 	rswitch_gwca_linkfix_free(priv);

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

@@ -6002,33 +6002,6 @@ static irqreturn_t stmmac_msi_intr_rx(int irq, void *data) · 6001 unmodified lines
6002	return IRQ_HANDLED;	6002	return IRQ_HANDLED;
6003	}	6003	}
6004		6004
6005	#ifdef CONFIG_NET_POLL_CONTROLLER
6006	/* Polling receive - used by NETCONSOLE and other diagnostic tools
6007	* to allow network I/O with interrupts disabled.
6008	*/
6009	static void stmmac_poll_controller(struct net_device *dev)
6010	{
6011	struct stmmac_priv *priv = netdev_priv(dev);
6012	int i;
6013
6014	/* If adapter is down, do nothing */
6015	if (test_bit(STMMAC_DOWN, &priv->state))
6016	return;
6017
6018	if (priv->plat->flags & STMMAC_FLAG_MULTI_MSI_EN) {
6019	for (i = 0; i < priv->plat->rx_queues_to_use; i++)
6020	stmmac_msi_intr_rx(0, &priv->dma_conf.rx_queue[i]);
6021
6022	for (i = 0; i < priv->plat->tx_queues_to_use; i++)
6023	stmmac_msi_intr_tx(0, &priv->dma_conf.tx_queue[i]);
6024	} else {
6025	disable_irq(dev->irq);
6026	stmmac_interrupt(dev->irq, dev);
6027	enable_irq(dev->irq);
6028	}
6029	}
6030	#endif
6031
6032	/**	6005	/**
6033	* stmmac_ioctl - Entry point for the Ioctl	6006	* stmmac_ioctl - Entry point for the Ioctl
6034	* @dev: Device pointer.	6007	* @dev: Device pointer.
@@ -6989,9 +6962,6 @@ static const struct net_device_ops stmmac_netdev_ops = { · 954 unmodified lines
6989	.ndo_get_stats64 = stmmac_get_stats64,	6962	.ndo_get_stats64 = stmmac_get_stats64,
6990	.ndo_setup_tc = stmmac_setup_tc,	6963	.ndo_setup_tc = stmmac_setup_tc,
6991	.ndo_select_queue = stmmac_select_queue,	6964	.ndo_select_queue = stmmac_select_queue,
6992	#ifdef CONFIG_NET_POLL_CONTROLLER
6993	.ndo_poll_controller = stmmac_poll_controller,
6994	#endif
6995	.ndo_set_mac_address = stmmac_set_mac_address,	6965	.ndo_set_mac_address = stmmac_set_mac_address,
6996	.ndo_vlan_rx_add_vid = stmmac_vlan_rx_add_vid,	6966	.ndo_vlan_rx_add_vid = stmmac_vlan_rx_add_vid,
6997	.ndo_vlan_rx_kill_vid = stmmac_vlan_rx_kill_vid,	6967	.ndo_vlan_rx_kill_vid = stmmac_vlan_rx_kill_vid,

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

@@ -901,7 +901,7 @@ static int __maybe_unused stmmac_pltfr_resume(struct device *dev) · 900 unmodified lines
901	struct platform_device *pdev = to_platform_device(dev);	901	struct platform_device *pdev = to_platform_device(dev);
902	int ret;	902	int ret;
903		903
904	ret = stmmac_pltfr_init(pdev, priv->plat->bsp_priv);	904	ret = stmmac_pltfr_init(pdev, priv->plat);
905	if (ret)	905	if (ret)
906	return ret;	906	return ret;
907		907

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/ieee802154/ca8210.c+3−14

 	struct device_node *np = spi->dev.of_node;
 	struct ca8210_priv *priv = spi_get_drvdata(spi);
 	struct ca8210_platform_data *pdata = spi->dev.platform_data;
-	int ret = 0;
 	if (!np)
 		return -EFAULT;
 		dev_crit(&spi->dev, "Failed to register external clk\n");
 		return PTR_ERR(priv->clk);
 	}
-	ret = of_clk_add_provider(np, of_clk_src_simple_get, priv->clk);
-	if (ret) {
-		clk_unregister(priv->clk);
-		dev_crit(
-			&spi->dev,
-			"Failed to register external clock as clock provider\n"
-		);
-	} else {
-		dev_info(&spi->dev, "External clock set as clock provider\n");
-	}
-	return ret;
+	return of_clk_add_provider(np, of_clk_src_simple_get, priv->clk);
 }
 /**
 {
 	struct ca8210_priv *priv = spi_get_drvdata(spi);
-	if (!priv->clk)
+	if (IS_ERR_OR_NULL(priv->clk))
-		return
+		return;
 	of_clk_del_provider(spi->dev.of_node);
 	clk_unregister(priv->clk);

drivers/net/macsec.c+2−0

 		ctx.sa.assoc_num = assoc_num;
 		ctx.sa.tx_sa = tx_sa;
+		ctx.sa.update_pn = !!prev_pn.full64;
 		ctx.secy = secy;
 		ret = macsec_offload(ops->mdo_upd_txsa, &ctx);
 		ctx.sa.assoc_num = assoc_num;
 		ctx.sa.rx_sa = rx_sa;
+		ctx.sa.update_pn = !!prev_pn.full64;
 		ctx.secy = secy;
 		ret = macsec_offload(ops->mdo_upd_rxsa, &ctx);

drivers/net/phy/mscc/mscc_macsec.c+6−0

 	struct macsec_flow *flow;
 	int ret;
+	if (ctx->sa.update_pn)
+		return -EINVAL;
 	flow = vsc8584_macsec_find_flow(ctx, MACSEC_INGR);
 	if (IS_ERR(flow))
 		return PTR_ERR(flow);
 	struct macsec_flow *flow;
 	int ret;
+	if (ctx->sa.update_pn)
+		return -EINVAL;
 	flow = vsc8584_macsec_find_flow(ctx, MACSEC_EGR);
 	if (IS_ERR(flow))
 		return PTR_ERR(flow);

drivers/net/usb/dm9601.c+6−1

 	struct usbnet *dev = netdev_priv(netdev);
 	__le16 res;
+	int err;
 	if (phy_id) {
 		netdev_dbg(dev->net, "Only internal phy supported\n");
 		return 0;
 	}
-	dm_read_shared_word(dev, 1, loc, &res);
+	err = dm_read_shared_word(dev, 1, loc, &res);
+	if (err < 0) {
+		netdev_err(dev->net, "MDIO read error: %d\n", err);
+		return err;
+	}
 	netdev_dbg(dev->net,
 		   "dm9601_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",

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/virtio_net.c+7−7

 	--dma->ref;
-	if (dma->ref) {
+	if (dma->need_sync && len) {
-		if (dma->need_sync && len) {
+		offset = buf - (head + sizeof(*dma));
-			offset = buf - (head + sizeof(*dma));
-			virtqueue_dma_sync_single_range_for_cpu(rq->vq, dma->addr, offset,
+		virtqueue_dma_sync_single_range_for_cpu(rq->vq, dma->addr,
-								len, DMA_FROM_DEVICE);
+							offset, len,
-		}
+							DMA_FROM_DEVICE);
+	}
+	if (dma->ref)
 		return;
-	}
 	virtqueue_dma_unmap_single_attrs(rq->vq, dma->addr, dma->len,
 					 DMA_FROM_DEVICE, DMA_ATTR_SKIP_CPU_SYNC);

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/net/xen-netback/interface.c+0−4

 #include <asm/xen/hypercall.h>
 #include <xen/balloon.h>
-#define XENVIF_QUEUE_LENGTH 32
 /* Number of bytes allowed on the internal guest Rx queue. */
 #define XENVIF_RX_QUEUE_BYTES (XEN_NETIF_RX_RING_SIZE/2 * PAGE_SIZE)
 	dev->features = dev->hw_features | NETIF_F_RXCSUM;
 	dev->ethtool_ops = &xenvif_ethtool_ops;
-	dev->tx_queue_len = XENVIF_QUEUE_LENGTH;
 	dev->min_mtu = ETH_MIN_MTU;
 	dev->max_mtu = ETH_MAX_MTU - VLAN_ETH_HLEN;

drivers/of/dynamic.c+3−3

 {
 	struct of_changeset_entry *ce;
+	if (WARN_ON(action >= ARRAY_SIZE(action_names)))
+		return -EINVAL;
 	ce = kzalloc(sizeof(*ce), GFP_KERNEL);
 	if (!ce)
 		return -ENOMEM;
-	if (WARN_ON(action >= ARRAY_SIZE(action_names)))
-		return -EINVAL;
 	/* get a reference to the node */
 	ce->action = action;
 	ce->np = of_node_get(np);

drivers/of/overlay.c+1−1

 /**
  * struct fragment - info about fragment nodes in overlay expanded device tree
- * @target:	target of the overlay operation
  * @overlay:	pointer to the __overlay__ node
+ * @target:	target of the overlay operation
  */
 struct fragment {
 	struct device_node *overlay;

drivers/pci/controller/dwc/pcie-qcom.c+1−3

 #define PARF_PHY_REFCLK				0x4c
 #define PARF_CONFIG_BITS			0x50
 #define PARF_DBI_BASE_ADDR			0x168
-#define PARF_SLV_ADDR_SPACE_SIZE_2_3_3		0x16c /* Register offset specific to IP ver 2.3.3 */
 #define PARF_MHI_CLOCK_RESET_CTRL		0x174
 #define PARF_AXI_MSTR_WR_ADDR_HALT		0x178
 #define PARF_AXI_MSTR_WR_ADDR_HALT_V2		0x1a8
 	u16 offset = dw_pcie_find_capability(pci, PCI_CAP_ID_EXP);
 	u32 val;
-	writel(SLV_ADDR_SPACE_SZ,
+	writel(SLV_ADDR_SPACE_SZ, pcie->parf + PARF_SLV_ADDR_SPACE_SIZE);
-		pcie->parf + PARF_SLV_ADDR_SPACE_SIZE_2_3_3);
 	val = readl(pcie->parf + PARF_PHY_CTRL);
 	val &= ~PHY_TEST_PWR_DOWN;

drivers/pci/of.c+11−8

 	cset = kmalloc(sizeof(*cset), GFP_KERNEL);
 	if (!cset)
-		goto failed;
+		goto out_free_name;
 	of_changeset_init(cset);
 	np = of_changeset_create_node(cset, ppnode, name);
 	if (!np)
-		goto failed;
+		goto out_destroy_cset;
-	np->data = cset;
 	ret = of_pci_add_properties(pdev, cset, np);
 	if (ret)
-		goto failed;
+		goto out_free_node;
 	ret = of_changeset_apply(cset);
 	if (ret)
-		goto failed;
+		goto out_free_node;
+	np->data = cset;
 	pdev->dev.of_node = np;
 	kfree(name);
 	return;
-failed:
+out_free_node:
-	if (np)
+	of_node_put(np);
-		of_node_put(np);
+out_destroy_cset:
+	of_changeset_destroy(cset);
+	kfree(cset);
+out_free_name:
 	kfree(name);
 }
 #endif

drivers/pci/of_property.c+18−7

 static int of_pci_prop_intr_map(struct pci_dev *pdev, struct of_changeset *ocs,
 				struct device_node *np)
 {
+	u32 i, addr_sz[OF_PCI_MAX_INT_PIN] = { 0 }, map_sz = 0;
 	struct of_phandle_args out_irq[OF_PCI_MAX_INT_PIN];
-	u32 i, addr_sz[OF_PCI_MAX_INT_PIN], map_sz = 0;
 	__be32 laddr[OF_PCI_ADDRESS_CELLS] = { 0 };
 	u32 int_map_mask[] = { 0xffff00, 0, 0, 7 };
 	struct device_node *pnode;
 		out_irq[i].args[0] = pin;
 		ret = of_irq_parse_raw(laddr, &out_irq[i]);
 		if (ret) {
-			pci_err(pdev, "parse irq %d failed, ret %d", pin, ret);
+			out_irq[i].np = NULL;
+			pci_dbg(pdev, "parse irq %d failed, ret %d", pin, ret);
 			continue;
 		}
-		ret = of_property_read_u32(out_irq[i].np, "#address-cells",
+		of_property_read_u32(out_irq[i].np, "#address-cells",
-					   &addr_sz[i]);
+				     &addr_sz[i]);
-		if (ret)
-			addr_sz[i] = 0;
 	}
 	list_for_each_entry(child, &pdev->subordinate->devices, bus_list) {
 		for (pin = 1; pin <= OF_PCI_MAX_INT_PIN; pin++) {
 			i = pci_swizzle_interrupt_pin(child, pin) - 1;
+			if (!out_irq[i].np)
+				continue;
 			map_sz += 5 + addr_sz[i] + out_irq[i].args_count;
 		}
 	}
+	/*
+	 * Parsing interrupt failed for all pins. In this case, it does not
+	 * need to generate interrupt-map property.
+	 */
+	if (!map_sz)
+		return 0;
 	int_map = kcalloc(map_sz, sizeof(u32), GFP_KERNEL);
 	mapp = int_map;
 	list_for_each_entry(child, &pdev->subordinate->devices, bus_list) {
 		for (pin = 1; pin <= OF_PCI_MAX_INT_PIN; pin++) {
+			i = pci_swizzle_interrupt_pin(child, pin) - 1;
+			if (!out_irq[i].np)
+				continue;
 			*mapp = (child->bus->number << 16) |
 				(child->devfn << 8);
 			mapp += OF_PCI_ADDRESS_CELLS;
 			*mapp = pin;
 			mapp++;
-			i = pci_swizzle_interrupt_pin(child, pin) - 1;
 			*mapp = out_irq[i].np->phandle;
 			mapp++;
 			if (addr_sz[i]) {

drivers/pci/pci-driver.c+13−1

@@ -572,7 +572,19 @@ static void pci_pm_default_resume_early(struct pci_dev *pci_dev) · 571 unmodified lines
572		572
573	static void pci_pm_bridge_power_up_actions(struct pci_dev *pci_dev)	573	static void pci_pm_bridge_power_up_actions(struct pci_dev *pci_dev)
574	{	574	{
575	pci_bridge_wait_for_secondary_bus(pci_dev, "resume");	575	int ret;
		576
		577	ret = pci_bridge_wait_for_secondary_bus(pci_dev, "resume");
		578	if (ret) {
		579	/*
		580	* The downstream link failed to come up, so mark the
		581	* devices below as disconnected to make sure we don't
		582	* attempt to resume them.
		583	*/
		584	pci_walk_bus(pci_dev->subordinate, pci_dev_set_disconnected,
		585	NULL);
		586	return;
		587	}
576		588
577	/*	589	/*
578	* When powering on a bridge from D3cold, the whole hierarchy may be	590	* When powering on a bridge from D3cold, the whole hierarchy may be

drivers/perf/arm-cmn.c+1−1

@@ -1972,7 +1972,7 @@ static irqreturn_t arm_cmn_handle_irq(int irq, void *dev_id) · 1971 unmodified lines
1972	u64 delta;	1972	u64 delta;
1973	int i;	1973	int i;
1974		1974
1975	for (i = 0; i < CMN_DTM_NUM_COUNTERS; i++) {	1975	for (i = 0; i < CMN_DT_NUM_COUNTERS; i++) {
1976	if (status & (1U << i)) {	1976	if (status & (1U << i)) {
1977	ret = IRQ_HANDLED;	1977	ret = IRQ_HANDLED;
1978	if (WARN_ON(!dtc->counters[i]))	1978	if (WARN_ON(!dtc->counters[i]))

drivers/perf/riscv_pmu.c+2−1

@@ -23,7 +23,8 @@ static bool riscv_perf_user_access(struct perf_event *event) · 22 unmodified lines
23	return ((event->attr.type == PERF_TYPE_HARDWARE) \|\|	23	return ((event->attr.type == PERF_TYPE_HARDWARE) \|\|
24	(event->attr.type == PERF_TYPE_HW_CACHE) \|\|	24	(event->attr.type == PERF_TYPE_HW_CACHE) \|\|
25	(event->attr.type == PERF_TYPE_RAW)) &&	25	(event->attr.type == PERF_TYPE_RAW)) &&
26	!!(event->hw.flags & PERF_EVENT_FLAG_USER_READ_CNT);	26	!!(event->hw.flags & PERF_EVENT_FLAG_USER_READ_CNT) &&
		27	(event->hw.idx != -1);
27	}	28	}
28		29
29	void arch_perf_update_userpage(struct perf_event *event,	30	void arch_perf_update_userpage(struct perf_event *event,

drivers/perf/riscv_pmu_sbi.c+10−6

 {
 	struct perf_event *event = (struct perf_event *)arg;
-	csr_write(CSR_SCOUNTEREN,
+	if (event->hw.idx != -1)
-		  csr_read(CSR_SCOUNTEREN) | (1 << pmu_sbi_csr_index(event)));
+		csr_write(CSR_SCOUNTEREN,
+			  csr_read(CSR_SCOUNTEREN) | (1 << pmu_sbi_csr_index(event)));
 }
 static void pmu_sbi_reset_scounteren(void *arg)
 {
 	struct perf_event *event = (struct perf_event *)arg;
-	csr_write(CSR_SCOUNTEREN,
+	if (event->hw.idx != -1)
-		  csr_read(CSR_SCOUNTEREN) & ~(1 << pmu_sbi_csr_index(event)));
+		csr_write(CSR_SCOUNTEREN,
+			  csr_read(CSR_SCOUNTEREN) & ~(1 << pmu_sbi_csr_index(event)));
 }
 static void pmu_sbi_ctr_start(struct perf_event *event, u64 ival)
 	if ((hwc->flags & PERF_EVENT_FLAG_USER_ACCESS) &&
 	    (hwc->flags & PERF_EVENT_FLAG_USER_READ_CNT))
-		pmu_sbi_set_scounteren((void *)event);
+		on_each_cpu_mask(mm_cpumask(event->owner->mm),
+				 pmu_sbi_set_scounteren, (void *)event, 1);
 }
 static void pmu_sbi_ctr_stop(struct perf_event *event, unsigned long flag)
 	if ((hwc->flags & PERF_EVENT_FLAG_USER_ACCESS) &&
 	    (hwc->flags & PERF_EVENT_FLAG_USER_READ_CNT))
-		pmu_sbi_reset_scounteren((void *)event);
+		on_each_cpu_mask(mm_cpumask(event->owner->mm),
+				 pmu_sbi_reset_scounteren, (void *)event, 1);
 	ret = sbi_ecall(SBI_EXT_PMU, SBI_EXT_PMU_COUNTER_STOP, hwc->idx, 1, flag, 0, 0, 0);
 	if (ret.error && (ret.error != SBI_ERR_ALREADY_STOPPED) &&

drivers/phy/freescale/phy-fsl-lynx-28g.c+24−3

 struct lynx_28g_priv {
 	void __iomem *base;
 	struct device *dev;
+	/* Serialize concurrent access to registers shared between lanes,
+	 * like PCCn
+	 */
+	spinlock_t pcc_lock;
 	struct lynx_28g_pll pll[LYNX_28G_NUM_PLL];
 	struct lynx_28g_lane lane[LYNX_28G_NUM_LANE];
 	if (powered_up)
 		lynx_28g_power_off(phy);
+	spin_lock(&priv->pcc_lock);
 	switch (submode) {
 	case PHY_INTERFACE_MODE_SGMII:
 	case PHY_INTERFACE_MODE_1000BASEX:
 	lane->interface = submode;
 out:
+	spin_unlock(&priv->pcc_lock);
 	/* Power up the lane if necessary */
 	if (powered_up)
 		lynx_28g_power_on(phy);
 	for (i = 0; i < LYNX_28G_NUM_LANE; i++) {
 		lane = &priv->lane[i];
-		if (!lane->init)
+		mutex_lock(&lane->phy->mutex);
-			continue;
-		if (!lane->powered_up)
+		if (!lane->init || !lane->powered_up) {
+			mutex_unlock(&lane->phy->mutex);
 			continue;
+		}
 		rrstctl = lynx_28g_lane_read(lane, LNaRRSTCTL);
 		if (!(rrstctl & LYNX_28G_LNaRRSTCTL_CDR_LOCK)) {
 				rrstctl = lynx_28g_lane_read(lane, LNaRRSTCTL);
 			} while (!(rrstctl & LYNX_28G_LNaRRSTCTL_RST_DONE));
 		}
+		mutex_unlock(&lane->phy->mutex);
 	}
 	queue_delayed_work(system_power_efficient_wq, &priv->cdr_check,
 			   msecs_to_jiffies(1000));
 	dev_set_drvdata(dev, priv);
+	spin_lock_init(&priv->pcc_lock);
 	INIT_DELAYED_WORK(&priv->cdr_check, lynx_28g_cdr_lock_check);
 	queue_delayed_work(system_power_efficient_wq, &priv->cdr_check,
 	return PTR_ERR_OR_ZERO(provider);
 }
+static void lynx_28g_remove(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct lynx_28g_priv *priv = dev_get_drvdata(dev);
+	cancel_delayed_work_sync(&priv->cdr_check);
+}
 static const struct of_device_id lynx_28g_of_match_table[] = {
 	{ .compatible = "fsl,lynx-28g" },
 	{ },
 static struct platform_driver lynx_28g_driver = {
 	.probe	= lynx_28g_probe,
+	.remove_new = lynx_28g_remove,
 	.driver	= {
 		.name = "lynx-28g",
 		.of_match_table = lynx_28g_of_match_table,

drivers/pinctrl/core.c+9−7

@@ -1022,17 +1022,20 @@ static int add_setting(struct pinctrl p, struct pinctrl_dev pctldev, · 1021 unmodified lines
1022		1022
1023	static struct pinctrl find_pinctrl(struct device dev)	1023	static struct pinctrl find_pinctrl(struct device dev)
1024	{	1024	{
1025	struct pinctrl *p;	1025	struct pinctrl entry, p = NULL;
1026		1026
1027	mutex_lock(&pinctrl_list_mutex);	1027	mutex_lock(&pinctrl_list_mutex);
1028	list_for_each_entry(p, &pinctrl_list, node)	1028
1029	if (p->dev == dev) {	1029	list_for_each_entry(entry, &pinctrl_list, node) {
1030	mutex_unlock(&pinctrl_list_mutex);	1030	if (entry->dev == dev) {
1031	return p;	1031	p = entry;
		1032	kref_get(&p->users);
		1033	break;
1032	}	1034	}
		1035	}
1033		1036
1034	mutex_unlock(&pinctrl_list_mutex);	1037	mutex_unlock(&pinctrl_list_mutex);
1035	return NULL;	1038	return p;
1036	}	1039	}
1037		1040
1038	static void pinctrl_free(struct pinctrl *p, bool inlist);	1041	static void pinctrl_free(struct pinctrl *p, bool inlist);
@@ -1140,7 +1143,6 @@ struct pinctrl pinctrl_get(struct device dev) · 101 unmodified lines
1140	p = find_pinctrl(dev);	1143	p = find_pinctrl(dev);
1141	if (p) {	1144	if (p) {
1142	dev_dbg(dev, "obtain a copy of previously claimed pinctrl\n");	1145	dev_dbg(dev, "obtain a copy of previously claimed pinctrl\n");
1143	kref_get(&p->users);
1144	return p;	1146	return p;
1145	}	1147	}
1146		1148

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c+3−3

 		if (ret < 0)
 			return ret;
-		gpio = &pctrl->gpio_bank[reg];
-		gpio->pctrl = pctrl;
 		if (reg >= WPCM450_NUM_BANKS)
 			return dev_err_probe(dev, -EINVAL,
 					     "GPIO index %d out of range!\n", reg);
+		gpio = &pctrl->gpio_bank[reg];
+		gpio->pctrl = pctrl;
 		bank = &wpcm450_banks[reg];
 		gpio->bank = bank;

drivers/pinctrl/pinctrl-lantiq.h+0−1

@@ -198,5 +198,4 @@ enum ltq_pin { · 197 unmodified lines
198		198
199	extern int ltq_pinctrl_register(struct platform_device *pdev,	199	extern int ltq_pinctrl_register(struct platform_device *pdev,
200	struct ltq_pinmux_info *info);	200	struct ltq_pinmux_info *info);
201	extern int ltq_pinctrl_unregister(struct platform_device *pdev);
202	#endif /* __PINCTRL_LANTIQ_H */	201	#endif /* __PINCTRL_LANTIQ_H */

drivers/pinctrl/renesas/Kconfig+1−0

@@ -235,6 +235,7 @@ config PINCTRL_RZN1 · 234 unmodified lines
235	depends on OF	235	depends on OF
236	depends on ARCH_RZN1 \|\| COMPILE_TEST	236	depends on ARCH_RZN1 \|\| COMPILE_TEST
237	select GENERIC_PINCONF	237	select GENERIC_PINCONF
		238	select PINMUX
238	help	239	help
239	This selects pinctrl driver for Renesas RZ/N1 devices.	240	This selects pinctrl driver for Renesas RZ/N1 devices.
240		241

drivers/pinctrl/starfive/pinctrl-starfive-jh7110-aon.c+4−0

 #define JH7110_AON_NGPIO		4
 #define JH7110_AON_GC_BASE		64
+#define JH7110_AON_REGS_NUM		37
 /* registers */
 #define JH7110_AON_DOEN			0x0
 #define JH7110_AON_DOUT			0x4
 	.gpi_mask	= GENMASK(3, 0),
 	.gpioin_reg_base	   = JH7110_AON_GPIOIN,
 	.irq_reg		   = &jh7110_aon_irq_reg,
+	.nsaved_regs		   = JH7110_AON_REGS_NUM,
 	.jh7110_set_one_pin_mux  = jh7110_aon_set_one_pin_mux,
 	.jh7110_get_padcfg_base  = jh7110_aon_get_padcfg_base,
 	.jh7110_gpio_irq_handler = jh7110_aon_irq_handler,
 	.driver = {
 		.name = "starfive-jh7110-aon-pinctrl",
 		.of_match_table = jh7110_aon_pinctrl_of_match,
+		.pm = pm_sleep_ptr(&jh7110_pinctrl_pm_ops),
 	},
 };
 module_platform_driver(jh7110_aon_pinctrl_driver);

drivers/pinctrl/starfive/pinctrl-starfive-jh7110-sys.c+4−0

 #define JH7110_SYS_NGPIO		64
 #define JH7110_SYS_GC_BASE		0
+#define JH7110_SYS_REGS_NUM		174
 /* registers */
 #define JH7110_SYS_DOEN			0x000
 #define JH7110_SYS_DOUT			0x040
 	.gpi_mask	= GENMASK(6, 0),
 	.gpioin_reg_base	   = JH7110_SYS_GPIOIN,
 	.irq_reg		   = &jh7110_sys_irq_reg,
+	.nsaved_regs		   = JH7110_SYS_REGS_NUM,
 	.jh7110_set_one_pin_mux  = jh7110_sys_set_one_pin_mux,
 	.jh7110_get_padcfg_base  = jh7110_sys_get_padcfg_base,
 	.jh7110_gpio_irq_handler = jh7110_sys_irq_handler,
 	.driver = {
 		.name = "starfive-jh7110-sys-pinctrl",
 		.of_match_table = jh7110_sys_pinctrl_of_match,
+		.pm = pm_sleep_ptr(&jh7110_pinctrl_pm_ops),
 	},
 };
 module_platform_driver(jh7110_sys_pinctrl_driver);

drivers/pinctrl/starfive/pinctrl-starfive-jh7110.c+40−2

@@ -872,6 +872,13 @@ int jh7110_pinctrl_probe(struct platform_device *pdev) · 871 unmodified lines
872	if (!sfp)	872	if (!sfp)
873	return -ENOMEM;	873	return -ENOMEM;
874		874
		875	#if IS_ENABLED(CONFIG_PM_SLEEP)
		876	sfp->saved_regs = devm_kcalloc(dev, info->nsaved_regs,
		877	sizeof(*sfp->saved_regs), GFP_KERNEL);
		878	if (!sfp->saved_regs)
		879	return -ENOMEM;
		880	#endif
		881
875	sfp->base = devm_platform_ioremap_resource(pdev, 0);	882	sfp->base = devm_platform_ioremap_resource(pdev, 0);
876	if (IS_ERR(sfp->base))	883	if (IS_ERR(sfp->base))
877	return PTR_ERR(sfp->base);	884	return PTR_ERR(sfp->base);
@@ -967,14 +974,45 @@ int jh7110_pinctrl_probe(struct platform_device *pdev) · 89 unmodified lines
967	if (ret)	974	if (ret)
968	return dev_err_probe(dev, ret, "could not register gpiochip\n");	975	return dev_err_probe(dev, ret, "could not register gpiochip\n");
969		976
970	irq_domain_set_pm_device(sfp->gc.irq.domain, dev);
971
972	dev_info(dev, "StarFive GPIO chip registered %d GPIOs\n", sfp->gc.ngpio);	977	dev_info(dev, "StarFive GPIO chip registered %d GPIOs\n", sfp->gc.ngpio);
973		978
974	return pinctrl_enable(sfp->pctl);	979	return pinctrl_enable(sfp->pctl);
975	}	980	}
976	EXPORT_SYMBOL_GPL(jh7110_pinctrl_probe);	981	EXPORT_SYMBOL_GPL(jh7110_pinctrl_probe);
977		982
		983	static int jh7110_pinctrl_suspend(struct device *dev)
		984	{
		985	struct jh7110_pinctrl *sfp = dev_get_drvdata(dev);
		986	unsigned long flags;
		987	unsigned int i;
		988
		989	raw_spin_lock_irqsave(&sfp->lock, flags);
		990	for (i = 0 ; i < sfp->info->nsaved_regs ; i++)
		991	sfp->saved_regs[i] = readl_relaxed(sfp->base + 4 * i);
		992
		993	raw_spin_unlock_irqrestore(&sfp->lock, flags);
		994	return 0;
		995	}
		996
		997	static int jh7110_pinctrl_resume(struct device *dev)
		998	{
		999	struct jh7110_pinctrl *sfp = dev_get_drvdata(dev);
		1000	unsigned long flags;
		1001	unsigned int i;
		1002
		1003	raw_spin_lock_irqsave(&sfp->lock, flags);
		1004	for (i = 0 ; i < sfp->info->nsaved_regs ; i++)
		1005	writel_relaxed(sfp->saved_regs[i], sfp->base + 4 * i);
		1006
		1007	raw_spin_unlock_irqrestore(&sfp->lock, flags);
		1008	return 0;
		1009	}
		1010
		1011	const struct dev_pm_ops jh7110_pinctrl_pm_ops = {
		1012	LATE_SYSTEM_SLEEP_PM_OPS(jh7110_pinctrl_suspend, jh7110_pinctrl_resume)
		1013	};
		1014	EXPORT_SYMBOL_GPL(jh7110_pinctrl_pm_ops);
		1015
978	MODULE_DESCRIPTION("Pinctrl driver for the StarFive JH7110 SoC");	1016	MODULE_DESCRIPTION("Pinctrl driver for the StarFive JH7110 SoC");
979	MODULE_AUTHOR("Emil Renner Berthing <kernel@esmil.dk>");	1017	MODULE_AUTHOR("Emil Renner Berthing <kernel@esmil.dk>");
980	MODULE_AUTHOR("Jianlong Huang <jianlong.huang@starfivetech.com>");	1018	MODULE_AUTHOR("Jianlong Huang <jianlong.huang@starfivetech.com>");

drivers/pinctrl/starfive/pinctrl-starfive-jh7110.h+4−0

 	/* register read/write mutex */
 	struct mutex mutex;
 	const struct jh7110_pinctrl_soc_info *info;
+	u32 *saved_regs;
 };
 struct jh7110_gpio_irq_reg {
 	const struct jh7110_gpio_irq_reg *irq_reg;
+	unsigned int nsaved_regs;
 	/* generic pinmux */
 	int (*jh7110_set_one_pin_mux)(struct jh7110_pinctrl *sfp,
 				      unsigned int pin,
 			unsigned int din, u32 dout, u32 doen);
 int jh7110_pinctrl_probe(struct platform_device *pdev);
 struct jh7110_pinctrl *jh7110_from_irq_desc(struct irq_desc *desc);
+extern const struct dev_pm_ops jh7110_pinctrl_pm_ops;
 #endif /* __PINCTRL_STARFIVE_JH7110_H__ */

drivers/pinctrl/tegra/pinctrl-tegra.c+2−17

 	{"nvidia,slew-rate-falling",	TEGRA_PINCONF_PARAM_SLEW_RATE_FALLING},
 	{"nvidia,slew-rate-rising",	TEGRA_PINCONF_PARAM_SLEW_RATE_RISING},
 	{"nvidia,drive-type",		TEGRA_PINCONF_PARAM_DRIVE_TYPE},
-	{"nvidia,function",		TEGRA_PINCONF_PARAM_FUNCTION},
 };
 static int tegra_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
 		*bit = g->drvtype_bit;
 		*width = 2;
 		break;
-	case TEGRA_PINCONF_PARAM_FUNCTION:
-		*bank = g->mux_bank;
-		*reg = g->mux_reg;
-		*bit = g->mux_bit;
-		*width = 2;
-		break;
 	default:
 		dev_err(pmx->dev, "Invalid config param %04x\n", param);
 		return -ENOTSUPP;
 		val >>= bit;
 		val &= (1 << width) - 1;
-		if (cfg_params[i].param == TEGRA_PINCONF_PARAM_FUNCTION) {
+		seq_printf(s, "\n\t%s=%u",
-			u8 idx = pmx->soc->groups[group].funcs[val];
+			   strip_prefix(cfg_params[i].property), val);
-			seq_printf(s, "\n\t%s=%s",
-				   strip_prefix(cfg_params[i].property),
-					 pmx->functions[idx].name);
-		} else {
-			seq_printf(s, "\n\t%s=%u",
-				   strip_prefix(cfg_params[i].property), val);
-		}
 	}
 }

drivers/pinctrl/tegra/pinctrl-tegra.h+0−2

@@ -54,8 +54,6 @@ enum tegra_pinconf_param { · 53 unmodified lines
54	TEGRA_PINCONF_PARAM_SLEW_RATE_RISING,	54	TEGRA_PINCONF_PARAM_SLEW_RATE_RISING,
55	/* argument: Integer, range is HW-dependant */	55	/* argument: Integer, range is HW-dependant */
56	TEGRA_PINCONF_PARAM_DRIVE_TYPE,	56	TEGRA_PINCONF_PARAM_DRIVE_TYPE,
57	/* argument: pinmux settings */
58	TEGRA_PINCONF_PARAM_FUNCTION,
59	};	57	};
60		58
61	enum tegra_pinconf_pull {	59	enum tegra_pinconf_pull {

drivers/platform/mellanox/mlxbf-tmfifo.c+8−6

 struct mlxbf_tmfifo;
 /**
- * mlxbf_tmfifo_vring - Structure of the TmFifo virtual ring
+ * struct mlxbf_tmfifo_vring - Structure of the TmFifo virtual ring
  * @va: virtual address of the ring
  * @dma: dma address of the ring
  * @vq: pointer to the virtio virtqueue
 };
 /**
- * mlxbf_tmfifo_vdev - Structure of the TmFifo virtual device
+ * struct mlxbf_tmfifo_vdev - Structure of the TmFifo virtual device
  * @vdev: virtio device, in which the vdev.id.device field has the
  *        VIRTIO_ID_xxx id to distinguish the virtual device.
  * @status: status of the device
  * @features: supported features of the device
  * @vrings: array of tmfifo vrings of this device
+ * @config: non-anonymous union for cons and net
  * @config.cons: virtual console config -
  *               select if vdev.id.device is VIRTIO_ID_CONSOLE
  * @config.net: virtual network config -
 };
 /**
- * mlxbf_tmfifo_irq_info - Structure of the interrupt information
+ * struct mlxbf_tmfifo_irq_info - Structure of the interrupt information
  * @fifo: pointer to the tmfifo structure
  * @irq: interrupt number
  * @index: index into the interrupt array
 };
 /**
- * mlxbf_tmfifo_io - Structure of the TmFifo IO resource (for both rx & tx)
+ * struct mlxbf_tmfifo_io - Structure of the TmFifo IO resource (for both rx & tx)
  * @ctl: control register offset (TMFIFO_RX_CTL / TMFIFO_TX_CTL)
  * @sts: status register offset (TMFIFO_RX_STS / TMFIFO_TX_STS)
  * @data: data register offset (TMFIFO_RX_DATA / TMFIFO_TX_DATA)
 };
 /**
- * mlxbf_tmfifo - Structure of the TmFifo
+ * struct mlxbf_tmfifo - Structure of the TmFifo
  * @vdev: array of the virtual devices running over the TmFifo
  * @lock: lock to protect the TmFifo access
  * @res0: mapped resource block 0
 };
 /**
- * mlxbf_tmfifo_msg_hdr - Structure of the TmFifo message header
+ * struct mlxbf_tmfifo_msg_hdr - Structure of the TmFifo message header
  * @type: message type
  * @len: payload length in network byte order. Messages sent into the FIFO
  *       will be read by the other side as data stream in the same byte order.
 struct mlxbf_tmfifo_msg_hdr {
 	u8 type;
 	__be16 len;
+	/* private: */
 	u8 unused[5];
 } __packed __aligned(sizeof(u64));

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c+10−4

 					  const char *guid, int min_elements,
 					  int instance_id)
 {
-	struct kobject *attr_name_kobj;
+	struct kobject *attr_name_kobj, *duplicate;
 	union acpi_object *elements;
 	struct kset *temp_kset;
 	}
 	/* All duplicate attributes found are ignored */
-	if (kset_find_obj(temp_kset, str_value)) {
+	duplicate = kset_find_obj(temp_kset, str_value);
+	if (duplicate) {
 		pr_debug("Duplicate attribute name found - %s\n", str_value);
+		/* kset_find_obj() returns a reference */
+		kobject_put(duplicate);
 		goto pack_attr_exit;
 	}
 					 const char *guid, int min_elements,
 					 int instance_id)
 {
-	struct kobject *attr_name_kobj;
+	struct kobject *attr_name_kobj, *duplicate;
 	struct kset *temp_kset;
 	char str[MAX_BUFF_SIZE];
 		temp_kset = bioscfg_drv.main_dir_kset;
 	/* All duplicate attributes found are ignored */
-	if (kset_find_obj(temp_kset, str)) {
+	duplicate = kset_find_obj(temp_kset, str);
+	if (duplicate) {
 		pr_debug("Duplicate attribute name found - %s\n", str);
+		/* kset_find_obj() returns a reference */
+		kobject_put(duplicate);
 		goto buff_attr_exit;
 	}

drivers/platform/x86/hp/hp-wmi.c+7−1

 	.restore  = hp_wmi_resume_handler,
 };
-static struct platform_driver hp_wmi_driver = {
+/*
+ * hp_wmi_bios_remove() lives in .exit.text. For drivers registered via
+ * module_platform_driver_probe() this is ok because they cannot get unbound at
+ * runtime. So mark the driver struct with __refdata to prevent modpost
+ * triggering a section mismatch warning.
+ */
+static struct platform_driver hp_wmi_driver __refdata = {
 	.driver = {
 		.name = "hp-wmi",
 		.pm = &hp_wmi_pm_ops,

drivers/platform/x86/intel/ifs/runtest.c+4−3

 	switch (test->test_num) {
 	case IFS_TYPE_SAF:
 		if (!ifsd->loaded)
-			return -EPERM;
+			ret = -EPERM;
-		ifs_test_core(cpu, dev);
+		else
+			ifs_test_core(cpu, dev);
 		break;
 	case IFS_TYPE_ARRAY_BIST:
 		ifs_array_test_core(cpu, dev);
 		break;
 	default:
-		return -EINVAL;
+		ret = -EINVAL;
 	}
 out:
 	cpus_read_unlock();

drivers/platform/x86/think-lmi.c+20−4

@@ -1248,6 +1248,24 @@ static void tlmi_release_attr(void) · 1247 unmodified lines
1248	kset_unregister(tlmi_priv.authentication_kset);	1248	kset_unregister(tlmi_priv.authentication_kset);
1249	}	1249	}
1250		1250
		1251	static int tlmi_validate_setting_name(struct kset attribute_kset, char name)
		1252	{
		1253	struct kobject *duplicate;
		1254
		1255	if (!strcmp(name, "Reserved"))
		1256	return -EINVAL;
		1257
		1258	duplicate = kset_find_obj(attribute_kset, name);
		1259	if (duplicate) {
		1260	pr_debug("Duplicate attribute name found - %s\n", name);
		1261	/* kset_find_obj() returns a reference */
		1262	kobject_put(duplicate);
		1263	return -EBUSY;
		1264	}
		1265
		1266	return 0;
		1267	}
		1268
1251	static int tlmi_sysfs_init(void)	1269	static int tlmi_sysfs_init(void)
1252	{	1270	{
1253	int i, ret;	1271	int i, ret;
@@ -1276,10 +1294,8 @@ static int tlmi_sysfs_init(void) · 22 unmodified lines
1276	continue;	1294	continue;
1277		1295
1278	/* check for duplicate or reserved values */	1296	/* check for duplicate or reserved values */
1279	if (kset_find_obj(tlmi_priv.attribute_kset, tlmi_priv.setting[i]->display_name) \|\|	1297	if (tlmi_validate_setting_name(tlmi_priv.attribute_kset,
1280	!strcmp(tlmi_priv.setting[i]->display_name, "Reserved")) {	1298	tlmi_priv.setting[i]->display_name) < 0) {
1281	pr_debug("duplicate or reserved attribute name found - %s\n",
1282	tlmi_priv.setting[i]->display_name);
1283	kfree(tlmi_priv.setting[i]->possible_values);	1299	kfree(tlmi_priv.setting[i]->possible_values);
1284	kfree(tlmi_priv.setting[i]);	1300	kfree(tlmi_priv.setting[i]);
1285	tlmi_priv.setting[i] = NULL;	1301	tlmi_priv.setting[i] = NULL;

drivers/platform/x86/touchscreen_dmi.c+45−0

@@ -42,6 +42,21 @@ static const struct ts_dmi_data archos_101_cesium_educ_data = { · 41 unmodified lines
42	.properties = archos_101_cesium_educ_props,	42	.properties = archos_101_cesium_educ_props,
43	};	43	};
44		44
		45	static const struct property_entry bush_bush_windows_tablet_props[] = {
		46	PROPERTY_ENTRY_U32("touchscreen-size-x", 1850),
		47	PROPERTY_ENTRY_U32("touchscreen-size-y", 1280),
		48	PROPERTY_ENTRY_BOOL("touchscreen-swapped-x-y"),
		49	PROPERTY_ENTRY_U32("silead,max-fingers", 10),
		50	PROPERTY_ENTRY_BOOL("silead,home-button"),
		51	PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-bush-bush-windows-tablet.fw"),
		52	{ }
		53	};
		54
		55	static const struct ts_dmi_data bush_bush_windows_tablet_data = {
		56	.acpi_name = "MSSL1680:00",
		57	.properties = bush_bush_windows_tablet_props,
		58	};
		59
45	static const struct property_entry chuwi_hi8_props[] = {	60	static const struct property_entry chuwi_hi8_props[] = {
46	PROPERTY_ENTRY_U32("touchscreen-size-x", 1665),	61	PROPERTY_ENTRY_U32("touchscreen-size-x", 1665),
47	PROPERTY_ENTRY_U32("touchscreen-size-y", 1140),	62	PROPERTY_ENTRY_U32("touchscreen-size-y", 1140),
@@ -756,6 +771,21 @@ static const struct ts_dmi_data pipo_w11_data = { · 708 unmodified lines
756	.properties = pipo_w11_props,	771	.properties = pipo_w11_props,
757	};	772	};
758		773
		774	static const struct property_entry positivo_c4128b_props[] = {
		775	PROPERTY_ENTRY_U32("touchscreen-min-x", 4),
		776	PROPERTY_ENTRY_U32("touchscreen-min-y", 13),
		777	PROPERTY_ENTRY_U32("touchscreen-size-x", 1915),
		778	PROPERTY_ENTRY_U32("touchscreen-size-y", 1269),
		779	PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-positivo-c4128b.fw"),
		780	PROPERTY_ENTRY_U32("silead,max-fingers", 10),
		781	{ }
		782	};
		783
		784	static const struct ts_dmi_data positivo_c4128b_data = {
		785	.acpi_name = "MSSL1680:00",
		786	.properties = positivo_c4128b_props,
		787	};
		788
759	static const struct property_entry pov_mobii_wintab_p800w_v20_props[] = {	789	static const struct property_entry pov_mobii_wintab_p800w_v20_props[] = {
760	PROPERTY_ENTRY_U32("touchscreen-min-x", 32),	790	PROPERTY_ENTRY_U32("touchscreen-min-x", 32),
761	PROPERTY_ENTRY_U32("touchscreen-min-y", 16),	791	PROPERTY_ENTRY_U32("touchscreen-min-y", 16),
@@ -1070,6 +1100,13 @@ const struct dmi_system_id touchscreen_dmi_table[] = { · 308 unmodified lines
1070	DMI_MATCH(DMI_PRODUCT_NAME, "ARCHOS 101 Cesium Educ"),	1100	DMI_MATCH(DMI_PRODUCT_NAME, "ARCHOS 101 Cesium Educ"),
1071	},	1101	},
1072	},	1102	},
		1103	{
		1104	/* Bush Windows tablet */
		1105	.driver_data = (void *)&bush_bush_windows_tablet_data,
		1106	.matches = {
		1107	DMI_MATCH(DMI_PRODUCT_NAME, "Bush Windows tablet"),
		1108	},
		1109	},
1073	{	1110	{
1074	/* Chuwi Hi8 */	1111	/* Chuwi Hi8 */
1075	.driver_data = (void *)&chuwi_hi8_data,	1112	.driver_data = (void *)&chuwi_hi8_data,
@@ -1480,6 +1517,14 @@ const struct dmi_system_id touchscreen_dmi_table[] = { · 404 unmodified lines
1480	DMI_MATCH(DMI_BIOS_VERSION, "MOMO.G.WI71C.MABMRBA02"),	1517	DMI_MATCH(DMI_BIOS_VERSION, "MOMO.G.WI71C.MABMRBA02"),
1481	},	1518	},
1482	},	1519	},
		1520	{
		1521	/* Positivo C4128B */
		1522	.driver_data = (void *)&positivo_c4128b_data,
		1523	.matches = {
		1524	DMI_MATCH(DMI_SYS_VENDOR, "Positivo Tecnologia SA"),
		1525	DMI_MATCH(DMI_PRODUCT_NAME, "C4128B-1"),
		1526	},
		1527	},
1483	{	1528	{
1484	/* Point of View mobii wintab p800w (v2.0) */	1529	/* Point of View mobii wintab p800w (v2.0) */
1485	.driver_data = (void *)&pov_mobii_wintab_p800w_v20_data,	1530	.driver_data = (void *)&pov_mobii_wintab_p800w_v20_data,

drivers/pmdomain/imx/scu-pd.c+2−1

 	{ "mclk-out-1", IMX_SC_R_MCLK_OUT_1, 1, false, 0 },
 	{ "dma0-ch", IMX_SC_R_DMA_0_CH0, 32, true, 0 },
 	{ "dma1-ch", IMX_SC_R_DMA_1_CH0, 16, true, 0 },
-	{ "dma2-ch", IMX_SC_R_DMA_2_CH0, 32, true, 0 },
+	{ "dma2-ch-0", IMX_SC_R_DMA_2_CH0, 5, true, 0 },
+	{ "dma2-ch-1", IMX_SC_R_DMA_2_CH5, 27, true, 0 },
 	{ "dma3-ch", IMX_SC_R_DMA_3_CH0, 32, true, 0 },
 	{ "asrc0", IMX_SC_R_ASRC_0, 1, false, 0 },
 	{ "asrc1", IMX_SC_R_ASRC_1, 1, false, 0 },

drivers/power/supply/qcom_battmgr.c+4−4

@@ -105,7 +105,7 @@ struct qcom_battmgr_property_request { · 104 unmodified lines
105		105
106	struct qcom_battmgr_update_request {	106	struct qcom_battmgr_update_request {
107	struct pmic_glink_hdr hdr;	107	struct pmic_glink_hdr hdr;
108	u32 battery_id;	108	__le32 battery_id;
109	};	109	};
110		110
111	struct qcom_battmgr_charge_time_request {	111	struct qcom_battmgr_charge_time_request {
@@ -1282,9 +1282,9 @@ static void qcom_battmgr_enable_worker(struct work_struct *work) · 1170 unmodified lines
1282	{	1282	{
1283	struct qcom_battmgr *battmgr = container_of(work, struct qcom_battmgr, enable_work);	1283	struct qcom_battmgr *battmgr = container_of(work, struct qcom_battmgr, enable_work);
1284	struct qcom_battmgr_enable_request req = {	1284	struct qcom_battmgr_enable_request req = {
1285	.hdr.owner = PMIC_GLINK_OWNER_BATTMGR,	1285	.hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR),
1286	.hdr.type = PMIC_GLINK_NOTIFY,	1286	.hdr.type = cpu_to_le32(PMIC_GLINK_NOTIFY),
1287	.hdr.opcode = BATTMGR_REQUEST_NOTIFICATION,	1287	.hdr.opcode = cpu_to_le32(BATTMGR_REQUEST_NOTIFICATION),
1288	};	1288	};
1289	int ret;	1289	int ret;
1290		1290

drivers/ptp/ptp_ocp.c+0−1

@@ -3998,7 +3998,6 @@ ptp_ocp_device_init(struct ptp_ocp bp, struct pci_dev pdev) · 3997 unmodified lines
3998	return 0;	3998	return 0;
3999		3999
4000	out:	4000	out:
4001	ptp_ocp_dev_release(&bp->dev);
4002	put_device(&bp->dev);	4001	put_device(&bp->dev);
4003	return err;	4002	return err;
4004	}	4003	}

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/net/Kconfig+1−1

@@ -102,7 +102,7 @@ config CCWGROUP · 101 unmodified lines
102		102
103	config ISM	103	config ISM
104	tristate "Support for ISM vPCI Adapter"	104	tristate "Support for ISM vPCI Adapter"
105	depends on PCI && SMC	105	depends on PCI
106	default n	106	default n
107	help	107	help
108	Select this option if you want to use the Internal Shared Memory	108	Select this option if you want to use the Internal Shared Memory

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_scan.c+6−5

@@ -1627,12 +1627,13 @@ int scsi_rescan_device(struct scsi_device *sdev) · 1626 unmodified lines
1627	device_lock(dev);	1627	device_lock(dev);
1628		1628
1629	/*	1629	/*
1630	* Bail out if the device is not running. Otherwise, the rescan may	1630	* Bail out if the device or its queue are not running. Otherwise,
1631	* block waiting for commands to be executed, with us holding the	1631	* the rescan may block waiting for commands to be executed, with us
1632	* device lock. This can result in a potential deadlock in the power	1632	* holding the device lock. This can result in a potential deadlock
1633	* management core code when system resume is on-going.	1633	* in the power management core code when system resume is on-going.
1634	*/	1634	*/
1635	if (sdev->sdev_state != SDEV_RUNNING) {	1635	if (sdev->sdev_state != SDEV_RUNNING \|\|
		1636	blk_queue_pm_only(sdev->request_queue)) {
1636	ret = -EWOULDBLOCK;	1637	ret = -EWOULDBLOCK;
1637	goto unlock;	1638	goto unlock;
1638	}	1639	}

drivers/soc/renesas/Kconfig+1−0

@@ -333,6 +333,7 @@ if RISCV · 332 unmodified lines
333		333
334	config ARCH_R9A07G043	334	config ARCH_R9A07G043
335	bool "RISC-V Platform support for RZ/Five"	335	bool "RISC-V Platform support for RZ/Five"
		336	depends on NONPORTABLE
336	select ARCH_RZG2L	337	select ARCH_RZG2L
337	select AX45MP_L2_CACHE if RISCV_DMA_NONCOHERENT	338	select AX45MP_L2_CACHE if RISCV_DMA_NONCOHERENT
338	select DMA_GLOBAL_POOL	339	select DMA_GLOBAL_POOL

drivers/soundwire/Makefile+4−0

 soundwire-bus-y += debugfs.o
 endif
+ifdef CONFIG_IRQ_DOMAIN
+soundwire-bus-y += irq.o
+endif
 #AMD driver
 soundwire-amd-y :=	amd_manager.o
 obj-$(CONFIG_SOUNDWIRE_AMD) += soundwire-amd.o

drivers/soundwire/bus.c+5−26

 #include <linux/acpi.h>
 #include <linux/delay.h>
-#include <linux/irq.h>
 #include <linux/mod_devicetable.h>
 #include <linux/pm_runtime.h>
 #include <linux/soundwire/sdw_registers.h>
 #include <linux/soundwire/sdw.h>
 #include <linux/soundwire/sdw_type.h>
 #include "bus.h"
+#include "irq.h"
 #include "sysfs_local.h"
 static DEFINE_IDA(sdw_bus_ida);
 	return 0;
 }
-static int sdw_irq_map(struct irq_domain *h, unsigned int virq,
-		       irq_hw_number_t hw)
-{
-	struct sdw_bus *bus = h->host_data;
-	irq_set_chip_data(virq, bus);
-	irq_set_chip(virq, &bus->irq_chip);
-	irq_set_nested_thread(virq, 1);
-	irq_set_noprobe(virq);
-	return 0;
-}
-static const struct irq_domain_ops sdw_domain_ops = {
-	.map	= sdw_irq_map,
-};
 /**
  * sdw_bus_master_add() - add a bus Master instance
  * @bus: bus instance
 	bus->params.curr_bank = SDW_BANK0;
 	bus->params.next_bank = SDW_BANK1;
-	bus->irq_chip.name = dev_name(bus->dev);
+	ret = sdw_irq_create(bus, fwnode);
-	bus->domain = irq_domain_create_linear(fwnode, SDW_MAX_DEVICES,
+	if (ret)
-					       &sdw_domain_ops, bus);
+		return ret;
-	if (!bus->domain) {
-		dev_err(bus->dev, "Failed to add IRQ domain\n");
-		return -EINVAL;
-	}
 	return 0;
 }
 {
 	device_for_each_child(bus->dev, NULL, sdw_delete_slave);
-	irq_domain_remove(bus->domain);
+	sdw_irq_delete(bus);
 	sdw_master_device_del(bus);

drivers/soundwire/bus_type.c+4−7

 #include <linux/soundwire/sdw.h>
 #include <linux/soundwire/sdw_type.h>
 #include "bus.h"
+#include "irq.h"
 #include "sysfs_local.h"
 /**
 	if (drv->ops && drv->ops->read_prop)
 		drv->ops->read_prop(slave);
-	if (slave->prop.use_domain_irq) {
+	if (slave->prop.use_domain_irq)
-		slave->irq = irq_create_mapping(slave->bus->domain, slave->dev_num);
+		sdw_irq_create_mapping(slave);
-		if (!slave->irq)
-			dev_warn(dev, "Failed to map IRQ\n");
-	}
 	/* init the sysfs as we have properties now */
 	ret = sdw_slave_sysfs_init(slave);
 	slave->probed = false;
 	if (slave->prop.use_domain_irq)
-		irq_dispose_mapping(irq_find_mapping(slave->bus->domain,
+		sdw_irq_dispose_mapping(slave);
-						     slave->dev_num));
 	mutex_unlock(&slave->sdw_dev_lock);

drivers/soundwire/irq.c+59−0

@@ -0,0 +1,59 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	// Copyright (C) 2023 Cirrus Logic, Inc. and
	3	// Cirrus Logic International Semiconductor Ltd.
	4
	5	#include <linux/device.h>
	6	#include <linux/fwnode.h>
	7	#include <linux/irq.h>
	8	#include <linux/irqdomain.h>
	9	#include <linux/soundwire/sdw.h>
	10	#include "irq.h"
	11
	12	static int sdw_irq_map(struct irq_domain *h, unsigned int virq,
	13	irq_hw_number_t hw)
	14	{
	15	struct sdw_bus *bus = h->host_data;
	16
	17	irq_set_chip_data(virq, bus);
	18	irq_set_chip(virq, &bus->irq_chip);
	19	irq_set_nested_thread(virq, 1);
	20	irq_set_noprobe(virq);
	21
	22	return 0;
	23	}
	24
	25	static const struct irq_domain_ops sdw_domain_ops = {
	26	.map = sdw_irq_map,
	27	};
	28
	29	int sdw_irq_create(struct sdw_bus *bus,
	30	struct fwnode_handle *fwnode)
	31	{
	32	bus->irq_chip.name = dev_name(bus->dev);
	33
	34	bus->domain = irq_domain_create_linear(fwnode, SDW_MAX_DEVICES,
	35	&sdw_domain_ops, bus);
	36	if (!bus->domain) {
	37	dev_err(bus->dev, "Failed to add IRQ domain\n");
	38	return -EINVAL;
	39	}
	40
	41	return 0;
	42	}
	43
	44	void sdw_irq_delete(struct sdw_bus *bus)
	45	{
	46	irq_domain_remove(bus->domain);
	47	}
	48
	49	void sdw_irq_create_mapping(struct sdw_slave *slave)
	50	{
	51	slave->irq = irq_create_mapping(slave->bus->domain, slave->dev_num);
	52	if (!slave->irq)
	53	dev_warn(&slave->dev, "Failed to map IRQ\n");
	54	}
	55
	56	void sdw_irq_dispose_mapping(struct sdw_slave *slave)
	57	{
	58	irq_dispose_mapping(irq_find_mapping(slave->bus->domain, slave->dev_num));
	59	}

drivers/soundwire/irq.h+43−0

@@ -0,0 +1,43 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Copyright (C) 2023 Cirrus Logic, Inc. and
	4	* Cirrus Logic International Semiconductor Ltd.
	5	*/
	6
	7	#ifndef __SDW_IRQ_H
	8	#define __SDW_IRQ_H
	9
	10	#include <linux/soundwire/sdw.h>
	11	#include <linux/fwnode.h>
	12
	13	#if IS_ENABLED(CONFIG_IRQ_DOMAIN)
	14
	15	int sdw_irq_create(struct sdw_bus *bus,
	16	struct fwnode_handle *fwnode);
	17	void sdw_irq_delete(struct sdw_bus *bus);
	18	void sdw_irq_create_mapping(struct sdw_slave *slave);
	19	void sdw_irq_dispose_mapping(struct sdw_slave *slave);
	20
	21	#else /* CONFIG_IRQ_DOMAIN */
	22
	23	static inline int sdw_irq_create(struct sdw_bus *bus,
	24	struct fwnode_handle *fwnode)
	25	{
	26	return 0;
	27	}
	28
	29	static inline void sdw_irq_delete(struct sdw_bus *bus)
	30	{
	31	}
	32
	33	static inline void sdw_irq_create_mapping(struct sdw_slave *slave)
	34	{
	35	}
	36
	37	static inline void sdw_irq_dispose_mapping(struct sdw_slave *slave)
	38	{
	39	}
	40
	41	#endif /* CONFIG_IRQ_DOMAIN */
	42
	43	#endif /* __SDW_IRQ_H */

drivers/staging/media/atomisp/Kconfig+1−1

 config VIDEO_ATOMISP
 	tristate "Intel Atom Image Signal Processor Driver"
 	depends on VIDEO_DEV && INTEL_ATOMISP
+	depends on IPU_BRIDGE
 	depends on MEDIA_PCI_SUPPORT
 	depends on PMIC_OPREGION
 	depends on I2C
 	select V4L2_FWNODE
 	select IOSF_MBI
-	select IPU_BRIDGE
 	select VIDEOBUF2_VMALLOC
 	select VIDEO_V4L2_SUBDEV_API
 	help

drivers/staging/media/tegra-video/vi.c+10−6

 }
 /*
- * Graph Management
+ * Find the entity matching a given fwnode in an v4l2_async_notifier list
  */
 static struct tegra_vi_graph_entity *
-tegra_vi_graph_find_entity(struct tegra_vi_channel *chan,
+tegra_vi_graph_find_entity(struct list_head *list,
 			   const struct fwnode_handle *fwnode)
 {
 	struct tegra_vi_graph_entity *entity;
 	struct v4l2_async_connection *asd;
-	list_for_each_entry(asd, &chan->notifier.done_list, asc_entry) {
+	list_for_each_entry(asd, list, asc_entry) {
 		entity = to_tegra_vi_graph_entity(asd);
 		if (entity->asd.match.fwnode == fwnode)
 			return entity;
 	}
 		}
 		/* find the remote entity from notifier list */
-		ent = tegra_vi_graph_find_entity(chan, link.remote_node);
+		ent = tegra_vi_graph_find_entity(&chan->notifier.done_list,
+						 link.remote_node);
 		if (!ent) {
 			dev_err(vi->dev, "no entity found for %pOF\n",
 				to_of_node(link.remote_node));
 	 * Locate the entity corresponding to the bound subdev and store the
 	 * subdev pointer.
 	 */
-	entity = tegra_vi_graph_find_entity(chan, subdev->fwnode);
+	entity = tegra_vi_graph_find_entity(&chan->notifier.waiting_list,
+					    subdev->fwnode);
 	if (!entity) {
 		dev_err(vi->dev, "no entity for subdev %s\n", subdev->name);
 		return -EINVAL;
 		/* skip entities that are already processed */
 		if (device_match_fwnode(vi->dev, remote) ||
-		    tegra_vi_graph_find_entity(chan, remote)) {
+		    tegra_vi_graph_find_entity(&chan->notifier.waiting_list,
+					       remote)) {
 			fwnode_handle_put(remote);
 			continue;
 		}

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/amdtee/core.c+6−4

 	return rc;
 }
+/* mutex must be held by caller */
 static void destroy_session(struct kref *ref)
 {
 	struct amdtee_session *sess = container_of(ref, struct amdtee_session,
 						   refcount);
-	mutex_lock(&session_list_mutex);
 	list_del(&sess->list_node);
 	mutex_unlock(&session_list_mutex);
 	kfree(sess);
 	if (arg->ret != TEEC_SUCCESS) {
 		pr_err("open_session failed %d\n", arg->ret);
 		handle_unload_ta(ta_handle);
-		kref_put(&sess->refcount, destroy_session);
+		kref_put_mutex(&sess->refcount, destroy_session,
+			       &session_list_mutex);
 		goto out;
 	}
 		pr_err("reached maximum session count %d\n", TEE_NUM_SESSIONS);
 		handle_close_session(ta_handle, session_info);
 		handle_unload_ta(ta_handle);
-		kref_put(&sess->refcount, destroy_session);
+		kref_put_mutex(&sess->refcount, destroy_session,
+			       &session_list_mutex);
 		rc = -ENOMEM;
 		goto out;
 	}
 	handle_close_session(ta_handle, session_info);
 	handle_unload_ta(ta_handle);
-	kref_put(&sess->refcount, destroy_session);
+	kref_put_mutex(&sess->refcount, destroy_session, &session_list_mutex);
 	return 0;
 }

drivers/thunderbolt/icm.c+20−20

 #define PHY_PORT_CS1_LINK_STATE_SHIFT	26
 #define ICM_TIMEOUT			5000	/* ms */
+#define ICM_RETRIES			3
 #define ICM_APPROVE_TIMEOUT		10000	/* ms */
 #define ICM_MAX_LINK			4
 static int icm_request(struct tb *tb, const void *request, size_t request_size,
 		       void *response, size_t response_size, size_t npackets,
-		       unsigned int timeout_msec)
+		       int retries, unsigned int timeout_msec)
 {
 	struct icm *icm = tb_priv(tb);
-	int retries = 3;
 	do {
 		struct tb_cfg_request *req;
 		return -ENOMEM;
 	ret = icm_request(tb, &request, sizeof(request), switches,
-			  sizeof(*switches), npackets, ICM_TIMEOUT);
+			  sizeof(*switches), npackets, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		goto err_free;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	/* Use larger timeout as establishing tunnels can take some time */
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_APPROVE_TIMEOUT);
+			  1, ICM_RETRIES, ICM_APPROVE_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, 20000);
+			  1, 10, 2000);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_APPROVE_TIMEOUT);
+			  1, ICM_RETRIES, ICM_APPROVE_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, 20000);
+			  1, ICM_RETRIES, 20000);
 	if (ret)
 		return ret;
 	memset(&reply, 0, sizeof(reply));
 	ret = icm_request(tb, &request, sizeof(request), &reply, sizeof(reply),
-			  1, ICM_TIMEOUT);
+			  1, ICM_RETRIES, ICM_TIMEOUT);
 	if (ret)
 		return ret;

drivers/thunderbolt/switch.c+7−0

@@ -2725,6 +2725,13 @@ int tb_switch_lane_bonding_enable(struct tb_switch *sw) · 2724 unmodified lines
2725	!tb_port_is_width_supported(down, TB_LINK_WIDTH_DUAL))	2725	!tb_port_is_width_supported(down, TB_LINK_WIDTH_DUAL))
2726	return 0;	2726	return 0;
2727		2727
		2728	/*
		2729	* Both lanes need to be in CL0. Here we assume lane 0 already be in
		2730	* CL0 and check just for lane 1.
		2731	*/
		2732	if (tb_wait_for_port(down->dual_link_port, false) <= 0)
		2733	return -ENOTCONN;
		2734
2728	ret = tb_port_lane_bonding_enable(up);	2735	ret = tb_port_lane_bonding_enable(up);
2729	if (ret) {	2736	if (ret) {
2730	tb_port_warn(up, "failed to enable lane bonding\n");	2737	tb_port_warn(up, "failed to enable lane bonding\n");

drivers/thunderbolt/tmu.c+1−1

@@ -382,7 +382,7 @@ static int tmu_mode_init(struct tb_switch *sw) · 381 unmodified lines
382	} else if (ucap && tb_port_tmu_is_unidirectional(up)) {	382	} else if (ucap && tb_port_tmu_is_unidirectional(up)) {
383	if (tmu_rates[TB_SWITCH_TMU_MODE_LOWRES] == rate)	383	if (tmu_rates[TB_SWITCH_TMU_MODE_LOWRES] == rate)
384	sw->tmu.mode = TB_SWITCH_TMU_MODE_LOWRES;	384	sw->tmu.mode = TB_SWITCH_TMU_MODE_LOWRES;
385	else if (tmu_rates[TB_SWITCH_TMU_MODE_LOWRES] == rate)	385	else if (tmu_rates[TB_SWITCH_TMU_MODE_HIFI_UNI] == rate)
386	sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_UNI;	386	sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_UNI;
387	} else if (rate) {	387	} else if (rate) {
388	sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_BI;	388	sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_BI;

drivers/thunderbolt/xdomain.c+41−17

 	mutex_unlock(&xdomain_lock);
 }
+static void start_handshake(struct tb_xdomain *xd)
+{
+	xd->state = XDOMAIN_STATE_INIT;
+	queue_delayed_work(xd->tb->wq, &xd->state_work,
+			   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
+}
+/* Can be called from state_work */
+static void __stop_handshake(struct tb_xdomain *xd)
+{
+	cancel_delayed_work_sync(&xd->properties_changed_work);
+	xd->properties_changed_retries = 0;
+	xd->state_retries = 0;
+}
+static void stop_handshake(struct tb_xdomain *xd)
+{
+	cancel_delayed_work_sync(&xd->state_work);
+	__stop_handshake(xd);
+}
 static void tb_xdp_handle_request(struct work_struct *work)
 {
 	struct xdomain_request_work *xw = container_of(work, typeof(*xw), work);
 	case UUID_REQUEST:
 		tb_dbg(tb, "%llx: received XDomain UUID request\n", route);
 		ret = tb_xdp_uuid_response(ctl, route, sequence, uuid);
+		/*
+		 * If we've stopped the discovery with an error such as
+		 * timing out, we will restart the handshake now that we
+		 * received UUID request from the remote host.
+		 */
+		if (!ret && xd && xd->state == XDOMAIN_STATE_ERROR) {
+			dev_dbg(&xd->dev, "restarting handshake\n");
+			start_handshake(xd);
+		}
 		break;
 	case LINK_STATE_STATUS_REQUEST:
 			   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
 }
+static void tb_xdomain_failed(struct tb_xdomain *xd)
+{
+	xd->state = XDOMAIN_STATE_ERROR;
+	queue_delayed_work(xd->tb->wq, &xd->state_work,
+			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
+}
 static void tb_xdomain_state_work(struct work_struct *work)
 {
 	struct tb_xdomain *xd = container_of(work, typeof(*xd), state_work.work);
 		if (ret) {
 			if (ret == -EAGAIN)
 				goto retry_state;
-			xd->state = XDOMAIN_STATE_ERROR;
+			tb_xdomain_failed(xd);
 		} else {
 			tb_xdomain_queue_properties_changed(xd);
 			if (xd->bonding_possible)
 		if (ret) {
 			if (ret == -EAGAIN)
 				goto retry_state;
-			xd->state = XDOMAIN_STATE_ERROR;
+			tb_xdomain_failed(xd);
 		} else {
 			xd->state = XDOMAIN_STATE_ENUMERATED;
 		}
 		break;
 	case XDOMAIN_STATE_ERROR:
+		dev_dbg(&xd->dev, "discovery failed, stopping handshake\n");
+		__stop_handshake(xd);
 		break;
 	default:
 	kfree(xd);
 }
-static void start_handshake(struct tb_xdomain *xd)
-{
-	xd->state = XDOMAIN_STATE_INIT;
-	queue_delayed_work(xd->tb->wq, &xd->state_work,
-			   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
-}
-static void stop_handshake(struct tb_xdomain *xd)
-{
-	cancel_delayed_work_sync(&xd->properties_changed_work);
-	cancel_delayed_work_sync(&xd->state_work);
-	xd->properties_changed_retries = 0;
-	xd->state_retries = 0;
-}
 static int __maybe_unused tb_xdomain_suspend(struct device *dev)
 {
 	stop_handshake(tb_to_xdomain(dev));

drivers/tty/serial/8250/8250_omap.c+10−15

 {
 	struct omap8250_priv *priv = dev_get_drvdata(dev);
 	struct uart_8250_port *up = serial8250_get_port(priv->line);
-	int err;
+	int err = 0;
 	serial8250_suspend_port(priv->line);
 	if (!device_may_wakeup(dev))
 		priv->wer = 0;
 	serial_out(up, UART_OMAP_WER, priv->wer);
-	err = pm_runtime_force_suspend(dev);
+	if (uart_console(&up->port) && console_suspend_enabled)
+		err = pm_runtime_force_suspend(dev);
 	flush_work(&priv->qos_work);
 	return err;
 static int omap8250_resume(struct device *dev)
 {
 	struct omap8250_priv *priv = dev_get_drvdata(dev);
+	struct uart_8250_port *up = serial8250_get_port(priv->line);
 	int err;
-	err = pm_runtime_force_resume(dev);
+	if (uart_console(&up->port) && console_suspend_enabled) {
-	if (err)
+		err = pm_runtime_force_resume(dev);
-		return err;
+		if (err)
+			return err;
+	}
 	serial8250_resume_port(priv->line);
 	/* Paired with pm_runtime_resume_and_get() in omap8250_suspend() */
 	pm_runtime_mark_last_busy(dev);
 	if (priv->line >= 0)
 		up = serial8250_get_port(priv->line);
-	/*
-	 * When using 'no_console_suspend', the console UART must not be
-	 * suspended. Since driver suspend is managed by runtime suspend,
-	 * preventing runtime suspend (by returning error) will keep device
-	 * active during suspend.
-	 */
-	if (priv->is_suspending && !console_suspend_enabled) {
-		if (up && uart_console(&up->port))
-			return -EBUSY;
-	}
 	if (priv->habit & UART_ERRATA_CLOCK_DISABLE) {
 		int ret;

drivers/tty/serial/serial_core.c+10−5

 	 * enabled, serial_port_runtime_resume() calls start_tx() again
 	 * after enabling the device.
 	 */
-	if (pm_runtime_active(&port_dev->dev))
+	if (!pm_runtime_enabled(port->dev) || pm_runtime_active(port->dev))
 		port->ops->start_tx(port);
 	pm_runtime_mark_last_busy(&port_dev->dev);
 	pm_runtime_put_autosuspend(&port_dev->dev);
 static int uart_rs485_config(struct uart_port *port)
 {
 	struct serial_rs485 *rs485 = &port->rs485;
+	unsigned long flags;
 	int ret;
+	if (!(rs485->flags & SER_RS485_ENABLED))
+		return 0;
 	uart_sanitize_serial_rs485(port, rs485);
 	uart_set_rs485_termination(port, rs485);
+	uart_port_lock_irqsave(port, &flags);
 	ret = port->rs485_config(port, NULL, rs485);
+	uart_port_unlock_irqrestore(port, flags);
 	if (ret)
 		memset(rs485, 0, sizeof(*rs485));
 			if (ret == 0) {
 				if (tty)
 					uart_change_line_settings(tty, state, NULL);
+				uart_rs485_config(uport);
 				uart_port_lock_irq(uport);
 				if (!(uport->rs485.flags & SER_RS485_ENABLED))
 					ops->set_mctrl(uport, uport->mctrl);
-				else
-					uart_rs485_config(uport);
 				ops->start_tx(uport);
 				uart_port_unlock_irq(uport);
 				tty_port_set_initialized(port, true);
 		port->mctrl &= TIOCM_DTR;
 		if (!(port->rs485.flags & SER_RS485_ENABLED))
 			port->ops->set_mctrl(port, port->mctrl);
-		else
-			uart_rs485_config(port);
 		uart_port_unlock_irqrestore(port, flags);
+		uart_rs485_config(port);
 		/*
 		 * If this driver supports console, and it hasn't been
 		 * successfully registered yet, try to re-register it.

drivers/ufs/core/ufshcd.c+1−1

@@ -6895,7 +6895,7 @@ static int ufshcd_clear_tm_cmd(struct ufs_hba *hba, int tag) · 6894 unmodified lines
6895	mask, 0, 1000, 1000);	6895	mask, 0, 1000, 1000);
6896		6896
6897	dev_err(hba->dev, "Clearing task management function with tag %d %s\n",	6897	dev_err(hba->dev, "Clearing task management function with tag %d %s\n",
6898	tag, err ? "succeeded" : "failed");	6898	tag, err < 0 ? "failed" : "succeeded");
6899		6899
6900	out:	6900	out:
6901	return err;	6901	return err;

drivers/usb/cdns3/cdnsp-gadget.c+3−0

@@ -1125,6 +1125,9 @@ static int cdnsp_gadget_ep_dequeue(struct usb_ep *ep, · 1124 unmodified lines
1125	unsigned long flags;	1125	unsigned long flags;
1126	int ret;	1126	int ret;
1127		1127
		1128	if (request->status != -EINPROGRESS)
		1129	return 0;
		1130
1128	if (!pep->endpoint.desc) {	1131	if (!pep->endpoint.desc) {
1129	dev_err(pdev->dev,	1132	dev_err(pdev->dev,
1130	"%s: can't dequeue to disabled endpoint\n",	1133	"%s: can't dequeue to disabled endpoint\n",

drivers/usb/cdns3/core.h+1−2

 #else /* CONFIG_PM_SLEEP */
 static inline int cdns_resume(struct cdns *cdns)
 { return 0; }
-static inline int cdns_set_active(struct cdns *cdns, u8 set_active)
+static inline void cdns_set_active(struct cdns *cdns, u8 set_active) { }
-{ return 0; }
 static inline int cdns_suspend(struct cdns *cdns)
 { return 0; }
 #endif /* CONFIG_PM_SLEEP */

drivers/usb/core/hub.c+22−3

 	if (udev->quirks & USB_QUIRK_NO_LPM)
 		return 0;
+	/* Skip if the device BOS descriptor couldn't be read */
+	if (!udev->bos)
+		return 0;
 	/* USB 2.1 (and greater) devices indicate LPM support through
 	 * their USB 2.0 Extended Capabilities BOS descriptor.
 	 */
 	if (!udev->lpm_capable || udev->speed < USB_SPEED_SUPER)
 		return;
+	/* Skip if the device BOS descriptor couldn't be read */
+	if (!udev->bos)
+		return;
 	hub = usb_hub_to_struct_hub(udev->parent);
 	/* It doesn't take time to transition the roothub into U0, since it
 	 * doesn't have an upstream link.
 static enum usb_ssp_rate get_port_ssp_rate(struct usb_device *hdev,
 					   u32 ext_portstatus)
 {
-	struct usb_ssp_cap_descriptor *ssp_cap = hdev->bos->ssp_cap;
+	struct usb_ssp_cap_descriptor *ssp_cap;
 	u32 attr;
 	u8 speed_id;
 	u8 ssac;
 	u8 lanes;
 	int i;
+	if (!hdev->bos)
+		goto out;
+	ssp_cap = hdev->bos->ssp_cap;
 	if (!ssp_cap)
 		goto out;
 		enum usb3_link_state state)
 {
 	int timeout;
-	__u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
+	__u8 u1_mel;
-	__le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
+	__le16 u2_mel;
+	/* Skip if the device BOS descriptor couldn't be read */
+	if (!udev->bos)
+		return;
+	u1_mel = udev->bos->ss_cap->bU1devExitLat;
+	u2_mel = udev->bos->ss_cap->bU2DevExitLat;
 	/* If the device says it doesn't have *any* exit latency to come out of
 	 * U1 or U2, it's probably lying.  Assume it doesn't implement that link

drivers/usb/core/hub.h+1−1

@@ -153,7 +153,7 @@ static inline int hub_is_superspeedplus(struct usb_device *hdev) · 152 unmodified lines
153	{	153	{
154	return (hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS &&	154	return (hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS &&
155	le16_to_cpu(hdev->descriptor.bcdUSB) >= 0x0310 &&	155	le16_to_cpu(hdev->descriptor.bcdUSB) >= 0x0310 &&
156	hdev->bos->ssp_cap);	156	hdev->bos && hdev->bos->ssp_cap);
157	}	157	}
158		158
159	static inline unsigned hub_power_on_good_delay(struct usb_hub *hub)	159	static inline unsigned hub_power_on_good_delay(struct usb_hub *hub)

drivers/usb/dwc3/core.c+38−1

@@ -279,9 +279,46 @@ int dwc3_core_soft_reset(struct dwc3 *dwc) · 278 unmodified lines
279	* XHCI driver will reset the host block. If dwc3 was configured for	279	* XHCI driver will reset the host block. If dwc3 was configured for
280	* host-only mode or current role is host, then we can return early.	280	* host-only mode or current role is host, then we can return early.
281	*/	281	*/
282	if (dwc->dr_mode == USB_DR_MODE_HOST \|\| dwc->current_dr_role == DWC3_GCTL_PRTCAP_HOST)	282	if (dwc->current_dr_role == DWC3_GCTL_PRTCAP_HOST)
283	return 0;	283	return 0;
284		284
		285	/*
		286	* If the dr_mode is host and the dwc->current_dr_role is not the
		287	* corresponding DWC3_GCTL_PRTCAP_HOST, then the dwc3_core_init_mode
		288	* isn't executed yet. Ensure the phy is ready before the controller
		289	* updates the GCTL.PRTCAPDIR or other settings by soft-resetting
		290	* the phy.
		291	*
		292	* Note: GUSB3PIPECTL[n] and GUSB2PHYCFG[n] are port settings where n
		293	* is port index. If this is a multiport host, then we need to reset
		294	* all active ports.
		295	*/
		296	if (dwc->dr_mode == USB_DR_MODE_HOST) {
		297	u32 usb3_port;
		298	u32 usb2_port;
		299
		300	usb3_port = dwc3_readl(dwc->regs, DWC3_GUSB3PIPECTL(0));
		301	usb3_port \|= DWC3_GUSB3PIPECTL_PHYSOFTRST;
		302	dwc3_writel(dwc->regs, DWC3_GUSB3PIPECTL(0), usb3_port);
		303
		304	usb2_port = dwc3_readl(dwc->regs, DWC3_GUSB2PHYCFG(0));
		305	usb2_port \|= DWC3_GUSB2PHYCFG_PHYSOFTRST;
		306	dwc3_writel(dwc->regs, DWC3_GUSB2PHYCFG(0), usb2_port);
		307
		308	/* Small delay for phy reset assertion */
		309	usleep_range(1000, 2000);
		310
		311	usb3_port &= ~DWC3_GUSB3PIPECTL_PHYSOFTRST;
		312	dwc3_writel(dwc->regs, DWC3_GUSB3PIPECTL(0), usb3_port);
		313
		314	usb2_port &= ~DWC3_GUSB2PHYCFG_PHYSOFTRST;
		315	dwc3_writel(dwc->regs, DWC3_GUSB2PHYCFG(0), usb2_port);
		316
		317	/* Wait for clock synchronization */
		318	msleep(50);
		319	return 0;
		320	}
		321
285	reg = dwc3_readl(dwc->regs, DWC3_DCTL);	322	reg = dwc3_readl(dwc->regs, DWC3_DCTL);
286	reg \|= DWC3_DCTL_CSFTRST;	323	reg \|= DWC3_DCTL_CSFTRST;
287	reg &= ~DWC3_DCTL_RUN_STOP;	324	reg &= ~DWC3_DCTL_RUN_STOP;

drivers/usb/gadget/function/f_ncm.c+19−7

 			  struct sk_buff_head *list)
 {
 	struct f_ncm	*ncm = func_to_ncm(&port->func);
-	__le16		*tmp = (void *) skb->data;
+	unsigned char	*ntb_ptr = skb->data;
+	__le16		*tmp;
 	unsigned	index, index2;
 	int		ndp_index;
 	unsigned	dg_len, dg_len2;
 	const struct ndp_parser_opts *opts = ncm->parser_opts;
 	unsigned	crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
 	int		dgram_counter;
+	int		to_process = skb->len;
+parse_ntb:
+	tmp = (__le16 *)ntb_ptr;
 	/* dwSignature */
 	if (get_unaligned_le32(tmp) != opts->nth_sign) {
 		 * walk through NDP
 		 * dwSignature
 		 */
-		tmp = (void *)(skb->data + ndp_index);
+		tmp = (__le16 *)(ntb_ptr + ndp_index);
 		if (get_unaligned_le32(tmp) != ncm->ndp_sign) {
 			INFO(port->func.config->cdev, "Wrong NDP SIGN\n");
 			goto err;
 			if (ncm->is_crc) {
 				uint32_t crc, crc2;
-				crc = get_unaligned_le32(skb->data +
+				crc = get_unaligned_le32(ntb_ptr +
 							 index + dg_len -
 							 crc_len);
 				crc2 = ~crc32_le(~0,
-						 skb->data + index,
+						 ntb_ptr + index,
 						 dg_len - crc_len);
 				if (crc != crc2) {
 					INFO(port->func.config->cdev,
 							 dg_len - crc_len);
 			if (skb2 == NULL)
 				goto err;
-			skb_put_data(skb2, skb->data + index,
+			skb_put_data(skb2, ntb_ptr + index,
 				     dg_len - crc_len);
 			skb_queue_tail(list, skb2);
 		} while (ndp_len > 2 * (opts->dgram_item_len * 2));
 	} while (ndp_index);
-	dev_consume_skb_any(skb);
 	VDBG(port->func.config->cdev,
 	     "Parsed NTB with %d frames\n", dgram_counter);
+	to_process -= block_len;
+	if (to_process != 0) {
+		ntb_ptr = (unsigned char *)(ntb_ptr + block_len);
+		goto parse_ntb;
+	}
+	dev_consume_skb_any(skb);
 	return 0;
 err:
 	skb_queue_purge(list);

drivers/usb/gadget/udc/udc-xilinx.c+12−8

 		/* Get the Buffer address and copy the transmit data.*/
 		eprambase = (u32 __force *)(udc->addr + ep->rambase);
 		if (ep->is_in) {
-			memcpy(eprambase, bufferptr, bytestosend);
+			memcpy_toio((void __iomem *)eprambase, bufferptr,
+				    bytestosend);
 			udc->write_fn(udc->addr, ep->offset +
 				      XUSB_EP_BUF0COUNT_OFFSET, bufferlen);
 		} else {
-			memcpy(bufferptr, eprambase, bytestosend);
+			memcpy_toio((void __iomem *)bufferptr, eprambase,
+				    bytestosend);
 		}
 		/*
 		 * Enable the buffer for transmission.
 		eprambase = (u32 __force *)(udc->addr + ep->rambase +
 			     ep->ep_usb.maxpacket);
 		if (ep->is_in) {
-			memcpy(eprambase, bufferptr, bytestosend);
+			memcpy_toio((void __iomem *)eprambase, bufferptr,
+				    bytestosend);
 			udc->write_fn(udc->addr, ep->offset +
 				      XUSB_EP_BUF1COUNT_OFFSET, bufferlen);
 		} else {
-			memcpy(bufferptr, eprambase, bytestosend);
+			memcpy_toio((void __iomem *)bufferptr, eprambase,
+				    bytestosend);
 		}
 		/*
 		 * Enable the buffer for transmission.
 			   udc->addr);
 		length = req->usb_req.actual = min_t(u32, length,
 						     EP0_MAX_PACKET);
-		memcpy(corebuf, req->usb_req.buf, length);
+		memcpy_toio((void __iomem *)corebuf, req->usb_req.buf, length);
 		udc->write_fn(udc->addr, XUSB_EP_BUF0COUNT_OFFSET, length);
 		udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET, 1);
 	} else {
 	/* Load up the chapter 9 command buffer.*/
 	ep0rambase = (u32 __force *) (udc->addr + XUSB_SETUP_PKT_ADDR_OFFSET);
-	memcpy(&setup, ep0rambase, 8);
+	memcpy_toio((void __iomem *)&setup, ep0rambase, 8);
 	udc->setup = setup;
 	udc->setup.wValue = cpu_to_le16((u16 __force)setup.wValue);
 			     (ep0->rambase << 2));
 		buffer = req->usb_req.buf + req->usb_req.actual;
 		req->usb_req.actual = req->usb_req.actual + bytes_to_rx;
-		memcpy(buffer, ep0rambase, bytes_to_rx);
+		memcpy_toio((void __iomem *)buffer, ep0rambase, bytes_to_rx);
 		if (req->usb_req.length == req->usb_req.actual) {
 			/* Data transfer completed get ready for Status stage */
 				     (ep0->rambase << 2));
 			buffer = req->usb_req.buf + req->usb_req.actual;
 			req->usb_req.actual = req->usb_req.actual + length;
-			memcpy(ep0rambase, buffer, length);
+			memcpy_toio((void __iomem *)ep0rambase, buffer, length);
 		}
 		udc->write_fn(udc->addr, XUSB_EP_BUF0COUNT_OFFSET, count);
 		udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET, 1);

drivers/usb/host/xhci-hub.c+10−9

 		*status |= USB_PORT_STAT_C_CONFIG_ERROR << 16;
 	/* USB3 specific wPortStatus bits */
-	if (portsc & PORT_POWER) {
+	if (portsc & PORT_POWER)
 		*status |= USB_SS_PORT_STAT_POWER;
-		/* link state handling */
-		if (link_state == XDEV_U0)
-			bus_state->suspended_ports &= ~(1 << portnum);
-	}
-	/* remote wake resume signaling complete */
+	/* no longer suspended or resuming */
-	if (bus_state->port_remote_wakeup & (1 << portnum) &&
+	if (link_state != XDEV_U3 &&
 	    link_state != XDEV_RESUME &&
 	    link_state != XDEV_RECOVERY) {
-		bus_state->port_remote_wakeup &= ~(1 << portnum);
+		/* remote wake resume signaling complete */
-		usb_hcd_end_port_resume(&hcd->self, portnum);
+		if (bus_state->port_remote_wakeup & (1 << portnum)) {
+			bus_state->port_remote_wakeup &= ~(1 << portnum);
+			usb_hcd_end_port_resume(&hcd->self, portnum);
+		}
+		bus_state->suspended_ports &= ~(1 << portnum);
 	}
 	xhci_hub_report_usb3_link_state(xhci, status, portsc);
 			usb_hcd_end_port_resume(&port->rhub->hcd->self, portnum);
 		}
 		port->rexit_active = 0;
+		bus_state->suspended_ports &= ~(1 << portnum);
 	}
 }

drivers/usb/host/xhci-mem.c+2−2

@@ -2285,8 +2285,8 @@ xhci_add_interrupter(struct xhci_hcd xhci, struct xhci_interrupter ir, · 2284 unmodified lines
2285	writel(erst_size, &ir->ir_set->erst_size);	2285	writel(erst_size, &ir->ir_set->erst_size);
2286		2286
2287	erst_base = xhci_read_64(xhci, &ir->ir_set->erst_base);	2287	erst_base = xhci_read_64(xhci, &ir->ir_set->erst_base);
2288	erst_base &= ERST_PTR_MASK;	2288	erst_base &= ERST_BASE_RSVDP;
2289	erst_base \|= (ir->erst.erst_dma_addr & (u64) ~ERST_PTR_MASK);	2289	erst_base \|= ir->erst.erst_dma_addr & ~ERST_BASE_RSVDP;
2290	xhci_write_64(xhci, erst_base, &ir->ir_set->erst_base);	2290	xhci_write_64(xhci, erst_base, &ir->ir_set->erst_base);
2291		2291
2292	/* Set the event ring dequeue address of this interrupter */	2292	/* Set the event ring dequeue address of this interrupter */

drivers/usb/host/xhci-ring.c+9−7

 static void xhci_unmap_td_bounce_buffer(struct xhci_hcd *xhci,
 		struct xhci_ring *ring, struct xhci_td *td)
 {
-	struct device *dev = xhci_to_hcd(xhci)->self.controller;
+	struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
 	struct xhci_segment *seg = td->bounce_seg;
 	struct urb *urb = td->urb;
 	size_t len;
  */
 static void xhci_update_erst_dequeue(struct xhci_hcd *xhci,
 				     struct xhci_interrupter *ir,
-				     union xhci_trb *event_ring_deq)
+				     union xhci_trb *event_ring_deq,
+				     bool clear_ehb)
 {
 	u64 temp_64;
 	dma_addr_t deq;
 			return;
 		/* Update HC event ring dequeue pointer */
-		temp_64 &= ERST_PTR_MASK;
+		temp_64 &= ERST_DESI_MASK;
 		temp_64 |= ((u64) deq & (u64) ~ERST_PTR_MASK);
 	}
 	/* Clear the event handler busy flag (RW1C) */
-	temp_64 |= ERST_EHB;
+	if (clear_ehb)
+		temp_64 |= ERST_EHB;
 	xhci_write_64(xhci, temp_64, &ir->ir_set->erst_dequeue);
 }
 	while (xhci_handle_event(xhci, ir) > 0) {
 		if (event_loop++ < TRBS_PER_SEGMENT / 2)
 			continue;
-		xhci_update_erst_dequeue(xhci, ir, event_ring_deq);
+		xhci_update_erst_dequeue(xhci, ir, event_ring_deq, false);
 		event_ring_deq = ir->event_ring->dequeue;
 		/* ring is half-full, force isoc trbs to interrupt more often */
 		event_loop = 0;
 	}
-	xhci_update_erst_dequeue(xhci, ir, event_ring_deq);
+	xhci_update_erst_dequeue(xhci, ir, event_ring_deq, true);
 	ret = IRQ_HANDLED;
 out:
 static int xhci_align_td(struct xhci_hcd *xhci, struct urb *urb, u32 enqd_len,
 			 u32 *trb_buff_len, struct xhci_segment *seg)
 {
-	struct device *dev = xhci_to_hcd(xhci)->self.controller;
+	struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
 	unsigned int unalign;
 	unsigned int max_pkt;
 	u32 new_buff_len;

drivers/usb/host/xhci.h+1−1

@@ -514,7 +514,7 @@ struct xhci_intr_reg { · 513 unmodified lines
514	#define ERST_SIZE_MASK (0xffff << 16)	514	#define ERST_SIZE_MASK (0xffff << 16)
515		515
516	/* erst_base bitmasks */	516	/* erst_base bitmasks */
517	#define ERST_BASE_RSVDP (0x3f)	517	#define ERST_BASE_RSVDP (GENMASK_ULL(5, 0))
518		518
519	/* erst_dequeue bitmasks */	519	/* erst_dequeue bitmasks */
520	/* Dequeue ERST Segment Index (DESI) - Segment number (or alias)	520	/* Dequeue ERST Segment Index (DESI) - Segment number (or alias)

drivers/usb/misc/onboard_usb_hub.c+1−0

@@ -434,6 +434,7 @@ static const struct usb_device_id onboard_hub_id_table[] = { · 433 unmodified lines
434	{ USB_DEVICE(VENDOR_ID_GENESYS, 0x0608) }, /* Genesys Logic GL850G USB 2.0 */	434	{ USB_DEVICE(VENDOR_ID_GENESYS, 0x0608) }, /* Genesys Logic GL850G USB 2.0 */
435	{ USB_DEVICE(VENDOR_ID_GENESYS, 0x0610) }, /* Genesys Logic GL852G USB 2.0 */	435	{ USB_DEVICE(VENDOR_ID_GENESYS, 0x0610) }, /* Genesys Logic GL852G USB 2.0 */
436	{ USB_DEVICE(VENDOR_ID_GENESYS, 0x0620) }, /* Genesys Logic GL3523 USB 3.1 */	436	{ USB_DEVICE(VENDOR_ID_GENESYS, 0x0620) }, /* Genesys Logic GL3523 USB 3.1 */
		437	{ USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2412) }, /* USB2412 USB 2.0 */
437	{ USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2514) }, /* USB2514B USB 2.0 */	438	{ USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2514) }, /* USB2514B USB 2.0 */
438	{ USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2517) }, /* USB2517 USB 2.0 */	439	{ USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2517) }, /* USB2517 USB 2.0 */
439	{ USB_DEVICE(VENDOR_ID_REALTEK, 0x0411) }, /* RTS5411 USB 3.1 */	440	{ USB_DEVICE(VENDOR_ID_REALTEK, 0x0411) }, /* RTS5411 USB 3.1 */

drivers/usb/misc/onboard_usb_hub.h+1−0

@@ -47,6 +47,7 @@ static const struct onboard_hub_pdata vialab_vl817_data = { · 46 unmodified lines
47	};	47	};
48		48
49	static const struct of_device_id onboard_hub_match[] = {	49	static const struct of_device_id onboard_hub_match[] = {
		50	{ .compatible = "usb424,2412", .data = &microchip_usb424_data, },
50	{ .compatible = "usb424,2514", .data = &microchip_usb424_data, },	51	{ .compatible = "usb424,2514", .data = &microchip_usb424_data, },
51	{ .compatible = "usb424,2517", .data = &microchip_usb424_data, },	52	{ .compatible = "usb424,2517", .data = &microchip_usb424_data, },
52	{ .compatible = "usb451,8140", .data = &ti_tusb8041_data, },	53	{ .compatible = "usb451,8140", .data = &ti_tusb8041_data, },

drivers/usb/musb/musb_debugfs.c+1−1

@@ -39,7 +39,7 @@ static const struct musb_register_map musb_regmap[] = { · 38 unmodified lines
39	{ "IntrUsbE", MUSB_INTRUSBE, 8 },	39	{ "IntrUsbE", MUSB_INTRUSBE, 8 },
40	{ "DevCtl", MUSB_DEVCTL, 8 },	40	{ "DevCtl", MUSB_DEVCTL, 8 },
41	{ "VControl", 0x68, 32 },	41	{ "VControl", 0x68, 32 },
42	{ "HWVers", 0x69, 16 },	42	{ "HWVers", MUSB_HWVERS, 16 },
43	{ "LinkInfo", MUSB_LINKINFO, 8 },	43	{ "LinkInfo", MUSB_LINKINFO, 8 },
44	{ "VPLen", MUSB_VPLEN, 8 },	44	{ "VPLen", MUSB_VPLEN, 8 },
45	{ "HS_EOF1", MUSB_HS_EOF1, 8 },	45	{ "HS_EOF1", MUSB_HS_EOF1, 8 },

drivers/usb/musb/musb_host.c+8−1

 	musb_giveback(musb, urb, status);
 	qh->is_ready = ready;
+	/*
+	 * musb->lock had been unlocked in musb_giveback, so qh may
+	 * be freed, need to get it again
+	 */
+	qh = musb_ep_get_qh(hw_ep, is_in);
 	/* reclaim resources (and bandwidth) ASAP; deschedule it, and
 	 * invalidate qh as soon as list_empty(&hep->urb_list)
 	 */
-	if (list_empty(&qh->hep->urb_list)) {
+	if (qh && list_empty(&qh->hep->urb_list)) {
 		struct list_head	*head;
 		struct dma_controller	*dma = musb->dma_controller;
 		 * and its URB list has emptied, recycle this qh.
 		 */
 		if (ready && list_empty(&qh->hep->urb_list)) {
+			musb_ep_set_qh(qh->hw_ep, is_in, NULL);
 			qh->hep->hcpriv = NULL;
 			list_del(&qh->ring);
 			kfree(qh);

drivers/usb/typec/altmodes/displayport.c+5−0

 			typec_altmode_update_active(alt, false);
 			dp->data.status = 0;
 			dp->data.conf = 0;
+			if (dp->hpd) {
+				drm_connector_oob_hotplug_event(dp->connector_fwnode);
+				dp->hpd = false;
+				sysfs_notify(&dp->alt->dev.kobj, "displayport", "hpd");
+			}
 			break;
 		case DP_CMD_STATUS_UPDATE:
 			dp->data.status = *vdo;

drivers/usb/typec/tcpm/qcom/qcom_pmic_typec_pdphy.c+6−6

 	struct device *dev = pmic_typec_pdphy->dev;
 	int ret;
-	ret = regulator_enable(pmic_typec_pdphy->vdd_pdphy);
-	if (ret)
-		return ret;
 	/* PD 2.0, DR=TYPEC_DEVICE, PR=TYPEC_SINK */
 	ret = regmap_update_bits(pmic_typec_pdphy->regmap,
 				 pmic_typec_pdphy->base + USB_PDPHY_MSG_CONFIG_REG,
 	ret = regmap_write(pmic_typec_pdphy->regmap,
 			   pmic_typec_pdphy->base + USB_PDPHY_EN_CONTROL_REG, 0);
-	regulator_disable(pmic_typec_pdphy->vdd_pdphy);
 	return ret;
 }
 	int i;
 	int ret;
+	ret = regulator_enable(pmic_typec_pdphy->vdd_pdphy);
+	if (ret)
+		return ret;
 	pmic_typec_pdphy->tcpm_port = tcpm_port;
 	ret = pmic_typec_pdphy_reset(pmic_typec_pdphy);
 		disable_irq(pmic_typec_pdphy->irq_data[i].irq);
 	qcom_pmic_typec_pdphy_reset_on(pmic_typec_pdphy);
+	regulator_disable(pmic_typec_pdphy->vdd_pdphy);
 }
 struct pmic_typec_pdphy *qcom_pmic_typec_pdphy_alloc(struct device *dev)

drivers/usb/typec/ucsi/psy.c+9−0

@@ -37,6 +37,15 @@ static int ucsi_psy_get_scope(struct ucsi_connector *con, · 36 unmodified lines
37	struct device *dev = con->ucsi->dev;	37	struct device *dev = con->ucsi->dev;
38		38
39	device_property_read_u8(dev, "scope", &scope);	39	device_property_read_u8(dev, "scope", &scope);
		40	if (scope == POWER_SUPPLY_SCOPE_UNKNOWN) {
		41	u32 mask = UCSI_CAP_ATTR_POWER_AC_SUPPLY \|
		42	UCSI_CAP_ATTR_BATTERY_CHARGING;
		43
		44	if (con->ucsi->cap.attributes & mask)
		45	scope = POWER_SUPPLY_SCOPE_SYSTEM;
		46	else
		47	scope = POWER_SUPPLY_SCOPE_DEVICE;
		48	}
40	val->intval = scope;	49	val->intval = scope;
41	return 0;	50	return 0;
42	}	51	}

drivers/usb/typec/ucsi/ucsi.c+2−0

 	typec_set_mode(con->port, TYPEC_STATE_SAFE);
+	typec_partner_set_usb_power_delivery(con->partner, NULL);
 	ucsi_unregister_partner_pdos(con);
 	ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP);
 	typec_unregister_partner(con->partner);
 	if (ret < 0) {
 		dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
 			__func__, ret);
+		clear_bit(EVENT_PENDING, &con->ucsi->flags);
 		goto out_unlock;
 	}

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/xen/events/events_base.c+46−41

 #include <linux/slab.h>
 #include <linux/irqnr.h>
 #include <linux/pci.h>
+#include <linux/rcupdate.h>
 #include <linux/spinlock.h>
 #include <linux/cpuhotplug.h>
 #include <linux/atomic.h>
 struct irq_info {
 	struct list_head list;
 	struct list_head eoi_list;
+	struct rcu_work rwork;
 	short refcnt;
 	u8 spurious_cnt;
 	u8 is_accounted;
  */
 static DEFINE_MUTEX(irq_mapping_update_lock);
-/*
- * Lock protecting event handling loop against removing event channels.
- * Adding of event channels is no issue as the associated IRQ becomes active
- * only after everything is setup (before request_[threaded_]irq() the handler
- * can't be entered for an event, as the event channel will be unmasked only
- * then).
- */
-static DEFINE_RWLOCK(evtchn_rwlock);
 /*
  * Lock hierarchy:
  *
  * irq_mapping_update_lock
- *   evtchn_rwlock
+ *   IRQ-desc lock
- *     IRQ-desc lock
+ *     percpu eoi_list_lock
- *       percpu eoi_list_lock
+ *       irq_info->lock
- *         irq_info->lock
  */
 static LIST_HEAD(xen_irq_list_head);
 	info->is_accounted = 1;
 }
+static void delayed_free_irq(struct work_struct *work)
+{
+	struct irq_info *info = container_of(to_rcu_work(work), struct irq_info,
+					     rwork);
+	unsigned int irq = info->irq;
+	/* Remove the info pointer only now, with no potential users left. */
+	set_info_for_irq(irq, NULL);
+	kfree(info);
+	/* Legacy IRQ descriptors are managed by the arch. */
+	if (irq >= nr_legacy_irqs())
+		irq_free_desc(irq);
+}
 /* Constructors for packed IRQ information. */
 static int xen_irq_info_common_setup(struct irq_info *info,
 				     unsigned irq,
 	eoi = container_of(to_delayed_work(work), struct lateeoi_work, delayed);
-	read_lock_irqsave(&evtchn_rwlock, flags);
+	rcu_read_lock();
 	while (true) {
-		spin_lock(&eoi->eoi_list_lock);
+		spin_lock_irqsave(&eoi->eoi_list_lock, flags);
 		info = list_first_entry_or_null(&eoi->eoi_list, struct irq_info,
 						eoi_list);
-		if (info == NULL || now < info->eoi_time) {
+		if (info == NULL)
-			spin_unlock(&eoi->eoi_list_lock);
+			break;
+		if (now < info->eoi_time) {
+			mod_delayed_work_on(info->eoi_cpu, system_wq,
+					    &eoi->delayed,
+					    info->eoi_time - now);
 			break;
 		}
 		list_del_init(&info->eoi_list);
-		spin_unlock(&eoi->eoi_list_lock);
+		spin_unlock_irqrestore(&eoi->eoi_list_lock, flags);
 		info->eoi_time = 0;
 		xen_irq_lateeoi_locked(info, false);
 	}
-	if (info)
+	spin_unlock_irqrestore(&eoi->eoi_list_lock, flags);
-		mod_delayed_work_on(info->eoi_cpu, system_wq,
-				    &eoi->delayed, info->eoi_time - now);
-	read_unlock_irqrestore(&evtchn_rwlock, flags);
+	rcu_read_unlock();
 }
 static void xen_cpu_init_eoi(unsigned int cpu)
 void xen_irq_lateeoi(unsigned int irq, unsigned int eoi_flags)
 {
 	struct irq_info *info;
-	unsigned long flags;
-	read_lock_irqsave(&evtchn_rwlock, flags);
+	rcu_read_lock();
 	info = info_for_irq(irq);
 	if (info)
 		xen_irq_lateeoi_locked(info, eoi_flags & XEN_EOI_FLAG_SPURIOUS);
-	read_unlock_irqrestore(&evtchn_rwlock, flags);
+	rcu_read_unlock();
 }
 EXPORT_SYMBOL_GPL(xen_irq_lateeoi);
 	info->type = IRQT_UNBOUND;
 	info->refcnt = -1;
+	INIT_RCU_WORK(&info->rwork, delayed_free_irq);
 	set_info_for_irq(irq, info);
 	/*
 static void xen_free_irq(unsigned irq)
 {
 	struct irq_info *info = info_for_irq(irq);
-	unsigned long flags;
 	if (WARN_ON(!info))
 		return;
-	write_lock_irqsave(&evtchn_rwlock, flags);
 	if (!list_empty(&info->eoi_list))
 		lateeoi_list_del(info);
 	list_del(&info->list);
-	set_info_for_irq(irq, NULL);
 	WARN_ON(info->refcnt > 0);
-	write_unlock_irqrestore(&evtchn_rwlock, flags);
+	queue_rcu_work(system_wq, &info->rwork);
-	kfree(info);
-	/* Legacy IRQ descriptors are managed by the arch. */
-	if (irq < nr_legacy_irqs())
-		return;
-	irq_free_desc(irq);
 }
 /* Not called for lateeoi events. */
 	int cpu = smp_processor_id();
 	struct evtchn_loop_ctrl ctrl = { 0 };
-	read_lock(&evtchn_rwlock);
+	/*
+	 * When closing an event channel the associated IRQ must not be freed
+	 * until all cpus have left the event handling loop. This is ensured
+	 * by taking the rcu_read_lock() while handling events, as freeing of
+	 * the IRQ is handled via queue_rcu_work() _after_ closing the event
+	 * channel.
+	 */
+	rcu_read_lock();
 	do {
 		vcpu_info->evtchn_upcall_pending = 0;
 	} while (vcpu_info->evtchn_upcall_pending);
-	read_unlock(&evtchn_rwlock);
+	rcu_read_unlock();
 	/*
 	 * Increment irq_epoch only now to defer EOIs only for

fs/btrfs/ctree.c+39−13

@@ -682,18 +682,30 @@ noinline int btrfs_cow_block(struct btrfs_trans_handle *trans, · 681 unmodified lines
682	u64 search_start;	682	u64 search_start;
683	int ret;	683	int ret;
684		684
685	if (test_bit(BTRFS_ROOT_DELETING, &root->state))	685	if (unlikely(test_bit(BTRFS_ROOT_DELETING, &root->state))) {
686	btrfs_err(fs_info,	686	btrfs_abort_transaction(trans, -EUCLEAN);
687	"COW'ing blocks on a fs root that's being dropped");	687	btrfs_crit(fs_info,
688		688	"attempt to COW block %llu on root %llu that is being deleted",
689	if (trans->transaction != fs_info->running_transaction)	689	buf->start, btrfs_root_id(root));
690	WARN(1, KERN_CRIT "trans %llu running %llu\n",	690	return -EUCLEAN;
691	trans->transid,	691	}
692	fs_info->running_transaction->transid);
693		692
694	if (trans->transid != fs_info->generation)	693	/*
695	WARN(1, KERN_CRIT "trans %llu running %llu\n",	694	* COWing must happen through a running transaction, which always
696	trans->transid, fs_info->generation);	695	* matches the current fs generation (it's a transaction with a state
		696	* less than TRANS_STATE_UNBLOCKED). If it doesn't, then turn the fs
		697	* into error state to prevent the commit of any transaction.
		698	*/
		699	if (unlikely(trans->transaction != fs_info->running_transaction \|\|
		700	trans->transid != fs_info->generation)) {
		701	btrfs_abort_transaction(trans, -EUCLEAN);
		702	btrfs_crit(fs_info,
		703	"unexpected transaction when attempting to COW block %llu on root %llu, transaction %llu running transaction %llu fs generation %llu",
		704	buf->start, btrfs_root_id(root), trans->transid,
		705	fs_info->running_transaction->transid,
		706	fs_info->generation);
		707	return -EUCLEAN;
		708	}
697		709
698	if (!should_cow_block(trans, root, buf)) {	710	if (!should_cow_block(trans, root, buf)) {
699	*cow_ret = buf;	711	*cow_ret = buf;
@@ -805,8 +817,22 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, · 105 unmodified lines
805	int progress_passed = 0;	817	int progress_passed = 0;
806	struct btrfs_disk_key disk_key;	818	struct btrfs_disk_key disk_key;
807		819
808	WARN_ON(trans->transaction != fs_info->running_transaction);	820	/*
809	WARN_ON(trans->transid != fs_info->generation);	821	* COWing must happen through a running transaction, which always
		822	* matches the current fs generation (it's a transaction with a state
		823	* less than TRANS_STATE_UNBLOCKED). If it doesn't, then turn the fs
		824	* into error state to prevent the commit of any transaction.
		825	*/
		826	if (unlikely(trans->transaction != fs_info->running_transaction \|\|
		827	trans->transid != fs_info->generation)) {
		828	btrfs_abort_transaction(trans, -EUCLEAN);
		829	btrfs_crit(fs_info,
		830	"unexpected transaction when attempting to reallocate parent %llu for root %llu, transaction %llu running transaction %llu fs generation %llu",
		831	parent->start, btrfs_root_id(root), trans->transid,
		832	fs_info->running_transaction->transid,
		833	fs_info->generation);
		834	return -EUCLEAN;
		835	}
810		836
811	parent_nritems = btrfs_header_nritems(parent);	837	parent_nritems = btrfs_header_nritems(parent);
812	blocksize = fs_info->nodesize;	838	blocksize = fs_info->nodesize;

fs/btrfs/delayed-inode.c+1−1

@@ -313,7 +313,7 @@ static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u16 data_len, · 312 unmodified lines
313	{	313	{
314	struct btrfs_delayed_item *item;	314	struct btrfs_delayed_item *item;
315		315
316	item = kmalloc(sizeof(*item) + data_len, GFP_NOFS);	316	item = kmalloc(struct_size(item, data, data_len), GFP_NOFS);
317	if (item) {	317	if (item) {
318	item->data_len = data_len;	318	item->data_len = data_len;
319	item->type = type;	319	item->type = type;

fs/btrfs/delayed-inode.h+1−1

@@ -95,7 +95,7 @@ struct btrfs_delayed_item { · 94 unmodified lines
95	bool logged;	95	bool logged;
96	/* The maximum leaf size is 64K, so u16 is more than enough. */	96	/* The maximum leaf size is 64K, so u16 is more than enough. */
97	u16 data_len;	97	u16 data_len;
98	char data[];	98	char data[] __counted_by(data_len);
99	};	99	};
100		100
101	static inline void btrfs_init_delayed_root(	101	static inline void btrfs_init_delayed_root(

fs/btrfs/ioctl.c+2−2

@@ -2978,7 +2978,7 @@ static void get_block_group_info(struct list_head *groups_list, · 2977 unmodified lines
2978	static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info,	2978	static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info,
2979	void __user *arg)	2979	void __user *arg)
2980	{	2980	{
2981	struct btrfs_ioctl_space_args space_args;	2981	struct btrfs_ioctl_space_args space_args = { 0 };
2982	struct btrfs_ioctl_space_info space;	2982	struct btrfs_ioctl_space_info space;
2983	struct btrfs_ioctl_space_info *dest;	2983	struct btrfs_ioctl_space_info *dest;
2984	struct btrfs_ioctl_space_info *dest_orig;	2984	struct btrfs_ioctl_space_info *dest_orig;
@@ -4338,7 +4338,7 @@ static int _btrfs_ioctl_send(struct inode inode, void __user argp, bool compat · 1353 unmodified lines
4338		4338
4339	if (compat) {	4339	if (compat) {
4340	#if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)	4340	#if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
4341	struct btrfs_ioctl_send_args_32 args32;	4341	struct btrfs_ioctl_send_args_32 args32 = { 0 };
4342		4342
4343	ret = copy_from_user(&args32, argp, sizeof(args32));	4343	ret = copy_from_user(&args32, argp, sizeof(args32));
4344	if (ret)	4344	if (ret)

fs/btrfs/transaction.h+2−2

@@ -219,8 +219,8 @@ do { \ · 218 unmodified lines
219	(errno))) { \	219	(errno))) { \
220	/* Stack trace printed. */ \	220	/* Stack trace printed. */ \
221	} else { \	221	} else { \
222	btrfs_debug((trans)->fs_info, \	222	btrfs_err((trans)->fs_info, \
223	"Transaction aborted (error %d)", \	223	"Transaction aborted (error %d)", \
224	(errno)); \	224	(errno)); \
225	} \	225	} \
226	} \	226	} \

fs/ceph/crypto.c+1−1

@@ -460,7 +460,7 @@ int ceph_fname_to_usr(const struct ceph_fname fname, struct fscrypt_str tname, · 459 unmodified lines
460	out:	460	out:
461	fscrypt_fname_free_buffer(&_tname);	461	fscrypt_fname_free_buffer(&_tname);
462	out_inode:	462	out_inode:
463	if ((dir != fname->dir) && !IS_ERR(dir)) {	463	if (dir != fname->dir) {
464	if ((dir->i_state & I_NEW))	464	if ((dir->i_state & I_NEW))
465	discard_new_inode(dir);	465	discard_new_inode(dir);
466	else	466	else

fs/ceph/file.c+1−1

@@ -2969,7 +2969,7 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, · 2968 unmodified lines
2969	ret = do_splice_direct(src_file, &src_off, dst_file,	2969	ret = do_splice_direct(src_file, &src_off, dst_file,
2970	&dst_off, src_objlen, flags);	2970	&dst_off, src_objlen, flags);
2971	/* Abort on short copies or on error */	2971	/* Abort on short copies or on error */
2972	if (ret < src_objlen) {	2972	if (ret < (long)src_objlen) {
2973	dout("Failed partial copy (%zd)\n", ret);	2973	dout("Failed partial copy (%zd)\n", ret);
2974	goto out;	2974	goto out;
2975	}	2975	}

fs/ceph/inode.c+1−3

 			ci->i_truncate_seq = truncate_seq;
 			/* the MDS should have revoked these caps */
-			WARN_ON_ONCE(issued & (CEPH_CAP_FILE_EXCL |
+			WARN_ON_ONCE(issued & (CEPH_CAP_FILE_RD |
-					       CEPH_CAP_FILE_RD |
-					       CEPH_CAP_FILE_WR |
 					       CEPH_CAP_FILE_LAZYIO));
 			/*
 			 * If we hold relevant caps, or in the case where we're

fs/erofs/decompressor_lzma.c+4−1

 			strm->buf.out_size = min_t(u32, outlen,
 						   PAGE_SIZE - pageofs);
 			outlen -= strm->buf.out_size;
-			if (!rq->out[no] && rq->fillgaps)	/* deduped */
+			if (!rq->out[no] && rq->fillgaps) {	/* deduped */
 				rq->out[no] = erofs_allocpage(pagepool,
 						GFP_KERNEL | __GFP_NOFAIL);
+				set_page_private(rq->out[no],
+						 Z_EROFS_SHORTLIVED_PAGE);
+			}
 			if (rq->out[no])
 				strm->buf.out = kmap(rq->out[no]) + pageofs;
 			pageofs = 0;

fs/erofs/super.c+1−1

@@ -235,7 +235,7 @@ static int erofs_init_device(struct erofs_buf buf, struct super_block sb, · 234 unmodified lines
235	return PTR_ERR(ptr);	235	return PTR_ERR(ptr);
236	dis = ptr + erofs_blkoff(sb, *pos);	236	dis = ptr + erofs_blkoff(sb, *pos);
237		237
238	if (!dif->path) {	238	if (!sbi->devs->flatdev && !dif->path) {
239	if (!dis->tag[0]) {	239	if (!dis->tag[0]) {
240	erofs_err(sb, "empty device tag @ pos %llu", *pos);	240	erofs_err(sb, "empty device tag @ pos %llu", *pos);
241	return -EINVAL;	241	return -EINVAL;

fs/fs_context.c+29−5

 EXPORT_SYMBOL(vfs_parse_fs_string);
 /**
- * generic_parse_monolithic - Parse key[=val][,key[=val]]* mount data
+ * vfs_parse_monolithic_sep - Parse key[=val][,key[=val]]* mount data
  * @fc: The superblock configuration to fill in.
  * @data: The data to parse
+ * @sep: callback for separating next option
  *
- * Parse a blob of data that's in key[=val][,key[=val]]* form.  This can be
+ * Parse a blob of data that's in key[=val][,key[=val]]* form with a custom
- * called from the ->monolithic_mount_data() fs_context operation.
+ * option separator callback.
  *
  * Returns 0 on success or the error returned by the ->parse_option() fs_context
  * operation on failure.
  */
-int generic_parse_monolithic(struct fs_context *fc, void *data)
+int vfs_parse_monolithic_sep(struct fs_context *fc, void *data,
+			     char *(*sep)(char **))
 {
 	char *options = data, *key;
 	int ret = 0;
 	if (ret)
 		return ret;
-	while ((key = strsep(&options, ",")) != NULL) {
+	while ((key = sep(&options)) != NULL) {
 		if (*key) {
 			size_t v_len = 0;
 			char *value = strchr(key, '=');
 	return ret;
 }
+EXPORT_SYMBOL(vfs_parse_monolithic_sep);
+static char *vfs_parse_comma_sep(char **s)
+{
+	return strsep(s, ",");
+}
+/**
+ * generic_parse_monolithic - Parse key[=val][,key[=val]]* mount data
+ * @fc: The superblock configuration to fill in.
+ * @data: The data to parse
+ *
+ * Parse a blob of data that's in key[=val][,key[=val]]* form.  This can be
+ * called from the ->monolithic_mount_data() fs_context operation.
+ *
+ * Returns 0 on success or the error returned by the ->parse_option() fs_context
+ * operation on failure.
+ */
+int generic_parse_monolithic(struct fs_context *fc, void *data)
+{
+	return vfs_parse_monolithic_sep(fc, data, vfs_parse_comma_sep);
+}
 EXPORT_SYMBOL(generic_parse_monolithic);
 /**

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/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+0−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 (!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+59−67

@@ -157,6 +157,34 @@ const struct fs_parameter_spec ovl_parameter_spec[] = { · 156 unmodified lines
157	{}	157	{}
158	};	158	};
159		159
		160	static char ovl_next_opt(char *s)
		161	{
		162	char sbegin = s;
		163	char *p;
		164
		165	if (sbegin == NULL)
		166	return NULL;
		167
		168	for (p = sbegin; *p; p++) {
		169	if (*p == '\\') {
		170	p++;
		171	if (!*p)
		172	break;
		173	} else if (*p == ',') {
		174	*p = '\0';
		175	*s = p + 1;
		176	return sbegin;
		177	}
		178	}
		179	*s = NULL;
		180	return sbegin;
		181	}
		182
		183	static int ovl_parse_monolithic(struct fs_context fc, void data)
		184	{
		185	return vfs_parse_monolithic_sep(fc, data, ovl_next_opt);
		186	}
		187
160	static ssize_t ovl_parse_param_split_lowerdirs(char *str)	188	static ssize_t ovl_parse_param_split_lowerdirs(char *str)
161	{	189	{
162	ssize_t nr_layers = 1, nr_colons = 0;	190	ssize_t nr_layers = 1, nr_colons = 0;
@@ -164,7 +192,8 @@ static ssize_t ovl_parse_param_split_lowerdirs(char *str) · 1 unmodified line
164		192
165	for (s = d = str;; s++, d++) {	193	for (s = d = str;; s++, d++) {
166	if (*s == '\\') {	194	if (*s == '\\') {
167	s++;	195	/* keep esc chars in split lowerdir */
		196	d++ = s++;
168	} else if (*s == ':') {	197	} else if (*s == ':') {
169	bool next_colon = (*(s + 1) == ':');	198	bool next_colon = (*(s + 1) == ':');
170		199
@@ -239,7 +268,7 @@ static void ovl_unescape(char *s) · 68 unmodified lines
239	}	268	}
240	}	269	}
241		270
242	static int ovl_mount_dir(const char name, struct path path)	271	static int ovl_mount_dir(const char name, struct path path, bool upper)
243	{	272	{
244	int err = -ENOMEM;	273	int err = -ENOMEM;
245	char *tmp = kstrdup(name, GFP_KERNEL);	274	char *tmp = kstrdup(name, GFP_KERNEL);
@@ -248,7 +277,7 @@ static int ovl_mount_dir(const char name, struct path path) · 2 unmodified lines
248	ovl_unescape(tmp);	277	ovl_unescape(tmp);
249	err = ovl_mount_dir_noesc(tmp, path);	278	err = ovl_mount_dir_noesc(tmp, path);
250		279
251	if (!err && path->dentry->d_flags & DCACHE_OP_REAL) {	280	if (!err && upper && path->dentry->d_flags & DCACHE_OP_REAL) {
252	pr_err("filesystem on '%s' not supported as upperdir\n",	281	pr_err("filesystem on '%s' not supported as upperdir\n",
253	tmp);	282	tmp);
254	path_put_init(path);	283	path_put_init(path);
@@ -269,7 +298,7 @@ static int ovl_parse_param_upperdir(const char name, struct fs_context fc, · 14 unmodified lines
269	struct path path;	298	struct path path;
270	char *dup;	299	char *dup;
271		300
272	err = ovl_mount_dir(name, &path);	301	err = ovl_mount_dir(name, &path, true);
273	if (err)	302	if (err)
274	return err;	303	return err;
275		304
@@ -321,12 +350,6 @@ static void ovl_parse_param_drop_lowerdir(struct ovl_fs_context *ctx) · 45 unmodified lines
321	* Set "/lower1", "/lower2", and "/lower3" as lower layers and	350	* Set "/lower1", "/lower2", and "/lower3" as lower layers and
322	* "/data1" and "/data2" as data lower layers. Any existing lower	351	* "/data1" and "/data2" as data lower layers. Any existing lower
323	* layers are replaced.	352	* layers are replaced.
324	* (2) lowerdir=:/lower4
325	* Append "/lower4" to current stack of lower layers. This requires
326	* that there already is at least one lower layer configured.
327	* (3) lowerdir=::/lower5
328	* Append data "/lower5" as data lower layer. This requires that
329	* there's at least one regular lower layer present.
330	*/	353	*/
331	static int ovl_parse_param_lowerdir(const char name, struct fs_context fc)	354	static int ovl_parse_param_lowerdir(const char name, struct fs_context fc)
332	{	355	{
@@ -348,49 +371,9 @@ static int ovl_parse_param_lowerdir(const char name, struct fs_context fc) · 15 unmodified lines
348	return 0;	371	return 0;
349	}	372	}
350		373
351	if (strncmp(name, "::", 2) == 0) {	374	if (*name == ':') {
352	/*	375	pr_err("cannot append lower layer");
353	* This is a data layer.	376	return -EINVAL;
354	* There must be at least one regular lower layer
355	* specified.
356	*/
357	if (ctx->nr == 0) {
358	pr_err("data lower layers without regular lower layers not allowed");
359	return -EINVAL;
360	}
361
362	/* Skip the leading "::". */
363	name += 2;
364	data_layer = true;
365	/*
366	* A data layer is automatically an append as there
367	* must've been at least one regular lower layer.
368	*/
369	append = true;
370	} else if (*name == ':') {
371	/*
372	* This is a regular lower layer.
373	* If users want to append a layer enforce that they
374	* have already specified a first layer before. It's
375	* better to be strict.
376	*/
377	if (ctx->nr == 0) {
378	pr_err("cannot append layer if no previous layer has been specified");
379	return -EINVAL;
380	}
381
382	/*
383	* Once a sequence of data layers has started regular
384	* lower layers are forbidden.
385	*/
386	if (ctx->nr_data > 0) {
387	pr_err("regular lower layers cannot follow data lower layers");
388	return -EINVAL;
389	}
390
391	/* Skip the leading ":". */
392	name++;
393	append = true;
394	}	377	}
395		378
396	dup = kstrdup(name, GFP_KERNEL);	379	dup = kstrdup(name, GFP_KERNEL);
@@ -472,7 +455,7 @@ static int ovl_parse_param_lowerdir(const char name, struct fs_context fc) · 75 unmodified lines
472	l = &ctx->lower[nr];	455	l = &ctx->lower[nr];
473	memset(l, 0, sizeof(*l));	456	memset(l, 0, sizeof(*l));
474		457
475	err = ovl_mount_dir_noesc(dup_iter, &l->path);	458	err = ovl_mount_dir(dup_iter, &l->path, false);
476	if (err)	459	if (err)
477	goto out_put;	460	goto out_put;
478		461
@@ -682,6 +665,7 @@ static int ovl_reconfigure(struct fs_context *fc) · 203 unmodified lines
682	}	665	}
683		666
684	static const struct fs_context_operations ovl_context_ops = {	667	static const struct fs_context_operations ovl_context_ops = {
		668	.parse_monolithic = ovl_parse_monolithic,
685	.parse_param = ovl_parse_param,	669	.parse_param = ovl_parse_param,
686	.get_tree = ovl_get_tree,	670	.get_tree = ovl_get_tree,
687	.reconfigure = ovl_reconfigure,	671	.reconfigure = ovl_reconfigure,
@@ -752,12 +736,12 @@ void ovl_free_fs(struct ovl_fs *ofs) · 64 unmodified lines
752	if (ofs->upperdir_locked)	736	if (ofs->upperdir_locked)
753	ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root);	737	ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root);
754		738
755	/* Hack! Reuse ofs->layers as a vfsmount array before freeing it */	739	/* Reuse ofs->config.lowerdirs as a vfsmount array before freeing it */
756	mounts = (struct vfsmount **) ofs->layers;	740	mounts = (struct vfsmount **) ofs->config.lowerdirs;
757	for (i = 0; i < ofs->numlayer; i++) {	741	for (i = 0; i < ofs->numlayer; i++) {
758	iput(ofs->layers[i].trap);	742	iput(ofs->layers[i].trap);
		743	kfree(ofs->config.lowerdirs[i]);
759	mounts[i] = ofs->layers[i].mnt;	744	mounts[i] = ofs->layers[i].mnt;
760	kfree(ofs->layers[i].name);
761	}	745	}
762	kern_unmount_array(mounts, ofs->numlayer);	746	kern_unmount_array(mounts, ofs->numlayer);
763	kfree(ofs->layers);	747	kfree(ofs->layers);
@@ -765,6 +749,7 @@ void ovl_free_fs(struct ovl_fs *ofs) · 1 unmodified line
765	free_anon_bdev(ofs->fs[i].pseudo_dev);	749	free_anon_bdev(ofs->fs[i].pseudo_dev);
766	kfree(ofs->fs);	750	kfree(ofs->fs);
767		751
		752	kfree(ofs->config.lowerdirs);
768	kfree(ofs->config.upperdir);	753	kfree(ofs->config.upperdir);
769	kfree(ofs->config.workdir);	754	kfree(ofs->config.workdir);
770	if (ofs->creator_cred)	755	if (ofs->creator_cred)
@@ -949,16 +934,23 @@ int ovl_show_options(struct seq_file m, struct dentry dentry) · 178 unmodified lines
949	struct super_block *sb = dentry->d_sb;	934	struct super_block *sb = dentry->d_sb;
950	struct ovl_fs *ofs = OVL_FS(sb);	935	struct ovl_fs *ofs = OVL_FS(sb);
951	size_t nr, nr_merged_lower = ofs->numlayer - ofs->numdatalayer;	936	size_t nr, nr_merged_lower = ofs->numlayer - ofs->numdatalayer;
952	const struct ovl_layer *data_layers = &ofs->layers[nr_merged_lower];	937
953		938	/*
954	/* ofs->layers[0] is the upper layer */	939	* lowerdirs[] starts from offset 1, then
955	seq_printf(m, ",lowerdir=%s", ofs->layers[1].name);	940	* >= 0 regular lower layers prefixed with : and
956	/* dump regular lower layers */	941	* >= 0 data-only lower layers prefixed with ::
957	for (nr = 2; nr < nr_merged_lower; nr++)	942	*
958	seq_printf(m, ":%s", ofs->layers[nr].name);	943	* we need to escase comma and space like seq_show_option() does and
959	/* dump data lower layers */	944	* we also need to escape the colon separator from lowerdir paths.
960	for (nr = 0; nr < ofs->numdatalayer; nr++)	945	*/
961	seq_printf(m, "::%s", data_layers[nr].name);	946	seq_puts(m, ",lowerdir=");
		947	for (nr = 1; nr < ofs->numlayer; nr++) {
		948	if (nr > 1)
		949	seq_putc(m, ':');
		950	if (nr >= nr_merged_lower)
		951	seq_putc(m, ':');
		952	seq_escape(m, ofs->config.lowerdirs[nr], ":, \t\n\\");
		953	}
962	if (ofs->config.upperdir) {	954	if (ofs->config.upperdir) {
963	seq_show_option(m, "upperdir", ofs->config.upperdir);	955	seq_show_option(m, "upperdir", ofs->config.upperdir);
964	seq_show_option(m, "workdir", ofs->config.workdir);	956	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/quota/dquot.c+39−27

  * All dquots are placed to the end of inuse_list when first created, and this
  * list is used for invalidate operation, which must look at every dquot.
  *
- * When the last reference of a dquot will be dropped, the dquot will be
+ * When the last reference of a dquot is dropped, the dquot is added to
- * added to releasing_dquots. We'd then queue work item which would call
+ * releasing_dquots. We'll then queue work item which will call
  * synchronize_srcu() and after that perform the final cleanup of all the
- * dquots on the list. Both releasing_dquots and free_dquots use the
+ * dquots on the list. Each cleaned up dquot is moved to free_dquots list.
- * dq_free list_head in the dquot struct. When a dquot is removed from
+ * Both releasing_dquots and free_dquots use the dq_free list_head in the dquot
- * releasing_dquots, a reference count is always subtracted, and if
+ * struct.
- * dq_count == 0 at that point, the dquot will be added to the free_dquots.
  *
- * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
+ * Unused and cleaned up dquots are in the free_dquots list and this list is
- * and this list is searched whenever we need an available dquot.  Dquots are
+ * searched whenever we need an available dquot. Dquots are removed from the
- * removed from the list as soon as they are used again, and
+ * list as soon as they are used again and dqstats.free_dquots gives the number
- * dqstats.free_dquots gives the number of dquots on the list. When
+ * of dquots on the list. When dquot is invalidated it's completely released
- * dquot is invalidated it's completely released from memory.
+ * from memory.
  *
  * Dirty dquots are added to the dqi_dirty_list of quota_info when mark
  * dirtied, and this list is searched when writing dirty dquots back to
 static inline void put_releasing_dquots(struct dquot *dquot)
 {
 	list_add_tail(&dquot->dq_free, &releasing_dquots);
+	set_bit(DQ_RELEASING_B, &dquot->dq_flags);
 }
 static inline void remove_free_dquot(struct dquot *dquot)
 	if (list_empty(&dquot->dq_free))
 		return;
 	list_del_init(&dquot->dq_free);
-	if (!atomic_read(&dquot->dq_count))
+	if (!test_bit(DQ_RELEASING_B, &dquot->dq_flags))
 		dqstats_dec(DQST_FREE_DQUOTS);
+	else
+		clear_bit(DQ_RELEASING_B, &dquot->dq_flags);
 }
 static inline void put_inuse(struct dquot *dquot)
 			continue;
 		/* Wait for dquot users */
 		if (atomic_read(&dquot->dq_count)) {
-			/* dquot in releasing_dquots, flush and retry */
-			if (!list_empty(&dquot->dq_free)) {
-				spin_unlock(&dq_list_lock);
-				goto restart;
-			}
 			atomic_inc(&dquot->dq_count);
 			spin_unlock(&dq_list_lock);
 			/*
 			 * restart. */
 			goto restart;
 		}
+		/*
+		 * The last user already dropped its reference but dquot didn't
+		 * get fully cleaned up yet. Restart the scan which flushes the
+		 * work cleaning up released dquots.
+		 */
+		if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) {
+			spin_unlock(&dq_list_lock);
+			goto restart;
+		}
 		/*
 		 * Quota now has no users and it has been written on last
 		 * dqput()
 						 dq_dirty);
 			WARN_ON(!dquot_active(dquot));
+			/* If the dquot is releasing we should not touch it */
+			if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) {
+				spin_unlock(&dq_list_lock);
+				flush_delayed_work(&quota_release_work);
+				spin_lock(&dq_list_lock);
+				continue;
+			}
 			/* Now we have active dquot from which someone is
  			 * holding reference so we can safely just increase
 	/* Exchange the list head to avoid livelock. */
 	list_replace_init(&releasing_dquots, &rls_head);
 	spin_unlock(&dq_list_lock);
+	synchronize_srcu(&dquot_srcu);
 restart:
-	synchronize_srcu(&dquot_srcu);
 	spin_lock(&dq_list_lock);
 	while (!list_empty(&rls_head)) {
 		dquot = list_first_entry(&rls_head, struct dquot, dq_free);
-		/* Dquot got used again? */
+		WARN_ON_ONCE(atomic_read(&dquot->dq_count));
-		if (atomic_read(&dquot->dq_count) > 1) {
+		/*
-			remove_free_dquot(dquot);
+		 * Note that DQ_RELEASING_B protects us from racing with
-			atomic_dec(&dquot->dq_count);
+		 * invalidate_dquots() calls so we are safe to work with the
-			continue;
+		 * dquot even after we drop dq_list_lock.
-		}
+		 */
 		if (dquot_dirty(dquot)) {
 			spin_unlock(&dq_list_lock);
 			/* Commit dquot before releasing */
 		}
 		/* Dquot is inactive and clean, now move it to free list */
 		remove_free_dquot(dquot);
-		atomic_dec(&dquot->dq_count);
 		put_dquot_last(dquot);
 	}
 	spin_unlock(&dq_list_lock);
 	BUG_ON(!list_empty(&dquot->dq_free));
 #endif
 	put_releasing_dquots(dquot);
+	atomic_dec(&dquot->dq_count);
 	spin_unlock(&dq_list_lock);
 	queue_delayed_work(system_unbound_wq, &quota_release_work, 1);
 }
 		dqstats_inc(DQST_LOOKUPS);
 	}
 	/* Wait for dq_lock - after this we know that either dquot_release() is
-	 * already finished or it will be canceled due to dq_count > 1 test */
+	 * already finished or it will be canceled due to dq_count > 0 test */
 	wait_on_dquot(dquot);
 	/* Read the dquot / allocate space in quota file */
 	if (!dquot_active(dquot)) {

fs/smb/client/cached_dir.c+68−73

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	static struct cached_fid init_cached_dir(const char path);	15	static struct cached_fid init_cached_dir(const char path);
16	static void free_cached_dir(struct cached_fid *cfid);	16	static void free_cached_dir(struct cached_fid *cfid);
17	static void smb2_close_cached_fid(struct kref *ref);	17	static void smb2_close_cached_fid(struct kref *ref);
		18	static void cfids_laundromat_worker(struct work_struct *work);
18		19
19	static struct cached_fid find_or_create_cached_dir(struct cached_fids cfids,	20	static struct cached_fid find_or_create_cached_dir(struct cached_fids cfids,
20	const char *path,	21	const char *path,
@@ -169,15 +170,18 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon, · 148 unmodified lines
169	return -ENOENT;	170	return -ENOENT;
170	}	171	}
171	/*	172	/*
172	* At this point we either have a lease already and we can just	173	* Return cached fid if it has a lease. Otherwise, it is either a new
173	* return it. If not we are guaranteed to be the only thread accessing	174	* entry or laundromat worker removed it from @cfids->entries. Caller
174	* this cfid.	175	* will put last reference if the latter.
175	*/	176	*/
		177	spin_lock(&cfids->cfid_list_lock);
176	if (cfid->has_lease) {	178	if (cfid->has_lease) {
		179	spin_unlock(&cfids->cfid_list_lock);
177	*ret_cfid = cfid;	180	*ret_cfid = cfid;
178	kfree(utf16_path);	181	kfree(utf16_path);
179	return 0;	182	return 0;
180	}	183	}
		184	spin_unlock(&cfids->cfid_list_lock);
181		185
182	/*	186	/*
183	* Skip any prefix paths in @path as lookup_positive_unlocked() ends up	187	* Skip any prefix paths in @path as lookup_positive_unlocked() ends up
@@ -294,9 +298,11 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon, · 110 unmodified lines
294	goto oshr_free;	298	goto oshr_free;
295	}	299	}
296	}	300	}
		301	spin_lock(&cfids->cfid_list_lock);
297	cfid->dentry = dentry;	302	cfid->dentry = dentry;
298	cfid->time = jiffies;	303	cfid->time = jiffies;
299	cfid->has_lease = true;	304	cfid->has_lease = true;
		305	spin_unlock(&cfids->cfid_list_lock);
300		306
301	oshr_free:	307	oshr_free:
302	kfree(utf16_path);	308	kfree(utf16_path);
@@ -305,24 +311,28 @@ oshr_free: · 2 unmodified lines
305	free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);	311	free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
306	free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);	312	free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
307	spin_lock(&cfids->cfid_list_lock);	313	spin_lock(&cfids->cfid_list_lock);
308	if (rc && !cfid->has_lease) {	314	if (!cfid->has_lease) {
309	if (cfid->on_list) {	315	if (rc) {
310	list_del(&cfid->entry);	316	if (cfid->on_list) {
311	cfid->on_list = false;	317	list_del(&cfid->entry);
312	cfids->num_entries--;	318	cfid->on_list = false;
		319	cfids->num_entries--;
		320	}
		321	rc = -ENOENT;
		322	} else {
		323	/*
		324	* We are guaranteed to have two references at this
		325	* point. One for the caller and one for a potential
		326	* lease. Release the Lease-ref so that the directory
		327	* will be closed when the caller closes the cached
		328	* handle.
		329	*/
		330	spin_unlock(&cfids->cfid_list_lock);
		331	kref_put(&cfid->refcount, smb2_close_cached_fid);
		332	goto out;
313	}	333	}
314	rc = -ENOENT;
315	}	334	}
316	spin_unlock(&cfids->cfid_list_lock);	335	spin_unlock(&cfids->cfid_list_lock);
317	if (!rc && !cfid->has_lease) {
318	/*
319	* We are guaranteed to have two references at this point.
320	* One for the caller and one for a potential lease.
321	* Release the Lease-ref so that the directory will be closed
322	* when the caller closes the cached handle.
323	*/
324	kref_put(&cfid->refcount, smb2_close_cached_fid);
325	}
326	if (rc) {	336	if (rc) {
327	if (cfid->is_open)	337	if (cfid->is_open)
328	SMB2_close(0, cfid->tcon, cfid->fid.persistent_fid,	338	SMB2_close(0, cfid->tcon, cfid->fid.persistent_fid,
@@ -330,7 +340,7 @@ oshr_free: · 1 unmodified line
330	free_cached_dir(cfid);	340	free_cached_dir(cfid);
331	cfid = NULL;	341	cfid = NULL;
332	}	342	}
333		343	out:
334	if (rc == 0) {	344	if (rc == 0) {
335	*ret_cfid = cfid;	345	*ret_cfid = cfid;
336	atomic_inc(&tcon->num_remote_opens);	346	atomic_inc(&tcon->num_remote_opens);
@@ -572,53 +582,51 @@ static void free_cached_dir(struct cached_fid *cfid) · 235 unmodified lines
572	kfree(cfid);	582	kfree(cfid);
573	}	583	}
574		584
575	static int	585	static void cfids_laundromat_worker(struct work_struct *work)
576	cifs_cfids_laundromat_thread(void *p)
577	{	586	{
578	struct cached_fids *cfids = p;	587	struct cached_fids *cfids;
579	struct cached_fid cfid, q;	588	struct cached_fid cfid, q;
580	struct list_head entry;	589	LIST_HEAD(entry);
581		590
582	while (!kthread_should_stop()) {	591	cfids = container_of(work, struct cached_fids, laundromat_work.work);
583	ssleep(1);
584	INIT_LIST_HEAD(&entry);
585	if (kthread_should_stop())
586	return 0;
587	spin_lock(&cfids->cfid_list_lock);
588	list_for_each_entry_safe(cfid, q, &cfids->entries, entry) {
589	if (time_after(jiffies, cfid->time + HZ * dir_cache_timeout)) {
590	list_del(&cfid->entry);
591	list_add(&cfid->entry, &entry);
592	cfids->num_entries--;
593	}
594	}
595	spin_unlock(&cfids->cfid_list_lock);
596		592
597	list_for_each_entry_safe(cfid, q, &entry, entry) {	593	spin_lock(&cfids->cfid_list_lock);
		594	list_for_each_entry_safe(cfid, q, &cfids->entries, entry) {
		595	if (cfid->time &&
		596	time_after(jiffies, cfid->time + HZ * dir_cache_timeout)) {
598	cfid->on_list = false;	597	cfid->on_list = false;
599	list_del(&cfid->entry);	598	list_move(&cfid->entry, &entry);
		599	cfids->num_entries--;
		600	/* To prevent race with smb2_cached_lease_break() */
		601	kref_get(&cfid->refcount);
		602	}
		603	}
		604	spin_unlock(&cfids->cfid_list_lock);
		605
		606	list_for_each_entry_safe(cfid, q, &entry, entry) {
		607	list_del(&cfid->entry);
		608	/*
		609	* Cancel and wait for the work to finish in case we are racing
		610	* with it.
		611	*/
		612	cancel_work_sync(&cfid->lease_break);
		613	if (cfid->has_lease) {
600	/*	614	/*
601	* Cancel, and wait for the work to finish in	615	* Our lease has not yet been cancelled from the server
602	* case we are racing with it.	616	* so we need to drop the reference.
603	*/	617	*/
604	cancel_work_sync(&cfid->lease_break);	618	spin_lock(&cfids->cfid_list_lock);
605	if (cfid->has_lease) {	619	cfid->has_lease = false;
606	/*	620	spin_unlock(&cfids->cfid_list_lock);
607	* We lease has not yet been cancelled from	621	kref_put(&cfid->refcount, smb2_close_cached_fid);
608	* the server so we need to drop the reference.
609	*/
610	spin_lock(&cfids->cfid_list_lock);
611	cfid->has_lease = false;
612	spin_unlock(&cfids->cfid_list_lock);
613	kref_put(&cfid->refcount, smb2_close_cached_fid);
614	}
615	}	622	}
		623	/* Drop the extra reference opened above */
		624	kref_put(&cfid->refcount, smb2_close_cached_fid);
616	}	625	}
617		626	queue_delayed_work(cifsiod_wq, &cfids->laundromat_work,
618	return 0;	627	dir_cache_timeout * HZ);
619	}	628	}
620		629
621
622	struct cached_fids *init_cached_dirs(void)	630	struct cached_fids *init_cached_dirs(void)
623	{	631	{
624	struct cached_fids *cfids;	632	struct cached_fids *cfids;
@@ -629,19 +637,10 @@ struct cached_fids *init_cached_dirs(void) · 4 unmodified lines
629	spin_lock_init(&cfids->cfid_list_lock);	637	spin_lock_init(&cfids->cfid_list_lock);
630	INIT_LIST_HEAD(&cfids->entries);	638	INIT_LIST_HEAD(&cfids->entries);
631		639
632	/*	640	INIT_DELAYED_WORK(&cfids->laundromat_work, cfids_laundromat_worker);
633	* since we're in a cifs function already, we know that	641	queue_delayed_work(cifsiod_wq, &cfids->laundromat_work,
634	* this will succeed. No need for try_module_get().	642	dir_cache_timeout * HZ);
635	*/	643
636	__module_get(THIS_MODULE);
637	cfids->laundromat = kthread_run(cifs_cfids_laundromat_thread,
638	cfids, "cifsd-cfid-laundromat");
639	if (IS_ERR(cfids->laundromat)) {
640	cifs_dbg(VFS, "Failed to start cfids laundromat thread.\n");
641	kfree(cfids);
642	module_put(THIS_MODULE);
643	return NULL;
644	}
645	return cfids;	644	return cfids;
646	}	645	}
647		646
@@ -657,11 +656,7 @@ void free_cached_dirs(struct cached_fids *cfids) · 9 unmodified lines
657	if (cfids == NULL)	656	if (cfids == NULL)
658	return;	657	return;
659		658
660	if (cfids->laundromat) {	659	cancel_delayed_work_sync(&cfids->laundromat_work);
661	kthread_stop(cfids->laundromat);
662	cfids->laundromat = NULL;
663	module_put(THIS_MODULE);
664	}
665		660
666	spin_lock(&cfids->cfid_list_lock);	661	spin_lock(&cfids->cfid_list_lock);
667	list_for_each_entry_safe(cfid, q, &cfids->entries, entry) {	662	list_for_each_entry_safe(cfid, q, &cfids->entries, entry) {

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

@@ -57,7 +57,7 @@ struct cached_fids { · 56 unmodified lines
57	spinlock_t cfid_list_lock;	57	spinlock_t cfid_list_lock;
58	int num_entries;	58	int num_entries;
59	struct list_head entries;	59	struct list_head entries;
60	struct task_struct *laundromat;	60	struct delayed_work laundromat_work;
61	};	61	};
62		62
63	extern struct cached_fids *init_cached_dirs(void);	63	extern struct cached_fids *init_cached_dirs(void);

fs/smb/client/connect.c+13−13

 static struct cifs_tcon *
 cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
 {
-	int rc, xid;
 	struct cifs_tcon *tcon;
+	bool nohandlecache;
+	int rc, xid;
 	tcon = cifs_find_tcon(ses, ctx);
 	if (tcon) {
 		goto out_fail;
 	}
-	if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
+	if (ses->server->dialect >= SMB20_PROT_ID &&
-		tcon = tcon_info_alloc(true);
+	    (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING))
+		nohandlecache = ctx->nohandlecache;
 	else
-		tcon = tcon_info_alloc(false);
+		nohandlecache = true;
+	tcon = tcon_info_alloc(!nohandlecache);
 	if (tcon == NULL) {
 		rc = -ENOMEM;
 		goto out_fail;
 	}
+	tcon->nohandlecache = nohandlecache;
 	if (ctx->snapshot_time) {
 		if (ses->server->vals->protocol_id == 0) {
 	tcon->nocase = ctx->nocase;
 	tcon->broken_sparse_sup = ctx->no_sparse;
 	tcon->max_cached_dirs = ctx->max_cached_dirs;
-	if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
-		tcon->nohandlecache = ctx->nohandlecache;
-	else
-		tcon->nohandlecache = true;
 	tcon->nodelete = ctx->nodelete;
 	tcon->local_lease = ctx->local_lease;
 	INIT_LIST_HEAD(&tcon->pending_opens);
 	if (server->srcaddr.ss_family != AF_UNSPEC) {
 		/* Bind to the specified local IP address */
 		struct socket *socket = server->ssocket;
-		rc = socket->ops->bind(socket,
+		rc = kernel_bind(socket,
-				       (struct sockaddr *) &server->srcaddr,
+				 (struct sockaddr *) &server->srcaddr,
-				       sizeof(server->srcaddr));
+				 sizeof(server->srcaddr));
 		if (rc < 0) {
 			struct sockaddr_in *saddr4;
 			struct sockaddr_in6 *saddr6;
 		 socket->sk->sk_sndbuf,
 		 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
-	rc = socket->ops->connect(socket, saddr, slen,
+	rc = kernel_connect(socket, saddr, slen,
-				  server->noblockcnt ? O_NONBLOCK : 0);
+			    server->noblockcnt ? O_NONBLOCK : 0);
 	/*
 	 * When mounting SMB root file systems, we do not want to block in
 	 * connect. Otherwise bail out and then let cifs_reconnect() perform

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

@@ -84,6 +84,8 @@ struct ksmbd_conn *ksmbd_conn_alloc(void) · 83 unmodified lines
84	spin_lock_init(&conn->llist_lock);	84	spin_lock_init(&conn->llist_lock);
85	INIT_LIST_HEAD(&conn->lock_list);	85	INIT_LIST_HEAD(&conn->lock_list);
86		86
		87	init_rwsem(&conn->session_lock);
		88
87	down_write(&conn_list_lock);	89	down_write(&conn_list_lock);
88	list_add(&conn->conns_list, &conn_list);	90	list_add(&conn->conns_list, &conn_list);
89	up_write(&conn_list_lock);	91	up_write(&conn_list_lock);

fs/smb/server/connection.h+1−0

@@ -50,6 +50,7 @@ struct ksmbd_conn { · 49 unmodified lines
50	struct nls_table *local_nls;	50	struct nls_table *local_nls;
51	struct unicode_map *um;	51	struct unicode_map *um;
52	struct list_head conns_list;	52	struct list_head conns_list;
		53	struct rw_semaphore session_lock;
53	/* smb session 1 per user */	54	/* smb session 1 per user */
54	struct xarray sessions;	55	struct xarray sessions;
55	unsigned long last_active;	56	unsigned long last_active;

fs/smb/server/mgmt/tree_connect.c+39−3

 	tree_conn->user = sess->user;
 	tree_conn->share_conf = sc;
+	tree_conn->t_state = TREE_NEW;
 	status.tree_conn = tree_conn;
+	atomic_set(&tree_conn->refcount, 1);
+	init_waitqueue_head(&tree_conn->refcount_q);
 	ret = xa_err(xa_store(&sess->tree_conns, tree_conn->id, tree_conn,
 			      GFP_KERNEL));
 	return status;
 }
+void ksmbd_tree_connect_put(struct ksmbd_tree_connect *tcon)
+{
+	/*
+	 * Checking waitqueue to releasing tree connect on
+	 * tree disconnect. waitqueue_active is safe because it
+	 * uses atomic operation for condition.
+	 */
+	if (!atomic_dec_return(&tcon->refcount) &&
+	    waitqueue_active(&tcon->refcount_q))
+		wake_up(&tcon->refcount_q);
+}
 int ksmbd_tree_conn_disconnect(struct ksmbd_session *sess,
 			       struct ksmbd_tree_connect *tree_conn)
 {
 	int ret;
+	write_lock(&sess->tree_conns_lock);
+	xa_erase(&sess->tree_conns, tree_conn->id);
+	write_unlock(&sess->tree_conns_lock);
+	if (!atomic_dec_and_test(&tree_conn->refcount))
+		wait_event(tree_conn->refcount_q,
+			   atomic_read(&tree_conn->refcount) == 0);
 	ret = ksmbd_ipc_tree_disconnect_request(sess->id, tree_conn->id);
 	ksmbd_release_tree_conn_id(sess, tree_conn->id);
-	xa_erase(&sess->tree_conns, tree_conn->id);
 	ksmbd_share_config_put(tree_conn->share_conf);
 	kfree(tree_conn);
 	return ret;
 {
 	struct ksmbd_tree_connect *tcon;
+	read_lock(&sess->tree_conns_lock);
 	tcon = xa_load(&sess->tree_conns, id);
 	if (tcon) {
-		if (test_bit(TREE_CONN_EXPIRE, &tcon->status))
+		if (tcon->t_state != TREE_CONNECTED)
+			tcon = NULL;
+		else if (!atomic_inc_not_zero(&tcon->refcount))
 			tcon = NULL;
 	}
+	read_unlock(&sess->tree_conns_lock);
 	return tcon;
 }
 	if (!sess)
 		return -EINVAL;
-	xa_for_each(&sess->tree_conns, id, tc)
+	xa_for_each(&sess->tree_conns, id, tc) {
+		write_lock(&sess->tree_conns_lock);
+		if (tc->t_state == TREE_DISCONNECTED) {
+			write_unlock(&sess->tree_conns_lock);
+			ret = -ENOENT;
+			continue;
+		}
+		tc->t_state = TREE_DISCONNECTED;
+		write_unlock(&sess->tree_conns_lock);
 		ret |= ksmbd_tree_conn_disconnect(sess, tc);
+	}
 	xa_destroy(&sess->tree_conns);
 	return ret;
 }

fs/smb/server/mgmt/tree_connect.h+9−2

 struct ksmbd_user;
 struct ksmbd_conn;
-#define TREE_CONN_EXPIRE		1
+enum {
+	TREE_NEW = 0,
+	TREE_CONNECTED,
+	TREE_DISCONNECTED
+};
 struct ksmbd_tree_connect {
 	int				id;
 	int				maximal_access;
 	bool				posix_extensions;
-	unsigned long			status;
+	atomic_t			refcount;
+	wait_queue_head_t		refcount_q;
+	unsigned int			t_state;
 };
 struct ksmbd_tree_conn_status {
 struct ksmbd_tree_conn_status
 ksmbd_tree_conn_connect(struct ksmbd_conn *conn, struct ksmbd_session *sess,
 			const char *share_name);
+void ksmbd_tree_connect_put(struct ksmbd_tree_connect *tcon);
 int ksmbd_tree_conn_disconnect(struct ksmbd_session *sess,
 			       struct ksmbd_tree_connect *tree_conn);

fs/smb/server/mgmt/user_session.c+8−3

 	unsigned long id;
 	struct ksmbd_session *sess;
-	down_write(&sessions_table_lock);
+	down_write(&conn->session_lock);
 	xa_for_each(&conn->sessions, id, sess) {
 		if (sess->state != SMB2_SESSION_VALID ||
 		    time_after(jiffies,
 			continue;
 		}
 	}
-	up_write(&sessions_table_lock);
+	up_write(&conn->session_lock);
 }
 int ksmbd_session_register(struct ksmbd_conn *conn,
 			}
 		}
 	}
+	up_write(&sessions_table_lock);
+	down_write(&conn->session_lock);
 	xa_for_each(&conn->sessions, id, sess) {
 		unsigned long chann_id;
 		struct channel *chann;
 			ksmbd_session_destroy(sess);
 		}
 	}
-	up_write(&sessions_table_lock);
+	up_write(&conn->session_lock);
 }
 struct ksmbd_session *ksmbd_session_lookup(struct ksmbd_conn *conn,
 {
 	struct ksmbd_session *sess;
+	down_read(&conn->session_lock);
 	sess = xa_load(&conn->sessions, id);
 	if (sess)
 		sess->last_active = jiffies;
+	up_read(&conn->session_lock);
 	return sess;
 }
 	xa_init(&sess->ksmbd_chann_list);
 	xa_init(&sess->rpc_handle_list);
 	sess->sequence_number = 1;
+	rwlock_init(&sess->tree_conns_lock);
 	ret = __init_smb2_session(sess);
 	if (ret)

fs/smb/server/mgmt/user_session.h+1−0

@@ -60,6 +60,7 @@ struct ksmbd_session { · 59 unmodified lines
60		60
61	struct ksmbd_file_table file_table;	61	struct ksmbd_file_table file_table;
62	unsigned long last_active;	62	unsigned long last_active;
		63	rwlock_t tree_conns_lock;
63	};	64	};
64		65
65	static inline int test_session_flag(struct ksmbd_session *sess, int bit)	66	static inline int test_session_flag(struct ksmbd_session *sess, int bit)

fs/smb/server/server.c+2−0

@@ -241,6 +241,8 @@ static void __handle_ksmbd_work(struct ksmbd_work *work, · 240 unmodified lines
241	} while (is_chained == true);	241	} while (is_chained == true);
242		242
243	send:	243	send:
		244	if (work->tcon)
		245	ksmbd_tree_connect_put(work->tcon);
244	smb3_preauth_hash_rsp(work);	246	smb3_preauth_hash_rsp(work);
245	if (work->sess && work->sess->enc && work->encrypted &&	247	if (work->sess && work->sess->enc && work->encrypted &&
246	conn->ops->encrypt_resp) {	248	conn->ops->encrypt_resp) {

fs/smb/server/smb2pdu.c+66−39

@@ -231,11 +231,12 @@ void set_smb2_rsp_status(struct ksmbd_work *work, __le32 err) · 230 unmodified lines
231	{	231	{
232	struct smb2_hdr *rsp_hdr;	232	struct smb2_hdr *rsp_hdr;
233		233
234	if (work->next_smb2_rcv_hdr_off)	234	rsp_hdr = smb2_get_msg(work->response_buf);
235	rsp_hdr = ksmbd_resp_buf_next(work);
236	else
237	rsp_hdr = smb2_get_msg(work->response_buf);
238	rsp_hdr->Status = err;	235	rsp_hdr->Status = err;
		236
		237	work->iov_idx = 0;
		238	work->iov_cnt = 0;
		239	work->next_smb2_rcv_hdr_off = 0;
239	smb2_set_err_rsp(work);	240	smb2_set_err_rsp(work);
240	}	241	}
241		242
@@ -1993,6 +1994,9 @@ int smb2_tree_connect(struct ksmbd_work *work) · 1751 unmodified lines
1993	if (conn->posix_ext_supported)	1994	if (conn->posix_ext_supported)
1994	status.tree_conn->posix_extensions = true;	1995	status.tree_conn->posix_extensions = true;
1995		1996
		1997	write_lock(&sess->tree_conns_lock);
		1998	status.tree_conn->t_state = TREE_CONNECTED;
		1999	write_unlock(&sess->tree_conns_lock);
1996	rsp->StructureSize = cpu_to_le16(16);	2000	rsp->StructureSize = cpu_to_le16(16);
1997	out_err1:	2001	out_err1:
1998	rsp->Capabilities = 0;	2002	rsp->Capabilities = 0;
@@ -2122,27 +2126,50 @@ int smb2_tree_disconnect(struct ksmbd_work *work) · 123 unmodified lines
2122		2126
2123	ksmbd_debug(SMB, "request\n");	2127	ksmbd_debug(SMB, "request\n");
2124		2128
		2129	if (!tcon) {
		2130	ksmbd_debug(SMB, "Invalid tid %d\n", req->hdr.Id.SyncId.TreeId);
		2131
		2132	rsp->hdr.Status = STATUS_NETWORK_NAME_DELETED;
		2133	err = -ENOENT;
		2134	goto err_out;
		2135	}
		2136
		2137	ksmbd_close_tree_conn_fds(work);
		2138
		2139	write_lock(&sess->tree_conns_lock);
		2140	if (tcon->t_state == TREE_DISCONNECTED) {
		2141	write_unlock(&sess->tree_conns_lock);
		2142	rsp->hdr.Status = STATUS_NETWORK_NAME_DELETED;
		2143	err = -ENOENT;
		2144	goto err_out;
		2145	}
		2146
		2147	WARN_ON_ONCE(atomic_dec_and_test(&tcon->refcount));
		2148	tcon->t_state = TREE_DISCONNECTED;
		2149	write_unlock(&sess->tree_conns_lock);
		2150
		2151	err = ksmbd_tree_conn_disconnect(sess, tcon);
		2152	if (err) {
		2153	rsp->hdr.Status = STATUS_NETWORK_NAME_DELETED;
		2154	goto err_out;
		2155	}
		2156
		2157	work->tcon = NULL;
		2158
2125	rsp->StructureSize = cpu_to_le16(4);	2159	rsp->StructureSize = cpu_to_le16(4);
2126	err = ksmbd_iov_pin_rsp(work, rsp,	2160	err = ksmbd_iov_pin_rsp(work, rsp,
2127	sizeof(struct smb2_tree_disconnect_rsp));	2161	sizeof(struct smb2_tree_disconnect_rsp));
2128	if (err) {	2162	if (err) {
2129	rsp->hdr.Status = STATUS_INSUFFICIENT_RESOURCES;	2163	rsp->hdr.Status = STATUS_INSUFFICIENT_RESOURCES;
2130	smb2_set_err_rsp(work);	2164	goto err_out;
2131	return err;
2132	}	2165	}
2133		2166
2134	if (!tcon \|\| test_and_set_bit(TREE_CONN_EXPIRE, &tcon->status)) {	2167	return 0;
2135	ksmbd_debug(SMB, "Invalid tid %d\n", req->hdr.Id.SyncId.TreeId);
2136		2168
2137	rsp->hdr.Status = STATUS_NETWORK_NAME_DELETED;	2169	err_out:
2138	smb2_set_err_rsp(work);	2170	smb2_set_err_rsp(work);
2139	return -ENOENT;	2171	return err;
2140	}
2141		2172
2142	ksmbd_close_tree_conn_fds(work);
2143	ksmbd_tree_conn_disconnect(sess, tcon);
2144	work->tcon = NULL;
2145	return 0;
2146	}	2173	}
2147		2174
2148	/**	2175	/**
@@ -2164,17 +2191,17 @@ int smb2_session_logoff(struct ksmbd_work *work) · 15 unmodified lines
2164		2191
2165	ksmbd_debug(SMB, "request\n");	2192	ksmbd_debug(SMB, "request\n");
2166		2193
2167	sess_id = le64_to_cpu(req->hdr.SessionId);	2194	ksmbd_conn_lock(conn);
2168		2195	if (!ksmbd_conn_good(conn)) {
2169	rsp->StructureSize = cpu_to_le16(4);	2196	ksmbd_conn_unlock(conn);
2170	err = ksmbd_iov_pin_rsp(work, rsp, sizeof(struct smb2_logoff_rsp));	2197	rsp->hdr.Status = STATUS_NETWORK_NAME_DELETED;
2171	if (err) {
2172	rsp->hdr.Status = STATUS_INSUFFICIENT_RESOURCES;
2173	smb2_set_err_rsp(work);	2198	smb2_set_err_rsp(work);
2174	return err;	2199	return -ENOENT;
2175	}	2200	}
2176		2201	sess_id = le64_to_cpu(req->hdr.SessionId);
2177	ksmbd_all_conn_set_status(sess_id, KSMBD_SESS_NEED_RECONNECT);	2202	ksmbd_all_conn_set_status(sess_id, KSMBD_SESS_NEED_RECONNECT);
		2203	ksmbd_conn_unlock(conn);
		2204
2178	ksmbd_close_session_fds(work);	2205	ksmbd_close_session_fds(work);
2179	ksmbd_conn_wait_idle(conn, sess_id);	2206	ksmbd_conn_wait_idle(conn, sess_id);
2180		2207
@@ -2196,6 +2223,14 @@ int smb2_session_logoff(struct ksmbd_work *work) · 15 unmodified lines
2196	ksmbd_free_user(sess->user);	2223	ksmbd_free_user(sess->user);
2197	sess->user = NULL;	2224	sess->user = NULL;
2198	ksmbd_all_conn_set_status(sess_id, KSMBD_SESS_NEED_NEGOTIATE);	2225	ksmbd_all_conn_set_status(sess_id, KSMBD_SESS_NEED_NEGOTIATE);
		2226
		2227	rsp->StructureSize = cpu_to_le16(4);
		2228	err = ksmbd_iov_pin_rsp(work, rsp, sizeof(struct smb2_logoff_rsp));
		2229	if (err) {
		2230	rsp->hdr.Status = STATUS_INSUFFICIENT_RESOURCES;
		2231	smb2_set_err_rsp(work);
		2232	return err;
		2233	}
2199	return 0;	2234	return 0;
2200	}	2235	}
2201		2236
@@ -3370,8 +3405,10 @@ err_out: · 1168 unmodified lines
3370	}	3405	}
3371	ksmbd_revert_fsids(work);	3406	ksmbd_revert_fsids(work);
3372	err_out1:	3407	err_out1:
3373	if (!rc)	3408	if (!rc) {
		3409	ksmbd_update_fstate(&work->sess->file_table, fp, FP_INITED);
3374	rc = ksmbd_iov_pin_rsp(work, (void *)rsp, iov_len);	3410	rc = ksmbd_iov_pin_rsp(work, (void *)rsp, iov_len);
		3411	}
3375	if (rc) {	3412	if (rc) {
3376	if (rc == -EINVAL)	3413	if (rc == -EINVAL)
3377	rsp->hdr.Status = STATUS_INVALID_PARAMETER;	3414	rsp->hdr.Status = STATUS_INVALID_PARAMETER;
@@ -6115,12 +6152,12 @@ static noinline int smb2_read_pipe(struct ksmbd_work *work) · 2737 unmodified lines
6115	memcpy(aux_payload_buf, rpc_resp->payload, rpc_resp->payload_sz);	6152	memcpy(aux_payload_buf, rpc_resp->payload, rpc_resp->payload_sz);
6116		6153
6117	nbytes = rpc_resp->payload_sz;	6154	nbytes = rpc_resp->payload_sz;
6118	kvfree(rpc_resp);
6119	err = ksmbd_iov_pin_rsp_read(work, (void *)rsp,	6155	err = ksmbd_iov_pin_rsp_read(work, (void *)rsp,
6120	offsetof(struct smb2_read_rsp, Buffer),	6156	offsetof(struct smb2_read_rsp, Buffer),
6121	aux_payload_buf, nbytes);	6157	aux_payload_buf, nbytes);
6122	if (err)	6158	if (err)
6123	goto out;	6159	goto out;
		6160	kvfree(rpc_resp);
6124	} else {	6161	} else {
6125	err = ksmbd_iov_pin_rsp(work, (void *)rsp,	6162	err = ksmbd_iov_pin_rsp(work, (void *)rsp,
6126	offsetof(struct smb2_read_rsp, Buffer));	6163	offsetof(struct smb2_read_rsp, Buffer));
@@ -7028,10 +7065,6 @@ skip: · 901 unmodified lines
7028		7065
7029	ksmbd_debug(SMB,	7066	ksmbd_debug(SMB,
7030	"would have to wait for getting lock\n");	7067	"would have to wait for getting lock\n");
7031	spin_lock(&work->conn->llist_lock);
7032	list_add_tail(&smb_lock->clist,
7033	&work->conn->lock_list);
7034	spin_unlock(&work->conn->llist_lock);
7035	list_add(&smb_lock->llist, &rollback_list);	7068	list_add(&smb_lock->llist, &rollback_list);
7036		7069
7037	argv = kmalloc(sizeof(void *), GFP_KERNEL);	7070	argv = kmalloc(sizeof(void *), GFP_KERNEL);
@@ -7062,9 +7095,6 @@ skip: · 24 unmodified lines
7062		7095
7063	if (work->state != KSMBD_WORK_ACTIVE) {	7096	if (work->state != KSMBD_WORK_ACTIVE) {
7064	list_del(&smb_lock->llist);	7097	list_del(&smb_lock->llist);
7065	spin_lock(&work->conn->llist_lock);
7066	list_del(&smb_lock->clist);
7067	spin_unlock(&work->conn->llist_lock);
7068	locks_free_lock(flock);	7098	locks_free_lock(flock);
7069		7099
7070	if (work->state == KSMBD_WORK_CANCELLED) {	7100	if (work->state == KSMBD_WORK_CANCELLED) {
@@ -7084,19 +7114,16 @@ skip: · 13 unmodified lines
7084	}	7114	}
7085		7115
7086	list_del(&smb_lock->llist);	7116	list_del(&smb_lock->llist);
7087	spin_lock(&work->conn->llist_lock);
7088	list_del(&smb_lock->clist);
7089	spin_unlock(&work->conn->llist_lock);
7090	release_async_work(work);	7117	release_async_work(work);
7091	goto retry;	7118	goto retry;
7092	} else if (!rc) {	7119	} else if (!rc) {
		7120	list_add(&smb_lock->llist, &rollback_list);
7093	spin_lock(&work->conn->llist_lock);	7121	spin_lock(&work->conn->llist_lock);
7094	list_add_tail(&smb_lock->clist,	7122	list_add_tail(&smb_lock->clist,
7095	&work->conn->lock_list);	7123	&work->conn->lock_list);
7096	list_add_tail(&smb_lock->flist,	7124	list_add_tail(&smb_lock->flist,
7097	&fp->lock_list);	7125	&fp->lock_list);
7098	spin_unlock(&work->conn->llist_lock);	7126	spin_unlock(&work->conn->llist_lock);
7099	list_add(&smb_lock->llist, &rollback_list);
7100	ksmbd_debug(SMB, "successful in taking lock\n");	7127	ksmbd_debug(SMB, "successful in taking lock\n");
7101	} else {	7128	} else {
7102	goto out;	7129	goto out;
@@ -8036,10 +8063,10 @@ static void smb20_oplock_break_ack(struct ksmbd_work *work) · 933 unmodified lines
8036	goto err_out;	8063	goto err_out;
8037	}	8064	}
8038		8065
8039	opinfo_put(opinfo);
8040	ksmbd_fd_put(work, fp);
8041	opinfo->op_state = OPLOCK_STATE_NONE;	8066	opinfo->op_state = OPLOCK_STATE_NONE;
8042	wake_up_interruptible_all(&opinfo->oplock_q);	8067	wake_up_interruptible_all(&opinfo->oplock_q);
		8068	opinfo_put(opinfo);
		8069	ksmbd_fd_put(work, fp);
8043		8070
8044	rsp->StructureSize = cpu_to_le16(24);	8071	rsp->StructureSize = cpu_to_le16(24);
8045	rsp->OplockLevel = rsp_oplevel;	8072	rsp->OplockLevel = rsp_oplevel;

fs/smb/server/vfs_cache.c+25−5

 	ci = __ksmbd_inode_lookup(inode);
 	if (ci) {
 		ret = KSMBD_INODE_STATUS_OK;
-		if (ci->m_flags & S_DEL_PENDING)
+		if (ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS))
 			ret = KSMBD_INODE_STATUS_PENDING_DELETE;
 		atomic_dec(&ci->m_count);
 	}
 bool ksmbd_inode_pending_delete(struct ksmbd_file *fp)
 {
-	return (fp->f_ci->m_flags & S_DEL_PENDING);
+	return (fp->f_ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS));
 }
 void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp)
 static struct ksmbd_file *ksmbd_fp_get(struct ksmbd_file *fp)
 {
+	if (fp->f_state != FP_INITED)
+		return NULL;
 	if (!atomic_inc_not_zero(&fp->refcount))
 		return NULL;
 	return fp;
 		return 0;
 	ft = &work->sess->file_table;
-	read_lock(&ft->lock);
+	write_lock(&ft->lock);
 	fp = idr_find(ft->idr, id);
 	if (fp) {
 		set_close_state_blocked_works(fp);
-		if (!atomic_dec_and_test(&fp->refcount))
+		if (fp->f_state != FP_INITED)
 			fp = NULL;
+		else {
+			fp->f_state = FP_CLOSED;
+			if (!atomic_dec_and_test(&fp->refcount))
+				fp = NULL;
+		}
 	}
-	read_unlock(&ft->lock);
+	write_unlock(&ft->lock);
 	if (!fp)
 		return -EINVAL;
 	fp->tcon		= work->tcon;
 	fp->volatile_id		= KSMBD_NO_FID;
 	fp->persistent_id	= KSMBD_NO_FID;
+	fp->f_state		= FP_NEW;
 	fp->f_ci		= ksmbd_inode_get(fp);
 	if (!fp->f_ci) {
 	return ERR_PTR(ret);
 }
+void ksmbd_update_fstate(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
+			 unsigned int state)
+{
+	if (!fp)
+		return;
+	write_lock(&ft->lock);
+	fp->f_state = state;
+	write_unlock(&ft->lock);
+}
 static int
 __close_file_table_ids(struct ksmbd_file_table *ft,
 		       struct ksmbd_tree_connect *tcon,

fs/smb/server/vfs_cache.h+9−0

 	__le32				m_fattr;
 };
+enum {
+	FP_NEW = 0,
+	FP_INITED,
+	FP_CLOSED
+};
 struct ksmbd_file {
 	struct file			*filp;
 	u64				persistent_id;
 	/* if ls is happening on directory, below is valid*/
 	struct ksmbd_readdir_data	readdir_data;
 	int				dot_dotdot[2];
+	unsigned int			f_state;
 };
 static inline void set_ctx_actor(struct dir_context *ctx,
 int ksmbd_init_global_file_table(void);
 void ksmbd_free_global_file_table(void);
 void ksmbd_set_fd_limit(unsigned long limit);
+void ksmbd_update_fstate(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
+			 unsigned int state);
 /*
  * INODE hash

fs/xfs/libxfs/xfs_ag.c+6−0

 		error = -ENOSPC;
 		goto resv_init_out;
 	}
+	/* Update perag geometry */
+	pag->block_count -= delta;
+	__xfs_agino_range(pag->pag_mount, pag->block_count, &pag->agino_min,
+				&pag->agino_max);
 	xfs_ialloc_log_agi(*tpp, agibp, XFS_AGI_LENGTH);
 	xfs_alloc_log_agf(*tpp, agfbp, XFS_AGF_LENGTH);
 	return 0;

fs/xfs/scrub/xfile.c+0−1

@@ -10,7 +10,6 @@ · 9 unmodified lines
10	#include "xfs_log_format.h"	10	#include "xfs_log_format.h"
11	#include "xfs_trans_resv.h"	11	#include "xfs_trans_resv.h"
12	#include "xfs_mount.h"	12	#include "xfs_mount.h"
13	#include "xfs_format.h"
14	#include "scrub/xfile.h"	13	#include "scrub/xfile.h"
15	#include "scrub/xfarray.h"	14	#include "scrub/xfarray.h"
16	#include "scrub/scrub.h"	15	#include "scrub/scrub.h"

fs/xfs/xfs_discard.c+242−24

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* Copyright (C) 2010 Red Hat, Inc.	3	* Copyright (C) 2010, 2023 Red Hat, Inc.
4	* All Rights Reserved.	4	* All Rights Reserved.
5	*/	5	*/
6	#include "xfs.h"	6	#include "xfs.h"
@@ -19,21 +19,147 @@ · 12 unmodified lines
19	#include "xfs_log.h"	19	#include "xfs_log.h"
20	#include "xfs_ag.h"	20	#include "xfs_ag.h"
21		21
22	STATIC int	22	/*
23	xfs_trim_extents(	23	* Notes on an efficient, low latency fstrim algorithm
		24	*
		25	* We need to walk the filesystem free space and issue discards on the free
		26	* space that meet the search criteria (size and location). We cannot issue
		27	* discards on extents that might be in use, or are so recently in use they are
		28	* still marked as busy. To serialise against extent state changes whilst we are
		29	* gathering extents to trim, we must hold the AGF lock to lock out other
		30	* allocations and extent free operations that might change extent state.
		31	*
		32	* However, we cannot just hold the AGF for the entire AG free space walk whilst
		33	* we issue discards on each free space that is found. Storage devices can have
		34	* extremely slow discard implementations (e.g. ceph RBD) and so walking a
		35	* couple of million free extents and issuing synchronous discards on each
		36	* extent can take a long time. Whilst we are doing this walk, nothing else
		37	* can access the AGF, and we can stall transactions and hence the log whilst
		38	* modifications wait for the AGF lock to be released. This can lead hung tasks
		39	* kicking the hung task timer and rebooting the system. This is bad.
		40	*
		41	* Hence we need to take a leaf from the bulkstat playbook. It takes the AGI
		42	* lock, gathers a range of inode cluster buffers that are allocated, drops the
		43	* AGI lock and then reads all the inode cluster buffers and processes them. It
		44	* loops doing this, using a cursor to keep track of where it is up to in the AG
		45	* for each iteration to restart the INOBT lookup from.
		46	*
		47	* We can't do this exactly with free space - once we drop the AGF lock, the
		48	* state of the free extent is out of our control and we cannot run a discard
		49	* safely on it in this situation. Unless, of course, we've marked the free
		50	* extent as busy and undergoing a discard operation whilst we held the AGF
		51	* locked.
		52	*
		53	* This is exactly how online discard works - free extents are marked busy when
		54	* they are freed, and once the extent free has been committed to the journal,
		55	* the busy extent record is marked as "undergoing discard" and the discard is
		56	* then issued on the free extent. Once the discard completes, the busy extent
		57	* record is removed and the extent is able to be allocated again.
		58	*
		59	* In the context of fstrim, if we find a free extent we need to discard, we
		60	* don't have to discard it immediately. All we need to do it record that free
		61	* extent as being busy and under discard, and all the allocation routines will
		62	* now avoid trying to allocate it. Hence if we mark the extent as busy under
		63	* the AGF lock, we can safely discard it without holding the AGF lock because
		64	* nothing will attempt to allocate that free space until the discard completes.
		65	*
		66	* This also allows us to issue discards asynchronously like we do with online
		67	* discard, and so for fast devices fstrim will run much faster as we can have
		68	* multiple discard operations in flight at once, as well as pipeline the free
		69	* extent search so that it overlaps in flight discard IO.
		70	*/
		71
		72	struct workqueue_struct *xfs_discard_wq;
		73
		74	static void
		75	xfs_discard_endio_work(
		76	struct work_struct *work)
		77	{
		78	struct xfs_busy_extents *extents =
		79	container_of(work, struct xfs_busy_extents, endio_work);
		80
		81	xfs_extent_busy_clear(extents->mount, &extents->extent_list, false);
		82	kmem_free(extents->owner);
		83	}
		84
		85	/*
		86	* Queue up the actual completion to a thread to avoid IRQ-safe locking for
		87	* pagb_lock.
		88	*/
		89	static void
		90	xfs_discard_endio(
		91	struct bio *bio)
		92	{
		93	struct xfs_busy_extents *extents = bio->bi_private;
		94
		95	INIT_WORK(&extents->endio_work, xfs_discard_endio_work);
		96	queue_work(xfs_discard_wq, &extents->endio_work);
		97	bio_put(bio);
		98	}
		99
		100	/*
		101	* Walk the discard list and issue discards on all the busy extents in the
		102	* list. We plug and chain the bios so that we only need a single completion
		103	* call to clear all the busy extents once the discards are complete.
		104	*/
		105	int
		106	xfs_discard_extents(
		107	struct xfs_mount *mp,
		108	struct xfs_busy_extents *extents)
		109	{
		110	struct xfs_extent_busy *busyp;
		111	struct bio *bio = NULL;
		112	struct blk_plug plug;
		113	int error = 0;
		114
		115	blk_start_plug(&plug);
		116	list_for_each_entry(busyp, &extents->extent_list, list) {
		117	trace_xfs_discard_extent(mp, busyp->agno, busyp->bno,
		118	busyp->length);
		119
		120	error = __blkdev_issue_discard(mp->m_ddev_targp->bt_bdev,
		121	XFS_AGB_TO_DADDR(mp, busyp->agno, busyp->bno),
		122	XFS_FSB_TO_BB(mp, busyp->length),
		123	GFP_NOFS, &bio);
		124	if (error && error != -EOPNOTSUPP) {
		125	xfs_info(mp,
		126	"discard failed for extent [0x%llx,%u], error %d",
		127	(unsigned long long)busyp->bno,
		128	busyp->length,
		129	error);
		130	break;
		131	}
		132	}
		133
		134	if (bio) {
		135	bio->bi_private = extents;
		136	bio->bi_end_io = xfs_discard_endio;
		137	submit_bio(bio);
		138	} else {
		139	xfs_discard_endio_work(&extents->endio_work);
		140	}
		141	blk_finish_plug(&plug);
		142
		143	return error;
		144	}
		145
		146
		147	static int
		148	xfs_trim_gather_extents(
24	struct xfs_perag *pag,	149	struct xfs_perag *pag,
25	xfs_daddr_t start,	150	xfs_daddr_t start,
26	xfs_daddr_t end,	151	xfs_daddr_t end,
27	xfs_daddr_t minlen,	152	xfs_daddr_t minlen,
		153	struct xfs_alloc_rec_incore *tcur,
		154	struct xfs_busy_extents *extents,
28	uint64_t *blocks_trimmed)	155	uint64_t *blocks_trimmed)
29	{	156	{
30	struct xfs_mount *mp = pag->pag_mount;	157	struct xfs_mount *mp = pag->pag_mount;
31	struct block_device *bdev = mp->m_ddev_targp->bt_bdev;
32	struct xfs_btree_cur *cur;	158	struct xfs_btree_cur *cur;
33	struct xfs_buf *agbp;	159	struct xfs_buf *agbp;
34	struct xfs_agf *agf;
35	int error;	160	int error;
36	int i;	161	int i;
		162	int batch = 100;
37		163
38	/*	164	/*
39	* Force out the log. This means any transactions that might have freed	165	* Force out the log. This means any transactions that might have freed
@@ -45,20 +171,28 @@ xfs_trim_extents( · 5 unmodified lines
45	error = xfs_alloc_read_agf(pag, NULL, 0, &agbp);	171	error = xfs_alloc_read_agf(pag, NULL, 0, &agbp);
46	if (error)	172	if (error)
47	return error;	173	return error;
48	agf = agbp->b_addr;
49		174
50	cur = xfs_allocbt_init_cursor(mp, NULL, agbp, pag, XFS_BTNUM_CNT);	175	cur = xfs_allocbt_init_cursor(mp, NULL, agbp, pag, XFS_BTNUM_CNT);
51		176
52	/*	177	/*
53	* Look up the longest btree in the AGF and start with it.	178	* Look up the extent length requested in the AGF and start with it.
54	*/	179	*/
55	error = xfs_alloc_lookup_ge(cur, 0, be32_to_cpu(agf->agf_longest), &i);	180	if (tcur->ar_startblock == NULLAGBLOCK)
		181	error = xfs_alloc_lookup_ge(cur, 0, tcur->ar_blockcount, &i);
		182	else
		183	error = xfs_alloc_lookup_le(cur, tcur->ar_startblock,
		184	tcur->ar_blockcount, &i);
56	if (error)	185	if (error)
57	goto out_del_cursor;	186	goto out_del_cursor;
		187	if (i == 0) {
		188	/* nothing of that length left in the AG, we are done */
		189	tcur->ar_blockcount = 0;
		190	goto out_del_cursor;
		191	}
58		192
59	/*	193	/*
60	* Loop until we are done with all extents that are large	194	* Loop until we are done with all extents that are large
61	* enough to be worth discarding.	195	* enough to be worth discarding or we hit batch limits.
62	*/	196	*/
63	while (i) {	197	while (i) {
64	xfs_agblock_t fbno;	198	xfs_agblock_t fbno;
@@ -73,7 +207,16 @@ xfs_trim_extents( · 8 unmodified lines
73	error = -EFSCORRUPTED;	207	error = -EFSCORRUPTED;
74	break;	208	break;
75	}	209	}
76	ASSERT(flen <= be32_to_cpu(agf->agf_longest));	210
		211	if (--batch <= 0) {
		212	/*
		213	* Update the cursor to point at this extent so we
		214	* restart the next batch from this extent.
		215	*/
		216	tcur->ar_startblock = fbno;
		217	tcur->ar_blockcount = flen;
		218	break;
		219	}
77		220
78	/*	221	/*
79	* use daddr format for all range/len calculations as that is	222	* use daddr format for all range/len calculations as that is
@@ -88,6 +231,7 @@ xfs_trim_extents( · 8 unmodified lines
88	*/	231	*/
89	if (dlen < minlen) {	232	if (dlen < minlen) {
90	trace_xfs_discard_toosmall(mp, pag->pag_agno, fbno, flen);	233	trace_xfs_discard_toosmall(mp, pag->pag_agno, fbno, flen);
		234	tcur->ar_blockcount = 0;
91	break;	235	break;
92	}	236	}
93		237
@@ -110,29 +254,103 @@ xfs_trim_extents( · 16 unmodified lines
110	goto next_extent;	254	goto next_extent;
111	}	255	}
112		256
113	trace_xfs_discard_extent(mp, pag->pag_agno, fbno, flen);	257	xfs_extent_busy_insert_discard(pag, fbno, flen,
114	error = blkdev_issue_discard(bdev, dbno, dlen, GFP_NOFS);	258	&extents->extent_list);
115	if (error)
116	break;
117	*blocks_trimmed += flen;	259	*blocks_trimmed += flen;
118
119	next_extent:	260	next_extent:
120	error = xfs_btree_decrement(cur, 0, &i);	261	error = xfs_btree_decrement(cur, 0, &i);
121	if (error)	262	if (error)
122	break;	263	break;
123		264
124	if (fatal_signal_pending(current)) {	265	/*
125	error = -ERESTARTSYS;	266	* If there's no more records in the tree, we are done. Set the
126	break;	267	* cursor block count to 0 to indicate to the caller that there
127	}	268	* is no more extents to search.
		269	*/
		270	if (i == 0)
		271	tcur->ar_blockcount = 0;
128	}	272	}
129		273
		274	/*
		275	* If there was an error, release all the gathered busy extents because
		276	* we aren't going to issue a discard on them any more.
		277	*/
		278	if (error)
		279	xfs_extent_busy_clear(mp, &extents->extent_list, false);
130	out_del_cursor:	280	out_del_cursor:
131	xfs_btree_del_cursor(cur, error);	281	xfs_btree_del_cursor(cur, error);
132	xfs_buf_relse(agbp);	282	xfs_buf_relse(agbp);
133	return error;	283	return error;
134	}	284	}
135		285
		286	static bool
		287	xfs_trim_should_stop(void)
		288	{
		289	return fatal_signal_pending(current) \|\| freezing(current);
		290	}
		291
		292	/*
		293	* Iterate the free list gathering extents and discarding them. We need a cursor
		294	* for the repeated iteration of gather/discard loop, so use the longest extent
		295	* we found in the last batch as the key to start the next.
		296	*/
		297	static int
		298	xfs_trim_extents(
		299	struct xfs_perag *pag,
		300	xfs_daddr_t start,
		301	xfs_daddr_t end,
		302	xfs_daddr_t minlen,
		303	uint64_t *blocks_trimmed)
		304	{
		305	struct xfs_alloc_rec_incore tcur = {
		306	.ar_blockcount = pag->pagf_longest,
		307	.ar_startblock = NULLAGBLOCK,
		308	};
		309	int error = 0;
		310
		311	do {
		312	struct xfs_busy_extents *extents;
		313
		314	extents = kzalloc(sizeof(*extents), GFP_KERNEL);
		315	if (!extents) {
		316	error = -ENOMEM;
		317	break;
		318	}
		319
		320	extents->mount = pag->pag_mount;
		321	extents->owner = extents;
		322	INIT_LIST_HEAD(&extents->extent_list);
		323
		324	error = xfs_trim_gather_extents(pag, start, end, minlen,
		325	&tcur, extents, blocks_trimmed);
		326	if (error) {
		327	kfree(extents);
		328	break;
		329	}
		330
		331	/*
		332	* We hand the extent list to the discard function here so the
		333	* discarded extents can be removed from the busy extent list.
		334	* This allows the discards to run asynchronously with gathering
		335	* the next round of extents to discard.
		336	*
		337	* However, we must ensure that we do not reference the extent
		338	* list after this function call, as it may have been freed by
		339	* the time control returns to us.
		340	*/
		341	error = xfs_discard_extents(pag->pag_mount, extents);
		342	if (error)
		343	break;
		344
		345	if (xfs_trim_should_stop())
		346	break;
		347
		348	} while (tcur.ar_blockcount != 0);
		349
		350	return error;
		351
		352	}
		353
136	/*	354	/*
137	* trim a range of the filesystem.	355	* trim a range of the filesystem.
138	*	356	*
@@ -195,12 +413,12 @@ xfs_ioc_trim( · 56 unmodified lines
195	for_each_perag_range(mp, agno, xfs_daddr_to_agno(mp, end), pag) {	413	for_each_perag_range(mp, agno, xfs_daddr_to_agno(mp, end), pag) {
196	error = xfs_trim_extents(pag, start, end, minlen,	414	error = xfs_trim_extents(pag, start, end, minlen,
197	&blocks_trimmed);	415	&blocks_trimmed);
198	if (error) {	416	if (error)
199	last_error = error;	417	last_error = error;
200	if (error == -ERESTARTSYS) {	418
201	xfs_perag_rele(pag);	419	if (xfs_trim_should_stop()) {
202	break;	420	xfs_perag_rele(pag);
203	}	421	break;
204	}	422	}
205	}	423	}
206		424

fs/xfs/xfs_discard.h+4−2

@@ -3,8 +3,10 @@ · 2 unmodified lines
3	#define XFS_DISCARD_H 1	3	#define XFS_DISCARD_H 1
4		4
5	struct fstrim_range;	5	struct fstrim_range;
6	struct list_head;	6	struct xfs_mount;
		7	struct xfs_busy_extents;
7		8
8	extern int xfs_ioc_trim(struct xfs_mount , struct fstrim_range __user );	9	int xfs_discard_extents(struct xfs_mount mp, struct xfs_busy_extents busy);
		10	int xfs_ioc_trim(struct xfs_mount mp, struct fstrim_range __user fstrim);
9		11
10	#endif /* XFS_DISCARD_H */	12	#endif /* XFS_DISCARD_H */

fs/xfs/xfs_extent_busy.c+29−6

 #include "xfs_log.h"
 #include "xfs_ag.h"
-void
+static void
-xfs_extent_busy_insert(
+xfs_extent_busy_insert_list(
-	struct xfs_trans	*tp,
 	struct xfs_perag	*pag,
 	xfs_agblock_t		bno,
 	xfs_extlen_t		len,
-	unsigned int		flags)
+	unsigned int		flags,
+	struct list_head	*busy_list)
 {
 	struct xfs_extent_busy	*new;
 	struct xfs_extent_busy	*busyp;
 	new->flags = flags;
 	/* trace before insert to be able to see failed inserts */
-	trace_xfs_extent_busy(tp->t_mountp, pag->pag_agno, bno, len);
+	trace_xfs_extent_busy(pag->pag_mount, pag->pag_agno, bno, len);
 	spin_lock(&pag->pagb_lock);
 	rbp = &pag->pagb_tree.rb_node;
 	rb_link_node(&new->rb_node, parent, rbp);
 	rb_insert_color(&new->rb_node, &pag->pagb_tree);
-	list_add(&new->list, &tp->t_busy);
+	/* always process discard lists in fifo order */
+	list_add_tail(&new->list, busy_list);
 	spin_unlock(&pag->pagb_lock);
 }
+void
+xfs_extent_busy_insert(
+	struct xfs_trans	*tp,
+	struct xfs_perag	*pag,
+	xfs_agblock_t		bno,
+	xfs_extlen_t		len,
+	unsigned int		flags)
+{
+	xfs_extent_busy_insert_list(pag, bno, len, flags, &tp->t_busy);
+}
+void
+xfs_extent_busy_insert_discard(
+	struct xfs_perag	*pag,
+	xfs_agblock_t		bno,
+	xfs_extlen_t		len,
+	struct list_head	*busy_list)
+{
+	xfs_extent_busy_insert_list(pag, bno, len, XFS_EXTENT_BUSY_DISCARDED,
+			busy_list);
+}
 /*
  * Search for a busy extent within the range of the extent we are about to
  * allocate.  You need to be holding the busy extent tree lock when calling

fs/xfs/xfs_extent_busy.h+21−3

@@ -16,9 +16,6 @@ struct xfs_alloc_arg; · 15 unmodified lines
16	/*	16	/*
17	* Busy block/extent entry. Indexed by a rbtree in perag to mark blocks that	17	* Busy block/extent entry. Indexed by a rbtree in perag to mark blocks that
18	* have been freed but whose transactions aren't committed to disk yet.	18	* have been freed but whose transactions aren't committed to disk yet.
19	*
20	* Note that we use the transaction ID to record the transaction, not the
21	* transaction structure itself. See xfs_extent_busy_insert() for details.
22	*/	19	*/
23	struct xfs_extent_busy {	20	struct xfs_extent_busy {
24	struct rb_node rb_node; /* ag by-bno indexed search tree */	21	struct rb_node rb_node; /* ag by-bno indexed search tree */
@@ -31,10 +28,31 @@ struct xfs_extent_busy { · 6 unmodified lines
31	#define XFS_EXTENT_BUSY_SKIP_DISCARD 0x02 /* do not discard */	28	#define XFS_EXTENT_BUSY_SKIP_DISCARD 0x02 /* do not discard */
32	};	29	};
33		30
		31	/*
		32	* List used to track groups of related busy extents all the way through
		33	* to discard completion.
		34	*/
		35	struct xfs_busy_extents {
		36	struct xfs_mount *mount;
		37	struct list_head extent_list;
		38	struct work_struct endio_work;
		39
		40	/*
		41	* Owner is the object containing the struct xfs_busy_extents to free
		42	* once the busy extents have been processed. If only the
		43	* xfs_busy_extents object needs freeing, then point this at itself.
		44	*/
		45	void *owner;
		46	};
		47
34	void	48	void
35	xfs_extent_busy_insert(struct xfs_trans tp, struct xfs_perag pag,	49	xfs_extent_busy_insert(struct xfs_trans tp, struct xfs_perag pag,
36	xfs_agblock_t bno, xfs_extlen_t len, unsigned int flags);	50	xfs_agblock_t bno, xfs_extlen_t len, unsigned int flags);
37		51
		52	void
		53	xfs_extent_busy_insert_discard(struct xfs_perag *pag, xfs_agblock_t bno,
		54	xfs_extlen_t len, struct list_head *busy_list);
		55
38	void	56	void
39	xfs_extent_busy_clear(struct xfs_mount mp, struct list_head list,	57	xfs_extent_busy_clear(struct xfs_mount mp, struct list_head list,
40	bool do_discard);	58	bool do_discard);

fs/xfs/xfs_iops.c+5−0

 		}
 	}
+	if ((request_mask & STATX_CHANGE_COOKIE) && IS_I_VERSION(inode)) {
+		stat->change_cookie = inode_query_iversion(inode);
+		stat->result_mask |= STATX_CHANGE_COOKIE;
+	}
 	/*
 	 * Note: If you add another clause to set an attribute flag, please
 	 * update attributes_mask below.

fs/xfs/xfs_log_cil.c+13−80

@@ -16,8 +16,7 @@ · 15 unmodified lines
16	#include "xfs_log.h"	16	#include "xfs_log.h"
17	#include "xfs_log_priv.h"	17	#include "xfs_log_priv.h"
18	#include "xfs_trace.h"	18	#include "xfs_trace.h"
19		19	#include "xfs_discard.h"
20	struct workqueue_struct *xfs_discard_wq;
21		20
22	/*	21	/*
23	* Allocate a new ticket. Failing to get a new ticket makes it really hard to	22	* Allocate a new ticket. Failing to get a new ticket makes it really hard to
@@ -103,7 +102,7 @@ xlog_cil_ctx_alloc(void) · 79 unmodified lines
103		102
104	ctx = kmem_zalloc(sizeof(*ctx), KM_NOFS);	103	ctx = kmem_zalloc(sizeof(*ctx), KM_NOFS);
105	INIT_LIST_HEAD(&ctx->committing);	104	INIT_LIST_HEAD(&ctx->committing);
106	INIT_LIST_HEAD(&ctx->busy_extents);	105	INIT_LIST_HEAD(&ctx->busy_extents.extent_list);
107	INIT_LIST_HEAD(&ctx->log_items);	106	INIT_LIST_HEAD(&ctx->log_items);
108	INIT_LIST_HEAD(&ctx->lv_chain);	107	INIT_LIST_HEAD(&ctx->lv_chain);
109	INIT_WORK(&ctx->push_work, xlog_cil_push_work);	108	INIT_WORK(&ctx->push_work, xlog_cil_push_work);
@@ -132,7 +131,7 @@ xlog_cil_push_pcp_aggregate( · 22 unmodified lines
132		131
133	if (!list_empty(&cilpcp->busy_extents)) {	132	if (!list_empty(&cilpcp->busy_extents)) {
134	list_splice_init(&cilpcp->busy_extents,	133	list_splice_init(&cilpcp->busy_extents,
135	&ctx->busy_extents);	134	&ctx->busy_extents.extent_list);
136	}	135	}
137	if (!list_empty(&cilpcp->log_items))	136	if (!list_empty(&cilpcp->log_items))
138	list_splice_init(&cilpcp->log_items, &ctx->log_items);	137	list_splice_init(&cilpcp->log_items, &ctx->log_items);
@@ -708,76 +707,6 @@ xlog_cil_free_logvec( · 569 unmodified lines
708	}	707	}
709	}	708	}
710		709
711	static void
712	xlog_discard_endio_work(
713	struct work_struct *work)
714	{
715	struct xfs_cil_ctx *ctx =
716	container_of(work, struct xfs_cil_ctx, discard_endio_work);
717	struct xfs_mount *mp = ctx->cil->xc_log->l_mp;
718
719	xfs_extent_busy_clear(mp, &ctx->busy_extents, false);
720	kmem_free(ctx);
721	}
722
723	/*
724	* Queue up the actual completion to a thread to avoid IRQ-safe locking for
725	* pagb_lock. Note that we need a unbounded workqueue, otherwise we might
726	* get the execution delayed up to 30 seconds for weird reasons.
727	*/
728	static void
729	xlog_discard_endio(
730	struct bio *bio)
731	{
732	struct xfs_cil_ctx *ctx = bio->bi_private;
733
734	INIT_WORK(&ctx->discard_endio_work, xlog_discard_endio_work);
735	queue_work(xfs_discard_wq, &ctx->discard_endio_work);
736	bio_put(bio);
737	}
738
739	static void
740	xlog_discard_busy_extents(
741	struct xfs_mount *mp,
742	struct xfs_cil_ctx *ctx)
743	{
744	struct list_head *list = &ctx->busy_extents;
745	struct xfs_extent_busy *busyp;
746	struct bio *bio = NULL;
747	struct blk_plug plug;
748	int error = 0;
749
750	ASSERT(xfs_has_discard(mp));
751
752	blk_start_plug(&plug);
753	list_for_each_entry(busyp, list, list) {
754	trace_xfs_discard_extent(mp, busyp->agno, busyp->bno,
755	busyp->length);
756
757	error = __blkdev_issue_discard(mp->m_ddev_targp->bt_bdev,
758	XFS_AGB_TO_DADDR(mp, busyp->agno, busyp->bno),
759	XFS_FSB_TO_BB(mp, busyp->length),
760	GFP_NOFS, &bio);
761	if (error && error != -EOPNOTSUPP) {
762	xfs_info(mp,
763	"discard failed for extent [0x%llx,%u], error %d",
764	(unsigned long long)busyp->bno,
765	busyp->length,
766	error);
767	break;
768	}
769	}
770
771	if (bio) {
772	bio->bi_private = ctx;
773	bio->bi_end_io = xlog_discard_endio;
774	submit_bio(bio);
775	} else {
776	xlog_discard_endio_work(&ctx->discard_endio_work);
777	}
778	blk_finish_plug(&plug);
779	}
780
781	/*	710	/*
782	* Mark all items committed and clear busy extents. We free the log vector	711	* Mark all items committed and clear busy extents. We free the log vector
783	* chains in a separate pass so that we unpin the log items as quickly as	712	* chains in a separate pass so that we unpin the log items as quickly as
@@ -807,8 +736,8 @@ xlog_cil_committed( · 23 unmodified lines
807	xfs_trans_committed_bulk(ctx->cil->xc_log->l_ailp, &ctx->lv_chain,	736	xfs_trans_committed_bulk(ctx->cil->xc_log->l_ailp, &ctx->lv_chain,
808	ctx->start_lsn, abort);	737	ctx->start_lsn, abort);
809		738
810	xfs_extent_busy_sort(&ctx->busy_extents);	739	xfs_extent_busy_sort(&ctx->busy_extents.extent_list);
811	xfs_extent_busy_clear(mp, &ctx->busy_extents,	740	xfs_extent_busy_clear(mp, &ctx->busy_extents.extent_list,
812	xfs_has_discard(mp) && !abort);	741	xfs_has_discard(mp) && !abort);
813		742
814	spin_lock(&ctx->cil->xc_push_lock);	743	spin_lock(&ctx->cil->xc_push_lock);
@@ -817,10 +746,14 @@ xlog_cil_committed( · 2 unmodified lines
817		746
818	xlog_cil_free_logvec(&ctx->lv_chain);	747	xlog_cil_free_logvec(&ctx->lv_chain);
819		748
820	if (!list_empty(&ctx->busy_extents))	749	if (!list_empty(&ctx->busy_extents.extent_list)) {
821	xlog_discard_busy_extents(mp, ctx);	750	ctx->busy_extents.mount = mp;
822	else	751	ctx->busy_extents.owner = ctx;
823	kmem_free(ctx);	752	xfs_discard_extents(mp, &ctx->busy_extents);
		753	return;
		754	}
		755
		756	kmem_free(ctx);
824	}	757	}
825		758
826	void	759	void

fs/xfs/xfs_log_priv.h+3−2

 #ifndef	__XFS_LOG_PRIV_H__
 #define __XFS_LOG_PRIV_H__
+#include "xfs_extent_busy.h"	/* for struct xfs_busy_extents */
 struct xfs_buf;
 struct xlog;
 struct xlog_ticket;
 	struct xlog_in_core	*commit_iclog;
 	struct xlog_ticket	*ticket;	/* chkpt ticket */
 	atomic_t		space_used;	/* aggregate size of regions */
-	struct list_head	busy_extents;	/* busy extents in chkpt */
+	struct xfs_busy_extents	busy_extents;
 	struct list_head	log_items;	/* log items in chkpt */
 	struct list_head	lv_chain;	/* logvecs being pushed */
 	struct list_head	iclog_entry;
 	struct list_head	committing;	/* ctx committing list */
-	struct work_struct	discard_endio_work;
 	struct work_struct	push_work;
 	atomic_t		order_id;

fs/xfs/xfs_notify_failure.c+3−3

 		struct xfs_rmap_irec	ri_low = { };
 		struct xfs_rmap_irec	ri_high;
 		struct xfs_agf		*agf;
-		xfs_agblock_t		agend;
 		struct xfs_perag	*pag;
+		xfs_agblock_t		range_agend;
 		pag = xfs_perag_get(mp, agno);
 		error = xfs_alloc_read_agf(pag, tp, 0, &agf_bp);
 			ri_high.rm_startblock = XFS_FSB_TO_AGBNO(mp, end_fsbno);
 		agf = agf_bp->b_addr;
-		agend = min(be32_to_cpu(agf->agf_length),
+		range_agend = min(be32_to_cpu(agf->agf_length) - 1,
 				ri_high.rm_startblock);
 		notify.startblock = ri_low.rm_startblock;
-		notify.blockcount = agend - ri_low.rm_startblock;
+		notify.blockcount = range_agend + 1 - ri_low.rm_startblock;
 		error = xfs_rmap_query_range(cur, &ri_low, &ri_high,
 				xfs_dax_failure_fn, &notify);

include/acpi/processor.h+0−5

@@ -465,9 +465,4 @@ extern int acpi_processor_ffh_lpi_probe(unsigned int cpu); · 464 unmodified lines
465	extern int acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi);	465	extern int acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi);
466	#endif	466	#endif
467		467
468	#ifdef CONFIG_ACPI_HOTPLUG_CPU
469	extern int arch_register_cpu(int cpu);
470	extern void arch_unregister_cpu(int cpu);
471	#endif
472
473	#endif	468	#endif

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

 	u32 nested_features;
 	u32 max_vp_index;
 	u32 max_lp_index;
+	u8 vtl;
 	union {
 		u32 isolation_config_a;
 		struct {
 		};
 	};
 	u64 shared_gpa_boundary;
-	u8 vtl;
 };
 extern struct ms_hyperv_info ms_hyperv;
 extern bool hv_nested;

include/linux/acpi.h+9−0

@@ -1480,6 +1480,15 @@ static inline int lpit_read_residency_count_address(u64 *address) · 1479 unmodified lines
1480	}	1480	}
1481	#endif	1481	#endif
1482		1482
		1483	#ifdef CONFIG_ACPI_PROCESSOR_IDLE
		1484	#ifndef arch_get_idle_state_flags
		1485	static inline unsigned int arch_get_idle_state_flags(u32 arch_flags)
		1486	{
		1487	return 0;
		1488	}
		1489	#endif
		1490	#endif /* CONFIG_ACPI_PROCESSOR_IDLE */
		1491
1483	#ifdef CONFIG_ACPI_PPTT	1492	#ifdef CONFIG_ACPI_PPTT
1484	int acpi_pptt_cpu_is_thread(unsigned int cpu);	1493	int acpi_pptt_cpu_is_thread(unsigned int cpu);
1485	int find_acpi_cpu_topology(unsigned int cpu, int level);	1494	int find_acpi_cpu_topology(unsigned int cpu, int level);

include/linux/bpf.h+1−1

@@ -1307,7 +1307,7 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, · 1306 unmodified lines
1307	static inline struct bpf_trampoline *bpf_trampoline_get(u64 key,	1307	static inline struct bpf_trampoline *bpf_trampoline_get(u64 key,
1308	struct bpf_attach_target_info *tgt_info)	1308	struct bpf_attach_target_info *tgt_info)
1309	{	1309	{
1310	return ERR_PTR(-EOPNOTSUPP);	1310	return NULL;
1311	}	1311	}
1312	static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}	1312	static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}
1313	#define DEFINE_BPF_DISPATCHER(name)	1313	#define DEFINE_BPF_DISPATCHER(name)

include/linux/cgroup-defs.h+1−1

@@ -238,7 +238,7 @@ struct css_set { · 237 unmodified lines
238	* Lists running through all tasks using this cgroup group.	238	* Lists running through all tasks using this cgroup group.
239	* mg_tasks lists tasks which belong to this cset but are in the	239	* mg_tasks lists tasks which belong to this cset but are in the
240	* process of being migrated out or in. Protected by	240	* process of being migrated out or in. Protected by
241	* css_set_rwsem, but, during migration, once tasks are moved to	241	* css_set_lock, but, during migration, once tasks are moved to
242	* mg_tasks, it can be read safely while holding cgroup_mutex.	242	* mg_tasks, it can be read safely while holding cgroup_mutex.
243	*/	243	*/
244	struct list_head tasks;	244	struct list_head tasks;

include/linux/cpu.h+2−0

 struct device *cpu_device_create(struct device *parent, void *drvdata,
 				 const struct attribute_group **groups,
 				 const char *fmt, ...);
+extern int arch_register_cpu(int cpu);
+extern void arch_unregister_cpu(int cpu);
 #ifdef CONFIG_HOTPLUG_CPU
 extern void unregister_cpu(struct cpu *cpu);
 extern ssize_t arch_cpu_probe(const char *, size_t);

include/linux/dma-fence.h+19−0

@@ -568,6 +568,25 @@ static inline void dma_fence_set_error(struct dma_fence *fence, · 567 unmodified lines
568	fence->error = error;	568	fence->error = error;
569	}	569	}
570		570
		571	/**
		572	* dma_fence_timestamp - helper to get the completion timestamp of a fence
		573	* @fence: fence to get the timestamp from.
		574	*
		575	* After a fence is signaled the timestamp is updated with the signaling time,
		576	* but setting the timestamp can race with tasks waiting for the signaling. This
		577	* helper busy waits for the correct timestamp to appear.
		578	*/
		579	static inline ktime_t dma_fence_timestamp(struct dma_fence *fence)
		580	{
		581	if (WARN_ON(!test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags)))
		582	return ktime_get();
		583
		584	while (!test_bit(DMA_FENCE_FLAG_TIMESTAMP_BIT, &fence->flags))
		585	cpu_relax();
		586
		587	return fence->timestamp;
		588	}
		589
571	signed long dma_fence_wait_timeout(struct dma_fence *,	590	signed long dma_fence_wait_timeout(struct dma_fence *,
572	bool intr, signed long timeout);	591	bool intr, signed long timeout);
573	signed long dma_fence_wait_any_timeout(struct dma_fence **fences,	592	signed long dma_fence_wait_any_timeout(struct dma_fence **fences,

include/linux/fs_context.h+2−0

 extern int vfs_parse_fs_param(struct fs_context *fc, struct fs_parameter *param);
 extern int vfs_parse_fs_string(struct fs_context *fc, const char *key,
 			       const char *value, size_t v_size);
+int vfs_parse_monolithic_sep(struct fs_context *fc, void *data,
+			     char *(*sep)(char **));
 extern int generic_parse_monolithic(struct fs_context *fc, void *data);
 extern int vfs_get_tree(struct fs_context *fc);
 extern void put_fs_context(struct fs_context *fc);

include/linux/mcb.h+0−1

@@ -63,7 +63,6 @@ static inline struct mcb_bus to_mcb_bus(struct device dev) · 62 unmodified lines
63	struct mcb_device {	63	struct mcb_device {
64	struct device dev;	64	struct device dev;
65	struct mcb_bus *bus;	65	struct mcb_bus *bus;
66	bool is_added;
67	struct mcb_driver *driver;	66	struct mcb_driver *driver;
68	u16 id;	67	u16 id;
69	int inst;	68	int inst;

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/quota.h+3−1

 #define DQ_FAKE_B	3	/* no limits only usage */
 #define DQ_READ_B	4	/* dquot was read into memory */
 #define DQ_ACTIVE_B	5	/* dquot is active (dquot_release not called) */
-#define DQ_LASTSET_B	6	/* Following 6 bits (see QIF_) are reserved\
+#define DQ_RELEASING_B	6	/* dquot is in releasing_dquots list waiting
+				 * to be cleaned up */
+#define DQ_LASTSET_B	7	/* Following 6 bits (see QIF_) are reserved\
 				 * for the mask of entries set via SETQUOTA\
 				 * quotactl. They are set under dq_data_lock\
 				 * and the quota format handling dquot can\

include/linux/quotaops.h+1−1

@@ -57,7 +57,7 @@ static inline bool dquot_is_busy(struct dquot *dquot) · 56 unmodified lines
57	{	57	{
58	if (test_bit(DQ_MOD_B, &dquot->dq_flags))	58	if (test_bit(DQ_MOD_B, &dquot->dq_flags))
59	return true;	59	return true;
60	if (atomic_read(&dquot->dq_count) > 1)	60	if (atomic_read(&dquot->dq_count) > 0)
61	return true;	61	return true;
62	return false;	62	return false;
63	}	63	}

include/linux/skbuff.h+2−2

@@ -1309,7 +1309,7 @@ struct sk_buff_fclones { · 1308 unmodified lines
1309	*	1309	*
1310	* Returns true if skb is a fast clone, and its clone is not freed.	1310	* Returns true if skb is a fast clone, and its clone is not freed.
1311	* Some drivers call skb_orphan() in their ndo_start_xmit(),	1311	* Some drivers call skb_orphan() in their ndo_start_xmit(),
1312	* so we also check that this didnt happen.	1312	* so we also check that didn't happen.
1313	*/	1313	*/
1314	static inline bool skb_fclone_busy(const struct sock *sk,	1314	static inline bool skb_fclone_busy(const struct sock *sk,
1315	const struct sk_buff *skb)	1315	const struct sk_buff *skb)
@@ -2016,7 +2016,7 @@ static inline struct sk_buff skb_share_check(struct sk_buff skb, gfp_t pri) · 700 unmodified lines
2016	* Copy shared buffers into a new sk_buff. We effectively do COW on	2016	* Copy shared buffers into a new sk_buff. We effectively do COW on
2017	* packets to handle cases where we have a local reader and forward	2017	* packets to handle cases where we have a local reader and forward
2018	* and a couple of other messy ones. The normal one is tcpdumping	2018	* and a couple of other messy ones. The normal one is tcpdumping
2019	* a packet thats being forwarded.	2019	* a packet that's being forwarded.
2020	*/	2020	*/
2021		2021
2022	/**	2022	/**

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[];	160	struct fib_nh fib_nh[];

include/net/macsec.h+1−0

@@ -258,6 +258,7 @@ struct macsec_context { · 257 unmodified lines
258	struct macsec_secy *secy;	258	struct macsec_secy *secy;
259	struct macsec_rx_sc *rx_sc;	259	struct macsec_rx_sc *rx_sc;
260	struct {	260	struct {
		261	bool update_pn;
261	unsigned char assoc_num;	262	unsigned char assoc_num;
262	u8 key[MACSEC_MAX_KEY_LEN];	263	u8 key[MACSEC_MAX_KEY_LEN];
263	union {	264	union {

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/sound/soc.h+2−0

@@ -1126,6 +1126,8 @@ struct snd_soc_pcm_runtime { · 1125 unmodified lines
1126	unsigned int pop_wait:1;	1126	unsigned int pop_wait:1;
1127	unsigned int fe_compr:1; /* for Dynamic PCM */	1127	unsigned int fe_compr:1; /* for Dynamic PCM */
1128		1128
		1129	bool initialized;
		1130
1129	int num_components;	1131	int num_components;
1130	struct snd_soc_component components[]; / CPU/Codec/Platform */	1132	struct snd_soc_component components[]; / CPU/Codec/Platform */
1131	};	1133	};

include/uapi/drm/nouveau_drm.h+10−0

@@ -44,6 +44,16 @@ extern "C" { · 43 unmodified lines
44	#define NOUVEAU_GETPARAM_PTIMER_TIME 14	44	#define NOUVEAU_GETPARAM_PTIMER_TIME 14
45	#define NOUVEAU_GETPARAM_HAS_BO_USAGE 15	45	#define NOUVEAU_GETPARAM_HAS_BO_USAGE 15
46	#define NOUVEAU_GETPARAM_HAS_PAGEFLIP 16	46	#define NOUVEAU_GETPARAM_HAS_PAGEFLIP 16
		47
		48	/**
		49	* @NOUVEAU_GETPARAM_EXEC_PUSH_MAX
		50	*
		51	* Query the maximum amount of IBs that can be pushed through a single
		52	* &drm_nouveau_exec structure and hence a single &DRM_IOCTL_NOUVEAU_EXEC
		53	* ioctl().
		54	*/
		55	#define NOUVEAU_GETPARAM_EXEC_PUSH_MAX 17
		56
47	struct drm_nouveau_getparam {	57	struct drm_nouveau_getparam {
48	__u64 param;	58	__u64 param;
49	__u64 value;	59	__u64 value;

include/uapi/linux/if_packet.h+1−5

 	unsigned short	sll_hatype;
 	unsigned char	sll_pkttype;
 	unsigned char	sll_halen;
-	union {
+	unsigned char	sll_addr[8];
-		unsigned char	sll_addr[8];
-		/* Actual length is in sll_halen. */
-		__DECLARE_FLEX_ARRAY(unsigned char, sll_addr_flex);
-	};
 };
 /* Packet types */

io_uring/io-wq.c+4−6

 	wq = kzalloc(sizeof(struct io_wq), GFP_KERNEL);
 	if (!wq)
 		return ERR_PTR(-ENOMEM);
-	ret = cpuhp_state_add_instance_nocalls(io_wq_online, &wq->cpuhp_node);
-	if (ret)
-		goto err_wq;
 	refcount_inc(&data->hash->refs);
 	wq->hash = data->hash;
 	wq->task = get_task_struct(data->task);
 	atomic_set(&wq->worker_refs, 1);
 	init_completion(&wq->worker_done);
+	ret = cpuhp_state_add_instance_nocalls(io_wq_online, &wq->cpuhp_node);
+	if (ret)
+		goto err;
 	return wq;
 err:
 	io_wq_put_hash(data->hash);
-	cpuhp_state_remove_instance_nocalls(io_wq_online, &wq->cpuhp_node);
 	free_cpumask_var(wq->cpu_mask);
-err_wq:
 	kfree(wq);
 	return ERR_PTR(ret);
 }

io_uring/io_uring.c+15−1

@@ -2686,7 +2686,7 @@ static void __io_uaddr_map(struct page *pages, unsigned short npages, · 2685 unmodified lines
2686	{	2686	{
2687	struct page **page_array;	2687	struct page **page_array;
2688	unsigned int nr_pages;	2688	unsigned int nr_pages;
2689	int ret;	2689	int ret, i;
2690		2690
2691	*npages = 0;	2691	*npages = 0;
2692		2692
@@ -2716,6 +2716,20 @@ err: · 23 unmodified lines
2716	*/	2716	*/
2717	if (page_array[0] != page_array[ret - 1])	2717	if (page_array[0] != page_array[ret - 1])
2718	goto err;	2718	goto err;
		2719
		2720	/*
		2721	* Can't support mapping user allocated ring memory on 32-bit archs
		2722	* where it could potentially reside in highmem. Just fail those with
		2723	* -EINVAL, just like we did on kernels that didn't support this
		2724	* feature.
		2725	*/
		2726	for (i = 0; i < nr_pages; i++) {
		2727	if (PageHighMem(page_array[i])) {
		2728	ret = -EINVAL;
		2729	goto err;
		2730	}
		2731	}
		2732
2719	*pages = page_array;	2733	*pages = page_array;
2720	*npages = nr_pages;	2734	*npages = nr_pages;
2721	return page_to_virt(page_array[0]);	2735	return page_to_virt(page_array[0]);

io_uring/io_uring.h+27−14

@@ -86,20 +86,33 @@ bool __io_alloc_req_refill(struct io_ring_ctx *ctx); · 85 unmodified lines
86	bool io_match_task_safe(struct io_kiocb head, struct task_struct task,	86	bool io_match_task_safe(struct io_kiocb head, struct task_struct task,
87	bool cancel_all);	87	bool cancel_all);
88		88
89	#define io_lockdep_assert_cq_locked(ctx) \	89	#if defined(CONFIG_PROVE_LOCKING)
90	do { \	90	static inline void io_lockdep_assert_cq_locked(struct io_ring_ctx *ctx)
91	lockdep_assert(in_task()); \	91	{
92	\	92	lockdep_assert(in_task());
93	if (ctx->flags & IORING_SETUP_IOPOLL) { \	93
94	lockdep_assert_held(&ctx->uring_lock); \	94	if (ctx->flags & IORING_SETUP_IOPOLL) {
95	} else if (!ctx->task_complete) { \	95	lockdep_assert_held(&ctx->uring_lock);
96	lockdep_assert_held(&ctx->completion_lock); \	96	} else if (!ctx->task_complete) {
97	} else if (ctx->submitter_task->flags & PF_EXITING) { \	97	lockdep_assert_held(&ctx->completion_lock);
98	lockdep_assert(current_work()); \	98	} else if (ctx->submitter_task) {
99	} else { \	99	/*
100	lockdep_assert(current == ctx->submitter_task); \	100	* ->submitter_task may be NULL and we can still post a CQE,
101	} \	101	* if the ring has been setup with IORING_SETUP_R_DISABLED.
102	} while (0)	102	* Not from an SQE, as those cannot be submitted, but via
		103	* updating tagged resources.
		104	*/
		105	if (ctx->submitter_task->flags & PF_EXITING)
		106	lockdep_assert(current_work());
		107	else
		108	lockdep_assert(current == ctx->submitter_task);
		109	}
		110	}
		111	#else
		112	static inline void io_lockdep_assert_cq_locked(struct io_ring_ctx *ctx)
		113	{
		114	}
		115	#endif
103		116
104	static inline void io_req_task_work_add(struct io_kiocb *req)	117	static inline void io_req_task_work_add(struct io_kiocb *req)
105	{	118	{

io_uring/kbuf.c+19−8

 {
 	struct io_uring_buf_ring *br;
 	struct page **pages;
-	int nr_pages;
+	int i, nr_pages;
 	pages = io_pin_pages(reg->ring_addr,
 			     flex_array_size(br, bufs, reg->ring_entries),
 	if (IS_ERR(pages))
 		return PTR_ERR(pages);
+	/*
+	 * Apparently some 32-bit boxes (ARM) will return highmem pages,
+	 * which then need to be mapped. We could support that, but it'd
+	 * complicate the code and slowdown the common cases quite a bit.
+	 * So just error out, returning -EINVAL just like we did on kernels
+	 * that didn't support mapped buffer rings.
+	 */
+	for (i = 0; i < nr_pages; i++)
+		if (PageHighMem(pages[i]))
+			goto error_unpin;
 	br = page_address(pages[0]);
 #ifdef SHM_COLOUR
 	/*
 	 * should use IOU_PBUF_RING_MMAP instead, and liburing will handle
 	 * this transparently.
 	 */
-	if ((reg->ring_addr | (unsigned long) br) & (SHM_COLOUR - 1)) {
+	if ((reg->ring_addr | (unsigned long) br) & (SHM_COLOUR - 1))
-		int i;
+		goto error_unpin;
-		for (i = 0; i < nr_pages; i++)
-			unpin_user_page(pages[i]);
-		return -EINVAL;
-	}
 #endif
 	bl->buf_pages = pages;
 	bl->buf_nr_pages = nr_pages;
 	bl->is_mapped = 1;
 	bl->is_mmap = 0;
 	return 0;
+error_unpin:
+	for (i = 0; i < nr_pages; i++)
+		unpin_user_page(pages[i]);
+	kvfree(pages);
+	return -EINVAL;
 }
 static int io_alloc_pbuf_ring(struct io_uring_buf_reg *reg,

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+9−4

 			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);
 	struct bpf_mprog_cp *cp;
 	struct bpf_prog *prog;
 	const u32 flags = 0;
+	u32 id, count = 0;
+	u64 revision = 1;
 	int i, ret = 0;
-	u32 id, count;
-	u64 revision;
 	if (attr->query.query_flags || attr->query.attach_flags)
 		return -EINVAL;
-	revision = bpf_mprog_revision(entry);
+	if (entry) {
-	count = bpf_mprog_total(entry);
+		revision = bpf_mprog_revision(entry);
+		count = bpf_mprog_total(entry);
+	}
 	if (copy_to_user(&uattr->query.attach_flags, &flags, sizeof(flags)))
 		return -EFAULT;
 	if (copy_to_user(&uattr->query.revision, &revision, sizeof(revision)))

kernel/bpf/syscall.c+15−6

 {
 	enum bpf_prog_type ptype;
 	struct bpf_prog *prog;
-	u32 mask;
 	int ret;
 	if (CHECK_ATTR(BPF_PROG_ATTACH))
 	ptype = attach_type_to_prog_type(attr->attach_type);
 	if (ptype == BPF_PROG_TYPE_UNSPEC)
 		return -EINVAL;
-	mask = bpf_mprog_supported(ptype) ?
+	if (bpf_mprog_supported(ptype)) {
-	       BPF_F_ATTACH_MASK_MPROG : BPF_F_ATTACH_MASK_BASE;
+		if (attr->attach_flags & ~BPF_F_ATTACH_MASK_MPROG)
-	if (attr->attach_flags & ~mask)
+			return -EINVAL;
-		return -EINVAL;
+	} else {
+		if (attr->attach_flags & ~BPF_F_ATTACH_MASK_BASE)
+			return -EINVAL;
+		if (attr->relative_fd ||
+		    attr->expected_revision)
+			return -EINVAL;
+	}
 	prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);
 	if (IS_ERR(prog))
 			if (IS_ERR(prog))
 				return PTR_ERR(prog);
 		}
+	} else if (attr->attach_flags ||
+		   attr->relative_fd ||
+		   attr->expected_revision) {
+		return -EINVAL;
 	}
 	switch (ptype) {
 	return ret;
 }
-#define BPF_PROG_QUERY_LAST_FIELD query.link_attach_flags
+#define BPF_PROG_QUERY_LAST_FIELD query.revision
 static int bpf_prog_query(const union bpf_attr *attr,
 			  union bpf_attr __user *uattr)

kernel/bpf/tcx.c+1−7

 {
 	bool ingress = attr->query.attach_type == BPF_TCX_INGRESS;
 	struct net *net = current->nsproxy->net_ns;
-	struct bpf_mprog_entry *entry;
 	struct net_device *dev;
 	int ret;
 		ret = -ENODEV;
 		goto out;
 	}
-	entry = tcx_entry_fetch(dev, ingress);
+	ret = bpf_mprog_query(attr, uattr, tcx_entry_fetch(dev, ingress));
-	if (!entry) {
-		ret = -ENOENT;
-		goto out;
-	}
-	ret = bpf_mprog_query(attr, uattr, entry);
 out:
 	rtnl_unlock();
 	return ret;

kernel/bpf/verifier.c+6−8

 				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;
 			}
 	struct tnum enforce_attach_type_range = tnum_unknown;
 	const struct bpf_prog *prog = env->prog;
 	struct bpf_reg_state *reg;
-	struct tnum range = tnum_range(0, 1);
+	struct tnum range = tnum_range(0, 1), const_0 = tnum_const(0);
 	enum bpf_prog_type prog_type = resolve_prog_type(env->prog);
 	int err;
 	struct bpf_func_state *frame = env->cur_state->frame[0];
 			return -EINVAL;
 		}
-		if (!tnum_in(tnum_const(0), reg->var_off)) {
+		if (!tnum_in(const_0, reg->var_off)) {
-			verbose_invalid_scalar(env, reg, &range, "async callback", "R0");
+			verbose_invalid_scalar(env, reg, &const_0, "async callback", "R0");
 			return -EINVAL;
 		}
 		return 0;

kernel/cgroup/cgroup-v1.c+2−3

 	}
 	css_task_iter_end(&it);
 	length = n;
-	/* now sort & (if procs) strip out duplicates */
+	/* now sort & strip out duplicates (tgids or recycled thread PIDs) */
 	sort(array, length, sizeof(pid_t), cmppid, NULL);
-	if (type == CGROUP_FILE_PROCS)
+	length = pidlist_uniq(array, length);
-		length = pidlist_uniq(array, length);
 	l = cgroup_pidlist_find_create(cgrp, type);
 	if (!l) {

kernel/power/snapshot.c+2−2

@@ -2647,7 +2647,7 @@ static int prepare_image(struct memory_bitmap new_bm, struct memory_bitmap bm, · 2646 unmodified lines
2647	memory_bm_free(bm, PG_UNSAFE_KEEP);	2647	memory_bm_free(bm, PG_UNSAFE_KEEP);
2648		2648
2649	/* Make a copy of zero_bm so it can be created in safe pages */	2649	/* Make a copy of zero_bm so it can be created in safe pages */
2650	error = memory_bm_create(&tmp, GFP_ATOMIC, PG_ANY);	2650	error = memory_bm_create(&tmp, GFP_ATOMIC, PG_SAFE);
2651	if (error)	2651	if (error)
2652	goto Free;	2652	goto Free;
2653		2653
@@ -2660,7 +2660,7 @@ static int prepare_image(struct memory_bitmap new_bm, struct memory_bitmap bm, · 6 unmodified lines
2660	goto Free;	2660	goto Free;
2661		2661
2662	duplicate_memory_bitmap(zero_bm, &tmp);	2662	duplicate_memory_bitmap(zero_bm, &tmp);
2663	memory_bm_free(&tmp, PG_UNSAFE_KEEP);	2663	memory_bm_free(&tmp, PG_UNSAFE_CLEAR);
2664	/* At this point zero_bm is in safe pages and it can be used for restoring. */	2664	/* At this point zero_bm is in safe pages and it can be used for restoring. */
2665		2665
2666	if (nr_highmem > 0) {	2666	if (nr_highmem > 0) {

kernel/printk/printk.c+7−1

 	seq = prb_next_seq(prb);
+	/* Flush the consoles so that records up to @seq are printed. */
+	console_lock();
+	console_unlock();
 	for (;;) {
 		diff = 0;
 		/*
 		 * Hold the console_lock to guarantee safe access to
-		 * console->seq.
+		 * console->seq. Releasing console_lock flushes more
+		 * records in case @seq is still not printed on all
+		 * usable consoles.
 		 */
 		console_lock();

kernel/sched/cpufreq_schedutil.c+2−1

@@ -350,7 +350,8 @@ static void sugov_update_single_freq(struct update_util_data *hook, u64 time, · 349 unmodified lines
350	* Except when the rq is capped by uclamp_max.	350	* Except when the rq is capped by uclamp_max.
351	*/	351	*/
352	if (!uclamp_rq_is_capped(cpu_rq(sg_cpu->cpu)) &&	352	if (!uclamp_rq_is_capped(cpu_rq(sg_cpu->cpu)) &&
353	sugov_cpu_is_busy(sg_cpu) && next_f < sg_policy->next_freq) {	353	sugov_cpu_is_busy(sg_cpu) && next_f < sg_policy->next_freq &&
		354	!sg_policy->need_freq_update) {
354	next_f = sg_policy->next_freq;	355	next_f = sg_policy->next_freq;
355		356
356	/* Restore cached freq as next_freq has changed */	357	/* Restore cached freq as next_freq has changed */

kernel/sched/fair.c+72−17

 	cfs_rq->avg_vruntime -= cfs_rq->avg_load * delta;
 }
+/*
+ * Specifically: avg_runtime() + 0 must result in entity_eligible() := true
+ * For this to be so, the result of this function must have a left bias.
+ */
 u64 avg_vruntime(struct cfs_rq *cfs_rq)
 {
 	struct sched_entity *curr = cfs_rq->curr;
 		load += weight;
 	}
-	if (load)
+	if (load) {
+		/* sign flips effective floor / ceil */
+		if (avg < 0)
+			avg -= (load - 1);
 		avg = div_s64(avg, load);
+	}
 	return cfs_rq->min_vruntime + avg;
 }
  *
  * Which allows an EDF like search on (sub)trees.
  */
-static struct sched_entity *pick_eevdf(struct cfs_rq *cfs_rq)
+static struct sched_entity *__pick_eevdf(struct cfs_rq *cfs_rq)
 {
 	struct rb_node *node = cfs_rq->tasks_timeline.rb_root.rb_node;
 	struct sched_entity *curr = cfs_rq->curr;
 	struct sched_entity *best = NULL;
+	struct sched_entity *best_left = NULL;
 	if (curr && (!curr->on_rq || !entity_eligible(cfs_rq, curr)))
 		curr = NULL;
+	best = curr;
 	/*
 	 * Once selected, run a task until it either becomes non-eligible or
 		}
 		/*
-		 * If this entity has an earlier deadline than the previous
+		 * Now we heap search eligible trees for the best (min_)deadline
-		 * best, take this one. If it also has the earliest deadline
-		 * of its subtree, we're done.
 		 */
-		if (!best || deadline_gt(deadline, best, se)) {
+		if (!best || deadline_gt(deadline, best, se))
 			best = se;
-			if (best->deadline == best->min_deadline)
-				break;
-		}
 		/*
-		 * If the earlest deadline in this subtree is in the fully
+		 * Every se in a left branch is eligible, keep track of the
-		 * eligible left half of our space, go there.
+		 * branch with the best min_deadline
 		 */
+		if (node->rb_left) {
+			struct sched_entity *left = __node_2_se(node->rb_left);
+			if (!best_left || deadline_gt(min_deadline, best_left, left))
+				best_left = left;
+			/*
+			 * min_deadline is in the left branch. rb_left and all
+			 * descendants are eligible, so immediately switch to the second
+			 * loop.
+			 */
+			if (left->min_deadline == se->min_deadline)
+				break;
+		}
+		/* min_deadline is at this node, no need to look right */
+		if (se->deadline == se->min_deadline)
+			break;
+		/* else min_deadline is in the right branch. */
+		node = node->rb_right;
+	}
+	/*
+	 * We ran into an eligible node which is itself the best.
+	 * (Or nr_running == 0 and both are NULL)
+	 */
+	if (!best_left || (s64)(best_left->min_deadline - best->deadline) > 0)
+		return best;
+	/*
+	 * Now best_left and all of its children are eligible, and we are just
+	 * looking for deadline == min_deadline
+	 */
+	node = &best_left->run_node;
+	while (node) {
+		struct sched_entity *se = __node_2_se(node);
+		/* min_deadline is the current node */
+		if (se->deadline == se->min_deadline)
+			return se;
+		/* min_deadline is in the left branch */
 		if (node->rb_left &&
 		    __node_2_se(node->rb_left)->min_deadline == se->min_deadline) {
 			node = node->rb_left;
 			continue;
 		}
+		/* else min_deadline is in the right branch */
 		node = node->rb_right;
 	}
+	return NULL;
+}
-	if (!best || (curr && deadline_gt(deadline, best, curr)))
+static struct sched_entity *pick_eevdf(struct cfs_rq *cfs_rq)
-		best = curr;
+{
+	struct sched_entity *se = __pick_eevdf(cfs_rq);
-	if (unlikely(!best)) {
+	if (!se) {
 		struct sched_entity *left = __pick_first_entity(cfs_rq);
 		if (left) {
 			pr_err("EEVDF scheduling fail, picking leftmost\n");
 		}
 	}
-	return best;
+	return se;
 }
 #ifdef CONFIG_SCHED_DEBUG
 		 */
 		deadline = div_s64(deadline * old_weight, weight);
 		se->deadline = se->vruntime + deadline;
+		min_deadline_cb_propagate(&se->run_node, NULL);
 	}
 #ifdef CONFIG_SMP
 static void
 place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
 {
-	u64 vslice = calc_delta_fair(se->slice, se);
+	u64 vslice, vruntime = avg_vruntime(cfs_rq);
-	u64 vruntime = avg_vruntime(cfs_rq);
 	s64 lag = 0;
+	se->slice = sysctl_sched_base_slice;
+	vslice = calc_delta_fair(se->slice, se);
 	/*
 	 * Due to how V is constructed as the weighted average of entities,
 	 * adding tasks with positive lag, or removing tasks with negative lag

kernel/workqueue.c+19−5

 {
 	struct worker *worker;
 	int id;
-	char id_buf[16];
+	char id_buf[23];
 	/* ID is needed to determine kthread name */
 	id = ida_alloc(&pool->worker_ida, GFP_KERNEL);
 	}
 	cpus_read_unlock();
+	/* for unbound pwq, flush the pwq_release_worker ensures that the
+	 * pwq_release_workfn() completes before calling kfree(wq).
+	 */
+	if (ret)
+		kthread_flush_worker(pwq_release_worker);
 	return ret;
 enomem:
 	if (wq->cpu_pwq) {
-		for_each_possible_cpu(cpu)
+		for_each_possible_cpu(cpu) {
-			kfree(*per_cpu_ptr(wq->cpu_pwq, cpu));
+			struct pool_workqueue *pwq = *per_cpu_ptr(wq->cpu_pwq, cpu);
+			if (pwq)
+				kmem_cache_free(pwq_cache, pwq);
+		}
 		free_percpu(wq->cpu_pwq);
 		wq->cpu_pwq = NULL;
 	}
 	list_for_each_entry(wq, &workqueues, list) {
 		if (!(wq->flags & WQ_UNBOUND))
 			continue;
 		/* creating multiple pwqs breaks ordering guarantee */
-		if (wq->flags & __WQ_ORDERED)
+		if (!list_empty(&wq->pwqs)) {
-			continue;
+			if (wq->flags & __WQ_ORDERED_EXPLICIT)
+				continue;
+			wq->flags &= ~__WQ_ORDERED;
+		}
 		ctx = apply_wqattrs_prepare(wq, wq->unbound_attrs, unbound_cpumask);
 		if (IS_ERR(ctx)) {

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/can/isotp.c+8−11

 	if (!so->bound || so->tx.state == ISOTP_SHUTDOWN)
 		return -EADDRNOTAVAIL;
-wait_free_buffer:
+	while (cmpxchg(&so->tx.state, ISOTP_IDLE, ISOTP_SENDING) != ISOTP_IDLE) {
-	/* we do not support multiple buffers - for now */
+		/* we do not support multiple buffers - for now */
-	if (wq_has_sleeper(&so->wait) && (msg->msg_flags & MSG_DONTWAIT))
+		if (msg->msg_flags & MSG_DONTWAIT)
-		return -EAGAIN;
+			return -EAGAIN;
-	/* wait for complete transmission of current pdu */
-	err = wait_event_interruptible(so->wait, so->tx.state == ISOTP_IDLE);
-	if (err)
-		goto err_event_drop;
-	if (cmpxchg(&so->tx.state, ISOTP_IDLE, ISOTP_SENDING) != ISOTP_IDLE) {
 		if (so->tx.state == ISOTP_SHUTDOWN)
 			return -EADDRNOTAVAIL;
-		goto wait_free_buffer;
+		/* wait for complete transmission of current pdu */
+		err = wait_event_interruptible(so->wait, so->tx.state == ISOTP_IDLE);
+		if (err)
+			goto err_event_drop;
 	}
 	/* PDU size > default => try max_pdu_size */

net/ceph/messenger.c+2−2

@@ -459,8 +459,8 @@ int ceph_tcp_connect(struct ceph_connection *con) · 458 unmodified lines
459	set_sock_callbacks(sock, con);	459	set_sock_callbacks(sock, con);
460		460
461	con_sock_state_connecting(con);	461	con_sock_state_connecting(con);
462	ret = sock->ops->connect(sock, (struct sockaddr *)&ss, sizeof(ss),	462	ret = kernel_connect(sock, (struct sockaddr *)&ss, sizeof(ss),
463	O_NONBLOCK);	463	O_NONBLOCK);
464	if (ret == -EINPROGRESS) {	464	if (ret == -EINPROGRESS) {
465	dout("connect %s EINPROGRESS sk_state = %u\n",	465	dout("connect %s EINPROGRESS sk_state = %u\n",
466	ceph_pr_addr(&con->peer_addr),	466	ceph_pr_addr(&con->peer_addr),

net/core/dev.c+6−2

 	offset = skb_checksum_start_offset(skb);
 	ret = -EINVAL;
-	if (WARN_ON_ONCE(offset >= skb_headlen(skb))) {
+	if (unlikely(offset >= skb_headlen(skb))) {
 		DO_ONCE_LITE(skb_dump, KERN_ERR, skb, false);
+		WARN_ONCE(true, "offset (%d) >= skb_headlen() (%u)\n",
+			  offset, skb_headlen(skb));
 		goto out;
 	}
 	csum = skb_checksum(skb, offset, skb->len - offset, 0);
 	offset += skb->csum_offset;
-	if (WARN_ON_ONCE(offset + sizeof(__sum16) > skb_headlen(skb))) {
+	if (unlikely(offset + sizeof(__sum16) > skb_headlen(skb))) {
 		DO_ONCE_LITE(skb_dump, KERN_ERR, skb, false);
+		WARN_ONCE(true, "offset+2 (%zu) > skb_headlen() (%u)\n",
+			  offset + sizeof(__sum16), skb_headlen(skb));
 		goto out;
 	}
 	ret = skb_ensure_writable(skb, offset + sizeof(__sum16));

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/devlink/health.c+16−14

 	struct devlink *devlink;
 	struct devlink_port *devlink_port;
 	struct devlink_fmsg *dump_fmsg;
-	struct mutex dump_lock; /* lock parallel read/write from dump buffers */
 	u64 graceful_period;
 	bool auto_recover;
 	bool auto_dump;
 	reporter->graceful_period = graceful_period;
 	reporter->auto_recover = !!ops->recover;
 	reporter->auto_dump = !!ops->dump;
-	mutex_init(&reporter->dump_lock);
 	return reporter;
 }
 static void
 devlink_health_reporter_free(struct devlink_health_reporter *reporter)
 {
-	mutex_destroy(&reporter->dump_lock);
 	if (reporter->dump_fmsg)
 		devlink_fmsg_free(reporter->dump_fmsg);
 	kfree(reporter);
 	}
 	if (reporter->auto_dump) {
-		mutex_lock(&reporter->dump_lock);
+		devl_lock(devlink);
 		/* store current dump of current error, for later analysis */
 		devlink_health_do_dump(reporter, priv_ctx, NULL);
-		mutex_unlock(&reporter->dump_lock);
+		devl_unlock(devlink);
 	}
 	if (!reporter->auto_recover)
 }
 static struct devlink_health_reporter *
-devlink_health_reporter_get_from_cb(struct netlink_callback *cb)
+devlink_health_reporter_get_from_cb_lock(struct netlink_callback *cb)
 {
 	const struct genl_info *info = genl_info_dump(cb);
 	struct devlink_health_reporter *reporter;
 	devlink = devlink_get_from_attrs_lock(sock_net(cb->skb->sk), attrs);
 	if (IS_ERR(devlink))
 		return NULL;
-	devl_unlock(devlink);
 	reporter = devlink_health_reporter_get_from_attrs(devlink, attrs);
-	devlink_put(devlink);
+	if (!reporter) {
+		devl_unlock(devlink);
+		devlink_put(devlink);
+	}
 	return reporter;
 }
 {
 	struct devlink_nl_dump_state *state = devlink_dump_state(cb);
 	struct devlink_health_reporter *reporter;
+	struct devlink *devlink;
 	int err;
-	reporter = devlink_health_reporter_get_from_cb(cb);
+	reporter = devlink_health_reporter_get_from_cb_lock(cb);
 	if (!reporter)
 		return -EINVAL;
-	if (!reporter->ops->dump)
+	devlink = reporter->devlink;
+	if (!reporter->ops->dump) {
+		devl_unlock(devlink);
+		devlink_put(devlink);
 		return -EOPNOTSUPP;
+	}
-	mutex_lock(&reporter->dump_lock);
 	if (!state->idx) {
 		err = devlink_health_do_dump(reporter, NULL, cb->extack);
 		if (err)
 	err = devlink_fmsg_dumpit(reporter->dump_fmsg, skb, cb,
 				  DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET);
 unlock:
-	mutex_unlock(&reporter->dump_lock);
+	devl_unlock(devlink);
+	devlink_put(devlink);
 	return err;
 }
 	if (!reporter->ops->dump)
 		return -EOPNOTSUPP;
-	mutex_lock(&reporter->dump_lock);
 	devlink_health_dump_clear(reporter);
-	mutex_unlock(&reporter->dump_lock);
 	return 0;
 }

net/ethtool/bitset.c+26−6

 			      ethnl_string_array_t names,
 			      struct netlink_ext_ack *extack, bool *mod)
 {
+	u32 *orig_bitmap, *saved_bitmap = NULL;
 	struct nlattr *bit_attr;
 	bool no_mask;
+	bool dummy;
 	int rem;
 	int ret;
 	}
 	no_mask = tb[ETHTOOL_A_BITSET_NOMASK];
-	if (no_mask)
+	if (no_mask) {
-		ethnl_bitmap32_clear(bitmap, 0, nbits, mod);
+		unsigned int nwords = DIV_ROUND_UP(nbits, 32);
+		unsigned int nbytes = nwords * sizeof(u32);
+		/* The bitmap size is only the size of the map part without
+		 * its mask part.
+		 */
+		saved_bitmap = kcalloc(nwords, sizeof(u32), GFP_KERNEL);
+		if (!saved_bitmap)
+			return -ENOMEM;
+		memcpy(saved_bitmap, bitmap, nbytes);
+		ethnl_bitmap32_clear(bitmap, 0, nbits, &dummy);
+		orig_bitmap = saved_bitmap;
+	} else {
+		orig_bitmap = bitmap;
+	}
 	nla_for_each_nested(bit_attr, tb[ETHTOOL_A_BITSET_BITS], rem) {
 		bool old_val, new_val;
 		if (nla_type(bit_attr) != ETHTOOL_A_BITSET_BITS_BIT) {
 			NL_SET_ERR_MSG_ATTR(extack, bit_attr,
 					    "only ETHTOOL_A_BITSET_BITS_BIT allowed in ETHTOOL_A_BITSET_BITS");
-			return -EINVAL;
+			ret = -EINVAL;
+			goto out;
 		}
 		ret = ethnl_parse_bit(&idx, &new_val, nbits, bit_attr, no_mask,
 				      names, extack);
 		if (ret < 0)
-			return ret;
+			goto out;
-		old_val = bitmap[idx / 32] & ((u32)1 << (idx % 32));
+		old_val = orig_bitmap[idx / 32] & ((u32)1 << (idx % 32));
 		if (new_val != old_val) {
 			if (new_val)
 				bitmap[idx / 32] |= ((u32)1 << (idx % 32));
 		}
 	}
-	return 0;
+	ret = 0;
+out:
+	kfree(saved_bitmap);
+	return ret;
 }
 static int ethnl_compact_sanity_checks(unsigned int nbits,

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+4−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);
 	/* build the payload, and be prepared to abort if this fails. */
 	if (tcp_clone_payload(sk, nskb, probe_size)) {
+		tcp_skb_tsorted_anchor_cleanup(nskb);
 		consume_skb(nskb);
 		return -1;
 	}

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/mctp/route.c+16−6

@@ -737,6 +737,8 @@ struct mctp_route mctp_route_lookup(struct net net, unsigned int dnet, · 736 unmodified lines
737	{	737	{
738	struct mctp_route tmp, rt = NULL;	738	struct mctp_route tmp, rt = NULL;
739		739
		740	rcu_read_lock();
		741
740	list_for_each_entry_rcu(tmp, &net->mctp.routes, list) {	742	list_for_each_entry_rcu(tmp, &net->mctp.routes, list) {
741	/* TODO: add metrics */	743	/* TODO: add metrics */
742	if (mctp_rt_match_eid(tmp, dnet, daddr)) {	744	if (mctp_rt_match_eid(tmp, dnet, daddr)) {
@@ -747,21 +749,29 @@ struct mctp_route mctp_route_lookup(struct net net, unsigned int dnet, · 4 unmodified lines
747	}	749	}
748	}	750	}
749		751
		752	rcu_read_unlock();
		753
750	return rt;	754	return rt;
751	}	755	}
752		756
753	static struct mctp_route mctp_route_lookup_null(struct net net,	757	static struct mctp_route mctp_route_lookup_null(struct net net,
754	struct net_device *dev)	758	struct net_device *dev)
755	{	759	{
756	struct mctp_route *rt;	760	struct mctp_route tmp, rt = NULL;
757		761
758	list_for_each_entry_rcu(rt, &net->mctp.routes, list) {	762	rcu_read_lock();
759	if (rt->dev->dev == dev && rt->type == RTN_LOCAL &&	763
760	refcount_inc_not_zero(&rt->refs))	764	list_for_each_entry_rcu(tmp, &net->mctp.routes, list) {
761	return rt;	765	if (tmp->dev->dev == dev && tmp->type == RTN_LOCAL &&
		766	refcount_inc_not_zero(&tmp->refs)) {
		767	rt = tmp;
		768	break;
		769	}
762	}	770	}
763		771
764	return NULL;	772	rcu_read_unlock();
		773
		774	return rt;
765	}	775	}
766		776
767	static int mctp_do_fragment_route(struct mctp_route rt, struct sk_buff skb,	777	static int mctp_do_fragment_route(struct mctp_route rt, struct sk_buff skb,

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

@@ -1439,7 +1439,7 @@ static int bind_mcastif_addr(struct socket sock, struct net_device dev) · 1438 unmodified lines
1439	sin.sin_addr.s_addr = addr;	1439	sin.sin_addr.s_addr = addr;
1440	sin.sin_port = 0;	1440	sin.sin_port = 0;
1441		1441
1442	return sock->ops->bind(sock, (struct sockaddr*)&sin, sizeof(sin));	1442	return kernel_bind(sock, (struct sockaddr *)&sin, sizeof(sin));
1443	}	1443	}
1444		1444
1445	static void get_mcast_sockaddr(union ipvs_sockaddr sa, int salen,	1445	static void get_mcast_sockaddr(union ipvs_sockaddr sa, int salen,
@@ -1505,8 +1505,8 @@ static int make_send_sock(struct netns_ipvs *ipvs, int id, · 59 unmodified lines
1505	}	1505	}
1506		1506
1507	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->mcfg, id);	1507	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->mcfg, id);
1508	result = sock->ops->connect(sock, (struct sockaddr *) &mcast_addr,	1508	result = kernel_connect(sock, (struct sockaddr *)&mcast_addr,
1509	salen, 0);	1509	salen, 0);
1510	if (result < 0) {	1510	if (result < 0) {
1511	pr_err("Error connecting to the multicast addr\n");	1511	pr_err("Error connecting to the multicast addr\n");
1512	goto error;	1512	goto error;
@@ -1546,7 +1546,7 @@ static int make_receive_sock(struct netns_ipvs *ipvs, int id, · 33 unmodified lines
1546		1546
1547	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->bcfg, id);	1547	get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->bcfg, id);
1548	sock->sk->sk_bound_dev_if = dev->ifindex;	1548	sock->sk->sk_bound_dev_if = dev->ifindex;
1549	result = sock->ops->bind(sock, (struct sockaddr *)&mcast_addr, salen);	1549	result = kernel_bind(sock, (struct sockaddr *)&mcast_addr, salen);
1550	if (result < 0) {	1550	if (result < 0) {
1551	pr_err("Error binding to the multicast addr\n");	1551	pr_err("Error binding to the multicast addr\n");
1552	goto error;	1552	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+14−18

 		if (tmp_sock->ssap == ssap && tmp_sock->dsap == dsap) {
 			llcp_sock = tmp_sock;
+			sock_hold(&llcp_sock->sk);
 			break;
 		}
 	}
 	read_unlock(&local->sockets.lock);
-	if (llcp_sock == NULL)
-		return NULL;
-	sock_hold(&llcp_sock->sk);
 	return llcp_sock;
 }
 static
 struct nfc_llcp_sock *nfc_llcp_sock_from_sn(struct nfc_llcp_local *local,
-					    const u8 *sn, size_t sn_len)
+					    const u8 *sn, size_t sn_len,
+					    bool needref)
 {
 	struct sock *sk;
 	struct nfc_llcp_sock *llcp_sock, *tmp_sock;
 		if (memcmp(sn, tmp_sock->service_name, sn_len) == 0) {
 			llcp_sock = tmp_sock;
+			if (needref)
+				sock_hold(&llcp_sock->sk);
 			break;
 		}
 	}
 		 * to this service name.
 		 */
 		if (nfc_llcp_sock_from_sn(local, sock->service_name,
-					  sock->service_name_len) != NULL) {
+					  sock->service_name_len,
+					  false) != NULL) {
 			mutex_unlock(&local->sdp_lock);
 			return LLCP_SAP_MAX;
 static struct nfc_llcp_sock *nfc_llcp_sock_get_sn(struct nfc_llcp_local *local,
 						  const u8 *sn, size_t sn_len)
 {
-	struct nfc_llcp_sock *llcp_sock;
+	return nfc_llcp_sock_from_sn(local, sn, sn_len, true);
-	llcp_sock = nfc_llcp_sock_from_sn(local, sn, sn_len);
-	if (llcp_sock == NULL)
-		return NULL;
-	sock_hold(&llcp_sock->sk);
-	return llcp_sock;
 }
 static const u8 *nfc_llcp_connect_sn(const struct sk_buff *skb, size_t *sn_len)
 			}
 			llcp_sock = nfc_llcp_sock_from_sn(local, service_name,
-							  service_name_len);
+							  service_name_len,
+							  true);
 			if (!llcp_sock) {
 				sap = 0;
 				goto add_snl;
 				if (sap == LLCP_SAP_MAX) {
 					sap = 0;
+					nfc_llcp_sock_put(llcp_sock);
 					goto add_snl;
 				}
 			pr_debug("%p %d\n", llcp_sock, sap);
+			nfc_llcp_sock_put(llcp_sock);
 add_snl:
 			sdp = nfc_llcp_build_sdres_tlv(tid, sap);
 			if (sdp == NULL)
 	timer_setup(&local->sdreq_timer, nfc_llcp_sdreq_timer, 0);
 	INIT_WORK(&local->sdreq_timeout_work, nfc_llcp_sdreq_timeout_work);
+	spin_lock(&llcp_devices_lock);
 	list_add(&local->list, &llcp_devices);
+	spin_unlock(&llcp_devices_lock);
 	return 0;
 }

net/nfc/nci/core.c+5−0

 		return -EINVAL;
 	}
+	if (protocol >= NFC_PROTO_MAX) {
+		pr_err("the requested nfc protocol is invalid\n");
+		return -EINVAL;
+	}
 	if (!(nci_target->supported_protocols & (1 << protocol))) {
 		pr_err("target does not support the requested protocol 0x%x\n",
 		       protocol);

net/packet/af_packet.c+6−1

@@ -3607,7 +3607,12 @@ static int packet_getname(struct socket sock, struct sockaddr uaddr, · 3606 unmodified lines
3607	if (dev) {	3607	if (dev) {
3608	sll->sll_hatype = dev->type;	3608	sll->sll_hatype = dev->type;
3609	sll->sll_halen = dev->addr_len;	3609	sll->sll_halen = dev->addr_len;
3610	memcpy(sll->sll_addr_flex, dev->dev_addr, dev->addr_len);	3610
		3611	/* Let __fortify_memcpy_chk() know the actual buffer size. */
		3612	memcpy(((struct sockaddr_storage *)sll)->__data +
		3613	offsetof(struct sockaddr_ll, sll_addr) -
		3614	offsetofend(struct sockaddr_ll, sll_family),
		3615	dev->dev_addr, dev->addr_len);
3611	} else {	3616	} else {
3612	sll->sll_hatype = 0; /* Bad: we have no ARPHRD_UNSPEC */	3617	sll->sll_hatype = 0; /* Bad: we have no ARPHRD_UNSPEC */
3613	sll->sll_halen = 0;	3618	sll->sll_halen = 0;

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/sched/cls_u32.c+1−1

@@ -366,7 +366,7 @@ static int u32_init(struct tcf_proto *tp) · 365 unmodified lines
366	idr_init(&root_ht->handle_idr);	366	idr_init(&root_ht->handle_idr);
367		367
368	if (tp_c == NULL) {	368	if (tp_c == NULL) {
369	tp_c = kzalloc(struct_size(tp_c, hlist->ht, 1), GFP_KERNEL);	369	tp_c = kzalloc(sizeof(*tp_c), GFP_KERNEL);
370	if (tp_c == NULL) {	370	if (tp_c == NULL) {
371	kfree(root_ht);	371	kfree(root_ht);
372	return -ENOBUFS;	372	return -ENOBUFS;

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/smc/Kconfig+1−0

@@ -2,6 +2,7 @@ · 1 unmodified line
2	config SMC	2	config SMC
3	tristate "SMC socket protocol family"	3	tristate "SMC socket protocol family"
4	depends on INET && INFINIBAND	4	depends on INET && INFINIBAND
		5	depends on m \|\| ISM != m
5	help	6	help
6	SMC-R provides a "sockets over RDMA" solution making use of	7	SMC-R provides a "sockets over RDMA" solution making use of
7	RDMA over Converged Ethernet (RoCE) technology to upgrade	8	RDMA over Converged Ethernet (RoCE) technology to upgrade

net/smc/smc_stats.h+9−5

 	typeof(_smc_stats) stats = (_smc_stats); \
 	typeof(_tech) t = (_tech); \
 	typeof(_len) l = (_len); \
-	int _pos = fls64((l) >> 13); \
+	int _pos; \
 	typeof(_rc) r = (_rc); \
 	int m = SMC_BUF_MAX - 1; \
 	this_cpu_inc((*stats).smc[t].key ## _cnt); \
-	if (r <= 0) \
+	if (r <= 0 || l <= 0) \
 		break; \
-	_pos = (_pos < m) ? ((l == 1 << (_pos + 12)) ? _pos - 1 : _pos) : m; \
+	_pos = fls64((l - 1) >> 13); \
+	_pos = (_pos <= m) ? _pos : m; \
 	this_cpu_inc((*stats).smc[t].key ## _pd.buf[_pos]); \
 	this_cpu_add((*stats).smc[t].key ## _bytes, r); \
 } \
 do { \
 	typeof(_len) _l = (_len); \
 	typeof(_tech) t = (_tech); \
-	int _pos = fls((_l) >> 13); \
+	int _pos; \
 	int m = SMC_BUF_MAX - 1; \
-	_pos = (_pos < m) ? ((_l == 1 << (_pos + 12)) ? _pos - 1 : _pos) : m; \
+	if (_l <= 0) \
+		break; \
+	_pos = fls((_l - 1) >> 13); \
+	_pos = (_pos <= m) ? _pos : m; \
 	this_cpu_inc((*(_smc_stats)).smc[t].k ## _rmbsize.buf[_pos]); \
 } \
 while (0)

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

net/xdp/xsk_queue.c+10−0

@@ -34,6 +34,16 @@ struct xsk_queue *xskq_create(u32 nentries, bool umem_queue) · 33 unmodified lines
34	q->ring_mask = nentries - 1;	34	q->ring_mask = nentries - 1;
35		35
36	size = xskq_get_ring_size(q, umem_queue);	36	size = xskq_get_ring_size(q, umem_queue);
		37
		38	/* size which is overflowing or close to SIZE_MAX will become 0 in
		39	* PAGE_ALIGN(), checking SIZE_MAX is enough due to the previous
		40	* is_power_of_2(), the rest will be handled by vmalloc_user()
		41	*/
		42	if (unlikely(size == SIZE_MAX)) {
		43	kfree(q);
		44	return NULL;
		45	}
		46
37	size = PAGE_ALIGN(size);	47	size = PAGE_ALIGN(size);
38		48
39	q->ring = vmalloc_user(size);	49	q->ring = vmalloc_user(size);

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

security/keys/trusted-keys/trusted_core.c+5−8

 #endif
 };
-DEFINE_STATIC_CALL_NULL(trusted_key_init, *trusted_key_sources[0].ops->init);
 DEFINE_STATIC_CALL_NULL(trusted_key_seal, *trusted_key_sources[0].ops->seal);
 DEFINE_STATIC_CALL_NULL(trusted_key_unseal,
 			*trusted_key_sources[0].ops->unseal);
 DEFINE_STATIC_CALL_NULL(trusted_key_get_random,
 			*trusted_key_sources[0].ops->get_random);
-DEFINE_STATIC_CALL_NULL(trusted_key_exit, *trusted_key_sources[0].ops->exit);
+static void (*trusted_key_exit)(void);
 static unsigned char migratable;
 enum {
 		if (!get_random)
 			get_random = kernel_get_random;
-		static_call_update(trusted_key_init,
-				   trusted_key_sources[i].ops->init);
 		static_call_update(trusted_key_seal,
 				   trusted_key_sources[i].ops->seal);
 		static_call_update(trusted_key_unseal,
 				   trusted_key_sources[i].ops->unseal);
 		static_call_update(trusted_key_get_random,
 				   get_random);
-		static_call_update(trusted_key_exit,
+		trusted_key_exit = trusted_key_sources[i].ops->exit;
-				   trusted_key_sources[i].ops->exit);
 		migratable = trusted_key_sources[i].ops->migratable;
-		ret = static_call(trusted_key_init)();
+		ret = trusted_key_sources[i].ops->init();
 		if (!ret)
 			break;
 	}
 static void __exit cleanup_trusted(void)
 {
-	static_call_cond(trusted_key_exit)();
+	if (trusted_key_exit)
+		(*trusted_key_exit)();
 }
 late_initcall(init_trusted);

sound/pci/hda/cs35l41_hda.c+79−36

@@ -185,10 +185,14 @@ static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41, · 184 unmodified lines
185	cs35l41->speaker_id, "wmfw");	185	cs35l41->speaker_id, "wmfw");
186	if (!ret) {	186	if (!ret) {
187	/* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */	187	/* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
188	return cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,	188	ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
189	CS35L41_FIRMWARE_ROOT,	189	CS35L41_FIRMWARE_ROOT,
190	cs35l41->acpi_subsystem_id, cs35l41->amp_name,	190	cs35l41->acpi_subsystem_id, cs35l41->amp_name,
191	cs35l41->speaker_id, "bin");	191	cs35l41->speaker_id, "bin");
		192	if (ret)
		193	goto coeff_err;
		194
		195	return 0;
192	}	196	}
193		197
194	/* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */	198	/* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
@@ -197,10 +201,14 @@ static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41, · 2 unmodified lines
197	cs35l41->amp_name, -1, "wmfw");	201	cs35l41->amp_name, -1, "wmfw");
198	if (!ret) {	202	if (!ret) {
199	/* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */	203	/* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
200	return cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,	204	ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
201	CS35L41_FIRMWARE_ROOT,	205	CS35L41_FIRMWARE_ROOT,
202	cs35l41->acpi_subsystem_id, cs35l41->amp_name,	206	cs35l41->acpi_subsystem_id, cs35l41->amp_name,
203	cs35l41->speaker_id, "bin");	207	cs35l41->speaker_id, "bin");
		208	if (ret)
		209	goto coeff_err;
		210
		211	return 0;
204	}	212	}
205		213
206	/* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */	214	/* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */
@@ -215,10 +223,14 @@ static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41, · 8 unmodified lines
215	cs35l41->amp_name, cs35l41->speaker_id, "bin");	223	cs35l41->amp_name, cs35l41->speaker_id, "bin");
216	if (ret)	224	if (ret)
217	/* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */	225	/* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
218	return cs35l41_request_firmware_file(cs35l41, coeff_firmware,	226	ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
219	coeff_filename, CS35L41_FIRMWARE_ROOT,	227	coeff_filename, CS35L41_FIRMWARE_ROOT,
220	cs35l41->acpi_subsystem_id, NULL,	228	cs35l41->acpi_subsystem_id, NULL,
221	cs35l41->speaker_id, "bin");	229	cs35l41->speaker_id, "bin");
		230	if (ret)
		231	goto coeff_err;
		232
		233	return 0;
222	}	234	}
223		235
224	/* try cirrus/part-dspN-fwtype-sub.wmfw */	236	/* try cirrus/part-dspN-fwtype-sub.wmfw */
@@ -233,12 +245,50 @@ static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41, · 8 unmodified lines
233	cs35l41->speaker_id, "bin");	245	cs35l41->speaker_id, "bin");
234	if (ret)	246	if (ret)
235	/* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */	247	/* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
236	return cs35l41_request_firmware_file(cs35l41, coeff_firmware,	248	ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
237	coeff_filename, CS35L41_FIRMWARE_ROOT,	249	coeff_filename, CS35L41_FIRMWARE_ROOT,
238	cs35l41->acpi_subsystem_id, NULL,	250	cs35l41->acpi_subsystem_id, NULL,
239	cs35l41->speaker_id, "bin");	251	cs35l41->speaker_id, "bin");
		252	if (ret)
		253	goto coeff_err;
		254	}
		255
		256	return ret;
		257	coeff_err:
		258	release_firmware(*wmfw_firmware);
		259	kfree(*wmfw_filename);
		260	return ret;
		261	}
		262
		263	static int cs35l41_fallback_firmware_file(struct cs35l41_hda *cs35l41,
		264	const struct firmware **wmfw_firmware,
		265	char **wmfw_filename,
		266	const struct firmware **coeff_firmware,
		267	char **coeff_filename)
		268	{
		269	int ret;
		270
		271	/* Handle fallback */
		272	dev_warn(cs35l41->dev, "Falling back to default firmware.\n");
		273
		274	/* fallback try cirrus/part-dspN-fwtype.wmfw */
		275	ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
		276	CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
		277	if (ret)
		278	goto err;
		279
		280	/* fallback try cirrus/part-dspN-fwtype.bin */
		281	ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
		282	CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
		283	if (ret) {
		284	release_firmware(*wmfw_firmware);
		285	kfree(*wmfw_filename);
		286	goto err;
240	}	287	}
		288	return 0;
241		289
		290	err:
		291	dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n");
242	return ret;	292	return ret;
243	}	293	}
244		294
@@ -254,7 +304,6 @@ static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41, · 9 unmodified lines
254	ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,	304	ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
255	coeff_firmware, coeff_filename);	305	coeff_firmware, coeff_filename);
256	goto out;	306	goto out;
257
258	}	307	}
259		308
260	/* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */	309	/* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
@@ -267,6 +316,9 @@ static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41, · 6 unmodified lines
267	CS35L41_FIRMWARE_ROOT,	316	CS35L41_FIRMWARE_ROOT,
268	cs35l41->acpi_subsystem_id, cs35l41->amp_name,	317	cs35l41->acpi_subsystem_id, cs35l41->amp_name,
269	-1, "bin");	318	-1, "bin");
		319	if (ret)
		320	goto coeff_err;
		321
270	goto out;	322	goto out;
271	}	323	}
272		324
@@ -286,32 +338,23 @@ static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41, · 13 unmodified lines
286	CS35L41_FIRMWARE_ROOT,	338	CS35L41_FIRMWARE_ROOT,
287	cs35l41->acpi_subsystem_id, NULL, -1,	339	cs35l41->acpi_subsystem_id, NULL, -1,
288	"bin");	340	"bin");
		341	if (ret)
		342	goto coeff_err;
289	}	343	}
290		344
291	out:	345	out:
292	if (!ret)	346	if (ret)
293	return 0;	347	/* if all attempts at finding firmware fail, try fallback */
		348	goto fallback;
294		349
295	/* Handle fallback */	350	return 0;
296	dev_warn(cs35l41->dev, "Falling back to default firmware.\n");
297		351
		352	coeff_err:
298	release_firmware(*wmfw_firmware);	353	release_firmware(*wmfw_firmware);
299	kfree(*wmfw_filename);	354	kfree(*wmfw_filename);
300		355	fallback:
301	/* fallback try cirrus/part-dspN-fwtype.wmfw */	356	return cs35l41_fallback_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
302	ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,	357	coeff_firmware, coeff_filename);
303	CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
304	if (!ret)
305	/* fallback try cirrus/part-dspN-fwtype.bin */
306	ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
307	CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
308
309	if (ret) {
310	release_firmware(*wmfw_firmware);
311	kfree(*wmfw_filename);
312	dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n");
313	}
314	return ret;
315	}	358	}
316		359
317	#if IS_ENABLED(CONFIG_EFI)	360	#if IS_ENABLED(CONFIG_EFI)

sound/pci/hda/patch_realtek.c+17−10

 	ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
 	ALC245_FIXUP_HP_X360_MUTE_LEDS,
 	ALC287_FIXUP_THINKPAD_I2S_SPK,
+	ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
 };
 /* A special fixup for Lenovo C940 and Yoga Duet 7;
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc287_fixup_bind_dacs,
 	},
+	[ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
+		.type = HDA_FIXUP_FUNC,
+		.v.func = alc287_fixup_bind_dacs,
+		.chained = true,
+		.chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
+	},
 };
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
 	SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
 	SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
-	SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC225_FIXUP_HEADSET_JACK),
+	SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
 	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
 	SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
 	SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
 	SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
 	SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
-	SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
-	SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
-	SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
-	SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
-	SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
-	SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
-	SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
-	SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
+	SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
 	SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
 	SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
 	SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
-	SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC225_FIXUP_HEADSET_JACK),
+	SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
 	SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
 #if 0

sound/soc/amd/yc/acp6x-mach.c+7−0

@@ -241,6 +241,13 @@ static const struct dmi_system_id yc_acp_quirk_table[] = { · 240 unmodified lines
241	DMI_MATCH(DMI_PRODUCT_NAME, "82V2"),	241	DMI_MATCH(DMI_PRODUCT_NAME, "82V2"),
242	}	242	}
243	},	243	},
		244	{
		245	.driver_data = &acp6x_card,
		246	.matches = {
		247	DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
		248	DMI_MATCH(DMI_PRODUCT_NAME, "82YM"),
		249	}
		250	},
244	{	251	{
245	.driver_data = &acp6x_card,	252	.driver_data = &acp6x_card,
246	.matches = {	253	.matches = {

sound/soc/codecs/hdmi-codec.c+4−1

 	hp->sample_rate = sample_rate;
 	hp->channels = channels;
-	hcp->chmap_idx = idx;
+	if (pcm_audio)
+		hcp->chmap_idx = ca_id;
+	else
+		hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
 	return 0;
 }

sound/soc/codecs/rt5682-i2c.c+5−5

 		return ret;
 	}
-	ret = devm_add_action_or_reset(&i2c->dev, rt5682_i2c_disable_regulators,
-				       rt5682);
-	if (ret)
-		return ret;
 	ret = regulator_bulk_enable(ARRAY_SIZE(rt5682->supplies),
 				    rt5682->supplies);
 	if (ret) {
 		return ret;
 	}
+	ret = devm_add_action_or_reset(&i2c->dev, rt5682_i2c_disable_regulators,
+				       rt5682);
+	if (ret)
+		return ret;
 	ret = rt5682_get_ldo1(rt5682, &i2c->dev);
 	if (ret)
 		return ret;

sound/soc/codecs/tlv320adc3xxx.c+2−2

@@ -293,7 +293,7 @@ · 292 unmodified lines
293	#define ADC3XXX_BYPASS_RPGA 0x80	293	#define ADC3XXX_BYPASS_RPGA 0x80
294		294
295	/* MICBIAS control bits */	295	/* MICBIAS control bits */
296	#define ADC3XXX_MICBIAS_MASK 0x2	296	#define ADC3XXX_MICBIAS_MASK 0x3
297	#define ADC3XXX_MICBIAS1_SHIFT 5	297	#define ADC3XXX_MICBIAS1_SHIFT 5
298	#define ADC3XXX_MICBIAS2_SHIFT 3	298	#define ADC3XXX_MICBIAS2_SHIFT 3
299		299
@@ -1099,7 +1099,7 @@ static int adc3xxx_parse_dt_micbias(struct adc3xxx *adc3xxx, · 799 unmodified lines
1099	unsigned int val;	1099	unsigned int val;
1100		1100
1101	if (!of_property_read_u32(np, propname, &val)) {	1101	if (!of_property_read_u32(np, propname, &val)) {
1102	if (val >= ADC3XXX_MICBIAS_AVDD) {	1102	if (val > ADC3XXX_MICBIAS_AVDD) {
1103	dev_err(dev, "Invalid property value for '%s'\n", propname);	1103	dev_err(dev, "Invalid property value for '%s'\n", propname);
1104	return -EINVAL;	1104	return -EINVAL;
1105	}	1105	}

sound/soc/fsl/fsl-asoc-card.c+8−4

 	unsigned long mclk_freq;
 	unsigned long free_freq;
 	u32 mclk_id;
-	u32 fll_id;
+	int fll_id;
-	u32 pll_id;
+	int pll_id;
 };
 /**
 	}
 	/* Specific configuration for PLL */
-	if (codec_priv->pll_id && codec_priv->fll_id) {
+	if (codec_priv->pll_id >= 0 && codec_priv->fll_id >= 0) {
 		if (priv->sample_format == SNDRV_PCM_FORMAT_S24_LE)
 			pll_out = priv->sample_rate * 384;
 		else
 	priv->streams &= ~BIT(substream->stream);
-	if (!priv->streams && codec_priv->pll_id && codec_priv->fll_id) {
+	if (!priv->streams && codec_priv->pll_id >= 0 && codec_priv->fll_id >= 0) {
 		/* Force freq to be free_freq to avoid error message in codec */
 		ret = snd_soc_dai_set_sysclk(asoc_rtd_to_codec(rtd, 0),
 					     codec_priv->mclk_id,
 	priv->card.dapm_routes = audio_map;
 	priv->card.num_dapm_routes = ARRAY_SIZE(audio_map);
 	priv->card.driver_name = DRIVER_NAME;
+	priv->codec_priv.fll_id = -1;
+	priv->codec_priv.pll_id = -1;
 	/* Diversify the card configurations */
 	if (of_device_is_compatible(np, "fsl,imx-audio-cs42888")) {
 		codec_dai_name = "cs42888";

sound/soc/fsl/fsl_sai.c+7−2

 {
 	unsigned int ofs = sai->soc_data->reg_offset;
 	bool tx = dir == TX;
-	u32 xcsr, count = 100;
+	u32 xcsr, count = 100, mask;
+	if (sai->soc_data->mclk_with_tere && sai->mclk_direction_output)
+		mask = FSL_SAI_CSR_TERE;
+	else
+		mask = FSL_SAI_CSR_TERE | FSL_SAI_CSR_BCE;
 	regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx, ofs),
-			   FSL_SAI_CSR_TERE | FSL_SAI_CSR_BCE, 0);
+			   mask, 0);
 	/* TERE will remain set till the end of current frame */
 	do {

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

 		if (fixed_sysclk % props->mclk_fs) {
 			dev_err(rtd->dev, "fixed sysclk %u not divisible by mclk_fs %u\n",
 				fixed_sysclk, props->mclk_fs);
-			return -EINVAL;
+			ret = -EINVAL;
+			goto codec_err;
 		}
 		ret = snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_RATE,
 			fixed_rate, fixed_rate);

sound/soc/generic/simple-card.c+4−2

 		struct snd_soc_dai_link *dai_link = priv->dai_link;
 		struct simple_dai_props *dai_props = priv->dai_props;
+		ret = -EINVAL;
 		cinfo = dev->platform_data;
 		if (!cinfo) {
 			dev_err(dev, "no info for asoc-simple-card\n");
-			return -EINVAL;
+			goto err;
 		}
 		if (!cinfo->name ||
 		    !cinfo->platform ||
 		    !cinfo->cpu_dai.name) {
 			dev_err(dev, "insufficient asoc_simple_card_info settings\n");
-			return -EINVAL;
+			goto err;
 		}
 		cpus			= dai_link->cpus;

sound/soc/intel/boards/sof_es8336.c+10−0

@@ -808,6 +808,16 @@ static const struct platform_device_id board_ids[] = { · 807 unmodified lines
808	SOF_ES8336_SPEAKERS_EN_GPIO1_QUIRK \|	808	SOF_ES8336_SPEAKERS_EN_GPIO1_QUIRK \|
809	SOF_ES8336_JD_INVERTED),	809	SOF_ES8336_JD_INVERTED),
810	},	810	},
		811	{
		812	.name = "mtl_es83x6_c1_h02",
		813	.driver_data = (kernel_ulong_t)(SOF_ES8336_SSP_CODEC(1) \|
		814	SOF_NO_OF_HDMI_CAPTURE_SSP(2) \|
		815	SOF_HDMI_CAPTURE_1_SSP(0) \|
		816	SOF_HDMI_CAPTURE_2_SSP(2) \|
		817	SOF_SSP_HDMI_CAPTURE_PRESENT \|
		818	SOF_ES8336_SPEAKERS_EN_GPIO1_QUIRK \|
		819	SOF_ES8336_JD_INVERTED),
		820	},
811	{ }	821	{ }
812	};	822	};
813	MODULE_DEVICE_TABLE(platform, board_ids);	823	MODULE_DEVICE_TABLE(platform, board_ids);

sound/soc/intel/boards/sof_sdw.c+10−0

@@ -376,6 +376,16 @@ static const struct dmi_system_id sof_sdw_quirk_table[] = { · 375 unmodified lines
376	/* No Jack */	376	/* No Jack */
377	.driver_data = (void *)SOF_SDW_TGL_HDMI,	377	.driver_data = (void *)SOF_SDW_TGL_HDMI,
378	},	378	},
		379	{
		380	.callback = sof_sdw_quirk_cb,
		381	.matches = {
		382	DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
		383	DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B14"),
		384	},
		385	/* No Jack */
		386	.driver_data = (void *)SOF_SDW_TGL_HDMI,
		387	},
		388
379	{	389	{
380	.callback = sof_sdw_quirk_cb,	390	.callback = sof_sdw_quirk_cb,
381	.matches = {	391	.matches = {

sound/soc/intel/common/soc-acpi-intel-adl-match.c+6−6

 		.drv_name = "sof_sdw",
 		.sof_tplg_filename = "sof-adl-rt1316-l2-mono-rt714-l3.tplg",
 	},
-	{
-		.link_mask = 0x3, /* rt1316 on link1 & rt714 on link0 */
-		.links = adl_sdw_rt1316_link1_rt714_link0,
-		.drv_name = "sof_sdw",
-		.sof_tplg_filename = "sof-adl-rt1316-l1-mono-rt714-l0.tplg",
-	},
 	{
 		.link_mask = 0x7, /* rt714 on link0 & two rt1316s on link1 and link2 */
 		.links = adl_sdw_rt1316_link12_rt714_link0,
 		.drv_name = "sof_sdw",
 		.sof_tplg_filename = "sof-adl-rt1316-l12-rt714-l0.tplg",
 	},
+	{
+		.link_mask = 0x3, /* rt1316 on link1 & rt714 on link0 */
+		.links = adl_sdw_rt1316_link1_rt714_link0,
+		.drv_name = "sof_sdw",
+		.sof_tplg_filename = "sof-adl-rt1316-l1-mono-rt714-l0.tplg",
+	},
 	{
 		.link_mask = 0x5, /* 2 active links required */
 		.links = adl_sdw_rt1316_link2_rt714_link0,

sound/soc/intel/common/soc-acpi-intel-mtl-match.c+25−0

@@ -30,6 +30,16 @@ static const struct snd_soc_acpi_codecs mtl_rt5682_rt5682s_hp = { · 29 unmodified lines
30	.codecs = {"10EC5682", "RTL5682"},	30	.codecs = {"10EC5682", "RTL5682"},
31	};	31	};
32		32
		33	static const struct snd_soc_acpi_codecs mtl_essx_83x6 = {
		34	.num_codecs = 3,
		35	.codecs = { "ESSX8316", "ESSX8326", "ESSX8336"},
		36	};
		37
		38	static const struct snd_soc_acpi_codecs mtl_lt6911_hdmi = {
		39	.num_codecs = 1,
		40	.codecs = {"INTC10B0"}
		41	};
		42
33	struct snd_soc_acpi_mach snd_soc_acpi_intel_mtl_machines[] = {	43	struct snd_soc_acpi_mach snd_soc_acpi_intel_mtl_machines[] = {
34	{	44	{
35	.comp_ids = &mtl_rt5682_rt5682s_hp,	45	.comp_ids = &mtl_rt5682_rt5682s_hp,
@@ -52,6 +62,21 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_mtl_machines[] = { · 16 unmodified lines
52	.quirk_data = &mtl_rt1019p_amp,	62	.quirk_data = &mtl_rt1019p_amp,
53	.sof_tplg_filename = "sof-mtl-rt1019-rt5682.tplg",	63	.sof_tplg_filename = "sof-mtl-rt1019-rt5682.tplg",
54	},	64	},
		65	{
		66	.comp_ids = &mtl_essx_83x6,
		67	.drv_name = "mtl_es83x6_c1_h02",
		68	.machine_quirk = snd_soc_acpi_codec_list,
		69	.quirk_data = &mtl_lt6911_hdmi,
		70	.sof_tplg_filename = "sof-mtl-es83x6-ssp1-hdmi-ssp02.tplg",
		71	},
		72	{
		73	.comp_ids = &mtl_essx_83x6,
		74	.drv_name = "sof-essx8336",
		75	.sof_tplg_filename = "sof-mtl-es8336", /* the tplg suffix is added at run time */
		76	.tplg_quirk_mask = SND_SOC_ACPI_TPLG_INTEL_SSP_NUMBER \|
		77	SND_SOC_ACPI_TPLG_INTEL_SSP_MSB \|
		78	SND_SOC_ACPI_TPLG_INTEL_DMIC_NUMBER,
		79	},
55	{},	80	{},
56	};	81	};
57	EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_mtl_machines);	82	EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_mtl_machines);

sound/soc/soc-core.c+17−7

 	snd_soc_runtime_get_dai_fmt(rtd);
 	ret = snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
 	if (ret)
-		return ret;
+		goto err;
 	/* add DPCM sysfs entries */
 	soc_dpcm_debugfs_add(rtd);
 	/* create compress_device if possible */
 	ret = snd_soc_dai_compress_new(cpu_dai, rtd, num);
 	if (ret != -ENOTSUPP)
-		return ret;
+		goto err;
 	/* create the pcm */
 	ret = soc_new_pcm(rtd, num);
 	if (ret < 0) {
 		dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
 			dai_link->stream_name, ret);
-		return ret;
+		goto err;
 	}
-	return snd_soc_pcm_dai_new(rtd);
+	ret = snd_soc_pcm_dai_new(rtd);
+	if (ret < 0)
+		goto err;
+	rtd->initialized = true;
+	return 0;
+err:
+	snd_soc_link_exit(rtd);
+	return ret;
 }
 static void soc_set_name_prefix(struct snd_soc_card *card,
 	if (component->card) {
 		if (component->card != card) {
 			dev_err(component->dev,
-				"Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
+				"Trying to bind component \"%s\" to card \"%s\" but is already bound to card \"%s\"\n",
-				card->name, component->card->name);
+				component->name, card->name, component->card->name);
 			return -ENODEV;
 		}
 		return 0;
 	/* release machine specific resources */
 	for_each_card_rtds(card, rtd)
-		snd_soc_link_exit(rtd);
+		if (rtd->initialized)
+			snd_soc_link_exit(rtd);
 	/* remove and free each DAI */
 	soc_remove_link_dais(card);
 	soc_remove_link_components(card);

sound/soc/soc-generic-dmaengine-pcm.c+2−2

@@ -44,8 +44,8 @@ static struct device dmaengine_dma_dev(struct dmaengine_pcm pcm, · 43 unmodified lines
44	* platforms which make use of the snd_dmaengine_dai_dma_data struct for their	44	* platforms which make use of the snd_dmaengine_dai_dma_data struct for their
45	* DAI DMA data. Internally the function will first call	45	* DAI DMA data. Internally the function will first call
46	* snd_hwparams_to_dma_slave_config to fill in the slave config based on the	46	* snd_hwparams_to_dma_slave_config to fill in the slave config based on the
47	* hw_params, followed by snd_dmaengine_set_config_from_dai_data to fill in the	47	* hw_params, followed by snd_dmaengine_pcm_set_config_from_dai_data to fill in
48	* remaining fields based on the DAI DMA data.	48	* the remaining fields based on the DAI DMA data.
49	*/	49	*/
50	int snd_dmaengine_pcm_prepare_slave_config(struct snd_pcm_substream *substream,	50	int snd_dmaengine_pcm_prepare_slave_config(struct snd_pcm_substream *substream,
51	struct snd_pcm_hw_params params, struct dma_slave_config slave_config)	51	struct snd_pcm_hw_params params, struct dma_slave_config slave_config)

sound/soc/sof/amd/pci-rmb.c+0−1

@@ -35,7 +35,6 @@ static const struct sof_amd_acp_desc rembrandt_chip_info = { · 34 unmodified lines
35	.dsp_intr_base = ACP6X_DSP_SW_INTR_BASE,	35	.dsp_intr_base = ACP6X_DSP_SW_INTR_BASE,
36	.sram_pte_offset = ACP6X_SRAM_PTE_OFFSET,	36	.sram_pte_offset = ACP6X_SRAM_PTE_OFFSET,
37	.hw_semaphore_offset = ACP6X_AXI2DAGB_SEM_0,	37	.hw_semaphore_offset = ACP6X_AXI2DAGB_SEM_0,
38	.acp_clkmux_sel = ACP6X_CLKMUX_SEL,
39	.fusion_dsp_offset = ACP6X_DSP_FUSION_RUNSTALL,	38	.fusion_dsp_offset = ACP6X_DSP_FUSION_RUNSTALL,
40	.probe_reg_offset = ACP6X_FUTURE_REG_ACLK_0,	39	.probe_reg_offset = ACP6X_FUTURE_REG_ACLK_0,
41	};	40	};

sound/soc/ti/ams-delta.c+2−2

@@ -336,8 +336,8 @@ static void cx81801_hangup(struct tty_struct *tty) · 335 unmodified lines
336	}	336	}
337		337
338	/* Line discipline .receive_buf() */	338	/* Line discipline .receive_buf() */
339	static void cx81801_receive(struct tty_struct tty, const u8 cp,	339	static void cx81801_receive(struct tty_struct tty, const u8 cp, const u8 *fp,
340	const char *fp, int count)	340	size_t count)
341	{	341	{
342	struct snd_soc_component *component = tty->disc_data;	342	struct snd_soc_component *component = tty->disc_data;
343	const unsigned char *c;	343	const unsigned char *c;

sound/usb/mixer.c+7−0

@@ -1204,6 +1204,13 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval, · 1203 unmodified lines
1204	cval->res = 16;	1204	cval->res = 16;
1205	}	1205	}
1206	break;	1206	break;
		1207	case USB_ID(0x1bcf, 0x2283): /* NexiGo N930AF FHD Webcam */
		1208	if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
		1209	usb_audio_info(chip,
		1210	"set resolution quirk: cval->res = 16\n");
		1211	cval->res = 16;
		1212	}
		1213	break;
1207	}	1214	}
1208	}	1215	}
1209		1216

sound/usb/quirks.c+7−1

@@ -1994,7 +1994,11 @@ void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio *chip, · 1993 unmodified lines
1994	/* mic works only when ep packet size is set to wMaxPacketSize */	1994	/* mic works only when ep packet size is set to wMaxPacketSize */
1995	fp->attributes \|= UAC_EP_CS_ATTR_FILL_MAX;	1995	fp->attributes \|= UAC_EP_CS_ATTR_FILL_MAX;
1996	break;	1996	break;
1997		1997	case USB_ID(0x3511, 0x2b1e): /* Opencomm2 UC USB Bluetooth dongle */
		1998	/* mic works only when ep pitch control is not set */
		1999	if (stream == SNDRV_PCM_STREAM_CAPTURE)
		2000	fp->attributes &= ~UAC_EP_CS_ATTR_PITCH_CONTROL;
		2001	break;
1998	}	2002	}
1999	}	2003	}
2000		2004
@@ -2173,6 +2177,8 @@ static const struct usb_audio_quirk_flags_table quirk_flags_table[] = { · 172 unmodified lines
2173	QUIRK_FLAG_FIXED_RATE),	2177	QUIRK_FLAG_FIXED_RATE),
2174	DEVICE_FLG(0x0ecb, 0x2069, /* JBL Quantum810 Wireless */	2178	DEVICE_FLG(0x0ecb, 0x2069, /* JBL Quantum810 Wireless */
2175	QUIRK_FLAG_FIXED_RATE),	2179	QUIRK_FLAG_FIXED_RATE),
		2180	DEVICE_FLG(0x1bcf, 0x2283, /* NexiGo N930AF FHD Webcam */
		2181	QUIRK_FLAG_GET_SAMPLE_RATE),
2176		2182
2177	/* Vendor matches */	2183	/* Vendor matches */
2178	VENDOR_FLG(0x045e, /* MS Lifecam */	2184	VENDOR_FLG(0x045e, /* MS Lifecam */

tools/hv/hv_kvp_daemon.c+202−31

@@ -1171,12 +1171,79 @@ static int process_ip_string(FILE f, char ip_string, int type) · 1170 unmodified lines
1171	return 0;	1171	return 0;
1172	}	1172	}
1173		1173
		1174	/*
		1175	* Only IPv4 subnet strings needs to be converted to plen
		1176	* For IPv6 the subnet is already privided in plen format
		1177	*/
		1178	static int kvp_subnet_to_plen(char *subnet_addr_str)
		1179	{
		1180	int plen = 0;
		1181	struct in_addr subnet_addr4;
		1182
		1183	/*
		1184	* Convert subnet address to binary representation
		1185	*/
		1186	if (inet_pton(AF_INET, subnet_addr_str, &subnet_addr4) == 1) {
		1187	uint32_t subnet_mask = ntohl(subnet_addr4.s_addr);
		1188
		1189	while (subnet_mask & 0x80000000) {
		1190	plen++;
		1191	subnet_mask <<= 1;
		1192	}
		1193	} else {
		1194	return -1;
		1195	}
		1196
		1197	return plen;
		1198	}
		1199
		1200	static int process_ip_string_nm(FILE f, char ip_string, char *subnet,
		1201	int is_ipv6)
		1202	{
		1203	char addr[INET6_ADDRSTRLEN];
		1204	char subnet_addr[INET6_ADDRSTRLEN];
		1205	int error, i = 0;
		1206	int ip_offset = 0, subnet_offset = 0;
		1207	int plen;
		1208
		1209	memset(addr, 0, sizeof(addr));
		1210	memset(subnet_addr, 0, sizeof(subnet_addr));
		1211
		1212	while (parse_ip_val_buffer(ip_string, &ip_offset, addr,
		1213	(MAX_IP_ADDR_SIZE * 2)) &&
		1214	parse_ip_val_buffer(subnet,
		1215	&subnet_offset,
		1216	subnet_addr,
		1217	(MAX_IP_ADDR_SIZE *
		1218	2))) {
		1219	if (!is_ipv6)
		1220	plen = kvp_subnet_to_plen((char *)subnet_addr);
		1221	else
		1222	plen = atoi(subnet_addr);
		1223
		1224	if (plen < 0)
		1225	return plen;
		1226
		1227	error = fprintf(f, "address%d=%s/%d\n", ++i, (char *)addr,
		1228	plen);
		1229	if (error < 0)
		1230	return error;
		1231
		1232	memset(addr, 0, sizeof(addr));
		1233	memset(subnet_addr, 0, sizeof(subnet_addr));
		1234	}
		1235
		1236	return 0;
		1237	}
		1238
1174	static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val)	1239	static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val)
1175	{	1240	{
1176	int error = 0;	1241	int error = 0;
1177	char if_file[PATH_MAX];	1242	char if_filename[PATH_MAX];
1178	FILE *file;	1243	char nm_filename[PATH_MAX];
		1244	FILE ifcfg_file, nmfile;
1179	char cmd[PATH_MAX];	1245	char cmd[PATH_MAX];
		1246	int is_ipv6 = 0;
1180	char *mac_addr;	1247	char *mac_addr;
1181	int str_len;	1248	int str_len;
1182		1249
@@ -1197,7 +1264,7 @@ static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val) · 14 unmodified lines
1197	* in a given distro to configure the interface and so are free	1264	* in a given distro to configure the interface and so are free
1198	* ignore information that may not be relevant.	1265	* ignore information that may not be relevant.
1199	*	1266	*
1200	* Here is the format of the ip configuration file:	1267	* Here is the ifcfg format of the ip configuration file:
1201	*	1268	*
1202	* HWADDR=macaddr	1269	* HWADDR=macaddr
1203	* DEVICE=interface name	1270	* DEVICE=interface name
@@ -1220,6 +1287,32 @@ static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val) · 16 unmodified lines
1220	* tagged as IPV6_DEFAULTGW and IPV6 NETMASK will be tagged as	1287	* tagged as IPV6_DEFAULTGW and IPV6 NETMASK will be tagged as
1221	* IPV6NETMASK.	1288	* IPV6NETMASK.
1222	*	1289	*
		1290	* Here is the keyfile format of the ip configuration file:
		1291	*
		1292	* [ethernet]
		1293	* mac-address=macaddr
		1294	* [connection]
		1295	* interface-name=interface name
		1296	*
		1297	* [ipv4]
		1298	* method=<protocol> (where <protocol> is "auto" if DHCP is configured
		1299	* or "manual" if no boot-time protocol should be used)
		1300	*
		1301	* address1=ipaddr1/plen
		1302	* address2=ipaddr2/plen
		1303	*
		1304	* gateway=gateway1;gateway2
		1305	*
		1306	* dns=dns1;dns2
		1307	*
		1308	* [ipv6]
		1309	* address1=ipaddr1/plen
		1310	* address2=ipaddr2/plen
		1311	*
		1312	* gateway=gateway1;gateway2
		1313	*
		1314	* dns=dns1;dns2
		1315	*
1223	* The host can specify multiple ipv4 and ipv6 addresses to be	1316	* The host can specify multiple ipv4 and ipv6 addresses to be
1224	* configured for the interface. Furthermore, the configuration	1317	* configured for the interface. Furthermore, the configuration
1225	* needs to be persistent. A subsequent GET call on the interface	1318	* needs to be persistent. A subsequent GET call on the interface
@@ -1227,14 +1320,29 @@ static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val) · 1 unmodified line
1227	* call.	1320	* call.
1228	*/	1321	*/
1229		1322
1230	snprintf(if_file, sizeof(if_file), "%s%s%s", KVP_CONFIG_LOC,	1323	/*
1231	"/ifcfg-", if_name);	1324	* We are populating both ifcfg and nmconnection files
		1325	*/
		1326	snprintf(if_filename, sizeof(if_filename), "%s%s%s", KVP_CONFIG_LOC,
		1327	"/ifcfg-", if_name);
1232		1328
1233	file = fopen(if_file, "w");	1329	ifcfg_file = fopen(if_filename, "w");
1234		1330
1235	if (file == NULL) {	1331	if (!ifcfg_file) {
1236	syslog(LOG_ERR, "Failed to open config file; error: %d %s",	1332	syslog(LOG_ERR, "Failed to open config file; error: %d %s",
1237	errno, strerror(errno));	1333	errno, strerror(errno));
		1334	return HV_E_FAIL;
		1335	}
		1336
		1337	snprintf(nm_filename, sizeof(nm_filename), "%s%s%s%s", KVP_CONFIG_LOC,
		1338	"/", if_name, ".nmconnection");
		1339
		1340	nmfile = fopen(nm_filename, "w");
		1341
		1342	if (!nmfile) {
		1343	syslog(LOG_ERR, "Failed to open config file; error: %d %s",
		1344	errno, strerror(errno));
		1345	fclose(ifcfg_file);
1238	return HV_E_FAIL;	1346	return HV_E_FAIL;
1239	}	1347	}
1240		1348
@@ -1248,14 +1356,31 @@ static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val) · 7 unmodified lines
1248	goto setval_error;	1356	goto setval_error;
1249	}	1357	}
1250		1358
1251	error = kvp_write_file(file, "HWADDR", "", mac_addr);	1359	error = kvp_write_file(ifcfg_file, "HWADDR", "", mac_addr);
1252	free(mac_addr);	1360	if (error < 0)
		1361	goto setmac_error;
		1362
		1363	error = kvp_write_file(ifcfg_file, "DEVICE", "", if_name);
		1364	if (error < 0)
		1365	goto setmac_error;
		1366
		1367	error = fprintf(nmfile, "\n[connection]\n");
		1368	if (error < 0)
		1369	goto setmac_error;
		1370
		1371	error = kvp_write_file(nmfile, "interface-name", "", if_name);
1253	if (error)	1372	if (error)
1254	goto setval_error;	1373	goto setmac_error;
1255		1374
1256	error = kvp_write_file(file, "DEVICE", "", if_name);	1375	error = fprintf(nmfile, "\n[ethernet]\n");
		1376	if (error < 0)
		1377	goto setmac_error;
		1378
		1379	error = kvp_write_file(nmfile, "mac-address", "", mac_addr);
1257	if (error)	1380	if (error)
1258	goto setval_error;	1381	goto setmac_error;
		1382
		1383	free(mac_addr);
1259		1384
1260	/*	1385	/*
1261	* The dhcp_enabled flag is only for IPv4. In the case the host only	1386	* The dhcp_enabled flag is only for IPv4. In the case the host only
@@ -1263,47 +1388,91 @@ static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val) · 1 unmodified line
1263	* proceed to parse and pass the IPv6 information to the	1388	* proceed to parse and pass the IPv6 information to the
1264	* disto-specific script hv_set_ifconfig.	1389	* disto-specific script hv_set_ifconfig.
1265	*/	1390	*/
		1391
		1392	/*
		1393	* First populate the ifcfg file format
		1394	*/
1266	if (new_val->dhcp_enabled) {	1395	if (new_val->dhcp_enabled) {
1267	error = kvp_write_file(file, "BOOTPROTO", "", "dhcp");	1396	error = kvp_write_file(ifcfg_file, "BOOTPROTO", "", "dhcp");
1268	if (error)	1397	if (error)
1269	goto setval_error;	1398	goto setval_error;
1270
1271	} else {	1399	} else {
1272	error = kvp_write_file(file, "BOOTPROTO", "", "none");	1400	error = kvp_write_file(ifcfg_file, "BOOTPROTO", "", "none");
1273	if (error)	1401	if (error)
1274	goto setval_error;	1402	goto setval_error;
1275	}	1403	}
1276		1404
1277	/*	1405	error = process_ip_string(ifcfg_file, (char *)new_val->ip_addr,
1278	* Write the configuration for ipaddress, netmask, gateway and	1406	IPADDR);
1279	* name servers.
1280	*/
1281
1282	error = process_ip_string(file, (char *)new_val->ip_addr, IPADDR);
1283	if (error)	1407	if (error)
1284	goto setval_error;	1408	goto setval_error;
1285		1409
1286	error = process_ip_string(file, (char *)new_val->sub_net, NETMASK);	1410	error = process_ip_string(ifcfg_file, (char *)new_val->sub_net,
		1411	NETMASK);
1287	if (error)	1412	if (error)
1288	goto setval_error;	1413	goto setval_error;
1289		1414
1290	error = process_ip_string(file, (char *)new_val->gate_way, GATEWAY);	1415	error = process_ip_string(ifcfg_file, (char *)new_val->gate_way,
		1416	GATEWAY);
1291	if (error)	1417	if (error)
1292	goto setval_error;	1418	goto setval_error;
1293		1419
1294	error = process_ip_string(file, (char *)new_val->dns_addr, DNS);	1420	error = process_ip_string(ifcfg_file, (char *)new_val->dns_addr, DNS);
1295	if (error)	1421	if (error)
1296	goto setval_error;	1422	goto setval_error;
1297		1423
1298	fclose(file);	1424	if (new_val->addr_family == ADDR_FAMILY_IPV6) {
		1425	error = fprintf(nmfile, "\n[ipv6]\n");
		1426	if (error < 0)
		1427	goto setval_error;
		1428	is_ipv6 = 1;
		1429	} else {
		1430	error = fprintf(nmfile, "\n[ipv4]\n");
		1431	if (error < 0)
		1432	goto setval_error;
		1433	}
		1434
		1435	/*
		1436	* Now we populate the keyfile format
		1437	*/
		1438
		1439	if (new_val->dhcp_enabled) {
		1440	error = kvp_write_file(nmfile, "method", "", "auto");
		1441	if (error < 0)
		1442	goto setval_error;
		1443	} else {
		1444	error = kvp_write_file(nmfile, "method", "", "manual");
		1445	if (error < 0)
		1446	goto setval_error;
		1447	}
		1448
		1449	/*
		1450	* Write the configuration for ipaddress, netmask, gateway and
		1451	* name services
		1452	*/
		1453	error = process_ip_string_nm(nmfile, (char *)new_val->ip_addr,
		1454	(char *)new_val->sub_net, is_ipv6);
		1455	if (error < 0)
		1456	goto setval_error;
		1457
		1458	error = fprintf(nmfile, "gateway=%s\n", (char *)new_val->gate_way);
		1459	if (error < 0)
		1460	goto setval_error;
		1461
		1462	error = fprintf(nmfile, "dns=%s\n", (char *)new_val->dns_addr);
		1463	if (error < 0)
		1464	goto setval_error;
		1465
		1466	fclose(nmfile);
		1467	fclose(ifcfg_file);
1299		1468
1300	/*	1469	/*
1301	* Now that we have populated the configuration file,	1470	* Now that we have populated the configuration file,
1302	* invoke the external script to do its magic.	1471	* invoke the external script to do its magic.
1303	*/	1472	*/
1304		1473
1305	str_len = snprintf(cmd, sizeof(cmd), KVP_SCRIPTS_PATH "%s %s",	1474	str_len = snprintf(cmd, sizeof(cmd), KVP_SCRIPTS_PATH "%s %s %s",
1306	"hv_set_ifconfig", if_file);	1475	"hv_set_ifconfig", if_filename, nm_filename);
1307	/*	1476	/*
1308	* This is a little overcautious, but it's necessary to suppress some	1477	* This is a little overcautious, but it's necessary to suppress some
1309	* false warnings from gcc 8.0.1.	1478	* false warnings from gcc 8.0.1.
@@ -1316,14 +1485,16 @@ static int kvp_set_ip_info(char if_name, struct hv_kvp_ipaddr_value new_val) · 6 unmodified lines
1316		1485
1317	if (system(cmd)) {	1486	if (system(cmd)) {
1318	syslog(LOG_ERR, "Failed to execute cmd '%s'; error: %d %s",	1487	syslog(LOG_ERR, "Failed to execute cmd '%s'; error: %d %s",
1319	cmd, errno, strerror(errno));	1488	cmd, errno, strerror(errno));
1320	return HV_E_FAIL;	1489	return HV_E_FAIL;
1321	}	1490	}
1322	return 0;	1491	return 0;
1323		1492	setmac_error:
		1493	free(mac_addr);
1324	setval_error:	1494	setval_error:
1325	syslog(LOG_ERR, "Failed to write config file");	1495	syslog(LOG_ERR, "Failed to write config file");
1326	fclose(file);	1496	fclose(ifcfg_file);
		1497	fclose(nmfile);
1327	return error;	1498	return error;
1328	}	1499	}
1329		1500

tools/hv/hv_set_ifconfig.sh+33−6

 #
 # This example script is based on a RHEL environment.
 #
-# Here is the format of the ip configuration file:
+# Here is the ifcfg format of the ip configuration file:
 #
 # HWADDR=macaddr
 # DEVICE=interface name
 # BOOTPROTO=<protocol> (where <protocol> is "dhcp" if DHCP is configured
-#                       or "none" if no boot-time protocol should be used)
+# 			or "none" if no boot-time protocol should be used)
 #
 # IPADDR0=ipaddr1
 # IPADDR1=ipaddr2
 # tagged as IPV6_DEFAULTGW and IPV6 NETMASK will be tagged as
 # IPV6NETMASK.
 #
+# Here is the keyfile format of the ip configuration file:
+#
+# [ethernet]
+# mac-address=macaddr
+# [connection]
+# interface-name=interface name
+#
+# [ipv4]
+# method=<protocol> (where <protocol> is "auto" if DHCP is configured
+#                       or "manual" if no boot-time protocol should be used)
+#
+# address1=ipaddr1/plen
+# address=ipaddr2/plen
+#
+# gateway=gateway1;gateway2
+#
+# dns=dns1;
+#
+# [ipv6]
+# address1=ipaddr1/plen
+# address2=ipaddr1/plen
+#
+# gateway=gateway1;gateway2
+#
+# dns=dns1;dns2
+#
 # The host can specify multiple ipv4 and ipv6 addresses to be
 # configured for the interface. Furthermore, the configuration
 # needs to be persistent. A subsequent GET call on the interface
 # call.
 #
 echo "IPV6INIT=yes" >> $1
 echo "NM_CONTROLLED=no" >> $1
 echo "PEERDNS=yes" >> $1
 echo "ONBOOT=yes" >> $1
 cp $1 /etc/sysconfig/network-scripts/
+chmod 600 $2
+interface=$(echo $2 | awk -F - '{ print $2 }')
+filename="${2##*/}"
+sed '/\[connection\]/a autoconnect=true' $2 > /etc/NetworkManager/system-connections/${filename}
-interface=$(echo $1 | awk -F - '{ print $2 }')
 /sbin/ifdown $interface 2>/dev/null
 /sbin/ifup $interface 2>/dev/null

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_helpers.h+9−7

 	return link_info.tcx.ifindex;
 }
-static inline void __assert_mprog_count(int target, int expected, bool miniq, int ifindex)
+static inline void __assert_mprog_count(int target, int expected, int ifindex)
 {
 	__u32 count = 0, attach_flags = 0;
 	int err;
 	err = bpf_prog_query(ifindex, target, 0, &attach_flags,
 			     NULL, &count);
 	ASSERT_EQ(count, expected, "count");
-	if (!expected && !miniq)
+	ASSERT_EQ(err, 0, "prog_query");
-		ASSERT_EQ(err, -ENOENT, "prog_query");
-	else
-		ASSERT_EQ(err, 0, "prog_query");
 }
 static inline void assert_mprog_count(int target, int expected)
 {
-	__assert_mprog_count(target, expected, false, loopback);
+	__assert_mprog_count(target, expected, loopback);
 }
 static inline void assert_mprog_count_ifindex(int ifindex, int target, int expected)
 {
-	__assert_mprog_count(target, expected, false, ifindex);
+	__assert_mprog_count(target, expected, ifindex);
+}
+static inline void tc_skel_reset_all_seen(struct test_tc_link *skel)
+{
+	memset(skel->bss, 0, sizeof(*skel->bss));
 }
 #endif /* TC_HELPERS */

tools/testing/selftests/bpf/prog_tests/tc_links.c+23−41

 	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
 	ASSERT_EQ(optq.link_ids[1], 0, "link_ids[1]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
 	ASSERT_EQ(optq.link_ids[1], 0, "link_ids[1]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
 	ASSERT_EQ(optq.link_ids[2], 0, "link_ids[2]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
 	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
 	LIBBPF_OPTS_RESET(optl,
 		.flags = BPF_F_BEFORE,
 		.relative_fd = bpf_program__fd(skel->progs.tc2),
 	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
 	ASSERT_EQ(optq.link_ids[4], 0, "link_ids[4]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
 	ASSERT_EQ(optq.link_ids[2], 0, "link_ids[2]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
 	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
 	LIBBPF_OPTS_RESET(optl,
 		.flags = BPF_F_AFTER,
 		.relative_fd = bpf_program__fd(skel->progs.tc1),
 	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
 	ASSERT_EQ(optq.link_ids[4], 0, "link_ids[4]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
 	ASSERT_EQ(optq.link_ids[2], 0, "prog_ids[2]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	assert_mprog_count(target, 2);
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
 	ASSERT_EQ(skel->bss->seen_tc3, chain_tc_old, "seen_tc3");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
-	skel->bss->seen_tc3 = false;
 	err = bpf_link__detach(skel->links.tc2);
 	if (!ASSERT_OK(err, "prog_detach"))
 		goto cleanup;
 	assert_mprog_count(target, 1);
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
 	ASSERT_EQ(optq.link_ids[2], 0, "link_ids[2]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
 	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
-	skel->bss->seen_tc3 = false;
 	LIBBPF_OPTS_RESET(optl,
 		.flags = BPF_F_REPLACE,
 		.relative_fd = bpf_program__fd(skel->progs.tc2),
 	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
 	ASSERT_EQ(optq.link_ids[2], 0, "link_ids[2]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");
 	ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
-	skel->bss->seen_tc3 = false;
 	err = bpf_link__detach(skel->links.tc2);
 	if (!ASSERT_OK(err, "link_detach"))
 		goto cleanup;
 	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
 	ASSERT_EQ(optq.link_ids[1], 0, "link_ids[1]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");
 	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
-	skel->bss->seen_tc3 = false;
 	err = bpf_link__update_program(skel->links.tc1, skel->progs.tc1);
 	if (!ASSERT_OK(err, "link_update_self"))
 		goto cleanup;
 	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
 	ASSERT_EQ(optq.link_ids[1], 0, "link_ids[1]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
 	ASSERT_EQ(optq.link_ids[2], 0, "link_ids[2]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
 	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
 	LIBBPF_OPTS_RESET(optl,
 		.flags = BPF_F_BEFORE,
 	);
 	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
 	ASSERT_EQ(optq.link_ids[4], 0, "link_ids[4]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
 	ASSERT_EQ(optq.link_ids[2], 0, "link_ids[2]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
 	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
 	LIBBPF_OPTS_RESET(optl,
 		.flags = BPF_F_AFTER,
 	);
 	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
 	ASSERT_EQ(optq.link_ids[4], 0, "link_ids[4]");
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	assert_mprog_count(target, 1);
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
 	ASSERT_EQ(skel->bss->seen_tc5, false, "seen_tc5");
 	ASSERT_EQ(skel->bss->seen_tc6, true, "seen_tc6");
-	skel->bss->seen_tc4 = false;
-	skel->bss->seen_tc5 = false;
-	skel->bss->seen_tc6 = false;
 	err = bpf_link__update_program(skel->links.tc6, skel->progs.tc4);
 	if (!ASSERT_OK(err, "link_update"))
 		goto cleanup;
 	assert_mprog_count(target, 1);
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");
 	ASSERT_EQ(skel->bss->seen_tc5, true, "seen_tc5");
 	ASSERT_EQ(skel->bss->seen_tc6, false, "seen_tc6");
-	skel->bss->seen_tc4 = false;
-	skel->bss->seen_tc5 = false;
-	skel->bss->seen_tc6 = false;
 	err = bpf_link__detach(skel->links.tc6);
 	if (!ASSERT_OK(err, "prog_detach"))
 		goto cleanup;
-	__assert_mprog_count(target, 0, true, loopback);
+	assert_mprog_count(target, 0);
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
 	assert_mprog_count(target, 2);
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
 	ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
 	ASSERT_EQ(skel->bss->seen_tc3, chain_tc_old, "seen_tc3");
-	skel->bss->seen_tc1 = false;
-	skel->bss->seen_tc2 = false;
-	skel->bss->seen_tc3 = false;
 	err = bpf_link__detach(skel->links.tc2);
 	if (!ASSERT_OK(err, "prog_detach"))
 		goto cleanup;
 	assert_mprog_count(target, 1);
+	tc_skel_reset_all_seen(skel);
 	ASSERT_OK(system(ping_cmd), ping_cmd);
 	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");

tools/testing/selftests/bpf/prog_tests/tc_opts.c+332−23

@@ -59,6 +59,7 @@ void serial_test_tc_opts_basic(void) · 58 unmodified lines
59	ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");	59	ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
60	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");	60	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
61		61
		62	tc_skel_reset_all_seen(skel);
62	ASSERT_OK(system(ping_cmd), ping_cmd);	63	ASSERT_OK(system(ping_cmd), ping_cmd);
63		64
64	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	65	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -83,6 +84,7 @@ void serial_test_tc_opts_basic(void) · 18 unmodified lines
83	ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");	84	ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
84	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");	85	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
85		86
		87	tc_skel_reset_all_seen(skel);
86	ASSERT_OK(system(ping_cmd), ping_cmd);	88	ASSERT_OK(system(ping_cmd), ping_cmd);
87		89
88	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	90	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -163,6 +165,7 @@ static void test_tc_opts_before_target(int target) · 74 unmodified lines
163	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");	165	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
164	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");	166	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
165		167
		168	tc_skel_reset_all_seen(skel);
166	ASSERT_OK(system(ping_cmd), ping_cmd);	169	ASSERT_OK(system(ping_cmd), ping_cmd);
167		170
168	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	171	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -219,6 +222,7 @@ static void test_tc_opts_before_target(int target) · 50 unmodified lines
219	ASSERT_EQ(optq.prog_ids[3], id2, "prog_ids[3]");	222	ASSERT_EQ(optq.prog_ids[3], id2, "prog_ids[3]");
220	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");	223	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
221		224
		225	tc_skel_reset_all_seen(skel);
222	ASSERT_OK(system(ping_cmd), ping_cmd);	226	ASSERT_OK(system(ping_cmd), ping_cmd);
223		227
224	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	228	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -313,6 +317,7 @@ static void test_tc_opts_after_target(int target) · 88 unmodified lines
313	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");	317	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
314	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");	318	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
315		319
		320	tc_skel_reset_all_seen(skel);
316	ASSERT_OK(system(ping_cmd), ping_cmd);	321	ASSERT_OK(system(ping_cmd), ping_cmd);
317		322
318	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	323	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -369,6 +374,7 @@ static void test_tc_opts_after_target(int target) · 50 unmodified lines
369	ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");	374	ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
370	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");	375	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
371		376
		377	tc_skel_reset_all_seen(skel);
372	ASSERT_OK(system(ping_cmd), ping_cmd);	378	ASSERT_OK(system(ping_cmd), ping_cmd);
373		379
374	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	380	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -514,6 +520,7 @@ static void test_tc_opts_revision_target(int target) · 139 unmodified lines
514	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");	520	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
515	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");	521	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
516		522
		523	tc_skel_reset_all_seen(skel);
517	ASSERT_OK(system(ping_cmd), ping_cmd);	524	ASSERT_OK(system(ping_cmd), ping_cmd);
518		525
519	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	526	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -608,22 +615,20 @@ static void test_tc_chain_classic(int target, bool chain_tc_old) · 88 unmodified lines
608		615
609	assert_mprog_count(target, 2);	616	assert_mprog_count(target, 2);
610		617
		618	tc_skel_reset_all_seen(skel);
611	ASSERT_OK(system(ping_cmd), ping_cmd);	619	ASSERT_OK(system(ping_cmd), ping_cmd);
612		620
613	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	621	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
614	ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");	622	ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
615	ASSERT_EQ(skel->bss->seen_tc3, chain_tc_old, "seen_tc3");	623	ASSERT_EQ(skel->bss->seen_tc3, chain_tc_old, "seen_tc3");
616		624
617	skel->bss->seen_tc1 = false;
618	skel->bss->seen_tc2 = false;
619	skel->bss->seen_tc3 = false;
620
621	err = bpf_prog_detach_opts(fd2, loopback, target, &optd);	625	err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
622	if (!ASSERT_OK(err, "prog_detach"))	626	if (!ASSERT_OK(err, "prog_detach"))
623	goto cleanup_detach;	627	goto cleanup_detach;
624		628
625	assert_mprog_count(target, 1);	629	assert_mprog_count(target, 1);
626		630
		631	tc_skel_reset_all_seen(skel);
627	ASSERT_OK(system(ping_cmd), ping_cmd);	632	ASSERT_OK(system(ping_cmd), ping_cmd);
628		633
629	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	634	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -635,7 +640,7 @@ cleanup_detach: · 5 unmodified lines
635	if (!ASSERT_OK(err, "prog_detach"))	640	if (!ASSERT_OK(err, "prog_detach"))
636	goto cleanup;	641	goto cleanup;
637		642
638	__assert_mprog_count(target, 0, chain_tc_old, loopback);	643	assert_mprog_count(target, 0);
639	cleanup:	644	cleanup:
640	if (tc_attached) {	645	if (tc_attached) {
641	tc_opts.flags = tc_opts.prog_fd = tc_opts.prog_id = 0;	646	tc_opts.flags = tc_opts.prog_fd = tc_opts.prog_id = 0;
@@ -730,16 +735,13 @@ static void test_tc_opts_replace_target(int target) · 88 unmodified lines
730	ASSERT_EQ(optq.prog_attach_flags[1], 0, "prog_flags[1]");	735	ASSERT_EQ(optq.prog_attach_flags[1], 0, "prog_flags[1]");
731	ASSERT_EQ(optq.prog_attach_flags[2], 0, "prog_flags[2]");	736	ASSERT_EQ(optq.prog_attach_flags[2], 0, "prog_flags[2]");
732		737
		738	tc_skel_reset_all_seen(skel);
733	ASSERT_OK(system(ping_cmd), ping_cmd);	739	ASSERT_OK(system(ping_cmd), ping_cmd);
734		740
735	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	741	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
736	ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");	742	ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
737	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");	743	ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
738		744
739	skel->bss->seen_tc1 = false;
740	skel->bss->seen_tc2 = false;
741	skel->bss->seen_tc3 = false;
742
743	LIBBPF_OPTS_RESET(opta,	745	LIBBPF_OPTS_RESET(opta,
744	.flags = BPF_F_REPLACE,	746	.flags = BPF_F_REPLACE,
745	.replace_prog_fd = fd2,	747	.replace_prog_fd = fd2,
@@ -767,16 +769,13 @@ static void test_tc_opts_replace_target(int target) · 21 unmodified lines
767	ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");	769	ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
768	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");	770	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
769		771
		772	tc_skel_reset_all_seen(skel);
770	ASSERT_OK(system(ping_cmd), ping_cmd);	773	ASSERT_OK(system(ping_cmd), ping_cmd);
771		774
772	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	775	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
773	ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");	776	ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");
774	ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");	777	ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");
775		778
776	skel->bss->seen_tc1 = false;
777	skel->bss->seen_tc2 = false;
778	skel->bss->seen_tc3 = false;
779
780	LIBBPF_OPTS_RESET(opta,	779	LIBBPF_OPTS_RESET(opta,
781	.flags = BPF_F_REPLACE \| BPF_F_BEFORE,	780	.flags = BPF_F_REPLACE \| BPF_F_BEFORE,
782	.replace_prog_fd = fd3,	781	.replace_prog_fd = fd3,
@@ -805,6 +804,7 @@ static void test_tc_opts_replace_target(int target) · 22 unmodified lines
805	ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");	804	ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
806	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");	805	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
807		806
		807	tc_skel_reset_all_seen(skel);
808	ASSERT_OK(system(ping_cmd), ping_cmd);	808	ASSERT_OK(system(ping_cmd), ping_cmd);
809		809
810	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	810	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -1084,6 +1084,7 @@ static void test_tc_opts_prepend_target(int target) · 273 unmodified lines
1084	ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");	1084	ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
1085	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");	1085	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
1086		1086
		1087	tc_skel_reset_all_seen(skel);
1087	ASSERT_OK(system(ping_cmd), ping_cmd);	1088	ASSERT_OK(system(ping_cmd), ping_cmd);
1088		1089
1089	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	1090	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -1124,6 +1125,7 @@ static void test_tc_opts_prepend_target(int target) · 34 unmodified lines
1124	ASSERT_EQ(optq.prog_ids[3], id1, "prog_ids[3]");	1125	ASSERT_EQ(optq.prog_ids[3], id1, "prog_ids[3]");
1125	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");	1126	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
1126		1127
		1128	tc_skel_reset_all_seen(skel);
1127	ASSERT_OK(system(ping_cmd), ping_cmd);	1129	ASSERT_OK(system(ping_cmd), ping_cmd);
1128		1130
1129	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	1131	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -1222,6 +1224,7 @@ static void test_tc_opts_append_target(int target) · 92 unmodified lines
1222	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");	1224	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
1223	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");	1225	ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
1224		1226
		1227	tc_skel_reset_all_seen(skel);
1225	ASSERT_OK(system(ping_cmd), ping_cmd);	1228	ASSERT_OK(system(ping_cmd), ping_cmd);
1226		1229
1227	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	1230	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -1262,6 +1265,7 @@ static void test_tc_opts_append_target(int target) · 34 unmodified lines
1262	ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");	1265	ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
1263	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");	1266	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
1264		1267
		1268	tc_skel_reset_all_seen(skel);
1265	ASSERT_OK(system(ping_cmd), ping_cmd);	1269	ASSERT_OK(system(ping_cmd), ping_cmd);
1266		1270
1267	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");	1271	ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
@@ -2250,7 +2254,7 @@ static void test_tc_opts_delete_empty(int target, bool chain_tc_old) · 982 unmodified lines
2250	BPF_TC_INGRESS : BPF_TC_EGRESS;	2254	BPF_TC_INGRESS : BPF_TC_EGRESS;
2251	err = bpf_tc_hook_create(&tc_hook);	2255	err = bpf_tc_hook_create(&tc_hook);
2252	ASSERT_OK(err, "bpf_tc_hook_create");	2256	ASSERT_OK(err, "bpf_tc_hook_create");
2253	__assert_mprog_count(target, 0, true, loopback);	2257	assert_mprog_count(target, 0);
2254	}	2258	}
2255	err = bpf_prog_detach_opts(0, loopback, target, &optd);	2259	err = bpf_prog_detach_opts(0, loopback, target, &optd);
2256	ASSERT_EQ(err, -ENOENT, "prog_detach");	2260	ASSERT_EQ(err, -ENOENT, "prog_detach");
@@ -2316,16 +2320,13 @@ static void test_tc_chain_mixed(int target) · 59 unmodified lines
2316		2320
2317	assert_mprog_count(target, 1);	2321	assert_mprog_count(target, 1);
2318		2322
		2323	tc_skel_reset_all_seen(skel);
2319	ASSERT_OK(system(ping_cmd), ping_cmd);	2324	ASSERT_OK(system(ping_cmd), ping_cmd);
2320		2325
2321	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");	2326	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
2322	ASSERT_EQ(skel->bss->seen_tc5, false, "seen_tc5");	2327	ASSERT_EQ(skel->bss->seen_tc5, false, "seen_tc5");
2323	ASSERT_EQ(skel->bss->seen_tc6, true, "seen_tc6");	2328	ASSERT_EQ(skel->bss->seen_tc6, true, "seen_tc6");
2324		2329
2325	skel->bss->seen_tc4 = false;
2326	skel->bss->seen_tc5 = false;
2327	skel->bss->seen_tc6 = false;
2328
2329	LIBBPF_OPTS_RESET(opta,	2330	LIBBPF_OPTS_RESET(opta,
2330	.flags = BPF_F_REPLACE,	2331	.flags = BPF_F_REPLACE,
2331	.replace_prog_fd = fd3,	2332	.replace_prog_fd = fd3,
@@ -2339,21 +2340,19 @@ static void test_tc_chain_mixed(int target) · 7 unmodified lines
2339		2340
2340	assert_mprog_count(target, 1);	2341	assert_mprog_count(target, 1);
2341		2342
		2343	tc_skel_reset_all_seen(skel);
2342	ASSERT_OK(system(ping_cmd), ping_cmd);	2344	ASSERT_OK(system(ping_cmd), ping_cmd);
2343		2345
2344	ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");	2346	ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");
2345	ASSERT_EQ(skel->bss->seen_tc5, true, "seen_tc5");	2347	ASSERT_EQ(skel->bss->seen_tc5, true, "seen_tc5");
2346	ASSERT_EQ(skel->bss->seen_tc6, false, "seen_tc6");	2348	ASSERT_EQ(skel->bss->seen_tc6, false, "seen_tc6");
2347		2349
2348	skel->bss->seen_tc4 = false;
2349	skel->bss->seen_tc5 = false;
2350	skel->bss->seen_tc6 = false;
2351
2352	cleanup_opts:	2350	cleanup_opts:
2353	err = bpf_prog_detach_opts(detach_fd, loopback, target, &optd);	2351	err = bpf_prog_detach_opts(detach_fd, loopback, target, &optd);
2354	ASSERT_OK(err, "prog_detach");	2352	ASSERT_OK(err, "prog_detach");
2355	__assert_mprog_count(target, 0, true, loopback);	2353	assert_mprog_count(target, 0);
2356		2354
		2355	tc_skel_reset_all_seen(skel);
2357	ASSERT_OK(system(ping_cmd), ping_cmd);	2356	ASSERT_OK(system(ping_cmd), ping_cmd);
2358		2357
2359	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");	2358	ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
@@ -2378,3 +2377,313 @@ void serial_test_tc_opts_chain_mixed(void) · 18 unmodified lines
2378	test_tc_chain_mixed(BPF_TCX_INGRESS);	2377	test_tc_chain_mixed(BPF_TCX_INGRESS);
2379	test_tc_chain_mixed(BPF_TCX_EGRESS);	2378	test_tc_chain_mixed(BPF_TCX_EGRESS);
2380	}	2379	}
		2380
		2381	static int generate_dummy_prog(void)
		2382	{
		2383	const struct bpf_insn prog_insns[] = {
		2384	BPF_MOV64_IMM(BPF_REG_0, 0),
		2385	BPF_EXIT_INSN(),
		2386	};
		2387	const size_t prog_insn_cnt = sizeof(prog_insns) / sizeof(struct bpf_insn);
		2388	LIBBPF_OPTS(bpf_prog_load_opts, opts);
		2389	const size_t log_buf_sz = 256;
		2390	char *log_buf;
		2391	int fd = -1;
		2392
		2393	log_buf = malloc(log_buf_sz);
		2394	if (!ASSERT_OK_PTR(log_buf, "log_buf_alloc"))
		2395	return fd;
		2396	opts.log_buf = log_buf;
		2397	opts.log_size = log_buf_sz;
		2398
		2399	log_buf[0] = '\0';
		2400	opts.log_level = 0;
		2401	fd = bpf_prog_load(BPF_PROG_TYPE_SCHED_CLS, "tcx_prog", "GPL",
		2402	prog_insns, prog_insn_cnt, &opts);
		2403	ASSERT_STREQ(log_buf, "", "log_0");
		2404	ASSERT_GE(fd, 0, "prog_fd");
		2405	free(log_buf);
		2406	return fd;
		2407	}
		2408
		2409	static void test_tc_opts_max_target(int target, int flags, bool relative)
		2410	{
		2411	int err, ifindex, i, prog_fd, last_fd = -1;
		2412	LIBBPF_OPTS(bpf_prog_attach_opts, opta);
		2413	const int max_progs = 63;
		2414
		2415	ASSERT_OK(system("ip link add dev tcx_opts1 type veth peer name tcx_opts2"), "add veth");
		2416	ifindex = if_nametoindex("tcx_opts1");
		2417	ASSERT_NEQ(ifindex, 0, "non_zero_ifindex");
		2418
		2419	assert_mprog_count_ifindex(ifindex, target, 0);
		2420
		2421	for (i = 0; i < max_progs; i++) {
		2422	prog_fd = generate_dummy_prog();
		2423	if (!ASSERT_GE(prog_fd, 0, "dummy_prog"))
		2424	goto cleanup;
		2425	err = bpf_prog_attach_opts(prog_fd, ifindex, target, &opta);
		2426	if (!ASSERT_EQ(err, 0, "prog_attach"))
		2427	goto cleanup;
		2428	assert_mprog_count_ifindex(ifindex, target, i + 1);
		2429	if (i == max_progs - 1 && relative)
		2430	last_fd = prog_fd;
		2431	else
		2432	close(prog_fd);
		2433	}
		2434
		2435	prog_fd = generate_dummy_prog();
		2436	if (!ASSERT_GE(prog_fd, 0, "dummy_prog"))
		2437	goto cleanup;
		2438	opta.flags = flags;
		2439	if (last_fd > 0)
		2440	opta.relative_fd = last_fd;
		2441	err = bpf_prog_attach_opts(prog_fd, ifindex, target, &opta);
		2442	ASSERT_EQ(err, -ERANGE, "prog_64_attach");
		2443	assert_mprog_count_ifindex(ifindex, target, max_progs);
		2444	close(prog_fd);
		2445	cleanup:
		2446	if (last_fd > 0)
		2447	close(last_fd);
		2448	ASSERT_OK(system("ip link del dev tcx_opts1"), "del veth");
		2449	ASSERT_EQ(if_nametoindex("tcx_opts1"), 0, "dev1_removed");
		2450	ASSERT_EQ(if_nametoindex("tcx_opts2"), 0, "dev2_removed");
		2451	}
		2452
		2453	void serial_test_tc_opts_max(void)
		2454	{
		2455	test_tc_opts_max_target(BPF_TCX_INGRESS, 0, false);
		2456	test_tc_opts_max_target(BPF_TCX_EGRESS, 0, false);
		2457
		2458	test_tc_opts_max_target(BPF_TCX_INGRESS, BPF_F_BEFORE, false);
		2459	test_tc_opts_max_target(BPF_TCX_EGRESS, BPF_F_BEFORE, true);
		2460
		2461	test_tc_opts_max_target(BPF_TCX_INGRESS, BPF_F_AFTER, true);
		2462	test_tc_opts_max_target(BPF_TCX_EGRESS, BPF_F_AFTER, false);
		2463	}
		2464
		2465	static void test_tc_opts_query_target(int target)
		2466	{
		2467	const size_t attr_size = offsetofend(union bpf_attr, query);
		2468	LIBBPF_OPTS(bpf_prog_attach_opts, opta);
		2469	LIBBPF_OPTS(bpf_prog_detach_opts, optd);
		2470	LIBBPF_OPTS(bpf_prog_query_opts, optq);
		2471	__u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
		2472	struct test_tc_link *skel;
		2473	union bpf_attr attr;
		2474	__u32 prog_ids[5];
		2475	int err;
		2476
		2477	skel = test_tc_link__open_and_load();
		2478	if (!ASSERT_OK_PTR(skel, "skel_load"))
		2479	goto cleanup;
		2480
		2481	fd1 = bpf_program__fd(skel->progs.tc1);
		2482	fd2 = bpf_program__fd(skel->progs.tc2);
		2483	fd3 = bpf_program__fd(skel->progs.tc3);
		2484	fd4 = bpf_program__fd(skel->progs.tc4);
		2485
		2486	id1 = id_from_prog_fd(fd1);
		2487	id2 = id_from_prog_fd(fd2);
		2488	id3 = id_from_prog_fd(fd3);
		2489	id4 = id_from_prog_fd(fd4);
		2490
		2491	assert_mprog_count(target, 0);
		2492
		2493	LIBBPF_OPTS_RESET(opta,
		2494	.expected_revision = 1,
		2495	);
		2496
		2497	err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
		2498	if (!ASSERT_EQ(err, 0, "prog_attach"))
		2499	goto cleanup;
		2500
		2501	assert_mprog_count(target, 1);
		2502
		2503	LIBBPF_OPTS_RESET(opta,
		2504	.expected_revision = 2,
		2505	);
		2506
		2507	err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
		2508	if (!ASSERT_EQ(err, 0, "prog_attach"))
		2509	goto cleanup1;
		2510
		2511	assert_mprog_count(target, 2);
		2512
		2513	LIBBPF_OPTS_RESET(opta,
		2514	.expected_revision = 3,
		2515	);
		2516
		2517	err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
		2518	if (!ASSERT_EQ(err, 0, "prog_attach"))
		2519	goto cleanup2;
		2520
		2521	assert_mprog_count(target, 3);
		2522
		2523	LIBBPF_OPTS_RESET(opta,
		2524	.expected_revision = 4,
		2525	);
		2526
		2527	err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
		2528	if (!ASSERT_EQ(err, 0, "prog_attach"))
		2529	goto cleanup3;
		2530
		2531	assert_mprog_count(target, 4);
		2532
		2533	/* Test 1: Double query via libbpf API */
		2534	err = bpf_prog_query_opts(loopback, target, &optq);
		2535	if (!ASSERT_OK(err, "prog_query"))
		2536	goto cleanup4;
		2537
		2538	ASSERT_EQ(optq.count, 4, "count");
		2539	ASSERT_EQ(optq.revision, 5, "revision");
		2540	ASSERT_EQ(optq.prog_ids, NULL, "prog_ids");
		2541	ASSERT_EQ(optq.link_ids, NULL, "link_ids");
		2542
		2543	memset(prog_ids, 0, sizeof(prog_ids));
		2544	optq.prog_ids = prog_ids;
		2545
		2546	err = bpf_prog_query_opts(loopback, target, &optq);
		2547	if (!ASSERT_OK(err, "prog_query"))
		2548	goto cleanup4;
		2549
		2550	ASSERT_EQ(optq.count, 4, "count");
		2551	ASSERT_EQ(optq.revision, 5, "revision");
		2552	ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
		2553	ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
		2554	ASSERT_EQ(optq.prog_ids[2], id3, "prog_ids[2]");
		2555	ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
		2556	ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
		2557	ASSERT_EQ(optq.link_ids, NULL, "link_ids");
		2558
		2559	/* Test 2: Double query via bpf_attr & bpf(2) directly */
		2560	memset(&attr, 0, attr_size);
		2561	attr.query.target_ifindex = loopback;
		2562	attr.query.attach_type = target;
		2563
		2564	err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
		2565	if (!ASSERT_OK(err, "prog_query"))
		2566	goto cleanup4;
		2567
		2568	ASSERT_EQ(attr.query.count, 4, "count");
		2569	ASSERT_EQ(attr.query.revision, 5, "revision");
		2570	ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
		2571	ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
		2572	ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
		2573	ASSERT_EQ(attr.query.attach_type, target, "attach_type");
		2574	ASSERT_EQ(attr.query.prog_ids, 0, "prog_ids");
		2575	ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
		2576	ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
		2577	ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
		2578
		2579	memset(prog_ids, 0, sizeof(prog_ids));
		2580	attr.query.prog_ids = ptr_to_u64(prog_ids);
		2581
		2582	err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
		2583	if (!ASSERT_OK(err, "prog_query"))
		2584	goto cleanup4;
		2585
		2586	ASSERT_EQ(attr.query.count, 4, "count");
		2587	ASSERT_EQ(attr.query.revision, 5, "revision");
		2588	ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
		2589	ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
		2590	ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
		2591	ASSERT_EQ(attr.query.attach_type, target, "attach_type");
		2592	ASSERT_EQ(attr.query.prog_ids, ptr_to_u64(prog_ids), "prog_ids");
		2593	ASSERT_EQ(prog_ids[0], id1, "prog_ids[0]");
		2594	ASSERT_EQ(prog_ids[1], id2, "prog_ids[1]");
		2595	ASSERT_EQ(prog_ids[2], id3, "prog_ids[2]");
		2596	ASSERT_EQ(prog_ids[3], id4, "prog_ids[3]");
		2597	ASSERT_EQ(prog_ids[4], 0, "prog_ids[4]");
		2598	ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
		2599	ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
		2600	ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
		2601
		2602	cleanup4:
		2603	err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
		2604	ASSERT_OK(err, "prog_detach");
		2605	assert_mprog_count(target, 3);
		2606
		2607	cleanup3:
		2608	err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
		2609	ASSERT_OK(err, "prog_detach");
		2610	assert_mprog_count(target, 2);
		2611
		2612	cleanup2:
		2613	err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
		2614	ASSERT_OK(err, "prog_detach");
		2615	assert_mprog_count(target, 1);
		2616
		2617	cleanup1:
		2618	err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
		2619	ASSERT_OK(err, "prog_detach");
		2620	assert_mprog_count(target, 0);
		2621
		2622	cleanup:
		2623	test_tc_link__destroy(skel);
		2624	}
		2625
		2626	void serial_test_tc_opts_query(void)
		2627	{
		2628	test_tc_opts_query_target(BPF_TCX_INGRESS);
		2629	test_tc_opts_query_target(BPF_TCX_EGRESS);
		2630	}
		2631
		2632	static void test_tc_opts_query_attach_target(int target)
		2633	{
		2634	LIBBPF_OPTS(bpf_prog_attach_opts, opta);
		2635	LIBBPF_OPTS(bpf_prog_detach_opts, optd);
		2636	LIBBPF_OPTS(bpf_prog_query_opts, optq);
		2637	struct test_tc_link *skel;
		2638	__u32 prog_ids[2];
		2639	__u32 fd1, id1;
		2640	int err;
		2641
		2642	skel = test_tc_link__open_and_load();
		2643	if (!ASSERT_OK_PTR(skel, "skel_load"))
		2644	goto cleanup;
		2645
		2646	fd1 = bpf_program__fd(skel->progs.tc1);
		2647	id1 = id_from_prog_fd(fd1);
		2648
		2649	err = bpf_prog_query_opts(loopback, target, &optq);
		2650	if (!ASSERT_OK(err, "prog_query"))
		2651	goto cleanup;
		2652
		2653	ASSERT_EQ(optq.count, 0, "count");
		2654	ASSERT_EQ(optq.revision, 1, "revision");
		2655
		2656	LIBBPF_OPTS_RESET(opta,
		2657	.expected_revision = optq.revision,
		2658	);
		2659
		2660	err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
		2661	if (!ASSERT_EQ(err, 0, "prog_attach"))
		2662	goto cleanup;
		2663
		2664	memset(prog_ids, 0, sizeof(prog_ids));
		2665	optq.prog_ids = prog_ids;
		2666	optq.count = ARRAY_SIZE(prog_ids);
		2667
		2668	err = bpf_prog_query_opts(loopback, target, &optq);
		2669	if (!ASSERT_OK(err, "prog_query"))
		2670	goto cleanup1;
		2671
		2672	ASSERT_EQ(optq.count, 1, "count");
		2673	ASSERT_EQ(optq.revision, 2, "revision");
		2674	ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
		2675	ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
		2676
		2677	cleanup1:
		2678	err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
		2679	ASSERT_OK(err, "prog_detach");
		2680	assert_mprog_count(target, 0);
		2681	cleanup:
		2682	test_tc_link__destroy(skel);
		2683	}
		2684
		2685	void serial_test_tc_opts_query_attach(void)
		2686	{
		2687	test_tc_opts_query_attach_target(BPF_TCX_INGRESS);
		2688	test_tc_opts_query_attach_target(BPF_TCX_EGRESS);
		2689	}

tools/testing/selftests/bpf/prog_tests/timer.c+4−2

 /* Copyright (c) 2021 Facebook */
 #include <test_progs.h>
 #include "timer.skel.h"
+#include "timer_failure.skel.h"
 static int timer(struct timer *timer_skel)
 {
 	timer_skel = timer__open_and_load();
 	if (!ASSERT_OK_PTR(timer_skel, "timer_skel_load"))
-		goto cleanup;
+		return;
 	err = timer(timer_skel);
 	ASSERT_OK(err, "timer");
-cleanup:
 	timer__destroy(timer_skel);
+	RUN_TESTS(timer_failure);
 }

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/bpf/progs/timer_failure.c+47−0

@@ -0,0 +1,47 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */
	3
	4	#include <linux/bpf.h>
	5	#include <time.h>
	6	#include <errno.h>
	7	#include <bpf/bpf_helpers.h>
	8	#include "bpf_misc.h"
	9	#include "bpf_tcp_helpers.h"
	10
	11	char _license[] SEC("license") = "GPL";
	12
	13	struct elem {
	14	struct bpf_timer t;
	15	};
	16
	17	struct {
	18	__uint(type, BPF_MAP_TYPE_ARRAY);
	19	__uint(max_entries, 1);
	20	__type(key, int);
	21	__type(value, struct elem);
	22	} timer_map SEC(".maps");
	23
	24	static int timer_cb_ret1(void map, int key, struct bpf_timer *timer)
	25	{
	26	if (bpf_get_smp_processor_id() % 2)
	27	return 1;
	28	else
	29	return 0;
	30	}
	31
	32	SEC("fentry/bpf_fentry_test1")
	33	__failure __msg("should have been in (0x0; 0x0)")
	34	int BPF_PROG2(test_ret_1, int, a)
	35	{
	36	int key = 0;
	37	struct bpf_timer *timer;
	38
	39	timer = bpf_map_lookup_elem(&timer_map, &key);
	40	if (timer) {
	41	bpf_timer_init(timer, &timer_map, CLOCK_BOOTTIME);
	42	bpf_timer_set_callback(timer, timer_cb_ret1);
	43	bpf_timer_start(timer, 1000, 0);
	44	}
	45
	46	return 0;
	47	}

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/riscv/mm/Makefile+3−3

@@ -5,11 +5,11 @@ · 4 unmodified lines
5	# Additional include paths needed by kselftest.h and local headers	5	# Additional include paths needed by kselftest.h and local headers
6	CFLAGS += -D_GNU_SOURCE -std=gnu99 -I.	6	CFLAGS += -D_GNU_SOURCE -std=gnu99 -I.
7		7
8	TEST_GEN_FILES := testcases/mmap_default testcases/mmap_bottomup	8	TEST_GEN_FILES := mmap_default mmap_bottomup
9		9
10	TEST_PROGS := testcases/run_mmap.sh	10	TEST_PROGS := run_mmap.sh
11		11
12	include ../../lib.mk	12	include ../../lib.mk
13		13
14	$(OUTPUT)/mm: testcases/mmap_default.c testcases/mmap_bottomup.c testcases/mmap_tests.h	14	$(OUTPUT)/mm: mmap_default.c mmap_bottomup.c mmap_tests.h
15	$(CC) -o$@ $(CFLAGS) $(LDFLAGS) $^	15	$(CC) -o$@ $(CFLAGS) $(LDFLAGS) $^

tools/testing/selftests/riscv/mm/mmap_bottomup.crenamed from tools/testing/selftests/riscv/mm/testcases/mmap_bottomup.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	#include <sys/mman.h>	2	#include <sys/mman.h>
3	#include <testcases/mmap_test.h>	3	#include <mmap_test.h>
4		4
5	#include "../../kselftest_harness.h"	5	#include "../../kselftest_harness.h"
6		6

tools/testing/selftests/riscv/mm/mmap_default.crenamed from tools/testing/selftests/riscv/mm/testcases/mmap_default.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	#include <sys/mman.h>	2	#include <sys/mman.h>
3	#include <testcases/mmap_test.h>	3	#include <mmap_test.h>
4		4
5	#include "../../kselftest_harness.h"	5	#include "../../kselftest_harness.h"
6		6

tools/testing/selftests/riscv/mm/mmap_test.hrenamed from tools/testing/selftests/riscv/mm/testcases/mmap_test.h+0−0

File renamed without changes.

tools/testing/selftests/riscv/mm/run_mmap.shrenamed from tools/testing/selftests/riscv/mm/testcases/run_mmap.sh+0−0

File renamed without changes.

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 6.6-rc6 into tty-next

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -25,15 +25,15 @@ Contact · 24 unmodified lines
25	The Linux kernel hardware security team is separate from the regular Linux	25	The Linux kernel hardware security team is separate from the regular Linux
26	kernel security team.	26	kernel security team.
27		27
28	The team only handles the coordination of embargoed hardware security	28	The team only handles developing fixes for embargoed hardware security
29	issues. Reports of pure software security bugs in the Linux kernel are not	29	issues. Reports of pure software security bugs in the Linux kernel are not
30	handled by this team and the reporter will be guided to contact the regular	30	handled by this team and the reporter will be guided to contact the regular
31	Linux kernel security team (:ref:`Documentation/admin-guide/	31	Linux kernel security team (:ref:`Documentation/admin-guide/
32	<securitybugs>`) instead.	32	<securitybugs>`) instead.
33		33
34	The team can be contacted by email at <hardware-security@kernel.org>. This	34	The team can be contacted by email at <hardware-security@kernel.org>. This
35	is a private list of security officers who will help you to coordinate an	35	is a private list of security officers who will help you to coordinate a
36	issue according to our documented process.	36	fix according to our documented process.
37		37
38	The list is encrypted and email to the list can be sent by either PGP or	38	The list is encrypted and email to the list can be sent by either PGP or
39	S/MIME encrypted and must be signed with the reporter's PGP key or S/MIME	39	S/MIME encrypted and must be signed with the reporter's PGP key or S/MIME
@@ -132,11 +132,11 @@ other hardware could be affected. · 92 unmodified lines
132		132
133	The hardware security team will provide an incident-specific encrypted	133	The hardware security team will provide an incident-specific encrypted
134	mailing-list which will be used for initial discussion with the reporter,	134	mailing-list which will be used for initial discussion with the reporter,
135	further disclosure and coordination.	135	further disclosure, and coordination of fixes.
136		136
137	The hardware security team will provide the disclosing party a list of	137	The hardware security team will provide the disclosing party a list of
138	developers (domain experts) who should be informed initially about the	138	developers (domain experts) who should be informed initially about the
139	issue after confirming with the developers that they will adhere to this	139	issue after confirming with the developers that they will adhere to this
140	Memorandum of Understanding and the documented process. These developers	140	Memorandum of Understanding and the documented process. These developers
141	form the initial response team and will be responsible for handling the	141	form the initial response team and will be responsible for handling the
142	issue after initial contact. The hardware security team is supporting the	142	issue after initial contact. The hardware security team is supporting the
@@ -209,13 +209,18 @@ five work days this is taken as silent acknowledgement. · 66 unmodified lines
209	After acknowledgement or resolution of an objection the expert is disclosed	209	After acknowledgement or resolution of an objection the expert is disclosed
210	by the incident team and brought into the development process.	210	by the incident team and brought into the development process.
211		211
		212	List participants may not communicate about the issue outside of the
		213	private mailing list. List participants may not use any shared resources
		214	(e.g. employer build farms, CI systems, etc) when working on patches.
		215
212		216
213	Coordinated release	217	Coordinated release
214	"""""""""""""""""""	218	"""""""""""""""""""
215		219
216	The involved parties will negotiate the date and time where the embargo	220	The involved parties will negotiate the date and time where the embargo
217	ends. At that point the prepared mitigations are integrated into the	221	ends. At that point the prepared mitigations are integrated into the
218	relevant kernel trees and published.	222	relevant kernel trees and published. There is no pre-notification process:
		223	fixes are published in public and available to everyone at the same time.
219		224
220	While we understand that hardware security issues need coordinated embargo	225	While we understand that hardware security issues need coordinated embargo
221	time, the embargo time should be constrained to the minimum time which is	226	time, the embargo time should be constrained to the minimum time which is