lael-labs/linux

.mailmap+1−0

@@ -608,6 +608,7 @@ Simon Kelley <simon@thekelleys.org.uk> · 607 unmodified lines
608	Sricharan Ramabadhran <quic_srichara@quicinc.com> <sricharan@codeaurora.org>	608	Sricharan Ramabadhran <quic_srichara@quicinc.com> <sricharan@codeaurora.org>
609	Srinivas Ramana <quic_sramana@quicinc.com> <sramana@codeaurora.org>	609	Srinivas Ramana <quic_sramana@quicinc.com> <sramana@codeaurora.org>
610	Sriram R <quic_srirrama@quicinc.com> <srirrama@codeaurora.org>	610	Sriram R <quic_srirrama@quicinc.com> <srirrama@codeaurora.org>
		611	Stanislav Fomichev <sdf@fomichev.me> <sdf@google.com>
611	Stefan Wahren <wahrenst@gmx.net> <stefan.wahren@i2se.com>	612	Stefan Wahren <wahrenst@gmx.net> <stefan.wahren@i2se.com>
612	Stéphane Witzmann <stephane.witzmann@ubpmes.univ-bpclermont.fr>	613	Stéphane Witzmann <stephane.witzmann@ubpmes.univ-bpclermont.fr>
613	Stephen Hemminger <stephen@networkplumber.org> <shemminger@linux-foundation.org>	614	Stephen Hemminger <stephen@networkplumber.org> <shemminger@linux-foundation.org>

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

 			Format: 0 | 1
 			Default set by CONFIG_INIT_ON_FREE_DEFAULT_ON.
-	init_mlocked_on_free=	[MM] Fill freed userspace memory with zeroes if
-				it was mlock'ed and not explicitly munlock'ed
-				afterwards.
-				Format: 0 | 1
-				Default set by CONFIG_INIT_MLOCKED_ON_FREE_DEFAULT_ON
 	init_pkru=	[X86] Specify the default memory protection keys rights
 			register contents for all processes.  0x55555554 by
 			default (disallow access to all but pkey 0).  Can

Documentation/devicetree/bindings/dma/fsl,edma.yaml+2−2

@@ -59,8 +59,8 @@ properties: · 58 unmodified lines
59	- 3	59	- 3
60		60
61	dma-channels:	61	dma-channels:
62	minItems: 1	62	minimum: 1
63	maxItems: 64	63	maximum: 64
64		64
65	clocks:	65	clocks:
66	minItems: 1	66	minItems: 1

Documentation/devicetree/bindings/i2c/atmel,at91sam-i2c.yaml+1−1

@@ -77,7 +77,7 @@ required: · 76 unmodified lines
77	- clocks	77	- clocks
78		78
79	allOf:	79	allOf:
80	- $ref: i2c-controller.yaml	80	- $ref: /schemas/i2c/i2c-controller.yaml#
81	- if:	81	- if:
82	properties:	82	properties:
83	compatible:	83	compatible:

Documentation/devicetree/bindings/i2c/google,cros-ec-i2c-tunnel.yaml+1−1

@@ -21,7 +21,7 @@ description: \| · 20 unmodified lines
21	google,cros-ec-spi or google,cros-ec-i2c.	21	google,cros-ec-spi or google,cros-ec-i2c.
22		22
23	allOf:	23	allOf:
24	- $ref: i2c-controller.yaml#	24	- $ref: /schemas/i2c/i2c-controller.yaml#
25		25
26	properties:	26	properties:
27	compatible:	27	compatible:

Documentation/i2c/i2c_bus.svg+8−7

 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!-- Created with Inkscape (http://www.inkscape.org/) -->
+<!-- Updated to inclusive terminology by Wolfram Sang -->
 <svg
    xmlns:dc="http://purl.org/dc/elements/1.1/"
     <rect
        style="opacity:1;fill:#ffb9b9;fill-opacity:1;stroke:#f00000;stroke-width:2.8125;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
        id="rect4424-3-2-9-7"
-       width="112.5"
+       width="134.5"
        height="113.75008"
        x="112.5"
        y="471.11221"
        y="521.46259"
        id="text4349"><tspan
          sodipodi:role="line"
-         x="167.5354"
+         x="178.5354"
          y="521.46259"
          style="font-size:25px;line-height:1.25;font-family:sans-serif;text-align:center;text-anchor:middle"
          id="tspan1273">I2C</tspan><tspan
          sodipodi:role="line"
-         x="167.5354"
+         x="178.5354"
          y="552.71259"
          style="font-size:25px;line-height:1.25;font-family:sans-serif;text-align:center;text-anchor:middle"
-         id="tspan1285">Master</tspan></text>
+         id="tspan1285">Controller</tspan></text>
     <rect
        style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#b9ffb9;fill-opacity:1;fill-rule:nonzero;stroke:#006400;stroke-width:2.8125;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
        id="rect4424-3-2-9-7-3-3-5-3"
          x="318.59131"
          y="552.08752"
          style="font-size:25.00000191px;line-height:1.25;font-family:sans-serif;text-align:center;text-anchor:middle;stroke-width:1px"
-         id="tspan1287">Slave</tspan></text>
+         id="tspan1287">Target</tspan></text>
     <path
        style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1.99968767;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
        d="m 112.49995,677.36223 c 712.50005,0 712.50005,0 712.50005,0"
          x="468.59131"
          y="552.08746"
          style="font-size:25.00000191px;line-height:1.25;font-family:sans-serif;text-align:center;text-anchor:middle;stroke-width:1px"
-         id="tspan1287-6">Slave</tspan></text>
+         id="tspan1287-6">Target</tspan></text>
     <rect
        style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#b9ffb9;fill-opacity:1;fill-rule:nonzero;stroke:#006400;stroke-width:2.8125;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
        id="rect4424-3-2-9-7-3-3-5-3-1"
          x="618.59131"
          y="552.08746"
          style="font-size:25.00000191px;line-height:1.25;font-family:sans-serif;text-align:center;text-anchor:middle;stroke-width:1px"
-         id="tspan1287-9">Slave</tspan></text>
+         id="tspan1287-9">Target</tspan></text>
     <path
        style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1.99968743;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#DotM)"
        d="m 150,583.61221 v 93.75"

Documentation/i2c/summary.rst+50−29

@@ -3,29 +3,27 @@ Introduction to I2C and SMBus · 2 unmodified lines
3	=============================	3	=============================
4		4
5	I²C (pronounce: I squared C and written I2C in the kernel documentation) is	5	I²C (pronounce: I squared C and written I2C in the kernel documentation) is
6	a protocol developed by Philips. It is a slow two-wire protocol (variable	6	a protocol developed by Philips. It is a two-wire protocol with variable
7	speed, up to 400 kHz), with a high speed extension (3.4 MHz). It provides	7	speed (typically up to 400 kHz, high speed modes up to 5 MHz). It provides
8	an inexpensive bus for connecting many types of devices with infrequent or	8	an inexpensive bus for connecting many types of devices with infrequent or
9	low bandwidth communications needs. I2C is widely used with embedded	9	low bandwidth communications needs. I2C is widely used with embedded
10	systems. Some systems use variants that don't meet branding requirements,	10	systems. Some systems use variants that don't meet branding requirements,
11	and so are not advertised as being I2C but come under different names,	11	and so are not advertised as being I2C but come under different names,
12	e.g. TWI (Two Wire Interface), IIC.	12	e.g. TWI (Two Wire Interface), IIC.
13		13
14	The latest official I2C specification is the `"I2C-bus specification and user	14	The latest official I2C specification is the `"I²C-bus specification and user
15	manual" (UM10204) <https://www.nxp.com/webapp/Download?colCode=UM10204>`_	15	manual" (UM10204) <https://www.nxp.com/docs/en/user-guide/UM10204.pdf>`_
16	published by NXP Semiconductors. However, you need to log-in to the site to	16	published by NXP Semiconductors, version 7 as of this writing.
17	access the PDF. An older version of the specification (revision 6) is archived
18	`here <https://web.archive.org/web/20210813122132/https://www.nxp.com/docs/en/user-guide/UM10204.pdf>`_.
19		17
20	SMBus (System Management Bus) is based on the I2C protocol, and is mostly	18	SMBus (System Management Bus) is based on the I2C protocol, and is mostly
21	a subset of I2C protocols and signaling. Many I2C devices will work on an	19	a subset of I2C protocols and signaling. Many I2C devices will work on an
22	SMBus, but some SMBus protocols add semantics beyond what is required to	20	SMBus, but some SMBus protocols add semantics beyond what is required to
23	achieve I2C branding. Modern PC mainboards rely on SMBus. The most common	21	achieve I2C branding. Modern PC mainboards rely on SMBus. The most common
24	devices connected through SMBus are RAM modules configured using I2C EEPROMs,	22	devices connected through SMBus are RAM modules configured using I2C EEPROMs,
25	and hardware monitoring chips.	23	and hardware monitoring chips.
26		24
27	Because the SMBus is mostly a subset of the generalized I2C bus, we can	25	Because the SMBus is mostly a subset of the generalized I2C bus, we can
28	use its protocols on many I2C systems. However, there are systems that don't	26	use its protocols on many I2C systems. However, there are systems that don't
29	meet both SMBus and I2C electrical constraints; and others which can't	27	meet both SMBus and I2C electrical constraints; and others which can't
30	implement all the common SMBus protocol semantics or messages.	28	implement all the common SMBus protocol semantics or messages.
31		29
@@ -33,29 +31,52 @@ implement all the common SMBus protocol semantics or messages. · 1 unmodified line
33	Terminology	31	Terminology
34	===========	32	===========
35		33
36	Using the terminology from the official documentation, the I2C bus connects	34	The I2C bus connects one or more controller chips and one or more target chips.
37	one or more master chips and one or more slave chips.
38		35
39	.. kernel-figure:: i2c_bus.svg	36	.. kernel-figure:: i2c_bus.svg
40	:alt: Simple I2C bus with one master and 3 slaves	37	:alt: Simple I2C bus with one controller and 3 targets
41		38
42	Simple I2C bus	39	Simple I2C bus
43		40
44	A master chip is a node that starts communications with slaves. In the	41	A controller chip is a node that starts communications with targets. In the
45	Linux kernel implementation it is called an adapter or bus. Adapter	42	Linux kernel implementation it is also called an "adapter" or "bus". Controller
46	drivers are in the ``drivers/i2c/busses/`` subdirectory.	43	drivers are usually in the ``drivers/i2c/busses/`` subdirectory.
47		44
48	An algorithm contains general code that can be used to implement a	45	An algorithm contains general code that can be used to implement a whole
49	whole class of I2C adapters. Each specific adapter driver either depends on	46	class of I2C controllers. Each specific controller driver either depends on an
50	an algorithm driver in the ``drivers/i2c/algos/`` subdirectory, or includes	47	algorithm driver in the ``drivers/i2c/algos/`` subdirectory, or includes its
51	its own implementation.	48	own implementation.
52		49
53	A slave chip is a node that responds to communications when addressed	50	A target chip is a node that responds to communications when addressed by a
54	by the master. In Linux it is called a client. Client drivers are kept	51	controller. In the Linux kernel implementation it is also called a "client".
55	in a directory specific to the feature they provide, for example	52	While targets are usually separate external chips, Linux can also act as a
56	``drivers/media/gpio/`` for GPIO expanders and ``drivers/media/i2c/`` for	53	target (needs hardware support) and respond to another controller on the bus.
		54	This is then called a local target. In contrast, an external chip is called
		55	a remote target.
		56
		57	Target drivers are kept in a directory specific to the feature they provide,
		58	for example ``drivers/gpio/`` for GPIO expanders and ``drivers/media/i2c/`` for
57	video-related chips.	59	video-related chips.
58		60
59	For the example configuration in figure, you will need a driver for your	61	For the example configuration in the figure above, you will need one driver for
60	I2C adapter, and drivers for your I2C devices (usually one driver for each	62	the I2C controller, and drivers for your I2C targets. Usually one driver for
61	device).	63	each target.
		64
		65	Synonyms
		66	--------
		67
		68	As mentioned above, the Linux I2C implementation historically uses the terms
		69	"adapter" for controller and "client" for target. A number of data structures
		70	have these synonyms in their name. So, when discussing implementation details,
		71	you should be aware of these terms as well. The official wording is preferred,
		72	though.
		73
		74	Outdated terminology
		75	--------------------
		76
		77	In earlier I2C specifications, controller was named "master" and target was
		78	named "slave". These terms have been obsoleted with v7 of the specification and
		79	their use is also discouraged by the Linux Kernel Code of Conduct. You may
		80	still find them in references to documentation which has not been updated. The
		81	general attitude, however, is to use the inclusive terms: controller and
		82	target. Work to replace the old terminology in the Linux Kernel is on-going.

Documentation/netlink/specs/nfsd.yaml+0−2

       doc: dump pending nfsd rpc
       attribute-set: rpc-status
       dump:
-        pre: nfsd-nl-rpc-status-get-start
-        post: nfsd-nl-rpc-status-get-done
         reply:
           attributes:
             - xid

Documentation/power/regulator/consumer.rst+6−0

@@ -227,3 +227,9 @@ directly written to the voltage selector register, use:: · 226 unmodified lines
227		227
228	int regulator_list_hardware_vsel(struct regulator *regulator,	228	int regulator_list_hardware_vsel(struct regulator *regulator,
229	unsigned selector);	229	unsigned selector);
		230
		231	To access the hardware for enabling/disabling the regulator, consumers must
		232	use regulator_get_exclusive(), as it can't work if there's more than one
		233	consumer. To enable/disable regulator use::
		234
		235	int regulator_hardware_enable(struct regulator *regulator, bool enable);

Documentation/userspace-api/index.rst+1−0

@@ -32,6 +32,7 @@ Security-related interfaces · 31 unmodified lines
32	seccomp_filter	32	seccomp_filter
33	landlock	33	landlock
34	lsm	34	lsm
		35	mfd_noexec
35	spec_ctrl	36	spec_ctrl
36	tee	37	tee
37		38

Documentation/userspace-api/mfd_noexec.rst+86−0

@@ -0,0 +1,86 @@
	1	.. SPDX-License-Identifier: GPL-2.0
	2
	3	==================================
	4	Introduction of non-executable mfd
	5	==================================
	6	:Author:
	7	Daniel Verkamp <dverkamp@chromium.org>
	8	Jeff Xu <jeffxu@chromium.org>
	9
	10	:Contributor:
	11	Aleksa Sarai <cyphar@cyphar.com>
	12
	13	Since Linux introduced the memfd feature, memfds have always had their
	14	execute bit set, and the memfd_create() syscall doesn't allow setting
	15	it differently.
	16
	17	However, in a secure-by-default system, such as ChromeOS, (where all
	18	executables should come from the rootfs, which is protected by verified
	19	boot), this executable nature of memfd opens a door for NoExec bypass
	20	and enables “confused deputy attack”. E.g, in VRP bug [1]: cros_vm
	21	process created a memfd to share the content with an external process,
	22	however the memfd is overwritten and used for executing arbitrary code
	23	and root escalation. [2] lists more VRP of this kind.
	24
	25	On the other hand, executable memfd has its legit use: runc uses memfd’s
	26	seal and executable feature to copy the contents of the binary then
	27	execute them. For such a system, we need a solution to differentiate runc's
	28	use of executable memfds and an attacker's [3].
	29
	30	To address those above:
	31	- Let memfd_create() set X bit at creation time.
	32	- Let memfd be sealed for modifying X bit when NX is set.
	33	- Add a new pid namespace sysctl: vm.memfd_noexec to help applications in
	34	migrating and enforcing non-executable MFD.
	35
	36	User API
	37	========
	38	``int memfd_create(const char *name, unsigned int flags)``
	39
	40	``MFD_NOEXEC_SEAL``
	41	When MFD_NOEXEC_SEAL bit is set in the ``flags``, memfd is created
	42	with NX. F_SEAL_EXEC is set and the memfd can't be modified to
	43	add X later. MFD_ALLOW_SEALING is also implied.
	44	This is the most common case for the application to use memfd.
	45
	46	``MFD_EXEC``
	47	When MFD_EXEC bit is set in the ``flags``, memfd is created with X.
	48
	49	Note:
	50	``MFD_NOEXEC_SEAL`` implies ``MFD_ALLOW_SEALING``. In case that
	51	an app doesn't want sealing, it can add F_SEAL_SEAL after creation.
	52
	53
	54	Sysctl:
	55	========
	56	``pid namespaced sysctl vm.memfd_noexec``
	57
	58	The new pid namespaced sysctl vm.memfd_noexec has 3 values:
	59
	60	- 0: MEMFD_NOEXEC_SCOPE_EXEC
	61	memfd_create() without MFD_EXEC nor MFD_NOEXEC_SEAL acts like
	62	MFD_EXEC was set.
	63
	64	- 1: MEMFD_NOEXEC_SCOPE_NOEXEC_SEAL
	65	memfd_create() without MFD_EXEC nor MFD_NOEXEC_SEAL acts like
	66	MFD_NOEXEC_SEAL was set.
	67
	68	- 2: MEMFD_NOEXEC_SCOPE_NOEXEC_ENFORCED
	69	memfd_create() without MFD_NOEXEC_SEAL will be rejected.
	70
	71	The sysctl allows finer control of memfd_create for old software that
	72	doesn't set the executable bit; for example, a container with
	73	vm.memfd_noexec=1 means the old software will create non-executable memfd
	74	by default while new software can create executable memfd by setting
	75	MFD_EXEC.
	76
	77	The value of vm.memfd_noexec is passed to child namespace at creation
	78	time. In addition, the setting is hierarchical, i.e. during memfd_create,
	79	we will search from current ns to root ns and use the most restrictive
	80	setting.
	81
	82	[1] https://crbug.com/1305267
	83
	84	[2] https://bugs.chromium.org/p/chromium/issues/list?q=type%3Dbug-security%20memfd%20escalation&can=1
	85
	86	[3] https://lwn.net/Articles/781013/

Documentation/virt/hyperv/clocks.rst+15−6

@@ -62,12 +62,21 @@ shared page with scale and offset values into user space. User · 61 unmodified lines
62	space code performs the same algorithm of reading the TSC and	62	space code performs the same algorithm of reading the TSC and
63	applying the scale and offset to get the constant 10 MHz clock.	63	applying the scale and offset to get the constant 10 MHz clock.
64		64
65	Linux clockevents are based on Hyper-V synthetic timer 0. While	65	Linux clockevents are based on Hyper-V synthetic timer 0 (stimer0).
66	Hyper-V offers 4 synthetic timers for each CPU, Linux only uses	66	While Hyper-V offers 4 synthetic timers for each CPU, Linux only uses
67	timer 0. Interrupts from stimer0 are recorded on the "HVS" line in	67	timer 0. In older versions of Hyper-V, an interrupt from stimer0
68	/proc/interrupts. Clockevents based on the virtualized PIT and	68	results in a VMBus control message that is demultiplexed by
69	local APIC timer also work, but the Hyper-V synthetic timer is	69	vmbus_isr() as described in the Documentation/virt/hyperv/vmbus.rst
70	preferred.	70	documentation. In newer versions of Hyper-V, stimer0 interrupts can
		71	be mapped to an architectural interrupt, which is referred to as
		72	"Direct Mode". Linux prefers to use Direct Mode when available. Since
		73	x86/x64 doesn't support per-CPU interrupts, Direct Mode statically
		74	allocates an x86 interrupt vector (HYPERV_STIMER0_VECTOR) across all CPUs
		75	and explicitly codes it to call the stimer0 interrupt handler. Hence
		76	interrupts from stimer0 are recorded on the "HVS" line in /proc/interrupts
		77	rather than being associated with a Linux IRQ. Clockevents based on the
		78	virtualized PIT and local APIC timer also work, but Hyper-V stimer0
		79	is preferred.
71		80
72	The driver for the Hyper-V synthetic system clock and timers is	81	The driver for the Hyper-V synthetic system clock and timers is
73	drivers/clocksource/hyperv_timer.c.	82	drivers/clocksource/hyperv_timer.c.

Documentation/virt/hyperv/overview.rst+11−11

Documentation/virt/hyperv/vmbus.rst+83−60

@@ -1,8 +1,8 @@
1	.. SPDX-License-Identifier: GPL-2.0	1	.. SPDX-License-Identifier: GPL-2.0
2		2
3	VMbus	3	VMBus
4	=====	4	=====
5	VMbus is a software construct provided by Hyper-V to guest VMs. It	5	VMBus is a software construct provided by Hyper-V to guest VMs. It
6	consists of a control path and common facilities used by synthetic	6	consists of a control path and common facilities used by synthetic
7	devices that Hyper-V presents to guest VMs. The control path is	7	devices that Hyper-V presents to guest VMs. The control path is
8	used to offer synthetic devices to the guest VM and, in some cases,	8	used to offer synthetic devices to the guest VM and, in some cases,
@@ -12,9 +12,9 @@ and the synthetic device implementation that is part of Hyper-V, and · 3 unmodified lines
12	signaling primitives to allow Hyper-V and the guest to interrupt	12	signaling primitives to allow Hyper-V and the guest to interrupt
13	each other.	13	each other.
14		14
15	VMbus is modeled in Linux as a bus, with the expected /sys/bus/vmbus	15	VMBus is modeled in Linux as a bus, with the expected /sys/bus/vmbus
16	entry in a running Linux guest. The VMbus driver (drivers/hv/vmbus_drv.c)	16	entry in a running Linux guest. The VMBus driver (drivers/hv/vmbus_drv.c)
17	establishes the VMbus control path with the Hyper-V host, then	17	establishes the VMBus control path with the Hyper-V host, then
18	registers itself as a Linux bus driver. It implements the standard	18	registers itself as a Linux bus driver. It implements the standard
19	bus functions for adding and removing devices to/from the bus.	19	bus functions for adding and removing devices to/from the bus.
20		20
@@ -49,9 +49,9 @@ synthetic NIC is referred to as "netvsc" and the Linux driver for · 28 unmodified lines
49	the synthetic SCSI controller is "storvsc". These drivers contain	49	the synthetic SCSI controller is "storvsc". These drivers contain
50	functions with names like "storvsc_connect_to_vsp".	50	functions with names like "storvsc_connect_to_vsp".
51		51
52	VMbus channels	52	VMBus channels
53	--------------	53	--------------
54	An instance of a synthetic device uses VMbus channels to communicate	54	An instance of a synthetic device uses VMBus channels to communicate
55	between the VSP and the VSC. Channels are bi-directional and used	55	between the VSP and the VSC. Channels are bi-directional and used
56	for passing messages. Most synthetic devices use a single channel,	56	for passing messages. Most synthetic devices use a single channel,
57	but the synthetic SCSI controller and synthetic NIC may use multiple	57	but the synthetic SCSI controller and synthetic NIC may use multiple
@@ -73,7 +73,7 @@ write indices and some control flags, followed by the memory for the · 15 unmodified lines
73	actual ring. The size of the ring is determined by the VSC in the	73	actual ring. The size of the ring is determined by the VSC in the
74	guest and is specific to each synthetic device. The list of GPAs	74	guest and is specific to each synthetic device. The list of GPAs
75	making up the ring is communicated to the Hyper-V host over the	75	making up the ring is communicated to the Hyper-V host over the
76	VMbus control path as a GPA Descriptor List (GPADL). See function	76	VMBus control path as a GPA Descriptor List (GPADL). See function
77	vmbus_establish_gpadl().	77	vmbus_establish_gpadl().
78		78
79	Each ring buffer is mapped into contiguous Linux kernel virtual	79	Each ring buffer is mapped into contiguous Linux kernel virtual
@@ -102,10 +102,10 @@ resources. For Windows Server 2019 and later, this limit is · 22 unmodified lines
102	approximately 1280 Mbytes. For versions prior to Windows Server	102	approximately 1280 Mbytes. For versions prior to Windows Server
103	2019, the limit is approximately 384 Mbytes.	103	2019, the limit is approximately 384 Mbytes.
104		104
105	VMbus messages	105	VMBus channel messages
106	--------------	106	----------------------
107	All VMbus messages have a standard header that includes the message	107	All messages sent in a VMBus channel have a standard header that includes
108	length, the offset of the message payload, some flags, and a	108	the message length, the offset of the message payload, some flags, and a
109	transactionID. The portion of the message after the header is	109	transactionID. The portion of the message after the header is
110	unique to each VSP/VSC pair.	110	unique to each VSP/VSC pair.
111		111
@@ -137,7 +137,7 @@ control message contains a list of GPAs that describe the data · 25 unmodified lines
137	buffer. For example, the storvsc driver uses this approach to	137	buffer. For example, the storvsc driver uses this approach to
138	specify the data buffers to/from which disk I/O is done.	138	specify the data buffers to/from which disk I/O is done.
139		139
140	Three functions exist to send VMbus messages:	140	Three functions exist to send VMBus channel messages:
141		141
142	1. vmbus_sendpacket(): Control-only messages and messages with	142	1. vmbus_sendpacket(): Control-only messages and messages with
143	embedded data -- no GPAs	143	embedded data -- no GPAs
@@ -154,20 +154,51 @@ Historically, Linux guests have trusted Hyper-V to send well-formed · 10 unmodified lines
154	and valid messages, and Linux drivers for synthetic devices did not	154	and valid messages, and Linux drivers for synthetic devices did not
155	fully validate messages. With the introduction of processor	155	fully validate messages. With the introduction of processor
156	technologies that fully encrypt guest memory and that allow the	156	technologies that fully encrypt guest memory and that allow the
157	guest to not trust the hypervisor (AMD SNP-SEV, Intel TDX), trusting	157	guest to not trust the hypervisor (AMD SEV-SNP, Intel TDX), trusting
158	the Hyper-V host is no longer a valid assumption. The drivers for	158	the Hyper-V host is no longer a valid assumption. The drivers for
159	VMbus synthetic devices are being updated to fully validate any	159	VMBus synthetic devices are being updated to fully validate any
160	values read from memory that is shared with Hyper-V, which includes	160	values read from memory that is shared with Hyper-V, which includes
161	messages from VMbus devices. To facilitate such validation,	161	messages from VMBus devices. To facilitate such validation,
162	messages read by the guest from the "in" ring buffer are copied to a	162	messages read by the guest from the "in" ring buffer are copied to a
163	temporary buffer that is not shared with Hyper-V. Validation is	163	temporary buffer that is not shared with Hyper-V. Validation is
164	performed in this temporary buffer without the risk of Hyper-V	164	performed in this temporary buffer without the risk of Hyper-V
165	maliciously modifying the message after it is validated but before	165	maliciously modifying the message after it is validated but before
166	it is used.	166	it is used.
167		167
168	VMbus interrupts	168	Synthetic Interrupt Controller (synic)
		169	--------------------------------------
		170	Hyper-V provides each guest CPU with a synthetic interrupt controller
		171	that is used by VMBus for host-guest communication. While each synic
		172	defines 16 synthetic interrupts (SINT), Linux uses only one of the 16
		173	(VMBUS_MESSAGE_SINT). All interrupts related to communication between
		174	the Hyper-V host and a guest CPU use that SINT.
		175
		176	The SINT is mapped to a single per-CPU architectural interrupt (i.e,
		177	an 8-bit x86/x64 interrupt vector, or an arm64 PPI INTID). Because
		178	each CPU in the guest has a synic and may receive VMBus interrupts,
		179	they are best modeled in Linux as per-CPU interrupts. This model works
		180	well on arm64 where a single per-CPU Linux IRQ is allocated for
		181	VMBUS_MESSAGE_SINT. This IRQ appears in /proc/interrupts as an IRQ labelled
		182	"Hyper-V VMbus". Since x86/x64 lacks support for per-CPU IRQs, an x86
		183	interrupt vector is statically allocated (HYPERVISOR_CALLBACK_VECTOR)
		184	across all CPUs and explicitly coded to call vmbus_isr(). In this case,
		185	there's no Linux IRQ, and the interrupts are visible in aggregate in
		186	/proc/interrupts on the "HYP" line.
		187
		188	The synic provides the means to demultiplex the architectural interrupt into
		189	one or more logical interrupts and route the logical interrupt to the proper
		190	VMBus handler in Linux. This demultiplexing is done by vmbus_isr() and
		191	related functions that access synic data structures.
		192
		193	The synic is not modeled in Linux as an irq chip or irq domain,
		194	and the demultiplexed logical interrupts are not Linux IRQs. As such,
		195	they don't appear in /proc/interrupts or /proc/irq. The CPU
		196	affinity for one of these logical interrupts is controlled via an
		197	entry under /sys/bus/vmbus as described below.
		198
		199	VMBus interrupts
169	----------------	200	----------------
170	VMbus provides a mechanism for the guest to interrupt the host when	201	VMBus provides a mechanism for the guest to interrupt the host when
171	the guest has queued new messages in a ring buffer. The host	202	the guest has queued new messages in a ring buffer. The host
172	expects that the guest will send an interrupt only when an "out"	203	expects that the guest will send an interrupt only when an "out"
173	ring buffer transitions from empty to non-empty. If the guest sends	204	ring buffer transitions from empty to non-empty. If the guest sends
@@ -176,63 +207,55 @@ unnecessary. If a guest sends an excessive number of unnecessary · 2 unmodified lines
176	interrupts, the host may throttle that guest by suspending its	207	interrupts, the host may throttle that guest by suspending its
177	execution for a few seconds to prevent a denial-of-service attack.	208	execution for a few seconds to prevent a denial-of-service attack.
178		209
179	Similarly, the host will interrupt the guest when it sends a new	210	Similarly, the host will interrupt the guest via the synic when
180	message on the VMbus control path, or when a VMbus channel "in" ring	211	it sends a new message on the VMBus control path, or when a VMBus
181	buffer transitions from empty to non-empty. Each CPU in the guest	212	channel "in" ring buffer transitions from empty to non-empty due to
182	may receive VMbus interrupts, so they are best modeled as per-CPU	213	the host inserting a new VMBus channel message. The control message stream
183	interrupts in Linux. This model works well on arm64 where a single	214	and each VMBus channel "in" ring buffer are separate logical interrupts
184	per-CPU IRQ is allocated for VMbus. Since x86/x64 lacks support for	215	that are demultiplexed by vmbus_isr(). It demultiplexes by first checking
185	per-CPU IRQs, an x86 interrupt vector is statically allocated (see	216	for channel interrupts by calling vmbus_chan_sched(), which looks at a synic
186	HYPERVISOR_CALLBACK_VECTOR) across all CPUs and explicitly coded to	217	bitmap to determine which channels have pending interrupts on this CPU.
187	call the VMbus interrupt service routine. These interrupts are	218	If multiple channels have pending interrupts for this CPU, they are
188	visible in /proc/interrupts on the "HYP" line.	219	processed sequentially. When all channel interrupts have been processed,
189		220	vmbus_isr() checks for and processes any messages received on the VMBus
190	The guest CPU that a VMbus channel will interrupt is selected by the	221	control path.
		222
		223	The guest CPU that a VMBus channel will interrupt is selected by the
191	guest when the channel is created, and the host is informed of that	224	guest when the channel is created, and the host is informed of that
192	selection. VMbus devices are broadly grouped into two categories:	225	selection. VMBus devices are broadly grouped into two categories:
193		226
194	1. "Slow" devices that need only one VMbus channel. The devices	227	1. "Slow" devices that need only one VMBus channel. The devices
195	(such as keyboard, mouse, heartbeat, and timesync) generate	228	(such as keyboard, mouse, heartbeat, and timesync) generate
196	relatively few interrupts. Their VMbus channels are all	229	relatively few interrupts. Their VMBus channels are all
197	assigned to interrupt the VMBUS_CONNECT_CPU, which is always	230	assigned to interrupt the VMBUS_CONNECT_CPU, which is always
198	CPU 0.	231	CPU 0.
199		232
200	2. "High speed" devices that may use multiple VMbus channels for	233	2. "High speed" devices that may use multiple VMBus channels for
201	higher parallelism and performance. These devices include the	234	higher parallelism and performance. These devices include the
202	synthetic SCSI controller and synthetic NIC. Their VMbus	235	synthetic SCSI controller and synthetic NIC. Their VMBus
203	channels interrupts are assigned to CPUs that are spread out	236	channels interrupts are assigned to CPUs that are spread out
204	among the available CPUs in the VM so that interrupts on	237	among the available CPUs in the VM so that interrupts on
205	multiple channels can be processed in parallel.	238	multiple channels can be processed in parallel.
206		239
207	The assignment of VMbus channel interrupts to CPUs is done in the	240	The assignment of VMBus channel interrupts to CPUs is done in the
208	function init_vp_index(). This assignment is done outside of the	241	function init_vp_index(). This assignment is done outside of the
209	normal Linux interrupt affinity mechanism, so the interrupts are	242	normal Linux interrupt affinity mechanism, so the interrupts are
210	neither "unmanaged" nor "managed" interrupts.	243	neither "unmanaged" nor "managed" interrupts.
211		244
212	The CPU that a VMbus channel will interrupt can be seen in	245	The CPU that a VMBus channel will interrupt can be seen in
213	/sys/bus/vmbus/devices/<deviceGUID>/ channels/<channelRelID>/cpu.	246	/sys/bus/vmbus/devices/<deviceGUID>/ channels/<channelRelID>/cpu.
214	When running on later versions of Hyper-V, the CPU can be changed	247	When running on later versions of Hyper-V, the CPU can be changed
215	by writing a new value to this sysfs entry. Because the interrupt	248	by writing a new value to this sysfs entry. Because VMBus channel
216	assignment is done outside of the normal Linux affinity mechanism,	249	interrupts are not Linux IRQs, there are no entries in /proc/interrupts
217	there are no entries in /proc/irq corresponding to individual	250	or /proc/irq corresponding to individual VMBus channel interrupts.
218	VMbus channel interrupts.
219		251
220	An online CPU in a Linux guest may not be taken offline if it has	252	An online CPU in a Linux guest may not be taken offline if it has
221	VMbus channel interrupts assigned to it. Any such channel	253	VMBus channel interrupts assigned to it. Any such channel
222	interrupts must first be manually reassigned to another CPU as	254	interrupts must first be manually reassigned to another CPU as
223	described above. When no channel interrupts are assigned to the	255	described above. When no channel interrupts are assigned to the
224	CPU, it can be taken offline.	256	CPU, it can be taken offline.
225		257
226	When a guest CPU receives a VMbus interrupt from the host, the	258	The VMBus channel interrupt handling code is designed to work
227	function vmbus_isr() handles the interrupt. It first checks for
228	channel interrupts by calling vmbus_chan_sched(), which looks at a
229	bitmap setup by the host to determine which channels have pending
230	interrupts on this CPU. If multiple channels have pending
231	interrupts for this CPU, they are processed sequentially. When all
232	channel interrupts have been processed, vmbus_isr() checks for and
233	processes any message received on the VMbus control path.
234
235	The VMbus channel interrupt handling code is designed to work
236	correctly even if an interrupt is received on a CPU other than the	259	correctly even if an interrupt is received on a CPU other than the
237	CPU assigned to the channel. Specifically, the code does not use	260	CPU assigned to the channel. Specifically, the code does not use
238	CPU-based exclusion for correctness. In normal operation, Hyper-V	261	CPU-based exclusion for correctness. In normal operation, Hyper-V
@@ -242,23 +265,23 @@ when Hyper-V will make the transition. The code must work correctly · 3 unmodified lines
242	even if there is a time lag before Hyper-V starts interrupting the	265	even if there is a time lag before Hyper-V starts interrupting the
243	new CPU. See comments in target_cpu_store().	266	new CPU. See comments in target_cpu_store().
244		267
245	VMbus device creation/deletion	268	VMBus device creation/deletion
246	------------------------------	269	------------------------------
247	Hyper-V and the Linux guest have a separate message-passing path	270	Hyper-V and the Linux guest have a separate message-passing path
248	that is used for synthetic device creation and deletion. This	271	that is used for synthetic device creation and deletion. This
249	path does not use a VMbus channel. See vmbus_post_msg() and	272	path does not use a VMBus channel. See vmbus_post_msg() and
250	vmbus_on_msg_dpc().	273	vmbus_on_msg_dpc().
251		274
252	The first step is for the guest to connect to the generic	275	The first step is for the guest to connect to the generic
253	Hyper-V VMbus mechanism. As part of establishing this connection,	276	Hyper-V VMBus mechanism. As part of establishing this connection,
254	the guest and Hyper-V agree on a VMbus protocol version they will	277	the guest and Hyper-V agree on a VMBus protocol version they will
255	use. This negotiation allows newer Linux kernels to run on older	278	use. This negotiation allows newer Linux kernels to run on older
256	Hyper-V versions, and vice versa.	279	Hyper-V versions, and vice versa.
257		280
258	The guest then tells Hyper-V to "send offers". Hyper-V sends an	281	The guest then tells Hyper-V to "send offers". Hyper-V sends an
259	offer message to the guest for each synthetic device that the VM	282	offer message to the guest for each synthetic device that the VM
260	is configured to have. Each VMbus device type has a fixed GUID	283	is configured to have. Each VMBus device type has a fixed GUID
261	known as the "class ID", and each VMbus device instance is also	284	known as the "class ID", and each VMBus device instance is also
262	identified by a GUID. The offer message from Hyper-V contains	285	identified by a GUID. The offer message from Hyper-V contains
263	both GUIDs to uniquely (within the VM) identify the device.	286	both GUIDs to uniquely (within the VM) identify the device.
264	There is one offer message for each device instance, so a VM with	287	There is one offer message for each device instance, so a VM with
@@ -275,7 +298,7 @@ type based on the class ID, and invokes the correct driver to set up · 10 unmodified lines
275	the device. Driver/device matching is performed using the standard	298	the device. Driver/device matching is performed using the standard
276	Linux mechanism.	299	Linux mechanism.
277		300
278	The device driver probe function opens the primary VMbus channel to	301	The device driver probe function opens the primary VMBus channel to
279	the corresponding VSP. It allocates guest memory for the channel	302	the corresponding VSP. It allocates guest memory for the channel
280	ring buffers and shares the ring buffer with the Hyper-V host by	303	ring buffers and shares the ring buffer with the Hyper-V host by
281	giving the host a list of GPAs for the ring buffer memory. See	304	giving the host a list of GPAs for the ring buffer memory. See
@@ -285,7 +308,7 @@ Once the ring buffer is set up, the device driver and VSP exchange · 3 unmodified lines
285	setup messages via the primary channel. These messages may include	308	setup messages via the primary channel. These messages may include
286	negotiating the device protocol version to be used between the Linux	309	negotiating the device protocol version to be used between the Linux
287	VSC and the VSP on the Hyper-V host. The setup messages may also	310	VSC and the VSP on the Hyper-V host. The setup messages may also
288	include creating additional VMbus channels, which are somewhat	311	include creating additional VMBus channels, which are somewhat
289	mis-named as "sub-channels" since they are functionally	312	mis-named as "sub-channels" since they are functionally
290	equivalent to the primary channel once they are created.	313	equivalent to the primary channel once they are created.
291		314

MAINTAINERS+15−17

 R:	Yonghong Song <yonghong.song@linux.dev>
 R:	John Fastabend <john.fastabend@gmail.com>
 R:	KP Singh <kpsingh@kernel.org>
-R:	Stanislav Fomichev <sdf@google.com>
+R:	Stanislav Fomichev <sdf@fomichev.me>
 R:	Hao Luo <haoluo@google.com>
 R:	Jiri Olsa <jolsa@kernel.org>
 L:	bpf@vger.kernel.org
 CLANG CONTROL FLOW INTEGRITY SUPPORT
 M:	Sami Tolvanen <samitolvanen@google.com>
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 R:	Nathan Chancellor <nathan@kernel.org>
 L:	llvm@lists.linux.dev
 S:	Supported
 EXEC & BINFMT API, ELF
 R:	Eric Biederman <ebiederm@xmission.com>
-R:	Kees Cook <keescook@chromium.org>
+R:	Kees Cook <kees@kernel.org>
 L:	linux-mm@kvack.org
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/execve
 F:	drivers/net/ethernet/nvidia/*
 FORTIFY_SOURCE
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 L:	linux-hardening@vger.kernel.org
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
 F:	include/linux/platform_data/gsc_hwmon.h
 GCC PLUGINS
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 L:	linux-hardening@vger.kernel.org
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
 F:	drivers/input/touchscreen/resistive-adc-touch.c
 GENERIC STRING LIBRARY
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 R:	Andy Shevchenko <andy@kernel.org>
 L:	linux-hardening@vger.kernel.org
 S:	Supported
 F:	usr/
 KERNEL HARDENING (not covered by other areas)
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 R:	Gustavo A. R. Silva <gustavoars@kernel.org>
 L:	linux-hardening@vger.kernel.org
 S:	Supported
 KVM PARAVIRT (KVM/paravirt)
 M:	Paolo Bonzini <pbonzini@redhat.com>
-R:	Wanpeng Li <wanpengli@tencent.com>
 R:	Vitaly Kuznetsov <vkuznets@redhat.com>
 L:	kvm@vger.kernel.org
 S:	Supported
 LEAKING_ADDRESSES
 M:	Tycho Andersen <tycho@tycho.pizza>
-R:	Kees Cook <keescook@chromium.org>
+R:	Kees Cook <kees@kernel.org>
 L:	linux-hardening@vger.kernel.org
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
 F:	arch/powerpc/platforms/83xx/
 LINUX KERNEL DUMP TEST MODULE (LKDTM)
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 S:	Maintained
 F:	drivers/misc/lkdtm/*
 F:	tools/testing/selftests/lkdtm/*
 F:	drivers/media/usb/dvb-usb-v2/lmedm04*
 LOADPIN SECURITY MODULE
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
 F:	Documentation/admin-guide/LSM/LoadPin.rst
 PROC SYSCTL
 M:	Luis Chamberlain <mcgrof@kernel.org>
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 M:	Joel Granados <j.granados@samsung.com>
 L:	linux-kernel@vger.kernel.org
 L:	linux-fsdevel@vger.kernel.org
 F:	drivers/net/pse-pd/
 PSTORE FILESYSTEM
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 R:	Tony Luck <tony.luck@intel.com>
 R:	Guilherme G. Piccoli <gpiccoli@igalia.com>
 L:	linux-hardening@vger.kernel.org
 F:	drivers/media/cec/platform/seco/seco-cec.h
 SECURE COMPUTING
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 R:	Andy Lutomirski <luto@amacapital.net>
 R:	Will Drewry <wad@chromium.org>
 S:	Supported
 F:	include/uapi/linux/ublk_cmd.h
 UBSAN
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 R:	Marco Elver <elver@google.com>
 R:	Andrey Konovalov <andreyknvl@gmail.com>
 R:	Andrey Ryabinin <ryabinin.a.a@gmail.com>
 M:	Andrew Morton <akpm@linux-foundation.org>
 R:	Uladzislau Rezki <urezki@gmail.com>
 R:	Christoph Hellwig <hch@infradead.org>
-R:	Lorenzo Stoakes <lstoakes@gmail.com>
 L:	linux-mm@kvack.org
 S:	Maintained
 W:	http://www.linux-mm.org
 F:	include/linux/yam.h
 YAMA SECURITY MODULE
-M:	Kees Cook <keescook@chromium.org>
+M:	Kees Cook <kees@kernel.org>
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
 F:	Documentation/admin-guide/LSM/Yama.rst

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 6	2	VERSION = 6
3	PATCHLEVEL = 10	3	PATCHLEVEL = 10
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc4	5	EXTRAVERSION = -rc5
6	NAME = Baby Opossum Posse	6	NAME = Baby Opossum Posse
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/boot/dts/nxp/imx/imx53-qsb-common.dtsi+1−1

@@ -85,7 +85,7 @@ · 84 unmodified lines
85	};	85	};
86	};	86	};
87		87
88	panel {	88	panel_dpi: panel {
89	compatible = "sii,43wvf1g";	89	compatible = "sii,43wvf1g";
90	pinctrl-names = "default";	90	pinctrl-names = "default";
91	pinctrl-0 = <&pinctrl_display_power>;	91	pinctrl-0 = <&pinctrl_display_power>;

arch/arm/boot/dts/nxp/imx/imx53-qsb-hdmi.dtso+4−2

 /plugin/;
 &{/} {
-	/delete-node/ panel;
 	hdmi: connector-hdmi {
 		compatible = "hdmi-connector";
 		label = "hdmi";
 	};
 };
+&panel_dpi {
+	status = "disabled";
+};
 &tve {
 	status = "disabled";
 };

arch/arm/include/asm/efi.h+13−0

@@ -14,6 +14,7 @@ · 13 unmodified lines
14	#include <asm/mach/map.h>	14	#include <asm/mach/map.h>
15	#include <asm/mmu_context.h>	15	#include <asm/mmu_context.h>
16	#include <asm/ptrace.h>	16	#include <asm/ptrace.h>
		17	#include <asm/uaccess.h>
17		18
18	#ifdef CONFIG_EFI	19	#ifdef CONFIG_EFI
19	void efi_init(void);	20	void efi_init(void);
@@ -25,6 +26,18 @@ int efi_set_mapping_permissions(struct mm_struct mm, efi_memory_desc_t md, boo · 5 unmodified lines
25	#define arch_efi_call_virt_setup() efi_virtmap_load()	26	#define arch_efi_call_virt_setup() efi_virtmap_load()
26	#define arch_efi_call_virt_teardown() efi_virtmap_unload()	27	#define arch_efi_call_virt_teardown() efi_virtmap_unload()
27		28
		29	#ifdef CONFIG_CPU_TTBR0_PAN
		30	#undef arch_efi_call_virt
		31	#define arch_efi_call_virt(p, f, args...) ({ \
		32	unsigned int flags = uaccess_save_and_enable(); \
		33	efi_status_t res = _Generic((p)->f(args), \
		34	efi_status_t: (p)->f(args), \
		35	default: ((p)->f(args), EFI_ABORTED)); \
		36	uaccess_restore(flags); \
		37	res; \
		38	})
		39	#endif
		40
28	#define ARCH_EFI_IRQ_FLAGS_MASK \	41	#define ARCH_EFI_IRQ_FLAGS_MASK \
29	(PSR_J_BIT \| PSR_E_BIT \| PSR_A_BIT \| PSR_I_BIT \| PSR_F_BIT \| \	42	(PSR_J_BIT \| PSR_E_BIT \| PSR_A_BIT \| PSR_I_BIT \| PSR_F_BIT \| \
30	PSR_T_BIT \| MODE_MASK)	43	PSR_T_BIT \| MODE_MASK)

arch/arm64/boot/dts/freescale/imx8mm-verdin.dtsi+2−1

 #include <dt-bindings/phy/phy-imx8-pcie.h>
 #include <dt-bindings/pwm/pwm.h>
 #include "imx8mm.dtsi"
+#include "imx8mm-overdrive.dtsi"
 / {
 	chosen {
 	/* Verdin GPIO_9_DSI (pulled-up as active-low) */
 	pinctrl_gpio_9_dsi: gpio9dsigrp {
 		fsl,pins =
-			<MX8MM_IOMUXC_NAND_RE_B_GPIO3_IO15		0x146>;	/* SODIMM 17 */
+			<MX8MM_IOMUXC_NAND_RE_B_GPIO3_IO15		0x1c6>;	/* SODIMM 17 */
 	};
 	/* Verdin GPIO_10_DSI (pulled-up as active-low) */

arch/arm64/boot/dts/freescale/imx8mp-dhcom-som.dtsi+1−1

@@ -254,7 +254,7 @@ · 253 unmodified lines
254	<&clk IMX8MP_CLK_CLKOUT2>,	254	<&clk IMX8MP_CLK_CLKOUT2>,
255	<&clk IMX8MP_AUDIO_PLL2_OUT>;	255	<&clk IMX8MP_AUDIO_PLL2_OUT>;
256	assigned-clock-parents = <&clk IMX8MP_AUDIO_PLL2_OUT>;	256	assigned-clock-parents = <&clk IMX8MP_AUDIO_PLL2_OUT>;
257	assigned-clock-rates = <13000000>, <13000000>, <156000000>;	257	assigned-clock-rates = <13000000>, <13000000>, <208000000>;
258	reset-gpios = <&gpio4 1 GPIO_ACTIVE_HIGH>;	258	reset-gpios = <&gpio4 1 GPIO_ACTIVE_HIGH>;
259	status = "disabled";	259	status = "disabled";
260		260

arch/arm64/boot/dts/freescale/imx8mp-venice-gw73xx.dtsi+1−1

@@ -219,7 +219,7 @@ · 218 unmodified lines
219		219
220	bluetooth {	220	bluetooth {
221	compatible = "brcm,bcm4330-bt";	221	compatible = "brcm,bcm4330-bt";
222	shutdown-gpios = <&gpio4 16 GPIO_ACTIVE_HIGH>;	222	shutdown-gpios = <&gpio1 3 GPIO_ACTIVE_HIGH>;
223	};	223	};
224	};	224	};
225		225

arch/arm64/boot/dts/freescale/imx8qm-mek.dts+1−1

@@ -36,7 +36,7 @@ · 35 unmodified lines
36	regulator-name = "SD1_SPWR";	36	regulator-name = "SD1_SPWR";
37	regulator-min-microvolt = <3000000>;	37	regulator-min-microvolt = <3000000>;
38	regulator-max-microvolt = <3000000>;	38	regulator-max-microvolt = <3000000>;
39	gpio = <&lsio_gpio4 19 GPIO_ACTIVE_HIGH>;	39	gpio = <&lsio_gpio4 7 GPIO_ACTIVE_HIGH>;
40	enable-active-high;	40	enable-active-high;
41	};	41	};
42		42

arch/arm64/boot/dts/freescale/imx93-11x11-evk.dts+0−1

@@ -296,7 +296,6 @@ · 295 unmodified lines
296	vmmc-supply = <&reg_usdhc2_vmmc>;	296	vmmc-supply = <&reg_usdhc2_vmmc>;
297	bus-width = <4>;	297	bus-width = <4>;
298	status = "okay";	298	status = "okay";
299	no-sdio;
300	no-mmc;	299	no-mmc;
301	};	300	};
302		301

arch/arm64/kernel/efi.c+2−0

 #include <linux/efi.h>
 #include <linux/init.h>
+#include <linux/kmemleak.h>
 #include <linux/screen_info.h>
 #include <linux/vmalloc.h>
 		return -ENOMEM;
 	}
+	kmemleak_not_leak(p);
 	efi_rt_stack_top = p + THREAD_SIZE;
 	return 0;
 }

arch/arm64/kvm/hyp/nvhe/ffa.c+12−0

 			  res);
 }
+static void ffa_rx_release(struct arm_smccc_res *res)
+{
+	arm_smccc_1_1_smc(FFA_RX_RELEASE,
+			  0, 0,
+			  0, 0, 0, 0, 0,
+			  res);
+}
 static void do_ffa_rxtx_map(struct arm_smccc_res *res,
 			    struct kvm_cpu_context *ctxt)
 {
 	if (WARN_ON(offset > len ||
 		    fraglen > KVM_FFA_MBOX_NR_PAGES * PAGE_SIZE)) {
 		ret = FFA_RET_ABORTED;
+		ffa_rx_release(res);
 		goto out_unlock;
 	}
 	if (len > ffa_desc_buf.len) {
 		ret = FFA_RET_NO_MEMORY;
+		ffa_rx_release(res);
 		goto out_unlock;
 	}
 	buf = ffa_desc_buf.buf;
 	memcpy(buf, hyp_buffers.rx, fraglen);
+	ffa_rx_release(res);
 	for (fragoff = fraglen; fragoff < len; fragoff += fraglen) {
 		ffa_mem_frag_rx(res, handle_lo, handle_hi, fragoff);
 		fraglen = res->a3;
 		memcpy((void *)buf + fragoff, hyp_buffers.rx, fraglen);
+		ffa_rx_release(res);
 	}
 	ffa_mem_reclaim(res, handle_lo, handle_hi, flags);

arch/arm64/kvm/vgic/vgic-init.c+1−1

@@ -391,7 +391,7 @@ static void kvm_vgic_dist_destroy(struct kvm *kvm) · 390 unmodified lines
391		391
392	if (dist->vgic_model == KVM_DEV_TYPE_ARM_VGIC_V3) {	392	if (dist->vgic_model == KVM_DEV_TYPE_ARM_VGIC_V3) {
393	list_for_each_entry_safe(rdreg, next, &dist->rd_regions, list)	393	list_for_each_entry_safe(rdreg, next, &dist->rd_regions, list)
394	vgic_v3_free_redist_region(rdreg);	394	vgic_v3_free_redist_region(kvm, rdreg);
395	INIT_LIST_HEAD(&dist->rd_regions);	395	INIT_LIST_HEAD(&dist->rd_regions);
396	} else {	396	} else {
397	dist->vgic_cpu_base = VGIC_ADDR_UNDEF;	397	dist->vgic_cpu_base = VGIC_ADDR_UNDEF;

arch/arm64/kvm/vgic/vgic-mmio-v3.c+13−2

 	return ret;
 }
-void vgic_v3_free_redist_region(struct vgic_redist_region *rdreg)
+void vgic_v3_free_redist_region(struct kvm *kvm, struct vgic_redist_region *rdreg)
 {
+	struct kvm_vcpu *vcpu;
+	unsigned long c;
+	lockdep_assert_held(&kvm->arch.config_lock);
+	/* Garbage collect the region */
+	kvm_for_each_vcpu(c, vcpu, kvm) {
+		if (vcpu->arch.vgic_cpu.rdreg == rdreg)
+			vcpu->arch.vgic_cpu.rdreg = NULL;
+	}
 	list_del(&rdreg->list);
 	kfree(rdreg);
 }
 		mutex_lock(&kvm->arch.config_lock);
 		rdreg = vgic_v3_rdist_region_from_index(kvm, index);
-		vgic_v3_free_redist_region(rdreg);
+		vgic_v3_free_redist_region(kvm, rdreg);
 		mutex_unlock(&kvm->arch.config_lock);
 		return ret;
 	}

arch/arm64/kvm/vgic/vgic.h+1−1

@@ -316,7 +316,7 @@ vgic_v3_rd_region_size(struct kvm kvm, struct vgic_redist_region rdreg) · 315 unmodified lines
316		316
317	struct vgic_redist_region vgic_v3_rdist_region_from_index(struct kvm kvm,	317	struct vgic_redist_region vgic_v3_rdist_region_from_index(struct kvm kvm,
318	u32 index);	318	u32 index);
319	void vgic_v3_free_redist_region(struct vgic_redist_region *rdreg);	319	void vgic_v3_free_redist_region(struct kvm kvm, struct vgic_redist_region rdreg);
320		320
321	bool vgic_v3_rdist_overlap(struct kvm *kvm, gpa_t base, size_t size);	321	bool vgic_v3_rdist_overlap(struct kvm *kvm, gpa_t base, size_t size);
322		322

arch/loongarch/Kconfig+4−1

 	select HAVE_LIVEPATCH
 	select HAVE_MOD_ARCH_SPECIFIC
 	select HAVE_NMI
-	select HAVE_OBJTOOL if AS_HAS_EXPLICIT_RELOCS
+	select HAVE_OBJTOOL if AS_HAS_EXPLICIT_RELOCS && AS_HAS_THIN_ADD_SUB && !CC_IS_CLANG
 	select HAVE_PCI
 	select HAVE_PERF_EVENTS
 	select HAVE_PERF_REGS
 config AS_HAS_FCSR_CLASS
 	def_bool $(as-instr,movfcsr2gr \$t0$(comma)\$fcsr0)
+config AS_HAS_THIN_ADD_SUB
+	def_bool $(cc-option,-Wa$(comma)-mthin-add-sub)
 config AS_HAS_LSX_EXTENSION
 	def_bool $(as-instr,vld \$vr0$(comma)\$a0$(comma)0)

arch/loongarch/Kconfig.debug+1−0

@@ -28,6 +28,7 @@ config UNWINDER_PROLOGUE · 27 unmodified lines
28		28
29	config UNWINDER_ORC	29	config UNWINDER_ORC
30	bool "ORC unwinder"	30	bool "ORC unwinder"
		31	depends on HAVE_OBJTOOL
31	select OBJTOOL	32	select OBJTOOL
32	help	33	help
33	This option enables the ORC (Oops Rewind Capability) unwinder for	34	This option enables the ORC (Oops Rewind Capability) unwinder for

arch/loongarch/include/asm/hw_breakpoint.h+3−1

 #define CSR_MWPC_NUM		0x3f
 #define CTRL_PLV_ENABLE		0x1e
+#define CTRL_PLV0_ENABLE	0x02
+#define CTRL_PLV3_ENABLE	0x10
 #define MWPnCFG3_LoadEn		8
 #define MWPnCFG3_StoreEn	9
 struct perf_event_attr;
 extern int arch_bp_generic_fields(struct arch_hw_breakpoint_ctrl ctrl,
-				  int *gen_len, int *gen_type, int *offset);
+				  int *gen_len, int *gen_type);
 extern int arch_check_bp_in_kernelspace(struct arch_hw_breakpoint *hw);
 extern int hw_breakpoint_arch_parse(struct perf_event *bp,
 				    const struct perf_event_attr *attr,

arch/loongarch/kernel/hw_breakpoint.c+55−41

@@ -174,11 +174,21 @@ void flush_ptrace_hw_breakpoint(struct task_struct *tsk) · 173 unmodified lines
174	static int hw_breakpoint_control(struct perf_event *bp,	174	static int hw_breakpoint_control(struct perf_event *bp,
175	enum hw_breakpoint_ops ops)	175	enum hw_breakpoint_ops ops)
176	{	176	{
177	u32 ctrl;	177	u32 ctrl, privilege;
178	int i, max_slots, enable;	178	int i, max_slots, enable;
		179	struct pt_regs *regs;
179	struct perf_event **slots;	180	struct perf_event **slots;
180	struct arch_hw_breakpoint *info = counter_arch_bp(bp);	181	struct arch_hw_breakpoint *info = counter_arch_bp(bp);
181		182
		183	if (arch_check_bp_in_kernelspace(info))
		184	privilege = CTRL_PLV0_ENABLE;
		185	else
		186	privilege = CTRL_PLV3_ENABLE;
		187
		188	/* Whether bp belongs to a task. */
		189	if (bp->hw.target)
		190	regs = task_pt_regs(bp->hw.target);
		191
182	if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) {	192	if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) {
183	/* Breakpoint */	193	/* Breakpoint */
184	slots = this_cpu_ptr(bp_on_reg);	194	slots = this_cpu_ptr(bp_on_reg);
@@ -197,31 +207,38 @@ static int hw_breakpoint_control(struct perf_event *bp, · 12 unmodified lines
197	switch (ops) {	207	switch (ops) {
198	case HW_BREAKPOINT_INSTALL:	208	case HW_BREAKPOINT_INSTALL:
199	/* Set the FWPnCFG/MWPnCFG 1~4 register. */	209	/* Set the FWPnCFG/MWPnCFG 1~4 register. */
200	write_wb_reg(CSR_CFG_ADDR, i, 0, info->address);
201	write_wb_reg(CSR_CFG_ADDR, i, 1, info->address);
202	write_wb_reg(CSR_CFG_MASK, i, 0, info->mask);
203	write_wb_reg(CSR_CFG_MASK, i, 1, info->mask);
204	write_wb_reg(CSR_CFG_ASID, i, 0, 0);
205	write_wb_reg(CSR_CFG_ASID, i, 1, 0);
206	if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) {	210	if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) {
207	write_wb_reg(CSR_CFG_CTRL, i, 0, CTRL_PLV_ENABLE);	211	write_wb_reg(CSR_CFG_ADDR, i, 0, info->address);
		212	write_wb_reg(CSR_CFG_MASK, i, 0, info->mask);
		213	write_wb_reg(CSR_CFG_ASID, i, 0, 0);
		214	write_wb_reg(CSR_CFG_CTRL, i, 0, privilege);
208	} else {	215	} else {
		216	write_wb_reg(CSR_CFG_ADDR, i, 1, info->address);
		217	write_wb_reg(CSR_CFG_MASK, i, 1, info->mask);
		218	write_wb_reg(CSR_CFG_ASID, i, 1, 0);
209	ctrl = encode_ctrl_reg(info->ctrl);	219	ctrl = encode_ctrl_reg(info->ctrl);
210	write_wb_reg(CSR_CFG_CTRL, i, 1, ctrl \| CTRL_PLV_ENABLE);	220	write_wb_reg(CSR_CFG_CTRL, i, 1, ctrl \| privilege);
211	}	221	}
212	enable = csr_read64(LOONGARCH_CSR_CRMD);	222	enable = csr_read64(LOONGARCH_CSR_CRMD);
213	csr_write64(CSR_CRMD_WE \| enable, LOONGARCH_CSR_CRMD);	223	csr_write64(CSR_CRMD_WE \| enable, LOONGARCH_CSR_CRMD);
		224	if (bp->hw.target)
		225	regs->csr_prmd \|= CSR_PRMD_PWE;
214	break;	226	break;
215	case HW_BREAKPOINT_UNINSTALL:	227	case HW_BREAKPOINT_UNINSTALL:
216	/* Reset the FWPnCFG/MWPnCFG 1~4 register. */	228	/* Reset the FWPnCFG/MWPnCFG 1~4 register. */
217	write_wb_reg(CSR_CFG_ADDR, i, 0, 0);	229	if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) {
218	write_wb_reg(CSR_CFG_ADDR, i, 1, 0);	230	write_wb_reg(CSR_CFG_ADDR, i, 0, 0);
219	write_wb_reg(CSR_CFG_MASK, i, 0, 0);	231	write_wb_reg(CSR_CFG_MASK, i, 0, 0);
220	write_wb_reg(CSR_CFG_MASK, i, 1, 0);	232	write_wb_reg(CSR_CFG_CTRL, i, 0, 0);
221	write_wb_reg(CSR_CFG_CTRL, i, 0, 0);	233	write_wb_reg(CSR_CFG_ASID, i, 0, 0);
222	write_wb_reg(CSR_CFG_CTRL, i, 1, 0);	234	} else {
223	write_wb_reg(CSR_CFG_ASID, i, 0, 0);	235	write_wb_reg(CSR_CFG_ADDR, i, 1, 0);
224	write_wb_reg(CSR_CFG_ASID, i, 1, 0);	236	write_wb_reg(CSR_CFG_MASK, i, 1, 0);
		237	write_wb_reg(CSR_CFG_CTRL, i, 1, 0);
		238	write_wb_reg(CSR_CFG_ASID, i, 1, 0);
		239	}
		240	if (bp->hw.target)
		241	regs->csr_prmd &= ~CSR_PRMD_PWE;
225	break;	242	break;
226	}	243	}
227		244
@@ -283,7 +300,7 @@ int arch_check_bp_in_kernelspace(struct arch_hw_breakpoint *hw) · 55 unmodified lines
283	* to generic breakpoint descriptions.	300	* to generic breakpoint descriptions.
284	*/	301	*/
285	int arch_bp_generic_fields(struct arch_hw_breakpoint_ctrl ctrl,	302	int arch_bp_generic_fields(struct arch_hw_breakpoint_ctrl ctrl,
286	int gen_len, int gen_type, int *offset)	303	int gen_len, int gen_type)
287	{	304	{
288	/* Type */	305	/* Type */
289	switch (ctrl.type) {	306	switch (ctrl.type) {
@@ -303,11 +320,6 @@ int arch_bp_generic_fields(struct arch_hw_breakpoint_ctrl ctrl, · 13 unmodified lines
303	return -EINVAL;	320	return -EINVAL;
304	}	321	}
305		322
306	if (!ctrl.len)
307	return -EINVAL;
308
309	*offset = __ffs(ctrl.len);
310
311	/* Len */	323	/* Len */
312	switch (ctrl.len) {	324	switch (ctrl.len) {
313	case LOONGARCH_BREAKPOINT_LEN_1:	325	case LOONGARCH_BREAKPOINT_LEN_1:
@@ -386,21 +398,17 @@ int hw_breakpoint_arch_parse(struct perf_event *bp, · 72 unmodified lines
386	struct arch_hw_breakpoint *hw)	398	struct arch_hw_breakpoint *hw)
387	{	399	{
388	int ret;	400	int ret;
389	u64 alignment_mask, offset;	401	u64 alignment_mask;
390		402
391	/* Build the arch_hw_breakpoint. */	403	/* Build the arch_hw_breakpoint. */
392	ret = arch_build_bp_info(bp, attr, hw);	404	ret = arch_build_bp_info(bp, attr, hw);
393	if (ret)	405	if (ret)
394	return ret;	406	return ret;
395		407
396	if (hw->ctrl.type != LOONGARCH_BREAKPOINT_EXECUTE)	408	if (hw->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) {
397	alignment_mask = 0x7;
398	else
399	alignment_mask = 0x3;	409	alignment_mask = 0x3;
400	offset = hw->address & alignment_mask;	410	hw->address &= ~alignment_mask;
401		411	}
402	hw->address &= ~alignment_mask;
403	hw->ctrl.len <<= offset;
404		412
405	return 0;	413	return 0;
406	}	414	}
@@ -471,12 +479,15 @@ void breakpoint_handler(struct pt_regs *regs) · 64 unmodified lines
471	slots = this_cpu_ptr(bp_on_reg);	479	slots = this_cpu_ptr(bp_on_reg);
472		480
473	for (i = 0; i < boot_cpu_data.watch_ireg_count; ++i) {	481	for (i = 0; i < boot_cpu_data.watch_ireg_count; ++i) {
474	bp = slots[i];	482	if ((csr_read32(LOONGARCH_CSR_FWPS) & (0x1 << i))) {
475	if (bp == NULL)	483	bp = slots[i];
476	continue;	484	if (bp == NULL)
477	perf_bp_event(bp, regs);	485	continue;
		486	perf_bp_event(bp, regs);
		487	csr_write32(0x1 << i, LOONGARCH_CSR_FWPS);
		488	update_bp_registers(regs, 0, 0);
		489	}
478	}	490	}
479	update_bp_registers(regs, 0, 0);
480	}	491	}
481	NOKPROBE_SYMBOL(breakpoint_handler);	492	NOKPROBE_SYMBOL(breakpoint_handler);
482		493
@@ -488,12 +499,15 @@ void watchpoint_handler(struct pt_regs *regs) · 5 unmodified lines
488	slots = this_cpu_ptr(wp_on_reg);	499	slots = this_cpu_ptr(wp_on_reg);
489		500
490	for (i = 0; i < boot_cpu_data.watch_dreg_count; ++i) {	501	for (i = 0; i < boot_cpu_data.watch_dreg_count; ++i) {
491	wp = slots[i];	502	if ((csr_read32(LOONGARCH_CSR_MWPS) & (0x1 << i))) {
492	if (wp == NULL)	503	wp = slots[i];
493	continue;	504	if (wp == NULL)
494	perf_bp_event(wp, regs);	505	continue;
		506	perf_bp_event(wp, regs);
		507	csr_write32(0x1 << i, LOONGARCH_CSR_MWPS);
		508	update_bp_registers(regs, 0, 1);
		509	}
495	}	510	}
496	update_bp_registers(regs, 0, 1);
497	}	511	}
498	NOKPROBE_SYMBOL(watchpoint_handler);	512	NOKPROBE_SYMBOL(watchpoint_handler);
499		513

arch/loongarch/kernel/ptrace.c+27−20

@@ -494,28 +494,14 @@ static int ptrace_hbp_fill_attr_ctrl(unsigned int note_type, · 493 unmodified lines
494	struct arch_hw_breakpoint_ctrl ctrl,	494	struct arch_hw_breakpoint_ctrl ctrl,
495	struct perf_event_attr *attr)	495	struct perf_event_attr *attr)
496	{	496	{
497	int err, len, type, offset;	497	int err, len, type;
498		498
499	err = arch_bp_generic_fields(ctrl, &len, &type, &offset);	499	err = arch_bp_generic_fields(ctrl, &len, &type);
500	if (err)	500	if (err)
501	return err;	501	return err;
502		502
503	switch (note_type) {
504	case NT_LOONGARCH_HW_BREAK:
505	if ((type & HW_BREAKPOINT_X) != type)
506	return -EINVAL;
507	break;
508	case NT_LOONGARCH_HW_WATCH:
509	if ((type & HW_BREAKPOINT_RW) != type)
510	return -EINVAL;
511	break;
512	default:
513	return -EINVAL;
514	}
515
516	attr->bp_len = len;	503	attr->bp_len = len;
517	attr->bp_type = type;	504	attr->bp_type = type;
518	attr->bp_addr += offset;
519		505
520	return 0;	506	return 0;
521	}	507	}
@@ -609,10 +595,27 @@ static int ptrace_hbp_set_ctrl(unsigned int note_type, · 87 unmodified lines
609	return PTR_ERR(bp);	595	return PTR_ERR(bp);
610		596
611	attr = bp->attr;	597	attr = bp->attr;
612	decode_ctrl_reg(uctrl, &ctrl);	598
613	err = ptrace_hbp_fill_attr_ctrl(note_type, ctrl, &attr);	599	switch (note_type) {
614	if (err)	600	case NT_LOONGARCH_HW_BREAK:
615	return err;	601	ctrl.type = LOONGARCH_BREAKPOINT_EXECUTE;
		602	ctrl.len = LOONGARCH_BREAKPOINT_LEN_4;
		603	break;
		604	case NT_LOONGARCH_HW_WATCH:
		605	decode_ctrl_reg(uctrl, &ctrl);
		606	break;
		607	default:
		608	return -EINVAL;
		609	}
		610
		611	if (uctrl & CTRL_PLV_ENABLE) {
		612	err = ptrace_hbp_fill_attr_ctrl(note_type, ctrl, &attr);
		613	if (err)
		614	return err;
		615	attr.disabled = 0;
		616	} else {
		617	attr.disabled = 1;
		618	}
616		619
617	return modify_user_hw_breakpoint(bp, &attr);	620	return modify_user_hw_breakpoint(bp, &attr);
618	}	621	}
@@ -643,6 +646,10 @@ static int ptrace_hbp_set_addr(unsigned int note_type, · 24 unmodified lines
643	struct perf_event *bp;	646	struct perf_event *bp;
644	struct perf_event_attr attr;	647	struct perf_event_attr attr;
645		648
		649	/* Kernel-space address cannot be monitored by user-space */
		650	if ((unsigned long)addr >= XKPRANGE)
		651	return -EINVAL;
		652
646	bp = ptrace_hbp_get_initialised_bp(note_type, tsk, idx);	653	bp = ptrace_hbp_get_initialised_bp(note_type, tsk, idx);
647	if (IS_ERR(bp))	654	if (IS_ERR(bp))
648	return PTR_ERR(bp);	655	return PTR_ERR(bp);

arch/loongarch/kvm/exit.c+1−1

@@ -761,7 +761,7 @@ static void kvm_handle_service(struct kvm_vcpu *vcpu) · 760 unmodified lines
761	default:	761	default:
762	ret = KVM_HCALL_INVALID_CODE;	762	ret = KVM_HCALL_INVALID_CODE;
763	break;	763	break;
764	};	764	}
765		765
766	kvm_write_reg(vcpu, LOONGARCH_GPR_A0, ret);	766	kvm_write_reg(vcpu, LOONGARCH_GPR_A0, ret);
767	}	767	}

arch/mips/bmips/setup.c+2−1

@@ -110,7 +110,8 @@ static void bcm6358_quirks(void) · 109 unmodified lines
110	* RAC flush causes kernel panics on BCM6358 when booting from TP1	110	* RAC flush causes kernel panics on BCM6358 when booting from TP1
111	* because the bootloader is not initializing it properly.	111	* because the bootloader is not initializing it properly.
112	*/	112	*/
113	bmips_rac_flush_disable = !!(read_c0_brcm_cmt_local() & (1 << 31));	113	bmips_rac_flush_disable = !!(read_c0_brcm_cmt_local() & (1 << 31)) \|\|
		114	!!BMIPS_GET_CBR();
114	}	115	}
115		116
116	static void bcm6368_quirks(void)	117	static void bcm6368_quirks(void)

arch/mips/include/asm/mipsmtregs.h+1−1

@@ -322,7 +322,7 @@ static inline void ehb(void) · 321 unmodified lines
322	" .set push \n" \	322	" .set push \n" \
323	" .set "MIPS_ISA_LEVEL" \n" \	323	" .set "MIPS_ISA_LEVEL" \n" \
324	_ASM_SET_MFTC0 \	324	_ASM_SET_MFTC0 \
325	" mftc0 $1, " #rt ", " #sel " \n" \	325	" mftc0 %0, " #rt ", " #sel " \n" \
326	_ASM_UNSET_MFTC0 \	326	_ASM_UNSET_MFTC0 \
327	" .set pop \n" \	327	" .set pop \n" \
328	: "=r" (__res)); \	328	: "=r" (__res)); \

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

@@ -27,7 +27,7 @@ · 26 unmodified lines
27	17 o32 break sys_ni_syscall	27	17 o32 break sys_ni_syscall
28	# 18 was sys_stat	28	# 18 was sys_stat
29	18 o32 unused18 sys_ni_syscall	29	18 o32 unused18 sys_ni_syscall
30	19 o32 lseek sys_lseek	30	19 o32 lseek sys_lseek compat_sys_lseek
31	20 o32 getpid sys_getpid	31	20 o32 getpid sys_getpid
32	21 o32 mount sys_mount	32	21 o32 mount sys_mount
33	22 o32 umount sys_oldumount	33	22 o32 umount sys_oldumount

arch/mips/pci/ops-rc32434.c+2−2

@@ -112,8 +112,8 @@ retry: · 111 unmodified lines
112	* gives them time to settle	112	* gives them time to settle
113	*/	113	*/
114	if (where == PCI_VENDOR_ID) {	114	if (where == PCI_VENDOR_ID) {
115	if (ret == 0xffffffff \|\| ret == 0x00000000 \|\|	115	if (val == 0xffffffff \|\| val == 0x00000000 \|\|
116	ret == 0x0000ffff \|\| ret == 0xffff0000) {	116	val == 0x0000ffff \|\| val == 0xffff0000) {
117	if (delay > 4)	117	if (delay > 4)
118	return 0;	118	return 0;
119	delay *= 2;	119	delay *= 2;

arch/powerpc/crypto/.gitignore+2−0

@@ -1,3 +1,5 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	aesp10-ppc.S	2	aesp10-ppc.S
		3	aesp8-ppc.S
3	ghashp10-ppc.S	4	ghashp10-ppc.S
		5	ghashp8-ppc.S

arch/powerpc/kvm/book3s_64_vio.c+13−5

@@ -130,14 +130,16 @@ long kvm_spapr_tce_attach_iommu_group(struct kvm *kvm, int tablefd, · 129 unmodified lines
130	}	130	}
131	rcu_read_unlock();	131	rcu_read_unlock();
132		132
133	fdput(f);	133	if (!found) {
134		134	fdput(f);
135	if (!found)
136	return -EINVAL;	135	return -EINVAL;
		136	}
137		137
138	table_group = iommu_group_get_iommudata(grp);	138	table_group = iommu_group_get_iommudata(grp);
139	if (WARN_ON(!table_group))	139	if (WARN_ON(!table_group)) {
		140	fdput(f);
140	return -EFAULT;	141	return -EFAULT;
		142	}
141		143
142	for (i = 0; i < IOMMU_TABLE_GROUP_MAX_TABLES; ++i) {	144	for (i = 0; i < IOMMU_TABLE_GROUP_MAX_TABLES; ++i) {
143	struct iommu_table *tbltmp = table_group->tables[i];	145	struct iommu_table *tbltmp = table_group->tables[i];
@@ -158,8 +160,10 @@ long kvm_spapr_tce_attach_iommu_group(struct kvm *kvm, int tablefd, · 14 unmodified lines
158	break;	160	break;
159	}	161	}
160	}	162	}
161	if (!tbl)	163	if (!tbl) {
		164	fdput(f);
162	return -EINVAL;	165	return -EINVAL;
		166	}
163		167
164	rcu_read_lock();	168	rcu_read_lock();
165	list_for_each_entry_rcu(stit, &stt->iommu_tables, next) {	169	list_for_each_entry_rcu(stit, &stt->iommu_tables, next) {
@@ -170,6 +174,7 @@ long kvm_spapr_tce_attach_iommu_group(struct kvm *kvm, int tablefd, · 4 unmodified lines
170	/* stit is being destroyed */	174	/* stit is being destroyed */
171	iommu_tce_table_put(tbl);	175	iommu_tce_table_put(tbl);
172	rcu_read_unlock();	176	rcu_read_unlock();
		177	fdput(f);
173	return -ENOTTY;	178	return -ENOTTY;
174	}	179	}
175	/*	180	/*
@@ -177,6 +182,7 @@ long kvm_spapr_tce_attach_iommu_group(struct kvm *kvm, int tablefd, · 1 unmodified line
177	* its KVM reference counter and can return.	182	* its KVM reference counter and can return.
178	*/	183	*/
179	rcu_read_unlock();	184	rcu_read_unlock();
		185	fdput(f);
180	return 0;	186	return 0;
181	}	187	}
182	rcu_read_unlock();	188	rcu_read_unlock();
@@ -184,6 +190,7 @@ long kvm_spapr_tce_attach_iommu_group(struct kvm *kvm, int tablefd, · 1 unmodified line
184	stit = kzalloc(sizeof(*stit), GFP_KERNEL);	190	stit = kzalloc(sizeof(*stit), GFP_KERNEL);
185	if (!stit) {	191	if (!stit) {
186	iommu_tce_table_put(tbl);	192	iommu_tce_table_put(tbl);
		193	fdput(f);
187	return -ENOMEM;	194	return -ENOMEM;
188	}	195	}
189		196
@@ -192,6 +199,7 @@ long kvm_spapr_tce_attach_iommu_group(struct kvm *kvm, int tablefd, · 2 unmodified lines
192		199
193	list_add_rcu(&stit->next, &stt->iommu_tables);	200	list_add_rcu(&stit->next, &stt->iommu_tables);
194		201
		202	fdput(f);
195	return 0;	203	return 0;
196	}	204	}
197		205

arch/riscv/boot/dts/sophgo/cv1800b-milkv-duo.dts+1−0

@@ -45,6 +45,7 @@ · 44 unmodified lines
45	no-1-8-v;	45	no-1-8-v;
46	no-mmc;	46	no-mmc;
47	no-sdio;	47	no-sdio;
		48	disable-wp;
48	};	49	};
49		50
50	&uart0 {	51	&uart0 {

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

@@ -401,7 +401,6 @@ extern int __init efi_memmap_alloc(unsigned int num_entries, · 400 unmodified lines
401	struct efi_memory_map_data *data);	401	struct efi_memory_map_data *data);
402	extern void __efi_memmap_free(u64 phys, unsigned long size,	402	extern void __efi_memmap_free(u64 phys, unsigned long size,
403	unsigned long flags);	403	unsigned long flags);
404	#define __efi_memmap_free __efi_memmap_free
405		404
406	extern int __init efi_memmap_install(struct efi_memory_map_data *data);	405	extern int __init efi_memmap_install(struct efi_memory_map_data *data);
407	extern int __init efi_memmap_split_count(efi_memory_desc_t *md,	406	extern int __init efi_memmap_split_count(efi_memory_desc_t *md,

arch/x86/kernel/cpu/resctrl/monitor.c+2−1

@@ -519,7 +519,8 @@ void free_rmid(u32 closid, u32 rmid) · 518 unmodified lines
519	* allows architectures that ignore the closid parameter to avoid an	519	* allows architectures that ignore the closid parameter to avoid an
520	* unnecessary check.	520	* unnecessary check.
521	*/	521	*/
522	if (idx == resctrl_arch_rmid_idx_encode(RESCTRL_RESERVED_CLOSID,	522	if (!resctrl_arch_mon_capable() \|\|
		523	idx == resctrl_arch_rmid_idx_encode(RESCTRL_RESERVED_CLOSID,
523	RESCTRL_RESERVED_RMID))	524	RESCTRL_RESERVED_RMID))
524	return;	525	return;
525		526

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

@@ -2843,7 +2843,7 @@ static int svm_get_msr(struct kvm_vcpu vcpu, struct msr_data msr_info) · 2842 unmodified lines
2843		2843
2844	if (sev_es_prevent_msr_access(vcpu, msr_info)) {	2844	if (sev_es_prevent_msr_access(vcpu, msr_info)) {
2845	msr_info->data = 0;	2845	msr_info->data = 0;
2846	return -EINVAL;	2846	return vcpu->kvm->arch.has_protected_state ? -EINVAL : 0;
2847	}	2847	}
2848		2848
2849	switch (msr_info->index) {	2849	switch (msr_info->index) {
@@ -2998,7 +2998,7 @@ static int svm_set_msr(struct kvm_vcpu vcpu, struct msr_data msr) · 148 unmodified lines
2998	u64 data = msr->data;	2998	u64 data = msr->data;
2999		2999
3000	if (sev_es_prevent_msr_access(vcpu, msr))	3000	if (sev_es_prevent_msr_access(vcpu, msr))
3001	return -EINVAL;	3001	return vcpu->kvm->arch.has_protected_state ? -EINVAL : 0;
3002		3002
3003	switch (ecx) {	3003	switch (ecx) {
3004	case MSR_AMD64_TSC_RATIO:	3004	case MSR_AMD64_TSC_RATIO:

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

 	bitmap_zero(vcpu->arch.ioapic_handled_vectors, 256);
+	static_call_cond(kvm_x86_sync_pir_to_irr)(vcpu);
 	if (irqchip_split(vcpu->kvm))
 		kvm_scan_ioapic_routes(vcpu, vcpu->arch.ioapic_handled_vectors);
-	else {
+	else if (ioapic_in_kernel(vcpu->kvm))
-		static_call_cond(kvm_x86_sync_pir_to_irr)(vcpu);
+		kvm_ioapic_scan_entry(vcpu, vcpu->arch.ioapic_handled_vectors);
-		if (ioapic_in_kernel(vcpu->kvm))
-			kvm_ioapic_scan_entry(vcpu, vcpu->arch.ioapic_handled_vectors);
-	}
 	if (is_guest_mode(vcpu))
 		vcpu->arch.load_eoi_exitmap_pending = true;

arch/x86/platform/efi/memmap.c+11−1

  */
 int __init efi_memmap_install(struct efi_memory_map_data *data)
 {
+	unsigned long size = efi.memmap.desc_size * efi.memmap.nr_map;
+	unsigned long flags = efi.memmap.flags;
+	u64 phys = efi.memmap.phys_map;
+	int ret;
 	efi_memmap_unmap();
 	if (efi_enabled(EFI_PARAVIRT))
 		return 0;
-	return __efi_memmap_init(data);
+	ret = __efi_memmap_init(data);
+	if (ret)
+		return ret;
+	__efi_memmap_free(phys, size, flags);
+	return 0;
 }
 /**

drivers/acpi/acpica/exregion.c+2−21

@@ -44,7 +44,6 @@ acpi_ex_system_memory_space_handler(u32 function, · 43 unmodified lines
44	struct acpi_mem_mapping *mm = mem_info->cur_mm;	44	struct acpi_mem_mapping *mm = mem_info->cur_mm;
45	u32 length;	45	u32 length;
46	acpi_size map_length;	46	acpi_size map_length;
47	acpi_size page_boundary_map_length;
48	#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED	47	#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
49	u32 remainder;	48	u32 remainder;
50	#endif	49	#endif
@@ -138,26 +137,8 @@ acpi_ex_system_memory_space_handler(u32 function, · 87 unmodified lines
138	map_length = (acpi_size)	137	map_length = (acpi_size)
139	((mem_info->address + mem_info->length) - address);	138	((mem_info->address + mem_info->length) - address);
140		139
141	/*	140	if (map_length > ACPI_DEFAULT_PAGE_SIZE)
142	* If mapping the entire remaining portion of the region will cross	141	map_length = ACPI_DEFAULT_PAGE_SIZE;
143	* a page boundary, just map up to the page boundary, do not cross.
144	* On some systems, crossing a page boundary while mapping regions
145	* can cause warnings if the pages have different attributes
146	* due to resource management.
147	*
148	* This has the added benefit of constraining a single mapping to
149	* one page, which is similar to the original code that used a 4k
150	* maximum window.
151	*/
152	page_boundary_map_length = (acpi_size)
153	(ACPI_ROUND_UP(address, ACPI_DEFAULT_PAGE_SIZE) - address);
154	if (page_boundary_map_length == 0) {
155	page_boundary_map_length = ACPI_DEFAULT_PAGE_SIZE;
156	}
157
158	if (map_length > page_boundary_map_length) {
159	map_length = page_boundary_map_length;
160	}
161		142
162	/* Create a new mapping starting at the address given */	143	/* Create a new mapping starting at the address given */
163		144

drivers/acpi/internal.h+4−0

 void acpi_mipi_scan_crs_csi2(void);
 void acpi_mipi_init_crs_csi2_swnodes(void);
 void acpi_mipi_crs_csi2_cleanup(void);
+#ifdef CONFIG_X86
 bool acpi_graph_ignore_port(acpi_handle handle);
+#else
+static inline bool acpi_graph_ignore_port(acpi_handle handle) { return false; }
+#endif
 #endif /* _ACPI_INTERNAL_H_ */

drivers/acpi/mipi-disco-img.c+19−9

@@ -725,14 +725,20 @@ void acpi_mipi_crs_csi2_cleanup(void) · 724 unmodified lines
725	acpi_mipi_del_crs_csi2(csi2);	725	acpi_mipi_del_crs_csi2(csi2);
726	}	726	}
727		727
728	static const struct dmi_system_id dmi_ignore_port_nodes[] = {	728	#ifdef CONFIG_X86
729	{	729	#include <asm/cpu_device_id.h>
730	.matches = {	730	#include <asm/intel-family.h>
731	DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),	731
732	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS 9315"),	732	/* CPU matches for Dell generations with broken ACPI MIPI DISCO info */
733	},	733	static const struct x86_cpu_id dell_broken_mipi_disco_cpu_gens[] = {
734	},	734	X86_MATCH_VFM(INTEL_TIGERLAKE, NULL),
735	{ }	735	X86_MATCH_VFM(INTEL_TIGERLAKE_L, NULL),
		736	X86_MATCH_VFM(INTEL_ALDERLAKE, NULL),
		737	X86_MATCH_VFM(INTEL_ALDERLAKE_L, NULL),
		738	X86_MATCH_VFM(INTEL_RAPTORLAKE, NULL),
		739	X86_MATCH_VFM(INTEL_RAPTORLAKE_P, NULL),
		740	X86_MATCH_VFM(INTEL_RAPTORLAKE_S, NULL),
		741	{}
736	};	742	};
737		743
738	static const char strnext(const char s1, const char *s2)	744	static const char strnext(const char s1, const char *s2)
@@ -761,7 +767,10 @@ bool acpi_graph_ignore_port(acpi_handle handle) · 22 unmodified lines
761	static bool dmi_tested, ignore_port;	767	static bool dmi_tested, ignore_port;
762		768
763	if (!dmi_tested) {	769	if (!dmi_tested) {
764	ignore_port = dmi_first_match(dmi_ignore_port_nodes);	770	if (dmi_name_in_vendors("Dell Inc.") &&
		771	x86_match_cpu(dell_broken_mipi_disco_cpu_gens))
		772	ignore_port = true;
		773
765	dmi_tested = true;	774	dmi_tested = true;
766	}	775	}
767		776
@@ -794,3 +803,4 @@ out_free: · 26 unmodified lines
794	kfree(orig_path);	803	kfree(orig_path);
795	return false;	804	return false;
796	}	805	}
		806	#endif

drivers/ata/ahci.c+8−0

@@ -1735,6 +1735,14 @@ static void ahci_update_initial_lpm_policy(struct ata_port *ap) · 1734 unmodified lines
1735	if (ap->pflags & ATA_PFLAG_EXTERNAL)	1735	if (ap->pflags & ATA_PFLAG_EXTERNAL)
1736	return;	1736	return;
1737		1737
		1738	/* If no LPM states are supported by the HBA, do not bother with LPM */
		1739	if ((ap->host->flags & ATA_HOST_NO_PART) &&
		1740	(ap->host->flags & ATA_HOST_NO_SSC) &&
		1741	(ap->host->flags & ATA_HOST_NO_DEVSLP)) {
		1742	ata_port_dbg(ap, "no LPM states supported, not enabling LPM\n");
		1743	return;
		1744	}
		1745
1738	/* user modified policy via module param */	1746	/* user modified policy via module param */
1739	if (mobile_lpm_policy != -1) {	1747	if (mobile_lpm_policy != -1) {
1740	policy = mobile_lpm_policy;	1748	policy = mobile_lpm_policy;

drivers/dma/Kconfig+1−1

@@ -394,7 +394,7 @@ config LS2X_APB_DMA · 393 unmodified lines
394		394
395	config MCF_EDMA	395	config MCF_EDMA
396	tristate "Freescale eDMA engine support, ColdFire mcf5441x SoCs"	396	tristate "Freescale eDMA engine support, ColdFire mcf5441x SoCs"
397	depends on M5441x \|\| COMPILE_TEST	397	depends on M5441x \|\| (COMPILE_TEST && FSL_EDMA=n)
398	select DMA_ENGINE	398	select DMA_ENGINE
399	select DMA_VIRTUAL_CHANNELS	399	select DMA_VIRTUAL_CHANNELS
400	help	400	help

drivers/dma/idxd/irq.c+3−1

 	spin_unlock(&irq_entry->list_lock);
-	list_for_each_entry(desc, &flist, list) {
+	list_for_each_entry_safe(desc, n, &flist, list) {
 		/*
 		 * Check against the original status as ABORT is software defined
 		 * and 0xff, which DSA_COMP_STATUS_MASK can mask out.
 		 */
+		list_del(&desc->list);
 		if (unlikely(desc->completion->status == IDXD_COMP_DESC_ABORT)) {
 			idxd_desc_complete(desc, IDXD_COMPLETE_ABORT, true);
 			continue;

drivers/dma/ioat/init.c+30−25

 	return err;
 }
-static int ioat_register(struct ioatdma_device *ioat_dma)
-{
-	int err = dma_async_device_register(&ioat_dma->dma_dev);
-	if (err) {
-		ioat_disable_interrupts(ioat_dma);
-		dma_pool_destroy(ioat_dma->completion_pool);
-	}
-	return err;
-}
 static void ioat_dma_remove(struct ioatdma_device *ioat_dma)
 {
 	struct dma_device *dma = &ioat_dma->dma_dev;
 		       ioat_chan->reg_base + IOAT_DCACTRL_OFFSET);
 	}
-	err = ioat_register(ioat_dma);
+	err = dma_async_device_register(&ioat_dma->dma_dev);
 	if (err)
-		return err;
+		goto err_disable_interrupts;
 	ioat_kobject_add(ioat_dma, &ioat_ktype);
 	/* disable relaxed ordering */
 	err = pcie_capability_read_word(pdev, PCI_EXP_DEVCTL, &val16);
-	if (err)
+	if (err) {
-		return pcibios_err_to_errno(err);
+		err = pcibios_err_to_errno(err);
+		goto err_disable_interrupts;
+	}
 	/* clear relaxed ordering enable */
 	val16 &= ~PCI_EXP_DEVCTL_RELAX_EN;
 	err = pcie_capability_write_word(pdev, PCI_EXP_DEVCTL, val16);
-	if (err)
+	if (err) {
-		return pcibios_err_to_errno(err);
+		err = pcibios_err_to_errno(err);
+		goto err_disable_interrupts;
+	}
 	if (ioat_dma->cap & IOAT_CAP_DPS)
 		writeb(ioat_pending_level + 1,
 		       ioat_dma->reg_base + IOAT_PREFETCH_LIMIT_OFFSET);
 	return 0;
+err_disable_interrupts:
+	ioat_disable_interrupts(ioat_dma);
+	dma_pool_destroy(ioat_dma->completion_pool);
+	return err;
 }
 static void ioat_shutdown(struct pci_dev *pdev)
 	void __iomem * const *iomap;
 	struct device *dev = &pdev->dev;
 	struct ioatdma_device *device;
+	unsigned int i;
+	u8 version;
 	int err;
 	err = pcim_enable_device(pdev);
 	if (!iomap)
 		return -ENOMEM;
+	version = readb(iomap[IOAT_MMIO_BAR] + IOAT_VER_OFFSET);
+	if (version < IOAT_VER_3_0)
+		return -ENODEV;
 	err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
 	if (err)
 		return err;
 	pci_set_master(pdev);
 	pci_set_drvdata(pdev, device);
-	device->version = readb(device->reg_base + IOAT_VER_OFFSET);
+	device->version = version;
 	if (device->version >= IOAT_VER_3_4)
 		ioat_dca_enabled = 0;
-	if (device->version >= IOAT_VER_3_0) {
-		if (is_skx_ioat(pdev))
-			device->version = IOAT_VER_3_2;
-		err = ioat3_dma_probe(device, ioat_dca_enabled);
-	} else
-		return -ENODEV;
+	if (is_skx_ioat(pdev))
+		device->version = IOAT_VER_3_2;
+	err = ioat3_dma_probe(device, ioat_dca_enabled);
 	if (err) {
+		for (i = 0; i < IOAT_MAX_CHANS; i++)
+			kfree(device->idx[i]);
+		kfree(device);
 		dev_err(dev, "Intel(R) I/OAT DMA Engine init failed\n");
 		return -ENODEV;
 	}
 static void __exit ioat_exit_module(void)
 {
 	pci_unregister_driver(&ioat_pci_driver);
+	kmem_cache_destroy(ioat_sed_cache);
 	kmem_cache_destroy(ioat_cache);
 }
 module_exit(ioat_exit_module);

drivers/dma/ti/k3-udma-glue.c+1−4

 	ret = of_k3_udma_glue_parse(udmax_np, common);
 	if (ret)
-		goto out_put_spec;
+		return ret;
 	ret = of_k3_udma_glue_parse_chn_common(common, thread_id, tx_chn);
-out_put_spec:
-	of_node_put(udmax_np);
 	return ret;
 }

drivers/dma/xilinx/xdma.c+2−2

 	u32 st;
 	bool repeat_tx;
+	spin_lock(&xchan->vchan.lock);
 	if (xchan->stop_requested)
 		complete(&xchan->last_interrupt);
-	spin_lock(&xchan->vchan.lock);
 	/* get submitted request */
 	vd = vchan_next_desc(&xchan->vchan);
 	if (!vd)

drivers/firmware/efi/memmap.c+0−9

 #include <asm/early_ioremap.h>
 #include <asm/efi.h>
-#ifndef __efi_memmap_free
-#define __efi_memmap_free(phys, size, flags) do { } while (0)
-#endif
 /**
  * __efi_memmap_init - Common code for mapping the EFI memory map
  * @data: EFI memory map data
 		return -ENOMEM;
 	}
-	if (efi.memmap.flags & (EFI_MEMMAP_MEMBLOCK | EFI_MEMMAP_SLAB))
-		__efi_memmap_free(efi.memmap.phys_map,
-				  efi.memmap.desc_size * efi.memmap.nr_map,
-				  efi.memmap.flags);
 	map.phys_map = data->phys_map;
 	map.nr_map = data->size / data->desc_size;
 	map.map_end = map.map + data->size;

drivers/firmware/psci/psci.c+3−1

 static int psci_system_suspend(unsigned long unused)
 {
+	int err;
 	phys_addr_t pa_cpu_resume = __pa_symbol(cpu_resume);
-	return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND),
+	err = invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND),
 			      pa_cpu_resume, 0, 0);
+	return psci_to_linux_errno(err);
 }
 static int psci_system_suspend_enter(suspend_state_t state)

drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c+0−34

@@ -41,8 +41,6 @@ · 40 unmodified lines
41	#include <linux/dma-buf.h>	41	#include <linux/dma-buf.h>
42	#include <linux/dma-fence-array.h>	42	#include <linux/dma-fence-array.h>
43	#include <linux/pci-p2pdma.h>	43	#include <linux/pci-p2pdma.h>
44	#include <linux/pm_runtime.h>
45	#include "amdgpu_trace.h"
46		44
47	/**	45	/**
48	* amdgpu_dma_buf_attach - &dma_buf_ops.attach implementation	46	* amdgpu_dma_buf_attach - &dma_buf_ops.attach implementation
@@ -58,42 +56,11 @@ static int amdgpu_dma_buf_attach(struct dma_buf *dmabuf, · 9 unmodified lines
58	struct drm_gem_object *obj = dmabuf->priv;	56	struct drm_gem_object *obj = dmabuf->priv;
59	struct amdgpu_bo *bo = gem_to_amdgpu_bo(obj);	57	struct amdgpu_bo *bo = gem_to_amdgpu_bo(obj);
60	struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);	58	struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
61	int r;
62		59
63	if (pci_p2pdma_distance(adev->pdev, attach->dev, false) < 0)	60	if (pci_p2pdma_distance(adev->pdev, attach->dev, false) < 0)
64	attach->peer2peer = false;	61	attach->peer2peer = false;
65		62
66	r = pm_runtime_get_sync(adev_to_drm(adev)->dev);
67	trace_amdgpu_runpm_reference_dumps(1, __func__);
68	if (r < 0)
69	goto out;
70
71	return 0;	63	return 0;
72
73	out:
74	pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);
75	trace_amdgpu_runpm_reference_dumps(0, __func__);
76	return r;
77	}
78
79	/**
80	* amdgpu_dma_buf_detach - &dma_buf_ops.detach implementation
81	*
82	* @dmabuf: DMA-buf where we remove the attachment from
83	* @attach: the attachment to remove
84	*
85	* Called when an attachment is removed from the DMA-buf.
86	*/
87	static void amdgpu_dma_buf_detach(struct dma_buf *dmabuf,
88	struct dma_buf_attachment *attach)
89	{
90	struct drm_gem_object *obj = dmabuf->priv;
91	struct amdgpu_bo *bo = gem_to_amdgpu_bo(obj);
92	struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
93
94	pm_runtime_mark_last_busy(adev_to_drm(adev)->dev);
95	pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);
96	trace_amdgpu_runpm_reference_dumps(0, __func__);
97	}	64	}
98		65
99	/**	66	/**
@@ -267,7 +234,6 @@ static int amdgpu_dma_buf_begin_cpu_access(struct dma_buf *dma_buf, · 167 unmodified lines
267		234
268	const struct dma_buf_ops amdgpu_dmabuf_ops = {	235	const struct dma_buf_ops amdgpu_dmabuf_ops = {
269	.attach = amdgpu_dma_buf_attach,	236	.attach = amdgpu_dma_buf_attach,
270	.detach = amdgpu_dma_buf_detach,
271	.pin = amdgpu_dma_buf_pin,	237	.pin = amdgpu_dma_buf_pin,
272	.unpin = amdgpu_dma_buf_unpin,	238	.unpin = amdgpu_dma_buf_unpin,
273	.map_dma_buf = amdgpu_dma_buf_map,	239	.map_dma_buf = amdgpu_dma_buf_map,

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

 	amdgpu_ring_emit_fence(ring, ring->fence_drv.gpu_addr,
 			       seq, flags | AMDGPU_FENCE_FLAG_INT);
 	pm_runtime_get_noresume(adev_to_drm(adev)->dev);
-	trace_amdgpu_runpm_reference_dumps(1, __func__);
 	ptr = &ring->fence_drv.fences[seq & ring->fence_drv.num_fences_mask];
 	if (unlikely(rcu_dereference_protected(*ptr, 1))) {
 		struct dma_fence *old;
 		dma_fence_put(fence);
 		pm_runtime_mark_last_busy(adev_to_drm(adev)->dev);
 		pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);
-		trace_amdgpu_runpm_reference_dumps(0, __func__);
 	} while (last_seq != seq);
 	return true;

drivers/gpu/drm/amd/amdgpu/amdgpu_gmc.c+34−32

@@ -684,12 +684,17 @@ int amdgpu_gmc_flush_gpu_tlb_pasid(struct amdgpu_device *adev, uint16_t pasid, · 683 unmodified lines
684	struct amdgpu_ring *ring = &adev->gfx.kiq[inst].ring;	684	struct amdgpu_ring *ring = &adev->gfx.kiq[inst].ring;
685	struct amdgpu_kiq *kiq = &adev->gfx.kiq[inst];	685	struct amdgpu_kiq *kiq = &adev->gfx.kiq[inst];
686	unsigned int ndw;	686	unsigned int ndw;
687	signed long r;	687	int r;
688	uint32_t seq;	688	uint32_t seq;
689		689
690	if (!adev->gmc.flush_pasid_uses_kiq \|\| !ring->sched.ready \|\|	690	/*
691	!down_read_trylock(&adev->reset_domain->sem)) {	691	* A GPU reset should flush all TLBs anyway, so no need to do
		692	* this while one is ongoing.
		693	*/
		694	if (!down_read_trylock(&adev->reset_domain->sem))
		695	return 0;
692		696
		697	if (!adev->gmc.flush_pasid_uses_kiq \|\| !ring->sched.ready) {
693	if (adev->gmc.flush_tlb_needs_extra_type_2)	698	if (adev->gmc.flush_tlb_needs_extra_type_2)
694	adev->gmc.gmc_funcs->flush_gpu_tlb_pasid(adev, pasid,	699	adev->gmc.gmc_funcs->flush_gpu_tlb_pasid(adev, pasid,
695	2, all_hub,	700	2, all_hub,
@@ -703,43 +708,40 @@ int amdgpu_gmc_flush_gpu_tlb_pasid(struct amdgpu_device *adev, uint16_t pasid, · 7 unmodified lines
703	adev->gmc.gmc_funcs->flush_gpu_tlb_pasid(adev, pasid,	708	adev->gmc.gmc_funcs->flush_gpu_tlb_pasid(adev, pasid,
704	flush_type, all_hub,	709	flush_type, all_hub,
705	inst);	710	inst);
706	return 0;	711	r = 0;
707	}	712	} else {
		713	/* 2 dwords flush + 8 dwords fence */
		714	ndw = kiq->pmf->invalidate_tlbs_size + 8;
708		715
709	/* 2 dwords flush + 8 dwords fence */	716	if (adev->gmc.flush_tlb_needs_extra_type_2)
710	ndw = kiq->pmf->invalidate_tlbs_size + 8;	717	ndw += kiq->pmf->invalidate_tlbs_size;
711		718
712	if (adev->gmc.flush_tlb_needs_extra_type_2)	719	if (adev->gmc.flush_tlb_needs_extra_type_0)
713	ndw += kiq->pmf->invalidate_tlbs_size;	720	ndw += kiq->pmf->invalidate_tlbs_size;
714		721
715	if (adev->gmc.flush_tlb_needs_extra_type_0)	722	spin_lock(&adev->gfx.kiq[inst].ring_lock);
716	ndw += kiq->pmf->invalidate_tlbs_size;	723	amdgpu_ring_alloc(ring, ndw);
		724	if (adev->gmc.flush_tlb_needs_extra_type_2)
		725	kiq->pmf->kiq_invalidate_tlbs(ring, pasid, 2, all_hub);
717		726
718	spin_lock(&adev->gfx.kiq[inst].ring_lock);	727	if (flush_type == 2 && adev->gmc.flush_tlb_needs_extra_type_0)
719	amdgpu_ring_alloc(ring, ndw);	728	kiq->pmf->kiq_invalidate_tlbs(ring, pasid, 0, all_hub);
720	if (adev->gmc.flush_tlb_needs_extra_type_2)
721	kiq->pmf->kiq_invalidate_tlbs(ring, pasid, 2, all_hub);
722		729
723	if (flush_type == 2 && adev->gmc.flush_tlb_needs_extra_type_0)	730	kiq->pmf->kiq_invalidate_tlbs(ring, pasid, flush_type, all_hub);
724	kiq->pmf->kiq_invalidate_tlbs(ring, pasid, 0, all_hub);	731	r = amdgpu_fence_emit_polling(ring, &seq, MAX_KIQ_REG_WAIT);
		732	if (r) {
		733	amdgpu_ring_undo(ring);
		734	spin_unlock(&adev->gfx.kiq[inst].ring_lock);
		735	goto error_unlock_reset;
		736	}
725		737
726	kiq->pmf->kiq_invalidate_tlbs(ring, pasid, flush_type, all_hub);	738	amdgpu_ring_commit(ring);
727	r = amdgpu_fence_emit_polling(ring, &seq, MAX_KIQ_REG_WAIT);
728	if (r) {
729	amdgpu_ring_undo(ring);
730	spin_unlock(&adev->gfx.kiq[inst].ring_lock);	739	spin_unlock(&adev->gfx.kiq[inst].ring_lock);
731	goto error_unlock_reset;	740	if (amdgpu_fence_wait_polling(ring, seq, usec_timeout) < 1) {
732	}	741	dev_err(adev->dev, "timeout waiting for kiq fence\n");
733		742	r = -ETIME;
734	amdgpu_ring_commit(ring);	743	}
735	spin_unlock(&adev->gfx.kiq[inst].ring_lock);
736	r = amdgpu_fence_wait_polling(ring, seq, usec_timeout);
737	if (r < 1) {
738	dev_err(adev->dev, "wait for kiq fence error: %ld.\n", r);
739	r = -ETIME;
740	goto error_unlock_reset;
741	}	744	}
742	r = 0;
743		745
744	error_unlock_reset:	746	error_unlock_reset:
745	up_read(&adev->reset_domain->sem);	747	up_read(&adev->reset_domain->sem);

drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h+0−15

@@ -554,21 +554,6 @@ TRACE_EVENT(amdgpu_reset_reg_dumps, · 553 unmodified lines
554	__entry->value)	554	__entry->value)
555	);	555	);
556		556
557	TRACE_EVENT(amdgpu_runpm_reference_dumps,
558	TP_PROTO(uint32_t index, const char *func),
559	TP_ARGS(index, func),
560	TP_STRUCT__entry(
561	__field(uint32_t, index)
562	__string(func, func)
563	),
564	TP_fast_assign(
565	__entry->index = index;
566	__assign_str(func);
567	),
568	TP_printk("amdgpu runpm reference dump 0x%x: 0x%s\n",
569	__entry->index,
570	__get_str(func))
571	);
572	#undef AMDGPU_JOB_GET_TIMELINE_NAME	557	#undef AMDGPU_JOB_GET_TIMELINE_NAME
573	#endif	558	#endif
574		559

drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.c+13−2

 static int gfx_v9_4_3_get_cu_info(struct amdgpu_device *adev,
 				 struct amdgpu_cu_info *cu_info)
 {
-	int i, j, k, counter, xcc_id, active_cu_number = 0;
+	int i, j, k, prev_counter, counter, xcc_id, active_cu_number = 0;
-	u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0;
+	u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0, tmp;
 	unsigned disable_masks[4 * 4];
+	bool is_symmetric_cus;
 	if (!adev || !cu_info)
 		return -EINVAL;
 	mutex_lock(&adev->grbm_idx_mutex);
 	for (xcc_id = 0; xcc_id < NUM_XCC(adev->gfx.xcc_mask); xcc_id++) {
+		is_symmetric_cus = true;
 		for (i = 0; i < adev->gfx.config.max_shader_engines; i++) {
 			for (j = 0; j < adev->gfx.config.max_sh_per_se; j++) {
 				mask = 1;
 					ao_cu_mask |= (ao_bitmap << (i * 16 + j * 8));
 				cu_info->ao_cu_bitmap[i][j] = ao_bitmap;
 			}
+			if (i && is_symmetric_cus && prev_counter != counter)
+				is_symmetric_cus = false;
+			prev_counter = counter;
+		}
+		if (is_symmetric_cus) {
+			tmp = RREG32_SOC15(GC, GET_INST(GC, xcc_id), regCP_CPC_DEBUG);
+			tmp = REG_SET_FIELD(tmp, CP_CPC_DEBUG, CPC_HARVESTING_RELAUNCH_DISABLE, 1);
+			tmp = REG_SET_FIELD(tmp, CP_CPC_DEBUG, CPC_HARVESTING_DISPATCH_DISABLE, 1);
+			WREG32_SOC15(GC, GET_INST(GC, xcc_id), regCP_CPC_DEBUG, tmp);
 		}
 		gfx_v9_4_3_xcc_select_se_sh(adev, 0xffffffff, 0xffffffff, 0xffffffff,
 					    xcc_id);

drivers/gpu/drm/amd/amdgpu/mes_v11_0.c+48−28

@@ -154,18 +154,18 @@ static int mes_v11_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes, · 153 unmodified lines
154	void *pkt, int size,	154	void *pkt, int size,
155	int api_status_off)	155	int api_status_off)
156	{	156	{
157	int ndw = size / 4;	157	union MESAPI__QUERY_MES_STATUS mes_status_pkt;
158	signed long r;	158	signed long timeout = 3000000; /* 3000 ms */
159	union MESAPI__MISC *x_pkt = pkt;
160	struct MES_API_STATUS *api_status;
161	struct amdgpu_device *adev = mes->adev;	159	struct amdgpu_device *adev = mes->adev;
162	struct amdgpu_ring *ring = &mes->ring;	160	struct amdgpu_ring *ring = &mes->ring;
163	unsigned long flags;	161	struct MES_API_STATUS *api_status;
164	signed long timeout = 3000000; /* 3000 ms */	162	union MESAPI__MISC *x_pkt = pkt;
165	const char op_str, misc_op_str;	163	const char op_str, misc_op_str;
166	u32 fence_offset;	164	unsigned long flags;
167	u64 fence_gpu_addr;	165	u64 status_gpu_addr;
168	u64 *fence_ptr;	166	u32 status_offset;
		167	u64 *status_ptr;
		168	signed long r;
169	int ret;	169	int ret;
170		170
171	if (x_pkt->header.opcode >= MES_SCH_API_MAX)	171	if (x_pkt->header.opcode >= MES_SCH_API_MAX)
@@ -177,28 +177,38 @@ static int mes_v11_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes, · 5 unmodified lines
177	/* Worst case in sriov where all other 15 VF timeout, each VF needs about 600ms */	177	/* Worst case in sriov where all other 15 VF timeout, each VF needs about 600ms */
178	timeout = 15 * 600 * 1000;	178	timeout = 15 * 600 * 1000;
179	}	179	}
180	BUG_ON(size % 4 != 0);
181		180
182	ret = amdgpu_device_wb_get(adev, &fence_offset);	181	ret = amdgpu_device_wb_get(adev, &status_offset);
183	if (ret)	182	if (ret)
184	return ret;	183	return ret;
185	fence_gpu_addr =	184
186	adev->wb.gpu_addr + (fence_offset * 4);	185	status_gpu_addr = adev->wb.gpu_addr + (status_offset * 4);
187	fence_ptr = (u64 *)&adev->wb.wb[fence_offset];	186	status_ptr = (u64 *)&adev->wb.wb[status_offset];
188	*fence_ptr = 0;	187	*status_ptr = 0;
189		188
190	spin_lock_irqsave(&mes->ring_lock, flags);	189	spin_lock_irqsave(&mes->ring_lock, flags);
191	if (amdgpu_ring_alloc(ring, ndw)) {	190	r = amdgpu_ring_alloc(ring, (size + sizeof(mes_status_pkt)) / 4);
192	spin_unlock_irqrestore(&mes->ring_lock, flags);	191	if (r)
193	amdgpu_device_wb_free(adev, fence_offset);	192	goto error_unlock_free;
194	return -ENOMEM;
195	}
196		193
197	api_status = (struct MES_API_STATUS )((char )pkt + api_status_off);	194	api_status = (struct MES_API_STATUS )((char )pkt + api_status_off);
198	api_status->api_completion_fence_addr = fence_gpu_addr;	195	api_status->api_completion_fence_addr = status_gpu_addr;
199	api_status->api_completion_fence_value = 1;	196	api_status->api_completion_fence_value = 1;
200		197
201	amdgpu_ring_write_multiple(ring, pkt, ndw);	198	amdgpu_ring_write_multiple(ring, pkt, size / 4);
		199
		200	memset(&mes_status_pkt, 0, sizeof(mes_status_pkt));
		201	mes_status_pkt.header.type = MES_API_TYPE_SCHEDULER;
		202	mes_status_pkt.header.opcode = MES_SCH_API_QUERY_SCHEDULER_STATUS;
		203	mes_status_pkt.header.dwsize = API_FRAME_SIZE_IN_DWORDS;
		204	mes_status_pkt.api_status.api_completion_fence_addr =
		205	ring->fence_drv.gpu_addr;
		206	mes_status_pkt.api_status.api_completion_fence_value =
		207	++ring->fence_drv.sync_seq;
		208
		209	amdgpu_ring_write_multiple(ring, &mes_status_pkt,
		210	sizeof(mes_status_pkt) / 4);
		211
202	amdgpu_ring_commit(ring);	212	amdgpu_ring_commit(ring);
203	spin_unlock_irqrestore(&mes->ring_lock, flags);	213	spin_unlock_irqrestore(&mes->ring_lock, flags);
204		214
@@ -206,15 +216,16 @@ static int mes_v11_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes, · 1 unmodified line
206	misc_op_str = mes_v11_0_get_misc_op_string(x_pkt);	216	misc_op_str = mes_v11_0_get_misc_op_string(x_pkt);
207		217
208	if (misc_op_str)	218	if (misc_op_str)
209	dev_dbg(adev->dev, "MES msg=%s (%s) was emitted\n", op_str, misc_op_str);	219	dev_dbg(adev->dev, "MES msg=%s (%s) was emitted\n", op_str,
		220	misc_op_str);
210	else if (op_str)	221	else if (op_str)
211	dev_dbg(adev->dev, "MES msg=%s was emitted\n", op_str);	222	dev_dbg(adev->dev, "MES msg=%s was emitted\n", op_str);
212	else	223	else
213	dev_dbg(adev->dev, "MES msg=%d was emitted\n", x_pkt->header.opcode);	224	dev_dbg(adev->dev, "MES msg=%d was emitted\n",
		225	x_pkt->header.opcode);
214		226
215	r = amdgpu_mes_fence_wait_polling(fence_ptr, (u64)1, timeout);	227	r = amdgpu_fence_wait_polling(ring, ring->fence_drv.sync_seq, timeout);
216	amdgpu_device_wb_free(adev, fence_offset);	228	if (r < 1 \|\| !*status_ptr) {
217	if (r < 1) {
218		229
219	if (misc_op_str)	230	if (misc_op_str)
220	dev_err(adev->dev, "MES failed to respond to msg=%s (%s)\n",	231	dev_err(adev->dev, "MES failed to respond to msg=%s (%s)\n",
@@ -229,10 +240,19 @@ static int mes_v11_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes, · 8 unmodified lines
229	while (halt_if_hws_hang)	240	while (halt_if_hws_hang)
230	schedule();	241	schedule();
231		242
232	return -ETIMEDOUT;	243	r = -ETIMEDOUT;
		244	goto error_wb_free;
233	}	245	}
234		246
		247	amdgpu_device_wb_free(adev, status_offset);
235	return 0;	248	return 0;
		249
		250	error_unlock_free:
		251	spin_unlock_irqrestore(&mes->ring_lock, flags);
		252
		253	error_wb_free:
		254	amdgpu_device_wb_free(adev, status_offset);
		255	return r;
236	}	256	}
237		257
238	static int convert_to_mes_queue_type(int queue_type)	258	static int convert_to_mes_queue_type(int queue_type)

drivers/gpu/drm/amd/amdgpu/psp_v14_0.c+5−0

 #include "mp/mp_14_0_2_sh_mask.h"
 MODULE_FIRMWARE("amdgpu/psp_14_0_2_sos.bin");
+MODULE_FIRMWARE("amdgpu/psp_14_0_2_ta.bin");
 MODULE_FIRMWARE("amdgpu/psp_14_0_3_sos.bin");
+MODULE_FIRMWARE("amdgpu/psp_14_0_3_ta.bin");
 /* For large FW files the time to complete can be very long */
 #define USBC_PD_POLLING_LIMIT_S 240
 	case IP_VERSION(14, 0, 2):
 	case IP_VERSION(14, 0, 3):
 		err = psp_init_sos_microcode(psp, ucode_prefix);
+		if (err)
+			return err;
+		err = psp_init_ta_microcode(psp, ucode_prefix);
 		if (err)
 			return err;
 		break;

drivers/gpu/drm/amd/display/Kconfig+1−1

@@ -8,7 +8,7 @@ config DRM_AMD_DC · 7 unmodified lines
8	depends on BROKEN \|\| !CC_IS_CLANG \|\| ARM64 \|\| RISCV \|\| SPARC64 \|\| X86_64	8	depends on BROKEN \|\| !CC_IS_CLANG \|\| ARM64 \|\| RISCV \|\| SPARC64 \|\| X86_64
9	select SND_HDA_COMPONENT if SND_HDA_CORE	9	select SND_HDA_COMPONENT if SND_HDA_CORE
10	# !CC_IS_CLANG: https://github.com/ClangBuiltLinux/linux/issues/1752	10	# !CC_IS_CLANG: https://github.com/ClangBuiltLinux/linux/issues/1752
11	select DRM_AMD_DC_FP if ARCH_HAS_KERNEL_FPU_SUPPORT && (!ARM64 \|\| !CC_IS_CLANG)	11	select DRM_AMD_DC_FP if ARCH_HAS_KERNEL_FPU_SUPPORT && !(CC_IS_CLANG && (ARM64 \|\| RISCV))
12	help	12	help
13	Choose this option if you want to use the new display engine	13	Choose this option if you want to use the new display engine
14	support for AMDGPU. This adds required support for Vega and	14	support for AMDGPU. This adds required support for Vega and

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+10−3

 	trace_amdgpu_dm_atomic_commit_tail_begin(state);
-	if (dm->dc->caps.ips_support && dm->dc->idle_optimizations_allowed)
-		dc_allow_idle_optimizations(dm->dc, false);
 	drm_atomic_helper_update_legacy_modeset_state(dev, state);
 	drm_dp_mst_atomic_wait_for_dependencies(state);
 	mutex_unlock(&adev->dm.dc_lock);
 }
+static inline void amdgpu_dm_exit_ips_for_hw_access(struct dc *dc)
+{
+	if (dc->ctx->dmub_srv && !dc->ctx->dmub_srv->idle_exit_counter)
+		dc_exit_ips_for_hw_access(dc);
+}
 void dm_write_reg_func(const struct dc_context *ctx, uint32_t address,
 		       u32 value, const char *func_name)
 {
 		return;
 	}
 #endif
+	amdgpu_dm_exit_ips_for_hw_access(ctx->dc);
 	cgs_write_register(ctx->cgs_device, address, value);
 	trace_amdgpu_dc_wreg(&ctx->perf_trace->write_count, address, value);
 }
 		return 0;
 	}
+	amdgpu_dm_exit_ips_for_hw_access(ctx->dc);
 	value = cgs_read_register(ctx->cgs_device, address);
 	trace_amdgpu_dc_rreg(&ctx->perf_trace->read_count, address, value);

drivers/gpu/drm/amd/display/dc/dml/dcn35/dcn35_fpu.c+1−1

@@ -177,7 +177,7 @@ struct _vcs_dpi_soc_bounding_box_st dcn3_5_soc = { · 176 unmodified lines
177	.urgent_latency_pixel_data_only_us = 4.0,	177	.urgent_latency_pixel_data_only_us = 4.0,
178	.urgent_latency_pixel_mixed_with_vm_data_us = 4.0,	178	.urgent_latency_pixel_mixed_with_vm_data_us = 4.0,
179	.urgent_latency_vm_data_only_us = 4.0,	179	.urgent_latency_vm_data_only_us = 4.0,
180	.dram_clock_change_latency_us = 11.72,	180	.dram_clock_change_latency_us = 34.0,
181	.urgent_out_of_order_return_per_channel_pixel_only_bytes = 4096,	181	.urgent_out_of_order_return_per_channel_pixel_only_bytes = 4096,
182	.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes = 4096,	182	.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes = 4096,
183	.urgent_out_of_order_return_per_channel_vm_only_bytes = 4096,	183	.urgent_out_of_order_return_per_channel_vm_only_bytes = 4096,

drivers/gpu/drm/amd/display/dc/dml/dcn351/dcn351_fpu.c+1−1

@@ -215,7 +215,7 @@ struct _vcs_dpi_soc_bounding_box_st dcn3_51_soc = { · 214 unmodified lines
215	.urgent_latency_pixel_data_only_us = 4.0,	215	.urgent_latency_pixel_data_only_us = 4.0,
216	.urgent_latency_pixel_mixed_with_vm_data_us = 4.0,	216	.urgent_latency_pixel_mixed_with_vm_data_us = 4.0,
217	.urgent_latency_vm_data_only_us = 4.0,	217	.urgent_latency_vm_data_only_us = 4.0,
218	.dram_clock_change_latency_us = 11.72,	218	.dram_clock_change_latency_us = 34,
219	.urgent_out_of_order_return_per_channel_pixel_only_bytes = 4096,	219	.urgent_out_of_order_return_per_channel_pixel_only_bytes = 4096,
220	.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes = 4096,	220	.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes = 4096,
221	.urgent_out_of_order_return_per_channel_vm_only_bytes = 4096,	221	.urgent_out_of_order_return_per_channel_vm_only_bytes = 4096,

drivers/gpu/drm/amd/display/dc/hwss/dcn35/dcn35_hwseq.c+72−0

@@ -1439,3 +1439,75 @@ void dcn35_set_long_vblank(struct pipe_ctx **pipe_ctx, · 1438 unmodified lines
1439	}	1439	}
1440	}	1440	}
1441	}	1441	}
		1442
		1443	static bool should_avoid_empty_tu(struct pipe_ctx *pipe_ctx)
		1444	{
		1445	/* Calculate average pixel count per TU, return false if under ~2.00 to
		1446	* avoid empty TUs. This is only required for DPIA tunneling as empty TUs
		1447	* are legal to generate for native DP links. Assume TU size 64 as there
		1448	* is currently no scenario where it's reprogrammed from HW default.
		1449	* MTPs have no such limitation, so this does not affect MST use cases.
		1450	*/
		1451	unsigned int pix_clk_mhz;
		1452	unsigned int symclk_mhz;
		1453	unsigned int avg_pix_per_tu_x1000;
		1454	unsigned int tu_size_bytes = 64;
		1455	struct dc_crtc_timing *timing = &pipe_ctx->stream->timing;
		1456	struct dc_link_settings *link_settings = &pipe_ctx->link_config.dp_link_settings;
		1457	const struct dc *dc = pipe_ctx->stream->link->dc;
		1458
		1459	if (pipe_ctx->stream->link->ep_type != DISPLAY_ENDPOINT_USB4_DPIA)
		1460	return false;
		1461
		1462	// Not necessary for MST configurations
		1463	if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST)
		1464	return false;
		1465
		1466	pix_clk_mhz = timing->pix_clk_100hz / 10000;
		1467
		1468	// If this is true, can't block due to dynamic ODM
		1469	if (pix_clk_mhz > dc->clk_mgr->bw_params->clk_table.entries[0].dispclk_mhz)
		1470	return false;
		1471
		1472	switch (link_settings->link_rate) {
		1473	case LINK_RATE_LOW:
		1474	symclk_mhz = 162;
		1475	break;
		1476	case LINK_RATE_HIGH:
		1477	symclk_mhz = 270;
		1478	break;
		1479	case LINK_RATE_HIGH2:
		1480	symclk_mhz = 540;
		1481	break;
		1482	case LINK_RATE_HIGH3:
		1483	symclk_mhz = 810;
		1484	break;
		1485	default:
		1486	// We shouldn't be tunneling any other rates, something is wrong
		1487	ASSERT(0);
		1488	return false;
		1489	}
		1490
		1491	avg_pix_per_tu_x1000 = (1000 * pix_clk_mhz * tu_size_bytes)
		1492	/ (symclk_mhz * link_settings->lane_count);
		1493
		1494	// Add small empirically-decided margin to account for potential jitter
		1495	return (avg_pix_per_tu_x1000 < 2020);
		1496	}
		1497
		1498	bool dcn35_is_dp_dig_pixel_rate_div_policy(struct pipe_ctx *pipe_ctx)
		1499	{
		1500	struct dc *dc = pipe_ctx->stream->ctx->dc;
		1501
		1502	if (!is_h_timing_divisible_by_2(pipe_ctx->stream))
		1503	return false;
		1504
		1505	if (should_avoid_empty_tu(pipe_ctx))
		1506	return false;
		1507
		1508	if (dc_is_dp_signal(pipe_ctx->stream->signal) && !dc->link_srv->dp_is_128b_132b_signal(pipe_ctx) &&
		1509	dc->debug.enable_dp_dig_pixel_rate_div_policy)
		1510	return true;
		1511
		1512	return false;
		1513	}

drivers/gpu/drm/amd/display/dc/hwss/dcn35/dcn35_hwseq.h+2−0

@@ -95,4 +95,6 @@ void dcn35_set_static_screen_control(struct pipe_ctx **pipe_ctx, · 94 unmodified lines
95	void dcn35_set_long_vblank(struct pipe_ctx **pipe_ctx,	95	void dcn35_set_long_vblank(struct pipe_ctx **pipe_ctx,
96	int num_pipes, uint32_t v_total_min, uint32_t v_total_max);	96	int num_pipes, uint32_t v_total_min, uint32_t v_total_max);
97		97
		98	bool dcn35_is_dp_dig_pixel_rate_div_policy(struct pipe_ctx *pipe_ctx);
		99
98	#endif /* __DC_HWSS_DCN35_H__ */	100	#endif /* __DC_HWSS_DCN35_H__ */

drivers/gpu/drm/amd/display/dc/hwss/dcn35/dcn35_init.c+1−1

@@ -158,7 +158,7 @@ static const struct hwseq_private_funcs dcn35_private_funcs = { · 157 unmodified lines
158	.setup_hpo_hw_control = dcn35_setup_hpo_hw_control,	158	.setup_hpo_hw_control = dcn35_setup_hpo_hw_control,
159	.calculate_dccg_k1_k2_values = dcn32_calculate_dccg_k1_k2_values,	159	.calculate_dccg_k1_k2_values = dcn32_calculate_dccg_k1_k2_values,
160	.set_pixels_per_cycle = dcn32_set_pixels_per_cycle,	160	.set_pixels_per_cycle = dcn32_set_pixels_per_cycle,
161	.is_dp_dig_pixel_rate_div_policy = dcn32_is_dp_dig_pixel_rate_div_policy,	161	.is_dp_dig_pixel_rate_div_policy = dcn35_is_dp_dig_pixel_rate_div_policy,
162	.dsc_pg_control = dcn35_dsc_pg_control,	162	.dsc_pg_control = dcn35_dsc_pg_control,
163	.dsc_pg_status = dcn32_dsc_pg_status,	163	.dsc_pg_status = dcn32_dsc_pg_status,
164	.enable_plane = dcn35_enable_plane,	164	.enable_plane = dcn35_enable_plane,

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c+2−0

@@ -164,6 +164,8 @@ static void sumo_construct_vid_mapping_table(struct amdgpu_device *adev, · 163 unmodified lines
164		164
165	for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS; i++) {	165	for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS; i++) {
166	if (table[i].ulSupportedSCLK != 0) {	166	if (table[i].ulSupportedSCLK != 0) {
		167	if (table[i].usVoltageIndex >= SUMO_MAX_NUMBER_VOLTAGES)
		168	continue;
167	vid_mapping_table->entries[table[i].usVoltageIndex].vid_7bit =	169	vid_mapping_table->entries[table[i].usVoltageIndex].vid_7bit =
168	table[i].usVoltageID;	170	table[i].usVoltageID;
169	vid_mapping_table->entries[table[i].usVoltageIndex].vid_2bit =	171	vid_mapping_table->entries[table[i].usVoltageIndex].vid_2bit =

drivers/gpu/drm/i915/display/intel_dp.c+4−0

 	struct intel_encoder *encoder = &intel_dig_port->base;
 	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
+	/* eDP MSO is not compatible with joiner */
+	if (intel_dp->mso_link_count)
+		return false;
 	return DISPLAY_VER(dev_priv) >= 12 ||
 		(DISPLAY_VER(dev_priv) == 11 &&
 		 encoder->port != PORT_A);

drivers/gpu/drm/radeon/sumo_dpm.c+2−0

@@ -1619,6 +1619,8 @@ void sumo_construct_vid_mapping_table(struct radeon_device *rdev, · 1618 unmodified lines
1619		1619
1620	for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS; i++) {	1620	for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS; i++) {
1621	if (table[i].ulSupportedSCLK != 0) {	1621	if (table[i].ulSupportedSCLK != 0) {
		1622	if (table[i].usVoltageIndex >= SUMO_MAX_NUMBER_VOLTAGES)
		1623	continue;
1622	vid_mapping_table->entries[table[i].usVoltageIndex].vid_7bit =	1624	vid_mapping_table->entries[table[i].usVoltageIndex].vid_7bit =
1623	table[i].usVoltageID;	1625	table[i].usVoltageID;
1624	vid_mapping_table->entries[table[i].usVoltageIndex].vid_2bit =	1626	vid_mapping_table->entries[table[i].usVoltageIndex].vid_2bit =

drivers/gpu/drm/vmwgfx/Kconfig+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	config DRM_VMWGFX	2	config DRM_VMWGFX
3	tristate "DRM driver for VMware Virtual GPU"	3	tristate "DRM driver for VMware Virtual GPU"
4	depends on DRM && PCI && MMU	4	depends on DRM && PCI && MMU
5	depends on X86 \|\| ARM64	5	depends on (X86 && HYPERVISOR_GUEST) \|\| ARM64
6	select DRM_TTM	6	select DRM_TTM
7	select DRM_TTM_HELPER	7	select DRM_TTM_HELPER
8	select MAPPING_DIRTY_HELPERS	8	select MAPPING_DIRTY_HELPERS

drivers/gpu/drm/xe/xe_guc.c+2−2

 	struct xe_device *xe = guc_to_xe(guc);
 	int err;
-	guc_enable_irq(guc);
 	if (IS_SRIOV_VF(xe) && xe_device_has_memirq(xe)) {
 		struct xe_gt *gt = guc_to_gt(guc);
 		struct xe_tile *tile = gt_to_tile(gt);
 		err = xe_memirq_init_guc(&tile->sriov.vf.memirq, guc);
 		if (err)
 			return err;
+	} else {
+		guc_enable_irq(guc);
 	}
 	xe_mmio_rmw32(guc_to_gt(guc), PMINTRMSK,

drivers/hv/hv.c+18−19

@@ -45,8 +45,8 @@ int hv_init(void) · 44 unmodified lines
45	* This involves a hypercall.	45	* This involves a hypercall.
46	*/	46	*/
47	int hv_post_message(union hv_connection_id connection_id,	47	int hv_post_message(union hv_connection_id connection_id,
48	enum hv_message_type message_type,	48	enum hv_message_type message_type,
49	void *payload, size_t payload_size)	49	void *payload, size_t payload_size)
50	{	50	{
51	struct hv_input_post_message *aligned_msg;	51	struct hv_input_post_message *aligned_msg;
52	unsigned long flags;	52	unsigned long flags;
@@ -86,7 +86,7 @@ int hv_post_message(union hv_connection_id connection_id, · 33 unmodified lines
86	status = HV_STATUS_INVALID_PARAMETER;	86	status = HV_STATUS_INVALID_PARAMETER;
87	} else {	87	} else {
88	status = hv_do_hypercall(HVCALL_POST_MESSAGE,	88	status = hv_do_hypercall(HVCALL_POST_MESSAGE,
89	aligned_msg, NULL);	89	aligned_msg, NULL);
90	}	90	}
91		91
92	local_irq_restore(flags);	92	local_irq_restore(flags);
@@ -111,7 +111,7 @@ int hv_synic_alloc(void) · 18 unmodified lines
111		111
112	hv_context.hv_numa_map = kcalloc(nr_node_ids, sizeof(struct cpumask),	112	hv_context.hv_numa_map = kcalloc(nr_node_ids, sizeof(struct cpumask),
113	GFP_KERNEL);	113	GFP_KERNEL);
114	if (hv_context.hv_numa_map == NULL) {	114	if (!hv_context.hv_numa_map) {
115	pr_err("Unable to allocate NUMA map\n");	115	pr_err("Unable to allocate NUMA map\n");
116	goto err;	116	goto err;
117	}	117	}
@@ -120,11 +120,11 @@ int hv_synic_alloc(void) · 2 unmodified lines
120	hv_cpu = per_cpu_ptr(hv_context.cpu_context, cpu);	120	hv_cpu = per_cpu_ptr(hv_context.cpu_context, cpu);
121		121
122	tasklet_init(&hv_cpu->msg_dpc,	122	tasklet_init(&hv_cpu->msg_dpc,
123	vmbus_on_msg_dpc, (unsigned long) hv_cpu);	123	vmbus_on_msg_dpc, (unsigned long)hv_cpu);
124		124
125	if (ms_hyperv.paravisor_present && hv_isolation_type_tdx()) {	125	if (ms_hyperv.paravisor_present && hv_isolation_type_tdx()) {
126	hv_cpu->post_msg_page = (void *)get_zeroed_page(GFP_ATOMIC);	126	hv_cpu->post_msg_page = (void *)get_zeroed_page(GFP_ATOMIC);
127	if (hv_cpu->post_msg_page == NULL) {	127	if (!hv_cpu->post_msg_page) {
128	pr_err("Unable to allocate post msg page\n");	128	pr_err("Unable to allocate post msg page\n");
129	goto err;	129	goto err;
130	}	130	}
@@ -147,14 +147,14 @@ int hv_synic_alloc(void) · 16 unmodified lines
147	if (!ms_hyperv.paravisor_present && !hv_root_partition) {	147	if (!ms_hyperv.paravisor_present && !hv_root_partition) {
148	hv_cpu->synic_message_page =	148	hv_cpu->synic_message_page =
149	(void *)get_zeroed_page(GFP_ATOMIC);	149	(void *)get_zeroed_page(GFP_ATOMIC);
150	if (hv_cpu->synic_message_page == NULL) {	150	if (!hv_cpu->synic_message_page) {
151	pr_err("Unable to allocate SYNIC message page\n");	151	pr_err("Unable to allocate SYNIC message page\n");
152	goto err;	152	goto err;
153	}	153	}
154		154
155	hv_cpu->synic_event_page =	155	hv_cpu->synic_event_page =
156	(void *)get_zeroed_page(GFP_ATOMIC);	156	(void *)get_zeroed_page(GFP_ATOMIC);
157	if (hv_cpu->synic_event_page == NULL) {	157	if (!hv_cpu->synic_event_page) {
158	pr_err("Unable to allocate SYNIC event page\n");	158	pr_err("Unable to allocate SYNIC event page\n");
159		159
160	free_page((unsigned long)hv_cpu->synic_message_page);	160	free_page((unsigned long)hv_cpu->synic_message_page);
@@ -203,14 +203,13 @@ err: · 42 unmodified lines
203	return ret;	203	return ret;
204	}	204	}
205		205
206
207	void hv_synic_free(void)	206	void hv_synic_free(void)
208	{	207	{
209	int cpu, ret;	208	int cpu, ret;
210		209
211	for_each_present_cpu(cpu) {	210	for_each_present_cpu(cpu) {
212	struct hv_per_cpu_context *hv_cpu	211	struct hv_per_cpu_context *hv_cpu =
213	= per_cpu_ptr(hv_context.cpu_context, cpu);	212	per_cpu_ptr(hv_context.cpu_context, cpu);
214		213
215	/* It's better to leak the page if the encryption fails. */	214	/* It's better to leak the page if the encryption fails. */
216	if (ms_hyperv.paravisor_present && hv_isolation_type_tdx()) {	215	if (ms_hyperv.paravisor_present && hv_isolation_type_tdx()) {
@@ -262,8 +261,8 @@ void hv_synic_free(void) · 45 unmodified lines
262	*/	261	*/
263	void hv_synic_enable_regs(unsigned int cpu)	262	void hv_synic_enable_regs(unsigned int cpu)
264	{	263	{
265	struct hv_per_cpu_context *hv_cpu	264	struct hv_per_cpu_context *hv_cpu =
266	= per_cpu_ptr(hv_context.cpu_context, cpu);	265	per_cpu_ptr(hv_context.cpu_context, cpu);
267	union hv_synic_simp simp;	266	union hv_synic_simp simp;
268	union hv_synic_siefp siefp;	267	union hv_synic_siefp siefp;
269	union hv_synic_sint shared_sint;	268	union hv_synic_sint shared_sint;
@@ -277,8 +276,8 @@ void hv_synic_enable_regs(unsigned int cpu) · 7 unmodified lines
277	/* Mask out vTOM bit. ioremap_cache() maps decrypted */	276	/* Mask out vTOM bit. ioremap_cache() maps decrypted */
278	u64 base = (simp.base_simp_gpa << HV_HYP_PAGE_SHIFT) &	277	u64 base = (simp.base_simp_gpa << HV_HYP_PAGE_SHIFT) &
279	~ms_hyperv.shared_gpa_boundary;	278	~ms_hyperv.shared_gpa_boundary;
280	hv_cpu->synic_message_page	279	hv_cpu->synic_message_page =
281	= (void *)ioremap_cache(base, HV_HYP_PAGE_SIZE);	280	(void *)ioremap_cache(base, HV_HYP_PAGE_SIZE);
282	if (!hv_cpu->synic_message_page)	281	if (!hv_cpu->synic_message_page)
283	pr_err("Fail to map synic message page.\n");	282	pr_err("Fail to map synic message page.\n");
284	} else {	283	} else {
@@ -296,8 +295,8 @@ void hv_synic_enable_regs(unsigned int cpu) · 11 unmodified lines
296	/* Mask out vTOM bit. ioremap_cache() maps decrypted */	295	/* Mask out vTOM bit. ioremap_cache() maps decrypted */
297	u64 base = (siefp.base_siefp_gpa << HV_HYP_PAGE_SHIFT) &	296	u64 base = (siefp.base_siefp_gpa << HV_HYP_PAGE_SHIFT) &
298	~ms_hyperv.shared_gpa_boundary;	297	~ms_hyperv.shared_gpa_boundary;
299	hv_cpu->synic_event_page	298	hv_cpu->synic_event_page =
300	= (void *)ioremap_cache(base, HV_HYP_PAGE_SIZE);	299	(void *)ioremap_cache(base, HV_HYP_PAGE_SIZE);
301	if (!hv_cpu->synic_event_page)	300	if (!hv_cpu->synic_event_page)
302	pr_err("Fail to map synic event page.\n");	301	pr_err("Fail to map synic event page.\n");
303	} else {	302	} else {
@@ -348,8 +347,8 @@ int hv_synic_init(unsigned int cpu) · 44 unmodified lines
348	*/	347	*/
349	void hv_synic_disable_regs(unsigned int cpu)	348	void hv_synic_disable_regs(unsigned int cpu)
350	{	349	{
351	struct hv_per_cpu_context *hv_cpu	350	struct hv_per_cpu_context *hv_cpu =
352	= per_cpu_ptr(hv_context.cpu_context, cpu);	351	per_cpu_ptr(hv_context.cpu_context, cpu);
353	union hv_synic_sint shared_sint;	352	union hv_synic_sint shared_sint;
354	union hv_synic_simp simp;	353	union hv_synic_simp simp;
355	union hv_synic_siefp siefp;	354	union hv_synic_siefp siefp;

drivers/hv/hv_balloon.c+80−110

@@ -25,6 +25,7 @@ · 24 unmodified lines
25	#include <linux/notifier.h>	25	#include <linux/notifier.h>
26	#include <linux/percpu_counter.h>	26	#include <linux/percpu_counter.h>
27	#include <linux/page_reporting.h>	27	#include <linux/page_reporting.h>
		28	#include <linux/sizes.h>
28		29
29	#include <linux/hyperv.h>	30	#include <linux/hyperv.h>
30	#include <asm/hyperv-tlfs.h>	31	#include <asm/hyperv-tlfs.h>
@@ -41,8 +42,6 @@ · 10 unmodified lines
41	* Begin protocol definitions.	42	* Begin protocol definitions.
42	*/	43	*/
43		44
44
45
46	/*	45	/*
47	* Protocol versions. The low word is the minor version, the high word the major	46	* Protocol versions. The low word is the minor version, the high word the major
48	* version.	47	* version.
@@ -71,8 +70,6 @@ enum { · 22 unmodified lines
71	DYNMEM_PROTOCOL_VERSION_CURRENT = DYNMEM_PROTOCOL_VERSION_WIN10	70	DYNMEM_PROTOCOL_VERSION_CURRENT = DYNMEM_PROTOCOL_VERSION_WIN10
72	};	71	};
73		72
74
75
76	/*	73	/*
77	* Message Types	74	* Message Types
78	*/	75	*/
@@ -101,7 +98,6 @@ enum dm_message_type { · 22 unmodified lines
101	DM_VERSION_1_MAX = 12	98	DM_VERSION_1_MAX = 12
102	};	99	};
103		100
104
105	/*	101	/*
106	* Structures defining the dynamic memory management	102	* Structures defining the dynamic memory management
107	* protocol.	103	* protocol.
@@ -115,7 +111,6 @@ union dm_version { · 7 unmodified lines
115	__u32 version;	111	__u32 version;
116	} __packed;	112	} __packed;
117		113
118
119	union dm_caps {	114	union dm_caps {
120	struct {	115	struct {
121	__u64 balloon:1;	116	__u64 balloon:1;
@@ -148,8 +143,6 @@ union dm_mem_page_range { · 26 unmodified lines
148	__u64 page_range;	143	__u64 page_range;
149	} __packed;	144	} __packed;
150		145
151
152
153	/*	146	/*
154	* The header for all dynamic memory messages:	147	* The header for all dynamic memory messages:
155	*	148	*
@@ -174,7 +167,6 @@ struct dm_message { · 18 unmodified lines
174	__u8 data[]; /* enclosed message */	167	__u8 data[]; /* enclosed message */
175	} __packed;	168	} __packed;
176		169
177
178	/*	170	/*
179	* Specific message types supporting the dynamic memory protocol.	171	* Specific message types supporting the dynamic memory protocol.
180	*/	172	*/
@@ -271,7 +263,6 @@ struct dm_status { · 90 unmodified lines
271	__u32 io_diff;	263	__u32 io_diff;
272	} __packed;	264	} __packed;
273		265
274
275	/*	266	/*
276	* Message to ask the guest to allocate memory - balloon up message.	267	* Message to ask the guest to allocate memory - balloon up message.
277	* This message is sent from the host to the guest. The guest may not be	268	* This message is sent from the host to the guest. The guest may not be
@@ -286,14 +277,13 @@ struct dm_balloon { · 8 unmodified lines
286	__u32 reservedz;	277	__u32 reservedz;
287	} __packed;	278	} __packed;
288		279
289
290	/*	280	/*
291	* Balloon response message; this message is sent from the guest	281	* Balloon response message; this message is sent from the guest
292	* to the host in response to the balloon message.	282	* to the host in response to the balloon message.
293	*	283	*
294	* reservedz: Reserved; must be set to zero.	284	* reservedz: Reserved; must be set to zero.
295	* more_pages: If FALSE, this is the last message of the transaction.	285	* more_pages: If FALSE, this is the last message of the transaction.
296	* if TRUE there will atleast one more message from the guest.	286	* if TRUE there will be at least one more message from the guest.
297	*	287	*
298	* range_count: The number of ranges in the range array.	288	* range_count: The number of ranges in the range array.
299	*	289	*
@@ -314,7 +304,7 @@ struct dm_balloon_response { · 14 unmodified lines
314	* to the guest to give guest more memory.	304	* to the guest to give guest more memory.
315	*	305	*
316	* more_pages: If FALSE, this is the last message of the transaction.	306	* more_pages: If FALSE, this is the last message of the transaction.
317	* if TRUE there will atleast one more message from the guest.	307	* if TRUE there will be at least one more message from the guest.
318	*	308	*
319	* reservedz: Reserved; must be set to zero.	309	* reservedz: Reserved; must be set to zero.
320	*	310	*
@@ -342,7 +332,6 @@ struct dm_unballoon_response { · 21 unmodified lines
342	struct dm_header hdr;	332	struct dm_header hdr;
343	} __packed;	333	} __packed;
344		334
345
346	/*	335	/*
347	* Hot add request message. Message sent from the host to the guest.	336	* Hot add request message. Message sent from the host to the guest.
348	*	337	*
@@ -390,7 +379,6 @@ enum dm_info_type { · 41 unmodified lines
390	MAX_INFO_TYPE	379	MAX_INFO_TYPE
391	};	380	};
392		381
393
394	/*	382	/*
395	* Header for the information message.	383	* Header for the information message.
396	*/	384	*/
@@ -425,11 +413,11 @@ struct dm_info_msg { · 28 unmodified lines
425	* The range start_pfn : end_pfn specifies the range	413	* The range start_pfn : end_pfn specifies the range
426	* that the host has asked us to hot add. The range	414	* that the host has asked us to hot add. The range
427	* start_pfn : ha_end_pfn specifies the range that we have	415	* start_pfn : ha_end_pfn specifies the range that we have
428	* currently hot added. We hot add in multiples of 128M	416	* currently hot added. We hot add in chunks equal to the
429	* chunks; it is possible that we may not be able to bring	417	* memory block size; it is possible that we may not be able
430	* online all the pages in the region. The range	418	* to bring online all the pages in the region. The range
431	* covered_start_pfn:covered_end_pfn defines the pages that can	419	* covered_start_pfn:covered_end_pfn defines the pages that can
432	* be brough online.	420	* be brought online.
433	*/	421	*/
434		422
435	struct hv_hotadd_state {	423	struct hv_hotadd_state {
@@ -480,10 +468,10 @@ static unsigned long last_post_time; · 44 unmodified lines
480		468
481	static int hv_hypercall_multi_failure;	469	static int hv_hypercall_multi_failure;
482		470
483	module_param(hot_add, bool, (S_IRUGO \| S_IWUSR));	471	module_param(hot_add, bool, 0644);
484	MODULE_PARM_DESC(hot_add, "If set attempt memory hot_add");	472	MODULE_PARM_DESC(hot_add, "If set attempt memory hot_add");
485		473
486	module_param(pressure_report_delay, uint, (S_IRUGO \| S_IWUSR));	474	module_param(pressure_report_delay, uint, 0644);
487	MODULE_PARM_DESC(pressure_report_delay, "Delay in secs in reporting pressure");	475	MODULE_PARM_DESC(pressure_report_delay, "Delay in secs in reporting pressure");
488	static atomic_t trans_id = ATOMIC_INIT(0);	476	static atomic_t trans_id = ATOMIC_INIT(0);
489		477
@@ -502,11 +490,13 @@ enum hv_dm_state { · 12 unmodified lines
502	DM_INIT_ERROR	490	DM_INIT_ERROR
503	};	491	};
504		492
505
506	static __u8 recv_buffer[HV_HYP_PAGE_SIZE];	493	static __u8 recv_buffer[HV_HYP_PAGE_SIZE];
507	static __u8 balloon_up_send_buffer[HV_HYP_PAGE_SIZE];	494	static __u8 balloon_up_send_buffer[HV_HYP_PAGE_SIZE];
		495
		496	static unsigned long ha_pages_in_chunk;
		497	#define HA_BYTES_IN_CHUNK (ha_pages_in_chunk << PAGE_SHIFT)
		498
508	#define PAGES_IN_2M (2 * 1024 * 1024 / PAGE_SIZE)	499	#define PAGES_IN_2M (2 * 1024 * 1024 / PAGE_SIZE)
509	#define HA_CHUNK (128 * 1024 * 1024 / PAGE_SIZE)
510		500
511	struct hv_dynmem_device {	501	struct hv_dynmem_device {
512	struct hv_device *dev;	502	struct hv_device *dev;
@@ -595,12 +585,12 @@ static inline bool has_pfn_is_backed(struct hv_hotadd_state *has, · 82 unmodified lines
595	struct hv_hotadd_gap *gap;	585	struct hv_hotadd_gap *gap;
596		586
597	/* The page is not backed. */	587	/* The page is not backed. */
598	if ((pfn < has->covered_start_pfn) \|\| (pfn >= has->covered_end_pfn))	588	if (pfn < has->covered_start_pfn \|\| pfn >= has->covered_end_pfn)
599	return false;	589	return false;
600		590
601	/* Check for gaps. */	591	/* Check for gaps. */
602	list_for_each_entry(gap, &has->gap_list, list) {	592	list_for_each_entry(gap, &has->gap_list, list) {
603	if ((pfn >= gap->start_pfn) && (pfn < gap->end_pfn))	593	if (pfn >= gap->start_pfn && pfn < gap->end_pfn)
604	return false;	594	return false;
605	}	595	}
606		596
@@ -724,28 +714,21 @@ static void hv_mem_hot_add(unsigned long start, unsigned long size, · 117 unmodified lines
724	unsigned long processed_pfn;	714	unsigned long processed_pfn;
725	unsigned long total_pfn = pfn_count;	715	unsigned long total_pfn = pfn_count;
726		716
727	for (i = 0; i < (size/HA_CHUNK); i++) {	717	for (i = 0; i < (size/ha_pages_in_chunk); i++) {
728	start_pfn = start + (i * HA_CHUNK);	718	start_pfn = start + (i * ha_pages_in_chunk);
729		719
730	scoped_guard(spinlock_irqsave, &dm_device.ha_lock) {	720	scoped_guard(spinlock_irqsave, &dm_device.ha_lock) {
731	has->ha_end_pfn += HA_CHUNK;	721	has->ha_end_pfn += ha_pages_in_chunk;
732		722	processed_pfn = umin(total_pfn, ha_pages_in_chunk);
733	if (total_pfn > HA_CHUNK) {	723	total_pfn -= processed_pfn;
734	processed_pfn = HA_CHUNK;	724	has->covered_end_pfn += processed_pfn;
735	total_pfn -= HA_CHUNK;
736	} else {
737	processed_pfn = total_pfn;
738	total_pfn = 0;
739	}
740
741	has->covered_end_pfn += processed_pfn;
742	}	725	}
743		726
744	reinit_completion(&dm_device.ol_waitevent);	727	reinit_completion(&dm_device.ol_waitevent);
745		728
746	nid = memory_add_physaddr_to_nid(PFN_PHYS(start_pfn));	729	nid = memory_add_physaddr_to_nid(PFN_PHYS(start_pfn));
747	ret = add_memory(nid, PFN_PHYS((start_pfn)),	730	ret = add_memory(nid, PFN_PHYS((start_pfn)),
748	(HA_CHUNK << PAGE_SHIFT), MHP_MERGE_RESOURCE);	731	HA_BYTES_IN_CHUNK, MHP_MERGE_RESOURCE);
749		732
750	if (ret) {	733	if (ret) {
751	pr_err("hot_add memory failed error is %d\n", ret);	734	pr_err("hot_add memory failed error is %d\n", ret);
@@ -760,7 +743,7 @@ static void hv_mem_hot_add(unsigned long start, unsigned long size, · 8 unmodified lines
760	do_hot_add = false;	743	do_hot_add = false;
761	}	744	}
762	scoped_guard(spinlock_irqsave, &dm_device.ha_lock) {	745	scoped_guard(spinlock_irqsave, &dm_device.ha_lock) {
763	has->ha_end_pfn -= HA_CHUNK;	746	has->ha_end_pfn -= ha_pages_in_chunk;
764	has->covered_end_pfn -= processed_pfn;	747	has->covered_end_pfn -= processed_pfn;
765	}	748	}
766	break;	749	break;
@@ -787,8 +770,8 @@ static void hv_online_page(struct page *pg, unsigned int order) · 20 unmodified lines
787	guard(spinlock_irqsave)(&dm_device.ha_lock);	770	guard(spinlock_irqsave)(&dm_device.ha_lock);
788	list_for_each_entry(has, &dm_device.ha_region_list, list) {	771	list_for_each_entry(has, &dm_device.ha_region_list, list) {
789	/* The page belongs to a different HAS. */	772	/* The page belongs to a different HAS. */
790	if ((pfn < has->start_pfn) \|\|	773	if (pfn < has->start_pfn \|\|
791	(pfn + (1UL << order) > has->end_pfn))	774	(pfn + (1UL << order) > has->end_pfn))
792	continue;	775	continue;
793		776
794	hv_bring_pgs_online(has, pfn, 1UL << order);	777	hv_bring_pgs_online(has, pfn, 1UL << order);
@@ -800,7 +783,7 @@ static int pfn_covered(unsigned long start_pfn, unsigned long pfn_cnt) · 5 unmodified lines
800	{	783	{
801	struct hv_hotadd_state *has;	784	struct hv_hotadd_state *has;
802	struct hv_hotadd_gap *gap;	785	struct hv_hotadd_gap *gap;
803	unsigned long residual, new_inc;	786	unsigned long residual;
804	int ret = 0;	787	int ret = 0;
805		788
806	guard(spinlock_irqsave)(&dm_device.ha_lock);	789	guard(spinlock_irqsave)(&dm_device.ha_lock);
@@ -836,15 +819,9 @@ static int pfn_covered(unsigned long start_pfn, unsigned long pfn_cnt) · 29 unmodified lines
836	* our current limit; extend it.	819	* our current limit; extend it.
837	*/	820	*/
838	if ((start_pfn + pfn_cnt) > has->end_pfn) {	821	if ((start_pfn + pfn_cnt) > has->end_pfn) {
		822	/* Extend the region by multiples of ha_pages_in_chunk */
839	residual = (start_pfn + pfn_cnt - has->end_pfn);	823	residual = (start_pfn + pfn_cnt - has->end_pfn);
840	/*	824	has->end_pfn += ALIGN(residual, ha_pages_in_chunk);
841	* Extend the region by multiples of HA_CHUNK.
842	*/
843	new_inc = (residual / HA_CHUNK) * HA_CHUNK;
844	if (residual % HA_CHUNK)
845	new_inc += HA_CHUNK;
846
847	has->end_pfn += new_inc;
848	}	825	}
849		826
850	ret = 1;	827	ret = 1;
@@ -855,7 +832,7 @@ static int pfn_covered(unsigned long start_pfn, unsigned long pfn_cnt) · 4 unmodified lines
855	}	832	}
856		833
857	static unsigned long handle_pg_range(unsigned long pg_start,	834	static unsigned long handle_pg_range(unsigned long pg_start,
858	unsigned long pg_count)	835	unsigned long pg_count)
859	{	836	{
860	unsigned long start_pfn = pg_start;	837	unsigned long start_pfn = pg_start;
861	unsigned long pfn_cnt = pg_count;	838	unsigned long pfn_cnt = pg_count;
@@ -866,7 +843,7 @@ static unsigned long handle_pg_range(unsigned long pg_start, · 4 unmodified lines
866	unsigned long res = 0, flags;	843	unsigned long res = 0, flags;
867		844
868	pr_debug("Hot adding %lu pages starting at pfn 0x%lx.\n", pg_count,	845	pr_debug("Hot adding %lu pages starting at pfn 0x%lx.\n", pg_count,
869	pg_start);	846	pg_start);
870		847
871	spin_lock_irqsave(&dm_device.ha_lock, flags);	848	spin_lock_irqsave(&dm_device.ha_lock, flags);
872	list_for_each_entry(has, &dm_device.ha_region_list, list) {	849	list_for_each_entry(has, &dm_device.ha_region_list, list) {
@@ -902,22 +879,19 @@ static unsigned long handle_pg_range(unsigned long pg_start, · 29 unmodified lines
902	if (start_pfn > has->start_pfn &&	879	if (start_pfn > has->start_pfn &&
903	online_section_nr(pfn_to_section_nr(start_pfn)))	880	online_section_nr(pfn_to_section_nr(start_pfn)))
904	hv_bring_pgs_online(has, start_pfn, pgs_ol);	881	hv_bring_pgs_online(has, start_pfn, pgs_ol);
905
906	}	882	}
907		883
908	if ((has->ha_end_pfn < has->end_pfn) && (pfn_cnt > 0)) {	884	if (has->ha_end_pfn < has->end_pfn && pfn_cnt > 0) {
909	/*	885	/*
910	* We have some residual hot add range	886	* We have some residual hot add range
911	* that needs to be hot added; hot add	887	* that needs to be hot added; hot add
912	* it now. Hot add a multiple of	888	* it now. Hot add a multiple of
913	* HA_CHUNK that fully covers the pages	889	* ha_pages_in_chunk that fully covers the pages
914	* we have.	890	* we have.
915	*/	891	*/
916	size = (has->end_pfn - has->ha_end_pfn);	892	size = (has->end_pfn - has->ha_end_pfn);
917	if (pfn_cnt <= size) {	893	if (pfn_cnt <= size) {
918	size = ((pfn_cnt / HA_CHUNK) * HA_CHUNK);	894	size = ALIGN(pfn_cnt, ha_pages_in_chunk);
919	if (pfn_cnt % HA_CHUNK)
920	size += HA_CHUNK;
921	} else {	895	} else {
922	pfn_cnt = size;	896	pfn_cnt = size;
923	}	897	}
@@ -1010,10 +984,7 @@ static void hot_add_req(struct work_struct *dummy) · 86 unmodified lines
1010	rg_start = dm->ha_wrk.ha_region_range.finfo.start_page;	984	rg_start = dm->ha_wrk.ha_region_range.finfo.start_page;
1011	rg_sz = dm->ha_wrk.ha_region_range.finfo.page_cnt;	985	rg_sz = dm->ha_wrk.ha_region_range.finfo.page_cnt;
1012		986
1013	if ((rg_start == 0) && (!dm->host_specified_ha_region)) {	987	if (rg_start == 0 && !dm->host_specified_ha_region) {
1014	unsigned long region_size;
1015	unsigned long region_start;
1016
1017	/*	988	/*
1018	* The host has not specified the hot-add region.	989	* The host has not specified the hot-add region.
1019	* Based on the hot-add page range being specified,	990	* Based on the hot-add page range being specified,
@@ -1021,19 +992,13 @@ static void hot_add_req(struct work_struct *dummy) · 1 unmodified line
1021	* that need to be hot-added while ensuring the alignment	992	* that need to be hot-added while ensuring the alignment
1022	* and size requirements of Linux as it relates to hot-add.	993	* and size requirements of Linux as it relates to hot-add.
1023	*/	994	*/
1024	region_size = (pfn_cnt / HA_CHUNK) * HA_CHUNK;	995	rg_start = ALIGN_DOWN(pg_start, ha_pages_in_chunk);
1025	if (pfn_cnt % HA_CHUNK)	996	rg_sz = ALIGN(pfn_cnt, ha_pages_in_chunk);
1026	region_size += HA_CHUNK;
1027
1028	region_start = (pg_start / HA_CHUNK) * HA_CHUNK;
1029
1030	rg_start = region_start;
1031	rg_sz = region_size;
1032	}	997	}
1033		998
1034	if (do_hot_add)	999	if (do_hot_add)
1035	resp.page_count = process_hot_add(pg_start, pfn_cnt,	1000	resp.page_count = process_hot_add(pg_start, pfn_cnt,
1036	rg_start, rg_sz);	1001	rg_start, rg_sz);
1037		1002
1038	dm->num_pages_added += resp.page_count;	1003	dm->num_pages_added += resp.page_count;
1039	#endif	1004	#endif
@@ -1211,11 +1176,10 @@ static void post_status(struct hv_dynmem_device *dm) · 171 unmodified lines
1211	sizeof(struct dm_status),	1176	sizeof(struct dm_status),
1212	(unsigned long)NULL,	1177	(unsigned long)NULL,
1213	VM_PKT_DATA_INBAND, 0);	1178	VM_PKT_DATA_INBAND, 0);
1214
1215	}	1179	}
1216		1180
1217	static void free_balloon_pages(struct hv_dynmem_device *dm,	1181	static void free_balloon_pages(struct hv_dynmem_device *dm,
1218	union dm_mem_page_range *range_array)	1182	union dm_mem_page_range *range_array)
1219	{	1183	{
1220	int num_pages = range_array->finfo.page_cnt;	1184	int num_pages = range_array->finfo.page_cnt;
1221	__u64 start_frame = range_array->finfo.start_page;	1185	__u64 start_frame = range_array->finfo.start_page;
@@ -1231,8 +1195,6 @@ static void free_balloon_pages(struct hv_dynmem_device *dm, · 9 unmodified lines
1231	}	1195	}
1232	}	1196	}
1233		1197
1234
1235
1236	static unsigned int alloc_balloon_pages(struct hv_dynmem_device *dm,	1198	static unsigned int alloc_balloon_pages(struct hv_dynmem_device *dm,
1237	unsigned int num_pages,	1199	unsigned int num_pages,
1238	struct dm_balloon_response *bl_resp,	1200	struct dm_balloon_response *bl_resp,
@@ -1278,7 +1240,6 @@ static unsigned int alloc_balloon_pages(struct hv_dynmem_device *dm, · 39 unmodified lines
1278	page_to_pfn(pg);	1240	page_to_pfn(pg);
1279	bl_resp->range_array[i].finfo.page_cnt = alloc_unit;	1241	bl_resp->range_array[i].finfo.page_cnt = alloc_unit;
1280	bl_resp->hdr.size += sizeof(union dm_mem_page_range);	1242	bl_resp->hdr.size += sizeof(union dm_mem_page_range);
1281
1282	}	1243	}
1283		1244
1284	return i * alloc_unit;	1245	return i * alloc_unit;
@@ -1332,7 +1293,7 @@ static void balloon_up(struct work_struct *dummy) · 47 unmodified lines
1332		1293
1333	if (num_ballooned == 0 \|\| num_ballooned == num_pages) {	1294	if (num_ballooned == 0 \|\| num_ballooned == num_pages) {
1334	pr_debug("Ballooned %u out of %u requested pages.\n",	1295	pr_debug("Ballooned %u out of %u requested pages.\n",
1335	num_pages, dm_device.balloon_wrk.num_pages);	1296	num_pages, dm_device.balloon_wrk.num_pages);
1336		1297
1337	bl_resp->more_pages = 0;	1298	bl_resp->more_pages = 0;
1338	done = true;	1299	done = true;
@@ -1366,16 +1327,15 @@ static void balloon_up(struct work_struct *dummy) · 27 unmodified lines
1366		1327
1367	for (i = 0; i < bl_resp->range_count; i++)	1328	for (i = 0; i < bl_resp->range_count; i++)
1368	free_balloon_pages(&dm_device,	1329	free_balloon_pages(&dm_device,
1369	&bl_resp->range_array[i]);	1330	&bl_resp->range_array[i]);
1370		1331
1371	done = true;	1332	done = true;
1372	}	1333	}
1373	}	1334	}
1374
1375	}	1335	}
1376		1336
1377	static void balloon_down(struct hv_dynmem_device *dm,	1337	static void balloon_down(struct hv_dynmem_device *dm,
1378	struct dm_unballoon_request *req)	1338	struct dm_unballoon_request *req)
1379	{	1339	{
1380	union dm_mem_page_range *range_array = req->range_array;	1340	union dm_mem_page_range *range_array = req->range_array;
1381	int range_count = req->range_count;	1341	int range_count = req->range_count;
@@ -1389,7 +1349,7 @@ static void balloon_down(struct hv_dynmem_device *dm, · 7 unmodified lines
1389	}	1349	}
1390		1350
1391	pr_debug("Freed %u ballooned pages.\n",	1351	pr_debug("Freed %u ballooned pages.\n",
1392	prev_pages_ballooned - dm->num_pages_ballooned);	1352	prev_pages_ballooned - dm->num_pages_ballooned);
1393		1353
1394	if (req->more_pages == 1)	1354	if (req->more_pages == 1)
1395	return;	1355	return;
@@ -1414,8 +1374,7 @@ static int dm_thread_func(void *dm_dev) · 18 unmodified lines
1414	struct hv_dynmem_device *dm = dm_dev;	1374	struct hv_dynmem_device *dm = dm_dev;
1415		1375
1416	while (!kthread_should_stop()) {	1376	while (!kthread_should_stop()) {
1417	wait_for_completion_interruptible_timeout(	1377	wait_for_completion_interruptible_timeout(&dm_device.config_event, 1 * HZ);
1418	&dm_device.config_event, 1*HZ);
1419	/*	1378	/*
1420	* The host expects us to post information on the memory	1379	* The host expects us to post information on the memory
1421	* pressure every second.	1380	* pressure every second.
@@ -1439,9 +1398,8 @@ static int dm_thread_func(void *dm_dev) · 17 unmodified lines
1439	return 0;	1398	return 0;
1440	}	1399	}
1441		1400
1442
1443	static void version_resp(struct hv_dynmem_device *dm,	1401	static void version_resp(struct hv_dynmem_device *dm,
1444	struct dm_version_response *vresp)	1402	struct dm_version_response *vresp)
1445	{	1403	{
1446	struct dm_version_request version_req;	1404	struct dm_version_request version_req;
1447	int ret;	1405	int ret;
@@ -1502,7 +1460,7 @@ version_error: · 54 unmodified lines
1502	}	1460	}
1503		1461
1504	static void cap_resp(struct hv_dynmem_device *dm,	1462	static void cap_resp(struct hv_dynmem_device *dm,
1505	struct dm_capabilities_resp_msg *cap_resp)	1463	struct dm_capabilities_resp_msg *cap_resp)
1506	{	1464	{
1507	if (!cap_resp->is_accepted) {	1465	if (!cap_resp->is_accepted) {
1508	pr_err("Capabilities not accepted by host\n");	1466	pr_err("Capabilities not accepted by host\n");
@@ -1535,7 +1493,7 @@ static void balloon_onchannelcallback(void *context) · 26 unmodified lines
1535	switch (dm_hdr->type) {	1493	switch (dm_hdr->type) {
1536	case DM_VERSION_RESPONSE:	1494	case DM_VERSION_RESPONSE:
1537	version_resp(dm,	1495	version_resp(dm,
1538	(struct dm_version_response *)dm_msg);	1496	(struct dm_version_response *)dm_msg);
1539	break;	1497	break;
1540		1498
1541	case DM_CAPABILITIES_RESPONSE:	1499	case DM_CAPABILITIES_RESPONSE:
@@ -1565,7 +1523,7 @@ static void balloon_onchannelcallback(void *context) · 23 unmodified lines
1565		1523
1566	dm->state = DM_BALLOON_DOWN;	1524	dm->state = DM_BALLOON_DOWN;
1567	balloon_down(dm,	1525	balloon_down(dm,
1568	(struct dm_unballoon_request *)recv_buffer);	1526	(struct dm_unballoon_request *)recv_buffer);
1569	break;	1527	break;
1570		1528
1571	case DM_MEM_HOT_ADD_REQUEST:	1529	case DM_MEM_HOT_ADD_REQUEST:
@@ -1603,17 +1561,15 @@ static void balloon_onchannelcallback(void *context) · 31 unmodified lines
1603		1561
1604	default:	1562	default:
1605	pr_warn_ratelimited("Unhandled message: type: %d\n", dm_hdr->type);	1563	pr_warn_ratelimited("Unhandled message: type: %d\n", dm_hdr->type);
1606
1607	}	1564	}
1608	}	1565	}
1609
1610	}	1566	}
1611		1567
1612	#define HV_LARGE_REPORTING_ORDER 9	1568	#define HV_LARGE_REPORTING_ORDER 9
1613	#define HV_LARGE_REPORTING_LEN (HV_HYP_PAGE_SIZE << \	1569	#define HV_LARGE_REPORTING_LEN (HV_HYP_PAGE_SIZE << \
1614	HV_LARGE_REPORTING_ORDER)	1570	HV_LARGE_REPORTING_ORDER)
1615	static int hv_free_page_report(struct page_reporting_dev_info *pr_dev_info,	1571	static int hv_free_page_report(struct page_reporting_dev_info *pr_dev_info,
1616	struct scatterlist *sgl, unsigned int nents)	1572	struct scatterlist *sgl, unsigned int nents)
1617	{	1573	{
1618	unsigned long flags;	1574	unsigned long flags;
1619	struct hv_memory_hint *hint;	1575	struct hv_memory_hint *hint;
@@ -1648,7 +1604,7 @@ static int hv_free_page_report(struct page_reporting_dev_info *pr_dev_info, · 28 unmodified lines
1648	*/	1604	*/
1649		1605
1650	/* page reporting for pages 2MB or higher */	1606	/* page reporting for pages 2MB or higher */
1651	if (order >= HV_LARGE_REPORTING_ORDER ) {	1607	if (order >= HV_LARGE_REPORTING_ORDER) {
1652	range->page.largepage = 1;	1608	range->page.largepage = 1;
1653	range->page_size = HV_GPA_PAGE_RANGE_PAGE_SIZE_2MB;	1609	range->page_size = HV_GPA_PAGE_RANGE_PAGE_SIZE_2MB;
1654	range->base_large_pfn = page_to_hvpfn(	1610	range->base_large_pfn = page_to_hvpfn(
@@ -1662,23 +1618,21 @@ static int hv_free_page_report(struct page_reporting_dev_info *pr_dev_info, · 7 unmodified lines
1662	range->page.additional_pages =	1618	range->page.additional_pages =
1663	(sg->length / HV_HYP_PAGE_SIZE) - 1;	1619	(sg->length / HV_HYP_PAGE_SIZE) - 1;
1664	}	1620	}
1665
1666	}	1621	}
1667		1622
1668	status = hv_do_rep_hypercall(HV_EXT_CALL_MEMORY_HEAT_HINT, nents, 0,	1623	status = hv_do_rep_hypercall(HV_EXT_CALL_MEMORY_HEAT_HINT, nents, 0,
1669	hint, NULL);	1624	hint, NULL);
1670	local_irq_restore(flags);	1625	local_irq_restore(flags);
1671	if (!hv_result_success(status)) {	1626	if (!hv_result_success(status)) {
1672
1673	pr_err("Cold memory discard hypercall failed with status %llx\n",	1627	pr_err("Cold memory discard hypercall failed with status %llx\n",
1674	status);	1628	status);
1675	if (hv_hypercall_multi_failure > 0)	1629	if (hv_hypercall_multi_failure > 0)
1676	hv_hypercall_multi_failure++;	1630	hv_hypercall_multi_failure++;
1677		1631
1678	if (hv_result(status) == HV_STATUS_INVALID_PARAMETER) {	1632	if (hv_result(status) == HV_STATUS_INVALID_PARAMETER) {
1679	pr_err("Underlying Hyper-V does not support order less than 9. Hypercall failed\n");	1633	pr_err("Underlying Hyper-V does not support order less than 9. Hypercall failed\n");
1680	pr_err("Defaulting to page_reporting_order %d\n",	1634	pr_err("Defaulting to page_reporting_order %d\n",
1681	pageblock_order);	1635	pageblock_order);
1682	page_reporting_order = pageblock_order;	1636	page_reporting_order = pageblock_order;
1683	hv_hypercall_multi_failure++;	1637	hv_hypercall_multi_failure++;
1684	return -EINVAL;	1638	return -EINVAL;
@@ -1712,7 +1666,7 @@ static void enable_page_reporting(void) · 27 unmodified lines
1712	pr_err("Failed to enable cold memory discard: %d\n", ret);	1666	pr_err("Failed to enable cold memory discard: %d\n", ret);
1713	} else {	1667	} else {
1714	pr_info("Cold memory discard hint enabled with order %d\n",	1668	pr_info("Cold memory discard hint enabled with order %d\n",
1715	page_reporting_order);	1669	page_reporting_order);
1716	}	1670	}
1717	}	1671	}
1718		1672
@@ -1795,7 +1749,7 @@ static int balloon_connect_vsp(struct hv_device *dev) · 76 unmodified lines
1795	if (ret)	1749	if (ret)
1796	goto out;	1750	goto out;
1797		1751
1798	t = wait_for_completion_timeout(&dm_device.host_event, 5*HZ);	1752	t = wait_for_completion_timeout(&dm_device.host_event, 5 * HZ);
1799	if (t == 0) {	1753	if (t == 0) {
1800	ret = -ETIMEDOUT;	1754	ret = -ETIMEDOUT;
1801	goto out;	1755	goto out;
@@ -1831,10 +1785,13 @@ static int balloon_connect_vsp(struct hv_device *dev) · 29 unmodified lines
1831	cap_msg.caps.cap_bits.hot_add = hot_add_enabled();	1785	cap_msg.caps.cap_bits.hot_add = hot_add_enabled();
1832		1786
1833	/*	1787	/*
1834	* Specify our alignment requirements as it relates	1788	* Specify our alignment requirements for memory hot-add. The value is
1835	* memory hot-add. Specify 128MB alignment.	1789	* the log base 2 of the number of megabytes in a chunk. For example,
		1790	* with 256 MiB chunks, the value is 8. The number of MiB in a chunk
		1791	* must be a power of 2.
1836	*/	1792	*/
1837	cap_msg.caps.cap_bits.hot_add_alignment = 7;	1793	cap_msg.caps.cap_bits.hot_add_alignment =
		1794	ilog2(HA_BYTES_IN_CHUNK / SZ_1M);
1838		1795
1839	/*	1796	/*
1840	* Currently the host does not use these	1797	* Currently the host does not use these
@@ -1850,7 +1807,7 @@ static int balloon_connect_vsp(struct hv_device *dev) · 9 unmodified lines
1850	if (ret)	1807	if (ret)
1851	goto out;	1808	goto out;
1852		1809
1853	t = wait_for_completion_timeout(&dm_device.host_event, 5*HZ);	1810	t = wait_for_completion_timeout(&dm_device.host_event, 5 * HZ);
1854	if (t == 0) {	1811	if (t == 0) {
1855	ret = -ETIMEDOUT;	1812	ret = -ETIMEDOUT;
1856	goto out;	1813	goto out;
@@ -1891,8 +1848,8 @@ static int hv_balloon_debug_show(struct seq_file f, void offset) · 34 unmodified lines
1891	char *sname;	1848	char *sname;
1892		1849
1893	seq_printf(f, "%-22s: %u.%u\n", "host_version",	1850	seq_printf(f, "%-22s: %u.%u\n", "host_version",
1894	DYNMEM_MAJOR_VERSION(dm->version),	1851	DYNMEM_MAJOR_VERSION(dm->version),
1895	DYNMEM_MINOR_VERSION(dm->version));	1852	DYNMEM_MINOR_VERSION(dm->version));
1896		1853
1897	seq_printf(f, "%-22s:", "capabilities");	1854	seq_printf(f, "%-22s:", "capabilities");
1898	if (ballooning_enabled())	1855	if (ballooning_enabled())
@@ -1941,10 +1898,10 @@ static int hv_balloon_debug_show(struct seq_file f, void offset) · 42 unmodified lines
1941	seq_printf(f, "%-22s: %u\n", "pages_ballooned", dm->num_pages_ballooned);	1898	seq_printf(f, "%-22s: %u\n", "pages_ballooned", dm->num_pages_ballooned);
1942		1899
1943	seq_printf(f, "%-22s: %lu\n", "total_pages_committed",	1900	seq_printf(f, "%-22s: %lu\n", "total_pages_committed",
1944	get_pages_committed(dm));	1901	get_pages_committed(dm));
1945		1902
1946	seq_printf(f, "%-22s: %llu\n", "max_dynamic_page_count",	1903	seq_printf(f, "%-22s: %llu\n", "max_dynamic_page_count",
1947	dm->max_dynamic_page_count);	1904	dm->max_dynamic_page_count);
1948		1905
1949	return 0;	1906	return 0;
1950	}	1907	}
@@ -1954,7 +1911,7 @@ DEFINE_SHOW_ATTRIBUTE(hv_balloon_debug); · 3 unmodified lines
1954	static void hv_balloon_debugfs_init(struct hv_dynmem_device *b)	1911	static void hv_balloon_debugfs_init(struct hv_dynmem_device *b)
1955	{	1912	{
1956	debugfs_create_file("hv-balloon", 0444, NULL, b,	1913	debugfs_create_file("hv-balloon", 0444, NULL, b,
1957	&hv_balloon_debug_fops);	1914	&hv_balloon_debug_fops);
1958	}	1915	}
1959		1916
1960	static void hv_balloon_debugfs_exit(struct hv_dynmem_device *b)	1917	static void hv_balloon_debugfs_exit(struct hv_dynmem_device *b)
@@ -1984,8 +1941,23 @@ static int balloon_probe(struct hv_device *dev, · 23 unmodified lines
1984	hot_add = false;	1941	hot_add = false;
1985		1942
1986	#ifdef CONFIG_MEMORY_HOTPLUG	1943	#ifdef CONFIG_MEMORY_HOTPLUG
		1944	/*
		1945	* Hot-add must operate in chunks that are of size equal to the
		1946	* memory block size because that's what the core add_memory()
		1947	* interface requires. The Hyper-V interface requires that the memory
		1948	* block size be a power of 2, which is guaranteed by the check in
		1949	* memory_dev_init().
		1950	*/
		1951	ha_pages_in_chunk = memory_block_size_bytes() / PAGE_SIZE;
1987	do_hot_add = hot_add;	1952	do_hot_add = hot_add;
1988	#else	1953	#else
		1954	/*
		1955	* Without MEMORY_HOTPLUG, the guest returns a failure status for all
		1956	* hot add requests from Hyper-V, and the chunk size is used only to
		1957	* specify alignment to Hyper-V as required by the host/guest protocol.
		1958	* Somewhat arbitrarily, use 128 MiB.
		1959	*/
		1960	ha_pages_in_chunk = SZ_128M / PAGE_SIZE;
1989	do_hot_add = false;	1961	do_hot_add = false;
1990	#endif	1962	#endif
1991	dm_device.dev = dev;	1963	dm_device.dev = dev;
@@ -2097,7 +2069,6 @@ static int balloon_suspend(struct hv_device *hv_dev) · 105 unmodified lines
2097	tasklet_enable(&hv_dev->channel->callback_event);	2069	tasklet_enable(&hv_dev->channel->callback_event);
2098		2070
2099	return 0;	2071	return 0;
2100
2101	}	2072	}
2102		2073
2103	static int balloon_resume(struct hv_device *dev)	2074	static int balloon_resume(struct hv_device *dev)
@@ -2156,7 +2127,6 @@ static struct hv_driver balloon_drv = { · 52 unmodified lines
2156		2127
2157	static int __init init_balloon_drv(void)	2128	static int __init init_balloon_drv(void)
2158	{	2129	{
2159
2160	return vmbus_driver_register(&balloon_drv);	2130	return vmbus_driver_register(&balloon_drv);
2161	}	2131	}
2162		2132

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

@@ -431,8 +431,8 @@ static int ocores_init(struct device dev, struct ocores_i2c i2c) · 430 unmodified lines
431	oc_setreg(i2c, OCI2C_PREHIGH, prescale >> 8);	431	oc_setreg(i2c, OCI2C_PREHIGH, prescale >> 8);
432		432
433	/* Init the device */	433	/* Init the device */
434	oc_setreg(i2c, OCI2C_CMD, OCI2C_CMD_IACK);
435	oc_setreg(i2c, OCI2C_CONTROL, ctrl \| OCI2C_CTRL_EN);	434	oc_setreg(i2c, OCI2C_CONTROL, ctrl \| OCI2C_CTRL_EN);
		435	oc_setreg(i2c, OCI2C_CMD, OCI2C_CMD_IACK);
436		436
437	return 0;	437	return 0;
438	}	438	}

drivers/infiniband/hw/bnxt_re/bnxt_re.h+1−3

 	struct	bnxt_re_sqp_entries *sqp_tbl;
 };
-#define BNXT_RE_MIN_MSIX		2
-#define BNXT_RE_MAX_MSIX		9
 #define BNXT_RE_AEQ_IDX			0
 #define BNXT_RE_NQ_IDX			1
 #define BNXT_RE_GEN_P5_MAX_VF		64
 	struct bnxt_qplib_rcfw		rcfw;
 	/* NQ */
-	struct bnxt_qplib_nq		nq[BNXT_RE_MAX_MSIX];
+	struct bnxt_qplib_nq		nq[BNXT_MAX_ROCE_MSIX];
 	/* Device Resources */
 	struct bnxt_qplib_dev_attr	dev_attr;

drivers/infiniband/hw/mana/mr.c+1−0

@@ -112,6 +112,7 @@ struct ib_mr mana_ib_reg_user_mr(struct ib_pd ibpd, u64 start, u64 length, · 111 unmodified lines
112	"start 0x%llx, iova 0x%llx length 0x%llx access_flags 0x%x",	112	"start 0x%llx, iova 0x%llx length 0x%llx access_flags 0x%x",
113	start, iova, length, access_flags);	113	start, iova, length, access_flags);
114		114
		115	access_flags &= ~IB_ACCESS_OPTIONAL;
115	if (access_flags & ~VALID_MR_FLAGS)	116	if (access_flags & ~VALID_MR_FLAGS)
116	return ERR_PTR(-EINVAL);	117	return ERR_PTR(-EINVAL);
117		118

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

 	spin_lock_init(&dev->dm.lock);
 	dev->dm.dev = mdev;
 	return 0;
-err:
-	mlx5r_macsec_dealloc_gids(dev);
 err_mp:
 	mlx5_ib_cleanup_multiport_master(dev);
+err:
+	mlx5r_macsec_dealloc_gids(dev);
 	return err;
 }

drivers/infiniband/hw/mlx5/mr.c+4−4

 	MLX5_SET(mkc, mkc, access_mode_1_0, ent->rb_key.access_mode & 0x3);
 	MLX5_SET(mkc, mkc, access_mode_4_2,
 		(ent->rb_key.access_mode >> 2) & 0x7);
+	MLX5_SET(mkc, mkc, ma_translation_mode, !!ent->rb_key.ats);
 	MLX5_SET(mkc, mkc, translations_octword_size,
 		 get_mkc_octo_size(ent->rb_key.access_mode,
 			new = &((*new)->rb_left);
 		if (cmp < 0)
 			new = &((*new)->rb_right);
-		if (cmp == 0) {
+		if (cmp == 0)
-			mutex_unlock(&cache->rb_lock);
 			return -EEXIST;
-		}
 	}
 	/* Add new node and rebalance tree. */
 	}
 	mr->mmkey.cache_ent = ent;
 	mr->mmkey.type = MLX5_MKEY_MR;
+	mr->mmkey.rb_key = ent->rb_key;
+	mr->mmkey.cacheable = true;
 	init_waitqueue_head(&mr->mmkey.wait);
 	return mr;
 }
 	mr->ibmr.pd = pd;
 	mr->umem = umem;
 	mr->page_shift = order_base_2(page_size);
-	mr->mmkey.cacheable = true;
 	set_mr_fields(dev, mr, umem->length, access_flags, iova);
 	return mr;

drivers/infiniband/hw/mlx5/srq.c+8−5

 	int err;
 	struct mlx5_srq_attr in = {};
 	__u32 max_srq_wqes = 1 << MLX5_CAP_GEN(dev->mdev, log_max_srq_sz);
+	__u32 max_sge_sz =  MLX5_CAP_GEN(dev->mdev, max_wqe_sz_rq) /
+			    sizeof(struct mlx5_wqe_data_seg);
 	if (init_attr->srq_type != IB_SRQT_BASIC &&
 	    init_attr->srq_type != IB_SRQT_XRC &&
 	    init_attr->srq_type != IB_SRQT_TM)
 		return -EOPNOTSUPP;
-	/* Sanity check SRQ size before proceeding */
+	/* Sanity check SRQ and sge size before proceeding */
-	if (init_attr->attr.max_wr >= max_srq_wqes) {
+	if (init_attr->attr.max_wr >= max_srq_wqes ||
-		mlx5_ib_dbg(dev, "max_wr %d, cap %d\n",
+	    init_attr->attr.max_sge > max_sge_sz) {
-			    init_attr->attr.max_wr,
+		mlx5_ib_dbg(dev, "max_wr %d,wr_cap %d,max_sge %d, sge_cap:%d\n",
-			    max_srq_wqes);
+			    init_attr->attr.max_wr, max_srq_wqes,
+			    init_attr->attr.max_sge, max_sge_sz);
 		return -EINVAL;
 	}

drivers/infiniband/sw/rxe/rxe_resp.c+13−0

@@ -344,6 +344,19 @@ static enum resp_states rxe_resp_check_length(struct rxe_qp *qp, · 343 unmodified lines
344	* receive buffer later. For rmda operations additional	344	* receive buffer later. For rmda operations additional
345	* length checks are performed in check_rkey.	345	* length checks are performed in check_rkey.
346	*/	346	*/
		347	if ((qp_type(qp) == IB_QPT_GSI) \|\| (qp_type(qp) == IB_QPT_UD)) {
		348	unsigned int payload = payload_size(pkt);
		349	unsigned int recv_buffer_len = 0;
		350	int i;
		351
		352	for (i = 0; i < qp->resp.wqe->dma.num_sge; i++)
		353	recv_buffer_len += qp->resp.wqe->dma.sge[i].length;
		354	if (payload + 40 > recv_buffer_len) {
		355	rxe_dbg_qp(qp, "The receive buffer is too small for this UD packet.\n");
		356	return RESPST_ERR_LENGTH;
		357	}
		358	}
		359
347	if (pkt->mask & RXE_PAYLOAD_MASK && ((qp_type(qp) == IB_QPT_RC) \|\|	360	if (pkt->mask & RXE_PAYLOAD_MASK && ((qp_type(qp) == IB_QPT_RC) \|\|
348	(qp_type(qp) == IB_QPT_UC))) {	361	(qp_type(qp) == IB_QPT_UC))) {
349	unsigned int mtu = qp->mtu;	362	unsigned int mtu = qp->mtu;

drivers/infiniband/sw/rxe/rxe_verbs.c+1−1

@@ -812,7 +812,7 @@ static void copy_inline_data_to_wqe(struct rxe_send_wqe *wqe, · 811 unmodified lines
812	int i;	812	int i;
813		813
814	for (i = 0; i < ibwr->num_sge; i++, sge++) {	814	for (i = 0; i < ibwr->num_sge; i++, sge++) {
815	memcpy(p, ib_virt_dma_to_page(sge->addr), sge->length);	815	memcpy(p, ib_virt_dma_to_ptr(sge->addr), sge->length);
816	p += sge->length;	816	p += sge->length;
817	}	817	}
818	}	818	}

drivers/mfd/axp20x.c+1−0

@@ -210,6 +210,7 @@ static const struct regmap_access_table axp313a_volatile_table = { · 209 unmodified lines
210		210
211	static const struct regmap_range axp717_writeable_ranges[] = {	211	static const struct regmap_range axp717_writeable_ranges[] = {
212	regmap_reg_range(AXP717_IRQ0_EN, AXP717_IRQ4_EN),	212	regmap_reg_range(AXP717_IRQ0_EN, AXP717_IRQ4_EN),
		213	regmap_reg_range(AXP717_IRQ0_STATE, AXP717_IRQ4_STATE),
213	regmap_reg_range(AXP717_DCDC_OUTPUT_CONTROL, AXP717_CPUSLDO_CONTROL),	214	regmap_reg_range(AXP717_DCDC_OUTPUT_CONTROL, AXP717_CPUSLDO_CONTROL),
214	};	215	};
215		216

drivers/net/ethernet/broadcom/bnxt/bnxt.c+5−3

 	return NETDEV_TX_OK;
 tx_dma_error:
-	if (BNXT_TX_PTP_IS_SET(lflags))
-		atomic_inc(&bp->ptp_cfg->tx_avail);
 	last_frag = i;
 	/* start back at beginning and unmap skb */
 tx_free:
 	dev_kfree_skb_any(skb);
 tx_kick_pending:
+	if (BNXT_TX_PTP_IS_SET(lflags))
+		atomic_inc(&bp->ptp_cfg->tx_avail);
 	if (txr->kick_pending)
 		bnxt_txr_db_kick(bp, txr, txr->tx_prod);
 	txr->tx_buf_ring[txr->tx_prod].skb = NULL;
 		memcpy(vf->mac_addr, resp->mac_address, ETH_ALEN);
 #endif
 	}
+	bp->tso_max_segs = le16_to_cpu(resp->max_tso_segs);
 hwrm_func_qcaps_exit:
 	hwrm_req_drop(bp, req);
 	dev->priv_flags |= IFF_UNICAST_FLT;
 	netif_set_tso_max_size(dev, GSO_MAX_SIZE);
+	if (bp->tso_max_segs)
+		netif_set_tso_max_segs(dev, bp->tso_max_segs);
 	dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT |
 			    NETDEV_XDP_ACT_RX_SG;

drivers/net/ethernet/broadcom/bnxt/bnxt.h+1−0

@@ -2318,6 +2318,7 @@ struct bnxt { · 2317 unmodified lines
2318	u8 rss_hash_key_updated:1;	2318	u8 rss_hash_key_updated:1;
2319		2319
2320	u16 max_mtu;	2320	u16 max_mtu;
		2321	u16 tso_max_segs;
2321	u8 max_tc;	2322	u8 max_tc;
2322	u8 max_lltc; /* lossless TCs */	2323	u8 max_lltc; /* lossless TCs */
2323	struct bnxt_queue_info q_info[BNXT_MAX_QUEUE];	2324	struct bnxt_queue_info q_info[BNXT_MAX_QUEUE];

drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h+178−133

  *
  * Copyright (c) 2014-2016 Broadcom Corporation
  * Copyright (c) 2014-2018 Broadcom Limited
- * Copyright (c) 2018-2023 Broadcom Inc.
+ * Copyright (c) 2018-2024 Broadcom Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
 	#define HWRM_TFC_IF_TBL_GET                       0x399UL
 	#define HWRM_TFC_TBL_SCOPE_CONFIG_GET             0x39aUL
 	#define HWRM_TFC_RESC_USAGE_QUERY                 0x39bUL
+	#define HWRM_QUEUE_PFCWD_TIMEOUT_QCAPS            0x39cUL
+	#define HWRM_QUEUE_PFCWD_TIMEOUT_CFG              0x39dUL
+	#define HWRM_QUEUE_PFCWD_TIMEOUT_QCFG             0x39eUL
 	#define HWRM_SV                                   0x400UL
+	#define HWRM_DBG_LOG_BUFFER_FLUSH                 0xff0fUL
 	#define HWRM_DBG_READ_DIRECT                      0xff10UL
 	#define HWRM_DBG_READ_INDIRECT                    0xff11UL
 	#define HWRM_DBG_WRITE_DIRECT                     0xff12UL
 #define HWRM_VERSION_MAJOR 1
 #define HWRM_VERSION_MINOR 10
 #define HWRM_VERSION_UPDATE 3
-#define HWRM_VERSION_RSVD 39
+#define HWRM_VERSION_RSVD 44
-#define HWRM_VERSION_STR "1.10.3.39"
+#define HWRM_VERSION_STR "1.10.3.44"
 /* hwrm_ver_get_input (size:192b/24B) */
 struct hwrm_ver_get_input {
 	#define VER_GET_RESP_DEV_CAPS_CFG_CFA_TFLIB_SUPPORTED                      0x2000UL
 	#define VER_GET_RESP_DEV_CAPS_CFG_CFA_TRUFLOW_SUPPORTED                    0x4000UL
 	#define VER_GET_RESP_DEV_CAPS_CFG_SECURE_BOOT_CAPABLE                      0x8000UL
+	#define VER_GET_RESP_DEV_CAPS_CFG_SECURE_SOC_CAPABLE                       0x10000UL
 	u8	roce_fw_maj_8b;
 	u8	roce_fw_min_8b;
 	u8	roce_fw_bld_8b;
 	#define ASYNC_EVENT_CMPL_EVENT_ID_HW_DOORBELL_RECOVERY_READ_ERROR 0x49UL
 	#define ASYNC_EVENT_CMPL_EVENT_ID_CTX_ERROR                       0x4aUL
 	#define ASYNC_EVENT_CMPL_EVENT_ID_UDCC_SESSION_CHANGE             0x4bUL
-	#define ASYNC_EVENT_CMPL_EVENT_ID_MAX_RGTR_EVENT_ID               0x4cUL
+	#define ASYNC_EVENT_CMPL_EVENT_ID_DBG_BUF_PRODUCER                0x4cUL
+	#define ASYNC_EVENT_CMPL_EVENT_ID_PEER_MMAP_CHANGE                0x4dUL
+	#define ASYNC_EVENT_CMPL_EVENT_ID_MAX_RGTR_EVENT_ID               0x4eUL
 	#define ASYNC_EVENT_CMPL_EVENT_ID_FW_TRACE_MSG                    0xfeUL
 	#define ASYNC_EVENT_CMPL_EVENT_ID_HWRM_ERROR                      0xffUL
 	#define ASYNC_EVENT_CMPL_EVENT_ID_LAST                           ASYNC_EVENT_CMPL_EVENT_ID_HWRM_ERROR
 	u8	timestamp_lo;
 	__le16	timestamp_hi;
 	__le32	event_data1;
-	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_MASK                   0xffUL
+	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_MASK                        0xffUL
-	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_SFT                    0
+	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_SFT                         0
-	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_RESERVED                 0x0UL
+	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_RESERVED                      0x0UL
-	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_PAUSE_STORM              0x1UL
+	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_PAUSE_STORM                   0x1UL
-	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_INVALID_SIGNAL           0x2UL
+	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_INVALID_SIGNAL                0x2UL
-	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_NVM                      0x3UL
+	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_NVM                           0x3UL
-	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_DOORBELL_DROP_THRESHOLD  0x4UL
+	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_DOORBELL_DROP_THRESHOLD       0x4UL
 	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_THERMAL_THRESHOLD             0x5UL
 	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_DUAL_DATA_RATE_NOT_SUPPORTED  0x6UL
 	#define ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_LAST                         ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_DUAL_DATA_RATE_NOT_SUPPORTED
 	#define FUNC_QCAPS_RESP_FLAGS_EXT2_SW_MAX_RESOURCE_LIMITS_SUPPORTED      0x800000UL
 	#define FUNC_QCAPS_RESP_FLAGS_EXT2_TF_INGRESS_NIC_FLOW_SUPPORTED         0x1000000UL
 	#define FUNC_QCAPS_RESP_FLAGS_EXT2_LPBK_STATS_SUPPORTED                  0x2000000UL
+	#define FUNC_QCAPS_RESP_FLAGS_EXT2_TF_EGRESS_NIC_FLOW_SUPPORTED          0x4000000UL
+	#define FUNC_QCAPS_RESP_FLAGS_EXT2_MULTI_LOSSLESS_QUEUES_SUPPORTED       0x8000000UL
+	#define FUNC_QCAPS_RESP_FLAGS_EXT2_PEER_MMAP_SUPPORTED                   0x10000000UL
 	__le16	tunnel_disable_flag;
 	#define FUNC_QCAPS_RESP_TUNNEL_DISABLE_FLAG_DISABLE_VXLAN      0x1UL
 	#define FUNC_QCAPS_RESP_TUNNEL_DISABLE_FLAG_DISABLE_NGE        0x2UL
 	#define FUNC_QCAPS_RESP_XID_PARTITION_CAP_RX_CK     0x2UL
 	u8	device_serial_number[8];
 	__le16	ctxs_per_partition;
-	u8	unused_2[2];
+	__le16	max_tso_segs;
 	__le32	roce_vf_max_av;
 	__le32	roce_vf_max_cq;
 	__le32	roce_vf_max_mrw;
 	#define FUNC_DRV_RGTR_REQ_FLAGS_NPAR_1_2_SUPPORT                 0x200UL
 	#define FUNC_DRV_RGTR_REQ_FLAGS_ASYM_QUEUE_CFG_SUPPORT           0x400UL
 	#define FUNC_DRV_RGTR_REQ_FLAGS_TF_INGRESS_NIC_FLOW_MODE         0x800UL
+	#define FUNC_DRV_RGTR_REQ_FLAGS_TF_EGRESS_NIC_FLOW_MODE          0x1000UL
 	__le32	enables;
 	#define FUNC_DRV_RGTR_REQ_ENABLES_OS_TYPE             0x1UL
 	#define FUNC_DRV_RGTR_REQ_ENABLES_VER                 0x2UL
 	__le16	target_id;
 	__le64	resp_addr;
 	__le16	type;
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_QP            0x0UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_QP              0x0UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SRQ           0x1UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SRQ             0x1UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_CQ            0x2UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_CQ              0x2UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_VNIC          0x3UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_VNIC            0x3UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_STAT          0x4UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_STAT            0x4UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SP_TQM_RING   0x5UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SP_TQM_RING     0x5UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_FP_TQM_RING   0x6UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_FP_TQM_RING     0x6UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_MRAV          0xeUL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_MRAV            0xeUL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_TIM           0xfUL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_TIM             0xfUL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_MP_TQM_RING   0x15UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_TX_CK           0x13UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SQ_DB_SHADOW  0x16UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_RX_CK           0x14UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_RQ_DB_SHADOW  0x17UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_MP_TQM_RING     0x15UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SRQ_DB_SHADOW 0x18UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SQ_DB_SHADOW    0x16UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_CQ_DB_SHADOW  0x19UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_RQ_DB_SHADOW    0x17UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_TBL_SCOPE     0x1cUL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SRQ_DB_SHADOW   0x18UL
-	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_XID_PARTITION 0x1dUL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_CQ_DB_SHADOW    0x19UL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_TBL_SCOPE       0x1cUL
+	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_XID_PARTITION   0x1dUL
 	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SRT_TRACE       0x1eUL
 	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_SRT2_TRACE      0x1fUL
 	#define FUNC_BACKING_STORE_CFG_V2_REQ_TYPE_CRT_TRACE       0x20UL
 	__le16	seq_id;
 	__le16	resp_len;
 	__le16	type;
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_QP            0x0UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_QP              0x0UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_SRQ           0x1UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_SRQ             0x1UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_CQ            0x2UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_CQ              0x2UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_VNIC          0x3UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_VNIC            0x3UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_STAT          0x4UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_STAT            0x4UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_SP_TQM_RING   0x5UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_SP_TQM_RING     0x5UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_FP_TQM_RING   0x6UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_FP_TQM_RING     0x6UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_MRAV          0xeUL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_MRAV            0xeUL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_TIM           0xfUL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_TIM             0xfUL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_MP_TQM_RING   0x15UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_TX_CK           0x13UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_TBL_SCOPE     0x1cUL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_RX_CK           0x14UL
-	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_XID_PARTITION 0x1dUL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_MP_TQM_RING     0x15UL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_TBL_SCOPE       0x1cUL
+	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_XID_PARTITION   0x1dUL
 	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_SRT_TRACE       0x1eUL
 	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_SRT2_TRACE      0x1fUL
 	#define FUNC_BACKING_STORE_QCFG_V2_RESP_TYPE_CRT_TRACE       0x20UL
 	__le16	target_id;
 	__le64	resp_addr;
 	__le16	type;
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_QP            0x0UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_QP              0x0UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SRQ           0x1UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SRQ             0x1UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_CQ            0x2UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_CQ              0x2UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_VNIC          0x3UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_VNIC            0x3UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_STAT          0x4UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_STAT            0x4UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SP_TQM_RING   0x5UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SP_TQM_RING     0x5UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_FP_TQM_RING   0x6UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_FP_TQM_RING     0x6UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_MRAV          0xeUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_MRAV            0xeUL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_TIM           0xfUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_TIM             0xfUL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_MP_TQM_RING   0x15UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_TX_CK           0x13UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SQ_DB_SHADOW  0x16UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_RX_CK           0x14UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_RQ_DB_SHADOW  0x17UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_MP_TQM_RING     0x15UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SRQ_DB_SHADOW 0x18UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SQ_DB_SHADOW    0x16UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_CQ_DB_SHADOW  0x19UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_RQ_DB_SHADOW    0x17UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_TBL_SCOPE     0x1cUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SRQ_DB_SHADOW   0x18UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_XID_PARTITION 0x1dUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_CQ_DB_SHADOW    0x19UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_TBL_SCOPE       0x1cUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_XID_PARTITION   0x1dUL
 	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SRT_TRACE       0x1eUL
 	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_SRT2_TRACE      0x1fUL
 	#define FUNC_BACKING_STORE_QCAPS_V2_REQ_TYPE_CRT_TRACE       0x20UL
 	__le16	seq_id;
 	__le16	resp_len;
 	__le16	type;
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_QP            0x0UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_QP              0x0UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SRQ           0x1UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SRQ             0x1UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_CQ            0x2UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_CQ              0x2UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_VNIC          0x3UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_VNIC            0x3UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_STAT          0x4UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_STAT            0x4UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SP_TQM_RING   0x5UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SP_TQM_RING     0x5UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_FP_TQM_RING   0x6UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_FP_TQM_RING     0x6UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_MRAV          0xeUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_MRAV            0xeUL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_TIM           0xfUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_TIM             0xfUL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_MP_TQM_RING   0x15UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_TX_CK           0x13UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SQ_DB_SHADOW  0x16UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_RX_CK           0x14UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_RQ_DB_SHADOW  0x17UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_MP_TQM_RING     0x15UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SRQ_DB_SHADOW 0x18UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SQ_DB_SHADOW    0x16UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_CQ_DB_SHADOW  0x19UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_RQ_DB_SHADOW    0x17UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_TBL_SCOPE     0x1cUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SRQ_DB_SHADOW   0x18UL
-	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_XID_PARTITION 0x1dUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_CQ_DB_SHADOW    0x19UL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_TBL_SCOPE       0x1cUL
+	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_XID_PARTITION   0x1dUL
 	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SRT_TRACE       0x1eUL
 	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_SRT2_TRACE      0x1fUL
 	#define FUNC_BACKING_STORE_QCAPS_V2_RESP_TYPE_CRT_TRACE       0x20UL
 	#define PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_100GB_PAM4_112 0x3eaUL
 	#define PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_200GB_PAM4_112 0x7d2UL
 	#define PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_400GB_PAM4_112 0xfa2UL
-	#define PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_LAST          PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_400GB_PAM4_112
+	#define PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_800GB_PAM4_112 0x1f42UL
+	#define PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_LAST          PORT_PHY_CFG_REQ_FORCE_LINK_SPEEDS2_800GB_PAM4_112
 	__le16	auto_link_speeds2_mask;
 	#define PORT_PHY_CFG_REQ_AUTO_LINK_SPEEDS2_MASK_1GB                0x1UL
 	#define PORT_PHY_CFG_REQ_AUTO_LINK_SPEEDS2_MASK_10GB               0x2UL
 	#define PORT_PHY_CFG_REQ_AUTO_LINK_SPEEDS2_MASK_100GB_PAM4_112     0x400UL
 	#define PORT_PHY_CFG_REQ_AUTO_LINK_SPEEDS2_MASK_200GB_PAM4_112     0x800UL
 	#define PORT_PHY_CFG_REQ_AUTO_LINK_SPEEDS2_MASK_400GB_PAM4_112     0x1000UL
+	#define PORT_PHY_CFG_REQ_AUTO_LINK_SPEEDS2_MASK_800GB_PAM4_112     0x2000UL
 	u8	unused_2[6];
 };
 	#define PORT_PHY_QCFG_RESP_LINK_SPEED_100GB 0x3e8UL
 	#define PORT_PHY_QCFG_RESP_LINK_SPEED_200GB 0x7d0UL
 	#define PORT_PHY_QCFG_RESP_LINK_SPEED_400GB 0xfa0UL
+	#define PORT_PHY_QCFG_RESP_LINK_SPEED_800GB 0x1f40UL
 	#define PORT_PHY_QCFG_RESP_LINK_SPEED_10MB  0xffffUL
 	#define PORT_PHY_QCFG_RESP_LINK_SPEED_LAST PORT_PHY_QCFG_RESP_LINK_SPEED_10MB
 	u8	duplex_cfg;
 	#define PORT_PHY_QCFG_RESP_PHY_TYPE_400G_BASESR4     0x35UL
 	#define PORT_PHY_QCFG_RESP_PHY_TYPE_400G_BASELR4     0x36UL
 	#define PORT_PHY_QCFG_RESP_PHY_TYPE_400G_BASEER4     0x37UL
-	#define PORT_PHY_QCFG_RESP_PHY_TYPE_LAST            PORT_PHY_QCFG_RESP_PHY_TYPE_400G_BASEER4
+	#define PORT_PHY_QCFG_RESP_PHY_TYPE_800G_BASECR8     0x38UL
+	#define PORT_PHY_QCFG_RESP_PHY_TYPE_800G_BASESR8     0x39UL
+	#define PORT_PHY_QCFG_RESP_PHY_TYPE_800G_BASELR8     0x3aUL
+	#define PORT_PHY_QCFG_RESP_PHY_TYPE_800G_BASEER8     0x3bUL
+	#define PORT_PHY_QCFG_RESP_PHY_TYPE_800G_BASEFR8     0x3cUL
+	#define PORT_PHY_QCFG_RESP_PHY_TYPE_800G_BASEDR8     0x3dUL
+	#define PORT_PHY_QCFG_RESP_PHY_TYPE_LAST            PORT_PHY_QCFG_RESP_PHY_TYPE_800G_BASEDR8
 	u8	media_type;
 	#define PORT_PHY_QCFG_RESP_MEDIA_TYPE_UNKNOWN 0x0UL
 	#define PORT_PHY_QCFG_RESP_MEDIA_TYPE_TP      0x1UL
 	u8	valid;
 };
-/* hwrm_port_lpbk_qstats_input (size:128b/16B) */
+/* hwrm_port_lpbk_qstats_input (size:256b/32B) */
 struct hwrm_port_lpbk_qstats_input {
 	__le16	req_type;
 	__le16	cmpl_ring;
 	__le16	seq_id;
 	__le16	target_id;
 	__le64	resp_addr;
+	__le16	lpbk_stat_size;
+	u8	flags;
+	#define PORT_LPBK_QSTATS_REQ_FLAGS_COUNTER_MASK     0x1UL
+	u8	unused_0[5];
+	__le64	lpbk_stat_host_addr;
 };
-/* hwrm_port_lpbk_qstats_output (size:768b/96B) */
+/* hwrm_port_lpbk_qstats_output (size:128b/16B) */
 struct hwrm_port_lpbk_qstats_output {
 	__le16	error_code;
 	__le16	req_type;
 	__le16	seq_id;
 	__le16	resp_len;
+	__le16	lpbk_stat_size;
+	u8	unused_0[5];
+	u8	valid;
+};
+/* port_lpbk_stats (size:640b/80B) */
+struct port_lpbk_stats {
 	__le64	lpbk_ucast_frames;
 	__le64	lpbk_mcast_frames;
 	__le64	lpbk_bcast_frames;
 	__le64	lpbk_ucast_bytes;
 	__le64	lpbk_mcast_bytes;
 	__le64	lpbk_bcast_bytes;
-	__le64	tx_stat_discard;
+	__le64	lpbk_tx_discards;
-	__le64	tx_stat_error;
+	__le64	lpbk_tx_errors;
-	__le64	rx_stat_discard;
+	__le64	lpbk_rx_discards;
-	__le64	rx_stat_error;
+	__le64	lpbk_rx_errors;
-	u8	unused_0[7];
-	u8	valid;
 };
 /* hwrm_port_ecn_qstats_input (size:256b/32B) */
 	u8	valid;
 };
-/* hwrm_port_lpbk_clr_stats_input (size:128b/16B) */
+/* hwrm_port_lpbk_clr_stats_input (size:192b/24B) */
 struct hwrm_port_lpbk_clr_stats_input {
 	__le16	req_type;
 	__le16	cmpl_ring;
 	__le16	seq_id;
 	__le16	target_id;
 	__le64	resp_addr;
+	__le16	port_id;
+	u8	unused_0[6];
 };
 /* hwrm_port_lpbk_clr_stats_output (size:128b/16B) */
 	#define PORT_PHY_QCAPS_RESP_SUPPORTED_PAM4_SPEEDS_FORCE_MODE_100G     0x2UL
 	#define PORT_PHY_QCAPS_RESP_SUPPORTED_PAM4_SPEEDS_FORCE_MODE_200G     0x4UL
 	__le16	flags2;
-	#define PORT_PHY_QCAPS_RESP_FLAGS2_PAUSE_UNSUPPORTED       0x1UL
+	#define PORT_PHY_QCAPS_RESP_FLAGS2_PAUSE_UNSUPPORTED           0x1UL
-	#define PORT_PHY_QCAPS_RESP_FLAGS2_PFC_UNSUPPORTED         0x2UL
+	#define PORT_PHY_QCAPS_RESP_FLAGS2_PFC_UNSUPPORTED             0x2UL
-	#define PORT_PHY_QCAPS_RESP_FLAGS2_BANK_ADDR_SUPPORTED     0x4UL
+	#define PORT_PHY_QCAPS_RESP_FLAGS2_BANK_ADDR_SUPPORTED         0x4UL
-	#define PORT_PHY_QCAPS_RESP_FLAGS2_SPEEDS2_SUPPORTED       0x8UL
+	#define PORT_PHY_QCAPS_RESP_FLAGS2_SPEEDS2_SUPPORTED           0x8UL
+	#define PORT_PHY_QCAPS_RESP_FLAGS2_REMOTE_LPBK_UNSUPPORTED     0x10UL
 	u8	internal_port_cnt;
 	u8	unused_0;
 	__le16	supported_speeds2_force_mode;
 	__le16	target_id;
 	__le64	resp_addr;
 	__le32	flags;
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH              0x1UL
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH                0x1UL
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_TX             0x0UL
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_TX               0x0UL
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_RX             0x1UL
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_RX               0x1UL
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_LAST          CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_RX
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_LAST            CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_RX
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_DROP              0x2UL
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_DROP                0x2UL
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_MASK      0xcUL
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_MASK        0xcUL
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_SFT       2
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_SFT         2
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_NO_ROCE_L2  (0x0UL << 2)
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_NO_ROCE_L2    (0x0UL << 2)
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_L2          (0x1UL << 2)
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_L2            (0x1UL << 2)
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_ROCE        (0x2UL << 2)
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_ROCE          (0x2UL << 2)
-	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_LAST       CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_ROCE
+	#define CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_LAST         CFA_L2_FILTER_CFG_REQ_FLAGS_TRAFFIC_ROCE
 	#define CFA_L2_FILTER_CFG_REQ_FLAGS_REMAP_OP_MASK       0x30UL
 	#define CFA_L2_FILTER_CFG_REQ_FLAGS_REMAP_OP_SFT        4
 	#define CFA_L2_FILTER_CFG_REQ_FLAGS_REMAP_OP_NO_UPDATE    (0x0UL << 4)
 	__le16	target_id;
 	__le64	resp_addr;
 	u8	tunnel_type;
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN        0x1UL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN              0x1UL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_GENEVE       0x5UL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_GENEVE             0x5UL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN_V4     0x9UL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN_V4           0x9UL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_IPGRE_V1     0xaUL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_IPGRE_V1           0xaUL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_L2_ETYPE     0xbUL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_L2_ETYPE           0xbUL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN_GPE_V6 0xcUL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN_GPE_V6       0xcUL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_CUSTOM_GRE   0xdUL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_CUSTOM_GRE         0xdUL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_ECPRI        0xeUL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_ECPRI              0xeUL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_SRV6         0xfUL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_SRV6               0xfUL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN_GPE    0x10UL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_VXLAN_GPE          0x10UL
-	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_GRE          0x11UL
+	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_GRE                0x11UL
 	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_ULP_DYN_UPAR       0x12UL
 	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_ULP_DYN_UPAR_RES01 0x13UL
 	#define TUNNEL_DST_PORT_QUERY_REQ_TUNNEL_TYPE_ULP_DYN_UPAR_RES02 0x14UL
 	__le16	target_id;
 	__le64	resp_addr;
 	u8	tunnel_type;
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN        0x1UL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN              0x1UL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_GENEVE       0x5UL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_GENEVE             0x5UL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN_V4     0x9UL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN_V4           0x9UL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_IPGRE_V1     0xaUL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_IPGRE_V1           0xaUL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_L2_ETYPE     0xbUL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_L2_ETYPE           0xbUL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN_GPE_V6 0xcUL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN_GPE_V6       0xcUL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_CUSTOM_GRE   0xdUL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_CUSTOM_GRE         0xdUL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_ECPRI        0xeUL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_ECPRI              0xeUL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_SRV6         0xfUL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_SRV6               0xfUL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN_GPE    0x10UL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_VXLAN_GPE          0x10UL
-	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_GRE          0x11UL
+	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_GRE                0x11UL
 	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_ULP_DYN_UPAR       0x12UL
 	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_ULP_DYN_UPAR_RES01 0x13UL
 	#define TUNNEL_DST_PORT_ALLOC_REQ_TUNNEL_TYPE_ULP_DYN_UPAR_RES02 0x14UL
 	__le16	target_id;
 	__le64	resp_addr;
 	u8	tunnel_type;
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN        0x1UL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN              0x1UL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_GENEVE       0x5UL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_GENEVE             0x5UL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN_V4     0x9UL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN_V4           0x9UL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_IPGRE_V1     0xaUL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_IPGRE_V1           0xaUL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_L2_ETYPE     0xbUL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_L2_ETYPE           0xbUL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN_GPE_V6 0xcUL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN_GPE_V6       0xcUL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_CUSTOM_GRE   0xdUL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_CUSTOM_GRE         0xdUL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_ECPRI        0xeUL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_ECPRI              0xeUL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_SRV6         0xfUL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_SRV6               0xfUL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN_GPE    0x10UL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_VXLAN_GPE          0x10UL
-	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_GRE          0x11UL
+	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_GRE                0x11UL
 	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_ULP_DYN_UPAR       0x12UL
 	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_ULP_DYN_UPAR_RES01 0x13UL
 	#define TUNNEL_DST_PORT_FREE_REQ_TUNNEL_TYPE_ULP_DYN_UPAR_RES02 0x14UL
 	#define STRUCT_HDR_STRUCT_ID_LLDP_GENERIC       0x424UL
 	#define STRUCT_HDR_STRUCT_ID_LLDP_DEVICE        0x426UL
 	#define STRUCT_HDR_STRUCT_ID_POWER_BKUP         0x427UL
+	#define STRUCT_HDR_STRUCT_ID_PEER_MMAP          0x429UL
 	#define STRUCT_HDR_STRUCT_ID_AFM_OPAQUE         0x1UL
 	#define STRUCT_HDR_STRUCT_ID_PORT_DESCRIPTION   0xaUL
 	#define STRUCT_HDR_STRUCT_ID_RSS_V2             0x64UL
 	__le16	instance;
 	__le16	unused_0;
 	u8	seg_flags;
+	#define DBG_COREDUMP_INITIATE_REQ_SEG_FLAGS_LIVE_DATA                0x1UL
+	#define DBG_COREDUMP_INITIATE_REQ_SEG_FLAGS_CRASH_DATA               0x2UL
+	#define DBG_COREDUMP_INITIATE_REQ_SEG_FLAGS_COLLECT_CTX_L1_CACHE     0x4UL
 	u8	unused_1[7];
 };
 /* dbc_dbc (size:64b/8B) */
 struct dbc_dbc {
-	u32	index;
+	__le32	index;
 	#define DBC_DBC_INDEX_MASK 0xffffffUL
 	#define DBC_DBC_INDEX_SFT  0
 	#define DBC_DBC_EPOCH      0x1000000UL
 	#define DBC_DBC_TOGGLE_MASK 0x6000000UL
 	#define DBC_DBC_TOGGLE_SFT 25
-	u32	type_path_xid;
+	__le32	type_path_xid;
 	#define DBC_DBC_XID_MASK          0xfffffUL
 	#define DBC_DBC_XID_SFT           0
 	#define DBC_DBC_PATH_MASK         0x3000000UL

drivers/net/ethernet/intel/ice/ice_ddp.c+21−2

@@ -1339,6 +1339,7 @@ ice_dwnld_cfg_bufs_no_lock(struct ice_hw hw, struct ice_buf bufs, u32 start, · 1338 unmodified lines
1339		1339
1340	for (i = 0; i < count; i++) {	1340	for (i = 0; i < count; i++) {
1341	bool last = false;	1341	bool last = false;
		1342	int try_cnt = 0;
1342	int status;	1343	int status;
1343		1344
1344	bh = (struct ice_buf_hdr *)(bufs + start + i);	1345	bh = (struct ice_buf_hdr *)(bufs + start + i);
@@ -1346,8 +1347,26 @@ ice_dwnld_cfg_bufs_no_lock(struct ice_hw hw, struct ice_buf bufs, u32 start, · 1 unmodified line
1346	if (indicate_last)	1347	if (indicate_last)
1347	last = ice_is_last_download_buffer(bh, i, count);	1348	last = ice_is_last_download_buffer(bh, i, count);
1348		1349
1349	status = ice_aq_download_pkg(hw, bh, ICE_PKG_BUF_SIZE, last,	1350	while (1) {
1350	&offset, &info, NULL);	1351	status = ice_aq_download_pkg(hw, bh, ICE_PKG_BUF_SIZE,
		1352	last, &offset, &info,
		1353	NULL);
		1354	if (hw->adminq.sq_last_status != ICE_AQ_RC_ENOSEC &&
		1355	hw->adminq.sq_last_status != ICE_AQ_RC_EBADSIG)
		1356	break;
		1357
		1358	try_cnt++;
		1359
		1360	if (try_cnt == 5)
		1361	break;
		1362
		1363	msleep(20);
		1364	}
		1365
		1366	if (try_cnt)
		1367	dev_dbg(ice_hw_to_dev(hw),
		1368	"ice_aq_download_pkg number of retries: %d\n",
		1369	try_cnt);
1351		1370
1352	/* Save AQ status from download package */	1371	/* Save AQ status from download package */
1353	if (status) {	1372	if (status) {

drivers/net/ethernet/intel/ice/ice_main.c+9−1

 	}
 	switch (vsi->port_info->phy.link_info.link_speed) {
+	case ICE_AQ_LINK_SPEED_200GB:
+		speed = "200 G";
+		break;
 	case ICE_AQ_LINK_SPEED_100GB:
 		speed = "100 G";
 		break;
 	 */
 	disabled = ice_service_task_stop(pf);
-	ice_unplug_aux_dev(pf);
+	ice_deinit_rdma(pf);
 	/* Already suspended?, then there is nothing to do */
 	if (test_and_set_bit(ICE_SUSPENDED, pf->state)) {
 	if (ret)
 		dev_err(dev, "Cannot restore interrupt scheme: %d\n", ret);
+	ret = ice_init_rdma(pf);
+	if (ret)
+		dev_err(dev, "Reinitialize RDMA during resume failed: %d\n",
+			ret);
 	clear_bit(ICE_DOWN, pf->state);
 	/* Now perform PF reset and rebuild */
 	reset_type = ICE_RESET_PFR;

drivers/net/ethernet/intel/ice/ice_switch.c+4−2

 	    lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC ||
 	    lkup_type == ICE_SW_LKUP_PROMISC ||
 	    lkup_type == ICE_SW_LKUP_PROMISC_VLAN ||
-	    lkup_type == ICE_SW_LKUP_DFLT) {
+	    lkup_type == ICE_SW_LKUP_DFLT ||
+	    lkup_type == ICE_SW_LKUP_LAST) {
 		sw_buf->res_type = cpu_to_le16(ICE_AQC_RES_TYPE_VSI_LIST_REP);
 	} else if (lkup_type == ICE_SW_LKUP_VLAN) {
 		if (opc == ice_aqc_opc_alloc_res)
 	    lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC ||
 	    lkup_type == ICE_SW_LKUP_PROMISC ||
 	    lkup_type == ICE_SW_LKUP_PROMISC_VLAN ||
-	    lkup_type == ICE_SW_LKUP_DFLT)
+	    lkup_type == ICE_SW_LKUP_DFLT ||
+	    lkup_type == ICE_SW_LKUP_LAST)
 		rule_type = remove ? ICE_AQC_SW_RULES_T_VSI_LIST_CLEAR :
 			ICE_AQC_SW_RULES_T_VSI_LIST_SET;
 	else if (lkup_type == ICE_SW_LKUP_VLAN)

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c+4−1

 			}
 		}
-		skb = build_skb(data, frag_size);
+		if (frag_size)
+			skb = build_skb(data, frag_size);
+		else
+			skb = slab_build_skb(data);
 		if (!skb) {
 			netdev_warn(port->dev, "skb build failed\n");
 			goto err_drop_frame;

drivers/net/ethernet/marvell/octeontx2/nic/Makefile+1−2

 rvu_nicpf-y := otx2_pf.o otx2_common.o otx2_txrx.o otx2_ethtool.o \
                otx2_flows.o otx2_tc.o cn10k.o otx2_dmac_flt.o \
                otx2_devlink.o qos_sq.o qos.o
-rvu_nicvf-y := otx2_vf.o otx2_devlink.o
+rvu_nicvf-y := otx2_vf.o
 rvu_nicpf-$(CONFIG_DCB) += otx2_dcbnl.o
-rvu_nicvf-$(CONFIG_DCB) += otx2_dcbnl.o
 rvu_nicpf-$(CONFIG_MACSEC) += cn10k_macsec.o
 ccflags-y += -I$(srctree)/drivers/net/ethernet/marvell/octeontx2/af

drivers/net/ethernet/marvell/octeontx2/nic/otx2_dcbnl.c+7−0

 	return 0;
 }
+EXPORT_SYMBOL(otx2_pfc_txschq_config);
 static int otx2_pfc_txschq_alloc_one(struct otx2_nic *pfvf, u8 prio)
 {
 	return 0;
 }
+EXPORT_SYMBOL(otx2_pfc_txschq_alloc);
 static int otx2_pfc_txschq_stop_one(struct otx2_nic *pfvf, u8 prio)
 {
 	return 0;
 }
+EXPORT_SYMBOL(otx2_pfc_txschq_update);
 int otx2_pfc_txschq_stop(struct otx2_nic *pfvf)
 {
 	return 0;
 }
+EXPORT_SYMBOL(otx2_pfc_txschq_stop);
 int otx2_config_priority_flow_ctrl(struct otx2_nic *pfvf)
 {
 	mutex_unlock(&pfvf->mbox.lock);
 	return err;
 }
+EXPORT_SYMBOL(otx2_config_priority_flow_ctrl);
 void otx2_update_bpid_in_rqctx(struct otx2_nic *pfvf, int vlan_prio, int qidx,
 			       bool pfc_enable)
 			 "Updating BPIDs in CQ and Aura contexts of RQ%d failed with err %d\n",
 			 qidx, err);
 }
+EXPORT_SYMBOL(otx2_update_bpid_in_rqctx);
 static int otx2_dcbnl_ieee_getpfc(struct net_device *dev, struct ieee_pfc *pfc)
 {
 	return 0;
 }
+EXPORT_SYMBOL(otx2_dcbnl_set_ops);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_devlink.c+2−0

 	devlink_free(dl);
 	return err;
 }
+EXPORT_SYMBOL(otx2_register_dl);
 void otx2_unregister_dl(struct otx2_nic *pfvf)
 {
 				  ARRAY_SIZE(otx2_dl_params));
 	devlink_free(dl);
 }
+EXPORT_SYMBOL(otx2_unregister_dl);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c+4−1

 	if (skb_shinfo(skb)->gso_size && !is_hw_tso_supported(pfvf, skb)) {
 		/* Insert vlan tag before giving pkt to tso */
-		if (skb_vlan_tag_present(skb))
+		if (skb_vlan_tag_present(skb)) {
 			skb = __vlan_hwaccel_push_inside(skb);
+			if (!skb)
+				return true;
+		}
 		otx2_sq_append_tso(pfvf, sq, skb, qidx);
 		return true;
 	}

drivers/net/ethernet/microchip/lan743x_ethtool.c+40−4

@@ -1127,8 +1127,12 @@ static void lan743x_ethtool_get_wol(struct net_device *netdev, · 1126 unmodified lines
1127	if (netdev->phydev)	1127	if (netdev->phydev)
1128	phy_ethtool_get_wol(netdev->phydev, wol);	1128	phy_ethtool_get_wol(netdev->phydev, wol);
1129		1129
1130	wol->supported \|= WAKE_BCAST \| WAKE_UCAST \| WAKE_MCAST \|	1130	if (wol->supported != adapter->phy_wol_supported)
1131	WAKE_MAGIC \| WAKE_PHY \| WAKE_ARP;	1131	netif_warn(adapter, drv, adapter->netdev,
		1132	"PHY changed its supported WOL! old=%x, new=%x\n",
		1133	adapter->phy_wol_supported, wol->supported);
		1134
		1135	wol->supported \|= MAC_SUPPORTED_WAKES;
1132		1136
1133	if (adapter->is_pci11x1x)	1137	if (adapter->is_pci11x1x)
1134	wol->supported \|= WAKE_MAGICSECURE;	1138	wol->supported \|= WAKE_MAGICSECURE;
@@ -1143,7 +1147,39 @@ static int lan743x_ethtool_set_wol(struct net_device *netdev, · 8 unmodified lines
1143	{	1147	{
1144	struct lan743x_adapter *adapter = netdev_priv(netdev);	1148	struct lan743x_adapter *adapter = netdev_priv(netdev);
1145		1149
		1150	/* WAKE_MAGICSEGURE is a modifier of and only valid together with
		1151	* WAKE_MAGIC
		1152	*/
		1153	if ((wol->wolopts & WAKE_MAGICSECURE) && !(wol->wolopts & WAKE_MAGIC))
		1154	return -EINVAL;
		1155
		1156	if (netdev->phydev) {
		1157	struct ethtool_wolinfo phy_wol;
		1158	int ret;
		1159
		1160	phy_wol.wolopts = wol->wolopts & adapter->phy_wol_supported;
		1161
		1162	/* If WAKE_MAGICSECURE was requested, filter out WAKE_MAGIC
		1163	* for PHYs that do not support WAKE_MAGICSECURE
		1164	*/
		1165	if (wol->wolopts & WAKE_MAGICSECURE &&
		1166	!(adapter->phy_wol_supported & WAKE_MAGICSECURE))
		1167	phy_wol.wolopts &= ~WAKE_MAGIC;
		1168
		1169	ret = phy_ethtool_set_wol(netdev->phydev, &phy_wol);
		1170	if (ret && (ret != -EOPNOTSUPP))
		1171	return ret;
		1172
		1173	if (ret == -EOPNOTSUPP)
		1174	adapter->phy_wolopts = 0;
		1175	else
		1176	adapter->phy_wolopts = phy_wol.wolopts;
		1177	} else {
		1178	adapter->phy_wolopts = 0;
		1179	}
		1180
1146	adapter->wolopts = 0;	1181	adapter->wolopts = 0;
		1182	wol->wolopts &= ~adapter->phy_wolopts;
1147	if (wol->wolopts & WAKE_UCAST)	1183	if (wol->wolopts & WAKE_UCAST)
1148	adapter->wolopts \|= WAKE_UCAST;	1184	adapter->wolopts \|= WAKE_UCAST;
1149	if (wol->wolopts & WAKE_MCAST)	1185	if (wol->wolopts & WAKE_MCAST)
@@ -1164,10 +1200,10 @@ static int lan743x_ethtool_set_wol(struct net_device *netdev, · 14 unmodified lines
1164	memset(adapter->sopass, 0, sizeof(u8) * SOPASS_MAX);	1200	memset(adapter->sopass, 0, sizeof(u8) * SOPASS_MAX);
1165	}	1201	}
1166		1202
		1203	wol->wolopts = adapter->wolopts \| adapter->phy_wolopts;
1167	device_set_wakeup_enable(&adapter->pdev->dev, (bool)wol->wolopts);	1204	device_set_wakeup_enable(&adapter->pdev->dev, (bool)wol->wolopts);
1168		1205
1169	return netdev->phydev ? phy_ethtool_set_wol(netdev->phydev, wol)	1206	return 0;
1170	: -ENETDOWN;
1171	}	1207	}
1172	#endif /* CONFIG_PM */	1208	#endif /* CONFIG_PM */
1173		1209

drivers/net/ethernet/microchip/lan743x_main.c+40−8

@@ -3118,6 +3118,17 @@ static int lan743x_netdev_open(struct net_device *netdev) · 3117 unmodified lines
3118	if (ret)	3118	if (ret)
3119	goto close_tx;	3119	goto close_tx;
3120	}	3120	}
		3121
		3122	#ifdef CONFIG_PM
		3123	if (adapter->netdev->phydev) {
		3124	struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
		3125
		3126	phy_ethtool_get_wol(netdev->phydev, &wol);
		3127	adapter->phy_wol_supported = wol.supported;
		3128	adapter->phy_wolopts = wol.wolopts;
		3129	}
		3130	#endif
		3131
3121	return 0;	3132	return 0;
3122		3133
3123	close_tx:	3134	close_tx:
@@ -3575,7 +3586,7 @@ static void lan743x_pm_set_wol(struct lan743x_adapter *adapter) · 451 unmodified lines
3575		3586
3576	/* clear wake settings */	3587	/* clear wake settings */
3577	pmtctl = lan743x_csr_read(adapter, PMT_CTL);	3588	pmtctl = lan743x_csr_read(adapter, PMT_CTL);
3578	pmtctl \|= PMT_CTL_WUPS_MASK_;	3589	pmtctl \|= PMT_CTL_WUPS_MASK_ \| PMT_CTL_RES_CLR_WKP_MASK_;
3579	pmtctl &= ~(PMT_CTL_GPIO_WAKEUP_EN_ \| PMT_CTL_EEE_WAKEUP_EN_ \|	3590	pmtctl &= ~(PMT_CTL_GPIO_WAKEUP_EN_ \| PMT_CTL_EEE_WAKEUP_EN_ \|
3580	PMT_CTL_WOL_EN_ \| PMT_CTL_MAC_D3_RX_CLK_OVR_ \|	3591	PMT_CTL_WOL_EN_ \| PMT_CTL_MAC_D3_RX_CLK_OVR_ \|
3581	PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_ \| PMT_CTL_ETH_PHY_WAKE_EN_);	3592	PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_ \| PMT_CTL_ETH_PHY_WAKE_EN_);
@@ -3587,10 +3598,9 @@ static void lan743x_pm_set_wol(struct lan743x_adapter *adapter) · 5 unmodified lines
3587		3598
3588	pmtctl \|= PMT_CTL_ETH_PHY_D3_COLD_OVR_ \| PMT_CTL_ETH_PHY_D3_OVR_;	3599	pmtctl \|= PMT_CTL_ETH_PHY_D3_COLD_OVR_ \| PMT_CTL_ETH_PHY_D3_OVR_;
3589		3600
3590	if (adapter->wolopts & WAKE_PHY) {	3601	if (adapter->phy_wolopts)
3591	pmtctl \|= PMT_CTL_ETH_PHY_EDPD_PLL_CTL_;
3592	pmtctl \|= PMT_CTL_ETH_PHY_WAKE_EN_;	3602	pmtctl \|= PMT_CTL_ETH_PHY_WAKE_EN_;
3593	}	3603
3594	if (adapter->wolopts & WAKE_MAGIC) {	3604	if (adapter->wolopts & WAKE_MAGIC) {
3595	wucsr \|= MAC_WUCSR_MPEN_;	3605	wucsr \|= MAC_WUCSR_MPEN_;
3596	macrx \|= MAC_RX_RXEN_;	3606	macrx \|= MAC_RX_RXEN_;
@@ -3686,7 +3696,7 @@ static int lan743x_pm_suspend(struct device *dev) · 89 unmodified lines
3686	lan743x_csr_write(adapter, MAC_WUCSR2, 0);	3696	lan743x_csr_write(adapter, MAC_WUCSR2, 0);
3687	lan743x_csr_write(adapter, MAC_WK_SRC, 0xFFFFFFFF);	3697	lan743x_csr_write(adapter, MAC_WK_SRC, 0xFFFFFFFF);
3688		3698
3689	if (adapter->wolopts)	3699	if (adapter->wolopts \|\| adapter->phy_wolopts)
3690	lan743x_pm_set_wol(adapter);	3700	lan743x_pm_set_wol(adapter);
3691		3701
3692	if (adapter->is_pci11x1x) {	3702	if (adapter->is_pci11x1x) {
@@ -3710,6 +3720,7 @@ static int lan743x_pm_resume(struct device *dev) · 17 unmodified lines
3710	struct pci_dev *pdev = to_pci_dev(dev);	3720	struct pci_dev *pdev = to_pci_dev(dev);
3711	struct net_device *netdev = pci_get_drvdata(pdev);	3721	struct net_device *netdev = pci_get_drvdata(pdev);
3712	struct lan743x_adapter *adapter = netdev_priv(netdev);	3722	struct lan743x_adapter *adapter = netdev_priv(netdev);
		3723	u32 data;
3713	int ret;	3724	int ret;
3714		3725
3715	pci_set_power_state(pdev, PCI_D0);	3726	pci_set_power_state(pdev, PCI_D0);
@@ -3728,6 +3739,30 @@ static int lan743x_pm_resume(struct device *dev) · 12 unmodified lines
3728	return ret;	3739	return ret;
3729	}	3740	}
3730		3741
		3742	ret = lan743x_csr_read(adapter, MAC_WK_SRC);
		3743	netif_dbg(adapter, drv, adapter->netdev,
		3744	"Wakeup source : 0x%08X\n", ret);
		3745
		3746	/* Clear the wol configuration and status bits. Note that
		3747	* the status bits are "Write One to Clear (W1C)"
		3748	*/
		3749	data = MAC_WUCSR_EEE_TX_WAKE_ \| MAC_WUCSR_EEE_RX_WAKE_ \|
		3750	MAC_WUCSR_RFE_WAKE_FR_ \| MAC_WUCSR_PFDA_FR_ \| MAC_WUCSR_WUFR_ \|
		3751	MAC_WUCSR_MPR_ \| MAC_WUCSR_BCAST_FR_;
		3752	lan743x_csr_write(adapter, MAC_WUCSR, data);
		3753
		3754	data = MAC_WUCSR2_NS_RCD_ \| MAC_WUCSR2_ARP_RCD_ \|
		3755	MAC_WUCSR2_IPV6_TCPSYN_RCD_ \| MAC_WUCSR2_IPV4_TCPSYN_RCD_;
		3756	lan743x_csr_write(adapter, MAC_WUCSR2, data);
		3757
		3758	data = MAC_WK_SRC_ETH_PHY_WK_ \| MAC_WK_SRC_IPV6_TCPSYN_RCD_WK_ \|
		3759	MAC_WK_SRC_IPV4_TCPSYN_RCD_WK_ \| MAC_WK_SRC_EEE_TX_WK_ \|
		3760	MAC_WK_SRC_EEE_RX_WK_ \| MAC_WK_SRC_RFE_FR_WK_ \|
		3761	MAC_WK_SRC_PFDA_FR_WK_ \| MAC_WK_SRC_MP_FR_WK_ \|
		3762	MAC_WK_SRC_BCAST_FR_WK_ \| MAC_WK_SRC_WU_FR_WK_ \|
		3763	MAC_WK_SRC_WK_FR_SAVED_;
		3764	lan743x_csr_write(adapter, MAC_WK_SRC, data);
		3765
3731	/* open netdev when netdev is at running state while resume.	3766	/* open netdev when netdev is at running state while resume.
3732	* For instance, it is true when system wakesup after pm-suspend	3767	* For instance, it is true when system wakesup after pm-suspend
3733	* However, it is false when system wakes up after suspend GUI menu	3768	* However, it is false when system wakes up after suspend GUI menu
@@ -3736,9 +3771,6 @@ static int lan743x_pm_resume(struct device *dev) · 2 unmodified lines
3736	lan743x_netdev_open(netdev);	3771	lan743x_netdev_open(netdev);
3737		3772
3738	netif_device_attach(netdev);	3773	netif_device_attach(netdev);
3739	ret = lan743x_csr_read(adapter, MAC_WK_SRC);
3740	netif_info(adapter, drv, adapter->netdev,
3741	"Wakeup source : 0x%08X\n", ret);
3742		3774
3743	return 0;	3775	return 0;
3744	}	3776	}

drivers/net/ethernet/microchip/lan743x_main.h+28−0

 #define PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_		BIT(18)
 #define PMT_CTL_GPIO_WAKEUP_EN_			BIT(15)
 #define PMT_CTL_EEE_WAKEUP_EN_			BIT(13)
+#define PMT_CTL_RES_CLR_WKP_MASK_		GENMASK(9, 8)
 #define PMT_CTL_READY_				BIT(7)
 #define PMT_CTL_ETH_PHY_RST_			BIT(4)
 #define PMT_CTL_WOL_EN_				BIT(3)
 #define MAC_WUCSR				(0x140)
 #define MAC_MP_SO_EN_				BIT(21)
 #define MAC_WUCSR_RFE_WAKE_EN_			BIT(14)
+#define MAC_WUCSR_EEE_TX_WAKE_			BIT(13)
+#define MAC_WUCSR_EEE_RX_WAKE_			BIT(11)
+#define MAC_WUCSR_RFE_WAKE_FR_			BIT(9)
+#define MAC_WUCSR_PFDA_FR_			BIT(7)
+#define MAC_WUCSR_WUFR_				BIT(6)
+#define MAC_WUCSR_MPR_				BIT(5)
+#define MAC_WUCSR_BCAST_FR_			BIT(4)
 #define MAC_WUCSR_PFDA_EN_			BIT(3)
 #define MAC_WUCSR_WAKE_EN_			BIT(2)
 #define MAC_WUCSR_MPEN_				BIT(1)
 #define MAC_WUCSR_BCST_EN_			BIT(0)
 #define MAC_WK_SRC				(0x144)
+#define MAC_WK_SRC_ETH_PHY_WK_			BIT(17)
+#define MAC_WK_SRC_IPV6_TCPSYN_RCD_WK_		BIT(16)
+#define MAC_WK_SRC_IPV4_TCPSYN_RCD_WK_		BIT(15)
+#define MAC_WK_SRC_EEE_TX_WK_			BIT(14)
+#define MAC_WK_SRC_EEE_RX_WK_			BIT(13)
+#define MAC_WK_SRC_RFE_FR_WK_			BIT(12)
+#define MAC_WK_SRC_PFDA_FR_WK_			BIT(11)
+#define MAC_WK_SRC_MP_FR_WK_			BIT(10)
+#define MAC_WK_SRC_BCAST_FR_WK_			BIT(9)
+#define MAC_WK_SRC_WU_FR_WK_			BIT(8)
+#define MAC_WK_SRC_WK_FR_SAVED_			BIT(7)
 #define MAC_MP_SO_HI				(0x148)
 #define MAC_MP_SO_LO				(0x14C)
 #define RFE_INDX(index)			(0x580 + (index << 2))
 #define MAC_WUCSR2			(0x600)
+#define MAC_WUCSR2_NS_RCD_		BIT(7)
+#define MAC_WUCSR2_ARP_RCD_		BIT(6)
+#define MAC_WUCSR2_IPV6_TCPSYN_RCD_	BIT(5)
+#define MAC_WUCSR2_IPV4_TCPSYN_RCD_	BIT(4)
 #define SGMII_ACC			(0x720)
 #define SGMII_ACC_SGMII_BZY_		BIT(31)
 	LINK_2500_SLAVE
 };
+#define MAC_SUPPORTED_WAKES  (WAKE_BCAST | WAKE_UCAST | WAKE_MCAST | \
+			      WAKE_MAGIC | WAKE_ARP)
 struct lan743x_adapter {
 	struct net_device       *netdev;
 	struct mii_bus		*mdiobus;
 #ifdef CONFIG_PM
 	u32			wolopts;
 	u8			sopass[SOPASS_MAX];
+	u32			phy_wolopts;
+	u32			phy_wol_supported;
 #endif
 	struct pci_dev		*pdev;
 	struct lan743x_csr      csr;

drivers/net/ethernet/qualcomm/qca_debug.c+2−4

 	seq_printf(s, "IRQ              : %d\n",
 		   qca->spi_dev->irq);
-	seq_printf(s, "INTR REQ         : %u\n",
+	seq_printf(s, "INTR             : %lx\n",
-		   qca->intr_req);
+		   qca->intr);
-	seq_printf(s, "INTR SVC         : %u\n",
-		   qca->intr_svc);
 	seq_printf(s, "SPI max speed    : %lu\n",
 		   (unsigned long)qca->spi_dev->max_speed_hz);

drivers/net/ethernet/qualcomm/qca_spi.c+8−8

 #define MAX_DMA_BURST_LEN 5000
+#define SPI_INTR 0
 /*   Modules parameters     */
 #define QCASPI_CLK_SPEED_MIN 1000000
 #define QCASPI_CLK_SPEED_MAX 16000000
 			continue;
 		}
-		if ((qca->intr_req == qca->intr_svc) &&
+		if (!test_bit(SPI_INTR, &qca->intr) &&
 		    !qca->txr.skb[qca->txr.head])
 			schedule();
 		set_current_state(TASK_RUNNING);
-		netdev_dbg(qca->net_dev, "have work to do. int: %d, tx_skb: %p\n",
+		netdev_dbg(qca->net_dev, "have work to do. int: %lu, tx_skb: %p\n",
-			   qca->intr_req - qca->intr_svc,
+			   qca->intr,
 			   qca->txr.skb[qca->txr.head]);
 		qcaspi_qca7k_sync(qca, QCASPI_EVENT_UPDATE);
 			msleep(QCASPI_QCA7K_REBOOT_TIME_MS);
 		}
-		if (qca->intr_svc != qca->intr_req) {
+		if (test_and_clear_bit(SPI_INTR, &qca->intr)) {
-			qca->intr_svc = qca->intr_req;
 			start_spi_intr_handling(qca, &intr_cause);
 			if (intr_cause & SPI_INT_CPU_ON) {
 {
 	struct qcaspi *qca = data;
-	qca->intr_req++;
+	set_bit(SPI_INTR, &qca->intr);
 	if (qca->spi_thread)
 		wake_up_process(qca->spi_thread);
 	if (!qca)
 		return -EINVAL;
-	qca->intr_req = 1;
+	set_bit(SPI_INTR, &qca->intr);
-	qca->intr_svc = 0;
 	qca->sync = QCASPI_SYNC_UNKNOWN;
 	qcafrm_fsm_init_spi(&qca->frm_handle);

drivers/net/ethernet/qualcomm/qca_spi.h+1−2

@@ -81,8 +81,7 @@ struct qcaspi { · 80 unmodified lines
81	struct qcafrm_handle frm_handle;	81	struct qcafrm_handle frm_handle;
82	struct sk_buff *rx_skb;	82	struct sk_buff *rx_skb;
83		83
84	unsigned int intr_req;	84	unsigned long intr;
85	unsigned int intr_svc;
86	u16 reset_count;	85	u16 reset_count;
87		86
88	#ifdef CONFIG_DEBUG_FS	87	#ifdef CONFIG_DEBUG_FS

drivers/net/ethernet/stmicro/stmmac/stmmac_hwtstamp.c+5−1

 {
 	u32 num_snapshot, ts_status, tsync_int;
 	struct ptp_clock_event event;
+	u32 acr_value, channel;
 	unsigned long flags;
 	u64 ptp_time;
 	int i;
 	num_snapshot = (ts_status & GMAC_TIMESTAMP_ATSNS_MASK) >>
 		       GMAC_TIMESTAMP_ATSNS_SHIFT;
+	acr_value = readl(priv->ptpaddr + PTP_ACR);
+	channel = ilog2(FIELD_GET(PTP_ACR_MASK, acr_value));
 	for (i = 0; i < num_snapshot; i++) {
 		read_lock_irqsave(&priv->ptp_lock, flags);
 		get_ptptime(priv->ptpaddr, &ptp_time);
 		read_unlock_irqrestore(&priv->ptp_lock, flags);
 		event.type = PTP_CLOCK_EXTTS;
-		event.index = 0;
+		event.index = channel;
 		event.timestamp = ptp_time;
 		ptp_clock_event(priv->ptp_clock, &event);
 	}

drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c+22−18

@@ -358,24 +358,28 @@ static int tc_setup_cbs(struct stmmac_priv *priv, · 357 unmodified lines
358		358
359	port_transmit_rate_kbps = qopt->idleslope - qopt->sendslope;	359	port_transmit_rate_kbps = qopt->idleslope - qopt->sendslope;
360		360
361	/* Port Transmit Rate and Speed Divider */	361	if (qopt->enable) {
362	switch (div_s64(port_transmit_rate_kbps, 1000)) {	362	/* Port Transmit Rate and Speed Divider */
363	case SPEED_10000:	363	switch (div_s64(port_transmit_rate_kbps, 1000)) {
364	case SPEED_5000:	364	case SPEED_10000:
365	ptr = 32;	365	case SPEED_5000:
366	break;	366	ptr = 32;
367	case SPEED_2500:	367	break;
368	case SPEED_1000:	368	case SPEED_2500:
369	ptr = 8;	369	case SPEED_1000:
370	break;	370	ptr = 8;
371	case SPEED_100:	371	break;
372	ptr = 4;	372	case SPEED_100:
373	break;	373	ptr = 4;
374	default:	374	break;
375	netdev_err(priv->dev,	375	default:
376	"Invalid portTransmitRate %lld (idleSlope - sendSlope)\n",	376	netdev_err(priv->dev,
377	port_transmit_rate_kbps);	377	"Invalid portTransmitRate %lld (idleSlope - sendSlope)\n",
378	return -EINVAL;	378	port_transmit_rate_kbps);
		379	return -EINVAL;
		380	}
		381	} else {
		382	ptr = 0;
379	}	383	}
380		384
381	mode_to_use = priv->plat->tx_queues_cfg[queue].mode_to_use;	385	mode_to_use = priv->plat->tx_queues_cfg[queue].mode_to_use;

drivers/net/phy/dp83tg720.c+34−4

 #define DP83TG720S_PHY_RESET			0x1f
 #define DP83TG720S_HW_RESET			BIT(15)
+#define DP83TG720S_LPS_CFG3			0x18c
+/* Power modes are documented as bit fields but used as values */
+/* Power Mode 0 is Normal mode */
+#define DP83TG720S_LPS_CFG3_PWR_MODE_0		BIT(0)
 #define DP83TG720S_RGMII_DELAY_CTRL		0x602
 /* In RGMII mode, Enable or disable the internal delay for RXD */
 #define DP83TG720S_RGMII_RX_CLK_SEL		BIT(1)
 static int dp83tg720_config_aneg(struct phy_device *phydev)
 {
+	int ret;
 	/* Autoneg is not supported and this PHY supports only one speed.
 	 * We need to care only about master/slave configuration if it was
 	 * changed by user.
 	 */
-	return genphy_c45_pma_baset1_setup_master_slave(phydev);
+	ret = genphy_c45_pma_baset1_setup_master_slave(phydev);
+	if (ret)
+		return ret;
+	/* Re-read role configuration to make changes visible even if
+	 * the link is in administrative down state.
+	 */
+	return genphy_c45_pma_baset1_read_master_slave(phydev);
 }
 static int dp83tg720_read_status(struct phy_device *phydev)
 			return ret;
 		/* After HW reset we need to restore master/slave configuration.
+		 * genphy_c45_pma_baset1_read_master_slave() call will be done
+		 * by the dp83tg720_config_aneg() function.
 		 */
 		ret = dp83tg720_config_aneg(phydev);
 		if (ret)
 	 */
 	usleep_range(1000, 2000);
-	if (phy_interface_is_rgmii(phydev))
+	if (phy_interface_is_rgmii(phydev)) {
-		return dp83tg720_config_rgmii_delay(phydev);
+		ret = dp83tg720_config_rgmii_delay(phydev);
+		if (ret)
+			return ret;
+	}
+	/* In case the PHY is bootstrapped in managed mode, we need to
+	 * wake it.
+	 */
+	ret = phy_write_mmd(phydev, MDIO_MMD_VEND2, DP83TG720S_LPS_CFG3,
+			    DP83TG720S_LPS_CFG3_PWR_MODE_0);
+	if (ret)
+		return ret;
-	return 0;
+	/* Make role configuration visible for ethtool on init and after
+	 * rest.
+	 */
+	return genphy_c45_pma_baset1_read_master_slave(phydev);
 }
 static struct phy_driver dp83tg720_driver[] = {

drivers/net/phy/mxl-gpy.c+38−20

@@ -107,6 +107,7 @@ struct gpy_priv { · 106 unmodified lines
107		107
108	u8 fw_major;	108	u8 fw_major;
109	u8 fw_minor;	109	u8 fw_minor;
		110	u32 wolopts;
110		111
111	/* It takes 3 seconds to fully switch out of loopback mode before	112	/* It takes 3 seconds to fully switch out of loopback mode before
112	* it can safely re-enter loopback mode. Record the time when	113	* it can safely re-enter loopback mode. Record the time when
@@ -221,6 +222,15 @@ static int gpy_hwmon_register(struct phy_device *phydev) · 108 unmodified lines
221	}	222	}
222	#endif	223	#endif
223		224
		225	static int gpy_ack_interrupt(struct phy_device *phydev)
		226	{
		227	int ret;
		228
		229	/* Clear all pending interrupts */
		230	ret = phy_read(phydev, PHY_ISTAT);
		231	return ret < 0 ? ret : 0;
		232	}
		233
224	static int gpy_mbox_read(struct phy_device *phydev, u32 addr)	234	static int gpy_mbox_read(struct phy_device *phydev, u32 addr)
225	{	235	{
226	struct gpy_priv *priv = phydev->priv;	236	struct gpy_priv *priv = phydev->priv;
@@ -262,16 +272,8 @@ out: · 35 unmodified lines
262		272
263	static int gpy_config_init(struct phy_device *phydev)	273	static int gpy_config_init(struct phy_device *phydev)
264	{	274	{
265	int ret;	275	/* Nothing to configure. Configuration Requirement Placeholder */
266		276	return 0;
267	/* Mask all interrupts */
268	ret = phy_write(phydev, PHY_IMASK, 0);
269	if (ret)
270	return ret;
271
272	/* Clear all pending interrupts */
273	ret = phy_read(phydev, PHY_ISTAT);
274	return ret < 0 ? ret : 0;
275	}	277	}
276		278
277	static int gpy21x_config_init(struct phy_device *phydev)	279	static int gpy21x_config_init(struct phy_device *phydev)
@@ -627,11 +629,23 @@ static int gpy_read_status(struct phy_device *phydev) · 349 unmodified lines
627		629
628	static int gpy_config_intr(struct phy_device *phydev)	630	static int gpy_config_intr(struct phy_device *phydev)
629	{	631	{
		632	struct gpy_priv *priv = phydev->priv;
630	u16 mask = 0;	633	u16 mask = 0;
		634	int ret;
		635
		636	ret = gpy_ack_interrupt(phydev);
		637	if (ret)
		638	return ret;
631		639
632	if (phydev->interrupts == PHY_INTERRUPT_ENABLED)	640	if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
633	mask = PHY_IMASK_MASK;	641	mask = PHY_IMASK_MASK;
634		642
		643	if (priv->wolopts & WAKE_MAGIC)
		644	mask \|= PHY_IMASK_WOL;
		645
		646	if (priv->wolopts & WAKE_PHY)
		647	mask \|= PHY_IMASK_LSTC;
		648
635	return phy_write(phydev, PHY_IMASK, mask);	649	return phy_write(phydev, PHY_IMASK, mask);
636	}	650	}
637		651
@@ -678,6 +692,7 @@ static int gpy_set_wol(struct phy_device *phydev, · 40 unmodified lines
678	struct ethtool_wolinfo *wol)	692	struct ethtool_wolinfo *wol)
679	{	693	{
680	struct net_device *attach_dev = phydev->attached_dev;	694	struct net_device *attach_dev = phydev->attached_dev;
		695	struct gpy_priv *priv = phydev->priv;
681	int ret;	696	int ret;
682		697
683	if (wol->wolopts & WAKE_MAGIC) {	698	if (wol->wolopts & WAKE_MAGIC) {
@@ -725,6 +740,8 @@ static int gpy_set_wol(struct phy_device *phydev, · 41 unmodified lines
725	ret = phy_read(phydev, PHY_ISTAT);	740	ret = phy_read(phydev, PHY_ISTAT);
726	if (ret < 0)	741	if (ret < 0)
727	return ret;	742	return ret;
		743
		744	priv->wolopts \|= WAKE_MAGIC;
728	} else {	745	} else {
729	/* Disable magic packet matching */	746	/* Disable magic packet matching */
730	ret = phy_clear_bits_mmd(phydev, MDIO_MMD_VEND2,	747	ret = phy_clear_bits_mmd(phydev, MDIO_MMD_VEND2,
@@ -732,6 +749,13 @@ static int gpy_set_wol(struct phy_device *phydev, · 1 unmodified line
732	WOL_EN);	749	WOL_EN);
733	if (ret < 0)	750	if (ret < 0)
734	return ret;	751	return ret;
		752
		753	/* Disable the WOL interrupt */
		754	ret = phy_clear_bits(phydev, PHY_IMASK, PHY_IMASK_WOL);
		755	if (ret < 0)
		756	return ret;
		757
		758	priv->wolopts &= ~WAKE_MAGIC;
735	}	759	}
736		760
737	if (wol->wolopts & WAKE_PHY) {	761	if (wol->wolopts & WAKE_PHY) {
@@ -748,9 +772,11 @@ static int gpy_set_wol(struct phy_device *phydev, · 10 unmodified lines
748	if (ret & (PHY_IMASK_MASK & ~PHY_IMASK_LSTC))	772	if (ret & (PHY_IMASK_MASK & ~PHY_IMASK_LSTC))
749	phy_trigger_machine(phydev);	773	phy_trigger_machine(phydev);
750		774
		775	priv->wolopts \|= WAKE_PHY;
751	return 0;	776	return 0;
752	}	777	}
753		778
		779	priv->wolopts &= ~WAKE_PHY;
754	/* Disable the link state change interrupt */	780	/* Disable the link state change interrupt */
755	return phy_clear_bits(phydev, PHY_IMASK, PHY_IMASK_LSTC);	781	return phy_clear_bits(phydev, PHY_IMASK, PHY_IMASK_LSTC);
756	}	782	}
@@ -758,18 +784,10 @@ static int gpy_set_wol(struct phy_device *phydev, · 1 unmodified line
758	static void gpy_get_wol(struct phy_device *phydev,	784	static void gpy_get_wol(struct phy_device *phydev,
759	struct ethtool_wolinfo *wol)	785	struct ethtool_wolinfo *wol)
760	{	786	{
761	int ret;	787	struct gpy_priv *priv = phydev->priv;
762		788
763	wol->supported = WAKE_MAGIC \| WAKE_PHY;	789	wol->supported = WAKE_MAGIC \| WAKE_PHY;
764	wol->wolopts = 0;	790	wol->wolopts = priv->wolopts;
765
766	ret = phy_read_mmd(phydev, MDIO_MMD_VEND2, VPSPEC2_WOL_CTL);
767	if (ret & WOL_EN)
768	wol->wolopts \|= WAKE_MAGIC;
769
770	ret = phy_read(phydev, PHY_IMASK);
771	if (ret & PHY_IMASK_LSTC)
772	wol->wolopts \|= WAKE_PHY;
773	}	791	}
774		792
775	static int gpy_loopback(struct phy_device *phydev, bool enable)	793	static int gpy_loopback(struct phy_device *phydev, bool enable)

drivers/net/usb/ax88179_178a.c+13−5

 	u32 wol_supported;
 	u32 wolopts;
 	u8 disconnecting;
-	u8 initialized;
 };
 struct ax88179_int_data {
 static int ax88179_net_reset(struct usbnet *dev)
 {
-	struct ax88179_data *ax179_data = dev->driver_priv;
+	u16 tmp16;
-	if (ax179_data->initialized)
+	ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID, GMII_PHY_PHYSR,
+			 2, &tmp16);
+	if (tmp16) {
+		ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
+				 2, 2, &tmp16);
+		if (!(tmp16 & AX_MEDIUM_RECEIVE_EN)) {
+			tmp16 |= AX_MEDIUM_RECEIVE_EN;
+			ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
+					  2, 2, &tmp16);
+		}
+	} else {
 		ax88179_reset(dev);
-	else
+	}
-		ax179_data->initialized = 1;
 	return 0;
 }

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

@@ -778,7 +778,8 @@ static int rtl8150_get_link_ksettings(struct net_device *netdev, · 777 unmodified lines
778	struct ethtool_link_ksettings *ecmd)	778	struct ethtool_link_ksettings *ecmd)
779	{	779	{
780	rtl8150_t *dev = netdev_priv(netdev);	780	rtl8150_t *dev = netdev_priv(netdev);
781	short lpa, bmcr;	781	short lpa = 0;
		782	short bmcr = 0;
782	u32 supported;	783	u32 supported;
783		784
784	supported = (SUPPORTED_10baseT_Half \|	785	supported = (SUPPORTED_10baseT_Half \|

drivers/net/virtio_net.c+29−3

@@ -1360,6 +1360,10 @@ static struct sk_buff receive_small_xdp(struct net_device dev, · 1359 unmodified lines
1360	if (unlikely(hdr->hdr.gso_type))	1360	if (unlikely(hdr->hdr.gso_type))
1361	goto err_xdp;	1361	goto err_xdp;
1362		1362
		1363	/* Partially checksummed packets must be dropped. */
		1364	if (unlikely(hdr->hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM))
		1365	goto err_xdp;
		1366
1363	buflen = SKB_DATA_ALIGN(GOOD_PACKET_LEN + headroom) +	1367	buflen = SKB_DATA_ALIGN(GOOD_PACKET_LEN + headroom) +
1364	SKB_DATA_ALIGN(sizeof(struct skb_shared_info));	1368	SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
1365		1369
@@ -1677,6 +1681,10 @@ static void mergeable_xdp_get_buf(struct virtnet_info vi, · 311 unmodified lines
1677	if (unlikely(hdr->hdr.gso_type))	1681	if (unlikely(hdr->hdr.gso_type))
1678	return NULL;	1682	return NULL;
1679		1683
		1684	/* Partially checksummed packets must be dropped. */
		1685	if (unlikely(hdr->hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM))
		1686	return NULL;
		1687
1680	/* Now XDP core assumes frag size is PAGE_SIZE, but buffers	1688	/* Now XDP core assumes frag size is PAGE_SIZE, but buffers
1681	* with headroom may add hole in truesize, which	1689	* with headroom may add hole in truesize, which
1682	* make their length exceed PAGE_SIZE. So we disabled the	1690	* make their length exceed PAGE_SIZE. So we disabled the
@@ -1943,6 +1951,7 @@ static void receive_buf(struct virtnet_info vi, struct receive_queue rq, · 260 unmodified lines
1943	struct net_device *dev = vi->dev;	1951	struct net_device *dev = vi->dev;
1944	struct sk_buff *skb;	1952	struct sk_buff *skb;
1945	struct virtio_net_common_hdr *hdr;	1953	struct virtio_net_common_hdr *hdr;
		1954	u8 flags;
1946		1955
1947	if (unlikely(len < vi->hdr_len + ETH_HLEN)) {	1956	if (unlikely(len < vi->hdr_len + ETH_HLEN)) {
1948	pr_debug("%s: short packet %i\n", dev->name, len);	1957	pr_debug("%s: short packet %i\n", dev->name, len);
@@ -1951,6 +1960,15 @@ static void receive_buf(struct virtnet_info vi, struct receive_queue rq, · 2 unmodified lines
1951	return;	1960	return;
1952	}	1961	}
1953		1962
		1963	/* 1. Save the flags early, as the XDP program might overwrite them.
		1964	* These flags ensure packets marked as VIRTIO_NET_HDR_F_DATA_VALID
		1965	* stay valid after XDP processing.
		1966	* 2. XDP doesn't work with partially checksummed packets (refer to
		1967	* virtnet_xdp_set()), so packets marked as
		1968	* VIRTIO_NET_HDR_F_NEEDS_CSUM get dropped during XDP processing.
		1969	*/
		1970	flags = ((struct virtio_net_common_hdr *)buf)->hdr.flags;
		1971
1954	if (vi->mergeable_rx_bufs)	1972	if (vi->mergeable_rx_bufs)
1955	skb = receive_mergeable(dev, vi, rq, buf, ctx, len, xdp_xmit,	1973	skb = receive_mergeable(dev, vi, rq, buf, ctx, len, xdp_xmit,
1956	stats);	1974	stats);
@@ -1966,7 +1984,7 @@ static void receive_buf(struct virtnet_info vi, struct receive_queue rq, · 9 unmodified lines
1966	if (dev->features & NETIF_F_RXHASH && vi->has_rss_hash_report)	1984	if (dev->features & NETIF_F_RXHASH && vi->has_rss_hash_report)
1967	virtio_skb_set_hash(&hdr->hash_v1_hdr, skb);	1985	virtio_skb_set_hash(&hdr->hash_v1_hdr, skb);
1968		1986
1969	if (hdr->hdr.flags & VIRTIO_NET_HDR_F_DATA_VALID)	1987	if (flags & VIRTIO_NET_HDR_F_DATA_VALID)
1970	skb->ip_summed = CHECKSUM_UNNECESSARY;	1988	skb->ip_summed = CHECKSUM_UNNECESSARY;
1971		1989
1972	if (virtio_net_hdr_to_skb(skb, &hdr->hdr,	1990	if (virtio_net_hdr_to_skb(skb, &hdr->hdr,
@@ -5666,8 +5684,16 @@ static int virtnet_probe(struct virtio_device *vdev) · 3693 unmodified lines
5666	dev->features \|= dev->hw_features & NETIF_F_ALL_TSO;	5684	dev->features \|= dev->hw_features & NETIF_F_ALL_TSO;
5667	/* (!csum && gso) case will be fixed by register_netdev() */	5685	/* (!csum && gso) case will be fixed by register_netdev() */
5668	}	5686	}
5669	if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_CSUM))	5687
5670	dev->features \|= NETIF_F_RXCSUM;	5688	/* 1. With VIRTIO_NET_F_GUEST_CSUM negotiation, the driver doesn't
		5689	* need to calculate checksums for partially checksummed packets,
		5690	* as they're considered valid by the upper layer.
		5691	* 2. Without VIRTIO_NET_F_GUEST_CSUM negotiation, the driver only
		5692	* receives fully checksummed packets. The device may assist in
		5693	* validating these packets' checksums, so the driver won't have to.
		5694	*/
		5695	dev->features \|= NETIF_F_RXCSUM;
		5696
5671	if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4) \|\|	5697	if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4) \|\|
5672	virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6))	5698	virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6))
5673	dev->features \|= NETIF_F_GRO_HW;	5699	dev->features \|= NETIF_F_GRO_HW;

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

@@ -4795,7 +4795,7 @@ static int iwl_mvm_roc_station(struct iwl_mvm *mvm, · 4794 unmodified lines
4795		4795
4796	if (fw_ver == IWL_FW_CMD_VER_UNKNOWN) {	4796	if (fw_ver == IWL_FW_CMD_VER_UNKNOWN) {
4797	ret = iwl_mvm_send_aux_roc_cmd(mvm, channel, vif, duration);	4797	ret = iwl_mvm_send_aux_roc_cmd(mvm, channel, vif, duration);
4798	} else if (fw_ver == 3) {	4798	} else if (fw_ver >= 3) {
4799	ret = iwl_mvm_roc_add_cmd(mvm, channel, vif, duration,	4799	ret = iwl_mvm_roc_add_cmd(mvm, channel, vif, duration,
4800	ROC_ACTIVITY_HOTSPOT);	4800	ROC_ACTIVITY_HOTSPOT);
4801	} else {	4801	} else {

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

@@ -1830,7 +1830,7 @@ iwl_mvm_umac_scan_cfg_channels_v7_6g(struct iwl_mvm *mvm, · 1829 unmodified lines
1830	*/	1830	*/
1831	if (!iwl_mvm_is_scan_fragmented(params->type)) {	1831	if (!iwl_mvm_is_scan_fragmented(params->type)) {
1832	if (!cfg80211_channel_is_psc(params->channels[i]) \|\|	1832	if (!cfg80211_channel_is_psc(params->channels[i]) \|\|
1833	flags & IWL_UHB_CHAN_CFG_FLAG_PSC_CHAN_NO_LISTEN) {	1833	psc_no_listen) {
1834	if (unsolicited_probe_on_chan) {	1834	if (unsolicited_probe_on_chan) {
1835	max_s_ssids = 2;	1835	max_s_ssids = 2;
1836	max_bssids = 6;	1836	max_bssids = 6;

drivers/net/wireless/intel/iwlwifi/mvm/time-event.c+2−0

 			if (te_data->id >= SESSION_PROTECT_CONF_MAX_ID) {
 				IWL_DEBUG_TE(mvm,
 					     "No remain on channel event\n");
+				mutex_unlock(&mvm->mutex);
 				return;
 			}
 	te_data = iwl_mvm_get_roc_te(mvm);
 	if (!te_data) {
 		IWL_WARN(mvm, "No remain on channel event\n");
+		mutex_unlock(&mvm->mutex);
 		return;
 	}

drivers/phy/qualcomm/phy-qcom-qmp-combo.c+160−29

@@ -187,6 +187,31 @@ static const unsigned int qmp_v6_usb3phy_regs_layout[QPHY_LAYOUT_SIZE] = { · 186 unmodified lines
187	[QPHY_TX_TRANSCEIVER_BIAS_EN] = QSERDES_V6_TX_TRANSCEIVER_BIAS_EN,	187	[QPHY_TX_TRANSCEIVER_BIAS_EN] = QSERDES_V6_TX_TRANSCEIVER_BIAS_EN,
188	};	188	};
189		189
		190	static const unsigned int qmp_v6_n4_usb3phy_regs_layout[QPHY_LAYOUT_SIZE] = {
		191	[QPHY_SW_RESET] = QPHY_V6_N4_PCS_SW_RESET,
		192	[QPHY_START_CTRL] = QPHY_V6_N4_PCS_START_CONTROL,
		193	[QPHY_PCS_STATUS] = QPHY_V6_N4_PCS_PCS_STATUS1,
		194	[QPHY_PCS_POWER_DOWN_CONTROL] = QPHY_V6_N4_PCS_POWER_DOWN_CONTROL,
		195
		196	/* In PCS_USB */
		197	[QPHY_PCS_AUTONOMOUS_MODE_CTRL] = QPHY_V6_PCS_USB3_AUTONOMOUS_MODE_CTRL,
		198	[QPHY_PCS_LFPS_RXTERM_IRQ_CLEAR] = QPHY_V6_PCS_USB3_LFPS_RXTERM_IRQ_CLEAR,
		199
		200	[QPHY_COM_RESETSM_CNTRL] = QSERDES_V6_COM_RESETSM_CNTRL,
		201	[QPHY_COM_C_READY_STATUS] = QSERDES_V6_COM_C_READY_STATUS,
		202	[QPHY_COM_CMN_STATUS] = QSERDES_V6_COM_CMN_STATUS,
		203	[QPHY_COM_BIAS_EN_CLKBUFLR_EN] = QSERDES_V6_COM_PLL_BIAS_EN_CLK_BUFLR_EN,
		204
		205	[QPHY_DP_PHY_STATUS] = QSERDES_V6_DP_PHY_STATUS,
		206	[QPHY_DP_PHY_VCO_DIV] = QSERDES_V6_DP_PHY_VCO_DIV,
		207
		208	[QPHY_TX_TX_POL_INV] = QSERDES_V6_N4_TX_TX_POL_INV,
		209	[QPHY_TX_TX_DRV_LVL] = QSERDES_V6_N4_TX_TX_DRV_LVL,
		210	[QPHY_TX_TX_EMP_POST1_LVL] = QSERDES_V6_N4_TX_TX_EMP_POST1_LVL,
		211	[QPHY_TX_HIGHZ_DRVR_EN] = QSERDES_V6_N4_TX_HIGHZ_DRVR_EN,
		212	[QPHY_TX_TRANSCEIVER_BIAS_EN] = QSERDES_V6_N4_TX_TRANSCEIVER_BIAS_EN,
		213	};
		214
190	static const struct qmp_phy_init_tbl qmp_v3_usb3_serdes_tbl[] = {	215	static const struct qmp_phy_init_tbl qmp_v3_usb3_serdes_tbl[] = {
191	QMP_PHY_INIT_CFG(QSERDES_V3_COM_PLL_IVCO, 0x07),	216	QMP_PHY_INIT_CFG(QSERDES_V3_COM_PLL_IVCO, 0x07),
192	QMP_PHY_INIT_CFG(QSERDES_V3_COM_SYSCLK_EN_SEL, 0x14),	217	QMP_PHY_INIT_CFG(QSERDES_V3_COM_SYSCLK_EN_SEL, 0x14),
@@ -997,6 +1022,31 @@ static const struct qmp_phy_init_tbl qmp_v6_dp_serdes_tbl[] = { · 804 unmodified lines
997	QMP_PHY_INIT_CFG(QSERDES_V6_COM_CORE_CLK_EN, 0x0f),	1022	QMP_PHY_INIT_CFG(QSERDES_V6_COM_CORE_CLK_EN, 0x0f),
998	};	1023	};
999		1024
		1025	static const struct qmp_phy_init_tbl qmp_v6_n4_dp_serdes_tbl[] = {
		1026	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SVS_MODE_CLK_SEL, 0x15),
		1027	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SYSCLK_EN_SEL, 0x3b),
		1028	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SYS_CLK_CTRL, 0x02),
		1029	QMP_PHY_INIT_CFG(QSERDES_V6_COM_CLK_ENABLE1, 0x0c),
		1030	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SYSCLK_BUF_ENABLE, 0x06),
		1031	QMP_PHY_INIT_CFG(QSERDES_V6_COM_CLK_SELECT, 0x30),
		1032	QMP_PHY_INIT_CFG(QSERDES_V6_COM_PLL_IVCO, 0x07),
		1033	QMP_PHY_INIT_CFG(QSERDES_V6_COM_PLL_CCTRL_MODE0, 0x36),
		1034	QMP_PHY_INIT_CFG(QSERDES_V6_COM_PLL_RCTRL_MODE0, 0x16),
		1035	QMP_PHY_INIT_CFG(QSERDES_V6_COM_CP_CTRL_MODE0, 0x06),
		1036	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DEC_START_MODE0, 0x34),
		1037	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DIV_FRAC_START1_MODE0, 0x00),
		1038	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DIV_FRAC_START2_MODE0, 0xc0),
		1039	QMP_PHY_INIT_CFG(QSERDES_V6_COM_CMN_CONFIG_1, 0x12),
		1040	QMP_PHY_INIT_CFG(QSERDES_V6_COM_INTEGLOOP_GAIN0_MODE0, 0x3f),
		1041	QMP_PHY_INIT_CFG(QSERDES_V6_COM_INTEGLOOP_GAIN1_MODE0, 0x00),
		1042	QMP_PHY_INIT_CFG(QSERDES_V6_COM_VCO_TUNE_MAP, 0x00),
		1043	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BG_TIMER, 0x0a),
		1044	QMP_PHY_INIT_CFG(QSERDES_V6_COM_PLL_CORE_CLK_DIV_MODE0, 0x14),
		1045	QMP_PHY_INIT_CFG(QSERDES_V6_COM_VCO_TUNE_CTRL, 0x00),
		1046	QMP_PHY_INIT_CFG(QSERDES_V6_COM_PLL_BIAS_EN_CLK_BUFLR_EN, 0x17),
		1047	QMP_PHY_INIT_CFG(QSERDES_V6_COM_CORE_CLK_EN, 0x0f),
		1048	};
		1049
1000	static const struct qmp_phy_init_tbl qmp_v6_dp_tx_tbl[] = {	1050	static const struct qmp_phy_init_tbl qmp_v6_dp_tx_tbl[] = {
1001	QMP_PHY_INIT_CFG(QSERDES_V6_TX_VMODE_CTRL1, 0x40),	1051	QMP_PHY_INIT_CFG(QSERDES_V6_TX_VMODE_CTRL1, 0x40),
1002	QMP_PHY_INIT_CFG(QSERDES_V6_TX_PRE_STALL_LDO_BOOST_EN, 0x30),	1052	QMP_PHY_INIT_CFG(QSERDES_V6_TX_PRE_STALL_LDO_BOOST_EN, 0x30),
@@ -1011,6 +1061,19 @@ static const struct qmp_phy_init_tbl qmp_v6_dp_tx_tbl[] = { · 8 unmodified lines
1011	QMP_PHY_INIT_CFG(QSERDES_V6_TX_TX_BAND, 0x4),	1061	QMP_PHY_INIT_CFG(QSERDES_V6_TX_TX_BAND, 0x4),
1012	};	1062	};
1013		1063
		1064	static const struct qmp_phy_init_tbl qmp_v6_n4_dp_tx_tbl[] = {
		1065	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_VMODE_CTRL1, 0x40),
		1066	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_PRE_STALL_LDO_BOOST_EN, 0x00),
		1067	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_INTERFACE_SELECT, 0xff),
		1068	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_CLKBUF_ENABLE, 0x0f),
		1069	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_RESET_TSYNC_EN, 0x03),
		1070	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_TRAN_DRVR_EMP_EN, 0x0f),
		1071	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_PARRATE_REC_DETECT_IDLE_EN, 0x00),
		1072	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_RES_CODE_LANE_OFFSET_TX, 0x11),
		1073	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_RES_CODE_LANE_OFFSET_RX, 0x11),
		1074	QMP_PHY_INIT_CFG(QSERDES_V6_N4_TX_TX_BAND, 0x1),
		1075	};
		1076
1014	static const struct qmp_phy_init_tbl qmp_v6_dp_serdes_tbl_rbr[] = {	1077	static const struct qmp_phy_init_tbl qmp_v6_dp_serdes_tbl_rbr[] = {
1015	QMP_PHY_INIT_CFG(QSERDES_V6_COM_HSCLK_SEL_1, 0x05),	1078	QMP_PHY_INIT_CFG(QSERDES_V6_COM_HSCLK_SEL_1, 0x05),
1016	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DEC_START_MODE0, 0x34),	1079	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DEC_START_MODE0, 0x34),
@@ -1059,6 +1122,74 @@ static const struct qmp_phy_init_tbl qmp_v6_dp_serdes_tbl_hbr3[] = { · 42 unmodified lines
1059	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE2_MODE0, 0x0c),	1122	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE2_MODE0, 0x0c),
1060	};	1123	};
1061		1124
		1125	static const struct qmp_phy_init_tbl qmp_v6_n4_dp_serdes_tbl_rbr[] = {
		1126	QMP_PHY_INIT_CFG(QSERDES_V6_COM_HSCLK_SEL_1, 0x05),
		1127	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DEC_START_MODE0, 0x34),
		1128	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP_EN, 0x04),
		1129	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DIV_FRAC_START3_MODE0, 0x0b),
		1130	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP1_MODE0, 0x37),
		1131	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP2_MODE0, 0x04),
		1132	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE1_MODE0, 0x71),
		1133	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE2_MODE0, 0x0c),
		1134	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_EN_CENTER, 0x01),
		1135	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_ADJ_PER1, 0x00),
		1136	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER1, 0x6b),
		1137	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER2, 0x02),
		1138	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE1_MODE0, 0x92),
		1139	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE2_MODE0, 0x01),
		1140	};
		1141
		1142	static const struct qmp_phy_init_tbl qmp_v6_n4_dp_serdes_tbl_hbr[] = {
		1143	QMP_PHY_INIT_CFG(QSERDES_V6_COM_HSCLK_SEL_1, 0x03),
		1144	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DEC_START_MODE0, 0x34),
		1145	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP_EN, 0x08),
		1146	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DIV_FRAC_START3_MODE0, 0x0b),
		1147	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP1_MODE0, 0x07),
		1148	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP2_MODE0, 0x07),
		1149	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE1_MODE0, 0x71),
		1150	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE2_MODE0, 0x0c),
		1151	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_EN_CENTER, 0x01),
		1152	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_ADJ_PER1, 0x00),
		1153	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER1, 0x6b),
		1154	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER2, 0x02),
		1155	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE1_MODE0, 0x92),
		1156	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE2_MODE0, 0x01),
		1157	};
		1158
		1159	static const struct qmp_phy_init_tbl qmp_v6_n4_dp_serdes_tbl_hbr2[] = {
		1160	QMP_PHY_INIT_CFG(QSERDES_V6_COM_HSCLK_SEL_1, 0x01),
		1161	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DEC_START_MODE0, 0x46),
		1162	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP_EN, 0x08),
		1163	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DIV_FRAC_START3_MODE0, 0x05),
		1164	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP1_MODE0, 0x0f),
		1165	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP2_MODE0, 0x0e),
		1166	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE1_MODE0, 0x97),
		1167	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE2_MODE0, 0x10),
		1168	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_EN_CENTER, 0x01),
		1169	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_ADJ_PER1, 0x00),
		1170	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER1, 0x6b),
		1171	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER2, 0x02),
		1172	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE1_MODE0, 0x18),
		1173	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE2_MODE0, 0x02),
		1174	};
		1175
		1176	static const struct qmp_phy_init_tbl qmp_v6_n4_dp_serdes_tbl_hbr3[] = {
		1177	QMP_PHY_INIT_CFG(QSERDES_V6_COM_HSCLK_SEL_1, 0x00),
		1178	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DEC_START_MODE0, 0x34),
		1179	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP_EN, 0x08),
		1180	QMP_PHY_INIT_CFG(QSERDES_V6_COM_DIV_FRAC_START3_MODE0, 0x0b),
		1181	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP1_MODE0, 0x17),
		1182	QMP_PHY_INIT_CFG(QSERDES_V6_COM_LOCK_CMP2_MODE0, 0x15),
		1183	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE1_MODE0, 0x71),
		1184	QMP_PHY_INIT_CFG(QSERDES_V6_COM_BIN_VCOCAL_CMP_CODE2_MODE0, 0x0c),
		1185	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_EN_CENTER, 0x01),
		1186	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_ADJ_PER1, 0x00),
		1187	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER1, 0x6b),
		1188	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_PER2, 0x02),
		1189	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE1_MODE0, 0x92),
		1190	QMP_PHY_INIT_CFG(QSERDES_V6_COM_SSC_STEP_SIZE2_MODE0, 0x01),
		1191	};
		1192
1062	static const struct qmp_phy_init_tbl sc8280xp_usb43dp_serdes_tbl[] = {	1193	static const struct qmp_phy_init_tbl sc8280xp_usb43dp_serdes_tbl[] = {
1063	QMP_PHY_INIT_CFG(QSERDES_V5_COM_SSC_EN_CENTER, 0x01),	1194	QMP_PHY_INIT_CFG(QSERDES_V5_COM_SSC_EN_CENTER, 0x01),
1064	QMP_PHY_INIT_CFG(QSERDES_V5_COM_SSC_PER1, 0x31),	1195	QMP_PHY_INIT_CFG(QSERDES_V5_COM_SSC_PER1, 0x31),
@@ -1273,20 +1404,20 @@ static const struct qmp_phy_init_tbl x1e80100_usb43dp_rx_tbl[] = { · 208 unmodified lines
1273	};	1404	};
1274		1405
1275	static const struct qmp_phy_init_tbl x1e80100_usb43dp_pcs_tbl[] = {	1406	static const struct qmp_phy_init_tbl x1e80100_usb43dp_pcs_tbl[] = {
1276	QMP_PHY_INIT_CFG(QPHY_V6_PCS_RCVR_DTCT_DLY_P1U2_L, 0xe7),	1407	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_RCVR_DTCT_DLY_P1U2_L, 0xe7),
1277	QMP_PHY_INIT_CFG(QPHY_V6_PCS_RCVR_DTCT_DLY_P1U2_H, 0x03),	1408	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_RCVR_DTCT_DLY_P1U2_H, 0x03),
1278	QMP_PHY_INIT_CFG(QPHY_V6_PCS_LOCK_DETECT_CONFIG1, 0xc4),	1409	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG1, 0xc4),
1279	QMP_PHY_INIT_CFG(QPHY_V6_PCS_LOCK_DETECT_CONFIG2, 0x89),	1410	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG2, 0x89),
1280	QMP_PHY_INIT_CFG(QPHY_V6_PCS_LOCK_DETECT_CONFIG3, 0x20),	1411	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG3, 0x20),
1281	QMP_PHY_INIT_CFG(QPHY_V6_PCS_LOCK_DETECT_CONFIG6, 0x13),	1412	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG6, 0x13),
1282	QMP_PHY_INIT_CFG(QPHY_V6_PCS_REFGEN_REQ_CONFIG1, 0x21),	1413	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_REFGEN_REQ_CONFIG1, 0x21),
1283	QMP_PHY_INIT_CFG(QPHY_V6_PCS_RX_SIGDET_LVL, 0x55),	1414	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_RX_SIGDET_LVL, 0x55),
1284	QMP_PHY_INIT_CFG(QPHY_V6_PCS_CDR_RESET_TIME, 0x0a),	1415	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_RX_CONFIG, 0x0a),
1285	QMP_PHY_INIT_CFG(QPHY_V6_PCS_ALIGN_DETECT_CONFIG1, 0xd4),	1416	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_ALIGN_DETECT_CONFIG1, 0xd4),
1286	QMP_PHY_INIT_CFG(QPHY_V6_PCS_ALIGN_DETECT_CONFIG2, 0x30),	1417	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_ALIGN_DETECT_CONFIG2, 0x30),
1287	QMP_PHY_INIT_CFG(QPHY_V6_PCS_PCS_TX_RX_CONFIG, 0x0c),	1418	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_PCS_TX_RX_CONFIG, 0x0c),
1288	QMP_PHY_INIT_CFG(QPHY_V6_PCS_EQ_CONFIG1, 0x4b),	1419	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_EQ_CONFIG1, 0x4b),
1289	QMP_PHY_INIT_CFG(QPHY_V6_PCS_EQ_CONFIG5, 0x10),	1420	QMP_PHY_INIT_CFG(QPHY_V6_N4_PCS_EQ_CONFIG5, 0x10),
1290	};	1421	};
1291		1422
1292	static const struct qmp_phy_init_tbl x1e80100_usb43dp_pcs_usb_tbl[] = {	1423	static const struct qmp_phy_init_tbl x1e80100_usb43dp_pcs_usb_tbl[] = {
@@ -1794,22 +1925,22 @@ static const struct qmp_phy_cfg x1e80100_usb3dpphy_cfg = { · 501 unmodified lines
1794	.pcs_usb_tbl = x1e80100_usb43dp_pcs_usb_tbl,	1925	.pcs_usb_tbl = x1e80100_usb43dp_pcs_usb_tbl,
1795	.pcs_usb_tbl_num = ARRAY_SIZE(x1e80100_usb43dp_pcs_usb_tbl),	1926	.pcs_usb_tbl_num = ARRAY_SIZE(x1e80100_usb43dp_pcs_usb_tbl),
1796		1927
1797	.dp_serdes_tbl = qmp_v6_dp_serdes_tbl,	1928	.dp_serdes_tbl = qmp_v6_n4_dp_serdes_tbl,
1798	.dp_serdes_tbl_num = ARRAY_SIZE(qmp_v6_dp_serdes_tbl),	1929	.dp_serdes_tbl_num = ARRAY_SIZE(qmp_v6_n4_dp_serdes_tbl),
1799	.dp_tx_tbl = qmp_v6_dp_tx_tbl,	1930	.dp_tx_tbl = qmp_v6_n4_dp_tx_tbl,
1800	.dp_tx_tbl_num = ARRAY_SIZE(qmp_v6_dp_tx_tbl),	1931	.dp_tx_tbl_num = ARRAY_SIZE(qmp_v6_n4_dp_tx_tbl),
1801		1932
1802	.serdes_tbl_rbr = qmp_v6_dp_serdes_tbl_rbr,	1933	.serdes_tbl_rbr = qmp_v6_n4_dp_serdes_tbl_rbr,
1803	.serdes_tbl_rbr_num = ARRAY_SIZE(qmp_v6_dp_serdes_tbl_rbr),	1934	.serdes_tbl_rbr_num = ARRAY_SIZE(qmp_v6_n4_dp_serdes_tbl_rbr),
1804	.serdes_tbl_hbr = qmp_v6_dp_serdes_tbl_hbr,	1935	.serdes_tbl_hbr = qmp_v6_n4_dp_serdes_tbl_hbr,
1805	.serdes_tbl_hbr_num = ARRAY_SIZE(qmp_v6_dp_serdes_tbl_hbr),	1936	.serdes_tbl_hbr_num = ARRAY_SIZE(qmp_v6_n4_dp_serdes_tbl_hbr),
1806	.serdes_tbl_hbr2 = qmp_v6_dp_serdes_tbl_hbr2,	1937	.serdes_tbl_hbr2 = qmp_v6_n4_dp_serdes_tbl_hbr2,
1807	.serdes_tbl_hbr2_num = ARRAY_SIZE(qmp_v6_dp_serdes_tbl_hbr2),	1938	.serdes_tbl_hbr2_num = ARRAY_SIZE(qmp_v6_n4_dp_serdes_tbl_hbr2),
1808	.serdes_tbl_hbr3 = qmp_v6_dp_serdes_tbl_hbr3,	1939	.serdes_tbl_hbr3 = qmp_v6_n4_dp_serdes_tbl_hbr3,
1809	.serdes_tbl_hbr3_num = ARRAY_SIZE(qmp_v6_dp_serdes_tbl_hbr3),	1940	.serdes_tbl_hbr3_num = ARRAY_SIZE(qmp_v6_n4_dp_serdes_tbl_hbr3),
1810		1941
1811	.swing_hbr_rbr = &qmp_dp_v5_voltage_swing_hbr_rbr,	1942	.swing_hbr_rbr = &qmp_dp_v6_voltage_swing_hbr_rbr,
1812	.pre_emphasis_hbr_rbr = &qmp_dp_v5_pre_emphasis_hbr_rbr,	1943	.pre_emphasis_hbr_rbr = &qmp_dp_v6_pre_emphasis_hbr_rbr,
1813	.swing_hbr3_hbr2 = &qmp_dp_v5_voltage_swing_hbr3_hbr2,	1944	.swing_hbr3_hbr2 = &qmp_dp_v5_voltage_swing_hbr3_hbr2,
1814	.pre_emphasis_hbr3_hbr2 = &qmp_dp_v5_pre_emphasis_hbr3_hbr2,	1945	.pre_emphasis_hbr3_hbr2 = &qmp_dp_v5_pre_emphasis_hbr3_hbr2,
1815		1946
@@ -1822,7 +1953,7 @@ static const struct qmp_phy_cfg x1e80100_usb3dpphy_cfg = { · 6 unmodified lines
1822	.num_resets = ARRAY_SIZE(msm8996_usb3phy_reset_l),	1953	.num_resets = ARRAY_SIZE(msm8996_usb3phy_reset_l),
1823	.vreg_list = qmp_phy_vreg_l,	1954	.vreg_list = qmp_phy_vreg_l,
1824	.num_vregs = ARRAY_SIZE(qmp_phy_vreg_l),	1955	.num_vregs = ARRAY_SIZE(qmp_phy_vreg_l),
1825	.regs = qmp_v45_usb3phy_regs_layout,	1956	.regs = qmp_v6_n4_usb3phy_regs_layout,
1826	};	1957	};
1827		1958
1828	static const struct qmp_phy_cfg sm6350_usb3dpphy_cfg = {	1959	static const struct qmp_phy_cfg sm6350_usb3dpphy_cfg = {

drivers/phy/qualcomm/phy-qcom-qmp-pcs-v6-n4.h+32−0

@@ -0,0 +1,32 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Copyright (c) 2023, Linaro Limited
	4	*/
	5
	6	#ifndef QCOM_PHY_QMP_PCS_V6_N4_H_
	7	#define QCOM_PHY_QMP_PCS_V6_N4_H_
	8
	9	/* Only for QMP V6 N4 PHY - USB/PCIe PCS registers */
	10	#define QPHY_V6_N4_PCS_SW_RESET 0x000
	11	#define QPHY_V6_N4_PCS_PCS_STATUS1 0x014
	12	#define QPHY_V6_N4_PCS_POWER_DOWN_CONTROL 0x040
	13	#define QPHY_V6_N4_PCS_START_CONTROL 0x044
	14	#define QPHY_V6_N4_PCS_POWER_STATE_CONFIG1 0x090
	15	#define QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG1 0x0c4
	16	#define QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG2 0x0c8
	17	#define QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG3 0x0cc
	18	#define QPHY_V6_N4_PCS_LOCK_DETECT_CONFIG6 0x0d8
	19	#define QPHY_V6_N4_PCS_REFGEN_REQ_CONFIG1 0x0dc
	20	#define QPHY_V6_N4_PCS_RX_SIGDET_LVL 0x188
	21	#define QPHY_V6_N4_PCS_RCVR_DTCT_DLY_P1U2_L 0x190
	22	#define QPHY_V6_N4_PCS_RCVR_DTCT_DLY_P1U2_H 0x194
	23	#define QPHY_V6_N4_PCS_RATE_SLEW_CNTRL1 0x198
	24	#define QPHY_V6_N4_PCS_RX_CONFIG 0x1b0
	25	#define QPHY_V6_N4_PCS_ALIGN_DETECT_CONFIG1 0x1c0
	26	#define QPHY_V6_N4_PCS_ALIGN_DETECT_CONFIG2 0x1c4
	27	#define QPHY_V6_N4_PCS_PCS_TX_RX_CONFIG 0x1d0
	28	#define QPHY_V6_N4_PCS_EQ_CONFIG1 0x1dc
	29	#define QPHY_V6_N4_PCS_EQ_CONFIG2 0x1e0
	30	#define QPHY_V6_N4_PCS_EQ_CONFIG5 0x1ec
	31
	32	#endif

drivers/phy/qualcomm/phy-qcom-qmp-qserdes-txrx-v6_n4.h+13−0

@@ -6,11 +6,24 @@ · 5 unmodified lines
6	#ifndef QCOM_PHY_QMP_QSERDES_TXRX_V6_N4_H_	6	#ifndef QCOM_PHY_QMP_QSERDES_TXRX_V6_N4_H_
7	#define QCOM_PHY_QMP_QSERDES_TXRX_V6_N4_H_	7	#define QCOM_PHY_QMP_QSERDES_TXRX_V6_N4_H_
8		8
		9	#define QSERDES_V6_N4_TX_CLKBUF_ENABLE 0x08
		10	#define QSERDES_V6_N4_TX_TX_EMP_POST1_LVL 0x0c
		11	#define QSERDES_V6_N4_TX_TX_DRV_LVL 0x14
		12	#define QSERDES_V6_N4_TX_RESET_TSYNC_EN 0x1c
		13	#define QSERDES_V6_N4_TX_PRE_STALL_LDO_BOOST_EN 0x20
9	#define QSERDES_V6_N4_TX_RES_CODE_LANE_OFFSET_TX 0x30	14	#define QSERDES_V6_N4_TX_RES_CODE_LANE_OFFSET_TX 0x30
10	#define QSERDES_V6_N4_TX_RES_CODE_LANE_OFFSET_RX 0x34	15	#define QSERDES_V6_N4_TX_RES_CODE_LANE_OFFSET_RX 0x34
		16	#define QSERDES_V6_N4_TX_TRANSCEIVER_BIAS_EN 0x48
		17	#define QSERDES_V6_N4_TX_HIGHZ_DRVR_EN 0x4c
		18	#define QSERDES_V6_N4_TX_TX_POL_INV 0x50
		19	#define QSERDES_V6_N4_TX_PARRATE_REC_DETECT_IDLE_EN 0x54
11	#define QSERDES_V6_N4_TX_LANE_MODE_1 0x78	20	#define QSERDES_V6_N4_TX_LANE_MODE_1 0x78
12	#define QSERDES_V6_N4_TX_LANE_MODE_2 0x7c	21	#define QSERDES_V6_N4_TX_LANE_MODE_2 0x7c
13	#define QSERDES_V6_N4_TX_LANE_MODE_3 0x80	22	#define QSERDES_V6_N4_TX_LANE_MODE_3 0x80
		23	#define QSERDES_V6_N4_TX_TRAN_DRVR_EMP_EN 0xac
		24	#define QSERDES_V6_N4_TX_TX_BAND 0xd8
		25	#define QSERDES_V6_N4_TX_INTERFACE_SELECT 0xe4
		26	#define QSERDES_V6_N4_TX_VMODE_CTRL1 0xb0
14		27
15	#define QSERDES_V6_N4_RX_UCDR_FO_GAIN_RATE2 0x8	28	#define QSERDES_V6_N4_RX_UCDR_FO_GAIN_RATE2 0x8
16	#define QSERDES_V6_N4_RX_UCDR_SO_GAIN_RATE2 0x18	29	#define QSERDES_V6_N4_RX_UCDR_SO_GAIN_RATE2 0x18

drivers/phy/qualcomm/phy-qcom-qmp.h+2−0

@@ -46,6 +46,8 @@ · 45 unmodified lines
46		46
47	#include "phy-qcom-qmp-pcs-v6.h"	47	#include "phy-qcom-qmp-pcs-v6.h"
48		48
		49	#include "phy-qcom-qmp-pcs-v6-n4.h"
		50
49	#include "phy-qcom-qmp-pcs-v6_20.h"	51	#include "phy-qcom-qmp-pcs-v6_20.h"
50		52
51	#include "phy-qcom-qmp-pcs-v7.h"	53	#include "phy-qcom-qmp-pcs-v7.h"

drivers/ptp/ptp_sysfs.c+1−2

@@ -296,8 +296,7 @@ static ssize_t max_vclocks_store(struct device *dev, · 295 unmodified lines
296	if (max < ptp->n_vclocks)	296	if (max < ptp->n_vclocks)
297	goto out;	297	goto out;
298		298
299	size = sizeof(int) * max;	299	vclock_index = kcalloc(max, sizeof(int), GFP_KERNEL);
300	vclock_index = kzalloc(size, GFP_KERNEL);
301	if (!vclock_index) {	300	if (!vclock_index) {
302	err = -ENOMEM;	301	err = -ENOMEM;
303	goto out;	302	goto out;

drivers/pwm/pwm-stm32.c+16−7

 	 * First we need to find the minimal value for prescaler such that
 	 *
 	 *        period_ns * clkrate
-	 *   ------------------------------
+	 *   ------------------------------ < max_arr + 1
 	 *   NSEC_PER_SEC * (prescaler + 1)
 	 *
-	 * isn't bigger than max_arr.
+	 * This equation is equivalent to
+	 *
+	 *        period_ns * clkrate
+	 *   ---------------------------- < prescaler + 1
+	 *   NSEC_PER_SEC * (max_arr + 1)
+	 *
+	 * Using integer division and knowing that the right hand side is
+	 * integer, this is further equivalent to
+	 *
+	 *   (period_ns * clkrate) // (NSEC_PER_SEC * (max_arr + 1)) ≤ prescaler
 	 */
 	prescaler = mul_u64_u64_div_u64(period_ns, clk_get_rate(priv->clk),
-					(u64)NSEC_PER_SEC * priv->max_arr);
+					(u64)NSEC_PER_SEC * ((u64)priv->max_arr + 1));
-	if (prescaler > 0)
-		prescaler -= 1;
 	if (prescaler > MAX_TIM_PSC)
 		return -EINVAL;
 	prd = mul_u64_u64_div_u64(period_ns, clk_get_rate(priv->clk),
 				  (u64)NSEC_PER_SEC * (prescaler + 1));
+	if (!prd)
+		return -EINVAL;
 	/*
 	 * All channels share the same prescaler and counter so when two
 	 * .apply() won't overflow.
 	 */
 	if (clk_get_rate(priv->clk) > 1000000000)
-		return dev_err_probe(dev, -EINVAL, "Failed to lock clock\n");
+		return dev_err_probe(dev, -EINVAL, "Clock freq too high (%lu)\n",
+				     clk_get_rate(priv->clk));
 	chip->ops = &stm32pwm_ops;

drivers/regulator/Kconfig+9−0

@@ -1634,6 +1634,15 @@ config REGULATOR_UNIPHIER · 1633 unmodified lines
1634	help	1634	help
1635	Support for regulators implemented on Socionext UniPhier SoCs.	1635	Support for regulators implemented on Socionext UniPhier SoCs.
1636		1636
		1637	config REGULATOR_RZG2L_VBCTRL
		1638	tristate "Renesas RZ/G2L USB VBUS regulator driver"
		1639	depends on ARCH_RZG2L \|\| COMPILE_TEST
		1640	depends on OF
		1641	select REGMAP_MMIO
		1642	default ARCH_RZG2L
		1643	help
		1644	Support for VBUS regulators implemented on Renesas RZ/G2L SoCs.
		1645
1637	config REGULATOR_VCTRL	1646	config REGULATOR_VCTRL
1638	tristate "Voltage controlled regulators"	1647	tristate "Voltage controlled regulators"
1639	depends on OF	1648	depends on OF

drivers/regulator/Makefile+1−0

@@ -189,6 +189,7 @@ obj-$(CONFIG_REGULATOR_TPS65132) += tps65132-regulator.o · 188 unmodified lines
189	obj-$(CONFIG_REGULATOR_TPS68470) += tps68470-regulator.o	189	obj-$(CONFIG_REGULATOR_TPS68470) += tps68470-regulator.o
190	obj-$(CONFIG_REGULATOR_TWL4030) += twl-regulator.o twl6030-regulator.o	190	obj-$(CONFIG_REGULATOR_TWL4030) += twl-regulator.o twl6030-regulator.o
191	obj-$(CONFIG_REGULATOR_UNIPHIER) += uniphier-regulator.o	191	obj-$(CONFIG_REGULATOR_UNIPHIER) += uniphier-regulator.o
		192	obj-$(CONFIG_REGULATOR_RZG2L_VBCTRL) += renesas-usb-vbus-regulator.o
192	obj-$(CONFIG_REGULATOR_VCTRL) += vctrl-regulator.o	193	obj-$(CONFIG_REGULATOR_VCTRL) += vctrl-regulator.o
193	obj-$(CONFIG_REGULATOR_VEXPRESS) += vexpress-regulator.o	194	obj-$(CONFIG_REGULATOR_VEXPRESS) += vexpress-regulator.o
194	obj-$(CONFIG_REGULATOR_VQMMC_IPQ4019) += vqmmc-ipq4019-regulator.o	195	obj-$(CONFIG_REGULATOR_VQMMC_IPQ4019) += vqmmc-ipq4019-regulator.o

drivers/regulator/axp20x-regulator.c+19−14

 #define AXP717_DCDC1_NUM_VOLTAGES	88
 #define AXP717_DCDC2_NUM_VOLTAGES	107
-#define AXP717_DCDC3_NUM_VOLTAGES	104
+#define AXP717_DCDC3_NUM_VOLTAGES	103
 #define AXP717_DCDC_V_OUT_MASK		GENMASK(6, 0)
 #define AXP717_LDO_V_OUT_MASK		GENMASK(4, 0)
 	REGULATOR_LINEAR_RANGE(1220000, 71, 87, 20000),
 };
+/*
+ * The manual says that the last voltage is 3.4V, encoded as 0b1101011 (107),
+ * but every other method proves that this is wrong, so it's really 106 that
+ * programs the final 3.4V.
+ */
 static const struct linear_range axp717_dcdc2_ranges[] = {
 	REGULATOR_LINEAR_RANGE(500000,   0,  70,  10000),
 	REGULATOR_LINEAR_RANGE(1220000, 71,  87,  20000),
-	REGULATOR_LINEAR_RANGE(1600000, 88, 107, 100000),
+	REGULATOR_LINEAR_RANGE(1600000, 88, 106, 100000),
 };
 static const struct linear_range axp717_dcdc3_ranges[] = {
 	AXP_DESC(AXP717, DCDC4, "dcdc4", "vin4", 1000, 3700, 100,
 		 AXP717_DCDC4_CONTROL, AXP717_DCDC_V_OUT_MASK,
 		 AXP717_DCDC_OUTPUT_CONTROL, BIT(3)),
-	AXP_DESC(AXP717, ALDO1, "aldo1", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, ALDO1, "aldo1", "aldoin", 500, 3500, 100,
 		 AXP717_ALDO1_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(0)),
-	AXP_DESC(AXP717, ALDO2, "aldo2", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, ALDO2, "aldo2", "aldoin", 500, 3500, 100,
 		 AXP717_ALDO2_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(1)),
-	AXP_DESC(AXP717, ALDO3, "aldo3", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, ALDO3, "aldo3", "aldoin", 500, 3500, 100,
 		 AXP717_ALDO3_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(2)),
-	AXP_DESC(AXP717, ALDO4, "aldo4", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, ALDO4, "aldo4", "aldoin", 500, 3500, 100,
 		 AXP717_ALDO4_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(3)),
-	AXP_DESC(AXP717, BLDO1, "bldo1", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, BLDO1, "bldo1", "bldoin", 500, 3500, 100,
 		 AXP717_BLDO1_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(4)),
-	AXP_DESC(AXP717, BLDO2, "bldo2", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, BLDO2, "bldo2", "bldoin", 500, 3500, 100,
 		 AXP717_BLDO2_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(5)),
-	AXP_DESC(AXP717, BLDO3, "bldo3", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, BLDO3, "bldo3", "bldoin", 500, 3500, 100,
 		 AXP717_BLDO3_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(6)),
-	AXP_DESC(AXP717, BLDO4, "bldo4", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, BLDO4, "bldo4", "bldoin", 500, 3500, 100,
 		 AXP717_BLDO4_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO0_OUTPUT_CONTROL, BIT(7)),
-	AXP_DESC(AXP717, CLDO1, "cldo1", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, CLDO1, "cldo1", "cldoin", 500, 3500, 100,
 		 AXP717_CLDO1_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO1_OUTPUT_CONTROL, BIT(0)),
-	AXP_DESC(AXP717, CLDO2, "cldo2", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, CLDO2, "cldo2", "cldoin", 500, 3500, 100,
 		 AXP717_CLDO2_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO1_OUTPUT_CONTROL, BIT(1)),
-	AXP_DESC(AXP717, CLDO3, "cldo3", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, CLDO3, "cldo3", "cldoin", 500, 3500, 100,
 		 AXP717_CLDO3_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO1_OUTPUT_CONTROL, BIT(2)),
-	AXP_DESC(AXP717, CLDO4, "cldo4", "vin1", 500, 3500, 100,
+	AXP_DESC(AXP717, CLDO4, "cldo4", "cldoin", 500, 3500, 100,
 		 AXP717_CLDO4_CONTROL, AXP717_LDO_V_OUT_MASK,
 		 AXP717_LDO1_OUTPUT_CONTROL, BIT(3)),
 	AXP_DESC(AXP717, CPUSLDO, "cpusldo", "vin1", 500, 1400, 50,

drivers/regulator/bd71815-regulator.c+1−1

@@ -256,7 +256,7 @@ static int buck12_set_hw_dvs_levels(struct device_node *np, · 255 unmodified lines
256	* 10: 2.50mV/usec 10mV 4uS	256	* 10: 2.50mV/usec 10mV 4uS
257	* 11: 1.25mV/usec 10mV 8uS	257	* 11: 1.25mV/usec 10mV 8uS
258	*/	258	*/
259	static const unsigned int bd7181x_ramp_table[] = { 1250, 2500, 5000, 10000 };	259	static const unsigned int bd7181x_ramp_table[] = { 10000, 5000, 2500, 1250 };
260		260
261	static int bd7181x_led_set_current_limit(struct regulator_dev *rdev,	261	static int bd7181x_led_set_current_limit(struct regulator_dev *rdev,
262	int min_uA, int max_uA)	262	int min_uA, int max_uA)

drivers/regulator/core.c+29−0

@@ -3347,6 +3347,7 @@ struct regmap regulator_get_regmap(struct regulator regulator) · 3346 unmodified lines
3347		3347
3348	return map ? map : ERR_PTR(-EOPNOTSUPP);	3348	return map ? map : ERR_PTR(-EOPNOTSUPP);
3349	}	3349	}
		3350	EXPORT_SYMBOL_GPL(regulator_get_regmap);
3350		3351
3351	/**	3352	/**
3352	* regulator_get_hardware_vsel_register - get the HW voltage selector register	3353	* regulator_get_hardware_vsel_register - get the HW voltage selector register
@@ -3407,6 +3408,34 @@ int regulator_list_hardware_vsel(struct regulator *regulator, · 54 unmodified lines
3407	}	3408	}
3408	EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);	3409	EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);
3409		3410
		3411	/**
		3412	* regulator_hardware_enable - access the HW for enable/disable regulator
		3413	* @regulator: regulator source
		3414	* @enable: true for enable, false for disable
		3415	*
		3416	* Request that the regulator be enabled/disabled with the regulator output at
		3417	* the predefined voltage or current value.
		3418	*
		3419	* On success 0 is returned, otherwise a negative errno is returned.
		3420	*/
		3421	int regulator_hardware_enable(struct regulator *regulator, bool enable)
		3422	{
		3423	struct regulator_dev *rdev = regulator->rdev;
		3424	const struct regulator_ops *ops = rdev->desc->ops;
		3425	int ret = -EOPNOTSUPP;
		3426
		3427	if (!rdev->exclusive \|\| !ops \|\| !ops->enable \|\| !ops->disable)
		3428	return ret;
		3429
		3430	if (enable)
		3431	ret = ops->enable(rdev);
		3432	else
		3433	ret = ops->disable(rdev);
		3434
		3435	return ret;
		3436	}
		3437	EXPORT_SYMBOL_GPL(regulator_hardware_enable);
		3438
3410	/**	3439	/**
3411	* regulator_get_linear_step - return the voltage step size between VSEL values	3440	* regulator_get_linear_step - return the voltage step size between VSEL values
3412	* @regulator: regulator source	3441	* @regulator: regulator source

drivers/regulator/renesas-usb-vbus-regulator.c+74−0

@@ -0,0 +1,74 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	//
	3	// Renesas USB VBUS output regulator driver
	4	//
	5	// Copyright (C) 2024 Renesas Electronics Corporation
	6	//
	7
	8	#include <linux/module.h>
	9	#include <linux/err.h>
	10	#include <linux/kernel.h>
	11	#include <linux/of.h>
	12	#include <linux/platform_device.h>
	13	#include <linux/regmap.h>
	14	#include <linux/regulator/driver.h>
	15	#include <linux/regulator/of_regulator.h>
	16
	17	static const struct regulator_ops rzg2l_usb_vbus_reg_ops = {
	18	.enable = regulator_enable_regmap,
	19	.disable = regulator_disable_regmap,
	20	.is_enabled = regulator_is_enabled_regmap,
	21	};
	22
	23	static const struct regulator_desc rzg2l_usb_vbus_rdesc = {
	24	.name = "vbus",
	25	.of_match = of_match_ptr("regulator-vbus"),
	26	.ops = &rzg2l_usb_vbus_reg_ops,
	27	.type = REGULATOR_VOLTAGE,
	28	.owner = THIS_MODULE,
	29	.enable_reg = 0,
	30	.enable_mask = BIT(0),
	31	.enable_is_inverted = true,
	32	.fixed_uV = 5000000,
	33	.n_voltages = 1,
	34	};
	35
	36	static int rzg2l_usb_vbus_regulator_probe(struct platform_device *pdev)
	37	{
	38	struct regulator_config config = { };
	39	struct device *dev = &pdev->dev;
	40	struct regulator_dev *rdev;
	41
	42	config.regmap = dev_get_regmap(dev->parent, NULL);
	43	if (!config.regmap)
	44	return dev_err_probe(dev, -ENOENT, "Failed to get regmap\n");
	45
	46	config.dev = dev;
	47	config.of_node = of_get_child_by_name(dev->parent->of_node, "regulator-vbus");
	48	if (!config.of_node)
	49	return dev_err_probe(dev, -ENODEV, "regulator node not found\n");
	50
	51	rdev = devm_regulator_register(dev, &rzg2l_usb_vbus_rdesc, &config);
	52	if (IS_ERR(rdev)) {
	53	of_node_put(config.of_node);
	54	return dev_err_probe(dev, PTR_ERR(rdev),
	55	"not able to register vbus regulator\n");
	56	}
	57
	58	of_node_put(config.of_node);
	59
	60	return 0;
	61	}
	62
	63	static struct platform_driver rzg2l_usb_vbus_regulator_driver = {
	64	.probe = rzg2l_usb_vbus_regulator_probe,
	65	.driver = {
	66	.name = "rzg2l-usb-vbus-regulator",
	67	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
	68	},
	69	};
	70	module_platform_driver(rzg2l_usb_vbus_regulator_driver);
	71
	72	MODULE_AUTHOR("Biju Das <biju.das.jz@bp.renesas.com>");
	73	MODULE_DESCRIPTION("Renesas RZ/G2L USB Vbus Regulator Driver");
	74	MODULE_LICENSE("GPL");

drivers/regulator/tps6594-regulator.c+4−8

 		}
 	}
-	if (tps->chip_id == LP8764) {
+	if (tps->chip_id == TPS65224) {
-		nr_buck = ARRAY_SIZE(buck_regs);
-		nr_ldo = 0;
-		nr_types = REGS_INT_NB;
-	} else if (tps->chip_id == TPS65224) {
 		nr_buck = ARRAY_SIZE(tps65224_buck_regs);
 		nr_ldo = ARRAY_SIZE(tps65224_ldo_regs);
-		nr_types = REGS_INT_NB;
+		nr_types = TPS65224_REGS_INT_NB;
 	} else {
 		nr_buck = ARRAY_SIZE(buck_regs);
-		nr_ldo = ARRAY_SIZE(tps6594_ldo_regs);
+		nr_ldo = (tps->chip_id == LP8764) ? 0 : ARRAY_SIZE(tps6594_ldo_regs);
-		nr_types = TPS65224_REGS_INT_NB;
+		nr_types = REGS_INT_NB;
 	}
 	reg_irq_nb = nr_types * (nr_buck + nr_ldo);

drivers/scsi/sd.c+4−0

 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_device.h>
+#include <scsi/scsi_devinfo.h>
 #include <scsi/scsi_driver.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_host.h>
 	struct scsi_mode_data data;
 	int res;
+	if (sdp->sdev_bflags & BLIST_SKIP_IO_HINTS)
+		return;
 	res = scsi_mode_sense(sdp, /*dbd=*/0x8, /*modepage=*/0x0a,
 			      /*subpage=*/0x05, buffer, SD_BUF_SIZE, SD_TIMEOUT,
 			      sdkp->max_retries, &data, &sshdr);

drivers/soc/tegra/fuse/fuse-tegra.c+2−2

@@ -127,8 +127,8 @@ static void tegra_fuse_print_sku_info(struct tegra_sku_info *tegra_sku_info) · 126 unmodified lines
127		127
128	static int tegra_fuse_add_lookups(struct tegra_fuse *fuse)	128	static int tegra_fuse_add_lookups(struct tegra_fuse *fuse)
129	{	129	{
130	fuse->lookups = kmemdup_array(fuse->soc->lookups, sizeof(*fuse->lookups),	130	fuse->lookups = kmemdup_array(fuse->soc->lookups, fuse->soc->num_lookups,
131	fuse->soc->num_lookups, GFP_KERNEL);	131	sizeof(*fuse->lookups), GFP_KERNEL);
132	if (!fuse->lookups)	132	if (!fuse->lookups)
133	return -ENOMEM;	133	return -ENOMEM;
134		134

drivers/soundwire/amd_manager.c+3−0

@@ -571,6 +571,9 @@ static int sdw_master_read_amd_prop(struct sdw_bus *bus) · 570 unmodified lines
571	amd_manager->wake_en_mask = wake_en_mask;	571	amd_manager->wake_en_mask = wake_en_mask;
572	fwnode_property_read_u32(link, "amd-sdw-power-mode", &power_mode_mask);	572	fwnode_property_read_u32(link, "amd-sdw-power-mode", &power_mode_mask);
573	amd_manager->power_mode_mask = power_mode_mask;	573	amd_manager->power_mode_mask = power_mode_mask;
		574
		575	fwnode_handle_put(link);
		576
574	return 0;	577	return 0;
575	}	578	}
576		579

drivers/soundwire/intel_auxdevice.c+5−1

 		SDW_MASTER_QUIRKS_CLEAR_INITIAL_PARITY;
 	intel_prop = devm_kzalloc(bus->dev, sizeof(*intel_prop), GFP_KERNEL);
-	if (!intel_prop)
+	if (!intel_prop) {
+		fwnode_handle_put(link);
 		return -ENOMEM;
+	}
 	/* initialize with hardware defaults, in case the properties are not found */
 	intel_prop->doaise = 0x1;
 		intel_prop->dodse,
 		intel_prop->dods);
+	fwnode_handle_put(link);
 	return 0;
 }

drivers/soundwire/mipi_disco.c+24−6

 		prop->clk_freq = devm_kcalloc(bus->dev, prop->num_clk_freq,
 					      sizeof(*prop->clk_freq),
 					      GFP_KERNEL);
-		if (!prop->clk_freq)
+		if (!prop->clk_freq) {
+			fwnode_handle_put(link);
 			return -ENOMEM;
+		}
 		fwnode_property_read_u32_array(link,
 				"mipi-sdw-clock-frequencies-supported",
 		prop->clk_gears = devm_kcalloc(bus->dev, prop->num_clk_gears,
 					       sizeof(*prop->clk_gears),
 					       GFP_KERNEL);
-		if (!prop->clk_gears)
+		if (!prop->clk_gears) {
+			fwnode_handle_put(link);
 			return -ENOMEM;
+		}
 		fwnode_property_read_u32_array(link,
 					       "mipi-sdw-supported-clock-gears",
 	fwnode_property_read_u32(link, "mipi-sdw-command-error-threshold",
 				 &prop->err_threshold);
+	fwnode_handle_put(link);
 	return 0;
 }
 EXPORT_SYMBOL(sdw_master_read_prop);
 						    dpn[i].num_words,
 						    sizeof(*dpn[i].words),
 						    GFP_KERNEL);
-			if (!dpn[i].words)
+			if (!dpn[i].words) {
+				fwnode_handle_put(node);
 				return -ENOMEM;
+			}
 			fwnode_property_read_u32_array(node,
 					"mipi-sdw-port-wordlength-configs",
 						       dpn[i].num_channels,
 						       sizeof(*dpn[i].channels),
 						 GFP_KERNEL);
-			if (!dpn[i].channels)
+			if (!dpn[i].channels) {
+				fwnode_handle_put(node);
 				return -ENOMEM;
+			}
 			fwnode_property_read_u32_array(node,
 					"mipi-sdw-channel-number-list",
 					dpn[i].num_ch_combinations,
 					sizeof(*dpn[i].ch_combinations),
 					GFP_KERNEL);
-			if (!dpn[i].ch_combinations)
+			if (!dpn[i].ch_combinations) {
+				fwnode_handle_put(node);
 				return -ENOMEM;
+			}
 			fwnode_property_read_u32_array(node,
 					"mipi-sdw-channel-combination-list",
 		/* TODO: Read audio mode */
+		fwnode_handle_put(node);
 		i++;
 	}
 		prop->dp0_prop = devm_kzalloc(&slave->dev,
 					      sizeof(*prop->dp0_prop),
 					      GFP_KERNEL);
-		if (!prop->dp0_prop)
+		if (!prop->dp0_prop) {
+			fwnode_handle_put(port);
 			return -ENOMEM;
+		}
 		sdw_slave_read_dp0(slave, port, prop->dp0_prop);
+		fwnode_handle_put(port);
 	}
 	/*

drivers/spi/spi-cs42l43.c+3−3

@@ -26,7 +26,7 @@ · 25 unmodified lines
26	#include <linux/units.h>	26	#include <linux/units.h>
27		27
28	#define CS42L43_FIFO_SIZE 16	28	#define CS42L43_FIFO_SIZE 16
29	#define CS42L43_SPI_ROOT_HZ (40 * HZ_PER_MHZ)	29	#define CS42L43_SPI_ROOT_HZ 49152000
30	#define CS42L43_SPI_MAX_LENGTH 65532	30	#define CS42L43_SPI_MAX_LENGTH 65532
31		31
32	enum cs42l43_spi_cmd {	32	enum cs42l43_spi_cmd {
@@ -54,7 +54,7 @@ static const struct software_node ampr = { · 21 unmodified lines
54		54
55	static struct spi_board_info ampl_info = {	55	static struct spi_board_info ampl_info = {
56	.modalias = "cs35l56",	56	.modalias = "cs35l56",
57	.max_speed_hz = 20 * HZ_PER_MHZ,	57	.max_speed_hz = 11 * HZ_PER_MHZ,
58	.chip_select = 0,	58	.chip_select = 0,
59	.mode = SPI_MODE_0,	59	.mode = SPI_MODE_0,
60	.swnode = &ampl,	60	.swnode = &ampl,
@@ -62,7 +62,7 @@ static struct spi_board_info ampl_info = { · 1 unmodified line
62		62
63	static struct spi_board_info ampr_info = {	63	static struct spi_board_info ampr_info = {
64	.modalias = "cs35l56",	64	.modalias = "cs35l56",
65	.max_speed_hz = 20 * HZ_PER_MHZ,	65	.max_speed_hz = 11 * HZ_PER_MHZ,
66	.chip_select = 1,	66	.chip_select = 1,
67	.mode = SPI_MODE_0,	67	.mode = SPI_MODE_0,
68	.swnode = &ampr,	68	.swnode = &ampr,

drivers/spi/spi-imx.c+2−12

@@ -660,18 +660,8 @@ static int mx51_ecspi_prepare_transfer(struct spi_imx_data *spi_imx, · 659 unmodified lines
660	ctrl \|= (spi_imx->target_burst * 8 - 1)	660	ctrl \|= (spi_imx->target_burst * 8 - 1)
661	<< MX51_ECSPI_CTRL_BL_OFFSET;	661	<< MX51_ECSPI_CTRL_BL_OFFSET;
662	else {	662	else {
663	if (spi_imx->usedma) {	663	ctrl \|= (spi_imx->bits_per_word - 1)
664	ctrl \|= (spi_imx->bits_per_word - 1)	664	<< MX51_ECSPI_CTRL_BL_OFFSET;
665	<< MX51_ECSPI_CTRL_BL_OFFSET;
666	} else {
667	if (spi_imx->count >= MX51_ECSPI_CTRL_MAX_BURST)
668	ctrl \|= (MX51_ECSPI_CTRL_MAX_BURST * BITS_PER_BYTE - 1)
669	<< MX51_ECSPI_CTRL_BL_OFFSET;
670	else
671	ctrl \|= (spi_imx->count / DIV_ROUND_UP(spi_imx->bits_per_word,
672	BITS_PER_BYTE) * spi_imx->bits_per_word - 1)
673	<< MX51_ECSPI_CTRL_BL_OFFSET;
674	}
675	}	665	}
676		666
677	/* set clock speed */	667	/* set clock speed */

drivers/spi/spi-stm32-qspi.c+5−7

 static int stm32_qspi_get_mode(u8 buswidth)
 {
-	if (buswidth == 4)
+	if (buswidth >= 4)
 		return CCR_BUSWIDTH_4;
 	return buswidth;
 		return -EINVAL;
 	mode = spi->mode & (SPI_TX_OCTAL | SPI_RX_OCTAL);
-	if ((mode == SPI_TX_OCTAL || mode == SPI_RX_OCTAL) ||
+	if (mode && gpiod_count(qspi->dev, "cs") == -ENOENT) {
-	    ((mode == (SPI_TX_OCTAL | SPI_RX_OCTAL)) &&
-	    gpiod_count(qspi->dev, "cs") == -ENOENT)) {
 		dev_err(qspi->dev, "spi-rx-bus-width\\/spi-tx-bus-width\\/cs-gpios\n");
 		dev_err(qspi->dev, "configuration not supported\n");
 	qspi->cr_reg = CR_APMS | 3 << CR_FTHRES_SHIFT | CR_SSHIFT | CR_EN;
 	/*
-	 * Dual flash mode is only enable in case SPI_TX_OCTAL and SPI_TX_OCTAL
+	 * Dual flash mode is only enable in case SPI_TX_OCTAL or SPI_RX_OCTAL
-	 * are both set in spi->mode and "cs-gpios" properties is found in DT
+	 * is set in spi->mode and "cs-gpios" properties is found in DT
 	 */
-	if (mode == (SPI_TX_OCTAL | SPI_RX_OCTAL)) {
+	if (mode) {
 		qspi->cr_reg |= CR_DFM;
 		dev_dbg(qspi->dev, "Dual flash mode enable");
 	}

drivers/spi/spi.c+10−6

 	 * Make sure that multiple logical CS doesn't map to the same physical CS.
 	 * For example, spi->chip_select[0] != spi->chip_select[1] and so on.
 	 */
-	for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
+	if (!spi_controller_is_target(ctlr)) {
-		status = spi_dev_check_cs(dev, spi, idx, spi, idx + 1);
+		for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
-		if (status)
+			status = spi_dev_check_cs(dev, spi, idx, spi, idx + 1);
-			return status;
+			if (status)
+				return status;
+		}
 	}
 	/* Set the bus ID string */
 				return -EINVAL;
 			if (xfer->tx_nbits != SPI_NBITS_SINGLE &&
 				xfer->tx_nbits != SPI_NBITS_DUAL &&
-				xfer->tx_nbits != SPI_NBITS_QUAD)
+				xfer->tx_nbits != SPI_NBITS_QUAD &&
+				xfer->tx_nbits != SPI_NBITS_OCTAL)
 				return -EINVAL;
 			if ((xfer->tx_nbits == SPI_NBITS_DUAL) &&
 				!(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
 				return -EINVAL;
 			if (xfer->rx_nbits != SPI_NBITS_SINGLE &&
 				xfer->rx_nbits != SPI_NBITS_DUAL &&
-				xfer->rx_nbits != SPI_NBITS_QUAD)
+				xfer->rx_nbits != SPI_NBITS_QUAD &&
+				xfer->rx_nbits != SPI_NBITS_OCTAL)
 				return -EINVAL;
 			if ((xfer->rx_nbits == SPI_NBITS_DUAL) &&
 				!(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))

drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c+2−1

 {
 	struct proc_thermal_pci *pci_info = devid;
 	struct proc_thermal_device *proc_priv;
-	int ret = IRQ_HANDLED;
+	int ret = IRQ_NONE;
 	u32 status;
 	proc_priv = pci_info->proc_priv;
 		/* Disable enable interrupt flag */
 		proc_thermal_mmio_write(pci_info, PROC_THERMAL_MMIO_INT_ENABLE_0, 0);
 		pkg_thermal_schedule_work(&pci_info->work);
+		ret = IRQ_HANDLED;
 	}
 	pci_write_config_byte(pci_info->pdev, 0xdc, 0x01);

drivers/thermal/mediatek/lvts_thermal.c+5−7

 	 */
 	gt = (((u32 *)calib)[0] >> lvts_data->gt_calib_bit_offset) & 0xff;
-	if (gt && gt < LVTS_GOLDEN_TEMP_MAX)
+	/* A zero value for gt means that device has invalid efuse data */
+	if (!gt)
+		return -ENODATA;
+	if (gt < LVTS_GOLDEN_TEMP_MAX)
 		golden_temp = gt;
 	golden_temp_offset = golden_temp * 500 + lvts_data->temp_offset;
 		},
 		VALID_SENSOR_MAP(1, 1, 1, 1),
 		.offset = 0x0,
-		.mode = LVTS_MSR_FILTERED_MODE,
 	},
 	{
 		.lvts_sensor = {
 		},
 		VALID_SENSOR_MAP(1, 1, 0, 0),
 		.offset = 0x100,
-		.mode = LVTS_MSR_FILTERED_MODE,
 	}
 };
 		},
 		VALID_SENSOR_MAP(0, 1, 0, 0),
 		.offset = 0x0,
-		.mode = LVTS_MSR_FILTERED_MODE,
 	},
 	{
 		.lvts_sensor = {
 		},
 		VALID_SENSOR_MAP(1, 1, 1, 0),
 		.offset = 0x100,
-		.mode = LVTS_MSR_FILTERED_MODE,
 	},
 	{
 		.lvts_sensor = {
 		},
 		VALID_SENSOR_MAP(1, 1, 0, 0),
 		.offset = 0x200,
-		.mode = LVTS_MSR_FILTERED_MODE,
 	},
 	{
 		.lvts_sensor = {
 		},
 		VALID_SENSOR_MAP(1, 1, 0, 0),
 		.offset = 0x300,
-		.mode = LVTS_MSR_FILTERED_MODE,
 	}
 };

drivers/thermal/thermal_core.c+27−0

 	ida_init(&tz->ida);
 	mutex_init(&tz->lock);
 	init_completion(&tz->removal);
+	init_completion(&tz->resume);
 	id = ida_alloc(&thermal_tz_ida, GFP_KERNEL);
 	if (id < 0) {
 		result = id;
 	thermal_zone_device_init(tz);
 	__thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
+	complete(&tz->resume);
+	tz->resuming = false;
 	mutex_unlock(&tz->lock);
 }
 		list_for_each_entry(tz, &thermal_tz_list, node) {
 			mutex_lock(&tz->lock);
+			if (tz->resuming) {
+				/*
+				 * thermal_zone_device_resume() queued up for
+				 * this zone has not acquired the lock yet, so
+				 * release it to let the function run and wait
+				 * util it has done the work.
+				 */
+				mutex_unlock(&tz->lock);
+				wait_for_completion(&tz->resume);
+				mutex_lock(&tz->lock);
+			}
 			tz->suspended = true;
 			mutex_unlock(&tz->lock);
 			cancel_delayed_work(&tz->poll_queue);
+			reinit_completion(&tz->resume);
+			tz->resuming = true;
 			/*
 			 * Replace the work function with the resume one, which
 			 * will restore the original work function and schedule
 static struct notifier_block thermal_pm_nb = {
 	.notifier_call = thermal_pm_notify,
+	/*
+	 * Run at the lowest priority to avoid interference between the thermal
+	 * zone resume work items spawned by thermal_pm_notify() and the other
+	 * PM notifiers.
+	 */
+	.priority = INT_MIN,
 };
 static int __init thermal_init(void)

drivers/thermal/thermal_core.h+4−0

  * @type:	the thermal zone device type
  * @device:	&struct device for this thermal zone
  * @removal:	removal completion
+ * @resume:	resume completion
  * @trip_temp_attrs:	attributes for trip points for sysfs: trip temperature
  * @trip_type_attrs:	attributes for trip points for sysfs: trip type
  * @trip_hyst_attrs:	attributes for trip points for sysfs: trip hysteresis
  * @poll_queue:	delayed work for polling
  * @notify_event: Last notification event
  * @suspended: thermal zone suspend indicator
+ * @resuming:	indicates whether or not thermal zone resume is in progress
  * @trips:	array of struct thermal_trip objects
  */
 struct thermal_zone_device {
 	char type[THERMAL_NAME_LENGTH];
 	struct device device;
 	struct completion removal;
+	struct completion resume;
 	struct attribute_group trips_attribute_group;
 	struct thermal_attr *trip_temp_attrs;
 	struct thermal_attr *trip_type_attrs;
 	struct delayed_work poll_queue;
 	enum thermal_notify_event notify_event;
 	bool suspended;
+	bool resuming;
 #ifdef CONFIG_THERMAL_DEBUGFS
 	struct thermal_debugfs *debugfs;
 #endif

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

@@ -8787,6 +8787,7 @@ static int ufshcd_probe_hba(struct ufs_hba *hba, bool init_dev_params) · 8786 unmodified lines
8787	(hba->quirks & UFSHCD_QUIRK_REINIT_AFTER_MAX_GEAR_SWITCH)) {	8787	(hba->quirks & UFSHCD_QUIRK_REINIT_AFTER_MAX_GEAR_SWITCH)) {
8788	/* Reset the device and controller before doing reinit */	8788	/* Reset the device and controller before doing reinit */
8789	ufshcd_device_reset(hba);	8789	ufshcd_device_reset(hba);
		8790	ufs_put_device_desc(hba);
8790	ufshcd_hba_stop(hba);	8791	ufshcd_hba_stop(hba);
8791	ufshcd_vops_reinit_notify(hba);	8792	ufshcd_vops_reinit_notify(hba);
8792	ret = ufshcd_hba_enable(hba);	8793	ret = ufshcd_hba_enable(hba);

drivers/usb/storage/scsiglue.c+6−0

 	if (us->protocol == USB_PR_BULK && us->max_lun > 0)
 		sdev->sdev_bflags |= BLIST_FORCELUN;
+	/*
+	 * Some USB storage devices reset if the IO advice hints grouping mode
+	 * page is queried. Hence skip that mode page.
+	 */
+	sdev->sdev_bflags |= BLIST_SKIP_IO_HINTS;
 	return 0;
 }

drivers/usb/storage/uas.c+7−0

 #include <scsi/scsi.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dbg.h>
+#include <scsi/scsi_devinfo.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 	struct uas_dev_info *devinfo =
 		(struct uas_dev_info *)sdev->host->hostdata;
+	/*
+	 * Some USB storage devices reset if the IO advice hints grouping mode
+	 * page is queried. Hence skip that mode page.
+	 */
+	sdev->sdev_bflags |= BLIST_SKIP_IO_HINTS;
 	sdev->hostdata = devinfo;
 	return 0;
 }

fs/bcachefs/alloc_background.c+61−15

@@ -259,6 +259,14 @@ int bch2_alloc_v4_invalid(struct bch_fs *c, struct bkey_s_c k, · 258 unmodified lines
259	"invalid data type (got %u should be %u)",	259	"invalid data type (got %u should be %u)",
260	a.v->data_type, alloc_data_type(*a.v, a.v->data_type));	260	a.v->data_type, alloc_data_type(*a.v, a.v->data_type));
261		261
		262	for (unsigned i = 0; i < 2; i++)
		263	bkey_fsck_err_on(a.v->io_time[i] > LRU_TIME_MAX,
		264	c, err,
		265	alloc_key_io_time_bad,
		266	"invalid io_time[%s]: %llu, max %llu",
		267	i == READ ? "read" : "write",
		268	a.v->io_time[i], LRU_TIME_MAX);
		269
262	switch (a.v->data_type) {	270	switch (a.v->data_type) {
263	case BCH_DATA_free:	271	case BCH_DATA_free:
264	case BCH_DATA_need_gc_gens:	272	case BCH_DATA_need_gc_gens:
@@ -757,8 +765,8 @@ int bch2_trigger_alloc(struct btree_trans *trans, · 492 unmodified lines
757	alloc_data_type_set(new_a, new_a->data_type);	765	alloc_data_type_set(new_a, new_a->data_type);
758		766
759	if (bch2_bucket_sectors_total(new_a) > bch2_bucket_sectors_total(old_a)) {	767	if (bch2_bucket_sectors_total(new_a) > bch2_bucket_sectors_total(old_a)) {
760	new_a->io_time[READ] = max_t(u64, 1, atomic64_read(&c->io_clock[READ].now));	768	new_a->io_time[READ] = bch2_current_io_time(c, READ);
761	new_a->io_time[WRITE]= max_t(u64, 1, atomic64_read(&c->io_clock[WRITE].now));	769	new_a->io_time[WRITE]= bch2_current_io_time(c, WRITE);
762	SET_BCH_ALLOC_V4_NEED_INC_GEN(new_a, true);	770	SET_BCH_ALLOC_V4_NEED_INC_GEN(new_a, true);
763	SET_BCH_ALLOC_V4_NEED_DISCARD(new_a, true);	771	SET_BCH_ALLOC_V4_NEED_DISCARD(new_a, true);
764	}	772	}
@@ -768,6 +776,7 @@ int bch2_trigger_alloc(struct btree_trans *trans, · 3 unmodified lines
768	!bch2_bucket_is_open_safe(c, new.k->p.inode, new.k->p.offset)) {	776	!bch2_bucket_is_open_safe(c, new.k->p.inode, new.k->p.offset)) {
769	new_a->gen++;	777	new_a->gen++;
770	SET_BCH_ALLOC_V4_NEED_INC_GEN(new_a, false);	778	SET_BCH_ALLOC_V4_NEED_INC_GEN(new_a, false);
		779	alloc_data_type_set(new_a, new_a->data_type);
771	}	780	}
772		781
773	if (old_a->data_type != new_a->data_type \|\|	782	if (old_a->data_type != new_a->data_type \|\|
@@ -781,7 +790,7 @@ int bch2_trigger_alloc(struct btree_trans *trans, · 7 unmodified lines
781		790
782	if (new_a->data_type == BCH_DATA_cached &&	791	if (new_a->data_type == BCH_DATA_cached &&
783	!new_a->io_time[READ])	792	!new_a->io_time[READ])
784	new_a->io_time[READ] = max_t(u64, 1, atomic64_read(&c->io_clock[READ].now));	793	new_a->io_time[READ] = bch2_current_io_time(c, READ);
785		794
786	u64 old_lru = alloc_lru_idx_read(*old_a);	795	u64 old_lru = alloc_lru_idx_read(*old_a);
787	u64 new_lru = alloc_lru_idx_read(*new_a);	796	u64 new_lru = alloc_lru_idx_read(*new_a);
@@ -882,7 +891,7 @@ int bch2_trigger_alloc(struct btree_trans *trans, · 94 unmodified lines
882	closure_wake_up(&c->freelist_wait);	891	closure_wake_up(&c->freelist_wait);
883		892
884	if (statechange(a->data_type == BCH_DATA_need_discard) &&	893	if (statechange(a->data_type == BCH_DATA_need_discard) &&
885	!bch2_bucket_is_open(c, new.k->p.inode, new.k->p.offset) &&	894	!bch2_bucket_is_open_safe(c, new.k->p.inode, new.k->p.offset) &&
886	bucket_flushed(new_a))	895	bucket_flushed(new_a))
887	bch2_discard_one_bucket_fast(c, new.k->p);	896	bch2_discard_one_bucket_fast(c, new.k->p);
888		897
@@ -1579,7 +1588,7 @@ static int bch2_check_alloc_to_lru_ref(struct btree_trans *trans, · 690 unmodified lines
1579	if (ret)	1588	if (ret)
1580	goto err;	1589	goto err;
1581		1590
1582	a_mut->v.io_time[READ] = atomic64_read(&c->io_clock[READ].now);	1591	a_mut->v.io_time[READ] = bch2_current_io_time(c, READ);
1583	ret = bch2_trans_update(trans, alloc_iter,	1592	ret = bch2_trans_update(trans, alloc_iter,
1584	&a_mut->k_i, BTREE_TRIGGER_norun);	1593	&a_mut->k_i, BTREE_TRIGGER_norun);
1585	if (ret)	1594	if (ret)
@@ -1634,7 +1643,7 @@ static int discard_in_flight_add(struct bch_fs *c, struct bpos bucket) · 48 unmodified lines
1634	mutex_lock(&c->discard_buckets_in_flight_lock);	1643	mutex_lock(&c->discard_buckets_in_flight_lock);
1635	darray_for_each(c->discard_buckets_in_flight, i)	1644	darray_for_each(c->discard_buckets_in_flight, i)
1636	if (bkey_eq(*i, bucket)) {	1645	if (bkey_eq(*i, bucket)) {
1637	ret = -EEXIST;	1646	ret = -BCH_ERR_EEXIST_discard_in_flight_add;
1638	goto out;	1647	goto out;
1639	}	1648	}
1640		1649
@@ -1788,8 +1797,9 @@ static int bch2_discard_one_bucket(struct btree_trans *trans, · 147 unmodified lines
1788	}	1797	}
1789		1798
1790	SET_BCH_ALLOC_V4_NEED_DISCARD(&a->v, false);	1799	SET_BCH_ALLOC_V4_NEED_DISCARD(&a->v, false);
1791	alloc_data_type_set(&a->v, a->v.data_type);
1792	write:	1800	write:
		1801	alloc_data_type_set(&a->v, a->v.data_type);
		1802
1793	ret = bch2_trans_update(trans, &iter, &a->k_i, 0) ?:	1803	ret = bch2_trans_update(trans, &iter, &a->k_i, 0) ?:
1794	bch2_trans_commit(trans, NULL, NULL,	1804	bch2_trans_commit(trans, NULL, NULL,
1795	BCH_WATERMARK_btree\|	1805	BCH_WATERMARK_btree\|
@@ -1975,8 +1985,8 @@ static int invalidate_one_bucket(struct btree_trans *trans, · 179 unmodified lines
1975	a->v.data_type = 0;	1985	a->v.data_type = 0;
1976	a->v.dirty_sectors = 0;	1986	a->v.dirty_sectors = 0;
1977	a->v.cached_sectors = 0;	1987	a->v.cached_sectors = 0;
1978	a->v.io_time[READ] = atomic64_read(&c->io_clock[READ].now);	1988	a->v.io_time[READ] = bch2_current_io_time(c, READ);
1979	a->v.io_time[WRITE] = atomic64_read(&c->io_clock[WRITE].now);	1989	a->v.io_time[WRITE] = bch2_current_io_time(c, WRITE);
1980		1990
1981	ret = bch2_trans_commit(trans, NULL, NULL,	1991	ret = bch2_trans_commit(trans, NULL, NULL,
1982	BCH_WATERMARK_btree\|	1992	BCH_WATERMARK_btree\|
@@ -2011,6 +2021,21 @@ err: · 28 unmodified lines
2011	goto out;	2021	goto out;
2012	}	2022	}
2013		2023
		2024	static struct bkey_s_c next_lru_key(struct btree_trans trans, struct btree_iter iter,
		2025	struct bch_dev ca, bool wrapped)
		2026	{
		2027	struct bkey_s_c k;
		2028	again:
		2029	k = bch2_btree_iter_peek_upto(iter, lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX));
		2030	if (!k.k && !*wrapped) {
		2031	bch2_btree_iter_set_pos(iter, lru_pos(ca->dev_idx, 0, 0));
		2032	*wrapped = true;
		2033	goto again;
		2034	}
		2035
		2036	return k;
		2037	}
		2038
2014	static void bch2_do_invalidates_work(struct work_struct *work)	2039	static void bch2_do_invalidates_work(struct work_struct *work)
2015	{	2040	{
2016	struct bch_fs *c = container_of(work, struct bch_fs, invalidate_work);	2041	struct bch_fs *c = container_of(work, struct bch_fs, invalidate_work);
@@ -2024,12 +2049,33 @@ static void bch2_do_invalidates_work(struct work_struct *work) · 7 unmodified lines
2024	for_each_member_device(c, ca) {	2049	for_each_member_device(c, ca) {
2025	s64 nr_to_invalidate =	2050	s64 nr_to_invalidate =
2026	should_invalidate_buckets(ca, bch2_dev_usage_read(ca));	2051	should_invalidate_buckets(ca, bch2_dev_usage_read(ca));
		2052	struct btree_iter iter;
		2053	bool wrapped = false;
		2054
		2055	bch2_trans_iter_init(trans, &iter, BTREE_ID_lru,
		2056	lru_pos(ca->dev_idx, 0,
		2057	((bch2_current_io_time(c, READ) + U32_MAX) &
		2058	LRU_TIME_MAX)), 0);
2027		2059
2028	ret = for_each_btree_key_upto(trans, iter, BTREE_ID_lru,	2060	while (true) {
2029	lru_pos(ca->dev_idx, 0, 0),	2061	bch2_trans_begin(trans);
2030	lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX),	2062
2031	BTREE_ITER_intent, k,	2063	struct bkey_s_c k = next_lru_key(trans, &iter, ca, &wrapped);
2032	invalidate_one_bucket(trans, &iter, k, &nr_to_invalidate));	2064	ret = bkey_err(k);
		2065	if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
		2066	continue;
		2067	if (ret)
		2068	break;
		2069	if (!k.k)
		2070	break;
		2071
		2072	ret = invalidate_one_bucket(trans, &iter, k, &nr_to_invalidate);
		2073	if (ret)
		2074	break;
		2075
		2076	bch2_btree_iter_advance(&iter);
		2077	}
		2078	bch2_trans_iter_exit(trans, &iter);
2033		2079
2034	if (ret < 0) {	2080	if (ret < 0) {
2035	bch2_dev_put(ca);	2081	bch2_dev_put(ca);
@@ -2204,7 +2250,7 @@ int bch2_bucket_io_time_reset(struct btree_trans *trans, unsigned dev, · 168 unmodified lines
2204	if (ret)	2250	if (ret)
2205	return ret;	2251	return ret;
2206		2252
2207	now = atomic64_read(&c->io_clock[rw].now);	2253	now = bch2_current_io_time(c, rw);
2208	if (a->v.io_time[rw] == now)	2254	if (a->v.io_time[rw] == now)
2209	goto out;	2255	goto out;
2210		2256

fs/bcachefs/alloc_background.h+7−1

 	    !bch2_bucket_sectors_fragmented(ca, a))
 		return 0;
-	u64 d = bch2_bucket_sectors_dirty(a);
+	/*
+	 * avoid overflowing LRU_TIME_BITS on a corrupted fs, when
+	 * bucket_sectors_dirty is (much) bigger than bucket_size
+	 */
+	u64 d = min(bch2_bucket_sectors_dirty(a),
+		    ca->mi.bucket_size);
 	return div_u64(d * (1ULL << 31), ca->mi.bucket_size);
 }

fs/bcachefs/bcachefs.h+5−0

 	return timespec_to_bch2_time(c, now);
 }
+static inline u64 bch2_current_io_time(const struct bch_fs *c, int rw)
+{
+	return max(1ULL, (u64) atomic64_read(&c->io_clock[rw].now) & LRU_TIME_MAX);
+}
 static inline struct stdio_redirect *bch2_fs_stdio_redirect(struct bch_fs *c)
 {
 	struct stdio_redirect *stdio = c->stdio;

fs/bcachefs/bcachefs_format.h+9−4

 #define LRU_ID_STRIPES		(1U << 16)
+#define LRU_TIME_BITS	48
+#define LRU_TIME_MAX	((1ULL << LRU_TIME_BITS) - 1)
 /* Optional/variable size superblock sections: */
 struct bch_sb_field {
 #define BCH_ERROR_ACTIONS()		\
 	x(continue,		0)	\
-	x(ro,			1)	\
+	x(fix_safe,		1)	\
-	x(panic,		2)
+	x(panic,		2)	\
+	x(ro,			3)
 enum bch_error_actions {
 #define x(t, n) BCH_ON_ERROR_##t = n,
 /*
  * Maximum number of btrees that we will _ever_ have under the current scheme,
- * where we refer to them with bitfields
+ * where we refer to them with 64 bit bitfields - and we also need a bit for
+ * the interior btree node type:
  */
-#define BTREE_ID_NR_MAX		64
+#define BTREE_ID_NR_MAX		63
 static inline bool btree_id_is_alloc(enum btree_id id)
 {

fs/bcachefs/bkey.c+1−1

@@ -1064,7 +1064,7 @@ void bch2_bkey_swab_key(const struct bkey_format _f, struct bkey_packed k) · 1063 unmodified lines
1064	{	1064	{
1065	const struct bkey_format *f = bkey_packed(k) ? _f : &bch2_bkey_format_current;	1065	const struct bkey_format *f = bkey_packed(k) ? _f : &bch2_bkey_format_current;
1066	u8 *l = k->key_start;	1066	u8 *l = k->key_start;
1067	u8 h = (u8 ) (k->_data + f->key_u64s) - 1;	1067	u8 h = (u8 ) ((u64 *) k->_data + f->key_u64s) - 1;
1068		1068
1069	while (l < h) {	1069	while (l < h) {
1070	swap(l, h);	1070	swap(l, h);

fs/bcachefs/bkey_methods.c+5−1

 	for (i = 0; i < nr_compat; i++)
 	switch (!write ? i : nr_compat - 1 - i) {
 	case 0:
-		if (big_endian != CPU_BIG_ENDIAN)
+		if (big_endian != CPU_BIG_ENDIAN) {
+			bch2_bkey_swab_key(f, k);
+		} else if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG)) {
 			bch2_bkey_swab_key(f, k);
+			bch2_bkey_swab_key(f, k);
+		}
 		break;
 	case 1:
 		if (version < bcachefs_metadata_version_bkey_renumber)

fs/bcachefs/bkey_methods.h+2−1

@@ -129,7 +129,8 @@ static inline void bch2_bkey_compat(unsigned level, enum btree_id btree_id, · 128 unmodified lines
129	struct bkey_packed *k)	129	struct bkey_packed *k)
130	{	130	{
131	if (version < bcachefs_metadata_version_current \|\|	131	if (version < bcachefs_metadata_version_current \|\|
132	big_endian != CPU_BIG_ENDIAN)	132	big_endian != CPU_BIG_ENDIAN \|\|
		133	IS_ENABLED(CONFIG_BCACHEFS_DEBUG))
133	__bch2_bkey_compat(level, btree_id, version,	134	__bch2_bkey_compat(level, btree_id, version,
134	big_endian, write, f, k);	135	big_endian, write, f, k);
135		136

fs/bcachefs/btree_iter.c+8−3

 list_add_done:
 	seqmutex_unlock(&c->btree_trans_lock);
 got_trans:
+	trans->ref.closure_get_happened = false;
 	trans->c		= c;
 	trans->last_begin_time	= local_clock();
 	trans->fn_idx		= fn_idx;
 	trans_for_each_update(trans, i)
 		__btree_path_put(trans->paths + i->path, true);
 	trans->nr_updates	= 0;
-	trans->locking_wait.task = NULL;
 	check_btree_paths_leaked(trans);
 	if (unlikely(trans->journal_replay_not_finished))
 		bch2_journal_keys_put(c);
+	/*
+	 * trans->ref protects trans->locking_wait.task, btree_paths arary; used
+	 * by cycle detector
+	 */
+	closure_sync(&trans->ref);
+	trans->locking_wait.task = NULL;
 	unsigned long *paths_allocated = trans->paths_allocated;
 	trans->paths_allocated	= NULL;
 	trans->paths		= NULL;
 		trans = this_cpu_xchg(c->btree_trans_bufs->trans, trans);
 	if (trans) {
-		closure_sync(&trans->ref);
 		seqmutex_lock(&c->btree_trans_lock);
 		list_del(&trans->list);
 		seqmutex_unlock(&c->btree_trans_lock);

fs/bcachefs/btree_types.h+8−8

@@ -761,13 +761,13 @@ static inline bool btree_node_type_needs_gc(enum btree_node_type type) · 760 unmodified lines
761		761
762	static inline bool btree_node_type_is_extents(enum btree_node_type type)	762	static inline bool btree_node_type_is_extents(enum btree_node_type type)
763	{	763	{
764	const unsigned mask = 0	764	const u64 mask = 0
765	#define x(name, nr, flags, ...) \|((!!((flags) & BTREE_ID_EXTENTS)) << (nr + 1))	765	#define x(name, nr, flags, ...) \|((!!((flags) & BTREE_ID_EXTENTS)) << (nr + 1))
766	BCH_BTREE_IDS()	766	BCH_BTREE_IDS()
767	#undef x	767	#undef x
768	;	768	;
769		769
770	return (1U << type) & mask;	770	return BIT_ULL(type) & mask;
771	}	771	}
772		772
773	static inline bool btree_id_is_extents(enum btree_id btree)	773	static inline bool btree_id_is_extents(enum btree_id btree)
@@ -777,35 +777,35 @@ static inline bool btree_id_is_extents(enum btree_id btree) · 3 unmodified lines
777		777
778	static inline bool btree_type_has_snapshots(enum btree_id id)	778	static inline bool btree_type_has_snapshots(enum btree_id id)
779	{	779	{
780	const unsigned mask = 0	780	const u64 mask = 0
781	#define x(name, nr, flags, ...) \|((!!((flags) & BTREE_ID_SNAPSHOTS)) << nr)	781	#define x(name, nr, flags, ...) \|((!!((flags) & BTREE_ID_SNAPSHOTS)) << nr)
782	BCH_BTREE_IDS()	782	BCH_BTREE_IDS()
783	#undef x	783	#undef x
784	;	784	;
785		785
786	return (1U << id) & mask;	786	return BIT_ULL(id) & mask;
787	}	787	}
788		788
789	static inline bool btree_type_has_snapshot_field(enum btree_id id)	789	static inline bool btree_type_has_snapshot_field(enum btree_id id)
790	{	790	{
791	const unsigned mask = 0	791	const u64 mask = 0
792	#define x(name, nr, flags, ...) \|((!!((flags) & (BTREE_ID_SNAPSHOT_FIELD\|BTREE_ID_SNAPSHOTS))) << nr)	792	#define x(name, nr, flags, ...) \|((!!((flags) & (BTREE_ID_SNAPSHOT_FIELD\|BTREE_ID_SNAPSHOTS))) << nr)
793	BCH_BTREE_IDS()	793	BCH_BTREE_IDS()
794	#undef x	794	#undef x
795	;	795	;
796		796
797	return (1U << id) & mask;	797	return BIT_ULL(id) & mask;
798	}	798	}
799		799
800	static inline bool btree_type_has_ptrs(enum btree_id id)	800	static inline bool btree_type_has_ptrs(enum btree_id id)
801	{	801	{
802	const unsigned mask = 0	802	const u64 mask = 0
803	#define x(name, nr, flags, ...) \|((!!((flags) & BTREE_ID_DATA)) << nr)	803	#define x(name, nr, flags, ...) \|((!!((flags) & BTREE_ID_DATA)) << nr)
804	BCH_BTREE_IDS()	804	BCH_BTREE_IDS()
805	#undef x	805	#undef x
806	;	806	;
807		807
808	return (1U << id) & mask;	808	return BIT_ULL(id) & mask;
809	}	809	}
810		810
811	struct btree_root {	811	struct btree_root {

fs/bcachefs/errcode.h+3−0

 	x(ENOENT,			ENOENT_dev_idx_not_found)		\
 	x(ENOTEMPTY,			ENOTEMPTY_dir_not_empty)		\
 	x(ENOTEMPTY,			ENOTEMPTY_subvol_not_empty)		\
+	x(EEXIST,			EEXIST_str_hash_set)			\
+	x(EEXIST,			EEXIST_discard_in_flight_add)		\
+	x(EEXIST,			EEXIST_subvolume_create)		\
 	x(0,				open_buckets_empty)			\
 	x(0,				freelist_empty)				\
 	x(BCH_ERR_freelist_empty,	no_buckets_found)			\

fs/bcachefs/error.c+18−1

 	switch (c->opts.errors) {
 	case BCH_ON_ERROR_continue:
 		return false;
+	case BCH_ON_ERROR_fix_safe:
 	case BCH_ON_ERROR_ro:
 		if (bch2_fs_emergency_read_only(c))
 			bch_err(c, "inconsistency detected - emergency read only at journal seq %llu",
 	prt_str(out, "ing");
 }
+static const u8 fsck_flags_extra[] = {
+#define x(t, n, flags)		[BCH_FSCK_ERR_##t] = flags,
+	BCH_SB_ERRS()
+#undef x
+};
 int bch2_fsck_err(struct bch_fs *c,
 		  enum bch_fsck_flags flags,
 		  enum bch_sb_error_id err,
 	int ret = -BCH_ERR_fsck_ignore;
 	const char *action_orig = "fix?", *action = action_orig;
+	if (!WARN_ON(err >= ARRAY_SIZE(fsck_flags_extra)))
+		flags |= fsck_flags_extra[err];
 	if ((flags & FSCK_CAN_FIX) &&
 	    test_bit(err, c->sb.errors_silent))
 		return -BCH_ERR_fsck_fix;
 		prt_printf(out, bch2_log_msg(c, ""));
 #endif
-	if (!test_bit(BCH_FS_fsck_running, &c->flags)) {
+	if ((flags & FSCK_CAN_FIX) &&
+	    (flags & FSCK_AUTOFIX) &&
+	    (c->opts.errors == BCH_ON_ERROR_continue ||
+	     c->opts.errors == BCH_ON_ERROR_fix_safe)) {
+		prt_str(out, ", ");
+		prt_actioning(out, action);
+		ret = -BCH_ERR_fsck_fix;
+	} else if (!test_bit(BCH_FS_fsck_running, &c->flags)) {
 		if (c->opts.errors != BCH_ON_ERROR_continue ||
 		    !(flags & (FSCK_CAN_FIX|FSCK_CAN_IGNORE))) {
 			prt_str(out, ", shutting down");

fs/bcachefs/error.h+0−7

@@ -108,13 +108,6 @@ struct fsck_err_state { · 107 unmodified lines
108	char *last_msg;	108	char *last_msg;
109	};	109	};
110		110
111	enum bch_fsck_flags {
112	FSCK_CAN_FIX = 1 << 0,
113	FSCK_CAN_IGNORE = 1 << 1,
114	FSCK_NEED_FSCK = 1 << 2,
115	FSCK_NO_RATELIMIT = 1 << 3,
116	};
117
118	#define fsck_err_count(_c, _err) bch2_sb_err_count(_c, BCH_FSCK_ERR_##_err)	111	#define fsck_err_count(_c, _err) bch2_sb_err_count(_c, BCH_FSCK_ERR_##_err)
119		112
120	__printf(4, 5) __cold	113	__printf(4, 5) __cold

fs/bcachefs/fs-ioctl.c+1−1

@@ -373,7 +373,7 @@ retry: · 372 unmodified lines
373	}	373	}
374		374
375	if (dst_dentry->d_inode) {	375	if (dst_dentry->d_inode) {
376	error = -EEXIST;	376	error = -BCH_ERR_EEXIST_subvolume_create;
377	goto err3;	377	goto err3;
378	}	378	}
379		379

fs/bcachefs/fs.c+14−7

 	BUG_ON(!old);
 	if (unlikely(old != inode)) {
+		/*
+		 * bcachefs doesn't use I_NEW; we have no use for it since we
+		 * only insert fully created inodes in the inode hash table. But
+		 * discard_new_inode() expects it to be set...
+		 */
+		inode->v.i_flags |= I_NEW;
 		discard_new_inode(&inode->v);
 		inode = old;
 	} else {
 		list_add(&inode->ei_vfs_inode_list, &c->vfs_inodes_list);
 		mutex_unlock(&c->vfs_inodes_lock);
 		/*
-		 * we really don't want insert_inode_locked2() to be setting
+		 * Again, I_NEW makes no sense for bcachefs. This is only needed
-		 * I_NEW...
+		 * for clearing I_NEW, but since the inode was already fully
+		 * created and initialized we didn't actually want
+		 * inode_insert5() to set it for us.
 		 */
 		unlock_new_inode(&inode->v);
 	}
 	.read_iter	= bch2_read_iter,
 	.write_iter	= bch2_write_iter,
 	.mmap		= bch2_mmap,
+	.get_unmapped_area = thp_get_unmapped_area,
 	.fsync		= bch2_fsync,
 	.splice_read	= filemap_splice_read,
 	.splice_write	= iter_file_splice_write,
 	bch2_iget5_set(&inode->v, &inum);
 	bch2_inode_update_after_write(trans, inode, bi, ~0);
-	if (BCH_SUBVOLUME_SNAP(subvol))
-		set_bit(EI_INODE_SNAPSHOT, &inode->ei_flags);
-	else
-		clear_bit(EI_INODE_SNAPSHOT, &inode->ei_flags);
 	inode->v.i_blocks	= bi->bi_sectors;
 	inode->v.i_ino		= bi->bi_inum;
 	inode->v.i_rdev		= bi->bi_dev;
 	inode->ei_qid		= bch_qid(bi);
 	inode->ei_subvol	= inum.subvol;
+	if (BCH_SUBVOLUME_SNAP(subvol))
+		set_bit(EI_INODE_SNAPSHOT, &inode->ei_flags);
 	inode->v.i_mapping->a_ops = &bch_address_space_operations;
 	switch (inode->v.i_mode & S_IFMT) {

fs/bcachefs/journal.c+3−0

@@ -1167,6 +1167,9 @@ void bch2_dev_journal_stop(struct journal j, struct bch_dev ca) · 1166 unmodified lines
1167		1167
1168	void bch2_fs_journal_stop(struct journal *j)	1168	void bch2_fs_journal_stop(struct journal *j)
1169	{	1169	{
		1170	if (!test_bit(JOURNAL_running, &j->flags))
		1171	return;
		1172
1170	bch2_journal_reclaim_stop(j);	1173	bch2_journal_reclaim_stop(j);
1171	bch2_journal_flush_all_pins(j);	1174	bch2_journal_flush_all_pins(j);
1172		1175

fs/bcachefs/journal_io.c+8−5

 	struct journal *j = container_of(w, struct journal, buf[w->idx]);
 	struct bch_fs *c = container_of(j, struct bch_fs, journal);
 	struct bch_replicas_padded replicas;
-	struct printbuf journal_debug_buf = PRINTBUF;
 	unsigned nr_rw_members = 0;
 	int ret;
 	}
 	if (ret) {
-		__bch2_journal_debug_to_text(&journal_debug_buf, j);
+		struct printbuf buf = PRINTBUF;
+		buf.atomic++;
+		prt_printf(&buf, bch2_fmt(c, "Unable to allocate journal write: %s"),
+			   bch2_err_str(ret));
+		__bch2_journal_debug_to_text(&buf, j);
 		spin_unlock(&j->lock);
-		bch_err(c, "Unable to allocate journal write:\n%s",
+		bch2_print_string_as_lines(KERN_ERR, buf.buf);
-			journal_debug_buf.buf);
+		printbuf_exit(&buf);
-		printbuf_exit(&journal_debug_buf);
 		goto err;
 	}

fs/bcachefs/lru.h+0−3

@@ -2,9 +2,6 @@ · 1 unmodified line
2	#ifndef _BCACHEFS_LRU_H	2	#ifndef _BCACHEFS_LRU_H
3	#define _BCACHEFS_LRU_H	3	#define _BCACHEFS_LRU_H
4		4
5	#define LRU_TIME_BITS 48
6	#define LRU_TIME_MAX ((1ULL << LRU_TIME_BITS) - 1)
7
8	static inline u64 lru_pos_id(struct bpos pos)	5	static inline u64 lru_pos_id(struct bpos pos)
9	{	6	{
10	return pos.inode >> LRU_TIME_BITS;	7	return pos.inode >> LRU_TIME_BITS;

fs/bcachefs/opts.h+1−1

@@ -137,7 +137,7 @@ enum fsck_err_opts { · 136 unmodified lines
137	x(errors, u8, \	137	x(errors, u8, \
138	OPT_FS\|OPT_FORMAT\|OPT_MOUNT\|OPT_RUNTIME, \	138	OPT_FS\|OPT_FORMAT\|OPT_MOUNT\|OPT_RUNTIME, \
139	OPT_STR(bch2_error_actions), \	139	OPT_STR(bch2_error_actions), \
140	BCH_SB_ERROR_ACTION, BCH_ON_ERROR_ro, \	140	BCH_SB_ERROR_ACTION, BCH_ON_ERROR_fix_safe, \
141	NULL, "Action to take on filesystem error") \	141	NULL, "Action to take on filesystem error") \
142	x(metadata_replicas, u8, \	142	x(metadata_replicas, u8, \
143	OPT_FS\|OPT_FORMAT\|OPT_MOUNT\|OPT_RUNTIME, \	143	OPT_FS\|OPT_FORMAT\|OPT_MOUNT\|OPT_RUNTIME, \

fs/bcachefs/recovery.c+9−3

@@ -326,6 +326,12 @@ static int journal_replay_entry_early(struct bch_fs *c, · 325 unmodified lines
326	case BCH_JSET_ENTRY_btree_root: {	326	case BCH_JSET_ENTRY_btree_root: {
327	struct btree_root *r;	327	struct btree_root *r;
328		328
		329	if (fsck_err_on(entry->btree_id >= BTREE_ID_NR_MAX,
		330	c, invalid_btree_id,
		331	"invalid btree id %u (max %u)",
		332	entry->btree_id, BTREE_ID_NR_MAX))
		333	return 0;
		334
329	while (entry->btree_id >= c->btree_roots_extra.nr + BTREE_ID_NR) {	335	while (entry->btree_id >= c->btree_roots_extra.nr + BTREE_ID_NR) {
330	ret = darray_push(&c->btree_roots_extra, (struct btree_root) { NULL });	336	ret = darray_push(&c->btree_roots_extra, (struct btree_root) { NULL });
331	if (ret)	337	if (ret)
@@ -415,7 +421,7 @@ static int journal_replay_entry_early(struct bch_fs *c, · 83 unmodified lines
415	atomic64_set(&c->io_clock[clock->rw].now, le64_to_cpu(clock->time));	421	atomic64_set(&c->io_clock[clock->rw].now, le64_to_cpu(clock->time));
416	}	422	}
417	}	423	}
418		424	fsck_err:
419	return ret;	425	return ret;
420	}	426	}
421		427
@@ -658,10 +664,10 @@ int bch2_fs_recovery(struct bch_fs *c) · 236 unmodified lines
658	if (check_version_upgrade(c))	664	if (check_version_upgrade(c))
659	write_sb = true;	665	write_sb = true;
660		666
		667	c->recovery_passes_explicit \|= bch2_recovery_passes_from_stable(le64_to_cpu(ext->recovery_passes_required[0]));
		668
661	if (write_sb)	669	if (write_sb)
662	bch2_write_super(c);	670	bch2_write_super(c);
663
664	c->recovery_passes_explicit \|= bch2_recovery_passes_from_stable(le64_to_cpu(ext->recovery_passes_required[0]));
665	mutex_unlock(&c->sb_lock);	671	mutex_unlock(&c->sb_lock);
666		672
667	if (c->opts.fsck && IS_ENABLED(CONFIG_BCACHEFS_DEBUG))	673	if (c->opts.fsck && IS_ENABLED(CONFIG_BCACHEFS_DEBUG))

fs/bcachefs/sb-downgrade.c+1−1

@@ -228,7 +228,7 @@ int bch2_sb_downgrade_update(struct bch_fs *c) · 227 unmodified lines
228		228
229	dst = (void *) &darray_top(table);	229	dst = (void *) &darray_top(table);
230	dst->version = cpu_to_le16(src->version);	230	dst->version = cpu_to_le16(src->version);
231	dst->recovery_passes[0] = cpu_to_le64(src->recovery_passes);	231	dst->recovery_passes[0] = cpu_to_le64(bch2_recovery_passes_to_stable(src->recovery_passes));
232	dst->recovery_passes[1] = 0;	232	dst->recovery_passes[1] = 0;
233	dst->nr_errors = cpu_to_le16(src->nr_errors);	233	dst->nr_errors = cpu_to_le16(src->nr_errors);
234	for (unsigned i = 0; i < src->nr_errors; i++)	234	for (unsigned i = 0; i < src->nr_errors; i++)

fs/bcachefs/sb-errors_format.h+286−273

@@ -2,281 +2,294 @@ · 1 unmodified line
2	#ifndef _BCACHEFS_SB_ERRORS_FORMAT_H	2	#ifndef _BCACHEFS_SB_ERRORS_FORMAT_H
3	#define _BCACHEFS_SB_ERRORS_FORMAT_H	3	#define _BCACHEFS_SB_ERRORS_FORMAT_H
4		4
5	#define BCH_SB_ERRS() \	5	enum bch_fsck_flags {
6	x(clean_but_journal_not_empty, 0) \	6	FSCK_CAN_FIX = 1 << 0,
7	x(dirty_but_no_journal_entries, 1) \	7	FSCK_CAN_IGNORE = 1 << 1,
8	x(dirty_but_no_journal_entries_post_drop_nonflushes, 2) \	8	FSCK_NEED_FSCK = 1 << 2,
9	x(sb_clean_journal_seq_mismatch, 3) \	9	FSCK_NO_RATELIMIT = 1 << 3,
10	x(sb_clean_btree_root_mismatch, 4) \	10	FSCK_AUTOFIX = 1 << 4,
11	x(sb_clean_missing, 5) \	11	};
12	x(jset_unsupported_version, 6) \	12
13	x(jset_unknown_csum, 7) \	13	#define BCH_SB_ERRS() \
14	x(jset_last_seq_newer_than_seq, 8) \	14	x(clean_but_journal_not_empty, 0, 0) \
15	x(jset_past_bucket_end, 9) \	15	x(dirty_but_no_journal_entries, 1, 0) \
16	x(jset_seq_blacklisted, 10) \	16	x(dirty_but_no_journal_entries_post_drop_nonflushes, 2, 0) \
17	x(journal_entries_missing, 11) \	17	x(sb_clean_journal_seq_mismatch, 3, 0) \
18	x(journal_entry_replicas_not_marked, 12) \	18	x(sb_clean_btree_root_mismatch, 4, 0) \
19	x(journal_entry_past_jset_end, 13) \	19	x(sb_clean_missing, 5, 0) \
20	x(journal_entry_replicas_data_mismatch, 14) \	20	x(jset_unsupported_version, 6, 0) \
21	x(journal_entry_bkey_u64s_0, 15) \	21	x(jset_unknown_csum, 7, 0) \
22	x(journal_entry_bkey_past_end, 16) \	22	x(jset_last_seq_newer_than_seq, 8, 0) \
23	x(journal_entry_bkey_bad_format, 17) \	23	x(jset_past_bucket_end, 9, 0) \
24	x(journal_entry_bkey_invalid, 18) \	24	x(jset_seq_blacklisted, 10, 0) \
25	x(journal_entry_btree_root_bad_size, 19) \	25	x(journal_entries_missing, 11, 0) \
26	x(journal_entry_blacklist_bad_size, 20) \	26	x(journal_entry_replicas_not_marked, 12, 0) \
27	x(journal_entry_blacklist_v2_bad_size, 21) \	27	x(journal_entry_past_jset_end, 13, 0) \
28	x(journal_entry_blacklist_v2_start_past_end, 22) \	28	x(journal_entry_replicas_data_mismatch, 14, 0) \
29	x(journal_entry_usage_bad_size, 23) \	29	x(journal_entry_bkey_u64s_0, 15, 0) \
30	x(journal_entry_data_usage_bad_size, 24) \	30	x(journal_entry_bkey_past_end, 16, 0) \
31	x(journal_entry_clock_bad_size, 25) \	31	x(journal_entry_bkey_bad_format, 17, 0) \
32	x(journal_entry_clock_bad_rw, 26) \	32	x(journal_entry_bkey_invalid, 18, 0) \
33	x(journal_entry_dev_usage_bad_size, 27) \	33	x(journal_entry_btree_root_bad_size, 19, 0) \
34	x(journal_entry_dev_usage_bad_dev, 28) \	34	x(journal_entry_blacklist_bad_size, 20, 0) \
35	x(journal_entry_dev_usage_bad_pad, 29) \	35	x(journal_entry_blacklist_v2_bad_size, 21, 0) \
36	x(btree_node_unreadable, 30) \	36	x(journal_entry_blacklist_v2_start_past_end, 22, 0) \
37	x(btree_node_fault_injected, 31) \	37	x(journal_entry_usage_bad_size, 23, 0) \
38	x(btree_node_bad_magic, 32) \	38	x(journal_entry_data_usage_bad_size, 24, 0) \
39	x(btree_node_bad_seq, 33) \	39	x(journal_entry_clock_bad_size, 25, 0) \
40	x(btree_node_unsupported_version, 34) \	40	x(journal_entry_clock_bad_rw, 26, 0) \
41	x(btree_node_bset_older_than_sb_min, 35) \	41	x(journal_entry_dev_usage_bad_size, 27, 0) \
42	x(btree_node_bset_newer_than_sb, 36) \	42	x(journal_entry_dev_usage_bad_dev, 28, 0) \
43	x(btree_node_data_missing, 37) \	43	x(journal_entry_dev_usage_bad_pad, 29, 0) \
44	x(btree_node_bset_after_end, 38) \	44	x(btree_node_unreadable, 30, 0) \
45	x(btree_node_replicas_sectors_written_mismatch, 39) \	45	x(btree_node_fault_injected, 31, 0) \
46	x(btree_node_replicas_data_mismatch, 40) \	46	x(btree_node_bad_magic, 32, 0) \
47	x(bset_unknown_csum, 41) \	47	x(btree_node_bad_seq, 33, 0) \
48	x(bset_bad_csum, 42) \	48	x(btree_node_unsupported_version, 34, 0) \
49	x(bset_past_end_of_btree_node, 43) \	49	x(btree_node_bset_older_than_sb_min, 35, 0) \
50	x(bset_wrong_sector_offset, 44) \	50	x(btree_node_bset_newer_than_sb, 36, 0) \
51	x(bset_empty, 45) \	51	x(btree_node_data_missing, 37, 0) \
52	x(bset_bad_seq, 46) \	52	x(btree_node_bset_after_end, 38, 0) \
53	x(bset_blacklisted_journal_seq, 47) \	53	x(btree_node_replicas_sectors_written_mismatch, 39, 0) \
54	x(first_bset_blacklisted_journal_seq, 48) \	54	x(btree_node_replicas_data_mismatch, 40, 0) \
55	x(btree_node_bad_btree, 49) \	55	x(bset_unknown_csum, 41, 0) \
56	x(btree_node_bad_level, 50) \	56	x(bset_bad_csum, 42, 0) \
57	x(btree_node_bad_min_key, 51) \	57	x(bset_past_end_of_btree_node, 43, 0) \
58	x(btree_node_bad_max_key, 52) \	58	x(bset_wrong_sector_offset, 44, 0) \
59	x(btree_node_bad_format, 53) \	59	x(bset_empty, 45, 0) \
60	x(btree_node_bkey_past_bset_end, 54) \	60	x(bset_bad_seq, 46, 0) \
61	x(btree_node_bkey_bad_format, 55) \	61	x(bset_blacklisted_journal_seq, 47, 0) \
62	x(btree_node_bad_bkey, 56) \	62	x(first_bset_blacklisted_journal_seq, 48, 0) \
63	x(btree_node_bkey_out_of_order, 57) \	63	x(btree_node_bad_btree, 49, 0) \
64	x(btree_root_bkey_invalid, 58) \	64	x(btree_node_bad_level, 50, 0) \
65	x(btree_root_read_error, 59) \	65	x(btree_node_bad_min_key, 51, 0) \
66	x(btree_root_bad_min_key, 60) \	66	x(btree_node_bad_max_key, 52, 0) \
67	x(btree_root_bad_max_key, 61) \	67	x(btree_node_bad_format, 53, 0) \
68	x(btree_node_read_error, 62) \	68	x(btree_node_bkey_past_bset_end, 54, 0) \
69	x(btree_node_topology_bad_min_key, 63) \	69	x(btree_node_bkey_bad_format, 55, 0) \
70	x(btree_node_topology_bad_max_key, 64) \	70	x(btree_node_bad_bkey, 56, 0) \
71	x(btree_node_topology_overwritten_by_prev_node, 65) \	71	x(btree_node_bkey_out_of_order, 57, 0) \
72	x(btree_node_topology_overwritten_by_next_node, 66) \	72	x(btree_root_bkey_invalid, 58, 0) \
73	x(btree_node_topology_interior_node_empty, 67) \	73	x(btree_root_read_error, 59, 0) \
74	x(fs_usage_hidden_wrong, 68) \	74	x(btree_root_bad_min_key, 60, 0) \
75	x(fs_usage_btree_wrong, 69) \	75	x(btree_root_bad_max_key, 61, 0) \
76	x(fs_usage_data_wrong, 70) \	76	x(btree_node_read_error, 62, 0) \
77	x(fs_usage_cached_wrong, 71) \	77	x(btree_node_topology_bad_min_key, 63, 0) \
78	x(fs_usage_reserved_wrong, 72) \	78	x(btree_node_topology_bad_max_key, 64, 0) \
79	x(fs_usage_persistent_reserved_wrong, 73) \	79	x(btree_node_topology_overwritten_by_prev_node, 65, 0) \
80	x(fs_usage_nr_inodes_wrong, 74) \	80	x(btree_node_topology_overwritten_by_next_node, 66, 0) \
81	x(fs_usage_replicas_wrong, 75) \	81	x(btree_node_topology_interior_node_empty, 67, 0) \
82	x(dev_usage_buckets_wrong, 76) \	82	x(fs_usage_hidden_wrong, 68, FSCK_AUTOFIX) \
83	x(dev_usage_sectors_wrong, 77) \	83	x(fs_usage_btree_wrong, 69, FSCK_AUTOFIX) \
84	x(dev_usage_fragmented_wrong, 78) \	84	x(fs_usage_data_wrong, 70, FSCK_AUTOFIX) \
85	x(dev_usage_buckets_ec_wrong, 79) \	85	x(fs_usage_cached_wrong, 71, FSCK_AUTOFIX) \
86	x(bkey_version_in_future, 80) \	86	x(fs_usage_reserved_wrong, 72, FSCK_AUTOFIX) \
87	x(bkey_u64s_too_small, 81) \	87	x(fs_usage_persistent_reserved_wrong, 73, FSCK_AUTOFIX) \
88	x(bkey_invalid_type_for_btree, 82) \	88	x(fs_usage_nr_inodes_wrong, 74, FSCK_AUTOFIX) \
89	x(bkey_extent_size_zero, 83) \	89	x(fs_usage_replicas_wrong, 75, FSCK_AUTOFIX) \
90	x(bkey_extent_size_greater_than_offset, 84) \	90	x(dev_usage_buckets_wrong, 76, FSCK_AUTOFIX) \
91	x(bkey_size_nonzero, 85) \	91	x(dev_usage_sectors_wrong, 77, FSCK_AUTOFIX) \
92	x(bkey_snapshot_nonzero, 86) \	92	x(dev_usage_fragmented_wrong, 78, FSCK_AUTOFIX) \
93	x(bkey_snapshot_zero, 87) \	93	x(dev_usage_buckets_ec_wrong, 79, FSCK_AUTOFIX) \
94	x(bkey_at_pos_max, 88) \	94	x(bkey_version_in_future, 80, 0) \
95	x(bkey_before_start_of_btree_node, 89) \	95	x(bkey_u64s_too_small, 81, 0) \
96	x(bkey_after_end_of_btree_node, 90) \	96	x(bkey_invalid_type_for_btree, 82, 0) \
97	x(bkey_val_size_nonzero, 91) \	97	x(bkey_extent_size_zero, 83, 0) \
98	x(bkey_val_size_too_small, 92) \	98	x(bkey_extent_size_greater_than_offset, 84, 0) \
99	x(alloc_v1_val_size_bad, 93) \	99	x(bkey_size_nonzero, 85, 0) \
100	x(alloc_v2_unpack_error, 94) \	100	x(bkey_snapshot_nonzero, 86, 0) \
101	x(alloc_v3_unpack_error, 95) \	101	x(bkey_snapshot_zero, 87, 0) \
102	x(alloc_v4_val_size_bad, 96) \	102	x(bkey_at_pos_max, 88, 0) \
103	x(alloc_v4_backpointers_start_bad, 97) \	103	x(bkey_before_start_of_btree_node, 89, 0) \
104	x(alloc_key_data_type_bad, 98) \	104	x(bkey_after_end_of_btree_node, 90, 0) \
105	x(alloc_key_empty_but_have_data, 99) \	105	x(bkey_val_size_nonzero, 91, 0) \
106	x(alloc_key_dirty_sectors_0, 100) \	106	x(bkey_val_size_too_small, 92, 0) \
107	x(alloc_key_data_type_inconsistency, 101) \	107	x(alloc_v1_val_size_bad, 93, 0) \
108	x(alloc_key_to_missing_dev_bucket, 102) \	108	x(alloc_v2_unpack_error, 94, 0) \
109	x(alloc_key_cached_inconsistency, 103) \	109	x(alloc_v3_unpack_error, 95, 0) \
110	x(alloc_key_cached_but_read_time_zero, 104) \	110	x(alloc_v4_val_size_bad, 96, 0) \
111	x(alloc_key_to_missing_lru_entry, 105) \	111	x(alloc_v4_backpointers_start_bad, 97, 0) \
112	x(alloc_key_data_type_wrong, 106) \	112	x(alloc_key_data_type_bad, 98, 0) \
113	x(alloc_key_gen_wrong, 107) \	113	x(alloc_key_empty_but_have_data, 99, 0) \
114	x(alloc_key_dirty_sectors_wrong, 108) \	114	x(alloc_key_dirty_sectors_0, 100, 0) \
115	x(alloc_key_cached_sectors_wrong, 109) \	115	x(alloc_key_data_type_inconsistency, 101, 0) \
116	x(alloc_key_stripe_wrong, 110) \	116	x(alloc_key_to_missing_dev_bucket, 102, 0) \
117	x(alloc_key_stripe_redundancy_wrong, 111) \	117	x(alloc_key_cached_inconsistency, 103, 0) \
118	x(bucket_sector_count_overflow, 112) \	118	x(alloc_key_cached_but_read_time_zero, 104, 0) \
119	x(bucket_metadata_type_mismatch, 113) \	119	x(alloc_key_to_missing_lru_entry, 105, 0) \
120	x(need_discard_key_wrong, 114) \	120	x(alloc_key_data_type_wrong, 106, FSCK_AUTOFIX) \
121	x(freespace_key_wrong, 115) \	121	x(alloc_key_gen_wrong, 107, FSCK_AUTOFIX) \
122	x(freespace_hole_missing, 116) \	122	x(alloc_key_dirty_sectors_wrong, 108, FSCK_AUTOFIX) \
123	x(bucket_gens_val_size_bad, 117) \	123	x(alloc_key_cached_sectors_wrong, 109, FSCK_AUTOFIX) \
124	x(bucket_gens_key_wrong, 118) \	124	x(alloc_key_stripe_wrong, 110, FSCK_AUTOFIX) \
125	x(bucket_gens_hole_wrong, 119) \	125	x(alloc_key_stripe_redundancy_wrong, 111, FSCK_AUTOFIX) \
126	x(bucket_gens_to_invalid_dev, 120) \	126	x(bucket_sector_count_overflow, 112, 0) \
127	x(bucket_gens_to_invalid_buckets, 121) \	127	x(bucket_metadata_type_mismatch, 113, 0) \
128	x(bucket_gens_nonzero_for_invalid_buckets, 122) \	128	x(need_discard_key_wrong, 114, 0) \
129	x(need_discard_freespace_key_to_invalid_dev_bucket, 123) \	129	x(freespace_key_wrong, 115, 0) \
130	x(need_discard_freespace_key_bad, 124) \	130	x(freespace_hole_missing, 116, 0) \
131	x(backpointer_bucket_offset_wrong, 125) \	131	x(bucket_gens_val_size_bad, 117, 0) \
132	x(backpointer_to_missing_device, 126) \	132	x(bucket_gens_key_wrong, 118, 0) \
133	x(backpointer_to_missing_alloc, 127) \	133	x(bucket_gens_hole_wrong, 119, 0) \
134	x(backpointer_to_missing_ptr, 128) \	134	x(bucket_gens_to_invalid_dev, 120, 0) \
135	x(lru_entry_at_time_0, 129) \	135	x(bucket_gens_to_invalid_buckets, 121, 0) \
136	x(lru_entry_to_invalid_bucket, 130) \	136	x(bucket_gens_nonzero_for_invalid_buckets, 122, 0) \
137	x(lru_entry_bad, 131) \	137	x(need_discard_freespace_key_to_invalid_dev_bucket, 123, 0) \
138	x(btree_ptr_val_too_big, 132) \	138	x(need_discard_freespace_key_bad, 124, 0) \
139	x(btree_ptr_v2_val_too_big, 133) \	139	x(backpointer_bucket_offset_wrong, 125, 0) \
140	x(btree_ptr_has_non_ptr, 134) \	140	x(backpointer_to_missing_device, 126, 0) \
141	x(extent_ptrs_invalid_entry, 135) \	141	x(backpointer_to_missing_alloc, 127, 0) \
142	x(extent_ptrs_no_ptrs, 136) \	142	x(backpointer_to_missing_ptr, 128, 0) \
143	x(extent_ptrs_too_many_ptrs, 137) \	143	x(lru_entry_at_time_0, 129, 0) \
144	x(extent_ptrs_redundant_crc, 138) \	144	x(lru_entry_to_invalid_bucket, 130, 0) \
145	x(extent_ptrs_redundant_stripe, 139) \	145	x(lru_entry_bad, 131, 0) \
146	x(extent_ptrs_unwritten, 140) \	146	x(btree_ptr_val_too_big, 132, 0) \
147	x(extent_ptrs_written_and_unwritten, 141) \	147	x(btree_ptr_v2_val_too_big, 133, 0) \
148	x(ptr_to_invalid_device, 142) \	148	x(btree_ptr_has_non_ptr, 134, 0) \
149	x(ptr_to_duplicate_device, 143) \	149	x(extent_ptrs_invalid_entry, 135, 0) \
150	x(ptr_after_last_bucket, 144) \	150	x(extent_ptrs_no_ptrs, 136, 0) \
151	x(ptr_before_first_bucket, 145) \	151	x(extent_ptrs_too_many_ptrs, 137, 0) \
152	x(ptr_spans_multiple_buckets, 146) \	152	x(extent_ptrs_redundant_crc, 138, 0) \
153	x(ptr_to_missing_backpointer, 147) \	153	x(extent_ptrs_redundant_stripe, 139, 0) \
154	x(ptr_to_missing_alloc_key, 148) \	154	x(extent_ptrs_unwritten, 140, 0) \
155	x(ptr_to_missing_replicas_entry, 149) \	155	x(extent_ptrs_written_and_unwritten, 141, 0) \
156	x(ptr_to_missing_stripe, 150) \	156	x(ptr_to_invalid_device, 142, 0) \
157	x(ptr_to_incorrect_stripe, 151) \	157	x(ptr_to_duplicate_device, 143, 0) \
158	x(ptr_gen_newer_than_bucket_gen, 152) \	158	x(ptr_after_last_bucket, 144, 0) \
159	x(ptr_too_stale, 153) \	159	x(ptr_before_first_bucket, 145, 0) \
160	x(stale_dirty_ptr, 154) \	160	x(ptr_spans_multiple_buckets, 146, 0) \
161	x(ptr_bucket_data_type_mismatch, 155) \	161	x(ptr_to_missing_backpointer, 147, 0) \
162	x(ptr_cached_and_erasure_coded, 156) \	162	x(ptr_to_missing_alloc_key, 148, 0) \
163	x(ptr_crc_uncompressed_size_too_small, 157) \	163	x(ptr_to_missing_replicas_entry, 149, 0) \
164	x(ptr_crc_csum_type_unknown, 158) \	164	x(ptr_to_missing_stripe, 150, 0) \
165	x(ptr_crc_compression_type_unknown, 159) \	165	x(ptr_to_incorrect_stripe, 151, 0) \
166	x(ptr_crc_redundant, 160) \	166	x(ptr_gen_newer_than_bucket_gen, 152, 0) \
167	x(ptr_crc_uncompressed_size_too_big, 161) \	167	x(ptr_too_stale, 153, 0) \
168	x(ptr_crc_nonce_mismatch, 162) \	168	x(stale_dirty_ptr, 154, 0) \
169	x(ptr_stripe_redundant, 163) \	169	x(ptr_bucket_data_type_mismatch, 155, 0) \
170	x(reservation_key_nr_replicas_invalid, 164) \	170	x(ptr_cached_and_erasure_coded, 156, 0) \
171	x(reflink_v_refcount_wrong, 165) \	171	x(ptr_crc_uncompressed_size_too_small, 157, 0) \
172	x(reflink_p_to_missing_reflink_v, 166) \	172	x(ptr_crc_csum_type_unknown, 158, 0) \
173	x(stripe_pos_bad, 167) \	173	x(ptr_crc_compression_type_unknown, 159, 0) \
174	x(stripe_val_size_bad, 168) \	174	x(ptr_crc_redundant, 160, 0) \
175	x(stripe_sector_count_wrong, 169) \	175	x(ptr_crc_uncompressed_size_too_big, 161, 0) \
176	x(snapshot_tree_pos_bad, 170) \	176	x(ptr_crc_nonce_mismatch, 162, 0) \
177	x(snapshot_tree_to_missing_snapshot, 171) \	177	x(ptr_stripe_redundant, 163, 0) \
178	x(snapshot_tree_to_missing_subvol, 172) \	178	x(reservation_key_nr_replicas_invalid, 164, 0) \
179	x(snapshot_tree_to_wrong_subvol, 173) \	179	x(reflink_v_refcount_wrong, 165, 0) \
180	x(snapshot_tree_to_snapshot_subvol, 174) \	180	x(reflink_p_to_missing_reflink_v, 166, 0) \
181	x(snapshot_pos_bad, 175) \	181	x(stripe_pos_bad, 167, 0) \
182	x(snapshot_parent_bad, 176) \	182	x(stripe_val_size_bad, 168, 0) \
183	x(snapshot_children_not_normalized, 177) \	183	x(stripe_sector_count_wrong, 169, 0) \
184	x(snapshot_child_duplicate, 178) \	184	x(snapshot_tree_pos_bad, 170, 0) \
185	x(snapshot_child_bad, 179) \	185	x(snapshot_tree_to_missing_snapshot, 171, 0) \
186	x(snapshot_skiplist_not_normalized, 180) \	186	x(snapshot_tree_to_missing_subvol, 172, 0) \
187	x(snapshot_skiplist_bad, 181) \	187	x(snapshot_tree_to_wrong_subvol, 173, 0) \
188	x(snapshot_should_not_have_subvol, 182) \	188	x(snapshot_tree_to_snapshot_subvol, 174, 0) \
189	x(snapshot_to_bad_snapshot_tree, 183) \	189	x(snapshot_pos_bad, 175, 0) \
190	x(snapshot_bad_depth, 184) \	190	x(snapshot_parent_bad, 176, 0) \
191	x(snapshot_bad_skiplist, 185) \	191	x(snapshot_children_not_normalized, 177, 0) \
192	x(subvol_pos_bad, 186) \	192	x(snapshot_child_duplicate, 178, 0) \
193	x(subvol_not_master_and_not_snapshot, 187) \	193	x(snapshot_child_bad, 179, 0) \
194	x(subvol_to_missing_root, 188) \	194	x(snapshot_skiplist_not_normalized, 180, 0) \
195	x(subvol_root_wrong_bi_subvol, 189) \	195	x(snapshot_skiplist_bad, 181, 0) \
196	x(bkey_in_missing_snapshot, 190) \	196	x(snapshot_should_not_have_subvol, 182, 0) \
197	x(inode_pos_inode_nonzero, 191) \	197	x(snapshot_to_bad_snapshot_tree, 183, 0) \
198	x(inode_pos_blockdev_range, 192) \	198	x(snapshot_bad_depth, 184, 0) \
199	x(inode_unpack_error, 193) \	199	x(snapshot_bad_skiplist, 185, 0) \
200	x(inode_str_hash_invalid, 194) \	200	x(subvol_pos_bad, 186, 0) \
201	x(inode_v3_fields_start_bad, 195) \	201	x(subvol_not_master_and_not_snapshot, 187, 0) \
202	x(inode_snapshot_mismatch, 196) \	202	x(subvol_to_missing_root, 188, 0) \
203	x(inode_unlinked_but_clean, 197) \	203	x(subvol_root_wrong_bi_subvol, 189, 0) \
204	x(inode_unlinked_but_nlink_nonzero, 198) \	204	x(bkey_in_missing_snapshot, 190, 0) \
205	x(inode_checksum_type_invalid, 199) \	205	x(inode_pos_inode_nonzero, 191, 0) \
206	x(inode_compression_type_invalid, 200) \	206	x(inode_pos_blockdev_range, 192, 0) \
207	x(inode_subvol_root_but_not_dir, 201) \	207	x(inode_unpack_error, 193, 0) \
208	x(inode_i_size_dirty_but_clean, 202) \	208	x(inode_str_hash_invalid, 194, 0) \
209	x(inode_i_sectors_dirty_but_clean, 203) \	209	x(inode_v3_fields_start_bad, 195, 0) \
210	x(inode_i_sectors_wrong, 204) \	210	x(inode_snapshot_mismatch, 196, 0) \
211	x(inode_dir_wrong_nlink, 205) \	211	x(inode_unlinked_but_clean, 197, 0) \
212	x(inode_dir_multiple_links, 206) \	212	x(inode_unlinked_but_nlink_nonzero, 198, 0) \
213	x(inode_multiple_links_but_nlink_0, 207) \	213	x(inode_checksum_type_invalid, 199, 0) \
214	x(inode_wrong_backpointer, 208) \	214	x(inode_compression_type_invalid, 200, 0) \
215	x(inode_wrong_nlink, 209) \	215	x(inode_subvol_root_but_not_dir, 201, 0) \
216	x(inode_unreachable, 210) \	216	x(inode_i_size_dirty_but_clean, 202, 0) \
217	x(deleted_inode_but_clean, 211) \	217	x(inode_i_sectors_dirty_but_clean, 203, 0) \
218	x(deleted_inode_missing, 212) \	218	x(inode_i_sectors_wrong, 204, 0) \
219	x(deleted_inode_is_dir, 213) \	219	x(inode_dir_wrong_nlink, 205, 0) \
220	x(deleted_inode_not_unlinked, 214) \	220	x(inode_dir_multiple_links, 206, 0) \
221	x(extent_overlapping, 215) \	221	x(inode_multiple_links_but_nlink_0, 207, 0) \
222	x(extent_in_missing_inode, 216) \	222	x(inode_wrong_backpointer, 208, 0) \
223	x(extent_in_non_reg_inode, 217) \	223	x(inode_wrong_nlink, 209, 0) \
224	x(extent_past_end_of_inode, 218) \	224	x(inode_unreachable, 210, 0) \
225	x(dirent_empty_name, 219) \	225	x(deleted_inode_but_clean, 211, 0) \
226	x(dirent_val_too_big, 220) \	226	x(deleted_inode_missing, 212, 0) \
227	x(dirent_name_too_long, 221) \	227	x(deleted_inode_is_dir, 213, 0) \
228	x(dirent_name_embedded_nul, 222) \	228	x(deleted_inode_not_unlinked, 214, 0) \
229	x(dirent_name_dot_or_dotdot, 223) \	229	x(extent_overlapping, 215, 0) \
230	x(dirent_name_has_slash, 224) \	230	x(extent_in_missing_inode, 216, 0) \
231	x(dirent_d_type_wrong, 225) \	231	x(extent_in_non_reg_inode, 217, 0) \
232	x(inode_bi_parent_wrong, 226) \	232	x(extent_past_end_of_inode, 218, 0) \
233	x(dirent_in_missing_dir_inode, 227) \	233	x(dirent_empty_name, 219, 0) \
234	x(dirent_in_non_dir_inode, 228) \	234	x(dirent_val_too_big, 220, 0) \
235	x(dirent_to_missing_inode, 229) \	235	x(dirent_name_too_long, 221, 0) \
236	x(dirent_to_missing_subvol, 230) \	236	x(dirent_name_embedded_nul, 222, 0) \
237	x(dirent_to_itself, 231) \	237	x(dirent_name_dot_or_dotdot, 223, 0) \
238	x(quota_type_invalid, 232) \	238	x(dirent_name_has_slash, 224, 0) \
239	x(xattr_val_size_too_small, 233) \	239	x(dirent_d_type_wrong, 225, 0) \
240	x(xattr_val_size_too_big, 234) \	240	x(inode_bi_parent_wrong, 226, 0) \
241	x(xattr_invalid_type, 235) \	241	x(dirent_in_missing_dir_inode, 227, 0) \
242	x(xattr_name_invalid_chars, 236) \	242	x(dirent_in_non_dir_inode, 228, 0) \
243	x(xattr_in_missing_inode, 237) \	243	x(dirent_to_missing_inode, 229, 0) \
244	x(root_subvol_missing, 238) \	244	x(dirent_to_missing_subvol, 230, 0) \
245	x(root_dir_missing, 239) \	245	x(dirent_to_itself, 231, 0) \
246	x(root_inode_not_dir, 240) \	246	x(quota_type_invalid, 232, 0) \
247	x(dir_loop, 241) \	247	x(xattr_val_size_too_small, 233, 0) \
248	x(hash_table_key_duplicate, 242) \	248	x(xattr_val_size_too_big, 234, 0) \
249	x(hash_table_key_wrong_offset, 243) \	249	x(xattr_invalid_type, 235, 0) \
250	x(unlinked_inode_not_on_deleted_list, 244) \	250	x(xattr_name_invalid_chars, 236, 0) \
251	x(reflink_p_front_pad_bad, 245) \	251	x(xattr_in_missing_inode, 237, 0) \
252	x(journal_entry_dup_same_device, 246) \	252	x(root_subvol_missing, 238, 0) \
253	x(inode_bi_subvol_missing, 247) \	253	x(root_dir_missing, 239, 0) \
254	x(inode_bi_subvol_wrong, 248) \	254	x(root_inode_not_dir, 240, 0) \
255	x(inode_points_to_missing_dirent, 249) \	255	x(dir_loop, 241, 0) \
256	x(inode_points_to_wrong_dirent, 250) \	256	x(hash_table_key_duplicate, 242, 0) \
257	x(inode_bi_parent_nonzero, 251) \	257	x(hash_table_key_wrong_offset, 243, 0) \
258	x(dirent_to_missing_parent_subvol, 252) \	258	x(unlinked_inode_not_on_deleted_list, 244, 0) \
259	x(dirent_not_visible_in_parent_subvol, 253) \	259	x(reflink_p_front_pad_bad, 245, 0) \
260	x(subvol_fs_path_parent_wrong, 254) \	260	x(journal_entry_dup_same_device, 246, 0) \
261	x(subvol_root_fs_path_parent_nonzero, 255) \	261	x(inode_bi_subvol_missing, 247, 0) \
262	x(subvol_children_not_set, 256) \	262	x(inode_bi_subvol_wrong, 248, 0) \
263	x(subvol_children_bad, 257) \	263	x(inode_points_to_missing_dirent, 249, 0) \
264	x(subvol_loop, 258) \	264	x(inode_points_to_wrong_dirent, 250, 0) \
265	x(subvol_unreachable, 259) \	265	x(inode_bi_parent_nonzero, 251, 0) \
266	x(btree_node_bkey_bad_u64s, 260) \	266	x(dirent_to_missing_parent_subvol, 252, 0) \
267	x(btree_node_topology_empty_interior_node, 261) \	267	x(dirent_not_visible_in_parent_subvol, 253, 0) \
268	x(btree_ptr_v2_min_key_bad, 262) \	268	x(subvol_fs_path_parent_wrong, 254, 0) \
269	x(btree_root_unreadable_and_scan_found_nothing, 263) \	269	x(subvol_root_fs_path_parent_nonzero, 255, 0) \
270	x(snapshot_node_missing, 264) \	270	x(subvol_children_not_set, 256, 0) \
271	x(dup_backpointer_to_bad_csum_extent, 265) \	271	x(subvol_children_bad, 257, 0) \
272	x(btree_bitmap_not_marked, 266) \	272	x(subvol_loop, 258, 0) \
273	x(sb_clean_entry_overrun, 267) \	273	x(subvol_unreachable, 259, 0) \
274	x(btree_ptr_v2_written_0, 268) \	274	x(btree_node_bkey_bad_u64s, 260, 0) \
275	x(subvol_snapshot_bad, 269) \	275	x(btree_node_topology_empty_interior_node, 261, 0) \
276	x(subvol_inode_bad, 270)	276	x(btree_ptr_v2_min_key_bad, 262, 0) \
		277	x(btree_root_unreadable_and_scan_found_nothing, 263, 0) \
		278	x(snapshot_node_missing, 264, 0) \
		279	x(dup_backpointer_to_bad_csum_extent, 265, 0) \
		280	x(btree_bitmap_not_marked, 266, 0) \
		281	x(sb_clean_entry_overrun, 267, 0) \
		282	x(btree_ptr_v2_written_0, 268, 0) \
		283	x(subvol_snapshot_bad, 269, 0) \
		284	x(subvol_inode_bad, 270, 0) \
		285	x(alloc_key_stripe_sectors_wrong, 271, 0) \
		286	x(accounting_mismatch, 272, 0) \
		287	x(accounting_replicas_not_marked, 273, 0) \
		288	x(invalid_btree_id, 274, 0) \
		289	x(alloc_key_io_time_bad, 275, 0)
277		290
278	enum bch_sb_error_id {	291	enum bch_sb_error_id {
279	#define x(t, n) BCH_FSCK_ERR_##t = n,	292	#define x(t, n, ...) BCH_FSCK_ERR_##t = n,
280	BCH_SB_ERRS()	293	BCH_SB_ERRS()
281	#undef x	294	#undef x
282	BCH_SB_ERR_MAX	295	BCH_SB_ERR_MAX

fs/bcachefs/snapshot.c+2−7

 	if (!test_and_clear_bit(BCH_FS_need_delete_dead_snapshots, &c->flags))
 		return 0;
-	if (!test_bit(BCH_FS_started, &c->flags)) {
-		ret = bch2_fs_read_write_early(c);
-		bch_err_msg(c, ret, "deleting dead snapshots: error going rw");
-		if (ret)
-			return ret;
-	}
 	trans = bch2_trans_get(c);
 	/*
 {
 	struct bch_fs *c = container_of(work, struct bch_fs, snapshot_delete_work);
+	set_worker_desc("bcachefs-delete-dead-snapshots/%s", c->name);
 	bch2_delete_dead_snapshots(c);
 	bch2_write_ref_put(c, BCH_WRITE_REF_delete_dead_snapshots);
 }

fs/bcachefs/str_hash.h+1−1

@@ -300,7 +300,7 @@ not_found: · 299 unmodified lines
300	if (!found && (flags & STR_HASH_must_replace)) {	300	if (!found && (flags & STR_HASH_must_replace)) {
301	ret = -BCH_ERR_ENOENT_str_hash_set_must_replace;	301	ret = -BCH_ERR_ENOENT_str_hash_set_must_replace;
302	} else if (found && (flags & STR_HASH_must_create)) {	302	} else if (found && (flags & STR_HASH_must_create)) {
303	ret = -EEXIST;	303	ret = -BCH_ERR_EEXIST_str_hash_set;
304	} else {	304	} else {
305	if (!found && slot.path)	305	if (!found && slot.path)
306	swap(iter, slot);	306	swap(iter, slot);

fs/bcachefs/super-io.c+4−3

@@ -649,9 +649,10 @@ reread: · 648 unmodified lines
649		649
650	bytes = vstruct_bytes(sb->sb);	650	bytes = vstruct_bytes(sb->sb);
651		651
652	if (bytes > 512ULL << min(BCH_SB_LAYOUT_SIZE_BITS_MAX, sb->sb->layout.sb_max_size_bits)) {	652	u64 sb_size = 512ULL << min(BCH_SB_LAYOUT_SIZE_BITS_MAX, sb->sb->layout.sb_max_size_bits);
653	prt_printf(err, "Invalid superblock: too big (got %zu bytes, layout max %lu)",	653	if (bytes > sb_size) {
654	bytes, 512UL << sb->sb->layout.sb_max_size_bits);	654	prt_printf(err, "Invalid superblock: too big (got %zu bytes, layout max %llu)",
		655	bytes, sb_size);
655	return -BCH_ERR_invalid_sb_too_big;	656	return -BCH_ERR_invalid_sb_too_big;
656	}	657	}
657		658

fs/bcachefs/super.c+7−6

 	    bch2_io_clock_init(&c->io_clock[WRITE]) ?:
 	    bch2_fs_journal_init(&c->journal) ?:
 	    bch2_fs_replicas_init(c) ?:
+	    bch2_fs_btree_iter_init(c) ?:
 	    bch2_fs_btree_cache_init(c) ?:
 	    bch2_fs_btree_key_cache_init(&c->btree_key_cache) ?:
-	    bch2_fs_btree_iter_init(c) ?:
 	    bch2_fs_btree_interior_update_init(c) ?:
 	    bch2_fs_buckets_waiting_for_journal_init(c) ?:
 	    bch2_fs_btree_write_buffer_init(c) ?:
 	if (ret)
 		goto err;
-	for (i = 0; i < c->sb.nr_devices; i++)
+	for (i = 0; i < c->sb.nr_devices; i++) {
-		if (bch2_member_exists(c->disk_sb.sb, i) &&
+		if (!bch2_member_exists(c->disk_sb.sb, i))
-		    bch2_dev_alloc(c, i)) {
+			continue;
-			ret = -EEXIST;
+		ret = bch2_dev_alloc(c, i);
+		if (ret)
 			goto err;
-		}
+	}
 	bch2_journal_entry_res_resize(&c->journal,
 			&c->btree_root_journal_res,

fs/btrfs/bio.c+3−1

 			ret = btrfs_bio_csum(bbio);
 			if (ret)
 				goto fail_put_bio;
-		} else if (use_append) {
+		} else if (use_append ||
+			   (btrfs_is_zoned(fs_info) && inode &&
+			    inode->flags & BTRFS_INODE_NODATASUM)) {
 			ret = btrfs_alloc_dummy_sum(bbio);
 			if (ret)
 				goto fail_put_bio;

fs/btrfs/block-group.c+9−2

 		container_of(work, struct btrfs_fs_info, reclaim_bgs_work);
 	struct btrfs_block_group *bg;
 	struct btrfs_space_info *space_info;
+	LIST_HEAD(retry_list);
 	if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
 		return;
 		}
 next:
-		if (ret)
+		if (ret) {
-			btrfs_mark_bg_to_reclaim(bg);
+			/* Refcount held by the reclaim_bgs list after splice. */
+			btrfs_get_block_group(bg);
+			list_add_tail(&bg->bg_list, &retry_list);
+		}
 		btrfs_put_block_group(bg);
 		mutex_unlock(&fs_info->reclaim_bgs_lock);
 	spin_unlock(&fs_info->unused_bgs_lock);
 	mutex_unlock(&fs_info->reclaim_bgs_lock);
 end:
+	spin_lock(&fs_info->unused_bgs_lock);
+	list_splice_tail(&retry_list, &fs_info->reclaim_bgs);
+	spin_unlock(&fs_info->unused_bgs_lock);
 	btrfs_exclop_finish(fs_info);
 	sb_end_write(fs_info->sb);
 }

fs/nfsd/netlink.c+0−2

 static const struct genl_split_ops nfsd_nl_ops[] = {
 	{
 		.cmd	= NFSD_CMD_RPC_STATUS_GET,
-		.start	= nfsd_nl_rpc_status_get_start,
 		.dumpit	= nfsd_nl_rpc_status_get_dumpit,
-		.done	= nfsd_nl_rpc_status_get_done,
 		.flags	= GENL_CMD_CAP_DUMP,
 	},
 	{

fs/nfsd/netlink.h+0−3

@@ -15,9 +15,6 @@ · 14 unmodified lines
15	extern const struct nla_policy nfsd_sock_nl_policy[NFSD_A_SOCK_TRANSPORT_NAME + 1];	15	extern const struct nla_policy nfsd_sock_nl_policy[NFSD_A_SOCK_TRANSPORT_NAME + 1];
16	extern const struct nla_policy nfsd_version_nl_policy[NFSD_A_VERSION_ENABLED + 1];	16	extern const struct nla_policy nfsd_version_nl_policy[NFSD_A_VERSION_ENABLED + 1];
17		17
18	int nfsd_nl_rpc_status_get_start(struct netlink_callback *cb);
19	int nfsd_nl_rpc_status_get_done(struct netlink_callback *cb);
20
21	int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,	18	int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,
22	struct netlink_callback *cb);	19	struct netlink_callback *cb);
23	int nfsd_nl_threads_set_doit(struct sk_buff skb, struct genl_info info);	20	int nfsd_nl_threads_set_doit(struct sk_buff skb, struct genl_info info);

fs/nfsd/nfsctl.c+11−37

@@ -1460,28 +1460,6 @@ static int create_proc_exports_entry(void) · 1459 unmodified lines
1460		1460
1461	unsigned int nfsd_net_id;	1461	unsigned int nfsd_net_id;
1462		1462
1463	/**
1464	* nfsd_nl_rpc_status_get_start - Prepare rpc_status_get dumpit
1465	* @cb: netlink metadata and command arguments
1466	*
1467	* Return values:
1468	* %0: The rpc_status_get command may proceed
1469	* %-ENODEV: There is no NFSD running in this namespace
1470	*/
1471	int nfsd_nl_rpc_status_get_start(struct netlink_callback *cb)
1472	{
1473	struct nfsd_net *nn = net_generic(sock_net(cb->skb->sk), nfsd_net_id);
1474	int ret = -ENODEV;
1475
1476	mutex_lock(&nfsd_mutex);
1477	if (nn->nfsd_serv)
1478	ret = 0;
1479	else
1480	mutex_unlock(&nfsd_mutex);
1481
1482	return ret;
1483	}
1484
1485	static int nfsd_genl_rpc_status_compose_msg(struct sk_buff *skb,	1463	static int nfsd_genl_rpc_status_compose_msg(struct sk_buff *skb,
1486	struct netlink_callback *cb,	1464	struct netlink_callback *cb,
1487	struct nfsd_genl_rqstp *rqstp)	1465	struct nfsd_genl_rqstp *rqstp)
@@ -1558,8 +1536,16 @@ static int nfsd_genl_rpc_status_compose_msg(struct sk_buff *skb, · 70 unmodified lines
1558	int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,	1536	int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,
1559	struct netlink_callback *cb)	1537	struct netlink_callback *cb)
1560	{	1538	{
1561	struct nfsd_net *nn = net_generic(sock_net(skb->sk), nfsd_net_id);
1562	int i, ret, rqstp_index = 0;	1539	int i, ret, rqstp_index = 0;
		1540	struct nfsd_net *nn;
		1541
		1542	mutex_lock(&nfsd_mutex);
		1543
		1544	nn = net_generic(sock_net(skb->sk), nfsd_net_id);
		1545	if (!nn->nfsd_serv) {
		1546	ret = -ENODEV;
		1547	goto out_unlock;
		1548	}
1563		1549
1564	rcu_read_lock();	1550	rcu_read_lock();
1565		1551
@@ -1636,22 +1622,10 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, · 70 unmodified lines
1636	ret = skb->len;	1622	ret = skb->len;
1637	out:	1623	out:
1638	rcu_read_unlock();	1624	rcu_read_unlock();
1639		1625	out_unlock:
1640	return ret;
1641	}
1642
1643	/**
1644	* nfsd_nl_rpc_status_get_done - rpc_status_get dumpit post-processing
1645	* @cb: netlink metadata and command arguments
1646	*
1647	* Return values:
1648	* %0: Success
1649	*/
1650	int nfsd_nl_rpc_status_get_done(struct netlink_callback *cb)
1651	{
1652	mutex_unlock(&nfsd_mutex);	1626	mutex_unlock(&nfsd_mutex);
1653		1627
1654	return 0;	1628	return ret;
1655	}	1629	}
1656		1630
1657	/**	1631	/**

fs/ocfs2/journal.c+107−85

 	return status;
 }
-struct ocfs2_triggers {
-	struct jbd2_buffer_trigger_type	ot_triggers;
-	int				ot_offset;
-};
 static inline struct ocfs2_triggers *to_ocfs2_trigger(struct jbd2_buffer_trigger_type *triggers)
 {
 	return container_of(triggers, struct ocfs2_triggers, ot_triggers);
 static void ocfs2_abort_trigger(struct jbd2_buffer_trigger_type *triggers,
 				struct buffer_head *bh)
 {
+	struct ocfs2_triggers *ot = to_ocfs2_trigger(triggers);
 	mlog(ML_ERROR,
 	     "ocfs2_abort_trigger called by JBD2.  bh = 0x%lx, "
 	     "bh->b_blocknr = %llu\n",
 	     (unsigned long)bh,
 	     (unsigned long long)bh->b_blocknr);
-	ocfs2_error(bh->b_assoc_map->host->i_sb,
+	ocfs2_error(ot->sb,
 		    "JBD2 has aborted our journal, ocfs2 cannot continue\n");
 }
-static struct ocfs2_triggers di_triggers = {
+static void ocfs2_setup_csum_triggers(struct super_block *sb,
-	.ot_triggers = {
+				      enum ocfs2_journal_trigger_type type,
-		.t_frozen = ocfs2_frozen_trigger,
+				      struct ocfs2_triggers *ot)
-		.t_abort = ocfs2_abort_trigger,
+{
-	},
+	BUG_ON(type >= OCFS2_JOURNAL_TRIGGER_COUNT);
-	.ot_offset	= offsetof(struct ocfs2_dinode, i_check),
-};
-static struct ocfs2_triggers eb_triggers = {
-	.ot_triggers = {
-		.t_frozen = ocfs2_frozen_trigger,
-		.t_abort = ocfs2_abort_trigger,
-	},
-	.ot_offset	= offsetof(struct ocfs2_extent_block, h_check),
-};
-static struct ocfs2_triggers rb_triggers = {
-	.ot_triggers = {
-		.t_frozen = ocfs2_frozen_trigger,
-		.t_abort = ocfs2_abort_trigger,
-	},
-	.ot_offset	= offsetof(struct ocfs2_refcount_block, rf_check),
-};
-static struct ocfs2_triggers gd_triggers = {
-	.ot_triggers = {
-		.t_frozen = ocfs2_frozen_trigger,
-		.t_abort = ocfs2_abort_trigger,
-	},
-	.ot_offset	= offsetof(struct ocfs2_group_desc, bg_check),
-};
-static struct ocfs2_triggers db_triggers = {
-	.ot_triggers = {
-		.t_frozen = ocfs2_db_frozen_trigger,
-		.t_abort = ocfs2_abort_trigger,
-	},
-};
-static struct ocfs2_triggers xb_triggers = {
+	switch (type) {
-	.ot_triggers = {
+	case OCFS2_JTR_DI:
-		.t_frozen = ocfs2_frozen_trigger,
+		ot->ot_triggers.t_frozen = ocfs2_frozen_trigger;
-		.t_abort = ocfs2_abort_trigger,
+		ot->ot_offset = offsetof(struct ocfs2_dinode, i_check);
-	},
+		break;
-	.ot_offset	= offsetof(struct ocfs2_xattr_block, xb_check),
+	case OCFS2_JTR_EB:
-};
+		ot->ot_triggers.t_frozen = ocfs2_frozen_trigger;
+		ot->ot_offset = offsetof(struct ocfs2_extent_block, h_check);
+		break;
+	case OCFS2_JTR_RB:
+		ot->ot_triggers.t_frozen = ocfs2_frozen_trigger;
+		ot->ot_offset = offsetof(struct ocfs2_refcount_block, rf_check);
+		break;
+	case OCFS2_JTR_GD:
+		ot->ot_triggers.t_frozen = ocfs2_frozen_trigger;
+		ot->ot_offset = offsetof(struct ocfs2_group_desc, bg_check);
+		break;
+	case OCFS2_JTR_DB:
+		ot->ot_triggers.t_frozen = ocfs2_db_frozen_trigger;
+		break;
+	case OCFS2_JTR_XB:
+		ot->ot_triggers.t_frozen = ocfs2_frozen_trigger;
+		ot->ot_offset = offsetof(struct ocfs2_xattr_block, xb_check);
+		break;
+	case OCFS2_JTR_DQ:
+		ot->ot_triggers.t_frozen = ocfs2_dq_frozen_trigger;
+		break;
+	case OCFS2_JTR_DR:
+		ot->ot_triggers.t_frozen = ocfs2_frozen_trigger;
+		ot->ot_offset = offsetof(struct ocfs2_dx_root_block, dr_check);
+		break;
+	case OCFS2_JTR_DL:
+		ot->ot_triggers.t_frozen = ocfs2_frozen_trigger;
+		ot->ot_offset = offsetof(struct ocfs2_dx_leaf, dl_check);
+		break;
+	case OCFS2_JTR_NONE:
+		/* To make compiler happy... */
+		return;
+	}
-static struct ocfs2_triggers dq_triggers = {
+	ot->ot_triggers.t_abort = ocfs2_abort_trigger;
-	.ot_triggers = {
+	ot->sb = sb;
-		.t_frozen = ocfs2_dq_frozen_trigger,
+}
-		.t_abort = ocfs2_abort_trigger,
-	},
-};
-static struct ocfs2_triggers dr_triggers = {
+void ocfs2_initialize_journal_triggers(struct super_block *sb,
-	.ot_triggers = {
+				       struct ocfs2_triggers triggers[])
-		.t_frozen = ocfs2_frozen_trigger,
+{
-		.t_abort = ocfs2_abort_trigger,
+	enum ocfs2_journal_trigger_type type;
-	},
-	.ot_offset	= offsetof(struct ocfs2_dx_root_block, dr_check),
-};
-static struct ocfs2_triggers dl_triggers = {
+	for (type = OCFS2_JTR_DI; type < OCFS2_JOURNAL_TRIGGER_COUNT; type++)
-	.ot_triggers = {
+		ocfs2_setup_csum_triggers(sb, type, &triggers[type]);
-		.t_frozen = ocfs2_frozen_trigger,
+}
-		.t_abort = ocfs2_abort_trigger,
-	},
-	.ot_offset	= offsetof(struct ocfs2_dx_leaf, dl_check),
-};
 static int __ocfs2_journal_access(handle_t *handle,
 				  struct ocfs2_caching_info *ci,
 int ocfs2_journal_access_di(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &di_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				      &osb->s_journal_triggers[OCFS2_JTR_DI],
+				      type);
 }
 int ocfs2_journal_access_eb(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &eb_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				      &osb->s_journal_triggers[OCFS2_JTR_EB],
+				      type);
 }
 int ocfs2_journal_access_rb(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &rb_triggers,
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				      &osb->s_journal_triggers[OCFS2_JTR_RB],
 				      type);
 }
 int ocfs2_journal_access_gd(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &gd_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				     &osb->s_journal_triggers[OCFS2_JTR_GD],
+				     type);
 }
 int ocfs2_journal_access_db(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &db_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				     &osb->s_journal_triggers[OCFS2_JTR_DB],
+				     type);
 }
 int ocfs2_journal_access_xb(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &xb_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				     &osb->s_journal_triggers[OCFS2_JTR_XB],
+				     type);
 }
 int ocfs2_journal_access_dq(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &dq_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				     &osb->s_journal_triggers[OCFS2_JTR_DQ],
+				     type);
 }
 int ocfs2_journal_access_dr(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &dr_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				     &osb->s_journal_triggers[OCFS2_JTR_DR],
+				     type);
 }
 int ocfs2_journal_access_dl(handle_t *handle, struct ocfs2_caching_info *ci,
 			    struct buffer_head *bh, int type)
 {
-	return __ocfs2_journal_access(handle, ci, bh, &dl_triggers, type);
+	struct ocfs2_super *osb = OCFS2_SB(ocfs2_metadata_cache_get_super(ci));
+	return __ocfs2_journal_access(handle, ci, bh,
+				     &osb->s_journal_triggers[OCFS2_JTR_DL],
+				     type);
 }
 int ocfs2_journal_access(handle_t *handle, struct ocfs2_caching_info *ci,
 		if (!is_handle_aborted(handle)) {
 			journal_t *journal = handle->h_transaction->t_journal;
-			mlog(ML_ERROR, "jbd2_journal_dirty_metadata failed. "
+			mlog(ML_ERROR, "jbd2_journal_dirty_metadata failed: "
-					"Aborting transaction and journal.\n");
+			     "handle type %u started at line %u, credits %u/%u "
+			     "errcode %d. Aborting transaction and journal.\n",
+			     handle->h_type, handle->h_line_no,
+			     handle->h_requested_credits,
+			     jbd2_handle_buffer_credits(handle), status);
 			handle->h_err = status;
 			jbd2_journal_abort_handle(handle);
 			jbd2_journal_abort(journal, status);
-			ocfs2_abort(bh->b_assoc_map->host->i_sb,
-				    "Journal already aborted.\n");
 		}
 	}
 }

fs/ocfs2/ocfs2.h+27−0

@@ -284,6 +284,30 @@ enum ocfs2_mount_options · 283 unmodified lines
284	#define OCFS2_OSB_ERROR_FS 0x0004	284	#define OCFS2_OSB_ERROR_FS 0x0004
285	#define OCFS2_DEFAULT_ATIME_QUANTUM 60	285	#define OCFS2_DEFAULT_ATIME_QUANTUM 60
286		286
		287	struct ocfs2_triggers {
		288	struct jbd2_buffer_trigger_type ot_triggers;
		289	int ot_offset;
		290	struct super_block *sb;
		291	};
		292
		293	enum ocfs2_journal_trigger_type {
		294	OCFS2_JTR_DI,
		295	OCFS2_JTR_EB,
		296	OCFS2_JTR_RB,
		297	OCFS2_JTR_GD,
		298	OCFS2_JTR_DB,
		299	OCFS2_JTR_XB,
		300	OCFS2_JTR_DQ,
		301	OCFS2_JTR_DR,
		302	OCFS2_JTR_DL,
		303	OCFS2_JTR_NONE /* This must be the last entry */
		304	};
		305
		306	#define OCFS2_JOURNAL_TRIGGER_COUNT OCFS2_JTR_NONE
		307
		308	void ocfs2_initialize_journal_triggers(struct super_block *sb,
		309	struct ocfs2_triggers triggers[]);
		310
287	struct ocfs2_journal;	311	struct ocfs2_journal;
288	struct ocfs2_slot_info;	312	struct ocfs2_slot_info;
289	struct ocfs2_recovery_map;	313	struct ocfs2_recovery_map;
@@ -351,6 +375,9 @@ struct ocfs2_super · 61 unmodified lines
351	struct ocfs2_journal *journal;	375	struct ocfs2_journal *journal;
352	unsigned long osb_commit_interval;	376	unsigned long osb_commit_interval;
353		377
		378	/* Journal triggers for checksum */
		379	struct ocfs2_triggers s_journal_triggers[OCFS2_JOURNAL_TRIGGER_COUNT];
		380
354	struct delayed_work la_enable_wq;	381	struct delayed_work la_enable_wq;
355		382
356	/*	383	/*

fs/ocfs2/super.c+3−1

 	debugfs_create_file("fs_state", S_IFREG|S_IRUSR, osb->osb_debug_root,
 			    osb, &ocfs2_osb_debug_fops);
-	if (ocfs2_meta_ecc(osb))
+	if (ocfs2_meta_ecc(osb)) {
+		ocfs2_initialize_journal_triggers(sb, osb->s_journal_triggers);
 		ocfs2_blockcheck_stats_debugfs_install( &osb->osb_ecc_stats,
 							osb->osb_debug_root);
+	}
 	status = ocfs2_mount_volume(sb);
 	if (status < 0)

fs/overlayfs/dir.c+4−4

 	int flags = file->f_flags | OVL_OPEN_FLAGS;
 	int err;
-	err = ovl_copy_up(dentry->d_parent);
-	if (err)
-		return err;
 	old_cred = ovl_override_creds(dentry->d_sb);
 	err = ovl_setup_cred_for_create(dentry, inode, mode, old_cred);
 	if (err)
 	if (!OVL_FS(dentry->d_sb)->tmpfile)
 		return -EOPNOTSUPP;
+	err = ovl_copy_up(dentry->d_parent);
+	if (err)
+		return err;
 	err = ovl_want_write(dentry);
 	if (err)
 		return err;

fs/overlayfs/export.c+5−1

 	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 	bool decodable = ofs->config.nfs_export;
+	/* No upper layer? */
+	if (!ovl_upper_mnt(ofs))
+		return 1;
 	/* Lower file handle for non-upper non-decodable */
 	if (!ovl_dentry_upper(dentry) && !decodable)
 		return 1;
 	 * ovl_connect_layer() will try to make origin's layer "connected" by
 	 * copying up a "connectable" ancestor.
 	 */
-	if (d_is_dir(dentry) && ovl_upper_mnt(ofs) && decodable)
+	if (d_is_dir(dentry) && decodable)
 		return ovl_connect_layer(dentry);
 	/* Lower file handle for indexed and non-upper dir/non-dir */

fs/smb/client/cifsfs.c+1−1

@@ -134,7 +134,7 @@ module_param(enable_oplocks, bool, 0644); · 133 unmodified lines
134	MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");	134	MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
135		135
136	module_param(enable_gcm_256, bool, 0644);	136	module_param(enable_gcm_256, bool, 0644);
137	MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");	137	MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: y/Y/0");
138		138
139	module_param(require_gcm_256, bool, 0644);	139	module_param(require_gcm_256, bool, 0644);
140	MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");	140	MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");

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

 struct cifs_io_request {
 	struct netfs_io_request		rreq;
 	struct cifsFileInfo		*cfile;
+	struct TCP_Server_Info		*server;
+	pid_t				pid;
 };
 /* asynchronous read support */
 		struct cifs_io_request *req;
 	};
 	ssize_t				got_bytes;
-	pid_t				pid;
 	unsigned int			xid;
 	int				result;
 	bool				have_xid;

fs/smb/client/cifssmb.c+4−4

@@ -1345,8 +1345,8 @@ cifs_async_readv(struct cifs_io_subrequest *rdata) · 1344 unmodified lines
1345	if (rc)	1345	if (rc)
1346	return rc;	1346	return rc;
1347		1347
1348	smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);	1348	smb->hdr.Pid = cpu_to_le16((__u16)rdata->req->pid);
1349	smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));	1349	smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->req->pid >> 16));
1350		1350
1351	smb->AndXCommand = 0xFF; /* none */	1351	smb->AndXCommand = 0xFF; /* none */
1352	smb->Fid = rdata->req->cfile->fid.netfid;	1352	smb->Fid = rdata->req->cfile->fid.netfid;
@@ -1689,8 +1689,8 @@ cifs_async_writev(struct cifs_io_subrequest *wdata) · 336 unmodified lines
1689	if (rc)	1689	if (rc)
1690	goto async_writev_out;	1690	goto async_writev_out;
1691		1691
1692	smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);	1692	smb->hdr.Pid = cpu_to_le16((__u16)wdata->req->pid);
1693	smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));	1693	smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->req->pid >> 16));
1694		1694
1695	smb->AndXCommand = 0xFF; /* none */	1695	smb->AndXCommand = 0xFF; /* none */
1696	smb->Fid = wdata->req->cfile->fid.netfid;	1696	smb->Fid = wdata->req->cfile->fid.netfid;

fs/smb/client/file.c+6−21

 static bool cifs_clamp_length(struct netfs_io_subrequest *subreq)
 {
 	struct netfs_io_request *rreq = subreq->rreq;
-	struct TCP_Server_Info *server;
 	struct cifs_io_subrequest *rdata = container_of(subreq, struct cifs_io_subrequest, subreq);
 	struct cifs_io_request *req = container_of(subreq->rreq, struct cifs_io_request, rreq);
+	struct TCP_Server_Info *server = req->server;
 	struct cifs_sb_info *cifs_sb = CIFS_SB(rreq->inode->i_sb);
 	size_t rsize = 0;
 	int rc;
 	rdata->xid = get_xid();
 	rdata->have_xid = true;
-	server = cifs_pick_channel(tlink_tcon(req->cfile->tlink)->ses);
 	rdata->server = server;
 	if (cifs_sb->ctx->rsize == 0)
 	struct netfs_io_request *rreq = subreq->rreq;
 	struct cifs_io_subrequest *rdata = container_of(subreq, struct cifs_io_subrequest, subreq);
 	struct cifs_io_request *req = container_of(subreq->rreq, struct cifs_io_request, rreq);
-	struct cifs_sb_info *cifs_sb = CIFS_SB(rreq->inode->i_sb);
-	pid_t pid;
 	int rc = 0;
-	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
-		pid = req->cfile->pid;
-	else
-		pid = current->tgid; // Ummm...  This may be a workqueue
 	cifs_dbg(FYI, "%s: op=%08x[%x] mapping=%p len=%zu/%zu\n",
 		 __func__, rreq->debug_id, subreq->debug_index, rreq->mapping,
 		 subreq->transferred, subreq->len);
 	}
 	__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
-	rdata->pid = pid;
-	rc = adjust_credits(rdata->server, &rdata->credits, rdata->subreq.len);
-	if (!rc) {
-		if (rdata->req->cfile->invalidHandle)
-			rc = -EAGAIN;
-		else
-			rc = rdata->server->ops->async_readv(rdata);
-	}
+	rc = rdata->server->ops->async_readv(rdata);
 out:
 	if (rc)
 		netfs_subreq_terminated(subreq, rc, false);
 	rreq->rsize = cifs_sb->ctx->rsize;
 	rreq->wsize = cifs_sb->ctx->wsize;
+	req->pid = current->tgid; // Ummm...  This may be a workqueue
 	if (file) {
 		open_file = file->private_data;
 		rreq->netfs_priv = file->private_data;
 		req->cfile = cifsFileInfo_get(open_file);
+		req->server = cifs_pick_channel(tlink_tcon(req->cfile->tlink)->ses);
+		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
+			req->pid = req->cfile->pid;
 	} else if (rreq->origin != NETFS_WRITEBACK) {
 		WARN_ON_ONCE(1);
 		return -EIO;
 {
 	ssize_t ret;
-	WARN_ON_ONCE(iov_iter_count(iter) != PAGE_SIZE);
 	if (iov_iter_rw(iter) == READ)
 		ret = netfs_unbuffered_read_iter_locked(iocb, iter);
 	else

fs/smb/client/smb2pdu.c+14−5

 	return rc;
 }
+static void smb2_readv_worker(struct work_struct *work)
+{
+	struct cifs_io_subrequest *rdata =
+		container_of(work, struct cifs_io_subrequest, subreq.work);
+	netfs_subreq_terminated(&rdata->subreq,
+				(rdata->result == 0 || rdata->result == -EAGAIN) ?
+				rdata->got_bytes : rdata->result, true);
+}
 static void
 smb2_readv_callback(struct mid_q_entry *mid)
 {
 			rdata->result = 0;
 	}
 	rdata->credits.value = 0;
-	netfs_subreq_terminated(&rdata->subreq,
+	INIT_WORK(&rdata->subreq.work, smb2_readv_worker);
-				(rdata->result == 0 || rdata->result == -EAGAIN) ?
+	queue_work(cifsiod_wq, &rdata->subreq.work);
-				rdata->got_bytes : rdata->result, true);
 	release_mid(mid);
 	add_credits(server, &credits, 0);
 }
 	io_parms.length = rdata->subreq.len;
 	io_parms.persistent_fid = rdata->req->cfile->fid.persistent_fid;
 	io_parms.volatile_fid = rdata->req->cfile->fid.volatile_fid;
-	io_parms.pid = rdata->pid;
+	io_parms.pid = rdata->req->pid;
 	rc = smb2_new_read_req(
 		(void **) &buf, &total_len, &io_parms, rdata, 0, 0);
 		.length = wdata->subreq.len,
 		.persistent_fid = wdata->req->cfile->fid.persistent_fid,
 		.volatile_fid = wdata->req->cfile->fid.volatile_fid,
-		.pid = wdata->pid,
+		.pid = wdata->req->pid,
 	};
 	io_parms = &_io_parms;

fs/xfs/xfs_inode.c+19−4

@@ -2548,11 +2548,26 @@ xfs_ifree_cluster( · 2547 unmodified lines
2548	* This buffer may not have been correctly initialised as we	2548	* This buffer may not have been correctly initialised as we
2549	* didn't read it from disk. That's not important because we are	2549	* didn't read it from disk. That's not important because we are
2550	* only using to mark the buffer as stale in the log, and to	2550	* only using to mark the buffer as stale in the log, and to
2551	* attach stale cached inodes on it. That means it will never be	2551	* attach stale cached inodes on it.
2552	* dispatched for IO. If it is, we want to know about it, and we	2552	*
2553	* want it to fail. We can acheive this by adding a write	2553	* For the inode that triggered the cluster freeing, this
2554	* verifier to the buffer.	2554	* attachment may occur in xfs_inode_item_precommit() after we
		2555	* have marked this buffer stale. If this buffer was not in
		2556	* memory before xfs_ifree_cluster() started, it will not be
		2557	* marked XBF_DONE and this will cause problems later in
		2558	* xfs_inode_item_precommit() when we trip over a (stale, !done)
		2559	* buffer to attached to the transaction.
		2560	*
		2561	* Hence we have to mark the buffer as XFS_DONE here. This is
		2562	* safe because we are also marking the buffer as XBF_STALE and
		2563	* XFS_BLI_STALE. That means it will never be dispatched for
		2564	* IO and it won't be unlocked until the cluster freeing has
		2565	* been committed to the journal and the buffer unpinned. If it
		2566	* is written, we want to know about it, and we want it to
		2567	* fail. We can acheive this by adding a write verifier to the
		2568	* buffer.
2555	*/	2569	*/
		2570	bp->b_flags \|= XBF_DONE;
2556	bp->b_ops = &xfs_inode_buf_ops;	2571	bp->b_ops = &xfs_inode_buf_ops;
2557		2572
2558	/*	2573	/*

include/linux/bpf_verifier.h+2−0

 	/* Same as scratched_regs but for stack slots */
 	u64 scratched_stack_slots;
 	u64 prev_log_pos, prev_insn_print_pos;
+	/* buffer used to temporary hold constants as scalar registers */
+	struct bpf_reg_state fake_reg[2];
 	/* buffer used to generate temporary string representations,
 	 * e.g., in reg_type_str() to generate reg_type string
 	 */

include/linux/btf.h+1−1

@@ -82,7 +82,7 @@ · 81 unmodified lines
82	* as to avoid issues such as the compiler inlining or eliding either a static	82	* as to avoid issues such as the compiler inlining or eliding either a static
83	* kfunc, or a global kfunc in an LTO build.	83	* kfunc, or a global kfunc in an LTO build.
84	*/	84	*/
85	#define __bpf_kfunc __used noinline	85	#define __bpf_kfunc __used __retain noinline
86		86
87	#define __bpf_kfunc_start_defs() \	87	#define __bpf_kfunc_start_defs() \
88	__diag_push(); \	88	__diag_push(); \

include/linux/compiler_types.h+23−0

@@ -143,6 +143,29 @@ static inline void __chk_io_ptr(const volatile void __iomem *ptr) { } · 142 unmodified lines
143	# define __preserve_most	143	# define __preserve_most
144	#endif	144	#endif
145		145
		146	/*
		147	* Annotating a function/variable with __retain tells the compiler to place
		148	* the object in its own section and set the flag SHF_GNU_RETAIN. This flag
		149	* instructs the linker to retain the object during garbage-cleanup or LTO
		150	* phases.
		151	*
		152	* Note that the __used macro is also used to prevent functions or data
		153	* being optimized out, but operates at the compiler/IR-level and may still
		154	* allow unintended removal of objects during linking.
		155	*
		156	* Optional: only supported since gcc >= 11, clang >= 13
		157	*
		158	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-retain-function-attribute
		159	* clang: https://clang.llvm.org/docs/AttributeReference.html#retain
		160	*/
		161	#if __has_attribute(__retain__) && \
		162	(defined(CONFIG_LD_DEAD_CODE_DATA_ELIMINATION) \|\| \
		163	defined(CONFIG_LTO_CLANG))
		164	# define __retain __attribute__((__retain__))
		165	#else
		166	# define __retain
		167	#endif
		168
146	/* Compiler specific macros. */	169	/* Compiler specific macros. */
147	#ifdef __clang__	170	#ifdef __clang__
148	#include <linux/compiler-clang.h>	171	#include <linux/compiler-clang.h>

include/linux/i2c.h+22−2

@@ -960,8 +960,6 @@ int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr); · 959 unmodified lines
960	#define builtin_i2c_driver(__i2c_driver) \	960	#define builtin_i2c_driver(__i2c_driver) \
961	builtin_driver(__i2c_driver, i2c_add_driver)	961	builtin_driver(__i2c_driver, i2c_add_driver)
962		962
963	#endif /* I2C */
964
965	/* must call put_device() when done with returned i2c_client device */	963	/* must call put_device() when done with returned i2c_client device */
966	struct i2c_client i2c_find_device_by_fwnode(struct fwnode_handle fwnode);	964	struct i2c_client i2c_find_device_by_fwnode(struct fwnode_handle fwnode);
967		965
@@ -971,6 +969,28 @@ struct i2c_adapter i2c_find_adapter_by_fwnode(struct fwnode_handle fwnode); · 3 unmodified lines
971	/* must call i2c_put_adapter() when done with returned i2c_adapter device */	969	/* must call i2c_put_adapter() when done with returned i2c_adapter device */
972	struct i2c_adapter i2c_get_adapter_by_fwnode(struct fwnode_handle fwnode);	970	struct i2c_adapter i2c_get_adapter_by_fwnode(struct fwnode_handle fwnode);
973		971
		972	#else /* I2C */
		973
		974	static inline struct i2c_client *
		975	i2c_find_device_by_fwnode(struct fwnode_handle *fwnode)
		976	{
		977	return NULL;
		978	}
		979
		980	static inline struct i2c_adapter *
		981	i2c_find_adapter_by_fwnode(struct fwnode_handle *fwnode)
		982	{
		983	return NULL;
		984	}
		985
		986	static inline struct i2c_adapter *
		987	i2c_get_adapter_by_fwnode(struct fwnode_handle *fwnode)
		988	{
		989	return NULL;
		990	}
		991
		992	#endif /* !I2C */
		993
974	#if IS_ENABLED(CONFIG_OF)	994	#if IS_ENABLED(CONFIG_OF)
975	/* must call put_device() when done with returned i2c_client device */	995	/* must call put_device() when done with returned i2c_client device */
976	static inline struct i2c_client of_find_i2c_device_by_node(struct device_node node)	996	static inline struct i2c_client of_find_i2c_device_by_node(struct device_node node)

include/linux/kcov.h+2−0

@@ -21,6 +21,8 @@ enum kcov_mode { · 20 unmodified lines
21	KCOV_MODE_TRACE_PC = 2,	21	KCOV_MODE_TRACE_PC = 2,
22	/* Collecting comparison operands mode. */	22	/* Collecting comparison operands mode. */
23	KCOV_MODE_TRACE_CMP = 3,	23	KCOV_MODE_TRACE_CMP = 3,
		24	/* The process owns a KCOV remote reference. */
		25	KCOV_MODE_REMOTE = 4,
24	};	26	};
25		27
26	#define KCOV_IN_CTXSW (1 << 30)	28	#define KCOV_IN_CTXSW (1 << 30)

include/linux/lsm_hook_defs.h+1−1

@@ -413,7 +413,7 @@ LSM_HOOK(void, LSM_RET_VOID, key_post_create_or_update, struct key *keyring, · 412 unmodified lines
413		413
414	#ifdef CONFIG_AUDIT	414	#ifdef CONFIG_AUDIT
415	LSM_HOOK(int, 0, audit_rule_init, u32 field, u32 op, char *rulestr,	415	LSM_HOOK(int, 0, audit_rule_init, u32 field, u32 op, char *rulestr,
416	void **lsmrule)	416	void **lsmrule, gfp_t gfp)
417	LSM_HOOK(int, 0, audit_rule_known, struct audit_krule *krule)	417	LSM_HOOK(int, 0, audit_rule_known, struct audit_krule *krule)
418	LSM_HOOK(int, 0, audit_rule_match, u32 secid, u32 field, u32 op, void *lsmrule)	418	LSM_HOOK(int, 0, audit_rule_match, u32 secid, u32 field, u32 op, void *lsmrule)
419	LSM_HOOK(void, LSM_RET_VOID, audit_rule_free, void *lsmrule)	419	LSM_HOOK(void, LSM_RET_VOID, audit_rule_free, void *lsmrule)

include/linux/mm.h+1−8

 static inline bool want_init_on_free(void)
 {
 	return static_branch_maybe(CONFIG_INIT_ON_FREE_DEFAULT_ON,
-				&init_on_free);
+				   &init_on_free);
-}
-DECLARE_STATIC_KEY_MAYBE(CONFIG_INIT_MLOCKED_ON_FREE_DEFAULT_ON, init_mlocked_on_free);
-static inline bool want_init_mlocked_on_free(void)
-{
-	return static_branch_maybe(CONFIG_INIT_MLOCKED_ON_FREE_DEFAULT_ON,
-				&init_mlocked_on_free);
 }
 extern bool _debug_pagealloc_enabled_early;

include/linux/numa.h+5−0

 #define	NUMA_NO_NODE	(-1)
 #define	NUMA_NO_MEMBLK	(-1)
+static inline bool numa_valid_node(int nid)
+{
+	return nid >= 0 && nid < MAX_NUMNODES;
+}
 /* optionally keep NUMA memory info available post init */
 #ifdef CONFIG_NUMA_KEEP_MEMINFO
 #define __initdata_or_meminfo

include/linux/pagemap.h+4−0

  */
 static inline bool mapping_large_folio_support(struct address_space *mapping)
 {
+	/* AS_LARGE_FOLIO_SUPPORT is only reasonable for pagecache folios */
+	VM_WARN_ONCE((unsigned long)mapping & PAGE_MAPPING_ANON,
+			"Anonymous mapping always supports large folio");
 	return IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE) &&
 		test_bit(AS_LARGE_FOLIO_SUPPORT, &mapping->flags);
 }

include/linux/pgalloc_tag.h+8−3

 static inline void put_page_tag_ref(union codetag_ref *ref)
 {
+	if (WARN_ON(!ref))
+		return;
 	page_ext_put(page_ext_from_codetag_ref(ref));
 }
 		union codetag_ref *ref = get_page_tag_ref(page);
 		alloc_tag_sub_check(ref);
-		if (ref && ref->ct)
+		if (ref) {
-			tag = ct_to_alloc_tag(ref->ct);
+			if (ref->ct)
-		put_page_tag_ref(ref);
+				tag = ct_to_alloc_tag(ref->ct);
+			put_page_tag_ref(ref);
+		}
 	}
 	return tag;

include/linux/regulator/consumer.h+7−0

 					 unsigned *vsel_mask);
 int regulator_list_hardware_vsel(struct regulator *regulator,
 				 unsigned selector);
+int regulator_hardware_enable(struct regulator *regulator, bool enable);
 /* regulator notifier block */
 int regulator_register_notifier(struct regulator *regulator,
 	return -EOPNOTSUPP;
 }
+static inline int regulator_hardware_enable(struct regulator *regulator,
+					    bool enable)
+{
+	return -EOPNOTSUPP;
+}
 static inline int regulator_register_notifier(struct regulator *regulator,
 			      struct notifier_block *nb)
 {

include/linux/security.h+3−2

 #ifdef CONFIG_AUDIT
 #ifdef CONFIG_SECURITY
-int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule);
+int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule,
+			     gfp_t gfp);
 int security_audit_rule_known(struct audit_krule *krule);
 int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule);
 void security_audit_rule_free(void *lsmrule);
 #else
 static inline int security_audit_rule_init(u32 field, u32 op, char *rulestr,
-					   void **lsmrule)
+					   void **lsmrule, gfp_t gfp)
 {
 	return 0;
 }

include/linux/spi/spi.h+3−2

 	unsigned	dummy_data:1;
 	unsigned	cs_off:1;
 	unsigned	cs_change:1;
-	unsigned	tx_nbits:3;
+	unsigned	tx_nbits:4;
-	unsigned	rx_nbits:3;
+	unsigned	rx_nbits:4;
 	unsigned	timestamped:1;
 #define	SPI_NBITS_SINGLE	0x01 /* 1-bit transfer */
 #define	SPI_NBITS_DUAL		0x02 /* 2-bit transfer */
 #define	SPI_NBITS_QUAD		0x04 /* 4-bit transfer */
+#define	SPI_NBITS_OCTAL	0x08 /* 8-bit transfer */
 	u8		bits_per_word;
 	struct spi_delay	delay;
 	struct spi_delay	cs_change_delay;

include/linux/string.h+1−1

@@ -289,7 +289,7 @@ extern void kmemdup_noprof(const void src, size_t len, gfp_t gfp) __realloc_si · 288 unmodified lines
289		289
290	extern void kvmemdup(const void src, size_t len, gfp_t gfp) __realloc_size(2);	290	extern void kvmemdup(const void src, size_t len, gfp_t gfp) __realloc_size(2);
291	extern char kmemdup_nul(const char s, size_t len, gfp_t gfp);	291	extern char kmemdup_nul(const char s, size_t len, gfp_t gfp);
292	extern void kmemdup_array(const void src, size_t element_size, size_t count, gfp_t gfp)	292	extern void kmemdup_array(const void src, size_t count, size_t element_size, gfp_t gfp)
293	__realloc_size(2, 3);	293	__realloc_size(2, 3);
294		294
295	/* lib/argv_split.c */	295	/* lib/argv_split.c */

include/net/netns/netfilter.h+3−0

 	const struct nf_logger __rcu *nf_loggers[NFPROTO_NUMPROTO];
 #ifdef CONFIG_SYSCTL
 	struct ctl_table_header *nf_log_dir_header;
+#ifdef CONFIG_LWTUNNEL
+	struct ctl_table_header *nf_lwtnl_dir_header;
+#endif
 #endif
 	struct nf_hook_entries __rcu *hooks_ipv4[NF_INET_NUMHOOKS];
 	struct nf_hook_entries __rcu *hooks_ipv6[NF_INET_NUMHOOKS];

include/scsi/scsi_devinfo.h+3−1

 #define BLIST_RETRY_ITF		((__force blist_flags_t)(1ULL << 32))
 /* Always retry ABORTED_COMMAND with ASC 0xc1 */
 #define BLIST_RETRY_ASC_C1	((__force blist_flags_t)(1ULL << 33))
+/* Do not query the IO Advice Hints Grouping mode page */
+#define BLIST_SKIP_IO_HINTS	((__force blist_flags_t)(1ULL << 34))
-#define __BLIST_LAST_USED BLIST_RETRY_ASC_C1
+#define __BLIST_LAST_USED BLIST_SKIP_IO_HINTS
 #define __BLIST_HIGH_UNUSED (~(__BLIST_LAST_USED | \
 			       (__force blist_flags_t) \

init/Kconfig+1−1

@@ -883,7 +883,7 @@ config GCC10_NO_ARRAY_BOUNDS · 882 unmodified lines
883		883
884	config CC_NO_ARRAY_BOUNDS	884	config CC_NO_ARRAY_BOUNDS
885	bool	885	bool
886	default y if CC_IS_GCC && GCC_VERSION >= 100000 && GCC10_NO_ARRAY_BOUNDS	886	default y if CC_IS_GCC && GCC_VERSION >= 90000 && GCC10_NO_ARRAY_BOUNDS
887		887
888	# Currently, disable -Wstringop-overflow for GCC globally.	888	# Currently, disable -Wstringop-overflow for GCC globally.
889	config GCC_NO_STRINGOP_OVERFLOW	889	config GCC_NO_STRINGOP_OVERFLOW

io_uring/rsrc.c+0−1

@@ -1068,7 +1068,6 @@ int io_import_fixed(int ddir, struct iov_iter *iter, · 1067 unmodified lines
1068	* branch doesn't expect non PAGE_SIZE'd chunks.	1068	* branch doesn't expect non PAGE_SIZE'd chunks.
1069	*/	1069	*/
1070	iter->bvec = bvec;	1070	iter->bvec = bvec;
1071	iter->nr_segs = bvec->bv_len;
1072	iter->count -= offset;	1071	iter->count -= offset;
1073	iter->iov_offset = offset;	1072	iter->iov_offset = offset;
1074	} else {	1073	} else {

kernel/auditfilter.c+3−2

 			entry->rule.buflen += f_val;
 			f->lsm_str = str;
 			err = security_audit_rule_init(f->type, f->op, str,
-						       (void **)&f->lsm_rule);
+						       (void **)&f->lsm_rule,
+						       GFP_KERNEL);
 			/* Keep currently invalid fields around in case they
 			 * become valid after a policy reload. */
 			if (err == -EINVAL) {
 	/* our own (refreshed) copy of lsm_rule */
 	ret = security_audit_rule_init(df->type, df->op, df->lsm_str,
-				       (void **)&df->lsm_rule);
+				       (void **)&df->lsm_rule, GFP_KERNEL);
 	/* Keep currently invalid fields around in case they
 	 * become valid after a policy reload. */
 	if (ret == -EINVAL) {

kernel/bpf/verifier.c+16−9

 			state->stack[spi].spilled_ptr.id = 0;
 	} else if (!reg && !(off % BPF_REG_SIZE) && is_bpf_st_mem(insn) &&
 		   env->bpf_capable) {
-		struct bpf_reg_state fake_reg = {};
+		struct bpf_reg_state *tmp_reg = &env->fake_reg[0];
-		__mark_reg_known(&fake_reg, insn->imm);
+		memset(tmp_reg, 0, sizeof(*tmp_reg));
-		fake_reg.type = SCALAR_VALUE;
+		__mark_reg_known(tmp_reg, insn->imm);
-		save_register_state(env, state, spi, &fake_reg, size);
+		tmp_reg->type = SCALAR_VALUE;
+		save_register_state(env, state, spi, tmp_reg, size);
 	} else if (reg && is_spillable_regtype(reg->type)) {
 		/* register containing pointer is being spilled into stack */
 		if (size != BPF_REG_SIZE) {
 	struct bpf_reg_state *regs = this_branch->frame[this_branch->curframe]->regs;
 	struct bpf_reg_state *dst_reg, *other_branch_regs, *src_reg = NULL;
 	struct bpf_reg_state *eq_branch_regs;
-	struct bpf_reg_state fake_reg = {};
 	u8 opcode = BPF_OP(insn->code);
 	bool is_jmp32;
 	int pred = -1;
 			verbose(env, "BPF_JMP/JMP32 uses reserved fields\n");
 			return -EINVAL;
 		}
-		src_reg = &fake_reg;
+		src_reg = &env->fake_reg[0];
+		memset(src_reg, 0, sizeof(*src_reg));
 		src_reg->type = SCALAR_VALUE;
 		__mark_reg_known(src_reg, insn->imm);
 	}
 				      &other_branch_regs[insn->src_reg],
 				      dst_reg, src_reg, opcode, is_jmp32);
 	} else /* BPF_SRC(insn->code) == BPF_K */ {
+		/* reg_set_min_max() can mangle the fake_reg. Make a copy
+		 * so that these are two different memory locations. The
+		 * src_reg is not used beyond here in context of K.
+		 */
+		memcpy(&env->fake_reg[1], &env->fake_reg[0],
+		       sizeof(env->fake_reg[0]));
 		err = reg_set_min_max(env,
 				      &other_branch_regs[insn->dst_reg],
-				      src_reg /* fake one */,
+				      &env->fake_reg[0],
-				      dst_reg, src_reg /* same fake one */,
+				      dst_reg, &env->fake_reg[1],
 				      opcode, is_jmp32);
 	}
 	if (err)
 			goto next_insn;
 		}
-#ifdef CONFIG_X86_64
+#if defined(CONFIG_X86_64) && !defined(CONFIG_UML)
 		/* Implement bpf_get_smp_processor_id() inline. */
 		if (insn->imm == BPF_FUNC_get_smp_processor_id &&
 		    prog->jit_requested && bpf_jit_supports_percpu_insn()) {

kernel/gcov/gcc_4_7.c+3−1

 #include <linux/mm.h>
 #include "gcov.h"
-#if (__GNUC__ >= 10)
+#if (__GNUC__ >= 14)
+#define GCOV_COUNTERS			9
+#elif (__GNUC__ >= 10)
 #define GCOV_COUNTERS			8
 #elif (__GNUC__ >= 7)
 #define GCOV_COUNTERS			9

kernel/kcov.c+1−0

@@ -632,6 +632,7 @@ static int kcov_ioctl_locked(struct kcov *kcov, unsigned int cmd, · 631 unmodified lines
632	return -EINVAL;	632	return -EINVAL;
633	kcov->mode = mode;	633	kcov->mode = mode;
634	t->kcov = kcov;	634	t->kcov = kcov;
		635	t->kcov_mode = KCOV_MODE_REMOTE;
635	kcov->t = t;	636	kcov->t = t;
636	kcov->remote = true;	637	kcov->remote = true;
637	kcov->remote_size = remote_arg->area_size;	638	kcov->remote_size = remote_arg->area_size;

kernel/pid_namespace.c+1−0

@@ -218,6 +218,7 @@ void zap_pid_ns_processes(struct pid_namespace *pid_ns) · 217 unmodified lines
218	*/	218	*/
219	do {	219	do {
220	clear_thread_flag(TIF_SIGPENDING);	220	clear_thread_flag(TIF_SIGPENDING);
		221	clear_thread_flag(TIF_NOTIFY_SIGNAL);
221	rc = kernel_wait4(-1, NULL, __WALL, NULL);	222	rc = kernel_wait4(-1, NULL, __WALL, NULL);
222	} while (rc != -ECHILD);	223	} while (rc != -ECHILD);
223		224

kernel/trace/Kconfig+2−2

@@ -1136,7 +1136,7 @@ config PREEMPTIRQ_DELAY_TEST · 1135 unmodified lines
1136		1136
1137	config SYNTH_EVENT_GEN_TEST	1137	config SYNTH_EVENT_GEN_TEST
1138	tristate "Test module for in-kernel synthetic event generation"	1138	tristate "Test module for in-kernel synthetic event generation"
1139	depends on SYNTH_EVENTS	1139	depends on SYNTH_EVENTS && m
1140	help	1140	help
1141	This option creates a test module to check the base	1141	This option creates a test module to check the base
1142	functionality of in-kernel synthetic event definition and	1142	functionality of in-kernel synthetic event definition and
@@ -1149,7 +1149,7 @@ config SYNTH_EVENT_GEN_TEST · 6 unmodified lines
1149		1149
1150	config KPROBE_EVENT_GEN_TEST	1150	config KPROBE_EVENT_GEN_TEST
1151	tristate "Test module for in-kernel kprobe event generation"	1151	tristate "Test module for in-kernel kprobe event generation"
1152	depends on KPROBE_EVENTS	1152	depends on KPROBE_EVENTS && m
1153	help	1153	help
1154	This option creates a test module to check the base	1154	This option creates a test module to check the base
1155	functionality of in-kernel kprobe event definition.	1155	functionality of in-kernel kprobe event definition.

lib/Kconfig+1−7

 	  stack overflow.
 config FORCE_NR_CPUS
-       bool "Set number of CPUs at compile time"
+	def_bool !SMP
-       depends on SMP && EXPERT && !COMPILE_TEST
-       help
-         Say Yes if you have NR_CPUS set to an actual number of possible
-         CPUs in your system, not to a default value. This forces the core
-         code to rely on compile-time value and optimize kernel routines
-         better.
 config CPU_RMAP
 	bool

lib/alloc_tag.c+13−3

 };
 EXPORT_SYMBOL(page_alloc_tagging_ops);
+#ifdef CONFIG_SYSCTL
 static struct ctl_table memory_allocation_profiling_sysctls[] = {
 	{
 		.procname	= "mem_profiling",
 	{ }
 };
+static void __init sysctl_init(void)
+{
+	if (!mem_profiling_support)
+		memory_allocation_profiling_sysctls[0].mode = 0444;
+	register_sysctl_init("vm", memory_allocation_profiling_sysctls);
+}
+#else /* CONFIG_SYSCTL */
+static inline void sysctl_init(void) {}
+#endif /* CONFIG_SYSCTL */
 static int __init alloc_tag_init(void)
 {
 	const struct codetag_type_desc desc = {
 	if (IS_ERR(alloc_tag_cttype))
 		return PTR_ERR(alloc_tag_cttype);
-	if (!mem_profiling_support)
+	sysctl_init();
-		memory_allocation_profiling_sysctls[0].mode = 0444;
-	register_sysctl_init("vm", memory_allocation_profiling_sysctls);
 	procfs_init();
 	return 0;

lib/closure.c+8−2

 {
 	int r = flags & CLOSURE_REMAINING_MASK;
-	BUG_ON(flags & CLOSURE_GUARD_MASK);
+	if (WARN(flags & CLOSURE_GUARD_MASK,
-	BUG_ON(!r && (flags & ~CLOSURE_DESTRUCTOR));
+		 "closure has guard bits set: %x (%u)",
+		 flags & CLOSURE_GUARD_MASK, (unsigned) __fls(r)))
+		r &= ~CLOSURE_GUARD_MASK;
 	if (!r) {
 		smp_acquire__after_ctrl_dep();
+		WARN(flags & ~CLOSURE_DESTRUCTOR,
+		     "closure ref hit 0 with incorrect flags set: %x (%u)",
+		     flags & ~CLOSURE_DESTRUCTOR, (unsigned) __fls(flags));
 		cl->closure_get_happened = false;
 		if (cl->fn && !(flags & CLOSURE_DESTRUCTOR)) {

lib/fortify_kunit.c+1−1

@@ -374,7 +374,7 @@ static const char * const test_strs[] = { · 373 unmodified lines
374	for (i = 0; i < ARRAY_SIZE(test_strs); i++) { \	374	for (i = 0; i < ARRAY_SIZE(test_strs); i++) { \
375	len = strlen(test_strs[i]); \	375	len = strlen(test_strs[i]); \
376	KUNIT_EXPECT_EQ(test, __builtin_constant_p(len), 0); \	376	KUNIT_EXPECT_EQ(test, __builtin_constant_p(len), 0); \
377	checker(len, kmemdup_array(test_strs[i], len, 1, gfp), \	377	checker(len, kmemdup_array(test_strs[i], 1, len, gfp), \
378	kfree(p)); \	378	kfree(p)); \
379	checker(len, kmemdup(test_strs[i], len, gfp), \	379	checker(len, kmemdup(test_strs[i], len, gfp), \
380	kfree(p)); \	380	kfree(p)); \

lib/overflow_kunit.c+17−3

 	s16 array[] __counted_by(counter);
 };
+struct bar {
+	int a;
+	u32 counter;
+	s16 array[];
+};
 static void DEFINE_FLEX_test(struct kunit *test)
 {
-	DEFINE_RAW_FLEX(struct foo, two, array, 2);
+	/* Using _RAW_ on a __counted_by struct will initialize "counter" to zero */
+	DEFINE_RAW_FLEX(struct foo, two_but_zero, array, 2);
+#if __has_attribute(__counted_by__)
+	int expected_raw_size = sizeof(struct foo);
+#else
+	int expected_raw_size = sizeof(struct foo) + 2 * sizeof(s16);
+#endif
+	/* Without annotation, it will always be on-stack size. */
+	DEFINE_RAW_FLEX(struct bar, two, array, 2);
 	DEFINE_FLEX(struct foo, eight, array, counter, 8);
 	DEFINE_FLEX(struct foo, empty, array, counter, 0);
-	KUNIT_EXPECT_EQ(test, __struct_size(two),
+	KUNIT_EXPECT_EQ(test, __struct_size(two_but_zero), expected_raw_size);
-			sizeof(struct foo) + sizeof(s16) + sizeof(s16));
+	KUNIT_EXPECT_EQ(test, __struct_size(two), sizeof(struct bar) + 2 * sizeof(s16));
 	KUNIT_EXPECT_EQ(test, __struct_size(eight), 24);
 	KUNIT_EXPECT_EQ(test, __struct_size(empty), sizeof(struct foo));
 }

mm/debug_vm_pgtable.c+5−26

  * Please refer Documentation/mm/arch_pgtable_helpers.rst for the semantics
  * expectations that are being validated here. All future changes in here
  * or the documentation need to be in sync.
- *
- * On s390 platform, the lower 4 bits are used to identify given page table
- * entry type. But these bits might affect the ability to clear entries with
- * pxx_clear() because of how dynamic page table folding works on s390. So
- * while loading up the entries do not change the lower 4 bits. It does not
- * have affect any other platform. Also avoid the 62nd bit on ppc64 that is
- * used to mark a pte entry.
  */
-#define S390_SKIP_MASK		GENMASK(3, 0)
-#if __BITS_PER_LONG == 64
-#define PPC64_SKIP_MASK		GENMASK(62, 62)
-#else
-#define PPC64_SKIP_MASK		0x0
-#endif
-#define ARCH_SKIP_MASK (S390_SKIP_MASK | PPC64_SKIP_MASK)
-#define RANDOM_ORVALUE (GENMASK(BITS_PER_LONG - 1, 0) & ~ARCH_SKIP_MASK)
 #define RANDOM_NZVALUE	GENMASK(7, 0)
 struct pgtable_debug_args {
 		return;
 	pr_debug("Validating PUD clear\n");
-	pud = __pud(pud_val(pud) | RANDOM_ORVALUE);
+	WARN_ON(pud_none(pud));
-	WRITE_ONCE(*args->pudp, pud);
 	pud_clear(args->pudp);
 	pud = READ_ONCE(*args->pudp);
 	WARN_ON(!pud_none(pud));
 		return;
 	pr_debug("Validating P4D clear\n");
-	p4d = __p4d(p4d_val(p4d) | RANDOM_ORVALUE);
+	WARN_ON(p4d_none(p4d));
-	WRITE_ONCE(*args->p4dp, p4d);
 	p4d_clear(args->p4dp);
 	p4d = READ_ONCE(*args->p4dp);
 	WARN_ON(!p4d_none(p4d));
 		return;
 	pr_debug("Validating PGD clear\n");
-	pgd = __pgd(pgd_val(pgd) | RANDOM_ORVALUE);
+	WARN_ON(pgd_none(pgd));
-	WRITE_ONCE(*args->pgdp, pgd);
 	pgd_clear(args->pgdp);
 	pgd = READ_ONCE(*args->pgdp);
 	WARN_ON(!pgd_none(pgd));
 	if (WARN_ON(!args->ptep))
 		return;
-#ifndef CONFIG_RISCV
-	pte = __pte(pte_val(pte) | RANDOM_ORVALUE);
-#endif
 	set_pte_at(args->mm, args->vaddr, args->ptep, pte);
+	WARN_ON(pte_none(pte));
 	flush_dcache_page(page);
 	barrier();
 	ptep_clear(args->mm, args->vaddr, args->ptep);
 	pmd_t pmd = READ_ONCE(*args->pmdp);
 	pr_debug("Validating PMD clear\n");
-	pmd = __pmd(pmd_val(pmd) | RANDOM_ORVALUE);
+	WARN_ON(pmd_none(pmd));
-	WRITE_ONCE(*args->pmdp, pmd);
 	pmd_clear(args->pmdp);
 	pmd = READ_ONCE(*args->pmdp);
 	WARN_ON(!pmd_none(pmd));

mm/huge_memory.c+17−11

 	if (new_order >= folio_order(folio))
 		return -EINVAL;
-	/* Cannot split anonymous THP to order-1 */
+	if (folio_test_anon(folio)) {
-	if (new_order == 1 && folio_test_anon(folio)) {
+		/* order-1 is not supported for anonymous THP. */
-		VM_WARN_ONCE(1, "Cannot split to order-1 folio");
+		if (new_order == 1) {
-		return -EINVAL;
+			VM_WARN_ONCE(1, "Cannot split to order-1 folio");
-	}
-	if (new_order) {
-		/* Only swapping a whole PMD-mapped folio is supported */
-		if (folio_test_swapcache(folio))
 			return -EINVAL;
+		}
+	} else if (new_order) {
 		/* Split shmem folio to non-zero order not supported */
 		if (shmem_mapping(folio->mapping)) {
 			VM_WARN_ONCE(1,
 				"Cannot split shmem folio to non-0 order");
 			return -EINVAL;
 		}
-		/* No split if the file system does not support large folio */
+		/*
-		if (!mapping_large_folio_support(folio->mapping)) {
+		 * No split if the file system does not support large folio.
+		 * Note that we might still have THPs in such mappings due to
+		 * CONFIG_READ_ONLY_THP_FOR_FS. But in that case, the mapping
+		 * does not actually support large folios properly.
+		 */
+		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
+		    !mapping_large_folio_support(folio->mapping)) {
 			VM_WARN_ONCE(1,
 				"Cannot split file folio to non-0 order");
 			return -EINVAL;
 		}
 	}
+	/* Only swapping a whole PMD-mapped folio is supported */
+	if (folio_test_swapcache(folio) && new_order)
+		return -EINVAL;
 	is_hzp = is_huge_zero_folio(folio);
 	if (is_hzp) {

mm/internal.h+0−1

@@ -588,7 +588,6 @@ extern void __putback_isolated_page(struct page *page, unsigned int order, · 587 unmodified lines
588	extern void memblock_free_pages(struct page *page, unsigned long pfn,	588	extern void memblock_free_pages(struct page *page, unsigned long pfn,
589	unsigned int order);	589	unsigned int order);
590	extern void __free_pages_core(struct page *page, unsigned int order);	590	extern void __free_pages_core(struct page *page, unsigned int order);
591	extern void kernel_init_pages(struct page *page, int numpages);
592		591
593	/*	592	/*
594	* This will have no effect, other than possibly generating a warning, if the	593	* This will have no effect, other than possibly generating a warning, if the

mm/memblock.c+7−21

 	/* calculate lose page */
 	for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid) {
-		if (nid == NUMA_NO_NODE)
+		if (!numa_valid_node(nid))
 			nr_pages += end_pfn - start_pfn;
 	}
 		return false;
 	/* only memory regions are associated with nodes, check it */
-	if (nid != NUMA_NO_NODE && nid != m_nid)
+	if (numa_valid_node(nid) && nid != m_nid)
 		return true;
 	/* skip hotpluggable memory regions if needed */
 	int idx_a = *idx & 0xffffffff;
 	int idx_b = *idx >> 32;
-	if (WARN_ONCE(nid == MAX_NUMNODES,
-	"Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
-		nid = NUMA_NO_NODE;
 	for (; idx_a < type_a->cnt; idx_a++) {
 		struct memblock_region *m = &type_a->regions[idx_a];
 	int idx_a = *idx & 0xffffffff;
 	int idx_b = *idx >> 32;
-	if (WARN_ONCE(nid == MAX_NUMNODES, "Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
-		nid = NUMA_NO_NODE;
 	if (*idx == (u64)ULLONG_MAX) {
 		idx_a = type_a->cnt - 1;
 		if (type_b != NULL)
 		if (PFN_UP(r->base) >= PFN_DOWN(r->base + r->size))
 			continue;
-		if (nid == MAX_NUMNODES || nid == r_nid)
+		if (!numa_valid_node(nid) || nid == r_nid)
 			break;
 	}
 	if (*idx >= type->cnt) {
 	int start_rgn, end_rgn;
 	int i, ret;
-	if (WARN_ONCE(nid == MAX_NUMNODES,
-		      "Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
-		nid = NUMA_NO_NODE;
 	ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn);
 	if (ret)
 		return ret;
 	enum memblock_flags flags = choose_memblock_flags();
 	phys_addr_t found;
-	if (WARN_ONCE(nid == MAX_NUMNODES, "Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
-		nid = NUMA_NO_NODE;
 	if (!align) {
 		/* Can't use WARNs this early in boot on powerpc */
 		dump_stack();
 	if (found && !memblock_reserve(found, size))
 		goto done;
-	if (nid != NUMA_NO_NODE && !exact_nid) {
+	if (numa_valid_node(nid) && !exact_nid) {
 		found = memblock_find_in_range_node(size, align, start,
 						    end, NUMA_NO_NODE,
 						    flags);
 		end = base + size - 1;
 		flags = rgn->flags;
 #ifdef CONFIG_NUMA
-		if (memblock_get_region_node(rgn) != MAX_NUMNODES)
+		if (numa_valid_node(memblock_get_region_node(rgn)))
 			snprintf(nid_buf, sizeof(nid_buf), " on node %d",
 				 memblock_get_region_node(rgn));
 #endif
 			start = region->base;
 			end = start + region->size;
-			if (nid == NUMA_NO_NODE || nid >= MAX_NUMNODES)
+			if (!numa_valid_node(nid))
 				nid = early_pfn_to_nid(PFN_DOWN(start));
 			reserve_bootmem_region(start, end, nid);
 		seq_printf(m, "%4d: ", i);
 		seq_printf(m, "%pa..%pa ", &reg->base, &end);
-		if (nid != MAX_NUMNODES)
+		if (numa_valid_node(nid))
 			seq_printf(m, "%4d ", nid);
 		else
 			seq_printf(m, "%4c ", 'x');

mm/memcontrol.c+1−2

  * @new: Replacement folio.
  *
  * Charge @new as a replacement folio for @old. @old will
- * be uncharged upon free. This is only used by the page cache
+ * be uncharged upon free.
- * (in replace_page_cache_folio()).
  *
  * Both folios must be locked, @new->mapping must be set up.
  */

mm/memory.c+10−10

 		if (unlikely(folio_mapcount(folio) < 0))
 			print_bad_pte(vma, addr, ptent, page);
 	}
-	if (want_init_mlocked_on_free() && folio_test_mlocked(folio) &&
-	    !delay_rmap && folio_test_anon(folio)) {
-		kernel_init_pages(page, folio_nr_pages(folio));
-	}
 	if (unlikely(__tlb_remove_folio_pages(tlb, page, nr, delay_rmap))) {
 		*force_flush = true;
 		*force_break = true;
 				       bool ignore_writable, bool pte_write_upgrade)
 {
 	int nr = pte_pfn(fault_pte) - folio_pfn(folio);
-	unsigned long start = max(vmf->address - nr * PAGE_SIZE, vma->vm_start);
+	unsigned long start, end, addr = vmf->address;
-	unsigned long end = min(vmf->address + (folio_nr_pages(folio) - nr) * PAGE_SIZE, vma->vm_end);
+	unsigned long addr_start = addr - (nr << PAGE_SHIFT);
-	pte_t *start_ptep = vmf->pte - (vmf->address - start) / PAGE_SIZE;
+	unsigned long pt_start = ALIGN_DOWN(addr, PMD_SIZE);
-	unsigned long addr;
+	pte_t *start_ptep;
+	/* Stay within the VMA and within the page table. */
+	start = max3(addr_start, pt_start, vma->vm_start);
+	end = min3(addr_start + folio_size(folio), pt_start + PMD_SIZE,
+		   vma->vm_end);
+	start_ptep = vmf->pte - ((addr - start) >> PAGE_SHIFT);
 	/* Restore all PTEs' mapping of the large folio */
 	for (addr = start; addr != end; start_ptep++, addr += PAGE_SIZE) {

mm/migrate.c+7−1

 			/*
 			 * The rare folio on the deferred split list should
-			 * be split now. It should not count as a failure.
+			 * be split now. It should not count as a failure:
+			 * but increment nr_failed because, without doing so,
+			 * migrate_pages() may report success with (split but
+			 * unmigrated) pages still on its fromlist; whereas it
+			 * always reports success when its fromlist is empty.
+			 *
 			 * Only check it without removing it from the list.
 			 * Since the folio can be on deferred_split_scan()
 			 * local list and removing it can cause the local list
 			if (nr_pages > 2 &&
 			   !list_empty(&folio->_deferred_list)) {
 				if (try_split_folio(folio, split_folios) == 0) {
+					nr_failed++;
 					stats->nr_thp_split += is_thp;
 					stats->nr_split++;
 					continue;

mm/mm_init.c+7−36

 DEFINE_STATIC_KEY_MAYBE(CONFIG_INIT_ON_FREE_DEFAULT_ON, init_on_free);
 EXPORT_SYMBOL(init_on_free);
-DEFINE_STATIC_KEY_MAYBE(CONFIG_INIT_MLOCKED_ON_FREE_DEFAULT_ON, init_mlocked_on_free);
-EXPORT_SYMBOL(init_mlocked_on_free);
 static bool _init_on_alloc_enabled_early __read_mostly
 				= IS_ENABLED(CONFIG_INIT_ON_ALLOC_DEFAULT_ON);
 static int __init early_init_on_alloc(char *buf)
 }
 early_param("init_on_free", early_init_on_free);
-static bool _init_mlocked_on_free_enabled_early __read_mostly
-				= IS_ENABLED(CONFIG_INIT_MLOCKED_ON_FREE_DEFAULT_ON);
-static int __init early_init_mlocked_on_free(char *buf)
-{
-	return kstrtobool(buf, &_init_mlocked_on_free_enabled_early);
-}
-early_param("init_mlocked_on_free", early_init_mlocked_on_free);
 DEFINE_STATIC_KEY_MAYBE(CONFIG_DEBUG_VM, check_pages_enabled);
 /*
 	}
 #endif
-	if ((_init_on_alloc_enabled_early || _init_on_free_enabled_early ||
+	if ((_init_on_alloc_enabled_early || _init_on_free_enabled_early) &&
-	    _init_mlocked_on_free_enabled_early) &&
 	    page_poisoning_requested) {
 		pr_info("mem auto-init: CONFIG_PAGE_POISONING is on, "
-			"will take precedence over init_on_alloc, init_on_free "
+			"will take precedence over init_on_alloc and init_on_free\n");
-			"and init_mlocked_on_free\n");
 		_init_on_alloc_enabled_early = false;
 		_init_on_free_enabled_early = false;
-		_init_mlocked_on_free_enabled_early = false;
-	}
-	if (_init_mlocked_on_free_enabled_early && _init_on_free_enabled_early) {
-		pr_info("mem auto-init: init_on_free is on, "
-			"will take precedence over init_mlocked_on_free\n");
-		_init_mlocked_on_free_enabled_early = false;
 	}
 	if (_init_on_alloc_enabled_early) {
 		static_branch_disable(&init_on_free);
 	}
-	if (_init_mlocked_on_free_enabled_early) {
+	if (IS_ENABLED(CONFIG_KMSAN) &&
-		want_check_pages = true;
+	    (_init_on_alloc_enabled_early || _init_on_free_enabled_early))
-		static_branch_enable(&init_mlocked_on_free);
+		pr_info("mem auto-init: please make sure init_on_alloc and init_on_free are disabled when running KMSAN\n");
-	} else {
-		static_branch_disable(&init_mlocked_on_free);
-	}
-	if (IS_ENABLED(CONFIG_KMSAN) && (_init_on_alloc_enabled_early ||
-	    _init_on_free_enabled_early || _init_mlocked_on_free_enabled_early))
-		pr_info("mem auto-init: please make sure init_on_alloc, init_on_free and "
-			"init_mlocked_on_free are disabled when running KMSAN\n");
 #ifdef CONFIG_DEBUG_PAGEALLOC
 	if (debug_pagealloc_enabled()) {
 	else
 		stack = "off";
-	pr_info("mem auto-init: stack:%s, heap alloc:%s, heap free:%s, mlocked free:%s\n",
+	pr_info("mem auto-init: stack:%s, heap alloc:%s, heap free:%s\n",
 		stack, want_init_on_alloc(GFP_KERNEL) ? "on" : "off",
-		want_init_on_free() ? "on" : "off",
+		want_init_on_free() ? "on" : "off");
-		want_init_mlocked_on_free() ? "on" : "off");
 	if (want_init_on_free())
 		pr_info("mem auto-init: clearing system memory may take some time...\n");
 }

mm/page_alloc.c+1−1

@@ -1016,7 +1016,7 @@ static inline bool should_skip_kasan_poison(struct page *page) · 1015 unmodified lines
1016	return page_kasan_tag(page) == KASAN_TAG_KERNEL;	1016	return page_kasan_tag(page) == KASAN_TAG_KERNEL;
1017	}	1017	}
1018		1018
1019	void kernel_init_pages(struct page *page, int numpages)	1019	static void kernel_init_pages(struct page *page, int numpages)
1020	{	1020	{
1021	int i;	1021	int i;
1022		1022

mm/page_table_check.c+10−1

@@ -73,6 +73,9 @@ static void page_table_check_clear(unsigned long pfn, unsigned long pgcnt) · 72 unmodified lines
73	page = pfn_to_page(pfn);	73	page = pfn_to_page(pfn);
74	page_ext = page_ext_get(page);	74	page_ext = page_ext_get(page);
75		75
		76	if (!page_ext)
		77	return;
		78
76	BUG_ON(PageSlab(page));	79	BUG_ON(PageSlab(page));
77	anon = PageAnon(page);	80	anon = PageAnon(page);
78		81
@@ -110,6 +113,9 @@ static void page_table_check_set(unsigned long pfn, unsigned long pgcnt, · 31 unmodified lines
110	page = pfn_to_page(pfn);	113	page = pfn_to_page(pfn);
111	page_ext = page_ext_get(page);	114	page_ext = page_ext_get(page);
112		115
		116	if (!page_ext)
		117	return;
		118
113	BUG_ON(PageSlab(page));	119	BUG_ON(PageSlab(page));
114	anon = PageAnon(page);	120	anon = PageAnon(page);
115		121
@@ -140,7 +146,10 @@ void __page_table_check_zero(struct page *page, unsigned int order) · 24 unmodified lines
140	BUG_ON(PageSlab(page));	146	BUG_ON(PageSlab(page));
141		147
142	page_ext = page_ext_get(page);	148	page_ext = page_ext_get(page);
143	BUG_ON(!page_ext);	149
		150	if (!page_ext)
		151	return;
		152
144	for (i = 0; i < (1ul << order); i++) {	153	for (i = 0; i < (1ul << order); i++) {
145	struct page_table_check *ptc = get_page_table_check(page_ext);	154	struct page_table_check *ptc = get_page_table_check(page_ext);
146		155

mm/shmem.c+1−1

@@ -1786,7 +1786,7 @@ static int shmem_replace_folio(struct folio **foliop, gfp_t gfp, · 1785 unmodified lines
1786	xa_lock_irq(&swap_mapping->i_pages);	1786	xa_lock_irq(&swap_mapping->i_pages);
1787	error = shmem_replace_entry(swap_mapping, swap_index, old, new);	1787	error = shmem_replace_entry(swap_mapping, swap_index, old, new);
1788	if (!error) {	1788	if (!error) {
1789	mem_cgroup_migrate(old, new);	1789	mem_cgroup_replace_folio(old, new);
1790	__lruvec_stat_mod_folio(new, NR_FILE_PAGES, 1);	1790	__lruvec_stat_mod_folio(new, NR_FILE_PAGES, 1);
1791	__lruvec_stat_mod_folio(new, NR_SHMEM, 1);	1791	__lruvec_stat_mod_folio(new, NR_SHMEM, 1);
1792	__lruvec_stat_mod_folio(old, NR_FILE_PAGES, -1);	1792	__lruvec_stat_mod_folio(old, NR_FILE_PAGES, -1);

mm/util.c+2−2

  * kmemdup_array - duplicate a given array.
  *
  * @src: array to duplicate.
- * @element_size: size of each element of array.
  * @count: number of elements to duplicate from array.
+ * @element_size: size of each element of array.
  * @gfp: GFP mask to use.
  *
  * Return: duplicated array of @src or %NULL in case of error,
  * result is physically contiguous. Use kfree() to free.
  */
-void *kmemdup_array(const void *src, size_t element_size, size_t count, gfp_t gfp)
+void *kmemdup_array(const void *src, size_t count, size_t element_size, gfp_t gfp)
 {
 	return kmemdup(src, size_mul(element_size, count), gfp);
 }

net/core/filter.c+5−0

 static inline int __bpf_try_make_writable(struct sk_buff *skb,
 					  unsigned int write_len)
 {
+#ifdef CONFIG_DEBUG_NET
+	/* Avoid a splat in pskb_may_pull_reason() */
+	if (write_len > INT_MAX)
+		return -EINVAL;
+#endif
 	return skb_ensure_writable(skb, write_len);
 }

net/core/net_namespace.c+7−2

  * get_net_ns - increment the refcount of the network namespace
  * @ns: common namespace (net)
  *
- * Returns the net's common namespace.
+ * Returns the net's common namespace or ERR_PTR() if ref is zero.
  */
 struct ns_common *get_net_ns(struct ns_common *ns)
 {
-	return &get_net(container_of(ns, struct net, ns))->ns;
+	struct net *net;
+	net = maybe_get_net(container_of(ns, struct net, ns));
+	if (net)
+		return &net->ns;
+	return ERR_PTR(-EINVAL);
 }
 EXPORT_SYMBOL_GPL(get_net_ns);

net/core/netdev-genl.c+8−8

 	    nla_put_u64_64bit(rsp, NETDEV_A_DEV_XDP_RX_METADATA_FEATURES,
 			      xdp_rx_meta, NETDEV_A_DEV_PAD) ||
 	    nla_put_u64_64bit(rsp, NETDEV_A_DEV_XSK_FEATURES,
-			      xsk_features, NETDEV_A_DEV_PAD)) {
+			      xsk_features, NETDEV_A_DEV_PAD))
-		genlmsg_cancel(rsp, hdr);
+		goto err_cancel_msg;
-		return -EINVAL;
-	}
 	if (netdev->xdp_features & NETDEV_XDP_ACT_XSK_ZEROCOPY) {
 		if (nla_put_u32(rsp, NETDEV_A_DEV_XDP_ZC_MAX_SEGS,
-				netdev->xdp_zc_max_segs)) {
+				netdev->xdp_zc_max_segs))
-			genlmsg_cancel(rsp, hdr);
+			goto err_cancel_msg;
-			return -EINVAL;
-		}
 	}
 	genlmsg_end(rsp, hdr);
 	return 0;
+err_cancel_msg:
+	genlmsg_cancel(rsp, hdr);
+	return -EMSGSIZE;
 }
 static void

net/core/sock.c+3−0

@@ -3742,6 +3742,9 @@ void sk_common_release(struct sock *sk) · 3741 unmodified lines
3742		3742
3743	sk->sk_prot->unhash(sk);	3743	sk->sk_prot->unhash(sk);
3744		3744
		3745	if (sk->sk_socket)
		3746	sk->sk_socket->sk = NULL;
		3747
3745	/*	3748	/*
3746	* In this point socket cannot receive new packets, but it is possible	3749	* In this point socket cannot receive new packets, but it is possible
3747	* that some packets are in flight because some CPU runs receiver and	3750	* that some packets are in flight because some CPU runs receiver and

net/ipv4/cipso_ipv4.c+54−21

@@ -1810,6 +1810,29 @@ static int cipso_v4_genopt(unsigned char *buf, u32 buf_len, · 1809 unmodified lines
1810	return CIPSO_V4_HDR_LEN + ret_val;	1810	return CIPSO_V4_HDR_LEN + ret_val;
1811	}	1811	}
1812		1812
		1813	static int cipso_v4_get_actual_opt_len(const unsigned char *data, int len)
		1814	{
		1815	int iter = 0, optlen = 0;
		1816
		1817	/* determining the new total option length is tricky because of
		1818	* the padding necessary, the only thing i can think to do at
		1819	* this point is walk the options one-by-one, skipping the
		1820	* padding at the end to determine the actual option size and
		1821	* from there we can determine the new total option length
		1822	*/
		1823	while (iter < len) {
		1824	if (data[iter] == IPOPT_END) {
		1825	break;
		1826	} else if (data[iter] == IPOPT_NOP) {
		1827	iter++;
		1828	} else {
		1829	iter += data[iter + 1];
		1830	optlen = iter;
		1831	}
		1832	}
		1833	return optlen;
		1834	}
		1835
1813	/**	1836	/**
1814	* cipso_v4_sock_setattr - Add a CIPSO option to a socket	1837	* cipso_v4_sock_setattr - Add a CIPSO option to a socket
1815	* @sk: the socket	1838	* @sk: the socket
@@ -1986,7 +2009,6 @@ static int cipso_v4_delopt(struct ip_options_rcu __rcu **opt_ptr) · 170 unmodified lines
1986	u8 cipso_len;	2009	u8 cipso_len;
1987	u8 cipso_off;	2010	u8 cipso_off;
1988	unsigned char *cipso_ptr;	2011	unsigned char *cipso_ptr;
1989	int iter;
1990	int optlen_new;	2012	int optlen_new;
1991		2013
1992	cipso_off = opt->opt.cipso - sizeof(struct iphdr);	2014	cipso_off = opt->opt.cipso - sizeof(struct iphdr);
@@ -2006,19 +2028,8 @@ static int cipso_v4_delopt(struct ip_options_rcu __rcu **opt_ptr) · 13 unmodified lines
2006	memmove(cipso_ptr, cipso_ptr + cipso_len,	2028	memmove(cipso_ptr, cipso_ptr + cipso_len,
2007	opt->opt.optlen - cipso_off - cipso_len);	2029	opt->opt.optlen - cipso_off - cipso_len);
2008		2030
2009	/* determining the new total option length is tricky because of	2031	optlen_new = cipso_v4_get_actual_opt_len(opt->opt.__data,
2010	* the padding necessary, the only thing i can think to do at	2032	opt->opt.optlen);
2011	* this point is walk the options one-by-one, skipping the
2012	* padding at the end to determine the actual option size and
2013	* from there we can determine the new total option length */
2014	iter = 0;
2015	optlen_new = 0;
2016	while (iter < opt->opt.optlen)
2017	if (opt->opt.__data[iter] != IPOPT_NOP) {
2018	iter += opt->opt.__data[iter + 1];
2019	optlen_new = iter;
2020	} else
2021	iter++;
2022	hdr_delta = opt->opt.optlen;	2033	hdr_delta = opt->opt.optlen;
2023	opt->opt.optlen = (optlen_new + 3) & ~3;	2034	opt->opt.optlen = (optlen_new + 3) & ~3;
2024	hdr_delta -= opt->opt.optlen;	2035	hdr_delta -= opt->opt.optlen;
@@ -2238,7 +2249,8 @@ int cipso_v4_skbuff_setattr(struct sk_buff *skb, · 213 unmodified lines
2238	*/	2249	*/
2239	int cipso_v4_skbuff_delattr(struct sk_buff *skb)	2250	int cipso_v4_skbuff_delattr(struct sk_buff *skb)
2240	{	2251	{
2241	int ret_val;	2252	int ret_val, cipso_len, hdr_len_actual, new_hdr_len_actual, new_hdr_len,
		2253	hdr_len_delta;
2242	struct iphdr *iph;	2254	struct iphdr *iph;
2243	struct ip_options *opt = &IPCB(skb)->opt;	2255	struct ip_options *opt = &IPCB(skb)->opt;
2244	unsigned char *cipso_ptr;	2256	unsigned char *cipso_ptr;
@@ -2251,16 +2263,37 @@ int cipso_v4_skbuff_delattr(struct sk_buff *skb) · 6 unmodified lines
2251	if (ret_val < 0)	2263	if (ret_val < 0)
2252	return ret_val;	2264	return ret_val;
2253		2265
2254	/* the easiest thing to do is just replace the cipso option with noop
2255	* options since we don't change the size of the packet, although we
2256	* still need to recalculate the checksum */
2257
2258	iph = ip_hdr(skb);	2266	iph = ip_hdr(skb);
2259	cipso_ptr = (unsigned char *)iph + opt->cipso;	2267	cipso_ptr = (unsigned char *)iph + opt->cipso;
2260	memset(cipso_ptr, IPOPT_NOOP, cipso_ptr[1]);	2268	cipso_len = cipso_ptr[1];
		2269
		2270	hdr_len_actual = sizeof(struct iphdr) +
		2271	cipso_v4_get_actual_opt_len((unsigned char *)(iph + 1),
		2272	opt->optlen);
		2273	new_hdr_len_actual = hdr_len_actual - cipso_len;
		2274	new_hdr_len = (new_hdr_len_actual + 3) & ~3;
		2275	hdr_len_delta = (iph->ihl << 2) - new_hdr_len;
		2276
		2277	/* 1. shift any options after CIPSO to the left */
		2278	memmove(cipso_ptr, cipso_ptr + cipso_len,
		2279	new_hdr_len_actual - opt->cipso);
		2280	/* 2. move the whole IP header to its new place */
		2281	memmove((unsigned char *)iph + hdr_len_delta, iph, new_hdr_len_actual);
		2282	/* 3. adjust the skb layout */
		2283	skb_pull(skb, hdr_len_delta);
		2284	skb_reset_network_header(skb);
		2285	iph = ip_hdr(skb);
		2286	/* 4. re-fill new padding with IPOPT_END (may now be longer) */
		2287	memset((unsigned char *)iph + new_hdr_len_actual, IPOPT_END,
		2288	new_hdr_len - new_hdr_len_actual);
		2289
		2290	opt->optlen -= hdr_len_delta;
2261	opt->cipso = 0;	2291	opt->cipso = 0;
2262	opt->is_changed = 1;	2292	opt->is_changed = 1;
2263		2293	if (hdr_len_delta != 0) {
		2294	iph->ihl = new_hdr_len >> 2;
		2295	iph_set_totlen(iph, skb->len);
		2296	}
2264	ip_send_check(iph);	2297	ip_send_check(iph);
2265		2298
2266	return 0;	2299	return 0;

net/ipv4/tcp_ao.c+4−2

 		first = true;
 	}
-	if (cmd.ao_required && tcp_ao_required_verify(sk))
+	if (cmd.ao_required && tcp_ao_required_verify(sk)) {
-		return -EKEYREJECTED;
+		err = -EKEYREJECTED;
+		goto out;
+	}
 	/* For sockets in TCP_CLOSED it's possible set keys that aren't
 	 * matching the future peer (address/port/VRF/etc),

net/ipv4/tcp_input.c+1−0

@@ -6296,6 +6296,7 @@ static bool tcp_rcv_fastopen_synack(struct sock sk, struct sk_buff synack, · 6295 unmodified lines
6296	skb_rbtree_walk_from(data)	6296	skb_rbtree_walk_from(data)
6297	tcp_mark_skb_lost(sk, data);	6297	tcp_mark_skb_lost(sk, data);
6298	tcp_xmit_retransmit_queue(sk);	6298	tcp_xmit_retransmit_queue(sk);
		6299	tp->retrans_stamp = 0;
6299	NET_INC_STATS(sock_net(sk),	6300	NET_INC_STATS(sock_net(sk),
6300	LINUX_MIB_TCPFASTOPENACTIVEFAIL);	6301	LINUX_MIB_TCPFASTOPENACTIVEFAIL);
6301	return true;	6302	return true;

net/ipv6/ip6_fib.c+2−1

@@ -2514,7 +2514,8 @@ int __init fib6_init(void) · 2513 unmodified lines
2514	goto out_kmem_cache_create;	2514	goto out_kmem_cache_create;
2515		2515
2516	ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETROUTE, NULL,	2516	ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETROUTE, NULL,
2517	inet6_dump_fib, RTNL_FLAG_DUMP_UNLOCKED);	2517	inet6_dump_fib, RTNL_FLAG_DUMP_UNLOCKED \|
		2518	RTNL_FLAG_DUMP_SPLIT_NLM_DONE);
2518	if (ret)	2519	if (ret)
2519	goto out_unregister_subsys;	2520	goto out_unregister_subsys;
2520		2521

net/ipv6/route.c+3−1

 	rcu_read_lock();
 	last_probe = READ_ONCE(fib6_nh->last_probe);
 	idev = __in6_dev_get(dev);
+	if (!idev)
+		goto out;
 	neigh = __ipv6_neigh_lookup_noref(dev, nh_gw);
 	if (neigh) {
 		if (READ_ONCE(neigh->nud_state) & NUD_VALID)
 	if (!dev)
 		goto out;
-	if (idev->cnf.disable_ipv6) {
+	if (!idev || idev->cnf.disable_ipv6) {
 		NL_SET_ERR_MSG(extack, "IPv6 is disabled on nexthop device");
 		err = -EACCES;
 		goto out;

net/ipv6/seg6_local.c+4−4

@@ -941,8 +941,8 @@ static int input_action_end_dx6(struct sk_buff *skb, · 940 unmodified lines
941		941
942	if (static_branch_unlikely(&nf_hooks_lwtunnel_enabled))	942	if (static_branch_unlikely(&nf_hooks_lwtunnel_enabled))
943	return NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING,	943	return NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING,
944	dev_net(skb->dev), NULL, skb, NULL,	944	dev_net(skb->dev), NULL, skb, skb->dev,
945	skb_dst(skb)->dev, input_action_end_dx6_finish);	945	NULL, input_action_end_dx6_finish);
946		946
947	return input_action_end_dx6_finish(dev_net(skb->dev), NULL, skb);	947	return input_action_end_dx6_finish(dev_net(skb->dev), NULL, skb);
948	drop:	948	drop:
@@ -991,8 +991,8 @@ static int input_action_end_dx4(struct sk_buff *skb, · 42 unmodified lines
991		991
992	if (static_branch_unlikely(&nf_hooks_lwtunnel_enabled))	992	if (static_branch_unlikely(&nf_hooks_lwtunnel_enabled))
993	return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,	993	return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
994	dev_net(skb->dev), NULL, skb, NULL,	994	dev_net(skb->dev), NULL, skb, skb->dev,
995	skb_dst(skb)->dev, input_action_end_dx4_finish);	995	NULL, input_action_end_dx4_finish);
996		996
997	return input_action_end_dx4_finish(dev_net(skb->dev), NULL, skb);	997	return input_action_end_dx4_finish(dev_net(skb->dev), NULL, skb);
998	drop:	998	drop:

net/ipv6/xfrm6_policy.c+7−1

 {
 	struct dst_entry *dst;
 	struct net_device *dev;
+	struct inet6_dev *idev;
 	dst = xfrm6_dst_lookup(net, 0, oif, NULL, daddr, mark);
 	if (IS_ERR(dst))
 		return -EHOSTUNREACH;
-	dev = ip6_dst_idev(dst)->dev;
+	idev = ip6_dst_idev(dst);
+	if (!idev) {
+		dst_release(dst);
+		return -EHOSTUNREACH;
+	}
+	dev = idev->dev;
 	ipv6_dev_get_saddr(dev_net(dev), dev, &daddr->in6, 0, &saddr->in6);
 	dst_release(dst);
 	return 0;

net/mac80211/driver-ops.c+17−0

@@ -311,6 +311,18 @@ int drv_assign_vif_chanctx(struct ieee80211_local *local, · 310 unmodified lines
311	might_sleep();	311	might_sleep();
312	lockdep_assert_wiphy(local->hw.wiphy);	312	lockdep_assert_wiphy(local->hw.wiphy);
313		313
		314	/*
		315	* We should perhaps push emulate chanctx down and only
		316	* make it call ->config() when the chanctx is actually
		317	* assigned here (and unassigned below), but that's yet
		318	* another change to all drivers to add assign/unassign
		319	* emulation callbacks. Maybe later.
		320	*/
		321	if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
		322	local->emulate_chanctx &&
		323	!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
		324	return 0;
		325
314	if (!check_sdata_in_driver(sdata))	326	if (!check_sdata_in_driver(sdata))
315	return -EIO;	327	return -EIO;
316		328
@@ -338,6 +350,11 @@ void drv_unassign_vif_chanctx(struct ieee80211_local *local, · 21 unmodified lines
338	might_sleep();	350	might_sleep();
339	lockdep_assert_wiphy(local->hw.wiphy);	351	lockdep_assert_wiphy(local->hw.wiphy);
340		352
		353	if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
		354	local->emulate_chanctx &&
		355	!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
		356	return;
		357
341	if (!check_sdata_in_driver(sdata))	358	if (!check_sdata_in_driver(sdata))
342	return;	359	return;
343		360

net/mac80211/iface.c+10−12

 			ieee80211_del_virtual_monitor(local);
 		ieee80211_recalc_idle(local);
+		ieee80211_recalc_offload(local);
 		if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
 			break;
 	struct ieee80211_sub_if_data *sdata;
 	int ret;
-	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
-		return 0;
 	ASSERT_RTNL();
 	lockdep_assert_wiphy(local->hw.wiphy);
 	ieee80211_set_default_queues(sdata);
-	ret = drv_add_interface(local, sdata);
+	if (ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF)) {
-	if (WARN_ON(ret)) {
+		ret = drv_add_interface(local, sdata);
-		/* ok .. stupid driver, it asked for this! */
+		if (WARN_ON(ret)) {
-		kfree(sdata);
+			/* ok .. stupid driver, it asked for this! */
-		return ret;
+			kfree(sdata);
+			return ret;
+		}
 	}
 	set_bit(SDATA_STATE_RUNNING, &sdata->state);
 {
 	struct ieee80211_sub_if_data *sdata;
-	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
-		return;
 	ASSERT_RTNL();
 	lockdep_assert_wiphy(local->hw.wiphy);
 	ieee80211_link_release_channel(&sdata->deflink);
-	drv_remove_interface(local, sdata);
+	if (ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
+		drv_remove_interface(local, sdata);
 	kfree(sdata);
 }

net/mac80211/scan.c+9−8

@@ -358,7 +358,8 @@ static bool ieee80211_prep_hw_scan(struct ieee80211_sub_if_data *sdata) · 357 unmodified lines
358	struct cfg80211_scan_request *req;	358	struct cfg80211_scan_request *req;
359	struct cfg80211_chan_def chandef;	359	struct cfg80211_chan_def chandef;
360	u8 bands_used = 0;	360	u8 bands_used = 0;
361	int i, ielen, n_chans;	361	int i, ielen;
		362	u32 *n_chans;
362	u32 flags = 0;	363	u32 flags = 0;
363		364
364	req = rcu_dereference_protected(local->scan_req,	365	req = rcu_dereference_protected(local->scan_req,
@@ -368,34 +369,34 @@ static bool ieee80211_prep_hw_scan(struct ieee80211_sub_if_data *sdata) · 3 unmodified lines
368	return false;	369	return false;
369		370
370	if (ieee80211_hw_check(&local->hw, SINGLE_SCAN_ON_ALL_BANDS)) {	371	if (ieee80211_hw_check(&local->hw, SINGLE_SCAN_ON_ALL_BANDS)) {
		372	local->hw_scan_req->req.n_channels = req->n_channels;
		373
371	for (i = 0; i < req->n_channels; i++) {	374	for (i = 0; i < req->n_channels; i++) {
372	local->hw_scan_req->req.channels[i] = req->channels[i];	375	local->hw_scan_req->req.channels[i] = req->channels[i];
373	bands_used \|= BIT(req->channels[i]->band);	376	bands_used \|= BIT(req->channels[i]->band);
374	}	377	}
375
376	n_chans = req->n_channels;
377	} else {	378	} else {
378	do {	379	do {
379	if (local->hw_scan_band == NUM_NL80211_BANDS)	380	if (local->hw_scan_band == NUM_NL80211_BANDS)
380	return false;	381	return false;
381		382
382	n_chans = 0;	383	n_chans = &local->hw_scan_req->req.n_channels;
		384	*n_chans = 0;
383		385
384	for (i = 0; i < req->n_channels; i++) {	386	for (i = 0; i < req->n_channels; i++) {
385	if (req->channels[i]->band !=	387	if (req->channels[i]->band !=
386	local->hw_scan_band)	388	local->hw_scan_band)
387	continue;	389	continue;
388	local->hw_scan_req->req.channels[n_chans] =	390	local->hw_scan_req->req.channels[(*n_chans)++] =
389	req->channels[i];	391	req->channels[i];
390	n_chans++;	392
391	bands_used \|= BIT(req->channels[i]->band);	393	bands_used \|= BIT(req->channels[i]->band);
392	}	394	}
393		395
394	local->hw_scan_band++;	396	local->hw_scan_band++;
395	} while (!n_chans);	397	} while (!*n_chans);
396	}	398	}
397		399
398	local->hw_scan_req->req.n_channels = n_chans;
399	ieee80211_prepare_scan_chandef(&chandef);	400	ieee80211_prepare_scan_chandef(&chandef);
400		401
401	if (req->flags & NL80211_SCAN_FLAG_MIN_PREQ_CONTENT)	402	if (req->flags & NL80211_SCAN_FLAG_MIN_PREQ_CONTENT)

net/mac80211/util.c+1−1

@@ -1843,7 +1843,7 @@ int ieee80211_reconfig(struct ieee80211_local *local) · 1842 unmodified lines
1843		1843
1844	/* add interfaces */	1844	/* add interfaces */
1845	sdata = wiphy_dereference(local->hw.wiphy, local->monitor_sdata);	1845	sdata = wiphy_dereference(local->hw.wiphy, local->monitor_sdata);
1846	if (sdata) {	1846	if (sdata && ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF)) {
1847	/* in HW restart it exists already */	1847	/* in HW restart it exists already */
1848	WARN_ON(local->resuming);	1848	WARN_ON(local->resuming);
1849	res = drv_add_interface(local, sdata);	1849	res = drv_add_interface(local, sdata);

net/netfilter/core.c+11−2

 	if (ret < 0)
 		goto err;
+#ifdef CONFIG_LWTUNNEL
+	ret = netfilter_lwtunnel_init();
+	if (ret < 0)
+		goto err_lwtunnel_pernet;
+#endif
 	ret = netfilter_log_init();
 	if (ret < 0)
-		goto err_pernet;
+		goto err_log_pernet;
 	return 0;
-err_pernet:
+err_log_pernet:
+#ifdef CONFIG_LWTUNNEL
+	netfilter_lwtunnel_fini();
+err_lwtunnel_pernet:
+#endif
 	unregister_pernet_subsys(&netfilter_net_ops);
 err:
 	return ret;

net/netfilter/ipset/ip_set_core.c+6−5

 MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_IPSET);
 /* When the nfnl mutex or ip_set_ref_lock is held: */
-#define ip_set_dereference(p)		\
+#define ip_set_dereference(inst)	\
-	rcu_dereference_protected(p,	\
+	rcu_dereference_protected((inst)->ip_set_list,	\
 		lockdep_nfnl_is_held(NFNL_SUBSYS_IPSET) || \
-		lockdep_is_held(&ip_set_ref_lock))
+		lockdep_is_held(&ip_set_ref_lock) || \
+		(inst)->is_deleted)
 #define ip_set(inst, id)		\
-	ip_set_dereference((inst)->ip_set_list)[id]
+	ip_set_dereference(inst)[id]
 #define ip_set_ref_netlink(inst,id)	\
 	rcu_dereference_raw((inst)->ip_set_list)[id]
 #define ip_set_dereference_nfnl(p)	\
 		if (!list)
 			goto cleanup;
 		/* nfnl mutex is held, both lists are valid */
-		tmp = ip_set_dereference(inst->ip_set_list);
+		tmp = ip_set_dereference(inst);
 		memcpy(list, tmp, sizeof(struct ip_set *) * inst->ip_set_max);
 		rcu_assign_pointer(inst->ip_set_list, list);
 		/* Make sure all current packets have passed through */

net/netfilter/nf_conntrack_standalone.c+0−15

 #include <net/netfilter/nf_conntrack_acct.h>
 #include <net/netfilter/nf_conntrack_zones.h>
 #include <net/netfilter/nf_conntrack_timestamp.h>
-#ifdef CONFIG_LWTUNNEL
-#include <net/netfilter/nf_hooks_lwtunnel.h>
-#endif
 #include <linux/rculist_nulls.h>
 static bool enable_hooks __read_mostly;
 	NF_SYSCTL_CT_PROTO_TIMEOUT_GRE,
 	NF_SYSCTL_CT_PROTO_TIMEOUT_GRE_STREAM,
 #endif
-#ifdef CONFIG_LWTUNNEL
-	NF_SYSCTL_CT_LWTUNNEL,
-#endif
 	NF_SYSCTL_CT_LAST_SYSCTL,
 };
 		.proc_handler   = proc_dointvec_jiffies,
 	},
 #endif
-#ifdef CONFIG_LWTUNNEL
-	[NF_SYSCTL_CT_LWTUNNEL] = {
-		.procname	= "nf_hooks_lwtunnel",
-		.data		= NULL,
-		.maxlen		= sizeof(int),
-		.mode		= 0644,
-		.proc_handler	= nf_hooks_lwtunnel_sysctl_handler,
-	},
-#endif
 };
 static struct ctl_table nf_ct_netfilter_table[] = {

net/netfilter/nf_hooks_lwtunnel.c+67−0

@@ -3,6 +3,9 @@ · 2 unmodified lines
3	#include <linux/sysctl.h>	3	#include <linux/sysctl.h>
4	#include <net/lwtunnel.h>	4	#include <net/lwtunnel.h>
5	#include <net/netfilter/nf_hooks_lwtunnel.h>	5	#include <net/netfilter/nf_hooks_lwtunnel.h>
		6	#include <linux/netfilter.h>
		7
		8	#include "nf_internals.h"
6		9
7	static inline int nf_hooks_lwtunnel_get(void)	10	static inline int nf_hooks_lwtunnel_get(void)
8	{	11	{
@@ -50,4 +53,68 @@ int nf_hooks_lwtunnel_sysctl_handler(struct ctl_table *table, int write, · 41 unmodified lines
50	return ret;	53	return ret;
51	}	54	}
52	EXPORT_SYMBOL_GPL(nf_hooks_lwtunnel_sysctl_handler);	55	EXPORT_SYMBOL_GPL(nf_hooks_lwtunnel_sysctl_handler);
		56
		57	static struct ctl_table nf_lwtunnel_sysctl_table[] = {
		58	{
		59	.procname = "nf_hooks_lwtunnel",
		60	.data = NULL,
		61	.maxlen = sizeof(int),
		62	.mode = 0644,
		63	.proc_handler = nf_hooks_lwtunnel_sysctl_handler,
		64	},
		65	};
		66
		67	static int __net_init nf_lwtunnel_net_init(struct net *net)
		68	{
		69	struct ctl_table_header *hdr;
		70	struct ctl_table *table;
		71
		72	table = nf_lwtunnel_sysctl_table;
		73	if (!net_eq(net, &init_net)) {
		74	table = kmemdup(nf_lwtunnel_sysctl_table,
		75	sizeof(nf_lwtunnel_sysctl_table),
		76	GFP_KERNEL);
		77	if (!table)
		78	goto err_alloc;
		79	}
		80
		81	hdr = register_net_sysctl_sz(net, "net/netfilter", table,
		82	ARRAY_SIZE(nf_lwtunnel_sysctl_table));
		83	if (!hdr)
		84	goto err_reg;
		85
		86	net->nf.nf_lwtnl_dir_header = hdr;
		87
		88	return 0;
		89	err_reg:
		90	if (!net_eq(net, &init_net))
		91	kfree(table);
		92	err_alloc:
		93	return -ENOMEM;
		94	}
		95
		96	static void __net_exit nf_lwtunnel_net_exit(struct net *net)
		97	{
		98	const struct ctl_table *table;
		99
		100	table = net->nf.nf_lwtnl_dir_header->ctl_table_arg;
		101	unregister_net_sysctl_table(net->nf.nf_lwtnl_dir_header);
		102	if (!net_eq(net, &init_net))
		103	kfree(table);
		104	}
		105
		106	static struct pernet_operations nf_lwtunnel_net_ops = {
		107	.init = nf_lwtunnel_net_init,
		108	.exit = nf_lwtunnel_net_exit,
		109	};
		110
		111	int __init netfilter_lwtunnel_init(void)
		112	{
		113	return register_pernet_subsys(&nf_lwtunnel_net_ops);
		114	}
		115
		116	void netfilter_lwtunnel_fini(void)
		117	{
		118	unregister_pernet_subsys(&nf_lwtunnel_net_ops);
		119	}
53	#endif /* CONFIG_SYSCTL */	120	#endif /* CONFIG_SYSCTL */

net/netfilter/nf_internals.h+6−0

 /* nf_log.c */
 int __init netfilter_log_init(void);
+#ifdef CONFIG_LWTUNNEL
+/* nf_hooks_lwtunnel.c */
+int __init netfilter_lwtunnel_init(void);
+void netfilter_lwtunnel_fini(void);
+#endif
 /* core.c */
 void nf_hook_entries_delete_raw(struct nf_hook_entries __rcu **pp,
 				const struct nf_hook_ops *reg);

net/netrom/nr_timer.c+2−1

 		   is accepted() it isn't 'dead' so doesn't get removed. */
 		if (sock_flag(sk, SOCK_DESTROY) ||
 		    (sk->sk_state == TCP_LISTEN && sock_flag(sk, SOCK_DEAD))) {
-			sock_hold(sk);
+			if (sk->sk_state == TCP_LISTEN)
+				sock_hold(sk);
 			bh_unlock_sock(sk);
 			nr_destroy_socket(sk);
 			goto out;

net/sched/act_api.c+1−2

 	u32 max;
 	if (*index) {
-again:
 		rcu_read_lock();
 		p = idr_find(&idrinfo->action_idr, *index);
 			 * index but did not assign the pointer yet.
 			 */
 			rcu_read_unlock();
-			goto again;
+			return -EAGAIN;
 		}
 		if (!p) {

net/sched/act_ct.c+11−5

 static struct rhashtable zones_ht;
 static DEFINE_MUTEX(zones_mutex);
+struct zones_ht_key {
+	struct net *net;
+	u16 zone;
+};
 struct tcf_ct_flow_table {
 	struct rhash_head node; /* In zones tables */
 	struct rcu_work rwork;
 	struct nf_flowtable nf_ft;
 	refcount_t ref;
-	u16 zone;
+	struct zones_ht_key key;
 	bool dying;
 };
 static const struct rhashtable_params zones_params = {
 	.head_offset = offsetof(struct tcf_ct_flow_table, node),
-	.key_offset = offsetof(struct tcf_ct_flow_table, zone),
+	.key_offset = offsetof(struct tcf_ct_flow_table, key),
-	.key_len = sizeof_field(struct tcf_ct_flow_table, zone),
+	.key_len = sizeof_field(struct tcf_ct_flow_table, key),
 	.automatic_shrinking = true,
 };
 static int tcf_ct_flow_table_get(struct net *net, struct tcf_ct_params *params)
 {
+	struct zones_ht_key key = { .net = net, .zone = params->zone };
 	struct tcf_ct_flow_table *ct_ft;
 	int err = -ENOMEM;
 	mutex_lock(&zones_mutex);
-	ct_ft = rhashtable_lookup_fast(&zones_ht, &params->zone, zones_params);
+	ct_ft = rhashtable_lookup_fast(&zones_ht, &key, zones_params);
 	if (ct_ft && refcount_inc_not_zero(&ct_ft->ref))
 		goto out_unlock;
 		goto err_alloc;
 	refcount_set(&ct_ft->ref, 1);
-	ct_ft->zone = params->zone;
+	ct_ft->key = key;
 	err = rhashtable_insert_fast(&zones_ht, &ct_ft->node, zones_params);
 	if (err)
 		goto err_insert;

net/sunrpc/svc_xprt.c+5−3

 	dprintk("svc_pool_stats_start, *pidx=%u\n", pidx);
+	if (!si->serv)
+		return NULL;
 	mutex_lock(si->mutex);
 	if (!pidx)
 		return SEQ_START_TOKEN;
-	if (!si->serv)
-		return NULL;
 	return pidx > si->serv->sv_nrpools ? NULL
 		: &si->serv->sv_pools[pidx - 1];
 }
 {
 	struct svc_info *si = m->private;
-	mutex_unlock(si->mutex);
+	if (si->serv)
+		mutex_unlock(si->mutex);
 }
 static int svc_pool_stats_show(struct seq_file *m, void *p)

net/tipc/node.c+1−0

@@ -2105,6 +2105,7 @@ void tipc_rcv(struct net net, struct sk_buff skb, struct tipc_bearer *b) · 2104 unmodified lines
2105	} else {	2105	} else {
2106	n = tipc_node_find_by_id(net, ehdr->id);	2106	n = tipc_node_find_by_id(net, ehdr->id);
2107	}	2107	}
		2108	skb_dst_force(skb);
2108	tipc_crypto_rcv(net, (n) ? n->crypto_rx : NULL, &skb, b);	2109	tipc_crypto_rcv(net, (n) ? n->crypto_rx : NULL, &skb, b);
2109	if (!skb)	2110	if (!skb)
2110	return;	2111	return;

net/wireless/scan.c+9−3

 	wiphy = &rdev->wiphy;
 	/* Determine number of channels, needed to allocate creq */
-	if (wreq && wreq->num_channels)
+	if (wreq && wreq->num_channels) {
+		/* Passed from userspace so should be checked */
+		if (unlikely(wreq->num_channels > IW_MAX_FREQUENCIES))
+			return -EINVAL;
 		n_channels = wreq->num_channels;
-	else
+	} else {
 		n_channels = ieee80211_get_num_supported_channels(wiphy);
+	}
 	creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
 		       n_channels * sizeof(void *),
 			memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
 			creq->ssids[0].ssid_len = wreq->essid_len;
 		}
-		if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE)
+		if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE) {
+			creq->ssids = NULL;
 			creq->n_ssids = 0;
+		}
 	}
 	for (i = 0; i < NUM_NL80211_BANDS; i++)

rust/kernel/alloc/vec_ext.rs+5−2

 use super::{AllocError, Flags};
 use alloc::vec::Vec;
-use core::ptr;
 /// Extensions to [`Vec`].
 pub trait VecExt<T>: Sized {
         // `krealloc_aligned`. A `Vec<T>`'s `ptr` value is not guaranteed to be NULL and might be
         // dangling after being created with `Vec::new`. Instead, we can rely on `Vec<T>`'s capacity
         // to be zero if no memory has been allocated yet.
-        let ptr = if cap == 0 { ptr::null_mut() } else { old_ptr };
+        let ptr = if cap == 0 {
+            core::ptr::null_mut()
+        } else {
+            old_ptr
+        };
         // SAFETY: `ptr` is valid because it's either NULL or comes from a previous call to
         // `krealloc_aligned`. We also verified that the type is not a ZST.

security/Kconfig.hardening+0−15

@@ -255,21 +255,6 @@ config INIT_ON_FREE_DEFAULT_ON · 254 unmodified lines
255	touching "cold" memory areas. Most cases see 3-5% impact. Some	255	touching "cold" memory areas. Most cases see 3-5% impact. Some
256	synthetic workloads have measured as high as 8%.	256	synthetic workloads have measured as high as 8%.
257		257
258	config INIT_MLOCKED_ON_FREE_DEFAULT_ON
259	bool "Enable mlocked memory zeroing on free"
260	depends on !KMSAN
261	help
262	This config has the effect of setting "init_mlocked_on_free=1"
263	on the kernel command line. If it is enabled, all mlocked process
264	memory is zeroed when freed. This restriction to mlocked memory
265	improves performance over "init_on_free" but can still be used to
266	protect confidential data like key material from content exposures
267	to other processes, as well as live forensics and cold boot attacks.
268	Any non-mlocked memory is not cleared before it is reassigned. This
269	configuration can be overwritten by setting "init_mlocked_on_free=0"
270	on the command line. The "init_on_free" boot option takes
271	precedence over "init_mlocked_on_free".
272
273	config CC_HAS_ZERO_CALL_USED_REGS	258	config CC_HAS_ZERO_CALL_USED_REGS
274	def_bool $(cc-option,-fzero-call-used-regs=used-gpr)	259	def_bool $(cc-option,-fzero-call-used-regs=used-gpr)
275	# https://github.com/ClangBuiltLinux/linux/issues/1766	260	# https://github.com/ClangBuiltLinux/linux/issues/1766

security/apparmor/audit.c+3−3

@@ -217,7 +217,7 @@ void aa_audit_rule_free(void *vrule) · 216 unmodified lines
217	}	217	}
218	}	218	}
219		219
220	int aa_audit_rule_init(u32 field, u32 op, char rulestr, void *vrule)	220	int aa_audit_rule_init(u32 field, u32 op, char rulestr, void *vrule, gfp_t gfp)
221	{	221	{
222	struct aa_audit_rule *rule;	222	struct aa_audit_rule *rule;
223		223
@@ -230,14 +230,14 @@ int aa_audit_rule_init(u32 field, u32 op, char rulestr, void *vrule) · 6 unmodified lines
230	return -EINVAL;	230	return -EINVAL;
231	}	231	}
232		232
233	rule = kzalloc(sizeof(struct aa_audit_rule), GFP_KERNEL);	233	rule = kzalloc(sizeof(struct aa_audit_rule), gfp);
234		234
235	if (!rule)	235	if (!rule)
236	return -ENOMEM;	236	return -ENOMEM;
237		237
238	/* Currently rules are treated as coming from the root ns */	238	/* Currently rules are treated as coming from the root ns */
239	rule->label = aa_label_parse(&root_ns->unconfined->label, rulestr,	239	rule->label = aa_label_parse(&root_ns->unconfined->label, rulestr,
240	GFP_KERNEL, true, false);	240	gfp, true, false);
241	if (IS_ERR(rule->label)) {	241	if (IS_ERR(rule->label)) {
242	int err = PTR_ERR(rule->label);	242	int err = PTR_ERR(rule->label);
243	aa_audit_rule_free(rule);	243	aa_audit_rule_free(rule);

security/apparmor/include/audit.h+1−1

@@ -200,7 +200,7 @@ static inline int complain_error(int error) · 199 unmodified lines
200	}	200	}
201		201
202	void aa_audit_rule_free(void *vrule);	202	void aa_audit_rule_free(void *vrule);
203	int aa_audit_rule_init(u32 field, u32 op, char rulestr, void *vrule);	203	int aa_audit_rule_init(u32 field, u32 op, char rulestr, void *vrule, gfp_t gfp);
204	int aa_audit_rule_known(struct audit_krule *rule);	204	int aa_audit_rule_known(struct audit_krule *rule);
205	int aa_audit_rule_match(u32 sid, u32 field, u32 op, void *vrule);	205	int aa_audit_rule_match(u32 sid, u32 field, u32 op, void *vrule);
206		206

security/integrity/ima/ima.h+1−1

@@ -546,7 +546,7 @@ static inline void ima_free_modsig(struct modsig *modsig) · 545 unmodified lines
546	#else	546	#else
547		547
548	static inline int ima_filter_rule_init(u32 field, u32 op, char *rulestr,	548	static inline int ima_filter_rule_init(u32 field, u32 op, char *rulestr,
549	void **lsmrule)	549	void **lsmrule, gfp_t gfp)
550	{	550	{
551	return -EINVAL;	551	return -EINVAL;
552	}	552	}

security/integrity/ima/ima_policy.c+9−6

 	kfree(entry);
 }
-static struct ima_rule_entry *ima_lsm_copy_rule(struct ima_rule_entry *entry)
+static struct ima_rule_entry *ima_lsm_copy_rule(struct ima_rule_entry *entry,
+						gfp_t gfp)
 {
 	struct ima_rule_entry *nentry;
 	int i;
 	 * Immutable elements are copied over as pointers and data; only
 	 * lsm rules can change
 	 */
-	nentry = kmemdup(entry, sizeof(*nentry), GFP_KERNEL);
+	nentry = kmemdup(entry, sizeof(*nentry), gfp);
 	if (!nentry)
 		return NULL;
 		ima_filter_rule_init(nentry->lsm[i].type, Audit_equal,
 				     nentry->lsm[i].args_p,
-				     &nentry->lsm[i].rule);
+				     &nentry->lsm[i].rule,
+				     gfp);
 		if (!nentry->lsm[i].rule)
 			pr_warn("rule for LSM \'%s\' is undefined\n",
 				nentry->lsm[i].args_p);
 	int i;
 	struct ima_rule_entry *nentry;
-	nentry = ima_lsm_copy_rule(entry);
+	nentry = ima_lsm_copy_rule(entry, GFP_KERNEL);
 	if (!nentry)
 		return -ENOMEM;
 		}
 		if (rc == -ESTALE && !rule_reinitialized) {
-			lsm_rule = ima_lsm_copy_rule(rule);
+			lsm_rule = ima_lsm_copy_rule(rule, GFP_ATOMIC);
 			if (lsm_rule) {
 				rule_reinitialized = true;
 				goto retry;
 	entry->lsm[lsm_rule].type = audit_type;
 	result = ima_filter_rule_init(entry->lsm[lsm_rule].type, Audit_equal,
 				      entry->lsm[lsm_rule].args_p,
-				      &entry->lsm[lsm_rule].rule);
+				      &entry->lsm[lsm_rule].rule,
+				      GFP_KERNEL);
 	if (!entry->lsm[lsm_rule].rule) {
 		pr_warn("rule for LSM \'%s\' is undefined\n",
 			entry->lsm[lsm_rule].args_p);

security/security.c+4−2

  * @op: rule operator
  * @rulestr: rule context
  * @lsmrule: receive buffer for audit rule struct
+ * @gfp: GFP flag used for kmalloc
  *
  * Allocate and initialize an LSM audit rule structure.
  *
  * Return: Return 0 if @lsmrule has been successfully set, -EINVAL in case of
  *         an invalid rule.
  */
-int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule)
+int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule,
+			     gfp_t gfp)
 {
-	return call_int_hook(audit_rule_init, field, op, rulestr, lsmrule);
+	return call_int_hook(audit_rule_init, field, op, rulestr, lsmrule, gfp);
 }
 /**

security/selinux/include/audit.h+3−1

  *	@op: the operator the rule uses
  *	@rulestr: the text "target" of the rule
  *	@rule: pointer to the new rule structure returned via this
+ *	@gfp: GFP flag used for kmalloc
  *
  *	Returns 0 if successful, -errno if not.  On success, the rule structure
  *	will be allocated internally.  The caller must free this structure with
  *	selinux_audit_rule_free() after use.
  */
-int selinux_audit_rule_init(u32 field, u32 op, char *rulestr, void **rule);
+int selinux_audit_rule_init(u32 field, u32 op, char *rulestr, void **rule,
+			    gfp_t gfp);
 /**
  *	selinux_audit_rule_free - free an selinux audit rule structure.

security/selinux/ss/services.c+3−2

 	}
 }
-int selinux_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
+int selinux_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule,
+			    gfp_t gfp)
 {
 	struct selinux_state *state = &selinux_state;
 	struct selinux_policy *policy;
 		return -EINVAL;
 	}
-	tmprule = kzalloc(sizeof(struct selinux_audit_rule), GFP_KERNEL);
+	tmprule = kzalloc(sizeof(struct selinux_audit_rule), gfp);
 	if (!tmprule)
 		return -ENOMEM;
 	context_init(&tmprule->au_ctxt);

security/smack/smack_lsm.c+3−1

  * @op: required testing operator (=, !=, >, <, ...)
  * @rulestr: smack label to be audited
  * @vrule: pointer to save our own audit rule representation
+ * @gfp: type of the memory for the allocation
  *
  * Prepare to audit cases where (@field @op @rulestr) is true.
  * The label to be audited is created if necessay.
  */
-static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
+static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule,
+				 gfp_t gfp)
 {
 	struct smack_known *skp;
 	char **rule = (char **)vrule;

security/yama/yama_lsm.c+1−0

@@ -111,6 +111,7 @@ static void report_access(const char access, struct task_struct target, · 110 unmodified lines
111		111
112	/**	112	/**
113	* yama_relation_cleanup - remove invalid entries from the relation list	113	* yama_relation_cleanup - remove invalid entries from the relation list
		114	* @work: unused
114	*	115	*
115	*/	116	*/
116	static void yama_relation_cleanup(struct work_struct *work)	117	static void yama_relation_cleanup(struct work_struct *work)

sound/core/seq/seq_ump_convert.c+2−0

@@ -1075,6 +1075,8 @@ static const struct seq_ev_to_ump seq_ev_ump_encoders[] = { · 1074 unmodified lines
1075	system_ev_to_ump_midi1, system_ev_to_ump_midi2 },	1075	system_ev_to_ump_midi1, system_ev_to_ump_midi2 },
1076	{ SNDRV_SEQ_EVENT_SENSING, UMP_SYSTEM_STATUS_ACTIVE_SENSING,	1076	{ SNDRV_SEQ_EVENT_SENSING, UMP_SYSTEM_STATUS_ACTIVE_SENSING,
1077	system_ev_to_ump_midi1, system_ev_to_ump_midi2 },	1077	system_ev_to_ump_midi1, system_ev_to_ump_midi2 },
		1078	{ SNDRV_SEQ_EVENT_RESET, UMP_SYSTEM_STATUS_RESET,
		1079	system_ev_to_ump_midi1, system_ev_to_ump_midi2 },
1078	};	1080	};
1079		1081
1080	static const struct seq_ev_to_ump *find_ump_encoder(int type)	1082	static const struct seq_ev_to_ump *find_ump_encoder(int type)

sound/hda/intel-dsp-config.c+1−1

@@ -18,7 +18,7 @@ · 17 unmodified lines
18	static int dsp_driver;	18	static int dsp_driver;
19		19
20	module_param(dsp_driver, int, 0444);	20	module_param(dsp_driver, int, 0444);
21	MODULE_PARM_DESC(dsp_driver, "Force the DSP driver for Intel DSP (0=auto, 1=legacy, 2=SST, 3=SOF)");	21	MODULE_PARM_DESC(dsp_driver, "Force the DSP driver for Intel DSP (0=auto, 1=legacy, 2=SST, 3=SOF, 4=AVS)");
22		22
23	#define FLAG_SST BIT(0)	23	#define FLAG_SST BIT(0)
24	#define FLAG_SOF BIT(1)	24	#define FLAG_SOF BIT(1)

sound/oss/dmasound/dmasound_core.c+1−0

@@ -204,6 +204,7 @@ module_param(numWriteBufs, int, 0); · 203 unmodified lines
204	static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ; /* in bytes */	204	static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ; /* in bytes */
205	module_param(writeBufSize, int, 0);	205	module_param(writeBufSize, int, 0);
206		206
		207	MODULE_DESCRIPTION("Atari/Amiga/Q40 core DMA sound driver");
207	MODULE_LICENSE("GPL");	208	MODULE_LICENSE("GPL");
208		209
209	static int sq_unit = -1;	210	static int sq_unit = -1;

sound/pci/hda/Kconfig+2−0

 	depends on ACPI || COMPILE_TEST
 	depends on SND_SOC
 	select FW_CS_DSP
+	imply SERIAL_MULTI_INSTANTIATE
 	select SND_HDA_GENERIC
 	select SND_SOC_CS35L56_SHARED
 	select SND_HDA_SCODEC_CS35L56
 	depends on ACPI || COMPILE_TEST
 	depends on SND_SOC
 	select FW_CS_DSP
+	imply SERIAL_MULTI_INSTANTIATE
 	select SND_HDA_GENERIC
 	select SND_SOC_CS35L56_SHARED
 	select SND_HDA_SCODEC_CS35L56

sound/pci/hda/cs35l41_hda.c+3−3

 	if (comps[cs35l41->index].dev == dev) {
 		memset(&comps[cs35l41->index], 0, sizeof(*comps));
 		sleep_flags = lock_system_sleep();
-		device_link_remove(&comps->codec->core.dev, cs35l41->dev);
+		device_link_remove(&cs35l41->codec->core.dev, cs35l41->dev);
 		unlock_system_sleep(sleep_flags);
 	}
 }
 {
 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
+	component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
 	pm_runtime_get_sync(cs35l41->dev);
 	pm_runtime_dont_use_autosuspend(cs35l41->dev);
 	pm_runtime_disable(cs35l41->dev);
 	if (cs35l41->halo_initialized)
 		cs35l41_remove_dsp(cs35l41);
-	component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
 	acpi_dev_put(cs35l41->dacpi);
 	pm_runtime_put_noidle(cs35l41->dev);

sound/pci/hda/cs35l41_hda_property.c+8−0

 	{ "17AA38B5", 2, EXTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, 0, 0 }, 0, 1, -1, 0, 0, 0 },
 	{ "17AA38B6", 2, EXTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, 0, 0 }, 0, 1, -1, 0, 0, 0 },
 	{ "17AA38B7", 2, EXTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, 0, 0 }, 0, 1, -1, 0, 0, 0 },
+	{ "17AA38C7", 4, INTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, CS35L41_LEFT, CS35L41_RIGHT }, 0, 2, -1, 1000, 4500, 24 },
+	{ "17AA38C8", 4, INTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, CS35L41_LEFT, CS35L41_RIGHT }, 0, 2, -1, 1000, 4500, 24 },
+	{ "17AA38F9", 2, EXTERNAL, { CS35L41_RIGHT, CS35L41_LEFT, 0, 0 }, 0, 2, -1, 0, 0, 0 },
+	{ "17AA38FA", 2, EXTERNAL, { CS35L41_RIGHT, CS35L41_LEFT, 0, 0 }, 0, 2, -1, 0, 0, 0 },
 	{}
 };
 	{ "CSC3551", "17AA38B5", generic_dsd_config },
 	{ "CSC3551", "17AA38B6", generic_dsd_config },
 	{ "CSC3551", "17AA38B7", generic_dsd_config },
+	{ "CSC3551", "17AA38C7", generic_dsd_config },
+	{ "CSC3551", "17AA38C8", generic_dsd_config },
+	{ "CSC3551", "17AA38F9", generic_dsd_config },
+	{ "CSC3551", "17AA38FA", generic_dsd_config },
 	{}
 };

sound/pci/hda/cs35l56_hda.c+7−2

 	if (comps[cs35l56->index].dev == dev)
 		memset(&comps[cs35l56->index], 0, sizeof(*comps));
+	cs35l56->codec = NULL;
 	dev_dbg(cs35l56->base.dev, "Unbound\n");
 }
 	cs35l56->suspended = false;
+	if (!cs35l56->codec)
+		return 0;
 	ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
 	dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
 	if (ret > 0) {
 {
 	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
+	component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
 	pm_runtime_dont_use_autosuspend(cs35l56->base.dev);
 	pm_runtime_get_sync(cs35l56->base.dev);
 	pm_runtime_disable(cs35l56->base.dev);
-	component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
 	cs_dsp_remove(&cs35l56->cs_dsp);
 	kfree(cs35l56->system_name);

sound/pci/hda/patch_realtek.c+36−3

 	switch (codec->core.vendor_id) {
 	case 0x10ec0236:
 	case 0x10ec0256:
+	case 0x10ec0257:
 	case 0x19e58326:
 	case 0x10ec0283:
+	case 0x10ec0285:
 	case 0x10ec0286:
+	case 0x10ec0287:
 	case 0x10ec0288:
+	case 0x10ec0295:
 	case 0x10ec0298:
 		alc_headset_mic_no_shutup(codec);
 		break;
 	ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1,
 	ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318,
 	ALC256_FIXUP_CHROME_BOOK,
+	ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7,
 };
 /* A special fixup for Lenovo C940 and Yoga Duet 7;
 	__snd_hda_apply_fixup(codec, id, action, 0);
 }
+/* Similar to above the Lenovo Yoga Pro 7 14ARP8 PCI SSID matches the codec SSID of the
+   Legion Y9000X 2022 IAH7.*/
+static void alc287_fixup_lenovo_14arp8_legion_iah7(struct hda_codec *codec,
+					   const struct hda_fixup *fix,
+					   int action)
+{
+	int id;
+	if (codec->core.subsystem_id == 0x17aa386e)
+		id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion Y9000X 2022 IAH7 */
+	else
+		id = ALC285_FIXUP_SPEAKER2_TO_DAC1; /* Yoga Pro 7 14ARP8 */
+	__snd_hda_apply_fixup(codec, id, action, 0);
+}
 /* Another hilarious PCI SSID conflict with Lenovo Legion Pro 7 16ARX8H (with
  * TAS2781 codec) and Legion 7i 16IAX7 (with CS35L41 codec);
  * we apply a corresponding fixup depending on the codec SSID instead
 		.chained = true,
 		.chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
 	},
+	[ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7] = {
+		.type = HDA_FIXUP_FUNC,
+		.v.func = alc287_fixup_lenovo_14arp8_legion_iah7,
+	},
 	[ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
 	SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
+	SND_PCI_QUIRK(0x103c, 0x8c7b, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
+	SND_PCI_QUIRK(0x103c, 0x8c7c, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
+	SND_PCI_QUIRK(0x103c, 0x8c7d, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
+	SND_PCI_QUIRK(0x103c, 0x8c7e, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
 	SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
 	SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
 	SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
-	SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+	SND_PCI_QUIRK(0x17aa, 0x3820, "IdeaPad 330-17IKB 81DM", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
 	SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
 	SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
 	SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
 	SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
 	SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
 	SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
-	SND_PCI_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7", ALC287_FIXUP_CS35L41_I2C_2),
+	SND_PCI_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7 / Yoga Pro 7 14ARP8",  ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7),
 	SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7/7i", ALC287_FIXUP_LENOVO_LEGION_7),
 	SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
 	SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
 	SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
+	SND_PCI_QUIRK(0x17aa, 0x3891, "Lenovo Yoga Pro 7 14AHP9", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
 	SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
 	SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
+	SND_PCI_QUIRK(0x17aa, 0x38c7, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
+	SND_PCI_QUIRK(0x17aa, 0x38c8, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
 	SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
 	SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
 	SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
+	SND_PCI_QUIRK(0x17aa, 0x38f9, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2),
+	SND_PCI_QUIRK(0x17aa, 0x38fa, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2),
 	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
 	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
 	SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
 	SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
 	SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
+	SND_PCI_QUIRK(0x1c6c, 0x122a, "Positivo N14AP7", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
 	SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
 	SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
 	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),
-	SND_PCI_QUIRK(0xf111, 0x0005, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
 #if 0

sound/pci/hda/tas2781_hda_i2c.c+2−2

 {
 	struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
+	component_del(tas_hda->dev, &tas2781_hda_comp_ops);
 	pm_runtime_get_sync(tas_hda->dev);
 	pm_runtime_disable(tas_hda->dev);
-	component_del(tas_hda->dev, &tas2781_hda_comp_ops);
 	pm_runtime_put_noidle(tas_hda->dev);
 	tasdevice_remove(tas_hda->priv);

tools/hv/Makefile+1−0

@@ -17,6 +17,7 @@ endif · 16 unmodified lines
17	MAKEFLAGS += -r	17	MAKEFLAGS += -r
18		18
19	override CFLAGS += -O2 -Wall -g -D_GNU_SOURCE -I$(OUTPUT)include	19	override CFLAGS += -O2 -Wall -g -D_GNU_SOURCE -I$(OUTPUT)include
		20	override CFLAGS += -Wno-address-of-packed-member
20		21
21	ALL_TARGETS := hv_kvp_daemon hv_vss_daemon	22	ALL_TARGETS := hv_kvp_daemon hv_vss_daemon
22	ifneq ($(ARCH), aarch64)	23	ifneq ($(ARCH), aarch64)

tools/testing/selftests/bpf/prog_tests/verifier.c+2−0

 #include "verifier_movsx.skel.h"
 #include "verifier_netfilter_ctx.skel.h"
 #include "verifier_netfilter_retcode.skel.h"
+#include "verifier_or_jmp32_k.skel.h"
 #include "verifier_precision.skel.h"
 #include "verifier_prevent_map_lookup.skel.h"
 #include "verifier_raw_stack.skel.h"
 void test_verifier_movsx(void)                 { RUN(verifier_movsx); }
 void test_verifier_netfilter_ctx(void)        { RUN(verifier_netfilter_ctx); }
 void test_verifier_netfilter_retcode(void)    { RUN(verifier_netfilter_retcode); }
+void test_verifier_or_jmp32_k(void)           { RUN(verifier_or_jmp32_k); }
 void test_verifier_precision(void)            { RUN(verifier_precision); }
 void test_verifier_prevent_map_lookup(void)   { RUN(verifier_prevent_map_lookup); }
 void test_verifier_raw_stack(void)            { RUN(verifier_raw_stack); }

tools/testing/selftests/bpf/progs/verifier_or_jmp32_k.c+41−0

@@ -0,0 +1,41 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#include <linux/bpf.h>
	4	#include <bpf/bpf_helpers.h>
	5	#include "bpf_misc.h"
	6
	7	SEC("socket")
	8	__description("or_jmp32_k: bit ops + branch on unknown value")
	9	__failure
	10	__msg("R0 invalid mem access 'scalar'")
	11	__naked void or_jmp32_k(void)
	12	{
	13	asm volatile (" \
	14	r0 = 0xffffffff; \
	15	r0 /= 1; \
	16	r1 = 0; \
	17	w1 = -1; \
	18	w1 >>= 1; \
	19	w0 &= w1; \
	20	w0 \|= 2; \
	21	if w0 != 0x7ffffffd goto l1; \
	22	r0 = 1; \
	23	exit; \
	24	l3: \
	25	r0 = 5; \
	26	(u64)(r0 - 8) = r0; \
	27	exit; \
	28	l2: \
	29	w0 -= 0xe; \
	30	if w0 == 1 goto l3; \
	31	r0 = 4; \
	32	exit; \
	33	l1: \
	34	w0 -= 0x7ffffff0; \
	35	if w0 s>= 0xe goto l2; \
	36	r0 = 3; \
	37	exit; \
	38	" ::: __clobber_all);
	39	}
	40
	41	char _license[] SEC("license") = "GPL";

tools/testing/selftests/drivers/net/virtio_net/config+7−1

@@ -1,2 +1,8 @@
1	CONFIG_VIRTIO_NET=y	1	CONFIG_BPF_SYSCALL=y
		2	CONFIG_CGROUP_BPF=y
		3	CONFIG_IPV6=y
		4	CONFIG_IPV6_MULTIPLE_TABLES=y
		5	CONFIG_NET_L3_MASTER_DEV=y
		6	CONFIG_NET_VRF=m
2	CONFIG_VIRTIO_DEBUG=y	7	CONFIG_VIRTIO_DEBUG=y
		8	CONFIG_VIRTIO_NET=y

tools/testing/selftests/fchmodat2/Makefile+10−1

@@ -1,6 +1,15 @@
1	# SPDX-License-Identifier: GPL-2.0-or-later	1	# SPDX-License-Identifier: GPL-2.0-or-later
2		2
3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined -static-libasan $(KHDR_INCLUDES)	3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined $(KHDR_INCLUDES)
		4
		5	# gcc requires -static-libasan in order to ensure that Address Sanitizer's
		6	# library is the first one loaded. However, clang already statically links the
		7	# Address Sanitizer if -fsanitize is specified. Therefore, simply omit
		8	# -static-libasan for clang builds.
		9	ifeq ($(LLVM),)
		10	CFLAGS += -static-libasan
		11	endif
		12
4	TEST_GEN_PROGS := fchmodat2_test	13	TEST_GEN_PROGS := fchmodat2_test
5		14
6	include ../lib.mk	15	include ../lib.mk

tools/testing/selftests/filesystems/statmount/statmount_test.c+10−2

@@ -125,8 +125,16 @@ static uint32_t old_root_id, old_parent_id; · 124 unmodified lines
125		125
126	static void cleanup_namespace(void)	126	static void cleanup_namespace(void)
127	{	127	{
128	fchdir(orig_root);	128	int ret;
129	chroot(".");	129
		130	ret = fchdir(orig_root);
		131	if (ret == -1)
		132	ksft_perror("fchdir to original root");
		133
		134	ret = chroot(".");
		135	if (ret == -1)
		136	ksft_perror("chroot to original root");
		137
130	umount2(root_mntpoint, MNT_DETACH);	138	umount2(root_mntpoint, MNT_DETACH);
131	rmdir(root_mntpoint);	139	rmdir(root_mntpoint);
132	}	140	}

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

@@ -277,6 +277,7 @@ struct kvm_x86_cpu_property { · 276 unmodified lines
277	#define X86_PROPERTY_MAX_EXT_LEAF KVM_X86_CPU_PROPERTY(0x80000000, 0, EAX, 0, 31)	277	#define X86_PROPERTY_MAX_EXT_LEAF KVM_X86_CPU_PROPERTY(0x80000000, 0, EAX, 0, 31)
278	#define X86_PROPERTY_MAX_PHY_ADDR KVM_X86_CPU_PROPERTY(0x80000008, 0, EAX, 0, 7)	278	#define X86_PROPERTY_MAX_PHY_ADDR KVM_X86_CPU_PROPERTY(0x80000008, 0, EAX, 0, 7)
279	#define X86_PROPERTY_MAX_VIRT_ADDR KVM_X86_CPU_PROPERTY(0x80000008, 0, EAX, 8, 15)	279	#define X86_PROPERTY_MAX_VIRT_ADDR KVM_X86_CPU_PROPERTY(0x80000008, 0, EAX, 8, 15)
		280	#define X86_PROPERTY_GUEST_MAX_PHY_ADDR KVM_X86_CPU_PROPERTY(0x80000008, 0, EAX, 16, 23)
280	#define X86_PROPERTY_SEV_C_BIT KVM_X86_CPU_PROPERTY(0x8000001F, 0, EBX, 0, 5)	281	#define X86_PROPERTY_SEV_C_BIT KVM_X86_CPU_PROPERTY(0x8000001F, 0, EBX, 0, 5)
281	#define X86_PROPERTY_PHYS_ADDR_REDUCTION KVM_X86_CPU_PROPERTY(0x8000001F, 0, EBX, 6, 11)	282	#define X86_PROPERTY_PHYS_ADDR_REDUCTION KVM_X86_CPU_PROPERTY(0x8000001F, 0, EBX, 6, 11)
282		283

tools/testing/selftests/kvm/lib/riscv/ucall.c+1−0

@@ -9,6 +9,7 @@ · 8 unmodified lines
9		9
10	#include "kvm_util.h"	10	#include "kvm_util.h"
11	#include "processor.h"	11	#include "processor.h"
		12	#include "sbi.h"
12		13
13	void ucall_arch_get_ucall(struct kvm_vcpu vcpu)	14	void ucall_arch_get_ucall(struct kvm_vcpu vcpu)
14	{	15	{

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

@@ -1247,9 +1247,20 @@ unsigned long vm_compute_max_gfn(struct kvm_vm *vm) · 1246 unmodified lines
1247	{	1247	{
1248	const unsigned long num_ht_pages = 12 << (30 - vm->page_shift); /* 12 GiB */	1248	const unsigned long num_ht_pages = 12 << (30 - vm->page_shift); /* 12 GiB */
1249	unsigned long ht_gfn, max_gfn, max_pfn;	1249	unsigned long ht_gfn, max_gfn, max_pfn;
1250	uint8_t maxphyaddr;	1250	uint8_t maxphyaddr, guest_maxphyaddr;
1251		1251
1252	max_gfn = (1ULL << (vm->pa_bits - vm->page_shift)) - 1;	1252	/*
		1253	* Use "guest MAXPHYADDR" from KVM if it's available. Guest MAXPHYADDR
		1254	* enumerates the max _mappable_ GPA, which can be less than the raw
		1255	* MAXPHYADDR, e.g. if MAXPHYADDR=52, KVM is using TDP, and the CPU
		1256	* doesn't support 5-level TDP.
		1257	*/
		1258	guest_maxphyaddr = kvm_cpu_property(X86_PROPERTY_GUEST_MAX_PHY_ADDR);
		1259	guest_maxphyaddr = guest_maxphyaddr ?: vm->pa_bits;
		1260	TEST_ASSERT(guest_maxphyaddr <= vm->pa_bits,
		1261	"Guest MAXPHYADDR should never be greater than raw MAXPHYADDR");
		1262
		1263	max_gfn = (1ULL << (guest_maxphyaddr - vm->page_shift)) - 1;
1253		1264
1254	/* Avoid reserved HyperTransport region on AMD processors. */	1265	/* Avoid reserved HyperTransport region on AMD processors. */
1255	if (!host_cpu_is_amd)	1266	if (!host_cpu_is_amd)

tools/testing/selftests/kvm/riscv/ebreak_test.c+1−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	*	6	*
7	*/	7	*/
8	#include "kvm_util.h"	8	#include "kvm_util.h"
		9	#include "ucall_common.h"
9		10
10	#define LABEL_ADDRESS(v) ((uint64_t)&(v))	11	#define LABEL_ADDRESS(v) ((uint64_t)&(v))
11		12

tools/testing/selftests/kvm/riscv/sbi_pmu_test.c+1−0

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include "processor.h"	15	#include "processor.h"
16	#include "sbi.h"	16	#include "sbi.h"
17	#include "arch_timer.h"	17	#include "arch_timer.h"
		18	#include "ucall_common.h"
18		19
19	/* Maximum counters(firmware + hardware) */	20	/* Maximum counters(firmware + hardware) */
20	#define RISCV_MAX_PMU_COUNTERS 64	21	#define RISCV_MAX_PMU_COUNTERS 64

tools/testing/selftests/kvm/x86_64/sev_init2_tests.c+2−2

@@ -105,11 +105,11 @@ void test_features(uint32_t vm_type, uint64_t supported_features) · 104 unmodified lines
105	int i;	105	int i;
106		106
107	for (i = 0; i < 64; i++) {	107	for (i = 0; i < 64; i++) {
108	if (!(supported_features & (1u << i)))	108	if (!(supported_features & BIT_ULL(i)))
109	test_init2_invalid(vm_type,	109	test_init2_invalid(vm_type,
110	&(struct kvm_sev_init){ .vmsa_features = BIT_ULL(i) },	110	&(struct kvm_sev_init){ .vmsa_features = BIT_ULL(i) },
111	"unknown feature");	111	"unknown feature");
112	else if (KNOWN_FEATURES & (1u << i))	112	else if (KNOWN_FEATURES & BIT_ULL(i))
113	test_init2(vm_type,	113	test_init2(vm_type,
114	&(struct kvm_sev_init){ .vmsa_features = BIT_ULL(i) });	114	&(struct kvm_sev_init){ .vmsa_features = BIT_ULL(i) });
115	}	115	}

tools/testing/selftests/mm/map_fixed_noreplace.c+16−8

 		dump_maps();
 		ksft_exit_fail_msg("Error: munmap failed!?\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() 5*PAGE_SIZE at base\n");
 	addr = base_addr + page_size;
 	size = 3 * page_size;
 		dump_maps();
 		ksft_exit_fail_msg("Error: first mmap() failed unexpectedly\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() 3*PAGE_SIZE at base+PAGE_SIZE\n");
 	/*
 	 * Exact same mapping again:
 		dump_maps();
 		ksft_exit_fail_msg("Error:1: mmap() succeeded when it shouldn't have\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() 5*PAGE_SIZE at base\n");
 	/*
 	 * Second mapping contained within first:
 		dump_maps();
 		ksft_exit_fail_msg("Error:2: mmap() succeeded when it shouldn't have\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() 2*PAGE_SIZE at base+PAGE_SIZE\n");
 	/*
 	 * Overlap end of existing mapping:
 		dump_maps();
 		ksft_exit_fail_msg("Error:3: mmap() succeeded when it shouldn't have\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() 2*PAGE_SIZE  at base+(3*PAGE_SIZE)\n");
 	/*
 	 * Overlap start of existing mapping:
 		dump_maps();
 		ksft_exit_fail_msg("Error:4: mmap() succeeded when it shouldn't have\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() 2*PAGE_SIZE bytes at base\n");
 	/*
 	 * Adjacent to start of existing mapping:
 		dump_maps();
 		ksft_exit_fail_msg("Error:5: mmap() failed when it shouldn't have\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() PAGE_SIZE at base\n");
 	/*
 	 * Adjacent to end of existing mapping:
 		dump_maps();
 		ksft_exit_fail_msg("Error:6: mmap() failed when it shouldn't have\n");
 	}
-	ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_print_msg("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);
+	ksft_test_result_pass("mmap() PAGE_SIZE at base+(4*PAGE_SIZE)\n");
 	addr = base_addr;
 	size = 5 * page_size;

tools/testing/selftests/net/Makefile+2−0

 TEST_PROGS += srv6_end_next_csid_l3vpn_test.sh
 TEST_PROGS += srv6_end_x_next_csid_l3vpn_test.sh
 TEST_PROGS += srv6_end_flavors_test.sh
+TEST_PROGS += srv6_end_dx4_netfilter_test.sh
+TEST_PROGS += srv6_end_dx6_netfilter_test.sh
 TEST_PROGS += vrf_strict_mode_test.sh
 TEST_PROGS += arp_ndisc_evict_nocarrier.sh
 TEST_PROGS += ndisc_unsolicited_na_test.sh

tools/testing/selftests/net/config+2−0

@@ -101,3 +101,5 @@ CONFIG_NETFILTER_XT_MATCH_POLICY=m · 100 unmodified lines
101	CONFIG_CRYPTO_ARIA=y	101	CONFIG_CRYPTO_ARIA=y
102	CONFIG_XFRM_INTERFACE=m	102	CONFIG_XFRM_INTERFACE=m
103	CONFIG_XFRM_USER=m	103	CONFIG_XFRM_USER=m
		104	CONFIG_IP_NF_MATCH_RPFILTER=m
		105	CONFIG_IP6_NF_MATCH_RPFILTER=m

tools/testing/selftests/net/mptcp/userspace_pm.sh+28−18

 	local is_v6=$1
 	local app_port=$app4_port
 	local connect_addr="10.0.1.1"
+	local client_addr="10.0.1.2"
 	local listen_addr="0.0.0.0"
 	if [ "$is_v6" = "v6" ]
 	then
 		connect_addr="dead:beef:1::1"
+		client_addr="dead:beef:1::2"
 		listen_addr="::"
 		app_port=$app6_port
 	else
 		   [ "$server_serverside" = 1 ]
 	then
 		test_pass
+		print_title "Connection info: ${client_addr}:${client_port} -> ${connect_addr}:${app_port}"
 	else
 		test_fail "Expected tokens (c:${client_token} - s:${server_token}) and server (c:${client_serverside} - s:${server_serverside})"
 		mptcp_lib_result_print_all_tap
 	ip netns exec "$ns2"\
 	   ./pm_nl_ctl ann 10.0.2.2 token "$client4_token" id $client_addr_id dev\
 	   ns2eth1
-	print_test "ADD_ADDR id:${client_addr_id} 10.0.2.2 (ns2) => ns1, reuse port"
+	print_test "ADD_ADDR id:client 10.0.2.2 (ns2) => ns1, reuse port"
 	sleep 0.5
 	verify_announce_event $server_evts $ANNOUNCED $server4_token "10.0.2.2" $client_addr_id \
 			      "$client4_port"
 	:>"$server_evts"
 	ip netns exec "$ns2" ./pm_nl_ctl ann\
 	   dead:beef:2::2 token "$client6_token" id $client_addr_id dev ns2eth1
-	print_test "ADD_ADDR6 id:${client_addr_id} dead:beef:2::2 (ns2) => ns1, reuse port"
+	print_test "ADD_ADDR6 id:client dead:beef:2::2 (ns2) => ns1, reuse port"
 	sleep 0.5
 	verify_announce_event "$server_evts" "$ANNOUNCED" "$server6_token" "dead:beef:2::2"\
 			      "$client_addr_id" "$client6_port" "v6"
 	client_addr_id=$((client_addr_id+1))
 	ip netns exec "$ns2" ./pm_nl_ctl ann 10.0.2.2 token "$client4_token" id\
 	   $client_addr_id dev ns2eth1 port $new4_port
-	print_test "ADD_ADDR id:${client_addr_id} 10.0.2.2 (ns2) => ns1, new port"
+	print_test "ADD_ADDR id:client+1 10.0.2.2 (ns2) => ns1, new port"
 	sleep 0.5
 	verify_announce_event "$server_evts" "$ANNOUNCED" "$server4_token" "10.0.2.2"\
 			      "$client_addr_id" "$new4_port"
 	# ADD_ADDR from the server to client machine reusing the subflow port
 	ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server4_token" id\
 	   $server_addr_id dev ns1eth2
-	print_test "ADD_ADDR id:${server_addr_id} 10.0.2.1 (ns1) => ns2, reuse port"
+	print_test "ADD_ADDR id:server 10.0.2.1 (ns1) => ns2, reuse port"
 	sleep 0.5
 	verify_announce_event "$client_evts" "$ANNOUNCED" "$client4_token" "10.0.2.1"\
 			      "$server_addr_id" "$app4_port"
 	:>"$client_evts"
 	ip netns exec "$ns1" ./pm_nl_ctl ann dead:beef:2::1 token "$server6_token" id\
 	   $server_addr_id dev ns1eth2
-	print_test "ADD_ADDR6 id:${server_addr_id} dead:beef:2::1 (ns1) => ns2, reuse port"
+	print_test "ADD_ADDR6 id:server dead:beef:2::1 (ns1) => ns2, reuse port"
 	sleep 0.5
 	verify_announce_event "$client_evts" "$ANNOUNCED" "$client6_token" "dead:beef:2::1"\
 			      "$server_addr_id" "$app6_port" "v6"
 	server_addr_id=$((server_addr_id+1))
 	ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server4_token" id\
 	   $server_addr_id dev ns1eth2 port $new4_port
-	print_test "ADD_ADDR id:${server_addr_id} 10.0.2.1 (ns1) => ns2, new port"
+	print_test "ADD_ADDR id:server+1 10.0.2.1 (ns1) => ns2, new port"
 	sleep 0.5
 	verify_announce_event "$client_evts" "$ANNOUNCED" "$client4_token" "10.0.2.1"\
 			      "$server_addr_id" "$new4_port"
 	local invalid_token=$(( client4_token - 1 ))
 	ip netns exec "$ns2" ./pm_nl_ctl rem token $invalid_token id\
 	   $client_addr_id > /dev/null 2>&1
-	print_test "RM_ADDR id:${client_addr_id} ns2 => ns1, invalid token"
+	print_test "RM_ADDR id:client ns2 => ns1, invalid token"
 	local type
 	type=$(mptcp_lib_evts_get_info type "$server_evts")
 	if [ "$type" = "" ]
 	local invalid_id=$(( client_addr_id + 1 ))
 	ip netns exec "$ns2" ./pm_nl_ctl rem token "$client4_token" id\
 	   $invalid_id > /dev/null 2>&1
-	print_test "RM_ADDR id:${invalid_id} ns2 => ns1, invalid id"
+	print_test "RM_ADDR id:client+1 ns2 => ns1, invalid id"
 	type=$(mptcp_lib_evts_get_info type "$server_evts")
 	if [ "$type" = "" ]
 	then
 	:>"$server_evts"
 	ip netns exec "$ns2" ./pm_nl_ctl rem token "$client4_token" id\
 	   $client_addr_id
-	print_test "RM_ADDR id:${client_addr_id} ns2 => ns1"
+	print_test "RM_ADDR id:client ns2 => ns1"
 	sleep 0.5
 	verify_remove_event "$server_evts" "$REMOVED" "$server4_token" "$client_addr_id"
 	client_addr_id=$(( client_addr_id - 1 ))
 	ip netns exec "$ns2" ./pm_nl_ctl rem token "$client4_token" id\
 	   $client_addr_id
-	print_test "RM_ADDR id:${client_addr_id} ns2 => ns1"
+	print_test "RM_ADDR id:client-1 ns2 => ns1"
 	sleep 0.5
 	verify_remove_event "$server_evts" "$REMOVED" "$server4_token" "$client_addr_id"
 	:>"$server_evts"
 	ip netns exec "$ns2" ./pm_nl_ctl rem token "$client6_token" id\
 	   $client_addr_id
-	print_test "RM_ADDR6 id:${client_addr_id} ns2 => ns1"
+	print_test "RM_ADDR6 id:client-1 ns2 => ns1"
 	sleep 0.5
 	verify_remove_event "$server_evts" "$REMOVED" "$server6_token" "$client_addr_id"
 	# RM_ADDR from the server to client machine
 	ip netns exec "$ns1" ./pm_nl_ctl rem token "$server4_token" id\
 	   $server_addr_id
-	print_test "RM_ADDR id:${server_addr_id} ns1 => ns2"
+	print_test "RM_ADDR id:server ns1 => ns2"
 	sleep 0.5
 	verify_remove_event "$client_evts" "$REMOVED" "$client4_token" "$server_addr_id"
 	server_addr_id=$(( server_addr_id - 1 ))
 	ip netns exec "$ns1" ./pm_nl_ctl rem token "$server4_token" id\
 	   $server_addr_id
-	print_test "RM_ADDR id:${server_addr_id} ns1 => ns2"
+	print_test "RM_ADDR id:server-1 ns1 => ns2"
 	sleep 0.5
 	verify_remove_event "$client_evts" "$REMOVED" "$client4_token" "$server_addr_id"
 	:>"$client_evts"
 	ip netns exec "$ns1" ./pm_nl_ctl rem token "$server6_token" id\
 	   $server_addr_id
-	print_test "RM_ADDR6 id:${server_addr_id} ns1 => ns2"
+	print_test "RM_ADDR6 id:server-1 ns1 => ns2"
 	sleep 0.5
 	verify_remove_event "$client_evts" "$REMOVED" "$client6_token" "$server_addr_id"
 }
 	local locid
 	local remid
 	local info
+	local e_dport_txt
-	info="${e_saddr} (${e_from}) => ${e_daddr}:${e_dport} (${e_to})"
+	# only display the fixed ports
+	if [ "${e_dport}" -ge "${app4_port}" ] && [ "${e_dport}" -le "${app6_port}" ]; then
+		e_dport_txt=":${e_dport}"
+	fi
+	info="${e_saddr} (${e_from}) => ${e_daddr}${e_dport_txt} (${e_to})"
 	if [ "$e_type" = "$SUB_ESTABLISHED" ]
 	then
 	:>"$client_evts"
 	ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server6_token" id\
 	   $server_addr_id dev ns1eth2
-	print_test "ADD_ADDR4 id:${server_addr_id} 10.0.2.1 (ns1) => ns2, reuse port"
+	print_test "ADD_ADDR4 id:server 10.0.2.1 (ns1) => ns2, reuse port"
 	sleep 0.5
 	verify_announce_event "$client_evts" "$ANNOUNCED" "$client6_token" "10.0.2.1"\
 			      "$server_addr_id" "$app6_port"
 	local listener_pid=$!
 	sleep 0.5
-	print_test "CREATE_LISTENER 10.0.2.2:$client4_port"
+	print_test "CREATE_LISTENER 10.0.2.2 (client port)"
 	verify_listener_events $client_evts $LISTENER_CREATED $AF_INET 10.0.2.2 $client4_port
 	# ADD_ADDR from client to server machine reusing the subflow port
 	mptcp_lib_kill_wait $listener_pid
 	sleep 0.5
-	print_test "CLOSE_LISTENER 10.0.2.2:$client4_port"
+	print_test "CLOSE_LISTENER 10.0.2.2 (client port)"
 	verify_listener_events $client_evts $LISTENER_CLOSED $AF_INET 10.0.2.2 $client4_port
 }
 print_title "Make connections"
 make_connection
 make_connection "v6"
+print_title "Will be using address IDs ${client_addr_id} (client) and ${server_addr_id} (server)"
 test_announce
 test_remove

tools/testing/selftests/net/openvswitch/openvswitch.sh+1−1

@@ -1,4 +1,4 @@
1	#!/bin/sh	1	#!/bin/bash
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3	#	3	#
4	# OVS kernel module self tests	4	# OVS kernel module self tests

tools/testing/selftests/net/openvswitch/ovs-dpctl.py+1−1

@@ -531,7 +531,7 @@ class ovsactions(nla): · 530 unmodified lines
531	for flat_act in parse_flat_map:	531	for flat_act in parse_flat_map:
532	if parse_starts_block(actstr, flat_act[0], False):	532	if parse_starts_block(actstr, flat_act[0], False):
533	actstr = actstr[len(flat_act[0]):]	533	actstr = actstr[len(flat_act[0]):]
534	self["attrs"].append([flat_act[1]])	534	self["attrs"].append([flat_act[1], True])
535	actstr = actstr[strspn(actstr, ", ") :]	535	actstr = actstr[strspn(actstr, ", ") :]
536	parsed = True	536	parsed = True
537		537

tools/testing/selftests/net/srv6_end_dx4_netfilter_test.sh+335−0

@@ -0,0 +1,335 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3	#
	4	# author: Jianguo Wu <wujianguo@chinatelecom.cn>
	5	#
	6	# Mostly copied from tools/testing/selftests/net/srv6_end_dt4_l3vpn_test.sh.
	7	#
	8	# This script is designed for testing the support of netfilter hooks for
	9	# SRv6 End.DX4 behavior.
	10	#
	11	# Hereafter a network diagram is shown, where one tenants (named 100) offer
	12	# IPv4 L3 VPN services allowing hosts to communicate with each other across
	13	# an IPv6 network.
	14	#
	15	# Routers rt-1 and rt-2 implement IPv4 L3 VPN services leveraging the SRv6
	16	# architecture. The key components for such VPNs are: a) SRv6 Encap behavior,
	17	# b) SRv6 End.DX4 behavior.
	18	#
	19	# To explain how an IPv4 L3 VPN based on SRv6 works, let us briefly consider an
	20	# example where, within the same domain of tenant 100, the host hs-1 pings
	21	# the host hs-2.
	22	#
	23	# First of all, L2 reachability of the host hs-2 is taken into account by
	24	# the router rt-1 which acts as an arp proxy.
	25	#
	26	# When the host hs-1 sends an IPv4 packet destined to hs-2, the router rt-1
	27	# receives the packet on the internal veth-t100 interface, rt-1 contains the
	28	# SRv6 Encap route for encapsulating the IPv4 packet in a IPv6 plus the Segment
	29	# Routing Header (SRH) packet. This packet is sent through the (IPv6) core
	30	# network up to the router rt-2 that receives it on veth0 interface.
	31	#
	32	# The rt-2 router uses the 'localsid' routing table to process incoming
	33	# IPv6+SRH packets which belong to the VPN of the tenant 100. For each of these
	34	# packets, the SRv6 End.DX4 behavior removes the outer IPv6+SRH headers and
	35	# routs the packet to the specified nexthop. Afterwards, the packet is sent to
	36	# the host hs-2 through the veth-t100 interface.
	37	#
	38	# The ping response follows the same processing but this time the role of rt-1
	39	# and rt-2 are swapped.
	40	#
	41	# And when net.netfilter.nf_hooks_lwtunnel is set to 1 in rt-1 or rt-2, and a
	42	# rpfilter iptables rule is added, SRv6 packets will go through netfilter PREROUTING
	43	# hooks.
	44	#
	45	#
	46	# +-------------------+ +-------------------+
	47	# \| \| \| \|
	48	# \| hs-1 netns \| \| hs-2 netns \|
	49	# \| \| \| \|
	50	# \| +-------------+ \| \| +-------------+ \|
	51	# \| \| veth0 \| \| \| \| veth0 \| \|
	52	# \| \| 10.0.0.1/24 \| \| \| \| 10.0.0.2/24 \| \|
	53	# \| +-------------+ \| \| +-------------+ \|
	54	# \| . \| \| . \|
	55	# +-------------------+ +-------------------+
	56	# . .
	57	# . .
	58	# . .
	59	# +-----------------------------------+ +-----------------------------------+
	60	# \| . \| \| . \|
	61	# \| +---------------+ \| \| +---------------- \|
	62	# \| \| veth-t100 \| \| \| \| veth-t100 \| \|
	63	# \| \| 10.0.0.11/24 \| +----------+ \| \| +----------+ \| 10.0.0.22/24 \| \|
	64	# \| +-------+-------+ \| route \| \| \| \| route \| +-------+-------- \|
	65	# \| \| table \| \| \| \| table \| \|
	66	# \| +----------+ \| \| +----------+ \|
	67	# \| +--------------+ \| \| +--------------+ \|
	68	# \| \| veth0 \| \| \| \| veth0 \| \|
	69	# \| \| 2001:11::1/64 \|.\|...\|.\| 2001:11::2/64 \| \|
	70	# \| +--------------+ \| \| +--------------+ \|
	71	# \| \| \| \|
	72	# \| rt-1 netns \| \| rt-2 netns \|
	73	# \| \| \| \|
	74	# +-----------------------------------+ +-----------------------------------+
	75	#
	76	# ~~~~~~~~~~~~~~~~~~~~~~~~~
	77	# \| Network configuration \|
	78	# ~~~~~~~~~~~~~~~~~~~~~~~~~
	79	#
	80	# rt-1: localsid table
	81	# +----------------------------------------------------------------+
	82	# \|SID \|Action \|
	83	# +----------------------------------------------------------------+
	84	# \|fc00:21:100::6004\|apply SRv6 End.DX4 nh4 10.0.0.1 dev veth-t100 \|
	85	# +----------------------------------------------------------------+
	86	#
	87	# rt-1: route table
	88	# +---------------------------------------------------+
	89	# \|host \|Action \|
	90	# +---------------------------------------------------+
	91	# \|10.0.0.2 \|apply seg6 encap segs fc00:12:100::6004\|
	92	# +---------------------------------------------------+
	93	# \|10.0.0.0/24\|forward to dev veth_t100 \|
	94	# +---------------------------------------------------+
	95	#
	96	#
	97	# rt-2: localsid table
	98	# +---------------------------------------------------------------+
	99	# \|SID \|Action \|
	100	# +---------------------------------------------------------------+
	101	# \|fc00:12:100::6004\|apply SRv6 End.DX4 nh4 10.0.0.2 dev veth-t100\|
	102	# +---------------------------------------------------------------+
	103	#
	104	# rt-2: route table
	105	# +---------------------------------------------------+
	106	# \|host \|Action \|
	107	# +---------------------------------------------------+
	108	# \|10.0.0.1 \|apply seg6 encap segs fc00:21:100::6004\|
	109	# +---------------------------------------------------+
	110	# \|10.0.0.0/24\|forward to dev veth_t100 \|
	111	# +---------------------------------------------------+
	112	#
	113
	114	# Kselftest framework requirement - SKIP code is 4.
	115	ksft_skip=4
	116
	117	readonly IPv6_RT_NETWORK=2001:11
	118	readonly IPv4_HS_NETWORK=10.0.0
	119	readonly SID_LOCATOR=fc00
	120
	121	PING_TIMEOUT_SEC=4
	122
	123	ret=0
	124
	125	PAUSE_ON_FAIL=${PAUSE_ON_FAIL:=no}
	126
	127	log_test()
	128	{
	129	local rc=$1
	130	local expected=$2
	131	local msg="$3"
	132
	133	if [ ${rc} -eq ${expected} ]; then
	134	nsuccess=$((nsuccess+1))
	135	printf "\n TEST: %-60s [ OK ]\n" "${msg}"
	136	else
	137	ret=1
	138	nfail=$((nfail+1))
	139	printf "\n TEST: %-60s [FAIL]\n" "${msg}"
	140	if [ "${PAUSE_ON_FAIL}" = "yes" ]; then
	141	echo
	142	echo "hit enter to continue, 'q' to quit"
	143	read a
	144	[ "$a" = "q" ] && exit 1
	145	fi
	146	fi
	147	}
	148
	149	print_log_test_results()
	150	{
	151	if [ "$TESTS" != "none" ]; then
	152	printf "\nTests passed: %3d\n" ${nsuccess}
	153	printf "Tests failed: %3d\n" ${nfail}
	154	fi
	155	}
	156
	157	log_section()
	158	{
	159	echo
	160	echo "################################################################################"
	161	echo "TEST SECTION: $*"
	162	echo "################################################################################"
	163	}
	164
	165	cleanup()
	166	{
	167	ip link del veth-rt-1 2>/dev/null \|\| true
	168	ip link del veth-rt-2 2>/dev/null \|\| true
	169
	170	# destroy routers rt-* and hosts hs-*
	171	for ns in $(ip netns show \| grep -E 'rt-\|hs-'); do
	172	ip netns del ${ns} \|\| true
	173	done
	174	}
	175
	176	# Setup the basic networking for the routers
	177	setup_rt_networking()
	178	{
	179	local rt=$1
	180	local nsname=rt-${rt}
	181
	182	ip netns add ${nsname}
	183
	184	ip netns exec ${nsname} sysctl -wq net.ipv6.conf.all.accept_dad=0
	185	ip netns exec ${nsname} sysctl -wq net.ipv6.conf.default.accept_dad=0
	186
	187	ip link set veth-rt-${rt} netns ${nsname}
	188	ip -netns ${nsname} link set veth-rt-${rt} name veth0
	189
	190	ip -netns ${nsname} addr add ${IPv6_RT_NETWORK}::${rt}/64 dev veth0 nodad
	191	ip -netns ${nsname} link set veth0 up
	192	ip -netns ${nsname} link set lo up
	193
	194	ip netns exec ${nsname} sysctl -wq net.ipv4.ip_forward=1
	195	ip netns exec ${nsname} sysctl -wq net.ipv6.conf.all.forwarding=1
	196	}
	197
	198	setup_rt_netfilter()
	199	{
	200	local rt=$1
	201	local nsname=rt-${rt}
	202
	203	ip netns exec ${nsname} sysctl -wq net.netfilter.nf_hooks_lwtunnel=1
	204	ip netns exec ${nsname} iptables -t raw -A PREROUTING -m rpfilter --invert -j DROP
	205	}
	206
	207	setup_hs()
	208	{
	209	local hs=$1
	210	local rt=$2
	211	local tid=$3
	212	local hsname=hs-${hs}
	213	local rtname=rt-${rt}
	214	local rtveth=veth-t${tid}
	215
	216	# set the networking for the host
	217	ip netns add ${hsname}
	218
	219	ip -netns ${hsname} link add veth0 type veth peer name ${rtveth}
	220	ip -netns ${hsname} link set ${rtveth} netns ${rtname}
	221	ip -netns ${hsname} addr add ${IPv4_HS_NETWORK}.${hs}/24 dev veth0
	222	ip -netns ${hsname} link set veth0 up
	223	ip -netns ${hsname} link set lo up
	224
	225	ip -netns ${rtname} addr add ${IPv4_HS_NETWORK}.${rt}${hs}/24 dev ${rtveth}
	226	ip -netns ${rtname} link set ${rtveth} up
	227
	228	ip netns exec ${rtname} sysctl -wq net.ipv4.conf.${rtveth}.proxy_arp=1
	229	}
	230
	231	setup_vpn_config()
	232	{
	233	local hssrc=$1
	234	local rtsrc=$2
	235	local hsdst=$3
	236	local rtdst=$4
	237	local tid=$5
	238
	239	local hssrc_name=hs-t${tid}-${hssrc}
	240	local hsdst_name=hs-t${tid}-${hsdst}
	241	local rtsrc_name=rt-${rtsrc}
	242	local rtdst_name=rt-${rtdst}
	243	local vpn_sid=${SID_LOCATOR}:${hssrc}${hsdst}:${tid}::6004
	244
	245	# set the encap route for encapsulating packets which arrive from the
	246	# host hssrc and destined to the access router rtsrc.
	247	ip -netns ${rtsrc_name} -4 route add ${IPv4_HS_NETWORK}.${hsdst}/32 \
	248	encap seg6 mode encap segs ${vpn_sid} dev veth0
	249	ip -netns ${rtsrc_name} -6 route add ${vpn_sid}/128 \
	250	via 2001:11::${rtdst} dev veth0
	251
	252	# set the decap route for decapsulating packets which arrive from
	253	# the rtdst router and destined to the hsdst host.
	254	ip -netns ${rtdst_name} -6 route add ${vpn_sid}/128 \
	255	encap seg6local action End.DX4 nh4 ${IPv4_HS_NETWORK}.${hsdst} dev veth-t${tid}
	256	}
	257
	258	setup()
	259	{
	260	ip link add veth-rt-1 type veth peer name veth-rt-2
	261	# setup the networking for router rt-1 and router rt-2
	262	setup_rt_networking 1
	263	setup_rt_networking 2
	264
	265	# setup two hosts for the tenant 100.
	266	# - host hs-1 is directly connected to the router rt-1;
	267	# - host hs-2 is directly connected to the router rt-2.
	268	setup_hs 1 1 100
	269	setup_hs 2 2 100
	270
	271	# setup the IPv4 L3 VPN which connects the host hs-1 and host hs-2.
	272	setup_vpn_config 1 1 2 2 100 #args: src_host src_router dst_host dst_router tenant
	273	setup_vpn_config 2 2 1 1 100
	274	}
	275
	276	check_hs_connectivity()
	277	{
	278	local hssrc=$1
	279	local hsdst=$2
	280	local tid=$3
	281
	282	ip netns exec hs-${hssrc} ping -c 1 -W ${PING_TIMEOUT_SEC} \
	283	${IPv4_HS_NETWORK}.${hsdst} >/dev/null 2>&1
	284	}
	285
	286	check_and_log_hs_connectivity()
	287	{
	288	local hssrc=$1
	289	local hsdst=$2
	290	local tid=$3
	291
	292	check_hs_connectivity ${hssrc} ${hsdst} ${tid}
	293	log_test $? 0 "Hosts connectivity: hs-${hssrc} -> hs-${hsdst} (tenant ${tid})"
	294	}
	295
	296	host_tests()
	297	{
	298	log_section "SRv6 VPN connectivity test among hosts in the same tenant"
	299
	300	check_and_log_hs_connectivity 1 2 100
	301	check_and_log_hs_connectivity 2 1 100
	302	}
	303
	304	router_netfilter_tests()
	305	{
	306	log_section "SRv6 VPN connectivity test with netfilter enabled in routers"
	307	setup_rt_netfilter 1
	308	setup_rt_netfilter 2
	309
	310	check_and_log_hs_connectivity 1 2 100
	311	check_and_log_hs_connectivity 2 1 100
	312	}
	313
	314	if [ "$(id -u)" -ne 0 ];then
	315	echo "SKIP: Need root privileges"
	316	exit $ksft_skip
	317	fi
	318
	319	if [ ! -x "$(command -v ip)" ]; then
	320	echo "SKIP: Could not run test without ip tool"
	321	exit $ksft_skip
	322	fi
	323
	324	cleanup &>/dev/null
	325
	326	setup
	327
	328	host_tests
	329	router_netfilter_tests
	330
	331	print_log_test_results
	332
	333	cleanup &>/dev/null
	334
	335	exit ${ret}

tools/testing/selftests/net/srv6_end_dx6_netfilter_test.sh+340−0

@@ -0,0 +1,340 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3	#
	4	# author: Jianguo Wu <wujianguo@chinatelecom.cn>
	5	#
	6	# Mostly copied from tools/testing/selftests/net/srv6_end_dt6_l3vpn_test.sh.
	7	#
	8	# This script is designed for testing the support of netfilter hooks for
	9	# SRv6 End.DX4 behavior.
	10	#
	11	# Hereafter a network diagram is shown, where one tenants (named 100) offer
	12	# IPv6 L3 VPN services allowing hosts to communicate with each other across
	13	# an IPv6 network.
	14	#
	15	# Routers rt-1 and rt-2 implement IPv6 L3 VPN services leveraging the SRv6
	16	# architecture. The key components for such VPNs are: a) SRv6 Encap behavior,
	17	# b) SRv6 End.DX4 behavior.
	18	#
	19	# To explain how an IPv6 L3 VPN based on SRv6 works, let us briefly consider an
	20	# example where, within the same domain of tenant 100, the host hs-1 pings
	21	# the host hs-2.
	22	#
	23	# First of all, L2 reachability of the host hs-2 is taken into account by
	24	# the router rt-1 which acts as an arp proxy.
	25	#
	26	# When the host hs-1 sends an IPv6 packet destined to hs-2, the router rt-1
	27	# receives the packet on the internal veth-t100 interface, rt-1 contains the
	28	# SRv6 Encap route for encapsulating the IPv6 packet in a IPv6 plus the Segment
	29	# Routing Header (SRH) packet. This packet is sent through the (IPv6) core
	30	# network up to the router rt-2 that receives it on veth0 interface.
	31	#
	32	# The rt-2 router uses the 'localsid' routing table to process incoming
	33	# IPv6+SRH packets which belong to the VPN of the tenant 100. For each of these
	34	# packets, the SRv6 End.DX4 behavior removes the outer IPv6+SRH headers and
	35	# routs the packet to the specified nexthop. Afterwards, the packet is sent to
	36	# the host hs-2 through the veth-t100 interface.
	37	#
	38	# The ping response follows the same processing but this time the role of rt-1
	39	# and rt-2 are swapped.
	40	#
	41	# And when net.netfilter.nf_hooks_lwtunnel is set to 1 in rt-1 or rt-2, and a
	42	# rpfilter iptables rule is added, SRv6 packets will go through netfilter PREROUTING
	43	# hooks.
	44	#
	45	#
	46	# +-------------------+ +-------------------+
	47	# \| \| \| \|
	48	# \| hs-1 netns \| \| hs-2 netns \|
	49	# \| \| \| \|
	50	# \| +-------------+ \| \| +-------------+ \|
	51	# \| \| veth0 \| \| \| \| veth0 \| \|
	52	# \| \| cafe::1/64 \| \| \| \| cafe::2/64 \| \|
	53	# \| +-------------+ \| \| +-------------+ \|
	54	# \| . \| \| . \|
	55	# +-------------------+ +-------------------+
	56	# . .
	57	# . .
	58	# . .
	59	# +-----------------------------------+ +-----------------------------------+
	60	# \| . \| \| . \|
	61	# \| +---------------+ \| \| +---------------- \|
	62	# \| \| veth-t100 \| \| \| \| veth-t100 \| \|
	63	# \| \| cafe::11/64 \| +----------+ \| \| +----------+ \| cafe::22/64 \| \|
	64	# \| +-------+-------+ \| route \| \| \| \| route \| +-------+-------- \|
	65	# \| \| table \| \| \| \| table \| \|
	66	# \| +----------+ \| \| +----------+ \|
	67	# \| +--------------+ \| \| +--------------+ \|
	68	# \| \| veth0 \| \| \| \| veth0 \| \|
	69	# \| \| 2001:11::1/64 \|.\|...\|.\| 2001:11::2/64 \| \|
	70	# \| +--------------+ \| \| +--------------+ \|
	71	# \| \| \| \|
	72	# \| rt-1 netns \| \| rt-2 netns \|
	73	# \| \| \| \|
	74	# +-----------------------------------+ +-----------------------------------+
	75	#
	76	# ~~~~~~~~~~~~~~~~~~~~~~~~~
	77	# \| Network configuration \|
	78	# ~~~~~~~~~~~~~~~~~~~~~~~~~
	79	#
	80	# rt-1: localsid table
	81	# +----------------------------------------------------------------+
	82	# \|SID \|Action \|
	83	# +----------------------------------------------------------------+
	84	# \|fc00:21:100::6004\|apply SRv6 End.DX6 nh6 cafe::1 dev veth-t100 \|
	85	# +----------------------------------------------------------------+
	86	#
	87	# rt-1: route table
	88	# +---------------------------------------------------+
	89	# \|host \|Action \|
	90	# +---------------------------------------------------+
	91	# \|cafe::2 \|apply seg6 encap segs fc00:12:100::6004\|
	92	# +---------------------------------------------------+
	93	# \|cafe::/64 \|forward to dev veth_t100 \|
	94	# +---------------------------------------------------+
	95	#
	96	#
	97	# rt-2: localsid table
	98	# +---------------------------------------------------------------+
	99	# \|SID \|Action \|
	100	# +---------------------------------------------------------------+
	101	# \|fc00:12:100::6004\|apply SRv6 End.DX6 nh6 cafe::2 dev veth-t100 \|
	102	# +---------------------------------------------------------------+
	103	#
	104	# rt-2: route table
	105	# +---------------------------------------------------+
	106	# \|host \|Action \|
	107	# +---------------------------------------------------+
	108	# \|cafe::1 \|apply seg6 encap segs fc00:21:100::6004\|
	109	# +---------------------------------------------------+
	110	# \|cafe::/64 \|forward to dev veth_t100 \|
	111	# +---------------------------------------------------+
	112	#
	113
	114	# Kselftest framework requirement - SKIP code is 4.
	115	ksft_skip=4
	116
	117	readonly IPv6_RT_NETWORK=2001:11
	118	readonly IPv6_HS_NETWORK=cafe
	119	readonly SID_LOCATOR=fc00
	120
	121	PING_TIMEOUT_SEC=4
	122
	123	ret=0
	124
	125	PAUSE_ON_FAIL=${PAUSE_ON_FAIL:=no}
	126
	127	log_test()
	128	{
	129	local rc=$1
	130	local expected=$2
	131	local msg="$3"
	132
	133	if [ ${rc} -eq ${expected} ]; then
	134	nsuccess=$((nsuccess+1))
	135	printf "\n TEST: %-60s [ OK ]\n" "${msg}"
	136	else
	137	ret=1
	138	nfail=$((nfail+1))
	139	printf "\n TEST: %-60s [FAIL]\n" "${msg}"
	140	if [ "${PAUSE_ON_FAIL}" = "yes" ]; then
	141	echo
	142	echo "hit enter to continue, 'q' to quit"
	143	read a
	144	[ "$a" = "q" ] && exit 1
	145	fi
	146	fi
	147	}
	148
	149	print_log_test_results()
	150	{
	151	if [ "$TESTS" != "none" ]; then
	152	printf "\nTests passed: %3d\n" ${nsuccess}
	153	printf "Tests failed: %3d\n" ${nfail}
	154	fi
	155	}
	156
	157	log_section()
	158	{
	159	echo
	160	echo "################################################################################"
	161	echo "TEST SECTION: $*"
	162	echo "################################################################################"
	163	}
	164
	165	cleanup()
	166	{
	167	ip link del veth-rt-1 2>/dev/null \|\| true
	168	ip link del veth-rt-2 2>/dev/null \|\| true
	169
	170	# destroy routers rt-* and hosts hs-*
	171	for ns in $(ip netns show \| grep -E 'rt-\|hs-'); do
	172	ip netns del ${ns} \|\| true
	173	done
	174	}
	175
	176	# Setup the basic networking for the routers
	177	setup_rt_networking()
	178	{
	179	local rt=$1
	180	local nsname=rt-${rt}
	181
	182	ip netns add ${nsname}
	183
	184	ip netns exec ${nsname} sysctl -wq net.ipv6.conf.all.accept_dad=0
	185	ip netns exec ${nsname} sysctl -wq net.ipv6.conf.default.accept_dad=0
	186
	187	ip link set veth-rt-${rt} netns ${nsname}
	188	ip -netns ${nsname} link set veth-rt-${rt} name veth0
	189
	190	ip -netns ${nsname} addr add ${IPv6_RT_NETWORK}::${rt}/64 dev veth0 nodad
	191	ip -netns ${nsname} link set veth0 up
	192	ip -netns ${nsname} link set lo up
	193
	194	ip netns exec ${nsname} sysctl -wq net.ipv6.conf.all.forwarding=1
	195	}
	196
	197	setup_rt_netfilter()
	198	{
	199	local rt=$1
	200	local nsname=rt-${rt}
	201
	202	ip netns exec ${nsname} sysctl -wq net.netfilter.nf_hooks_lwtunnel=1
	203	ip netns exec ${nsname} ip6tables -t raw -A PREROUTING -m rpfilter --invert -j DROP
	204	}
	205
	206	setup_hs()
	207	{
	208	local hs=$1
	209	local rt=$2
	210	local tid=$3
	211	local hsname=hs-${hs}
	212	local rtname=rt-${rt}
	213	local rtveth=veth-t${tid}
	214
	215	# set the networking for the host
	216	ip netns add ${hsname}
	217
	218	ip -netns ${hsname} link add veth0 type veth peer name ${rtveth}
	219	ip -netns ${hsname} link set ${rtveth} netns ${rtname}
	220	ip -netns ${hsname} addr add ${IPv6_HS_NETWORK}::${hs}/64 dev veth0 nodad
	221	ip -netns ${hsname} link set veth0 up
	222	ip -netns ${hsname} link set lo up
	223
	224	ip -netns ${rtname} addr add ${IPv6_HS_NETWORK}::${rt}${hs}/64 dev ${rtveth}
	225	ip -netns ${rtname} link set ${rtveth} up
	226
	227	ip netns exec ${rtname} sysctl -wq net.ipv6.conf.all.accept_dad=0
	228	ip netns exec ${rtname} sysctl -wq net.ipv6.conf.default.accept_dad=0
	229
	230	ip netns exec ${rtname} sysctl -wq net.ipv6.conf.${rtveth}.proxy_ndp=1
	231	}
	232
	233	setup_vpn_config()
	234	{
	235	local hssrc=$1
	236	local rtsrc=$2
	237	local hsdst=$3
	238	local rtdst=$4
	239	local tid=$5
	240
	241	local hssrc_name=hs-t${tid}-${hssrc}
	242	local hsdst_name=hs-t${tid}-${hsdst}
	243	local rtsrc_name=rt-${rtsrc}
	244	local rtdst_name=rt-${rtdst}
	245	local rtveth=veth-t${tid}
	246	local vpn_sid=${SID_LOCATOR}:${hssrc}${hsdst}:${tid}::6004
	247
	248	ip -netns ${rtsrc_name} -6 neigh add proxy ${IPv6_HS_NETWORK}::${hsdst} dev ${rtveth}
	249
	250	# set the encap route for encapsulating packets which arrive from the
	251	# host hssrc and destined to the access router rtsrc.
	252	ip -netns ${rtsrc_name} -6 route add ${IPv6_HS_NETWORK}::${hsdst}/128 \
	253	encap seg6 mode encap segs ${vpn_sid} dev veth0
	254	ip -netns ${rtsrc_name} -6 route add ${vpn_sid}/128 \
	255	via 2001:11::${rtdst} dev veth0
	256
	257	# set the decap route for decapsulating packets which arrive from
	258	# the rtdst router and destined to the hsdst host.
	259	ip -netns ${rtdst_name} -6 route add ${vpn_sid}/128 \
	260	encap seg6local action End.DX6 nh6 ${IPv6_HS_NETWORK}::${hsdst} dev veth-t${tid}
	261	}
	262
	263	setup()
	264	{
	265	ip link add veth-rt-1 type veth peer name veth-rt-2
	266	# setup the networking for router rt-1 and router rt-2
	267	setup_rt_networking 1
	268	setup_rt_networking 2
	269
	270	# setup two hosts for the tenant 100.
	271	# - host hs-1 is directly connected to the router rt-1;
	272	# - host hs-2 is directly connected to the router rt-2.
	273	setup_hs 1 1 100
	274	setup_hs 2 2 100
	275
	276	# setup the IPv4 L3 VPN which connects the host hs-1 and host hs-2.
	277	setup_vpn_config 1 1 2 2 100 #args: src_host src_router dst_host dst_router tenant
	278	setup_vpn_config 2 2 1 1 100
	279	}
	280
	281	check_hs_connectivity()
	282	{
	283	local hssrc=$1
	284	local hsdst=$2
	285	local tid=$3
	286
	287	ip netns exec hs-${hssrc} ping -6 -c 1 -W ${PING_TIMEOUT_SEC} \
	288	${IPv6_HS_NETWORK}::${hsdst} >/dev/null 2>&1
	289	}
	290
	291	check_and_log_hs_connectivity()
	292	{
	293	local hssrc=$1
	294	local hsdst=$2
	295	local tid=$3
	296
	297	check_hs_connectivity ${hssrc} ${hsdst} ${tid}
	298	log_test $? 0 "Hosts connectivity: hs-${hssrc} -> hs-${hsdst} (tenant ${tid})"
	299	}
	300
	301	host_tests()
	302	{
	303	log_section "SRv6 VPN connectivity test among hosts in the same tenant"
	304
	305	check_and_log_hs_connectivity 1 2 100
	306	check_and_log_hs_connectivity 2 1 100
	307	}
	308
	309	router_netfilter_tests()
	310	{
	311	log_section "SRv6 VPN connectivity test with netfilter enabled in routers"
	312	setup_rt_netfilter 1
	313	setup_rt_netfilter 2
	314
	315	check_and_log_hs_connectivity 1 2 100
	316	check_and_log_hs_connectivity 2 1 100
	317	}
	318
	319	if [ "$(id -u)" -ne 0 ];then
	320	echo "SKIP: Need root privileges"
	321	exit $ksft_skip
	322	fi
	323
	324	if [ ! -x "$(command -v ip)" ]; then
	325	echo "SKIP: Could not run test without ip tool"
	326	exit $ksft_skip
	327	fi
	328
	329	cleanup &>/dev/null
	330
	331	setup
	332
	333	host_tests
	334	router_netfilter_tests
	335
	336	print_log_test_results
	337
	338	cleanup &>/dev/null
	339
	340	exit ${ret}

tools/testing/selftests/openat2/Makefile+12−2

@@ -1,8 +1,18 @@
1	# SPDX-License-Identifier: GPL-2.0-or-later	1	# SPDX-License-Identifier: GPL-2.0-or-later
2		2
3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined -static-libasan	3	CFLAGS += -Wall -O2 -g -fsanitize=address -fsanitize=undefined
4	TEST_GEN_PROGS := openat2_test resolve_test rename_attack_test	4	TEST_GEN_PROGS := openat2_test resolve_test rename_attack_test
5		5
		6	# gcc requires -static-libasan in order to ensure that Address Sanitizer's
		7	# library is the first one loaded. However, clang already statically links the
		8	# Address Sanitizer if -fsanitize is specified. Therefore, simply omit
		9	# -static-libasan for clang builds.
		10	ifeq ($(LLVM),)
		11	CFLAGS += -static-libasan
		12	endif
		13
		14	LOCAL_HDRS += helpers.h
		15
6	include ../lib.mk	16	include ../lib.mk
7		17
8	$(TEST_GEN_PROGS): helpers.c helpers.h	18	$(TEST_GEN_PROGS): helpers.c

tools/testing/selftests/seccomp/seccomp_benchmark.c+3−3

@@ -194,14 +194,14 @@ int main(int argc, char *argv[]) · 193 unmodified lines
194	ksft_set_plan(7);	194	ksft_set_plan(7);
195		195
196	ksft_print_msg("Running on:\n");	196	ksft_print_msg("Running on:\n");
197	ksft_print_msg("");	197	ksft_print_msg("%s", "");
198	system("uname -a");	198	system("uname -a");
199		199
200	ksft_print_msg("Current BPF sysctl settings:\n");	200	ksft_print_msg("Current BPF sysctl settings:\n");
201	/* Avoid using "sysctl" which may not be installed. */	201	/* Avoid using "sysctl" which may not be installed. */
202	ksft_print_msg("");	202	ksft_print_msg("%s", "");
203	system("grep -H . /proc/sys/net/core/bpf_jit_enable");	203	system("grep -H . /proc/sys/net/core/bpf_jit_enable");
204	ksft_print_msg("");	204	ksft_print_msg("%s", "");
205	system("grep -H . /proc/sys/net/core/bpf_jit_harden");	205	system("grep -H . /proc/sys/net/core/bpf_jit_harden");
206		206
207	affinity();	207	affinity();

virt/kvm/dirty_ring.c+3−0

@@ -55,6 +55,9 @@ static void kvm_reset_dirty_gfn(struct kvm *kvm, u32 slot, u64 offset, u64 mask) · 54 unmodified lines
55	struct kvm_memory_slot *memslot;	55	struct kvm_memory_slot *memslot;
56	int as_id, id;	56	int as_id, id;
57		57
		58	if (!mask)
		59	return;
		60
58	as_id = slot >> 16;	61	as_id = slot >> 16;
59	id = (u16)slot;	62	id = (u16)slot;
60		63

virt/kvm/guest_memfd.c+3−2

 	}
 	if (folio_test_hwpoison(folio)) {
+		folio_unlock(folio);
+		folio_put(folio);
 		r = -EHWPOISON;
-		goto out_unlock;
+		goto out_fput;
 	}
 	page = folio_file_page(folio, index);
 	r = 0;
-out_unlock:
 	folio_unlock(folio);
 out_fput:
 	fput(file);

virt/kvm/kvm_main.c+10−9

 					range->on_lock(kvm);
 				if (IS_KVM_NULL_FN(range->handler))
-					break;
+					goto mmu_unlock;
 			}
 			r.ret |= range->handler(kvm, &gfn_range);
 		}
 	if (range->flush_on_ret && r.ret)
 		kvm_flush_remote_tlbs(kvm);
+mmu_unlock:
 	if (r.found_memslot)
 		KVM_MMU_UNLOCK(kvm);
 {
 	struct kvm *kvm = me->kvm;
 	struct kvm_vcpu *vcpu;
-	int last_boosted_vcpu = me->kvm->last_boosted_vcpu;
+	int last_boosted_vcpu;
 	unsigned long i;
 	int yielded = 0;
 	int try = 3;
 	int pass;
+	last_boosted_vcpu = READ_ONCE(kvm->last_boosted_vcpu);
 	kvm_vcpu_set_in_spin_loop(me, true);
 	/*
 	 * We boost the priority of a VCPU that is runnable but not
 			yielded = kvm_vcpu_yield_to(vcpu);
 			if (yielded > 0) {
-				kvm->last_boosted_vcpu = i;
+				WRITE_ONCE(kvm->last_boosted_vcpu, i);
 				break;
 			} else if (yielded < 0) {
 				try--;
 		struct kvm_regs *kvm_regs;
 		r = -ENOMEM;
-		kvm_regs = kzalloc(sizeof(struct kvm_regs), GFP_KERNEL_ACCOUNT);
+		kvm_regs = kzalloc(sizeof(struct kvm_regs), GFP_KERNEL);
 		if (!kvm_regs)
 			goto out;
 		r = kvm_arch_vcpu_ioctl_get_regs(vcpu, kvm_regs);
 		break;
 	}
 	case KVM_GET_SREGS: {
-		kvm_sregs = kzalloc(sizeof(struct kvm_sregs),
+		kvm_sregs = kzalloc(sizeof(struct kvm_sregs), GFP_KERNEL);
-				    GFP_KERNEL_ACCOUNT);
 		r = -ENOMEM;
 		if (!kvm_sregs)
 			goto out;
 		break;
 	}
 	case KVM_GET_FPU: {
-		fpu = kzalloc(sizeof(struct kvm_fpu), GFP_KERNEL_ACCOUNT);
+		fpu = kzalloc(sizeof(struct kvm_fpu), GFP_KERNEL);
 		r = -ENOMEM;
 		if (!fpu)
 			goto out;
 	active = kvm_active_vms;
 	mutex_unlock(&kvm_lock);
-	env = kzalloc(sizeof(*env), GFP_KERNEL_ACCOUNT);
+	env = kzalloc(sizeof(*env), GFP_KERNEL);
 	if (!env)
 		return;
 	add_uevent_var(env, "PID=%d", kvm->userspace_pid);
 	if (!IS_ERR(kvm->debugfs_dentry)) {
-		char *tmp, *p = kmalloc(PATH_MAX, GFP_KERNEL_ACCOUNT);
+		char *tmp, *p = kmalloc(PATH_MAX, GFP_KERNEL);
 		if (p) {
 			tmp = dentry_path_raw(kvm->debugfs_dentry, p, PATH_MAX);

@@ -40,7 +40,7 @@ Linux guests communicate with Hyper-V in four different ways: · 39 unmodified lines
40	arm64, these synthetic registers must be accessed using explicit	40	arm64, these synthetic registers must be accessed using explicit
41	hypercalls.	41	hypercalls.
42		42
43	* VMbus: VMbus is a higher-level software construct that is built on	43	* VMBus: VMBus is a higher-level software construct that is built on
44	the other 3 mechanisms. It is a message passing interface between	44	the other 3 mechanisms. It is a message passing interface between
45	the Hyper-V host and the Linux guest. It uses memory that is shared	45	the Hyper-V host and the Linux guest. It uses memory that is shared
46	between Hyper-V and the guest, along with various signaling	46	between Hyper-V and the guest, along with various signaling
@@ -54,8 +54,8 @@ x86/x64 architecture only. · 7 unmodified lines
54		54
55	.. _Hyper-V Top Level Functional Spec (TLFS): https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/tlfs/tlfs	55	.. _Hyper-V Top Level Functional Spec (TLFS): https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/tlfs/tlfs
56		56
57	VMbus is not documented. This documentation provides a high-level	57	VMBus is not documented. This documentation provides a high-level
58	overview of VMbus and how it works, but the details can be discerned	58	overview of VMBus and how it works, but the details can be discerned
59	only from the code.	59	only from the code.
60		60
61	Sharing Memory	61	Sharing Memory
@@ -74,7 +74,7 @@ follows: · 12 unmodified lines
74	physical address space. How Hyper-V is told about the GPA or list	74	physical address space. How Hyper-V is told about the GPA or list
75	of GPAs varies. In some cases, a single GPA is written to a	75	of GPAs varies. In some cases, a single GPA is written to a
76	synthetic register. In other cases, a GPA or list of GPAs is sent	76	synthetic register. In other cases, a GPA or list of GPAs is sent
77	in a VMbus message.	77	in a VMBus message.
78		78
79	* Hyper-V translates the GPAs into "real" physical memory addresses,	79	* Hyper-V translates the GPAs into "real" physical memory addresses,
80	and creates a virtual mapping that it can use to access the memory.	80	and creates a virtual mapping that it can use to access the memory.
@@ -133,9 +133,9 @@ only the CPUs actually present in the VM, so Linux does not report · 52 unmodified lines
133	any hot-add CPUs.	133	any hot-add CPUs.
134		134
135	A Linux guest CPU may be taken offline using the normal Linux	135	A Linux guest CPU may be taken offline using the normal Linux
136	mechanisms, provided no VMbus channel interrupts are assigned to	136	mechanisms, provided no VMBus channel interrupts are assigned to
137	the CPU. See the section on VMbus Interrupts for more details	137	the CPU. See the section on VMBus Interrupts for more details
138	on how VMbus channel interrupts can be re-assigned to permit	138	on how VMBus channel interrupts can be re-assigned to permit
139	taking a CPU offline.	139	taking a CPU offline.
140		140
141	32-bit and 64-bit	141	32-bit and 64-bit
@@ -169,14 +169,14 @@ and functionality. Hyper-V indicates feature/function availability · 27 unmodified lines
169	via flags in synthetic MSRs that Hyper-V provides to the guest,	169	via flags in synthetic MSRs that Hyper-V provides to the guest,
170	and the guest code tests these flags.	170	and the guest code tests these flags.
171		171
172	VMbus has its own protocol version that is negotiated during the	172	VMBus has its own protocol version that is negotiated during the
173	initial VMbus connection from the guest to Hyper-V. This version	173	initial VMBus connection from the guest to Hyper-V. This version
174	number is also output to dmesg during boot. This version number	174	number is also output to dmesg during boot. This version number
175	is checked in a few places in the code to determine if specific	175	is checked in a few places in the code to determine if specific
176	functionality is present.	176	functionality is present.
177		177
178	Furthermore, each synthetic device on VMbus also has a protocol	178	Furthermore, each synthetic device on VMBus also has a protocol
179	version that is separate from the VMbus protocol version. Device	179	version that is separate from the VMBus protocol version. Device
180	drivers for these synthetic devices typically negotiate the device	180	drivers for these synthetic devices typically negotiate the device
181	protocol version, and may test that protocol version to determine	181	protocol version, and may test that protocol version to determine
182	if specific device functionality is present.	182	if specific device functionality is present.