lael-labs/linux

Documentation/admin-guide/device-mapper/dm-integrity.rst+9−6

@@ -182,12 +182,15 @@ fix_padding · 181 unmodified lines
182	space-efficient. If this option is not present, large padding is	182	space-efficient. If this option is not present, large padding is
183	used - that is for compatibility with older kernels.	183	used - that is for compatibility with older kernels.
184		184
185		185	allow_discards
186	The journal mode (D/J), buffer_sectors, journal_watermark, commit_time can	186	Allow block discard requests (a.k.a. TRIM) for the integrity device.
187	be changed when reloading the target (load an inactive table and swap the	187	Discards are only allowed to devices using internal hash.
188	tables with suspend and resume). The other arguments should not be changed	188
189	when reloading the target because the layout of disk data depend on them	189	The journal mode (D/J), buffer_sectors, journal_watermark, commit_time and
190	and the reloaded target would be non-functional.	190	allow_discards can be changed when reloading the target (load an inactive
		191	table and swap the tables with suspend and resume). The other arguments
		192	should not be changed when reloading the target because the layout of disk
		193	data depend on them and the reloaded target would be non-functional.
191		194
192		195
193	The layout of the formatted block device:	196	The layout of the formatted block device:

Documentation/devicetree/bindings/dma/socionext,uniphier-xdmac.yaml+3−4

     const: socionext,uniphier-xdmac
   reg:
-    items:
+    maxItems: 1
-      - description: XDMAC base register region (offset and length)
-      - description: XDMAC extension register region (offset and length)
   interrupts:
     maxItems: 1
   - reg
   - interrupts
   - "#dma-cells"
+  - dma-channels
 examples:
   - |
     xdmac: dma-controller@5fc10000 {
         compatible = "socionext,uniphier-xdmac";
-        reg = <0x5fc10000 0x1000>, <0x5fc20000 0x800>;
+        reg = <0x5fc10000 0x5300>;
         interrupts = <0 188 4>;
         #dma-cells = <2>;
         dma-channels = <16>;

Documentation/networking/devlink/ice.rst+2−2

@@ -61,8 +61,8 @@ The ``ice`` driver reports the following versions · 60 unmodified lines
61	- running	61	- running
62	- ICE OS Default Package	62	- ICE OS Default Package
63	- The name of the DDP package that is active in the device. The DDP	63	- The name of the DDP package that is active in the device. The DDP
64	package is loaded by the driver during initialization. Each varation	64	package is loaded by the driver during initialization. Each
65	of DDP package shall have a unique name.	65	variation of the DDP package has a unique name.
66	* - ``fw.app``	66	* - ``fw.app``
67	- running	67	- running
68	- 1.3.1.0	68	- 1.3.1.0

Documentation/virt/kvm/index.rst+2−0

@@ -28,3 +28,5 @@ KVM · 27 unmodified lines
28	arm/index	28	arm/index
29		29
30	devices/index	30	devices/index
		31
		32	running-nested-guests

Documentation/virt/kvm/running-nested-guests.rst+276−0

@@ -0,0 +1,276 @@
	1	==============================
	2	Running nested guests with KVM
	3	==============================
	4
	5	A nested guest is the ability to run a guest inside another guest (it
	6	can be KVM-based or a different hypervisor). The straightforward
	7	example is a KVM guest that in turn runs on a KVM guest (the rest of
	8	this document is built on this example)::
	9
	10	.----------------. .----------------.
	11	\| \| \| \|
	12	\| L2 \| \| L2 \|
	13	\| (Nested Guest) \| \| (Nested Guest) \|
	14	\| \| \| \|
	15	\|----------------'--'----------------\|
	16	\| \|
	17	\| L1 (Guest Hypervisor) \|
	18	\| KVM (/dev/kvm) \|
	19	\| \|
	20	.------------------------------------------------------.
	21	\| L0 (Host Hypervisor) \|
	22	\| KVM (/dev/kvm) \|
	23	\|------------------------------------------------------\|
	24	\| Hardware (with virtualization extensions) \|
	25	'------------------------------------------------------'
	26
	27	Terminology:
	28
	29	- L0 – level-0; the bare metal host, running KVM
	30
	31	- L1 – level-1 guest; a VM running on L0; also called the "guest
	32	hypervisor", as it itself is capable of running KVM.
	33
	34	- L2 – level-2 guest; a VM running on L1, this is the "nested guest"
	35
	36	.. note:: The above diagram is modelled after the x86 architecture;
	37	s390x, ppc64 and other architectures are likely to have
	38	a different design for nesting.
	39
	40	For example, s390x always has an LPAR (LogicalPARtition)
	41	hypervisor running on bare metal, adding another layer and
	42	resulting in at least four levels in a nested setup — L0 (bare
	43	metal, running the LPAR hypervisor), L1 (host hypervisor), L2
	44	(guest hypervisor), L3 (nested guest).
	45
	46	This document will stick with the three-level terminology (L0,
	47	L1, and L2) for all architectures; and will largely focus on
	48	x86.
	49
	50
	51	Use Cases
	52	---------
	53
	54	There are several scenarios where nested KVM can be useful, to name a
	55	few:
	56
	57	- As a developer, you want to test your software on different operating
	58	systems (OSes). Instead of renting multiple VMs from a Cloud
	59	Provider, using nested KVM lets you rent a large enough "guest
	60	hypervisor" (level-1 guest). This in turn allows you to create
	61	multiple nested guests (level-2 guests), running different OSes, on
	62	which you can develop and test your software.
	63
	64	- Live migration of "guest hypervisors" and their nested guests, for
	65	load balancing, disaster recovery, etc.
	66
	67	- VM image creation tools (e.g. ``virt-install``, etc) often run
	68	their own VM, and users expect these to work inside a VM.
	69
	70	- Some OSes use virtualization internally for security (e.g. to let
	71	applications run safely in isolation).
	72
	73
	74	Enabling "nested" (x86)
	75	-----------------------
	76
	77	From Linux kernel v4.19 onwards, the ``nested`` KVM parameter is enabled
	78	by default for Intel and AMD. (Though your Linux distribution might
	79	override this default.)
	80
	81	In case you are running a Linux kernel older than v4.19, to enable
	82	nesting, set the ``nested`` KVM module parameter to ``Y`` or ``1``. To
	83	persist this setting across reboots, you can add it in a config file, as
	84	shown below:
	85
	86	1. On the bare metal host (L0), list the kernel modules and ensure that
	87	the KVM modules::
	88
	89	$ lsmod \| grep -i kvm
	90	kvm_intel 133627 0
	91	kvm 435079 1 kvm_intel
	92
	93	2. Show information for ``kvm_intel`` module::
	94
	95	$ modinfo kvm_intel \| grep -i nested
	96	parm: nested:bool
	97
	98	3. For the nested KVM configuration to persist across reboots, place the
	99	below in ``/etc/modprobed/kvm_intel.conf`` (create the file if it
	100	doesn't exist)::
	101
	102	$ cat /etc/modprobe.d/kvm_intel.conf
	103	options kvm-intel nested=y
	104
	105	4. Unload and re-load the KVM Intel module::
	106
	107	$ sudo rmmod kvm-intel
	108	$ sudo modprobe kvm-intel
	109
	110	5. Verify if the ``nested`` parameter for KVM is enabled::
	111
	112	$ cat /sys/module/kvm_intel/parameters/nested
	113	Y
	114
	115	For AMD hosts, the process is the same as above, except that the module
	116	name is ``kvm-amd``.
	117
	118
	119	Additional nested-related kernel parameters (x86)
	120	-------------------------------------------------
	121
	122	If your hardware is sufficiently advanced (Intel Haswell processor or
	123	higher, which has newer hardware virt extensions), the following
	124	additional features will also be enabled by default: "Shadow VMCS
	125	(Virtual Machine Control Structure)", APIC Virtualization on your bare
	126	metal host (L0). Parameters for Intel hosts::
	127
	128	$ cat /sys/module/kvm_intel/parameters/enable_shadow_vmcs
	129	Y
	130
	131	$ cat /sys/module/kvm_intel/parameters/enable_apicv
	132	Y
	133
	134	$ cat /sys/module/kvm_intel/parameters/ept
	135	Y
	136
	137	.. note:: If you suspect your L2 (i.e. nested guest) is running slower,
	138	ensure the above are enabled (particularly
	139	``enable_shadow_vmcs`` and ``ept``).
	140
	141
	142	Starting a nested guest (x86)
	143	-----------------------------
	144
	145	Once your bare metal host (L0) is configured for nesting, you should be
	146	able to start an L1 guest with::
	147
	148	$ qemu-kvm -cpu host [...]
	149
	150	The above will pass through the host CPU's capabilities as-is to the
	151	gues); or for better live migration compatibility, use a named CPU
	152	model supported by QEMU. e.g.::
	153
	154	$ qemu-kvm -cpu Haswell-noTSX-IBRS,vmx=on
	155
	156	then the guest hypervisor will subsequently be capable of running a
	157	nested guest with accelerated KVM.
	158
	159
	160	Enabling "nested" (s390x)
	161	-------------------------
	162
	163	1. On the host hypervisor (L0), enable the ``nested`` parameter on
	164	s390x::
	165
	166	$ rmmod kvm
	167	$ modprobe kvm nested=1
	168
	169	.. note:: On s390x, the kernel parameter ``hpage`` is mutually exclusive
	170	with the ``nested`` paramter — i.e. to be able to enable
	171	``nested``, the ``hpage`` parameter must be disabled.
	172
	173	2. The guest hypervisor (L1) must be provided with the ``sie`` CPU
	174	feature — with QEMU, this can be done by using "host passthrough"
	175	(via the command-line ``-cpu host``).
	176
	177	3. Now the KVM module can be loaded in the L1 (guest hypervisor)::
	178
	179	$ modprobe kvm
	180
	181
	182	Live migration with nested KVM
	183	------------------------------
	184
	185	Migrating an L1 guest, with a live nested guest in it, to another
	186	bare metal host, works as of Linux kernel 5.3 and QEMU 4.2.0 for
	187	Intel x86 systems, and even on older versions for s390x.
	188
	189	On AMD systems, once an L1 guest has started an L2 guest, the L1 guest
	190	should no longer be migrated or saved (refer to QEMU documentation on
	191	"savevm"/"loadvm") until the L2 guest shuts down. Attempting to migrate
	192	or save-and-load an L1 guest while an L2 guest is running will result in
	193	undefined behavior. You might see a ``kernel BUG!`` entry in ``dmesg``, a
	194	kernel 'oops', or an outright kernel panic. Such a migrated or loaded L1
	195	guest can no longer be considered stable or secure, and must be restarted.
	196	Migrating an L1 guest merely configured to support nesting, while not
	197	actually running L2 guests, is expected to function normally even on AMD
	198	systems but may fail once guests are started.
	199
	200	Migrating an L2 guest is always expected to succeed, so all the following
	201	scenarios should work even on AMD systems:
	202
	203	- Migrating a nested guest (L2) to another L1 guest on the same bare
	204	metal host.
	205
	206	- Migrating a nested guest (L2) to another L1 guest on a different
	207	bare metal host.
	208
	209	- Migrating a nested guest (L2) to a bare metal host.
	210
	211	Reporting bugs from nested setups
	212	-----------------------------------
	213
	214	Debugging "nested" problems can involve sifting through log files across
	215	L0, L1 and L2; this can result in tedious back-n-forth between the bug
	216	reporter and the bug fixer.
	217
	218	- Mention that you are in a "nested" setup. If you are running any kind
	219	of "nesting" at all, say so. Unfortunately, this needs to be called
	220	out because when reporting bugs, people tend to forget to even
	221	mention that they're using nested virtualization.
	222
	223	- Ensure you are actually running KVM on KVM. Sometimes people do not
	224	have KVM enabled for their guest hypervisor (L1), which results in
	225	them running with pure emulation or what QEMU calls it as "TCG", but
	226	they think they're running nested KVM. Thus confusing "nested Virt"
	227	(which could also mean, QEMU on KVM) with "nested KVM" (KVM on KVM).
	228
	229	Information to collect (generic)
	230	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	231
	232	The following is not an exhaustive list, but a very good starting point:
	233
	234	- Kernel, libvirt, and QEMU version from L0
	235
	236	- Kernel, libvirt and QEMU version from L1
	237
	238	- QEMU command-line of L1 -- when using libvirt, you'll find it here:
	239	``/var/log/libvirt/qemu/instance.log``
	240
	241	- QEMU command-line of L2 -- as above, when using libvirt, get the
	242	complete libvirt-generated QEMU command-line
	243
	244	- ``cat /sys/cpuinfo`` from L0
	245
	246	- ``cat /sys/cpuinfo`` from L1
	247
	248	- ``lscpu`` from L0
	249
	250	- ``lscpu`` from L1
	251
	252	- Full ``dmesg`` output from L0
	253
	254	- Full ``dmesg`` output from L1
	255
	256	x86-specific info to collect
	257	~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	258
	259	Both the below commands, ``x86info`` and ``dmidecode``, should be
	260	available on most Linux distributions with the same name:
	261
	262	- Output of: ``x86info -a`` from L0
	263
	264	- Output of: ``x86info -a`` from L1
	265
	266	- Output of: ``dmidecode`` from L0
	267
	268	- Output of: ``dmidecode`` from L1
	269
	270	s390x-specific info to collect
	271	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	272
	273	Along with the earlier mentioned generic details, the below is
	274	also recommended:
	275
	276	- ``/proc/sysinfo`` from L1; this will also include the info from L0

MAINTAINERS+4−14

@@ -3657,7 +3657,7 @@ L: linux-btrfs@vger.kernel.org · 3656 unmodified lines
3657	S: Maintained	3657	S: Maintained
3658	W: http://btrfs.wiki.kernel.org/	3658	W: http://btrfs.wiki.kernel.org/
3659	Q: http://patchwork.kernel.org/project/linux-btrfs/list/	3659	Q: http://patchwork.kernel.org/project/linux-btrfs/list/
3660	T: git git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs.git	3660	T: git git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git
3661	F: Documentation/filesystems/btrfs.rst	3661	F: Documentation/filesystems/btrfs.rst
3662	F: fs/btrfs/	3662	F: fs/btrfs/
3663	F: include/linux/btrfs*	3663	F: include/linux/btrfs*
@@ -3936,11 +3936,9 @@ F: arch/powerpc/platforms/cell/ · 272 unmodified lines
3936	CEPH COMMON CODE (LIBCEPH)	3936	CEPH COMMON CODE (LIBCEPH)
3937	M: Ilya Dryomov <idryomov@gmail.com>	3937	M: Ilya Dryomov <idryomov@gmail.com>
3938	M: Jeff Layton <jlayton@kernel.org>	3938	M: Jeff Layton <jlayton@kernel.org>
3939	M: Sage Weil <sage@redhat.com>
3940	L: ceph-devel@vger.kernel.org	3939	L: ceph-devel@vger.kernel.org
3941	S: Supported	3940	S: Supported
3942	W: http://ceph.com/	3941	W: http://ceph.com/
3943	T: git git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client.git
3944	T: git git://github.com/ceph/ceph-client.git	3942	T: git git://github.com/ceph/ceph-client.git
3945	F: include/linux/ceph/	3943	F: include/linux/ceph/
3946	F: include/linux/crush/	3944	F: include/linux/crush/
@@ -3948,12 +3946,10 @@ F: net/ceph/ · 1 unmodified line
3948		3946
3949	CEPH DISTRIBUTED FILE SYSTEM CLIENT (CEPH)	3947	CEPH DISTRIBUTED FILE SYSTEM CLIENT (CEPH)
3950	M: Jeff Layton <jlayton@kernel.org>	3948	M: Jeff Layton <jlayton@kernel.org>
3951	M: Sage Weil <sage@redhat.com>
3952	M: Ilya Dryomov <idryomov@gmail.com>	3949	M: Ilya Dryomov <idryomov@gmail.com>
3953	L: ceph-devel@vger.kernel.org	3950	L: ceph-devel@vger.kernel.org
3954	S: Supported	3951	S: Supported
3955	W: http://ceph.com/	3952	W: http://ceph.com/
3956	T: git git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client.git
3957	T: git git://github.com/ceph/ceph-client.git	3953	T: git git://github.com/ceph/ceph-client.git
3958	F: Documentation/filesystems/ceph.rst	3954	F: Documentation/filesystems/ceph.rst
3959	F: fs/ceph/	3955	F: fs/ceph/
@@ -5935,9 +5931,9 @@ F: lib/dynamic_debug.c · 1975 unmodified lines
5935	DYNAMIC INTERRUPT MODERATION	5931	DYNAMIC INTERRUPT MODERATION
5936	M: Tal Gilboa <talgi@mellanox.com>	5932	M: Tal Gilboa <talgi@mellanox.com>
5937	S: Maintained	5933	S: Maintained
		5934	F: Documentation/networking/net_dim.rst
5938	F: include/linux/dim.h	5935	F: include/linux/dim.h
5939	F: lib/dim/	5936	F: lib/dim/
5940	F: Documentation/networking/net_dim.rst
5941		5937
5942	DZ DECSTATION DZ11 SERIAL DRIVER	5938	DZ DECSTATION DZ11 SERIAL DRIVER
5943	M: "Maciej W. Rozycki" <macro@linux-mips.org>	5939	M: "Maciej W. Rozycki" <macro@linux-mips.org>
@@ -7119,9 +7115,10 @@ F: include/uapi/asm-generic/ · 1175 unmodified lines
7119		7115
7120	GENERIC PHY FRAMEWORK	7116	GENERIC PHY FRAMEWORK
7121	M: Kishon Vijay Abraham I <kishon@ti.com>	7117	M: Kishon Vijay Abraham I <kishon@ti.com>
		7118	M: Vinod Koul <vkoul@kernel.org>
7122	L: linux-kernel@vger.kernel.org	7119	L: linux-kernel@vger.kernel.org
7123	S: Supported	7120	S: Supported
7124	T: git git://git.kernel.org/pub/scm/linux/kernel/git/kishon/linux-phy.git	7121	T: git git://git.kernel.org/pub/scm/linux/kernel/git/phy/linux-phy.git
7125	F: Documentation/devicetree/bindings/phy/	7122	F: Documentation/devicetree/bindings/phy/
7126	F: drivers/phy/	7123	F: drivers/phy/
7127	F: include/linux/phy/	7124	F: include/linux/phy/
@@ -7746,11 +7743,6 @@ L: platform-driver-x86@vger.kernel.org · 618 unmodified lines
7746	S: Orphan	7743	S: Orphan
7747	F: drivers/platform/x86/tc1100-wmi.c	7744	F: drivers/platform/x86/tc1100-wmi.c
7748		7745
7749	HP100: Driver for HP 10/100 Mbit/s Voice Grade Network Adapter Series
7750	M: Jaroslav Kysela <perex@perex.cz>
7751	S: Obsolete
7752	F: drivers/staging/hp/hp100.*
7753
7754	HPET: High Precision Event Timers driver	7746	HPET: High Precision Event Timers driver
7755	M: Clemens Ladisch <clemens@ladisch.de>	7747	M: Clemens Ladisch <clemens@ladisch.de>
7756	S: Maintained	7748	S: Maintained
@@ -14102,12 +14094,10 @@ F: drivers/media/radio/radio-tea5777.c · 6345 unmodified lines
14102		14094
14103	RADOS BLOCK DEVICE (RBD)	14095	RADOS BLOCK DEVICE (RBD)
14104	M: Ilya Dryomov <idryomov@gmail.com>	14096	M: Ilya Dryomov <idryomov@gmail.com>
14105	M: Sage Weil <sage@redhat.com>
14106	R: Dongsheng Yang <dongsheng.yang@easystack.cn>	14097	R: Dongsheng Yang <dongsheng.yang@easystack.cn>
14107	L: ceph-devel@vger.kernel.org	14098	L: ceph-devel@vger.kernel.org
14108	S: Supported	14099	S: Supported
14109	W: http://ceph.com/	14100	W: http://ceph.com/
14110	T: git git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client.git
14111	T: git git://github.com/ceph/ceph-client.git	14101	T: git git://github.com/ceph/ceph-client.git
14112	F: Documentation/ABI/testing/sysfs-bus-rbd	14102	F: Documentation/ABI/testing/sysfs-bus-rbd
14113	F: drivers/block/rbd.c	14103	F: drivers/block/rbd.c

Makefile+12−5

 VERSION = 5
 PATCHLEVEL = 7
 SUBLEVEL = 0
-EXTRAVERSION = -rc3
+EXTRAVERSION = -rc5
 NAME = Kleptomaniac Octopus
 # *DOCUMENTATION*
 KBUILD_CFLAGS += -Os
 endif
-ifdef CONFIG_CC_DISABLE_WARN_MAYBE_UNINITIALIZED
-KBUILD_CFLAGS   += -Wno-maybe-uninitialized
-endif
 # Tell gcc to never replace conditional load with a non-conditional one
 KBUILD_CFLAGS	+= $(call cc-option,--param=allow-store-data-races=0)
 KBUILD_CFLAGS	+= $(call cc-option,-fno-allow-store-data-races)
 # disable stringop warnings in gcc 8+
 KBUILD_CFLAGS += $(call cc-disable-warning, stringop-truncation)
+# We'll want to enable this eventually, but it's not going away for 5.7 at least
+KBUILD_CFLAGS += $(call cc-disable-warning, zero-length-bounds)
+KBUILD_CFLAGS += $(call cc-disable-warning, array-bounds)
+KBUILD_CFLAGS += $(call cc-disable-warning, stringop-overflow)
+# Another good warning that we'll want to enable eventually
+KBUILD_CFLAGS += $(call cc-disable-warning, restrict)
+# Enabled with W=2, disabled by default as noisy
+KBUILD_CFLAGS += $(call cc-disable-warning, maybe-uninitialized)
 # disable invalid "can't wrap" optimizations for signed / pointers
 KBUILD_CFLAGS	+= $(call cc-option,-fno-strict-overflow)

arch/arm/crypto/chacha-glue.c+11−3

@@ -91,9 +91,17 @@ void chacha_crypt_arch(u32 state, u8 dst, const u8 *src, unsigned int bytes, · 90 unmodified lines
91	return;	91	return;
92	}	92	}
93		93
94	kernel_neon_begin();	94	do {
95	chacha_doneon(state, dst, src, bytes, nrounds);	95	unsigned int todo = min_t(unsigned int, bytes, SZ_4K);
96	kernel_neon_end();	96
		97	kernel_neon_begin();
		98	chacha_doneon(state, dst, src, todo, nrounds);
		99	kernel_neon_end();
		100
		101	bytes -= todo;
		102	src += todo;
		103	dst += todo;
		104	} while (bytes);
97	}	105	}
98	EXPORT_SYMBOL(chacha_crypt_arch);	106	EXPORT_SYMBOL(chacha_crypt_arch);
99		107

arch/arm/crypto/nhpoly1305-neon-glue.c+1−1

@@ -30,7 +30,7 @@ static int nhpoly1305_neon_update(struct shash_desc *desc, · 29 unmodified lines
30	return crypto_nhpoly1305_update(desc, src, srclen);	30	return crypto_nhpoly1305_update(desc, src, srclen);
31		31
32	do {	32	do {
33	unsigned int n = min_t(unsigned int, srclen, PAGE_SIZE);	33	unsigned int n = min_t(unsigned int, srclen, SZ_4K);
34		34
35	kernel_neon_begin();	35	kernel_neon_begin();
36	crypto_nhpoly1305_update_helper(desc, src, n, _nh_neon);	36	crypto_nhpoly1305_update_helper(desc, src, n, _nh_neon);

arch/arm/crypto/poly1305-glue.c+11−4

@@ -160,13 +160,20 @@ void poly1305_update_arch(struct poly1305_desc_ctx dctx, const u8 src, · 159 unmodified lines
160	unsigned int len = round_down(nbytes, POLY1305_BLOCK_SIZE);	160	unsigned int len = round_down(nbytes, POLY1305_BLOCK_SIZE);
161		161
162	if (static_branch_likely(&have_neon) && do_neon) {	162	if (static_branch_likely(&have_neon) && do_neon) {
163	kernel_neon_begin();	163	do {
164	poly1305_blocks_neon(&dctx->h, src, len, 1);	164	unsigned int todo = min_t(unsigned int, len, SZ_4K);
165	kernel_neon_end();	165
		166	kernel_neon_begin();
		167	poly1305_blocks_neon(&dctx->h, src, todo, 1);
		168	kernel_neon_end();
		169
		170	len -= todo;
		171	src += todo;
		172	} while (len);
166	} else {	173	} else {
167	poly1305_blocks_arm(&dctx->h, src, len, 1);	174	poly1305_blocks_arm(&dctx->h, src, len, 1);
		175	src += len;
168	}	176	}
169	src += len;
170	nbytes %= POLY1305_BLOCK_SIZE;	177	nbytes %= POLY1305_BLOCK_SIZE;
171	}	178	}
172		179

arch/arm/include/asm/futex.h+7−2

 	preempt_enable();
 #endif
-	if (!ret)
+	/*
-		*oval = oldval;
+	 * Store unconditionally. If ret != 0 the extra store is the least
+	 * of the worries but GCC cannot figure out that __futex_atomic_op()
+	 * is either setting ret to -EFAULT or storing the old value in
+	 * oldval which results in a uninitialized warning at the call site.
+	 */
+	*oval = oldval;
 	return ret;
 }

arch/arm64/crypto/chacha-neon-glue.c+11−3

@@ -87,9 +87,17 @@ void chacha_crypt_arch(u32 state, u8 dst, const u8 *src, unsigned int bytes, · 86 unmodified lines
87	!crypto_simd_usable())	87	!crypto_simd_usable())
88	return chacha_crypt_generic(state, dst, src, bytes, nrounds);	88	return chacha_crypt_generic(state, dst, src, bytes, nrounds);
89		89
90	kernel_neon_begin();	90	do {
91	chacha_doneon(state, dst, src, bytes, nrounds);	91	unsigned int todo = min_t(unsigned int, bytes, SZ_4K);
92	kernel_neon_end();	92
		93	kernel_neon_begin();
		94	chacha_doneon(state, dst, src, todo, nrounds);
		95	kernel_neon_end();
		96
		97	bytes -= todo;
		98	src += todo;
		99	dst += todo;
		100	} while (bytes);
93	}	101	}
94	EXPORT_SYMBOL(chacha_crypt_arch);	102	EXPORT_SYMBOL(chacha_crypt_arch);
95		103

arch/arm64/crypto/nhpoly1305-neon-glue.c+1−1

@@ -30,7 +30,7 @@ static int nhpoly1305_neon_update(struct shash_desc *desc, · 29 unmodified lines
30	return crypto_nhpoly1305_update(desc, src, srclen);	30	return crypto_nhpoly1305_update(desc, src, srclen);
31		31
32	do {	32	do {
33	unsigned int n = min_t(unsigned int, srclen, PAGE_SIZE);	33	unsigned int n = min_t(unsigned int, srclen, SZ_4K);
34		34
35	kernel_neon_begin();	35	kernel_neon_begin();
36	crypto_nhpoly1305_update_helper(desc, src, n, _nh_neon);	36	crypto_nhpoly1305_update_helper(desc, src, n, _nh_neon);

arch/arm64/crypto/poly1305-glue.c+11−4

@@ -143,13 +143,20 @@ void poly1305_update_arch(struct poly1305_desc_ctx dctx, const u8 src, · 142 unmodified lines
143	unsigned int len = round_down(nbytes, POLY1305_BLOCK_SIZE);	143	unsigned int len = round_down(nbytes, POLY1305_BLOCK_SIZE);
144		144
145	if (static_branch_likely(&have_neon) && crypto_simd_usable()) {	145	if (static_branch_likely(&have_neon) && crypto_simd_usable()) {
146	kernel_neon_begin();	146	do {
147	poly1305_blocks_neon(&dctx->h, src, len, 1);	147	unsigned int todo = min_t(unsigned int, len, SZ_4K);
148	kernel_neon_end();	148
		149	kernel_neon_begin();
		150	poly1305_blocks_neon(&dctx->h, src, todo, 1);
		151	kernel_neon_end();
		152
		153	len -= todo;
		154	src += todo;
		155	} while (len);
149	} else {	156	} else {
150	poly1305_blocks(&dctx->h, src, len, 1);	157	poly1305_blocks(&dctx->h, src, len, 1);
		158	src += len;
151	}	159	}
152	src += len;
153	nbytes %= POLY1305_BLOCK_SIZE;	160	nbytes %= POLY1305_BLOCK_SIZE;
154	}	161	}
155		162

arch/arm64/kernel/vdso/Makefile+1−1

@@ -32,7 +32,7 @@ UBSAN_SANITIZE := n · 31 unmodified lines
32	OBJECT_FILES_NON_STANDARD := y	32	OBJECT_FILES_NON_STANDARD := y
33	KCOV_INSTRUMENT := n	33	KCOV_INSTRUMENT := n
34		34
35	CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny	35	CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny -fasynchronous-unwind-tables
36		36
37	ifneq ($(c-gettimeofday-y),)	37	ifneq ($(c-gettimeofday-y),)
38	CFLAGS_vgettimeofday.o += -include $(c-gettimeofday-y)	38	CFLAGS_vgettimeofday.o += -include $(c-gettimeofday-y)

arch/arm64/kvm/guest.c+7−0

@@ -200,6 +200,13 @@ static int set_core_reg(struct kvm_vcpu vcpu, const struct kvm_one_reg reg) · 199 unmodified lines
200	}	200	}
201		201
202	memcpy((u32 *)regs + off, valp, KVM_REG_SIZE(reg->id));	202	memcpy((u32 *)regs + off, valp, KVM_REG_SIZE(reg->id));
		203
		204	if (*vcpu_cpsr(vcpu) & PSR_MODE32_BIT) {
		205	int i;
		206
		207	for (i = 0; i < 16; i++)
		208	vcpu_reg32(vcpu, i) = (u32)vcpu_reg32(vcpu, i);
		209	}
203	out:	210	out:
204	return err;	211	return err;
205	}	212	}

arch/arm64/kvm/hyp/entry.S+23−0

 #define CPU_GP_REG_OFFSET(x)	(CPU_GP_REGS + x)
 #define CPU_XREG_OFFSET(x)	CPU_GP_REG_OFFSET(CPU_USER_PT_REGS + 8*x)
+#define CPU_SP_EL0_OFFSET	(CPU_XREG_OFFSET(30) + 8)
 	.text
 	.pushsection	.hyp.text, "ax"
 	ldp	x29, lr,  [\ctxt, #CPU_XREG_OFFSET(29)]
 .endm
+.macro save_sp_el0 ctxt, tmp
+	mrs	\tmp,	sp_el0
+	str	\tmp,	[\ctxt, #CPU_SP_EL0_OFFSET]
+.endm
+.macro restore_sp_el0 ctxt, tmp
+	ldr	\tmp,	  [\ctxt, #CPU_SP_EL0_OFFSET]
+	msr	sp_el0, \tmp
+.endm
 /*
  * u64 __guest_enter(struct kvm_vcpu *vcpu,
  *		     struct kvm_cpu_context *host_ctxt);
 	// Store the host regs
 	save_callee_saved_regs x1
+	// Save the host's sp_el0
+	save_sp_el0	x1, x2
 	// Now the host state is stored if we have a pending RAS SError it must
 	// affect the host. If any asynchronous exception is pending we defer
 	// the guest entry. The DSB isn't necessary before v8.2 as any SError
 	// when this feature is enabled for kernel code.
 	ptrauth_switch_to_guest x29, x0, x1, x2
+	// Restore the guest's sp_el0
+	restore_sp_el0 x29, x0
 	// Restore guest regs x0-x17
 	ldp	x0, x1,   [x29, #CPU_XREG_OFFSET(0)]
 	ldp	x2, x3,   [x29, #CPU_XREG_OFFSET(2)]
 	// Store the guest regs x18-x29, lr
 	save_callee_saved_regs x1
+	// Store the guest's sp_el0
+	save_sp_el0	x1, x2
 	get_host_ctxt	x2, x3
 	// Macro ptrauth_switch_to_guest format:
 	// when this feature is enabled for kernel code.
 	ptrauth_switch_to_host x1, x2, x3, x4, x5
+	// Restore the hosts's sp_el0
+	restore_sp_el0 x2, x3
 	// Now restore the host regs
 	restore_callee_saved_regs x2

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

@@ -198,7 +198,6 @@ SYM_CODE_END(__hyp_panic) · 197 unmodified lines
198	.macro invalid_vector label, target = __hyp_panic	198	.macro invalid_vector label, target = __hyp_panic
199	.align 2	199	.align 2
200	SYM_CODE_START(\label)	200	SYM_CODE_START(\label)
201	\label:
202	b \target	201	b \target
203	SYM_CODE_END(\label)	202	SYM_CODE_END(\label)
204	.endm	203	.endm

arch/arm64/kvm/hyp/sysreg-sr.c+3−14

 /*
  * Non-VHE: Both host and guest must save everything.
  *
- * VHE: Host and guest must save mdscr_el1 and sp_el0 (and the PC and pstate,
+ * VHE: Host and guest must save mdscr_el1 and sp_el0 (and the PC and
- * which are handled as part of the el2 return state) on every switch.
+ * pstate, which are handled as part of the el2 return state) on every
+ * switch (sp_el0 is being dealt with in the assembly code).
  * tpidr_el0 and tpidrro_el0 only need to be switched when going
  * to host userspace or a different VCPU.  EL1 registers only need to be
  * switched when potentially going to run a different VCPU.  The latter two
 static void __hyp_text __sysreg_save_common_state(struct kvm_cpu_context *ctxt)
 {
 	ctxt->sys_regs[MDSCR_EL1]	= read_sysreg(mdscr_el1);
-	/*
-	 * The host arm64 Linux uses sp_el0 to point to 'current' and it must
-	 * therefore be saved/restored on every entry/exit to/from the guest.
-	 */
-	ctxt->gp_regs.regs.sp		= read_sysreg(sp_el0);
 }
 static void __hyp_text __sysreg_save_user_state(struct kvm_cpu_context *ctxt)
 static void __hyp_text __sysreg_restore_common_state(struct kvm_cpu_context *ctxt)
 {
 	write_sysreg(ctxt->sys_regs[MDSCR_EL1],	  mdscr_el1);
-	/*
-	 * The host arm64 Linux uses sp_el0 to point to 'current' and it must
-	 * therefore be saved/restored on every entry/exit to/from the guest.
-	 */
-	write_sysreg(ctxt->gp_regs.regs.sp,	  sp_el0);
 }
 static void __hyp_text __sysreg_restore_user_state(struct kvm_cpu_context *ctxt)

arch/arm64/mm/hugetlbpage.c+2−0

@@ -230,6 +230,8 @@ pte_t huge_pte_alloc(struct mm_struct mm, · 229 unmodified lines
230	ptep = (pte_t *)pudp;	230	ptep = (pte_t *)pudp;
231	} else if (sz == (CONT_PTE_SIZE)) {	231	} else if (sz == (CONT_PTE_SIZE)) {
232	pmdp = pmd_alloc(mm, pudp, addr);	232	pmdp = pmd_alloc(mm, pudp, addr);
		233	if (!pmdp)
		234	return NULL;
233		235
234	WARN_ON(addr & (sz - 1));	236	WARN_ON(addr & (sz - 1));
235	/*	237	/*

arch/powerpc/kvm/powerpc.c+1−0

@@ -521,6 +521,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) · 520 unmodified lines
521	case KVM_CAP_IOEVENTFD:	521	case KVM_CAP_IOEVENTFD:
522	case KVM_CAP_DEVICE_CTRL:	522	case KVM_CAP_DEVICE_CTRL:
523	case KVM_CAP_IMMEDIATE_EXIT:	523	case KVM_CAP_IMMEDIATE_EXIT:
		524	case KVM_CAP_SET_GUEST_DEBUG:
524	r = 1;	525	r = 1;
525	break;	526	break;
526	case KVM_CAP_PPC_GUEST_DEBUG_SSTEP:	527	case KVM_CAP_PPC_GUEST_DEBUG_SSTEP:

arch/riscv/Kconfig+1−1

@@ -60,7 +60,7 @@ config RISCV · 59 unmodified lines
60	select ARCH_HAS_GIGANTIC_PAGE	60	select ARCH_HAS_GIGANTIC_PAGE
61	select ARCH_HAS_SET_DIRECT_MAP	61	select ARCH_HAS_SET_DIRECT_MAP
62	select ARCH_HAS_SET_MEMORY	62	select ARCH_HAS_SET_MEMORY
63	select ARCH_HAS_STRICT_KERNEL_RWX	63	select ARCH_HAS_STRICT_KERNEL_RWX if MMU
64	select ARCH_WANT_HUGE_PMD_SHARE if 64BIT	64	select ARCH_WANT_HUGE_PMD_SHARE if 64BIT
65	select SPARSEMEM_STATIC if 32BIT	65	select SPARSEMEM_STATIC if 32BIT
66	select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU	66	select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU

arch/riscv/include/asm/csr.h+0−3

 #define CAUSE_IRQ_FLAG		(_AC(1, UL) << (__riscv_xlen - 1))
 /* Interrupt causes (minus the high bit) */
-#define IRQ_U_SOFT		0
 #define IRQ_S_SOFT		1
 #define IRQ_M_SOFT		3
-#define IRQ_U_TIMER		4
 #define IRQ_S_TIMER		5
 #define IRQ_M_TIMER		7
-#define IRQ_U_EXT		8
 #define IRQ_S_EXT		9
 #define IRQ_M_EXT		11

arch/riscv/include/asm/hwcap.h+22−0

@@ -8,6 +8,7 @@ · 7 unmodified lines
8	#ifndef _ASM_RISCV_HWCAP_H	8	#ifndef _ASM_RISCV_HWCAP_H
9	#define _ASM_RISCV_HWCAP_H	9	#define _ASM_RISCV_HWCAP_H
10		10
		11	#include <linux/bits.h>
11	#include <uapi/asm/hwcap.h>	12	#include <uapi/asm/hwcap.h>
12		13
13	#ifndef __ASSEMBLY__	14	#ifndef __ASSEMBLY__
@@ -22,6 +23,27 @@ enum { · 8 unmodified lines
22	};	23	};
23		24
24	extern unsigned long elf_hwcap;	25	extern unsigned long elf_hwcap;
		26
		27	#define RISCV_ISA_EXT_a ('a' - 'a')
		28	#define RISCV_ISA_EXT_c ('c' - 'a')
		29	#define RISCV_ISA_EXT_d ('d' - 'a')
		30	#define RISCV_ISA_EXT_f ('f' - 'a')
		31	#define RISCV_ISA_EXT_h ('h' - 'a')
		32	#define RISCV_ISA_EXT_i ('i' - 'a')
		33	#define RISCV_ISA_EXT_m ('m' - 'a')
		34	#define RISCV_ISA_EXT_s ('s' - 'a')
		35	#define RISCV_ISA_EXT_u ('u' - 'a')
		36
		37	#define RISCV_ISA_EXT_MAX 64
		38
		39	unsigned long riscv_isa_extension_base(const unsigned long *isa_bitmap);
		40
		41	#define riscv_isa_extension_mask(ext) BIT_MASK(RISCV_ISA_EXT_##ext)
		42
		43	bool __riscv_isa_extension_available(const unsigned long *isa_bitmap, int bit);
		44	#define riscv_isa_extension_available(isa_bitmap, ext) \
		45	__riscv_isa_extension_available(isa_bitmap, RISCV_ISA_EXT_##ext)
		46
25	#endif	47	#endif
26		48
27	#endif /* _ASM_RISCV_HWCAP_H */	49	#endif /* _ASM_RISCV_HWCAP_H */

arch/riscv/include/asm/set_memory.h+0−8

@@ -22,14 +22,6 @@ static inline int set_memory_x(unsigned long addr, int numpages) { return 0; } · 21 unmodified lines
22	static inline int set_memory_nx(unsigned long addr, int numpages) { return 0; }	22	static inline int set_memory_nx(unsigned long addr, int numpages) { return 0; }
23	#endif	23	#endif
24		24
25	#ifdef CONFIG_STRICT_KERNEL_RWX
26	void set_kernel_text_ro(void);
27	void set_kernel_text_rw(void);
28	#else
29	static inline void set_kernel_text_ro(void) { }
30	static inline void set_kernel_text_rw(void) { }
31	#endif
32
33	int set_direct_map_invalid_noflush(struct page *page);	25	int set_direct_map_invalid_noflush(struct page *page);
34	int set_direct_map_default_noflush(struct page *page);	26	int set_direct_map_default_noflush(struct page *page);
35		27

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

@@ -15,8 +15,8 @@ · 14 unmodified lines
15		15
16	const struct cpu_operations *cpu_ops[NR_CPUS] __ro_after_init;	16	const struct cpu_operations *cpu_ops[NR_CPUS] __ro_after_init;
17		17
18	void *__cpu_up_stack_pointer[NR_CPUS];	18	void *__cpu_up_stack_pointer[NR_CPUS] __section(.data);
19	void *__cpu_up_task_pointer[NR_CPUS];	19	void *__cpu_up_task_pointer[NR_CPUS] __section(.data);
20		20
21	extern const struct cpu_operations cpu_ops_sbi;	21	extern const struct cpu_operations cpu_ops_sbi;
22	extern const struct cpu_operations cpu_ops_spinwait;	22	extern const struct cpu_operations cpu_ops_spinwait;

arch/riscv/kernel/cpufeature.c+80−3

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	* Copyright (C) 2017 SiFive	6	* Copyright (C) 2017 SiFive
7	*/	7	*/
8		8
		9	#include <linux/bitmap.h>
9	#include <linux/of.h>	10	#include <linux/of.h>
10	#include <asm/processor.h>	11	#include <asm/processor.h>
11	#include <asm/hwcap.h>	12	#include <asm/hwcap.h>
@@ -13,15 +14,57 @@ · 1 unmodified line
13	#include <asm/switch_to.h>	14	#include <asm/switch_to.h>
14		15
15	unsigned long elf_hwcap __read_mostly;	16	unsigned long elf_hwcap __read_mostly;
		17
		18	/* Host ISA bitmap */
		19	static DECLARE_BITMAP(riscv_isa, RISCV_ISA_EXT_MAX) __read_mostly;
		20
16	#ifdef CONFIG_FPU	21	#ifdef CONFIG_FPU
17	bool has_fpu __read_mostly;	22	bool has_fpu __read_mostly;
18	#endif	23	#endif
19		24
		25	/**
		26	* riscv_isa_extension_base() - Get base extension word
		27	*
		28	* @isa_bitmap: ISA bitmap to use
		29	* Return: base extension word as unsigned long value
		30	*
		31	* NOTE: If isa_bitmap is NULL then Host ISA bitmap will be used.
		32	*/
		33	unsigned long riscv_isa_extension_base(const unsigned long *isa_bitmap)
		34	{
		35	if (!isa_bitmap)
		36	return riscv_isa[0];
		37	return isa_bitmap[0];
		38	}
		39	EXPORT_SYMBOL_GPL(riscv_isa_extension_base);
		40
		41	/**
		42	* __riscv_isa_extension_available() - Check whether given extension
		43	* is available or not
		44	*
		45	* @isa_bitmap: ISA bitmap to use
		46	* @bit: bit position of the desired extension
		47	* Return: true or false
		48	*
		49	* NOTE: If isa_bitmap is NULL then Host ISA bitmap will be used.
		50	*/
		51	bool __riscv_isa_extension_available(const unsigned long *isa_bitmap, int bit)
		52	{
		53	const unsigned long *bmap = (isa_bitmap) ? isa_bitmap : riscv_isa;
		54
		55	if (bit >= RISCV_ISA_EXT_MAX)
		56	return false;
		57
		58	return test_bit(bit, bmap) ? true : false;
		59	}
		60	EXPORT_SYMBOL_GPL(__riscv_isa_extension_available);
		61
20	void riscv_fill_hwcap(void)	62	void riscv_fill_hwcap(void)
21	{	63	{
22	struct device_node *node;	64	struct device_node *node;
23	const char *isa;	65	const char *isa;
24	size_t i;	66	char print_str[BITS_PER_LONG + 1];
		67	size_t i, j, isa_len;
25	static unsigned long isa2hwcap[256] = {0};	68	static unsigned long isa2hwcap[256] = {0};
26		69
27	isa2hwcap['i'] = isa2hwcap['I'] = COMPAT_HWCAP_ISA_I;	70	isa2hwcap['i'] = isa2hwcap['I'] = COMPAT_HWCAP_ISA_I;
@@ -33,8 +76,11 @@ void riscv_fill_hwcap(void) · 5 unmodified lines
33		76
34	elf_hwcap = 0;	77	elf_hwcap = 0;
35		78
		79	bitmap_zero(riscv_isa, RISCV_ISA_EXT_MAX);
		80
36	for_each_of_cpu_node(node) {	81	for_each_of_cpu_node(node) {
37	unsigned long this_hwcap = 0;	82	unsigned long this_hwcap = 0;
		83	unsigned long this_isa = 0;
38		84
39	if (riscv_of_processor_hartid(node) < 0)	85	if (riscv_of_processor_hartid(node) < 0)
40	continue;	86	continue;
@@ -44,8 +90,24 @@ void riscv_fill_hwcap(void) · 3 unmodified lines
44	continue;	90	continue;
45	}	91	}
46		92
47	for (i = 0; i < strlen(isa); ++i)	93	i = 0;
		94	isa_len = strlen(isa);
		95	#if IS_ENABLED(CONFIG_32BIT)
		96	if (!strncmp(isa, "rv32", 4))
		97	i += 4;
		98	#elif IS_ENABLED(CONFIG_64BIT)
		99	if (!strncmp(isa, "rv64", 4))
		100	i += 4;
		101	#endif
		102	for (; i < isa_len; ++i) {
48	this_hwcap \|= isa2hwcap[(unsigned char)(isa[i])];	103	this_hwcap \|= isa2hwcap[(unsigned char)(isa[i])];
		104	/*
		105	* TODO: X, Y and Z extension parsing for Host ISA
		106	* bitmap will be added in-future.
		107	*/
		108	if ('a' <= isa[i] && isa[i] < 'x')
		109	this_isa \|= (1UL << (isa[i] - 'a'));
		110	}
49		111
50	/*	112	/*
51	* All "okay" hart should have same isa. Set HWCAP based on	113	* All "okay" hart should have same isa. Set HWCAP based on
@@ -56,6 +118,11 @@ void riscv_fill_hwcap(void) · 4 unmodified lines
56	elf_hwcap &= this_hwcap;	118	elf_hwcap &= this_hwcap;
57	else	119	else
58	elf_hwcap = this_hwcap;	120	elf_hwcap = this_hwcap;
		121
		122	if (riscv_isa[0])
		123	riscv_isa[0] &= this_isa;
		124	else
		125	riscv_isa[0] = this_isa;
59	}	126	}
60		127
61	/* We don't support systems with F but without D, so mask those out	128	/* We don't support systems with F but without D, so mask those out
@@ -65,7 +132,17 @@ void riscv_fill_hwcap(void) · 3 unmodified lines
65	elf_hwcap &= ~COMPAT_HWCAP_ISA_F;	132	elf_hwcap &= ~COMPAT_HWCAP_ISA_F;
66	}	133	}
67		134
68	pr_info("elf_hwcap is 0x%lx\n", elf_hwcap);	135	memset(print_str, 0, sizeof(print_str));
		136	for (i = 0, j = 0; i < BITS_PER_LONG; i++)
		137	if (riscv_isa[0] & BIT_MASK(i))
		138	print_str[j++] = (char)('a' + i);
		139	pr_info("riscv: ISA extensions %s\n", print_str);
		140
		141	memset(print_str, 0, sizeof(print_str));
		142	for (i = 0, j = 0; i < BITS_PER_LONG; i++)
		143	if (elf_hwcap & BIT_MASK(i))
		144	print_str[j++] = (char)('a' + i);
		145	pr_info("riscv: ELF capabilities %s\n", print_str);
69		146
70	#ifdef CONFIG_FPU	147	#ifdef CONFIG_FPU
71	if (elf_hwcap & (COMPAT_HWCAP_ISA_F \| COMPAT_HWCAP_ISA_D))	148	if (elf_hwcap & (COMPAT_HWCAP_ISA_F \| COMPAT_HWCAP_ISA_D))

arch/riscv/kernel/sbi.c+10−7

 {
 	sbi_ecall(SBI_EXT_0_1_SHUTDOWN, 0, 0, 0, 0, 0, 0, 0);
 }
-EXPORT_SYMBOL(sbi_set_timer);
+EXPORT_SYMBOL(sbi_shutdown);
 /**
  * sbi_clear_ipi() - Clear any pending IPIs for the calling hart.
 {
 	sbi_ecall(SBI_EXT_0_1_CLEAR_IPI, 0, 0, 0, 0, 0, 0, 0);
 }
-EXPORT_SYMBOL(sbi_shutdown);
+EXPORT_SYMBOL(sbi_clear_ipi);
 /**
  * sbi_set_timer_v01() - Program the timer for next timer event.
 	return result;
 }
+static void sbi_set_power_off(void)
+{
+	pm_power_off = sbi_shutdown;
+}
 #else
 static void __sbi_set_timer_v01(uint64_t stime_value)
 {
 	return 0;
 }
+static void sbi_set_power_off(void) {}
 #endif /* CONFIG_RISCV_SBI_V01 */
 static void __sbi_set_timer_v02(uint64_t stime_value)
 	return __sbi_base_ecall(SBI_EXT_BASE_GET_IMP_VERSION);
 }
-static void sbi_power_off(void)
-{
-	sbi_shutdown();
-}
 int __init sbi_init(void)
 {
 	int ret;
-	pm_power_off = sbi_power_off;
+	sbi_set_power_off();
 	ret = sbi_get_spec_version();
 	if (ret > 0)
 		sbi_spec_version = ret;

arch/riscv/kernel/smp.c+2−0

 #include <linux/cpu.h>
 #include <linux/interrupt.h>
+#include <linux/module.h>
 #include <linux/profile.h>
 #include <linux/smp.h>
 #include <linux/sched.h>
 	for_each_cpu(cpu, in)
 		cpumask_set_cpu(cpuid_to_hartid_map(cpu), out);
 }
+EXPORT_SYMBOL_GPL(riscv_cpuid_to_hartid_mask);
 bool arch_match_cpu_phys_id(int cpu, u64 phys_id)
 {

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

 #include <linux/stacktrace.h>
 #include <linux/ftrace.h>
+register unsigned long sp_in_global __asm__("sp");
 #ifdef CONFIG_FRAME_POINTER
 struct stackframe {
 	unsigned long ra;
 };
-register unsigned long sp_in_global __asm__("sp");
 void notrace walk_stackframe(struct task_struct *task, struct pt_regs *regs,
 			     bool (*fn)(unsigned long, void *), void *arg)
 {

arch/riscv/kernel/vdso/Makefile+4−4

@@ -12,7 +12,7 @@ vdso-syms += getcpu · 11 unmodified lines
12	vdso-syms += flush_icache	12	vdso-syms += flush_icache
13		13
14	# Files to link into the vdso	14	# Files to link into the vdso
15	obj-vdso = $(patsubst %, %.o, $(vdso-syms))	15	obj-vdso = $(patsubst %, %.o, $(vdso-syms)) note.o
16		16
17	# Build rules	17	# Build rules
18	targets := $(obj-vdso) vdso.so vdso.so.dbg vdso.lds vdso-dummy.o	18	targets := $(obj-vdso) vdso.so vdso.so.dbg vdso.lds vdso-dummy.o
@@ -33,15 +33,15 @@ $(obj)/vdso.so.dbg: $(src)/vdso.lds $(obj-vdso) FORCE · 14 unmodified lines
33	$(call if_changed,vdsold)	33	$(call if_changed,vdsold)
34		34
35	# We also create a special relocatable object that should mirror the symbol	35	# We also create a special relocatable object that should mirror the symbol
36	# table and layout of the linked DSO. With ld -R we can then refer to	36	# table and layout of the linked DSO. With ld --just-symbols we can then
37	# these symbols in the kernel code rather than hand-coded addresses.	37	# refer to these symbols in the kernel code rather than hand-coded addresses.
38		38
39	SYSCFLAGS_vdso.so.dbg = -shared -s -Wl,-soname=linux-vdso.so.1 \	39	SYSCFLAGS_vdso.so.dbg = -shared -s -Wl,-soname=linux-vdso.so.1 \
40	-Wl,--build-id -Wl,--hash-style=both	40	-Wl,--build-id -Wl,--hash-style=both
41	$(obj)/vdso-dummy.o: $(src)/vdso.lds $(obj)/rt_sigreturn.o FORCE	41	$(obj)/vdso-dummy.o: $(src)/vdso.lds $(obj)/rt_sigreturn.o FORCE
42	$(call if_changed,vdsold)	42	$(call if_changed,vdsold)
43		43
44	LDFLAGS_vdso-syms.o := -r -R	44	LDFLAGS_vdso-syms.o := -r --just-symbols
45	$(obj)/vdso-syms.o: $(obj)/vdso-dummy.o FORCE	45	$(obj)/vdso-syms.o: $(obj)/vdso-dummy.o FORCE
46	$(call if_changed,ld)	46	$(call if_changed,ld)
47		47

arch/riscv/kernel/vdso/note.S+12−0

@@ -0,0 +1,12 @@
	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
	2	/*
	3	* This supplies .note.* sections to go into the PT_NOTE inside the vDSO text.
	4	* Here we can supply some information useful to userland.
	5	*/
	6
	7	#include <linux/elfnote.h>
	8	#include <linux/version.h>
	9
	10	ELFNOTE_START(Linux, 0, "a")
	11	.long LINUX_VERSION_CODE
	12	ELFNOTE_END

arch/riscv/mm/init.c+2−17

@@ -150,7 +150,8 @@ void __init setup_bootmem(void) · 149 unmodified lines
150	memblock_reserve(vmlinux_start, vmlinux_end - vmlinux_start);	150	memblock_reserve(vmlinux_start, vmlinux_end - vmlinux_start);
151		151
152	set_max_mapnr(PFN_DOWN(mem_size));	152	set_max_mapnr(PFN_DOWN(mem_size));
153	max_low_pfn = PFN_DOWN(memblock_end_of_DRAM());	153	max_pfn = PFN_DOWN(memblock_end_of_DRAM());
		154	max_low_pfn = max_pfn;
154		155
155	#ifdef CONFIG_BLK_DEV_INITRD	156	#ifdef CONFIG_BLK_DEV_INITRD
156	setup_initrd();	157	setup_initrd();
@@ -501,22 +502,6 @@ static inline void setup_vm_final(void) · 344 unmodified lines
501	#endif /* CONFIG_MMU */	502	#endif /* CONFIG_MMU */
502		503
503	#ifdef CONFIG_STRICT_KERNEL_RWX	504	#ifdef CONFIG_STRICT_KERNEL_RWX
504	void set_kernel_text_rw(void)
505	{
506	unsigned long text_start = (unsigned long)_text;
507	unsigned long text_end = (unsigned long)_etext;
508
509	set_memory_rw(text_start, (text_end - text_start) >> PAGE_SHIFT);
510	}
511
512	void set_kernel_text_ro(void)
513	{
514	unsigned long text_start = (unsigned long)_text;
515	unsigned long text_end = (unsigned long)_etext;
516
517	set_memory_ro(text_start, (text_end - text_start) >> PAGE_SHIFT);
518	}
519
520	void mark_rodata_ro(void)	505	void mark_rodata_ro(void)
521	{	506	{
522	unsigned long text_start = (unsigned long)_text;	507	unsigned long text_start = (unsigned long)_text;

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

@@ -545,6 +545,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) · 544 unmodified lines
545	case KVM_CAP_S390_AIS:	545	case KVM_CAP_S390_AIS:
546	case KVM_CAP_S390_AIS_MIGRATION:	546	case KVM_CAP_S390_AIS_MIGRATION:
547	case KVM_CAP_S390_VCPU_RESETS:	547	case KVM_CAP_S390_VCPU_RESETS:
		548	case KVM_CAP_SET_GUEST_DEBUG:
548	r = 1;	549	r = 1;
549	break;	550	break;
550	case KVM_CAP_S390_HPAGE_1M:	551	case KVM_CAP_S390_HPAGE_1M:

arch/s390/kvm/priv.c+3−1

 	 * available for the guest are AQIC and TAPQ with the t bit set
 	 * since we do not set IC.3 (FIII) we currently will only intercept
 	 * the AQIC function code.
+	 * Note: running nested under z/VM can result in intercepts for other
+	 * function codes, e.g. PQAP(QCI). We do not support this and bail out.
 	 */
 	reg0 = vcpu->run->s.regs.gprs[0];
 	fc = (reg0 >> 24) & 0xff;
-	if (WARN_ON_ONCE(fc != 0x03))
+	if (fc != 0x03)
 		return -EOPNOTSUPP;
 	/* PQAP instruction is allowed for guest kernel only */

arch/s390/lib/uaccess.c+4−0

 {
 	mm_segment_t old_fs;
 	unsigned long asce, cr;
+	unsigned long flags;
 	old_fs = current->thread.mm_segment;
 	if (old_fs & 1)
 		return old_fs;
+	/* protect against a concurrent page table upgrade */
+	local_irq_save(flags);
 	current->thread.mm_segment |= 1;
 	asce = S390_lowcore.kernel_asce;
 	if (likely(old_fs == USER_DS)) {
 		__ctl_load(asce, 7, 7);
 		set_cpu_flag(CIF_ASCE_SECONDARY);
 	}
+	local_irq_restore(flags);
 	return old_fs;
 }
 EXPORT_SYMBOL(enable_sacf_uaccess);

arch/s390/mm/pgalloc.c+14−2

@@ -70,8 +70,20 @@ static void __crst_table_upgrade(void *arg) · 69 unmodified lines
70	{	70	{
71	struct mm_struct *mm = arg;	71	struct mm_struct *mm = arg;
72		72
73	if (current->active_mm == mm)	73	/* we must change all active ASCEs to avoid the creation of new TLBs */
74	set_user_asce(mm);	74	if (current->active_mm == mm) {
		75	S390_lowcore.user_asce = mm->context.asce;
		76	if (current->thread.mm_segment == USER_DS) {
		77	__ctl_load(S390_lowcore.user_asce, 1, 1);
		78	/* Mark user-ASCE present in CR1 */
		79	clear_cpu_flag(CIF_ASCE_PRIMARY);
		80	}
		81	if (current->thread.mm_segment == USER_DS_SACF) {
		82	__ctl_load(S390_lowcore.user_asce, 7, 7);
		83	/* enable_sacf_uaccess does all or nothing */
		84	WARN_ON(!test_cpu_flag(CIF_ASCE_SECONDARY));
		85	}
		86	}
75	__tlb_flush_local();	87	__tlb_flush_local();
76	}	88	}
77		89

arch/x86/crypto/blake2s-glue.c+4−6

 			   const u32 inc)
 {
 	/* SIMD disables preemption, so relax after processing each page. */
-	BUILD_BUG_ON(PAGE_SIZE / BLAKE2S_BLOCK_SIZE < 8);
+	BUILD_BUG_ON(SZ_4K / BLAKE2S_BLOCK_SIZE < 8);
 	if (!static_branch_likely(&blake2s_use_ssse3) || !crypto_simd_usable()) {
 		blake2s_compress_generic(state, block, nblocks, inc);
 		return;
 	}
-	for (;;) {
+	do {
 		const size_t blocks = min_t(size_t, nblocks,
-					    PAGE_SIZE / BLAKE2S_BLOCK_SIZE);
+					    SZ_4K / BLAKE2S_BLOCK_SIZE);
 		kernel_fpu_begin();
 		if (IS_ENABLED(CONFIG_AS_AVX512) &&
 		kernel_fpu_end();
 		nblocks -= blocks;
-		if (!nblocks)
-			break;
 		block += blocks * BLAKE2S_BLOCK_SIZE;
-	}
+	} while (nblocks);
 }
 EXPORT_SYMBOL(blake2s_compress_arch);

arch/x86/crypto/chacha_glue.c+11−3

@@ -153,9 +153,17 @@ void chacha_crypt_arch(u32 state, u8 dst, const u8 *src, unsigned int bytes, · 152 unmodified lines
153	bytes <= CHACHA_BLOCK_SIZE)	153	bytes <= CHACHA_BLOCK_SIZE)
154	return chacha_crypt_generic(state, dst, src, bytes, nrounds);	154	return chacha_crypt_generic(state, dst, src, bytes, nrounds);
155		155
156	kernel_fpu_begin();	156	do {
157	chacha_dosimd(state, dst, src, bytes, nrounds);	157	unsigned int todo = min_t(unsigned int, bytes, SZ_4K);
158	kernel_fpu_end();	158
		159	kernel_fpu_begin();
		160	chacha_dosimd(state, dst, src, todo, nrounds);
		161	kernel_fpu_end();
		162
		163	bytes -= todo;
		164	src += todo;
		165	dst += todo;
		166	} while (bytes);
159	}	167	}
160	EXPORT_SYMBOL(chacha_crypt_arch);	168	EXPORT_SYMBOL(chacha_crypt_arch);
161		169

arch/x86/crypto/nhpoly1305-avx2-glue.c+1−1

@@ -29,7 +29,7 @@ static int nhpoly1305_avx2_update(struct shash_desc *desc, · 28 unmodified lines
29	return crypto_nhpoly1305_update(desc, src, srclen);	29	return crypto_nhpoly1305_update(desc, src, srclen);
30		30
31	do {	31	do {
32	unsigned int n = min_t(unsigned int, srclen, PAGE_SIZE);	32	unsigned int n = min_t(unsigned int, srclen, SZ_4K);
33		33
34	kernel_fpu_begin();	34	kernel_fpu_begin();
35	crypto_nhpoly1305_update_helper(desc, src, n, _nh_avx2);	35	crypto_nhpoly1305_update_helper(desc, src, n, _nh_avx2);

arch/x86/crypto/nhpoly1305-sse2-glue.c+1−1

@@ -29,7 +29,7 @@ static int nhpoly1305_sse2_update(struct shash_desc *desc, · 28 unmodified lines
29	return crypto_nhpoly1305_update(desc, src, srclen);	29	return crypto_nhpoly1305_update(desc, src, srclen);
30		30
31	do {	31	do {
32	unsigned int n = min_t(unsigned int, srclen, PAGE_SIZE);	32	unsigned int n = min_t(unsigned int, srclen, SZ_4K);
33		33
34	kernel_fpu_begin();	34	kernel_fpu_begin();
35	crypto_nhpoly1305_update_helper(desc, src, n, _nh_sse2);	35	crypto_nhpoly1305_update_helper(desc, src, n, _nh_sse2);

arch/x86/crypto/poly1305_glue.c+6−7

 	struct poly1305_arch_internal *state = ctx;
 	/* SIMD disables preemption, so relax after processing each page. */
-	BUILD_BUG_ON(PAGE_SIZE < POLY1305_BLOCK_SIZE ||
+	BUILD_BUG_ON(SZ_4K < POLY1305_BLOCK_SIZE ||
-		     PAGE_SIZE % POLY1305_BLOCK_SIZE);
+		     SZ_4K % POLY1305_BLOCK_SIZE);
 	if (!static_branch_likely(&poly1305_use_avx) ||
 	    (len < (POLY1305_BLOCK_SIZE * 18) && !state->is_base2_26) ||
 		return;
 	}
-	for (;;) {
+	do {
-		const size_t bytes = min_t(size_t, len, PAGE_SIZE);
+		const size_t bytes = min_t(size_t, len, SZ_4K);
 		kernel_fpu_begin();
 		if (IS_ENABLED(CONFIG_AS_AVX512) && static_branch_likely(&poly1305_use_avx512))
 		else
 			poly1305_blocks_avx(ctx, inp, bytes, padbit);
 		kernel_fpu_end();
 		len -= bytes;
-		if (!len)
-			break;
 		inp += bytes;
-	}
+	} while (len);
 }
 static void poly1305_simd_emit(void *ctx, u8 mac[POLY1305_DIGEST_SIZE],

arch/x86/entry/calling.h+21−19

 #define SIZEOF_PTREGS	21*8
 .macro PUSH_AND_CLEAR_REGS rdx=%rdx rax=%rax save_ret=0
-	/*
-	 * Push registers and sanitize registers of values that a
-	 * speculation attack might otherwise want to exploit. The
-	 * lower registers are likely clobbered well before they
-	 * could be put to use in a speculative execution gadget.
-	 * Interleave XOR with PUSH for better uop scheduling:
-	 */
 	.if \save_ret
 	pushq	%rsi		/* pt_regs->si */
 	movq	8(%rsp), %rsi	/* temporarily store the return address in %rsi */
 	pushq   %rsi		/* pt_regs->si */
 	.endif
 	pushq	\rdx		/* pt_regs->dx */
-	xorl	%edx, %edx	/* nospec   dx */
 	pushq   %rcx		/* pt_regs->cx */
-	xorl	%ecx, %ecx	/* nospec   cx */
 	pushq   \rax		/* pt_regs->ax */
 	pushq   %r8		/* pt_regs->r8 */
-	xorl	%r8d, %r8d	/* nospec   r8 */
 	pushq   %r9		/* pt_regs->r9 */
-	xorl	%r9d, %r9d	/* nospec   r9 */
 	pushq   %r10		/* pt_regs->r10 */
-	xorl	%r10d, %r10d	/* nospec   r10 */
 	pushq   %r11		/* pt_regs->r11 */
-	xorl	%r11d, %r11d	/* nospec   r11*/
 	pushq	%rbx		/* pt_regs->rbx */
-	xorl    %ebx, %ebx	/* nospec   rbx*/
 	pushq	%rbp		/* pt_regs->rbp */
-	xorl    %ebp, %ebp	/* nospec   rbp*/
 	pushq	%r12		/* pt_regs->r12 */
-	xorl	%r12d, %r12d	/* nospec   r12*/
 	pushq	%r13		/* pt_regs->r13 */
-	xorl	%r13d, %r13d	/* nospec   r13*/
 	pushq	%r14		/* pt_regs->r14 */
-	xorl	%r14d, %r14d	/* nospec   r14*/
 	pushq	%r15		/* pt_regs->r15 */
-	xorl	%r15d, %r15d	/* nospec   r15*/
 	UNWIND_HINT_REGS
 	.if \save_ret
 	pushq	%rsi		/* return address on top of stack */
 	.endif
+	/*
+	 * Sanitize registers of values that a speculation attack might
+	 * otherwise want to exploit. The lower registers are likely clobbered
+	 * well before they could be put to use in a speculative execution
+	 * gadget.
+	 */
+	xorl	%edx,  %edx	/* nospec dx  */
+	xorl	%ecx,  %ecx	/* nospec cx  */
+	xorl	%r8d,  %r8d	/* nospec r8  */
+	xorl	%r9d,  %r9d	/* nospec r9  */
+	xorl	%r10d, %r10d	/* nospec r10 */
+	xorl	%r11d, %r11d	/* nospec r11 */
+	xorl	%ebx,  %ebx	/* nospec rbx */
+	xorl	%ebp,  %ebp	/* nospec rbp */
+	xorl	%r12d, %r12d	/* nospec r12 */
+	xorl	%r13d, %r13d	/* nospec r13 */
+	xorl	%r14d, %r14d	/* nospec r14 */
+	xorl	%r15d, %r15d	/* nospec r15 */
 .endm
 .macro POP_REGS pop_rdi=1 skip_r11rcx=0

arch/x86/entry/entry_64.S+7−7

 	 */
 syscall_return_via_sysret:
 	/* rcx and r11 are already restored (see code above) */
-	UNWIND_HINT_EMPTY
 	POP_REGS pop_rdi=0 skip_r11rcx=1
 	/*
 	 */
 	movq	%rsp, %rdi
 	movq	PER_CPU_VAR(cpu_tss_rw + TSS_sp0), %rsp
+	UNWIND_HINT_EMPTY
 	pushq	RSP-RDI(%rdi)	/* RSP */
 	pushq	(%rdi)		/* RDI */
  * %rdi: prev task
  * %rsi: next task
  */
-SYM_CODE_START(__switch_to_asm)
+SYM_FUNC_START(__switch_to_asm)
-	UNWIND_HINT_FUNC
 	/*
 	 * Save callee-saved registers
 	 * This must match the order in inactive_task_frame
 	popq	%rbp
 	jmp	__switch_to
-SYM_CODE_END(__switch_to_asm)
+SYM_FUNC_END(__switch_to_asm)
 /*
  * A newly forked process directly context switches into this address.
  * +----------------------------------------------------+
  */
 SYM_CODE_START(interrupt_entry)
-	UNWIND_HINT_FUNC
+	UNWIND_HINT_IRET_REGS offset=16
 	ASM_CLAC
 	cld
 	pushq	5*8(%rdi)		/* regs->eflags */
 	pushq	4*8(%rdi)		/* regs->cs */
 	pushq	3*8(%rdi)		/* regs->ip */
+	UNWIND_HINT_IRET_REGS
 	pushq	2*8(%rdi)		/* regs->orig_ax */
 	pushq	8(%rdi)			/* return address */
-	UNWIND_HINT_FUNC
 	movq	(%rdi), %rdi
 	jmp	2f
 	 */
 	movq	%rsp, %rdi
 	movq	PER_CPU_VAR(cpu_tss_rw + TSS_sp0), %rsp
+	UNWIND_HINT_EMPTY
 	/* Copy the IRET frame to the trampoline stack. */
 	pushq	6*8(%rdi)	/* SS */
 	movq	PER_CPU_VAR(cpu_current_top_of_stack), %rax
 	leaq	-PTREGS_SIZE(%rax), %rsp
-	UNWIND_HINT_FUNC sp_offset=PTREGS_SIZE
+	UNWIND_HINT_REGS
 	call	do_exit
 SYM_CODE_END(rewind_stack_do_exit)

arch/x86/hyperv/hv_init.c+10−2

 	struct page *pg;
 	input_arg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg);
-	pg = alloc_page(GFP_KERNEL);
+	/* hv_cpu_init() can be called with IRQs disabled from hv_resume() */
+	pg = alloc_page(irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
 	if (unlikely(!pg))
 		return -ENOMEM;
 	*input_arg = page_address(pg);
 static int hv_suspend(void)
 {
 	union hv_x64_msr_hypercall_contents hypercall_msr;
+	int ret;
 	/*
 	 * Reset the hypercall page as it is going to be invalidated
 	hypercall_msr.enable = 0;
 	wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
-	return 0;
+	ret = hv_cpu_die(0);
+	return ret;
 }
 static void hv_resume(void)
 {
 	union hv_x64_msr_hypercall_contents hypercall_msr;
+	int ret;
+	ret = hv_cpu_init(0);
+	WARN_ON(ret);
 	/* Re-enable the hypercall page */
 	rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
 	hv_hypercall_pg_saved = NULL;
 }
+/* Note: when the ops are called, only CPU0 is online and IRQs are disabled. */
 static struct syscore_ops hv_syscore_ops = {
 	.suspend	= hv_suspend,
 	.resume		= hv_resume,

arch/x86/include/asm/ftrace.h+3−2

 {
 	/*
 	 * Compare the symbol name with the system call name. Skip the
-	 * "__x64_sys", "__ia32_sys" or simple "sys" prefix.
+	 * "__x64_sys", "__ia32_sys", "__do_sys" or simple "sys" prefix.
 	 */
 	return !strcmp(sym + 3, name + 3) ||
 		(!strncmp(sym, "__x64_", 6) && !strcmp(sym + 9, name + 3)) ||
-		(!strncmp(sym, "__ia32_", 7) && !strcmp(sym + 10, name + 3));
+		(!strncmp(sym, "__ia32_", 7) && !strcmp(sym + 10, name + 3)) ||
+		(!strncmp(sym, "__do_sys", 8) && !strcmp(sym + 8, name + 3));
 }
 #ifndef COMPILE_OFFSETS

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

@@ -1663,8 +1663,8 @@ void kvm_set_msi_irq(struct kvm kvm, struct kvm_kernel_irq_routing_entry e, · 1662 unmodified lines
1663	static inline bool kvm_irq_is_postable(struct kvm_lapic_irq *irq)	1663	static inline bool kvm_irq_is_postable(struct kvm_lapic_irq *irq)
1664	{	1664	{
1665	/* We can only post Fixed and LowPrio IRQs */	1665	/* We can only post Fixed and LowPrio IRQs */
1666	return (irq->delivery_mode == dest_Fixed \|\|	1666	return (irq->delivery_mode == APIC_DM_FIXED \|\|
1667	irq->delivery_mode == dest_LowestPrio);	1667	irq->delivery_mode == APIC_DM_LOWEST);
1668	}	1668	}
1669		1669
1670	static inline void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu)	1670	static inline void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu)

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

@@ -35,6 +35,8 @@ typedef int (*hyperv_fill_flush_list_func)( · 34 unmodified lines
35	rdmsrl(HV_X64_MSR_SINT0 + int_num, val)	35	rdmsrl(HV_X64_MSR_SINT0 + int_num, val)
36	#define hv_set_synint_state(int_num, val) \	36	#define hv_set_synint_state(int_num, val) \
37	wrmsrl(HV_X64_MSR_SINT0 + int_num, val)	37	wrmsrl(HV_X64_MSR_SINT0 + int_num, val)
		38	#define hv_recommend_using_aeoi() \
		39	(!(ms_hyperv.hints & HV_DEPRECATING_AEOI_RECOMMENDED))
38		40
39	#define hv_get_crash_ctl(val) \	41	#define hv_get_crash_ctl(val) \
40	rdmsrl(HV_X64_MSR_CRASH_CTL, val)	42	rdmsrl(HV_X64_MSR_CRASH_CTL, val)

arch/x86/include/asm/unwind.h+1−1

@@ -19,7 +19,7 @@ struct unwind_state { · 18 unmodified lines
19	#if defined(CONFIG_UNWINDER_ORC)	19	#if defined(CONFIG_UNWINDER_ORC)
20	bool signal, full_regs;	20	bool signal, full_regs;
21	unsigned long sp, bp, ip;	21	unsigned long sp, bp, ip;
22	struct pt_regs *regs;	22	struct pt_regs regs, prev_regs;
23	#elif defined(CONFIG_UNWINDER_FRAME_POINTER)	23	#elif defined(CONFIG_UNWINDER_FRAME_POINTER)
24	bool got_irq;	24	bool got_irq;
25	unsigned long bp, orig_sp, ip;	25	unsigned long bp, orig_sp, ip;

arch/x86/kernel/apic/apic.c+14−13

 		 * According to Intel, MFENCE can do the serialization here.
 		 */
 		asm volatile("mfence" : : : "memory");
-		printk_once(KERN_DEBUG "TSC deadline timer enabled\n");
 		return;
 	}
 };
 static DEFINE_PER_CPU(struct clock_event_device, lapic_events);
-static u32 hsx_deadline_rev(void)
+static __init u32 hsx_deadline_rev(void)
 {
 	switch (boot_cpu_data.x86_stepping) {
 	case 0x02: return 0x3a; /* EP */
 	return ~0U;
 }
-static u32 bdx_deadline_rev(void)
+static __init u32 bdx_deadline_rev(void)
 {
 	switch (boot_cpu_data.x86_stepping) {
 	case 0x02: return 0x00000011;
 	return ~0U;
 }
-static u32 skx_deadline_rev(void)
+static __init u32 skx_deadline_rev(void)
 {
 	switch (boot_cpu_data.x86_stepping) {
 	case 0x03: return 0x01000136;
 	return ~0U;
 }
-static const struct x86_cpu_id deadline_match[] = {
+static const struct x86_cpu_id deadline_match[] __initconst = {
 	X86_MATCH_INTEL_FAM6_MODEL( HASWELL_X,		&hsx_deadline_rev),
 	X86_MATCH_INTEL_FAM6_MODEL( BROADWELL_X,	0x0b000020),
 	X86_MATCH_INTEL_FAM6_MODEL( BROADWELL_D,	&bdx_deadline_rev),
 	{},
 };
-static void apic_check_deadline_errata(void)
+static __init bool apic_validate_deadline_timer(void)
 {
 	const struct x86_cpu_id *m;
 	u32 rev;
-	if (!boot_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER) ||
+	if (!boot_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER))
-	    boot_cpu_has(X86_FEATURE_HYPERVISOR))
+		return false;
-		return;
+	if (boot_cpu_has(X86_FEATURE_HYPERVISOR))
+		return true;
 	m = x86_match_cpu(deadline_match);
 	if (!m)
-		return;
+		return true;
 	/*
 	 * Function pointers will have the MSB set due to address layout,
 		rev = (u32)m->driver_data;
 	if (boot_cpu_data.microcode >= rev)
-		return;
+		return true;
 	setup_clear_cpu_cap(X86_FEATURE_TSC_DEADLINE_TIMER);
 	pr_err(FW_BUG "TSC_DEADLINE disabled due to Errata; "
 	       "please update microcode to version: 0x%x (or later)\n", rev);
+	return false;
 }
 /*
 {
 	unsigned int new_apicid;
-	apic_check_deadline_errata();
+	if (apic_validate_deadline_timer())
+		pr_debug("TSC deadline timer available\n");
 	if (x2apic_mode) {
 		boot_cpu_physical_apicid = read_apic_id();

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

 	 */
 	if (visit_mask) {
 		if (*visit_mask & (1UL << info->type)) {
-			printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type);
+			if (task == current)
+				printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type);
 			goto unknown;
 		}
 		*visit_mask |= 1UL << info->type;

arch/x86/kernel/unwind_frame.c+3−0

@@ -344,6 +344,9 @@ bad_address: · 343 unmodified lines
344	if (IS_ENABLED(CONFIG_X86_32))	344	if (IS_ENABLED(CONFIG_X86_32))
345	goto the_end;	345	goto the_end;
346		346
		347	if (state->task != current)
		348	goto the_end;
		349
347	if (state->regs) {	350	if (state->regs) {
348	printk_deferred_once(KERN_WARNING	351	printk_deferred_once(KERN_WARNING
349	"WARNING: kernel stack regs at %p in %s:%d has bad 'bp' value %p\n",	352	"WARNING: kernel stack regs at %p in %s:%d has bad 'bp' value %p\n",

arch/x86/kernel/unwind_orc.c+74−39

 #include <asm/orc_lookup.h>
 #define orc_warn(fmt, ...) \
-	printk_deferred_once(KERN_WARNING pr_fmt("WARNING: " fmt), ##__VA_ARGS__)
+	printk_deferred_once(KERN_WARNING "WARNING: " fmt, ##__VA_ARGS__)
+#define orc_warn_current(args...)					\
+({									\
+	if (state->task == current)					\
+		orc_warn(args);						\
+})
 extern int __start_orc_unwind_ip[];
 extern int __stop_orc_unwind_ip[];
 extern struct orc_entry __start_orc_unwind[];
 extern struct orc_entry __stop_orc_unwind[];
-static DEFINE_MUTEX(sort_mutex);
+static bool orc_init __ro_after_init;
-int *cur_orc_ip_table = __start_orc_unwind_ip;
+static unsigned int lookup_num_blocks __ro_after_init;
-struct orc_entry *cur_orc_table = __start_orc_unwind;
-unsigned int lookup_num_blocks;
-bool orc_init;
 static inline unsigned long orc_ip(const int *ip)
 {
 {
 	static struct orc_entry *orc;
-	if (!orc_init)
-		return NULL;
 	if (ip == 0)
 		return &null_orc_entry;
 #ifdef CONFIG_MODULES
+static DEFINE_MUTEX(sort_mutex);
+static int *cur_orc_ip_table = __start_orc_unwind_ip;
+static struct orc_entry *cur_orc_table = __start_orc_unwind;
 static void orc_sort_swap(void *_a, void *_b, int size)
 {
 	struct orc_entry *orc_a, *orc_b;
 	return true;
 }
+/*
+ * If state->regs is non-NULL, and points to a full pt_regs, just get the reg
+ * value from state->regs.
+ *
+ * Otherwise, if state->regs just points to IRET regs, and the previous frame
+ * had full regs, it's safe to get the value from the previous regs.  This can
+ * happen when early/late IRQ entry code gets interrupted by an NMI.
+ */
+static bool get_reg(struct unwind_state *state, unsigned int reg_off,
+		    unsigned long *val)
+{
+	unsigned int reg = reg_off/8;
+	if (!state->regs)
+		return false;
+	if (state->full_regs) {
+		*val = ((unsigned long *)state->regs)[reg];
+		return true;
+	}
+	if (state->prev_regs) {
+		*val = ((unsigned long *)state->prev_regs)[reg];
+		return true;
+	}
+	return false;
+}
 bool unwind_next_frame(struct unwind_state *state)
 {
-	unsigned long ip_p, sp, orig_ip = state->ip, prev_sp = state->sp;
+	unsigned long ip_p, sp, tmp, orig_ip = state->ip, prev_sp = state->sp;
 	enum stack_type prev_type = state->stack_info.type;
 	struct orc_entry *orc;
 	bool indirect = false;
 		break;
 	case ORC_REG_R10:
-		if (!state->regs || !state->full_regs) {
+		if (!get_reg(state, offsetof(struct pt_regs, r10), &sp)) {
-			orc_warn("missing regs for base reg R10 at ip %pB\n",
+			orc_warn_current("missing R10 value at %pB\n",
-				 (void *)state->ip);
+					 (void *)state->ip);
 			goto err;
 		}
-		sp = state->regs->r10;
 		break;
 	case ORC_REG_R13:
-		if (!state->regs || !state->full_regs) {
+		if (!get_reg(state, offsetof(struct pt_regs, r13), &sp)) {
-			orc_warn("missing regs for base reg R13 at ip %pB\n",
+			orc_warn_current("missing R13 value at %pB\n",
-				 (void *)state->ip);
+					 (void *)state->ip);
 			goto err;
 		}
-		sp = state->regs->r13;
 		break;
 	case ORC_REG_DI:
-		if (!state->regs || !state->full_regs) {
+		if (!get_reg(state, offsetof(struct pt_regs, di), &sp)) {
-			orc_warn("missing regs for base reg DI at ip %pB\n",
+			orc_warn_current("missing RDI value at %pB\n",
-				 (void *)state->ip);
+					 (void *)state->ip);
 			goto err;
 		}
-		sp = state->regs->di;
 		break;
 	case ORC_REG_DX:
-		if (!state->regs || !state->full_regs) {
+		if (!get_reg(state, offsetof(struct pt_regs, dx), &sp)) {
-			orc_warn("missing regs for base reg DX at ip %pB\n",
+			orc_warn_current("missing DX value at %pB\n",
-				 (void *)state->ip);
+					 (void *)state->ip);
 			goto err;
 		}
-		sp = state->regs->dx;
 		break;
 	default:
-		orc_warn("unknown SP base reg %d for ip %pB\n",
+		orc_warn("unknown SP base reg %d at %pB\n",
 			 orc->sp_reg, (void *)state->ip);
 		goto err;
 	}
 		state->sp = sp;
 		state->regs = NULL;
+		state->prev_regs = NULL;
 		state->signal = false;
 		break;
 	case ORC_TYPE_REGS:
 		if (!deref_stack_regs(state, sp, &state->ip, &state->sp)) {
-			orc_warn("can't dereference registers at %p for ip %pB\n",
+			orc_warn_current("can't access registers at %pB\n",
-				 (void *)sp, (void *)orig_ip);
+					 (void *)orig_ip);
 			goto err;
 		}
 		state->regs = (struct pt_regs *)sp;
+		state->prev_regs = NULL;
 		state->full_regs = true;
 		state->signal = true;
 		break;
 	case ORC_TYPE_REGS_IRET:
 		if (!deref_stack_iret_regs(state, sp, &state->ip, &state->sp)) {
-			orc_warn("can't dereference iret registers at %p for ip %pB\n",
+			orc_warn_current("can't access iret registers at %pB\n",
-				 (void *)sp, (void *)orig_ip);
+					 (void *)orig_ip);
 			goto err;
 		}
+		if (state->full_regs)
+			state->prev_regs = state->regs;
 		state->regs = (void *)sp - IRET_FRAME_OFFSET;
 		state->full_regs = false;
 		state->signal = true;
 		break;
 	default:
-		orc_warn("unknown .orc_unwind entry type %d for ip %pB\n",
+		orc_warn("unknown .orc_unwind entry type %d at %pB\n",
 			 orc->type, (void *)orig_ip);
-		break;
+		goto err;
 	}
 	/* Find BP: */
 	switch (orc->bp_reg) {
 	case ORC_REG_UNDEFINED:
-		if (state->regs && state->full_regs)
+		if (get_reg(state, offsetof(struct pt_regs, bp), &tmp))
-			state->bp = state->regs->bp;
+			state->bp = tmp;
 		break;
 	case ORC_REG_PREV_SP:
 	if (state->stack_info.type == prev_type &&
 	    on_stack(&state->stack_info, (void *)state->sp, sizeof(long)) &&
 	    state->sp <= prev_sp) {
-		orc_warn("stack going in the wrong direction? ip=%pB\n",
+		orc_warn_current("stack going in the wrong direction? at %pB\n",
-			 (void *)orig_ip);
+				 (void *)orig_ip);
 		goto err;
 	}
 void __unwind_start(struct unwind_state *state, struct task_struct *task,
 		    struct pt_regs *regs, unsigned long *first_frame)
 {
+	if (!orc_init)
+		goto done;
 	memset(state, 0, sizeof(*state));
 	state->task = task;
 	/* Otherwise, skip ahead to the user-specified starting frame: */
 	while (!unwind_done(state) &&
 	       (!on_stack(&state->stack_info, first_frame, sizeof(long)) ||
-			state->sp <= (unsigned long)first_frame))
+			state->sp < (unsigned long)first_frame))
 		unwind_next_frame(state);
 	return;

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

@@ -225,12 +225,12 @@ static int ioapic_set_irq(struct kvm_ioapic *ioapic, unsigned int irq, · 224 unmodified lines
225	}	225	}
226		226
227	/*	227	/*
228	* AMD SVM AVIC accelerate EOI write and do not trap,	228	* AMD SVM AVIC accelerate EOI write iff the interrupt is edge
229	* in-kernel IOAPIC will not be able to receive the EOI.	229	* triggered, in which case the in-kernel IOAPIC will not be able
230	* In this case, we do lazy update of the pending EOI when	230	* to receive the EOI. In this case, we do a lazy update of the
231	* trying to set IOAPIC irq.	231	* pending EOI when trying to set IOAPIC irq.
232	*/	232	*/
233	if (kvm_apicv_activated(ioapic->kvm))	233	if (edge && kvm_apicv_activated(ioapic->kvm))
234	ioapic_lazy_update_eoi(ioapic, irq);	234	ioapic_lazy_update_eoi(ioapic, irq);
235		235
236	/*	236	/*

arch/x86/kvm/svm/sev.c+1−1

@@ -345,7 +345,7 @@ static struct page *sev_pin_memory(struct kvm kvm, unsigned long uaddr, · 344 unmodified lines
345	return NULL;	345	return NULL;
346		346
347	/* Pin the user virtual address. */	347	/* Pin the user virtual address. */
348	npinned = get_user_pages_fast(uaddr, npages, FOLL_WRITE, pages);	348	npinned = get_user_pages_fast(uaddr, npages, write ? FOLL_WRITE : 0, pages);
349	if (npinned != npages) {	349	if (npinned != npages) {
350	pr_err("SEV: Failure locking %lu pages.\n", npages);	350	pr_err("SEV: Failure locking %lu pages.\n", npages);
351	goto err;	351	goto err;

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

 	if (svm->vcpu.guest_debug &
 	    (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP)) {
 		kvm_run->exit_reason = KVM_EXIT_DEBUG;
+		kvm_run->debug.arch.dr6 = svm->vmcb->save.dr6;
+		kvm_run->debug.arch.dr7 = svm->vmcb->save.dr7;
 		kvm_run->debug.arch.pc =
 			svm->vmcb->save.cs.base + svm->vmcb->save.rip;
 		kvm_run->debug.arch.exception = DB_VECTOR;

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

@@ -5165,7 +5165,7 @@ static int handle_invept(struct kvm_vcpu *vcpu) · 5164 unmodified lines
5165	*/	5165	*/
5166	break;	5166	break;
5167	default:	5167	default:
5168	BUG_ON(1);	5168	BUG();
5169	break;	5169	break;
5170	}	5170	}
5171		5171

arch/x86/kvm/vmx/vmenter.S+3−0

@@ -82,6 +82,9 @@ SYM_FUNC_START(vmx_vmexit) · 81 unmodified lines
82	/* IMPORTANT: Stuff the RSB immediately after VM-Exit, before RET! */	82	/* IMPORTANT: Stuff the RSB immediately after VM-Exit, before RET! */
83	FILL_RETURN_BUFFER %_ASM_AX, RSB_CLEAR_LOOPS, X86_FEATURE_RETPOLINE	83	FILL_RETURN_BUFFER %_ASM_AX, RSB_CLEAR_LOOPS, X86_FEATURE_RETPOLINE
84		84
		85	/* Clear RFLAGS.CF and RFLAGS.ZF to preserve VM-Exit, i.e. !VM-Fail. */
		86	or $1, %_ASM_AX
		87
85	pop %_ASM_AX	88	pop %_ASM_AX
86	.Lvmexit_skip_rsb:	89	.Lvmexit_skip_rsb:
87	#endif	90	#endif

arch/x86/kvm/x86.c+6−15

 	__reserved_bits;				\
 })
-static u64 kvm_host_cr4_reserved_bits(struct cpuinfo_x86 *c)
-{
-	u64 reserved_bits = __cr4_reserved_bits(cpu_has, c);
-	if (kvm_cpu_cap_has(X86_FEATURE_LA57))
-		reserved_bits &= ~X86_CR4_LA57;
-	if (kvm_cpu_cap_has(X86_FEATURE_UMIP))
-		reserved_bits &= ~X86_CR4_UMIP;
-	return reserved_bits;
-}
 static int kvm_valid_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
 {
 	if (cr4 & cr4_reserved_bits)
 	case KVM_CAP_GET_MSR_FEATURES:
 	case KVM_CAP_MSR_PLATFORM_INFO:
 	case KVM_CAP_EXCEPTION_PAYLOAD:
+	case KVM_CAP_SET_GUEST_DEBUG:
 		r = 1;
 		break;
 	case KVM_CAP_SYNC_REGS:
 	if (!kvm_cpu_cap_has(X86_FEATURE_XSAVES))
 		supported_xss = 0;
-	cr4_reserved_bits = kvm_host_cr4_reserved_bits(&boot_cpu_data);
+#define __kvm_cpu_cap_has(UNUSED_, f) kvm_cpu_cap_has(f)
+	cr4_reserved_bits = __cr4_reserved_bits(__kvm_cpu_cap_has, UNUSED_);
+#undef __kvm_cpu_cap_has
 	if (kvm_has_tsc_control) {
 		/*
 	WARN_ON(!irqs_disabled());
-	if (kvm_host_cr4_reserved_bits(c) != cr4_reserved_bits)
+	if (__cr4_reserved_bits(cpu_has, c) !=
+	    __cr4_reserved_bits(cpu_has, &boot_cpu_data))
 		return -EIO;
 	return ops->check_processor_compatibility();

arch/x86/mm/pat/set_memory.c+8−4

 	unsigned long	pfn;
 	unsigned int	flags;
 	unsigned int	force_split		: 1,
-			force_static_prot	: 1;
+			force_static_prot	: 1,
+			force_flush_all		: 1;
 	struct page	**pages;
 };
 		return;
 	}
-	if (cpa->numpages <= tlb_single_page_flush_ceiling)
+	if (cpa->force_flush_all || cpa->numpages > tlb_single_page_flush_ceiling)
-		on_each_cpu(__cpa_flush_tlb, cpa, 1);
-	else
 		flush_tlb_all();
+	else
+		on_each_cpu(__cpa_flush_tlb, cpa, 1);
 	if (!cache)
 		return;
 		alias_cpa.flags &= ~(CPA_PAGES_ARRAY | CPA_ARRAY);
 		alias_cpa.curpage = 0;
+		cpa->force_flush_all = 1;
 		ret = __change_page_attr_set_clr(&alias_cpa, 0);
 		if (ret)
 			return ret;
 		alias_cpa.flags &= ~(CPA_PAGES_ARRAY | CPA_ARRAY);
 		alias_cpa.curpage = 0;
+		cpa->force_flush_all = 1;
 		/*
 		 * The high mapping range is imprecise, so ignore the
 		 * return value.

block/bfq-iosched.c+4−2

 #include <linux/ioprio.h>
 #include <linux/sbitmap.h>
 #include <linux/delay.h>
+#include <linux/backing-dev.h>
 #include "blk.h"
 #include "blk-mq.h"
 	ioprio_class = IOPRIO_PRIO_CLASS(bic->ioprio);
 	switch (ioprio_class) {
 	default:
-		dev_err(bfqq->bfqd->queue->backing_dev_info->dev,
+		pr_err("bdi %s: bfq: bad prio class %d\n",
-			"bfq: bad prio class %d\n", ioprio_class);
+				bdi_dev_name(bfqq->bfqd->queue->backing_dev_info),
+				ioprio_class);
 		/* fall through */
 	case IOPRIO_CLASS_NONE:
 		/*

block/blk-cgroup.c+1−1

@@ -496,7 +496,7 @@ const char blkg_dev_name(struct blkcg_gq blkg) · 495 unmodified lines
496	{	496	{
497	/* some drivers (floppy) instantiate a queue w/o disk registered */	497	/* some drivers (floppy) instantiate a queue w/o disk registered */
498	if (blkg->q->backing_dev_info->dev)	498	if (blkg->q->backing_dev_info->dev)
499	return dev_name(blkg->q->backing_dev_info->dev);	499	return bdi_dev_name(blkg->q->backing_dev_info);
500	return NULL;	500	return NULL;
501	}	501	}
502		502

block/blk-iocost.c+71−46

 	 */
 	atomic64_t			vtime;
 	atomic64_t			done_vtime;
-	atomic64_t			abs_vdebt;
+	u64				abs_vdebt;
 	u64				last_vtime;
 	/*
 	struct iocg_wake_ctx ctx = { .iocg = iocg };
 	u64 margin_ns = (u64)(ioc->period_us *
 			      WAITQ_TIMER_MARGIN_PCT / 100) * NSEC_PER_USEC;
-	u64 abs_vdebt, vdebt, vshortage, expires, oexpires;
+	u64 vdebt, vshortage, expires, oexpires;
 	s64 vbudget;
 	u32 hw_inuse;
 	vbudget = now->vnow - atomic64_read(&iocg->vtime);
 	/* pay off debt */
-	abs_vdebt = atomic64_read(&iocg->abs_vdebt);
+	vdebt = abs_cost_to_cost(iocg->abs_vdebt, hw_inuse);
-	vdebt = abs_cost_to_cost(abs_vdebt, hw_inuse);
 	if (vdebt && vbudget > 0) {
 		u64 delta = min_t(u64, vbudget, vdebt);
 		u64 abs_delta = min(cost_to_abs_cost(delta, hw_inuse),
-				    abs_vdebt);
+				    iocg->abs_vdebt);
 		atomic64_add(delta, &iocg->vtime);
 		atomic64_add(delta, &iocg->done_vtime);
-		atomic64_sub(abs_delta, &iocg->abs_vdebt);
+		iocg->abs_vdebt -= abs_delta;
-		if (WARN_ON_ONCE(atomic64_read(&iocg->abs_vdebt) < 0))
-			atomic64_set(&iocg->abs_vdebt, 0);
 	}
 	/*
 	u64 expires, oexpires;
 	u32 hw_inuse;
+	lockdep_assert_held(&iocg->waitq.lock);
 	/* debt-adjust vtime */
 	current_hweight(iocg, NULL, &hw_inuse);
-	vtime += abs_cost_to_cost(atomic64_read(&iocg->abs_vdebt), hw_inuse);
+	vtime += abs_cost_to_cost(iocg->abs_vdebt, hw_inuse);
-	/* clear or maintain depending on the overage */
+	/*
-	if (time_before_eq64(vtime, now->vnow)) {
+	 * Clear or maintain depending on the overage. Non-zero vdebt is what
+	 * guarantees that @iocg is online and future iocg_kick_delay() will
+	 * clear use_delay. Don't leave it on when there's no vdebt.
+	 */
+	if (!iocg->abs_vdebt || time_before_eq64(vtime, now->vnow)) {
 		blkcg_clear_delay(blkg);
 		return false;
 	}
 {
 	struct ioc_gq *iocg = container_of(timer, struct ioc_gq, delay_timer);
 	struct ioc_now now;
+	unsigned long flags;
+	spin_lock_irqsave(&iocg->waitq.lock, flags);
 	ioc_now(iocg->ioc, &now);
 	iocg_kick_delay(iocg, &now, 0);
+	spin_unlock_irqrestore(&iocg->waitq.lock, flags);
 	return HRTIMER_NORESTART;
 }
 	 * should have woken up in the last period and expire idle iocgs.
 	 */
 	list_for_each_entry_safe(iocg, tiocg, &ioc->active_iocgs, active_list) {
-		if (!waitqueue_active(&iocg->waitq) &&
+		if (!waitqueue_active(&iocg->waitq) && iocg->abs_vdebt &&
-		    !atomic64_read(&iocg->abs_vdebt) && !iocg_is_idle(iocg))
+		    !iocg_is_idle(iocg))
 			continue;
 		spin_lock(&iocg->waitq.lock);
-		if (waitqueue_active(&iocg->waitq) ||
+		if (waitqueue_active(&iocg->waitq) || iocg->abs_vdebt) {
-		    atomic64_read(&iocg->abs_vdebt)) {
 			/* might be oversleeping vtime / hweight changes, kick */
 			iocg_kick_waitq(iocg, &now);
 			iocg_kick_delay(iocg, &now, 0);
 	 * tests are racy but the races aren't systemic - we only miss once
 	 * in a while which is fine.
 	 */
-	if (!waitqueue_active(&iocg->waitq) &&
+	if (!waitqueue_active(&iocg->waitq) && !iocg->abs_vdebt &&
-	    !atomic64_read(&iocg->abs_vdebt) &&
 	    time_before_eq64(vtime + cost, now.vnow)) {
 		iocg_commit_bio(iocg, bio, cost);
 		return;
 	}
 	/*
-	 * We're over budget.  If @bio has to be issued regardless,
+	 * We activated above but w/o any synchronization. Deactivation is
-	 * remember the abs_cost instead of advancing vtime.
+	 * synchronized with waitq.lock and we won't get deactivated as long
-	 * iocg_kick_waitq() will pay off the debt before waking more IOs.
+	 * as we're waiting or has debt, so we're good if we're activated
+	 * here. In the unlikely case that we aren't, just issue the IO.
+	 */
+	spin_lock_irq(&iocg->waitq.lock);
+	if (unlikely(list_empty(&iocg->active_list))) {
+		spin_unlock_irq(&iocg->waitq.lock);
+		iocg_commit_bio(iocg, bio, cost);
+		return;
+	}
+	/*
+	 * We're over budget. If @bio has to be issued regardless, remember
+	 * the abs_cost instead of advancing vtime. iocg_kick_waitq() will pay
+	 * off the debt before waking more IOs.
+	 *
 	 * This way, the debt is continuously paid off each period with the
-	 * actual budget available to the cgroup.  If we just wound vtime,
+	 * actual budget available to the cgroup. If we just wound vtime, we
-	 * we would incorrectly use the current hw_inuse for the entire
+	 * would incorrectly use the current hw_inuse for the entire amount
-	 * amount which, for example, can lead to the cgroup staying
+	 * which, for example, can lead to the cgroup staying blocked for a
-	 * blocked for a long time even with substantially raised hw_inuse.
+	 * long time even with substantially raised hw_inuse.
+	 *
+	 * An iocg with vdebt should stay online so that the timer can keep
+	 * deducting its vdebt and [de]activate use_delay mechanism
+	 * accordingly. We don't want to race against the timer trying to
+	 * clear them and leave @iocg inactive w/ dangling use_delay heavily
+	 * penalizing the cgroup and its descendants.
 	 */
 	if (bio_issue_as_root_blkg(bio) || fatal_signal_pending(current)) {
-		atomic64_add(abs_cost, &iocg->abs_vdebt);
+		iocg->abs_vdebt += abs_cost;
 		if (iocg_kick_delay(iocg, &now, cost))
 			blkcg_schedule_throttle(rqos->q,
 					(bio->bi_opf & REQ_SWAP) == REQ_SWAP);
+		spin_unlock_irq(&iocg->waitq.lock);
 		return;
 	}
 	 * All waiters are on iocg->waitq and the wait states are
 	 * synchronized using waitq.lock.
 	 */
-	spin_lock_irq(&iocg->waitq.lock);
-	/*
-	 * We activated above but w/o any synchronization.  Deactivation is
-	 * synchronized with waitq.lock and we won't get deactivated as
-	 * long as we're waiting, so we're good if we're activated here.
-	 * In the unlikely case that we are deactivated, just issue the IO.
-	 */
-	if (unlikely(list_empty(&iocg->active_list))) {
-		spin_unlock_irq(&iocg->waitq.lock);
-		iocg_commit_bio(iocg, bio, cost);
-		return;
-	}
 	init_waitqueue_func_entry(&wait.wait, iocg_wake_fn);
 	wait.wait.private = current;
 	wait.bio = bio;
 	struct ioc_now now;
 	u32 hw_inuse;
 	u64 abs_cost, cost;
+	unsigned long flags;
 	/* bypass if disabled or for root cgroup */
 	if (!ioc->enabled || !iocg->level)
 		iocg->cursor = bio_end;
 	/*
-	 * Charge if there's enough vtime budget and the existing request
+	 * Charge if there's enough vtime budget and the existing request has
-	 * has cost assigned.  Otherwise, account it as debt.  See debt
+	 * cost assigned.
-	 * handling in ioc_rqos_throttle() for details.
 	 */
 	if (rq->bio && rq->bio->bi_iocost_cost &&
-	    time_before_eq64(atomic64_read(&iocg->vtime) + cost, now.vnow))
+	    time_before_eq64(atomic64_read(&iocg->vtime) + cost, now.vnow)) {
 		iocg_commit_bio(iocg, bio, cost);
-	else
+		return;
-		atomic64_add(abs_cost, &iocg->abs_vdebt);
+	}
+	/*
+	 * Otherwise, account it as debt if @iocg is online, which it should
+	 * be for the vast majority of cases. See debt handling in
+	 * ioc_rqos_throttle() for details.
+	 */
+	spin_lock_irqsave(&iocg->waitq.lock, flags);
+	if (likely(!list_empty(&iocg->active_list))) {
+		iocg->abs_vdebt += abs_cost;
+		iocg_kick_delay(iocg, &now, cost);
+	} else {
+		iocg_commit_bio(iocg, bio, cost);
+	}
+	spin_unlock_irqrestore(&iocg->waitq.lock, flags);
 }
 static void ioc_rqos_done_bio(struct rq_qos *rqos, struct bio *bio)
 	iocg->ioc = ioc;
 	atomic64_set(&iocg->vtime, now.vnow);
 	atomic64_set(&iocg->done_vtime, now.vnow);
-	atomic64_set(&iocg->abs_vdebt, 0);
 	atomic64_set(&iocg->active_period, atomic64_read(&ioc->cur_period));
 	INIT_LIST_HEAD(&iocg->active_list);
 	iocg->hweight_active = HWEIGHT_WHOLE;

block/partitions/core.c+1−1

@@ -496,7 +496,7 @@ int blk_drop_partitions(struct gendisk disk, struct block_device bdev) · 495 unmodified lines
496		496
497	if (!disk_part_scan_enabled(disk))	497	if (!disk_part_scan_enabled(disk))
498	return 0;	498	return 0;
499	if (bdev->bd_part_count \|\| bdev->bd_openers > 1)	499	if (bdev->bd_part_count)
500	return -EBUSY;	500	return -EBUSY;
501	res = invalidate_partition(disk, 0);	501	res = invalidate_partition(disk, 0);
502	if (res)	502	if (res)

crypto/lrw.c+3−3

@@ -287,7 +287,7 @@ static void exit_tfm(struct crypto_skcipher *tfm) · 286 unmodified lines
287	crypto_free_skcipher(ctx->child);	287	crypto_free_skcipher(ctx->child);
288	}	288	}
289		289
290	static void free(struct skcipher_instance *inst)	290	static void free_inst(struct skcipher_instance *inst)
291	{	291	{
292	crypto_drop_skcipher(skcipher_instance_ctx(inst));	292	crypto_drop_skcipher(skcipher_instance_ctx(inst));
293	kfree(inst);	293	kfree(inst);
@@ -400,12 +400,12 @@ static int create(struct crypto_template tmpl, struct rtattr *tb) · 106 unmodified lines
400	inst->alg.encrypt = encrypt;	400	inst->alg.encrypt = encrypt;
401	inst->alg.decrypt = decrypt;	401	inst->alg.decrypt = decrypt;
402		402
403	inst->free = free;	403	inst->free = free_inst;
404		404
405	err = skcipher_register_instance(tmpl, inst);	405	err = skcipher_register_instance(tmpl, inst);
406	if (err) {	406	if (err) {
407	err_free_inst:	407	err_free_inst:
408	free(inst);	408	free_inst(inst);
409	}	409	}
410	return err;	410	return err;
411	}	411	}

crypto/xts.c+3−3

@@ -322,7 +322,7 @@ static void exit_tfm(struct crypto_skcipher *tfm) · 321 unmodified lines
322	crypto_free_cipher(ctx->tweak);	322	crypto_free_cipher(ctx->tweak);
323	}	323	}
324		324
325	static void free(struct skcipher_instance *inst)	325	static void free_inst(struct skcipher_instance *inst)
326	{	326	{
327	crypto_drop_skcipher(skcipher_instance_ctx(inst));	327	crypto_drop_skcipher(skcipher_instance_ctx(inst));
328	kfree(inst);	328	kfree(inst);
@@ -434,12 +434,12 @@ static int create(struct crypto_template tmpl, struct rtattr *tb) · 105 unmodified lines
434	inst->alg.encrypt = encrypt;	434	inst->alg.encrypt = encrypt;
435	inst->alg.decrypt = decrypt;	435	inst->alg.decrypt = decrypt;
436		436
437	inst->free = free;	437	inst->free = free_inst;
438		438
439	err = skcipher_register_instance(tmpl, inst);	439	err = skcipher_register_instance(tmpl, inst);
440	if (err) {	440	if (err) {
441	err_free_inst:	441	err_free_inst:
442	free(inst);	442	free_inst(inst);
443	}	443	}
444	return err;	444	return err;
445	}	445	}

drivers/acpi/device_pm.c+2−2

@@ -273,13 +273,13 @@ int acpi_device_set_power(struct acpi_device *device, int state) · 272 unmodified lines
273	end:	273	end:
274	if (result) {	274	if (result) {
275	dev_warn(&device->dev, "Failed to change power state to %s\n",	275	dev_warn(&device->dev, "Failed to change power state to %s\n",
276	acpi_power_state_string(state));	276	acpi_power_state_string(target_state));
277	} else {	277	} else {
278	device->power.state = target_state;	278	device->power.state = target_state;
279	ACPI_DEBUG_PRINT((ACPI_DB_INFO,	279	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
280	"Device [%s] transitioned to %s\n",	280	"Device [%s] transitioned to %s\n",
281	device->pnp.bus_id,	281	device->pnp.bus_id,
282	acpi_power_state_string(state)));	282	acpi_power_state_string(target_state)));
283	}	283	}
284		284
285	return result;	285	return result;

drivers/amba/bus.c+1−0

@@ -645,6 +645,7 @@ static void amba_device_initialize(struct amba_device dev, const char name) · 644 unmodified lines
645	dev->dev.release = amba_device_release;	645	dev->dev.release = amba_device_release;
646	dev->dev.bus = &amba_bustype;	646	dev->dev.bus = &amba_bustype;
647	dev->dev.dma_mask = &dev->dev.coherent_dma_mask;	647	dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
		648	dev->dev.dma_parms = &dev->dma_parms;
648	dev->res.name = dev_name(&dev->dev);	649	dev->res.name = dev_name(&dev->dev);
649	}	650	}
650		651

drivers/base/component.c+5−3

 	ret = master->ops->bind(master->dev);
 	if (ret < 0) {
 		devres_release_group(master->dev, NULL);
-		dev_info(master->dev, "master bind failed: %d\n", ret);
+		if (ret != -EPROBE_DEFER)
+			dev_info(master->dev, "master bind failed: %d\n", ret);
 		return ret;
 	}
 		devres_release_group(component->dev, NULL);
 		devres_release_group(master->dev, NULL);
-		dev_err(master->dev, "failed to bind %s (ops %ps): %d\n",
+		if (ret != -EPROBE_DEFER)
-			dev_name(component->dev), component->ops, ret);
+			dev_err(master->dev, "failed to bind %s (ops %ps): %d\n",
+				dev_name(component->dev), component->ops, ret);
 	}
 	return ret;

drivers/base/core.c+6−1

 	return fw_devlink_flags;
 }
+static bool fw_devlink_is_permissive(void)
+{
+	return fw_devlink_flags == DL_FLAG_SYNC_STATE_ONLY;
+}
 /**
  * device_add - add device to device hierarchy.
  * @dev: device.
 	if (fw_devlink_flags && is_fwnode_dev &&
 	    fwnode_has_op(dev->fwnode, add_links)) {
 		fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev);
-		if (fw_ret == -ENODEV)
+		if (fw_ret == -ENODEV && !fw_devlink_is_permissive())
 			device_link_wait_for_mandatory_supplier(dev);
 		else if (fw_ret)
 			device_link_wait_for_optional_supplier(dev);

drivers/base/dd.c+8−12

 }
 DEFINE_SHOW_ATTRIBUTE(deferred_devs);
-#ifdef CONFIG_MODULES
+int driver_deferred_probe_timeout;
-/*
- * In the case of modules, set the default probe timeout to
- * 30 seconds to give userland some time to load needed modules
- */
-int driver_deferred_probe_timeout = 30;
-#else
-/* In the case of !modules, no probe timeout needed */
-int driver_deferred_probe_timeout = -1;
-#endif
 EXPORT_SYMBOL_GPL(driver_deferred_probe_timeout);
+static DECLARE_WAIT_QUEUE_HEAD(probe_timeout_waitqueue);
 static int __init deferred_probe_timeout_setup(char *str)
 {
 		return -ENODEV;
 	}
-	if (!driver_deferred_probe_timeout) {
+	if (!driver_deferred_probe_timeout && initcalls_done) {
-		dev_WARN(dev, "deferred probe timeout, ignoring dependency\n");
+		dev_warn(dev, "deferred probe timeout, ignoring dependency\n");
 		return -ETIMEDOUT;
 	}
 	list_for_each_entry_safe(private, p, &deferred_probe_pending_list, deferred_probe)
 		dev_info(private->device, "deferred probe pending\n");
+	wake_up(&probe_timeout_waitqueue);
 }
 static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func);
  */
 void wait_for_device_probe(void)
 {
+	/* wait for probe timeout */
+	wait_event(probe_timeout_waitqueue, !driver_deferred_probe_timeout);
 	/* wait for the deferred probe workqueue to finish */
 	flush_work(&deferred_probe_work);

drivers/base/platform.c+2−0

@@ -380,6 +380,8 @@ struct platform_object { · 379 unmodified lines
380	*/	380	*/
381	static void setup_pdev_dma_masks(struct platform_device *pdev)	381	static void setup_pdev_dma_masks(struct platform_device *pdev)
382	{	382	{
		383	pdev->dev.dma_parms = &pdev->dma_parms;
		384
383	if (!pdev->dev.coherent_dma_mask)	385	if (!pdev->dev.coherent_dma_mask)
384	pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);	386	pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
385	if (!pdev->dev.dma_mask) {	387	if (!pdev->dev.dma_mask) {

drivers/block/virtio_blk.c+78−8

@@ -33,6 +33,15 @@ struct virtio_blk_vq { · 32 unmodified lines
33	} ____cacheline_aligned_in_smp;	33	} ____cacheline_aligned_in_smp;
34		34
35	struct virtio_blk {	35	struct virtio_blk {
		36	/*
		37	* This mutex must be held by anything that may run after
		38	* virtblk_remove() sets vblk->vdev to NULL.
		39	*
		40	* blk-mq, virtqueue processing, and sysfs attribute code paths are
		41	* shut down before vblk->vdev is set to NULL and therefore do not need
		42	* to hold this mutex.
		43	*/
		44	struct mutex vdev_mutex;
36	struct virtio_device *vdev;	45	struct virtio_device *vdev;
37		46
38	/* The disk structure for the kernel. */	47	/* The disk structure for the kernel. */
@@ -44,6 +53,13 @@ struct virtio_blk { · 5 unmodified lines
44	/* Process context for config space updates */	53	/* Process context for config space updates */
45	struct work_struct config_work;	54	struct work_struct config_work;
46		55
		56	/*
		57	* Tracks references from block_device_operations open/release and
		58	* virtio_driver probe/remove so this object can be freed once no
		59	* longer in use.
		60	*/
		61	refcount_t refs;
		62
47	/* What host tells us, plus 2 for header & tailer. */	63	/* What host tells us, plus 2 for header & tailer. */
48	unsigned int sg_elems;	64	unsigned int sg_elems;
49		65
@@ -295,10 +311,55 @@ out: · 245 unmodified lines
295	return err;	311	return err;
296	}	312	}
297		313
		314	static void virtblk_get(struct virtio_blk *vblk)
		315	{
		316	refcount_inc(&vblk->refs);
		317	}
		318
		319	static void virtblk_put(struct virtio_blk *vblk)
		320	{
		321	if (refcount_dec_and_test(&vblk->refs)) {
		322	ida_simple_remove(&vd_index_ida, vblk->index);
		323	mutex_destroy(&vblk->vdev_mutex);
		324	kfree(vblk);
		325	}
		326	}
		327
		328	static int virtblk_open(struct block_device *bd, fmode_t mode)
		329	{
		330	struct virtio_blk *vblk = bd->bd_disk->private_data;
		331	int ret = 0;
		332
		333	mutex_lock(&vblk->vdev_mutex);
		334
		335	if (vblk->vdev)
		336	virtblk_get(vblk);
		337	else
		338	ret = -ENXIO;
		339
		340	mutex_unlock(&vblk->vdev_mutex);
		341	return ret;
		342	}
		343
		344	static void virtblk_release(struct gendisk *disk, fmode_t mode)
		345	{
		346	struct virtio_blk *vblk = disk->private_data;
		347
		348	virtblk_put(vblk);
		349	}
		350
298	/* We provide getgeo only to please some old bootloader/partitioning tools */	351	/* We provide getgeo only to please some old bootloader/partitioning tools */
299	static int virtblk_getgeo(struct block_device bd, struct hd_geometry geo)	352	static int virtblk_getgeo(struct block_device bd, struct hd_geometry geo)
300	{	353	{
301	struct virtio_blk *vblk = bd->bd_disk->private_data;	354	struct virtio_blk *vblk = bd->bd_disk->private_data;
		355	int ret = 0;
		356
		357	mutex_lock(&vblk->vdev_mutex);
		358
		359	if (!vblk->vdev) {
		360	ret = -ENXIO;
		361	goto out;
		362	}
302		363
303	/* see if the host passed in geometry config */	364	/* see if the host passed in geometry config */
304	if (virtio_has_feature(vblk->vdev, VIRTIO_BLK_F_GEOMETRY)) {	365	if (virtio_has_feature(vblk->vdev, VIRTIO_BLK_F_GEOMETRY)) {
@@ -314,11 +375,15 @@ static int virtblk_getgeo(struct block_device bd, struct hd_geometry geo) · 9 unmodified lines
314	geo->sectors = 1 << 5;	375	geo->sectors = 1 << 5;
315	geo->cylinders = get_capacity(bd->bd_disk) >> 11;	376	geo->cylinders = get_capacity(bd->bd_disk) >> 11;
316	}	377	}
317	return 0;	378	out:
		379	mutex_unlock(&vblk->vdev_mutex);
		380	return ret;
318	}	381	}
319		382
320	static const struct block_device_operations virtblk_fops = {	383	static const struct block_device_operations virtblk_fops = {
321	.owner = THIS_MODULE,	384	.owner = THIS_MODULE,
		385	.open = virtblk_open,
		386	.release = virtblk_release,
322	.getgeo = virtblk_getgeo,	387	.getgeo = virtblk_getgeo,
323	};	388	};
324		389
@@ -655,6 +720,10 @@ static int virtblk_probe(struct virtio_device *vdev) · 330 unmodified lines
655	goto out_free_index;	720	goto out_free_index;
656	}	721	}
657		722
		723	/* This reference is dropped in virtblk_remove(). */
		724	refcount_set(&vblk->refs, 1);
		725	mutex_init(&vblk->vdev_mutex);
		726
658	vblk->vdev = vdev;	727	vblk->vdev = vdev;
659	vblk->sg_elems = sg_elems;	728	vblk->sg_elems = sg_elems;
660		729
@@ -820,8 +889,6 @@ out: · 159 unmodified lines
820	static void virtblk_remove(struct virtio_device *vdev)	889	static void virtblk_remove(struct virtio_device *vdev)
821	{	890	{
822	struct virtio_blk *vblk = vdev->priv;	891	struct virtio_blk *vblk = vdev->priv;
823	int index = vblk->index;
824	int refc;
825		892
826	/* Make sure no work handler is accessing the device. */	893	/* Make sure no work handler is accessing the device. */
827	flush_work(&vblk->config_work);	894	flush_work(&vblk->config_work);
@@ -831,18 +898,21 @@ static void virtblk_remove(struct virtio_device *vdev) · 3 unmodified lines
831		898
832	blk_mq_free_tag_set(&vblk->tag_set);	899	blk_mq_free_tag_set(&vblk->tag_set);
833		900
		901	mutex_lock(&vblk->vdev_mutex);
		902
834	/* Stop all the virtqueues. */	903	/* Stop all the virtqueues. */
835	vdev->config->reset(vdev);	904	vdev->config->reset(vdev);
836		905
837	refc = kref_read(&disk_to_dev(vblk->disk)->kobj.kref);	906	/* Virtqueues are stopped, nothing can use vblk->vdev anymore. */
		907	vblk->vdev = NULL;
		908
838	put_disk(vblk->disk);	909	put_disk(vblk->disk);
839	vdev->config->del_vqs(vdev);	910	vdev->config->del_vqs(vdev);
840	kfree(vblk->vqs);	911	kfree(vblk->vqs);
841	kfree(vblk);
842		912
843	/* Only free device id if we don't have any users */	913	mutex_unlock(&vblk->vdev_mutex);
844	if (refc == 1)	914
845	ida_simple_remove(&vd_index_ida, index);	915	virtblk_put(vblk);
846	}	916	}
847		917
848	#ifdef CONFIG_PM_SLEEP	918	#ifdef CONFIG_PM_SLEEP

drivers/bus/mhi/core/init.c+3−4

@@ -812,10 +812,9 @@ int mhi_register_controller(struct mhi_controller *mhi_cntrl, · 811 unmodified lines
812	if (!mhi_cntrl)	812	if (!mhi_cntrl)
813	return -EINVAL;	813	return -EINVAL;
814		814
815	if (!mhi_cntrl->runtime_get \|\| !mhi_cntrl->runtime_put)	815	if (!mhi_cntrl->runtime_get \|\| !mhi_cntrl->runtime_put \|\|
816	return -EINVAL;	816	!mhi_cntrl->status_cb \|\| !mhi_cntrl->read_reg \|\|
817		817	!mhi_cntrl->write_reg)
818	if (!mhi_cntrl->status_cb \|\| !mhi_cntrl->link_status)
819	return -EINVAL;	818	return -EINVAL;
820		819
821	ret = parse_config(mhi_cntrl, config);	820	ret = parse_config(mhi_cntrl, config);

drivers/bus/mhi/core/internal.h+0−3

@@ -11,9 +11,6 @@ · 10 unmodified lines
11		11
12	extern struct bus_type mhi_bus_type;	12	extern struct bus_type mhi_bus_type;
13		13
14	/* MHI MMIO register mapping */
15	#define PCI_INVALID_READ(val) (val == U32_MAX)
16
17	#define MHIREGLEN (0x0)	14	#define MHIREGLEN (0x0)
18	#define MHIREGLEN_MHIREGLEN_MASK (0xFFFFFFFF)	15	#define MHIREGLEN_MHIREGLEN_MASK (0xFFFFFFFF)
19	#define MHIREGLEN_MHIREGLEN_SHIFT (0)	16	#define MHIREGLEN_MHIREGLEN_SHIFT (0)

drivers/bus/mhi/core/main.c+5−13

 int __must_check mhi_read_reg(struct mhi_controller *mhi_cntrl,
 			      void __iomem *base, u32 offset, u32 *out)
 {
-	u32 tmp = readl(base + offset);
+	return mhi_cntrl->read_reg(mhi_cntrl, base + offset, out);
-	/* If there is any unexpected value, query the link status */
-	if (PCI_INVALID_READ(tmp) &&
-	    mhi_cntrl->link_status(mhi_cntrl))
-		return -EIO;
-	*out = tmp;
-	return 0;
 }
 int __must_check mhi_read_reg_field(struct mhi_controller *mhi_cntrl,
 void mhi_write_reg(struct mhi_controller *mhi_cntrl, void __iomem *base,
 		   u32 offset, u32 val)
 {
-	writel(val, base + offset);
+	mhi_cntrl->write_reg(mhi_cntrl, base + offset, val);
 }
 void mhi_write_reg_field(struct mhi_controller *mhi_cntrl, void __iomem *base,
 		    !(mhi_chan->ee_mask & BIT(mhi_cntrl->ee)))
 			continue;
 		mhi_dev = mhi_alloc_device(mhi_cntrl);
-		if (!mhi_dev)
+		if (IS_ERR(mhi_dev))
 			return;
 		mhi_dev->dev_type = MHI_DEVICE_XFER;
 		/* Channel name is same for both UL and DL */
 		mhi_dev->chan_name = mhi_chan->name;
-		dev_set_name(&mhi_dev->dev, "%04x_%s", mhi_chan->chan,
+		dev_set_name(&mhi_dev->dev, "%s_%s",
+			     dev_name(mhi_cntrl->cntrl_dev),
 			     mhi_dev->chan_name);
 		/* Init wakeup source if available */

drivers/bus/mhi/core/pm.c+5−1

 			   MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state),
 			   msecs_to_jiffies(mhi_cntrl->timeout_ms));
-	return (MHI_IN_MISSION_MODE(mhi_cntrl->ee)) ? 0 : -EIO;
+	ret = (MHI_IN_MISSION_MODE(mhi_cntrl->ee)) ? 0 : -ETIMEDOUT;
+	if (ret)
+		mhi_power_down(mhi_cntrl, false);
+	return ret;
 }
 EXPORT_SYMBOL(mhi_sync_power_up);

drivers/cpufreq/intel_pstate.c+1−1

@@ -1059,7 +1059,7 @@ static ssize_t store_no_turbo(struct kobject a, struct kobj_attribute b, · 1058 unmodified lines
1059		1059
1060	update_turbo_state();	1060	update_turbo_state();
1061	if (global.turbo_disabled) {	1061	if (global.turbo_disabled) {
1062	pr_warn("Turbo disabled by BIOS or unavailable on processor\n");	1062	pr_notice_once("Turbo disabled by BIOS or unavailable on processor\n");
1063	mutex_unlock(&intel_pstate_limits_lock);	1063	mutex_unlock(&intel_pstate_limits_lock);
1064	mutex_unlock(&intel_pstate_driver_lock);	1064	mutex_unlock(&intel_pstate_driver_lock);
1065	return -EPERM;	1065	return -EPERM;

drivers/crypto/caam/caamalg.c+7−3

 	struct caam_drv_private_jr *jrp = dev_get_drvdata(jrdev);
 	struct aead_edesc *edesc;
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = rctx->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		aead_request_complete(req, ecode);
 	else
 		crypto_finalize_aead_request(jrp->engine, req, ecode);
 	struct caam_drv_private_jr *jrp = dev_get_drvdata(jrdev);
 	int ivsize = crypto_skcipher_ivsize(skcipher);
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = rctx->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		skcipher_request_complete(req, ecode);
 	else
 		crypto_finalize_skcipher_request(jrp->engine, req, ecode);
 	if (ivsize || mapped_dst_nents > 1)
 		sg_to_sec4_set_last(edesc->sec4_sg + dst_sg_idx +
-				    mapped_dst_nents);
+				    mapped_dst_nents - 1 + !!ivsize);
 	if (sec4_sg_bytes) {
 		edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,

drivers/crypto/caam/caamhash.c+6−2

 	struct caam_hash_state *state = ahash_request_ctx(req);
 	struct caam_hash_ctx *ctx = crypto_ahash_ctx(ahash);
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = state->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		req->base.complete(&req->base, ecode);
 	else
 		crypto_finalize_hash_request(jrp->engine, req, ecode);
 	struct caam_hash_state *state = ahash_request_ctx(req);
 	int digestsize = crypto_ahash_digestsize(ahash);
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = state->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		req->base.complete(&req->base, ecode);
 	else
 		crypto_finalize_hash_request(jrp->engine, req, ecode);

drivers/crypto/caam/caampkc.c+6−2

 	struct caam_drv_private_jr *jrp = dev_get_drvdata(dev);
 	struct rsa_edesc *edesc;
 	int ecode = 0;
+	bool has_bklog;
 	if (err)
 		ecode = caam_jr_strstatus(dev, err);
 	edesc = req_ctx->edesc;
+	has_bklog = edesc->bklog;
 	rsa_pub_unmap(dev, edesc, req);
 	rsa_io_unmap(dev, edesc, req);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		akcipher_request_complete(req, ecode);
 	else
 		crypto_finalize_akcipher_request(jrp->engine, req, ecode);
 	struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req);
 	struct rsa_edesc *edesc;
 	int ecode = 0;
+	bool has_bklog;
 	if (err)
 		ecode = caam_jr_strstatus(dev, err);
 	edesc = req_ctx->edesc;
+	has_bklog = edesc->bklog;
 	switch (key->priv_form) {
 	case FORM1:
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		akcipher_request_complete(req, ecode);
 	else
 		crypto_finalize_akcipher_request(jrp->engine, req, ecode);

drivers/crypto/chelsio/chcr_ktls.c+46−37

@@ -673,41 +673,14 @@ int chcr_ktls_cpl_set_tcb_rpl(struct adapter adap, unsigned char input) · 672 unmodified lines
673	return 0;	673	return 0;
674	}	674	}
675		675
676	/*	676	static void __chcr_write_cpl_set_tcb_ulp(struct chcr_ktls_info tx_info,
677	* chcr_write_cpl_set_tcb_ulp: update tcb values.	677	u32 tid, void *pos, u16 word, u64 mask,
678	* TCB is responsible to create tcp headers, so all the related values
679	* should be correctly updated.
680	* @tx_info - driver specific tls info.
681	* @q - tx queue on which packet is going out.
682	* @tid - TCB identifier.
683	* @pos - current index where should we start writing.
684	* @word - TCB word.
685	* @mask - TCB word related mask.
686	* @val - TCB word related value.
687	* @reply - set 1 if looking for TP response.
688	* return - next position to write.
689	*/
690	static void chcr_write_cpl_set_tcb_ulp(struct chcr_ktls_info tx_info,
691	struct sge_eth_txq *q, u32 tid,
692	void *pos, u16 word, u64 mask,
693	u64 val, u32 reply)	678	u64 val, u32 reply)
694	{	679	{
695	struct cpl_set_tcb_field_core *cpl;	680	struct cpl_set_tcb_field_core *cpl;
696	struct ulptx_idata *idata;	681	struct ulptx_idata *idata;
697	struct ulp_txpkt *txpkt;	682	struct ulp_txpkt *txpkt;
698	void *save_pos = NULL;
699	u8 buf[48] = {0};
700	int left;
701		683
702	left = (void *)q->q.stat - pos;
703	if (unlikely(left < CHCR_SET_TCB_FIELD_LEN)) {
704	if (!left) {
705	pos = q->q.desc;
706	} else {
707	save_pos = pos;
708	pos = buf;
709	}
710	}
711	/* ULP_TXPKT */	684	/* ULP_TXPKT */
712	txpkt = pos;	685	txpkt = pos;
713	txpkt->cmd_dest = htonl(ULPTX_CMD_V(ULP_TX_PKT) \| ULP_TXPKT_DEST_V(0));	686	txpkt->cmd_dest = htonl(ULPTX_CMD_V(ULP_TX_PKT) \| ULP_TXPKT_DEST_V(0));
@@ -732,18 +705,54 @@ static void chcr_write_cpl_set_tcb_ulp(struct chcr_ktls_info tx_info, · 18 unmodified lines
732	idata = (struct ulptx_idata *)(cpl + 1);	705	idata = (struct ulptx_idata *)(cpl + 1);
733	idata->cmd_more = htonl(ULPTX_CMD_V(ULP_TX_SC_NOOP));	706	idata->cmd_more = htonl(ULPTX_CMD_V(ULP_TX_SC_NOOP));
734	idata->len = htonl(0);	707	idata->len = htonl(0);
		708	pos = idata + 1;
735		709
736	if (save_pos) {	710	return pos;
737	pos = chcr_copy_to_txd(buf, &q->q, save_pos,	711	}
738	CHCR_SET_TCB_FIELD_LEN);	712
739	} else {	713
740	/* check again if we are at the end of the queue */	714	/*
741	if (left == CHCR_SET_TCB_FIELD_LEN)	715	* chcr_write_cpl_set_tcb_ulp: update tcb values.
		716	* TCB is responsible to create tcp headers, so all the related values
		717	* should be correctly updated.
		718	* @tx_info - driver specific tls info.
		719	* @q - tx queue on which packet is going out.
		720	* @tid - TCB identifier.
		721	* @pos - current index where should we start writing.
		722	* @word - TCB word.
		723	* @mask - TCB word related mask.
		724	* @val - TCB word related value.
		725	* @reply - set 1 if looking for TP response.
		726	* return - next position to write.
		727	*/
		728	static void chcr_write_cpl_set_tcb_ulp(struct chcr_ktls_info tx_info,
		729	struct sge_eth_txq *q, u32 tid,
		730	void *pos, u16 word, u64 mask,
		731	u64 val, u32 reply)
		732	{
		733	int left = (void *)q->q.stat - pos;
		734
		735	if (unlikely(left < CHCR_SET_TCB_FIELD_LEN)) {
		736	if (!left) {
742	pos = q->q.desc;	737	pos = q->q.desc;
743	else	738	} else {
744	pos = idata + 1;	739	u8 buf[48] = {0};
		740
		741	__chcr_write_cpl_set_tcb_ulp(tx_info, tid, buf, word,
		742	mask, val, reply);
		743
		744	return chcr_copy_to_txd(buf, &q->q, pos,
		745	CHCR_SET_TCB_FIELD_LEN);
		746	}
745	}	747	}
746		748
		749	pos = __chcr_write_cpl_set_tcb_ulp(tx_info, tid, pos, word,
		750	mask, val, reply);
		751
		752	/* check again if we are at the end of the queue */
		753	if (left == CHCR_SET_TCB_FIELD_LEN)
		754	pos = q->q.desc;
		755
747	return pos;	756	return pos;
748	}	757	}
749		758

drivers/dma-buf/dma-buf.c+4−3

 		return ret;
-	case DMA_BUF_SET_NAME:
+	case DMA_BUF_SET_NAME_A:
+	case DMA_BUF_SET_NAME_B:
 		return dma_buf_set_name(dmabuf, (const char __user *)arg);
 	default:
  * calls attach() of dma_buf_ops to allow device-specific attach functionality
  * @dmabuf:		[in]	buffer to attach device to.
  * @dev:		[in]	device to be attached.
- * @importer_ops	[in]	importer operations for the attachment
+ * @importer_ops:	[in]	importer operations for the attachment
- * @importer_priv	[in]	importer private pointer for the attachment
+ * @importer_priv:	[in]	importer private pointer for the attachment
  *
  * Returns struct dma_buf_attachment pointer for this attachment. Attachments
  * must be cleaned up by calling dma_buf_detach().

drivers/dma/Kconfig+2−1

@@ -241,7 +241,8 @@ config FSL_RAID · 240 unmodified lines
241		241
242	config HISI_DMA	242	config HISI_DMA
243	tristate "HiSilicon DMA Engine support"	243	tristate "HiSilicon DMA Engine support"
244	depends on ARM64 \|\| (COMPILE_TEST && PCI_MSI)	244	depends on ARM64 \|\| COMPILE_TEST
		245	depends on PCI_MSI
245	select DMA_ENGINE	246	select DMA_ENGINE
246	select DMA_VIRTUAL_CHANNELS	247	select DMA_VIRTUAL_CHANNELS
247	help	248	help

drivers/dma/dmaengine.c+26−34

 	struct dma_chan_dev *chan_dev;
 	chan_dev = container_of(dev, typeof(*chan_dev), device);
-	if (atomic_dec_and_test(chan_dev->idr_ref)) {
-		ida_free(&dma_ida, chan_dev->dev_id);
-		kfree(chan_dev->idr_ref);
-	}
 	kfree(chan_dev);
 }
 }
 static int __dma_async_device_channel_register(struct dma_device *device,
-					       struct dma_chan *chan,
+					       struct dma_chan *chan)
-					       int chan_id)
 {
 	int rc = 0;
-	int chancnt = device->chancnt;
-	atomic_t *idr_ref;
-	struct dma_chan *tchan;
-	tchan = list_first_entry_or_null(&device->channels,
-					 struct dma_chan, device_node);
-	if (!tchan)
-		return -ENODEV;
-	if (tchan->dev) {
-		idr_ref = tchan->dev->idr_ref;
-	} else {
-		idr_ref = kmalloc(sizeof(*idr_ref), GFP_KERNEL);
-		if (!idr_ref)
-			return -ENOMEM;
-		atomic_set(idr_ref, 0);
-	}
 	chan->local = alloc_percpu(typeof(*chan->local));
 	if (!chan->local)
 	 * When the chan_id is a negative value, we are dynamically adding
 	 * the channel. Otherwise we are static enumerating.
 	 */
-	chan->chan_id = chan_id < 0 ? chancnt : chan_id;
+	mutex_lock(&device->chan_mutex);
+	chan->chan_id = ida_alloc(&device->chan_ida, GFP_KERNEL);
+	mutex_unlock(&device->chan_mutex);
+	if (chan->chan_id < 0) {
+		pr_err("%s: unable to alloc ida for chan: %d\n",
+		       __func__, chan->chan_id);
+		goto err_out;
+	}
 	chan->dev->device.class = &dma_devclass;
 	chan->dev->device.parent = device->dev;
 	chan->dev->chan = chan;
-	chan->dev->idr_ref = idr_ref;
 	chan->dev->dev_id = device->dev_id;
-	atomic_inc(idr_ref);
 	dev_set_name(&chan->dev->device, "dma%dchan%d",
 		     device->dev_id, chan->chan_id);
 	rc = device_register(&chan->dev->device);
 	if (rc)
-		goto err_out;
+		goto err_out_ida;
 	chan->client_count = 0;
-	device->chancnt = chan->chan_id + 1;
+	device->chancnt++;
 	return 0;
+ err_out_ida:
+	mutex_lock(&device->chan_mutex);
+	ida_free(&device->chan_ida, chan->chan_id);
+	mutex_unlock(&device->chan_mutex);
  err_out:
 	free_percpu(chan->local);
 	kfree(chan->dev);
-	if (atomic_dec_return(idr_ref) == 0)
-		kfree(idr_ref);
 	return rc;
 }
 {
 	int rc;
-	rc = __dma_async_device_channel_register(device, chan, -1);
+	rc = __dma_async_device_channel_register(device, chan);
 	if (rc < 0)
 		return rc;
 	device->chancnt--;
 	chan->dev->chan = NULL;
 	mutex_unlock(&dma_list_mutex);
+	mutex_lock(&device->chan_mutex);
+	ida_free(&device->chan_ida, chan->chan_id);
+	mutex_unlock(&device->chan_mutex);
 	device_unregister(&chan->dev->device);
 	free_percpu(chan->local);
 }
  */
 int dma_async_device_register(struct dma_device *device)
 {
-	int rc, i = 0;
+	int rc;
 	struct dma_chan* chan;
 	if (!device)
 	if (rc != 0)
 		return rc;
+	mutex_init(&device->chan_mutex);
+	ida_init(&device->chan_ida);
 	/* represent channels in sysfs. Probably want devs too */
 	list_for_each_entry(chan, &device->channels, device_node) {
-		rc = __dma_async_device_channel_register(device, chan, i++);
+		rc = __dma_async_device_channel_register(device, chan);
 		if (rc < 0)
 			goto err_out;
 	}
 	 */
 	dma_cap_set(DMA_PRIVATE, device->cap_mask);
 	dma_channel_rebalance();
+	ida_free(&dma_ida, device->dev_id);
 	dma_device_put(device);
 	mutex_unlock(&dma_list_mutex);
 }

drivers/dma/dmatest.c+3−3

@@ -240,7 +240,7 @@ static bool is_threaded_test_run(struct dmatest_info *info) · 239 unmodified lines
240	struct dmatest_thread *thread;	240	struct dmatest_thread *thread;
241		241
242	list_for_each_entry(thread, &dtc->threads, node) {	242	list_for_each_entry(thread, &dtc->threads, node) {
243	if (!thread->done)	243	if (!thread->done && !thread->pending)
244	return true;	244	return true;
245	}	245	}
246	}	246	}
@@ -662,8 +662,8 @@ static int dmatest_func(void *data) · 415 unmodified lines
662	flags = DMA_CTRL_ACK \| DMA_PREP_INTERRUPT;	662	flags = DMA_CTRL_ACK \| DMA_PREP_INTERRUPT;
663		663
664	ktime = ktime_get();	664	ktime = ktime_get();
665	while (!kthread_should_stop()	665	while (!(kthread_should_stop() \|\|
666	&& !(params->iterations && total_tests >= params->iterations)) {	666	(params->iterations && total_tests >= params->iterations))) {
667	struct dma_async_tx_descriptor *tx = NULL;	667	struct dma_async_tx_descriptor *tx = NULL;
668	struct dmaengine_unmap_data *um;	668	struct dmaengine_unmap_data *um;
669	dma_addr_t *dsts;	669	dma_addr_t *dsts;

drivers/dma/mmp_tdma.c+4−1

 		gen_pool_free(gpool, (unsigned long)tdmac->desc_arr,
 				size);
 	tdmac->desc_arr = NULL;
+	if (tdmac->status == DMA_ERROR)
+		tdmac->status = DMA_COMPLETE;
 	return;
 }
 	if (!desc)
 		goto err_out;
-	mmp_tdma_config_write(chan, direction, &tdmac->slave_config);
+	if (mmp_tdma_config_write(chan, direction, &tdmac->slave_config))
+		goto err_out;
 	while (buf < buf_len) {
 		desc = &tdmac->desc_arr[i];

drivers/dma/pch_dma.c+1−1

 	}
 	pci_set_master(pdev);
+	pd->dma.dev = &pdev->dev;
 	err = request_irq(pdev->irq, pd_irq, IRQF_SHARED, DRV_NAME, pd);
 	if (err) {
 		goto err_free_irq;
 	}
-	pd->dma.dev = &pdev->dev;
 	INIT_LIST_HEAD(&pd->dma.channels);

drivers/dma/tegra20-apb-dma.c+9−0

 static void tegra_dma_synchronize(struct dma_chan *dc)
 {
 	struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
+	int err;
+	err = pm_runtime_get_sync(tdc->tdma->dev);
+	if (err < 0) {
+		dev_err(tdc2dev(tdc), "Failed to synchronize DMA: %d\n", err);
+		return;
+	}
 	/*
 	 * CPU, which handles interrupt, could be busy in
 	wait_event(tdc->wq, tegra_dma_eoc_interrupt_deasserted(tdc));
 	tasklet_kill(&tdc->tasklet);
+	pm_runtime_put(tdc->tdma->dev);
 }
 static unsigned int tegra_dma_sg_bytes_xferred(struct tegra_dma_channel *tdc,

drivers/dma/ti/k3-psil.c+1−0

@@ -27,6 +27,7 @@ struct psil_endpoint_config *psil_get_ep_config(u32 thread_id) · 26 unmodified lines
27	soc_ep_map = &j721e_ep_map;	27	soc_ep_map = &j721e_ep_map;
28	} else {	28	} else {
29	pr_err("PSIL: No compatible machine found for map\n");	29	pr_err("PSIL: No compatible machine found for map\n");
		30	mutex_unlock(&ep_map_mutex);
30	return ERR_PTR(-ENOTSUPP);	31	return ERR_PTR(-ENOTSUPP);
31	}	32	}
32	pr_debug("%s: Using map for %s\n", __func__, soc_ep_map->name);	33	pr_debug("%s: Using map for %s\n", __func__, soc_ep_map->name);

drivers/dma/xilinx/xilinx_dma.c+10−10

@@ -1230,16 +1230,16 @@ static enum dma_status xilinx_dma_tx_status(struct dma_chan *dchan, · 1229 unmodified lines
1230	return ret;	1230	return ret;
1231		1231
1232	spin_lock_irqsave(&chan->lock, flags);	1232	spin_lock_irqsave(&chan->lock, flags);
1233		1233	if (!list_empty(&chan->active_list)) {
1234	desc = list_last_entry(&chan->active_list,	1234	desc = list_last_entry(&chan->active_list,
1235	struct xilinx_dma_tx_descriptor, node);	1235	struct xilinx_dma_tx_descriptor, node);
1236	/*	1236	/*
1237	* VDMA and simple mode do not support residue reporting, so the	1237	* VDMA and simple mode do not support residue reporting, so the
1238	* residue field will always be 0.	1238	* residue field will always be 0.
1239	*/	1239	*/
1240	if (chan->has_sg && chan->xdev->dma_config->dmatype != XDMA_TYPE_VDMA)	1240	if (chan->has_sg && chan->xdev->dma_config->dmatype != XDMA_TYPE_VDMA)
1241	residue = xilinx_dma_get_residue(chan, desc);	1241	residue = xilinx_dma_get_residue(chan, desc);
1242		1242	}
1243	spin_unlock_irqrestore(&chan->lock, flags);	1243	spin_unlock_irqrestore(&chan->lock, flags);
1244		1244
1245	dma_set_residue(txstate, residue);	1245	dma_set_residue(txstate, residue);

drivers/firmware/efi/tpm.c+1−1

@@ -16,7 +16,7 @@ · 15 unmodified lines
16	int efi_tpm_final_log_size;	16	int efi_tpm_final_log_size;
17	EXPORT_SYMBOL(efi_tpm_final_log_size);	17	EXPORT_SYMBOL(efi_tpm_final_log_size);
18		18
19	static int tpm2_calc_event_log_size(void data, int count, void size_info)	19	static int __init tpm2_calc_event_log_size(void data, int count, void size_info)
20	{	20	{
21	struct tcg_pcr_event2_head *header;	21	struct tcg_pcr_event2_head *header;
22	int event_size, size = 0;	22	int event_size, size = 0;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c+2−5

 		}
 	}
-	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
-	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
-	amdgpu_amdkfd_suspend(adev, !fbcon);
 	amdgpu_ras_suspend(adev);
 	r = amdgpu_device_ip_suspend_phase1(adev);
+	amdgpu_amdkfd_suspend(adev, !fbcon);
 	/* evict vram memory */
 	amdgpu_bo_evict_vram(adev);

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

  * - 3.34.0 - Non-DC can flip correctly between buffers with different pitches
  * - 3.35.0 - Add drm_amdgpu_info_device::tcc_disabled_mask
  * - 3.36.0 - Allow reading more status registers on si/cik
+ * - 3.37.0 - L2 is invalidated before SDMA IBs, needed for correctness
  */
 #define KMS_DRIVER_MAJOR	3
-#define KMS_DRIVER_MINOR	36
+#define KMS_DRIVER_MINOR	37
 #define KMS_DRIVER_PATCHLEVEL	0
 int amdgpu_vram_limit = 0;

drivers/gpu/drm/amd/amdgpu/navi10_sdma_pkt_open.h+16−0

@@ -73,6 +73,22 @@ · 72 unmodified lines
73	#define SDMA_OP_AQL_COPY 0	73	#define SDMA_OP_AQL_COPY 0
74	#define SDMA_OP_AQL_BARRIER_OR 0	74	#define SDMA_OP_AQL_BARRIER_OR 0
75		75
		76	#define SDMA_GCR_RANGE_IS_PA (1 << 18)
		77	#define SDMA_GCR_SEQ(x) (((x) & 0x3) << 16)
		78	#define SDMA_GCR_GL2_WB (1 << 15)
		79	#define SDMA_GCR_GL2_INV (1 << 14)
		80	#define SDMA_GCR_GL2_DISCARD (1 << 13)
		81	#define SDMA_GCR_GL2_RANGE(x) (((x) & 0x3) << 11)
		82	#define SDMA_GCR_GL2_US (1 << 10)
		83	#define SDMA_GCR_GL1_INV (1 << 9)
		84	#define SDMA_GCR_GLV_INV (1 << 8)
		85	#define SDMA_GCR_GLK_INV (1 << 7)
		86	#define SDMA_GCR_GLK_WB (1 << 6)
		87	#define SDMA_GCR_GLM_INV (1 << 5)
		88	#define SDMA_GCR_GLM_WB (1 << 4)
		89	#define SDMA_GCR_GL1_RANGE(x) (((x) & 0x3) << 2)
		90	#define SDMA_GCR_GLI_INV(x) (((x) & 0x3) << 0)
		91
76	/define for op field/	92	/define for op field/
77	#define SDMA_PKT_HEADER_op_offset 0	93	#define SDMA_PKT_HEADER_op_offset 0
78	#define SDMA_PKT_HEADER_op_mask 0x000000FF	94	#define SDMA_PKT_HEADER_op_mask 0x000000FF

drivers/gpu/drm/amd/amdgpu/sdma_v5_0.c+13−1

 	unsigned vmid = AMDGPU_JOB_GET_VMID(job);
 	uint64_t csa_mc_addr = amdgpu_sdma_get_csa_mc_addr(ring, vmid);
+	/* Invalidate L2, because if we don't do it, we might get stale cache
+	 * lines from previous IBs.
+	 */
+	amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_GCR_REQ));
+	amdgpu_ring_write(ring, 0);
+	amdgpu_ring_write(ring, (SDMA_GCR_GL2_INV |
+				 SDMA_GCR_GL2_WB |
+				 SDMA_GCR_GLM_INV |
+				 SDMA_GCR_GLM_WB) << 16);
+	amdgpu_ring_write(ring, 0xffffff80);
+	amdgpu_ring_write(ring, 0xffff);
 	/* An IB packet must end on a 8 DW boundary--the next dword
 	 * must be on a 8-dword boundary. Our IB packet below is 6
 	 * dwords long, thus add x number of NOPs, such that, in
 		SOC15_FLUSH_GPU_TLB_NUM_WREG * 3 +
 		SOC15_FLUSH_GPU_TLB_NUM_REG_WAIT * 6 * 2 +
 		10 + 10 + 10, /* sdma_v5_0_ring_emit_fence x3 for user fence, vm fence */
-	.emit_ib_size = 7 + 6, /* sdma_v5_0_ring_emit_ib */
+	.emit_ib_size = 5 + 7 + 6, /* sdma_v5_0_ring_emit_ib */
 	.emit_ib = sdma_v5_0_ring_emit_ib,
 	.emit_fence = sdma_v5_0_ring_emit_fence,
 	.emit_pipeline_sync = sdma_v5_0_ring_emit_pipeline_sync,

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+40−15

@@ -2008,17 +2008,22 @@ void amdgpu_dm_update_connector_after_detect( · 2007 unmodified lines
2008	dc_sink_retain(aconnector->dc_sink);	2008	dc_sink_retain(aconnector->dc_sink);
2009	if (sink->dc_edid.length == 0) {	2009	if (sink->dc_edid.length == 0) {
2010	aconnector->edid = NULL;	2010	aconnector->edid = NULL;
2011	drm_dp_cec_unset_edid(&aconnector->dm_dp_aux.aux);	2011	if (aconnector->dc_link->aux_mode) {
		2012	drm_dp_cec_unset_edid(
		2013	&aconnector->dm_dp_aux.aux);
		2014	}
2012	} else {	2015	} else {
2013	aconnector->edid =	2016	aconnector->edid =
2014	(struct edid *) sink->dc_edid.raw_edid;	2017	(struct edid *)sink->dc_edid.raw_edid;
2015
2016		2018
2017	drm_connector_update_edid_property(connector,	2019	drm_connector_update_edid_property(connector,
2018	aconnector->edid);	2020	aconnector->edid);
2019	drm_dp_cec_set_edid(&aconnector->dm_dp_aux.aux,	2021
2020	aconnector->edid);	2022	if (aconnector->dc_link->aux_mode)
		2023	drm_dp_cec_set_edid(&aconnector->dm_dp_aux.aux,
		2024	aconnector->edid);
2021	}	2025	}
		2026
2022	amdgpu_dm_update_freesync_caps(connector, aconnector->edid);	2027	amdgpu_dm_update_freesync_caps(connector, aconnector->edid);
2023	update_connector_ext_caps(aconnector);	2028	update_connector_ext_caps(aconnector);
2024	} else {	2029	} else {
@@ -3340,7 +3345,8 @@ fill_plane_dcc_attributes(struct amdgpu_device *adev, · 1315 unmodified lines
3340	const union dc_tiling_info *tiling_info,	3345	const union dc_tiling_info *tiling_info,
3341	const uint64_t info,	3346	const uint64_t info,
3342	struct dc_plane_dcc_param *dcc,	3347	struct dc_plane_dcc_param *dcc,
3343	struct dc_plane_address *address)	3348	struct dc_plane_address *address,
		3349	bool force_disable_dcc)
3344	{	3350	{
3345	struct dc *dc = adev->dm.dc;	3351	struct dc *dc = adev->dm.dc;
3346	struct dc_dcc_surface_param input;	3352	struct dc_dcc_surface_param input;
@@ -3352,6 +3358,9 @@ fill_plane_dcc_attributes(struct amdgpu_device *adev, · 5 unmodified lines
3352	memset(&input, 0, sizeof(input));	3358	memset(&input, 0, sizeof(input));
3353	memset(&output, 0, sizeof(output));	3359	memset(&output, 0, sizeof(output));
3354		3360
		3361	if (force_disable_dcc)
		3362	return 0;
		3363
3355	if (!offset)	3364	if (!offset)
3356	return 0;	3365	return 0;
3357		3366
@@ -3401,7 +3410,8 @@ fill_plane_buffer_attributes(struct amdgpu_device *adev, · 43 unmodified lines
3401	union dc_tiling_info *tiling_info,	3410	union dc_tiling_info *tiling_info,
3402	struct plane_size *plane_size,	3411	struct plane_size *plane_size,
3403	struct dc_plane_dcc_param *dcc,	3412	struct dc_plane_dcc_param *dcc,
3404	struct dc_plane_address *address)	3413	struct dc_plane_address *address,
		3414	bool force_disable_dcc)
3405	{	3415	{
3406	const struct drm_framebuffer *fb = &afb->base;	3416	const struct drm_framebuffer *fb = &afb->base;
3407	int ret;	3417	int ret;
@@ -3507,7 +3517,8 @@ fill_plane_buffer_attributes(struct amdgpu_device *adev, · 99 unmodified lines
3507		3517
3508	ret = fill_plane_dcc_attributes(adev, afb, format, rotation,	3518	ret = fill_plane_dcc_attributes(adev, afb, format, rotation,
3509	plane_size, tiling_info,	3519	plane_size, tiling_info,
3510	tiling_flags, dcc, address);	3520	tiling_flags, dcc, address,
		3521	force_disable_dcc);
3511	if (ret)	3522	if (ret)
3512	return ret;	3523	return ret;
3513	}	3524	}
@@ -3599,7 +3610,8 @@ fill_dc_plane_info_and_addr(struct amdgpu_device *adev, · 85 unmodified lines
3599	const struct drm_plane_state *plane_state,	3610	const struct drm_plane_state *plane_state,
3600	const uint64_t tiling_flags,	3611	const uint64_t tiling_flags,
3601	struct dc_plane_info *plane_info,	3612	struct dc_plane_info *plane_info,
3602	struct dc_plane_address *address)	3613	struct dc_plane_address *address,
		3614	bool force_disable_dcc)
3603	{	3615	{
3604	const struct drm_framebuffer *fb = plane_state->fb;	3616	const struct drm_framebuffer *fb = plane_state->fb;
3605	const struct amdgpu_framebuffer *afb =	3617	const struct amdgpu_framebuffer *afb =
@@ -3681,7 +3693,8 @@ fill_dc_plane_info_and_addr(struct amdgpu_device *adev, · 75 unmodified lines
3681	plane_info->rotation, tiling_flags,	3693	plane_info->rotation, tiling_flags,
3682	&plane_info->tiling_info,	3694	&plane_info->tiling_info,
3683	&plane_info->plane_size,	3695	&plane_info->plane_size,
3684	&plane_info->dcc, address);	3696	&plane_info->dcc, address,
		3697	force_disable_dcc);
3685	if (ret)	3698	if (ret)
3686	return ret;	3699	return ret;
3687		3700
@@ -3704,6 +3717,7 @@ static int fill_dc_plane_attributes(struct amdgpu_device *adev, · 16 unmodified lines
3704	struct dc_plane_info plane_info;	3717	struct dc_plane_info plane_info;
3705	uint64_t tiling_flags;	3718	uint64_t tiling_flags;
3706	int ret;	3719	int ret;
		3720	bool force_disable_dcc = false;
3707		3721
3708	ret = fill_dc_scaling_info(plane_state, &scaling_info);	3722	ret = fill_dc_scaling_info(plane_state, &scaling_info);
3709	if (ret)	3723	if (ret)
@@ -3718,9 +3732,11 @@ static int fill_dc_plane_attributes(struct amdgpu_device *adev, · 8 unmodified lines
3718	if (ret)	3732	if (ret)
3719	return ret;	3733	return ret;
3720		3734
		3735	force_disable_dcc = adev->asic_type == CHIP_RAVEN && adev->in_suspend;
3721	ret = fill_dc_plane_info_and_addr(adev, plane_state, tiling_flags,	3736	ret = fill_dc_plane_info_and_addr(adev, plane_state, tiling_flags,
3722	&plane_info,	3737	&plane_info,
3723	&dc_plane_state->address);	3738	&dc_plane_state->address,
		3739	force_disable_dcc);
3724	if (ret)	3740	if (ret)
3725	return ret;	3741	return ret;
3726		3742
@@ -5342,6 +5358,7 @@ static int dm_plane_helper_prepare_fb(struct drm_plane *plane, · 1615 unmodified lines
5342	uint64_t tiling_flags;	5358	uint64_t tiling_flags;
5343	uint32_t domain;	5359	uint32_t domain;
5344	int r;	5360	int r;
		5361	bool force_disable_dcc = false;
5345		5362
5346	dm_plane_state_old = to_dm_plane_state(plane->state);	5363	dm_plane_state_old = to_dm_plane_state(plane->state);
5347	dm_plane_state_new = to_dm_plane_state(new_state);	5364	dm_plane_state_new = to_dm_plane_state(new_state);
@@ -5400,11 +5417,13 @@ static int dm_plane_helper_prepare_fb(struct drm_plane *plane, · 52 unmodified lines
5400	dm_plane_state_old->dc_state != dm_plane_state_new->dc_state) {	5417	dm_plane_state_old->dc_state != dm_plane_state_new->dc_state) {
5401	struct dc_plane_state *plane_state = dm_plane_state_new->dc_state;	5418	struct dc_plane_state *plane_state = dm_plane_state_new->dc_state;
5402		5419
		5420	force_disable_dcc = adev->asic_type == CHIP_RAVEN && adev->in_suspend;
5403	fill_plane_buffer_attributes(	5421	fill_plane_buffer_attributes(
5404	adev, afb, plane_state->format, plane_state->rotation,	5422	adev, afb, plane_state->format, plane_state->rotation,
5405	tiling_flags, &plane_state->tiling_info,	5423	tiling_flags, &plane_state->tiling_info,
5406	&plane_state->plane_size, &plane_state->dcc,	5424	&plane_state->plane_size, &plane_state->dcc,
5407	&plane_state->address);	5425	&plane_state->address,
		5426	force_disable_dcc);
5408	}	5427	}
5409		5428
5410	return 0;	5429	return 0;
@@ -6676,7 +6695,12 @@ static void amdgpu_dm_commit_planes(struct drm_atomic_state *state, · 1265 unmodified lines
6676	fill_dc_plane_info_and_addr(	6695	fill_dc_plane_info_and_addr(
6677	dm->adev, new_plane_state, tiling_flags,	6696	dm->adev, new_plane_state, tiling_flags,
6678	&bundle->plane_infos[planes_count],	6697	&bundle->plane_infos[planes_count],
6679	&bundle->flip_addrs[planes_count].address);	6698	&bundle->flip_addrs[planes_count].address,
		6699	false);
		6700
		6701	DRM_DEBUG_DRIVER("plane: id=%d dcc_en=%d\n",
		6702	new_plane_state->plane->index,
		6703	bundle->plane_infos[planes_count].dcc.enable);
6680		6704
6681	bundle->surface_updates[planes_count].plane_info =	6705	bundle->surface_updates[planes_count].plane_info =
6682	&bundle->plane_infos[planes_count];	6706	&bundle->plane_infos[planes_count];
@@ -8096,7 +8120,8 @@ dm_determine_update_type_for_commit(struct amdgpu_display_manager *dm, · 1413 unmodified lines
8096	ret = fill_dc_plane_info_and_addr(	8120	ret = fill_dc_plane_info_and_addr(
8097	dm->adev, new_plane_state, tiling_flags,	8121	dm->adev, new_plane_state, tiling_flags,
8098	plane_info,	8122	plane_info,
8099	&flip_addr->address);	8123	&flip_addr->address,
		8124	false);
8100	if (ret)	8125	if (ret)
8101	goto cleanup;	8126	goto cleanup;
8102		8127

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

 static void wait_for_no_pipes_pending(struct dc *dc, struct dc_state *context)
 {
 	int i;
-	int count = 0;
-	struct pipe_ctx *pipe;
 	PERF_TRACE();
 	for (i = 0; i < MAX_PIPES; i++) {
-		pipe = &context->res_ctx.pipe_ctx[i];
+		int count = 0;
+		struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
 		if (!pipe->plane_state)
 			continue;

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

@@ -2908,6 +2908,12 @@ bool dc_link_handle_hpd_rx_irq(struct dc_link link, union hpd_irq_data out_hpd · 2907 unmodified lines
2908	sizeof(hpd_irq_dpcd_data),	2908	sizeof(hpd_irq_dpcd_data),
2909	"Status: ");	2909	"Status: ");
2910		2910
		2911	for (i = 0; i < MAX_PIPES; i++) {
		2912	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];
		2913	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)
		2914	link->dc->hwss.blank_stream(pipe_ctx);
		2915	}
		2916
2911	for (i = 0; i < MAX_PIPES; i++) {	2917	for (i = 0; i < MAX_PIPES; i++) {
2912	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];	2918	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];
2913	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)	2919	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)
@@ -2927,6 +2933,12 @@ bool dc_link_handle_hpd_rx_irq(struct dc_link link, union hpd_irq_data out_hpd · 13 unmodified lines
2927	if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST)	2933	if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST)
2928	dc_link_reallocate_mst_payload(link);	2934	dc_link_reallocate_mst_payload(link);
2929		2935
		2936	for (i = 0; i < MAX_PIPES; i++) {
		2937	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];
		2938	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)
		2939	link->dc->hwss.unblank_stream(pipe_ctx, &previous_link_settings);
		2940	}
		2941
2930	status = false;	2942	status = false;
2931	if (out_link_loss)	2943	if (out_link_loss)
2932	*out_link_loss = true;	2944	*out_link_loss = true;
@@ -4227,6 +4239,21 @@ void dp_set_fec_enable(struct dc_link *link, bool enable) · 1294 unmodified lines
4227	void dpcd_set_source_specific_data(struct dc_link *link)	4239	void dpcd_set_source_specific_data(struct dc_link *link)
4228	{	4240	{
4229	const uint32_t post_oui_delay = 30; // 30ms	4241	const uint32_t post_oui_delay = 30; // 30ms
		4242	uint8_t dspc = 0;
		4243	enum dc_status ret = DC_ERROR_UNEXPECTED;
		4244
		4245	ret = core_link_read_dpcd(link, DP_DOWN_STREAM_PORT_COUNT, &dspc,
		4246	sizeof(dspc));
		4247
		4248	if (ret != DC_OK) {
		4249	DC_LOG_ERROR("Error in DP aux read transaction,"
		4250	" not writing source specific data\n");
		4251	return;
		4252	}
		4253
		4254	/* Return if OUI unsupported */
		4255	if (!(dspc & DP_OUI_SUPPORT))
		4256	return;
4230		4257
4231	if (!link->dc->vendor_signature.is_valid) {	4258	if (!link->dc->vendor_signature.is_valid) {
4232	struct dpcd_amd_signature amd_signature;	4259	struct dpcd_amd_signature amd_signature;

drivers/gpu/drm/amd/display/dc/core/dc_stream.c+4−36

@@ -231,34 +231,6 @@ struct dc_stream_status *dc_stream_get_status( · 230 unmodified lines
231	return dc_stream_get_status_from_state(dc->current_state, stream);	231	return dc_stream_get_status_from_state(dc->current_state, stream);
232	}	232	}
233		233
234	static void delay_cursor_until_vupdate(struct pipe_ctx pipe_ctx, struct dc dc)
235	{
236	#if defined(CONFIG_DRM_AMD_DC_DCN)
237	unsigned int vupdate_line;
238	unsigned int lines_to_vupdate, us_to_vupdate, vpos, nvpos;
239	struct dc_stream_state *stream = pipe_ctx->stream;
240	unsigned int us_per_line;
241
242	if (stream->ctx->asic_id.chip_family == FAMILY_RV &&
243	ASICREV_IS_RAVEN(stream->ctx->asic_id.hw_internal_rev)) {
244
245	vupdate_line = dc->hwss.get_vupdate_offset_from_vsync(pipe_ctx);
246	if (!dc_stream_get_crtc_position(dc, &stream, 1, &vpos, &nvpos))
247	return;
248
249	if (vpos >= vupdate_line)
250	return;
251
252	us_per_line = stream->timing.h_total * 10000 / stream->timing.pix_clk_100hz;
253	lines_to_vupdate = vupdate_line - vpos;
254	us_to_vupdate = lines_to_vupdate * us_per_line;
255
256	/* 70 us is a conservative estimate of cursor update time*/
257	if (us_to_vupdate < 70)
258	udelay(us_to_vupdate);
259	}
260	#endif
261	}
262		234
263	/**	235	/**
264	* dc_stream_set_cursor_attributes() - Update cursor attributes and set cursor surface address	236	* dc_stream_set_cursor_attributes() - Update cursor attributes and set cursor surface address
@@ -298,9 +270,7 @@ bool dc_stream_set_cursor_attributes( · 33 unmodified lines
298		270
299	if (!pipe_to_program) {	271	if (!pipe_to_program) {
300	pipe_to_program = pipe_ctx;	272	pipe_to_program = pipe_ctx;
301		273	dc->hwss.cursor_lock(dc, pipe_to_program, true);
302	delay_cursor_until_vupdate(pipe_ctx, dc);
303	dc->hwss.pipe_control_lock(dc, pipe_to_program, true);
304	}	274	}
305		275
306	dc->hwss.set_cursor_attribute(pipe_ctx);	276	dc->hwss.set_cursor_attribute(pipe_ctx);
@@ -309,7 +279,7 @@ bool dc_stream_set_cursor_attributes( · 2 unmodified lines
309	}	279	}
310		280
311	if (pipe_to_program)	281	if (pipe_to_program)
312	dc->hwss.pipe_control_lock(dc, pipe_to_program, false);	282	dc->hwss.cursor_lock(dc, pipe_to_program, false);
313		283
314	return true;	284	return true;
315	}	285	}
@@ -349,16 +319,14 @@ bool dc_stream_set_cursor_position( · 33 unmodified lines
349		319
350	if (!pipe_to_program) {	320	if (!pipe_to_program) {
351	pipe_to_program = pipe_ctx;	321	pipe_to_program = pipe_ctx;
352		322	dc->hwss.cursor_lock(dc, pipe_to_program, true);
353	delay_cursor_until_vupdate(pipe_ctx, dc);
354	dc->hwss.pipe_control_lock(dc, pipe_to_program, true);
355	}	323	}
356		324
357	dc->hwss.set_cursor_position(pipe_ctx);	325	dc->hwss.set_cursor_position(pipe_ctx);
358	}	326	}
359		327
360	if (pipe_to_program)	328	if (pipe_to_program)
361	dc->hwss.pipe_control_lock(dc, pipe_to_program, false);	329	dc->hwss.cursor_lock(dc, pipe_to_program, false);
362		330
363	return true;	331	return true;
364	}	332	}

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

@@ -2757,6 +2757,7 @@ static const struct hw_sequencer_funcs dce110_funcs = { · 2756 unmodified lines
2757	.disable_plane = dce110_power_down_fe,	2757	.disable_plane = dce110_power_down_fe,
2758	.pipe_control_lock = dce_pipe_control_lock,	2758	.pipe_control_lock = dce_pipe_control_lock,
2759	.interdependent_update_lock = NULL,	2759	.interdependent_update_lock = NULL,
		2760	.cursor_lock = dce_pipe_control_lock,
2760	.prepare_bandwidth = dce110_prepare_bandwidth,	2761	.prepare_bandwidth = dce110_prepare_bandwidth,
2761	.optimize_bandwidth = dce110_optimize_bandwidth,	2762	.optimize_bandwidth = dce110_optimize_bandwidth,
2762	.set_drr = set_drr,	2763	.set_drr = set_drr,

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c+10−0

@@ -1625,6 +1625,16 @@ void dcn10_pipe_control_lock( · 1624 unmodified lines
1625	hws->funcs.verify_allow_pstate_change_high(dc);	1625	hws->funcs.verify_allow_pstate_change_high(dc);
1626	}	1626	}
1627		1627
		1628	void dcn10_cursor_lock(struct dc dc, struct pipe_ctx pipe, bool lock)
		1629	{
		1630	/* cursor lock is per MPCC tree, so only need to lock one pipe per stream */
		1631	if (!pipe \|\| pipe->top_pipe)
		1632	return;
		1633
		1634	dc->res_pool->mpc->funcs->cursor_lock(dc->res_pool->mpc,
		1635	pipe->stream_res.opp->inst, lock);
		1636	}
		1637
1628	static bool wait_for_reset_trigger_to_occur(	1638	static bool wait_for_reset_trigger_to_occur(
1629	struct dc_context *dc_ctx,	1639	struct dc_context *dc_ctx,
1630	struct timing_generator *tg)	1640	struct timing_generator *tg)

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.h+1−0

@@ -49,6 +49,7 @@ void dcn10_pipe_control_lock( · 48 unmodified lines
49	struct dc *dc,	49	struct dc *dc,
50	struct pipe_ctx *pipe,	50	struct pipe_ctx *pipe,
51	bool lock);	51	bool lock);
		52	void dcn10_cursor_lock(struct dc dc, struct pipe_ctx pipe, bool lock);
52	void dcn10_blank_pixel_data(	53	void dcn10_blank_pixel_data(
53	struct dc *dc,	54	struct dc *dc,
54	struct pipe_ctx *pipe_ctx,	55	struct pipe_ctx *pipe_ctx,

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

@@ -50,6 +50,7 @@ static const struct hw_sequencer_funcs dcn10_funcs = { · 49 unmodified lines
50	.disable_audio_stream = dce110_disable_audio_stream,	50	.disable_audio_stream = dce110_disable_audio_stream,
51	.disable_plane = dcn10_disable_plane,	51	.disable_plane = dcn10_disable_plane,
52	.pipe_control_lock = dcn10_pipe_control_lock,	52	.pipe_control_lock = dcn10_pipe_control_lock,
		53	.cursor_lock = dcn10_cursor_lock,
53	.interdependent_update_lock = dcn10_lock_all_pipes,	54	.interdependent_update_lock = dcn10_lock_all_pipes,
54	.prepare_bandwidth = dcn10_prepare_bandwidth,	55	.prepare_bandwidth = dcn10_prepare_bandwidth,
55	.optimize_bandwidth = dcn10_optimize_bandwidth,	56	.optimize_bandwidth = dcn10_optimize_bandwidth,

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.c+15−0

 	REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, dpp_id);
 	REG_SET(MPCC_OPP_ID[mpcc_id], 0, MPCC_OPP_ID, tree->opp_id);
+	/* Configure VUPDATE lock set for this MPCC to map to the OPP */
+	REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, tree->opp_id);
 	/* update mpc tree mux setting */
 	if (tree->opp_list == insert_above_mpcc) {
 		/* insert the toppest mpcc */
 		REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 		REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 		REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+		REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 		/* mark this mpcc as not in use */
 		mpc10->mpcc_in_use_mask &= ~(1 << mpcc_id);
 		REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 		REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 		REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+		REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 	}
 }
 		REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 		REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 		REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+		REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 		mpc1_init_mpcc(&(mpc->mpcc_array[mpcc_id]), mpcc_id);
 	}
 	REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 	REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 	REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+	REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 	mpc1_init_mpcc(&(mpc->mpcc_array[mpcc_id]), mpcc_id);
 			MPCC_BUSY, &s->busy);
 }
+void mpc1_cursor_lock(struct mpc *mpc, int opp_id, bool lock)
+{
+	struct dcn10_mpc *mpc10 = TO_DCN10_MPC(mpc);
+	REG_SET(CUR[opp_id], 0, CUR_VUPDATE_LOCK_SET, lock ? 1 : 0);
+}
 static const struct mpc_funcs dcn10_mpc_funcs = {
 	.read_mpcc_state = mpc1_read_mpcc_state,
 	.insert_plane = mpc1_insert_plane,
 	.assert_mpcc_idle_before_connect = mpc1_assert_mpcc_idle_before_connect,
 	.init_mpcc_list_from_hw = mpc1_init_mpcc_list_from_hw,
 	.update_blending = mpc1_update_blending,
+	.cursor_lock = mpc1_cursor_lock,
 	.set_denorm = NULL,
 	.set_denorm_clamp = NULL,
 	.set_output_csc = NULL,

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.h+14−6

 	SRII(MPCC_BG_G_Y, MPCC, inst),\
 	SRII(MPCC_BG_R_CR, MPCC, inst),\
 	SRII(MPCC_BG_B_CB, MPCC, inst),\
-	SRII(MPCC_BG_B_CB, MPCC, inst),\
+	SRII(MPCC_SM_CONTROL, MPCC, inst),\
-	SRII(MPCC_SM_CONTROL, MPCC, inst)
+	SRII(MPCC_UPDATE_LOCK_SEL, MPCC, inst)
 #define MPC_OUT_MUX_COMMON_REG_LIST_DCN1_0(inst) \
-	SRII(MUX, MPC_OUT, inst)
+	SRII(MUX, MPC_OUT, inst),\
+	VUPDATE_SRII(CUR, VUPDATE_LOCK_SET, inst)
 #define MPC_COMMON_REG_VARIABLE_LIST \
 	uint32_t MPCC_TOP_SEL[MAX_MPCC]; \
 	uint32_t MPCC_BG_R_CR[MAX_MPCC]; \
 	uint32_t MPCC_BG_B_CB[MAX_MPCC]; \
 	uint32_t MPCC_SM_CONTROL[MAX_MPCC]; \
-	uint32_t MUX[MAX_OPP];
+	uint32_t MUX[MAX_OPP]; \
+	uint32_t MPCC_UPDATE_LOCK_SEL[MAX_MPCC]; \
+	uint32_t CUR[MAX_OPP];
 #define MPC_COMMON_MASK_SH_LIST_DCN1_0(mask_sh)\
 	SF(MPCC0_MPCC_TOP_SEL, MPCC_TOP_SEL, mask_sh),\
 	SF(MPCC0_MPCC_SM_CONTROL, MPCC_SM_FIELD_ALT, mask_sh),\
 	SF(MPCC0_MPCC_SM_CONTROL, MPCC_SM_FORCE_NEXT_FRAME_POL, mask_sh),\
 	SF(MPCC0_MPCC_SM_CONTROL, MPCC_SM_FORCE_NEXT_TOP_POL, mask_sh),\
-	SF(MPC_OUT0_MUX, MPC_OUT_MUX, mask_sh)
+	SF(MPC_OUT0_MUX, MPC_OUT_MUX, mask_sh),\
+	SF(MPCC0_MPCC_UPDATE_LOCK_SEL, MPCC_UPDATE_LOCK_SEL, mask_sh)
 #define MPC_REG_FIELD_LIST(type) \
 	type MPCC_TOP_SEL;\
 	type MPCC_SM_FIELD_ALT;\
 	type MPCC_SM_FORCE_NEXT_FRAME_POL;\
 	type MPCC_SM_FORCE_NEXT_TOP_POL;\
-	type MPC_OUT_MUX;
+	type MPC_OUT_MUX;\
+	type MPCC_UPDATE_LOCK_SEL;\
+	type CUR_VUPDATE_LOCK_SET;
 struct dcn_mpc_registers {
 	MPC_COMMON_REG_VARIABLE_LIST
 		int mpcc_inst,
 		struct mpcc_state *s);
+void mpc1_cursor_lock(struct mpc *mpc, int opp_id, bool lock);
 #endif

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_resource.c+12−2

 	.reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
 					mm ## block ## id ## _ ## reg_name
+#define VUPDATE_SRII(reg_name, block, id)\
+	.reg_name[id] = BASE(mm ## reg_name ## 0 ## _ ## block ## id ## _BASE_IDX) + \
+					mm ## reg_name ## 0 ## _ ## block ## id
+/* set field/register/bitfield name */
+#define SFRB(field_name, reg_name, bitfield, post_fix)\
+	.field_name = reg_name ## __ ## bitfield ## post_fix
 /* NBIO */
 #define NBIO_BASE_INNER(seg) \
 	NBIF_BASE__INST0_SEG ## seg
 };
 static const struct dcn_mpc_shift mpc_shift = {
-	MPC_COMMON_MASK_SH_LIST_DCN1_0(__SHIFT)
+	MPC_COMMON_MASK_SH_LIST_DCN1_0(__SHIFT),\
+	SFRB(CUR_VUPDATE_LOCK_SET, CUR0_VUPDATE_LOCK_SET0, CUR0_VUPDATE_LOCK_SET, __SHIFT)
 };
 static const struct dcn_mpc_mask mpc_mask = {
-	MPC_COMMON_MASK_SH_LIST_DCN1_0(_MASK),
+	MPC_COMMON_MASK_SH_LIST_DCN1_0(_MASK),\
+	SFRB(CUR_VUPDATE_LOCK_SET, CUR0_VUPDATE_LOCK_SET0, CUR0_VUPDATE_LOCK_SET, _MASK)
 };
 #define tg_regs(id)\

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

@@ -2294,7 +2294,8 @@ void dcn20_fpga_init_hw(struct dc *dc) · 2293 unmodified lines
2294		2294
2295	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_REFDIV, 2);	2295	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_REFDIV, 2);
2296	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_ENABLE, 1);	2296	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_ENABLE, 1);
2297	REG_WRITE(REFCLK_CNTL, 0);	2297	if (REG(REFCLK_CNTL))
		2298	REG_WRITE(REFCLK_CNTL, 0);
2298	//	2299	//
2299		2300
2300		2301

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

@@ -52,6 +52,7 @@ static const struct hw_sequencer_funcs dcn20_funcs = { · 51 unmodified lines
52	.disable_plane = dcn20_disable_plane,	52	.disable_plane = dcn20_disable_plane,
53	.pipe_control_lock = dcn20_pipe_control_lock,	53	.pipe_control_lock = dcn20_pipe_control_lock,
54	.interdependent_update_lock = dcn10_lock_all_pipes,	54	.interdependent_update_lock = dcn10_lock_all_pipes,
		55	.cursor_lock = dcn10_cursor_lock,
55	.prepare_bandwidth = dcn20_prepare_bandwidth,	56	.prepare_bandwidth = dcn20_prepare_bandwidth,
56	.optimize_bandwidth = dcn20_optimize_bandwidth,	57	.optimize_bandwidth = dcn20_optimize_bandwidth,
57	.update_bandwidth = dcn20_update_bandwidth,	58	.update_bandwidth = dcn20_update_bandwidth,

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

@@ -545,6 +545,7 @@ const struct mpc_funcs dcn20_mpc_funcs = { · 544 unmodified lines
545	.mpc_init = mpc1_mpc_init,	545	.mpc_init = mpc1_mpc_init,
546	.mpc_init_single_inst = mpc1_mpc_init_single_inst,	546	.mpc_init_single_inst = mpc1_mpc_init_single_inst,
547	.update_blending = mpc2_update_blending,	547	.update_blending = mpc2_update_blending,
		548	.cursor_lock = mpc1_cursor_lock,
548	.get_mpcc_for_dpp = mpc2_get_mpcc_for_dpp,	549	.get_mpcc_for_dpp = mpc2_get_mpcc_for_dpp,
549	.wait_for_idle = mpc2_assert_idle_mpcc,	550	.wait_for_idle = mpc2_assert_idle_mpcc,
550	.assert_mpcc_idle_before_connect = mpc2_assert_mpcc_idle_before_connect,	551	.assert_mpcc_idle_before_connect = mpc2_assert_mpcc_idle_before_connect,

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.h+2−1

@@ -179,7 +179,8 @@ · 178 unmodified lines
179	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MAX_G_Y, mask_sh),\	179	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MAX_G_Y, mask_sh),\
180	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MIN_G_Y, mask_sh),\	180	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MIN_G_Y, mask_sh),\
181	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MAX_B_CB, mask_sh),\	181	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MAX_B_CB, mask_sh),\
182	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MIN_B_CB, mask_sh)	182	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MIN_B_CB, mask_sh),\
		183	SF(CUR_VUPDATE_LOCK_SET0, CUR_VUPDATE_LOCK_SET, mask_sh)
183		184
184	/*	185	/*
185	* DCN2 MPC_OCSC debug status register:	186	* DCN2 MPC_OCSC debug status register:

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c+27−8

@@ -508,6 +508,10 @@ enum dcn20_clk_src_array_id { · 507 unmodified lines
508	.block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \	508	.block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
509	mm ## block ## id ## _ ## reg_name	509	mm ## block ## id ## _ ## reg_name
510		510
		511	#define VUPDATE_SRII(reg_name, block, id)\
		512	.reg_name[id] = BASE(mm ## reg_name ## _ ## block ## id ## _BASE_IDX) + \
		513	mm ## reg_name ## _ ## block ## id
		514
511	/* NBIO */	515	/* NBIO */
512	#define NBIO_BASE_INNER(seg) \	516	#define NBIO_BASE_INNER(seg) \
513	NBIO_BASE__INST0_SEG ## seg	517	NBIO_BASE__INST0_SEG ## seg
@@ -3064,25 +3068,32 @@ validate_out: · 2550 unmodified lines
3064	return out;	3068	return out;
3065	}	3069	}
3066		3070
3067		3071	/*
3068	bool dcn20_validate_bandwidth(struct dc dc, struct dc_state context,	3072	* This must be noinline to ensure anything that deals with FP registers
3069	bool fast_validate)	3073	* is contained within this call; previously our compiling with hard-float
		3074	* would result in fp instructions being emitted outside of the boundaries
		3075	* of the DC_FP_START/END macros, which makes sense as the compiler has no
		3076	* idea about what is wrapped and what is not
		3077	*
		3078	* This is largely just a workaround to avoid breakage introduced with 5.6,
		3079	* ideally all fp-using code should be moved into its own file, only that
		3080	* should be compiled with hard-float, and all code exported from there
		3081	* should be strictly wrapped with DC_FP_START/END
		3082	*/
		3083	static noinline bool dcn20_validate_bandwidth_fp(struct dc *dc,
		3084	struct dc_state *context, bool fast_validate)
3070	{	3085	{
3071	bool voltage_supported = false;	3086	bool voltage_supported = false;
3072	bool full_pstate_supported = false;	3087	bool full_pstate_supported = false;
3073	bool dummy_pstate_supported = false;	3088	bool dummy_pstate_supported = false;
3074	double p_state_latency_us;	3089	double p_state_latency_us;
3075		3090
3076	DC_FP_START();
3077	p_state_latency_us = context->bw_ctx.dml.soc.dram_clock_change_latency_us;	3091	p_state_latency_us = context->bw_ctx.dml.soc.dram_clock_change_latency_us;
3078	context->bw_ctx.dml.soc.disable_dram_clock_change_vactive_support =	3092	context->bw_ctx.dml.soc.disable_dram_clock_change_vactive_support =
3079	dc->debug.disable_dram_clock_change_vactive_support;	3093	dc->debug.disable_dram_clock_change_vactive_support;
3080		3094
3081	if (fast_validate) {	3095	if (fast_validate) {
3082	voltage_supported = dcn20_validate_bandwidth_internal(dc, context, true);	3096	return dcn20_validate_bandwidth_internal(dc, context, true);
3083
3084	DC_FP_END();
3085	return voltage_supported;
3086	}	3097	}
3087		3098
3088	// Best case, we support full UCLK switch latency	3099	// Best case, we support full UCLK switch latency
@@ -3111,7 +3122,15 @@ bool dcn20_validate_bandwidth(struct dc dc, struct dc_state context, · 22 unmodified lines
3111		3122
3112	restore_dml_state:	3123	restore_dml_state:
3113	context->bw_ctx.dml.soc.dram_clock_change_latency_us = p_state_latency_us;	3124	context->bw_ctx.dml.soc.dram_clock_change_latency_us = p_state_latency_us;
		3125	return voltage_supported;
		3126	}
3114		3127
		3128	bool dcn20_validate_bandwidth(struct dc dc, struct dc_state context,
		3129	bool fast_validate)
		3130	{
		3131	bool voltage_supported = false;
		3132	DC_FP_START();
		3133	voltage_supported = dcn20_validate_bandwidth_fp(dc, context, fast_validate);
3115	DC_FP_END();	3134	DC_FP_END();
3116	return voltage_supported;	3135	return voltage_supported;
3117	}	3136	}

drivers/gpu/drm/amd/display/dc/dcn21/dcn21_init.c+1−0

@@ -53,6 +53,7 @@ static const struct hw_sequencer_funcs dcn21_funcs = { · 52 unmodified lines
53	.disable_plane = dcn20_disable_plane,	53	.disable_plane = dcn20_disable_plane,
54	.pipe_control_lock = dcn20_pipe_control_lock,	54	.pipe_control_lock = dcn20_pipe_control_lock,
55	.interdependent_update_lock = dcn10_lock_all_pipes,	55	.interdependent_update_lock = dcn10_lock_all_pipes,
		56	.cursor_lock = dcn10_cursor_lock,
56	.prepare_bandwidth = dcn20_prepare_bandwidth,	57	.prepare_bandwidth = dcn20_prepare_bandwidth,
57	.optimize_bandwidth = dcn20_optimize_bandwidth,	58	.optimize_bandwidth = dcn20_optimize_bandwidth,
58	.update_bandwidth = dcn20_update_bandwidth,	59	.update_bandwidth = dcn20_update_bandwidth,

drivers/gpu/drm/amd/display/dc/dcn21/dcn21_resource.c+33−44

@@ -284,7 +284,7 @@ struct _vcs_dpi_soc_bounding_box_st dcn2_1_soc = { · 283 unmodified lines
284	.dram_channel_width_bytes = 4,	284	.dram_channel_width_bytes = 4,
285	.fabric_datapath_to_dcn_data_return_bytes = 32,	285	.fabric_datapath_to_dcn_data_return_bytes = 32,
286	.dcn_downspread_percent = 0.5,	286	.dcn_downspread_percent = 0.5,
287	.downspread_percent = 0.5,	287	.downspread_percent = 0.38,
288	.dram_page_open_time_ns = 50.0,	288	.dram_page_open_time_ns = 50.0,
289	.dram_rw_turnaround_time_ns = 17.5,	289	.dram_rw_turnaround_time_ns = 17.5,
290	.dram_return_buffer_per_channel_bytes = 8192,	290	.dram_return_buffer_per_channel_bytes = 8192,
@@ -340,6 +340,10 @@ struct _vcs_dpi_soc_bounding_box_st dcn2_1_soc = { · 49 unmodified lines
340	.block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \	340	.block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
341	mm ## block ## id ## _ ## reg_name	341	mm ## block ## id ## _ ## reg_name
342		342
		343	#define VUPDATE_SRII(reg_name, block, id)\
		344	.reg_name[id] = BASE(mm ## reg_name ## _ ## block ## id ## _BASE_IDX) + \
		345	mm ## reg_name ## _ ## block ## id
		346
343	/* NBIO */	347	/* NBIO */
344	#define NBIO_BASE_INNER(seg) \	348	#define NBIO_BASE_INNER(seg) \
345	NBIF0_BASE__INST0_SEG ## seg	349	NBIF0_BASE__INST0_SEG ## seg
@@ -1374,64 +1378,49 @@ static void update_bw_bounding_box(struct dc dc, struct clk_bw_params bw_param · 1028 unmodified lines
1374	{	1378	{
1375	struct dcn21_resource_pool *pool = TO_DCN21_RES_POOL(dc->res_pool);	1379	struct dcn21_resource_pool *pool = TO_DCN21_RES_POOL(dc->res_pool);
1376	struct clk_limit_table *clk_table = &bw_params->clk_table;	1380	struct clk_limit_table *clk_table = &bw_params->clk_table;
1377	unsigned int i, j, k;	1381	struct _vcs_dpi_voltage_scaling_st clock_limits[DC__VOLTAGE_STATES];
1378	int closest_clk_lvl;	1382	unsigned int i, j, closest_clk_lvl;
1379		1383
1380	// Default clock levels are used for diags, which may lead to overclocking.	1384	// Default clock levels are used for diags, which may lead to overclocking.
1381	if (!IS_FPGA_MAXIMUS_DC(dc->ctx->dce_environment) && !IS_DIAG_DC(dc->ctx->dce_environment)) {	1385	if (!IS_DIAG_DC(dc->ctx->dce_environment)) {
1382	dcn2_1_ip.max_num_otg = pool->base.res_cap->num_timing_generator;	1386	dcn2_1_ip.max_num_otg = pool->base.res_cap->num_timing_generator;
1383	dcn2_1_ip.max_num_dpp = pool->base.pipe_count;	1387	dcn2_1_ip.max_num_dpp = pool->base.pipe_count;
1384	dcn2_1_soc.num_chans = bw_params->num_channels;	1388	dcn2_1_soc.num_chans = bw_params->num_channels;
1385		1389
1386	/* Vmin: leave lowest DCN clocks, override with dcfclk, fclk, memclk from fuse */	1390	ASSERT(clk_table->num_entries);
1387	dcn2_1_soc.clock_limits[0].state = 0;	1391	for (i = 0; i < clk_table->num_entries; i++) {
1388	dcn2_1_soc.clock_limits[0].dcfclk_mhz = clk_table->entries[0].dcfclk_mhz;	1392	/* loop backwards*/
1389	dcn2_1_soc.clock_limits[0].fabricclk_mhz = clk_table->entries[0].fclk_mhz;	1393	for (closest_clk_lvl = 0, j = dcn2_1_soc.num_states - 1; j >= 0; j--) {
1390	dcn2_1_soc.clock_limits[0].socclk_mhz = clk_table->entries[0].socclk_mhz;
1391	dcn2_1_soc.clock_limits[0].dram_speed_mts = clk_table->entries[0].memclk_mhz * 2;
1392
1393	/*
1394	* Other levels: find closest DCN clocks that fit the given clock limit using dcfclk
1395	* as indicator
1396	*/
1397
1398	closest_clk_lvl = -1;
1399	/* index currently being filled */
1400	k = 1;
1401	for (i = 1; i < clk_table->num_entries; i++) {
1402	/* loop backwards, skip duplicate state*/
1403	for (j = dcn2_1_soc.num_states - 1; j >= k; j--) {
1404	if ((unsigned int) dcn2_1_soc.clock_limits[j].dcfclk_mhz <= clk_table->entries[i].dcfclk_mhz) {	1394	if ((unsigned int) dcn2_1_soc.clock_limits[j].dcfclk_mhz <= clk_table->entries[i].dcfclk_mhz) {
1405	closest_clk_lvl = j;	1395	closest_clk_lvl = j;
1406	break;	1396	break;
1407	}	1397	}
1408	}	1398	}
1409		1399
1410	/* if found a lvl that fits, use the DCN clks from it, if not, go to next clk limit*/	1400	clock_limits[i].state = i;
1411	if (closest_clk_lvl != -1) {	1401	clock_limits[i].dcfclk_mhz = clk_table->entries[i].dcfclk_mhz;
1412	dcn2_1_soc.clock_limits[k].state = i;	1402	clock_limits[i].fabricclk_mhz = clk_table->entries[i].fclk_mhz;
1413	dcn2_1_soc.clock_limits[k].dcfclk_mhz = clk_table->entries[i].dcfclk_mhz;	1403	clock_limits[i].socclk_mhz = clk_table->entries[i].socclk_mhz;
1414	dcn2_1_soc.clock_limits[k].fabricclk_mhz = clk_table->entries[i].fclk_mhz;	1404	clock_limits[i].dram_speed_mts = clk_table->entries[i].memclk_mhz * 2;
1415	dcn2_1_soc.clock_limits[k].socclk_mhz = clk_table->entries[i].socclk_mhz;	1405
1416	dcn2_1_soc.clock_limits[k].dram_speed_mts = clk_table->entries[i].memclk_mhz * 2;	1406	clock_limits[i].dispclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dispclk_mhz;
1417		1407	clock_limits[i].dppclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dppclk_mhz;
1418	dcn2_1_soc.clock_limits[k].dispclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dispclk_mhz;	1408	clock_limits[i].dram_bw_per_chan_gbps = dcn2_1_soc.clock_limits[closest_clk_lvl].dram_bw_per_chan_gbps;
1419	dcn2_1_soc.clock_limits[k].dppclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dppclk_mhz;	1409	clock_limits[i].dscclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dscclk_mhz;
1420	dcn2_1_soc.clock_limits[k].dram_bw_per_chan_gbps = dcn2_1_soc.clock_limits[closest_clk_lvl].dram_bw_per_chan_gbps;	1410	clock_limits[i].dtbclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dtbclk_mhz;
1421	dcn2_1_soc.clock_limits[k].dscclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dscclk_mhz;	1411	clock_limits[i].phyclk_d18_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_d18_mhz;
1422	dcn2_1_soc.clock_limits[k].dtbclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dtbclk_mhz;	1412	clock_limits[i].phyclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_mhz;
1423	dcn2_1_soc.clock_limits[k].phyclk_d18_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_d18_mhz;	1413	}
1424	dcn2_1_soc.clock_limits[k].phyclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_mhz;	1414	for (i = 0; i < clk_table->num_entries; i++)
1425	k++;	1415	dcn2_1_soc.clock_limits[i] = clock_limits[i];
1426	}	1416	if (clk_table->num_entries) {
		1417	dcn2_1_soc.num_states = clk_table->num_entries;
		1418	/* duplicate last level */
		1419	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states] = dcn2_1_soc.clock_limits[dcn2_1_soc.num_states - 1];
		1420	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states].state = dcn2_1_soc.num_states;
1427	}	1421	}
1428	dcn2_1_soc.num_states = k;
1429	}	1422	}
1430		1423
1431	/* duplicate last level */
1432	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states] = dcn2_1_soc.clock_limits[dcn2_1_soc.num_states - 1];
1433	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states].state = dcn2_1_soc.num_states;
1434
1435	dml_init_instance(&dc->dml, &dcn2_1_soc, &dcn2_1_ip, DML_PROJECT_DCN21);	1424	dml_init_instance(&dc->dml, &dcn2_1_soc, &dcn2_1_ip, DML_PROJECT_DCN21);
1436	}	1425	}
1437		1426

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c+4−4

@@ -1200,7 +1200,7 @@ static void dml_rq_dlg_get_dlg_params( · 1199 unmodified lines
1200	min_hratio_fact_l = 1.0;	1200	min_hratio_fact_l = 1.0;
1201	min_hratio_fact_c = 1.0;	1201	min_hratio_fact_c = 1.0;
1202		1202
1203	if (htaps_l <= 1)	1203	if (hratio_l <= 1)
1204	min_hratio_fact_l = 2.0;	1204	min_hratio_fact_l = 2.0;
1205	else if (htaps_l <= 6) {	1205	else if (htaps_l <= 6) {
1206	if ((hratio_l * 2.0) > 4.0)	1206	if ((hratio_l * 2.0) > 4.0)
@@ -1216,7 +1216,7 @@ static void dml_rq_dlg_get_dlg_params( · 9 unmodified lines
1216		1216
1217	hscale_pixel_rate_l = min_hratio_fact_l * dppclk_freq_in_mhz;	1217	hscale_pixel_rate_l = min_hratio_fact_l * dppclk_freq_in_mhz;
1218		1218
1219	if (htaps_c <= 1)	1219	if (hratio_c <= 1)
1220	min_hratio_fact_c = 2.0;	1220	min_hratio_fact_c = 2.0;
1221	else if (htaps_c <= 6) {	1221	else if (htaps_c <= 6) {
1222	if ((hratio_c * 2.0) > 4.0)	1222	if ((hratio_c * 2.0) > 4.0)
@@ -1522,8 +1522,8 @@ static void dml_rq_dlg_get_dlg_params( · 299 unmodified lines
1522		1522
1523	disp_dlg_regs->refcyc_per_vm_group_vblank = get_refcyc_per_vm_group_vblank(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz;	1523	disp_dlg_regs->refcyc_per_vm_group_vblank = get_refcyc_per_vm_group_vblank(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz;
1524	disp_dlg_regs->refcyc_per_vm_group_flip = get_refcyc_per_vm_group_flip(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz;	1524	disp_dlg_regs->refcyc_per_vm_group_flip = get_refcyc_per_vm_group_flip(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz;
1525	disp_dlg_regs->refcyc_per_vm_req_vblank = get_refcyc_per_vm_req_vblank(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz;	1525	disp_dlg_regs->refcyc_per_vm_req_vblank = get_refcyc_per_vm_req_vblank(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz * dml_pow(2, 10);
1526	disp_dlg_regs->refcyc_per_vm_req_flip = get_refcyc_per_vm_req_flip(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz;	1526	disp_dlg_regs->refcyc_per_vm_req_flip = get_refcyc_per_vm_req_flip(mode_lib, e2e_pipe_param, num_pipes, pipe_idx) * refclk_freq_in_mhz * dml_pow(2, 10);
1527		1527
1528	// Clamp to max for now	1528	// Clamp to max for now
1529	if (disp_dlg_regs->refcyc_per_vm_group_vblank >= (unsigned int)dml_pow(2, 23))	1529	if (disp_dlg_regs->refcyc_per_vm_group_vblank >= (unsigned int)dml_pow(2, 23))

drivers/gpu/drm/amd/display/dc/inc/hw/mpc.h+16−0

@@ -210,6 +210,22 @@ struct mpc_funcs { · 209 unmodified lines
210	struct mpcc_blnd_cfg *blnd_cfg,	210	struct mpcc_blnd_cfg *blnd_cfg,
211	int mpcc_id);	211	int mpcc_id);
212		212
		213	/*
		214	* Lock cursor updates for the specified OPP.
		215	* OPP defines the set of MPCC that are locked together for cursor.
		216	*
		217	* Parameters:
		218	* [in] mpc - MPC context.
		219	* [in] opp_id - The OPP to lock cursor updates on
		220	* [in] lock - lock/unlock the OPP
		221	*
		222	* Return: void
		223	*/
		224	void (*cursor_lock)(
		225	struct mpc *mpc,
		226	int opp_id,
		227	bool lock);
		228
213	struct mpcc* (*get_mpcc_for_dpp)(	229	struct mpcc* (*get_mpcc_for_dpp)(
214	struct mpc_tree *tree,	230	struct mpc_tree *tree,
215	int dpp_id);	231	int dpp_id);

drivers/gpu/drm/amd/display/dc/inc/hw_sequencer.h+1−0

@@ -86,6 +86,7 @@ struct hw_sequencer_funcs { · 85 unmodified lines
86	struct dc_state *context, bool lock);	86	struct dc_state *context, bool lock);
87	void (set_flip_control_gsl)(struct pipe_ctx pipe_ctx,	87	void (set_flip_control_gsl)(struct pipe_ctx pipe_ctx,
88	bool flip_immediate);	88	bool flip_immediate);
		89	void (cursor_lock)(struct dc dc, struct pipe_ctx *pipe, bool lock);
89		90
90	/* Timing Related */	91	/* Timing Related */
91	void (get_position)(struct pipe_ctx *pipe_ctx, int num_pipes,	92	void (get_position)(struct pipe_ctx *pipe_ctx, int num_pipes,

drivers/gpu/drm/amd/display/dc/os_types.h+1−1

@@ -108,7 +108,7 @@ · 107 unmodified lines
108	#define ASSERT(expr) ASSERT_CRITICAL(expr)	108	#define ASSERT(expr) ASSERT_CRITICAL(expr)
109		109
110	#else	110	#else
111	#define ASSERT(expr) WARN_ON(!(expr))	111	#define ASSERT(expr) WARN_ON_ONCE(!(expr))
112	#endif	112	#endif
113		113
114	#define BREAK_TO_DEBUGGER() ASSERT(0)	114	#define BREAK_TO_DEBUGGER() ASSERT(0)

drivers/gpu/drm/amd/powerplay/amd_powerplay.c+5−4

 	if (!hwmgr)
 		return -EINVAL;
-	if (!hwmgr->pm_en || !hwmgr->hwmgr_func->get_asic_baco_capability)
+	if (!(hwmgr->not_vf && amdgpu_dpm) ||
+		!hwmgr->hwmgr_func->get_asic_baco_capability)
 		return 0;
 	mutex_lock(&hwmgr->smu_lock);
 	if (!hwmgr)
 		return -EINVAL;
-	if (!(hwmgr->not_vf && amdgpu_dpm) ||
+	if (!hwmgr->pm_en || !hwmgr->hwmgr_func->get_asic_baco_state)
-		!hwmgr->hwmgr_func->get_asic_baco_state)
 		return 0;
 	mutex_lock(&hwmgr->smu_lock);
 	if (!hwmgr)
 		return -EINVAL;
-	if (!hwmgr->pm_en || !hwmgr->hwmgr_func->set_asic_baco_state)
+	if (!(hwmgr->not_vf && amdgpu_dpm) ||
+		!hwmgr->hwmgr_func->set_asic_baco_state)
 		return 0;
 	mutex_lock(&hwmgr->smu_lock);

drivers/gpu/drm/drm_dp_mst_topology.c+6−2

 	drm_dp_queue_down_tx(mgr, txmsg);
 	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
-	if (ret > 0 && txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
+	if (ret > 0) {
-		ret = -EIO;
+		if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
+			ret = -EIO;
+		else
+			ret = size;
+	}
 	kfree(txmsg);
 fail_put:

drivers/gpu/drm/drm_edid.c+1−1

@@ -5111,7 +5111,7 @@ static struct drm_display_mode drm_mode_displayid_detailed(struct drm_device d · 5110 unmodified lines
5111	struct drm_display_mode *mode;	5111	struct drm_display_mode *mode;
5112	unsigned pixel_clock = (timings->pixel_clock[0] \|	5112	unsigned pixel_clock = (timings->pixel_clock[0] \|
5113	(timings->pixel_clock[1] << 8) \|	5113	(timings->pixel_clock[1] << 8) \|
5114	(timings->pixel_clock[2] << 16));	5114	(timings->pixel_clock[2] << 16)) + 1;
5115	unsigned hactive = (timings->hactive[0] \| timings->hactive[1] << 8) + 1;	5115	unsigned hactive = (timings->hactive[0] \| timings->hactive[1] << 8) + 1;
5116	unsigned hblank = (timings->hblank[0] \| timings->hblank[1] << 8) + 1;	5116	unsigned hblank = (timings->hblank[0] \| timings->hblank[1] << 8) + 1;
5117	unsigned hsync = (timings->hsync[0] \| (timings->hsync[1] & 0x7f) << 8) + 1;	5117	unsigned hsync = (timings->hsync[0] \| (timings->hsync[1] & 0x7f) << 8) + 1;

drivers/gpu/drm/drm_hdcp.c+7−1

 	ret = request_firmware_direct(&fw, (const char *)fw_name,
 				      drm_dev->dev);
-	if (ret < 0)
+	if (ret < 0) {
+		*revoked_ksv_cnt = 0;
+		*revoked_ksv_list = NULL;
+		ret = 0;
 		goto exit;
+	}
 	if (fw->size && fw->data)
 		ret = drm_hdcp_srm_update(fw->data, fw->size, revoked_ksv_list,
 	ret = drm_hdcp_request_srm(drm_dev, &revoked_ksv_list,
 				   &revoked_ksv_cnt);
+	if (ret)
+		return ret;
 	/* revoked_ksv_cnt will be zero when above function failed */
 	for (i = 0; i < revoked_ksv_cnt; i++)

drivers/gpu/drm/i915/gem/i915_gem_tiling.c+18−2

 			      int tiling_mode, unsigned int stride)
 {
 	struct i915_ggtt *ggtt = &to_i915(obj->base.dev)->ggtt;
-	struct i915_vma *vma;
+	struct i915_vma *vma, *vn;
+	LIST_HEAD(unbind);
 	int ret = 0;
 	if (tiling_mode == I915_TILING_NONE)
 		return 0;
 	mutex_lock(&ggtt->vm.mutex);
+	spin_lock(&obj->vma.lock);
 	for_each_ggtt_vma(vma, obj) {
+		GEM_BUG_ON(vma->vm != &ggtt->vm);
 		if (i915_vma_fence_prepare(vma, tiling_mode, stride))
 			continue;
+		list_move(&vma->vm_link, &unbind);
+	}
+	spin_unlock(&obj->vma.lock);
+	list_for_each_entry_safe(vma, vn, &unbind, vm_link) {
 		ret = __i915_vma_unbind(vma);
-		if (ret)
+		if (ret) {
+			/* Restore the remaining vma on an error */
+			list_splice(&unbind, &ggtt->vm.bound_list);
 			break;
+		}
 	}
 	mutex_unlock(&ggtt->vm.mutex);
 	return ret;
 	}
 	mutex_unlock(&obj->mm.lock);
+	spin_lock(&obj->vma.lock);
 	for_each_ggtt_vma(vma, obj) {
 		vma->fence_size =
 			i915_gem_fence_size(i915, vma->size, tiling, stride);
 		if (vma->fence)
 			vma->fence->dirty = true;
 	}
+	spin_unlock(&obj->vma.lock);
 	obj->tiling_and_stride = tiling | stride;
 	i915_gem_object_unlock(obj);

drivers/gpu/drm/i915/gem/selftests/huge_pages.c+8−4

 		unsigned int page_size = BIT(first);
 		obj = i915_gem_object_create_internal(dev_priv, page_size);
-		if (IS_ERR(obj))
+		if (IS_ERR(obj)) {
-			return PTR_ERR(obj);
+			err = PTR_ERR(obj);
+			goto out_vm;
+		}
 		vma = i915_vma_instance(obj, vm, NULL);
 		if (IS_ERR(vma)) {
 	}
 	obj = i915_gem_object_create_internal(dev_priv, PAGE_SIZE);
-	if (IS_ERR(obj))
+	if (IS_ERR(obj)) {
-		return PTR_ERR(obj);
+		err = PTR_ERR(obj);
+		goto out_vm;
+	}
 	vma = i915_vma_instance(obj, vm, NULL);
 	if (IS_ERR(vma)) {

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

@@ -521,6 +521,8 @@ int intel_timeline_read_hwsp(struct i915_request *from, · 520 unmodified lines
521		521
522	rcu_read_lock();	522	rcu_read_lock();
523	cl = rcu_dereference(from->hwsp_cacheline);	523	cl = rcu_dereference(from->hwsp_cacheline);
		524	if (i915_request_completed(from)) /* confirm cacheline is valid */
		525	goto unlock;
524	if (unlikely(!i915_active_acquire_if_busy(&cl->active)))	526	if (unlikely(!i915_active_acquire_if_busy(&cl->active)))
525	goto unlock; /* seqno wrapped and completed! */	527	goto unlock; /* seqno wrapped and completed! */
526	if (unlikely(i915_request_completed(from)))	528	if (unlikely(i915_request_completed(from)))

drivers/gpu/drm/i915/i915_irq.c+2−4

 {
 	struct intel_uncore *uncore = &dev_priv->uncore;
-	u32 de_pipe_masked = GEN8_PIPE_CDCLK_CRC_DONE;
+	u32 de_pipe_masked = gen8_de_pipe_fault_mask(dev_priv) |
+		GEN8_PIPE_CDCLK_CRC_DONE;
 	u32 de_pipe_enables;
 	u32 de_port_masked = GEN8_AUX_CHANNEL_A;
 	u32 de_port_enables;
 		de_misc_masked |= GEN8_DE_MISC_GSE;
 	if (INTEL_GEN(dev_priv) >= 9) {
-		de_pipe_masked |= GEN9_DE_PIPE_IRQ_FAULT_ERRORS;
 		de_port_masked |= GEN9_AUX_CHANNEL_B | GEN9_AUX_CHANNEL_C |
 				  GEN9_AUX_CHANNEL_D;
 		if (IS_GEN9_LP(dev_priv))
 			de_port_masked |= BXT_DE_PORT_GMBUS;
-	} else {
-		de_pipe_masked |= GEN8_DE_PIPE_IRQ_FAULT_ERRORS;
 	}
 	if (INTEL_GEN(dev_priv) >= 11)

drivers/gpu/drm/i915/i915_vma.c+6−4

 	GEM_BUG_ON(!IS_ALIGNED(vma->size, I915_GTT_PAGE_SIZE));
+	spin_lock(&obj->vma.lock);
 	if (i915_is_ggtt(vm)) {
 		if (unlikely(overflows_type(vma->size, u32)))
-			goto err_vma;
+			goto err_unlock;
 		vma->fence_size = i915_gem_fence_size(vm->i915, vma->size,
 						      i915_gem_object_get_tiling(obj),
 						      i915_gem_object_get_stride(obj));
 		if (unlikely(vma->fence_size < vma->size || /* overflow */
 			     vma->fence_size > vm->total))
-			goto err_vma;
+			goto err_unlock;
 		GEM_BUG_ON(!IS_ALIGNED(vma->fence_size, I915_GTT_MIN_ALIGNMENT));
 		__set_bit(I915_VMA_GGTT_BIT, __i915_vma_flags(vma));
 	}
-	spin_lock(&obj->vma.lock);
 	rb = NULL;
 	p = &obj->vma.tree.rb_node;
 	while (*p) {
 	return vma;
+err_unlock:
+	spin_unlock(&obj->vma.lock);
 err_vma:
 	i915_vma_free(vma);
 	return ERR_PTR(-E2BIG);

drivers/gpu/drm/ingenic/ingenic-drm.c+1−0

@@ -843,6 +843,7 @@ static const struct of_device_id ingenic_drm_of_match[] = { · 842 unmodified lines
843	{ .compatible = "ingenic,jz4770-lcd", .data = &jz4770_soc_info },	843	{ .compatible = "ingenic,jz4770-lcd", .data = &jz4770_soc_info },
844	{ /* sentinel */ },	844	{ /* sentinel */ },
845	};	845	};
		846	MODULE_DEVICE_TABLE(of, ingenic_drm_of_match);
846		847
847	static struct platform_driver ingenic_drm_driver = {	848	static struct platform_driver ingenic_drm_driver = {
848	.driver = {	849	.driver = {

drivers/gpu/drm/qxl/qxl_cmd.c+5−5

@@ -480,9 +480,10 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev, · 479 unmodified lines
480	return ret;	480	return ret;
481		481
482	ret = qxl_release_reserve_list(release, true);	482	ret = qxl_release_reserve_list(release, true);
483	if (ret)	483	if (ret) {
		484	qxl_release_free(qdev, release);
484	return ret;	485	return ret;
485		486	}
486	cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);	487	cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);
487	cmd->type = QXL_SURFACE_CMD_CREATE;	488	cmd->type = QXL_SURFACE_CMD_CREATE;
488	cmd->flags = QXL_SURF_FLAG_KEEP_DATA;	489	cmd->flags = QXL_SURF_FLAG_KEEP_DATA;
@@ -499,8 +500,8 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev, · 10 unmodified lines
499	/* no need to add a release to the fence for this surface bo,	500	/* no need to add a release to the fence for this surface bo,
500	since it is only released when we ask to destroy the surface	501	since it is only released when we ask to destroy the surface
501	and it would never signal otherwise */	502	and it would never signal otherwise */
502	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
503	qxl_release_fence_buffer_objects(release);	503	qxl_release_fence_buffer_objects(release);
		504	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
504		505
505	surf->hw_surf_alloc = true;	506	surf->hw_surf_alloc = true;
506	spin_lock(&qdev->surf_id_idr_lock);	507	spin_lock(&qdev->surf_id_idr_lock);
@@ -542,9 +543,8 @@ int qxl_hw_surface_dealloc(struct qxl_device *qdev, · 35 unmodified lines
542	cmd->surface_id = id;	543	cmd->surface_id = id;
543	qxl_release_unmap(qdev, release, &cmd->release_info);	544	qxl_release_unmap(qdev, release, &cmd->release_info);
544		545
545	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
546
547	qxl_release_fence_buffer_objects(release);	546	qxl_release_fence_buffer_objects(release);
		547	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
548		548
549	return 0;	549	return 0;
550	}	550	}

drivers/gpu/drm/qxl/qxl_display.c+3−3

 	cmd->u.set.visible = 1;
 	qxl_release_unmap(qdev, release, &cmd->release_info);
-	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	qxl_release_fence_buffer_objects(release);
+	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	return ret;
 	cmd->u.position.y = plane->state->crtc_y + fb->hot_y;
 	qxl_release_unmap(qdev, release, &cmd->release_info);
-	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	qxl_release_fence_buffer_objects(release);
+	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	if (old_cursor_bo != NULL)
 		qxl_bo_unpin(old_cursor_bo);
 	cmd->type = QXL_CURSOR_HIDE;
 	qxl_release_unmap(qdev, release, &cmd->release_info);
-	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	qxl_release_fence_buffer_objects(release);
+	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 }
 static void qxl_update_dumb_head(struct qxl_device *qdev,

drivers/gpu/drm/qxl/qxl_draw.c+4−3

@@ -209,9 +209,10 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, · 208 unmodified lines
209	goto out_release_backoff;	209	goto out_release_backoff;
210		210
211	rects = drawable_set_clipping(qdev, num_clips, clips_bo);	211	rects = drawable_set_clipping(qdev, num_clips, clips_bo);
212	if (!rects)	212	if (!rects) {
		213	ret = -EINVAL;
213	goto out_release_backoff;	214	goto out_release_backoff;
214		215	}
215	drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);	216	drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
216		217
217	drawable->clip.type = SPICE_CLIP_TYPE_RECTS;	218	drawable->clip.type = SPICE_CLIP_TYPE_RECTS;
@@ -242,8 +243,8 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, · 24 unmodified lines
242	}	243	}
243	qxl_bo_kunmap(clips_bo);	244	qxl_bo_kunmap(clips_bo);
244		245
245	qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
246	qxl_release_fence_buffer_objects(release);	246	qxl_release_fence_buffer_objects(release);
		247	qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
247		248
248	out_release_backoff:	249	out_release_backoff:
249	if (ret)	250	if (ret)

drivers/gpu/drm/qxl/qxl_image.c+2−1

 		break;
 	default:
 		DRM_ERROR("unsupported image bit depth\n");
-		return -EINVAL; /* TODO: cleanup */
+		qxl_bo_kunmap_atomic_page(qdev, image_bo, ptr);
+		return -EINVAL;
 	}
 	image->u.bitmap.flags = QXL_BITMAP_TOP_DOWN;
 	image->u.bitmap.x = width;

drivers/gpu/drm/qxl/qxl_ioctl.c+1−4

 			apply_surf_reloc(qdev, &reloc_info[i]);
 	}
+	qxl_release_fence_buffer_objects(release);
 	ret = qxl_push_command_ring_release(qdev, release, cmd->type, true);
-	if (ret)
-		qxl_release_backoff_reserve_list(release);
-	else
-		qxl_release_fence_buffer_objects(release);
 out_free_bos:
 out_free_release:

drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c+1−1

@@ -717,7 +717,7 @@ static void sun6i_dsi_encoder_enable(struct drm_encoder *encoder) · 716 unmodified lines
717	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;	717	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
718	struct sun6i_dsi *dsi = encoder_to_sun6i_dsi(encoder);	718	struct sun6i_dsi *dsi = encoder_to_sun6i_dsi(encoder);
719	struct mipi_dsi_device *device = dsi->device;	719	struct mipi_dsi_device *device = dsi->device;
720	union phy_configure_opts opts = { 0 };	720	union phy_configure_opts opts = { };
721	struct phy_configure_opts_mipi_dphy *cfg = &opts.mipi_dphy;	721	struct phy_configure_opts_mipi_dphy *cfg = &opts.mipi_dphy;
722	u16 delay;	722	u16 delay;
723	int err;	723	int err;

drivers/gpu/drm/virtio/virtgpu_drv.h+1−0

@@ -221,6 +221,7 @@ struct virtio_gpu_fpriv { · 220 unmodified lines
221	/* virtio_ioctl.c */	221	/* virtio_ioctl.c */
222	#define DRM_VIRTIO_NUM_IOCTLS 10	222	#define DRM_VIRTIO_NUM_IOCTLS 10
223	extern struct drm_ioctl_desc virtio_gpu_ioctls[DRM_VIRTIO_NUM_IOCTLS];	223	extern struct drm_ioctl_desc virtio_gpu_ioctls[DRM_VIRTIO_NUM_IOCTLS];
		224	void virtio_gpu_create_context(struct drm_device dev, struct drm_file file);
224		225
225	/* virtio_kms.c */	226	/* virtio_kms.c */
226	int virtio_gpu_init(struct drm_device *dev);	227	int virtio_gpu_init(struct drm_device *dev);

drivers/gpu/drm/virtio/virtgpu_gem.c+3−0

@@ -39,6 +39,9 @@ int virtio_gpu_gem_create(struct drm_file *file, · 38 unmodified lines
39	int ret;	39	int ret;
40	u32 handle;	40	u32 handle;
41		41
		42	if (vgdev->has_virgl_3d)
		43	virtio_gpu_create_context(dev, file);
		44
42	ret = virtio_gpu_object_create(vgdev, params, &obj, NULL);	45	ret = virtio_gpu_object_create(vgdev, params, &obj, NULL);
43	if (ret < 0)	46	if (ret < 0)
44	return ret;	47	return ret;

drivers/gpu/drm/virtio/virtgpu_ioctl.c+1−2

@@ -34,8 +34,7 @@ · 33 unmodified lines
34		34
35	#include "virtgpu_drv.h"	35	#include "virtgpu_drv.h"
36		36
37	static void virtio_gpu_create_context(struct drm_device *dev,	37	void virtio_gpu_create_context(struct drm_device dev, struct drm_file file)
38	struct drm_file *file)
39	{	38	{
40	struct virtio_gpu_device *vgdev = dev->dev_private;	39	struct virtio_gpu_device *vgdev = dev->dev_private;
41	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;	40	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;

drivers/gpu/drm/virtio/virtgpu_kms.c+6−11

 		      events_clear, &events_clear);
 }
-static void virtio_gpu_context_destroy(struct virtio_gpu_device *vgdev,
-				      uint32_t ctx_id)
-{
-	virtio_gpu_cmd_context_destroy(vgdev, ctx_id);
-	virtio_gpu_notify(vgdev);
-	ida_free(&vgdev->ctx_id_ida, ctx_id - 1);
-}
 static void virtio_gpu_init_vq(struct virtio_gpu_queue *vgvq,
 			       void (*work_func)(struct work_struct *work))
 {
 void virtio_gpu_driver_postclose(struct drm_device *dev, struct drm_file *file)
 {
 	struct virtio_gpu_device *vgdev = dev->dev_private;
-	struct virtio_gpu_fpriv *vfpriv;
+	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;
 	if (!vgdev->has_virgl_3d)
 		return;
-	vfpriv = file->driver_priv;
+	if (vfpriv->context_created) {
+		virtio_gpu_cmd_context_destroy(vgdev, vfpriv->ctx_id);
+		virtio_gpu_notify(vgdev);
+	}
-	virtio_gpu_context_destroy(vgdev, vfpriv->ctx_id);
+	ida_free(&vgdev->ctx_id_ida, vfpriv->ctx_id - 1);
 	mutex_destroy(&vfpriv->context_lock);
 	kfree(vfpriv);
 	file->driver_priv = NULL;

drivers/hid/Kconfig+1−0

@@ -1155,6 +1155,7 @@ config HID_ALPS · 1154 unmodified lines
1155	config HID_MCP2221	1155	config HID_MCP2221
1156	tristate "Microchip MCP2221 HID USB-to-I2C/SMbus host support"	1156	tristate "Microchip MCP2221 HID USB-to-I2C/SMbus host support"
1157	depends on USB_HID && I2C	1157	depends on USB_HID && I2C
		1158	depends on GPIOLIB
1158	---help---	1159	---help---
1159	Provides I2C and SMBUS host adapter functionality over USB-HID	1160	Provides I2C and SMBUS host adapter functionality over USB-HID
1160	through MCP2221 device.	1161	through MCP2221 device.

drivers/hid/hid-alps.c+1−0

@@ -802,6 +802,7 @@ static int alps_probe(struct hid_device hdev, const struct hid_device_id id) · 801 unmodified lines
802	break;	802	break;
803	case HID_DEVICE_ID_ALPS_U1_DUAL:	803	case HID_DEVICE_ID_ALPS_U1_DUAL:
804	case HID_DEVICE_ID_ALPS_U1:	804	case HID_DEVICE_ID_ALPS_U1:
		805	case HID_DEVICE_ID_ALPS_U1_UNICORN_LEGACY:
805	data->dev_type = U1;	806	data->dev_type = U1;
806	break;	807	break;
807	default:	808	default:

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

 #define HID_DEVICE_ID_ALPS_U1_DUAL_PTP	0x121F
 #define HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP	0x1220
 #define HID_DEVICE_ID_ALPS_U1		0x1215
+#define HID_DEVICE_ID_ALPS_U1_UNICORN_LEGACY         0x121E
 #define HID_DEVICE_ID_ALPS_T4_BTNLESS	0x120C
 #define HID_DEVICE_ID_ALPS_1222		0x1222
 #define USB_VENDOR_ID_AMI		0x046b
 #define USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE	0xff10
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349	0x7349
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7	0x73f7
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001	0xa001
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002	0xc002
 #define USB_VENDOR_ID_ELAN		0x04f3
 #define USB_DEVICE_ID_TOSHIBA_CLICK_L9W	0x0401
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2	0xc218
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2	0xc219
 #define USB_DEVICE_ID_LOGITECH_G15_LCD		0xc222
+#define USB_DEVICE_ID_LOGITECH_G11		0xc225
 #define USB_DEVICE_ID_LOGITECH_G15_V2_LCD	0xc227
 #define USB_DEVICE_ID_LOGITECH_G510		0xc22d
 #define USB_DEVICE_ID_LOGITECH_G510_USB_AUDIO	0xc22e
 #define USB_DEVICE_ID_SYMBOL_SCANNER_2	0x1300
 #define USB_DEVICE_ID_SYMBOL_SCANNER_3	0x1200
+#define I2C_VENDOR_ID_SYNAPTICS     0x06cb
+#define I2C_PRODUCT_ID_SYNAPTICS_SYNA2393   0x7a13
 #define USB_VENDOR_ID_SYNAPTICS		0x06cb
 #define USB_DEVICE_ID_SYNAPTICS_TP	0x0001
 #define USB_DEVICE_ID_SYNAPTICS_INT_TP	0x0002
 #define USB_DEVICE_ID_SYNAPTICS_LTS2	0x1d10
 #define USB_DEVICE_ID_SYNAPTICS_HD	0x0ac3
 #define USB_DEVICE_ID_SYNAPTICS_QUAD_HD	0x1ac3
+#define USB_DEVICE_ID_SYNAPTICS_DELL_K12A	0x2819
 #define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5_012	0x2968
 #define USB_DEVICE_ID_SYNAPTICS_TP_V103	0x5710
 #define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5	0x81a7

drivers/hid/hid-lg-g15.c+4−0

 }
 static const struct hid_device_id lg_g15_devices[] = {
+	/* The G11 is a G15 without the LCD, treat it as a G15 */
+	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
+		USB_DEVICE_ID_LOGITECH_G11),
+		.driver_data = LG_G15 },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 			 USB_DEVICE_ID_LOGITECH_G15_LCD),
 		.driver_data = LG_G15 },

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

 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
+	{ .driver_data = MT_CLS_EGALAX,
+		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
+			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002) },
 	/* Elitegroup panel */
 	{ .driver_data = MT_CLS_SERIAL,

drivers/hid/hid-quirks.c+1−0

@@ -163,6 +163,7 @@ static const struct hid_device_id hid_quirks[] = { · 162 unmodified lines
163	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS2), HID_QUIRK_NO_INIT_REPORTS },	163	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS2), HID_QUIRK_NO_INIT_REPORTS },
164	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_QUAD_HD), HID_QUIRK_NO_INIT_REPORTS },	164	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_QUAD_HD), HID_QUIRK_NO_INIT_REPORTS },
165	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP_V103), HID_QUIRK_NO_INIT_REPORTS },	165	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP_V103), HID_QUIRK_NO_INIT_REPORTS },
		166	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DELL_K12A), HID_QUIRK_NO_INIT_REPORTS },
166	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD), HID_QUIRK_BADPAD },	167	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD), HID_QUIRK_BADPAD },
167	{ HID_USB_DEVICE(USB_VENDOR_ID_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS), HID_QUIRK_MULTI_INPUT },	168	{ HID_USB_DEVICE(USB_VENDOR_ID_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS), HID_QUIRK_MULTI_INPUT },
168	{ HID_USB_DEVICE(USB_VENDOR_ID_TPV, USB_DEVICE_ID_TPV_OPTICAL_TOUCHSCREEN_8882), HID_QUIRK_NOGET },	169	{ HID_USB_DEVICE(USB_VENDOR_ID_TPV, USB_DEVICE_ID_TPV_OPTICAL_TOUCHSCREEN_8882), HID_QUIRK_NOGET },

drivers/hid/i2c-hid/i2c-hid-core.c+2−0

 		 I2C_HID_QUIRK_BOGUS_IRQ },
 	{ USB_VENDOR_ID_ALPS_JP, HID_ANY_ID,
 		 I2C_HID_QUIRK_RESET_ON_RESUME },
+	{ I2C_VENDOR_ID_SYNAPTICS, I2C_PRODUCT_ID_SYNAPTICS_SYNA2393,
+		 I2C_HID_QUIRK_RESET_ON_RESUME },
 	{ USB_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_LENOVO_LEGION_Y720,
 		I2C_HID_QUIRK_BAD_INPUT_SIZE },
 	{ 0, 0 }

drivers/hid/usbhid/hid-core.c+29−8

 	struct usbhid_device *usbhid = hid->driver_data;
 	int res;
+	mutex_lock(&usbhid->mutex);
 	set_bit(HID_OPENED, &usbhid->iofl);
-	if (hid->quirks & HID_QUIRK_ALWAYS_POLL)
+	if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
-		return 0;
+		res = 0;
+		goto Done;
+	}
 	res = usb_autopm_get_interface(usbhid->intf);
 	/* the device must be awake to reliably request remote wakeup */
 	if (res < 0) {
 		clear_bit(HID_OPENED, &usbhid->iofl);
-		return -EIO;
+		res = -EIO;
+		goto Done;
 	}
 	usbhid->intf->needs_remote_wakeup = 1;
 		msleep(50);
 	clear_bit(HID_RESUME_RUNNING, &usbhid->iofl);
+ Done:
+	mutex_unlock(&usbhid->mutex);
 	return res;
 }
 {
 	struct usbhid_device *usbhid = hid->driver_data;
+	mutex_lock(&usbhid->mutex);
 	/*
 	 * Make sure we don't restart data acquisition due to
 	 * a resumption we no longer care about by avoiding racing
 		clear_bit(HID_IN_POLLING, &usbhid->iofl);
 	spin_unlock_irq(&usbhid->lock);
-	if (hid->quirks & HID_QUIRK_ALWAYS_POLL)
+	if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL)) {
-		return;
+		hid_cancel_delayed_stuff(usbhid);
+		usb_kill_urb(usbhid->urbin);
+		usbhid->intf->needs_remote_wakeup = 0;
+	}
-	hid_cancel_delayed_stuff(usbhid);
+	mutex_unlock(&usbhid->mutex);
-	usb_kill_urb(usbhid->urbin);
-	usbhid->intf->needs_remote_wakeup = 0;
 }
 /*
 	unsigned int n, insize = 0;
 	int ret;
+	mutex_lock(&usbhid->mutex);
 	clear_bit(HID_DISCONNECTED, &usbhid->iofl);
 	usbhid->bufsize = HID_MIN_BUFFER_SIZE;
 		usbhid_set_leds(hid);
 		device_set_wakeup_enable(&dev->dev, 1);
 	}
+	mutex_unlock(&usbhid->mutex);
 	return 0;
 fail:
 	usbhid->urbout = NULL;
 	usbhid->urbctrl = NULL;
 	hid_free_buffers(dev, hid);
+	mutex_unlock(&usbhid->mutex);
 	return ret;
 }
 		usbhid->intf->needs_remote_wakeup = 0;
 	}
+	mutex_lock(&usbhid->mutex);
 	clear_bit(HID_STARTED, &usbhid->iofl);
 	spin_lock_irq(&usbhid->lock);	/* Sync with error and led handlers */
 	set_bit(HID_DISCONNECTED, &usbhid->iofl);
 	usbhid->urbout = NULL;
 	hid_free_buffers(hid_to_usb_dev(hid), hid);
+	mutex_unlock(&usbhid->mutex);
 }
 static int usbhid_power(struct hid_device *hid, int lvl)
 	INIT_WORK(&usbhid->reset_work, hid_reset);
 	timer_setup(&usbhid->io_retry, hid_retry_timeout, 0);
 	spin_lock_init(&usbhid->lock);
+	mutex_init(&usbhid->mutex);
 	ret = hid_add_device(hid);
 	if (ret) {

drivers/hid/usbhid/usbhid.h+1−0

@@ -80,6 +80,7 @@ struct usbhid_device { · 79 unmodified lines
80	dma_addr_t outbuf_dma; /* Output buffer dma */	80	dma_addr_t outbuf_dma; /* Output buffer dma */
81	unsigned long last_out; /* record of last output for timeouts */	81	unsigned long last_out; /* record of last output for timeouts */
82		82
		83	struct mutex mutex; /* start/stop/open/close */
83	spinlock_t lock; /* fifo spinlock */	84	spinlock_t lock; /* fifo spinlock */
84	unsigned long iofl; /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */	85	unsigned long iofl; /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
85	struct timer_list io_retry; /* Retry timer */	86	struct timer_list io_retry; /* Retry timer */

drivers/hid/wacom_sys.c+3−1

 			data[0] = field->report->id;
 			ret = wacom_get_report(hdev, HID_FEATURE_REPORT,
 					       data, n, WAC_CMD_RETRIES);
-			if (ret == n) {
+			if (ret == n && features->type == HID_GENERIC) {
 				ret = hid_report_raw_event(hdev,
 					HID_FEATURE_REPORT, data, n, 0);
+			} else if (ret == 2 && features->type != HID_GENERIC) {
+				features->touch_max = data[1];
 			} else {
 				features->touch_max = 16;
 				hid_warn(hdev, "wacom_feature_mapping: "

drivers/hid/wacom_wac.c+22−66

 {
 	struct input_dev *pad_input = wacom->pad_input;
 	unsigned char *data = wacom->data;
+	int nbuttons = wacom->features.numbered_buttons;
-	int buttons = data[282] | ((data[281] & 0x40) << 2);
+	int expresskeys = data[282];
+	int center = (data[281] & 0x40) >> 6;
 	int ring = data[285] & 0x7F;
 	bool ringstatus = data[285] & 0x80;
-	bool prox = buttons || ringstatus;
+	bool prox = expresskeys || center || ringstatus;
 	/* Fix touchring data: userspace expects 0 at left and increasing clockwise */
 	ring = 71 - ring;
 	if (ring > 71)
 		ring -= 72;
-	wacom_report_numbered_buttons(pad_input, 9, buttons);
+	wacom_report_numbered_buttons(pad_input, nbuttons,
+                                      expresskeys | (center << (nbuttons - 1)));
 	input_report_abs(pad_input, ABS_WHEEL, ringstatus ? ring : 0);
 			case HID_DG_TIPSWITCH:
 				hid_data->last_slot_field = equivalent_usage;
 				break;
+			case HID_DG_CONTACTCOUNT:
+				hid_data->cc_report = report->id;
+				hid_data->cc_index = i;
+				hid_data->cc_value_index = j;
+				break;
 			}
 		}
 	}
+	if (hid_data->cc_report != 0 &&
+	    hid_data->cc_index >= 0) {
+		struct hid_field *field = report->field[hid_data->cc_index];
+		int value = field->value[hid_data->cc_value_index];
+		if (value)
+			hid_data->num_expected = value;
+	}
+	else {
+		hid_data->num_expected = wacom_wac->features.touch_max;
+	}
 }
 static void wacom_wac_finger_report(struct hid_device *hdev,
 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
 	struct input_dev *input = wacom_wac->touch_input;
 	unsigned touch_max = wacom_wac->features.touch_max;
-	struct hid_data *hid_data = &wacom_wac->hid_data;
 	/* If more packets of data are expected, give us a chance to
 	 * process them rather than immediately syncing a partial
 	input_sync(input);
 	wacom_wac->hid_data.num_received = 0;
-	hid_data->num_expected = 0;
 	/* keep touch state for pen event */
 	wacom_wac->shared->touch_down = wacom_wac_finger_count_touches(wacom_wac);
 	}
 }
-static void wacom_set_num_expected(struct hid_device *hdev,
-				   struct hid_report *report,
-				   int collection_index,
-				   struct hid_field *field,
-				   int field_index)
-{
-	struct wacom *wacom = hid_get_drvdata(hdev);
-	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
-	struct hid_data *hid_data = &wacom_wac->hid_data;
-	unsigned int original_collection_level =
-		hdev->collection[collection_index].level;
-	bool end_collection = false;
-	int i;
-	if (hid_data->num_expected)
-		return;
-	// find the contact count value for this segment
-	for (i = field_index; i < report->maxfield && !end_collection; i++) {
-		struct hid_field *field = report->field[i];
-		unsigned int field_level =
-			hdev->collection[field->usage[0].collection_index].level;
-		unsigned int j;
-		if (field_level != original_collection_level)
-			continue;
-		for (j = 0; j < field->maxusage; j++) {
-			struct hid_usage *usage = &field->usage[j];
-			if (usage->collection_index != collection_index) {
-				end_collection = true;
-				break;
-			}
-			if (wacom_equivalent_usage(usage->hid) == HID_DG_CONTACTCOUNT) {
-				hid_data->cc_report = report->id;
-				hid_data->cc_index = i;
-				hid_data->cc_value_index = j;
-				if (hid_data->cc_report != 0 &&
-				    hid_data->cc_index >= 0) {
-					struct hid_field *field =
-						report->field[hid_data->cc_index];
-					int value =
-						field->value[hid_data->cc_value_index];
-					if (value)
-						hid_data->num_expected = value;
-				}
-			}
-		}
-	}
-	if (hid_data->cc_report == 0 || hid_data->cc_index < 0)
-		hid_data->num_expected = wacom_wac->features.touch_max;
-}
 static int wacom_wac_collection(struct hid_device *hdev, struct hid_report *report,
 			 int collection_index, struct hid_field *field,
 			 int field_index)
 {
 	struct wacom *wacom = hid_get_drvdata(hdev);
-	if (WACOM_FINGER_FIELD(field))
-		wacom_set_num_expected(hdev, report, collection_index, field,
-				       field_index);
 	wacom_report_events(hdev, report, collection_index, field_index);
 	/*

drivers/hv/hv.c+1−5

 	shared_sint.vector = HYPERVISOR_CALLBACK_VECTOR;
 	shared_sint.masked = false;
-	if (ms_hyperv.hints & HV_DEPRECATING_AEOI_RECOMMENDED)
+	shared_sint.auto_eoi = hv_recommend_using_aeoi();
-		shared_sint.auto_eoi = false;
-	else
-		shared_sint.auto_eoi = true;
 	hv_set_synint_state(VMBUS_MESSAGE_SINT, shared_sint.as_uint64);
 	/* Enable the global synic bit */

drivers/hv/hv_trace.h+2−2

@@ -286,8 +286,8 @@ TRACE_EVENT(vmbus_send_tl_connect_request, · 285 unmodified lines
286	__field(int, ret)	286	__field(int, ret)
287	),	287	),
288	TP_fast_assign(	288	TP_fast_assign(
289	memcpy(__entry->guest_id, &msg->guest_endpoint_id.b, 16);	289	export_guid(__entry->guest_id, &msg->guest_endpoint_id);
290	memcpy(__entry->host_id, &msg->host_service_id.b, 16);	290	export_guid(__entry->host_id, &msg->host_service_id);
291	__entry->ret = ret;	291	__entry->ret = ret;
292	),	292	),
293	TP_printk("sending guest_endpoint_id %pUl, host_service_id %pUl, "	293	TP_printk("sending guest_endpoint_id %pUl, host_service_id %pUl, "

drivers/hv/vmbus_drv.c+34−9

 	return drv->resume(dev);
 }
+#else
+#define vmbus_suspend NULL
+#define vmbus_resume NULL
 #endif /* CONFIG_PM_SLEEP */
 /*
 }
 /*
- * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
+ * Note: we must use the "noirq" ops: see the comment before vmbus_bus_pm.
- * SET_SYSTEM_SLEEP_PM_OPS: see the comment before vmbus_bus_pm.
+ *
+ * suspend_noirq/resume_noirq are set to NULL to support Suspend-to-Idle: we
+ * shouldn't suspend the vmbus devices upon Suspend-to-Idle, otherwise there
+ * is no way to wake up a Generation-2 VM.
+ *
+ * The other 4 ops are for hibernation.
  */
 static const struct dev_pm_ops vmbus_pm = {
-	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_suspend, vmbus_resume)
+	.suspend_noirq	= NULL,
+	.resume_noirq	= NULL,
+	.freeze_noirq	= vmbus_suspend,
+	.thaw_noirq	= vmbus_resume,
+	.poweroff_noirq	= vmbus_suspend,
+	.restore_noirq	= vmbus_resume,
 };
 /* The one and only one */
 	return 0;
 }
+#else
+#define vmbus_bus_suspend NULL
+#define vmbus_bus_resume NULL
 #endif /* CONFIG_PM_SLEEP */
 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
 /*
- * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
+ * Note: we must use the "no_irq" ops, otherwise hibernation can not work with
- * SET_SYSTEM_SLEEP_PM_OPS, otherwise NIC SR-IOV can not work, because the
+ * PCI device assignment, because "pci_dev_pm_ops" uses the "noirq" ops: in
- * "pci_dev_pm_ops" uses the "noirq" callbacks: in the resume path, the
+ * the resume path, the pci "noirq" restore op runs before "non-noirq" op (see
- * pci "noirq" restore callback runs before "non-noirq" callbacks (see
  * resume_target_kernel() -> dpm_resume_start(), and hibernation_restore() ->
  * dpm_resume_end()). This means vmbus_bus_resume() and the pci-hyperv's
- * resume callback must also run via the "noirq" callbacks.
+ * resume callback must also run via the "noirq" ops.
+ *
+ * Set suspend_noirq/resume_noirq to NULL for Suspend-to-Idle: see the comment
+ * earlier in this file before vmbus_pm.
  */
 static const struct dev_pm_ops vmbus_bus_pm = {
-	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_bus_suspend, vmbus_bus_resume)
+	.suspend_noirq	= NULL,
+	.resume_noirq	= NULL,
+	.freeze_noirq	= vmbus_bus_suspend,
+	.thaw_noirq	= vmbus_bus_resume,
+	.poweroff_noirq	= vmbus_bus_suspend,
+	.restore_noirq	= vmbus_bus_resume
 };
 static struct acpi_driver vmbus_acpi_driver = {

drivers/i2c/busses/i2c-amd-mp2-pci.c+1−1

 	if (!privdata)
 		return -ENOMEM;
+	privdata->pci_dev = pci_dev;
 	rc = amd_mp2_pci_init(privdata, pci_dev);
 	if (rc)
 		return rc;
 	mutex_init(&privdata->c2p_lock);
-	privdata->pci_dev = pci_dev;
 	pm_runtime_set_autosuspend_delay(&pci_dev->dev, 1000);
 	pm_runtime_use_autosuspend(&pci_dev->dev);

drivers/i2c/busses/i2c-aspeed.c+4−1

 	/* Ack all interrupts except for Rx done */
 	writel(irq_received & ~ASPEED_I2CD_INTR_RX_DONE,
 	       bus->base + ASPEED_I2C_INTR_STS_REG);
+	readl(bus->base + ASPEED_I2C_INTR_STS_REG);
 	irq_remaining = irq_received;
 #if IS_ENABLED(CONFIG_I2C_SLAVE)
 			irq_received, irq_handled);
 	/* Ack Rx done */
-	if (irq_received & ASPEED_I2CD_INTR_RX_DONE)
+	if (irq_received & ASPEED_I2CD_INTR_RX_DONE) {
 		writel(ASPEED_I2CD_INTR_RX_DONE,
 		       bus->base + ASPEED_I2C_INTR_STS_REG);
+		readl(bus->base + ASPEED_I2C_INTR_STS_REG);
+	}
 	spin_unlock(&bus->lock);
 	return irq_remaining ? IRQ_NONE : IRQ_HANDLED;
 }

drivers/i2c/busses/i2c-bcm-iproc.c+3−0

 			value = (u8)((val >> S_RX_DATA_SHIFT) & S_RX_DATA_MASK);
 			i2c_slave_event(iproc_i2c->slave,
 					I2C_SLAVE_WRITE_RECEIVED, &value);
+			if (rx_status == I2C_SLAVE_RX_END)
+				i2c_slave_event(iproc_i2c->slave,
+						I2C_SLAVE_STOP, &value);
 		}
 	} else if (status & BIT(IS_S_TX_UNDERRUN_SHIFT)) {
 		/* Master read other than start */

drivers/i2c/busses/i2c-tegra.c+12−24

 	do {
 		u32 status = i2c_readl(i2c_dev, I2C_INT_STATUS);
-		if (status)
+		if (status) {
 			tegra_i2c_isr(i2c_dev->irq, i2c_dev);
-		if (completion_done(complete)) {
+			if (completion_done(complete)) {
-			s64 delta = ktime_ms_delta(ktimeout, ktime);
+				s64 delta = ktime_ms_delta(ktimeout, ktime);
-			return msecs_to_jiffies(delta) ?: 1;
+				return msecs_to_jiffies(delta) ?: 1;
+			}
 		}
 		ktime = ktime_get();
 		disable_irq(i2c_dev->irq);
 		/*
-		 * Under some rare circumstances (like running KASAN +
+		 * There is a chance that completion may happen after IRQ
-		 * NFS root) CPU, which handles interrupt, may stuck in
+		 * synchronization, which is done by disable_irq().
-		 * uninterruptible state for a significant time.  In this
-		 * case we will get timeout if I2C transfer is running on
-		 * a sibling CPU, despite of IRQ being raised.
-		 *
-		 * In order to handle this rare condition, the IRQ status
-		 * needs to be checked after timeout.
 		 */
-		if (ret == 0)
+		if (ret == 0 && completion_done(complete)) {
-			ret = tegra_i2c_poll_completion_timeout(i2c_dev,
+			dev_warn(i2c_dev->dev,
-								complete, 0);
+				 "completion done after timeout\n");
+			ret = 1;
+		}
 	}
 	return ret;
 		time_left = tegra_i2c_wait_completion_timeout(
 				i2c_dev, &i2c_dev->dma_complete, xfer_time);
-		/*
-		 * Synchronize DMA first, since dmaengine_terminate_sync()
-		 * performs synchronization after the transfer's termination
-		 * and we want to get a completion if transfer succeeded.
-		 */
-		dmaengine_synchronize(i2c_dev->msg_read ?
-				      i2c_dev->rx_dma_chan :
-				      i2c_dev->tx_dma_chan);
 		dmaengine_terminate_sync(i2c_dev->msg_read ?
 					 i2c_dev->rx_dma_chan :
 					 i2c_dev->tx_dma_chan);

drivers/infiniband/core/cm.c+14−12

 	ret = xa_alloc_cyclic_irq(&cm.local_id_table, &id, NULL, xa_limit_32b,
 				  &cm.local_id_next, GFP_KERNEL);
-	if (ret)
+	if (ret < 0)
 		goto error;
 	cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand;
 static void cm_format_rej(struct cm_rej_msg *rej_msg,
 			  struct cm_id_private *cm_id_priv,
-			  enum ib_cm_rej_reason reason,
+			  enum ib_cm_rej_reason reason, void *ari,
-			  void *ari,
+			  u8 ari_length, const void *private_data,
-			  u8 ari_length,
+			  u8 private_data_len, enum ib_cm_state state)
-			  const void *private_data,
-			  u8 private_data_len)
 {
 	lockdep_assert_held(&cm_id_priv->lock);
 	IBA_SET(CM_REJ_REMOTE_COMM_ID, rej_msg,
 		be32_to_cpu(cm_id_priv->id.remote_id));
-	switch(cm_id_priv->id.state) {
+	switch (state) {
 	case IB_CM_REQ_RCVD:
 		IBA_SET(CM_REJ_LOCAL_COMM_ID, rej_msg, be32_to_cpu(0));
 		IBA_SET(CM_REJ_MESSAGE_REJECTED, rej_msg, CM_MSG_RESPONSE_REQ);
 			      cm_id_priv->private_data_len);
 		break;
 	case IB_CM_TIMEWAIT:
-		cm_format_rej((struct cm_rej_msg *) msg->mad, cm_id_priv,
+		cm_format_rej((struct cm_rej_msg *)msg->mad, cm_id_priv,
-			      IB_CM_REJ_STALE_CONN, NULL, 0, NULL, 0);
+			      IB_CM_REJ_STALE_CONN, NULL, 0, NULL, 0,
+			      IB_CM_TIMEWAIT);
 		break;
 	default:
 		goto unlock;
 			      u8 ari_length, const void *private_data,
 			      u8 private_data_len)
 {
+	enum ib_cm_state state = cm_id_priv->id.state;
 	struct ib_mad_send_buf *msg;
 	int ret;
 	    (ari && ari_length > IB_CM_REJ_ARI_LENGTH))
 		return -EINVAL;
-	switch (cm_id_priv->id.state) {
+	switch (state) {
 	case IB_CM_REQ_SENT:
 	case IB_CM_MRA_REQ_RCVD:
 	case IB_CM_REQ_RCVD:
 		if (ret)
 			return ret;
 		cm_format_rej((struct cm_rej_msg *)msg->mad, cm_id_priv, reason,
-			      ari, ari_length, private_data, private_data_len);
+			      ari, ari_length, private_data, private_data_len,
+			      state);
 		break;
 	case IB_CM_REP_SENT:
 	case IB_CM_MRA_REP_RCVD:
 		if (ret)
 			return ret;
 		cm_format_rej((struct cm_rej_msg *)msg->mad, cm_id_priv, reason,
-			      ari, ari_length, private_data, private_data_len);
+			      ari, ari_length, private_data, private_data_len,
+			      state);
 		break;
 	default:
 		pr_debug("%s: local_id %d, cm_id->state: %d\n", __func__,

drivers/infiniband/core/rdma_core.c+4−5

 	 * uverbs_uobject_fd_release(), and the caller is expected to ensure
 	 * that release is never done while a call to lookup is possible.
 	 */
-	if (f->f_op != fd_type->fops) {
+	if (f->f_op != fd_type->fops || uobject->ufile != ufile) {
 		fput(f);
 		return ERR_PTR(-EBADF);
 	}
 	filp = anon_inode_getfile(fd_type->name, fd_type->fops, NULL,
 				  fd_type->flags);
 	if (IS_ERR(filp)) {
+		uverbs_uobject_put(uobj);
 		uobj = ERR_CAST(filp);
-		goto err_uobj;
+		goto err_fd;
 	}
 	uobj->object = filp;
 	uobj->id = new_fd;
 	return uobj;
-err_uobj:
-	uverbs_uobject_put(uobj);
 err_fd:
 	put_unused_fd(new_fd);
 	return uobj;
 			     enum rdma_lookup_mode mode)
 {
 	assert_uverbs_usecnt(uobj, mode);
-	uobj->uapi_object->type_class->lookup_put(uobj, mode);
 	/*
 	 * In order to unlock an object, either decrease its usecnt for
 	 * read access or zero it in case of exclusive access. See
 		break;
 	}
+	uobj->uapi_object->type_class->lookup_put(uobj, mode);
 	/* Pairs with the kref obtained by type->lookup_get */
 	uverbs_uobject_put(uobj);
 }

drivers/infiniband/core/uverbs_main.c+4−0

 			ret = mmget_not_zero(mm);
 			if (!ret) {
 				list_del_init(&priv->list);
+				if (priv->entry) {
+					rdma_user_mmap_entry_put(priv->entry);
+					priv->entry = NULL;
+				}
 				mm = NULL;
 				continue;
 			}

drivers/infiniband/hw/i40iw/i40iw_ctrl.c+1−1

@@ -1046,7 +1046,7 @@ i40iw_sc_query_rdma_features(struct i40iw_sc_cqp *cqp, · 1045 unmodified lines
1046	u64 header;	1046	u64 header;
1047		1047
1048	wqe = i40iw_sc_cqp_get_next_send_wqe(cqp, scratch);	1048	wqe = i40iw_sc_cqp_get_next_send_wqe(cqp, scratch);
1049	if (wqe)	1049	if (!wqe)
1050	return I40IW_ERR_RING_FULL;	1050	return I40IW_ERR_RING_FULL;
1051		1051
1052	set_64bit_val(wqe, 32, feat_mem->pa);	1052	set_64bit_val(wqe, 32, feat_mem->pa);

drivers/infiniband/hw/mlx4/main.c+2−1

@@ -1499,8 +1499,9 @@ static int __mlx4_ib_create_default_rules( · 1498 unmodified lines
1499	int i;	1499	int i;
1500		1500
1501	for (i = 0; i < ARRAY_SIZE(pdefault_rules->rules_create_list); i++) {	1501	for (i = 0; i < ARRAY_SIZE(pdefault_rules->rules_create_list); i++) {
		1502	union ib_flow_spec ib_spec = {};
1502	int ret;	1503	int ret;
1503	union ib_flow_spec ib_spec;	1504
1504	switch (pdefault_rules->rules_create_list[i]) {	1505	switch (pdefault_rules->rules_create_list[i]) {
1505	case 0:	1506	case 0:
1506	/* no rule */	1507	/* no rule */

drivers/infiniband/hw/mlx5/qp.c+3−1

@@ -5558,7 +5558,9 @@ static void to_rdma_ah_attr(struct mlx5_ib_dev *ibdev, · 5557 unmodified lines
5558	rdma_ah_set_path_bits(ah_attr, path->grh_mlid & 0x7f);	5558	rdma_ah_set_path_bits(ah_attr, path->grh_mlid & 0x7f);
5559	rdma_ah_set_static_rate(ah_attr,	5559	rdma_ah_set_static_rate(ah_attr,
5560	path->static_rate ? path->static_rate - 5 : 0);	5560	path->static_rate ? path->static_rate - 5 : 0);
5561	if (path->grh_mlid & (1 << 7)) {	5561
		5562	if (path->grh_mlid & (1 << 7) \|\|
		5563	ah_attr->type == RDMA_AH_ATTR_TYPE_ROCE) {
5562	u32 tc_fl = be32_to_cpu(path->tclass_flowlabel);	5564	u32 tc_fl = be32_to_cpu(path->tclass_flowlabel);
5563		5565
5564	rdma_ah_set_grh(ah_attr, NULL,	5566	rdma_ah_set_grh(ah_attr, NULL,

drivers/infiniband/sw/rdmavt/cq.c+2−2

@@ -248,8 +248,8 @@ int rvt_create_cq(struct ib_cq ibcq, const struct ib_cq_init_attr attr, · 247 unmodified lines
248	*/	248	*/
249	if (udata && udata->outlen >= sizeof(__u64)) {	249	if (udata && udata->outlen >= sizeof(__u64)) {
250	cq->ip = rvt_create_mmap_info(rdi, sz, udata, u_wc);	250	cq->ip = rvt_create_mmap_info(rdi, sz, udata, u_wc);
251	if (!cq->ip) {	251	if (IS_ERR(cq->ip)) {
252	err = -ENOMEM;	252	err = PTR_ERR(cq->ip);
253	goto bail_wc;	253	goto bail_wc;
254	}	254	}
255		255

drivers/infiniband/sw/rdmavt/mmap.c+2−2

@@ -154,7 +154,7 @@ done: · 153 unmodified lines
154	* @udata: user data (must be valid!)	154	* @udata: user data (must be valid!)
155	* @obj: opaque pointer to a cq, wq etc	155	* @obj: opaque pointer to a cq, wq etc
156	*	156	*
157	* Return: rvt_mmap struct on success	157	* Return: rvt_mmap struct on success, ERR_PTR on failure
158	*/	158	*/
159	struct rvt_mmap_info rvt_create_mmap_info(struct rvt_dev_info rdi, u32 size,	159	struct rvt_mmap_info rvt_create_mmap_info(struct rvt_dev_info rdi, u32 size,
160	struct ib_udata udata, void obj)	160	struct ib_udata udata, void obj)
@@ -166,7 +166,7 @@ struct rvt_mmap_info rvt_create_mmap_info(struct rvt_dev_info rdi, u32 size, · 5 unmodified lines
166		166
167	ip = kmalloc_node(sizeof(*ip), GFP_KERNEL, rdi->dparms.node);	167	ip = kmalloc_node(sizeof(*ip), GFP_KERNEL, rdi->dparms.node);
168	if (!ip)	168	if (!ip)
169	return ip;	169	return ERR_PTR(-ENOMEM);
170		170
171	size = PAGE_ALIGN(size);	171	size = PAGE_ALIGN(size);
172		172

drivers/infiniband/sw/rdmavt/qp.c+2−2

@@ -1244,8 +1244,8 @@ struct ib_qp rvt_create_qp(struct ib_pd ibpd, · 1243 unmodified lines
1244		1244
1245	qp->ip = rvt_create_mmap_info(rdi, s, udata,	1245	qp->ip = rvt_create_mmap_info(rdi, s, udata,
1246	qp->r_rq.wq);	1246	qp->r_rq.wq);
1247	if (!qp->ip) {	1247	if (IS_ERR(qp->ip)) {
1248	ret = ERR_PTR(-ENOMEM);	1248	ret = ERR_CAST(qp->ip);
1249	goto bail_qpn;	1249	goto bail_qpn;
1250	}	1250	}
1251		1251

drivers/infiniband/sw/rdmavt/srq.c+2−2

@@ -111,8 +111,8 @@ int rvt_create_srq(struct ib_srq ibsrq, struct ib_srq_init_attr srq_init_attr, · 110 unmodified lines
111	u32 s = sizeof(struct rvt_rwq) + srq->rq.size * sz;	111	u32 s = sizeof(struct rvt_rwq) + srq->rq.size * sz;
112		112
113	srq->ip = rvt_create_mmap_info(dev, s, udata, srq->rq.wq);	113	srq->ip = rvt_create_mmap_info(dev, s, udata, srq->rq.wq);
114	if (!srq->ip) {	114	if (IS_ERR(srq->ip)) {
115	ret = -ENOMEM;	115	ret = PTR_ERR(srq->ip);
116	goto bail_wq;	116	goto bail_wq;
117	}	117	}
118		118

drivers/infiniband/sw/siw/siw_qp_tx.c+11−4

 {
 	struct ib_mr *base_mr = (struct ib_mr *)(uintptr_t)sqe->base_mr;
 	struct siw_device *sdev = to_siw_dev(pd->device);
-	struct siw_mem *mem = siw_mem_id2obj(sdev, sqe->rkey  >> 8);
+	struct siw_mem *mem;
 	int rv = 0;
 	siw_dbg_pd(pd, "STag 0x%08x\n", sqe->rkey);
-	if (unlikely(!mem || !base_mr)) {
+	if (unlikely(!base_mr)) {
 		pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
 		return -EINVAL;
 	}
 	if (unlikely(base_mr->rkey >> 8 != sqe->rkey  >> 8)) {
 		pr_warn("siw: fastreg: STag 0x%08x: bad MR\n", sqe->rkey);
-		rv = -EINVAL;
+		return -EINVAL;
-		goto out;
 	}
+	mem = siw_mem_id2obj(sdev, sqe->rkey  >> 8);
+	if (unlikely(!mem)) {
+		pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
+		return -EINVAL;
+	}
 	if (unlikely(mem->pd != pd)) {
 		pr_warn("siw: fastreg: PD mismatch\n");
 		rv = -EINVAL;

drivers/interconnect/qcom/osm-l3.c+2−2

@@ -78,7 +78,7 @@ static struct qcom_icc_node *sdm845_osm_l3_nodes[] = { · 77 unmodified lines
78	[SLAVE_OSM_L3] = &sdm845_osm_l3,	78	[SLAVE_OSM_L3] = &sdm845_osm_l3,
79	};	79	};
80		80
81	const static struct qcom_icc_desc sdm845_icc_osm_l3 = {	81	static const struct qcom_icc_desc sdm845_icc_osm_l3 = {
82	.nodes = sdm845_osm_l3_nodes,	82	.nodes = sdm845_osm_l3_nodes,
83	.num_nodes = ARRAY_SIZE(sdm845_osm_l3_nodes),	83	.num_nodes = ARRAY_SIZE(sdm845_osm_l3_nodes),
84	};	84	};
@@ -91,7 +91,7 @@ static struct qcom_icc_node *sc7180_osm_l3_nodes[] = { · 6 unmodified lines
91	[SLAVE_OSM_L3] = &sc7180_osm_l3,	91	[SLAVE_OSM_L3] = &sc7180_osm_l3,
92	};	92	};
93		93
94	const static struct qcom_icc_desc sc7180_icc_osm_l3 = {	94	static const struct qcom_icc_desc sc7180_icc_osm_l3 = {
95	.nodes = sc7180_osm_l3_nodes,	95	.nodes = sc7180_osm_l3_nodes,
96	.num_nodes = ARRAY_SIZE(sc7180_osm_l3_nodes),	96	.num_nodes = ARRAY_SIZE(sc7180_osm_l3_nodes),
97	};	97	};

drivers/interconnect/qcom/sdm845.c+8−8

@@ -192,7 +192,7 @@ static struct qcom_icc_node *aggre1_noc_nodes[] = { · 191 unmodified lines
192	[SLAVE_ANOC_PCIE_A1NOC_SNOC] = &qns_pcie_a1noc_snoc,	192	[SLAVE_ANOC_PCIE_A1NOC_SNOC] = &qns_pcie_a1noc_snoc,
193	};	193	};
194		194
195	const static struct qcom_icc_desc sdm845_aggre1_noc = {	195	static const struct qcom_icc_desc sdm845_aggre1_noc = {
196	.nodes = aggre1_noc_nodes,	196	.nodes = aggre1_noc_nodes,
197	.num_nodes = ARRAY_SIZE(aggre1_noc_nodes),	197	.num_nodes = ARRAY_SIZE(aggre1_noc_nodes),
198	.bcms = aggre1_noc_bcms,	198	.bcms = aggre1_noc_bcms,
@@ -220,7 +220,7 @@ static struct qcom_icc_node *aggre2_noc_nodes[] = { · 21 unmodified lines
220	[SLAVE_SERVICE_A2NOC] = &srvc_aggre2_noc,	220	[SLAVE_SERVICE_A2NOC] = &srvc_aggre2_noc,
221	};	221	};
222		222
223	const static struct qcom_icc_desc sdm845_aggre2_noc = {	223	static const struct qcom_icc_desc sdm845_aggre2_noc = {
224	.nodes = aggre2_noc_nodes,	224	.nodes = aggre2_noc_nodes,
225	.num_nodes = ARRAY_SIZE(aggre2_noc_nodes),	225	.num_nodes = ARRAY_SIZE(aggre2_noc_nodes),
226	.bcms = aggre2_noc_bcms,	226	.bcms = aggre2_noc_bcms,
@@ -281,7 +281,7 @@ static struct qcom_icc_node *config_noc_nodes[] = { · 54 unmodified lines
281	[SLAVE_SERVICE_CNOC] = &srvc_cnoc,	281	[SLAVE_SERVICE_CNOC] = &srvc_cnoc,
282	};	282	};
283		283
284	const static struct qcom_icc_desc sdm845_config_noc = {	284	static const struct qcom_icc_desc sdm845_config_noc = {
285	.nodes = config_noc_nodes,	285	.nodes = config_noc_nodes,
286	.num_nodes = ARRAY_SIZE(config_noc_nodes),	286	.num_nodes = ARRAY_SIZE(config_noc_nodes),
287	.bcms = config_noc_bcms,	287	.bcms = config_noc_bcms,
@@ -297,7 +297,7 @@ static struct qcom_icc_node *dc_noc_nodes[] = { · 9 unmodified lines
297	[SLAVE_MEM_NOC_CFG] = &qhs_memnoc,	297	[SLAVE_MEM_NOC_CFG] = &qhs_memnoc,
298	};	298	};
299		299
300	const static struct qcom_icc_desc sdm845_dc_noc = {	300	static const struct qcom_icc_desc sdm845_dc_noc = {
301	.nodes = dc_noc_nodes,	301	.nodes = dc_noc_nodes,
302	.num_nodes = ARRAY_SIZE(dc_noc_nodes),	302	.num_nodes = ARRAY_SIZE(dc_noc_nodes),
303	.bcms = dc_noc_bcms,	303	.bcms = dc_noc_bcms,
@@ -315,7 +315,7 @@ static struct qcom_icc_node *gladiator_noc_nodes[] = { · 11 unmodified lines
315	[SLAVE_SERVICE_GNOC] = &srvc_gnoc,	315	[SLAVE_SERVICE_GNOC] = &srvc_gnoc,
316	};	316	};
317		317
318	const static struct qcom_icc_desc sdm845_gladiator_noc = {	318	static const struct qcom_icc_desc sdm845_gladiator_noc = {
319	.nodes = gladiator_noc_nodes,	319	.nodes = gladiator_noc_nodes,
320	.num_nodes = ARRAY_SIZE(gladiator_noc_nodes),	320	.num_nodes = ARRAY_SIZE(gladiator_noc_nodes),
321	.bcms = gladiator_noc_bcms,	321	.bcms = gladiator_noc_bcms,
@@ -350,7 +350,7 @@ static struct qcom_icc_node *mem_noc_nodes[] = { · 28 unmodified lines
350	[SLAVE_EBI1] = &ebi,	350	[SLAVE_EBI1] = &ebi,
351	};	351	};
352		352
353	const static struct qcom_icc_desc sdm845_mem_noc = {	353	static const struct qcom_icc_desc sdm845_mem_noc = {
354	.nodes = mem_noc_nodes,	354	.nodes = mem_noc_nodes,
355	.num_nodes = ARRAY_SIZE(mem_noc_nodes),	355	.num_nodes = ARRAY_SIZE(mem_noc_nodes),
356	.bcms = mem_noc_bcms,	356	.bcms = mem_noc_bcms,
@@ -384,7 +384,7 @@ static struct qcom_icc_node *mmss_noc_nodes[] = { · 27 unmodified lines
384	[SLAVE_CAMNOC_UNCOMP] = &qns_camnoc_uncomp,	384	[SLAVE_CAMNOC_UNCOMP] = &qns_camnoc_uncomp,
385	};	385	};
386		386
387	const static struct qcom_icc_desc sdm845_mmss_noc = {	387	static const struct qcom_icc_desc sdm845_mmss_noc = {
388	.nodes = mmss_noc_nodes,	388	.nodes = mmss_noc_nodes,
389	.num_nodes = ARRAY_SIZE(mmss_noc_nodes),	389	.num_nodes = ARRAY_SIZE(mmss_noc_nodes),
390	.bcms = mmss_noc_bcms,	390	.bcms = mmss_noc_bcms,
@@ -430,7 +430,7 @@ static struct qcom_icc_node *system_noc_nodes[] = { · 39 unmodified lines
430	[SLAVE_TCU] = &xs_sys_tcu_cfg,	430	[SLAVE_TCU] = &xs_sys_tcu_cfg,
431	};	431	};
432		432
433	const static struct qcom_icc_desc sdm845_system_noc = {	433	static const struct qcom_icc_desc sdm845_system_noc = {
434	.nodes = system_noc_nodes,	434	.nodes = system_noc_nodes,
435	.num_nodes = ARRAY_SIZE(system_noc_nodes),	435	.num_nodes = ARRAY_SIZE(system_noc_nodes),
436	.bcms = system_noc_bcms,	436	.bcms = system_noc_bcms,

drivers/iommu/Kconfig+2−2

@@ -362,7 +362,7 @@ config IPMMU_VMSA · 361 unmodified lines
362		362
363	config SPAPR_TCE_IOMMU	363	config SPAPR_TCE_IOMMU
364	bool "sPAPR TCE IOMMU Support"	364	bool "sPAPR TCE IOMMU Support"
365	depends on PPC_POWERNV \|\| PPC_PSERIES \|\| (PPC && COMPILE_TEST)	365	depends on PPC_POWERNV \|\| PPC_PSERIES
366	select IOMMU_API	366	select IOMMU_API
367	help	367	help
368	Enables bits of IOMMU API required by VFIO. The iommu_ops	368	Enables bits of IOMMU API required by VFIO. The iommu_ops
@@ -457,7 +457,7 @@ config S390_AP_IOMMU · 88 unmodified lines
457		457
458	config MTK_IOMMU	458	config MTK_IOMMU
459	bool "MTK IOMMU Support"	459	bool "MTK IOMMU Support"
460	depends on ARM \|\| ARM64 \|\| COMPILE_TEST	460	depends on HAS_DMA
461	depends on ARCH_MEDIATEK \|\| COMPILE_TEST	461	depends on ARCH_MEDIATEK \|\| COMPILE_TEST
462	select ARM_DMA_USE_IOMMU	462	select ARM_DMA_USE_IOMMU
463	select IOMMU_API	463	select IOMMU_API

drivers/iommu/amd_iommu.c+154−44

@@ -101,6 +101,8 @@ struct kmem_cache *amd_iommu_irq_cache; · 100 unmodified lines
101	static void update_domain(struct protection_domain *domain);	101	static void update_domain(struct protection_domain *domain);
102	static int protection_domain_init(struct protection_domain *domain);	102	static int protection_domain_init(struct protection_domain *domain);
103	static void detach_device(struct device *dev);	103	static void detach_device(struct device *dev);
		104	static void update_and_flush_device_table(struct protection_domain *domain,
		105	struct domain_pgtable *pgtable);
104		106
105	/****************************************************************************	107	/****************************************************************************
106	*	108	*
@@ -151,6 +153,26 @@ static struct protection_domain to_pdomain(struct iommu_domain dom) · 44 unmodified lines
151	return container_of(dom, struct protection_domain, domain);	153	return container_of(dom, struct protection_domain, domain);
152	}	154	}
153		155
		156	static void amd_iommu_domain_get_pgtable(struct protection_domain *domain,
		157	struct domain_pgtable *pgtable)
		158	{
		159	u64 pt_root = atomic64_read(&domain->pt_root);
		160
		161	pgtable->root = (u64 *)(pt_root & PAGE_MASK);
		162	pgtable->mode = pt_root & 7; /* lowest 3 bits encode pgtable mode */
		163	}
		164
		165	static u64 amd_iommu_domain_encode_pgtable(u64 *root, int mode)
		166	{
		167	u64 pt_root;
		168
		169	/* lowest 3 bits encode pgtable mode */
		170	pt_root = mode & 7;
		171	pt_root \|= (u64)root;
		172
		173	return pt_root;
		174	}
		175
154	static struct iommu_dev_data *alloc_dev_data(u16 devid)	176	static struct iommu_dev_data *alloc_dev_data(u16 devid)
155	{	177	{
156	struct iommu_dev_data *dev_data;	178	struct iommu_dev_data *dev_data;
@@ -1397,13 +1419,18 @@ static struct page *free_sub_pt(unsigned long root, int mode, · 1240 unmodified lines
1397		1419
1398	static void free_pagetable(struct protection_domain *domain)	1420	static void free_pagetable(struct protection_domain *domain)
1399	{	1421	{
1400	unsigned long root = (unsigned long)domain->pt_root;	1422	struct domain_pgtable pgtable;
1401	struct page *freelist = NULL;	1423	struct page *freelist = NULL;
		1424	unsigned long root;
1402		1425
1403	BUG_ON(domain->mode < PAGE_MODE_NONE \|\|	1426	amd_iommu_domain_get_pgtable(domain, &pgtable);
1404	domain->mode > PAGE_MODE_6_LEVEL);	1427	atomic64_set(&domain->pt_root, 0);
1405		1428
1406	freelist = free_sub_pt(root, domain->mode, freelist);	1429	BUG_ON(pgtable.mode < PAGE_MODE_NONE \|\|
		1430	pgtable.mode > PAGE_MODE_6_LEVEL);
		1431
		1432	root = (unsigned long)pgtable.root;
		1433	freelist = free_sub_pt(root, pgtable.mode, freelist);
1407		1434
1408	free_page_list(freelist);	1435	free_page_list(freelist);
1409	}	1436	}
@@ -1417,24 +1444,39 @@ static bool increase_address_space(struct protection_domain *domain, · 7 unmodified lines
1417	unsigned long address,	1444	unsigned long address,
1418	gfp_t gfp)	1445	gfp_t gfp)
1419	{	1446	{
		1447	struct domain_pgtable pgtable;
1420	unsigned long flags;	1448	unsigned long flags;
1421	bool ret = false;	1449	bool ret = true;
1422	u64 *pte;	1450	u64 *pte, root;
1423		1451
1424	spin_lock_irqsave(&domain->lock, flags);	1452	spin_lock_irqsave(&domain->lock, flags);
1425		1453
1426	if (address <= PM_LEVEL_SIZE(domain->mode) \|\|	1454	amd_iommu_domain_get_pgtable(domain, &pgtable);
1427	WARN_ON_ONCE(domain->mode == PAGE_MODE_6_LEVEL))	1455
		1456	if (address <= PM_LEVEL_SIZE(pgtable.mode))
		1457	goto out;
		1458
		1459	ret = false;
		1460	if (WARN_ON_ONCE(pgtable.mode == PAGE_MODE_6_LEVEL))
1428	goto out;	1461	goto out;
1429		1462
1430	pte = (void *)get_zeroed_page(gfp);	1463	pte = (void *)get_zeroed_page(gfp);
1431	if (!pte)	1464	if (!pte)
1432	goto out;	1465	goto out;
1433		1466
1434	*pte = PM_LEVEL_PDE(domain->mode,	1467	*pte = PM_LEVEL_PDE(pgtable.mode, iommu_virt_to_phys(pgtable.root));
1435	iommu_virt_to_phys(domain->pt_root));	1468
1436	domain->pt_root = pte;	1469	pgtable.root = pte;
1437	domain->mode += 1;	1470	pgtable.mode += 1;
		1471	update_and_flush_device_table(domain, &pgtable);
		1472	domain_flush_complete(domain);
		1473
		1474	/*
		1475	* Device Table needs to be updated and flushed before the new root can
		1476	* be published.
		1477	*/
		1478	root = amd_iommu_domain_encode_pgtable(pte, pgtable.mode);
		1479	atomic64_set(&domain->pt_root, root);
1438		1480
1439	ret = true;	1481	ret = true;
1440		1482
@@ -1451,16 +1493,29 @@ static u64 alloc_pte(struct protection_domain domain, · 10 unmodified lines
1451	gfp_t gfp,	1493	gfp_t gfp,
1452	bool *updated)	1494	bool *updated)
1453	{	1495	{
		1496	struct domain_pgtable pgtable;
1454	int level, end_lvl;	1497	int level, end_lvl;
1455	u64 pte, page;	1498	u64 pte, page;
1456		1499
1457	BUG_ON(!is_power_of_2(page_size));	1500	BUG_ON(!is_power_of_2(page_size));
1458		1501
1459	while (address > PM_LEVEL_SIZE(domain->mode))	1502	amd_iommu_domain_get_pgtable(domain, &pgtable);
1460	updated = increase_address_space(domain, address, gfp) \|\| updated;	1503
		1504	while (address > PM_LEVEL_SIZE(pgtable.mode)) {
		1505	/*
		1506	* Return an error if there is no memory to update the
		1507	* page-table.
		1508	*/
		1509	if (!increase_address_space(domain, address, gfp))
		1510	return NULL;
		1511
		1512	/* Read new values to check if update was successful */
		1513	amd_iommu_domain_get_pgtable(domain, &pgtable);
		1514	}
		1515
1461		1516
1462	level = domain->mode - 1;	1517	level = pgtable.mode - 1;
1463	pte = &domain->pt_root[PM_LEVEL_INDEX(level, address)];	1518	pte = &pgtable.root[PM_LEVEL_INDEX(level, address)];
1464	address = PAGE_SIZE_ALIGN(address, page_size);	1519	address = PAGE_SIZE_ALIGN(address, page_size);
1465	end_lvl = PAGE_SIZE_LEVEL(page_size);	1520	end_lvl = PAGE_SIZE_LEVEL(page_size);
1466		1521
@@ -1536,16 +1591,19 @@ static u64 fetch_pte(struct protection_domain domain, · 69 unmodified lines
1536	unsigned long address,	1591	unsigned long address,
1537	unsigned long *page_size)	1592	unsigned long *page_size)
1538	{	1593	{
		1594	struct domain_pgtable pgtable;
1539	int level;	1595	int level;
1540	u64 *pte;	1596	u64 *pte;
1541		1597
1542	*page_size = 0;	1598	*page_size = 0;
1543		1599
1544	if (address > PM_LEVEL_SIZE(domain->mode))	1600	amd_iommu_domain_get_pgtable(domain, &pgtable);
		1601
		1602	if (address > PM_LEVEL_SIZE(pgtable.mode))
1545	return NULL;	1603	return NULL;
1546		1604
1547	level = domain->mode - 1;	1605	level = pgtable.mode - 1;
1548	pte = &domain->pt_root[PM_LEVEL_INDEX(level, address)];	1606	pte = &pgtable.root[PM_LEVEL_INDEX(level, address)];
1549	*page_size = PTE_LEVEL_PAGE_SIZE(level);	1607	*page_size = PTE_LEVEL_PAGE_SIZE(level);
1550		1608
1551	while (level > 0) {	1609	while (level > 0) {
@@ -1660,7 +1718,13 @@ out: · 108 unmodified lines
1660	unsigned long flags;	1718	unsigned long flags;
1661		1719
1662	spin_lock_irqsave(&dom->lock, flags);	1720	spin_lock_irqsave(&dom->lock, flags);
1663	update_domain(dom);	1721	/*
		1722	* Flush domain TLB(s) and wait for completion. Any Device-Table
		1723	* Updates and flushing already happened in
		1724	* increase_address_space().
		1725	*/
		1726	domain_flush_tlb_pde(dom);
		1727	domain_flush_complete(dom);
1664	spin_unlock_irqrestore(&dom->lock, flags);	1728	spin_unlock_irqrestore(&dom->lock, flags);
1665	}	1729	}
1666		1730
@@ -1806,6 +1870,7 @@ static void dma_ops_domain_free(struct protection_domain *domain) · 139 unmodified lines
1806	static struct protection_domain *dma_ops_domain_alloc(void)	1870	static struct protection_domain *dma_ops_domain_alloc(void)
1807	{	1871	{
1808	struct protection_domain *domain;	1872	struct protection_domain *domain;
		1873	u64 *pt_root, root;
1809		1874
1810	domain = kzalloc(sizeof(struct protection_domain), GFP_KERNEL);	1875	domain = kzalloc(sizeof(struct protection_domain), GFP_KERNEL);
1811	if (!domain)	1876	if (!domain)
@@ -1814,12 +1879,14 @@ static struct protection_domain *dma_ops_domain_alloc(void) · 2 unmodified lines
1814	if (protection_domain_init(domain))	1879	if (protection_domain_init(domain))
1815	goto free_domain;	1880	goto free_domain;
1816		1881
1817	domain->mode = PAGE_MODE_3_LEVEL;	1882	pt_root = (void *)get_zeroed_page(GFP_KERNEL);
1818	domain->pt_root = (void *)get_zeroed_page(GFP_KERNEL);	1883	if (!pt_root)
1819	domain->flags = PD_DMA_OPS_MASK;
1820	if (!domain->pt_root)
1821	goto free_domain;	1884	goto free_domain;
1822		1885
		1886	root = amd_iommu_domain_encode_pgtable(pt_root, PAGE_MODE_3_LEVEL);
		1887	atomic64_set(&domain->pt_root, root);
		1888	domain->flags = PD_DMA_OPS_MASK;
		1889
1823	if (iommu_get_dma_cookie(&domain->domain) == -ENOMEM)	1890	if (iommu_get_dma_cookie(&domain->domain) == -ENOMEM)
1824	goto free_domain;	1891	goto free_domain;
1825		1892
@@ -1841,16 +1908,17 @@ static bool dma_ops_domain(struct protection_domain *domain) · 15 unmodified lines
1841	}	1908	}
1842		1909
1843	static void set_dte_entry(u16 devid, struct protection_domain *domain,	1910	static void set_dte_entry(u16 devid, struct protection_domain *domain,
		1911	struct domain_pgtable *pgtable,
1844	bool ats, bool ppr)	1912	bool ats, bool ppr)
1845	{	1913	{
1846	u64 pte_root = 0;	1914	u64 pte_root = 0;
1847	u64 flags = 0;	1915	u64 flags = 0;
1848	u32 old_domid;	1916	u32 old_domid;
1849		1917
1850	if (domain->mode != PAGE_MODE_NONE)	1918	if (pgtable->mode != PAGE_MODE_NONE)
1851	pte_root = iommu_virt_to_phys(domain->pt_root);	1919	pte_root = iommu_virt_to_phys(pgtable->root);
1852		1920
1853	pte_root \|= (domain->mode & DEV_ENTRY_MODE_MASK)	1921	pte_root \|= (pgtable->mode & DEV_ENTRY_MODE_MASK)
1854	<< DEV_ENTRY_MODE_SHIFT;	1922	<< DEV_ENTRY_MODE_SHIFT;
1855	pte_root \|= DTE_FLAG_IR \| DTE_FLAG_IW \| DTE_FLAG_V \| DTE_FLAG_TV;	1923	pte_root \|= DTE_FLAG_IR \| DTE_FLAG_IW \| DTE_FLAG_V \| DTE_FLAG_TV;
1856		1924
@@ -1923,6 +1991,7 @@ static void clear_dte_entry(u16 devid) · 66 unmodified lines
1923	static void do_attach(struct iommu_dev_data *dev_data,	1991	static void do_attach(struct iommu_dev_data *dev_data,
1924	struct protection_domain *domain)	1992	struct protection_domain *domain)
1925	{	1993	{
		1994	struct domain_pgtable pgtable;
1926	struct amd_iommu *iommu;	1995	struct amd_iommu *iommu;
1927	bool ats;	1996	bool ats;
1928		1997
@@ -1938,7 +2007,9 @@ static void do_attach(struct iommu_dev_data *dev_data, · 9 unmodified lines
1938	domain->dev_cnt += 1;	2007	domain->dev_cnt += 1;
1939		2008
1940	/* Update device table */	2009	/* Update device table */
1941	set_dte_entry(dev_data->devid, domain, ats, dev_data->iommu_v2);	2010	amd_iommu_domain_get_pgtable(domain, &pgtable);
		2011	set_dte_entry(dev_data->devid, domain, &pgtable,
		2012	ats, dev_data->iommu_v2);
1942	clone_aliases(dev_data->pdev);	2013	clone_aliases(dev_data->pdev);
1943		2014
1944	device_flush_dte(dev_data);	2015	device_flush_dte(dev_data);
@@ -2249,23 +2320,36 @@ static int amd_iommu_domain_get_attr(struct iommu_domain *domain, · 304 unmodified lines
2249	*	2320	*
2250	*****************************************************************************/	2321	*****************************************************************************/
2251		2322
2252	static void update_device_table(struct protection_domain *domain)	2323	static void update_device_table(struct protection_domain *domain,
		2324	struct domain_pgtable *pgtable)
2253	{	2325	{
2254	struct iommu_dev_data *dev_data;	2326	struct iommu_dev_data *dev_data;
2255		2327
2256	list_for_each_entry(dev_data, &domain->dev_list, list) {	2328	list_for_each_entry(dev_data, &domain->dev_list, list) {
2257	set_dte_entry(dev_data->devid, domain, dev_data->ats.enabled,	2329	set_dte_entry(dev_data->devid, domain, pgtable,
2258	dev_data->iommu_v2);	2330	dev_data->ats.enabled, dev_data->iommu_v2);
2259	clone_aliases(dev_data->pdev);	2331	clone_aliases(dev_data->pdev);
2260	}	2332	}
2261	}	2333	}
2262		2334
		2335	static void update_and_flush_device_table(struct protection_domain *domain,
		2336	struct domain_pgtable *pgtable)
		2337	{
		2338	update_device_table(domain, pgtable);
		2339	domain_flush_devices(domain);
		2340	}
		2341
2263	static void update_domain(struct protection_domain *domain)	2342	static void update_domain(struct protection_domain *domain)
2264	{	2343	{
2265	update_device_table(domain);	2344	struct domain_pgtable pgtable;
2266		2345
2267	domain_flush_devices(domain);	2346	/* Update device table */
		2347	amd_iommu_domain_get_pgtable(domain, &pgtable);
		2348	update_and_flush_device_table(domain, &pgtable);
		2349
		2350	/* Flush domain TLB(s) and wait for completion */
2268	domain_flush_tlb_pde(domain);	2351	domain_flush_tlb_pde(domain);
		2352	domain_flush_complete(domain);
2269	}	2353	}
2270		2354
2271	int __init amd_iommu_init_api(void)	2355	int __init amd_iommu_init_api(void)
@@ -2375,6 +2459,7 @@ out_err: · 103 unmodified lines
2375	static struct iommu_domain *amd_iommu_domain_alloc(unsigned type)	2459	static struct iommu_domain *amd_iommu_domain_alloc(unsigned type)
2376	{	2460	{
2377	struct protection_domain *pdomain;	2461	struct protection_domain *pdomain;
		2462	u64 *pt_root, root;
2378		2463
2379	switch (type) {	2464	switch (type) {
2380	case IOMMU_DOMAIN_UNMANAGED:	2465	case IOMMU_DOMAIN_UNMANAGED:
@@ -2382,13 +2467,15 @@ static struct iommu_domain *amd_iommu_domain_alloc(unsigned type) · 1 unmodified line
2382	if (!pdomain)	2467	if (!pdomain)
2383	return NULL;	2468	return NULL;
2384		2469
2385	pdomain->mode = PAGE_MODE_3_LEVEL;	2470	pt_root = (void *)get_zeroed_page(GFP_KERNEL);
2386	pdomain->pt_root = (void *)get_zeroed_page(GFP_KERNEL);	2471	if (!pt_root) {
2387	if (!pdomain->pt_root) {
2388	protection_domain_free(pdomain);	2472	protection_domain_free(pdomain);
2389	return NULL;	2473	return NULL;
2390	}	2474	}
2391		2475
		2476	root = amd_iommu_domain_encode_pgtable(pt_root, PAGE_MODE_3_LEVEL);
		2477	atomic64_set(&pdomain->pt_root, root);
		2478
2392	pdomain->domain.geometry.aperture_start = 0;	2479	pdomain->domain.geometry.aperture_start = 0;
2393	pdomain->domain.geometry.aperture_end = ~0ULL;	2480	pdomain->domain.geometry.aperture_end = ~0ULL;
2394	pdomain->domain.geometry.force_aperture = true;	2481	pdomain->domain.geometry.force_aperture = true;
@@ -2406,7 +2493,7 @@ static struct iommu_domain *amd_iommu_domain_alloc(unsigned type) · 11 unmodified lines
2406	if (!pdomain)	2493	if (!pdomain)
2407	return NULL;	2494	return NULL;
2408		2495
2409	pdomain->mode = PAGE_MODE_NONE;	2496	atomic64_set(&pdomain->pt_root, PAGE_MODE_NONE);
2410	break;	2497	break;
2411	default:	2498	default:
2412	return NULL;	2499	return NULL;
@@ -2418,6 +2505,7 @@ static struct iommu_domain *amd_iommu_domain_alloc(unsigned type) · 5 unmodified lines
2418	static void amd_iommu_domain_free(struct iommu_domain *dom)	2505	static void amd_iommu_domain_free(struct iommu_domain *dom)
2419	{	2506	{
2420	struct protection_domain *domain;	2507	struct protection_domain *domain;
		2508	struct domain_pgtable pgtable;
2421		2509
2422	domain = to_pdomain(dom);	2510	domain = to_pdomain(dom);
2423		2511
@@ -2435,7 +2523,9 @@ static void amd_iommu_domain_free(struct iommu_domain *dom) · 11 unmodified lines
2435	dma_ops_domain_free(domain);	2523	dma_ops_domain_free(domain);
2436	break;	2524	break;
2437	default:	2525	default:
2438	if (domain->mode != PAGE_MODE_NONE)	2526	amd_iommu_domain_get_pgtable(domain, &pgtable);
		2527
		2528	if (pgtable.mode != PAGE_MODE_NONE)
2439	free_pagetable(domain);	2529	free_pagetable(domain);
2440		2530
2441	if (domain->flags & PD_IOMMUV2_MASK)	2531	if (domain->flags & PD_IOMMUV2_MASK)
@@ -2518,10 +2608,12 @@ static int amd_iommu_map(struct iommu_domain *dom, unsigned long iova, · 76 unmodified lines
2518	gfp_t gfp)	2608	gfp_t gfp)
2519	{	2609	{
2520	struct protection_domain *domain = to_pdomain(dom);	2610	struct protection_domain *domain = to_pdomain(dom);
		2611	struct domain_pgtable pgtable;
2521	int prot = 0;	2612	int prot = 0;
2522	int ret;	2613	int ret;
2523		2614
2524	if (domain->mode == PAGE_MODE_NONE)	2615	amd_iommu_domain_get_pgtable(domain, &pgtable);
		2616	if (pgtable.mode == PAGE_MODE_NONE)
2525	return -EINVAL;	2617	return -EINVAL;
2526		2618
2527	if (iommu_prot & IOMMU_READ)	2619	if (iommu_prot & IOMMU_READ)
@@ -2541,8 +2633,10 @@ static size_t amd_iommu_unmap(struct iommu_domain *dom, unsigned long iova, · 13 unmodified lines
2541	struct iommu_iotlb_gather *gather)	2633	struct iommu_iotlb_gather *gather)
2542	{	2634	{
2543	struct protection_domain *domain = to_pdomain(dom);	2635	struct protection_domain *domain = to_pdomain(dom);
		2636	struct domain_pgtable pgtable;
2544		2637
2545	if (domain->mode == PAGE_MODE_NONE)	2638	amd_iommu_domain_get_pgtable(domain, &pgtable);
		2639	if (pgtable.mode == PAGE_MODE_NONE)
2546	return 0;	2640	return 0;
2547		2641
2548	return iommu_unmap_page(domain, iova, page_size);	2642	return iommu_unmap_page(domain, iova, page_size);
@@ -2553,9 +2647,11 @@ static phys_addr_t amd_iommu_iova_to_phys(struct iommu_domain *dom, · 4 unmodified lines
2553	{	2647	{
2554	struct protection_domain *domain = to_pdomain(dom);	2648	struct protection_domain *domain = to_pdomain(dom);
2555	unsigned long offset_mask, pte_pgsize;	2649	unsigned long offset_mask, pte_pgsize;
		2650	struct domain_pgtable pgtable;
2556	u64 *pte, __pte;	2651	u64 *pte, __pte;
2557		2652
2558	if (domain->mode == PAGE_MODE_NONE)	2653	amd_iommu_domain_get_pgtable(domain, &pgtable);
		2654	if (pgtable.mode == PAGE_MODE_NONE)
2559	return iova;	2655	return iova;
2560		2656
2561	pte = fetch_pte(domain, iova, &pte_pgsize);	2657	pte = fetch_pte(domain, iova, &pte_pgsize);
@@ -2708,16 +2804,26 @@ EXPORT_SYMBOL(amd_iommu_unregister_ppr_notifier); · 146 unmodified lines
2708	void amd_iommu_domain_direct_map(struct iommu_domain *dom)	2804	void amd_iommu_domain_direct_map(struct iommu_domain *dom)
2709	{	2805	{
2710	struct protection_domain *domain = to_pdomain(dom);	2806	struct protection_domain *domain = to_pdomain(dom);
		2807	struct domain_pgtable pgtable;
2711	unsigned long flags;	2808	unsigned long flags;
		2809	u64 pt_root;
2712		2810
2713	spin_lock_irqsave(&domain->lock, flags);	2811	spin_lock_irqsave(&domain->lock, flags);
2714		2812
		2813	/* First save pgtable configuration*/
		2814	amd_iommu_domain_get_pgtable(domain, &pgtable);
		2815
2715	/* Update data structure */	2816	/* Update data structure */
2716	domain->mode = PAGE_MODE_NONE;	2817	pt_root = amd_iommu_domain_encode_pgtable(NULL, PAGE_MODE_NONE);
		2818	atomic64_set(&domain->pt_root, pt_root);
2717		2819
2718	/* Make changes visible to IOMMUs */	2820	/* Make changes visible to IOMMUs */
2719	update_domain(domain);	2821	update_domain(domain);
2720		2822
		2823	/* Restore old pgtable in domain->ptroot to free page-table */
		2824	pt_root = amd_iommu_domain_encode_pgtable(pgtable.root, pgtable.mode);
		2825	atomic64_set(&domain->pt_root, pt_root);
		2826
2721	/* Page-table is not visible to IOMMU anymore, so free it */	2827	/* Page-table is not visible to IOMMU anymore, so free it */
2722	free_pagetable(domain);	2828	free_pagetable(domain);
2723		2829
@@ -2908,9 +3014,11 @@ static u64 __get_gcr3_pte(u64 root, int level, int pasid, bool alloc) · 184 unmodified lines
2908	static int __set_gcr3(struct protection_domain *domain, int pasid,	3014	static int __set_gcr3(struct protection_domain *domain, int pasid,
2909	unsigned long cr3)	3015	unsigned long cr3)
2910	{	3016	{
		3017	struct domain_pgtable pgtable;
2911	u64 *pte;	3018	u64 *pte;
2912		3019
2913	if (domain->mode != PAGE_MODE_NONE)	3020	amd_iommu_domain_get_pgtable(domain, &pgtable);
		3021	if (pgtable.mode != PAGE_MODE_NONE)
2914	return -EINVAL;	3022	return -EINVAL;
2915		3023
2916	pte = __get_gcr3_pte(domain->gcr3_tbl, domain->glx, pasid, true);	3024	pte = __get_gcr3_pte(domain->gcr3_tbl, domain->glx, pasid, true);
@@ -2924,9 +3032,11 @@ static int __set_gcr3(struct protection_domain *domain, int pasid, · 7 unmodified lines
2924		3032
2925	static int __clear_gcr3(struct protection_domain *domain, int pasid)	3033	static int __clear_gcr3(struct protection_domain *domain, int pasid)
2926	{	3034	{
		3035	struct domain_pgtable pgtable;
2927	u64 *pte;	3036	u64 *pte;
2928		3037
2929	if (domain->mode != PAGE_MODE_NONE)	3038	amd_iommu_domain_get_pgtable(domain, &pgtable);
		3039	if (pgtable.mode != PAGE_MODE_NONE)
2930	return -EINVAL;	3040	return -EINVAL;
2931		3041
2932	pte = __get_gcr3_pte(domain->gcr3_tbl, domain->glx, pasid, false);	3042	pte = __get_gcr3_pte(domain->gcr3_tbl, domain->glx, pasid, false);

drivers/iommu/amd_iommu_init.c+1−1

@@ -2936,7 +2936,7 @@ static int __init parse_amd_iommu_intr(char *str) · 2935 unmodified lines
2936	{	2936	{
2937	for (; *str; ++str) {	2937	for (; *str; ++str) {
2938	if (strncmp(str, "legacy", 6) == 0) {	2938	if (strncmp(str, "legacy", 6) == 0) {
2939	amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY;	2939	amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY_GA;
2940	break;	2940	break;
2941	}	2941	}
2942	if (strncmp(str, "vapic", 5) == 0) {	2942	if (strncmp(str, "vapic", 5) == 0) {

drivers/iommu/amd_iommu_types.h+7−2

 				       iommu core code */
 	spinlock_t lock;	/* mostly used to lock the page table*/
 	u16 id;			/* the domain id written to the device table */
-	int mode;		/* paging mode (0-6 levels) */
+	atomic64_t pt_root;	/* pgtable root and pgtable mode */
-	u64 *pt_root;		/* page table root pointer */
 	int glx;		/* Number of levels for GCR3 table */
 	u64 *gcr3_tbl;		/* Guest CR3 table */
 	unsigned long flags;	/* flags to find out type of domain */
 	unsigned dev_iommu[MAX_IOMMUS]; /* per-IOMMU reference count */
 };
+/* For decocded pt_root */
+struct domain_pgtable {
+	int mode;
+	u64 *root;
+};
 /*
  * Structure where we save information about one hardware AMD IOMMU in the
  * system.

drivers/iommu/intel-iommu.c+2−2

@@ -371,11 +371,11 @@ int dmar_disabled = 0; · 370 unmodified lines
371	int dmar_disabled = 1;	371	int dmar_disabled = 1;
372	#endif /* CONFIG_INTEL_IOMMU_DEFAULT_ON */	372	#endif /* CONFIG_INTEL_IOMMU_DEFAULT_ON */
373		373
374	#ifdef INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON	374	#ifdef CONFIG_INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON
375	int intel_iommu_sm = 1;	375	int intel_iommu_sm = 1;
376	#else	376	#else
377	int intel_iommu_sm;	377	int intel_iommu_sm;
378	#endif /* INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON */	378	#endif /* CONFIG_INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON */
379		379
380	int intel_iommu_enabled = 0;	380	int intel_iommu_enabled = 0;
381	EXPORT_SYMBOL_GPL(intel_iommu_enabled);	381	EXPORT_SYMBOL_GPL(intel_iommu_enabled);

drivers/iommu/iommu.c+2−1

 static void dev_iommu_free(struct device *dev)
 {
+	iommu_fwspec_free(dev);
 	kfree(dev->iommu);
 	dev->iommu = NULL;
 }
 	return group;
 }
-EXPORT_SYMBOL(iommu_group_get_for_dev);
+EXPORT_SYMBOL_GPL(iommu_group_get_for_dev);
 struct iommu_domain *iommu_group_default_domain(struct iommu_group *group)
 {

drivers/iommu/qcom_iommu.c+4−1

 	qcom_iommu->dev = dev;
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-	if (res)
+	if (res) {
 		qcom_iommu->local_base = devm_ioremap_resource(dev, res);
+		if (IS_ERR(qcom_iommu->local_base))
+			return PTR_ERR(qcom_iommu->local_base);
+	}
 	qcom_iommu->iface_clk = devm_clk_get(dev, "iface");
 	if (IS_ERR(qcom_iommu->iface_clk)) {

drivers/iommu/virtio-iommu.c+1−1

@@ -453,7 +453,7 @@ static int viommu_add_resv_mem(struct viommu_endpoint *vdev, · 452 unmodified lines
453	if (!region)	453	if (!region)
454	return -ENOMEM;	454	return -ENOMEM;
455		455
456	list_add(&vdev->resv_regions, &region->list);	456	list_add(&region->list, &vdev->resv_regions);
457	return 0;	457	return 0;
458	}	458	}
459		459

drivers/md/dm-mpath.c+4−2

 	/* Do we need to select a new pgpath? */
 	pgpath = READ_ONCE(m->current_pgpath);
-	queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
+	if (!pgpath || !test_bit(MPATHF_QUEUE_IO, &m->flags))
-	if (!pgpath || !queue_io)
 		pgpath = choose_pgpath(m, bio->bi_iter.bi_size);
+	/* MPATHF_QUEUE_IO might have been cleared by choose_pgpath. */
+	queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
 	if ((pgpath && queue_io) ||
 	    (!pgpath && test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))) {
 		/* Queue for the daemon to resubmit */

drivers/md/dm-verity-fec.c+1−1

@@ -435,7 +435,7 @@ int verity_fec_decode(struct dm_verity v, struct dm_verity_io io, · 434 unmodified lines
435	fio->level++;	435	fio->level++;
436		436
437	if (type == DM_VERITY_BLOCK_TYPE_METADATA)	437	if (type == DM_VERITY_BLOCK_TYPE_METADATA)
438	block += v->data_blocks;	438	block = block - v->hash_start + v->data_blocks;
439		439
440	/*	440	/*
441	* For RS(M, N), the continuous FEC data is divided into blocks of N	441	* For RS(M, N), the continuous FEC data is divided into blocks of N

drivers/md/dm-writecache.c+37−15

 	return 0;
 }
+static int writecache_read_metadata(struct dm_writecache *wc, sector_t n_sectors)
+{
+	struct dm_io_region region;
+	struct dm_io_request req;
+	region.bdev = wc->ssd_dev->bdev;
+	region.sector = wc->start_sector;
+	region.count = n_sectors;
+	req.bi_op = REQ_OP_READ;
+	req.bi_op_flags = REQ_SYNC;
+	req.mem.type = DM_IO_VMA;
+	req.mem.ptr.vma = (char *)wc->memory_map;
+	req.client = wc->dm_io;
+	req.notify.fn = NULL;
+	return dm_io(&req, 1, &region, NULL);
+}
 static void writecache_resume(struct dm_target *ti)
 {
 	struct dm_writecache *wc = ti->private;
 	wc_lock(wc);
-	if (WC_MODE_PMEM(wc))
+	if (WC_MODE_PMEM(wc)) {
 		persistent_memory_invalidate_cache(wc->memory_map, wc->memory_map_size);
+	} else {
+		r = writecache_read_metadata(wc, wc->metadata_sectors);
+		if (r) {
+			size_t sb_entries_offset;
+			writecache_error(wc, r, "unable to read metadata: %d", r);
+			sb_entries_offset = offsetof(struct wc_memory_superblock, entries);
+			memset((char *)wc->memory_map + sb_entries_offset, -1,
+			       (wc->metadata_sectors << SECTOR_SHIFT) - sb_entries_offset);
+		}
+	}
 	wc->tree = RB_ROOT;
 	INIT_LIST_HEAD(&wc->lru);
 		ti->error = "Invalid block size";
 		goto bad;
 	}
+	if (wc->block_size < bdev_logical_block_size(wc->dev->bdev) ||
+	    wc->block_size < bdev_logical_block_size(wc->ssd_dev->bdev)) {
+		r = -EINVAL;
+		ti->error = "Block size is smaller than device logical block size";
+		goto bad;
+	}
 	wc->block_size_bits = __ffs(wc->block_size);
 	wc->max_writeback_jobs = MAX_WRITEBACK_JOBS;
 			goto bad;
 		}
 	} else {
-		struct dm_io_region region;
-		struct dm_io_request req;
 		size_t n_blocks, n_metadata_blocks;
 		uint64_t n_bitmap_bits;
 			goto bad;
 		}
-		region.bdev = wc->ssd_dev->bdev;
+		r = writecache_read_metadata(wc, wc->block_size >> SECTOR_SHIFT);
-		region.sector = wc->start_sector;
-		region.count = wc->metadata_sectors;
-		req.bi_op = REQ_OP_READ;
-		req.bi_op_flags = REQ_SYNC;
-		req.mem.type = DM_IO_VMA;
-		req.mem.ptr.vma = (char *)wc->memory_map;
-		req.client = wc->dm_io;
-		req.notify.fn = NULL;
-		r = dm_io(&req, 1, &region, NULL);
 		if (r) {
-			ti->error = "Unable to read metadata";
+			ti->error = "Unable to read first block of metadata";
 			goto bad;
 		}
 	}

drivers/misc/mei/hw-me.c+8−0

 	MEI_CFG_DMA_128,
 };
+/* LBG with quirk for SPS Firmware exclusion */
+static const struct mei_cfg mei_me_pch12_sps_cfg = {
+	MEI_CFG_PCH8_HFS,
+	MEI_CFG_FW_VER_SUPP,
+	MEI_CFG_FW_SPS,
+};
 /* Tiger Lake and newer devices */
 static const struct mei_cfg mei_me_pch15_cfg = {
 	MEI_CFG_PCH8_HFS,
 	[MEI_ME_PCH8_CFG] = &mei_me_pch8_cfg,
 	[MEI_ME_PCH8_SPS_CFG] = &mei_me_pch8_sps_cfg,
 	[MEI_ME_PCH12_CFG] = &mei_me_pch12_cfg,
+	[MEI_ME_PCH12_SPS_CFG] = &mei_me_pch12_sps_cfg,
 	[MEI_ME_PCH15_CFG] = &mei_me_pch15_cfg,
 };

drivers/misc/mei/hw-me.h+4−0

  *                         servers platforms with quirk for
  *                         SPS firmware exclusion.
  * @MEI_ME_PCH12_CFG:      Platform Controller Hub Gen12 and newer
+ * @MEI_ME_PCH12_SPS_CFG:  Platform Controller Hub Gen12 and newer
+ *                         servers platforms with quirk for
+ *                         SPS firmware exclusion.
  * @MEI_ME_PCH15_CFG:      Platform Controller Hub Gen15 and newer
  * @MEI_ME_NUM_CFG:        Upper Sentinel.
  */
 	MEI_ME_PCH8_CFG,
 	MEI_ME_PCH8_SPS_CFG,
 	MEI_ME_PCH12_CFG,
+	MEI_ME_PCH12_SPS_CFG,
 	MEI_ME_PCH15_CFG,
 	MEI_ME_NUM_CFG,
 };

drivers/misc/mei/pci-me.c+1−1

@@ -70,7 +70,7 @@ static const struct pci_device_id mei_me_pci_tbl[] = { · 69 unmodified lines
70	{MEI_PCI_DEVICE(MEI_DEV_ID_SPT_2, MEI_ME_PCH8_CFG)},	70	{MEI_PCI_DEVICE(MEI_DEV_ID_SPT_2, MEI_ME_PCH8_CFG)},
71	{MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H, MEI_ME_PCH8_SPS_CFG)},	71	{MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H, MEI_ME_PCH8_SPS_CFG)},
72	{MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H_2, MEI_ME_PCH8_SPS_CFG)},	72	{MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H_2, MEI_ME_PCH8_SPS_CFG)},
73	{MEI_PCI_DEVICE(MEI_DEV_ID_LBG, MEI_ME_PCH12_CFG)},	73	{MEI_PCI_DEVICE(MEI_DEV_ID_LBG, MEI_ME_PCH12_SPS_CFG)},
74		74
75	{MEI_PCI_DEVICE(MEI_DEV_ID_BXT_M, MEI_ME_PCH8_CFG)},	75	{MEI_PCI_DEVICE(MEI_DEV_ID_BXT_M, MEI_ME_PCH8_CFG)},
76	{MEI_PCI_DEVICE(MEI_DEV_ID_APL_I, MEI_ME_PCH8_CFG)},	76	{MEI_PCI_DEVICE(MEI_DEV_ID_APL_I, MEI_ME_PCH8_CFG)},

drivers/mmc/core/mmc_ops.c+1−1

@@ -878,7 +878,7 @@ static int mmc_send_hpi_cmd(struct mmc_card *card) · 877 unmodified lines
878	* Issued High Priority Interrupt, and check for card status	878	* Issued High Priority Interrupt, and check for card status
879	* until out-of prg-state.	879	* until out-of prg-state.
880	*/	880	*/
881	int mmc_interrupt_hpi(struct mmc_card *card)	881	static int mmc_interrupt_hpi(struct mmc_card *card)
882	{	882	{
883	int err;	883	int err;
884	u32 status;	884	u32 status;

drivers/mmc/host/cqhci.c+10−11

 #include <linux/delay.h>
 #include <linux/highmem.h>
 #include <linux/io.h>
+#include <linux/iopoll.h>
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
 /* CQHCI is idle and should halt immediately, so set a small timeout */
 #define CQHCI_OFF_TIMEOUT 100
+static u32 cqhci_read_ctl(struct cqhci_host *cq_host)
+{
+	return cqhci_readl(cq_host, CQHCI_CTL);
+}
 static void cqhci_off(struct mmc_host *mmc)
 {
 	struct cqhci_host *cq_host = mmc->cqe_private;
-	ktime_t timeout;
-	bool timed_out;
 	u32 reg;
+	int err;
 	if (!cq_host->enabled || !mmc->cqe_on || cq_host->recovery_halt)
 		return;
 	cqhci_writel(cq_host, CQHCI_HALT, CQHCI_CTL);
-	timeout = ktime_add_us(ktime_get(), CQHCI_OFF_TIMEOUT);
+	err = readx_poll_timeout(cqhci_read_ctl, cq_host, reg,
-	while (1) {
+				 reg & CQHCI_HALT, 0, CQHCI_OFF_TIMEOUT);
-		timed_out = ktime_compare(ktime_get(), timeout) > 0;
+	if (err < 0)
-		reg = cqhci_readl(cq_host, CQHCI_CTL);
-		if ((reg & CQHCI_HALT) || timed_out)
-			break;
-	}
-	if (timed_out)
 		pr_err("%s: cqhci: CQE stuck on\n", mmc_hostname(mmc));
 	else
 		pr_debug("%s: cqhci: CQE off\n", mmc_hostname(mmc));

drivers/mmc/host/meson-mx-sdio.c+1−10

 		meson_mx_mmc_start_cmd(mmc, mrq->cmd);
 }
-static int meson_mx_mmc_card_busy(struct mmc_host *mmc)
-{
-	struct meson_mx_mmc_host *host = mmc_priv(mmc);
-	u32 irqc = readl(host->base + MESON_MX_SDIO_IRQC);
-	return !!(irqc & MESON_MX_SDIO_IRQC_FORCE_DATA_DAT_MASK);
-}
 static void meson_mx_mmc_read_response(struct mmc_host *mmc,
 				       struct mmc_command *cmd)
 {
 static struct mmc_host_ops meson_mx_mmc_ops = {
 	.request		= meson_mx_mmc_request,
 	.set_ios		= meson_mx_mmc_set_ios,
-	.card_busy		= meson_mx_mmc_card_busy,
 	.get_cd			= mmc_gpio_get_cd,
 	.get_ro			= mmc_gpio_get_ro,
 };
 	mmc->f_max = clk_round_rate(host->cfg_div_clk,
 				    clk_get_rate(host->parent_clk));
-	mmc->caps |= MMC_CAP_ERASE | MMC_CAP_CMD23;
+	mmc->caps |= MMC_CAP_ERASE | MMC_CAP_CMD23 | MMC_CAP_WAIT_WHILE_BUSY;
 	mmc->ops = &meson_mx_mmc_ops;
 	ret = mmc_of_parse(mmc);

drivers/mmc/host/sdhci-msm.c+2−0

@@ -2087,6 +2087,8 @@ static int sdhci_msm_probe(struct platform_device *pdev) · 2086 unmodified lines
2087	goto clk_disable;	2087	goto clk_disable;
2088	}	2088	}
2089		2089
		2090	msm_host->mmc->caps \|= MMC_CAP_WAIT_WHILE_BUSY \| MMC_CAP_NEED_RSP_BUSY;
		2091
2090	pm_runtime_get_noresume(&pdev->dev);	2092	pm_runtime_get_noresume(&pdev->dev);
2091	pm_runtime_set_active(&pdev->dev);	2093	pm_runtime_set_active(&pdev->dev);
2092	pm_runtime_enable(&pdev->dev);	2094	pm_runtime_enable(&pdev->dev);

drivers/mmc/host/sdhci-pci-core.c+3−0

@@ -601,6 +601,9 @@ static int intel_select_drive_strength(struct mmc_card *card, · 600 unmodified lines
601	struct sdhci_pci_slot *slot = sdhci_priv(host);	601	struct sdhci_pci_slot *slot = sdhci_priv(host);
602	struct intel_host *intel_host = sdhci_pci_priv(slot);	602	struct intel_host *intel_host = sdhci_pci_priv(slot);
603		603
		604	if (!(mmc_driver_type_mask(intel_host->drv_strength) & card_drv))
		605	return 0;
		606
604	return intel_host->drv_strength;	607	return intel_host->drv_strength;
605	}	608	}
606		609

drivers/mmc/host/sdhci-xenon.c+10−0

@@ -235,6 +235,16 @@ static void xenon_voltage_switch(struct sdhci_host *host) · 234 unmodified lines
235	{	235	{
236	/* Wait for 5ms after set 1.8V signal enable bit */	236	/* Wait for 5ms after set 1.8V signal enable bit */
237	usleep_range(5000, 5500);	237	usleep_range(5000, 5500);
		238
		239	/*
		240	* For some reason the controller's Host Control2 register reports
		241	* the bit representing 1.8V signaling as 0 when read after it was
		242	* written as 1. Subsequent read reports 1.
		243	*
		244	* Since this may cause some issues, do an empty read of the Host
		245	* Control2 register here to circumvent this.
		246	*/
		247	sdhci_readw(host, SDHCI_HOST_CONTROL2);
238	}	248	}
239		249
240	static const struct sdhci_ops sdhci_xenon_ops = {	250	static const struct sdhci_ops sdhci_xenon_ops = {

drivers/most/core.c+1−1

@@ -1483,7 +1483,7 @@ static void __exit most_exit(void) · 1482 unmodified lines
1483	ida_destroy(&mdev_id);	1483	ida_destroy(&mdev_id);
1484	}	1484	}
1485		1485
1486	module_init(most_init);	1486	subsys_initcall(most_init);
1487	module_exit(most_exit);	1487	module_exit(most_exit);
1488	MODULE_LICENSE("GPL");	1488	MODULE_LICENSE("GPL");
1489	MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>");	1489	MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>");

drivers/net/dsa/mv88e6xxx/Kconfig+1−1

 	bool "PTP support for Marvell 88E6xxx"
 	default n
 	depends on NET_DSA_MV88E6XXX_GLOBAL2
+	depends on PTP_1588_CLOCK
 	imply NETWORK_PHY_TIMESTAMPING
-	imply PTP_1588_CLOCK
 	help
 	  Say Y to enable PTP hardware timestamping on Marvell 88E6xxx switch
 	  chips that support it.

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

 	.serdes_get_stats = mv88e6390_serdes_get_stats,
 	.serdes_get_regs_len = mv88e6390_serdes_get_regs_len,
 	.serdes_get_regs = mv88e6390_serdes_get_regs,
-	.phylink_validate = mv88e6390_phylink_validate,
 	.gpio_ops = &mv88e6352_gpio_ops,
 	.phylink_validate = mv88e6390_phylink_validate,
 };
 	.serdes_get_stats = mv88e6390_serdes_get_stats,
 	.serdes_get_regs_len = mv88e6390_serdes_get_regs_len,
 	.serdes_get_regs = mv88e6390_serdes_get_regs,
-	.phylink_validate = mv88e6390_phylink_validate,
 	.gpio_ops = &mv88e6352_gpio_ops,
 	.phylink_validate = mv88e6390x_phylink_validate,
 };
 	.serdes_get_stats = mv88e6390_serdes_get_stats,
 	.serdes_get_regs_len = mv88e6390_serdes_get_regs_len,
 	.serdes_get_regs = mv88e6390_serdes_get_regs,
-	.phylink_validate = mv88e6390_phylink_validate,
 	.avb_ops = &mv88e6390_avb_ops,
 	.ptp_ops = &mv88e6352_ptp_ops,
 	.phylink_validate = mv88e6390_phylink_validate,
 	.serdes_get_stats = mv88e6390_serdes_get_stats,
 	.serdes_get_regs_len = mv88e6390_serdes_get_regs_len,
 	.serdes_get_regs = mv88e6390_serdes_get_regs,
-	.phylink_validate = mv88e6390_phylink_validate,
 	.gpio_ops = &mv88e6352_gpio_ops,
 	.avb_ops = &mv88e6390_avb_ops,
 	.ptp_ops = &mv88e6352_ptp_ops,

drivers/net/dsa/ocelot/felix.c+1−0

@@ -400,6 +400,7 @@ static int felix_init_structs(struct felix *felix, int num_phys_ports) · 399 unmodified lines
400	ocelot->stats_layout = felix->info->stats_layout;	400	ocelot->stats_layout = felix->info->stats_layout;
401	ocelot->num_stats = felix->info->num_stats;	401	ocelot->num_stats = felix->info->num_stats;
402	ocelot->shared_queue_sz = felix->info->shared_queue_sz;	402	ocelot->shared_queue_sz = felix->info->shared_queue_sz;
		403	ocelot->num_mact_rows = felix->info->num_mact_rows;
403	ocelot->vcap_is2_keys = felix->info->vcap_is2_keys;	404	ocelot->vcap_is2_keys = felix->info->vcap_is2_keys;
404	ocelot->vcap_is2_actions= felix->info->vcap_is2_actions;	405	ocelot->vcap_is2_actions= felix->info->vcap_is2_actions;
405	ocelot->vcap = felix->info->vcap;	406	ocelot->vcap = felix->info->vcap;

drivers/net/dsa/ocelot/felix.h+1−0

@@ -15,6 +15,7 @@ struct felix_info { · 14 unmodified lines
15	const u32 const map;	15	const u32 const map;
16	const struct ocelot_ops *ops;	16	const struct ocelot_ops *ops;
17	int shared_queue_sz;	17	int shared_queue_sz;
		18	int num_mact_rows;
18	const struct ocelot_stat_layout *stats_layout;	19	const struct ocelot_stat_layout *stats_layout;
19	unsigned int num_stats;	20	unsigned int num_stats;
20	int num_ports;	21	int num_ports;

drivers/net/dsa/ocelot/felix_vsc9959.c+1−0

@@ -1220,6 +1220,7 @@ struct felix_info felix_info_vsc9959 = { · 1219 unmodified lines
1220	.vcap_is2_actions = vsc9959_vcap_is2_actions,	1220	.vcap_is2_actions = vsc9959_vcap_is2_actions,
1221	.vcap = vsc9959_vcap_props,	1221	.vcap = vsc9959_vcap_props,
1222	.shared_queue_sz = 128 * 1024,	1222	.shared_queue_sz = 128 * 1024,
		1223	.num_mact_rows = 2048,
1223	.num_ports = 6,	1224	.num_ports = 6,
1224	.switch_pci_bar = 4,	1225	.switch_pci_bar = 4,
1225	.imdio_pci_bar = 0,	1226	.imdio_pci_bar = 0,

drivers/net/dsa/sja1105/Kconfig+1−0

@@ -20,6 +20,7 @@ tristate "NXP SJA1105 Ethernet switch family support" · 19 unmodified lines
20	config NET_DSA_SJA1105_PTP	20	config NET_DSA_SJA1105_PTP
21	bool "Support for the PTP clock on the NXP SJA1105 Ethernet switch"	21	bool "Support for the PTP clock on the NXP SJA1105 Ethernet switch"
22	depends on NET_DSA_SJA1105	22	depends on NET_DSA_SJA1105
		23	depends on PTP_1588_CLOCK
23	help	24	help
24	This enables support for timestamping and PTP clock manipulations in	25	This enables support for timestamping and PTP clock manipulations in
25	the SJA1105 DSA driver.	26	the SJA1105 DSA driver.

drivers/net/dsa/sja1105/sja1105_ptp.c+18−8

 /* PTPSYNCTS has no interrupt or update mechanism, because the intended
  * hardware use case is for the timestamp to be collected synchronously,
- * immediately after the CAS_MASTER SJA1105 switch has triggered a CASSYNC
+ * immediately after the CAS_MASTER SJA1105 switch has performed a CASSYNC
- * pulse on the PTP_CLK pin. When used as a generic extts source, it needs
+ * one-shot toggle (no return to level) on the PTP_CLK pin. When used as a
- * polling and a comparison with the old value. The polling interval is just
+ * generic extts source, the PTPSYNCTS register needs polling and a comparison
- * the Nyquist rate of a canonical PPS input (e.g. from a GPS module).
+ * with the old value. The polling interval is configured as the Nyquist rate
- * Anything of higher frequency than 1 Hz will be lost, since there is no
+ * of a signal with 50% duty cycle and 1Hz frequency, which is sadly all that
- * timestamp FIFO.
+ * this hardware can do (but may be enough for some setups). Anything of higher
+ * frequency than 1 Hz will be lost, since there is no timestamp FIFO.
  */
-#define SJA1105_EXTTS_INTERVAL		(HZ / 2)
+#define SJA1105_EXTTS_INTERVAL		(HZ / 4)
 /*            This range is actually +/- SJA1105_MAX_ADJ_PPB
  *            divided by 1000 (ppb -> ppm) and with a 16-bit
 		return -EOPNOTSUPP;
 	/* Reject requests with unsupported flags */
-	if (extts->flags)
+	if (extts->flags & ~(PTP_ENABLE_FEATURE |
+			     PTP_RISING_EDGE |
+			     PTP_FALLING_EDGE |
+			     PTP_STRICT_FLAGS))
+		return -EOPNOTSUPP;
+	/* We can only enable time stamping on both edges, sadly. */
+	if ((extts->flags & PTP_STRICT_FLAGS) &&
+	    (extts->flags & PTP_ENABLE_FEATURE) &&
+	    (extts->flags & PTP_EXTTS_EDGES) != PTP_EXTTS_EDGES)
 		return -EOPNOTSUPP;
 	rc = sja1105_change_ptp_clk_pin_func(priv, PTP_PF_EXTTS);

drivers/net/ethernet/amazon/ena/ena_netdev.h+1−1

@@ -69,7 +69,7 @@ · 68 unmodified lines
69	* 16kB.	69	* 16kB.
70	*/	70	*/
71	#if PAGE_SIZE > SZ_16K	71	#if PAGE_SIZE > SZ_16K
72	#define ENA_PAGE_SIZE SZ_16K	72	#define ENA_PAGE_SIZE (_AC(SZ_16K, UL))
73	#else	73	#else
74	#define ENA_PAGE_SIZE PAGE_SIZE	74	#define ENA_PAGE_SIZE PAGE_SIZE
75	#endif	75	#endif

drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c+1−1

@@ -57,7 +57,7 @@ static const struct aq_board_revision_s hw_atl_boards[] = { · 56 unmodified lines
57	{ AQ_DEVICE_ID_D108, AQ_HWREV_2, &hw_atl_ops_b0, &hw_atl_b0_caps_aqc108, },	57	{ AQ_DEVICE_ID_D108, AQ_HWREV_2, &hw_atl_ops_b0, &hw_atl_b0_caps_aqc108, },
58	{ AQ_DEVICE_ID_D109, AQ_HWREV_2, &hw_atl_ops_b0, &hw_atl_b0_caps_aqc109, },	58	{ AQ_DEVICE_ID_D109, AQ_HWREV_2, &hw_atl_ops_b0, &hw_atl_b0_caps_aqc109, },
59		59
60	{ AQ_DEVICE_ID_AQC100, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc107, },	60	{ AQ_DEVICE_ID_AQC100, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc100, },
61	{ AQ_DEVICE_ID_AQC107, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc107, },	61	{ AQ_DEVICE_ID_AQC107, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc107, },
62	{ AQ_DEVICE_ID_AQC108, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc108, },	62	{ AQ_DEVICE_ID_AQC108, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc108, },
63	{ AQ_DEVICE_ID_AQC109, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc109, },	63	{ AQ_DEVICE_ID_AQC109, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc109, },

drivers/net/ethernet/broadcom/bgmac-platform.c+15−9

 {
 	struct device_node *np = pdev->dev.of_node;
 	struct bgmac *bgmac;
+	struct resource *regs;
 	const u8 *mac_addr;
 	bgmac = bgmac_alloc(&pdev->dev);
 	if (IS_ERR(bgmac->plat.base))
 		return PTR_ERR(bgmac->plat.base);
-	bgmac->plat.idm_base =
+	regs = platform_get_resource_byname(pdev, IORESOURCE_MEM, "idm_base");
-		devm_platform_ioremap_resource_byname(pdev, "idm_base");
+	if (regs) {
-	if (IS_ERR(bgmac->plat.idm_base))
+		bgmac->plat.idm_base = devm_ioremap_resource(&pdev->dev, regs);
-		return PTR_ERR(bgmac->plat.idm_base);
+		if (IS_ERR(bgmac->plat.idm_base))
-	bgmac->feature_flags &= ~BGMAC_FEAT_IDM_MASK;
+			return PTR_ERR(bgmac->plat.idm_base);
+		bgmac->feature_flags &= ~BGMAC_FEAT_IDM_MASK;
+	}
-	bgmac->plat.nicpm_base =
+	regs = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nicpm_base");
-		devm_platform_ioremap_resource_byname(pdev, "nicpm_base");
+	if (regs) {
-	if (IS_ERR(bgmac->plat.nicpm_base))
+		bgmac->plat.nicpm_base = devm_ioremap_resource(&pdev->dev,
-		return PTR_ERR(bgmac->plat.nicpm_base);
+							       regs);
+		if (IS_ERR(bgmac->plat.nicpm_base))
+			return PTR_ERR(bgmac->plat.nicpm_base);
+	}
 	bgmac->read = platform_bgmac_read;
 	bgmac->write = platform_bgmac_write;

drivers/net/ethernet/broadcom/bnxt/bnxt.c+13−7

 	int rc;
 	if (!mem_size)
-		return 0;
+		return -EINVAL;
 	ctx_pg->nr_pages = DIV_ROUND_UP(mem_size, BNXT_PAGE_SIZE);
 	if (ctx_pg->nr_pages > MAX_CTX_TOTAL_PAGES) {
 					   netdev_features_t features)
 {
 	struct bnxt *bp = netdev_priv(dev);
+	netdev_features_t vlan_features;
 	if ((features & NETIF_F_NTUPLE) && !bnxt_rfs_capable(bp))
 		features &= ~NETIF_F_NTUPLE;
 	/* Both CTAG and STAG VLAN accelaration on the RX side have to be
 	 * turned on or off together.
 	 */
-	if ((features & (NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_STAG_RX)) !=
+	vlan_features = features & (NETIF_F_HW_VLAN_CTAG_RX |
-	    (NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_STAG_RX)) {
+				    NETIF_F_HW_VLAN_STAG_RX);
+	if (vlan_features != (NETIF_F_HW_VLAN_CTAG_RX |
+			      NETIF_F_HW_VLAN_STAG_RX)) {
 		if (dev->features & NETIF_F_HW_VLAN_CTAG_RX)
 			features &= ~(NETIF_F_HW_VLAN_CTAG_RX |
 				      NETIF_F_HW_VLAN_STAG_RX);
-		else
+		else if (vlan_features)
 			features |= NETIF_F_HW_VLAN_CTAG_RX |
 				    NETIF_F_HW_VLAN_STAG_RX;
 	}
 		bnxt_ulp_start(bp, err);
 	}
-	if (result != PCI_ERS_RESULT_RECOVERED && netif_running(netdev))
+	if (result != PCI_ERS_RESULT_RECOVERED) {
-		dev_close(netdev);
+		if (netif_running(netdev))
+			dev_close(netdev);
+		pci_disable_device(pdev);
+	}
 	rtnl_unlock();
-	return PCI_ERS_RESULT_RECOVERED;
+	return result;
 }
 /**

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

@@ -1066,7 +1066,6 @@ struct bnxt_vf_info { · 1065 unmodified lines
1066	#define BNXT_VF_LINK_FORCED 0x4	1066	#define BNXT_VF_LINK_FORCED 0x4
1067	#define BNXT_VF_LINK_UP 0x8	1067	#define BNXT_VF_LINK_UP 0x8
1068	#define BNXT_VF_TRUST 0x10	1068	#define BNXT_VF_TRUST 0x10
1069	u32 func_flags; /* func cfg flags */
1070	u32 min_tx_rate;	1069	u32 min_tx_rate;
1071	u32 max_tx_rate;	1070	u32 max_tx_rate;
1072	void *hwrm_cmd_req_addr;	1071	void *hwrm_cmd_req_addr;

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

@@ -43,7 +43,7 @@ static inline void bnxt_link_bp_to_dl(struct bnxt bp, struct devlink dl) · 42 unmodified lines
43	#define BNXT_NVM_CFG_VER_BITS 24	43	#define BNXT_NVM_CFG_VER_BITS 24
44	#define BNXT_NVM_CFG_VER_BYTES 4	44	#define BNXT_NVM_CFG_VER_BYTES 4
45		45
46	#define BNXT_MSIX_VEC_MAX 1280	46	#define BNXT_MSIX_VEC_MAX 512
47	#define BNXT_MSIX_VEC_MIN_MAX 128	47	#define BNXT_MSIX_VEC_MIN_MAX 128
48		48
49	enum bnxt_nvm_dir_type {	49	enum bnxt_nvm_dir_type {

drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c+2−8

 	if (old_setting == setting)
 		return 0;
-	func_flags = vf->func_flags;
 	if (setting)
-		func_flags |= FUNC_CFG_REQ_FLAGS_SRC_MAC_ADDR_CHECK_ENABLE;
+		func_flags = FUNC_CFG_REQ_FLAGS_SRC_MAC_ADDR_CHECK_ENABLE;
 	else
-		func_flags |= FUNC_CFG_REQ_FLAGS_SRC_MAC_ADDR_CHECK_DISABLE;
+		func_flags = FUNC_CFG_REQ_FLAGS_SRC_MAC_ADDR_CHECK_DISABLE;
 	/*TODO: if the driver supports VLAN filter on guest VLAN,
 	 * the spoof check should also include vlan anti-spoofing
 	 */
 	req.flags = cpu_to_le32(func_flags);
 	rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
 	if (!rc) {
-		vf->func_flags = func_flags;
 		if (setting)
 			vf->flags |= BNXT_VF_SPOOFCHK;
 		else
 	memcpy(vf->mac_addr, mac, ETH_ALEN);
 	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1);
 	req.fid = cpu_to_le16(vf->fw_fid);
-	req.flags = cpu_to_le32(vf->func_flags);
 	req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_DFLT_MAC_ADDR);
 	memcpy(req.dflt_mac_addr, mac, ETH_ALEN);
 	return hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
 	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1);
 	req.fid = cpu_to_le16(vf->fw_fid);
-	req.flags = cpu_to_le32(vf->func_flags);
 	req.dflt_vlan = cpu_to_le16(vlan_tag);
 	req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_DFLT_VLAN);
 	rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
 		return 0;
 	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1);
 	req.fid = cpu_to_le16(vf->fw_fid);
-	req.flags = cpu_to_le32(vf->func_flags);
 	req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_MAX_BW);
 	req.max_bw = cpu_to_le32(max_tx_rate);
 	req.enables |= cpu_to_le32(FUNC_CFG_REQ_ENABLES_MIN_BW);
 	vf = &bp->pf.vf[vf_id];
 	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1);
 	req.fid = cpu_to_le16(vf->fw_fid);
-	req.flags = cpu_to_le32(vf->func_flags);
 	if (is_valid_ether_addr(vf->mac_addr)) {
 		req.enables |= cpu_to_le32(FUNC_CFG_REQ_ENABLES_DFLT_MAC_ADDR);

drivers/net/ethernet/cadence/Kconfig+1−1

 config MACB_USE_HWSTAMP
 	bool "Use IEEE 1588 hwstamp"
 	depends on MACB
+	depends on PTP_1588_CLOCK
 	default y
-	imply PTP_1588_CLOCK
 	---help---
 	  Enable IEEE 1588 Precision Time Protocol (PTP) support for MACB.

drivers/net/ethernet/cadence/macb_main.c+12−12

@@ -334,8 +334,10 @@ static int macb_mdio_read(struct mii_bus *bus, int mii_id, int regnum) · 333 unmodified lines
334	int status;	334	int status;
335		335
336	status = pm_runtime_get_sync(&bp->pdev->dev);	336	status = pm_runtime_get_sync(&bp->pdev->dev);
337	if (status < 0)	337	if (status < 0) {
		338	pm_runtime_put_noidle(&bp->pdev->dev);
338	goto mdio_pm_exit;	339	goto mdio_pm_exit;
		340	}
339		341
340	status = macb_mdio_wait_for_idle(bp);	342	status = macb_mdio_wait_for_idle(bp);
341	if (status < 0)	343	if (status < 0)
@@ -386,8 +388,10 @@ static int macb_mdio_write(struct mii_bus *bus, int mii_id, int regnum, · 44 unmodified lines
386	int status;	388	int status;
387		389
388	status = pm_runtime_get_sync(&bp->pdev->dev);	390	status = pm_runtime_get_sync(&bp->pdev->dev);
389	if (status < 0)	391	if (status < 0) {
		392	pm_runtime_put_noidle(&bp->pdev->dev);
390	goto mdio_pm_exit;	393	goto mdio_pm_exit;
		394	}
391		395
392	status = macb_mdio_wait_for_idle(bp);	396	status = macb_mdio_wait_for_idle(bp);
393	if (status < 0)	397	if (status < 0)
@@ -3816,8 +3820,10 @@ static int at91ether_open(struct net_device *dev) · 3422 unmodified lines
3816	int ret;	3820	int ret;
3817		3821
3818	ret = pm_runtime_get_sync(&lp->pdev->dev);	3822	ret = pm_runtime_get_sync(&lp->pdev->dev);
3819	if (ret < 0)	3823	if (ret < 0) {
		3824	pm_runtime_put_noidle(&lp->pdev->dev);
3820	return ret;	3825	return ret;
		3826	}
3821		3827
3822	/* Clear internal statistics */	3828	/* Clear internal statistics */
3823	ctl = macb_readl(lp, NCR);	3829	ctl = macb_readl(lp, NCR);
@@ -4172,15 +4178,9 @@ static int fu540_c000_clk_init(struct platform_device pdev, struct clk *pclk, · 348 unmodified lines
4172		4178
4173	static int fu540_c000_init(struct platform_device *pdev)	4179	static int fu540_c000_init(struct platform_device *pdev)
4174	{	4180	{
4175	struct resource *res;	4181	mgmt->reg = devm_platform_ioremap_resource(pdev, 1);
4176		4182	if (IS_ERR(mgmt->reg))
4177	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);	4183	return PTR_ERR(mgmt->reg);
4178	if (!res)
4179	return -ENODEV;
4180
4181	mgmt->reg = ioremap(res->start, resource_size(res));
4182	if (!mgmt->reg)
4183	return -ENOMEM;
4184		4184
4185	return macb_init(pdev);	4185	return macb_init(pdev);
4186	}	4186	}

drivers/net/ethernet/cavium/Kconfig+1−1

@@ -54,7 +54,7 @@ config THUNDER_NIC_RGX · 53 unmodified lines
54	config CAVIUM_PTP	54	config CAVIUM_PTP
55	tristate "Cavium PTP coprocessor as PTP clock"	55	tristate "Cavium PTP coprocessor as PTP clock"
56	depends on 64BIT && PCI	56	depends on 64BIT && PCI
57	imply PTP_1588_CLOCK	57	depends on PTP_1588_CLOCK
58	---help---	58	---help---
59	This driver adds support for the Precision Time Protocol Clocks and	59	This driver adds support for the Precision Time Protocol Clocks and
60	Timestamping coprocessor (PTP) found on Cavium processors.	60	Timestamping coprocessor (PTP) found on Cavium processors.

drivers/net/ethernet/chelsio/cxgb4/sge.c+37−3

@@ -2207,6 +2207,9 @@ static void ethofld_hard_xmit(struct net_device *dev, · 2206 unmodified lines
2207	if (unlikely(skip_eotx_wr)) {	2207	if (unlikely(skip_eotx_wr)) {
2208	start = (u64 *)wr;	2208	start = (u64 *)wr;
2209	eosw_txq->state = next_state;	2209	eosw_txq->state = next_state;
		2210	eosw_txq->cred -= wrlen16;
		2211	eosw_txq->ncompl++;
		2212	eosw_txq->last_compl = 0;
2210	goto write_wr_headers;	2213	goto write_wr_headers;
2211	}	2214	}
2212		2215
@@ -2365,6 +2368,34 @@ netdev_tx_t t4_start_xmit(struct sk_buff skb, struct net_device dev) · 152 unmodified lines
2365	return cxgb4_eth_xmit(skb, dev);	2368	return cxgb4_eth_xmit(skb, dev);
2366	}	2369	}
2367		2370
		2371	static void eosw_txq_flush_pending_skbs(struct sge_eosw_txq *eosw_txq)
		2372	{
		2373	int pktcount = eosw_txq->pidx - eosw_txq->last_pidx;
		2374	int pidx = eosw_txq->pidx;
		2375	struct sk_buff *skb;
		2376
		2377	if (!pktcount)
		2378	return;
		2379
		2380	if (pktcount < 0)
		2381	pktcount += eosw_txq->ndesc;
		2382
		2383	while (pktcount--) {
		2384	pidx--;
		2385	if (pidx < 0)
		2386	pidx += eosw_txq->ndesc;
		2387
		2388	skb = eosw_txq->desc[pidx].skb;
		2389	if (skb) {
		2390	dev_consume_skb_any(skb);
		2391	eosw_txq->desc[pidx].skb = NULL;
		2392	eosw_txq->inuse--;
		2393	}
		2394	}
		2395
		2396	eosw_txq->pidx = eosw_txq->last_pidx + 1;
		2397	}
		2398
2368	/**	2399	/**
2369	* cxgb4_ethofld_send_flowc - Send ETHOFLD flowc request to bind eotid to tc.	2400	* cxgb4_ethofld_send_flowc - Send ETHOFLD flowc request to bind eotid to tc.
2370	* @dev - netdevice	2401	* @dev - netdevice
@@ -2440,9 +2471,11 @@ int cxgb4_ethofld_send_flowc(struct net_device *dev, u32 eotid, u32 tc) · 69 unmodified lines
2440	FW_FLOWC_MNEM_EOSTATE_CLOSING :	2471	FW_FLOWC_MNEM_EOSTATE_CLOSING :
2441	FW_FLOWC_MNEM_EOSTATE_ESTABLISHED);	2472	FW_FLOWC_MNEM_EOSTATE_ESTABLISHED);
2442		2473
2443	eosw_txq->cred -= len16;	2474	/* Free up any pending skbs to ensure there's room for
2444	eosw_txq->ncompl++;	2475	* termination FLOWC.
2445	eosw_txq->last_compl = 0;	2476	*/
		2477	if (tc == FW_SCHED_CLS_NONE)
		2478	eosw_txq_flush_pending_skbs(eosw_txq);
2446		2479
2447	ret = eosw_txq_enqueue(eosw_txq, skb);	2480	ret = eosw_txq_enqueue(eosw_txq, skb);
2448	if (ret) {	2481	if (ret) {
@@ -2695,6 +2728,7 @@ static void ofldtxq_stop(struct sge_uld_txq q, struct fw_wr_hdr wr) · 246 unmodified lines
2695	* is ever running at a time ...	2728	* is ever running at a time ...
2696	*/	2729	*/
2697	static void service_ofldq(struct sge_uld_txq *q)	2730	static void service_ofldq(struct sge_uld_txq *q)
		2731	__must_hold(&q->sendq.lock)
2698	{	2732	{
2699	u64 pos, before, *end;	2733	u64 pos, before, *end;
2700	int credits;	2734	int credits;

drivers/net/ethernet/freescale/enetc/enetc_pci_mdio.c+1−1

 	pci_disable_device(pdev);
 err_pci_enable:
 err_mdiobus_alloc:
-	iounmap(port_regs);
 err_hw_alloc:
+	iounmap(port_regs);
 err_ioremap:
 	return err;
 }

drivers/net/ethernet/ibm/ibmvnic.c+2−1

 				rc = do_hard_reset(adapter, rwi, reset_state);
 				rtnl_unlock();
 			}
-		} else {
+		} else if (!(rwi->reset_reason == VNIC_RESET_FATAL &&
+				adapter->from_passive_init)) {
 			rc = do_reset(adapter, rwi, reset_state);
 		}
 		kfree(rwi);

drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c+3−0

@@ -1428,6 +1428,9 @@ int mvpp2_ethtool_cls_rule_del(struct mvpp2_port *port, · 1427 unmodified lines
1428	struct mvpp2_ethtool_fs *efs;	1428	struct mvpp2_ethtool_fs *efs;
1429	int ret;	1429	int ret;
1430		1430
		1431	if (info->fs.location >= MVPP2_N_RFS_ENTRIES_PER_FLOW)
		1432	return -EINVAL;
		1433
1431	efs = port->rfs_rules[info->fs.location];	1434	efs = port->rfs_rules[info->fs.location];
1432	if (!efs)	1435	if (!efs)
1433	return -EINVAL;	1436	return -EINVAL;

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c+2−0

@@ -4329,6 +4329,8 @@ static int mvpp2_ethtool_get_rxfh_context(struct net_device dev, u32 indir, · 4328 unmodified lines
4329		4329
4330	if (!mvpp22_rss_is_supported())	4330	if (!mvpp22_rss_is_supported())
4331	return -EOPNOTSUPP;	4331	return -EOPNOTSUPP;
		4332	if (rss_context >= MVPP22_N_RSS_TABLES)
		4333	return -EINVAL;
4332		4334
4333	if (hfunc)	4335	if (hfunc)
4334	*hfunc = ETH_RSS_HASH_CRC32;	4336	*hfunc = ETH_RSS_HASH_CRC32;

drivers/net/ethernet/mellanox/mlx4/main.c+3−1

@@ -2550,6 +2550,7 @@ static int mlx4_allocate_default_counters(struct mlx4_dev *dev) · 2549 unmodified lines
2550		2550
2551	if (!err \|\| err == -ENOSPC) {	2551	if (!err \|\| err == -ENOSPC) {
2552	priv->def_counter[port] = idx;	2552	priv->def_counter[port] = idx;
		2553	err = 0;
2553	} else if (err == -ENOENT) {	2554	} else if (err == -ENOENT) {
2554	err = 0;	2555	err = 0;
2555	continue;	2556	continue;
@@ -2600,7 +2601,8 @@ int mlx4_counter_alloc(struct mlx4_dev dev, u32 idx, u8 usage) · 44 unmodified lines
2600	MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);	2601	MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
2601	if (!err)	2602	if (!err)
2602	*idx = get_param_l(&out_param);	2603	*idx = get_param_l(&out_param);
2603		2604	if (WARN_ON(err == -ENOSPC))
		2605	err = -EINVAL;
2604	return err;	2606	return err;
2605	}	2607	}
2606	return __mlx4_counter_alloc(dev, idx);	2608	return __mlx4_counter_alloc(dev, idx);

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

 	}
 	cmd->ent_arr[ent->idx] = ent;
-	set_bit(MLX5_CMD_ENT_STATE_PENDING_COMP, &ent->state);
 	lay = get_inst(cmd, ent->idx);
 	ent->lay = lay;
 	memset(lay, 0, sizeof(*lay));
 	if (ent->callback)
 		schedule_delayed_work(&ent->cb_timeout_work, cb_timeout);
+	set_bit(MLX5_CMD_ENT_STATE_PENDING_COMP, &ent->state);
 	/* Skip sending command to fw if internal error */
 	if (pci_channel_offline(dev->pdev) ||
 		MLX5_SET(mbox_out, ent->out, syndrome, drv_synd);
 		mlx5_cmd_comp_handler(dev, 1UL << ent->idx, true);
+		/* no doorbell, no need to keep the entry */
+		free_ent(cmd, ent->idx);
+		if (ent->callback)
+			free_cmd(ent);
 		return;
 	}

drivers/net/ethernet/mellanox/mlx5/core/en_rep.c+2−7

 static int mlx5e_init_ul_rep_rx(struct mlx5e_priv *priv)
 {
-	int err = mlx5e_init_rep_rx(priv);
-	if (err)
-		return err;
 	mlx5e_create_q_counters(priv);
-	return 0;
+	return mlx5e_init_rep_rx(priv);
 }
 static void mlx5e_cleanup_ul_rep_rx(struct mlx5e_priv *priv)
 {
-	mlx5e_destroy_q_counters(priv);
 	mlx5e_cleanup_rep_rx(priv);
+	mlx5e_destroy_q_counters(priv);
 }
 static int mlx5e_init_uplink_rep_tx(struct mlx5e_rep_priv *rpriv)

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+9−9

@@ -1550,9 +1550,9 @@ static int esw_create_restore_table(struct mlx5_eswitch *esw) · 1549 unmodified lines
1550	MLX5_FLOW_NAMESPACE_KERNEL, 1,	1550	MLX5_FLOW_NAMESPACE_KERNEL, 1,
1551	modact);	1551	modact);
1552	if (IS_ERR(mod_hdr)) {	1552	if (IS_ERR(mod_hdr)) {
		1553	err = PTR_ERR(mod_hdr);
1553	esw_warn(dev, "Failed to create restore mod header, err: %d\n",	1554	esw_warn(dev, "Failed to create restore mod header, err: %d\n",
1554	err);	1555	err);
1555	err = PTR_ERR(mod_hdr);
1556	goto err_mod_hdr;	1556	goto err_mod_hdr;
1557	}	1557	}
1558		1558
@@ -2219,10 +2219,12 @@ static int esw_offloads_steering_init(struct mlx5_eswitch *esw) · 660 unmodified lines
2219	total_vports = num_vfs + MLX5_SPECIAL_VPORTS(esw->dev);	2219	total_vports = num_vfs + MLX5_SPECIAL_VPORTS(esw->dev);
2220		2220
2221	memset(&esw->fdb_table.offloads, 0, sizeof(struct offloads_fdb));	2221	memset(&esw->fdb_table.offloads, 0, sizeof(struct offloads_fdb));
		2222	mutex_init(&esw->fdb_table.offloads.vports.lock);
		2223	hash_init(esw->fdb_table.offloads.vports.table);
2222		2224
2223	err = esw_create_uplink_offloads_acl_tables(esw);	2225	err = esw_create_uplink_offloads_acl_tables(esw);
2224	if (err)	2226	if (err)
2225	return err;	2227	goto create_acl_err;
2226		2228
2227	err = esw_create_offloads_table(esw, total_vports);	2229	err = esw_create_offloads_table(esw, total_vports);
2228	if (err)	2230	if (err)
@@ -2240,9 +2242,6 @@ static int esw_offloads_steering_init(struct mlx5_eswitch *esw) · 11 unmodified lines
2240	if (err)	2242	if (err)
2241	goto create_fg_err;	2243	goto create_fg_err;
2242		2244
2243	mutex_init(&esw->fdb_table.offloads.vports.lock);
2244	hash_init(esw->fdb_table.offloads.vports.table);
2245
2246	return 0;	2245	return 0;
2247		2246
2248	create_fg_err:	2247	create_fg_err:
@@ -2253,18 +2252,19 @@ create_restore_err: · 4 unmodified lines
2253	esw_destroy_offloads_table(esw);	2252	esw_destroy_offloads_table(esw);
2254	create_offloads_err:	2253	create_offloads_err:
2255	esw_destroy_uplink_offloads_acl_tables(esw);	2254	esw_destroy_uplink_offloads_acl_tables(esw);
2256		2255	create_acl_err:
		2256	mutex_destroy(&esw->fdb_table.offloads.vports.lock);
2257	return err;	2257	return err;
2258	}	2258	}
2259		2259
2260	static void esw_offloads_steering_cleanup(struct mlx5_eswitch *esw)	2260	static void esw_offloads_steering_cleanup(struct mlx5_eswitch *esw)
2261	{	2261	{
2262	mutex_destroy(&esw->fdb_table.offloads.vports.lock);
2263	esw_destroy_vport_rx_group(esw);	2262	esw_destroy_vport_rx_group(esw);
2264	esw_destroy_offloads_fdb_tables(esw);	2263	esw_destroy_offloads_fdb_tables(esw);
2265	esw_destroy_restore_table(esw);	2264	esw_destroy_restore_table(esw);
2266	esw_destroy_offloads_table(esw);	2265	esw_destroy_offloads_table(esw);
2267	esw_destroy_uplink_offloads_acl_tables(esw);	2266	esw_destroy_uplink_offloads_acl_tables(esw);
		2267	mutex_destroy(&esw->fdb_table.offloads.vports.lock);
2268	}	2268	}
2269		2269
2270	static void	2270	static void
@@ -2377,9 +2377,9 @@ int esw_offloads_enable(struct mlx5_eswitch *esw) · 106 unmodified lines
2377	err_vports:	2377	err_vports:
2378	esw_offloads_unload_rep(esw, MLX5_VPORT_UPLINK);	2378	esw_offloads_unload_rep(esw, MLX5_VPORT_UPLINK);
2379	err_uplink:	2379	err_uplink:
2380	esw_set_passing_vport_metadata(esw, false);
2381	err_steering_init:
2382	esw_offloads_steering_cleanup(esw);	2380	esw_offloads_steering_cleanup(esw);
		2381	err_steering_init:
		2382	esw_set_passing_vport_metadata(esw, false);
2383	err_vport_metadata:	2383	err_vport_metadata:
2384	mlx5_rdma_disable_roce(esw->dev);	2384	mlx5_rdma_disable_roce(esw->dev);
2385	mutex_destroy(&esw->offloads.termtbl_mutex);	2385	mutex_destroy(&esw->offloads.termtbl_mutex);

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_send.c+13−1

@@ -695,6 +695,12 @@ static void dr_cq_event(struct mlx5_core_cq *mcq, · 694 unmodified lines
695	pr_info("CQ event %u on CQ #%u\n", event, mcq->cqn);	695	pr_info("CQ event %u on CQ #%u\n", event, mcq->cqn);
696	}	696	}
697		697
		698	static void dr_cq_complete(struct mlx5_core_cq *mcq,
		699	struct mlx5_eqe *eqe)
		700	{
		701	pr_err("CQ completion CQ: #%u\n", mcq->cqn);
		702	}
		703
698	static struct mlx5dr_cq dr_create_cq(struct mlx5_core_dev mdev,	704	static struct mlx5dr_cq dr_create_cq(struct mlx5_core_dev mdev,
699	struct mlx5_uars_page *uar,	705	struct mlx5_uars_page *uar,
700	size_t ncqe)	706	size_t ncqe)
@@ -756,6 +762,7 @@ static struct mlx5dr_cq dr_create_cq(struct mlx5_core_dev mdev, · 55 unmodified lines
756	mlx5_fill_page_frag_array(&cq->wq_ctrl.buf, pas);	762	mlx5_fill_page_frag_array(&cq->wq_ctrl.buf, pas);
757		763
758	cq->mcq.event = dr_cq_event;	764	cq->mcq.event = dr_cq_event;
		765	cq->mcq.comp = dr_cq_complete;
759		766
760	err = mlx5_core_create_cq(mdev, &cq->mcq, in, inlen, out, sizeof(out));	767	err = mlx5_core_create_cq(mdev, &cq->mcq, in, inlen, out, sizeof(out));
761	kvfree(in);	768	kvfree(in);
@@ -767,7 +774,12 @@ static struct mlx5dr_cq dr_create_cq(struct mlx5_core_dev mdev, · 5 unmodified lines
767	cq->mcq.set_ci_db = cq->wq_ctrl.db.db;	774	cq->mcq.set_ci_db = cq->wq_ctrl.db.db;
768	cq->mcq.arm_db = cq->wq_ctrl.db.db + 1;	775	cq->mcq.arm_db = cq->wq_ctrl.db.db + 1;
769	*cq->mcq.set_ci_db = 0;	776	*cq->mcq.set_ci_db = 0;
770	*cq->mcq.arm_db = 0;	777
		778	/* set no-zero value, in order to avoid the HW to run db-recovery on
		779	* CQ that used in polling mode.
		780	*/
		781	*cq->mcq.arm_db = cpu_to_be32(2 << 28);
		782
771	cq->mcq.vector = 0;	783	cq->mcq.vector = 0;
772	cq->mcq.irqn = irqn;	784	cq->mcq.irqn = irqn;
773	cq->mcq.uar = uar;	785	cq->mcq.uar = uar;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c+10−2

@@ -986,8 +986,9 @@ mlxsw_sp_acl_tcam_vchunk_create(struct mlxsw_sp *mlxsw_sp, · 985 unmodified lines
986	unsigned int priority,	986	unsigned int priority,
987	struct mlxsw_afk_element_usage *elusage)	987	struct mlxsw_afk_element_usage *elusage)
988	{	988	{
		989	struct mlxsw_sp_acl_tcam_vchunk vchunk, vchunk2;
989	struct mlxsw_sp_acl_tcam_vregion *vregion;	990	struct mlxsw_sp_acl_tcam_vregion *vregion;
990	struct mlxsw_sp_acl_tcam_vchunk *vchunk;	991	struct list_head *pos;
991	int err;	992	int err;
992		993
993	if (priority == MLXSW_SP_ACL_TCAM_CATCHALL_PRIO)	994	if (priority == MLXSW_SP_ACL_TCAM_CATCHALL_PRIO)
@@ -1025,7 +1026,14 @@ mlxsw_sp_acl_tcam_vchunk_create(struct mlxsw_sp *mlxsw_sp, · 31 unmodified lines
1025	}	1026	}
1026		1027
1027	mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed(vregion);	1028	mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed(vregion);
1028	list_add_tail(&vchunk->list, &vregion->vchunk_list);	1029
		1030	/* Position the vchunk inside the list according to priority */
		1031	list_for_each(pos, &vregion->vchunk_list) {
		1032	vchunk2 = list_entry(pos, typeof(*vchunk2), list);
		1033	if (vchunk2->priority > priority)
		1034	break;
		1035	}
		1036	list_add_tail(&vchunk->list, pos);
1029	mutex_unlock(&vregion->lock);	1037	mutex_unlock(&vregion->lock);
1030		1038
1031	return vchunk;	1039	return vchunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c+2−1

 		err = mlxsw_sp_acl_rulei_act_count(mlxsw_sp, rulei, extack);
 		if (err)
 			return err;
-	} else if (act->hw_stats != FLOW_ACTION_HW_STATS_DISABLED) {
+	} else if (act->hw_stats != FLOW_ACTION_HW_STATS_DISABLED &&
+		   act->hw_stats != FLOW_ACTION_HW_STATS_DONT_CARE) {
 		NL_SET_ERR_MSG_MOD(extack, "Unsupported action HW stats type");
 		return -EOPNOTSUPP;
 	}

drivers/net/ethernet/moxa/moxart_ether.c+1−1

@@ -564,7 +564,7 @@ static int moxart_remove(struct platform_device *pdev) · 563 unmodified lines
564	struct net_device *ndev = platform_get_drvdata(pdev);	564	struct net_device *ndev = platform_get_drvdata(pdev);
565		565
566	unregister_netdev(ndev);	566	unregister_netdev(ndev);
567	free_irq(ndev->irq, ndev);	567	devm_free_irq(&pdev->dev, ndev->irq, ndev);
568	moxart_mac_free_memory(ndev);	568	moxart_mac_free_memory(ndev);
569	free_netdev(ndev);	569	free_netdev(ndev);
570		570

drivers/net/ethernet/mscc/ocelot.c+11−6

@@ -1031,10 +1031,8 @@ int ocelot_fdb_dump(struct ocelot *ocelot, int port, · 1030 unmodified lines
1031	{	1031	{
1032	int i, j;	1032	int i, j;
1033		1033
1034	/* Loop through all the mac tables entries. There are 1024 rows of 4	1034	/* Loop through all the mac tables entries. */
1035	* entries.	1035	for (i = 0; i < ocelot->num_mact_rows; i++) {
1036	*/
1037	for (i = 0; i < 1024; i++) {
1038	for (j = 0; j < 4; j++) {	1036	for (j = 0; j < 4; j++) {
1039	struct ocelot_mact_entry entry;	1037	struct ocelot_mact_entry entry;
1040	bool is_static;	1038	bool is_static;
@@ -1453,8 +1451,15 @@ static void ocelot_port_attr_stp_state_set(struct ocelot *ocelot, int port, · 412 unmodified lines
1453		1451
1454	void ocelot_set_ageing_time(struct ocelot *ocelot, unsigned int msecs)	1452	void ocelot_set_ageing_time(struct ocelot *ocelot, unsigned int msecs)
1455	{	1453	{
1456	ocelot_write(ocelot, ANA_AUTOAGE_AGE_PERIOD(msecs / 2),	1454	unsigned int age_period = ANA_AUTOAGE_AGE_PERIOD(msecs / 2000);
1457	ANA_AUTOAGE);	1455
		1456	/* Setting AGE_PERIOD to zero effectively disables automatic aging,
		1457	* which is clearly not what our intention is. So avoid that.
		1458	*/
		1459	if (!age_period)
		1460	age_period = 1;
		1461
		1462	ocelot_rmw(ocelot, age_period, ANA_AUTOAGE_AGE_PERIOD_M, ANA_AUTOAGE);
1458	}	1463	}
1459	EXPORT_SYMBOL(ocelot_set_ageing_time);	1464	EXPORT_SYMBOL(ocelot_set_ageing_time);
1460		1465

drivers/net/ethernet/mscc/ocelot_regs.c+1−0

@@ -431,6 +431,7 @@ int ocelot_chip_init(struct ocelot ocelot, const struct ocelot_ops ops) · 430 unmodified lines
431	ocelot->stats_layout = ocelot_stats_layout;	431	ocelot->stats_layout = ocelot_stats_layout;
432	ocelot->num_stats = ARRAY_SIZE(ocelot_stats_layout);	432	ocelot->num_stats = ARRAY_SIZE(ocelot_stats_layout);
433	ocelot->shared_queue_sz = 224 * 1024;	433	ocelot->shared_queue_sz = 224 * 1024;
		434	ocelot->num_mact_rows = 1024;
434	ocelot->ops = ops;	435	ocelot->ops = ops;
435		436
436	ret = ocelot_regfields_init(ocelot, ocelot_regfields);	437	ret = ocelot_regfields_init(ocelot, ocelot_regfields);

drivers/net/ethernet/natsemi/jazzsonic.c+4−2

 	err = register_netdev(dev);
 	if (err)
-		goto out1;
+		goto undo_probe1;
 	return 0;
-out1:
+undo_probe1:
+	dma_free_coherent(lp->device, SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
+			  lp->descriptors, lp->descriptors_laddr);
 	release_mem_region(dev->base_addr, SONIC_MEM_SIZE);
 out:
 	free_netdev(dev);

drivers/net/ethernet/netronome/nfp/abm/main.c+1−0

@@ -283,6 +283,7 @@ nfp_abm_vnic_set_mac(struct nfp_pf pf, struct nfp_abm abm, struct nfp_net *nn, · 282 unmodified lines
283	if (!nfp_nsp_has_hwinfo_lookup(nsp)) {	283	if (!nfp_nsp_has_hwinfo_lookup(nsp)) {
284	nfp_warn(pf->cpp, "NSP doesn't support PF MAC generation\n");	284	nfp_warn(pf->cpp, "NSP doesn't support PF MAC generation\n");
285	eth_hw_addr_random(nn->dp.netdev);	285	eth_hw_addr_random(nn->dp.netdev);
		286	nfp_nsp_close(nsp);
286	return;	287	return;
287	}	288	}
288		289

drivers/net/ethernet/pensando/ionic/ionic_debugfs.c+1−2

@@ -170,8 +170,7 @@ void ionic_debugfs_add_qcq(struct ionic_lif lif, struct ionic_qcq qcq) · 169 unmodified lines
170	debugfs_create_x64("base_pa", 0400, cq_dentry, &cq->base_pa);	170	debugfs_create_x64("base_pa", 0400, cq_dentry, &cq->base_pa);
171	debugfs_create_u32("num_descs", 0400, cq_dentry, &cq->num_descs);	171	debugfs_create_u32("num_descs", 0400, cq_dentry, &cq->num_descs);
172	debugfs_create_u32("desc_size", 0400, cq_dentry, &cq->desc_size);	172	debugfs_create_u32("desc_size", 0400, cq_dentry, &cq->desc_size);
173	debugfs_create_u8("done_color", 0400, cq_dentry,	173	debugfs_create_bool("done_color", 0400, cq_dentry, &cq->done_color);
174	(u8 *)&cq->done_color);
175		174
176	debugfs_create_file("tail", 0400, cq_dentry, cq, &cq_tail_fops);	175	debugfs_create_file("tail", 0400, cq_dentry, cq, &cq_tail_fops);
177		176

drivers/net/ethernet/pensando/ionic/ionic_lif.c+2−2

 		ionic_txrx_free(lif);
 	}
 	ionic_lifs_deinit(ionic);
+	ionic_reset(ionic);
 	ionic_qcqs_free(lif);
 	dev_info(ionic->dev, "FW Down: LIFs stopped\n");
 	dev_info(ionic->dev, "FW Up: restarting LIFs\n");
+	ionic_init_devinfo(ionic);
 	err = ionic_qcqs_alloc(lif);
 	if (err)
 		goto err_out;
 		dev_err(ionic->dev, "Cannot register net device, aborting\n");
 		return err;
 	}
-	ionic_link_status_check_request(ionic->master_lif);
 	ionic->master_lif->registered = true;
 	return 0;

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

@@ -624,7 +624,7 @@ int dwmac5_est_configure(void __iomem ioaddr, struct stmmac_est cfg, · 623 unmodified lines
624	total_offset += offset;	624	total_offset += offset;
625	}	625	}
626		626
627	total_ctr = cfg->ctr[0] + cfg->ctr[1] * 1000000000;	627	total_ctr = cfg->ctr[0] + cfg->ctr[1] * 1000000000ULL;
628	total_ctr += total_offset;	628	total_ctr += total_offset;
629		629
630	ctr_low = do_div(total_ctr, 1000000000);	630	ctr_low = do_div(total_ctr, 1000000000);

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

 /**
  *  stmmac_interrupt - main ISR
  *  @irq: interrupt number.
- *  @dev_id: to pass the net device pointer.
+ *  @dev_id: to pass the net device pointer (must be valid).
  *  Description: this is the main driver interrupt service routine.
  *  It can call:
  *  o DMA service routine (to manage incoming frame reception and transmission
 	if (priv->irq_wake)
 		pm_wakeup_event(priv->device, 0);
-	if (unlikely(!dev)) {
-		netdev_err(priv->dev, "%s: invalid dev pointer\n", __func__);
-		return IRQ_NONE;
-	}
 	/* Check if adapter is up */
 	if (test_bit(STMMAC_DOWN, &priv->state))
 		return IRQ_HANDLED;
 						 priv->plat->bsp_priv);
 		if (ret < 0)
-			return ret;
+			goto error_serdes_powerup;
 	}
 #ifdef CONFIG_DEBUG_FS
 	return ret;
+error_serdes_powerup:
+	unregister_netdev(ndev);
 error_netdev_register:
 	phylink_destroy(priv->phylink);
 error_phy_setup:

drivers/net/ethernet/ti/Kconfig+1−2

 config TI_CPTS_MOD
 	tristate
 	depends on TI_CPTS
+	depends on PTP_1588_CLOCK
 	default y if TI_CPSW=y || TI_KEYSTONE_NETCP=y || TI_CPSW_SWITCHDEV=y
-	select NET_PTP_CLASSIFY
-	imply PTP_1588_CLOCK
 	default m
 config TI_K3_AM65_CPSW_NUSS

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

 		ret = devm_request_irq(dev, tx_chn->irq,
 				       am65_cpsw_nuss_tx_irq,
-				       0, tx_chn->tx_chn_name, tx_chn);
+				       IRQF_TRIGGER_HIGH,
+				       tx_chn->tx_chn_name, tx_chn);
 		if (ret) {
 			dev_err(dev, "failure requesting tx%u irq %u, %d\n",
 				tx_chn->id, tx_chn->irq, ret);
 	ret = devm_request_irq(dev, common->rx_chns.irq,
 			       am65_cpsw_nuss_rx_irq,
-			       0, dev_name(dev), common);
+			       IRQF_TRIGGER_HIGH, dev_name(dev), common);
 	if (ret) {
 		dev_err(dev, "failure requesting rx irq %u, %d\n",
 			common->rx_chns.irq, ret);

drivers/net/ethernet/toshiba/tc35815.c+1−1

@@ -643,7 +643,7 @@ static int tc_mii_probe(struct net_device *dev) · 642 unmodified lines
643	linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, mask);	643	linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, mask);
644	linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, mask);	644	linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, mask);
645	}	645	}
646	linkmode_and(phydev->supported, phydev->supported, mask);	646	linkmode_andnot(phydev->supported, phydev->supported, mask);
647	linkmode_copy(phydev->advertising, phydev->supported);	647	linkmode_copy(phydev->advertising, phydev->supported);
648		648
649	lp->link = 0;	649	lp->link = 0;

drivers/net/gtp.c+5−4

 static struct genl_family gtp_genl_family;
 static int gtp_genl_fill_info(struct sk_buff *skb, u32 snd_portid, u32 snd_seq,
-			      u32 type, struct pdp_ctx *pctx)
+			      int flags, u32 type, struct pdp_ctx *pctx)
 {
 	void *genlh;
-	genlh = genlmsg_put(skb, snd_portid, snd_seq, &gtp_genl_family, 0,
+	genlh = genlmsg_put(skb, snd_portid, snd_seq, &gtp_genl_family, flags,
 			    type);
 	if (genlh == NULL)
 		goto nlmsg_failure;
 		goto err_unlock;
 	}
-	err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid,
+	err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid, info->snd_seq,
-				 info->snd_seq, info->nlhdr->nlmsg_type, pctx);
+				 0, info->nlhdr->nlmsg_type, pctx);
 	if (err < 0)
 		goto err_unlock_free;
 				    gtp_genl_fill_info(skb,
 					    NETLINK_CB(cb->skb).portid,
 					    cb->nlh->nlmsg_seq,
+					    NLM_F_MULTI,
 					    cb->nlh->nlmsg_type, pctx)) {
 					cb->args[0] = i;
 					cb->args[1] = j;

drivers/net/hyperv/netvsc_drv.c+2−1

@@ -707,7 +707,8 @@ no_memory: · 706 unmodified lines
707	goto drop;	707	goto drop;
708	}	708	}
709		709
710	static int netvsc_start_xmit(struct sk_buff skb, struct net_device ndev)	710	static netdev_tx_t netvsc_start_xmit(struct sk_buff *skb,
		711	struct net_device *ndev)
711	{	712	{
712	return netvsc_xmit(skb, ndev, false);	713	return netvsc_xmit(skb, ndev, false);
713	}	714	}

drivers/net/ipa/gsi.c+9−2

 	complete(&gsi->completion);
 }
 /* Inter-EE interrupt handler */
 static void gsi_isr_glob_ee(struct gsi *gsi)
 {
 	struct completion *completion = &gsi->completion;
 	u32 val;
+	/* First zero the result code field */
+	val = ioread32(gsi->virt + GSI_CNTXT_SCRATCH_0_OFFSET);
+	val &= ~GENERIC_EE_RESULT_FMASK;
+	iowrite32(val, gsi->virt + GSI_CNTXT_SCRATCH_0_OFFSET);
+	/* Now issue the command */
 	val = u32_encode_bits(opcode, GENERIC_OPCODE_FMASK);
 	val |= u32_encode_bits(channel_id, GENERIC_CHID_FMASK);
 	val |= u32_encode_bits(GSI_EE_MODEM, GENERIC_EE_FMASK);
 	/* Worst case we need an event for every outstanding TRE */
 	if (data->channel.tre_count > data->channel.event_count) {
-		dev_warn(gsi->dev, "channel %u limited to %u TREs\n",
-			data->channel_id, data->channel.tre_count);
 		tre_count = data->channel.event_count;
+		dev_warn(gsi->dev, "channel %u limited to %u TREs\n",
+			 data->channel_id, tre_count);
 	} else {
 		tre_count = data->channel.tre_count;
 	}

drivers/net/ipa/gsi_reg.h+2−0

 #define INTER_EE_RESULT_FMASK		GENMASK(2, 0)
 #define GENERIC_EE_RESULT_FMASK		GENMASK(7, 5)
 #define GENERIC_EE_SUCCESS_FVAL			1
+#define GENERIC_EE_INCORRECT_DIRECTION_FVAL	3
+#define GENERIC_EE_INCORRECT_CHANNEL_FVAL	5
 #define GENERIC_EE_NO_RESOURCES_FVAL		7
 #define USB_MAX_PACKET_FMASK		GENMASK(15, 15)	/* 0: HS; 1: SS */
 #define MHI_BASE_CHANNEL_FMASK		GENMASK(31, 24)

drivers/net/ipa/ipa_endpoint.c+2−5

  */
 int ipa_endpoint_stop(struct ipa_endpoint *endpoint)
 {
-	u32 retries = endpoint->toward_ipa ? 0 : IPA_ENDPOINT_STOP_RX_RETRIES;
+	u32 retries = IPA_ENDPOINT_STOP_RX_RETRIES;
 	int ret;
 	do {
 		struct gsi *gsi = &ipa->gsi;
 		ret = gsi_channel_stop(gsi, endpoint->channel_id);
-		if (ret != -EAGAIN)
+		if (ret != -EAGAIN || endpoint->toward_ipa)
 			break;
-		if (endpoint->toward_ipa)
-			continue;
 		/* For IPA v3.5.1, send a DMA read task and check again */
 		if (ipa->version == IPA_VERSION_3_5_1) {
 			ret = ipa_endpoint_stop_rx_dma(ipa);

drivers/net/macsec.c+4−2

 	struct crypto_aead *tfm;
 	int ret;
-	tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
+	/* Pick a sync gcm(aes) cipher to ensure order is preserved. */
+	tfm = crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC);
 	if (IS_ERR(tfm))
 		return tfm;
 	if (ret)
 		goto rollback;
-	rtnl_unlock();
 	/* Force features update, since they are different for SW MACSec and
 	 * HW offloading cases.
 	 */
 	netdev_update_features(dev);
+	rtnl_unlock();
 	return 0;
 rollback:

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

@@ -1120,7 +1120,7 @@ static struct dp83640_clock dp83640_clock_get_bus(struct mii_bus bus) · 1119 unmodified lines
1120	goto out;	1120	goto out;
1121	}	1121	}
1122	dp83640_clock_init(clock, bus);	1122	dp83640_clock_init(clock, bus);
1123	list_add_tail(&phyter_clocks, &clock->list);	1123	list_add_tail(&clock->list, &phyter_clocks);
1124	out:	1124	out:
1125	mutex_unlock(&phyter_clocks_lock);	1125	mutex_unlock(&phyter_clocks_lock);
1126		1126

drivers/net/phy/dp83822.c+14−16

@@ -137,19 +137,18 @@ static int dp83822_set_wol(struct phy_device *phydev, · 136 unmodified lines
137	value &= ~DP83822_WOL_SECURE_ON;	137	value &= ~DP83822_WOL_SECURE_ON;
138	}	138	}
139		139
140	value \|= (DP83822_WOL_EN \| DP83822_WOL_INDICATION_SEL \|	140	/* Clear any pending WoL interrupt */
141	DP83822_WOL_CLR_INDICATION);	141	phy_read(phydev, MII_DP83822_MISR2);
142	phy_write_mmd(phydev, DP83822_DEVADDR, MII_DP83822_WOL_CFG,	142
143	value);	143	value \|= DP83822_WOL_EN \| DP83822_WOL_INDICATION_SEL \|
		144	DP83822_WOL_CLR_INDICATION;
		145
		146	return phy_write_mmd(phydev, DP83822_DEVADDR,
		147	MII_DP83822_WOL_CFG, value);
144	} else {	148	} else {
145	value = phy_read_mmd(phydev, DP83822_DEVADDR,	149	return phy_clear_bits_mmd(phydev, DP83822_DEVADDR,
146	MII_DP83822_WOL_CFG);	150	MII_DP83822_WOL_CFG, DP83822_WOL_EN);
147	value &= ~DP83822_WOL_EN;
148	phy_write_mmd(phydev, DP83822_DEVADDR, MII_DP83822_WOL_CFG,
149	value);
150	}	151	}
151
152	return 0;
153	}	152	}
154		153
155	static void dp83822_get_wol(struct phy_device *phydev,	154	static void dp83822_get_wol(struct phy_device *phydev,
@@ -258,12 +257,11 @@ static int dp83822_config_intr(struct phy_device *phydev) · 102 unmodified lines
258		257
259	static int dp83822_config_init(struct phy_device *phydev)	258	static int dp83822_config_init(struct phy_device *phydev)
260	{	259	{
261	int value;	260	int value = DP83822_WOL_EN \| DP83822_WOL_MAGIC_EN \|
262		261	DP83822_WOL_SECURE_ON;
263	value = DP83822_WOL_MAGIC_EN \| DP83822_WOL_SECURE_ON \| DP83822_WOL_EN;
264		262
265	return phy_write_mmd(phydev, DP83822_DEVADDR, MII_DP83822_WOL_CFG,	263	return phy_clear_bits_mmd(phydev, DP83822_DEVADDR,
266	value);	264	MII_DP83822_WOL_CFG, value);
267	}	265	}
268		266
269	static int dp83822_phy_reset(struct phy_device *phydev)	267	static int dp83822_phy_reset(struct phy_device *phydev)

drivers/net/phy/dp83tc811.c+12−9

@@ -139,16 +139,19 @@ static int dp83811_set_wol(struct phy_device *phydev, · 138 unmodified lines
139	value &= ~DP83811_WOL_SECURE_ON;	139	value &= ~DP83811_WOL_SECURE_ON;
140	}	140	}
141		141
142	value \|= (DP83811_WOL_EN \| DP83811_WOL_INDICATION_SEL \|	142	/* Clear any pending WoL interrupt */
143	DP83811_WOL_CLR_INDICATION);	143	phy_read(phydev, MII_DP83811_INT_STAT1);
144	phy_write_mmd(phydev, DP83811_DEVADDR, MII_DP83811_WOL_CFG,	144
145	value);	145	value \|= DP83811_WOL_EN \| DP83811_WOL_INDICATION_SEL \|
		146	DP83811_WOL_CLR_INDICATION;
		147
		148	return phy_write_mmd(phydev, DP83811_DEVADDR,
		149	MII_DP83811_WOL_CFG, value);
146	} else {	150	} else {
147	phy_clear_bits_mmd(phydev, DP83811_DEVADDR, MII_DP83811_WOL_CFG,	151	return phy_clear_bits_mmd(phydev, DP83811_DEVADDR,
148	DP83811_WOL_EN);	152	MII_DP83811_WOL_CFG, DP83811_WOL_EN);
149	}	153	}
150		154
151	return 0;
152	}	155	}
153		156
154	static void dp83811_get_wol(struct phy_device *phydev,	157	static void dp83811_get_wol(struct phy_device *phydev,
@@ -292,8 +295,8 @@ static int dp83811_config_init(struct phy_device *phydev) · 137 unmodified lines
292		295
293	value = DP83811_WOL_MAGIC_EN \| DP83811_WOL_SECURE_ON \| DP83811_WOL_EN;	296	value = DP83811_WOL_MAGIC_EN \| DP83811_WOL_SECURE_ON \| DP83811_WOL_EN;
294		297
295	return phy_write_mmd(phydev, DP83811_DEVADDR, MII_DP83811_WOL_CFG,	298	return phy_clear_bits_mmd(phydev, DP83811_DEVADDR, MII_DP83811_WOL_CFG,
296	value);	299	value);
297	}	300	}
298		301
299	static int dp83811_phy_reset(struct phy_device *phydev)	302	static int dp83811_phy_reset(struct phy_device *phydev)

drivers/net/phy/marvell10g.c+26−1

 	MV_PCS_CSSR1_SPD2_2500	= 0x0004,
 	MV_PCS_CSSR1_SPD2_10000	= 0x0000,
+	/* Temperature read register (88E2110 only) */
+	MV_PCS_TEMP		= 0x8042,
 	/* These registers appear at 0x800X and 0xa00X - the 0xa00X control
 	 * registers appear to set themselves to the 0x800X when AN is
 	 * restarted, but status registers appear readable from either.
 	MV_V2_PORT_CTRL		= 0xf001,
 	MV_V2_PORT_CTRL_SWRST	= BIT(15),
 	MV_V2_PORT_CTRL_PWRDOWN = BIT(11),
+	/* Temperature control/read registers (88X3310 only) */
 	MV_V2_TEMP_CTRL		= 0xf08a,
 	MV_V2_TEMP_CTRL_MASK	= 0xc000,
 	MV_V2_TEMP_CTRL_SAMPLE	= 0x0000,
 	return 0;
 }
+static int mv3310_hwmon_read_temp_reg(struct phy_device *phydev)
+{
+	return phy_read_mmd(phydev, MDIO_MMD_VEND2, MV_V2_TEMP);
+}
+static int mv2110_hwmon_read_temp_reg(struct phy_device *phydev)
+{
+	return phy_read_mmd(phydev, MDIO_MMD_PCS, MV_PCS_TEMP);
+}
+static int mv10g_hwmon_read_temp_reg(struct phy_device *phydev)
+{
+	if (phydev->drv->phy_id == MARVELL_PHY_ID_88X3310)
+		return mv3310_hwmon_read_temp_reg(phydev);
+	else /* MARVELL_PHY_ID_88E2110 */
+		return mv2110_hwmon_read_temp_reg(phydev);
+}
 static int mv3310_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
 			     u32 attr, int channel, long *value)
 {
 	}
 	if (type == hwmon_temp && attr == hwmon_temp_input) {
-		temp = phy_read_mmd(phydev, MDIO_MMD_VEND2, MV_V2_TEMP);
+		temp = mv10g_hwmon_read_temp_reg(phydev);
 		if (temp < 0)
 			return temp;
 	u16 val;
 	int ret;
+	if (phydev->drv->phy_id != MARVELL_PHY_ID_88X3310)
+		return 0;
 	ret = phy_write_mmd(phydev, MDIO_MMD_VEND2, MV_V2_TEMP,
 			    MV_V2_TEMP_UNKNOWN);
 	if (ret < 0)

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

@@ -1359,6 +1359,7 @@ static const struct usb_device_id products[] = { · 1358 unmodified lines
1359	{QMI_FIXED_INTF(0x413c, 0x81b3, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */	1359	{QMI_FIXED_INTF(0x413c, 0x81b3, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */
1360	{QMI_FIXED_INTF(0x413c, 0x81b6, 8)}, /* Dell Wireless 5811e */	1360	{QMI_FIXED_INTF(0x413c, 0x81b6, 8)}, /* Dell Wireless 5811e */
1361	{QMI_FIXED_INTF(0x413c, 0x81b6, 10)}, /* Dell Wireless 5811e */	1361	{QMI_FIXED_INTF(0x413c, 0x81b6, 10)}, /* Dell Wireless 5811e */
		1362	{QMI_FIXED_INTF(0x413c, 0x81cc, 8)}, /* Dell Wireless 5816e */
1362	{QMI_FIXED_INTF(0x413c, 0x81d7, 0)}, /* Dell Wireless 5821e */	1363	{QMI_FIXED_INTF(0x413c, 0x81d7, 0)}, /* Dell Wireless 5821e */
1363	{QMI_FIXED_INTF(0x413c, 0x81d7, 1)}, /* Dell Wireless 5821e preproduction config */	1364	{QMI_FIXED_INTF(0x413c, 0x81d7, 1)}, /* Dell Wireless 5821e preproduction config */
1364	{QMI_FIXED_INTF(0x413c, 0x81e0, 0)}, /* Dell Wireless 5821e with eSIM support*/	1365	{QMI_FIXED_INTF(0x413c, 0x81e0, 0)}, /* Dell Wireless 5821e with eSIM support*/

drivers/net/wireguard/queueing.c+3−1

 		if (multicore) {
 			queue->worker = wg_packet_percpu_multicore_worker_alloc(
 				function, queue);
-			if (!queue->worker)
+			if (!queue->worker) {
+				ptr_ring_cleanup(&queue->ring, NULL);
 				return -ENOMEM;
+			}
 		} else {
 			INIT_WORK(&queue->work, function);
 		}

drivers/net/wireguard/receive.c+10−11

 static void keep_key_fresh(struct wg_peer *peer)
 {
 	struct noise_keypair *keypair;
-	bool send = false;
+	bool send;
 	if (peer->sent_lastminute_handshake)
 		return;
 	rcu_read_lock_bh();
 	keypair = rcu_dereference_bh(peer->keypairs.current_keypair);
-	if (likely(keypair && READ_ONCE(keypair->sending.is_valid)) &&
+	send = keypair && READ_ONCE(keypair->sending.is_valid) &&
-	    keypair->i_am_the_initiator &&
+	       keypair->i_am_the_initiator &&
-	    unlikely(wg_birthdate_has_expired(keypair->sending.birthdate,
+	       wg_birthdate_has_expired(keypair->sending.birthdate,
-			REJECT_AFTER_TIME - KEEPALIVE_TIMEOUT - REKEY_TIMEOUT)))
+			REJECT_AFTER_TIME - KEEPALIVE_TIMEOUT - REKEY_TIMEOUT);
-		send = true;
 	rcu_read_unlock_bh();
-	if (send) {
+	if (unlikely(send)) {
 		peer->sent_lastminute_handshake = true;
 		wg_packet_send_queued_handshake_initiation(peer, false);
 	}
 		len = ntohs(ip_hdr(skb)->tot_len);
 		if (unlikely(len < sizeof(struct iphdr)))
 			goto dishonest_packet_size;
-		if (INET_ECN_is_ce(PACKET_CB(skb)->ds))
+		INET_ECN_decapsulate(skb, PACKET_CB(skb)->ds, ip_hdr(skb)->tos);
-			IP_ECN_set_ce(ip_hdr(skb));
 	} else if (skb->protocol == htons(ETH_P_IPV6)) {
 		len = ntohs(ipv6_hdr(skb)->payload_len) +
 		      sizeof(struct ipv6hdr);
-		if (INET_ECN_is_ce(PACKET_CB(skb)->ds))
+		INET_ECN_decapsulate(skb, PACKET_CB(skb)->ds, ipv6_get_dsfield(ipv6_hdr(skb)));
-			IP6_ECN_set_ce(skb, ipv6_hdr(skb));
 	} else {
 		goto dishonest_packet_type;
 	}
 				&PACKET_CB(skb)->keypair->receiving)) ?
 				PACKET_STATE_CRYPTED : PACKET_STATE_DEAD;
 		wg_queue_enqueue_per_peer_napi(skb, state);
+		if (need_resched())
+			cond_resched();
 	}
 }

drivers/net/wireguard/selftest/ratelimiter.c+2−2

@@ -120,9 +120,9 @@ bool __init wg_ratelimiter_selftest(void) · 119 unmodified lines
120	enum { TRIALS_BEFORE_GIVING_UP = 5000 };	120	enum { TRIALS_BEFORE_GIVING_UP = 5000 };
121	bool success = false;	121	bool success = false;
122	int test = 0, trials;	122	int test = 0, trials;
123	struct sk_buff skb4, skb6;	123	struct sk_buff skb4, skb6 = NULL;
124	struct iphdr *hdr4;	124	struct iphdr *hdr4;
125	struct ipv6hdr *hdr6;	125	struct ipv6hdr *hdr6 = NULL;
126		126
127	if (IS_ENABLED(CONFIG_KASAN) \|\| IS_ENABLED(CONFIG_UBSAN))	127	if (IS_ENABLED(CONFIG_KASAN) \|\| IS_ENABLED(CONFIG_UBSAN))
128	return true;	128	return true;

drivers/net/wireguard/send.c+10−10

@@ -124,20 +124,17 @@ void wg_packet_send_handshake_cookie(struct wg_device *wg, · 123 unmodified lines
124	static void keep_key_fresh(struct wg_peer *peer)	124	static void keep_key_fresh(struct wg_peer *peer)
125	{	125	{
126	struct noise_keypair *keypair;	126	struct noise_keypair *keypair;
127	bool send = false;	127	bool send;
128		128
129	rcu_read_lock_bh();	129	rcu_read_lock_bh();
130	keypair = rcu_dereference_bh(peer->keypairs.current_keypair);	130	keypair = rcu_dereference_bh(peer->keypairs.current_keypair);
131	if (likely(keypair && READ_ONCE(keypair->sending.is_valid)) &&	131	send = keypair && READ_ONCE(keypair->sending.is_valid) &&
132	(unlikely(atomic64_read(&keypair->sending.counter.counter) >	132	(atomic64_read(&keypair->sending.counter.counter) > REKEY_AFTER_MESSAGES \|\|
133	REKEY_AFTER_MESSAGES) \|\|	133	(keypair->i_am_the_initiator &&
134	(keypair->i_am_the_initiator &&	134	wg_birthdate_has_expired(keypair->sending.birthdate, REKEY_AFTER_TIME)));
135	unlikely(wg_birthdate_has_expired(keypair->sending.birthdate,
136	REKEY_AFTER_TIME)))))
137	send = true;
138	rcu_read_unlock_bh();	135	rcu_read_unlock_bh();
139		136
140	if (send)	137	if (unlikely(send))
141	wg_packet_send_queued_handshake_initiation(peer, false);	138	wg_packet_send_queued_handshake_initiation(peer, false);
142	}	139	}
143		140
@@ -281,6 +278,8 @@ void wg_packet_tx_worker(struct work_struct *work) · 137 unmodified lines
281		278
282	wg_noise_keypair_put(keypair, false);	279	wg_noise_keypair_put(keypair, false);
283	wg_peer_put(peer);	280	wg_peer_put(peer);
		281	if (need_resched())
		282	cond_resched();
284	}	283	}
285	}	284	}
286		285
@@ -304,7 +303,8 @@ void wg_packet_encrypt_worker(struct work_struct *work) · 17 unmodified lines
304	}	303	}
305	wg_queue_enqueue_per_peer(&PACKET_PEER(first)->tx_queue, first,	304	wg_queue_enqueue_per_peer(&PACKET_PEER(first)->tx_queue, first,
306	state);	305	state);
307		306	if (need_resched())
		307	cond_resched();
308	}	308	}
309	}	309	}
310		310

drivers/net/wireguard/socket.c+0−12

 			net_dbg_ratelimited("%s: No route to %pISpfsc, error %d\n",
 					    wg->dev->name, &endpoint->addr, ret);
 			goto err;
-		} else if (unlikely(rt->dst.dev == skb->dev)) {
-			ip_rt_put(rt);
-			ret = -ELOOP;
-			net_dbg_ratelimited("%s: Avoiding routing loop to %pISpfsc\n",
-					    wg->dev->name, &endpoint->addr);
-			goto err;
 		}
 		if (cache)
 			dst_cache_set_ip4(cache, &rt->dst, fl.saddr);
 			net_dbg_ratelimited("%s: No route to %pISpfsc, error %d\n",
 					    wg->dev->name, &endpoint->addr, ret);
 			goto err;
-		} else if (unlikely(dst->dev == skb->dev)) {
-			dst_release(dst);
-			ret = -ELOOP;
-			net_dbg_ratelimited("%s: Avoiding routing loop to %pISpfsc\n",
-					    wg->dev->name, &endpoint->addr);
-			goto err;
 		}
 		if (cache)
 			dst_cache_set_ip6(cache, dst, &fl.saddr);

drivers/nvme/host/core.c+3−1

 		  * Don't treat an error as fatal, as we potentially already
 		  * have a NGUID or EUI-64.
 		  */
-		if (status > 0)
+		if (status > 0 && !(status & NVME_SC_DNR))
 			status = 0;
 		goto free_data;
 	}
 	return;
  out_put_disk:
+	/* prevent double queue cleanup */
+	ns->disk->queue = NULL;
 	put_disk(ns->disk);
  out_unlink_ns:
 	mutex_lock(&ctrl->subsys->lock);

drivers/nvme/host/pci.c+5−1

 static inline void nvme_update_cq_head(struct nvme_queue *nvmeq)
 {
-	if (++nvmeq->cq_head == nvmeq->q_depth) {
+	u16 tmp = nvmeq->cq_head + 1;
+	if (tmp == nvmeq->q_depth) {
 		nvmeq->cq_head = 0;
 		nvmeq->cq_phase ^= 1;
+	} else {
+		nvmeq->cq_head = tmp;
 	}
 }

drivers/phy/qualcomm/phy-qcom-qusb2.c+7−0

@@ -815,6 +815,13 @@ static const struct of_device_id qusb2_phy_of_match_table[] = { · 814 unmodified lines
815	}, {	815	}, {
816	.compatible = "qcom,msm8998-qusb2-phy",	816	.compatible = "qcom,msm8998-qusb2-phy",
817	.data = &msm8998_phy_cfg,	817	.data = &msm8998_phy_cfg,
		818	}, {
		819	/*
		820	* Deprecated. Only here to support legacy device
		821	* trees that didn't include "qcom,qusb2-v2-phy"
		822	*/
		823	.compatible = "qcom,sdm845-qusb2-phy",
		824	.data = &qusb2_v2_phy_cfg,
818	}, {	825	}, {
819	.compatible = "qcom,qusb2-v2-phy",	826	.compatible = "qcom,qusb2-v2-phy",
820	.data = &qusb2_v2_phy_cfg,	827	.data = &qusb2_v2_phy_cfg,

drivers/phy/qualcomm/phy-qcom-usb-hs-28nm.c+21−11

@@ -160,18 +160,11 @@ static int qcom_snps_hsphy_power_on(struct phy *phy) · 159 unmodified lines
160	ret = regulator_bulk_enable(VREG_NUM, priv->vregs);	160	ret = regulator_bulk_enable(VREG_NUM, priv->vregs);
161	if (ret)	161	if (ret)
162	return ret;	162	return ret;
163	ret = clk_bulk_prepare_enable(priv->num_clks, priv->clks);	163
164	if (ret)
165	goto err_disable_regulator;
166	qcom_snps_hsphy_disable_hv_interrupts(priv);	164	qcom_snps_hsphy_disable_hv_interrupts(priv);
167	qcom_snps_hsphy_exit_retention(priv);	165	qcom_snps_hsphy_exit_retention(priv);
168		166
169	return 0;	167	return 0;
170
171	err_disable_regulator:
172	regulator_bulk_disable(VREG_NUM, priv->vregs);
173
174	return ret;
175	}	168	}
176		169
177	static int qcom_snps_hsphy_power_off(struct phy *phy)	170	static int qcom_snps_hsphy_power_off(struct phy *phy)
@@ -180,7 +173,6 @@ static int qcom_snps_hsphy_power_off(struct phy *phy) · 2 unmodified lines
180		173
181	qcom_snps_hsphy_enter_retention(priv);	174	qcom_snps_hsphy_enter_retention(priv);
182	qcom_snps_hsphy_enable_hv_interrupts(priv);	175	qcom_snps_hsphy_enable_hv_interrupts(priv);
183	clk_bulk_disable_unprepare(priv->num_clks, priv->clks);
184	regulator_bulk_disable(VREG_NUM, priv->vregs);	176	regulator_bulk_disable(VREG_NUM, priv->vregs);
185		177
186	return 0;	178	return 0;
@@ -266,21 +258,39 @@ static int qcom_snps_hsphy_init(struct phy *phy) · 79 unmodified lines
266	struct hsphy_priv *priv = phy_get_drvdata(phy);	258	struct hsphy_priv *priv = phy_get_drvdata(phy);
267	int ret;	259	int ret;
268		260
269	ret = qcom_snps_hsphy_reset(priv);	261	ret = clk_bulk_prepare_enable(priv->num_clks, priv->clks);
270	if (ret)	262	if (ret)
271	return ret;	263	return ret;
272		264
		265	ret = qcom_snps_hsphy_reset(priv);
		266	if (ret)
		267	goto disable_clocks;
		268
273	qcom_snps_hsphy_init_sequence(priv);	269	qcom_snps_hsphy_init_sequence(priv);
274		270
275	ret = qcom_snps_hsphy_por_reset(priv);	271	ret = qcom_snps_hsphy_por_reset(priv);
276	if (ret)	272	if (ret)
277	return ret;	273	goto disable_clocks;
		274
		275	return 0;
		276
		277	disable_clocks:
		278	clk_bulk_disable_unprepare(priv->num_clks, priv->clks);
		279	return ret;
		280	}
		281
		282	static int qcom_snps_hsphy_exit(struct phy *phy)
		283	{
		284	struct hsphy_priv *priv = phy_get_drvdata(phy);
		285
		286	clk_bulk_disable_unprepare(priv->num_clks, priv->clks);
278		287
279	return 0;	288	return 0;
280	}	289	}
281		290
282	static const struct phy_ops qcom_snps_hsphy_ops = {	291	static const struct phy_ops qcom_snps_hsphy_ops = {
283	.init = qcom_snps_hsphy_init,	292	.init = qcom_snps_hsphy_init,
		293	.exit = qcom_snps_hsphy_exit,
284	.power_on = qcom_snps_hsphy_power_on,	294	.power_on = qcom_snps_hsphy_power_on,
285	.power_off = qcom_snps_hsphy_power_off,	295	.power_off = qcom_snps_hsphy_power_off,
286	.set_mode = qcom_snps_hsphy_set_mode,	296	.set_mode = qcom_snps_hsphy_set_mode,

drivers/platform/chrome/cros_ec_sensorhub.c+46−34

 	int sensor_type[MOTIONSENSE_TYPE_MAX] = { 0 };
 	struct cros_ec_command *msg = sensorhub->msg;
 	struct cros_ec_dev *ec = sensorhub->ec;
-	int ret, i, sensor_num;
+	int ret, i;
 	char *name;
-	sensor_num = cros_ec_get_sensor_count(ec);
-	if (sensor_num < 0) {
-		dev_err(dev,
-			"Unable to retrieve sensor information (err:%d)\n",
-			sensor_num);
-		return sensor_num;
-	}
-	sensorhub->sensor_num = sensor_num;
-	if (sensor_num == 0) {
-		dev_err(dev, "Zero sensors reported.\n");
-		return -EINVAL;
-	}
 	msg->version = 1;
 	msg->insize = sizeof(struct ec_response_motion_sense);
 	msg->outsize = sizeof(struct ec_params_motion_sense);
-	for (i = 0; i < sensor_num; i++) {
+	for (i = 0; i < sensorhub->sensor_num; i++) {
 		sensorhub->params->cmd = MOTIONSENSE_CMD_INFO;
 		sensorhub->params->info.sensor_num = i;
 	struct cros_ec_dev *ec = dev_get_drvdata(dev->parent);
 	struct cros_ec_sensorhub *data;
 	struct cros_ec_command *msg;
-	int ret;
+	int ret, i, sensor_num;
-	int i;
 	msg = devm_kzalloc(dev, sizeof(struct cros_ec_command) +
 			   max((u16)sizeof(struct ec_params_motion_sense),
 	dev_set_drvdata(dev, data);
 	/* Check whether this EC is a sensor hub. */
-	if (cros_ec_check_features(data->ec, EC_FEATURE_MOTION_SENSE)) {
+	if (cros_ec_check_features(ec, EC_FEATURE_MOTION_SENSE)) {
+		sensor_num = cros_ec_get_sensor_count(ec);
+		if (sensor_num < 0) {
+			dev_err(dev,
+				"Unable to retrieve sensor information (err:%d)\n",
+				sensor_num);
+			return sensor_num;
+		}
+		if (sensor_num == 0) {
+			dev_err(dev, "Zero sensors reported.\n");
+			return -EINVAL;
+		}
+		data->sensor_num = sensor_num;
+		/*
+		 * Prepare the ring handler before enumering the
+		 * sensors.
+		 */
+		if (cros_ec_check_features(ec, EC_FEATURE_MOTION_SENSE_FIFO)) {
+			ret = cros_ec_sensorhub_ring_allocate(data);
+			if (ret)
+				return ret;
+		}
+		/* Enumerate the sensors.*/
 		ret = cros_ec_sensorhub_register(dev, data);
 		if (ret)
 			return ret;
+		/*
+		 * When the EC does not have a FIFO, the sensors will query
+		 * their data themselves via sysfs or a software trigger.
+		 */
+		if (cros_ec_check_features(ec, EC_FEATURE_MOTION_SENSE_FIFO)) {
+			ret = cros_ec_sensorhub_ring_add(data);
+			if (ret)
+				return ret;
+			/*
+			 * The msg and its data is not under the control of the
+			 * ring handler.
+			 */
+			return devm_add_action_or_reset(dev,
+					cros_ec_sensorhub_ring_remove,
+					data);
+		}
 	} else {
 		/*
 		 * If the device has sensors but does not claim to
 		}
 	}
-	/*
-	 * If the EC does not have a FIFO, the sensors will query their data
-	 * themselves via sysfs or a software trigger.
-	 */
-	if (cros_ec_check_features(ec, EC_FEATURE_MOTION_SENSE_FIFO)) {
-		ret = cros_ec_sensorhub_ring_add(data);
-		if (ret)
-			return ret;
-		/*
-		 * The msg and its data is not under the control of the ring
-		 * handler.
-		 */
-		return devm_add_action_or_reset(dev,
-						cros_ec_sensorhub_ring_remove,
-						data);
-	}
 	return 0;
 }

drivers/platform/chrome/cros_ec_sensorhub_ring.c+46−27

 }
 /**
- * cros_ec_sensorhub_ring_add() - Add the FIFO functionality if the EC
+ * cros_ec_sensorhub_ring_allocate() - Prepare the FIFO functionality if the EC
- *				  supports it.
+ *				       supports it.
  *
  * @sensorhub : Sensor Hub object.
  *
  * Return: 0 on success.
  */
-int cros_ec_sensorhub_ring_add(struct cros_ec_sensorhub *sensorhub)
+int cros_ec_sensorhub_ring_allocate(struct cros_ec_sensorhub *sensorhub)
 {
-	struct cros_ec_dev *ec = sensorhub->ec;
-	int ret;
 	int fifo_info_length =
 		sizeof(struct ec_response_motion_sense_fifo_info) +
 		sizeof(u16) * sensorhub->sensor_num;
 	if (!sensorhub->fifo_info)
 		return -ENOMEM;
+	/*
+	 * Allocate the callback area based on the number of sensors.
+	 * Add one for the sensor ring.
+	 */
+	sensorhub->push_data = devm_kcalloc(sensorhub->dev,
+			sensorhub->sensor_num,
+			sizeof(*sensorhub->push_data),
+			GFP_KERNEL);
+	if (!sensorhub->push_data)
+		return -ENOMEM;
+	sensorhub->tight_timestamps = cros_ec_check_features(
+			sensorhub->ec,
+			EC_FEATURE_MOTION_SENSE_TIGHT_TIMESTAMPS);
+	if (sensorhub->tight_timestamps) {
+		sensorhub->batch_state = devm_kcalloc(sensorhub->dev,
+				sensorhub->sensor_num,
+				sizeof(*sensorhub->batch_state),
+				GFP_KERNEL);
+		if (!sensorhub->batch_state)
+			return -ENOMEM;
+	}
+	return 0;
+}
+/**
+ * cros_ec_sensorhub_ring_add() - Add the FIFO functionality if the EC
+ *				  supports it.
+ *
+ * @sensorhub : Sensor Hub object.
+ *
+ * Return: 0 on success.
+ */
+int cros_ec_sensorhub_ring_add(struct cros_ec_sensorhub *sensorhub)
+{
+	struct cros_ec_dev *ec = sensorhub->ec;
+	int ret;
+	int fifo_info_length =
+		sizeof(struct ec_response_motion_sense_fifo_info) +
+		sizeof(u16) * sensorhub->sensor_num;
 	/* Retrieve FIFO information */
 	sensorhub->msg->version = 2;
 	sensorhub->params->cmd = MOTIONSENSE_CMD_FIFO_INFO;
 	if (!sensorhub->ring)
 		return -ENOMEM;
-	/*
-	 * Allocate the callback area based on the number of sensors.
-	 */
-	sensorhub->push_data = devm_kcalloc(
-			sensorhub->dev, sensorhub->sensor_num,
-			sizeof(*sensorhub->push_data),
-			GFP_KERNEL);
-	if (!sensorhub->push_data)
-		return -ENOMEM;
 	sensorhub->fifo_timestamp[CROS_EC_SENSOR_LAST_TS] =
 		cros_ec_get_time_ns();
-	sensorhub->tight_timestamps = cros_ec_check_features(
-			ec, EC_FEATURE_MOTION_SENSE_TIGHT_TIMESTAMPS);
-	if (sensorhub->tight_timestamps) {
-		sensorhub->batch_state = devm_kcalloc(sensorhub->dev,
-				sensorhub->sensor_num,
-				sizeof(*sensorhub->batch_state),
-				GFP_KERNEL);
-		if (!sensorhub->batch_state)
-			return -ENOMEM;
-	}
 	/* Register the notifier that will act as a top half interrupt. */
 	sensorhub->notifier.notifier_call = cros_ec_sensorhub_event;
 	ret = blocking_notifier_chain_register(&ec->ec_dev->event_notifier,

drivers/platform/x86/asus-nb-wmi.c+24−0

@@ -515,9 +515,33 @@ static struct asus_wmi_driver asus_nb_wmi_driver = { · 514 unmodified lines
515	.detect_quirks = asus_nb_wmi_quirks,	515	.detect_quirks = asus_nb_wmi_quirks,
516	};	516	};
517		517
		518	static const struct dmi_system_id asus_nb_wmi_blacklist[] __initconst = {
		519	{
		520	/*
		521	* asus-nb-wm adds no functionality. The T100TA has a detachable
		522	* USB kbd, so no hotkeys and it has no WMI rfkill; and loading
		523	* asus-nb-wm causes the camera LED to turn and _stay_ on.
		524	*/
		525	.matches = {
		526	DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
		527	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100TA"),
		528	},
		529	},
		530	{
		531	/* The Asus T200TA has the same issue as the T100TA */
		532	.matches = {
		533	DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
		534	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T200TA"),
		535	},
		536	},
		537	{} /* Terminating entry */
		538	};
518		539
519	static int __init asus_nb_wmi_init(void)	540	static int __init asus_nb_wmi_init(void)
520	{	541	{
		542	if (dmi_check_system(asus_nb_wmi_blacklist))
		543	return -ENODEV;
		544
521	return asus_wmi_register_driver(&asus_nb_wmi_driver);	545	return asus_wmi_register_driver(&asus_nb_wmi_driver);
522	}	546	}
523		547

drivers/platform/x86/intel-uncore-frequency.c+1−1

@@ -53,7 +53,7 @@ static int uncore_max_entries __read_mostly; · 52 unmodified lines
53	/* Storage for uncore data for all instances */	53	/* Storage for uncore data for all instances */
54	static struct uncore_data *uncore_instances;	54	static struct uncore_data *uncore_instances;
55	/* Root of the all uncore sysfs kobjs */	55	/* Root of the all uncore sysfs kobjs */
56	struct kobject *uncore_root_kobj;	56	static struct kobject *uncore_root_kobj;
57	/* Stores the CPU mask of the target CPUs to use during uncore read/write */	57	/* Stores the CPU mask of the target CPUs to use during uncore read/write */
58	static cpumask_t uncore_cpu_mask;	58	static cpumask_t uncore_cpu_mask;
59	/* CPU online callback register instance */	59	/* CPU online callback register instance */

drivers/platform/x86/intel_pmc_core.c+5−19

 };
 static const struct pmc_bit_map icl_pfear_map[] = {
-	/* Ice Lake generation onwards only */
+	/* Ice Lake and Jasper Lake generation onwards only */
 	{"RES_65",		BIT(0)},
 	{"RES_66",		BIT(1)},
 	{"RES_67",		BIT(2)},
 };
 static const struct pmc_bit_map tgl_pfear_map[] = {
-	/* Tiger Lake, Elkhart Lake and Jasper Lake generation onwards only */
+	/* Tiger Lake and Elkhart Lake generation onwards only */
 	{"PSF9",		BIT(0)},
 	{"RES_66",		BIT(1)},
 	{"RES_67",		BIT(2)},
 	kfree(lpm_regs);
 }
-#if IS_ENABLED(CONFIG_DEBUG_FS)
 static bool slps0_dbg_latch;
 static inline u8 pmc_core_reg_read_byte(struct pmc_dev *pmcdev, int offset)
 				    &pmc_core_substate_l_sts_regs_fops);
 	}
 }
-#else
-static inline void pmc_core_dbgfs_register(struct pmc_dev *pmcdev)
-{
-}
-static inline void pmc_core_dbgfs_unregister(struct pmc_dev *pmcdev)
-{
-}
-#endif /* CONFIG_DEBUG_FS */
 static const struct x86_cpu_id intel_pmc_core_ids[] = {
 	X86_MATCH_INTEL_FAM6_MODEL(SKYLAKE_L,		&spt_reg_map),
 	X86_MATCH_INTEL_FAM6_MODEL(TIGERLAKE_L,		&tgl_reg_map),
 	X86_MATCH_INTEL_FAM6_MODEL(TIGERLAKE,		&tgl_reg_map),
 	X86_MATCH_INTEL_FAM6_MODEL(ATOM_TREMONT,	&tgl_reg_map),
-	X86_MATCH_INTEL_FAM6_MODEL(ATOM_TREMONT_L,	&tgl_reg_map),
+	X86_MATCH_INTEL_FAM6_MODEL(ATOM_TREMONT_L,	&icl_reg_map),
 	{}
 };
 	return 0;
 }
-#ifdef CONFIG_PM_SLEEP
 static bool warn_on_s0ix_failures;
 module_param(warn_on_s0ix_failures, bool, 0644);
 MODULE_PARM_DESC(warn_on_s0ix_failures, "Check and warn for S0ix failures");
-static int pmc_core_suspend(struct device *dev)
+static __maybe_unused int pmc_core_suspend(struct device *dev)
 {
 	struct pmc_dev *pmcdev = dev_get_drvdata(dev);
 	return false;
 }
-static int pmc_core_resume(struct device *dev)
+static __maybe_unused int pmc_core_resume(struct device *dev)
 {
 	struct pmc_dev *pmcdev = dev_get_drvdata(dev);
 	const struct pmc_bit_map **maps = pmcdev->map->lpm_sts;
 	return 0;
 }
-#endif
 static const struct dev_pm_ops pmc_core_pm_ops = {
 	SET_LATE_SYSTEM_SLEEP_PM_OPS(pmc_core_suspend, pmc_core_resume)
 };

drivers/platform/x86/intel_pmc_core.h+0−2

 	u32 base_addr;
 	void __iomem *regbase;
 	const struct pmc_reg_map *map;
-#if IS_ENABLED(CONFIG_DEBUG_FS)
 	struct dentry *dbgfs_dir;
-#endif /* CONFIG_DEBUG_FS */
 	int pmc_xram_read_bit;
 	struct mutex lock; /* generic mutex lock for PMC Core */

drivers/platform/x86/surface3_power.c+2−2

@@ -522,8 +522,8 @@ static int mshw0011_probe(struct i2c_client *client) · 521 unmodified lines
522	strlcpy(board_info.type, "MSHW0011-bat0", I2C_NAME_SIZE);	522	strlcpy(board_info.type, "MSHW0011-bat0", I2C_NAME_SIZE);
523		523
524	bat0 = i2c_acpi_new_device(dev, 1, &board_info);	524	bat0 = i2c_acpi_new_device(dev, 1, &board_info);
525	if (!bat0)	525	if (IS_ERR(bat0))
526	return -ENOMEM;	526	return PTR_ERR(bat0);
527		527
528	data->bat0 = bat0;	528	data->bat0 = bat0;
529	i2c_set_clientdata(bat0, data);	529	i2c_set_clientdata(bat0, data);

drivers/platform/x86/thinkpad_acpi.c+1−1

@@ -9548,7 +9548,7 @@ static ssize_t tpacpi_battery_store(int what, · 9547 unmodified lines
9548	if (!battery_info.batteries[battery].start_support)	9548	if (!battery_info.batteries[battery].start_support)
9549	return -ENODEV;	9549	return -ENODEV;
9550	/* valid values are [0, 99] */	9550	/* valid values are [0, 99] */
9551	if (value < 0 \|\| value > 99)	9551	if (value > 99)
9552	return -EINVAL;	9552	return -EINVAL;
9553	if (value > battery_info.batteries[battery].charge_stop)	9553	if (value > battery_info.batteries[battery].charge_stop)
9554	return -EINVAL;	9554	return -EINVAL;

drivers/platform/x86/xiaomi-wmi.c+2−2

@@ -23,7 +23,7 @@ struct xiaomi_wmi { · 22 unmodified lines
23	unsigned int key_code;	23	unsigned int key_code;
24	};	24	};
25		25
26	int xiaomi_wmi_probe(struct wmi_device wdev, const void context)	26	static int xiaomi_wmi_probe(struct wmi_device wdev, const void context)
27	{	27	{
28	struct xiaomi_wmi *data;	28	struct xiaomi_wmi *data;
29		29
@@ -48,7 +48,7 @@ int xiaomi_wmi_probe(struct wmi_device wdev, const void context) · 18 unmodified lines
48	return input_register_device(data->input_dev);	48	return input_register_device(data->input_dev);
49	}	49	}
50		50
51	void xiaomi_wmi_notify(struct wmi_device wdev, union acpi_object dummy)	51	static void xiaomi_wmi_notify(struct wmi_device wdev, union acpi_object dummy)
52	{	52	{
53	struct xiaomi_wmi *data;	53	struct xiaomi_wmi *data;
54		54

drivers/regulator/core.c+11−14

@@ -5754,10 +5754,6 @@ static DECLARE_DELAYED_WORK(regulator_init_complete_work, · 5753 unmodified lines
5754		5754
5755	static int __init regulator_init_complete(void)	5755	static int __init regulator_init_complete(void)
5756	{	5756	{
5757	int delay = driver_deferred_probe_timeout;
5758
5759	if (delay < 0)
5760	delay = 0;
5761	/*	5757	/*
5762	* Since DT doesn't provide an idiomatic mechanism for	5758	* Since DT doesn't provide an idiomatic mechanism for
5763	* enabling full constraints and since it's much more natural	5759	* enabling full constraints and since it's much more natural
@@ -5768,17 +5764,18 @@ static int __init regulator_init_complete(void) · 4 unmodified lines
5768	has_full_constraints = true;	5764	has_full_constraints = true;
5769		5765
5770	/*	5766	/*
5771	* If driver_deferred_probe_timeout is set, we punt	5767	* We punt completion for an arbitrary amount of time since
5772	* completion for that many seconds since systems like	5768	* systems like distros will load many drivers from userspace
5773	* distros will load many drivers from userspace so consumers	5769	* so consumers might not always be ready yet, this is
5774	* might not always be ready yet, this is particularly an	5770	* particularly an issue with laptops where this might bounce
5775	* issue with laptops where this might bounce the display off	5771	* the display off then on. Ideally we'd get a notification
5776	* then on. Ideally we'd get a notification from userspace	5772	* from userspace when this happens but we don't so just wait
5777	* when this happens but we don't so just wait a bit and hope	5773	* a bit and hope we waited long enough. It'd be better if
5778	* we waited long enough. It'd be better if we'd only do	5774	* we'd only do this on systems that need it, and a kernel
5779	* this on systems that need it.	5775	* command line option might be useful.
5780	*/	5776	*/
5781	schedule_delayed_work(&regulator_init_complete_work, delay * HZ);	5777	schedule_delayed_work(&regulator_init_complete_work,
		5778	msecs_to_jiffies(30000));
5782		5779
5783	return 0;	5780	return 0;
5784	}	5781	}

drivers/s390/net/qeth_core_main.c+5−5

 		unsigned int i;
 		/* Quiesce the NAPI instances: */
-		qeth_for_each_output_queue(card, queue, i) {
+		qeth_for_each_output_queue(card, queue, i)
 			napi_disable(&queue->napi);
-			del_timer_sync(&queue->timer);
-		}
 		/* Stop .ndo_start_xmit, might still access queue->napi. */
 		netif_tx_disable(dev);
-		/* Queues may get re-allocated, so remove the NAPIs here. */
+		qeth_for_each_output_queue(card, queue, i) {
-		qeth_for_each_output_queue(card, queue, i)
+			del_timer_sync(&queue->timer);
+			/* Queues may get re-allocated, so remove the NAPIs. */
 			netif_napi_del(&queue->napi);
+		}
 	} else {
 		netif_tx_disable(dev);
 	}

drivers/scsi/ibmvscsi/ibmvfc.c+5−0

 	struct ibmvfc_host *vhost = tgt->vhost;
 	struct ibmvfc_event *evt;
+	if (!vhost->logged_in) {
+		ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
+		return;
+	}
 	if (vhost->discovery_threads >= disc_threads)
 		return;

drivers/scsi/ibmvscsi/ibmvscsi.c+0−4

 static int ibmvscsi_remove(struct vio_dev *vdev)
 {
 	struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev);
-	unsigned long flags;
 	srp_remove_host(hostdata->host);
 	scsi_remove_host(hostdata->host);
 	purge_requests(hostdata, DID_ERROR);
-	spin_lock_irqsave(hostdata->host->host_lock, flags);
 	release_event_pool(&hostdata->pool, hostdata);
-	spin_unlock_irqrestore(hostdata->host->host_lock, flags);
 	ibmvscsi_release_crq_queue(&hostdata->queue, hostdata,
 					max_events);

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

 	    test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
 		msleep(1000);
-	qla_nvme_delete(vha);
 	qla24xx_disable_vp(vha);
 	qla2x00_wait_for_sess_deletion(vha);
+	qla_nvme_delete(vha);
 	vha->flags.delete_progress = 1;
 	qlt_remove_target(ha, vha);

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

@@ -3153,7 +3153,7 @@ qla24xx_abort_command(srb_t *sp) · 3152 unmodified lines
3153	ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108c,	3153	ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108c,
3154	"Entered %s.\n", __func__);	3154	"Entered %s.\n", __func__);
3155		3155
3156	if (vha->flags.qpairs_available && sp->qpair)	3156	if (sp->qpair)
3157	req = sp->qpair->req;	3157	req = sp->qpair->req;
3158	else	3158	else
3159	return QLA_FUNCTION_FAILED;	3159	return QLA_FUNCTION_FAILED;

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

 	}
 	qla2x00_wait_for_hba_ready(base_vha);
+	/*
+	 * if UNLOADING flag is already set, then continue unload,
+	 * where it was set first.
+	 */
+	if (test_and_set_bit(UNLOADING, &base_vha->dpc_flags))
+		return;
 	if (IS_QLA25XX(ha) || IS_QLA2031(ha) || IS_QLA27XX(ha) ||
 	    IS_QLA28XX(ha)) {
 		if (ha->flags.fw_started)
 	qla2x00_wait_for_sess_deletion(base_vha);
-	/*
-	 * if UNLOAD flag is already set, then continue unload,
-	 * where it was set first.
-	 */
-	if (test_bit(UNLOADING, &base_vha->dpc_flags))
-		return;
-	set_bit(UNLOADING, &base_vha->dpc_flags);
 	qla_nvme_delete(base_vha);
 	dma_free_coherent(&ha->pdev->dev,
 	struct qla_work_evt *e;
 	uint8_t bail;
+	if (test_bit(UNLOADING, &vha->dpc_flags))
+		return NULL;
 	QLA_VHA_MARK_BUSY(vha, bail);
 	if (bail)
 		return NULL;
 	struct pci_dev *pdev = ha->pdev;
 	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
-	/*
-	 * if UNLOAD flag is already set, then continue unload,
-	 * where it was set first.
-	 */
-	if (test_bit(UNLOADING, &base_vha->dpc_flags))
-		return;
 	ql_log(ql_log_warn, base_vha, 0x015b,
 	    "Disabling adapter.\n");
 		return;
 	}
-	qla2x00_wait_for_sess_deletion(base_vha);
+	/*
+	 * if UNLOADING flag is already set, then continue unload,
+	 * where it was set first.
+	 */
+	if (test_and_set_bit(UNLOADING, &base_vha->dpc_flags))
+		return;
-	set_bit(UNLOADING, &base_vha->dpc_flags);
+	qla2x00_wait_for_sess_deletion(base_vha);
 	qla2x00_delete_all_vps(ha, base_vha);

drivers/scsi/scsi_lib.c+1−0

@@ -2284,6 +2284,7 @@ scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state) · 2283 unmodified lines
2284	switch (oldstate) {	2284	switch (oldstate) {
2285	case SDEV_RUNNING:	2285	case SDEV_RUNNING:
2286	case SDEV_CREATED_BLOCK:	2286	case SDEV_CREATED_BLOCK:
		2287	case SDEV_QUIESCE:
2287	case SDEV_OFFLINE:	2288	case SDEV_OFFLINE:
2288	break;	2289	break;
2289	default:	2290	default:

drivers/staging/gasket/gasket_core.c+4−0

 		gasket_get_bar_index(gasket_dev,
 				     (vma->vm_pgoff << PAGE_SHIFT) +
 				     driver_desc->legacy_mmap_address_offset);
+	if (bar_index < 0)
+		return DO_MAP_REGION_INVALID;
 	phys_base = gasket_dev->bar_data[bar_index].phys_base + phys_offset;
 	while (mapped_bytes < map_length) {
 		/*

drivers/staging/ks7010/TODO+0−1

@@ -30,5 +30,4 @@ Now the TODOs: · 29 unmodified lines
30		30
31	Please send any patches to:	31	Please send any patches to:
32	Greg Kroah-Hartman <gregkh@linuxfoundation.org>	32	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
33	Wolfram Sang <wsa@the-dreams.de>
34	Linux Driver Project Developer List <driverdev-devel@linuxdriverproject.org>	33	Linux Driver Project Developer List <driverdev-devel@linuxdriverproject.org>

drivers/target/target_core_iblock.c+1−1

@@ -432,7 +432,7 @@ iblock_execute_zero_out(struct block_device bdev, struct se_cmd cmd) · 431 unmodified lines
432	target_to_linux_sector(dev, cmd->t_task_lba),	432	target_to_linux_sector(dev, cmd->t_task_lba),
433	target_to_linux_sector(dev,	433	target_to_linux_sector(dev,
434	sbc_get_write_same_sectors(cmd)),	434	sbc_get_write_same_sectors(cmd)),
435	GFP_KERNEL, false);	435	GFP_KERNEL, BLKDEV_ZERO_NOUNMAP);
436	if (ret)	436	if (ret)
437	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	437	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
438		438

drivers/thunderbolt/usb4.c+3−0

@@ -182,6 +182,9 @@ static int usb4_switch_op(struct tb_switch sw, u16 opcode, u8 status) · 181 unmodified lines
182	return ret;	182	return ret;
183		183
184	ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, ROUTER_CS_26, 1);	184	ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, ROUTER_CS_26, 1);
		185	if (ret)
		186	return ret;
		187
185	if (val & ROUTER_CS_26_ONS)	188	if (val & ROUTER_CS_26_ONS)
186	return -EOPNOTSUPP;	189	return -EOPNOTSUPP;
187		190

drivers/tty/hvc/Kconfig+1−1

@@ -88,7 +88,7 @@ config HVC_DCC · 87 unmodified lines
88		88
89	config HVC_RISCV_SBI	89	config HVC_RISCV_SBI
90	bool "RISC-V SBI console support"	90	bool "RISC-V SBI console support"
91	depends on RISCV_SBI	91	depends on RISCV_SBI_V01
92	select HVC_DRIVER	92	select HVC_DRIVER
93	help	93	help
94	This enables support for console output via RISC-V SBI calls, which	94	This enables support for console output via RISC-V SBI calls, which

drivers/tty/serial/Kconfig+1−1

@@ -86,7 +86,7 @@ config SERIAL_EARLYCON_ARM_SEMIHOST · 85 unmodified lines
86		86
87	config SERIAL_EARLYCON_RISCV_SBI	87	config SERIAL_EARLYCON_RISCV_SBI
88	bool "Early console using RISC-V SBI"	88	bool "Early console using RISC-V SBI"
89	depends on RISCV_SBI	89	depends on RISCV_SBI_V01
90	select SERIAL_CORE	90	select SERIAL_CORE
91	select SERIAL_CORE_CONSOLE	91	select SERIAL_CORE_CONSOLE
92	select SERIAL_EARLYCON	92	select SERIAL_EARLYCON

drivers/tty/serial/bcm63xx_uart.c+1−3

 	if (IS_ERR(clk) && pdev->dev.of_node)
 		clk = of_clk_get(pdev->dev.of_node, 0);
-	if (IS_ERR(clk)) {
+	if (IS_ERR(clk))
-		clk_put(clk);
 		return -ENODEV;
-	}
 	port->iotype = UPIO_MEM;
 	port->irq = res_irq->start;

drivers/tty/serial/xilinx_uartps.c+1−0

@@ -1459,6 +1459,7 @@ static int cdns_uart_probe(struct platform_device *pdev) · 1458 unmodified lines
1459	cdns_uart_uart_driver.nr = CDNS_UART_NR_PORTS;	1459	cdns_uart_uart_driver.nr = CDNS_UART_NR_PORTS;
1460	#ifdef CONFIG_SERIAL_XILINX_PS_UART_CONSOLE	1460	#ifdef CONFIG_SERIAL_XILINX_PS_UART_CONSOLE
1461	cdns_uart_uart_driver.cons = &cdns_uart_console;	1461	cdns_uart_uart_driver.cons = &cdns_uart_console;
		1462	cdns_uart_console.index = id;
1462	#endif	1463	#endif
1463		1464
1464	rc = uart_register_driver(&cdns_uart_uart_driver);	1465	rc = uart_register_driver(&cdns_uart_uart_driver);

drivers/tty/vt/vt.c+7−2

 	return uniscr;
 }
+static void vc_uniscr_free(struct uni_screen *uniscr)
+{
+	vfree(uniscr);
+}
 static void vc_uniscr_set(struct vc_data *vc, struct uni_screen *new_uniscr)
 {
-	vfree(vc->vc_uni_screen);
+	vc_uniscr_free(vc->vc_uni_screen);
 	vc->vc_uni_screen = new_uniscr;
 }
 	err = resize_screen(vc, new_cols, new_rows, user);
 	if (err) {
 		kfree(newscreen);
-		kfree(new_uniscr);
+		vc_uniscr_free(new_uniscr);
 		return err;
 	}

drivers/usb/chipidea/ci_hdrc_msm.c+1−1

@@ -114,7 +114,7 @@ static int ci_hdrc_msm_notify_event(struct ci_hdrc *ci, unsigned event) · 113 unmodified lines
114	hw_write_id_reg(ci, HS_PHY_GENCONFIG_2,	114	hw_write_id_reg(ci, HS_PHY_GENCONFIG_2,
115	HS_PHY_ULPI_TX_PKT_EN_CLR_FIX, 0);	115	HS_PHY_ULPI_TX_PKT_EN_CLR_FIX, 0);
116		116
117	if (!IS_ERR(ci->platdata->vbus_extcon.edev)) {	117	if (!IS_ERR(ci->platdata->vbus_extcon.edev) \|\| ci->role_switch) {
118	hw_write_id_reg(ci, HS_PHY_GENCONFIG_2,	118	hw_write_id_reg(ci, HS_PHY_GENCONFIG_2,
119	HS_PHY_SESS_VLD_CTRL_EN,	119	HS_PHY_SESS_VLD_CTRL_EN,
120	HS_PHY_SESS_VLD_CTRL_EN);	120	HS_PHY_SESS_VLD_CTRL_EN);

drivers/usb/core/devio.c+2−3

 {
 	struct usb_memory *usbm = NULL;
 	struct usb_dev_state *ps = file->private_data;
+	struct usb_hcd *hcd = bus_to_hcd(ps->dev->bus);
 	size_t size = vma->vm_end - vma->vm_start;
 	void *mem;
 	unsigned long flags;
 	usbm->vma_use_count = 1;
 	INIT_LIST_HEAD(&usbm->memlist);
-	if (remap_pfn_range(vma, vma->vm_start,
+	if (dma_mmap_coherent(hcd->self.sysdev, vma, mem, dma_handle, size)) {
-			virt_to_phys(usbm->mem) >> PAGE_SHIFT,
-			size, vma->vm_page_prot) < 0) {
 		dec_usb_memory_use_count(usbm, &usbm->vma_use_count);
 		return -EAGAIN;
 	}

drivers/usb/core/message.c+2−2

@@ -1144,11 +1144,11 @@ void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr, · 1143 unmodified lines
1144		1144
1145	if (usb_endpoint_out(epaddr)) {	1145	if (usb_endpoint_out(epaddr)) {
1146	ep = dev->ep_out[epnum];	1146	ep = dev->ep_out[epnum];
1147	if (reset_hardware)	1147	if (reset_hardware && epnum != 0)
1148	dev->ep_out[epnum] = NULL;	1148	dev->ep_out[epnum] = NULL;
1149	} else {	1149	} else {
1150	ep = dev->ep_in[epnum];	1150	ep = dev->ep_in[epnum];
1151	if (reset_hardware)	1151	if (reset_hardware && epnum != 0)
1152	dev->ep_in[epnum] = NULL;	1152	dev->ep_in[epnum] = NULL;
1153	}	1153	}
1154	if (ep) {	1154	if (ep) {

drivers/usb/serial/garmin_gps.c+2−2

@@ -1138,8 +1138,8 @@ static void garmin_read_process(struct garmin_data *garmin_data_p, · 1137 unmodified lines
1138	send it directly to the tty port */	1138	send it directly to the tty port */
1139	if (garmin_data_p->flags & FLAGS_QUEUING) {	1139	if (garmin_data_p->flags & FLAGS_QUEUING) {
1140	pkt_add(garmin_data_p, data, data_length);	1140	pkt_add(garmin_data_p, data, data_length);
1141	} else if (bulk_data \|\|	1141	} else if (bulk_data \|\| (data_length >= sizeof(u32) &&
1142	getLayerId(data) == GARMIN_LAYERID_APPL) {	1142	getLayerId(data) == GARMIN_LAYERID_APPL)) {
1143		1143
1144	spin_lock_irqsave(&garmin_data_p->lock, flags);	1144	spin_lock_irqsave(&garmin_data_p->lock, flags);
1145	garmin_data_p->flags \|= APP_RESP_SEEN;	1145	garmin_data_p->flags \|= APP_RESP_SEEN;

drivers/usb/serial/qcserial.c+1−0

@@ -173,6 +173,7 @@ static const struct usb_device_id id_table[] = { · 172 unmodified lines
173	{DEVICE_SWI(0x413c, 0x81b3)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */	173	{DEVICE_SWI(0x413c, 0x81b3)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */
174	{DEVICE_SWI(0x413c, 0x81b5)}, /* Dell Wireless 5811e QDL */	174	{DEVICE_SWI(0x413c, 0x81b5)}, /* Dell Wireless 5811e QDL */
175	{DEVICE_SWI(0x413c, 0x81b6)}, /* Dell Wireless 5811e QDL */	175	{DEVICE_SWI(0x413c, 0x81b6)}, /* Dell Wireless 5811e QDL */
		176	{DEVICE_SWI(0x413c, 0x81cc)}, /* Dell Wireless 5816e */
176	{DEVICE_SWI(0x413c, 0x81cf)}, /* Dell Wireless 5819 */	177	{DEVICE_SWI(0x413c, 0x81cf)}, /* Dell Wireless 5819 */
177	{DEVICE_SWI(0x413c, 0x81d0)}, /* Dell Wireless 5819 */	178	{DEVICE_SWI(0x413c, 0x81d0)}, /* Dell Wireless 5819 */
178	{DEVICE_SWI(0x413c, 0x81d1)}, /* Dell Wireless 5818 */	179	{DEVICE_SWI(0x413c, 0x81d1)}, /* Dell Wireless 5818 */

drivers/usb/storage/unusual_uas.h+7−0

@@ -28,6 +28,13 @@ · 27 unmodified lines
28	* and don't forget to CC: the USB development list <linux-usb@vger.kernel.org>	28	* and don't forget to CC: the USB development list <linux-usb@vger.kernel.org>
29	*/	29	*/
30		30
		31	/* Reported-by: Julian Groß <julian.g@posteo.de> */
		32	UNUSUAL_DEV(0x059f, 0x105f, 0x0000, 0x9999,
		33	"LaCie",
		34	"2Big Quadra USB3",
		35	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
		36	US_FL_NO_REPORT_OPCODES),
		37
31	/*	38	/*
32	* Apricorn USB3 dongle sometimes returns "USBSUSBSUSBS" in response to SCSI	39	* Apricorn USB3 dongle sometimes returns "USBSUSBSUSBS" in response to SCSI
33	* commands in UAS mode. Observed with the 1.28 firmware; are there others?	40	* commands in UAS mode. Observed with the 1.28 firmware; are there others?

drivers/usb/typec/mux/intel_pmc_mux.c+6−2

 	req.mode_data |= (state->mode - TYPEC_STATE_MODAL) <<
 			 PMC_USB_ALTMODE_DP_MODE_SHIFT;
+	if (data->status & DP_STATUS_HPD_STATE)
+		req.mode_data |= PMC_USB_DP_HPD_LVL <<
+				 PMC_USB_ALTMODE_DP_MODE_SHIFT;
 	return pmc_usb_command(port, (void *)&req, sizeof(req));
 }
 	struct typec_mux_desc mux_desc = { };
 	int ret;
-	ret = fwnode_property_read_u8(fwnode, "usb2-port", &port->usb2_port);
+	ret = fwnode_property_read_u8(fwnode, "usb2-port-number", &port->usb2_port);
 	if (ret)
 		return ret;
-	ret = fwnode_property_read_u8(fwnode, "usb3-port", &port->usb3_port);
+	ret = fwnode_property_read_u8(fwnode, "usb3-port-number", &port->usb3_port);
 	if (ret)
 		return ret;

drivers/vfio/vfio_iommu_type1.c+5−5

@@ -342,8 +342,8 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr, · 341 unmodified lines
342	vma = find_vma_intersection(mm, vaddr, vaddr + 1);	342	vma = find_vma_intersection(mm, vaddr, vaddr + 1);
343		343
344	if (vma && vma->vm_flags & VM_PFNMAP) {	344	if (vma && vma->vm_flags & VM_PFNMAP) {
345	*pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;	345	if (!follow_pfn(vma, vaddr, pfn) &&
346	if (is_invalid_reserved_pfn(*pfn))	346	is_invalid_reserved_pfn(*pfn))
347	ret = 0;	347	ret = 0;
348	}	348	}
349	done:	349	done:
@@ -555,7 +555,7 @@ static int vfio_iommu_type1_pin_pages(void *iommu_data, · 205 unmodified lines
555	continue;	555	continue;
556	}	556	}
557		557
558	remote_vaddr = dma->vaddr + iova - dma->iova;	558	remote_vaddr = dma->vaddr + (iova - dma->iova);
559	ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i],	559	ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i],
560	do_accounting);	560	do_accounting);
561	if (ret)	561	if (ret)
@@ -2345,10 +2345,10 @@ static int vfio_iommu_type1_dma_rw_chunk(struct vfio_iommu *iommu, · 1783 unmodified lines
2345	vaddr = dma->vaddr + offset;	2345	vaddr = dma->vaddr + offset;
2346		2346
2347	if (write)	2347	if (write)
2348	copied = __copy_to_user((void __user )vaddr, data,	2348	copied = copy_to_user((void __user )vaddr, data,
2349	count) ? 0 : count;	2349	count) ? 0 : count;
2350	else	2350	else
2351	copied = __copy_from_user(data, (void __user )vaddr,	2351	copied = copy_from_user(data, (void __user )vaddr,
2352	count) ? 0 : count;	2352	count) ? 0 : count;
2353	if (kthread)	2353	if (kthread)
2354	unuse_mm(mm);	2354	unuse_mm(mm);

drivers/vhost/vsock.c+16−5

 			break;
 		}
-		vhost_add_used(vq, head, sizeof(pkt->hdr) + payload_len);
+		/* Deliver to monitoring devices all packets that we
-		added = true;
+		 * will transmit.
-		/* Deliver to monitoring devices all correctly transmitted
-		 * packets.
 		 */
 		virtio_transport_deliver_tap_pkt(pkt);
+		vhost_add_used(vq, head, sizeof(pkt->hdr) + payload_len);
+		added = true;
 		pkt->off += payload_len;
 		total_len += payload_len;
 		 * to send it with the next available buffer.
 		 */
 		if (pkt->off < pkt->len) {
+			/* We are queueing the same virtio_vsock_pkt to handle
+			 * the remaining bytes, and we want to deliver it
+			 * to monitoring devices in the next iteration.
+			 */
+			pkt->tap_delivered = false;
 			spin_lock_bh(&vsock->send_pkt_list_lock);
 			list_add(&pkt->list, &vsock->send_pkt_list);
 			spin_unlock_bh(&vsock->send_pkt_list_lock);
 		mutex_unlock(&vq->mutex);
 	}
+	/* Some packets may have been queued before the device was started,
+	 * let's kick the send worker to send them.
+	 */
+	vhost_work_queue(&vsock->dev, &vsock->send_pkt_work);
 	mutex_unlock(&vsock->dev.mutex);
 	return 0;

fs/btrfs/backref.c+1−1

@@ -391,7 +391,7 @@ static int is_shared_data_backref(struct preftrees *preftrees, u64 bytenr) · 390 unmodified lines
391	struct rb_node **p = &preftrees->direct.root.rb_root.rb_node;	391	struct rb_node **p = &preftrees->direct.root.rb_root.rb_node;
392	struct rb_node *parent = NULL;	392	struct rb_node *parent = NULL;
393	struct prelim_ref *ref = NULL;	393	struct prelim_ref *ref = NULL;
394	struct prelim_ref target = {0};	394	struct prelim_ref target = {};
395	int result;	395	int result;
396		396
397	target.parent = bytenr;	397	target.parent = bytenr;

fs/btrfs/block-group.c+14−6

 	path = btrfs_alloc_path();
 	if (!path) {
 		ret = -ENOMEM;
-		goto out;
+		goto out_put_group;
 	}
 	/*
 		ret = btrfs_orphan_add(trans, BTRFS_I(inode));
 		if (ret) {
 			btrfs_add_delayed_iput(inode);
-			goto out;
+			goto out_put_group;
 		}
 		clear_nlink(inode);
 		/* One for the block groups ref */
 	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
 	if (ret < 0)
-		goto out;
+		goto out_put_group;
 	if (ret > 0)
 		btrfs_release_path(path);
 	if (ret == 0) {
 		ret = btrfs_del_item(trans, tree_root, path);
 		if (ret)
-			goto out;
+			goto out_put_group;
 		btrfs_release_path(path);
 	}
 	ret = remove_block_group_free_space(trans, block_group);
 	if (ret)
-		goto out;
+		goto out_put_group;
-	btrfs_put_block_group(block_group);
+	/* Once for the block groups rbtree */
 	btrfs_put_block_group(block_group);
 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 		/* once for the tree */
 		free_extent_map(em);
 	}
+out_put_group:
+	/* Once for the lookup reference */
+	btrfs_put_block_group(block_group);
 out:
 	if (remove_rsv)
 		btrfs_delayed_refs_rsv_release(fs_info, 1);
 	if (ret)
 		goto err;
 	mutex_unlock(&fs_info->unused_bg_unpin_mutex);
+	if (prev_trans)
+		btrfs_put_transaction(prev_trans);
 	return true;
 err:
 	mutex_unlock(&fs_info->unused_bg_unpin_mutex);
+	if (prev_trans)
+		btrfs_put_transaction(prev_trans);
 	btrfs_dec_block_group_ro(bg);
 	return false;
 }

fs/btrfs/discard.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2		2
3	#ifndef BTRFS_DISCARD_H	3	#ifndef BTRFS_DISCARD_H
4	#define BTRFS_DISCARD_H	4	#define BTRFS_DISCARD_H

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

@@ -2036,9 +2036,6 @@ void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info) · 2035 unmodified lines
2036	for (i = 0; i < ret; i++)	2036	for (i = 0; i < ret; i++)
2037	btrfs_drop_and_free_fs_root(fs_info, gang[i]);	2037	btrfs_drop_and_free_fs_root(fs_info, gang[i]);
2038	}	2038	}
2039
2040	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
2041	btrfs_free_log_root_tree(NULL, fs_info);
2042	}	2039	}
2043		2040
2044	static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)	2041	static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
@@ -3888,7 +3885,7 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info, · 1843 unmodified lines
3888	spin_unlock(&fs_info->fs_roots_radix_lock);	3885	spin_unlock(&fs_info->fs_roots_radix_lock);
3889		3886
3890	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {	3887	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
3891	btrfs_free_log(NULL, root);	3888	ASSERT(root->log_root == NULL);
3892	if (root->reloc_root) {	3889	if (root->reloc_root) {
3893	btrfs_put_root(root->reloc_root);	3890	btrfs_put_root(root->reloc_root);
3894	root->reloc_root = NULL;	3891	root->reloc_root = NULL;
@@ -4211,6 +4208,36 @@ static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info) · 316 unmodified lines
4211	up_write(&fs_info->cleanup_work_sem);	4208	up_write(&fs_info->cleanup_work_sem);
4212	}	4209	}
4213		4210
		4211	static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)
		4212	{
		4213	struct btrfs_root *gang[8];
		4214	u64 root_objectid = 0;
		4215	int ret;
		4216
		4217	spin_lock(&fs_info->fs_roots_radix_lock);
		4218	while ((ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
		4219	(void **)gang, root_objectid,
		4220	ARRAY_SIZE(gang))) != 0) {
		4221	int i;
		4222
		4223	for (i = 0; i < ret; i++)
		4224	gang[i] = btrfs_grab_root(gang[i]);
		4225	spin_unlock(&fs_info->fs_roots_radix_lock);
		4226
		4227	for (i = 0; i < ret; i++) {
		4228	if (!gang[i])
		4229	continue;
		4230	root_objectid = gang[i]->root_key.objectid;
		4231	btrfs_free_log(NULL, gang[i]);
		4232	btrfs_put_root(gang[i]);
		4233	}
		4234	root_objectid++;
		4235	spin_lock(&fs_info->fs_roots_radix_lock);
		4236	}
		4237	spin_unlock(&fs_info->fs_roots_radix_lock);
		4238	btrfs_free_log_root_tree(NULL, fs_info);
		4239	}
		4240
4214	static void btrfs_destroy_ordered_extents(struct btrfs_root *root)	4241	static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
4215	{	4242	{
4216	struct btrfs_ordered_extent *ordered;	4243	struct btrfs_ordered_extent *ordered;
@@ -4603,6 +4630,7 @@ static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info) · 386 unmodified lines
4603	btrfs_destroy_delayed_inodes(fs_info);	4630	btrfs_destroy_delayed_inodes(fs_info);
4604	btrfs_assert_delayed_root_empty(fs_info);	4631	btrfs_assert_delayed_root_empty(fs_info);
4605	btrfs_destroy_all_delalloc_inodes(fs_info);	4632	btrfs_destroy_all_delalloc_inodes(fs_info);
		4633	btrfs_drop_all_logs(fs_info);
4606	mutex_unlock(&fs_info->transaction_kthread_mutex);	4634	mutex_unlock(&fs_info->transaction_kthread_mutex);
4607		4635
4608	return 0;	4636	return 0;

fs/btrfs/relocation.c+1−0

@@ -4559,6 +4559,7 @@ int btrfs_recover_relocation(struct btrfs_root *root) · 4558 unmodified lines
4559	if (IS_ERR(fs_root)) {	4559	if (IS_ERR(fs_root)) {
4560	err = PTR_ERR(fs_root);	4560	err = PTR_ERR(fs_root);
4561	list_add_tail(&reloc_root->root_list, &reloc_roots);	4561	list_add_tail(&reloc_root->root_list, &reloc_roots);
		4562	btrfs_end_transaction(trans);
4562	goto out_unset;	4563	goto out_unset;
4563	}	4564	}
4564		4565

fs/btrfs/transaction.c+11−2

@@ -662,10 +662,19 @@ again: · 661 unmodified lines
662	}	662	}
663		663
664	got_it:	664	got_it:
665	btrfs_record_root_in_trans(h, root);
666
667	if (!current->journal_info)	665	if (!current->journal_info)
668	current->journal_info = h;	666	current->journal_info = h;
		667
		668	/*
		669	* btrfs_record_root_in_trans() needs to alloc new extents, and may
		670	* call btrfs_join_transaction() while we're also starting a
		671	* transaction.
		672	*
		673	* Thus it need to be called after current->journal_info initialized,
		674	* or we can deadlock.
		675	*/
		676	btrfs_record_root_in_trans(h, root);
		677
669	return h;	678	return h;
670		679
671	join_fail:	680	join_fail:

fs/btrfs/tree-log.c+40−3

@@ -4226,6 +4226,9 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 4225 unmodified lines
4226	const u64 ino = btrfs_ino(inode);	4226	const u64 ino = btrfs_ino(inode);
4227	struct btrfs_path *dst_path = NULL;	4227	struct btrfs_path *dst_path = NULL;
4228	bool dropped_extents = false;	4228	bool dropped_extents = false;
		4229	u64 truncate_offset = i_size;
		4230	struct extent_buffer *leaf;
		4231	int slot;
4229	int ins_nr = 0;	4232	int ins_nr = 0;
4230	int start_slot;	4233	int start_slot;
4231	int ret;	4234	int ret;
@@ -4240,9 +4243,43 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 8 unmodified lines
4240	if (ret < 0)	4243	if (ret < 0)
4241	goto out;	4244	goto out;
4242		4245
		4246	/*
		4247	* We must check if there is a prealloc extent that starts before the
		4248	* i_size and crosses the i_size boundary. This is to ensure later we
		4249	* truncate down to the end of that extent and not to the i_size, as
		4250	* otherwise we end up losing part of the prealloc extent after a log
		4251	* replay and with an implicit hole if there is another prealloc extent
		4252	* that starts at an offset beyond i_size.
		4253	*/
		4254	ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY);
		4255	if (ret < 0)
		4256	goto out;
		4257
		4258	if (ret == 0) {
		4259	struct btrfs_file_extent_item *ei;
		4260
		4261	leaf = path->nodes[0];
		4262	slot = path->slots[0];
		4263	ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
		4264
		4265	if (btrfs_file_extent_type(leaf, ei) ==
		4266	BTRFS_FILE_EXTENT_PREALLOC) {
		4267	u64 extent_end;
		4268
		4269	btrfs_item_key_to_cpu(leaf, &key, slot);
		4270	extent_end = key.offset +
		4271	btrfs_file_extent_num_bytes(leaf, ei);
		4272
		4273	if (extent_end > i_size)
		4274	truncate_offset = extent_end;
		4275	}
		4276	} else {
		4277	ret = 0;
		4278	}
		4279
4243	while (true) {	4280	while (true) {
4244	struct extent_buffer *leaf = path->nodes[0];	4281	leaf = path->nodes[0];
4245	int slot = path->slots[0];	4282	slot = path->slots[0];
4246		4283
4247	if (slot >= btrfs_header_nritems(leaf)) {	4284	if (slot >= btrfs_header_nritems(leaf)) {
4248	if (ins_nr > 0) {	4285	if (ins_nr > 0) {
@@ -4280,7 +4317,7 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 31 unmodified lines
4280	ret = btrfs_truncate_inode_items(trans,	4317	ret = btrfs_truncate_inode_items(trans,
4281	root->log_root,	4318	root->log_root,
4282	&inode->vfs_inode,	4319	&inode->vfs_inode,
4283	i_size,	4320	truncate_offset,
4284	BTRFS_EXTENT_DATA_KEY);	4321	BTRFS_EXTENT_DATA_KEY);
4285	} while (ret == -EAGAIN);	4322	} while (ret == -EAGAIN);
4286	if (ret)	4323	if (ret)

fs/ceph/caps.c+2−1

 	ret = try_get_cap_refs(inode, need, want, 0, flags, got);
 	/* three special error codes */
-	if (ret == -EAGAIN || ret == -EFBIG || ret == -EAGAIN)
+	if (ret == -EAGAIN || ret == -EFBIG || ret == -ESTALE)
 		ret = 0;
 	return ret;
 }
 		WARN_ON(1);
 		tsession = NULL;
 		target = -1;
+		mutex_lock(&session->s_mutex);
 	}
 	goto retry;

fs/ceph/debugfs.c+1−1

@@ -271,7 +271,7 @@ void ceph_fs_debugfs_init(struct ceph_fs_client *fsc) · 270 unmodified lines
271	&congestion_kb_fops);	271	&congestion_kb_fops);
272		272
273	snprintf(name, sizeof(name), "../../bdi/%s",	273	snprintf(name, sizeof(name), "../../bdi/%s",
274	dev_name(fsc->sb->s_bdi->dev));	274	bdi_dev_name(fsc->sb->s_bdi));
275	fsc->debugfs_bdi =	275	fsc->debugfs_bdi =
276	debugfs_create_symlink("bdi",	276	debugfs_create_symlink("bdi",
277	fsc->client->debugfs_dir,	277	fsc->client->debugfs_dir,

fs/ceph/mds_client.c+3−5

 	void *end = p + msg->front.iov_len;
 	struct ceph_mds_session_head *h;
 	u32 op;
-	u64 seq;
+	u64 seq, features = 0;
-	unsigned long features = 0;
 	int wake = 0;
 	bool blacklisted = false;
 			goto bad;
 		/* version >= 3, feature bits */
 		ceph_decode_32_safe(&p, end, len, bad);
-		ceph_decode_need(&p, end, len, bad);
+		ceph_decode_64_safe(&p, end, features, bad);
-		memcpy(&features, p, min_t(size_t, len, sizeof(features)));
+		p += len - sizeof(features);
-		p += len;
 	}
 	mutex_lock(&mdsc->mutex);

fs/ceph/quota.c+2−2

@@ -159,8 +159,8 @@ static struct inode lookup_quotarealm_inode(struct ceph_mds_client mdsc, · 158 unmodified lines
159	}	159	}
160		160
161	if (IS_ERR(in)) {	161	if (IS_ERR(in)) {
162	pr_warn("Can't lookup inode %llx (err: %ld)\n",	162	dout("Can't lookup inode %llx (err: %ld)\n",
163	realm->ino, PTR_ERR(in));	163	realm->ino, PTR_ERR(in));
164	qri->timeout = jiffies + msecs_to_jiffies(60 * 1000); /* XXX */	164	qri->timeout = jiffies + msecs_to_jiffies(60 * 1000); /* XXX */
165	} else {	165	} else {
166	qri->timeout = 0;	166	qri->timeout = 0;

fs/configfs/dir.c+1−0

@@ -1519,6 +1519,7 @@ static int configfs_rmdir(struct inode dir, struct dentry dentry) · 1518 unmodified lines
1519	spin_lock(&configfs_dirent_lock);	1519	spin_lock(&configfs_dirent_lock);
1520	configfs_detach_rollback(dentry);	1520	configfs_detach_rollback(dentry);
1521	spin_unlock(&configfs_dirent_lock);	1521	spin_unlock(&configfs_dirent_lock);
		1522	config_item_put(parent_item);
1522	return -EINTR;	1523	return -EINTR;
1523	}	1524	}
1524	frag->frag_dead = true;	1525	frag->frag_dead = true;

fs/coredump.c+8−0

@@ -788,6 +788,14 @@ void do_coredump(const kernel_siginfo_t *siginfo) · 787 unmodified lines
788	if (displaced)	788	if (displaced)
789	put_files_struct(displaced);	789	put_files_struct(displaced);
790	if (!dump_interrupted()) {	790	if (!dump_interrupted()) {
		791	/*
		792	* umh disabled with CONFIG_STATIC_USERMODEHELPER_PATH="" would
		793	* have this set to NULL.
		794	*/
		795	if (!cprm.file) {
		796	pr_info("Core dump to \|%s disabled\n", cn.corename);
		797	goto close_fail;
		798	}
791	file_start_write(cprm.file);	799	file_start_write(cprm.file);
792	core_dumped = binfmt->core_dump(&cprm);	800	core_dumped = binfmt->core_dump(&cprm);
793	file_end_write(cprm.file);	801	file_end_write(cprm.file);

fs/eventpoll.c+33−28

@@ -1171,6 +1171,10 @@ static inline bool chain_epi_lockless(struct epitem *epi) · 1170 unmodified lines
1171	{	1171	{
1172	struct eventpoll *ep = epi->ep;	1172	struct eventpoll *ep = epi->ep;
1173		1173
		1174	/* Fast preliminary check */
		1175	if (epi->next != EP_UNACTIVE_PTR)
		1176	return false;
		1177
1174	/* Check that the same epi has not been just chained from another CPU */	1178	/* Check that the same epi has not been just chained from another CPU */
1175	if (cmpxchg(&epi->next, EP_UNACTIVE_PTR, NULL) != EP_UNACTIVE_PTR)	1179	if (cmpxchg(&epi->next, EP_UNACTIVE_PTR, NULL) != EP_UNACTIVE_PTR)
1176	return false;	1180	return false;
@@ -1237,16 +1241,12 @@ static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode, int sync, v · 60 unmodified lines
1237	* chained in ep->ovflist and requeued later on.	1241	* chained in ep->ovflist and requeued later on.
1238	*/	1242	*/
1239	if (READ_ONCE(ep->ovflist) != EP_UNACTIVE_PTR) {	1243	if (READ_ONCE(ep->ovflist) != EP_UNACTIVE_PTR) {
1240	if (epi->next == EP_UNACTIVE_PTR &&	1244	if (chain_epi_lockless(epi))
1241	chain_epi_lockless(epi))	1245	ep_pm_stay_awake_rcu(epi);
		1246	} else if (!ep_is_linked(epi)) {
		1247	/* In the usual case, add event to ready list. */
		1248	if (list_add_tail_lockless(&epi->rdllink, &ep->rdllist))
1242	ep_pm_stay_awake_rcu(epi);	1249	ep_pm_stay_awake_rcu(epi);
1243	goto out_unlock;
1244	}
1245
1246	/* If this file is already in the ready list we exit soon */
1247	if (!ep_is_linked(epi) &&
1248	list_add_tail_lockless(&epi->rdllink, &ep->rdllist)) {
1249	ep_pm_stay_awake_rcu(epi);
1250	}	1250	}
1251		1251
1252	/*	1252	/*
@@ -1822,7 +1822,6 @@ static int ep_poll(struct eventpoll ep, struct epoll_event __user events, · 569 unmodified lines
1822	{	1822	{
1823	int res = 0, eavail, timed_out = 0;	1823	int res = 0, eavail, timed_out = 0;
1824	u64 slack = 0;	1824	u64 slack = 0;
1825	bool waiter = false;
1826	wait_queue_entry_t wait;	1825	wait_queue_entry_t wait;
1827	ktime_t expires, *to = NULL;	1826	ktime_t expires, *to = NULL;
1828		1827
@@ -1867,21 +1866,23 @@ fetch_events: · 38 unmodified lines
1867	*/	1866	*/
1868	ep_reset_busy_poll_napi_id(ep);	1867	ep_reset_busy_poll_napi_id(ep);
1869		1868
1870	/*	1869	do {
1871	* We don't have any available event to return to the caller. We need	1870	/*
1872	* to sleep here, and we will be woken by ep_poll_callback() when events	1871	* Internally init_wait() uses autoremove_wake_function(),
1873	* become available.	1872	* thus wait entry is removed from the wait queue on each
1874	*/	1873	* wakeup. Why it is important? In case of several waiters
1875	if (!waiter) {	1874	* each new wakeup will hit the next waiter, giving it the
1876	waiter = true;	1875	* chance to harvest new event. Otherwise wakeup can be
1877	init_waitqueue_entry(&wait, current);	1876	* lost. This is also good performance-wise, because on
1878		1877	* normal wakeup path no need to call __remove_wait_queue()
		1878	* explicitly, thus ep->lock is not taken, which halts the
		1879	* event delivery.
		1880	*/
		1881	init_wait(&wait);
1879	write_lock_irq(&ep->lock);	1882	write_lock_irq(&ep->lock);
1880	__add_wait_queue_exclusive(&ep->wq, &wait);	1883	__add_wait_queue_exclusive(&ep->wq, &wait);
1881	write_unlock_irq(&ep->lock);	1884	write_unlock_irq(&ep->lock);
1882	}
1883		1885
1884	for (;;) {
1885	/*	1886	/*
1886	* We don't want to sleep if the ep_poll_callback() sends us	1887	* We don't want to sleep if the ep_poll_callback() sends us
1887	* a wakeup in between. That's why we set the task state	1888	* a wakeup in between. That's why we set the task state
@@ -1911,10 +1912,20 @@ fetch_events: · 23 unmodified lines
1911	timed_out = 1;	1912	timed_out = 1;
1912	break;	1913	break;
1913	}	1914	}
1914	}	1915
		1916	/* We were woken up, thus go and try to harvest some events */
		1917	eavail = 1;
		1918
		1919	} while (0);
1915		1920
1916	__set_current_state(TASK_RUNNING);	1921	__set_current_state(TASK_RUNNING);
1917		1922
		1923	if (!list_empty_careful(&wait.entry)) {
		1924	write_lock_irq(&ep->lock);
		1925	__remove_wait_queue(&ep->wq, &wait);
		1926	write_unlock_irq(&ep->lock);
		1927	}
		1928
1918	send_events:	1929	send_events:
1919	/*	1930	/*
1920	* Try to transfer events to user space. In case we get 0 events and	1931	* Try to transfer events to user space. In case we get 0 events and
@@ -1925,12 +1936,6 @@ send_events: · 4 unmodified lines
1925	!(res = ep_send_events(ep, events, maxevents)) && !timed_out)	1936	!(res = ep_send_events(ep, events, maxevents)) && !timed_out)
1926	goto fetch_events;	1937	goto fetch_events;
1927		1938
1928	if (waiter) {
1929	write_lock_irq(&ep->lock);
1930	__remove_wait_queue(&ep->wq, &wait);
1931	write_unlock_irq(&ep->lock);
1932	}
1933
1934	return res;	1939	return res;
1935	}	1940	}
1936		1941

fs/io_uring.c+53−70

 	REQ_F_OVERFLOW_BIT,
 	REQ_F_POLLED_BIT,
 	REQ_F_BUFFER_SELECTED_BIT,
+	REQ_F_NO_FILE_TABLE_BIT,
 	/* not a real bit, just to check we're not overflowing the space */
 	__REQ_F_LAST_BIT,
 	REQ_F_POLLED		= BIT(REQ_F_POLLED_BIT),
 	/* buffer already selected */
 	REQ_F_BUFFER_SELECTED	= BIT(REQ_F_BUFFER_SELECTED_BIT),
+	/* doesn't need file table for this request */
+	REQ_F_NO_FILE_TABLE	= BIT(REQ_F_NO_FILE_TABLE_BIT),
 };
 struct async_poll {
 	unsigned		needs_mm : 1;
 	/* needs req->file assigned */
 	unsigned		needs_file : 1;
-	/* needs req->file assigned IFF fd is >= 0 */
-	unsigned		fd_non_neg : 1;
 	/* hash wq insertion if file is a regular file */
 	unsigned		hash_reg_file : 1;
 	/* unbound wq insertion if file is a non-regular file */
 		.needs_file		= 1,
 	},
 	[IORING_OP_OPENAT] = {
-		.needs_file		= 1,
-		.fd_non_neg		= 1,
 		.file_table		= 1,
 		.needs_fs		= 1,
 	},
 	},
 	[IORING_OP_STATX] = {
 		.needs_mm		= 1,
-		.needs_file		= 1,
-		.fd_non_neg		= 1,
 		.needs_fs		= 1,
+		.file_table		= 1,
 	},
 	[IORING_OP_READ] = {
 		.needs_mm		= 1,
 		.buffer_select		= 1,
 	},
 	[IORING_OP_OPENAT2] = {
-		.needs_file		= 1,
-		.fd_non_neg		= 1,
 		.file_table		= 1,
 		.needs_fs		= 1,
 	},
 	struct io_kiocb *req;
 	req = ctx->fallback_req;
-	if (!test_and_set_bit_lock(0, (unsigned long *) ctx->fallback_req))
+	if (!test_and_set_bit_lock(0, (unsigned long *) &ctx->fallback_req))
 		return req;
 	return NULL;
 	if (likely(!io_is_fallback_req(req)))
 		kmem_cache_free(req_cachep, req);
 	else
-		clear_bit_unlock(0, (unsigned long *) req->ctx->fallback_req);
+		clear_bit_unlock(0, (unsigned long *) &req->ctx->fallback_req);
 }
 struct req_batch {
  * any file. For now, just ensure that anything potentially problematic is done
  * inline.
  */
-static bool io_file_supports_async(struct file *file)
+static bool io_file_supports_async(struct file *file, int rw)
 {
 	umode_t mode = file_inode(file)->i_mode;
 	if (S_ISREG(mode) && file->f_op != &io_uring_fops)
 		return true;
-	return false;
+	if (!(file->f_mode & FMODE_NOWAIT))
+		return false;
+	if (rw == READ)
+		return file->f_op->read_iter != NULL;
+	return file->f_op->write_iter != NULL;
 }
 static int io_prep_rw(struct io_kiocb *req, const struct io_uring_sqe *sqe,
 	 * If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
 	 * we know to async punt it even if it was opened O_NONBLOCK
 	 */
-	if (force_nonblock && !io_file_supports_async(req->file))
+	if (force_nonblock && !io_file_supports_async(req->file, READ))
 		goto copy_iov;
 	iov_count = iov_iter_count(&iter);
 			if (ret)
 				goto out_free;
 			/* any defer here is final, must blocking retry */
-			if (!(req->flags & REQ_F_NOWAIT))
+			if (!(req->flags & REQ_F_NOWAIT) &&
+			    !file_can_poll(req->file))
 				req->flags |= REQ_F_MUST_PUNT;
 			return -EAGAIN;
 		}
 	 * If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
 	 * we know to async punt it even if it was opened O_NONBLOCK
 	 */
-	if (force_nonblock && !io_file_supports_async(req->file))
+	if (force_nonblock && !io_file_supports_async(req->file, WRITE))
 		goto copy_iov;
 	/* file path doesn't support NOWAIT for non-direct_IO */
 			if (ret)
 				goto out_free;
 			/* any defer here is final, must blocking retry */
-			req->flags |= REQ_F_MUST_PUNT;
+			if (!file_can_poll(req->file))
+				req->flags |= REQ_F_MUST_PUNT;
 			return -EAGAIN;
 		}
 	}
 	return 0;
 }
-static bool io_splice_punt(struct file *file)
-{
-	if (get_pipe_info(file))
-		return false;
-	if (!io_file_supports_async(file))
-		return true;
-	return !(file->f_flags & O_NONBLOCK);
-}
 static int io_splice(struct io_kiocb *req, bool force_nonblock)
 {
 	struct io_splice *sp = &req->splice;
 	loff_t *poff_in, *poff_out;
 	long ret;
-	if (force_nonblock) {
+	if (force_nonblock)
-		if (io_splice_punt(in) || io_splice_punt(out))
+		return -EAGAIN;
-			return -EAGAIN;
-		flags |= SPLICE_F_NONBLOCK;
-	}
 	poff_in = (sp->off_in == -1) ? NULL : &sp->off_in;
 	poff_out = (sp->off_out == -1) ? NULL : &sp->off_out;
 	struct kstat stat;
 	int ret;
-	if (force_nonblock)
+	if (force_nonblock) {
+		/* only need file table for an actual valid fd */
+		if (ctx->dfd == -1 || ctx->dfd == AT_FDCWD)
+			req->flags |= REQ_F_NO_FILE_TABLE;
 		return -EAGAIN;
+	}
 	if (vfs_stat_set_lookup_flags(&lookup_flags, ctx->how.flags))
 		return -EINVAL;
 	if (io_req_cancelled(req))
 		return;
 	__io_sync_file_range(req);
-	io_put_req(req); /* put submission ref */
+	io_steal_work(req, workptr);
 }
 static int io_sync_file_range(struct io_kiocb *req, bool force_nonblock)
 	int ret;
 	/* Still need defer if there is pending req in defer list. */
-	if (!req_need_defer(req) && list_empty(&ctx->defer_list))
+	if (!req_need_defer(req) && list_empty_careful(&ctx->defer_list))
 		return 0;
 	if (!req->io && io_alloc_async_ctx(req))
 	io_steal_work(req, workptr);
 }
-static int io_req_needs_file(struct io_kiocb *req, int fd)
-{
-	if (!io_op_defs[req->opcode].needs_file)
-		return 0;
-	if ((fd == -1 || fd == AT_FDCWD) && io_op_defs[req->opcode].fd_non_neg)
-		return 0;
-	return 1;
-}
 static inline struct file *io_file_from_index(struct io_ring_ctx *ctx,
 					      int index)
 {
 }
 static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req,
-			   int fd, unsigned int flags)
+			   int fd)
 {
 	bool fixed;
-	if (!io_req_needs_file(req, fd))
+	fixed = (req->flags & REQ_F_FIXED_FILE) != 0;
-		return 0;
-	fixed = (flags & IOSQE_FIXED_FILE);
 	if (unlikely(!fixed && req->needs_fixed_file))
 		return -EBADF;
 	int ret = -EBADF;
 	struct io_ring_ctx *ctx = req->ctx;
-	if (req->work.files)
+	if (req->work.files || (req->flags & REQ_F_NO_FILE_TABLE))
 		return 0;
 	if (!ctx->ring_file)
 		return -EBADF;
 		       struct io_submit_state *state, bool async)
 {
 	unsigned int sqe_flags;
-	int id, fd;
+	int id;
 	/*
 	 * All io need record the previous position, if LINK vs DARIN,
 					IOSQE_ASYNC | IOSQE_FIXED_FILE |
 					IOSQE_BUFFER_SELECT | IOSQE_IO_LINK);
-	fd = READ_ONCE(sqe->fd);
+	if (!io_op_defs[req->opcode].needs_file)
-	return io_req_set_file(state, req, fd, sqe_flags);
+		return 0;
+	return io_req_set_file(state, req, READ_ONCE(sqe->fd));
 }
 static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr,
 	 * it could cause shutdown to hang.
 	 */
 	while (ctx->sqo_thread && !wq_has_sleeper(&ctx->sqo_wait))
-		cpu_relax();
+		cond_resched();
 	io_kill_timeouts(ctx);
 	io_poll_remove_all(ctx);
 static void io_uring_cancel_files(struct io_ring_ctx *ctx,
 				  struct files_struct *files)
 {
-	struct io_kiocb *req;
-	DEFINE_WAIT(wait);
 	while (!list_empty_careful(&ctx->inflight_list)) {
-		struct io_kiocb *cancel_req = NULL;
+		struct io_kiocb *cancel_req = NULL, *req;
+		DEFINE_WAIT(wait);
 		spin_lock_irq(&ctx->inflight_lock);
 		list_for_each_entry(req, &ctx->inflight_list, inflight_entry) {
 			 */
 			if (refcount_sub_and_test(2, &cancel_req->refs)) {
 				io_put_req(cancel_req);
+				finish_wait(&ctx->inflight_wait, &wait);
 				continue;
 			}
 		}
 		io_wq_cancel_work(ctx->io_wq, &cancel_req->work);
 		io_put_req(cancel_req);
 		schedule();
+		finish_wait(&ctx->inflight_wait, &wait);
 	}
-	finish_wait(&ctx->inflight_wait, &wait);
 }
 static int io_uring_flush(struct file *file, void *data)
 	return ret;
 }
-static int io_uring_create(unsigned entries, struct io_uring_params *p)
+static int io_uring_create(unsigned entries, struct io_uring_params *p,
+			   struct io_uring_params __user *params)
 {
 	struct user_struct *user = NULL;
 	struct io_ring_ctx *ctx;
 	p->cq_off.overflow = offsetof(struct io_rings, cq_overflow);
 	p->cq_off.cqes = offsetof(struct io_rings, cqes);
+	p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP |
+			IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS |
+			IORING_FEAT_CUR_PERSONALITY | IORING_FEAT_FAST_POLL;
+	if (copy_to_user(params, p, sizeof(*p))) {
+		ret = -EFAULT;
+		goto err;
+	}
 	/*
 	 * Install ring fd as the very last thing, so we don't risk someone
 	 * having closed it before we finish setup
 	if (ret < 0)
 		goto err;
-	p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP |
-			IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS |
-			IORING_FEAT_CUR_PERSONALITY | IORING_FEAT_FAST_POLL;
 	trace_io_uring_create(ret, ctx, p->sq_entries, p->cq_entries, p->flags);
 	return ret;
 err:
 static long io_uring_setup(u32 entries, struct io_uring_params __user *params)
 {
 	struct io_uring_params p;
-	long ret;
 	int i;
 	if (copy_from_user(&p, params, sizeof(p)))
 			IORING_SETUP_CLAMP | IORING_SETUP_ATTACH_WQ))
 		return -EINVAL;
-	ret = io_uring_create(entries, &p);
+	return  io_uring_create(entries, &p, params);
-	if (ret < 0)
-		return ret;
-	if (copy_to_user(params, &p, sizeof(p)))
-		return -EFAULT;
-	return ret;
 }
 SYSCALL_DEFINE2(io_uring_setup, u32, entries,

fs/ioctl.c+8−0

 static int ioctl_fibmap(struct file *filp, int __user *p)
 {
 	struct inode *inode = file_inode(filp);
+	struct super_block *sb = inode->i_sb;
 	int error, ur_block;
 	sector_t block;
 	block = ur_block;
 	error = bmap(inode, &block);
+	if (block > INT_MAX) {
+		error = -ERANGE;
+		pr_warn_ratelimited("[%s/%d] FS: %s File: %pD4 would truncate fibmap result\n",
+				    current->comm, task_pid_nr(current),
+				    sb->s_id, filp);
+	}
 	if (error)
 		ur_block = 0;
 	else

fs/iomap/fiemap.c+1−4

 	if (iomap->type == IOMAP_MAPPED) {
 		addr = (pos - iomap->offset + iomap->addr) >> inode->i_blkbits;
-		if (addr > INT_MAX)
+		*bno = addr;
-			WARN(1, "would truncate bmap result\n");
-		else
-			*bno = addr;
 	}
 	return 0;
 }

fs/nfs/nfs3acl.c+15−7

 int nfs3_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 {
-	struct posix_acl *alloc = NULL, *dfacl = NULL;
+	struct posix_acl *orig = acl, *dfacl = NULL, *alloc;
 	int status;
 	if (S_ISDIR(inode->i_mode)) {
 		switch(type) {
 		case ACL_TYPE_ACCESS:
-			alloc = dfacl = get_acl(inode, ACL_TYPE_DEFAULT);
+			alloc = get_acl(inode, ACL_TYPE_DEFAULT);
 			if (IS_ERR(alloc))
 				goto fail;
+			dfacl = alloc;
 			break;
 		case ACL_TYPE_DEFAULT:
-			dfacl = acl;
+			alloc = get_acl(inode, ACL_TYPE_ACCESS);
-			alloc = acl = get_acl(inode, ACL_TYPE_ACCESS);
 			if (IS_ERR(alloc))
 				goto fail;
+			dfacl = acl;
+			acl = alloc;
 			break;
 		}
 	}
 	if (acl == NULL) {
-		alloc = acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
+		alloc = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
 		if (IS_ERR(alloc))
 			goto fail;
+		acl = alloc;
 	}
 	status = __nfs3_proc_setacls(inode, acl, dfacl);
-	posix_acl_release(alloc);
+out:
+	if (acl != orig)
+		posix_acl_release(acl);
+	if (dfacl != orig)
+		posix_acl_release(dfacl);
 	return status;
 fail:
-	return PTR_ERR(alloc);
+	status = PTR_ERR(alloc);
+	goto out;
 }
 const struct xattr_handler *nfs3_xattr_handlers[] = {

fs/nfs/nfs4proc.c+9−2

@@ -7891,6 +7891,7 @@ static void · 7890 unmodified lines
7891	nfs4_bind_one_conn_to_session_done(struct rpc_task task, void calldata)	7891	nfs4_bind_one_conn_to_session_done(struct rpc_task task, void calldata)
7892	{	7892	{
7893	struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp;	7893	struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp;
		7894	struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp;
7894	struct nfs_client *clp = args->client;	7895	struct nfs_client *clp = args->client;
7895		7896
7896	switch (task->tk_status) {	7897	switch (task->tk_status) {
@@ -7899,6 +7900,12 @@ nfs4_bind_one_conn_to_session_done(struct rpc_task task, void calldata) · 2 unmodified lines
7899	nfs4_schedule_session_recovery(clp->cl_session,	7900	nfs4_schedule_session_recovery(clp->cl_session,
7900	task->tk_status);	7901	task->tk_status);
7901	}	7902	}
		7903	if (args->dir == NFS4_CDFC4_FORE_OR_BOTH &&
		7904	res->dir != NFS4_CDFS4_BOTH) {
		7905	rpc_task_close_connection(task);
		7906	if (args->retries++ < MAX_BIND_CONN_TO_SESSION_RETRIES)
		7907	rpc_restart_call(task);
		7908	}
7902	}	7909	}
7903		7910
7904	static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {	7911	static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
@@ -7921,6 +7928,7 @@ int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt, · 16 unmodified lines
7921	struct nfs41_bind_conn_to_session_args args = {	7928	struct nfs41_bind_conn_to_session_args args = {
7922	.client = clp,	7929	.client = clp,
7923	.dir = NFS4_CDFC4_FORE_OR_BOTH,	7930	.dir = NFS4_CDFC4_FORE_OR_BOTH,
		7931	.retries = 0,
7924	};	7932	};
7925	struct nfs41_bind_conn_to_session_res res;	7933	struct nfs41_bind_conn_to_session_res res;
7926	struct rpc_message msg = {	7934	struct rpc_message msg = {
@@ -9191,8 +9199,7 @@ nfs4_proc_layoutget(struct nfs4_layoutget lgp, long timeout) · 1264 unmodified lines
9191	nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0, 0);	9199	nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0, 0);
9192		9200
9193	task = rpc_run_task(&task_setup_data);	9201	task = rpc_run_task(&task_setup_data);
9194	if (IS_ERR(task))	9202
9195	return ERR_CAST(task);
9196	status = rpc_wait_for_completion_task(task);	9203	status = rpc_wait_for_completion_task(task);
9197	if (status != 0)	9204	if (status != 0)
9198	goto out;	9205	goto out;

fs/nfs/pnfs.c+5−6

 			!valid_layout) {
 		spin_unlock(&ino->i_lock);
 		dprintk("NFS: %s no layout segments to return\n", __func__);
-		goto out_put_layout_hdr;
+		goto out_wait_layoutreturn;
 	}
 	send = pnfs_prepare_layoutreturn(lo, &stateid, &cred, NULL);
 	spin_unlock(&ino->i_lock);
 	if (send)
 		status = pnfs_send_layoutreturn(lo, &stateid, &cred, IOMODE_ANY, true);
+out_wait_layoutreturn:
+	wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN, TASK_UNINTERRUPTIBLE);
 out_put_layout_hdr:
 	pnfs_free_lseg_list(&tmp_list);
 	pnfs_put_layout_hdr(lo);
 	/* lo ref dropped in pnfs_roc_release() */
 	layoutreturn = pnfs_prepare_layoutreturn(lo, &stateid, &lc_cred, &iomode);
 	/* If the creds don't match, we can't compound the layoutreturn */
-	if (!layoutreturn)
+	if (!layoutreturn || cred_fscmp(cred, lc_cred) != 0)
 		goto out_noroc;
-	if (cred_fscmp(cred, lc_cred) != 0)
-		goto out_noroc_put_cred;
 	roc = layoutreturn;
 	pnfs_init_layoutreturn_args(args, lo, &stateid, iomode);
 	res->lrs_present = 0;
 	layoutreturn = false;
-out_noroc_put_cred:
 	put_cred(lc_cred);
 out_noroc:
 	spin_unlock(&ino->i_lock);
 	rcu_read_unlock();

fs/nfs/super.c+1−1

@@ -185,7 +185,7 @@ static int __nfs_list_for_each_server(struct list_head *head, · 184 unmodified lines
185		185
186	rcu_read_lock();	186	rcu_read_lock();
187	list_for_each_entry_rcu(server, head, client_link) {	187	list_for_each_entry_rcu(server, head, client_link) {
188	if (!nfs_sb_active(server->super))	188	if (!(server->super && nfs_sb_active(server->super)))
189	continue;	189	continue;
190	rcu_read_unlock();	190	rcu_read_unlock();
191	if (last)	191	if (last)

fs/ocfs2/dlmfs/dlmfs.c+12−15

 				loff_t *ppos)
 {
 	int bytes_left;
-	ssize_t writelen;
 	char *lvb_buf;
 	struct inode *inode = file_inode(filp);
 	if (*ppos >= i_size_read(inode))
 		return -ENOSPC;
+	/* don't write past the lvb */
+	if (count > i_size_read(inode) - *ppos)
+		count = i_size_read(inode) - *ppos;
 	if (!count)
 		return 0;
 	if (!access_ok(buf, count))
 		return -EFAULT;
-	/* don't write past the lvb */
+	lvb_buf = kmalloc(count, GFP_NOFS);
-	if ((count + *ppos) > i_size_read(inode))
-		writelen = i_size_read(inode) - *ppos;
-	else
-		writelen = count - *ppos;
-	lvb_buf = kmalloc(writelen, GFP_NOFS);
 	if (!lvb_buf)
 		return -ENOMEM;
-	bytes_left = copy_from_user(lvb_buf, buf, writelen);
+	bytes_left = copy_from_user(lvb_buf, buf, count);
-	writelen -= bytes_left;
+	count -= bytes_left;
-	if (writelen)
+	if (count)
-		user_dlm_write_lvb(inode, lvb_buf, writelen);
+		user_dlm_write_lvb(inode, lvb_buf, count);
 	kfree(lvb_buf);
-	*ppos = *ppos + writelen;
+	*ppos = *ppos + count;
-	mlog(0, "wrote %zd bytes\n", writelen);
+	mlog(0, "wrote %zu bytes\n", count);
-	return writelen;
+	return count;
 }
 static void dlmfs_init_once(void *foo)

fs/pnode.c+4−5

 	child = copy_tree(last_source, last_source->mnt.mnt_root, type);
 	if (IS_ERR(child))
 		return PTR_ERR(child);
+	read_seqlock_excl(&mount_lock);
 	mnt_set_mountpoint(m, mp, child);
+	if (m->mnt_master != dest_master)
+		SET_MNT_MARK(m->mnt_master);
+	read_sequnlock_excl(&mount_lock);
 	last_dest = m;
 	last_source = child;
-	if (m->mnt_master != dest_master) {
-		read_seqlock_excl(&mount_lock);
-		SET_MNT_MARK(m->mnt_master);
-		read_sequnlock_excl(&mount_lock);
-	}
 	hlist_add_head(&child->mnt_hash, list);
 	return count_mounts(m->mnt_ns, child);
 }

fs/splice.c+18−27

 	loff_t offset;
 	long ret;
+	if (unlikely(!(in->f_mode & FMODE_READ) ||
+		     !(out->f_mode & FMODE_WRITE)))
+		return -EBADF;
 	ipipe = get_pipe_info(in);
 	opipe = get_pipe_info(out);
 		if (off_in || off_out)
 			return -ESPIPE;
-		if (!(in->f_mode & FMODE_READ))
-			return -EBADF;
-		if (!(out->f_mode & FMODE_WRITE))
-			return -EBADF;
 		/* Splicing to self would be fun, but... */
 		if (ipipe == opipe)
 			return -EINVAL;
 			offset = out->f_pos;
 		}
-		if (unlikely(!(out->f_mode & FMODE_WRITE)))
-			return -EBADF;
 		if (unlikely(out->f_flags & O_APPEND))
 			return -EINVAL;
 	error = -EBADF;
 	in = fdget(fd_in);
 	if (in.file) {
-		if (in.file->f_mode & FMODE_READ) {
+		out = fdget(fd_out);
-			out = fdget(fd_out);
+		if (out.file) {
-			if (out.file) {
+			error = do_splice(in.file, off_in, out.file, off_out,
-				if (out.file->f_mode & FMODE_WRITE)
+					  len, flags);
-					error = do_splice(in.file, off_in,
+			fdput(out);
-							  out.file, off_out,
-							  len, flags);
-				fdput(out);
-			}
 		}
 		fdput(in);
 	}
 	struct pipe_inode_info *opipe = get_pipe_info(out);
 	int ret = -EINVAL;
+	if (unlikely(!(in->f_mode & FMODE_READ) ||
+		     !(out->f_mode & FMODE_WRITE)))
+		return -EBADF;
 	/*
 	 * Duplicate the contents of ipipe to opipe without actually
 	 * copying the data.
 SYSCALL_DEFINE4(tee, int, fdin, int, fdout, size_t, len, unsigned int, flags)
 {
-	struct fd in;
+	struct fd in, out;
 	int error;
 	if (unlikely(flags & ~SPLICE_F_ALL))
 	error = -EBADF;
 	in = fdget(fdin);
 	if (in.file) {
-		if (in.file->f_mode & FMODE_READ) {
+		out = fdget(fdout);
-			struct fd out = fdget(fdout);
+		if (out.file) {
-			if (out.file) {
+			error = do_tee(in.file, out.file, len, flags);
-				if (out.file->f_mode & FMODE_WRITE)
+			fdput(out);
-					error = do_tee(in.file, out.file,
-							len, flags);
-				fdput(out);
-			}
 		}
  		fdput(in);
  	}

fs/super.c+1−1

 	mutex_lock(&bdev->bd_fsfreeze_mutex);
 	if (bdev->bd_fsfreeze_count > 0) {
 		mutex_unlock(&bdev->bd_fsfreeze_mutex);
-		blkdev_put(bdev, mode);
 		warnf(fc, "%pg: Can't mount, blockdev is frozen", bdev);
+		blkdev_put(bdev, mode);
 		return -EBUSY;
 	}

fs/vboxsf/super.c+1−1

@@ -164,7 +164,7 @@ static int vboxsf_fill_super(struct super_block sb, struct fs_context fc) · 163 unmodified lines
164	goto fail_free;	164	goto fail_free;
165	}	165	}
166		166
167	err = super_setup_bdi_name(sb, "vboxsf-%s.%d", fc->source, sbi->bdi_id);	167	err = super_setup_bdi_name(sb, "vboxsf-%d", sbi->bdi_id);
168	if (err)	168	if (err)
169	goto fail_free;	169	goto fail_free;
170		170

include/linux/amba/bus.h+1−0

@@ -65,6 +65,7 @@ struct amba_device { · 64 unmodified lines
65	struct device dev;	65	struct device dev;
66	struct resource res;	66	struct resource res;
67	struct clk *pclk;	67	struct clk *pclk;
		68	struct device_dma_parameters dma_parms;
68	unsigned int periphid;	69	unsigned int periphid;
69	unsigned int cid;	70	unsigned int cid;
70	struct amba_cs_uci_id uci;	71	struct amba_cs_uci_id uci;

include/linux/backing-dev-defs.h+1−0

@@ -219,6 +219,7 @@ struct backing_dev_info { · 218 unmodified lines
219	wait_queue_head_t wb_waitq;	219	wait_queue_head_t wb_waitq;
220		220
221	struct device *dev;	221	struct device *dev;
		222	char dev_name[64];
222	struct device *owner;	223	struct device *owner;
223		224
224	struct timer_list laptop_mode_wb_timer;	225	struct timer_list laptop_mode_wb_timer;

include/linux/backing-dev.h+1−8

@@ -505,13 +505,6 @@ static inline int bdi_rw_congested(struct backing_dev_info *bdi) · 504 unmodified lines
505	(1 << WB_async_congested));	505	(1 << WB_async_congested));
506	}	506	}
507		507
508	extern const char *bdi_unknown_name;	508	const char bdi_dev_name(struct backing_dev_info bdi);
509
510	static inline const char bdi_dev_name(struct backing_dev_info bdi)
511	{
512	if (!bdi \|\| !bdi->dev)
513	return bdi_unknown_name;
514	return dev_name(bdi->dev);
515	}
516		509
517	#endif /* _LINUX_BACKING_DEV_H */	510	#endif /* _LINUX_BACKING_DEV_H */

include/linux/dma-buf.h+1−2

 /**
  * struct dma_buf_attach_ops - importer operations for an attachment
- * @move_notify: [optional] notification that the DMA-buf is moving
  *
  * Attachment operations implemented by the importer.
  */
 struct dma_buf_attach_ops {
 	/**
-	 * @move_notify
+	 * @move_notify: [optional] notification that the DMA-buf is moving
 	 *
 	 * If this callback is provided the framework can avoid pinning the
 	 * backing store while mappings exists.

include/linux/dmaengine.h+6−6

 /**
  * Interleaved Transfer Request
  * ----------------------------
- * A chunk is collection of contiguous bytes to be transfered.
+ * A chunk is collection of contiguous bytes to be transferred.
  * The gap(in bytes) between two chunks is called inter-chunk-gap(ICG).
- * ICGs may or maynot change between chunks.
+ * ICGs may or may not change between chunks.
  * A FRAME is the smallest series of contiguous {chunk,icg} pairs,
  *  that when repeated an integral number of times, specifies the transfer.
  * A transfer template is specification of a Frame, the number of times
  * @chan: driver channel device
  * @device: sysfs device
  * @dev_id: parent dma_device dev_id
- * @idr_ref: reference count to gate release of dma_device dev_id
  */
 struct dma_chan_dev {
 	struct dma_chan *chan;
 	struct device device;
 	int dev_id;
-	atomic_t *idr_ref;
 };
 /**
 	int dev_id;
 	struct device *dev;
 	struct module *owner;
+	struct ida chan_ida;
+	struct mutex chan_mutex;	/* to protect chan_ida */
 	u32 src_addr_widths;
 	u32 dst_addr_widths;
  * dmaengine_synchronize() needs to be called before it is safe to free
  * any memory that is accessed by previously submitted descriptors or before
  * freeing any resources accessed from within the completion callback of any
- * perviously submitted descriptors.
+ * previously submitted descriptors.
  *
  * This function can be called from atomic context as well as from within a
  * complete callback of a descriptor submitted on the same channel.
  *
  * Synchronizes to the DMA channel termination to the current context. When this
  * function returns it is guaranteed that all transfers for previously issued
- * descriptors have stopped and and it is safe to free the memory assoicated
+ * descriptors have stopped and it is safe to free the memory associated
  * with them. Furthermore it is guaranteed that all complete callback functions
  * for a previously submitted descriptor have finished running and it is safe to
  * free resources accessed from within the complete callbacks.

include/linux/fs.h+1−1

@@ -983,7 +983,7 @@ struct file_handle { · 982 unmodified lines
983	__u32 handle_bytes;	983	__u32 handle_bytes;
984	int handle_type;	984	int handle_type;
985	/* file identifier */	985	/* file identifier */
986	unsigned char f_handle[0];	986	unsigned char f_handle[];
987	};	987	};
988		988
989	static inline struct file get_file(struct file f)	989	static inline struct file get_file(struct file f)

include/linux/lsm_hook_defs.h+1−1

@@ -55,7 +55,7 @@ LSM_HOOK(void, LSM_RET_VOID, bprm_committing_creds, struct linux_binprm *bprm) · 54 unmodified lines
55	LSM_HOOK(void, LSM_RET_VOID, bprm_committed_creds, struct linux_binprm *bprm)	55	LSM_HOOK(void, LSM_RET_VOID, bprm_committed_creds, struct linux_binprm *bprm)
56	LSM_HOOK(int, 0, fs_context_dup, struct fs_context *fc,	56	LSM_HOOK(int, 0, fs_context_dup, struct fs_context *fc,
57	struct fs_context *src_sc)	57	struct fs_context *src_sc)
58	LSM_HOOK(int, 0, fs_context_parse_param, struct fs_context *fc,	58	LSM_HOOK(int, -ENOPARAM, fs_context_parse_param, struct fs_context *fc,
59	struct fs_parameter *param)	59	struct fs_parameter *param)
60	LSM_HOOK(int, 0, sb_alloc_security, struct super_block *sb)	60	LSM_HOOK(int, 0, sb_alloc_security, struct super_block *sb)
61	LSM_HOOK(void, LSM_RET_VOID, sb_free_security, struct super_block *sb)	61	LSM_HOOK(void, LSM_RET_VOID, sb_free_security, struct super_block *sb)

include/linux/mhi.h+10−6

  * @MHI_CHAIN: Linked transfer
  */
 enum mhi_flags {
-	MHI_EOB,
+	MHI_EOB = BIT(0),
-	MHI_EOT,
+	MHI_EOT = BIT(1),
-	MHI_CHAIN,
+	MHI_CHAIN = BIT(2),
 };
 /**
  * @syserr_worker: System error worker
  * @state_event: State change event
  * @status_cb: CB function to notify power states of the device (required)
- * @link_status: CB function to query link status of the device (required)
  * @wake_get: CB function to assert device wake (optional)
  * @wake_put: CB function to de-assert device wake (optional)
  * @wake_toggle: CB function to assert and de-assert device wake (optional)
  * @runtime_get: CB function to controller runtime resume (required)
- * @runtimet_put: CB function to decrement pm usage (required)
+ * @runtime_put: CB function to decrement pm usage (required)
  * @map_single: CB function to create TRE buffer
  * @unmap_single: CB function to destroy TRE buffer
+ * @read_reg: Read a MHI register via the physical link (required)
+ * @write_reg: Write a MHI register via the physical link (required)
  * @buffer_len: Bounce buffer length
  * @bounce_buf: Use of bounce buffer
  * @fbc_download: MHI host needs to do complete image transfer (optional)
 	void (*status_cb)(struct mhi_controller *mhi_cntrl,
 			  enum mhi_callback cb);
-	int (*link_status)(struct mhi_controller *mhi_cntrl);
 	void (*wake_get)(struct mhi_controller *mhi_cntrl, bool override);
 	void (*wake_put)(struct mhi_controller *mhi_cntrl, bool override);
 	void (*wake_toggle)(struct mhi_controller *mhi_cntrl);
 			  struct mhi_buf_info *buf);
 	void (*unmap_single)(struct mhi_controller *mhi_cntrl,
 			     struct mhi_buf_info *buf);
+	int (*read_reg)(struct mhi_controller *mhi_cntrl, void __iomem *addr,
+			u32 *out);
+	void (*write_reg)(struct mhi_controller *mhi_cntrl, void __iomem *addr,
+			  u32 val);
 	size_t buffer_len;
 	bool bounce_buf;

include/linux/nfs_xdr.h+2−0

 	struct nfstime4			date;
 };
+#define MAX_BIND_CONN_TO_SESSION_RETRIES 3
 struct nfs41_bind_conn_to_session_args {
 	struct nfs_client		*client;
 	struct nfs4_sessionid		sessionid;
 	u32				dir;
 	bool				use_conn_in_rdma_mode;
+	int				retries;
 };
 struct nfs41_bind_conn_to_session_res {

include/linux/platform_data/cros_ec_sensorhub.h+1−0

@@ -185,6 +185,7 @@ int cros_ec_sensorhub_register_push_data(struct cros_ec_sensorhub *sensorhub, · 184 unmodified lines
185	void cros_ec_sensorhub_unregister_push_data(struct cros_ec_sensorhub *sensorhub,	185	void cros_ec_sensorhub_unregister_push_data(struct cros_ec_sensorhub *sensorhub,
186	u8 sensor_num);	186	u8 sensor_num);
187		187
		188	int cros_ec_sensorhub_ring_allocate(struct cros_ec_sensorhub *sensorhub);
188	int cros_ec_sensorhub_ring_add(struct cros_ec_sensorhub *sensorhub);	189	int cros_ec_sensorhub_ring_add(struct cros_ec_sensorhub *sensorhub);
189	void cros_ec_sensorhub_ring_remove(void *arg);	190	void cros_ec_sensorhub_ring_remove(void *arg);
190	int cros_ec_sensorhub_ring_fifo_enable(struct cros_ec_sensorhub *sensorhub,	191	int cros_ec_sensorhub_ring_fifo_enable(struct cros_ec_sensorhub *sensorhub,

include/linux/platform_device.h+1−0

@@ -25,6 +25,7 @@ struct platform_device { · 24 unmodified lines
25	bool id_auto;	25	bool id_auto;
26	struct device dev;	26	struct device dev;
27	u64 platform_dma_mask;	27	u64 platform_dma_mask;
		28	struct device_dma_parameters dma_parms;
28	u32 num_resources;	29	u32 num_resources;
29	struct resource *resource;	30	struct resource *resource;
30		31

include/linux/sunrpc/clnt.h+12−1

 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 	struct dentry		*cl_debugfs;	/* debugfs directory */
 #endif
-	struct rpc_xprt_iter	cl_xpi;
+	/* cl_work is only needed after cl_xpi is no longer used,
+	 * and that are of similar size
+	 */
+	union {
+		struct rpc_xprt_iter	cl_xpi;
+		struct work_struct	cl_work;
+	};
 	const struct cred	*cl_cred;
 };
 		(task->tk_msg.rpc_proc->p_decode != NULL);
 }
+static inline void rpc_task_close_connection(struct rpc_task *task)
+{
+	if (task->tk_xprt)
+		xprt_force_disconnect(task->tk_xprt);
+}
 #endif /* _LINUX_SUNRPC_CLNT_H */

include/linux/tcp.h+0−51

@@ -78,47 +78,6 @@ struct tcp_sack_block { · 77 unmodified lines
78	#define TCP_SACK_SEEN (1 << 0) /1 = peer is SACK capable, /	78	#define TCP_SACK_SEEN (1 << 0) /1 = peer is SACK capable, /
79	#define TCP_DSACK_SEEN (1 << 2) /1 = DSACK was received from peer/	79	#define TCP_DSACK_SEEN (1 << 2) /1 = DSACK was received from peer/
80		80
81	#if IS_ENABLED(CONFIG_MPTCP)
82	struct mptcp_options_received {
83	u64 sndr_key;
84	u64 rcvr_key;
85	u64 data_ack;
86	u64 data_seq;
87	u32 subflow_seq;
88	u16 data_len;
89	u16 mp_capable : 1,
90	mp_join : 1,
91	dss : 1,
92	add_addr : 1,
93	rm_addr : 1,
94	family : 4,
95	echo : 1,
96	backup : 1;
97	u32 token;
98	u32 nonce;
99	u64 thmac;
100	u8 hmac[20];
101	u8 join_id;
102	u8 use_map:1,
103	dsn64:1,
104	data_fin:1,
105	use_ack:1,
106	ack64:1,
107	mpc_map:1,
108	__unused:2;
109	u8 addr_id;
110	u8 rm_id;
111	union {
112	struct in_addr addr;
113	#if IS_ENABLED(CONFIG_MPTCP_IPV6)
114	struct in6_addr addr6;
115	#endif
116	};
117	u64 ahmac;
118	u16 port;
119	};
120	#endif
121
122	struct tcp_options_received {	81	struct tcp_options_received {
123	/* PAWS/RTTM data */	82	/* PAWS/RTTM data */
124	int ts_recent_stamp;/* Time we stored ts_recent (for aging) */	83	int ts_recent_stamp;/* Time we stored ts_recent (for aging) */
@@ -136,9 +95,6 @@ struct tcp_options_received { · 11 unmodified lines
136	u8 num_sacks; /* Number of SACK blocks */	95	u8 num_sacks; /* Number of SACK blocks */
137	u16 user_mss; /* mss requested by user in ioctl */	96	u16 user_mss; /* mss requested by user in ioctl */
138	u16 mss_clamp; /* Maximal mss, negotiated at connection setup */	97	u16 mss_clamp; /* Maximal mss, negotiated at connection setup */
139	#if IS_ENABLED(CONFIG_MPTCP)
140	struct mptcp_options_received mptcp;
141	#endif
142	};	98	};
143		99
144	static inline void tcp_clear_options(struct tcp_options_received *rx_opt)	100	static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
@@ -148,13 +104,6 @@ static inline void tcp_clear_options(struct tcp_options_received *rx_opt) · 3 unmodified lines
148	#if IS_ENABLED(CONFIG_SMC)	104	#if IS_ENABLED(CONFIG_SMC)
149	rx_opt->smc_ok = 0;	105	rx_opt->smc_ok = 0;
150	#endif	106	#endif
151	#if IS_ENABLED(CONFIG_MPTCP)
152	rx_opt->mptcp.mp_capable = 0;
153	rx_opt->mptcp.mp_join = 0;
154	rx_opt->mptcp.add_addr = 0;
155	rx_opt->mptcp.rm_addr = 0;
156	rx_opt->mptcp.dss = 0;
157	#endif
158	}	107	}
159		108
160	/* This is the max number of SACKS that we'll generate and process. It's safe	109	/* This is the max number of SACKS that we'll generate and process. It's safe

include/linux/tty.h+1−1

@@ -66,7 +66,7 @@ struct tty_buffer { · 65 unmodified lines
66	int read;	66	int read;
67	int flags;	67	int flags;
68	/* Data points here */	68	/* Data points here */
69	unsigned long data[0];	69	unsigned long data[];
70	};	70	};
71		71
72	/* Values for .flags field of tty_buffer */	72	/* Values for .flags field of tty_buffer */

include/linux/virtio_net.h+24−2

 #define _LINUX_VIRTIO_NET_H
 #include <linux/if_vlan.h>
+#include <uapi/linux/tcp.h>
+#include <uapi/linux/udp.h>
 #include <uapi/linux/virtio_net.h>
 static inline int virtio_net_hdr_set_proto(struct sk_buff *skb,
 					bool little_endian)
 {
 	unsigned int gso_type = 0;
+	unsigned int thlen = 0;
+	unsigned int ip_proto;
 	if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
 		switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
 		case VIRTIO_NET_HDR_GSO_TCPV4:
 			gso_type = SKB_GSO_TCPV4;
+			ip_proto = IPPROTO_TCP;
+			thlen = sizeof(struct tcphdr);
 			break;
 		case VIRTIO_NET_HDR_GSO_TCPV6:
 			gso_type = SKB_GSO_TCPV6;
+			ip_proto = IPPROTO_TCP;
+			thlen = sizeof(struct tcphdr);
 			break;
 		case VIRTIO_NET_HDR_GSO_UDP:
 			gso_type = SKB_GSO_UDP;
+			ip_proto = IPPROTO_UDP;
+			thlen = sizeof(struct udphdr);
 			break;
 		default:
 			return -EINVAL;
 		if (!skb_partial_csum_set(skb, start, off))
 			return -EINVAL;
+		if (skb_transport_offset(skb) + thlen > skb_headlen(skb))
+			return -EINVAL;
 	} else {
 		/* gso packets without NEEDS_CSUM do not set transport_offset.
 		 * probe and drop if does not match one of the above types.
 		 */
 		if (gso_type && skb->network_header) {
+			struct flow_keys_basic keys;
 			if (!skb->protocol)
 				virtio_net_hdr_set_proto(skb, hdr);
 retry:
-			skb_probe_transport_header(skb);
+			if (!skb_flow_dissect_flow_keys_basic(NULL, skb, &keys,
-			if (!skb_transport_header_was_set(skb)) {
+							      NULL, 0, 0, 0,
+							      0)) {
 				/* UFO does not specify ipv4 or 6: try both */
 				if (gso_type & SKB_GSO_UDP &&
 				    skb->protocol == htons(ETH_P_IP)) {
 				}
 				return -EINVAL;
 			}
+			if (keys.control.thoff + thlen > skb_headlen(skb) ||
+			    keys.basic.ip_proto != ip_proto)
+				return -EINVAL;
+			skb_set_transport_header(skb, keys.control.thoff);
 		}
 	}

include/linux/virtio_vsock.h+1−0

@@ -48,6 +48,7 @@ struct virtio_vsock_pkt { · 47 unmodified lines
48	u32 len;	48	u32 len;
49	u32 off;	49	u32 off;
50	bool reply;	50	bool reply;
		51	bool tap_delivered;
51	};	52	};
52		53
53	struct virtio_vsock_pkt_info {	54	struct virtio_vsock_pkt_info {

include/net/flow_offload.h+8−1

 enum flow_action_hw_stats_bit {
 	FLOW_ACTION_HW_STATS_IMMEDIATE_BIT,
 	FLOW_ACTION_HW_STATS_DELAYED_BIT,
+	FLOW_ACTION_HW_STATS_DISABLED_BIT,
 };
 enum flow_action_hw_stats {
-	FLOW_ACTION_HW_STATS_DISABLED = 0,
+	FLOW_ACTION_HW_STATS_DONT_CARE = 0,
 	FLOW_ACTION_HW_STATS_IMMEDIATE =
 		BIT(FLOW_ACTION_HW_STATS_IMMEDIATE_BIT),
 	FLOW_ACTION_HW_STATS_DELAYED = BIT(FLOW_ACTION_HW_STATS_DELAYED_BIT),
 	FLOW_ACTION_HW_STATS_ANY = FLOW_ACTION_HW_STATS_IMMEDIATE |
 				   FLOW_ACTION_HW_STATS_DELAYED,
+	FLOW_ACTION_HW_STATS_DISABLED =
+		BIT(FLOW_ACTION_HW_STATS_DISABLED_BIT),
 };
 typedef void (*action_destr)(void *priv);
 		return true;
 	if (!flow_action_mixed_hw_stats_check(action, extack))
 		return false;
 	action_entry = flow_action_first_entry_get(action);
+	if (action_entry->hw_stats == FLOW_ACTION_HW_STATS_DONT_CARE)
+		return true;
 	if (!check_allow_bit &&
 	    action_entry->hw_stats != FLOW_ACTION_HW_STATS_ANY) {
 		NL_SET_ERR_MSG_MOD(extack, "Driver supports only default HW stats type \"any\"");

include/net/inet_ecn.h+55−2

@@ -99,6 +99,20 @@ static inline int IP_ECN_set_ce(struct iphdr *iph) · 98 unmodified lines
99	return 1;	99	return 1;
100	}	100	}
101		101
		102	static inline int IP_ECN_set_ect1(struct iphdr *iph)
		103	{
		104	u32 check = (__force u32)iph->check;
		105
		106	if ((iph->tos & INET_ECN_MASK) != INET_ECN_ECT_0)
		107	return 0;
		108
		109	check += (__force u16)htons(0x100);
		110
		111	iph->check = (__force __sum16)(check + (check>=0xFFFF));
		112	iph->tos ^= INET_ECN_MASK;
		113	return 1;
		114	}
		115
102	static inline void IP_ECN_clear(struct iphdr *iph)	116	static inline void IP_ECN_clear(struct iphdr *iph)
103	{	117	{
104	iph->tos &= ~INET_ECN_MASK;	118	iph->tos &= ~INET_ECN_MASK;
@@ -134,6 +148,22 @@ static inline int IP6_ECN_set_ce(struct sk_buff skb, struct ipv6hdr iph) · 29 unmodified lines
134	return 1;	148	return 1;
135	}	149	}
136		150
		151	static inline int IP6_ECN_set_ect1(struct sk_buff skb, struct ipv6hdr iph)
		152	{
		153	__be32 from, to;
		154
		155	if ((ipv6_get_dsfield(iph) & INET_ECN_MASK) != INET_ECN_ECT_0)
		156	return 0;
		157
		158	from = (__be32 )iph;
		159	to = from ^ htonl(INET_ECN_MASK << 20);
		160	(__be32 )iph = to;
		161	if (skb->ip_summed == CHECKSUM_COMPLETE)
		162	skb->csum = csum_add(csum_sub(skb->csum, (__force __wsum)from),
		163	(__force __wsum)to);
		164	return 1;
		165	}
		166
137	static inline void ipv6_copy_dscp(unsigned int dscp, struct ipv6hdr *inner)	167	static inline void ipv6_copy_dscp(unsigned int dscp, struct ipv6hdr *inner)
138	{	168	{
139	dscp &= ~INET_ECN_MASK;	169	dscp &= ~INET_ECN_MASK;
@@ -159,6 +189,25 @@ static inline int INET_ECN_set_ce(struct sk_buff *skb) · 19 unmodified lines
159	return 0;	189	return 0;
160	}	190	}
161		191
		192	static inline int INET_ECN_set_ect1(struct sk_buff *skb)
		193	{
		194	switch (skb->protocol) {
		195	case cpu_to_be16(ETH_P_IP):
		196	if (skb_network_header(skb) + sizeof(struct iphdr) <=
		197	skb_tail_pointer(skb))
		198	return IP_ECN_set_ect1(ip_hdr(skb));
		199	break;
		200
		201	case cpu_to_be16(ETH_P_IPV6):
		202	if (skb_network_header(skb) + sizeof(struct ipv6hdr) <=
		203	skb_tail_pointer(skb))
		204	return IP6_ECN_set_ect1(skb, ipv6_hdr(skb));
		205	break;
		206	}
		207
		208	return 0;
		209	}
		210
162	/*	211	/*
163	* RFC 6040 4.2	212	* RFC 6040 4.2
164	* To decapsulate the inner header at the tunnel egress, a compliant	213	* To decapsulate the inner header at the tunnel egress, a compliant
@@ -208,8 +257,12 @@ static inline int INET_ECN_decapsulate(struct sk_buff *skb, · 43 unmodified lines
208	int rc;	257	int rc;
209		258
210	rc = __INET_ECN_decapsulate(outer, inner, &set_ce);	259	rc = __INET_ECN_decapsulate(outer, inner, &set_ce);
211	if (!rc && set_ce)	260	if (!rc) {
212	INET_ECN_set_ce(skb);	261	if (set_ce)
		262	INET_ECN_set_ce(skb);
		263	else if ((outer & INET_ECN_MASK) == INET_ECN_ECT_1)
		264	INET_ECN_set_ect1(skb);
		265	}
213		266
214	return rc;	267	return rc;
215	}	268	}

include/net/ip6_fib.h+4−0

 struct rt6_info {
 	struct dst_entry		dst;
 	struct fib6_info __rcu		*from;
+	int				sernum;
 	struct rt6key			rt6i_dst;
 	struct rt6key			rt6i_src;
 	struct fib6_info *from;
 	u32 cookie = 0;
+	if (rt->sernum)
+		return rt->sernum;
 	rcu_read_lock();
 	from = rcu_dereference(rt->from);

include/net/mptcp.h+0−3

 	return tcp_rsk(req)->is_mptcp;
 }
-void mptcp_parse_option(const struct sk_buff *skb, const unsigned char *ptr,
-			int opsize, struct tcp_options_received *opt_rx);
 bool mptcp_syn_options(struct sock *sk, const struct sk_buff *skb,
 		       unsigned int *size, struct mptcp_out_options *opts);
-void mptcp_rcv_synsent(struct sock *sk);
 bool mptcp_synack_options(const struct request_sock *req, unsigned int *size,
 			  struct mptcp_out_options *opts);
 bool mptcp_established_options(struct sock *sk, struct sk_buff *skb,

include/net/net_namespace.h+7−0

@@ -437,6 +437,13 @@ static inline int rt_genid_ipv4(const struct net *net) · 436 unmodified lines
437	return atomic_read(&net->ipv4.rt_genid);	437	return atomic_read(&net->ipv4.rt_genid);
438	}	438	}
439		439
		440	#if IS_ENABLED(CONFIG_IPV6)
		441	static inline int rt_genid_ipv6(const struct net *net)
		442	{
		443	return atomic_read(&net->ipv6.fib6_sernum);
		444	}
		445	#endif
		446
440	static inline void rt_genid_bump_ipv4(struct net *net)	447	static inline void rt_genid_bump_ipv4(struct net *net)
441	{	448	{
442	atomic_inc(&net->ipv4.rt_genid);	449	atomic_inc(&net->ipv4.rt_genid);

include/net/sch_generic.h+1−0

@@ -407,6 +407,7 @@ struct tcf_block { · 406 unmodified lines
407	struct mutex lock;	407	struct mutex lock;
408	struct list_head chain_list;	408	struct list_head chain_list;
409	u32 index; /* block index for shared blocks */	409	u32 index; /* block index for shared blocks */
		410	u32 classid; /* which class this block belongs to */
410	refcount_t refcnt;	411	refcount_t refcnt;
411	struct net *net;	412	struct net *net;
412	struct Qdisc *q;	413	struct Qdisc *q;

include/soc/mscc/ocelot.h+1−0

@@ -502,6 +502,7 @@ struct ocelot { · 501 unmodified lines
502	unsigned int num_stats;	502	unsigned int num_stats;
503		503
504	int shared_queue_sz;	504	int shared_queue_sz;
		505	int num_mact_rows;
505		506
506	struct net_device *hw_bridge_dev;	507	struct net_device *hw_bridge_dev;
507	u16 bridge_mask;	508	u16 bridge_mask;

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

@@ -24,7 +24,7 @@ · 23 unmodified lines
24	*	24	*
25	* @pid: Put 0 for global total, while positive pid for process total.	25	* @pid: Put 0 for global total, while positive pid for process total.
26	*	26	*
27	* @size: Virtual size of the allocation in bytes.	27	* @size: Size of the allocation in bytes.
28	*	28	*
29	*/	29	*/
30	TRACE_EVENT(gpu_mem_total,	30	TRACE_EVENT(gpu_mem_total,

include/trace/events/rpcrdma.h+4−8

 TRACE_EVENT(xprtrdma_post_send,
 	TP_PROTO(
-		const struct rpcrdma_req *req,
+		const struct rpcrdma_req *req
-		int status
 	),
-	TP_ARGS(req, status),
+	TP_ARGS(req),
 	TP_STRUCT__entry(
 		__field(const void *, req)
 		__field(unsigned int, client_id)
 		__field(int, num_sge)
 		__field(int, signaled)
-		__field(int, status)
 	),
 	TP_fast_assign(
 		__entry->sc = req->rl_sendctx;
 		__entry->num_sge = req->rl_wr.num_sge;
 		__entry->signaled = req->rl_wr.send_flags & IB_SEND_SIGNALED;
-		__entry->status = status;
 	),
-	TP_printk("task:%u@%u req=%p sc=%p (%d SGE%s) %sstatus=%d",
+	TP_printk("task:%u@%u req=%p sc=%p (%d SGE%s) %s",
 		__entry->task_id, __entry->client_id,
 		__entry->req, __entry->sc, __entry->num_sge,
 		(__entry->num_sge == 1 ? "" : "s"),
-		(__entry->signaled ? "signaled " : ""),
+		(__entry->signaled ? "signaled" : "")
-		__entry->status
 	)
 );

include/trace/events/wbt.h+4−4

@@ -33,7 +33,7 @@ TRACE_EVENT(wbt_stat, · 32 unmodified lines
33	),	33	),
34		34
35	TP_fast_assign(	35	TP_fast_assign(
36	strlcpy(__entry->name, dev_name(bdi->dev),	36	strlcpy(__entry->name, bdi_dev_name(bdi),
37	ARRAY_SIZE(__entry->name));	37	ARRAY_SIZE(__entry->name));
38	__entry->rmean = stat[0].mean;	38	__entry->rmean = stat[0].mean;
39	__entry->rmin = stat[0].min;	39	__entry->rmin = stat[0].min;
@@ -68,7 +68,7 @@ TRACE_EVENT(wbt_lat, · 28 unmodified lines
68	),	68	),
69		69
70	TP_fast_assign(	70	TP_fast_assign(
71	strlcpy(__entry->name, dev_name(bdi->dev),	71	strlcpy(__entry->name, bdi_dev_name(bdi),
72	ARRAY_SIZE(__entry->name));	72	ARRAY_SIZE(__entry->name));
73	__entry->lat = div_u64(lat, 1000);	73	__entry->lat = div_u64(lat, 1000);
74	),	74	),
@@ -105,7 +105,7 @@ TRACE_EVENT(wbt_step, · 30 unmodified lines
105	),	105	),
106		106
107	TP_fast_assign(	107	TP_fast_assign(
108	strlcpy(__entry->name, dev_name(bdi->dev),	108	strlcpy(__entry->name, bdi_dev_name(bdi),
109	ARRAY_SIZE(__entry->name));	109	ARRAY_SIZE(__entry->name));
110	__entry->msg = msg;	110	__entry->msg = msg;
111	__entry->step = step;	111	__entry->step = step;
@@ -141,7 +141,7 @@ TRACE_EVENT(wbt_timer, · 29 unmodified lines
141	),	141	),
142		142
143	TP_fast_assign(	143	TP_fast_assign(
144	strlcpy(__entry->name, dev_name(bdi->dev),	144	strlcpy(__entry->name, bdi_dev_name(bdi),
145	ARRAY_SIZE(__entry->name));	145	ARRAY_SIZE(__entry->name));
146	__entry->status = status;	146	__entry->status = status;
147	__entry->step = step;	147	__entry->step = step;

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

 #define AMDGPU_TILING_DCC_PITCH_MAX_MASK		0x3FFF
 #define AMDGPU_TILING_DCC_INDEPENDENT_64B_SHIFT		43
 #define AMDGPU_TILING_DCC_INDEPENDENT_64B_MASK		0x1
+#define AMDGPU_TILING_DCC_INDEPENDENT_128B_SHIFT	44
+#define AMDGPU_TILING_DCC_INDEPENDENT_128B_MASK		0x1
+#define AMDGPU_TILING_SCANOUT_SHIFT			63
+#define AMDGPU_TILING_SCANOUT_MASK			0x1
 /* Set/Get helpers for tiling flags. */
 #define AMDGPU_TILING_SET(field, value) \

include/uapi/linux/bpf.h+1−1

@@ -73,7 +73,7 @@ struct bpf_insn { · 72 unmodified lines
73	/* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */	73	/* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */
74	struct bpf_lpm_trie_key {	74	struct bpf_lpm_trie_key {
75	__u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */	75	__u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */
76	__u8 data[]; /* Arbitrary size */	76	__u8 data[0]; /* Arbitrary size */
77	};	77	};
78		78
79	struct bpf_cgroup_storage_key {	79	struct bpf_cgroup_storage_key {

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

@@ -45,13 +45,13 @@ struct dlm_lock_params { · 44 unmodified lines
45	void __user *bastaddr;	45	void __user *bastaddr;
46	struct dlm_lksb __user *lksb;	46	struct dlm_lksb __user *lksb;
47	char lvb[DLM_USER_LVB_LEN];	47	char lvb[DLM_USER_LVB_LEN];
48	char name[];	48	char name[0];
49	};	49	};
50		50
51	struct dlm_lspace_params {	51	struct dlm_lspace_params {
52	__u32 flags;	52	__u32 flags;
53	__u32 minor;	53	__u32 minor;
54	char name[];	54	char name[0];
55	};	55	};
56		56
57	struct dlm_purge_params {	57	struct dlm_purge_params {

include/uapi/linux/dma-buf.h+6−0

 #define DMA_BUF_BASE		'b'
 #define DMA_BUF_IOCTL_SYNC	_IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
+/* 32/64bitness of this uapi was botched in android, there's no difference
+ * between them in actual uapi, they're just different numbers.
+ */
 #define DMA_BUF_SET_NAME	_IOW(DMA_BUF_BASE, 1, const char *)
+#define DMA_BUF_SET_NAME_A	_IOW(DMA_BUF_BASE, 1, u32)
+#define DMA_BUF_SET_NAME_B	_IOW(DMA_BUF_BASE, 1, u64)
 #endif

include/uapi/linux/fiemap.h+1−1

@@ -34,7 +34,7 @@ struct fiemap { · 33 unmodified lines
34	__u32 fm_mapped_extents;/* number of extents that were mapped (out) */	34	__u32 fm_mapped_extents;/* number of extents that were mapped (out) */
35	__u32 fm_extent_count; /* size of fm_extents array (in) */	35	__u32 fm_extent_count; /* size of fm_extents array (in) */
36	__u32 fm_reserved;	36	__u32 fm_reserved;
37	struct fiemap_extent fm_extents[]; /* array of mapped extents (out) */	37	struct fiemap_extent fm_extents[0]; /* array of mapped extents (out) */
38	};	38	};
39		39
40	#define FIEMAP_MAX_OFFSET (~0ULL)	40	#define FIEMAP_MAX_OFFSET (~0ULL)

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

@@ -119,8 +119,8 @@ enum hv_fcopy_op { · 118 unmodified lines
119		119
120	struct hv_fcopy_hdr {	120	struct hv_fcopy_hdr {
121	__u32 operation;	121	__u32 operation;
122	uuid_le service_id0; /* currently unused */	122	__u8 service_id0[16]; /* currently unused */
123	uuid_le service_id1; /* currently unused */	123	__u8 service_id1[16]; /* currently unused */
124	} __attribute__((packed));	124	} __attribute__((packed));
125		125
126	#define OVER_WRITE 0x1	126	#define OVER_WRITE 0x1

include/uapi/linux/if_arcnet.h+3−3

@@ -60,7 +60,7 @@ struct arc_rfc1201 { · 59 unmodified lines
60	__u8 proto; /* protocol ID field - varies */	60	__u8 proto; /* protocol ID field - varies */
61	__u8 split_flag; /* for use with split packets */	61	__u8 split_flag; /* for use with split packets */
62	__be16 sequence; /* sequence number */	62	__be16 sequence; /* sequence number */
63	__u8 payload[]; /* space remaining in packet (504 bytes)*/	63	__u8 payload[0]; /* space remaining in packet (504 bytes)*/
64	};	64	};
65	#define RFC1201_HDR_SIZE 4	65	#define RFC1201_HDR_SIZE 4
66		66
@@ -69,7 +69,7 @@ struct arc_rfc1201 { · 2 unmodified lines
69	*/	69	*/
70	struct arc_rfc1051 {	70	struct arc_rfc1051 {
71	__u8 proto; /* ARC_P_RFC1051_ARP/RFC1051_IP */	71	__u8 proto; /* ARC_P_RFC1051_ARP/RFC1051_IP */
72	__u8 payload[]; /* 507 bytes */	72	__u8 payload[0]; /* 507 bytes */
73	};	73	};
74	#define RFC1051_HDR_SIZE 1	74	#define RFC1051_HDR_SIZE 1
75		75
@@ -80,7 +80,7 @@ struct arc_rfc1051 { · 4 unmodified lines
80	struct arc_eth_encap {	80	struct arc_eth_encap {
81	__u8 proto; /* Always ARC_P_ETHER */	81	__u8 proto; /* Always ARC_P_ETHER */
82	struct ethhdr eth; /* standard ethernet header (yuck!) */	82	struct ethhdr eth; /* standard ethernet header (yuck!) */
83	__u8 payload[]; /* 493 bytes */	83	__u8 payload[0]; /* 493 bytes */
84	};	84	};
85	#define ETH_ENCAP_HDR_SIZE 14	85	#define ETH_ENCAP_HDR_SIZE 14
86		86

include/uapi/linux/mmc/ioctl.h+1−1

@@ -57,7 +57,7 @@ struct mmc_ioc_cmd { · 56 unmodified lines
57	*/	57	*/
58	struct mmc_ioc_multi_cmd {	58	struct mmc_ioc_multi_cmd {
59	__u64 num_of_cmds;	59	__u64 num_of_cmds;
60	struct mmc_ioc_cmd cmds[];	60	struct mmc_ioc_cmd cmds[0];
61	};	61	};
62		62
63	#define MMC_IOC_CMD _IOWR(MMC_BLOCK_MAJOR, 0, struct mmc_ioc_cmd)	63	#define MMC_IOC_CMD _IOWR(MMC_BLOCK_MAJOR, 0, struct mmc_ioc_cmd)

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

@@ -29,12 +29,12 @@ struct net_dm_config_entry { · 28 unmodified lines
29		29
30	struct net_dm_config_msg {	30	struct net_dm_config_msg {
31	__u32 entries;	31	__u32 entries;
32	struct net_dm_config_entry options[];	32	struct net_dm_config_entry options[0];
33	};	33	};
34		34
35	struct net_dm_alert_msg {	35	struct net_dm_alert_msg {
36	__u32 entries;	36	__u32 entries;
37	struct net_dm_drop_point points[];	37	struct net_dm_drop_point points[0];
38	};	38	};
39		39
40	struct net_dm_user_msg {	40	struct net_dm_user_msg {

include/uapi/linux/netfilter_bridge/ebt_among.h+1−1

@@ -40,7 +40,7 @@ struct ebt_mac_wormhash_tuple { · 39 unmodified lines
40	struct ebt_mac_wormhash {	40	struct ebt_mac_wormhash {
41	int table[257];	41	int table[257];
42	int poolsize;	42	int poolsize;
43	struct ebt_mac_wormhash_tuple pool[];	43	struct ebt_mac_wormhash_tuple pool[0];
44	};	44	};
45		45
46	#define ebt_mac_wormhash_size(x) ((x) ? sizeof(struct ebt_mac_wormhash) \	46	#define ebt_mac_wormhash_size(x) ((x) ? sizeof(struct ebt_mac_wormhash) \

include/uapi/scsi/scsi_bsg_fc.h+1−1

@@ -209,7 +209,7 @@ struct fc_bsg_host_vendor { · 208 unmodified lines
209	__u64 vendor_id;	209	__u64 vendor_id;
210		210
211	/* start of vendor command area */	211	/* start of vendor command area */
212	__u32 vendor_cmd[];	212	__u32 vendor_cmd[0];
213	};	213	};
214		214
215	/* Response:	215	/* Response:

init/Kconfig+0−18

 config CC_HAS_ASM_INLINE
 	def_bool $(success,echo 'void foo(void) { asm inline (""); }' | $(CC) -x c - -c -o /dev/null)
-config CC_HAS_WARN_MAYBE_UNINITIALIZED
-	def_bool $(cc-option,-Wmaybe-uninitialized)
-	help
-	  GCC >= 4.7 supports this option.
-config CC_DISABLE_WARN_MAYBE_UNINITIALIZED
-	bool
-	depends on CC_HAS_WARN_MAYBE_UNINITIALIZED
-	default CC_IS_GCC && GCC_VERSION < 40900  # unreliable for GCC < 4.9
-	help
-	  GCC's -Wmaybe-uninitialized is not reliable by definition.
-	  Lots of false positive warnings are produced in some cases.
-	  If this option is enabled, -Wno-maybe-uninitialzed is passed
-	  to the compiler to suppress maybe-uninitialized warnings.
 config CONSTRUCTORS
 	bool
 	depends on !UML
 config CC_OPTIMIZE_FOR_PERFORMANCE_O3
 	bool "Optimize more for performance (-O3)"
 	depends on ARC
-	imply CC_DISABLE_WARN_MAYBE_UNINITIALIZED  # avoid false positives
 	help
 	  Choosing this option will pass "-O3" to your compiler to optimize
 	  the kernel yet more for performance.
 config CC_OPTIMIZE_FOR_SIZE
 	bool "Optimize for size (-Os)"
-	imply CC_DISABLE_WARN_MAYBE_UNINITIALIZED  # avoid false positives
 	help
 	  Choosing this option will pass "-Os" to your compiler resulting
 	  in a smaller kernel.

init/initramfs.c+1−1

@@ -542,7 +542,7 @@ void __weak free_initrd_mem(unsigned long start, unsigned long end) · 541 unmodified lines
542	}	542	}
543		543
544	#ifdef CONFIG_KEXEC_CORE	544	#ifdef CONFIG_KEXEC_CORE
545	static bool kexec_free_initrd(void)	545	static bool __init kexec_free_initrd(void)
546	{	546	{
547	unsigned long crashk_start = (unsigned long)__va(crashk_res.start);	547	unsigned long crashk_start = (unsigned long)__va(crashk_res.start);
548	unsigned long crashk_end = (unsigned long)__va(crashk_res.end);	548	unsigned long crashk_end = (unsigned long)__va(crashk_res.end);

init/main.c+52−17

@@ -257,6 +257,47 @@ static int __init loglevel(char *str) · 256 unmodified lines
257		257
258	early_param("loglevel", loglevel);	258	early_param("loglevel", loglevel);
259		259
		260	#ifdef CONFIG_BLK_DEV_INITRD
		261	static void * __init get_boot_config_from_initrd(u32 _size, u32 _csum)
		262	{
		263	u32 size, csum;
		264	char *data;
		265	u32 *hdr;
		266
		267	if (!initrd_end)
		268	return NULL;
		269
		270	data = (char *)initrd_end - BOOTCONFIG_MAGIC_LEN;
		271	if (memcmp(data, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN))
		272	return NULL;
		273
		274	hdr = (u32 *)(data - 8);
		275	size = hdr[0];
		276	csum = hdr[1];
		277
		278	data = ((void *)hdr) - size;
		279	if ((unsigned long)data < initrd_start) {
		280	pr_err("bootconfig size %d is greater than initrd size %ld\n",
		281	size, initrd_end - initrd_start);
		282	return NULL;
		283	}
		284
		285	/* Remove bootconfig from initramfs/initrd */
		286	initrd_end = (unsigned long)data;
		287	if (_size)
		288	*_size = size;
		289	if (_csum)
		290	*_csum = csum;
		291
		292	return data;
		293	}
		294	#else
		295	static void * __init get_boot_config_from_initrd(u32 _size, u32 _csum)
		296	{
		297	return NULL;
		298	}
		299	#endif
		300
260	#ifdef CONFIG_BOOT_CONFIG	301	#ifdef CONFIG_BOOT_CONFIG
261		302
262	char xbc_namebuf[XBC_KEYLEN_MAX] __initdata;	303	char xbc_namebuf[XBC_KEYLEN_MAX] __initdata;
@@ -357,9 +398,12 @@ static void __init setup_boot_config(const char *cmdline) · 94 unmodified lines
357	int pos;	398	int pos;
358	u32 size, csum;	399	u32 size, csum;
359	char data, copy;	400	char data, copy;
360	u32 *hdr;
361	int ret;	401	int ret;
362		402
		403	data = get_boot_config_from_initrd(&size, &csum);
		404	if (!data)
		405	goto not_found;
		406
363	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);	407	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
364	parse_args("bootconfig", tmp_cmdline, NULL, 0, 0, 0, NULL,	408	parse_args("bootconfig", tmp_cmdline, NULL, 0, 0, 0, NULL,
365	bootconfig_params);	409	bootconfig_params);
@@ -367,27 +411,12 @@ static void __init setup_boot_config(const char *cmdline) · 1 unmodified line
367	if (!bootconfig_found)	411	if (!bootconfig_found)
368	return;	412	return;
369		413
370	if (!initrd_end)
371	goto not_found;
372
373	data = (char *)initrd_end - BOOTCONFIG_MAGIC_LEN;
374	if (memcmp(data, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN))
375	goto not_found;
376
377	hdr = (u32 *)(data - 8);
378	size = hdr[0];
379	csum = hdr[1];
380
381	if (size >= XBC_DATA_MAX) {	414	if (size >= XBC_DATA_MAX) {
382	pr_err("bootconfig size %d greater than max size %d\n",	415	pr_err("bootconfig size %d greater than max size %d\n",
383	size, XBC_DATA_MAX);	416	size, XBC_DATA_MAX);
384	return;	417	return;
385	}	418	}
386		419
387	data = ((void *)hdr) - size;
388	if ((unsigned long)data < initrd_start)
389	goto not_found;
390
391	if (boot_config_checksum((unsigned char *)data, size) != csum) {	420	if (boot_config_checksum((unsigned char *)data, size) != csum) {
392	pr_err("bootconfig checksum failed\n");	421	pr_err("bootconfig checksum failed\n");
393	return;	422	return;
@@ -420,8 +449,14 @@ static void __init setup_boot_config(const char *cmdline) · 26 unmodified lines
420	not_found:	449	not_found:
421	pr_err("'bootconfig' found on command line, but no bootconfig found\n");	450	pr_err("'bootconfig' found on command line, but no bootconfig found\n");
422	}	451	}
		452
423	#else	453	#else
424	#define setup_boot_config(cmdline) do { } while (0)	454
		455	static void __init setup_boot_config(const char *cmdline)
		456	{
		457	/* Remove bootconfig data from initrd */
		458	get_boot_config_from_initrd(NULL, NULL);
		459	}
425		460
426	static int __init warn_bootconfig(char *str)	461	static int __init warn_bootconfig(char *str)
427	{	462	{

ipc/mqueue.c+26−8

 	struct sigevent notify;
 	struct pid *notify_owner;
+	u32 notify_self_exec_id;
 	struct user_namespace *notify_user_ns;
 	struct user_struct *user;	/* user who created, for accounting */
 	struct sock *notify_sock;
 	 * synchronously. */
 	if (info->notify_owner &&
 	    info->attr.mq_curmsgs == 1) {
-		struct kernel_siginfo sig_i;
 		switch (info->notify.sigev_notify) {
 		case SIGEV_NONE:
 			break;
-		case SIGEV_SIGNAL:
+		case SIGEV_SIGNAL: {
-			/* sends signal */
+			struct kernel_siginfo sig_i;
+			struct task_struct *task;
+			/* do_mq_notify() accepts sigev_signo == 0, why?? */
+			if (!info->notify.sigev_signo)
+				break;
 			clear_siginfo(&sig_i);
 			sig_i.si_signo = info->notify.sigev_signo;
 			sig_i.si_errno = 0;
 			sig_i.si_code = SI_MESGQ;
 			sig_i.si_value = info->notify.sigev_value;
-			/* map current pid/uid into info->owner's namespaces */
 			rcu_read_lock();
+			/* map current pid/uid into info->owner's namespaces */
 			sig_i.si_pid = task_tgid_nr_ns(current,
 						ns_of_pid(info->notify_owner));
-			sig_i.si_uid = from_kuid_munged(info->notify_user_ns, current_uid());
+			sig_i.si_uid = from_kuid_munged(info->notify_user_ns,
+						current_uid());
+			/*
+			 * We can't use kill_pid_info(), this signal should
+			 * bypass check_kill_permission(). It is from kernel
+			 * but si_fromuser() can't know this.
+			 * We do check the self_exec_id, to avoid sending
+			 * signals to programs that don't expect them.
+			 */
+			task = pid_task(info->notify_owner, PIDTYPE_TGID);
+			if (task && task->self_exec_id ==
+						info->notify_self_exec_id) {
+				do_send_sig_info(info->notify.sigev_signo,
+						&sig_i, task, PIDTYPE_TGID);
+			}
 			rcu_read_unlock();
-			kill_pid_info(info->notify.sigev_signo,
-				      &sig_i, info->notify_owner);
 			break;
+		}
 		case SIGEV_THREAD:
 			set_cookie(info->notify_cookie, NOTIFY_WOKENUP);
 			netlink_sendskb(info->notify_sock, info->notify_cookie);
 			info->notify.sigev_signo = notification->sigev_signo;
 			info->notify.sigev_value = notification->sigev_value;
 			info->notify.sigev_notify = SIGEV_SIGNAL;
+			info->notify_self_exec_id = current->self_exec_id;
 			break;
 		}

kernel/kcov.c+2−2

@@ -740,8 +740,8 @@ static const struct file_operations kcov_fops = { · 739 unmodified lines
740	* kcov_remote_handle() with KCOV_SUBSYSTEM_COMMON as the subsystem id and an	740	* kcov_remote_handle() with KCOV_SUBSYSTEM_COMMON as the subsystem id and an
741	* arbitrary 4-byte non-zero number as the instance id). This common handle	741	* arbitrary 4-byte non-zero number as the instance id). This common handle
742	* then gets saved into the task_struct of the process that issued the	742	* then gets saved into the task_struct of the process that issued the
743	* KCOV_REMOTE_ENABLE ioctl. When this proccess issues system calls that spawn	743	* KCOV_REMOTE_ENABLE ioctl. When this process issues system calls that spawn
744	* kernel threads, the common handle must be retrived via kcov_common_handle()	744	* kernel threads, the common handle must be retrieved via kcov_common_handle()
745	* and passed to the spawned threads via custom annotations. Those kernel	745	* and passed to the spawned threads via custom annotations. Those kernel
746	* threads must in turn be annotated with kcov_remote_start(common_handle) and	746	* threads must in turn be annotated with kcov_remote_start(common_handle) and
747	* kcov_remote_stop(). All of the threads that are spawned by the same process	747	* kcov_remote_stop(). All of the threads that are spawned by the same process

kernel/power/hibernate.c+7−0

@@ -898,6 +898,13 @@ static int software_resume(void) · 897 unmodified lines
898	error = freeze_processes();	898	error = freeze_processes();
899	if (error)	899	if (error)
900	goto Close_Finish;	900	goto Close_Finish;
		901
		902	error = freeze_kernel_threads();
		903	if (error) {
		904	thaw_processes();
		905	goto Close_Finish;
		906	}
		907
901	error = load_image_and_restore();	908	error = load_image_and_restore();
902	thaw_processes();	909	thaw_processes();
903	Finish:	910	Finish:

kernel/trace/Kconfig+0−1

@@ -466,7 +466,6 @@ config PROFILE_ANNOTATED_BRANCHES · 465 unmodified lines
466	config PROFILE_ALL_BRANCHES	466	config PROFILE_ALL_BRANCHES
467	bool "Profile all if conditionals" if !FORTIFY_SOURCE	467	bool "Profile all if conditionals" if !FORTIFY_SOURCE
468	select TRACE_BRANCH_PROFILING	468	select TRACE_BRANCH_PROFILING
469	imply CC_DISABLE_WARN_MAYBE_UNINITIALIZED # avoid false positives
470	help	469	help
471	This tracer profiles all branch conditions. Every if ()	470	This tracer profiles all branch conditions. Every if ()
472	taken in the kernel is recorded whether it hit or miss.	471	taken in the kernel is recorded whether it hit or miss.

kernel/trace/preemptirq_delay_test.c+24−6

 	for (i = 0; i < s; i++)
 		(testfuncs[i])(i);
+	set_current_state(TASK_INTERRUPTIBLE);
+	while (!kthread_should_stop()) {
+		schedule();
+		set_current_state(TASK_INTERRUPTIBLE);
+	}
+	__set_current_state(TASK_RUNNING);
 	return 0;
 }
-static struct task_struct *preemptirq_start_test(void)
+static int preemptirq_run_test(void)
 {
+	struct task_struct *task;
 	char task_name[50];
 	snprintf(task_name, sizeof(task_name), "%s_test", test_mode);
-	return kthread_run(preemptirq_delay_run, NULL, task_name);
+	task =  kthread_run(preemptirq_delay_run, NULL, task_name);
+	if (IS_ERR(task))
+		return PTR_ERR(task);
+	if (task)
+		kthread_stop(task);
+	return 0;
 }
 static ssize_t trigger_store(struct kobject *kobj, struct kobj_attribute *attr,
 			 const char *buf, size_t count)
 {
-	preemptirq_start_test();
+	ssize_t ret;
+	ret = preemptirq_run_test();
+	if (ret)
+		return ret;
 	return count;
 }
 static int __init preemptirq_delay_init(void)
 {
-	struct task_struct *test_task;
 	int retval;
-	test_task = preemptirq_start_test();
+	retval = preemptirq_run_test();
-	retval = PTR_ERR_OR_ZERO(test_task);
 	if (retval != 0)
 		return retval;

kernel/trace/trace.c+15−1

@@ -947,7 +947,8 @@ int __trace_bputs(unsigned long ip, const char *str) · 946 unmodified lines
947	EXPORT_SYMBOL_GPL(__trace_bputs);	947	EXPORT_SYMBOL_GPL(__trace_bputs);
948		948
949	#ifdef CONFIG_TRACER_SNAPSHOT	949	#ifdef CONFIG_TRACER_SNAPSHOT
950	void tracing_snapshot_instance_cond(struct trace_array tr, void cond_data)	950	static void tracing_snapshot_instance_cond(struct trace_array *tr,
		951	void *cond_data)
951	{	952	{
952	struct tracer *tracer = tr->current_trace;	953	struct tracer *tracer = tr->current_trace;
953	unsigned long flags;	954	unsigned long flags;
@@ -8525,6 +8526,19 @@ static int allocate_trace_buffers(struct trace_array *tr, int size) · 7571 unmodified lines
8525	*/	8526	*/
8526	allocate_snapshot = false;	8527	allocate_snapshot = false;
8527	#endif	8528	#endif
		8529
		8530	/*
		8531	* Because of some magic with the way alloc_percpu() works on
		8532	* x86_64, we need to synchronize the pgd of all the tables,
		8533	* otherwise the trace events that happen in x86_64 page fault
		8534	* handlers can't cope with accessing the chance that a
		8535	* alloc_percpu()'d memory might be touched in the page fault trace
		8536	* event. Oh, and we need to audit all other alloc_percpu() and vmalloc()
		8537	* calls in tracing, because something might get triggered within a
		8538	* page fault trace event!
		8539	*/
		8540	vmalloc_sync_mappings();
		8541
8528	return 0;	8542	return 0;
8529	}	8543	}
8530		8544

kernel/trace/trace_boot.c+8−12

 	struct xbc_node *anode;
 	char buf[MAX_BUF_LEN];
 	const char *val;
-	int ret;
+	int ret = 0;
-	kprobe_event_cmd_init(&cmd, buf, MAX_BUF_LEN);
+	xbc_node_for_each_array_value(node, "probes", anode, val) {
+		kprobe_event_cmd_init(&cmd, buf, MAX_BUF_LEN);
-	ret = kprobe_event_gen_cmd_start(&cmd, event, NULL);
+		ret = kprobe_event_gen_cmd_start(&cmd, event, val);
-	if (ret)
+		if (ret)
-		return ret;
+			break;
-	xbc_node_for_each_array_value(node, "probes", anode, val) {
+		ret = kprobe_event_gen_cmd_end(&cmd);
-		ret = kprobe_event_add_field(&cmd, val);
 		if (ret)
-			return ret;
+			pr_err("Failed to add probe: %s\n", buf);
 	}
-	ret = kprobe_event_gen_cmd_end(&cmd);
-	if (ret)
-		pr_err("Failed to add probe: %s\n", buf);
 	return ret;
 }
 #else

kernel/trace/trace_kprobe.c+7−1

 static bool within_notrace_func(struct trace_kprobe *tk)
 {
-	unsigned long addr = addr = trace_kprobe_address(tk);
+	unsigned long addr = trace_kprobe_address(tk);
 	char symname[KSYM_NAME_LEN], *p;
 	if (!__within_notrace_func(addr))
  * complete command or only the first part of it; in the latter case,
  * kprobe_event_add_fields() can be used to add more fields following this.
  *
+ * Unlikely the synth_event_gen_cmd_start(), @loc must be specified. This
+ * returns -EINVAL if @loc == NULL.
+ *
  * Return: 0 if successful, error otherwise.
  */
 int __kprobe_event_gen_cmd_start(struct dynevent_cmd *cmd, bool kretprobe,
 	if (cmd->type != DYNEVENT_TYPE_KPROBE)
 		return -EINVAL;
+	if (!loc)
+		return -EINVAL;
 	if (kretprobe)
 		snprintf(buf, MAX_EVENT_NAME_LEN, "r:kprobes/%s", name);
 	else

kernel/umh.c+5−0

  * Runs a user-space application.  The application is started
  * asynchronously if wait is not set, and runs as a child of system workqueues.
  * (ie. it runs with full root capabilities and optimized affinity).
+ *
+ * Note: successful return value does not guarantee the helper was called at
+ * all. You can't rely on sub_info->{init,cleanup} being called even for
+ * UMH_WAIT_* wait modes as STATIC_USERMODEHELPER_PATH="" turns all helpers
+ * into a successful no-op.
  */
 int call_usermodehelper_exec(struct subprocess_info *sub_info, int wait)
 {

lib/Kconfig.ubsan+6−9

 	  Enabling this option will get kernel image size increased
 	  significantly.
-config UBSAN_NO_ALIGNMENT
+config UBSAN_ALIGNMENT
-	bool "Disable checking of pointers alignment"
+	bool "Enable checks for pointers alignment"
-	default y if HAVE_EFFICIENT_UNALIGNED_ACCESS
+	default !HAVE_EFFICIENT_UNALIGNED_ACCESS
+	depends on !X86 || !COMPILE_TEST
 	help
-	  This option disables the check of unaligned memory accesses.
+	  This option enables the check of unaligned memory accesses.
-	  This option should be used when building allmodconfig.
+	  Enabling this option on architectures that support unaligned
-	  Disabling this option on architectures that support unaligned
 	  accesses may produce a lot of false positives.
-config UBSAN_ALIGNMENT
-	def_bool !UBSAN_NO_ALIGNMENT
 config TEST_UBSAN
 	tristate "Module for testing for undefined behavior detection"
 	depends on m

lib/kunit/test.c+1−1

@@ -93,7 +93,7 @@ static void kunit_print_ok_not_ok(void *test_or_suite, · 92 unmodified lines
93	* representation.	93	* representation.
94	*/	94	*/
95	if (suite)	95	if (suite)
96	pr_info("%s %zd - %s",	96	pr_info("%s %zd - %s\n",
97	kunit_status_to_string(is_ok),	97	kunit_status_to_string(is_ok),
98	test_number, description);	98	test_number, description);
99	else	99	else

mm/backing-dev.c+11−2

 EXPORT_SYMBOL_GPL(noop_backing_dev_info);
 static struct class *bdi_class;
-const char *bdi_unknown_name = "(unknown)";
+static const char *bdi_unknown_name = "(unknown)";
 /*
  * bdi_lock protects bdi_tree and updates to bdi_list. bdi_list has RCU
 	if (bdi->dev)	/* The driver needs to use separate queues per device */
 		return 0;
-	dev = device_create_vargs(bdi_class, NULL, MKDEV(0, 0), bdi, fmt, args);
+	vsnprintf(bdi->dev_name, sizeof(bdi->dev_name), fmt, args);
+	dev = device_create(bdi_class, NULL, MKDEV(0, 0), bdi, bdi->dev_name);
 	if (IS_ERR(dev))
 		return PTR_ERR(dev);
 }
 EXPORT_SYMBOL(bdi_put);
+const char *bdi_dev_name(struct backing_dev_info *bdi)
+{
+	if (!bdi || !bdi->dev)
+		return bdi_unknown_name;
+	return bdi->dev_name;
+}
+EXPORT_SYMBOL_GPL(bdi_dev_name);
 static wait_queue_head_t congestion_wqh[2] = {
 		__WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]),
 		__WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1])

mm/memcontrol.c+9−6

 	unsigned int size;
 	int node;
 	int __maybe_unused i;
+	long error = -ENOMEM;
 	size = sizeof(struct mem_cgroup);
 	size += nr_node_ids * sizeof(struct mem_cgroup_per_node *);
 	memcg = kzalloc(size, GFP_KERNEL);
 	if (!memcg)
-		return NULL;
+		return ERR_PTR(error);
 	memcg->id.id = idr_alloc(&mem_cgroup_idr, NULL,
 				 1, MEM_CGROUP_ID_MAX,
 				 GFP_KERNEL);
-	if (memcg->id.id < 0)
+	if (memcg->id.id < 0) {
+		error = memcg->id.id;
 		goto fail;
+	}
 	memcg->vmstats_local = alloc_percpu(struct memcg_vmstats_percpu);
 	if (!memcg->vmstats_local)
 fail:
 	mem_cgroup_id_remove(memcg);
 	__mem_cgroup_free(memcg);
-	return NULL;
+	return ERR_PTR(error);
 }
 static struct cgroup_subsys_state * __ref
 	long error = -ENOMEM;
 	memcg = mem_cgroup_alloc();
-	if (!memcg)
+	if (IS_ERR(memcg))
-		return ERR_PTR(error);
+		return ERR_CAST(memcg);
 	WRITE_ONCE(memcg->high, PAGE_COUNTER_MAX);
 	memcg->soft_limit = PAGE_COUNTER_MAX;
 fail:
 	mem_cgroup_id_remove(memcg);
 	mem_cgroup_free(memcg);
-	return ERR_PTR(-ENOMEM);
+	return ERR_PTR(error);
 }
 static int mem_cgroup_css_online(struct cgroup_subsys_state *css)

mm/page_alloc.c+9−0

 		if (!__pageblock_pfn_to_page(block_start_pfn,
 					     block_end_pfn, zone))
 			return;
+		cond_resched();
 	}
 	/* We confirm that there is no hole */
 	if (!watermark_boost_factor)
 		return;
+	/*
+	 * Don't bother in zones that are unlikely to produce results.
+	 * On small machines, including kdump capture kernels running
+	 * in a small area, boosting the watermark can cause an out of
+	 * memory situation immediately.
+	 */
+	if ((pageblock_nr_pages * 4) > zone_managed_pages(zone))
+		return;
 	max_boost = mult_frac(zone->_watermark[WMARK_HIGH],
 			watermark_boost_factor, 10000);

mm/percpu.c+10−4

 #include <linux/workqueue.h>
 #include <linux/kmemleak.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
 #include <asm/cacheflush.h>
 #include <asm/sections.h>
 static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
 				 gfp_t gfp)
 {
-	/* whitelisted flags that can be passed to the backing allocators */
+	gfp_t pcpu_gfp;
-	gfp_t pcpu_gfp = gfp & (GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN);
+	bool is_atomic;
-	bool is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
+	bool do_warn;
-	bool do_warn = !(gfp & __GFP_NOWARN);
 	static int warn_limit = 10;
 	struct pcpu_chunk *chunk, *next;
 	const char *err;
 	void __percpu *ptr;
 	size_t bits, bit_align;
+	gfp = current_gfp_context(gfp);
+	/* whitelisted flags that can be passed to the backing allocators */
+	pcpu_gfp = gfp & (GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN);
+	is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
+	do_warn = !(gfp & __GFP_NOWARN);
 	/*
 	 * There is now a minimum allocation size of PCPU_MIN_ALLOC_SIZE,
 	 * therefore alignment must be a minimum of that many bytes.

mm/slub.c+30−15

 	metadata_access_disable();
 }
+/*
+ * See comment in calculate_sizes().
+ */
+static inline bool freeptr_outside_object(struct kmem_cache *s)
+{
+	return s->offset >= s->inuse;
+}
+/*
+ * Return offset of the end of info block which is inuse + free pointer if
+ * not overlapping with object.
+ */
+static inline unsigned int get_info_end(struct kmem_cache *s)
+{
+	if (freeptr_outside_object(s))
+		return s->inuse + sizeof(void *);
+	else
+		return s->inuse;
+}
 static struct track *get_track(struct kmem_cache *s, void *object,
 	enum track_item alloc)
 {
 	struct track *p;
-	if (s->offset)
+	p = object + get_info_end(s);
-		p = object + s->offset + sizeof(void *);
-	else
-		p = object + s->inuse;
 	return p + alloc;
 }
 		print_section(KERN_ERR, "Redzone ", p + s->object_size,
 			s->inuse - s->object_size);
-	if (s->offset)
+	off = get_info_end(s);
-		off = s->offset + sizeof(void *);
-	else
-		off = s->inuse;
 	if (s->flags & SLAB_STORE_USER)
 		off += 2 * sizeof(struct track);
  * object address
  * 	Bytes of the object to be managed.
  * 	If the freepointer may overlay the object then the free
- * 	pointer is the first word of the object.
+ *	pointer is at the middle of the object.
  *
  * 	Poisoning uses 0x6b (POISON_FREE) and the last byte is
  * 	0xa5 (POISON_END)
 static int check_pad_bytes(struct kmem_cache *s, struct page *page, u8 *p)
 {
-	unsigned long off = s->inuse;	/* The end of info */
+	unsigned long off = get_info_end(s);	/* The end of info */
-	if (s->offset)
-		/* Freepointer is placed after the object. */
-		off += sizeof(void *);
 	if (s->flags & SLAB_STORE_USER)
 		/* We also have user information there */
 		check_pad_bytes(s, page, p);
 	}
-	if (!s->offset && val == SLUB_RED_ACTIVE)
+	if (!freeptr_outside_object(s) && val == SLUB_RED_ACTIVE)
 		/*
 		 * Object and freepointer overlap. Cannot check
 		 * freepointer while object is allocated.
 		 *
 		 * This is the case if we do RCU, have a constructor or
 		 * destructor or are poisoning the objects.
+		 *
+		 * The assumption that s->offset >= s->inuse means free
+		 * pointer is outside of the object is used in the
+		 * freeptr_outside_object() function. If that is no
+		 * longer true, the function needs to be modified.
 		 */
 		s->offset = size;
 		size += sizeof(void *);

mm/vmscan.c+0−1

@@ -1625,7 +1625,6 @@ static __always_inline void update_lru_sizes(struct lruvec *lruvec, · 1624 unmodified lines
1625	* @dst: The temp list to put pages on to.	1625	* @dst: The temp list to put pages on to.
1626	* @nr_scanned: The number of pages that were scanned.	1626	* @nr_scanned: The number of pages that were scanned.
1627	* @sc: The scan_control struct for this reclaim session	1627	* @sc: The scan_control struct for this reclaim session
1628	* @mode: One of the LRU isolation modes
1629	* @lru: LRU list id for isolating	1628	* @lru: LRU list id for isolating
1630	*	1629	*
1631	* returns how many pages were moved onto *@dst.	1630	* returns how many pages were moved onto *@dst.

net/atm/common.c+11−11

@@ -177,18 +177,18 @@ static void vcc_destroy_socket(struct sock *sk) · 176 unmodified lines
177		177
178	set_bit(ATM_VF_CLOSE, &vcc->flags);	178	set_bit(ATM_VF_CLOSE, &vcc->flags);
179	clear_bit(ATM_VF_READY, &vcc->flags);	179	clear_bit(ATM_VF_READY, &vcc->flags);
180	if (vcc->dev) {	180	if (vcc->dev && vcc->dev->ops->close)
181	if (vcc->dev->ops->close)	181	vcc->dev->ops->close(vcc);
182	vcc->dev->ops->close(vcc);	182	if (vcc->push)
183	if (vcc->push)	183	vcc->push(vcc, NULL); /* atmarpd has no push */
184	vcc->push(vcc, NULL); /* atmarpd has no push */	184	module_put(vcc->owner);
185	module_put(vcc->owner);	185
186		186	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
187	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {	187	atm_return(vcc, skb->truesize);
188	atm_return(vcc, skb->truesize);	188	kfree_skb(skb);
189	kfree_skb(skb);	189	}
190	}
191		190
		191	if (vcc->dev && vcc->dev->ops->owner) {
192	module_put(vcc->dev->ops->owner);	192	module_put(vcc->dev->ops->owner);
193	atm_dev_put(vcc->dev);	193	atm_dev_put(vcc->dev);
194	}	194	}

net/atm/lec.c+6−0

 		entry->vcc = NULL;
 	}
 	if (entry->recv_vcc) {
+		struct atm_vcc *vcc = entry->recv_vcc;
+		struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
+		kfree(vpriv);
+		vcc->user_back = NULL;
 		entry->recv_vcc->push = entry->old_recv_push;
 		vcc_release_async(entry->recv_vcc, -EPIPE);
 		entry->recv_vcc = NULL;

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

@@ -893,7 +893,7 @@ static void batadv_v_ogm_process(const struct sk_buff *skb, int ogm_offset, · 892 unmodified lines
893		893
894	orig_node = batadv_v_ogm_orig_get(bat_priv, ogm_packet->orig);	894	orig_node = batadv_v_ogm_orig_get(bat_priv, ogm_packet->orig);
895	if (!orig_node)	895	if (!orig_node)
896	return;	896	goto out;
897		897
898	neigh_node = batadv_neigh_node_get_or_create(orig_node, if_incoming,	898	neigh_node = batadv_neigh_node_get_or_create(orig_node, if_incoming,
899	ethhdr->h_source);	899	ethhdr->h_source);

net/batman-adv/network-coding.c+1−8

  */
 static u8 batadv_nc_random_weight_tq(u8 tq)
 {
-	u8 rand_val, rand_tq;
-	get_random_bytes(&rand_val, sizeof(rand_val));
 	/* randomize the estimated packet loss (max TQ - estimated TQ) */
-	rand_tq = rand_val * (BATADV_TQ_MAX_VALUE - tq);
+	u8 rand_tq = prandom_u32_max(BATADV_TQ_MAX_VALUE + 1 - tq);
-	/* normalize the randomized packet loss */
-	rand_tq /= BATADV_TQ_MAX_VALUE;
 	/* convert to (randomized) estimated tq again */
 	return BATADV_TQ_MAX_VALUE - rand_tq;

net/batman-adv/sysfs.c+2−1

 	ret = batadv_parse_throughput(net_dev, buff, "throughput_override",
 				      &tp_override);
 	if (!ret)
-		return count;
+		goto out;
 	old_tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
 	if (old_tp_override == tp_override)
 	tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
+	batadv_hardif_put(hard_iface);
 	return sprintf(buff, "%u.%u MBit\n", tp_override / 10,
 		       tp_override % 10);
 }

net/bridge/br_netlink.c+1−0

@@ -612,6 +612,7 @@ int br_process_vlan_info(struct net_bridge *br, · 611 unmodified lines
612	v - 1, rtm_cmd);	612	v - 1, rtm_cmd);
613	v_change_start = 0;	613	v_change_start = 0;
614	}	614	}
		615	cond_resched();
615	}	616	}
616	/* v_change_start is set only if the last/whole range changed */	617	/* v_change_start is set only if the last/whole range changed */
617	if (v_change_start)	618	if (v_change_start)

net/core/devlink.c+10−2

 		end_offset = nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
 		end_offset += nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]);
 		dump = false;
+		if (start_offset == end_offset) {
+			err = 0;
+			goto nla_put_failure;
+		}
 	}
 	err = devlink_nl_region_read_snapshot_fill(skb, devlink,
 {
 	enum devlink_health_reporter_state prev_health_state;
 	struct devlink *devlink = reporter->devlink;
+	unsigned long recover_ts_threshold;
 	/* write a log message of the current error */
 	WARN_ON(!msg);
 	devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
 	/* abort if the previous error wasn't recovered */
+	recover_ts_threshold = reporter->last_recovery_ts +
+			       msecs_to_jiffies(reporter->graceful_period);
 	if (reporter->auto_recover &&
 	    (prev_health_state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY ||
-	     jiffies - reporter->last_recovery_ts <
+	     (reporter->last_recovery_ts && reporter->recovery_count &&
-	     msecs_to_jiffies(reporter->graceful_period))) {
+	      time_is_after_jiffies(recover_ts_threshold)))) {
 		trace_devlink_health_recover_aborted(devlink,
 						     reporter->ops->name,
 						     reporter->health_state,

net/core/drop_monitor.c+7−4

 static void trace_drop_common(struct sk_buff *skb, void *location)
 {
 	struct net_dm_alert_msg *msg;
+	struct net_dm_drop_point *point;
 	struct nlmsghdr *nlh;
 	struct nlattr *nla;
 	int i;
 	nlh = (struct nlmsghdr *)dskb->data;
 	nla = genlmsg_data(nlmsg_data(nlh));
 	msg = nla_data(nla);
+	point = msg->points;
 	for (i = 0; i < msg->entries; i++) {
-		if (!memcmp(&location, msg->points[i].pc, sizeof(void *))) {
+		if (!memcmp(&location, &point->pc, sizeof(void *))) {
-			msg->points[i].count++;
+			point->count++;
 			goto out;
 		}
+		point++;
 	}
 	if (msg->entries == dm_hit_limit)
 		goto out;
 	 */
 	__nla_reserve_nohdr(dskb, sizeof(struct net_dm_drop_point));
 	nla->nla_len += NLA_ALIGN(sizeof(struct net_dm_drop_point));
-	memcpy(msg->points[msg->entries].pc, &location, sizeof(void *));
+	memcpy(point->pc, &location, sizeof(void *));
-	msg->points[msg->entries].count = 1;
+	point->count = 1;
 	msg->entries++;
 	if (!timer_pending(&data->send_timer)) {

net/core/neighbour.c+3−3

 				   NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
 	}
+	if (protocol)
+		neigh->protocol = protocol;
 	if (ndm->ndm_flags & NTF_EXT_LEARNED)
 		flags |= NEIGH_UPDATE_F_EXT_LEARNED;
 		err = __neigh_update(neigh, lladdr, ndm->ndm_state, flags,
 				     NETLINK_CB(skb).portid, extack);
-	if (protocol)
-		neigh->protocol = protocol;
 	neigh_release(neigh);
 out:

net/core/sock.c+0−1

@@ -2364,7 +2364,6 @@ static void sk_leave_memory_pressure(struct sock *sk) · 2363 unmodified lines
2364	}	2364	}
2365	}	2365	}
2366		2366
2367	/* On 32bit arches, an skb frag is limited to 2^15 */
2368	#define SKB_FRAG_PAGE_ORDER get_order(32768)	2367	#define SKB_FRAG_PAGE_ORDER get_order(32768)
2369	DEFINE_STATIC_KEY_FALSE(net_high_order_alloc_disable_key);	2368	DEFINE_STATIC_KEY_FALSE(net_high_order_alloc_disable_key);
2370		2369

net/dsa/dsa2.c+1−1

@@ -459,7 +459,7 @@ static int dsa_tree_setup_switches(struct dsa_switch_tree *dst) · 458 unmodified lines
459	list_for_each_entry(dp, &dst->ports, list) {	459	list_for_each_entry(dp, &dst->ports, list) {
460	err = dsa_port_setup(dp);	460	err = dsa_port_setup(dp);
461	if (err)	461	if (err)
462	goto teardown;	462	continue;
463	}	463	}
464		464
465	return 0;	465	return 0;

net/dsa/master.c+2−1

@@ -289,7 +289,8 @@ static void dsa_master_ndo_teardown(struct net_device *dev) · 288 unmodified lines
289	{	289	{
290	struct dsa_port *cpu_dp = dev->dsa_ptr;	290	struct dsa_port *cpu_dp = dev->dsa_ptr;
291		291
292	dev->netdev_ops = cpu_dp->orig_ndo_ops;	292	if (cpu_dp->orig_ndo_ops)
		293	dev->netdev_ops = cpu_dp->orig_ndo_ops;
293	cpu_dp->orig_ndo_ops = NULL;	294	cpu_dp->orig_ndo_ops = NULL;
294	}	295	}
295		296

net/dsa/slave.c+3−5

 	struct dsa_port *to_dp;
 	int err;
-	act = &cls->rule->action.entries[0];
 	if (!ds->ops->port_mirror_add)
 		return -EOPNOTSUPP;
-	if (!act->dev)
-		return -EINVAL;
 	if (!flow_action_basic_hw_stats_check(&cls->rule->action,
 					      cls->common.extack))
 		return -EOPNOTSUPP;
 	act = &cls->rule->action.entries[0];
+	if (!act->dev)
+		return -EINVAL;
 	if (!dsa_slave_dev_check(act->dev))
 		return -EOPNOTSUPP;

net/hsr/hsr_slave.c+1−1

@@ -18,7 +18,7 @@ static rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb) · 17 unmodified lines
18	{	18	{
19	struct sk_buff skb = pskb;	19	struct sk_buff skb = pskb;
20	struct hsr_port *port;	20	struct hsr_port *port;
21	u16 protocol;	21	__be16 protocol;
22		22
23	if (!skb_mac_header_was_set(skb)) {	23	if (!skb_mac_header_was_set(skb)) {
24	WARN_ONCE(1, "%s: skb invalid", __func__);	24	WARN_ONCE(1, "%s: skb invalid", __func__);

net/ipv4/tcp_input.c+0−7

 				 */
 				break;
 #endif
-			case TCPOPT_MPTCP:
-				mptcp_parse_option(skb, ptr, opsize, opt_rx);
-				break;
 			case TCPOPT_FASTOPEN:
 				tcp_parse_fastopen_option(
 					opsize - TCPOLEN_FASTOPEN_BASE,
 		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
 		tcp_initialize_rcv_mss(sk);
-		if (sk_is_mptcp(sk))
-			mptcp_rcv_synsent(sk);
 		/* Remember, tcp_poll() does not lock socket!
 		 * Change state from SYN-SENT only after copied_seq
 		 * is initialized. */

net/ipv6/route.c+25−0

@@ -1385,9 +1385,18 @@ static struct rt6_info ip6_rt_pcpu_alloc(const struct fib6_result res) · 1384 unmodified lines
1385	}	1385	}
1386	ip6_rt_copy_init(pcpu_rt, res);	1386	ip6_rt_copy_init(pcpu_rt, res);
1387	pcpu_rt->rt6i_flags \|= RTF_PCPU;	1387	pcpu_rt->rt6i_flags \|= RTF_PCPU;
		1388
		1389	if (f6i->nh)
		1390	pcpu_rt->sernum = rt_genid_ipv6(dev_net(dev));
		1391
1388	return pcpu_rt;	1392	return pcpu_rt;
1389	}	1393	}
1390		1394
		1395	static bool rt6_is_valid(const struct rt6_info *rt6)
		1396	{
		1397	return rt6->sernum == rt_genid_ipv6(dev_net(rt6->dst.dev));
		1398	}
		1399
1391	/* It should be called with rcu_read_lock() acquired */	1400	/* It should be called with rcu_read_lock() acquired */
1392	static struct rt6_info rt6_get_pcpu_route(const struct fib6_result res)	1401	static struct rt6_info rt6_get_pcpu_route(const struct fib6_result res)
1393	{	1402	{
@@ -1395,6 +1404,19 @@ static struct rt6_info rt6_get_pcpu_route(const struct fib6_result res) · 1 unmodified line
1395		1404
1396	pcpu_rt = this_cpu_read(*res->nh->rt6i_pcpu);	1405	pcpu_rt = this_cpu_read(*res->nh->rt6i_pcpu);
1397		1406
		1407	if (pcpu_rt && pcpu_rt->sernum && !rt6_is_valid(pcpu_rt)) {
		1408	struct rt6_info prev, *p;
		1409
		1410	p = this_cpu_ptr(res->nh->rt6i_pcpu);
		1411	prev = xchg(p, NULL);
		1412	if (prev) {
		1413	dst_dev_put(&prev->dst);
		1414	dst_release(&prev->dst);
		1415	}
		1416
		1417	pcpu_rt = NULL;
		1418	}
		1419
1398	return pcpu_rt;	1420	return pcpu_rt;
1399	}	1421	}
1400		1422
@@ -2593,6 +2615,9 @@ static struct dst_entry ip6_dst_check(struct dst_entry dst, u32 cookie) · 1192 unmodified lines
2593		2615
2594	rt = container_of(dst, struct rt6_info, dst);	2616	rt = container_of(dst, struct rt6_info, dst);
2595		2617
		2618	if (rt->sernum)
		2619	return rt6_is_valid(rt) ? dst : NULL;
		2620
2596	rcu_read_lock();	2621	rcu_read_lock();
2597		2622
2598	/* All IPV6 dsts are created with ->obsolete set to the value	2623	/* All IPV6 dsts are created with ->obsolete set to the value

net/ipv6/seg6.c+8−2

 bool seg6_validate_srh(struct ipv6_sr_hdr *srh, int len)
 {
-	int trailing;
 	unsigned int tlv_offset;
+	int max_last_entry;
+	int trailing;
 	if (srh->type != IPV6_SRCRT_TYPE_4)
 		return false;
 	if (((srh->hdrlen + 1) << 3) != len)
 		return false;
-	if (srh->segments_left > srh->first_segment)
+	max_last_entry = (srh->hdrlen / 2) - 1;
+	if (srh->first_segment > max_last_entry)
+		return false;
+	if (srh->segments_left > srh->first_segment + 1)
 		return false;
 	tlv_offset = sizeof(*srh) + ((srh->first_segment + 1) << 4);

net/mptcp/options.c+41−54

 	return (flags & MPTCP_CAP_FLAG_MASK) == MPTCP_CAP_HMAC_SHA256;
 }
-void mptcp_parse_option(const struct sk_buff *skb, const unsigned char *ptr,
+static void mptcp_parse_option(const struct sk_buff *skb,
-			int opsize, struct tcp_options_received *opt_rx)
+			       const unsigned char *ptr, int opsize,
+			       struct mptcp_options_received *mp_opt)
 {
-	struct mptcp_options_received *mp_opt = &opt_rx->mptcp;
 	u8 subtype = *ptr >> 4;
 	int expected_opsize;
 	u8 version;
 }
 void mptcp_get_options(const struct sk_buff *skb,
-		       struct tcp_options_received *opt_rx)
+		       struct mptcp_options_received *mp_opt)
 {
-	const unsigned char *ptr;
 	const struct tcphdr *th = tcp_hdr(skb);
-	int length = (th->doff * 4) - sizeof(struct tcphdr);
+	const unsigned char *ptr;
+	int length;
+	/* initialize option status */
+	mp_opt->mp_capable = 0;
+	mp_opt->mp_join = 0;
+	mp_opt->add_addr = 0;
+	mp_opt->rm_addr = 0;
+	mp_opt->dss = 0;
+	length = (th->doff * 4) - sizeof(struct tcphdr);
 	ptr = (const unsigned char *)(th + 1);
 	while (length > 0) {
 			if (opsize > length)
 				return;	/* don't parse partial options */
 			if (opcode == TCPOPT_MPTCP)
-				mptcp_parse_option(skb, ptr, opsize, opt_rx);
+				mptcp_parse_option(skb, ptr, opsize, mp_opt);
 			ptr += opsize - 2;
 			length -= opsize;
 		}
 	return false;
 }
-void mptcp_rcv_synsent(struct sock *sk)
-{
-	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
-	struct tcp_sock *tp = tcp_sk(sk);
-	if (subflow->request_mptcp && tp->rx_opt.mptcp.mp_capable) {
-		subflow->mp_capable = 1;
-		subflow->can_ack = 1;
-		subflow->remote_key = tp->rx_opt.mptcp.sndr_key;
-		pr_debug("subflow=%p, remote_key=%llu", subflow,
-			 subflow->remote_key);
-	} else if (subflow->request_join && tp->rx_opt.mptcp.mp_join) {
-		subflow->mp_join = 1;
-		subflow->thmac = tp->rx_opt.mptcp.thmac;
-		subflow->remote_nonce = tp->rx_opt.mptcp.nonce;
-		pr_debug("subflow=%p, thmac=%llu, remote_nonce=%u", subflow,
-			 subflow->thmac, subflow->remote_nonce);
-	} else if (subflow->request_mptcp) {
-		tcp_sk(sk)->is_mptcp = 0;
-	}
-}
 /* MP_JOIN client subflow must wait for 4th ack before sending any data:
  * TCP can't schedule delack timer before the subflow is fully established.
  * MPTCP uses the delack timer to do 3rd ack retransmissions
 	if (TCP_SKB_CB(skb)->seq != subflow->ssn_offset + 1)
 		return subflow->mp_capable;
-	if (mp_opt->use_ack) {
+	if (mp_opt->dss && mp_opt->use_ack) {
 		/* subflows are fully established as soon as we get any
 		 * additional ack.
 		 */
 		goto fully_established;
 	}
-	WARN_ON_ONCE(subflow->can_ack);
 	/* If the first established packet does not contain MP_CAPABLE + data
 	 * then fallback to TCP
 	 */
 		return false;
 	}
+	if (unlikely(!READ_ONCE(msk->pm.server_side)))
+		pr_warn_once("bogus mpc option on established client sk");
 	subflow->fully_established = 1;
 	subflow->remote_key = mp_opt->sndr_key;
 	subflow->can_ack = 1;
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
 	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
-	struct mptcp_options_received *mp_opt;
+	struct mptcp_options_received mp_opt;
 	struct mptcp_ext *mpext;
-	mp_opt = &opt_rx->mptcp;
+	mptcp_get_options(skb, &mp_opt);
-	if (!check_fully_established(msk, sk, subflow, skb, mp_opt))
+	if (!check_fully_established(msk, sk, subflow, skb, &mp_opt))
 		return;
-	if (mp_opt->add_addr && add_addr_hmac_valid(msk, mp_opt)) {
+	if (mp_opt.add_addr && add_addr_hmac_valid(msk, &mp_opt)) {
 		struct mptcp_addr_info addr;
-		addr.port = htons(mp_opt->port);
+		addr.port = htons(mp_opt.port);
-		addr.id = mp_opt->addr_id;
+		addr.id = mp_opt.addr_id;
-		if (mp_opt->family == MPTCP_ADDR_IPVERSION_4) {
+		if (mp_opt.family == MPTCP_ADDR_IPVERSION_4) {
 			addr.family = AF_INET;
-			addr.addr = mp_opt->addr;
+			addr.addr = mp_opt.addr;
 		}
 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
-		else if (mp_opt->family == MPTCP_ADDR_IPVERSION_6) {
+		else if (mp_opt.family == MPTCP_ADDR_IPVERSION_6) {
 			addr.family = AF_INET6;
-			addr.addr6 = mp_opt->addr6;
+			addr.addr6 = mp_opt.addr6;
 		}
 #endif
-		if (!mp_opt->echo)
+		if (!mp_opt.echo)
 			mptcp_pm_add_addr_received(msk, &addr);
-		mp_opt->add_addr = 0;
+		mp_opt.add_addr = 0;
 	}
-	if (!mp_opt->dss)
+	if (!mp_opt.dss)
 		return;
 	/* we can't wait for recvmsg() to update the ack_seq, otherwise
 	 * monodirectional flows will stuck
 	 */
-	if (mp_opt->use_ack)
+	if (mp_opt.use_ack)
-		update_una(msk, mp_opt);
+		update_una(msk, &mp_opt);
 	mpext = skb_ext_add(skb, SKB_EXT_MPTCP);
 	if (!mpext)
 	memset(mpext, 0, sizeof(*mpext));
-	if (mp_opt->use_map) {
+	if (mp_opt.use_map) {
-		if (mp_opt->mpc_map) {
+		if (mp_opt.mpc_map) {
 			/* this is an MP_CAPABLE carrying MPTCP data
 			 * we know this map the first chunk of data
 			 */
 			mpext->subflow_seq = 1;
 			mpext->dsn64 = 1;
 			mpext->mpc_map = 1;
+			mpext->data_fin = 0;
 		} else {
-			mpext->data_seq = mp_opt->data_seq;
+			mpext->data_seq = mp_opt.data_seq;
-			mpext->subflow_seq = mp_opt->subflow_seq;
+			mpext->subflow_seq = mp_opt.subflow_seq;
-			mpext->dsn64 = mp_opt->dsn64;
+			mpext->dsn64 = mp_opt.dsn64;
-			mpext->data_fin = mp_opt->data_fin;
+			mpext->data_fin = mp_opt.data_fin;
 		}
-		mpext->data_len = mp_opt->data_len;
+		mpext->data_len = mp_opt.data_len;
 		mpext->use_map = 1;
 	}
 }

net/mptcp/protocol.c+9−8

 static int mptcp_disconnect(struct sock *sk, int flags)
 {
-	lock_sock(sk);
+	/* Should never be called.
-	__mptcp_clear_xmit(sk);
+	 * inet_stream_connect() calls ->disconnect, but that
-	release_sock(sk);
+	 * refers to the subflow socket, not the mptcp one.
-	mptcp_cancel_work(sk);
+	 */
-	return tcp_disconnect(sk, flags);
+	WARN_ON_ONCE(1);
+	return 0;
 }
 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 #endif
 struct sock *mptcp_sk_clone(const struct sock *sk,
-			    const struct tcp_options_received *opt_rx,
+			    const struct mptcp_options_received *mp_opt,
 			    struct request_sock *req)
 {
 	struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
 	msk->write_seq = subflow_req->idsn + 1;
 	atomic64_set(&msk->snd_una, msk->write_seq);
-	if (opt_rx->mptcp.mp_capable) {
+	if (mp_opt->mp_capable) {
 		msk->can_ack = true;
-		msk->remote_key = opt_rx->mptcp.sndr_key;
+		msk->remote_key = mp_opt->sndr_key;
 		mptcp_crypto_key_sha(msk->remote_key, NULL, &ack_seq);
 		ack_seq++;
 		msk->ack_seq = ack_seq;

net/mptcp/protocol.h+41−2

@@ -91,6 +91,45 @@ · 90 unmodified lines
91	#define MPTCP_WORK_RTX 2	91	#define MPTCP_WORK_RTX 2
92	#define MPTCP_WORK_EOF 3	92	#define MPTCP_WORK_EOF 3
93		93
		94	struct mptcp_options_received {
		95	u64 sndr_key;
		96	u64 rcvr_key;
		97	u64 data_ack;
		98	u64 data_seq;
		99	u32 subflow_seq;
		100	u16 data_len;
		101	u16 mp_capable : 1,
		102	mp_join : 1,
		103	dss : 1,
		104	add_addr : 1,
		105	rm_addr : 1,
		106	family : 4,
		107	echo : 1,
		108	backup : 1;
		109	u32 token;
		110	u32 nonce;
		111	u64 thmac;
		112	u8 hmac[20];
		113	u8 join_id;
		114	u8 use_map:1,
		115	dsn64:1,
		116	data_fin:1,
		117	use_ack:1,
		118	ack64:1,
		119	mpc_map:1,
		120	__unused:2;
		121	u8 addr_id;
		122	u8 rm_id;
		123	union {
		124	struct in_addr addr;
		125	#if IS_ENABLED(CONFIG_MPTCP_IPV6)
		126	struct in6_addr addr6;
		127	#endif
		128	};
		129	u64 ahmac;
		130	u16 port;
		131	};
		132
94	static inline __be32 mptcp_option(u8 subopt, u8 len, u8 nib, u8 field)	133	static inline __be32 mptcp_option(u8 subopt, u8 len, u8 nib, u8 field)
95	{	134	{
96	return htonl((TCPOPT_MPTCP << 24) \| (len << 16) \| (subopt << 12) \|	135	return htonl((TCPOPT_MPTCP << 24) \| (len << 16) \| (subopt << 12) \|
@@ -331,10 +370,10 @@ int mptcp_proto_v6_init(void); · 234 unmodified lines
331	#endif	370	#endif
332		371
333	struct sock mptcp_sk_clone(const struct sock sk,	372	struct sock mptcp_sk_clone(const struct sock sk,
334	const struct tcp_options_received *opt_rx,	373	const struct mptcp_options_received *mp_opt,
335	struct request_sock *req);	374	struct request_sock *req);
336	void mptcp_get_options(const struct sk_buff *skb,	375	void mptcp_get_options(const struct sk_buff *skb,
337	struct tcp_options_received *opt_rx);	376	struct mptcp_options_received *mp_opt);
338		377
339	void mptcp_finish_connect(struct sock *sk);	378	void mptcp_finish_connect(struct sock *sk);
340	void mptcp_data_ready(struct sock sk, struct sock ssk);	379	void mptcp_data_ready(struct sock sk, struct sock ssk);

net/mptcp/subflow.c+55−31

 {
 	struct mptcp_subflow_context *listener = mptcp_subflow_ctx(sk_listener);
 	struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
-	struct tcp_options_received rx_opt;
+	struct mptcp_options_received mp_opt;
 	pr_debug("subflow_req=%p, listener=%p", subflow_req, listener);
-	memset(&rx_opt.mptcp, 0, sizeof(rx_opt.mptcp));
+	mptcp_get_options(skb, &mp_opt);
-	mptcp_get_options(skb, &rx_opt);
 	subflow_req->mp_capable = 0;
 	subflow_req->mp_join = 0;
 		return;
 #endif
-	if (rx_opt.mptcp.mp_capable) {
+	if (mp_opt.mp_capable) {
 		SUBFLOW_REQ_INC_STATS(req, MPTCP_MIB_MPCAPABLEPASSIVE);
-		if (rx_opt.mptcp.mp_join)
+		if (mp_opt.mp_join)
 			return;
-	} else if (rx_opt.mptcp.mp_join) {
+	} else if (mp_opt.mp_join) {
 		SUBFLOW_REQ_INC_STATS(req, MPTCP_MIB_JOINSYNRX);
 	}
-	if (rx_opt.mptcp.mp_capable && listener->request_mptcp) {
+	if (mp_opt.mp_capable && listener->request_mptcp) {
 		int err;
 		err = mptcp_token_new_request(req);
 			subflow_req->mp_capable = 1;
 		subflow_req->ssn_offset = TCP_SKB_CB(skb)->seq;
-	} else if (rx_opt.mptcp.mp_join && listener->request_mptcp) {
+	} else if (mp_opt.mp_join && listener->request_mptcp) {
 		subflow_req->ssn_offset = TCP_SKB_CB(skb)->seq;
 		subflow_req->mp_join = 1;
-		subflow_req->backup = rx_opt.mptcp.backup;
+		subflow_req->backup = mp_opt.backup;
-		subflow_req->remote_id = rx_opt.mptcp.join_id;
+		subflow_req->remote_id = mp_opt.join_id;
-		subflow_req->token = rx_opt.mptcp.token;
+		subflow_req->token = mp_opt.token;
-		subflow_req->remote_nonce = rx_opt.mptcp.nonce;
+		subflow_req->remote_nonce = mp_opt.nonce;
 		pr_debug("token=%u, remote_nonce=%u", subflow_req->token,
 			 subflow_req->remote_nonce);
 		if (!subflow_token_join_request(req, skb)) {
 static void subflow_finish_connect(struct sock *sk, const struct sk_buff *skb)
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
+	struct mptcp_options_received mp_opt;
 	struct sock *parent = subflow->conn;
+	struct tcp_sock *tp = tcp_sk(sk);
 	subflow->icsk_af_ops->sk_rx_dst_set(sk, skb);
-	if (inet_sk_state_load(parent) != TCP_ESTABLISHED) {
+	if (inet_sk_state_load(parent) == TCP_SYN_SENT) {
 		inet_sk_state_store(parent, TCP_ESTABLISHED);
 		parent->sk_state_change(parent);
 	}
-	if (subflow->conn_finished || !tcp_sk(sk)->is_mptcp)
+	/* be sure no special action on any packet other than syn-ack */
+	if (subflow->conn_finished)
+		return;
+	subflow->conn_finished = 1;
+	mptcp_get_options(skb, &mp_opt);
+	if (subflow->request_mptcp && mp_opt.mp_capable) {
+		subflow->mp_capable = 1;
+		subflow->can_ack = 1;
+		subflow->remote_key = mp_opt.sndr_key;
+		pr_debug("subflow=%p, remote_key=%llu", subflow,
+			 subflow->remote_key);
+	} else if (subflow->request_join && mp_opt.mp_join) {
+		subflow->mp_join = 1;
+		subflow->thmac = mp_opt.thmac;
+		subflow->remote_nonce = mp_opt.nonce;
+		pr_debug("subflow=%p, thmac=%llu, remote_nonce=%u", subflow,
+			 subflow->thmac, subflow->remote_nonce);
+	} else if (subflow->request_mptcp) {
+		tp->is_mptcp = 0;
+	}
+	if (!tp->is_mptcp)
 		return;
 	if (subflow->mp_capable) {
 		pr_debug("subflow=%p, remote_key=%llu", mptcp_subflow_ctx(sk),
 			 subflow->remote_key);
 		mptcp_finish_connect(sk);
-		subflow->conn_finished = 1;
 		if (skb) {
 			pr_debug("synack seq=%u", TCP_SKB_CB(skb)->seq);
 		if (!mptcp_finish_join(sk))
 			goto do_reset;
-		subflow->conn_finished = 1;
 		MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_JOINSYNACKRX);
 	} else {
 do_reset:
 /* validate hmac received in third ACK */
 static bool subflow_hmac_valid(const struct request_sock *req,
-			       const struct tcp_options_received *rx_opt)
+			       const struct mptcp_options_received *mp_opt)
 {
 	const struct mptcp_subflow_request_sock *subflow_req;
 	u8 hmac[MPTCPOPT_HMAC_LEN];
 			      subflow_req->local_nonce, hmac);
 	ret = true;
-	if (crypto_memneq(hmac, rx_opt->mptcp.hmac, sizeof(hmac)))
+	if (crypto_memneq(hmac, mp_opt->hmac, sizeof(hmac)))
 		ret = false;
 	sock_put((struct sock *)msk);
 {
 	struct mptcp_subflow_context *listener = mptcp_subflow_ctx(sk);
 	struct mptcp_subflow_request_sock *subflow_req;
-	struct tcp_options_received opt_rx;
+	struct mptcp_options_received mp_opt;
 	bool fallback_is_fatal = false;
 	struct sock *new_msk = NULL;
 	bool fallback = false;
 	pr_debug("listener=%p, req=%p, conn=%p", listener, req, listener->conn);
-	opt_rx.mptcp.mp_capable = 0;
+	/* we need later a valid 'mp_capable' value even when options are not
+	 * parsed
+	 */
+	mp_opt.mp_capable = 0;
 	if (tcp_rsk(req)->is_mptcp == 0)
 		goto create_child;
 			goto create_msk;
 		}
-		mptcp_get_options(skb, &opt_rx);
+		mptcp_get_options(skb, &mp_opt);
-		if (!opt_rx.mptcp.mp_capable) {
+		if (!mp_opt.mp_capable) {
 			fallback = true;
 			goto create_child;
 		}
 create_msk:
-		new_msk = mptcp_sk_clone(listener->conn, &opt_rx, req);
+		new_msk = mptcp_sk_clone(listener->conn, &mp_opt, req);
 		if (!new_msk)
 			fallback = true;
 	} else if (subflow_req->mp_join) {
 		fallback_is_fatal = true;
-		opt_rx.mptcp.mp_join = 0;
+		mptcp_get_options(skb, &mp_opt);
-		mptcp_get_options(skb, &opt_rx);
+		if (!mp_opt.mp_join ||
-		if (!opt_rx.mptcp.mp_join ||
+		    !subflow_hmac_valid(req, &mp_opt)) {
-		    !subflow_hmac_valid(req, &opt_rx)) {
 			SUBFLOW_REQ_INC_STATS(req, MPTCP_MIB_JOINACKMAC);
 			return NULL;
 		}
 			/* with OoO packets we can reach here without ingress
 			 * mpc option
 			 */
-			ctx->remote_key = opt_rx.mptcp.sndr_key;
+			ctx->remote_key = mp_opt.sndr_key;
-			ctx->fully_established = opt_rx.mptcp.mp_capable;
+			ctx->fully_established = mp_opt.mp_capable;
-			ctx->can_ack = opt_rx.mptcp.mp_capable;
+			ctx->can_ack = mp_opt.mp_capable;
 		} else if (ctx->mp_join) {
 			struct mptcp_sock *owner;
 	/* check for expected invariant - should never trigger, just help
 	 * catching eariler subtle bugs
 	 */
-	WARN_ON_ONCE(*own_req && child && tcp_sk(child)->is_mptcp &&
+	WARN_ON_ONCE(child && *own_req && tcp_sk(child)->is_mptcp &&
 		     (!mptcp_subflow_ctx(child) ||
 		      !mptcp_subflow_ctx(child)->conn));
 	return child;

net/netfilter/nf_nat_proto.c+1−3

 			  enum nf_nat_manip_type maniptype)
 {
 	struct udphdr *hdr;
-	bool do_csum;
 	if (skb_ensure_writable(skb, hdroff + sizeof(*hdr)))
 		return false;
 	hdr = (struct udphdr *)(skb->data + hdroff);
-	do_csum = hdr->check || skb->ip_summed == CHECKSUM_PARTIAL;
+	__udp_manip_pkt(skb, iphdroff, hdr, tuple, maniptype, !!hdr->check);
-	__udp_manip_pkt(skb, iphdroff, hdr, tuple, maniptype, do_csum);
 	return true;
 }

net/netfilter/nfnetlink_osf.c+7−5

 static const struct tcphdr *nf_osf_hdr_ctx_init(struct nf_osf_hdr_ctx *ctx,
 						const struct sk_buff *skb,
 						const struct iphdr *ip,
-						unsigned char *opts)
+						unsigned char *opts,
+						struct tcphdr *_tcph)
 {
 	const struct tcphdr *tcp;
-	struct tcphdr _tcph;
-	tcp = skb_header_pointer(skb, ip_hdrlen(skb), sizeof(struct tcphdr), &_tcph);
+	tcp = skb_header_pointer(skb, ip_hdrlen(skb), sizeof(struct tcphdr), _tcph);
 	if (!tcp)
 		return NULL;
 	int fmatch = FMATCH_WRONG;
 	struct nf_osf_hdr_ctx ctx;
 	const struct tcphdr *tcp;
+	struct tcphdr _tcph;
 	memset(&ctx, 0, sizeof(ctx));
-	tcp = nf_osf_hdr_ctx_init(&ctx, skb, ip, opts);
+	tcp = nf_osf_hdr_ctx_init(&ctx, skb, ip, opts, &_tcph);
 	if (!tcp)
 		return false;
 	const struct nf_osf_finger *kf;
 	struct nf_osf_hdr_ctx ctx;
 	const struct tcphdr *tcp;
+	struct tcphdr _tcph;
 	memset(&ctx, 0, sizeof(ctx));
-	tcp = nf_osf_hdr_ctx_init(&ctx, skb, ip, opts);
+	tcp = nf_osf_hdr_ctx_init(&ctx, skb, ip, opts, &_tcph);
 	if (!tcp)
 		return false;

net/sched/cls_api.c+16−6

 		err = PTR_ERR(block);
 		goto errout;
 	}
+	block->classid = parent;
 	chain_index = tca[TCA_CHAIN] ? nla_get_u32(tca[TCA_CHAIN]) : 0;
 	if (chain_index > TC_ACT_EXT_VAL_MASK) {
 			return skb->len;
 		parent = tcm->tcm_parent;
-		if (!parent) {
+		if (!parent)
 			q = dev->qdisc;
-			parent = q->handle;
+		else
-		} else {
 			q = qdisc_lookup(dev, TC_H_MAJ(tcm->tcm_parent));
-		}
 		if (!q)
 			goto out;
 		cops = q->ops->cl_ops;
 		block = cops->tcf_block(q, cl, NULL);
 		if (!block)
 			goto out;
+		parent = block->classid;
 		if (tcf_block_shared(block))
 			q = NULL;
 	}
 #endif
 }
+static enum flow_action_hw_stats tc_act_hw_stats(u8 hw_stats)
+{
+	if (WARN_ON_ONCE(hw_stats > TCA_ACT_HW_STATS_ANY))
+		return FLOW_ACTION_HW_STATS_DONT_CARE;
+	else if (!hw_stats)
+		return FLOW_ACTION_HW_STATS_DISABLED;
+	return hw_stats;
+}
 int tc_setup_flow_action(struct flow_action *flow_action,
 			 const struct tcf_exts *exts)
 {
 		if (err)
 			goto err_out_locked;
-		entry->hw_stats = act->hw_stats;
+		entry->hw_stats = tc_act_hw_stats(act->hw_stats);
 		if (is_tcf_gact_ok(act)) {
 			entry->id = FLOW_ACTION_ACCEPT;
 				entry->mangle.mask = tcf_pedit_mask(act, k);
 				entry->mangle.val = tcf_pedit_val(act, k);
 				entry->mangle.offset = tcf_pedit_offset(act, k);
-				entry->hw_stats = act->hw_stats;
+				entry->hw_stats = tc_act_hw_stats(act->hw_stats);
 				entry = &flow_action->entries[++j];
 			}
 		} else if (is_tcf_csum(act)) {

net/sched/sch_choke.c+2−1

@@ -323,7 +323,8 @@ static void choke_reset(struct Qdisc *sch) · 322 unmodified lines
323		323
324	sch->q.qlen = 0;	324	sch->q.qlen = 0;
325	sch->qstats.backlog = 0;	325	sch->qstats.backlog = 0;
326	memset(q->tab, 0, (q->tab_mask + 1) * sizeof(struct sk_buff *));	326	if (q->tab)
		327	memset(q->tab, 0, (q->tab_mask + 1) * sizeof(struct sk_buff *));
327	q->head = q->tail = 0;	328	q->head = q->tail = 0;
328	red_restart(&q->vars);	329	red_restart(&q->vars);
329	}	330	}

net/sched/sch_fq_codel.c+1−1

@@ -416,7 +416,7 @@ static int fq_codel_change(struct Qdisc sch, struct nlattr opt, · 415 unmodified lines
416	q->quantum = max(256U, nla_get_u32(tb[TCA_FQ_CODEL_QUANTUM]));	416	q->quantum = max(256U, nla_get_u32(tb[TCA_FQ_CODEL_QUANTUM]));
417		417
418	if (tb[TCA_FQ_CODEL_DROP_BATCH_SIZE])	418	if (tb[TCA_FQ_CODEL_DROP_BATCH_SIZE])
419	q->drop_batch_size = min(1U, nla_get_u32(tb[TCA_FQ_CODEL_DROP_BATCH_SIZE]));	419	q->drop_batch_size = max(1U, nla_get_u32(tb[TCA_FQ_CODEL_DROP_BATCH_SIZE]));
420		420
421	if (tb[TCA_FQ_CODEL_MEMORY_LIMIT])	421	if (tb[TCA_FQ_CODEL_MEMORY_LIMIT])
422	q->memory_limit = min(1U << 31, nla_get_u32(tb[TCA_FQ_CODEL_MEMORY_LIMIT]));	422	q->memory_limit = min(1U << 31, nla_get_u32(tb[TCA_FQ_CODEL_MEMORY_LIMIT]));

net/sched/sch_sfq.c+9−0

@@ -637,6 +637,15 @@ static int sfq_change(struct Qdisc sch, struct nlattr opt) · 636 unmodified lines
637	if (ctl->divisor &&	637	if (ctl->divisor &&
638	(!is_power_of_2(ctl->divisor) \|\| ctl->divisor > 65536))	638	(!is_power_of_2(ctl->divisor) \|\| ctl->divisor > 65536))
639	return -EINVAL;	639	return -EINVAL;
		640
		641	/* slot->allot is a short, make sure quantum is not too big. */
		642	if (ctl->quantum) {
		643	unsigned int scaled = SFQ_ALLOT_SIZE(ctl->quantum);
		644
		645	if (scaled <= 0 \|\| scaled > SHRT_MAX)
		646	return -EINVAL;
		647	}
		648
640	if (ctl_v1 && !red_check_params(ctl_v1->qth_min, ctl_v1->qth_max,	649	if (ctl_v1 && !red_check_params(ctl_v1->qth_min, ctl_v1->qth_max,
641	ctl_v1->Wlog))	650	ctl_v1->Wlog))
642	return -EINVAL;	651	return -EINVAL;

net/sched/sch_skbprio.c+3−0

@@ -169,6 +169,9 @@ static int skbprio_change(struct Qdisc sch, struct nlattr opt, · 168 unmodified lines
169	{	169	{
170	struct tc_skbprio_qopt *ctl = nla_data(opt);	170	struct tc_skbprio_qopt *ctl = nla_data(opt);
171		171
		172	if (opt->nla_len != nla_attr_size(sizeof(*ctl)))
		173	return -EINVAL;
		174
172	sch->limit = ctl->limit;	175	sch->limit = ctl->limit;
173	return 0;	176	return 0;
174	}	177	}

net/sunrpc/clnt.c+18−6

@@ -880,6 +880,20 @@ EXPORT_SYMBOL_GPL(rpc_shutdown_client); · 879 unmodified lines
880	/*	880	/*
881	* Free an RPC client	881	* Free an RPC client
882	*/	882	*/
		883	static void rpc_free_client_work(struct work_struct *work)
		884	{
		885	struct rpc_clnt *clnt = container_of(work, struct rpc_clnt, cl_work);
		886
		887	/* These might block on processes that might allocate memory,
		888	* so they cannot be called in rpciod, so they are handled separately
		889	* here.
		890	*/
		891	rpc_clnt_debugfs_unregister(clnt);
		892	rpc_clnt_remove_pipedir(clnt);
		893
		894	kfree(clnt);
		895	rpciod_down();
		896	}
883	static struct rpc_clnt *	897	static struct rpc_clnt *
884	rpc_free_client(struct rpc_clnt *clnt)	898	rpc_free_client(struct rpc_clnt *clnt)
885	{	899	{
@@ -890,17 +904,16 @@ rpc_free_client(struct rpc_clnt *clnt) · 4 unmodified lines
890	rcu_dereference(clnt->cl_xprt)->servername);	904	rcu_dereference(clnt->cl_xprt)->servername);
891	if (clnt->cl_parent != clnt)	905	if (clnt->cl_parent != clnt)
892	parent = clnt->cl_parent;	906	parent = clnt->cl_parent;
893	rpc_clnt_debugfs_unregister(clnt);
894	rpc_clnt_remove_pipedir(clnt);
895	rpc_unregister_client(clnt);	907	rpc_unregister_client(clnt);
896	rpc_free_iostats(clnt->cl_metrics);	908	rpc_free_iostats(clnt->cl_metrics);
897	clnt->cl_metrics = NULL;	909	clnt->cl_metrics = NULL;
898	xprt_put(rcu_dereference_raw(clnt->cl_xprt));	910	xprt_put(rcu_dereference_raw(clnt->cl_xprt));
899	xprt_iter_destroy(&clnt->cl_xpi);	911	xprt_iter_destroy(&clnt->cl_xpi);
900	rpciod_down();
901	put_cred(clnt->cl_cred);	912	put_cred(clnt->cl_cred);
902	rpc_free_clid(clnt);	913	rpc_free_clid(clnt);
903	kfree(clnt);	914
		915	INIT_WORK(&clnt->cl_work, rpc_free_client_work);
		916	schedule_work(&clnt->cl_work);
904	return parent;	917	return parent;
905	}	918	}
906		919
@@ -2808,8 +2821,7 @@ int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt, · 1901 unmodified lines
2808	task = rpc_call_null_helper(clnt, xprt, NULL,	2821	task = rpc_call_null_helper(clnt, xprt, NULL,
2809	RPC_TASK_SOFT\|RPC_TASK_SOFTCONN\|RPC_TASK_ASYNC\|RPC_TASK_NULLCREDS,	2822	RPC_TASK_SOFT\|RPC_TASK_SOFTCONN\|RPC_TASK_ASYNC\|RPC_TASK_NULLCREDS,
2810	&rpc_cb_add_xprt_call_ops, data);	2823	&rpc_cb_add_xprt_call_ops, data);
2811	if (IS_ERR(task))	2824
2812	return PTR_ERR(task);
2813	rpc_put_task(task);	2825	rpc_put_task(task);
2814	success:	2826	success:
2815	return 1;	2827	return 1;

net/sunrpc/xprtrdma/rpc_rdma.c+11−4

 	} while (nsegs);
 done:
-	return xdr_stream_encode_item_absent(xdr);
+	if (xdr_stream_encode_item_absent(xdr) < 0)
+		return -EMSGSIZE;
+	return 0;
 }
 /* Register and XDR encode the Write list. Supports encoding a list
 	*segcount = cpu_to_be32(nchunks);
 done:
-	return xdr_stream_encode_item_absent(xdr);
+	if (xdr_stream_encode_item_absent(xdr) < 0)
+		return -EMSGSIZE;
+	return 0;
 }
 /* Register and XDR encode the Reply chunk. Supports encoding an array
 	int nsegs, nchunks;
 	__be32 *segcount;
-	if (wtype != rpcrdma_replych)
+	if (wtype != rpcrdma_replych) {
-		return xdr_stream_encode_item_absent(xdr);
+		if (xdr_stream_encode_item_absent(xdr) < 0)
+			return -EMSGSIZE;
+		return 0;
+	}
 	seg = req->rl_segments;
 	nsegs = rpcrdma_convert_iovs(r_xprt, &rqst->rq_rcv_buf, 0, wtype, seg);

net/sunrpc/xprtrdma/verbs.c+2−1

 	case RDMA_CM_EVENT_DISCONNECTED:
 		ep->re_connect_status = -ECONNABORTED;
 disconnected:
+		xprt_force_disconnect(xprt);
 		return rpcrdma_ep_destroy(ep);
 	default:
 		break;
 		--ep->re_send_count;
 	}
+	trace_xprtrdma_post_send(req);
 	rc = frwr_send(r_xprt, req);
-	trace_xprtrdma_post_send(req, rc);
 	if (rc)
 		return -ENOTCONN;
 	return 0;

net/tipc/topsrv.c+3−2

 		read_lock_bh(&sk->sk_callback_lock);
 		ret = tipc_conn_rcv_sub(srv, con, &s);
 		read_unlock_bh(&sk->sk_callback_lock);
+		if (!ret)
+			return 0;
 	}
-	if (ret < 0)
-		tipc_conn_close(con);
+	tipc_conn_close(con);
 	return ret;
 }

net/tls/tls_sw.c+5−2

 			*copied -= sk_msg_free(sk, msg);
 			tls_free_open_rec(sk);
 		}
+		if (psock)
+			sk_psock_put(sk, psock);
 		return err;
 	}
 more_data:
 	strp_data_ready(&ctx->strp);
 	psock = sk_psock_get(sk);
-	if (psock && !list_empty(&psock->ingress_msg)) {
+	if (psock) {
-		ctx->saved_data_ready(sk);
+		if (!list_empty(&psock->ingress_msg))
+			ctx->saved_data_ready(sk);
 		sk_psock_put(sk, psock);
 	}
 }

net/vmw_vsock/virtio_transport_common.c+4−0

 void virtio_transport_deliver_tap_pkt(struct virtio_vsock_pkt *pkt)
 {
+	if (pkt->tap_delivered)
+		return;
 	vsock_deliver_tap(virtio_transport_build_skb, pkt);
+	pkt->tap_delivered = true;
 }
 EXPORT_SYMBOL_GPL(virtio_transport_deliver_tap_pkt);

net/x25/x25_subr.c+6−0

 		sk->sk_state_change(sk);
 		sock_set_flag(sk, SOCK_DEAD);
 	}
+	if (x25->neighbour) {
+		read_lock_bh(&x25_list_lock);
+		x25_neigh_put(x25->neighbour);
+		x25->neighbour = NULL;
+		read_unlock_bh(&x25_list_lock);
+	}
 }
 /*

samples/trace_events/trace-events-sample.h+1−1

@@ -416,7 +416,7 @@ TRACE_EVENT_FN(foo_bar_with_fn, · 415 unmodified lines
416	* Note, TRACE_EVENT() itself is simply defined as:	416	* Note, TRACE_EVENT() itself is simply defined as:
417	*	417	*
418	* #define TRACE_EVENT(name, proto, args, tstruct, assign, printk) \	418	* #define TRACE_EVENT(name, proto, args, tstruct, assign, printk) \
419	* DEFINE_EVENT_CLASS(name, proto, args, tstruct, assign, printk); \	419	* DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, printk); \
420	* DEFINE_EVENT(name, name, proto, args)	420	* DEFINE_EVENT(name, name, proto, args)
421	*	421	*
422	* The DEFINE_EVENT() also can be declared with conditions and reg functions:	422	* The DEFINE_EVENT() also can be declared with conditions and reg functions:

scripts/decodecode+1−1

@@ -126,7 +126,7 @@ faultlinenum=$(( $(wc -l $T.oo \| cut -d" " -f1) - \ · 125 unmodified lines
126	faultline=`cat $T.dis \| head -1 \| cut -d":" -f2-`	126	faultline=`cat $T.dis \| head -1 \| cut -d":" -f2-`
127	faultline=`echo "$faultline" \| sed -e 's/\[/\\\[/g; s/\]/\\\]/g'`	127	faultline=`echo "$faultline" \| sed -e 's/\[/\\\[/g; s/\]/\\\]/g'`
128		128
129	cat $T.oo \| sed -e "${faultlinenum}s/^$.:$$.$/\1\*\2\t\t<-- trapping instruction/"	129	cat $T.oo \| sed -e "${faultlinenum}s/^$[^:]:$$.$/\1\*\2\t\t<-- trapping instruction/"
130	echo	130	echo
131	cat $T.aa	131	cat $T.aa
132	cleanup	132	cleanup

scripts/gcc-plugins/Makefile+1−0

@@ -4,6 +4,7 @@ GCC_PLUGINS_DIR := $(shell $(CC) -print-file-name=plugin) · 3 unmodified lines
4	HOST_EXTRACXXFLAGS += -I$(GCC_PLUGINS_DIR)/include -I$(src) -std=gnu++98 -fno-rtti	4	HOST_EXTRACXXFLAGS += -I$(GCC_PLUGINS_DIR)/include -I$(src) -std=gnu++98 -fno-rtti
5	HOST_EXTRACXXFLAGS += -fno-exceptions -fasynchronous-unwind-tables -ggdb	5	HOST_EXTRACXXFLAGS += -fno-exceptions -fasynchronous-unwind-tables -ggdb
6	HOST_EXTRACXXFLAGS += -Wno-narrowing -Wno-unused-variable -Wno-c++11-compat	6	HOST_EXTRACXXFLAGS += -Wno-narrowing -Wno-unused-variable -Wno-c++11-compat
		7	HOST_EXTRACXXFLAGS += -Wno-format-diag
7		8
8	$(obj)/randomize_layout_plugin.o: $(objtree)/$(obj)/randomize_layout_seed.h	9	$(obj)/randomize_layout_plugin.o: $(objtree)/$(obj)/randomize_layout_seed.h
9	quiet_cmd_create_randomize_layout_seed = GENSEED $@	10	quiet_cmd_create_randomize_layout_seed = GENSEED $@

scripts/gcc-plugins/gcc-common.h+4−0

 #include "ggc.h"
 #include "timevar.h"
+#if BUILDING_GCC_VERSION < 10000
 #include "params.h"
+#endif
 #if BUILDING_GCC_VERSION <= 4009
 #include "pointer-set.h"
 	return gimple_build_assign(lhs, subcode, op1, op2 PASS_MEM_STAT);
 }
+#if BUILDING_GCC_VERSION < 10000
 template <>
 template <>
 inline bool is_a_helper<const ggoto *>::test(const_gimple gs)
 {
 	return gs->code == GIMPLE_RETURN;
 }
+#endif
 static inline gasm *as_a_gasm(gimple stmt)
 {

scripts/gcc-plugins/stackleak_plugin.c+2−3

 	gimple stmt;
 	gcall *stackleak_track_stack;
 	cgraph_node_ptr node;
-	int frequency;
 	basic_block bb;
 	/* Insert call to void stackleak_track_stack(void) */
 	bb = gimple_bb(stackleak_track_stack);
 	node = cgraph_get_create_node(track_function_decl);
 	gcc_assert(node);
-	frequency = compute_call_stmt_bb_frequency(current_function_decl, bb);
 	cgraph_create_edge(cgraph_get_node(current_function_decl), node,
-			stackleak_track_stack, bb->count, frequency);
+			stackleak_track_stack, bb->count,
+			compute_call_stmt_bb_frequency(current_function_decl, bb));
 }
 static bool is_alloca(gimple stmt)

scripts/gdb/linux/rbtree.py+2−2

@@ -12,7 +12,7 @@ rb_node_type = utils.CachedType("struct rb_node") · 11 unmodified lines
12		12
13	def rb_first(root):	13	def rb_first(root):
14	if root.type == rb_root_type.get_type():	14	if root.type == rb_root_type.get_type():
15	node = node.address.cast(rb_root_type.get_type().pointer())	15	node = root.address.cast(rb_root_type.get_type().pointer())
16	elif root.type != rb_root_type.get_type().pointer():	16	elif root.type != rb_root_type.get_type().pointer():
17	raise gdb.GdbError("Must be struct rb_root not {}".format(root.type))	17	raise gdb.GdbError("Must be struct rb_root not {}".format(root.type))
18		18
@@ -28,7 +28,7 @@ def rb_first(root): · 9 unmodified lines
28		28
29	def rb_last(root):	29	def rb_last(root):
30	if root.type == rb_root_type.get_type():	30	if root.type == rb_root_type.get_type():
31	node = node.address.cast(rb_root_type.get_type().pointer())	31	node = root.address.cast(rb_root_type.get_type().pointer())
32	elif root.type != rb_root_type.get_type().pointer():	32	elif root.type != rb_root_type.get_type().pointer():
33	raise gdb.GdbError("Must be struct rb_root not {}".format(root.type))	33	raise gdb.GdbError("Must be struct rb_root not {}".format(root.type))
34		34

scripts/kallsyms.c+1−1

@@ -34,7 +34,7 @@ struct sym_entry { · 33 unmodified lines
34	unsigned int len;	34	unsigned int len;
35	unsigned int start_pos;	35	unsigned int start_pos;
36	unsigned int percpu_absolute;	36	unsigned int percpu_absolute;
37	unsigned char sym[0];	37	unsigned char sym[];
38	};	38	};
39		39
40	struct addr_range {	40	struct addr_range {

security/selinux/hooks.c+45−25

@@ -5842,40 +5842,60 @@ static unsigned int selinux_ipv6_postroute(void *priv, · 5841 unmodified lines
5842		5842
5843	static int selinux_netlink_send(struct sock sk, struct sk_buff skb)	5843	static int selinux_netlink_send(struct sock sk, struct sk_buff skb)
5844	{	5844	{
5845	int err = 0;	5845	int rc = 0;
5846	u32 perm;	5846	unsigned int msg_len;
		5847	unsigned int data_len = skb->len;
		5848	unsigned char *data = skb->data;
5847	struct nlmsghdr *nlh;	5849	struct nlmsghdr *nlh;
5848	struct sk_security_struct *sksec = sk->sk_security;	5850	struct sk_security_struct *sksec = sk->sk_security;
		5851	u16 sclass = sksec->sclass;
		5852	u32 perm;
5849		5853
5850	if (skb->len < NLMSG_HDRLEN) {	5854	while (data_len >= nlmsg_total_size(0)) {
5851	err = -EINVAL;	5855	nlh = (struct nlmsghdr *)data;
5852	goto out;	5856
5853	}	5857	/* NOTE: the nlmsg_len field isn't reliably set by some netlink
5854	nlh = nlmsg_hdr(skb);	5858	* users which means we can't reject skb's with bogus
		5859	* length fields; our solution is to follow what
		5860	* netlink_rcv_skb() does and simply skip processing at
		5861	* messages with length fields that are clearly junk
		5862	*/
		5863	if (nlh->nlmsg_len < NLMSG_HDRLEN \|\| nlh->nlmsg_len > data_len)
		5864	return 0;
5855		5865
5856	err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm);	5866	rc = selinux_nlmsg_lookup(sclass, nlh->nlmsg_type, &perm);
5857	if (err) {	5867	if (rc == 0) {
5858	if (err == -EINVAL) {	5868	rc = sock_has_perm(sk, perm);
		5869	if (rc)
		5870	return rc;
		5871	} else if (rc == -EINVAL) {
		5872	/* -EINVAL is a missing msg/perm mapping */
5859	pr_warn_ratelimited("SELinux: unrecognized netlink"	5873	pr_warn_ratelimited("SELinux: unrecognized netlink"
5860	" message: protocol=%hu nlmsg_type=%hu sclass=%s"	5874	" message: protocol=%hu nlmsg_type=%hu sclass=%s"
5861	" pid=%d comm=%s\n",	5875	" pid=%d comm=%s\n",
5862	sk->sk_protocol, nlh->nlmsg_type,	5876	sk->sk_protocol, nlh->nlmsg_type,
5863	secclass_map[sksec->sclass - 1].name,	5877	secclass_map[sclass - 1].name,
5864	task_pid_nr(current), current->comm);	5878	task_pid_nr(current), current->comm);
5865	if (!enforcing_enabled(&selinux_state) \|\|	5879	if (enforcing_enabled(&selinux_state) &&
5866	security_get_allow_unknown(&selinux_state))	5880	!security_get_allow_unknown(&selinux_state))
5867	err = 0;	5881	return rc;
		5882	rc = 0;
		5883	} else if (rc == -ENOENT) {
		5884	/* -ENOENT is a missing socket/class mapping, ignore */
		5885	rc = 0;
		5886	} else {
		5887	return rc;
5868	}	5888	}
5869		5889
5870	/* Ignore */	5890	/* move to the next message after applying netlink padding */
5871	if (err == -ENOENT)	5891	msg_len = NLMSG_ALIGN(nlh->nlmsg_len);
5872	err = 0;	5892	if (msg_len >= data_len)
5873	goto out;	5893	return 0;
		5894	data_len -= msg_len;
		5895	data += msg_len;
5874	}	5896	}
5875		5897
5876	err = sock_has_perm(sk, perm);	5898	return rc;
5877	out:
5878	return err;
5879	}	5899	}
5880		5900
5881	static void ipc_init_security(struct ipc_security_struct *isec, u16 sclass)	5901	static void ipc_init_security(struct ipc_security_struct *isec, u16 sclass)

security/selinux/ss/conditional.c+1−1

@@ -429,7 +429,7 @@ int cond_read_list(struct policydb p, void fp) · 428 unmodified lines
429		429
430	p->cond_list = kcalloc(len, sizeof(*p->cond_list), GFP_KERNEL);	430	p->cond_list = kcalloc(len, sizeof(*p->cond_list), GFP_KERNEL);
431	if (!p->cond_list)	431	if (!p->cond_list)
432	return rc;	432	return -ENOMEM;
433		433
434	rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel);	434	rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel);
435	if (rc)	435	if (rc)

sound/core/oss/pcm_plugin.c+6−4

 	plugin = snd_pcm_plug_first(plug);
 	while (plugin && frames > 0) {
 		plugin_next = plugin->next;
+		if (check_size && plugin->buf_frames &&
+		    frames > plugin->buf_frames)
+			frames = plugin->buf_frames;
 		if (plugin->dst_frames) {
 			frames = plugin->dst_frames(plugin, frames);
 			if (frames < 0)
 				return frames;
 		}
-		if (check_size && frames > plugin->buf_frames)
-			frames = plugin->buf_frames;
 		plugin = plugin_next;
 	}
 	return frames;
 	plugin = snd_pcm_plug_last(plug);
 	while (plugin && frames > 0) {
-		if (check_size && frames > plugin->buf_frames)
-			frames = plugin->buf_frames;
 		plugin_prev = plugin->prev;
 		if (plugin->src_frames) {
 			frames = plugin->src_frames(plugin, frames);
 			if (frames < 0)
 				return frames;
 		}
+		if (check_size && plugin->buf_frames &&
+		    frames > plugin->buf_frames)
+			frames = plugin->buf_frames;
 		plugin = plugin_prev;
 	}
 	return frames;

sound/isa/opti9xx/miro.c+6−3

 	spin_unlock_irqrestore(&chip->lock, flags);
 }
+static inline void snd_miro_write_mask(struct snd_miro *chip,
+		unsigned char reg, unsigned char value, unsigned char mask)
+{
+	unsigned char oldval = snd_miro_read(chip, reg);
-#define snd_miro_write_mask(chip, reg, value, mask)	\
+	snd_miro_write(chip, reg, (oldval & ~mask) | (value & mask));
-	snd_miro_write(chip, reg,			\
+}
-		(snd_miro_read(chip, reg) & ~(mask)) | ((value) & (mask)))
 /*
  *  Proc Interface

sound/isa/opti9xx/opti92x-ad1848.c+6−3

 }
-#define snd_opti9xx_write_mask(chip, reg, value, mask)	\
+static inline void snd_opti9xx_write_mask(struct snd_opti9xx *chip,
-	snd_opti9xx_write(chip, reg,			\
+		unsigned char reg, unsigned char value, unsigned char mask)
-		(snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
+{
+	unsigned char oldval = snd_opti9xx_read(chip, reg);
+	snd_opti9xx_write(chip, reg, (oldval & ~mask) | (value & mask));
+}
 static int snd_opti9xx_configure(struct snd_opti9xx *chip,
 					   long port,

sound/pci/hda/hda_intel.c+5−4

  * some HD-audio PCI entries are exposed without any codecs, and such devices
  * should be ignored from the beginning.
  */
-static const struct snd_pci_quirk driver_blacklist[] = {
+static const struct pci_device_id driver_blacklist[] = {
-	SND_PCI_QUIRK(0x1462, 0xcb59, "MSI TRX40 Creator", 0),
+	{ PCI_DEVICE_SUB(0x1022, 0x1487, 0x1043, 0x874f) }, /* ASUS ROG Zenith II / Strix */
-	SND_PCI_QUIRK(0x1462, 0xcb60, "MSI TRX40", 0),
+	{ PCI_DEVICE_SUB(0x1022, 0x1487, 0x1462, 0xcb59) }, /* MSI TRX40 Creator */
+	{ PCI_DEVICE_SUB(0x1022, 0x1487, 0x1462, 0xcb60) }, /* MSI TRX40 */
 	{}
 };
 	bool schedule_probe;
 	int err;
-	if (snd_pci_quirk_lookup(pci, driver_blacklist)) {
+	if (pci_match_id(driver_blacklist, pci)) {
 		dev_info(&pci->dev, "Skipping the blacklisted device\n");
 		return -ENODEV;
 	}

sound/pci/hda/patch_hdmi.c+5−1

 	/* Add sanity check to pass klockwork check.
 	 * This should never happen.
 	 */
-	if (WARN_ON(spdif == NULL))
+	if (WARN_ON(spdif == NULL)) {
+		mutex_unlock(&codec->spdif_mutex);
 		return true;
+	}
 	non_pcm = !!(spdif->status & IEC958_AES0_NONAUDIO);
 	mutex_unlock(&codec->spdif_mutex);
 	return non_pcm;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
+		struct hdmi_eld *pin_eld = &per_pin->sink_eld;
+		pin_eld->eld_valid = false;
 		hdmi_present_sense(per_pin, 0);
 	}

sound/pci/hda/patch_realtek.c+1−0

@@ -7420,6 +7420,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { · 7419 unmodified lines
7420	SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),	7420	SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7421	SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),	7421	SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7422	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),	7422	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
		7423	SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7423	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),	7424	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
7424	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),	7425	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
7425	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),	7426	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),

sound/usb/line6/podhd.c+5−17

 enum {
 	LINE6_PODHD300,
 	LINE6_PODHD400,
-	LINE6_PODHD500_0,
+	LINE6_PODHD500,
-	LINE6_PODHD500_1,
 	LINE6_PODX3,
 	LINE6_PODX3LIVE,
 	LINE6_PODHD500X,
 	/* TODO: no need to alloc data interfaces when only audio is used */
 	{ LINE6_DEVICE(0x5057),    .driver_info = LINE6_PODHD300 },
 	{ LINE6_DEVICE(0x5058),    .driver_info = LINE6_PODHD400 },
-	{ LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 },
+	{ LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500 },
-	{ LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 },
 	{ LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 },
 	{ LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE },
 	{ LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X },
 		.ep_audio_r = 0x82,
 		.ep_audio_w = 0x01,
 	},
-	[LINE6_PODHD500_0] = {
+	[LINE6_PODHD500] = {
 		.id = "PODHD500",
 		.name = "POD HD500",
-		.capabilities	= LINE6_CAP_PCM
+		.capabilities	= LINE6_CAP_PCM | LINE6_CAP_CONTROL
 				| LINE6_CAP_HWMON,
 		.altsetting = 1,
-		.ep_ctrl_r = 0x81,
+		.ctrl_if = 1,
-		.ep_ctrl_w = 0x01,
-		.ep_audio_r = 0x86,
-		.ep_audio_w = 0x02,
-	},
-	[LINE6_PODHD500_1] = {
-		.id = "PODHD500",
-		.name = "POD HD500",
-		.capabilities	= LINE6_CAP_PCM
-				| LINE6_CAP_HWMON,
-		.altsetting = 0,
 		.ep_ctrl_r = 0x81,
 		.ep_ctrl_w = 0x01,
 		.ep_audio_r = 0x86,

sound/usb/quirks.c+1−1

@@ -1687,7 +1687,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, · 1686 unmodified lines
1687		1687
1688	case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */	1688	case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
1689	case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */	1689	case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
1690	case USB_ID(0x16b0, 0x06b2): /* NuPrime DAC-10 */	1690	case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */
1691	case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */	1691	case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
1692	case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */	1692	case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
1693	case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */	1693	case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */

tools/bootconfig/main.c+6−3

 	ret = delete_xbc(path);
 	if (ret < 0) {
 		pr_err("Failed to delete previous boot config: %d\n", ret);
+		free(data);
 		return ret;
 	}
 	fd = open(path, O_RDWR | O_APPEND);
 	if (fd < 0) {
 		pr_err("Failed to open %s: %d\n", path, fd);
+		free(data);
 		return fd;
 	}
 	/* TODO: Ensure the @path is initramfs/initrd image */
 	ret = write(fd, data, size + 8);
 	if (ret < 0) {
 		pr_err("Failed to apply a boot config: %d\n", ret);
-		return ret;
+		goto out;
 	}
 	/* Write a magic word of the bootconfig */
 	ret = write(fd, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN);
 	if (ret < 0) {
 		pr_err("Failed to apply a boot config magic: %d\n", ret);
-		return ret;
+		goto out;
 	}
+out:
 	close(fd);
 	free(data);
-	return 0;
+	return ret;
 }
 int usage(void)

tools/cgroup/iocost_monitor.py+6−1

         else:
             self.inflight_pct = 0
-        self.debt_ms = iocg.abs_vdebt.counter.value_() / VTIME_PER_USEC / 1000
+        # vdebt used to be an atomic64_t and is now u64, support both
+        try:
+            self.debt_ms = iocg.abs_vdebt.counter.value_() / VTIME_PER_USEC / 1000
+        except:
+            self.debt_ms = iocg.abs_vdebt.value_() / VTIME_PER_USEC / 1000
         self.use_delay = blkg.use_delay.counter.value_()
         self.delay_ms = blkg.delay_nsec.counter.value_() / 1_000_000

tools/objtool/check.c+14−3

 	return find_insn(file, func->cfunc->sec, func->cfunc->offset);
 }
+static struct instruction *prev_insn_same_sym(struct objtool_file *file,
+					       struct instruction *insn)
+{
+	struct instruction *prev = list_prev_entry(insn, list);
+	if (&prev->list != &file->insn_list && prev->func == insn->func)
+		return prev;
+	return NULL;
+}
 #define func_for_each_insn(file, func, insn)				\
 	for (insn = find_insn(file, func->sec, func->offset);		\
 	     insn;							\
 	 * it.
 	 */
 	for (;
-	     &insn->list != &file->insn_list && insn->func && insn->func->pfunc == func;
+	     insn && insn->func && insn->func->pfunc == func;
-	     insn = insn->first_jump_src ?: list_prev_entry(insn, list)) {
+	     insn = insn->first_jump_src ?: prev_insn_same_sym(file, insn)) {
 		if (insn != orig_insn && insn->type == INSN_JUMP_DYNAMIC)
 			break;
 	struct cfi_reg *cfa = &state->cfa;
 	struct stack_op *op = &insn->stack_op;
-	if (cfa->base != CFI_SP)
+	if (cfa->base != CFI_SP && cfa->base != CFI_SP_INDIRECT)
 		return 0;
 	/* push */

tools/objtool/elf.h+4−3

 #define OFFSET_STRIDE		(1UL << OFFSET_STRIDE_BITS)
 #define OFFSET_STRIDE_MASK	(~(OFFSET_STRIDE - 1))
-#define for_offset_range(_offset, _start, _end)		\
+#define for_offset_range(_offset, _start, _end)			\
-	for (_offset = ((_start) & OFFSET_STRIDE_MASK);	\
+	for (_offset = ((_start) & OFFSET_STRIDE_MASK);		\
-	     _offset <= ((_end) & OFFSET_STRIDE_MASK);	\
+	     _offset >= ((_start) & OFFSET_STRIDE_MASK) &&	\
+	     _offset <= ((_end) & OFFSET_STRIDE_MASK);		\
 	     _offset += OFFSET_STRIDE)
 static inline u32 sec_offset_hash(struct section *sec, unsigned long offset)

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c+146−0

@@ -3,6 +3,7 @@ · 2 unmodified lines
3	#define _GNU_SOURCE	3	#define _GNU_SOURCE
4	#include <poll.h>	4	#include <poll.h>
5	#include <unistd.h>	5	#include <unistd.h>
		6	#include <assert.h>
6	#include <signal.h>	7	#include <signal.h>
7	#include <pthread.h>	8	#include <pthread.h>
8	#include <sys/epoll.h>	9	#include <sys/epoll.h>
@@ -3136,4 +3137,149 @@ TEST(epoll59) · 3127 unmodified lines
3136	close(ctx.sfd[0]);	3137	close(ctx.sfd[0]);
3137	}	3138	}
3138		3139
		3140	enum {
		3141	EPOLL60_EVENTS_NR = 10,
		3142	};
		3143
		3144	struct epoll60_ctx {
		3145	volatile int stopped;
		3146	int ready;
		3147	int waiters;
		3148	int epfd;
		3149	int evfd[EPOLL60_EVENTS_NR];
		3150	};
		3151
		3152	static void epoll60_wait_thread(void ctx_)
		3153	{
		3154	struct epoll60_ctx *ctx = ctx_;
		3155	struct epoll_event e;
		3156	sigset_t sigmask;
		3157	uint64_t v;
		3158	int ret;
		3159
		3160	/* Block SIGUSR1 */
		3161	sigemptyset(&sigmask);
		3162	sigaddset(&sigmask, SIGUSR1);
		3163	sigprocmask(SIG_SETMASK, &sigmask, NULL);
		3164
		3165	/* Prepare empty mask for epoll_pwait() */
		3166	sigemptyset(&sigmask);
		3167
		3168	while (!ctx->stopped) {
		3169	/* Mark we are ready */
		3170	__atomic_fetch_add(&ctx->ready, 1, __ATOMIC_ACQUIRE);
		3171
		3172	/* Start when all are ready */
		3173	while (__atomic_load_n(&ctx->ready, __ATOMIC_ACQUIRE) &&
		3174	!ctx->stopped);
		3175
		3176	/* Account this waiter */
		3177	__atomic_fetch_add(&ctx->waiters, 1, __ATOMIC_ACQUIRE);
		3178
		3179	ret = epoll_pwait(ctx->epfd, &e, 1, 2000, &sigmask);
		3180	if (ret != 1) {
		3181	/* We expect only signal delivery on stop */
		3182	assert(ret < 0 && errno == EINTR && "Lost wakeup!\n");
		3183	assert(ctx->stopped);
		3184	break;
		3185	}
		3186
		3187	ret = read(e.data.fd, &v, sizeof(v));
		3188	/* Since we are on ET mode, thus each thread gets its own fd. */
		3189	assert(ret == sizeof(v));
		3190
		3191	__atomic_fetch_sub(&ctx->waiters, 1, __ATOMIC_RELEASE);
		3192	}
		3193
		3194	return NULL;
		3195	}
		3196
		3197	static inline unsigned long long msecs(void)
		3198	{
		3199	struct timespec ts;
		3200	unsigned long long msecs;
		3201
		3202	clock_gettime(CLOCK_REALTIME, &ts);
		3203	msecs = ts.tv_sec * 1000ull;
		3204	msecs += ts.tv_nsec / 1000000ull;
		3205
		3206	return msecs;
		3207	}
		3208
		3209	static inline int count_waiters(struct epoll60_ctx *ctx)
		3210	{
		3211	return __atomic_load_n(&ctx->waiters, __ATOMIC_ACQUIRE);
		3212	}
		3213
		3214	TEST(epoll60)
		3215	{
		3216	struct epoll60_ctx ctx = { 0 };
		3217	pthread_t waiters[ARRAY_SIZE(ctx.evfd)];
		3218	struct epoll_event e;
		3219	int i, n, ret;
		3220
		3221	signal(SIGUSR1, signal_handler);
		3222
		3223	ctx.epfd = epoll_create1(0);
		3224	ASSERT_GE(ctx.epfd, 0);
		3225
		3226	/* Create event fds */
		3227	for (i = 0; i < ARRAY_SIZE(ctx.evfd); i++) {
		3228	ctx.evfd[i] = eventfd(0, EFD_NONBLOCK);
		3229	ASSERT_GE(ctx.evfd[i], 0);
		3230
		3231	e.events = EPOLLIN \| EPOLLET;
		3232	e.data.fd = ctx.evfd[i];
		3233	ASSERT_EQ(epoll_ctl(ctx.epfd, EPOLL_CTL_ADD, ctx.evfd[i], &e), 0);
		3234	}
		3235
		3236	/* Create waiter threads */
		3237	for (i = 0; i < ARRAY_SIZE(waiters); i++)
		3238	ASSERT_EQ(pthread_create(&waiters[i], NULL,
		3239	epoll60_wait_thread, &ctx), 0);
		3240
		3241	for (i = 0; i < 300; i++) {
		3242	uint64_t v = 1, ms;
		3243
		3244	/* Wait for all to be ready */
		3245	while (__atomic_load_n(&ctx.ready, __ATOMIC_ACQUIRE) !=
		3246	ARRAY_SIZE(ctx.evfd))
		3247	;
		3248
		3249	/* Steady, go */
		3250	__atomic_fetch_sub(&ctx.ready, ARRAY_SIZE(ctx.evfd),
		3251	__ATOMIC_ACQUIRE);
		3252
		3253	/* Wait all have gone to kernel */
		3254	while (count_waiters(&ctx) != ARRAY_SIZE(ctx.evfd))
		3255	;
		3256
		3257	/* 1ms should be enough to schedule away */
		3258	usleep(1000);
		3259
		3260	/* Quickly signal all handles at once */
		3261	for (n = 0; n < ARRAY_SIZE(ctx.evfd); n++) {
		3262	ret = write(ctx.evfd[n], &v, sizeof(v));
		3263	ASSERT_EQ(ret, sizeof(v));
		3264	}
		3265
		3266	/* Busy loop for 1s and wait for all waiters to wake up */
		3267	ms = msecs();
		3268	while (count_waiters(&ctx) && msecs() < ms + 1000)
		3269	;
		3270
		3271	ASSERT_EQ(count_waiters(&ctx), 0);
		3272	}
		3273	ctx.stopped = 1;
		3274	/* Stop waiters */
		3275	for (i = 0; i < ARRAY_SIZE(waiters); i++)
		3276	ret = pthread_kill(waiters[i], SIGUSR1);
		3277	for (i = 0; i < ARRAY_SIZE(waiters); i++)
		3278	pthread_join(waiters[i], NULL);
		3279
		3280	for (i = 0; i < ARRAY_SIZE(waiters); i++)
		3281	close(ctx.evfd[i]);
		3282	close(ctx.epfd);
		3283	}
		3284
3139	TEST_HARNESS_MAIN	3285	TEST_HARNESS_MAIN

tools/testing/selftests/ftrace/ftracetest+30−2

 echo "		-vv        Alias of -v -v (Show all results in stdout)"
 echo "		-vvv       Alias of -v -v -v (Show all commands immediately)"
 echo "		--fail-unsupported Treat UNSUPPORTED as a failure"
+echo "		--fail-unresolved Treat UNRESOLVED as a failure"
 echo "		-d|--debug Debug mode (trace all shell commands)"
 echo "		-l|--logdir <dir> Save logs on the <dir>"
 echo "		            If <dir> is -, all logs output in console only"
 # kselftest skip code is 4
 err_skip=4
+# cgroup RT scheduling prevents chrt commands from succeeding, which
+# induces failures in test wakeup tests.  Disable for the duration of
+# the tests.
+readonly sched_rt_runtime=/proc/sys/kernel/sched_rt_runtime_us
+sched_rt_runtime_orig=$(cat $sched_rt_runtime)
+setup() {
+  echo -1 > $sched_rt_runtime
+}
+cleanup() {
+  echo $sched_rt_runtime_orig > $sched_rt_runtime
+}
 errexit() { # message
   echo "Error: $1" 1>&2
+  cleanup
   exit $err_ret
 }
   errexit "this must be run by root user"
 fi
+setup
 # Utilities
 absdir() { # file_path
   (cd `dirname $1`; pwd)
       UNSUPPORTED_RESULT=1
       shift 1
     ;;
+    --fail-unresolved)
+      UNRESOLVED_RESULT=1
+      shift 1
+    ;;
     --logdir|-l)
       LOG_DIR=$2
       shift 2
 DEBUG=0
 VERBOSE=0
 UNSUPPORTED_RESULT=0
+UNRESOLVED_RESULT=0
 STOP_FAILURE=0
 # Parse command-line options
 parse_opts $*
 INSTANCE=
 CASENO=0
 testcase() { # testfile
   CASENO=$((CASENO+1))
   desc=`grep "^#[ \t]*description:" $1 | cut -f2 -d:`
     $UNRESOLVED)
       prlog "	[${color_blue}UNRESOLVED${color_reset}]"
       UNRESOLVED_CASES="$UNRESOLVED_CASES $CASENO"
-      return 1 # this is a kind of bug.. something happened.
+      return $UNRESOLVED_RESULT # depends on use case
     ;;
     $UNTESTED)
       prlog "	[${color_blue}UNTESTED${color_reset}]"
       return $UNSUPPORTED_RESULT # depends on use case
     ;;
     $XFAIL)
-      prlog "	[${color_red}XFAIL${color_reset}]"
+      prlog "	[${color_green}XFAIL${color_reset}]"
       XFAILED_CASES="$XFAILED_CASES $CASENO"
       return 0
     ;;
 prlog "# of xfailed: " `echo $XFAILED_CASES | wc -w`
 prlog "# of undefined(test bug): " `echo $UNDEFINED_CASES | wc -w`
+cleanup
 # if no error, return 0
 exit $TOTAL_RESULT

tools/testing/selftests/ftrace/test.d/ftrace/fgraph-filter-stack.tc+1−4

     exit_unsupported
 fi
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 do_reset() {
     if [ -e /proc/sys/kernel/stack_tracer_enabled ]; then

tools/testing/selftests/ftrace/test.d/ftrace/fgraph-filter.tc+2−0

@@ -9,6 +9,8 @@ if ! grep -q function_graph available_tracers; then · 8 unmodified lines
9	exit_unsupported	9	exit_unsupported
10	fi	10	fi
11		11
		12	check_filter_file set_ftrace_filter
		13
12	fail() { # msg	14	fail() { # msg
13	echo $1	15	echo $1
14	exit_fail	16	exit_fail

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-glob.tc+2−0

@@ -9,6 +9,8 @@ if ! grep -q function available_tracers; then · 8 unmodified lines
9	exit_unsupported	9	exit_unsupported
10	fi	10	fi
11		11
		12	check_filter_file set_ftrace_filter
		13
12	disable_tracing	14	disable_tracing
13	clear_trace	15	clear_trace
14		16

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-notrace-pid.tc+1−4

@@ -15,10 +15,7 @@ if [ ! -f set_ftrace_notrace_pid ]; then · 14 unmodified lines
15	exit_unsupported	15	exit_unsupported
16	fi	16	fi
17		17
18	if [ ! -f set_ftrace_filter ]; then	18	check_filter_file set_ftrace_filter
19	echo "set_ftrace_filter not found? Is function tracer not set?"
20	exit_unsupported
21	fi
22		19
23	do_function_fork=1	20	do_function_fork=1
24		21

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-pid.tc+1−4

@@ -16,10 +16,7 @@ if [ ! -f set_ftrace_pid ]; then · 15 unmodified lines
16	exit_unsupported	16	exit_unsupported
17	fi	17	fi
18		18
19	if [ ! -f set_ftrace_filter ]; then	19	check_filter_file set_ftrace_filter
20	echo "set_ftrace_filter not found? Is function tracer not set?"
21	exit_unsupported
22	fi
23		20
24	do_function_fork=1	21	do_function_fork=1
25		22

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-stacktrace.tc+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	# description: ftrace - stacktrace filter command	3	# description: ftrace - stacktrace filter command
4	# flags: instance	4	# flags: instance
5		5
6	[ ! -f set_ftrace_filter ] && exit_unsupported	6	check_filter_file set_ftrace_filter
7		7
8	echo _do_fork:stacktrace >> set_ftrace_filter	8	echo _do_fork:stacktrace >> set_ftrace_filter
9		9

tools/testing/selftests/ftrace/test.d/ftrace/func_event_triggers.tc+1−4

 #
 # The triggers are set within the set_ftrace_filter file
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 do_reset() {
     reset_ftrace_filter

tools/testing/selftests/ftrace/test.d/ftrace/func_mod_trace.tc+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3	# description: ftrace - function trace on module	3	# description: ftrace - function trace on module
4		4
5	[ ! -f set_ftrace_filter ] && exit_unsupported	5	check_filter_file set_ftrace_filter
6		6
7	: "mod: allows to filter a non exist function"	7	: "mod: allows to filter a non exist function"
8	echo 'non_exist_func:mod:non_exist_module' > set_ftrace_filter	8	echo 'non_exist_func:mod:non_exist_module' > set_ftrace_filter

tools/testing/selftests/ftrace/test.d/ftrace/func_profiler.tc+1−4

     exit_unsupported;
 fi
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 if [ ! -f function_profile_enabled ]; then
     echo "function_profile_enabled not found, function profiling enabled?"

tools/testing/selftests/ftrace/test.d/ftrace/func_set_ftrace_file.tc+1−4

 #
 # The triggers are set within the set_ftrace_filter file
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 fail() { # mesg
     echo $1

tools/testing/selftests/ftrace/test.d/ftrace/func_stack_tracer.tc+2−0

@@ -8,6 +8,8 @@ if [ ! -f stack_trace ]; then · 7 unmodified lines
8	exit_unsupported	8	exit_unsupported
9	fi	9	fi
10		10
		11	check_filter_file stack_trace_filter
		12
11	echo > stack_trace_filter	13	echo > stack_trace_filter
12	echo 0 > stack_max_size	14	echo 0 > stack_max_size
13	echo 1 > /proc/sys/kernel/stack_tracer_enabled	15	echo 1 > /proc/sys/kernel/stack_tracer_enabled

tools/testing/selftests/ftrace/test.d/ftrace/func_traceonoff_triggers.tc+1−4

 #
 # The triggers are set within the set_ftrace_filter file
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 fail() { # mesg
     echo $1

tools/testing/selftests/ftrace/test.d/functions+6−0

@@ -1,3 +1,9 @@
		1	check_filter_file() { # check filter file introduced by dynamic ftrace
		2	if [ ! -f "$1" ]; then
		3	echo "$1 not found? Is dynamic ftrace not set?"
		4	exit_unsupported
		5	fi
		6	}
1		7
2	clear_trace() { # reset trace output	8	clear_trace() { # reset trace output
3	echo > trace	9	echo > trace

tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_type.tc+1−1

@@ -38,7 +38,7 @@ for width in 64 32 16 8; do · 37 unmodified lines
38	echo 0 > events/kprobes/testprobe/enable	38	echo 0 > events/kprobes/testprobe/enable
39		39
40	: "Confirm the arguments is recorded in given types correctly"	40	: "Confirm the arguments is recorded in given types correctly"
41	ARGS=`grep "testprobe" trace \| sed -e 's/.* arg1=$.$ arg2=$.$ arg3=$.$ arg4=$.$/\1 \2 \3 \4/'`	41	ARGS=`grep "testprobe" trace \| head -n 1 \| sed -e 's/.* arg1=$.$ arg2=$.$ arg3=$.$ arg4=$.$/\1 \2 \3 \4/'`
42	check_types $ARGS $width	42	check_types $ARGS $width
43		43
44	: "Clear event for next loop"	44	: "Clear event for next loop"

tools/testing/selftests/ftrace/test.d/kprobe/kprobe_ftrace.tc+2−0

@@ -5,6 +5,8 @@ · 4 unmodified lines
5	[ -f kprobe_events ] \|\| exit_unsupported # this is configurable	5	[ -f kprobe_events ] \|\| exit_unsupported # this is configurable
6	grep "function" available_tracers \|\| exit_unsupported # this is configurable	6	grep "function" available_tracers \|\| exit_unsupported # this is configurable
7		7
		8	check_filter_file set_ftrace_filter
		9
8	# prepare	10	# prepare
9	echo nop > current_tracer	11	echo nop > current_tracer
10	echo _do_fork > set_ftrace_filter	12	echo _do_fork > set_ftrace_filter

tools/testing/selftests/gpio/Makefile+6−6

@@ -1,13 +1,13 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2		2
3	MOUNT_CFLAGS := $(shell pkg-config --cflags mount 2>/dev/null)	3	VAR_CFLAGS := $(shell pkg-config --cflags mount 2>/dev/null)
4	MOUNT_LDLIBS := $(shell pkg-config --libs mount 2>/dev/null)	4	VAR_LDLIBS := $(shell pkg-config --libs mount 2>/dev/null)
5	ifeq ($(MOUNT_LDLIBS),)	5	ifeq ($(VAR_LDLIBS),)
6	MOUNT_LDLIBS := -lmount -I/usr/include/libmount	6	VAR_LDLIBS := -lmount -I/usr/include/libmount
7	endif	7	endif
8		8
9	CFLAGS += -O2 -g -std=gnu99 -Wall -I../../../../usr/include/ $(MOUNT_CFLAGS)	9	CFLAGS += -O2 -g -std=gnu99 -Wall -I../../../../usr/include/ $(VAR_CFLAGS)
10	LDLIBS += $(MOUNT_LDLIBS)	10	LDLIBS += $(VAR_LDLIBS)
11		11
12	TEST_PROGS := gpio-mockup.sh	12	TEST_PROGS := gpio-mockup.sh
13	TEST_FILES := gpio-mockup-sysfs.sh	13	TEST_FILES := gpio-mockup-sysfs.sh

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

@@ -1,6 +1,6 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	CFLAGS := $(CFLAGS) -Wall -D_GNU_SOURCE	2	CFLAGS := $(CFLAGS) -Wall -D_GNU_SOURCE
3	LDLIBS := $(LDLIBS) -lm	3	LDLIBS += -lm
4		4
5	uname_M := $(shell uname -m 2>/dev/null \|\| echo not)	5	uname_M := $(shell uname -m 2>/dev/null \|\| echo not)
6	ARCH ?= $(shell echo $(uname_M) \| sed -e s/i.86/x86/ -e s/x86_64/x86/)	6	ARCH ?= $(shell echo $(uname_M) \| sed -e s/i.86/x86/ -e s/x86_64/x86/)

tools/testing/selftests/kselftest_deps.sh+272−0

@@ -0,0 +1,272 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3	# kselftest_deps.sh
	4	#
	5	# Checks for kselftest build dependencies on the build system.
	6	# Copyright (c) 2020 Shuah Khan <skhan@linuxfoundation.org>
	7	#
	8	#
	9
	10	usage()
	11	{
	12
	13	echo -e "Usage: $0 -[p] <compiler> [test_name]\n"
	14	echo -e "\tkselftest_deps.sh [-p] gcc"
	15	echo -e "\tkselftest_deps.sh [-p] gcc vm"
	16	echo -e "\tkselftest_deps.sh [-p] aarch64-linux-gnu-gcc"
	17	echo -e "\tkselftest_deps.sh [-p] aarch64-linux-gnu-gcc vm\n"
	18	echo "- Should be run in selftests directory in the kernel repo."
	19	echo "- Checks if Kselftests can be built/cross-built on a system."
	20	echo "- Parses all test/sub-test Makefile to find library dependencies."
	21	echo "- Runs compile test on a trivial C file with LDLIBS specified"
	22	echo " in the test Makefiles to identify missing library dependencies."
	23	echo "- Prints suggested target list for a system filtering out tests"
	24	echo " failed the build dependency check from the TARGETS in Selftests"
	25	echo " main Makefile when optional -p is specified."
	26	echo "- Prints pass/fail dependency check for each tests/sub-test."
	27	echo "- Prints pass/fail targets and libraries."
	28	echo "- Default: runs dependency checks on all tests."
	29	echo "- Optional test name can be specified to check dependencies for it."
	30	exit 1
	31
	32	}
	33
	34	# Start main()
	35	main()
	36	{
	37
	38	base_dir=`pwd`
	39	# Make sure we're in the selftests top-level directory.
	40	if [ $(basename "$base_dir") != "selftests" ]; then
	41	echo -e "\tPlease run $0 in"
	42	echo -e "\ttools/testing/selftests directory ..."
	43	exit 1
	44	fi
	45
	46	print_targets=0
	47
	48	while getopts "p" arg; do
	49	case $arg in
	50	p)
	51	print_targets=1
	52	shift;;
	53	esac
	54	done
	55
	56	if [ $# -eq 0 ]
	57	then
	58	usage
	59	fi
	60
	61	# Compiler
	62	CC=$1
	63
	64	tmp_file=$(mktemp).c
	65	trap "rm -f $tmp_file.o $tmp_file $tmp_file.bin" EXIT
	66	#echo $tmp_file
	67
	68	pass=$(mktemp).out
	69	trap "rm -f $pass" EXIT
	70	#echo $pass
	71
	72	fail=$(mktemp).out
	73	trap "rm -f $fail" EXIT
	74	#echo $fail
	75
	76	# Generate tmp source fire for compile test
	77	cat << "EOF" > $tmp_file
	78	int main()
	79	{
	80	}
	81	EOF
	82
	83	# Save results
	84	total_cnt=0
	85	fail_trgts=()
	86	fail_libs=()
	87	fail_cnt=0
	88	pass_trgts=()
	89	pass_libs=()
	90	pass_cnt=0
	91
	92	# Get all TARGETS from selftests Makefile
	93	targets=$(egrep "^TARGETS +\|^TARGETS =" Makefile \| cut -d "=" -f2)
	94
	95	# Single test case
	96	if [ $# -eq 2 ]
	97	then
	98	test=$2/Makefile
	99
	100	l1_test $test
	101	l2_test $test
	102	l3_test $test
	103
	104	print_results $1 $2
	105	exit $?
	106	fi
	107
	108	# Level 1: LDLIBS set static.
	109	#
	110	# Find all LDLIBS set statically for all executables built by a Makefile
	111	# and filter out VAR_LDLIBS to discard the following:
	112	# gpio/Makefile:LDLIBS += $(VAR_LDLIBS)
	113	# Append space at the end of the list to append more tests.
	114
	115	l1_tests=$(grep -r --include=Makefile "^LDLIBS" \| \
	116	grep -v "VAR_LDLIBS" \| awk -F: '{print $1}')
	117
	118	# Level 2: LDLIBS set dynamically.
	119	#
	120	# Level 2
	121	# Some tests have multiple valid LDLIBS lines for individual sub-tests
	122	# that need dependency checks. Find them and append them to the tests
	123	# e.g: vm/Makefile:$(OUTPUT)/userfaultfd: LDLIBS += -lpthread
	124	# Filter out VAR_LDLIBS to discard the following:
	125	# memfd/Makefile:$(OUTPUT)/fuse_mnt: LDLIBS += $(VAR_LDLIBS)
	126	# Append space at the end of the list to append more tests.
	127
	128	l2_tests=$(grep -r --include=Makefile ": LDLIBS" \| \
	129	grep -v "VAR_LDLIBS" \| awk -F: '{print $1}')
	130
	131	# Level 3
	132	# gpio, memfd and others use pkg-config to find mount and fuse libs
	133	# respectively and save it in VAR_LDLIBS. If pkg-config doesn't find
	134	# any, VAR_LDLIBS set to default.
	135	# Use the default value and filter out pkg-config for dependency check.
	136	# e.g:
	137	# gpio/Makefile
	138	# VAR_LDLIBS := $(shell pkg-config --libs mount) 2>/dev/null)
	139	# memfd/Makefile
	140	# VAR_LDLIBS := $(shell pkg-config fuse --libs 2>/dev/null)
	141
	142	l3_tests=$(grep -r --include=Makefile "^VAR_LDLIBS" \| \
	143	grep -v "pkg-config" \| awk -F: '{print $1}')
	144
	145	#echo $l1_tests
	146	#echo $l2_1_tests
	147	#echo $l3_tests
	148
	149	all_tests
	150	print_results $1 $2
	151
	152	exit $?
	153	}
	154	# end main()
	155
	156	all_tests()
	157	{
	158	for test in $l1_tests; do
	159	l1_test $test
	160	done
	161
	162	for test in $l2_tests; do
	163	l2_test $test
	164	done
	165
	166	for test in $l3_tests; do
	167	l3_test $test
	168	done
	169	}
	170
	171	# Use same parsing used for l1_tests and pick libraries this time.
	172	l1_test()
	173	{
	174	test_libs=$(grep --include=Makefile "^LDLIBS" $test \| \
	175	grep -v "VAR_LDLIBS" \| \
	176	sed -e 's/\:/ /' \| \
	177	sed -e 's/+/ /' \| cut -d "=" -f 2)
	178
	179	check_libs $test $test_libs
	180	}
	181
	182	# Use same parsing used for l2__tests and pick libraries this time.
	183	l2_test()
	184	{
	185	test_libs=$(grep --include=Makefile ": LDLIBS" $test \| \
	186	grep -v "VAR_LDLIBS" \| \
	187	sed -e 's/\:/ /' \| sed -e 's/+/ /' \| \
	188	cut -d "=" -f 2)
	189
	190	check_libs $test $test_libs
	191	}
	192
	193	l3_test()
	194	{
	195	test_libs=$(grep --include=Makefile "^VAR_LDLIBS" $test \| \
	196	grep -v "pkg-config" \| sed -e 's/\:/ /' \|
	197	sed -e 's/+/ /' \| cut -d "=" -f 2)
	198
	199	check_libs $test $test_libs
	200	}
	201
	202	check_libs()
	203	{
	204
	205	if [[ ! -z "${test_libs// }" ]]
	206	then
	207
	208	#echo $test_libs
	209
	210	for lib in $test_libs; do
	211
	212	let total_cnt+=1
	213	$CC -o $tmp_file.bin $lib $tmp_file > /dev/null 2>&1
	214	if [ $? -ne 0 ]; then
	215	echo "FAIL: $test dependency check: $lib" >> $fail
	216	let fail_cnt+=1
	217	fail_libs+="$lib "
	218	fail_target=$(echo "$test" \| cut -d "/" -f1)
	219	fail_trgts+="$fail_target "
	220	targets=$(echo "$targets" \| grep -v "$fail_target")
	221	else
	222	echo "PASS: $test dependency check passed $lib" >> $pass
	223	let pass_cnt+=1
	224	pass_libs+="$lib "
	225	pass_trgts+="$(echo "$test" \| cut -d "/" -f1) "
	226	fi
	227
	228	done
	229	fi
	230	}
	231
	232	print_results()
	233	{
	234	echo -e "========================================================";
	235	echo -e "Kselftest Dependency Check for [$0 $1 $2] results..."
	236
	237	if [ $print_targets -ne 0 ]
	238	then
	239	echo -e "Suggested Selftest Targets for your configuration:"
	240	echo -e "$targets";
	241	fi
	242
	243	echo -e "========================================================";
	244	echo -e "Checked tests defining LDLIBS dependencies"
	245	echo -e "--------------------------------------------------------";
	246	echo -e "Total tests with Dependencies:"
	247	echo -e "$total_cnt Pass: $pass_cnt Fail: $fail_cnt";
	248
	249	if [ $pass_cnt -ne 0 ]; then
	250	echo -e "--------------------------------------------------------";
	251	cat $pass
	252	echo -e "--------------------------------------------------------";
	253	echo -e "Targets passed build dependency check on system:"
	254	echo -e "$(echo "$pass_trgts" \| xargs -n1 \| sort -u \| xargs)"
	255	fi
	256
	257	if [ $fail_cnt -ne 0 ]; then
	258	echo -e "--------------------------------------------------------";
	259	cat $fail
	260	echo -e "--------------------------------------------------------";
	261	echo -e "Targets failed build dependency check on system:"
	262	echo -e "$(echo "$fail_trgts" \| xargs -n1 \| sort -u \| xargs)"
	263	echo -e "--------------------------------------------------------";
	264	echo -e "Missing libraries system"
	265	echo -e "$(echo "$fail_libs" \| xargs -n1 \| sort -u \| xargs)"
	266	fi
	267
	268	echo -e "--------------------------------------------------------";
	269	echo -e "========================================================";
	270	}
	271
	272	main "$@"

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

@@ -5,8 +5,34 @@ all: · 4 unmodified lines
5		5
6	top_srcdir = ../../../..	6	top_srcdir = ../../../..
7	KSFT_KHDR_INSTALL := 1	7	KSFT_KHDR_INSTALL := 1
		8
		9	# For cross-builds to work, UNAME_M has to map to ARCH and arch specific
		10	# directories and targets in this Makefile. "uname -m" doesn't map to
		11	# arch specific sub-directory names.
		12	#
		13	# UNAME_M variable to used to run the compiles pointing to the right arch
		14	# directories and build the right targets for these supported architectures.
		15	#
		16	# TEST_GEN_PROGS and LIBKVM are set using UNAME_M variable.
		17	# LINUX_TOOL_ARCH_INCLUDE is set using ARCH variable.
		18	#
		19	# x86_64 targets are named to include x86_64 as a suffix and directories
		20	# for includes are in x86_64 sub-directory. s390x and aarch64 follow the
		21	# same convention. "uname -m" doesn't result in the correct mapping for
		22	# s390x and aarch64.
		23	#
		24	# No change necessary for x86_64
8	UNAME_M := $(shell uname -m)	25	UNAME_M := $(shell uname -m)
9		26
		27	# Set UNAME_M for arm64 compile/install to work
		28	ifeq ($(ARCH),arm64)
		29	UNAME_M := aarch64
		30	endif
		31	# Set UNAME_M s390x compile/install to work
		32	ifeq ($(ARCH),s390)
		33	UNAME_M := s390x
		34	endif
		35
10	LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/sparsebit.c lib/test_util.c	36	LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/sparsebit.c lib/test_util.c
11	LIBKVM_x86_64 = lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c	37	LIBKVM_x86_64 = lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c
12	LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c	38	LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c
@@ -53,7 +79,7 @@ LIBKVM += $(LIBKVM_$(UNAME_M)) · 40 unmodified lines
53	INSTALL_HDR_PATH = $(top_srcdir)/usr	79	INSTALL_HDR_PATH = $(top_srcdir)/usr
54	LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/	80	LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/
55	LINUX_TOOL_INCLUDE = $(top_srcdir)/tools/include	81	LINUX_TOOL_INCLUDE = $(top_srcdir)/tools/include
56	LINUX_TOOL_ARCH_INCLUDE = $(top_srcdir)/tools/arch/x86/include	82	LINUX_TOOL_ARCH_INCLUDE = $(top_srcdir)/tools/arch/$(ARCH)/include
57	CFLAGS += -Wall -Wstrict-prototypes -Wuninitialized -O2 -g -std=gnu99 \	83	CFLAGS += -Wall -Wstrict-prototypes -Wuninitialized -O2 -g -std=gnu99 \
58	-fno-stack-protector -fno-PIE -I$(LINUX_TOOL_INCLUDE) \	84	-fno-stack-protector -fno-PIE -I$(LINUX_TOOL_INCLUDE) \
59	-I$(LINUX_TOOL_ARCH_INCLUDE) -I$(LINUX_HDR_PATH) -Iinclude \	85	-I$(LINUX_TOOL_ARCH_INCLUDE) -I$(LINUX_HDR_PATH) -Iinclude \
@@ -84,6 +110,7 @@ $(LIBKVM_OBJ): $(OUTPUT)/%.o: %.c · 24 unmodified lines
84	$(OUTPUT)/libkvm.a: $(LIBKVM_OBJ)	110	$(OUTPUT)/libkvm.a: $(LIBKVM_OBJ)
85	$(AR) crs $@ $^	111	$(AR) crs $@ $^
86		112
		113	x := $(shell mkdir -p $(sort $(dir $(TEST_GEN_PROGS))))
87	all: $(STATIC_LIBS)	114	all: $(STATIC_LIBS)
88	$(TEST_GEN_PROGS): $(STATIC_LIBS)	115	$(TEST_GEN_PROGS): $(STATIC_LIBS)
89		116

tools/testing/selftests/kvm/include/evmcs.h+2−2

@@ -219,8 +219,8 @@ struct hv_enlightened_vmcs { · 218 unmodified lines
219	#define HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_MASK \	219	#define HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_MASK \
220	(~((1ull << HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_SHIFT) - 1))	220	(~((1ull << HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_SHIFT) - 1))
221		221
222	struct hv_enlightened_vmcs *current_evmcs;	222	extern struct hv_enlightened_vmcs *current_evmcs;
223	struct hv_vp_assist_page *current_vp_assist;	223	extern struct hv_vp_assist_page *current_vp_assist;
224		224
225	int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id);	225	int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id);
226		226

tools/testing/selftests/kvm/lib/x86_64/vmx.c+3−0

@@ -17,6 +17,9 @@ · 16 unmodified lines
17		17
18	bool enable_evmcs;	18	bool enable_evmcs;
19		19
		20	struct hv_enlightened_vmcs *current_evmcs;
		21	struct hv_vp_assist_page *current_vp_assist;
		22
20	struct eptPageTableEntry {	23	struct eptPageTableEntry {
21	uint64_t readable:1;	24	uint64_t readable:1;
22	uint64_t writable:1;	25	uint64_t writable:1;

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

 TEST_PROGS := run_fuse_test.sh run_hugetlbfs_test.sh
 TEST_GEN_FILES := fuse_test fuse_mnt
-fuse_mnt.o: CFLAGS += $(shell pkg-config fuse --cflags)
+VAR_CFLAGS := $(shell pkg-config fuse --cflags 2>/dev/null)
+ifeq ($(VAR_CFLAGS),)
+VAR_CFLAGS := -D_FILE_OFFSET_BITS=64 -I/usr/include/fuse
+endif
+VAR_LDLIBS := $(shell pkg-config fuse --libs 2>/dev/null)
+ifeq ($(VAR_LDLIBS),)
+VAR_LDLIBS := -lfuse -pthread
+endif
+fuse_mnt.o: CFLAGS += $(VAR_CFLAGS)
 include ../lib.mk
-$(OUTPUT)/fuse_mnt: LDLIBS += $(shell pkg-config fuse --libs)
+$(OUTPUT)/fuse_mnt: LDLIBS += $(VAR_LDLIBS)
 $(OUTPUT)/memfd_test: memfd_test.c common.c
 $(OUTPUT)/fuse_test: fuse_test.c common.c

tools/testing/selftests/net/tcp_mmap.c+5−2

@@ -165,9 +165,10 @@ void child_thread(void arg) · 164 unmodified lines
165	socklen_t zc_len = sizeof(zc);	165	socklen_t zc_len = sizeof(zc);
166	int res;	166	int res;
167		167
		168	memset(&zc, 0, sizeof(zc));
168	zc.address = (__u64)((unsigned long)addr);	169	zc.address = (__u64)((unsigned long)addr);
169	zc.length = chunk_size;	170	zc.length = chunk_size;
170	zc.recv_skip_hint = 0;	171
171	res = getsockopt(fd, IPPROTO_TCP, TCP_ZEROCOPY_RECEIVE,	172	res = getsockopt(fd, IPPROTO_TCP, TCP_ZEROCOPY_RECEIVE,
172	&zc, &zc_len);	173	&zc, &zc_len);
173	if (res == -1)	174	if (res == -1)
@@ -281,12 +282,14 @@ static void setup_sockaddr(int domain, const char *str_addr, · 107 unmodified lines
281	static void do_accept(int fdlisten)	282	static void do_accept(int fdlisten)
282	{	283	{
283	pthread_attr_t attr;	284	pthread_attr_t attr;
		285	int rcvlowat;
284		286
285	pthread_attr_init(&attr);	287	pthread_attr_init(&attr);
286	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);	288	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
287		289
		290	rcvlowat = chunk_size;
288	if (setsockopt(fdlisten, SOL_SOCKET, SO_RCVLOWAT,	291	if (setsockopt(fdlisten, SOL_SOCKET, SO_RCVLOWAT,
289	&chunk_size, sizeof(chunk_size)) == -1) {	292	&rcvlowat, sizeof(rcvlowat)) == -1) {
290	perror("setsockopt SO_RCVLOWAT");	293	perror("setsockopt SO_RCVLOWAT");
291	}	294	}
292		295

tools/testing/selftests/wireguard/netns.sh+51−3

@@ -48,8 +48,11 @@ cleanup() { · 47 unmodified lines
48	exec 2>/dev/null	48	exec 2>/dev/null
49	printf "$orig_message_cost" > /proc/sys/net/core/message_cost	49	printf "$orig_message_cost" > /proc/sys/net/core/message_cost
50	ip0 link del dev wg0	50	ip0 link del dev wg0
		51	ip0 link del dev wg1
51	ip1 link del dev wg0	52	ip1 link del dev wg0
		53	ip1 link del dev wg1
52	ip2 link del dev wg0	54	ip2 link del dev wg0
		55	ip2 link del dev wg1
53	local to_kill="$(ip netns pids $netns0) $(ip netns pids $netns1) $(ip netns pids $netns2)"	56	local to_kill="$(ip netns pids $netns0) $(ip netns pids $netns1) $(ip netns pids $netns2)"
54	[[ -n $to_kill ]] && kill $to_kill	57	[[ -n $to_kill ]] && kill $to_kill
55	pp ip netns del $netns1	58	pp ip netns del $netns1
@@ -77,18 +80,20 @@ ip0 link set wg0 netns $netns2 · 21 unmodified lines
77	key1="$(pp wg genkey)"	80	key1="$(pp wg genkey)"
78	key2="$(pp wg genkey)"	81	key2="$(pp wg genkey)"
79	key3="$(pp wg genkey)"	82	key3="$(pp wg genkey)"
		83	key4="$(pp wg genkey)"
80	pub1="$(pp wg pubkey <<<"$key1")"	84	pub1="$(pp wg pubkey <<<"$key1")"
81	pub2="$(pp wg pubkey <<<"$key2")"	85	pub2="$(pp wg pubkey <<<"$key2")"
82	pub3="$(pp wg pubkey <<<"$key3")"	86	pub3="$(pp wg pubkey <<<"$key3")"
		87	pub4="$(pp wg pubkey <<<"$key4")"
83	psk="$(pp wg genpsk)"	88	psk="$(pp wg genpsk)"
84	[[ -n $key1 && -n $key2 && -n $psk ]]	89	[[ -n $key1 && -n $key2 && -n $psk ]]
85		90
86	configure_peers() {	91	configure_peers() {
87	ip1 addr add 192.168.241.1/24 dev wg0	92	ip1 addr add 192.168.241.1/24 dev wg0
88	ip1 addr add fd00::1/24 dev wg0	93	ip1 addr add fd00::1/112 dev wg0
89		94
90	ip2 addr add 192.168.241.2/24 dev wg0	95	ip2 addr add 192.168.241.2/24 dev wg0
91	ip2 addr add fd00::2/24 dev wg0	96	ip2 addr add fd00::2/112 dev wg0
92		97
93	n1 wg set wg0 \	98	n1 wg set wg0 \
94	private-key <(echo "$key1") \	99	private-key <(echo "$key1") \
@@ -230,9 +235,38 @@ n1 ping -W 1 -c 1 192.168.241.2 · 135 unmodified lines
230	n1 wg set wg0 private-key <(echo "$key3")	235	n1 wg set wg0 private-key <(echo "$key3")
231	n2 wg set wg0 peer "$pub3" preshared-key <(echo "$psk") allowed-ips 192.168.241.1/32 peer "$pub1" remove	236	n2 wg set wg0 peer "$pub3" preshared-key <(echo "$psk") allowed-ips 192.168.241.1/32 peer "$pub1" remove
232	n1 ping -W 1 -c 1 192.168.241.2	237	n1 ping -W 1 -c 1 192.168.241.2
		238	n2 wg set wg0 peer "$pub3" remove
		239
		240	# Test that we can route wg through wg
		241	ip1 addr flush dev wg0
		242	ip2 addr flush dev wg0
		243	ip1 addr add fd00::5:1/112 dev wg0
		244	ip2 addr add fd00::5:2/112 dev wg0
		245	n1 wg set wg0 private-key <(echo "$key1") peer "$pub2" preshared-key <(echo "$psk") allowed-ips fd00::5:2/128 endpoint 127.0.0.1:2
		246	n2 wg set wg0 private-key <(echo "$key2") listen-port 2 peer "$pub1" preshared-key <(echo "$psk") allowed-ips fd00::5:1/128 endpoint 127.212.121.99:9998
		247	ip1 link add wg1 type wireguard
		248	ip2 link add wg1 type wireguard
		249	ip1 addr add 192.168.241.1/24 dev wg1
		250	ip1 addr add fd00::1/112 dev wg1
		251	ip2 addr add 192.168.241.2/24 dev wg1
		252	ip2 addr add fd00::2/112 dev wg1
		253	ip1 link set mtu 1340 up dev wg1
		254	ip2 link set mtu 1340 up dev wg1
		255	n1 wg set wg1 listen-port 5 private-key <(echo "$key3") peer "$pub4" allowed-ips 192.168.241.2/32,fd00::2/128 endpoint [fd00::5:2]:5
		256	n2 wg set wg1 listen-port 5 private-key <(echo "$key4") peer "$pub3" allowed-ips 192.168.241.1/32,fd00::1/128 endpoint [fd00::5:1]:5
		257	tests
		258	# Try to set up a routing loop between the two namespaces
		259	ip1 link set netns $netns0 dev wg1
		260	ip0 addr add 192.168.241.1/24 dev wg1
		261	ip0 link set up dev wg1
		262	n0 ping -W 1 -c 1 192.168.241.2
		263	n1 wg set wg0 peer "$pub2" endpoint 192.168.241.2:7
		264	ip2 link del wg0
		265	ip2 link del wg1
		266	! n0 ping -W 1 -c 10 -f 192.168.241.2 \|\| false # Should not crash kernel
233		267
		268	ip0 link del wg1
234	ip1 link del wg0	269	ip1 link del wg0
235	ip2 link del wg0
236		270
237	# Test using NAT. We now change the topology to this:	271	# Test using NAT. We now change the topology to this:
238	# ┌────────────────────────────────────────┐ ┌────────────────────────────────────────────────┐ ┌────────────────────────────────────────┐	272	# ┌────────────────────────────────────────┐ ┌────────────────────────────────────────────────┐ ┌────────────────────────────────────────┐
@@ -282,6 +316,20 @@ pp sleep 3 · 43 unmodified lines
282	n2 ping -W 1 -c 1 192.168.241.1	316	n2 ping -W 1 -c 1 192.168.241.1
283	n1 wg set wg0 peer "$pub2" persistent-keepalive 0	317	n1 wg set wg0 peer "$pub2" persistent-keepalive 0
284		318
		319	# Test that onion routing works, even when it loops
		320	n1 wg set wg0 peer "$pub3" allowed-ips 192.168.242.2/32 endpoint 192.168.241.2:5
		321	ip1 addr add 192.168.242.1/24 dev wg0
		322	ip2 link add wg1 type wireguard
		323	ip2 addr add 192.168.242.2/24 dev wg1
		324	n2 wg set wg1 private-key <(echo "$key3") listen-port 5 peer "$pub1" allowed-ips 192.168.242.1/32
		325	ip2 link set wg1 up
		326	n1 ping -W 1 -c 1 192.168.242.2
		327	ip2 link del wg1
		328	n1 wg set wg0 peer "$pub3" endpoint 192.168.242.2:5
		329	! n1 ping -W 1 -c 1 192.168.242.2 \|\| false # Should not crash kernel
		330	n1 wg set wg0 peer "$pub3" remove
		331	ip1 addr del 192.168.242.1/24 dev wg0
		332
285	# Do a wg-quick(8)-style policy routing for the default route, making sure vethc has a v6 address to tease out bugs.	333	# Do a wg-quick(8)-style policy routing for the default route, making sure vethc has a v6 address to tease out bugs.
286	ip1 -6 addr add fc00::9/96 dev vethc	334	ip1 -6 addr add fc00::9/96 dev vethc
287	ip1 -6 route add default via fc00::1	335	ip1 -6 route add default via fc00::1

tools/testing/selftests/wireguard/qemu/arch/powerpc64le.config+1−0

@@ -10,3 +10,4 @@ CONFIG_CMDLINE_BOOL=y · 9 unmodified lines
10	CONFIG_CMDLINE="console=hvc0 wg.success=hvc1"	10	CONFIG_CMDLINE="console=hvc0 wg.success=hvc1"
11	CONFIG_SECTION_MISMATCH_WARN_ONLY=y	11	CONFIG_SECTION_MISMATCH_WARN_ONLY=y
12	CONFIG_FRAME_WARN=1280	12	CONFIG_FRAME_WARN=1280
		13	CONFIG_THREAD_SHIFT=14

tools/testing/selftests/wireguard/qemu/debug.config+0−1

@@ -25,7 +25,6 @@ CONFIG_KASAN=y · 24 unmodified lines
25	CONFIG_KASAN_INLINE=y	25	CONFIG_KASAN_INLINE=y
26	CONFIG_UBSAN=y	26	CONFIG_UBSAN=y
27	CONFIG_UBSAN_SANITIZE_ALL=y	27	CONFIG_UBSAN_SANITIZE_ALL=y
28	CONFIG_UBSAN_NO_ALIGNMENT=y
29	CONFIG_UBSAN_NULL=y	28	CONFIG_UBSAN_NULL=y
30	CONFIG_DEBUG_KMEMLEAK=y	29	CONFIG_DEBUG_KMEMLEAK=y
31	CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE=8192	30	CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE=8192

virt/kvm/arm/hyp/aarch32.c+6−2

  */
 void __hyp_text kvm_skip_instr32(struct kvm_vcpu *vcpu, bool is_wide_instr)
 {
+	u32 pc = *vcpu_pc(vcpu);
 	bool is_thumb;
 	is_thumb = !!(*vcpu_cpsr(vcpu) & PSR_AA32_T_BIT);
 	if (is_thumb && !is_wide_instr)
-		*vcpu_pc(vcpu) += 2;
+		pc += 2;
 	else
-		*vcpu_pc(vcpu) += 4;
+		pc += 4;
+	*vcpu_pc(vcpu) = pc;
 	kvm_adjust_itstate(vcpu);
 }

virt/kvm/arm/psci.c+40−0

@@ -186,6 +186,33 @@ static void kvm_psci_system_reset(struct kvm_vcpu *vcpu) · 185 unmodified lines
186	kvm_prepare_system_event(vcpu, KVM_SYSTEM_EVENT_RESET);	186	kvm_prepare_system_event(vcpu, KVM_SYSTEM_EVENT_RESET);
187	}	187	}
188		188
		189	static void kvm_psci_narrow_to_32bit(struct kvm_vcpu *vcpu)
		190	{
		191	int i;
		192
		193	/*
		194	* Zero the input registers' upper 32 bits. They will be fully
		195	* zeroed on exit, so we're fine changing them in place.
		196	*/
		197	for (i = 1; i < 4; i++)
		198	vcpu_set_reg(vcpu, i, lower_32_bits(vcpu_get_reg(vcpu, i)));
		199	}
		200
		201	static unsigned long kvm_psci_check_allowed_function(struct kvm_vcpu *vcpu, u32 fn)
		202	{
		203	switch(fn) {
		204	case PSCI_0_2_FN64_CPU_SUSPEND:
		205	case PSCI_0_2_FN64_CPU_ON:
		206	case PSCI_0_2_FN64_AFFINITY_INFO:
		207	/* Disallow these functions for 32bit guests */
		208	if (vcpu_mode_is_32bit(vcpu))
		209	return PSCI_RET_NOT_SUPPORTED;
		210	break;
		211	}
		212
		213	return 0;
		214	}
		215
189	static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu)	216	static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu)
190	{	217	{
191	struct kvm *kvm = vcpu->kvm;	218	struct kvm *kvm = vcpu->kvm;
@@ -193,6 +220,10 @@ static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu) · 1 unmodified line
193	unsigned long val;	220	unsigned long val;
194	int ret = 1;	221	int ret = 1;
195		222
		223	val = kvm_psci_check_allowed_function(vcpu, psci_fn);
		224	if (val)
		225	goto out;
		226
196	switch (psci_fn) {	227	switch (psci_fn) {
197	case PSCI_0_2_FN_PSCI_VERSION:	228	case PSCI_0_2_FN_PSCI_VERSION:
198	/*	229	/*
@@ -210,12 +241,16 @@ static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu) · 11 unmodified lines
210	val = PSCI_RET_SUCCESS;	241	val = PSCI_RET_SUCCESS;
211	break;	242	break;
212	case PSCI_0_2_FN_CPU_ON:	243	case PSCI_0_2_FN_CPU_ON:
		244	kvm_psci_narrow_to_32bit(vcpu);
		245	fallthrough;
213	case PSCI_0_2_FN64_CPU_ON:	246	case PSCI_0_2_FN64_CPU_ON:
214	mutex_lock(&kvm->lock);	247	mutex_lock(&kvm->lock);
215	val = kvm_psci_vcpu_on(vcpu);	248	val = kvm_psci_vcpu_on(vcpu);
216	mutex_unlock(&kvm->lock);	249	mutex_unlock(&kvm->lock);
217	break;	250	break;
218	case PSCI_0_2_FN_AFFINITY_INFO:	251	case PSCI_0_2_FN_AFFINITY_INFO:
		252	kvm_psci_narrow_to_32bit(vcpu);
		253	fallthrough;
219	case PSCI_0_2_FN64_AFFINITY_INFO:	254	case PSCI_0_2_FN64_AFFINITY_INFO:
220	val = kvm_psci_vcpu_affinity_info(vcpu);	255	val = kvm_psci_vcpu_affinity_info(vcpu);
221	break;	256	break;
@@ -256,6 +291,7 @@ static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu) · 34 unmodified lines
256	break;	291	break;
257	}	292	}
258		293
		294	out:
259	smccc_set_retval(vcpu, val, 0, 0, 0);	295	smccc_set_retval(vcpu, val, 0, 0, 0);
260	return ret;	296	return ret;
261	}	297	}
@@ -273,6 +309,10 @@ static int kvm_psci_1_0_call(struct kvm_vcpu *vcpu) · 11 unmodified lines
273	break;	309	break;
274	case PSCI_1_0_FN_PSCI_FEATURES:	310	case PSCI_1_0_FN_PSCI_FEATURES:
275	feature = smccc_get_arg1(vcpu);	311	feature = smccc_get_arg1(vcpu);
		312	val = kvm_psci_check_allowed_function(vcpu, feature);
		313	if (val)
		314	break;
		315
276	switch(feature) {	316	switch(feature) {
277	case PSCI_0_2_FN_PSCI_VERSION:	317	case PSCI_0_2_FN_PSCI_VERSION:
278	case PSCI_0_2_FN_CPU_SUSPEND:	318	case PSCI_0_2_FN_CPU_SUSPEND:

virt/kvm/arm/vgic/vgic-init.c+16−3

 		}
 	}
-	if (vgic_has_its(kvm)) {
+	if (vgic_has_its(kvm))
 		vgic_lpi_translation_cache_init(kvm);
+	/*
+	 * If we have GICv4.1 enabled, unconditionnaly request enable the
+	 * v4 support so that we get HW-accelerated vSGIs. Otherwise, only
+	 * enable it if we present a virtual ITS to the guest.
+	 */
+	if (vgic_supports_direct_msis(kvm)) {
 		ret = vgic_v4_init(kvm);
 		if (ret)
 			goto out;
 {
 	struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;
+	/*
+	 * Retire all pending LPIs on this vcpu anyway as we're
+	 * going to destroy it.
+	 */
+	vgic_flush_pending_lpis(vcpu);
 	INIT_LIST_HEAD(&vgic_cpu->ap_list_head);
 }
 	vgic_debug_destroy(kvm);
-	kvm_vgic_dist_destroy(kvm);
 	kvm_for_each_vcpu(i, vcpu, kvm)
 		kvm_vgic_vcpu_destroy(vcpu);
+	kvm_vgic_dist_destroy(kvm);
 }
 void kvm_vgic_destroy(struct kvm *kvm)

virt/kvm/arm/vgic/vgic-its.c+9−2

 	 * We "cache" the configuration table entries in our struct vgic_irq's.
 	 * However we only have those structs for mapped IRQs, so we read in
 	 * the respective config data from memory here upon mapping the LPI.
+	 *
+	 * Should any of these fail, behave as if we couldn't create the LPI
+	 * by dropping the refcount and returning the error.
 	 */
 	ret = update_lpi_config(kvm, irq, NULL, false);
-	if (ret)
+	if (ret) {
+		vgic_put_irq(kvm, irq);
 		return ERR_PTR(ret);
+	}
 	ret = vgic_v3_lpi_sync_pending_status(kvm, irq);
-	if (ret)
+	if (ret) {
+		vgic_put_irq(kvm, irq);
 		return ERR_PTR(ret);
+	}
 	return irq;
 }

virt/kvm/arm/vgic/vgic-mmio-v2.c+10−6

 		NULL, vgic_mmio_uaccess_write_v2_group, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ(GIC_DIST_ENABLE_SET,
-		vgic_mmio_read_enable, vgic_mmio_write_senable, NULL, NULL, 1,
+		vgic_mmio_read_enable, vgic_mmio_write_senable,
+		NULL, vgic_uaccess_write_senable, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ(GIC_DIST_ENABLE_CLEAR,
-		vgic_mmio_read_enable, vgic_mmio_write_cenable, NULL, NULL, 1,
+		vgic_mmio_read_enable, vgic_mmio_write_cenable,
+		NULL, vgic_uaccess_write_cenable, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ(GIC_DIST_PENDING_SET,
-		vgic_mmio_read_pending, vgic_mmio_write_spending, NULL, NULL, 1,
+		vgic_mmio_read_pending, vgic_mmio_write_spending,
+		NULL, vgic_uaccess_write_spending, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ(GIC_DIST_PENDING_CLEAR,
-		vgic_mmio_read_pending, vgic_mmio_write_cpending, NULL, NULL, 1,
+		vgic_mmio_read_pending, vgic_mmio_write_cpending,
+		NULL, vgic_uaccess_write_cpending, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ(GIC_DIST_ACTIVE_SET,
 		vgic_mmio_read_active, vgic_mmio_write_sactive,
-		NULL, vgic_mmio_uaccess_write_sactive, 1,
+		vgic_uaccess_read_active, vgic_mmio_uaccess_write_sactive, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ(GIC_DIST_ACTIVE_CLEAR,
 		vgic_mmio_read_active, vgic_mmio_write_cactive,
-		NULL, vgic_mmio_uaccess_write_cactive, 1,
+		vgic_uaccess_read_active, vgic_mmio_uaccess_write_cactive, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ(GIC_DIST_PRI,
 		vgic_mmio_read_priority, vgic_mmio_write_priority, NULL, NULL,

virt/kvm/arm/vgic/vgic-mmio-v3.c+18−13

 bool vgic_supports_direct_msis(struct kvm *kvm)
 {
-	return kvm_vgic_global_state.has_gicv4 && vgic_has_its(kvm);
+	return (kvm_vgic_global_state.has_gicv4_1 ||
+		(kvm_vgic_global_state.has_gicv4 && vgic_has_its(kvm)));
 }
 /*
 		vgic_mmio_read_group, vgic_mmio_write_group, NULL, NULL, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ_SHARED(GICD_ISENABLER,
-		vgic_mmio_read_enable, vgic_mmio_write_senable, NULL, NULL, 1,
+		vgic_mmio_read_enable, vgic_mmio_write_senable,
+		NULL, vgic_uaccess_write_senable, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ_SHARED(GICD_ICENABLER,
-		vgic_mmio_read_enable, vgic_mmio_write_cenable, NULL, NULL, 1,
+		vgic_mmio_read_enable, vgic_mmio_write_cenable,
+	       NULL, vgic_uaccess_write_cenable, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ_SHARED(GICD_ISPENDR,
 		vgic_mmio_read_pending, vgic_mmio_write_spending,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ_SHARED(GICD_ISACTIVER,
 		vgic_mmio_read_active, vgic_mmio_write_sactive,
-		NULL, vgic_mmio_uaccess_write_sactive, 1,
+		vgic_uaccess_read_active, vgic_mmio_uaccess_write_sactive, 1,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ_SHARED(GICD_ICACTIVER,
 		vgic_mmio_read_active, vgic_mmio_write_cactive,
-		NULL, vgic_mmio_uaccess_write_cactive,
+		vgic_uaccess_read_active, vgic_mmio_uaccess_write_cactive,
 		1, VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_BITS_PER_IRQ_SHARED(GICD_IPRIORITYR,
 		vgic_mmio_read_priority, vgic_mmio_write_priority, NULL, NULL,
 	REGISTER_DESC_WITH_LENGTH(SZ_64K + GICR_IGROUPR0,
 		vgic_mmio_read_group, vgic_mmio_write_group, 4,
 		VGIC_ACCESS_32bit),
-	REGISTER_DESC_WITH_LENGTH(SZ_64K + GICR_ISENABLER0,
+	REGISTER_DESC_WITH_LENGTH_UACCESS(SZ_64K + GICR_ISENABLER0,
-		vgic_mmio_read_enable, vgic_mmio_write_senable, 4,
+		vgic_mmio_read_enable, vgic_mmio_write_senable,
+		NULL, vgic_uaccess_write_senable, 4,
 		VGIC_ACCESS_32bit),
-	REGISTER_DESC_WITH_LENGTH(SZ_64K + GICR_ICENABLER0,
+	REGISTER_DESC_WITH_LENGTH_UACCESS(SZ_64K + GICR_ICENABLER0,
-		vgic_mmio_read_enable, vgic_mmio_write_cenable, 4,
+		vgic_mmio_read_enable, vgic_mmio_write_cenable,
+		NULL, vgic_uaccess_write_cenable, 4,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_LENGTH_UACCESS(SZ_64K + GICR_ISPENDR0,
 		vgic_mmio_read_pending, vgic_mmio_write_spending,
 		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_LENGTH_UACCESS(SZ_64K + GICR_ISACTIVER0,
 		vgic_mmio_read_active, vgic_mmio_write_sactive,
-		NULL, vgic_mmio_uaccess_write_sactive,
+		vgic_uaccess_read_active, vgic_mmio_uaccess_write_sactive, 4,
-		4, VGIC_ACCESS_32bit),
+		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_LENGTH_UACCESS(SZ_64K + GICR_ICACTIVER0,
 		vgic_mmio_read_active, vgic_mmio_write_cactive,
-		NULL, vgic_mmio_uaccess_write_cactive,
+		vgic_uaccess_read_active, vgic_mmio_uaccess_write_cactive, 4,
-		4, VGIC_ACCESS_32bit),
+		VGIC_ACCESS_32bit),
 	REGISTER_DESC_WITH_LENGTH(SZ_64K + GICR_IPRIORITYR0,
 		vgic_mmio_read_priority, vgic_mmio_write_priority, 32,
 		VGIC_ACCESS_32bit | VGIC_ACCESS_8bit),

virt/kvm/arm/vgic/vgic-mmio.c+170−58

@@ -184,6 +184,48 @@ void vgic_mmio_write_cenable(struct kvm_vcpu *vcpu, · 183 unmodified lines
184	}	184	}
185	}	185	}
186		186
		187	int vgic_uaccess_write_senable(struct kvm_vcpu *vcpu,
		188	gpa_t addr, unsigned int len,
		189	unsigned long val)
		190	{
		191	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
		192	int i;
		193	unsigned long flags;
		194
		195	for_each_set_bit(i, &val, len * 8) {
		196	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
		197
		198	raw_spin_lock_irqsave(&irq->irq_lock, flags);
		199	irq->enabled = true;
		200	vgic_queue_irq_unlock(vcpu->kvm, irq, flags);
		201
		202	vgic_put_irq(vcpu->kvm, irq);
		203	}
		204
		205	return 0;
		206	}
		207
		208	int vgic_uaccess_write_cenable(struct kvm_vcpu *vcpu,
		209	gpa_t addr, unsigned int len,
		210	unsigned long val)
		211	{
		212	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
		213	int i;
		214	unsigned long flags;
		215
		216	for_each_set_bit(i, &val, len * 8) {
		217	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
		218
		219	raw_spin_lock_irqsave(&irq->irq_lock, flags);
		220	irq->enabled = false;
		221	raw_spin_unlock_irqrestore(&irq->irq_lock, flags);
		222
		223	vgic_put_irq(vcpu->kvm, irq);
		224	}
		225
		226	return 0;
		227	}
		228
187	unsigned long vgic_mmio_read_pending(struct kvm_vcpu *vcpu,	229	unsigned long vgic_mmio_read_pending(struct kvm_vcpu *vcpu,
188	gpa_t addr, unsigned int len)	230	gpa_t addr, unsigned int len)
189	{	231	{
@@ -219,17 +261,6 @@ unsigned long vgic_mmio_read_pending(struct kvm_vcpu *vcpu, · 29 unmodified lines
219	return value;	261	return value;
220	}	262	}
221		263
222	/* Must be called with irq->irq_lock held */
223	static void vgic_hw_irq_spending(struct kvm_vcpu vcpu, struct vgic_irq irq,
224	bool is_uaccess)
225	{
226	if (is_uaccess)
227	return;
228
229	irq->pending_latch = true;
230	vgic_irq_set_phys_active(irq, true);
231	}
232
233	static bool is_vgic_v2_sgi(struct kvm_vcpu vcpu, struct vgic_irq irq)	264	static bool is_vgic_v2_sgi(struct kvm_vcpu vcpu, struct vgic_irq irq)
234	{	265	{
235	return (vgic_irq_is_sgi(irq->intid) &&	266	return (vgic_irq_is_sgi(irq->intid) &&
@@ -240,7 +271,6 @@ void vgic_mmio_write_spending(struct kvm_vcpu *vcpu, · 4 unmodified lines
240	gpa_t addr, unsigned int len,	271	gpa_t addr, unsigned int len,
241	unsigned long val)	272	unsigned long val)
242	{	273	{
243	bool is_uaccess = !kvm_get_running_vcpu();
244	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);	274	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
245	int i;	275	int i;
246	unsigned long flags;	276	unsigned long flags;
@@ -270,22 +300,48 @@ void vgic_mmio_write_spending(struct kvm_vcpu *vcpu, · 23 unmodified lines
270	continue;	300	continue;
271	}	301	}
272		302
		303	irq->pending_latch = true;
273	if (irq->hw)	304	if (irq->hw)
274	vgic_hw_irq_spending(vcpu, irq, is_uaccess);	305	vgic_irq_set_phys_active(irq, true);
275	else	306
276	irq->pending_latch = true;
277	vgic_queue_irq_unlock(vcpu->kvm, irq, flags);	307	vgic_queue_irq_unlock(vcpu->kvm, irq, flags);
278	vgic_put_irq(vcpu->kvm, irq);	308	vgic_put_irq(vcpu->kvm, irq);
279	}	309	}
280	}	310	}
281		311
282	/* Must be called with irq->irq_lock held */	312	int vgic_uaccess_write_spending(struct kvm_vcpu *vcpu,
283	static void vgic_hw_irq_cpending(struct kvm_vcpu vcpu, struct vgic_irq irq,	313	gpa_t addr, unsigned int len,
284	bool is_uaccess)	314	unsigned long val)
285	{	315	{
286	if (is_uaccess)	316	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
287	return;	317	int i;
		318	unsigned long flags;
		319
		320	for_each_set_bit(i, &val, len * 8) {
		321	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
		322
		323	raw_spin_lock_irqsave(&irq->irq_lock, flags);
		324	irq->pending_latch = true;
288		325
		326	/*
		327	* GICv2 SGIs are terribly broken. We can't restore
		328	* the source of the interrupt, so just pick the vcpu
		329	* itself as the source...
		330	*/
		331	if (is_vgic_v2_sgi(vcpu, irq))
		332	irq->source \|= BIT(vcpu->vcpu_id);
		333
		334	vgic_queue_irq_unlock(vcpu->kvm, irq, flags);
		335
		336	vgic_put_irq(vcpu->kvm, irq);
		337	}
		338
		339	return 0;
		340	}
		341
		342	/* Must be called with irq->irq_lock held */
		343	static void vgic_hw_irq_cpending(struct kvm_vcpu vcpu, struct vgic_irq irq)
		344	{
289	irq->pending_latch = false;	345	irq->pending_latch = false;
290		346
291	/*	347	/*
@@ -308,7 +364,6 @@ void vgic_mmio_write_cpending(struct kvm_vcpu *vcpu, · 16 unmodified lines
308	gpa_t addr, unsigned int len,	364	gpa_t addr, unsigned int len,
309	unsigned long val)	365	unsigned long val)
310	{	366	{
311	bool is_uaccess = !kvm_get_running_vcpu();
312	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);	367	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
313	int i;	368	int i;
314	unsigned long flags;	369	unsigned long flags;
@@ -339,7 +394,7 @@ void vgic_mmio_write_cpending(struct kvm_vcpu *vcpu, · 24 unmodified lines
339	}	394	}
340		395
341	if (irq->hw)	396	if (irq->hw)
342	vgic_hw_irq_cpending(vcpu, irq, is_uaccess);	397	vgic_hw_irq_cpending(vcpu, irq);
343	else	398	else
344	irq->pending_latch = false;	399	irq->pending_latch = false;
345		400
@@ -348,8 +403,68 @@ void vgic_mmio_write_cpending(struct kvm_vcpu *vcpu, · 2 unmodified lines
348	}	403	}
349	}	404	}
350		405
351	unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu,	406	int vgic_uaccess_write_cpending(struct kvm_vcpu *vcpu,
352	gpa_t addr, unsigned int len)	407	gpa_t addr, unsigned int len,
		408	unsigned long val)
		409	{
		410	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
		411	int i;
		412	unsigned long flags;
		413
		414	for_each_set_bit(i, &val, len * 8) {
		415	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
		416
		417	raw_spin_lock_irqsave(&irq->irq_lock, flags);
		418	/*
		419	* More fun with GICv2 SGIs! If we're clearing one of them
		420	* from userspace, which source vcpu to clear? Let's not
		421	* even think of it, and blow the whole set.
		422	*/
		423	if (is_vgic_v2_sgi(vcpu, irq))
		424	irq->source = 0;
		425
		426	irq->pending_latch = false;
		427
		428	raw_spin_unlock_irqrestore(&irq->irq_lock, flags);
		429
		430	vgic_put_irq(vcpu->kvm, irq);
		431	}
		432
		433	return 0;
		434	}
		435
		436	/*
		437	* If we are fiddling with an IRQ's active state, we have to make sure the IRQ
		438	* is not queued on some running VCPU's LRs, because then the change to the
		439	* active state can be overwritten when the VCPU's state is synced coming back
		440	* from the guest.
		441	*
		442	* For shared interrupts as well as GICv3 private interrupts, we have to
		443	* stop all the VCPUs because interrupts can be migrated while we don't hold
		444	* the IRQ locks and we don't want to be chasing moving targets.
		445	*
		446	* For GICv2 private interrupts we don't have to do anything because
		447	* userspace accesses to the VGIC state already require all VCPUs to be
		448	* stopped, and only the VCPU itself can modify its private interrupts
		449	* active state, which guarantees that the VCPU is not running.
		450	*/
		451	static void vgic_access_active_prepare(struct kvm_vcpu *vcpu, u32 intid)
		452	{
		453	if (vcpu->kvm->arch.vgic.vgic_model == KVM_DEV_TYPE_ARM_VGIC_V3 \|\|
		454	intid >= VGIC_NR_PRIVATE_IRQS)
		455	kvm_arm_halt_guest(vcpu->kvm);
		456	}
		457
		458	/* See vgic_access_active_prepare */
		459	static void vgic_access_active_finish(struct kvm_vcpu *vcpu, u32 intid)
		460	{
		461	if (vcpu->kvm->arch.vgic.vgic_model == KVM_DEV_TYPE_ARM_VGIC_V3 \|\|
		462	intid >= VGIC_NR_PRIVATE_IRQS)
		463	kvm_arm_resume_guest(vcpu->kvm);
		464	}
		465
		466	static unsigned long __vgic_mmio_read_active(struct kvm_vcpu *vcpu,
		467	gpa_t addr, unsigned int len)
353	{	468	{
354	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);	469	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
355	u32 value = 0;	470	u32 value = 0;
@@ -359,6 +474,10 @@ unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu, · 3 unmodified lines
359	for (i = 0; i < len * 8; i++) {	474	for (i = 0; i < len * 8; i++) {
360	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);	475	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
361		476
		477	/*
		478	* Even for HW interrupts, don't evaluate the HW state as
		479	* all the guest is interested in is the virtual state.
		480	*/
362	if (irq->active)	481	if (irq->active)
363	value \|= (1U << i);	482	value \|= (1U << i);
364		483
@@ -368,6 +487,29 @@ unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu, · 3 unmodified lines
368	return value;	487	return value;
369	}	488	}
370		489
		490	unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu,
		491	gpa_t addr, unsigned int len)
		492	{
		493	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
		494	u32 val;
		495
		496	mutex_lock(&vcpu->kvm->lock);
		497	vgic_access_active_prepare(vcpu, intid);
		498
		499	val = __vgic_mmio_read_active(vcpu, addr, len);
		500
		501	vgic_access_active_finish(vcpu, intid);
		502	mutex_unlock(&vcpu->kvm->lock);
		503
		504	return val;
		505	}
		506
		507	unsigned long vgic_uaccess_read_active(struct kvm_vcpu *vcpu,
		508	gpa_t addr, unsigned int len)
		509	{
		510	return __vgic_mmio_read_active(vcpu, addr, len);
		511	}
		512
371	/* Must be called with irq->irq_lock held */	513	/* Must be called with irq->irq_lock held */
372	static void vgic_hw_irq_change_active(struct kvm_vcpu vcpu, struct vgic_irq irq,	514	static void vgic_hw_irq_change_active(struct kvm_vcpu vcpu, struct vgic_irq irq,
373	bool active, bool is_uaccess)	515	bool active, bool is_uaccess)
@@ -426,36 +568,6 @@ static void vgic_mmio_change_active(struct kvm_vcpu vcpu, struct vgic_irq irq, · 52 unmodified lines
426	raw_spin_unlock_irqrestore(&irq->irq_lock, flags);	568	raw_spin_unlock_irqrestore(&irq->irq_lock, flags);
427	}	569	}
428		570
429	/*
430	* If we are fiddling with an IRQ's active state, we have to make sure the IRQ
431	* is not queued on some running VCPU's LRs, because then the change to the
432	* active state can be overwritten when the VCPU's state is synced coming back
433	* from the guest.
434	*
435	* For shared interrupts, we have to stop all the VCPUs because interrupts can
436	* be migrated while we don't hold the IRQ locks and we don't want to be
437	* chasing moving targets.
438	*
439	* For private interrupts we don't have to do anything because userspace
440	* accesses to the VGIC state already require all VCPUs to be stopped, and
441	* only the VCPU itself can modify its private interrupts active state, which
442	* guarantees that the VCPU is not running.
443	*/
444	static void vgic_change_active_prepare(struct kvm_vcpu *vcpu, u32 intid)
445	{
446	if (vcpu->kvm->arch.vgic.vgic_model == KVM_DEV_TYPE_ARM_VGIC_V3 \|\|
447	intid > VGIC_NR_PRIVATE_IRQS)
448	kvm_arm_halt_guest(vcpu->kvm);
449	}
450
451	/* See vgic_change_active_prepare */
452	static void vgic_change_active_finish(struct kvm_vcpu *vcpu, u32 intid)
453	{
454	if (vcpu->kvm->arch.vgic.vgic_model == KVM_DEV_TYPE_ARM_VGIC_V3 \|\|
455	intid > VGIC_NR_PRIVATE_IRQS)
456	kvm_arm_resume_guest(vcpu->kvm);
457	}
458
459	static void __vgic_mmio_write_cactive(struct kvm_vcpu *vcpu,	571	static void __vgic_mmio_write_cactive(struct kvm_vcpu *vcpu,
460	gpa_t addr, unsigned int len,	572	gpa_t addr, unsigned int len,
461	unsigned long val)	573	unsigned long val)
@@ -477,11 +589,11 @@ void vgic_mmio_write_cactive(struct kvm_vcpu *vcpu, · 15 unmodified lines
477	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);	589	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
478		590
479	mutex_lock(&vcpu->kvm->lock);	591	mutex_lock(&vcpu->kvm->lock);
480	vgic_change_active_prepare(vcpu, intid);	592	vgic_access_active_prepare(vcpu, intid);
481		593
482	__vgic_mmio_write_cactive(vcpu, addr, len, val);	594	__vgic_mmio_write_cactive(vcpu, addr, len, val);
483		595
484	vgic_change_active_finish(vcpu, intid);	596	vgic_access_active_finish(vcpu, intid);
485	mutex_unlock(&vcpu->kvm->lock);	597	mutex_unlock(&vcpu->kvm->lock);
486	}	598	}
487		599
@@ -514,11 +626,11 @@ void vgic_mmio_write_sactive(struct kvm_vcpu *vcpu, · 26 unmodified lines
514	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);	626	u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
515		627
516	mutex_lock(&vcpu->kvm->lock);	628	mutex_lock(&vcpu->kvm->lock);
517	vgic_change_active_prepare(vcpu, intid);	629	vgic_access_active_prepare(vcpu, intid);
518		630
519	__vgic_mmio_write_sactive(vcpu, addr, len, val);	631	__vgic_mmio_write_sactive(vcpu, addr, len, val);
520		632
521	vgic_change_active_finish(vcpu, intid);	633	vgic_access_active_finish(vcpu, intid);
522	mutex_unlock(&vcpu->kvm->lock);	634	mutex_unlock(&vcpu->kvm->lock);
523	}	635	}
524		636

virt/kvm/arm/vgic/vgic-mmio.h+19−0

@@ -138,6 +138,14 @@ void vgic_mmio_write_cenable(struct kvm_vcpu *vcpu, · 137 unmodified lines
138	gpa_t addr, unsigned int len,	138	gpa_t addr, unsigned int len,
139	unsigned long val);	139	unsigned long val);
140		140
		141	int vgic_uaccess_write_senable(struct kvm_vcpu *vcpu,
		142	gpa_t addr, unsigned int len,
		143	unsigned long val);
		144
		145	int vgic_uaccess_write_cenable(struct kvm_vcpu *vcpu,
		146	gpa_t addr, unsigned int len,
		147	unsigned long val);
		148
141	unsigned long vgic_mmio_read_pending(struct kvm_vcpu *vcpu,	149	unsigned long vgic_mmio_read_pending(struct kvm_vcpu *vcpu,
142	gpa_t addr, unsigned int len);	150	gpa_t addr, unsigned int len);
143		151
@@ -149,9 +157,20 @@ void vgic_mmio_write_cpending(struct kvm_vcpu *vcpu, · 5 unmodified lines
149	gpa_t addr, unsigned int len,	157	gpa_t addr, unsigned int len,
150	unsigned long val);	158	unsigned long val);
151		159
		160	int vgic_uaccess_write_spending(struct kvm_vcpu *vcpu,
		161	gpa_t addr, unsigned int len,
		162	unsigned long val);
		163
		164	int vgic_uaccess_write_cpending(struct kvm_vcpu *vcpu,
		165	gpa_t addr, unsigned int len,
		166	unsigned long val);
		167
152	unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu,	168	unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu,
153	gpa_t addr, unsigned int len);	169	gpa_t addr, unsigned int len);
154		170
		171	unsigned long vgic_uaccess_read_active(struct kvm_vcpu *vcpu,
		172	gpa_t addr, unsigned int len);
		173
155	void vgic_mmio_write_cactive(struct kvm_vcpu *vcpu,	174	void vgic_mmio_write_cactive(struct kvm_vcpu *vcpu,
156	gpa_t addr, unsigned int len,	175	gpa_t addr, unsigned int len,
157	unsigned long val);	176	unsigned long val);