lael-labs/linux

.mailmap+3−0

 Andrew Murray <amurray@thegoodpenguin.co.uk> <amurray@embedded-bits.co.uk>
 Andrew Murray <amurray@thegoodpenguin.co.uk> <andrew.murray@arm.com>
 Andrew Vasquez <andrew.vasquez@qlogic.com>
+Andrey Konovalov <andreyknvl@gmail.com> <andreyknvl@google.com>
 Andrey Ryabinin <ryabinin.a.a@gmail.com> <a.ryabinin@samsung.com>
 Andrey Ryabinin <ryabinin.a.a@gmail.com> <aryabinin@virtuozzo.com>
 Andy Adamson <andros@citi.umich.edu>
 Changbin Du <changbin.du@intel.com> <changbin.du@intel.com>
 Chao Yu <chao@kernel.org> <chao2.yu@samsung.com>
 Chao Yu <chao@kernel.org> <yuchao0@huawei.com>
+Chris Chiu <chris.chiu@canonical.com> <chiu@endlessm.com>
+Chris Chiu <chris.chiu@canonical.com> <chiu@endlessos.org>
 Christophe Ricard <christophe.ricard@gmail.com>
 Christoph Hellwig <hch@lst.de>
 Corey Minyard <minyard@acm.org>

Documentation/ABI/testing/sysfs-fs-xfs+1−1

@@ -33,7 +33,7 @@ Contact: xfs@oss.sgi.com · 32 unmodified lines
33	Description:	33	Description:
34	The current state of the log write grant head. It	34	The current state of the log write grant head. It
35	represents the total log reservation of all currently	35	represents the total log reservation of all currently
36	oustanding transactions, including regrants due to	36	outstanding transactions, including regrants due to
37	rolling transactions. The grant head is exported in	37	rolling transactions. The grant head is exported in
38	"cycle:bytes" format.	38	"cycle:bytes" format.
39	Users: xfstests	39	Users: xfstests

Documentation/arm64/acpi_object_usage.rst+5−5

@@ -17,12 +17,12 @@ For ACPI on arm64, tables also fall into the following categories: · 16 unmodified lines
17		17
18	- Recommended: BERT, EINJ, ERST, HEST, PCCT, SSDT	18	- Recommended: BERT, EINJ, ERST, HEST, PCCT, SSDT
19		19
20	- Optional: BGRT, CPEP, CSRT, DBG2, DRTM, ECDT, FACS, FPDT, IORT,	20	- Optional: BGRT, CPEP, CSRT, DBG2, DRTM, ECDT, FACS, FPDT, IBFT,
21	MCHI, MPST, MSCT, NFIT, PMTT, RASF, SBST, SLIT, SPMI, SRAT, STAO,	21	IORT, MCHI, MPST, MSCT, NFIT, PMTT, RASF, SBST, SLIT, SPMI, SRAT,
22	TCPA, TPM2, UEFI, XENV	22	STAO, TCPA, TPM2, UEFI, XENV
23		23
24	- Not supported: BOOT, DBGP, DMAR, ETDT, HPET, IBFT, IVRS, LPIT,	24	- Not supported: BOOT, DBGP, DMAR, ETDT, HPET, IVRS, LPIT, MSDM, OEMx,
25	MSDM, OEMx, PSDT, RSDT, SLIC, WAET, WDAT, WDRT, WPBT	25	PSDT, RSDT, SLIC, WAET, WDAT, WDRT, WPBT
26		26
27	====== ========================================================================	27	====== ========================================================================
28	Table Usage for ARMv8 Linux	28	Table Usage for ARMv8 Linux

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

 | Marvell        | ARM-MMU-500     | #582743         | N/A                         |
 +----------------+-----------------+-----------------+-----------------------------+
 +----------------+-----------------+-----------------+-----------------------------+
+| NVIDIA         | Carmel Core     | N/A             | NVIDIA_CARMEL_CNP_ERRATUM   |
++----------------+-----------------+-----------------+-----------------------------+
++----------------+-----------------+-----------------+-----------------------------+
 | Freescale/NXP  | LS2080A/LS1043A | A-008585        | FSL_ERRATUM_A008585         |
 +----------------+-----------------+-----------------+-----------------------------+
 +----------------+-----------------+-----------------+-----------------------------+

Documentation/devicetree/bindings/interrupt-controller/ingenic,intc.yaml+1−0

@@ -23,6 +23,7 @@ properties: · 22 unmodified lines
23	- enum:	23	- enum:
24	- ingenic,jz4775-intc	24	- ingenic,jz4775-intc
25	- ingenic,jz4770-intc	25	- ingenic,jz4770-intc
		26	- ingenic,jz4760b-intc
26	- const: ingenic,jz4760-intc	27	- const: ingenic,jz4760-intc
27	- items:	28	- items:
28	- const: ingenic,x1000-intc	29	- const: ingenic,x1000-intc

Documentation/devicetree/bindings/sound/fsl,spdif.yaml+4−0

       - fsl,vf610-spdif
       - fsl,imx6sx-spdif
       - fsl,imx8qm-spdif
+      - fsl,imx8qxp-spdif
+      - fsl,imx8mq-spdif
+      - fsl,imx8mm-spdif
+      - fsl,imx8mn-spdif
   reg:
     maxItems: 1

Documentation/gpu/todo.rst+21−0

@@ -613,6 +613,27 @@ Some of these date from the very introduction of KMS in 2008 ... · 612 unmodified lines
613		613
614	Level: Intermediate	614	Level: Intermediate
615		615
		616	Remove automatic page mapping from dma-buf importing
		617	----------------------------------------------------
		618
		619	When importing dma-bufs, the dma-buf and PRIME frameworks automatically map
		620	imported pages into the importer's DMA area. drm_gem_prime_fd_to_handle() and
		621	drm_gem_prime_handle_to_fd() require that importers call dma_buf_attach()
		622	even if they never do actual device DMA, but only CPU access through
		623	dma_buf_vmap(). This is a problem for USB devices, which do not support DMA
		624	operations.
		625
		626	To fix the issue, automatic page mappings should be removed from the
		627	buffer-sharing code. Fixing this is a bit more involved, since the import/export
		628	cache is also tied to &drm_gem_object.import_attach. Meanwhile we paper over
		629	this problem for USB devices by fishing out the USB host controller device, as
		630	long as that supports DMA. Otherwise importing can still needlessly fail.
		631
		632	Contact: Thomas Zimmermann <tzimmermann@suse.de>, Daniel Vetter
		633
		634	Level: Advanced
		635
		636
616	Better Testing	637	Better Testing
617	==============	638	==============
618		639

Documentation/networking/device_drivers/ethernet/amazon/ena.rst+1−1

@@ -267,7 +267,7 @@ DATA PATH · 266 unmodified lines
267	Tx	267	Tx
268	--	268	--
269		269
270	end_start_xmit() is called by the stack. This function does the following:	270	ena_start_xmit() is called by the stack. This function does the following:
271		271
272	- Maps data buffers (skb->data and frags).	272	- Maps data buffers (skb->data and frags).
273	- Populates ena_buf for the push buffer (if the driver and device are	273	- Populates ena_buf for the push buffer (if the driver and device are

Documentation/networking/devlink/devlink-dpipe.rst+1−1

@@ -52,7 +52,7 @@ purposes as a standard complementary tool. The system's view from · 51 unmodified lines
52	``devlink-dpipe`` should change according to the changes done by the	52	``devlink-dpipe`` should change according to the changes done by the
53	standard configuration tools.	53	standard configuration tools.
54		54
55	For example, it’s quiet common to implement Access Control Lists (ACL)	55	For example, it’s quite common to implement Access Control Lists (ACL)
56	using Ternary Content Addressable Memory (TCAM). The TCAM memory can be	56	using Ternary Content Addressable Memory (TCAM). The TCAM memory can be
57	divided into TCAM regions. Complex TC filters can have multiple rules with	57	divided into TCAM regions. Complex TC filters can have multiple rules with
58	different priorities and different lookup keys. On the other hand hardware	58	different priorities and different lookup keys. On the other hand hardware

Documentation/networking/devlink/devlink-port.rst+2−2

@@ -151,7 +151,7 @@ representor netdevice. · 150 unmodified lines
151	-------------	151	-------------
152	A subfunction devlink port is created but it is not active yet. That means the	152	A subfunction devlink port is created but it is not active yet. That means the
153	entities are created on devlink side, the e-switch port representor is created,	153	entities are created on devlink side, the e-switch port representor is created,
154	but the subfunction device itself it not created. A user might use e-switch port	154	but the subfunction device itself is not created. A user might use e-switch port
155	representor to do settings, putting it into bridge, adding TC rules, etc. A user	155	representor to do settings, putting it into bridge, adding TC rules, etc. A user
156	might as well configure the hardware address (such as MAC address) of the	156	might as well configure the hardware address (such as MAC address) of the
157	subfunction while subfunction is inactive.	157	subfunction while subfunction is inactive.
@@ -173,7 +173,7 @@ Terms and Definitions · 15 unmodified lines
173	* - Term	173	* - Term
174	- Definitions	174	- Definitions
175	* - ``PCI device``	175	* - ``PCI device``
176	- A physical PCI device having one or more PCI bus consists of one or	176	- A physical PCI device having one or more PCI buses consists of one or
177	more PCI controllers.	177	more PCI controllers.
178	* - ``PCI controller``	178	* - ``PCI controller``
179	- A controller consists of potentially multiple physical functions,	179	- A controller consists of potentially multiple physical functions,

Documentation/networking/xfrm_device.rst+1−1

@@ -50,7 +50,7 @@ Callbacks to implement · 49 unmodified lines
50		50
51	The NIC driver offering ipsec offload will need to implement these	51	The NIC driver offering ipsec offload will need to implement these
52	callbacks to make the offload available to the network stack's	52	callbacks to make the offload available to the network stack's
53	XFRM subsytem. Additionally, the feature bits NETIF_F_HW_ESP and	53	XFRM subsystem. Additionally, the feature bits NETIF_F_HW_ESP and
54	NETIF_F_HW_ESP_TX_CSUM will signal the availability of the offload.	54	NETIF_F_HW_ESP_TX_CSUM will signal the availability of the offload.
55		55
56		56

Documentation/virt/kvm/api.rst+9−3

 be retrieved using KVM_CAP_ARM_VM_IPA_SIZE of the KVM_CHECK_EXTENSION
 ioctl() at run-time.
+Creation of the VM will fail if the requested IPA size (whether it is
+implicit or explicit) is unsupported on the host.
 Please note that configuring the IPA size does not affect the capability
 exposed by the guest CPUs in ID_AA64MMFR0_EL1[PARange]. It only affects
 size of the address translated by the stage2 level (guest physical to
 Define which vcpu is the Bootstrap Processor (BSP).  Values are the same
 as the vcpu id in KVM_CREATE_VCPU.  If this ioctl is not called, the default
-is vcpu 0.
+is vcpu 0. This ioctl has to be called before vcpu creation,
+otherwise it will return EBUSY error.
 4.42 KVM_GET_XSAVE
 allows user space to deflect and potentially handle various MSR accesses
 into user space.
-If a vCPU is in running state while this ioctl is invoked, the vCPU may
+Note, invoking this ioctl with a vCPU is running is inherently racy.  However,
-experience inconsistent filtering behavior on MSR accesses.
+KVM does guarantee that vCPUs will see either the previous filter or the new
+filter, e.g. MSRs with identical settings in both the old and new filter will
+have deterministic behavior.
 4.127 KVM_XEN_HVM_SET_ATTR
 --------------------------

MAINTAINERS+14−16

 L:	linux-api@vger.kernel.org
 F:	include/linux/syscalls.h
 F:	kernel/sys_ni.c
-F:	include/uapi/
+X:	include/uapi/
-F:	arch/*/include/uapi/
+X:	arch/*/include/uapi/
 ABIT UGURU 1,2 HARDWARE MONITOR DRIVER
 M:	Hans de Goede <hdegoede@redhat.com>
 M:	Christian Brauner <christian@brauner.io>
 M:	Hridya Valsaraju <hridya@google.com>
 M:	Suren Baghdasaryan <surenb@google.com>
-L:	devel@driverdev.osuosl.org
+L:	linux-kernel@vger.kernel.org
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
 F:	drivers/android/
 M:	Daniel Vetter <daniel@ffwll.ch>
 L:	dri-devel@lists.freedesktop.org
 S:	Maintained
-B:	https://bugs.freedesktop.org/
+B:	https://gitlab.freedesktop.org/drm
 C:	irc://chat.freenode.net/dri-devel
 T:	git git://anongit.freedesktop.org/drm/drm
 F:	Documentation/devicetree/bindings/display/
 HISILICON STAGING DRIVERS FOR HIKEY 960/970
 M:	Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
-L:	devel@driverdev.osuosl.org
 S:	Maintained
 F:	drivers/staging/hikey9xx/
 M:	Dany Madden <drt@linux.ibm.com>
 M:	Lijun Pan <ljp@linux.ibm.com>
 M:	Sukadev Bhattiprolu <sukadev@linux.ibm.com>
+R:	Thomas Falcon <tlfalcon@linux.ibm.com>
 L:	netdev@vger.kernel.org
 S:	Supported
 F:	drivers/net/ethernet/ibm/ibmvnic.*
 M:	Mat Martineau <mathew.j.martineau@linux.intel.com>
 M:	Matthieu Baerts <matthieu.baerts@tessares.net>
 L:	netdev@vger.kernel.org
-L:	mptcp@lists.01.org
+L:	mptcp@lists.linux.dev
 S:	Maintained
 W:	https://github.com/multipath-tcp/mptcp_net-next/wiki
 B:	https://github.com/multipath-tcp/mptcp_net-next/issues
 QLOGIC QLGE 10Gb ETHERNET DRIVER
 M:	Manish Chopra <manishc@marvell.com>
 M:	GR-Linux-NIC-Dev@marvell.com
-L:	netdev@vger.kernel.org
-S:	Supported
-F:	drivers/staging/qlge/
-QLOGIC QLGE 10Gb ETHERNET DRIVER
 M:	Coiby Xu <coiby.xu@gmail.com>
 L:	netdev@vger.kernel.org
-S:	Maintained
+S:	Supported
 F:	Documentation/networking/device_drivers/qlogic/qlge.rst
+F:	drivers/staging/qlge/
 QM1D1B0004 MEDIA DRIVER
 M:	Akihiro Tsukada <tskd08@gmail.com>
 SPIDERNET NETWORK DRIVER for CELL
 M:	Ishizaki Kou <kou.ishizaki@toshiba.co.jp>
+M:	Geoff Levand <geoff@infradead.org>
 L:	netdev@vger.kernel.org
-S:	Supported
+L:	linuxppc-dev@lists.ozlabs.org
+S:	Maintained
 F:	Documentation/networking/device_drivers/ethernet/toshiba/spider_net.rst
 F:	drivers/net/ethernet/toshiba/spider_net*
 STAGING SUBSYSTEM
 M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
-L:	devel@driverdev.osuosl.org
+L:	linux-staging@lists.linux.dev
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
 F:	drivers/staging/
 M:	Martyn Welch <martyn@welchs.me.uk>
 M:	Manohar Vanga <manohar.vanga@gmail.com>
 M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
-L:	devel@driverdev.osuosl.org
+L:	linux-kernel@vger.kernel.org
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc.git
 F:	Documentation/driver-api/vme.rst
 F:	drivers/infiniband/hw/vmw_pvrdma/
 VMware PVSCSI driver
-M:	Jim Gill <jgill@vmware.com>
+M:	Vishal Bhakta <vbhakta@vmware.com>
 M:	VMware PV-Drivers <pv-drivers@vmware.com>
 L:	linux-scsi@vger.kernel.org
 S:	Maintained

Makefile+4−2

 VERSION = 5
 PATCHLEVEL = 12
 SUBLEVEL = 0
-EXTRAVERSION = -rc2
+EXTRAVERSION = -rc4
 NAME = Frozen Wasteland
 # *DOCUMENTATION*
 			 $(version_h) headers headers_% archheaders archscripts \
 			 %asm-generic kernelversion %src-pkg dt_binding_check \
 			 outputmakefile
-no-sync-config-targets := $(no-dot-config-targets) %install kernelrelease
+no-sync-config-targets := $(no-dot-config-targets) %install kernelrelease \
+			  image_name
 single-targets := %.a %.i %.ko %.lds %.ll %.lst %.mod %.o %.s %.symtypes %/
 config-build	:=
 		-I$(objtree)/arch/$(SRCARCH)/include/generated/uapi \
 		-I$(srctree)/include/uapi \
 		-I$(objtree)/include/generated/uapi \
+                -include $(srctree)/include/linux/compiler-version.h \
                 -include $(srctree)/include/linux/kconfig.h
 # Use LINUXINCLUDE when you must reference the include/ directory.

arch/Kconfig+1−2

 	def_bool y
 	# Clang >= 11: https://github.com/ClangBuiltLinux/linux/issues/510
 	depends on CC_IS_CLANG && CLANG_VERSION >= 110000 && LD_IS_LLD
-	depends on $(success,test $(LLVM) -eq 1)
 	depends on $(success,test $(LLVM_IAS) -eq 1)
 	depends on $(success,$(NM) --help | head -n 1 | grep -qi llvm)
 	depends on $(success,$(AR) --help | head -n 1 | grep -qi llvm)
 	depends on ARCH_SUPPORTS_LTO_CLANG
 	depends on !FTRACE_MCOUNT_USE_RECORDMCOUNT
-	depends on !KASAN
+	depends on !KASAN || KASAN_HW_TAGS
 	depends on !GCOV_KERNEL
 	help
 	  The compiler and Kconfig options support building with Clang's

arch/arm/Kconfig+1−0

@@ -348,6 +348,7 @@ config ARCH_EP93XX · 347 unmodified lines
348	select ARM_AMBA	348	select ARM_AMBA
349	imply ARM_PATCH_PHYS_VIRT	349	imply ARM_PATCH_PHYS_VIRT
350	select ARM_VIC	350	select ARM_VIC
		351	select GENERIC_IRQ_MULTI_HANDLER
351	select AUTO_ZRELADDR	352	select AUTO_ZRELADDR
352	select CLKDEV_LOOKUP	353	select CLKDEV_LOOKUP
353	select CLKSRC_MMIO	354	select CLKSRC_MMIO

arch/arm/xen/p2m.c+2−3

 #include <xen/xen.h>
 #include <xen/interface/memory.h>
+#include <xen/grant_table.h>
 #include <xen/page.h>
 #include <xen/swiotlb-xen.h>
 		map_ops[i].status = GNTST_general_error;
 		unmap.host_addr = map_ops[i].host_addr,
 		unmap.handle = map_ops[i].handle;
-		map_ops[i].handle = ~0;
+		map_ops[i].handle = INVALID_GRANT_HANDLE;
 		if (map_ops[i].flags & GNTMAP_device_map)
 			unmap.dev_bus_addr = map_ops[i].dev_bus_addr;
 		else
 	return 0;
 }
-EXPORT_SYMBOL_GPL(set_foreign_p2m_mapping);
 int clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops,
 			      struct gnttab_unmap_grant_ref *kunmap_ops,
 	return 0;
 }
-EXPORT_SYMBOL_GPL(clear_foreign_p2m_mapping);
 bool __set_phys_to_machine_multi(unsigned long pfn,
 		unsigned long mfn, unsigned long nr_pages)

arch/arm64/Kconfig+12−10

 	  If unsure, say Y.
+config NVIDIA_CARMEL_CNP_ERRATUM
+	bool "NVIDIA Carmel CNP: CNP on Carmel semantically different than ARM cores"
+	default y
+	help
+	  If CNP is enabled on Carmel cores, non-sharable TLBIs on a core will not
+	  invalidate shared TLB entries installed by a different core, as it would
+	  on standard ARM cores.
+	  If unsure, say Y.
 config SOCIONEXT_SYNQUACER_PREITS
 	bool "Socionext Synquacer: Workaround for GICv3 pre-ITS"
 	default y
 config SYS_SUPPORTS_HUGETLBFS
 	def_bool y
-config ARCH_WANT_HUGE_PMD_SHARE
 config ARCH_HAS_CACHE_LINE_SIZE
 	def_bool y
 config FORCE_MAX_ZONEORDER
 	int
-	default "14" if (ARM64_64K_PAGES && TRANSPARENT_HUGEPAGE)
+	default "14" if ARM64_64K_PAGES
-	default "12" if (ARM64_16K_PAGES && TRANSPARENT_HUGEPAGE)
+	default "12" if ARM64_16K_PAGES
 	default "11"
 	help
 	  The kernel memory allocator divides physically contiguous memory
 	  the boot loader doesn't provide any, the default kernel command
 	  string provided in CMDLINE will be used.
-config CMDLINE_EXTEND
-	bool "Extend bootloader kernel arguments"
-	help
-	  The command-line arguments provided by the boot loader will be
-	  appended to the default kernel command string.
 config CMDLINE_FORCE
 	bool "Always use the default kernel command string"
 	help

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

@@ -37,7 +37,7 @@ static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl) · 36 unmodified lines
37	} while (--n > 0);	37	} while (--n > 0);
38		38
39	sum += ((sum >> 32) \| (sum << 32));	39	sum += ((sum >> 32) \| (sum << 32));
40	return csum_fold((__force u32)(sum >> 32));	40	return csum_fold((__force __wsum)(sum >> 32));
41	}	41	}
42	#define ip_fast_csum ip_fast_csum	42	#define ip_fast_csum ip_fast_csum
43		43

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

@@ -66,7 +66,8 @@ · 65 unmodified lines
66	#define ARM64_WORKAROUND_1508412 58	66	#define ARM64_WORKAROUND_1508412 58
67	#define ARM64_HAS_LDAPR 59	67	#define ARM64_HAS_LDAPR 59
68	#define ARM64_KVM_PROTECTED_MODE 60	68	#define ARM64_KVM_PROTECTED_MODE 60
		69	#define ARM64_WORKAROUND_NVIDIA_CARMEL_CNP 61
69		70
70	#define ARM64_NCAPS 61	71	#define ARM64_NCAPS 62
71		72
72	#endif /* __ASM_CPUCAPS_H */	73	#endif /* __ASM_CPUCAPS_H */

arch/arm64/include/asm/kvm_asm.h+4−4

 #define __KVM_HOST_SMCCC_FUNC___kvm_flush_vm_context		2
 #define __KVM_HOST_SMCCC_FUNC___kvm_tlb_flush_vmid_ipa		3
 #define __KVM_HOST_SMCCC_FUNC___kvm_tlb_flush_vmid		4
-#define __KVM_HOST_SMCCC_FUNC___kvm_tlb_flush_local_vmid	5
+#define __KVM_HOST_SMCCC_FUNC___kvm_flush_cpu_context		5
 #define __KVM_HOST_SMCCC_FUNC___kvm_timer_set_cntvoff		6
 #define __KVM_HOST_SMCCC_FUNC___kvm_enable_ssbs			7
-#define __KVM_HOST_SMCCC_FUNC___vgic_v3_get_ich_vtr_el2		8
+#define __KVM_HOST_SMCCC_FUNC___vgic_v3_get_gic_config		8
 #define __KVM_HOST_SMCCC_FUNC___vgic_v3_read_vmcr		9
 #define __KVM_HOST_SMCCC_FUNC___vgic_v3_write_vmcr		10
 #define __KVM_HOST_SMCCC_FUNC___vgic_v3_init_lrs		11
 #define __bp_harden_hyp_vecs	CHOOSE_HYP_SYM(__bp_harden_hyp_vecs)
 extern void __kvm_flush_vm_context(void);
+extern void __kvm_flush_cpu_context(struct kvm_s2_mmu *mmu);
 extern void __kvm_tlb_flush_vmid_ipa(struct kvm_s2_mmu *mmu, phys_addr_t ipa,
 				     int level);
 extern void __kvm_tlb_flush_vmid(struct kvm_s2_mmu *mmu);
-extern void __kvm_tlb_flush_local_vmid(struct kvm_s2_mmu *mmu);
 extern void __kvm_timer_set_cntvoff(u64 cntvoff);
 extern int __kvm_vcpu_run(struct kvm_vcpu *vcpu);
-extern u64 __vgic_v3_get_ich_vtr_el2(void);
+extern u64 __vgic_v3_get_gic_config(void);
 extern u64 __vgic_v3_read_vmcr(void);
 extern void __vgic_v3_write_vmcr(u32 vmcr);
 extern void __vgic_v3_init_lrs(void);

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

 void __debug_switch_to_guest(struct kvm_vcpu *vcpu);
 void __debug_switch_to_host(struct kvm_vcpu *vcpu);
+#ifdef __KVM_NVHE_HYPERVISOR__
+void __debug_save_host_buffers_nvhe(struct kvm_vcpu *vcpu);
+void __debug_restore_host_buffers_nvhe(struct kvm_vcpu *vcpu);
+#endif
 void __fpsimd_save_state(struct user_fpsimd_state *fp_regs);
 void __fpsimd_restore_state(struct user_fpsimd_state *fp_regs);
 void __noreturn hyp_panic(void);
 #ifdef __KVM_NVHE_HYPERVISOR__
-void __noreturn __hyp_do_panic(bool restore_host, u64 spsr, u64 elr, u64 par);
+void __noreturn __hyp_do_panic(struct kvm_cpu_context *host_ctxt, u64 spsr,
+			       u64 elr, u64 par);
 #endif
 #endif /* __ARM64_KVM_HYP_H__ */

arch/arm64/include/asm/memory.h+5−0

 #define ARCH_PFN_OFFSET		((unsigned long)PHYS_PFN_OFFSET)
 #if !defined(CONFIG_SPARSEMEM_VMEMMAP) || defined(CONFIG_DEBUG_VIRTUAL)
+#define page_to_virt(x)	({						\
+	__typeof__(x) __page = x;					\
+	void *__addr = __va(page_to_phys(__page));			\
+	(void *)__tag_set((const void *)__addr, page_kasan_tag(__page));\
+})
 #define virt_to_page(x)		pfn_to_page(virt_to_pfn(x))
 #else
 #define page_to_virt(x)	({						\

arch/arm64/include/asm/mmu_context.h+0−17

@@ -63,23 +63,6 @@ static inline void cpu_switch_mm(pgd_t pgd, struct mm_struct mm) · 62 unmodified lines
63	extern u64 idmap_t0sz;	63	extern u64 idmap_t0sz;
64	extern u64 idmap_ptrs_per_pgd;	64	extern u64 idmap_ptrs_per_pgd;
65		65
66	static inline bool __cpu_uses_extended_idmap(void)
67	{
68	if (IS_ENABLED(CONFIG_ARM64_VA_BITS_52))
69	return false;
70
71	return unlikely(idmap_t0sz != TCR_T0SZ(VA_BITS));
72	}
73
74	/*
75	* True if the extended ID map requires an extra level of translation table
76	* to be configured.
77	*/
78	static inline bool __cpu_uses_extended_idmap_level(void)
79	{
80	return ARM64_HW_PGTABLE_LEVELS(64 - idmap_t0sz) > CONFIG_PGTABLE_LEVELS;
81	}
82
83	/*	66	/*
84	* Ensure TCR.T0SZ is set to the provided value.	67	* Ensure TCR.T0SZ is set to the provided value.
85	*/	68	*/

arch/arm64/include/asm/pgtable-prot.h+0−1

@@ -66,7 +66,6 @@ extern bool arm64_use_ng_mappings; · 65 unmodified lines
66	#define _PAGE_DEFAULT (_PROT_DEFAULT \| PTE_ATTRINDX(MT_NORMAL))	66	#define _PAGE_DEFAULT (_PROT_DEFAULT \| PTE_ATTRINDX(MT_NORMAL))
67		67
68	#define PAGE_KERNEL __pgprot(PROT_NORMAL)	68	#define PAGE_KERNEL __pgprot(PROT_NORMAL)
69	#define PAGE_KERNEL_TAGGED __pgprot(PROT_NORMAL_TAGGED)
70	#define PAGE_KERNEL_RO __pgprot((PROT_NORMAL & ~PTE_WRITE) \| PTE_RDONLY)	69	#define PAGE_KERNEL_RO __pgprot((PROT_NORMAL & ~PTE_WRITE) \| PTE_RDONLY)
71	#define PAGE_KERNEL_ROX __pgprot((PROT_NORMAL & ~(PTE_WRITE \| PTE_PXN)) \| PTE_RDONLY)	70	#define PAGE_KERNEL_ROX __pgprot((PROT_NORMAL & ~(PTE_WRITE \| PTE_PXN)) \| PTE_RDONLY)
72	#define PAGE_KERNEL_EXEC __pgprot(PROT_NORMAL & ~PTE_PXN)	71	#define PAGE_KERNEL_EXEC __pgprot(PROT_NORMAL & ~PTE_PXN)

arch/arm64/include/asm/pgtable.h+3−0

 	__pgprot_modify(prot, PTE_ATTRINDX_MASK, PTE_ATTRINDX(MT_NORMAL_NC) | PTE_PXN | PTE_UXN)
 #define pgprot_device(prot) \
 	__pgprot_modify(prot, PTE_ATTRINDX_MASK, PTE_ATTRINDX(MT_DEVICE_nGnRE) | PTE_PXN | PTE_UXN)
+#define pgprot_tagged(prot) \
+	__pgprot_modify(prot, PTE_ATTRINDX_MASK, PTE_ATTRINDX(MT_NORMAL_TAGGED))
+#define pgprot_mhp	pgprot_tagged
 /*
  * DMA allocations for non-coherent devices use what the Arm architecture calls
  * "Normal non-cacheable" memory, which permits speculation, unaligned accesses

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

@@ -251,6 +251,8 @@ unsigned long get_wchan(struct task_struct *p); · 250 unmodified lines
251	extern struct task_struct cpu_switch_to(struct task_struct prev,	251	extern struct task_struct cpu_switch_to(struct task_struct prev,
252	struct task_struct *next);	252	struct task_struct *next);
253		253
		254	asmlinkage void arm64_preempt_schedule_irq(void);
		255
254	#define task_pt_regs(p) \	256	#define task_pt_regs(p) \
255	((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)	257	((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)
256		258

arch/arm64/include/asm/sysreg.h+14−6

 #define ID_AA64MMFR0_PARANGE_48		0x5
 #define ID_AA64MMFR0_PARANGE_52		0x6
+#define ID_AA64MMFR0_TGRAN_2_SUPPORTED_DEFAULT	0x0
+#define ID_AA64MMFR0_TGRAN_2_SUPPORTED_NONE	0x1
+#define ID_AA64MMFR0_TGRAN_2_SUPPORTED_MIN	0x2
+#define ID_AA64MMFR0_TGRAN_2_SUPPORTED_MAX	0x7
 #ifdef CONFIG_ARM64_PA_BITS_52
 #define ID_AA64MMFR0_PARANGE_MAX	ID_AA64MMFR0_PARANGE_52
 #else
 #define ID_PFR1_PROGMOD_SHIFT		0
 #if defined(CONFIG_ARM64_4K_PAGES)
-#define ID_AA64MMFR0_TGRAN_SHIFT	ID_AA64MMFR0_TGRAN4_SHIFT
+#define ID_AA64MMFR0_TGRAN_SHIFT		ID_AA64MMFR0_TGRAN4_SHIFT
-#define ID_AA64MMFR0_TGRAN_SUPPORTED	ID_AA64MMFR0_TGRAN4_SUPPORTED
+#define ID_AA64MMFR0_TGRAN_SUPPORTED_MIN	ID_AA64MMFR0_TGRAN4_SUPPORTED
+#define ID_AA64MMFR0_TGRAN_SUPPORTED_MAX	0x7
 #elif defined(CONFIG_ARM64_16K_PAGES)
-#define ID_AA64MMFR0_TGRAN_SHIFT	ID_AA64MMFR0_TGRAN16_SHIFT
+#define ID_AA64MMFR0_TGRAN_SHIFT		ID_AA64MMFR0_TGRAN16_SHIFT
-#define ID_AA64MMFR0_TGRAN_SUPPORTED	ID_AA64MMFR0_TGRAN16_SUPPORTED
+#define ID_AA64MMFR0_TGRAN_SUPPORTED_MIN	ID_AA64MMFR0_TGRAN16_SUPPORTED
+#define ID_AA64MMFR0_TGRAN_SUPPORTED_MAX	0xF
 #elif defined(CONFIG_ARM64_64K_PAGES)
-#define ID_AA64MMFR0_TGRAN_SHIFT	ID_AA64MMFR0_TGRAN64_SHIFT
+#define ID_AA64MMFR0_TGRAN_SHIFT		ID_AA64MMFR0_TGRAN64_SHIFT
-#define ID_AA64MMFR0_TGRAN_SUPPORTED	ID_AA64MMFR0_TGRAN64_SUPPORTED
+#define ID_AA64MMFR0_TGRAN_SUPPORTED_MIN	ID_AA64MMFR0_TGRAN64_SUPPORTED
+#define ID_AA64MMFR0_TGRAN_SUPPORTED_MAX	0x7
 #endif
 #define MVFR2_FPMISC_SHIFT		4

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

@@ -55,6 +55,8 @@ void arch_setup_new_exec(void); · 54 unmodified lines
55	#define arch_setup_new_exec arch_setup_new_exec	55	#define arch_setup_new_exec arch_setup_new_exec
56		56
57	void arch_release_task_struct(struct task_struct *tsk);	57	void arch_release_task_struct(struct task_struct *tsk);
		58	int arch_dup_task_struct(struct task_struct *dst,
		59	struct task_struct *src);
58		60
59	#endif	61	#endif
60		62

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

@@ -525,6 +525,14 @@ const struct arm64_cpu_capabilities arm64_errata[] = { · 524 unmodified lines
525	0, 0,	525	0, 0,
526	1, 0),	526	1, 0),
527	},	527	},
		528	#endif
		529	#ifdef CONFIG_NVIDIA_CARMEL_CNP_ERRATUM
		530	{
		531	/* NVIDIA Carmel */
		532	.desc = "NVIDIA Carmel CNP erratum",
		533	.capability = ARM64_WORKAROUND_NVIDIA_CARMEL_CNP,
		534	ERRATA_MIDR_ALL_VERSIONS(MIDR_NVIDIA_CARMEL),
		535	},
528	#endif	536	#endif
529	{	537	{
530	}	538	}

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

 	 * may share TLB entries with a CPU stuck in the crashed
 	 * kernel.
 	 */
-	 if (is_kdump_kernel())
+	if (is_kdump_kernel())
+		return false;
+	if (cpus_have_const_cap(ARM64_WORKAROUND_NVIDIA_CARMEL_CNP))
 		return false;
 	return has_cpuid_feature(entry, scope);

arch/arm64/kernel/cpuinfo.c+1−1

@@ -353,7 +353,7 @@ static void __cpuinfo_store_cpu(struct cpuinfo_arm64 *info) · 352 unmodified lines
353	* with the CLIDR_EL1 fields to avoid triggering false warnings	353	* with the CLIDR_EL1 fields to avoid triggering false warnings
354	* when there is a mismatch across the CPUs. Keep track of the	354	* when there is a mismatch across the CPUs. Keep track of the
355	* effective value of the CTR_EL0 in our internal records for	355	* effective value of the CTR_EL0 in our internal records for
356	* acurate sanity check and feature enablement.	356	* accurate sanity check and feature enablement.
357	*/	357	*/
358	info->reg_ctr = read_cpuid_effective_cachetype();	358	info->reg_ctr = read_cpuid_effective_cachetype();
359	info->reg_dczid = read_cpuid(DCZID_EL0);	359	info->reg_dczid = read_cpuid(DCZID_EL0);

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

@@ -64,5 +64,7 @@ ssize_t copy_oldmem_page(unsigned long pfn, char *buf, · 63 unmodified lines
64	ssize_t elfcorehdr_read(char buf, size_t count, u64 ppos)	64	ssize_t elfcorehdr_read(char buf, size_t count, u64 ppos)
65	{	65	{
66	memcpy(buf, phys_to_virt((phys_addr_t)*ppos), count);	66	memcpy(buf, phys_to_virt((phys_addr_t)*ppos), count);
		67	*ppos += count;
		68
67	return count;	69	return count;
68	}	70	}

arch/arm64/kernel/head.S+5−3

 	 */
 	adrp	x5, __idmap_text_end
 	clz	x5, x5
-	cmp	x5, TCR_T0SZ(VA_BITS)	// default T0SZ small enough?
+	cmp	x5, TCR_T0SZ(VA_BITS_MIN) // default T0SZ small enough?
 	b.ge	1f			// .. then skip VA range extension
 	adr_l	x6, idmap_t0sz
 SYM_FUNC_START(__enable_mmu)
 	mrs	x2, ID_AA64MMFR0_EL1
 	ubfx	x2, x2, #ID_AA64MMFR0_TGRAN_SHIFT, 4
-	cmp	x2, #ID_AA64MMFR0_TGRAN_SUPPORTED
+	cmp     x2, #ID_AA64MMFR0_TGRAN_SUPPORTED_MIN
-	b.ne	__no_granule_support
+	b.lt    __no_granule_support
+	cmp     x2, #ID_AA64MMFR0_TGRAN_SUPPORTED_MAX
+	b.gt    __no_granule_support
 	update_early_cpu_boot_status 0, x2, x3
 	adrp	x2, idmap_pg_dir
 	phys_to_ttbr x1, x1

arch/arm64/kernel/idreg-override.c+23−20

@@ -163,33 +163,36 @@ static __init void __parse_cmdline(const char *cmdline, bool parse_aliases) · 162 unmodified lines
163	} while (1);	163	} while (1);
164	}	164	}
165		165
166	static __init void parse_cmdline(void)	166	static __init const u8 *get_bootargs_cmdline(void)
167	{	167	{
168	if (!IS_ENABLED(CONFIG_CMDLINE_FORCE)) {	168	const u8 *prop;
169	const u8 *prop;	169	void *fdt;
170	void *fdt;	170	int node;
171	int node;
172		171
173	fdt = get_early_fdt_ptr();	172	fdt = get_early_fdt_ptr();
174	if (!fdt)	173	if (!fdt)
175	goto out;	174	return NULL;
176		175
177	node = fdt_path_offset(fdt, "/chosen");	176	node = fdt_path_offset(fdt, "/chosen");
178	if (node < 0)	177	if (node < 0)
179	goto out;	178	return NULL;
180		179
181	prop = fdt_getprop(fdt, node, "bootargs", NULL);	180	prop = fdt_getprop(fdt, node, "bootargs", NULL);
182	if (!prop)	181	if (!prop)
183	goto out;	182	return NULL;
184		183
185	__parse_cmdline(prop, true);	184	return strlen(prop) ? prop : NULL;
		185	}
186		186
187	if (!IS_ENABLED(CONFIG_CMDLINE_EXTEND))	187	static __init void parse_cmdline(void)
188	return;	188	{
189	}	189	const u8 *prop = get_bootargs_cmdline();
190		190
191	out:	191	if (IS_ENABLED(CONFIG_CMDLINE_FORCE) \|\| !prop)
192	__parse_cmdline(CONFIG_CMDLINE, true);	192	__parse_cmdline(CONFIG_CMDLINE, true);
		193
		194	if (!IS_ENABLED(CONFIG_CMDLINE_FORCE) && prop)
		195	__parse_cmdline(prop, true);
193	}	196	}
194		197
195	/* Keep checkers quiet */	198	/* Keep checkers quiet */

arch/arm64/kernel/image-vars.h+3−0

@@ -101,6 +101,9 @@ KVM_NVHE_ALIAS(__stop___kvm_ex_table); · 100 unmodified lines
101	/* Array containing bases of nVHE per-CPU memory regions. */	101	/* Array containing bases of nVHE per-CPU memory regions. */
102	KVM_NVHE_ALIAS(kvm_arm_hyp_percpu_base);	102	KVM_NVHE_ALIAS(kvm_arm_hyp_percpu_base);
103		103
		104	/* PMU available static key */
		105	KVM_NVHE_ALIAS(kvm_arm_pmu_available);
		106
104	#endif /* CONFIG_KVM */	107	#endif /* CONFIG_KVM */
105		108
106	#endif /* __ARM64_KERNEL_IMAGE_VARS_H */	109	#endif /* __ARM64_KERNEL_IMAGE_VARS_H */

arch/arm64/kernel/perf_event.c+1−1

@@ -460,7 +460,7 @@ static inline int armv8pmu_counter_has_overflowed(u32 pmnc, int idx) · 459 unmodified lines
460	return pmnc & BIT(ARMV8_IDX_TO_COUNTER(idx));	460	return pmnc & BIT(ARMV8_IDX_TO_COUNTER(idx));
461	}	461	}
462		462
463	static inline u32 armv8pmu_read_evcntr(int idx)	463	static inline u64 armv8pmu_read_evcntr(int idx)
464	{	464	{
465	u32 counter = ARMV8_IDX_TO_COUNTER(idx);	465	u32 counter = ARMV8_IDX_TO_COUNTER(idx);
466		466

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

@@ -57,6 +57,8 @@ · 56 unmodified lines
57	#include <asm/processor.h>	57	#include <asm/processor.h>
58	#include <asm/pointer_auth.h>	58	#include <asm/pointer_auth.h>
59	#include <asm/stacktrace.h>	59	#include <asm/stacktrace.h>
		60	#include <asm/switch_to.h>
		61	#include <asm/system_misc.h>
60		62
61	#if defined(CONFIG_STACKPROTECTOR) && !defined(CONFIG_STACKPROTECTOR_PER_TASK)	63	#if defined(CONFIG_STACKPROTECTOR) && !defined(CONFIG_STACKPROTECTOR_PER_TASK)
62	#include <linux/stackprotector.h>	64	#include <linux/stackprotector.h>

arch/arm64/kernel/stacktrace.c+5−4

 #ifdef CONFIG_STACKTRACE
-void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,
+noinline void arch_stack_walk(stack_trace_consume_fn consume_entry,
-		     struct task_struct *task, struct pt_regs *regs)
+			      void *cookie, struct task_struct *task,
+			      struct pt_regs *regs)
 {
 	struct stackframe frame;
 		start_backtrace(&frame, regs->regs[29], regs->pc);
 	else if (task == current)
 		start_backtrace(&frame,
-				(unsigned long)__builtin_frame_address(0),
+				(unsigned long)__builtin_frame_address(1),
-				(unsigned long)arch_stack_walk);
+				(unsigned long)__builtin_return_address(0));
 	else
 		start_backtrace(&frame, thread_saved_fp(task),
 				thread_saved_pc(task));

arch/arm64/kvm/arm.c+6−1

 	last_ran = this_cpu_ptr(mmu->last_vcpu_ran);
 	/*
+	 * We guarantee that both TLBs and I-cache are private to each
+	 * vcpu. If detecting that a vcpu from the same VM has
+	 * previously run on the same physical CPU, call into the
+	 * hypervisor code to nuke the relevant contexts.
+	 *
 	 * We might get preempted before the vCPU actually runs, but
 	 * over-invalidation doesn't affect correctness.
 	 */
 	if (*last_ran != vcpu->vcpu_id) {
-		kvm_call_hyp(__kvm_tlb_flush_local_vmid, mmu);
+		kvm_call_hyp(__kvm_flush_cpu_context, mmu);
 		*last_ran = vcpu->vcpu_id;
 	}

arch/arm64/kvm/hyp/entry.S+5−3

 	// If the hyp context is loaded, go straight to hyp_panic
 	get_loaded_vcpu x0, x1
-	cbz	x0, hyp_panic
+	cbnz	x0, 1f
+	b	hyp_panic
+1:
 	// The hyp context is saved so make sure it is restored to allow
 	// hyp_panic to run at hyp and, subsequently, panic to run in the host.
 	// This makes use of __guest_exit to avoid duplication but sets the
 	// current state is saved to the guest context but it will only be
 	// accurate if the guest had been completely restored.
 	adr_this_cpu x0, kvm_hyp_ctxt, x1
-	adr	x1, hyp_panic
+	adr_l	x1, hyp_panic
 	str	x1, [x0, #CPU_XREG_OFFSET(30)]
 	get_vcpu_ptr	x1, x0
 	// Now restore the hyp regs
 	restore_callee_saved_regs x2
-	set_loaded_vcpu xzr, x1, x2
+	set_loaded_vcpu xzr, x2, x3
 alternative_if ARM64_HAS_RAS_EXTN
 	// If we have the RAS extensions we can consume a pending error

arch/arm64/kvm/hyp/include/hyp/switch.h+6−3

 	 * counter, which could make a PMXEVCNTR_EL0 access UNDEF at
 	 * EL1 instead of being trapped to EL2.
 	 */
-	write_sysreg(0, pmselr_el0);
+	if (kvm_arm_support_pmu_v3()) {
-	write_sysreg(ARMV8_PMU_USERENR_MASK, pmuserenr_el0);
+		write_sysreg(0, pmselr_el0);
+		write_sysreg(ARMV8_PMU_USERENR_MASK, pmuserenr_el0);
+	}
 	write_sysreg(vcpu->arch.mdcr_el2, mdcr_el2);
 }
 static inline void __deactivate_traps_common(void)
 {
 	write_sysreg(0, hstr_el2);
-	write_sysreg(0, pmuserenr_el0);
+	if (kvm_arm_support_pmu_v3())
+		write_sysreg(0, pmuserenr_el0);
 }
 static inline void ___activate_traps(struct kvm_vcpu *vcpu)

arch/arm64/kvm/hyp/nvhe/debug-sr.c+10−2

 	write_sysreg_s(pmscr_el1, SYS_PMSCR_EL1);
 }
-void __debug_switch_to_guest(struct kvm_vcpu *vcpu)
+void __debug_save_host_buffers_nvhe(struct kvm_vcpu *vcpu)
 {
 	/* Disable and flush SPE data generation */
 	__debug_save_spe(&vcpu->arch.host_debug_state.pmscr_el1);
+}
+void __debug_switch_to_guest(struct kvm_vcpu *vcpu)
+{
 	__debug_switch_to_guest_common(vcpu);
 }
-void __debug_switch_to_host(struct kvm_vcpu *vcpu)
+void __debug_restore_host_buffers_nvhe(struct kvm_vcpu *vcpu)
 {
 	__debug_restore_spe(vcpu->arch.host_debug_state.pmscr_el1);
+}
+void __debug_switch_to_host(struct kvm_vcpu *vcpu)
+{
 	__debug_switch_to_host_common(vcpu);
 }

arch/arm64/kvm/hyp/nvhe/host.S+8−7

@@ -71,7 +71,8 @@ SYM_FUNC_START(__host_enter) · 70 unmodified lines
71	SYM_FUNC_END(__host_enter)	71	SYM_FUNC_END(__host_enter)
72		72
73	/*	73	/*
74	* void __noreturn __hyp_do_panic(bool restore_host, u64 spsr, u64 elr, u64 par);	74	* void __noreturn __hyp_do_panic(struct kvm_cpu_context *host_ctxt, u64 spsr,
		75	* u64 elr, u64 par);
75	*/	76	*/
76	SYM_FUNC_START(__hyp_do_panic)	77	SYM_FUNC_START(__hyp_do_panic)
77	/* Prepare and exit to the host's panic funciton. */	78	/* Prepare and exit to the host's panic funciton. */
@@ -82,9 +83,11 @@ SYM_FUNC_START(__hyp_do_panic) · 4 unmodified lines
82	hyp_kimg_va lr, x6	83	hyp_kimg_va lr, x6
83	msr elr_el2, lr	84	msr elr_el2, lr
84		85
85	/* Set the panic format string. Use the, now free, LR as scratch. */	86	mov x29, x0
86	ldr lr, =__hyp_panic_string	87
87	hyp_kimg_va lr, x6	88	/* Load the format string into x0 and arguments into x1-7 */
		89	ldr x0, =__hyp_panic_string
		90	hyp_kimg_va x0, x6
88		91
89	/* Load the format arguments into x1-7. */	92	/* Load the format arguments into x1-7. */
90	mov x6, x3	93	mov x6, x3
@@ -94,9 +97,7 @@ SYM_FUNC_START(__hyp_do_panic) · 3 unmodified lines
94	mrs x5, hpfar_el2	97	mrs x5, hpfar_el2
95		98
96	/* Enter the host, conditionally restoring the host context. */	99	/* Enter the host, conditionally restoring the host context. */
97	cmp x0, xzr	100	cbz x29, __host_enter_without_restoring
98	mov x0, lr
99	b.eq __host_enter_without_restoring
100	b __host_enter_for_panic	101	b __host_enter_for_panic
101	SYM_FUNC_END(__hyp_do_panic)	102	SYM_FUNC_END(__hyp_do_panic)
102		103

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

@@ -46,11 +46,11 @@ static void handle___kvm_tlb_flush_vmid(struct kvm_cpu_context *host_ctxt) · 45 unmodified lines
46	__kvm_tlb_flush_vmid(kern_hyp_va(mmu));	46	__kvm_tlb_flush_vmid(kern_hyp_va(mmu));
47	}	47	}
48		48
49	static void handle___kvm_tlb_flush_local_vmid(struct kvm_cpu_context *host_ctxt)	49	static void handle___kvm_flush_cpu_context(struct kvm_cpu_context *host_ctxt)
50	{	50	{
51	DECLARE_REG(struct kvm_s2_mmu *, mmu, host_ctxt, 1);	51	DECLARE_REG(struct kvm_s2_mmu *, mmu, host_ctxt, 1);
52		52
53	__kvm_tlb_flush_local_vmid(kern_hyp_va(mmu));	53	__kvm_flush_cpu_context(kern_hyp_va(mmu));
54	}	54	}
55		55
56	static void handle___kvm_timer_set_cntvoff(struct kvm_cpu_context *host_ctxt)	56	static void handle___kvm_timer_set_cntvoff(struct kvm_cpu_context *host_ctxt)
@@ -67,9 +67,9 @@ static void handle___kvm_enable_ssbs(struct kvm_cpu_context *host_ctxt) · 10 unmodified lines
67	write_sysreg_el2(tmp, SYS_SCTLR);	67	write_sysreg_el2(tmp, SYS_SCTLR);
68	}	68	}
69		69
70	static void handle___vgic_v3_get_ich_vtr_el2(struct kvm_cpu_context *host_ctxt)	70	static void handle___vgic_v3_get_gic_config(struct kvm_cpu_context *host_ctxt)
71	{	71	{
72	cpu_reg(host_ctxt, 1) = __vgic_v3_get_ich_vtr_el2();	72	cpu_reg(host_ctxt, 1) = __vgic_v3_get_gic_config();
73	}	73	}
74		74
75	static void handle___vgic_v3_read_vmcr(struct kvm_cpu_context *host_ctxt)	75	static void handle___vgic_v3_read_vmcr(struct kvm_cpu_context *host_ctxt)
@@ -115,10 +115,10 @@ static const hcall_t host_hcall[] = { · 39 unmodified lines
115	HANDLE_FUNC(__kvm_flush_vm_context),	115	HANDLE_FUNC(__kvm_flush_vm_context),
116	HANDLE_FUNC(__kvm_tlb_flush_vmid_ipa),	116	HANDLE_FUNC(__kvm_tlb_flush_vmid_ipa),
117	HANDLE_FUNC(__kvm_tlb_flush_vmid),	117	HANDLE_FUNC(__kvm_tlb_flush_vmid),
118	HANDLE_FUNC(__kvm_tlb_flush_local_vmid),	118	HANDLE_FUNC(__kvm_flush_cpu_context),
119	HANDLE_FUNC(__kvm_timer_set_cntvoff),	119	HANDLE_FUNC(__kvm_timer_set_cntvoff),
120	HANDLE_FUNC(__kvm_enable_ssbs),	120	HANDLE_FUNC(__kvm_enable_ssbs),
121	HANDLE_FUNC(__vgic_v3_get_ich_vtr_el2),	121	HANDLE_FUNC(__vgic_v3_get_gic_config),
122	HANDLE_FUNC(__vgic_v3_read_vmcr),	122	HANDLE_FUNC(__vgic_v3_read_vmcr),
123	HANDLE_FUNC(__vgic_v3_write_vmcr),	123	HANDLE_FUNC(__vgic_v3_write_vmcr),
124	HANDLE_FUNC(__vgic_v3_init_lrs),	124	HANDLE_FUNC(__vgic_v3_init_lrs),

arch/arm64/kvm/hyp/nvhe/switch.c+11−3

 	pmu_switch_needed = __pmu_switch_to_guest(host_ctxt);
 	__sysreg_save_state_nvhe(host_ctxt);
+	/*
+	 * We must flush and disable the SPE buffer for nVHE, as
+	 * the translation regime(EL1&0) is going to be loaded with
+	 * that of the guest. And we must do this before we change the
+	 * translation regime to EL2 (via MDCR_EL2_E2PB == 0) and
+	 * before we load guest Stage1.
+	 */
+	__debug_save_host_buffers_nvhe(vcpu);
 	__adjust_pc(vcpu);
 	if (vcpu->arch.flags & KVM_ARM64_FP_ENABLED)
 		__fpsimd_save_fpexc32(vcpu);
+	__debug_switch_to_host(vcpu);
 	/*
 	 * This must come after restoring the host sysregs, since a non-VHE
 	 * system may enable SPE here and make use of the TTBRs.
 	 */
-	__debug_switch_to_host(vcpu);
+	__debug_restore_host_buffers_nvhe(vcpu);
 	if (pmu_switch_needed)
 		__pmu_switch_to_host(host_ctxt);
 	u64 spsr = read_sysreg_el2(SYS_SPSR);
 	u64 elr = read_sysreg_el2(SYS_ELR);
 	u64 par = read_sysreg_par();
-	bool restore_host = true;
 	struct kvm_cpu_context *host_ctxt;
 	struct kvm_vcpu *vcpu;
 		__sysreg_restore_state_nvhe(host_ctxt);
 	}
-	__hyp_do_panic(restore_host, spsr, elr, par);
+	__hyp_do_panic(host_ctxt, spsr, elr, par);
 	unreachable();
 }

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

 	__tlb_switch_to_host(&cxt);
 }
-void __kvm_tlb_flush_local_vmid(struct kvm_s2_mmu *mmu)
+void __kvm_flush_cpu_context(struct kvm_s2_mmu *mmu)
 {
 	struct tlb_inv_context cxt;
 	__tlb_switch_to_guest(mmu, &cxt);
 	__tlbi(vmalle1);
+	asm volatile("ic iallu");
 	dsb(nsh);
 	isb();

arch/arm64/kvm/hyp/pgtable.c+1−0

@@ -223,6 +223,7 @@ static inline int __kvm_pgtable_visit(struct kvm_pgtable_walk_data *data, · 222 unmodified lines
223	goto out;	223	goto out;
224		224
225	if (!table) {	225	if (!table) {
		226	data->addr = ALIGN_DOWN(data->addr, kvm_granule_size(level));
226	data->addr += kvm_granule_size(level);	227	data->addr += kvm_granule_size(level);
227	goto out;	228	goto out;
228	}	229	}

arch/arm64/kvm/hyp/vgic-v3-sr.c+38−2

@@ -405,9 +405,45 @@ void __vgic_v3_init_lrs(void) · 404 unmodified lines
405	__gic_v3_set_lr(0, i);	405	__gic_v3_set_lr(0, i);
406	}	406	}
407		407
408	u64 __vgic_v3_get_ich_vtr_el2(void)	408	/*
		409	* Return the GIC CPU configuration:
		410	* - [31:0] ICH_VTR_EL2
		411	* - [62:32] RES0
		412	* - [63] MMIO (GICv2) capable
		413	*/
		414	u64 __vgic_v3_get_gic_config(void)
409	{	415	{
410	return read_gicreg(ICH_VTR_EL2);	416	u64 val, sre = read_gicreg(ICC_SRE_EL1);
		417	unsigned long flags = 0;
		418
		419	/*
		420	* To check whether we have a MMIO-based (GICv2 compatible)
		421	* CPU interface, we need to disable the system register
		422	* view. To do that safely, we have to prevent any interrupt
		423	* from firing (which would be deadly).
		424	*
		425	* Note that this only makes sense on VHE, as interrupts are
		426	* already masked for nVHE as part of the exception entry to
		427	* EL2.
		428	*/
		429	if (has_vhe())
		430	flags = local_daif_save();
		431
		432	write_gicreg(0, ICC_SRE_EL1);
		433	isb();
		434
		435	val = read_gicreg(ICC_SRE_EL1);
		436
		437	write_gicreg(sre, ICC_SRE_EL1);
		438	isb();
		439
		440	if (has_vhe())
		441	local_daif_restore(flags);
		442
		443	val = (val & ICC_SRE_EL1_SRE) ? 0 : (1ULL << 63);
		444	val \|= read_gicreg(ICH_VTR_EL2);
		445
		446	return val;
411	}	447	}
412		448
413	u64 __vgic_v3_read_vmcr(void)	449	u64 __vgic_v3_read_vmcr(void)

arch/arm64/kvm/hyp/vhe/tlb.c+2−1

 	__tlb_switch_to_host(&cxt);
 }
-void __kvm_tlb_flush_local_vmid(struct kvm_s2_mmu *mmu)
+void __kvm_flush_cpu_context(struct kvm_s2_mmu *mmu)
 {
 	struct tlb_inv_context cxt;
 	__tlb_switch_to_guest(mmu, &cxt);
 	__tlbi(vmalle1);
+	asm volatile("ic iallu");
 	dsb(nsh);
 	isb();

arch/arm64/kvm/mmu.c+1−2

@@ -1312,8 +1312,7 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm, · 1311 unmodified lines
1312	* Prevent userspace from creating a memory region outside of the IPA	1312	* Prevent userspace from creating a memory region outside of the IPA
1313	* space addressable by the KVM guest IPA space.	1313	* space addressable by the KVM guest IPA space.
1314	*/	1314	*/
1315	if (memslot->base_gfn + memslot->npages >=	1315	if ((memslot->base_gfn + memslot->npages) > (kvm_phys_size(kvm) >> PAGE_SHIFT))
1316	(kvm_phys_size(kvm) >> PAGE_SHIFT))
1317	return -EFAULT;	1316	return -EFAULT;
1318		1317
1319	mmap_read_lock(current->mm);	1318	mmap_read_lock(current->mm);

arch/arm64/kvm/perf.c+10−0

 #include <asm/kvm_emulate.h>
+DEFINE_STATIC_KEY_FALSE(kvm_arm_pmu_available);
 static int kvm_is_in_guest(void)
 {
         return kvm_get_running_vcpu() != NULL;
 int kvm_perf_init(void)
 {
+	/*
+	 * Check if HW_PERF_EVENTS are supported by checking the number of
+	 * hardware performance counters. This could ensure the presence of
+	 * a physical PMU and CONFIG_PERF_EVENT is selected.
+	 */
+	if (IS_ENABLED(CONFIG_ARM_PMU) && perf_num_counters() > 0)
+		static_branch_enable(&kvm_arm_pmu_available);
 	return perf_register_guest_info_callbacks(&kvm_guest_cbs);
 }

arch/arm64/kvm/pmu-emul.c+0−10

@@ -823,16 +823,6 @@ u64 kvm_pmu_get_pmceid(struct kvm_vcpu *vcpu, bool pmceid1) · 822 unmodified lines
823	return val & mask;	823	return val & mask;
824	}	824	}
825		825
826	bool kvm_arm_support_pmu_v3(void)
827	{
828	/*
829	* Check if HW_PERF_EVENTS are supported by checking the number of
830	* hardware performance counters. This could ensure the presence of
831	* a physical PMU and CONFIG_PERF_EVENT is selected.
832	*/
833	return (perf_num_counters() > 0);
834	}
835
836	int kvm_arm_pmu_v3_enable(struct kvm_vcpu *vcpu)	826	int kvm_arm_pmu_v3_enable(struct kvm_vcpu *vcpu)
837	{	827	{
838	if (!kvm_vcpu_has_pmu(vcpu))	828	if (!kvm_vcpu_has_pmu(vcpu))

arch/arm64/kvm/reset.c+14−8

 	}
 	switch (cpuid_feature_extract_unsigned_field(mmfr0, tgran_2)) {
-	default:
+	case ID_AA64MMFR0_TGRAN_2_SUPPORTED_NONE:
-	case 1:
 		kvm_err("PAGE_SIZE not supported at Stage-2, giving up\n");
 		return -EINVAL;
-	case 0:
+	case ID_AA64MMFR0_TGRAN_2_SUPPORTED_DEFAULT:
 		kvm_debug("PAGE_SIZE supported at Stage-2 (default)\n");
 		break;
-	case 2:
+	case ID_AA64MMFR0_TGRAN_2_SUPPORTED_MIN ... ID_AA64MMFR0_TGRAN_2_SUPPORTED_MAX:
 		kvm_debug("PAGE_SIZE supported at Stage-2 (advertised)\n");
 		break;
+	default:
+		kvm_err("Unsupported value for TGRAN_2, giving up\n");
+		return -EINVAL;
 	}
 	kvm_ipa_limit = id_aa64mmfr0_parange_to_phys_shift(parange);
-	WARN(kvm_ipa_limit < KVM_PHYS_SHIFT,
+	kvm_info("IPA Size Limit: %d bits%s\n", kvm_ipa_limit,
-	     "KVM IPA Size Limit (%d bits) is smaller than default size\n",
+		 ((kvm_ipa_limit < KVM_PHYS_SHIFT) ?
-	     kvm_ipa_limit);
+		  " (Reduced IPA size, limited VM/VMM compatibility)" : ""));
-	kvm_info("IPA Size Limit: %d bits\n", kvm_ipa_limit);
 	return 0;
 }
 			return -EINVAL;
 	} else {
 		phys_shift = KVM_PHYS_SHIFT;
+		if (phys_shift > kvm_ipa_limit) {
+			pr_warn_once("%s using unsupported default IPA limit, upgrade your VMM\n",
+				     current->comm);
+			return -EINVAL;
+		}
 	}
 	mmfr0 = read_sanitised_ftr_reg(SYS_ID_AA64MMFR0_EL1);

arch/arm64/kvm/vgic/vgic-v3.c+9−3

  */
 int vgic_v3_probe(const struct gic_kvm_info *info)
 {
-	u32 ich_vtr_el2 = kvm_call_hyp_ret(__vgic_v3_get_ich_vtr_el2);
+	u64 ich_vtr_el2 = kvm_call_hyp_ret(__vgic_v3_get_gic_config);
+	bool has_v2;
 	int ret;
+	has_v2 = ich_vtr_el2 >> 63;
+	ich_vtr_el2 = (u32)ich_vtr_el2;
 	/*
 	 * The ListRegs field is 5 bits, but there is an architectural
 	 * maximum of 16 list registers. Just ignore bit 4...
 			 gicv4_enable ? "en" : "dis");
 	}
+	kvm_vgic_global_state.vcpu_base = 0;
 	if (!info->vcpu.start) {
 		kvm_info("GICv3: no GICV resource entry\n");
-		kvm_vgic_global_state.vcpu_base = 0;
+	} else if (!has_v2) {
+		pr_warn(FW_BUG "CPU interface incapable of MMIO access\n");
 	} else if (!PAGE_ALIGNED(info->vcpu.start)) {
 		pr_warn("GICV physical address 0x%llx not page aligned\n",
 			(unsigned long long)info->vcpu.start);
-		kvm_vgic_global_state.vcpu_base = 0;
 	} else {
 		kvm_vgic_global_state.vcpu_base = info->vcpu.start;
 		kvm_vgic_global_state.can_emulate_gicv2 = true;

arch/arm64/mm/init.c+26−3

@@ -219,17 +219,40 @@ static void __init zone_sizes_init(unsigned long min, unsigned long max) · 218 unmodified lines
219		219
220	int pfn_valid(unsigned long pfn)	220	int pfn_valid(unsigned long pfn)
221	{	221	{
222	phys_addr_t addr = pfn << PAGE_SHIFT;	222	phys_addr_t addr = PFN_PHYS(pfn);
223		223
224	if ((addr >> PAGE_SHIFT) != pfn)	224	/*
		225	* Ensure the upper PAGE_SHIFT bits are clear in the
		226	* pfn. Else it might lead to false positives when
		227	* some of the upper bits are set, but the lower bits
		228	* match a valid pfn.
		229	*/
		230	if (PHYS_PFN(addr) != pfn)
225	return 0;	231	return 0;
226		232
227	#ifdef CONFIG_SPARSEMEM	233	#ifdef CONFIG_SPARSEMEM
		234	{
		235	struct mem_section *ms;
		236
228	if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)	237	if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
229	return 0;	238	return 0;
230		239
231	if (!valid_section(__pfn_to_section(pfn)))	240	ms = __pfn_to_section(pfn);
		241	if (!valid_section(ms))
232	return 0;	242	return 0;
		243
		244	/*
		245	* ZONE_DEVICE memory does not have the memblock entries.
		246	* memblock_is_map_memory() check for ZONE_DEVICE based
		247	* addresses will always fail. Even the normal hotplugged
		248	* memory will never have MEMBLOCK_NOMAP flag set in their
		249	* memblock entries. Skip memblock search for all non early
		250	* memory sections covering all of hotplug memory including
		251	* both normal and ZONE_DEVICE based.
		252	*/
		253	if (!early_section(ms))
		254	return pfn_section_valid(ms, pfn);
		255	}
233	#endif	256	#endif
234	return memblock_is_map_memory(addr);	257	return memblock_is_map_memory(addr);
235	}	258	}

arch/arm64/mm/mmu.c+22−4

 #define NO_BLOCK_MAPPINGS	BIT(0)
 #define NO_CONT_MAPPINGS	BIT(1)
-u64 idmap_t0sz = TCR_T0SZ(VA_BITS);
+u64 idmap_t0sz = TCR_T0SZ(VA_BITS_MIN);
 u64 idmap_ptrs_per_pgd = PTRS_PER_PGD;
 u64 __section(".mmuoff.data.write") vabits_actual;
 		 * if MTE is present. Otherwise, it has the same attributes as
 		 * PAGE_KERNEL.
 		 */
-		__map_memblock(pgdp, start, end, PAGE_KERNEL_TAGGED, flags);
+		__map_memblock(pgdp, start, end, pgprot_tagged(PAGE_KERNEL),
+			       flags);
 	}
 	/*
 struct range arch_get_mappable_range(void)
 {
 	struct range mhp_range;
+	u64 start_linear_pa = __pa(_PAGE_OFFSET(vabits_actual));
+	u64 end_linear_pa = __pa(PAGE_END - 1);
+	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
+		/*
+		 * Check for a wrap, it is possible because of randomized linear
+		 * mapping the start physical address is actually bigger than
+		 * the end physical address. In this case set start to zero
+		 * because [0, end_linear_pa] range must still be able to cover
+		 * all addressable physical addresses.
+		 */
+		if (start_linear_pa > end_linear_pa)
+			start_linear_pa = 0;
+	}
+	WARN_ON(start_linear_pa > end_linear_pa);
 	/*
 	 * Linear mapping region is the range [PAGE_OFFSET..(PAGE_END - 1)]
 	 * range which can be mapped inside this linear mapping range, must
 	 * also be derived from its end points.
 	 */
-	mhp_range.start = __pa(_PAGE_OFFSET(vabits_actual));
+	mhp_range.start = start_linear_pa;
-	mhp_range.end =  __pa(PAGE_END - 1);
+	mhp_range.end =  end_linear_pa;
 	return mhp_range;
 }

arch/csky/kernel/probes/ftrace.c+1−1

@@ -9,7 +9,7 @@ int arch_check_ftrace_location(struct kprobe *p) · 8 unmodified lines
9	return 0;	9	return 0;
10	}	10	}
11		11
12	/* Ftrace callback handler for kprobes -- called under preepmt disabed */	12	/* Ftrace callback handler for kprobes -- called under preepmt disabled */
13	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,	13	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
14	struct ftrace_ops ops, struct ftrace_regs fregs)	14	struct ftrace_ops ops, struct ftrace_regs fregs)
15	{	15	{

arch/ia64/include/asm/syscall.h+1−1

@@ -32,7 +32,7 @@ static inline void syscall_rollback(struct task_struct *task, · 31 unmodified lines
32	static inline long syscall_get_error(struct task_struct *task,	32	static inline long syscall_get_error(struct task_struct *task,
33	struct pt_regs *regs)	33	struct pt_regs *regs)
34	{	34	{
35	return regs->r10 == -1 ? regs->r8:0;	35	return regs->r10 == -1 ? -regs->r8:0;
36	}	36	}
37		37
38	static inline long syscall_get_return_value(struct task_struct *task,	38	static inline long syscall_get_return_value(struct task_struct *task,

arch/ia64/kernel/err_inject.c+11−11

@@ -59,7 +59,7 @@ show_##name(struct device dev, struct device_attribute attr, \ · 58 unmodified lines
59	char *buf) \	59	char *buf) \
60	{ \	60	{ \
61	u32 cpu=dev->id; \	61	u32 cpu=dev->id; \
62	return sprintf(buf, "%lx\n", name[cpu]); \	62	return sprintf(buf, "%llx\n", name[cpu]); \
63	}	63	}
64		64
65	#define store(name) \	65	#define store(name) \
@@ -86,9 +86,9 @@ store_call_start(struct device dev, struct device_attribute attr, · 20 unmodified lines
86		86
87	#ifdef ERR_INJ_DEBUG	87	#ifdef ERR_INJ_DEBUG
88	printk(KERN_DEBUG "pal_mc_err_inject for cpu%d:\n", cpu);	88	printk(KERN_DEBUG "pal_mc_err_inject for cpu%d:\n", cpu);
89	printk(KERN_DEBUG "err_type_info=%lx,\n", err_type_info[cpu]);	89	printk(KERN_DEBUG "err_type_info=%llx,\n", err_type_info[cpu]);
90	printk(KERN_DEBUG "err_struct_info=%lx,\n", err_struct_info[cpu]);	90	printk(KERN_DEBUG "err_struct_info=%llx,\n", err_struct_info[cpu]);
91	printk(KERN_DEBUG "err_data_buffer=%lx, %lx, %lx.\n",	91	printk(KERN_DEBUG "err_data_buffer=%llx, %llx, %llx.\n",
92	err_data_buffer[cpu].data1,	92	err_data_buffer[cpu].data1,
93	err_data_buffer[cpu].data2,	93	err_data_buffer[cpu].data2,
94	err_data_buffer[cpu].data3);	94	err_data_buffer[cpu].data3);
@@ -117,8 +117,8 @@ store_call_start(struct device dev, struct device_attribute attr, · 22 unmodified lines
117		117
118	#ifdef ERR_INJ_DEBUG	118	#ifdef ERR_INJ_DEBUG
119	printk(KERN_DEBUG "Returns: status=%d,\n", (int)status[cpu]);	119	printk(KERN_DEBUG "Returns: status=%d,\n", (int)status[cpu]);
120	printk(KERN_DEBUG "capabilities=%lx,\n", capabilities[cpu]);	120	printk(KERN_DEBUG "capabilities=%llx,\n", capabilities[cpu]);
121	printk(KERN_DEBUG "resources=%lx\n", resources[cpu]);	121	printk(KERN_DEBUG "resources=%llx\n", resources[cpu]);
122	#endif	122	#endif
123	return size;	123	return size;
124	}	124	}
@@ -131,7 +131,7 @@ show_virtual_to_phys(struct device dev, struct device_attribute attr, · 6 unmodified lines
131	char *buf)	131	char *buf)
132	{	132	{
133	unsigned int cpu=dev->id;	133	unsigned int cpu=dev->id;
134	return sprintf(buf, "%lx\n", phys_addr[cpu]);	134	return sprintf(buf, "%llx\n", phys_addr[cpu]);
135	}	135	}
136		136
137	static ssize_t	137	static ssize_t
@@ -145,7 +145,7 @@ store_virtual_to_phys(struct device dev, struct device_attribute attr, · 7 unmodified lines
145	ret = get_user_pages_fast(virt_addr, 1, FOLL_WRITE, NULL);	145	ret = get_user_pages_fast(virt_addr, 1, FOLL_WRITE, NULL);
146	if (ret<=0) {	146	if (ret<=0) {
147	#ifdef ERR_INJ_DEBUG	147	#ifdef ERR_INJ_DEBUG
148	printk("Virtual address %lx is not existing.\n",virt_addr);	148	printk("Virtual address %llx is not existing.\n", virt_addr);
149	#endif	149	#endif
150	return -EINVAL;	150	return -EINVAL;
151	}	151	}
@@ -163,7 +163,7 @@ show_err_data_buffer(struct device *dev, · 11 unmodified lines
163	{	163	{
164	unsigned int cpu=dev->id;	164	unsigned int cpu=dev->id;
165		165
166	return sprintf(buf, "%lx, %lx, %lx\n",	166	return sprintf(buf, "%llx, %llx, %llx\n",
167	err_data_buffer[cpu].data1,	167	err_data_buffer[cpu].data1,
168	err_data_buffer[cpu].data2,	168	err_data_buffer[cpu].data2,
169	err_data_buffer[cpu].data3);	169	err_data_buffer[cpu].data3);
@@ -178,13 +178,13 @@ store_err_data_buffer(struct device *dev, · 8 unmodified lines
178	int ret;	178	int ret;
179		179
180	#ifdef ERR_INJ_DEBUG	180	#ifdef ERR_INJ_DEBUG
181	printk("write err_data_buffer=[%lx,%lx,%lx] on cpu%d\n",	181	printk("write err_data_buffer=[%llx,%llx,%llx] on cpu%d\n",
182	err_data_buffer[cpu].data1,	182	err_data_buffer[cpu].data1,
183	err_data_buffer[cpu].data2,	183	err_data_buffer[cpu].data2,
184	err_data_buffer[cpu].data3,	184	err_data_buffer[cpu].data3,
185	cpu);	185	cpu);
186	#endif	186	#endif
187	ret=sscanf(buf, "%lx, %lx, %lx",	187	ret = sscanf(buf, "%llx, %llx, %llx",
188	&err_data_buffer[cpu].data1,	188	&err_data_buffer[cpu].data1,
189	&err_data_buffer[cpu].data2,	189	&err_data_buffer[cpu].data2,
190	&err_data_buffer[cpu].data3);	190	&err_data_buffer[cpu].data3);

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

@@ -1824,7 +1824,7 @@ ia64_mca_cpu_init(void *cpu_data) · 1823 unmodified lines
1824	data = mca_bootmem();	1824	data = mca_bootmem();
1825	first_time = 0;	1825	first_time = 0;
1826	} else	1826	} else
1827	data = (void *)__get_free_pages(GFP_KERNEL,	1827	data = (void *)__get_free_pages(GFP_ATOMIC,
1828	get_order(sz));	1828	get_order(sz));
1829	if (!data)	1829	if (!data)
1830	panic("Could not allocate MCA memory for cpu %d\n",	1830	panic("Could not allocate MCA memory for cpu %d\n",

arch/ia64/kernel/ptrace.c+18−6

 {
 	struct syscall_get_set_args *args = data;
 	struct pt_regs *pt = args->regs;
-	unsigned long *krbs, cfm, ndirty;
+	unsigned long *krbs, cfm, ndirty, nlocals, nouts;
 	int i, count;
 	if (unw_unwind_to_user(info) < 0)
 		return;
+	/*
+	 * We get here via a few paths:
+	 * - break instruction: cfm is shared with caller.
+	 *   syscall args are in out= regs, locals are non-empty.
+	 * - epsinstruction: cfm is set by br.call
+	 *   locals don't exist.
+	 *
+	 * For both cases argguments are reachable in cfm.sof - cfm.sol.
+	 * CFM: [ ... | sor: 17..14 | sol : 13..7 | sof : 6..0 ]
+	 */
 	cfm = pt->cr_ifs;
+	nlocals = (cfm >> 7) & 0x7f; /* aka sol */
+	nouts = (cfm & 0x7f) - nlocals; /* aka sof - sol */
 	krbs = (unsigned long *)info->task + IA64_RBS_OFFSET/8;
 	ndirty = ia64_rse_num_regs(krbs, krbs + (pt->loadrs >> 19));
 	count = 0;
 	if (in_syscall(pt))
-		count = min_t(int, args->n, cfm & 0x7f);
+		count = min_t(int, args->n, nouts);
+	/* Iterate over outs. */
 	for (i = 0; i < count; i++) {
+		int j = ndirty + nlocals + i + args->i;
 		if (args->rw)
-			*ia64_rse_skip_regs(krbs, ndirty + i + args->i) =
+			*ia64_rse_skip_regs(krbs, j) = args->args[i];
-				args->args[i];
 		else
-			args->args[i] = *ia64_rse_skip_regs(krbs,
+			args->args[i] = *ia64_rse_skip_regs(krbs, j);
-				ndirty + i + args->i);
 	}
 	if (!args->rw) {

arch/mips/kernel/vmlinux.lds.S+1−1

@@ -176,7 +176,7 @@ SECTIONS · 175 unmodified lines
176	.fill : {	176	.fill : {
177	FILL(0);	177	FILL(0);
178	BYTE(0);	178	BYTE(0);
179	. = ALIGN(8);	179	STRUCT_ALIGN();
180	}	180	}
181	__appended_dtb = .;	181	__appended_dtb = .;
182	/* leave space for appended DTB */	182	/* leave space for appended DTB */

arch/powerpc/include/asm/code-patching.h+4−3

@@ -73,9 +73,10 @@ void __patch_exception(int exc, unsigned long addr); · 72 unmodified lines
73	#endif	73	#endif
74		74
75	#define OP_RT_RA_MASK 0xffff0000UL	75	#define OP_RT_RA_MASK 0xffff0000UL
76	#define LIS_R2 0x3c020000UL	76	#define LIS_R2 (PPC_INST_ADDIS \| __PPC_RT(R2))
77	#define ADDIS_R2_R12 0x3c4c0000UL	77	#define ADDIS_R2_R12 (PPC_INST_ADDIS \| __PPC_RT(R2) \| __PPC_RA(R12))
78	#define ADDI_R2_R2 0x38420000UL	78	#define ADDI_R2_R2 (PPC_INST_ADDI \| __PPC_RT(R2) \| __PPC_RA(R2))
		79
79		80
80	static inline unsigned long ppc_function_entry(void *func)	81	static inline unsigned long ppc_function_entry(void *func)
81	{	82	{

arch/powerpc/include/asm/cpu_has_feature.h+2−2

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	#include <linux/bug.h>	7	#include <linux/bug.h>
8	#include <asm/cputable.h>	8	#include <asm/cputable.h>
9		9
10	static inline bool early_cpu_has_feature(unsigned long feature)	10	static __always_inline bool early_cpu_has_feature(unsigned long feature)
11	{	11	{
12	return !!((CPU_FTRS_ALWAYS & feature) \|\|	12	return !!((CPU_FTRS_ALWAYS & feature) \|\|
13	(CPU_FTRS_POSSIBLE & cur_cpu_spec->cpu_features & feature));	13	(CPU_FTRS_POSSIBLE & cur_cpu_spec->cpu_features & feature));
@@ -46,7 +46,7 @@ static __always_inline bool cpu_has_feature(unsigned long feature) · 32 unmodified lines
46	return static_branch_likely(&cpu_feature_keys[i]);	46	return static_branch_likely(&cpu_feature_keys[i]);
47	}	47	}
48	#else	48	#else
49	static inline bool cpu_has_feature(unsigned long feature)	49	static __always_inline bool cpu_has_feature(unsigned long feature)
50	{	50	{
51	return early_cpu_has_feature(feature);	51	return early_cpu_has_feature(feature);
52	}	52	}

arch/powerpc/include/asm/interrupt.h+2−1

 DECLARE_INTERRUPT_HANDLER(CacheLockingException);
 DECLARE_INTERRUPT_HANDLER(SPEFloatingPointException);
 DECLARE_INTERRUPT_HANDLER(SPEFloatingPointRoundException);
-DECLARE_INTERRUPT_HANDLER(unrecoverable_exception);
 DECLARE_INTERRUPT_HANDLER(WatchdogException);
 DECLARE_INTERRUPT_HANDLER(kernel_bad_stack);
 DECLARE_INTERRUPT_HANDLER_ASYNC(TAUException);
+void unrecoverable_exception(struct pt_regs *regs);
 void replay_system_reset(void);
 void replay_soft_interrupts(void);

arch/powerpc/include/asm/ptrace.h+2−2

arch/powerpc/include/asm/switch_to.h+10−0

@@ -71,6 +71,16 @@ static inline void disable_kernel_vsx(void) · 70 unmodified lines
71	{	71	{
72	msr_check_and_clear(MSR_FP\|MSR_VEC\|MSR_VSX);	72	msr_check_and_clear(MSR_FP\|MSR_VEC\|MSR_VSX);
73	}	73	}
		74	#else
		75	static inline void enable_kernel_vsx(void)
		76	{
		77	BUILD_BUG();
		78	}
		79
		80	static inline void disable_kernel_vsx(void)
		81	{
		82	BUILD_BUG();
		83	}
74	#endif	84	#endif
75		85
76	#ifdef CONFIG_SPE	86	#ifdef CONFIG_SPE

arch/powerpc/kernel/exceptions-64s.S+1−1

@@ -466,7 +466,7 @@ DEFINE_FIXED_SYMBOL(\name\()_common_real) · 465 unmodified lines
466		466
467	ld r10,PACAKMSR(r13) /* get MSR value for kernel */	467	ld r10,PACAKMSR(r13) /* get MSR value for kernel */
468	/* MSR[RI] is clear iff using SRR regs */	468	/* MSR[RI] is clear iff using SRR regs */
469	.if IHSRR == EXC_HV_OR_STD	469	.if IHSRR_IF_HVMODE
470	BEGIN_FTR_SECTION	470	BEGIN_FTR_SECTION
471	xori r10,r10,MSR_RI	471	xori r10,r10,MSR_RI
472	END_FTR_SECTION_IFCLR(CPU_FTR_HVMODE)	472	END_FTR_SECTION_IFCLR(CPU_FTR_HVMODE)

arch/powerpc/kernel/interrupt.c+0−1

@@ -436,7 +436,6 @@ again: · 435 unmodified lines
436	return ret;	436	return ret;
437	}	437	}
438		438
439	void unrecoverable_exception(struct pt_regs *regs);
440	void preempt_schedule_irq(void);	439	void preempt_schedule_irq(void);
441		440
442	notrace unsigned long interrupt_exit_kernel_prepare(struct pt_regs *regs, unsigned long msr)	441	notrace unsigned long interrupt_exit_kernel_prepare(struct pt_regs *regs, unsigned long msr)

arch/powerpc/kernel/traps.c+1−1

@@ -2170,7 +2170,7 @@ DEFINE_INTERRUPT_HANDLER(SPEFloatingPointRoundException) · 2169 unmodified lines
2170	* in the MSR is 0. This indicates that SRR0/1 are live, and that	2170	* in the MSR is 0. This indicates that SRR0/1 are live, and that
2171	* we therefore lost state by taking this exception.	2171	* we therefore lost state by taking this exception.
2172	*/	2172	*/
2173	DEFINE_INTERRUPT_HANDLER(unrecoverable_exception)	2173	void unrecoverable_exception(struct pt_regs *regs)
2174	{	2174	{
2175	pr_emerg("Unrecoverable exception %lx at %lx (msr=%lx)\n",	2175	pr_emerg("Unrecoverable exception %lx at %lx (msr=%lx)\n",
2176	regs->trap, regs->nip, regs->msr);	2176	regs->trap, regs->nip, regs->msr);

arch/powerpc/kernel/vdso32/gettimeofday.S+11−0

@@ -65,3 +65,14 @@ V_FUNCTION_END(__kernel_clock_getres) · 64 unmodified lines
65	V_FUNCTION_BEGIN(__kernel_time)	65	V_FUNCTION_BEGIN(__kernel_time)
66	cvdso_call_time __c_kernel_time	66	cvdso_call_time __c_kernel_time
67	V_FUNCTION_END(__kernel_time)	67	V_FUNCTION_END(__kernel_time)
		68
		69	/* Routines for restoring integer registers, called by the compiler. */
		70	/* Called with r11 pointing to the stack header word of the caller of the */
		71	/* function, just beyond the end of the integer restore area. */
		72	_GLOBAL(_restgpr_31_x)
		73	_GLOBAL(_rest32gpr_31_x)
		74	lwz r0,4(r11)
		75	lwz r31,-4(r11)
		76	mtlr r0
		77	mr r1,r11
		78	blr

arch/riscv/Kconfig+2−2

 	select PCI_MSI if PCI
 	select RISCV_INTC
 	select RISCV_TIMER if RISCV_SBI
-	select SPARSEMEM_STATIC if 32BIT
 	select SPARSE_IRQ
 	select SYSCTL_EXCEPTION_TRACE
 	select THREAD_INFO_IN_TASK
 config ARCH_SPARSEMEM_ENABLE
 	def_bool y
 	depends on MMU
-	select SPARSEMEM_VMEMMAP_ENABLE
+	select SPARSEMEM_STATIC if 32BIT && SPARSMEM
+	select SPARSEMEM_VMEMMAP_ENABLE if 64BIT
 config ARCH_SELECT_MEMORY_MODEL
 	def_bool ARCH_SPARSEMEM_ENABLE

arch/riscv/Kconfig.socs+2−0

@@ -31,6 +31,8 @@ config SOC_CANAAN · 30 unmodified lines
31	select SIFIVE_PLIC	31	select SIFIVE_PLIC
32	select ARCH_HAS_RESET_CONTROLLER	32	select ARCH_HAS_RESET_CONTROLLER
33	select PINCTRL	33	select PINCTRL
		34	select COMMON_CLK
		35	select COMMON_CLK_K210
34	help	36	help
35	This enables support for Canaan Kendryte K210 SoC platform hardware.	37	This enables support for Canaan Kendryte K210 SoC platform hardware.
36		38

arch/riscv/include/asm/asm-prototypes.h+16−0

@@ -9,4 +9,20 @@ long long __lshrti3(long long a, int b); · 8 unmodified lines
9	long long __ashrti3(long long a, int b);	9	long long __ashrti3(long long a, int b);
10	long long __ashlti3(long long a, int b);	10	long long __ashlti3(long long a, int b);
11		11
		12
		13	#define DECLARE_DO_ERROR_INFO(name) asmlinkage void name(struct pt_regs *regs)
		14
		15	DECLARE_DO_ERROR_INFO(do_trap_unknown);
		16	DECLARE_DO_ERROR_INFO(do_trap_insn_misaligned);
		17	DECLARE_DO_ERROR_INFO(do_trap_insn_fault);
		18	DECLARE_DO_ERROR_INFO(do_trap_insn_illegal);
		19	DECLARE_DO_ERROR_INFO(do_trap_load_fault);
		20	DECLARE_DO_ERROR_INFO(do_trap_load_misaligned);
		21	DECLARE_DO_ERROR_INFO(do_trap_store_misaligned);
		22	DECLARE_DO_ERROR_INFO(do_trap_store_fault);
		23	DECLARE_DO_ERROR_INFO(do_trap_ecall_u);
		24	DECLARE_DO_ERROR_INFO(do_trap_ecall_s);
		25	DECLARE_DO_ERROR_INFO(do_trap_ecall_m);
		26	DECLARE_DO_ERROR_INFO(do_trap_break);
		27
12	#endif /* _ASM_RISCV_PROTOTYPES_H */	28	#endif /* _ASM_RISCV_PROTOTYPES_H */

arch/riscv/include/asm/irq.h+2−0

@@ -12,4 +12,6 @@ · 11 unmodified lines
12		12
13	#include <asm-generic/irq.h>	13	#include <asm-generic/irq.h>
14		14
		15	extern void __init init_IRQ(void);
		16
15	#endif /* _ASM_RISCV_IRQ_H */	17	#endif /* _ASM_RISCV_IRQ_H */

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

@@ -71,6 +71,7 @@ int riscv_of_processor_hartid(struct device_node *node); · 70 unmodified lines
71	int riscv_of_parent_hartid(struct device_node *node);	71	int riscv_of_parent_hartid(struct device_node *node);
72		72
73	extern void riscv_fill_hwcap(void);	73	extern void riscv_fill_hwcap(void);
		74	extern int arch_dup_task_struct(struct task_struct dst, struct task_struct src);
74		75
75	#endif /* __ASSEMBLY__ */	76	#endif /* __ASSEMBLY__ */
76		77

arch/riscv/include/asm/ptrace.h+5−0

 extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
 					       unsigned int n);
+void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,
+			   unsigned long frame_pointer);
+int do_syscall_trace_enter(struct pt_regs *regs);
+void do_syscall_trace_exit(struct pt_regs *regs);
 /**
  * regs_get_register() - get register value from its offset
  * @regs:	pt_regs from which register value is gotten

arch/riscv/include/asm/sbi.h+2−2

 	SBI_EXT_RFENCE_REMOTE_FENCE_I = 0,
 	SBI_EXT_RFENCE_REMOTE_SFENCE_VMA,
 	SBI_EXT_RFENCE_REMOTE_SFENCE_VMA_ASID,
-	SBI_EXT_RFENCE_REMOTE_HFENCE_GVMA,
 	SBI_EXT_RFENCE_REMOTE_HFENCE_GVMA_VMID,
-	SBI_EXT_RFENCE_REMOTE_HFENCE_VVMA,
+	SBI_EXT_RFENCE_REMOTE_HFENCE_GVMA,
 	SBI_EXT_RFENCE_REMOTE_HFENCE_VVMA_ASID,
+	SBI_EXT_RFENCE_REMOTE_HFENCE_VVMA,
 };
 enum sbi_ext_hsm_fid {

arch/riscv/include/asm/timex.h+2−0

@@ -88,4 +88,6 @@ static inline int read_current_timer(unsigned long *timer_val) · 87 unmodified lines
88	return 0;	88	return 0;
89	}	89	}
90		90
		91	extern void time_init(void);
		92
91	#endif /* _ASM_RISCV_TIMEX_H */	93	#endif /* _ASM_RISCV_TIMEX_H */

arch/riscv/kernel/Makefile+1−0

@@ -8,6 +8,7 @@ CFLAGS_REMOVE_ftrace.o = $(CC_FLAGS_FTRACE) · 7 unmodified lines
8	CFLAGS_REMOVE_patch.o = $(CC_FLAGS_FTRACE)	8	CFLAGS_REMOVE_patch.o = $(CC_FLAGS_FTRACE)
9	CFLAGS_REMOVE_sbi.o = $(CC_FLAGS_FTRACE)	9	CFLAGS_REMOVE_sbi.o = $(CC_FLAGS_FTRACE)
10	endif	10	endif
		11	CFLAGS_syscall_table.o += $(call cc-option,-Wno-override-init,)
11		12
12	extra-y += head.o	13	extra-y += head.o
13	extra-y += vmlinux.lds	14	extra-y += vmlinux.lds

arch/riscv/kernel/probes/ftrace.c+10−8

 #include <linux/kprobes.h>
-/* Ftrace callback handler for kprobes -- called under preepmt disabed */
+/* Ftrace callback handler for kprobes -- called under preepmt disabled */
 void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
-			   struct ftrace_ops *ops, struct ftrace_regs *regs)
+			   struct ftrace_ops *ops, struct ftrace_regs *fregs)
 {
 	struct kprobe *p;
+	struct pt_regs *regs;
 	struct kprobe_ctlblk *kcb;
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (unlikely(!p) || kprobe_disabled(p))
 		return;
+	regs = ftrace_get_regs(fregs);
 	kcb = get_kprobe_ctlblk();
 	if (kprobe_running()) {
 		kprobes_inc_nmissed_count(p);
 	} else {
-		unsigned long orig_ip = instruction_pointer(&(regs->regs));
+		unsigned long orig_ip = instruction_pointer(regs);
-		instruction_pointer_set(&(regs->regs), ip);
+		instruction_pointer_set(regs, ip);
 		__this_cpu_write(current_kprobe, p);
 		kcb->kprobe_status = KPROBE_HIT_ACTIVE;
-		if (!p->pre_handler || !p->pre_handler(p, &(regs->regs))) {
+		if (!p->pre_handler || !p->pre_handler(p, regs)) {
 			/*
 			 * Emulate singlestep (and also recover regs->pc)
 			 * as if there is a nop
 			 */
-			instruction_pointer_set(&(regs->regs),
+			instruction_pointer_set(regs,
 				(unsigned long)p->addr + MCOUNT_INSN_SIZE);
 			if (unlikely(p->post_handler)) {
 				kcb->kprobe_status = KPROBE_HIT_SSDONE;
-				p->post_handler(p, &(regs->regs), 0);
+				p->post_handler(p, regs, 0);
 			}
-			instruction_pointer_set(&(regs->regs), orig_ip);
+			instruction_pointer_set(regs, orig_ip);
 		}
 		/*

arch/riscv/kernel/probes/kprobes.c+1−2

@@ -256,8 +256,7 @@ int __kprobes kprobe_fault_handler(struct pt_regs *regs, unsigned int trapnr) · 255 unmodified lines
256	* normal page fault.	256	* normal page fault.
257	*/	257	*/
258	regs->epc = (unsigned long) cur->addr;	258	regs->epc = (unsigned long) cur->addr;
259	if (!instruction_pointer(regs))	259	BUG_ON(!instruction_pointer(regs));
260	BUG();
261		260
262	if (kcb->kprobe_status == KPROBE_REENTER)	261	if (kcb->kprobe_status == KPROBE_REENTER)
263	restore_previous_kprobe(kcb);	262	restore_previous_kprobe(kcb);

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

@@ -10,6 +10,7 @@ · 9 unmodified lines
10	#include <linux/cpu.h>	10	#include <linux/cpu.h>
11	#include <linux/kernel.h>	11	#include <linux/kernel.h>
12	#include <linux/sched.h>	12	#include <linux/sched.h>
		13	#include <linux/sched/debug.h>
13	#include <linux/sched/task_stack.h>	14	#include <linux/sched/task_stack.h>
14	#include <linux/tick.h>	15	#include <linux/tick.h>
15	#include <linux/ptrace.h>	16	#include <linux/ptrace.h>

arch/riscv/kernel/sbi.c+1−1

@@ -116,7 +116,7 @@ void sbi_clear_ipi(void) · 115 unmodified lines
116	EXPORT_SYMBOL(sbi_clear_ipi);	116	EXPORT_SYMBOL(sbi_clear_ipi);
117		117
118	/**	118	/**
119	* sbi_set_timer_v01() - Program the timer for next timer event.	119	* __sbi_set_timer_v01() - Program the timer for next timer event.
120	* @stime_value: The value after which next timer event should fire.	120	* @stime_value: The value after which next timer event should fire.
121	*	121	*
122	* Return: None	122	* Return: None

arch/riscv/kernel/setup.c+2−1

@@ -147,7 +147,8 @@ static void __init init_resources(void) · 146 unmodified lines
147	bss_res.end = __pa_symbol(__bss_stop) - 1;	147	bss_res.end = __pa_symbol(__bss_stop) - 1;
148	bss_res.flags = IORESOURCE_SYSTEM_RAM \| IORESOURCE_BUSY;	148	bss_res.flags = IORESOURCE_SYSTEM_RAM \| IORESOURCE_BUSY;
149		149
150	mem_res_sz = (memblock.memory.cnt + memblock.reserved.cnt) * sizeof(*mem_res);	150	/* + 1 as memblock_alloc() might increase memblock.reserved.cnt */
		151	mem_res_sz = (memblock.memory.cnt + memblock.reserved.cnt + 1) * sizeof(*mem_res);
151	mem_res = memblock_alloc(mem_res_sz, SMP_CACHE_BYTES);	152	mem_res = memblock_alloc(mem_res_sz, SMP_CACHE_BYTES);
152	if (!mem_res)	153	if (!mem_res)
153	panic("%s: Failed to allocate %zu bytes\n", __func__, mem_res_sz);	154	panic("%s: Failed to allocate %zu bytes\n", __func__, mem_res_sz);

arch/riscv/kernel/time.c+1−0

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#include <linux/delay.h>	9	#include <linux/delay.h>
10	#include <asm/sbi.h>	10	#include <asm/sbi.h>
11	#include <asm/processor.h>	11	#include <asm/processor.h>
		12	#include <asm/timex.h>
12		13
13	unsigned long riscv_timebase;	14	unsigned long riscv_timebase;
14	EXPORT_SYMBOL_GPL(riscv_timebase);	15	EXPORT_SYMBOL_GPL(riscv_timebase);

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

@@ -17,6 +17,7 @@ · 16 unmodified lines
17	#include <linux/module.h>	17	#include <linux/module.h>
18	#include <linux/irq.h>	18	#include <linux/irq.h>
19		19
		20	#include <asm/asm-prototypes.h>
20	#include <asm/bug.h>	21	#include <asm/bug.h>
21	#include <asm/processor.h>	22	#include <asm/processor.h>
22	#include <asm/ptrace.h>	23	#include <asm/ptrace.h>

arch/riscv/mm/kasan_init.c+3−1

 	memset(start, KASAN_SHADOW_INIT, end - start);
 }
-void __init kasan_shallow_populate(void *start, void *end)
+static void __init kasan_shallow_populate(void *start, void *end)
 {
 	unsigned long vaddr = (unsigned long)start & PAGE_MASK;
 	unsigned long vend = PAGE_ALIGN((unsigned long)end);
 		}
 		vaddr += PAGE_SIZE;
 	}
+	local_flush_tlb_all();
 }
 void __init kasan_init(void)

arch/s390/configs/debug_defconfig+3−13

 CONFIG_IP_VS_SH=m
 CONFIG_IP_VS_SED=m
 CONFIG_IP_VS_NQ=m
+CONFIG_IP_VS_TWOS=m
 CONFIG_IP_VS_FTP=m
 CONFIG_IP_VS_PE_SIP=m
-CONFIG_NF_TABLES_IPV4=y
 CONFIG_NFT_FIB_IPV4=m
 CONFIG_NF_TABLES_ARP=y
 CONFIG_IP_NF_IPTABLES=m
 CONFIG_IP_NF_ARPTABLES=m
 CONFIG_IP_NF_ARPFILTER=m
 CONFIG_IP_NF_ARP_MANGLE=m
-CONFIG_NF_TABLES_IPV6=y
 CONFIG_NFT_FIB_IPV6=m
 CONFIG_IP6_NF_IPTABLES=m
 CONFIG_IP6_NF_MATCH_AH=m
 # CONFIG_NET_VENDOR_AQUANTIA is not set
 # CONFIG_NET_VENDOR_ARC is not set
 # CONFIG_NET_VENDOR_ATHEROS is not set
-# CONFIG_NET_VENDOR_AURORA is not set
 # CONFIG_NET_VENDOR_BROADCOM is not set
 # CONFIG_NET_VENDOR_BROCADE is not set
 # CONFIG_NET_VENDOR_CADENCE is not set
 CONFIG_VIRTIO_INPUT=y
 CONFIG_VHOST_NET=m
 CONFIG_VHOST_VSOCK=m
-# CONFIG_SURFACE_PLATFORMS is not set
 CONFIG_S390_CCW_IOMMU=y
 CONFIG_S390_AP_IOMMU=y
 CONFIG_EXT4_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_TMPFS=y
 CONFIG_TMPFS_POSIX_ACL=y
+CONFIG_TMPFS_INODE64=y
 CONFIG_HUGETLBFS=y
 CONFIG_CONFIGFS_FS=m
 CONFIG_ECRYPT_FS=m
 CONFIG_CRYPTO_CRC32=m
 CONFIG_CRYPTO_BLAKE2S=m
 CONFIG_CRYPTO_MICHAEL_MIC=m
-CONFIG_CRYPTO_RMD128=m
 CONFIG_CRYPTO_RMD160=m
-CONFIG_CRYPTO_RMD256=m
-CONFIG_CRYPTO_RMD320=m
 CONFIG_CRYPTO_SHA3=m
-CONFIG_CRYPTO_TGR192=m
 CONFIG_CRYPTO_WP512=m
 CONFIG_CRYPTO_AES_TI=m
 CONFIG_CRYPTO_ANUBIS=m
 CONFIG_CRYPTO_DES=m
 CONFIG_CRYPTO_FCRYPT=m
 CONFIG_CRYPTO_KHAZAD=m
-CONFIG_CRYPTO_SALSA20=m
 CONFIG_CRYPTO_SEED=m
 CONFIG_CRYPTO_SERPENT=m
 CONFIG_CRYPTO_SM4=m
 CONFIG_DEBUG_OBJECTS_PERCPU_COUNTER=y
 CONFIG_SLUB_DEBUG_ON=y
 CONFIG_SLUB_STATS=y
-CONFIG_DEBUG_KMEMLEAK=y
-CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF=y
 CONFIG_DEBUG_STACK_USAGE=y
 CONFIG_DEBUG_VM=y
 CONFIG_DEBUG_VM_VMACACHE=y
-CONFIG_DEBUG_VM_RB=y
 CONFIG_DEBUG_VM_PGFLAGS=y
 CONFIG_DEBUG_MEMORY_INIT=y
 CONFIG_MEMORY_NOTIFIER_ERROR_INJECT=m
 CONFIG_HIST_TRIGGERS=y
 CONFIG_FTRACE_STARTUP_TEST=y
 # CONFIG_EVENT_TRACE_STARTUP_TEST is not set
+CONFIG_DEBUG_ENTRY=y
 CONFIG_NOTIFIER_ERROR_INJECTION=m
 CONFIG_NETDEV_NOTIFIER_ERROR_INJECT=m
 CONFIG_FAULT_INJECTION=y
 CONFIG_ATOMIC64_SELFTEST=y
 CONFIG_TEST_BITOPS=m
 CONFIG_TEST_BPF=m
-CONFIG_DEBUG_ENTRY=y

arch/s390/configs/defconfig+2−9

 CONFIG_IP_VS_SH=m
 CONFIG_IP_VS_SED=m
 CONFIG_IP_VS_NQ=m
+CONFIG_IP_VS_TWOS=m
 CONFIG_IP_VS_FTP=m
 CONFIG_IP_VS_PE_SIP=m
-CONFIG_NF_TABLES_IPV4=y
 CONFIG_NFT_FIB_IPV4=m
 CONFIG_NF_TABLES_ARP=y
 CONFIG_IP_NF_IPTABLES=m
 CONFIG_IP_NF_ARPTABLES=m
 CONFIG_IP_NF_ARPFILTER=m
 CONFIG_IP_NF_ARP_MANGLE=m
-CONFIG_NF_TABLES_IPV6=y
 CONFIG_NFT_FIB_IPV6=m
 CONFIG_IP6_NF_IPTABLES=m
 CONFIG_IP6_NF_MATCH_AH=m
 # CONFIG_NET_VENDOR_AQUANTIA is not set
 # CONFIG_NET_VENDOR_ARC is not set
 # CONFIG_NET_VENDOR_ATHEROS is not set
-# CONFIG_NET_VENDOR_AURORA is not set
 # CONFIG_NET_VENDOR_BROADCOM is not set
 # CONFIG_NET_VENDOR_BROCADE is not set
 # CONFIG_NET_VENDOR_CADENCE is not set
 CONFIG_VIRTIO_INPUT=y
 CONFIG_VHOST_NET=m
 CONFIG_VHOST_VSOCK=m
-# CONFIG_SURFACE_PLATFORMS is not set
 CONFIG_S390_CCW_IOMMU=y
 CONFIG_S390_AP_IOMMU=y
 CONFIG_EXT4_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_TMPFS=y
 CONFIG_TMPFS_POSIX_ACL=y
+CONFIG_TMPFS_INODE64=y
 CONFIG_HUGETLBFS=y
 CONFIG_CONFIGFS_FS=m
 CONFIG_ECRYPT_FS=m
 CONFIG_CRYPTO_CRC32=m
 CONFIG_CRYPTO_BLAKE2S=m
 CONFIG_CRYPTO_MICHAEL_MIC=m
-CONFIG_CRYPTO_RMD128=m
 CONFIG_CRYPTO_RMD160=m
-CONFIG_CRYPTO_RMD256=m
-CONFIG_CRYPTO_RMD320=m
 CONFIG_CRYPTO_SHA3=m
-CONFIG_CRYPTO_TGR192=m
 CONFIG_CRYPTO_WP512=m
 CONFIG_CRYPTO_AES_TI=m
 CONFIG_CRYPTO_ANUBIS=m
 CONFIG_CRYPTO_DES=m
 CONFIG_CRYPTO_FCRYPT=m
 CONFIG_CRYPTO_KHAZAD=m
-CONFIG_CRYPTO_SALSA20=m
 CONFIG_CRYPTO_SEED=m
 CONFIG_CRYPTO_SERPENT=m
 CONFIG_CRYPTO_SM4=m

arch/s390/configs/zfcpdump_defconfig+0−3

 # CONFIG_SECCOMP is not set
 # CONFIG_GCC_PLUGINS is not set
 CONFIG_PARTITION_ADVANCED=y
-CONFIG_IBM_PARTITION=y
 # CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
 # CONFIG_COMPACTION is not set
 # CONFIG_MIGRATION is not set
 # CONFIG_HID is not set
 # CONFIG_VIRTIO_MENU is not set
 # CONFIG_VHOST_MENU is not set
-# CONFIG_SURFACE_PLATFORMS is not set
 # CONFIG_IOMMU_SUPPORT is not set
 # CONFIG_DNOTIFY is not set
 # CONFIG_INOTIFY_USER is not set
-CONFIG_CONFIGFS_FS=y
 # CONFIG_MISC_FILESYSTEMS is not set
 # CONFIG_NETWORK_FILESYSTEMS is not set
 CONFIG_LSM="yama,loadpin,safesetid,integrity"

arch/s390/include/asm/idle.h+6−6

@@ -14,12 +14,12 @@ · 13 unmodified lines
14		14
15	struct s390_idle_data {	15	struct s390_idle_data {
16	seqcount_t seqcount;	16	seqcount_t seqcount;
17	unsigned long long idle_count;	17	unsigned long idle_count;
18	unsigned long long idle_time;	18	unsigned long idle_time;
19	unsigned long long clock_idle_enter;	19	unsigned long clock_idle_enter;
20	unsigned long long clock_idle_exit;	20	unsigned long clock_idle_exit;
21	unsigned long long timer_idle_enter;	21	unsigned long timer_idle_enter;
22	unsigned long long timer_idle_exit;	22	unsigned long timer_idle_exit;
23	unsigned long mt_cycles_enter[8];	23	unsigned long mt_cycles_enter[8];
24	};	24	};
25		25

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

@@ -202,7 +202,7 @@ extern unsigned int s390_pci_no_rid; · 201 unmodified lines
202	----------------------------------------------------------------------------- */	202	----------------------------------------------------------------------------- */
203	/* Base stuff */	203	/* Base stuff */
204	int zpci_create_device(u32 fid, u32 fh, enum zpci_state state);	204	int zpci_create_device(u32 fid, u32 fh, enum zpci_state state);
205	void zpci_remove_device(struct zpci_dev *zdev);	205	void zpci_remove_device(struct zpci_dev *zdev, bool set_error);
206	int zpci_enable_device(struct zpci_dev *);	206	int zpci_enable_device(struct zpci_dev *);
207	int zpci_disable_device(struct zpci_dev *);	207	int zpci_disable_device(struct zpci_dev *);
208	int zpci_register_ioat(struct zpci_dev *, u8, u64, u64, u64);	208	int zpci_register_ioat(struct zpci_dev *, u8, u64, u64, u64);

arch/s390/include/asm/timex.h+18−18

@@ -98,10 +98,10 @@ extern unsigned char ptff_function_mask[16]; · 97 unmodified lines
98		98
99	/* Query TOD offset result */	99	/* Query TOD offset result */
100	struct ptff_qto {	100	struct ptff_qto {
101	unsigned long long physical_clock;	101	unsigned long physical_clock;
102	unsigned long long tod_offset;	102	unsigned long tod_offset;
103	unsigned long long logical_tod_offset;	103	unsigned long logical_tod_offset;
104	unsigned long long tod_epoch_difference;	104	unsigned long tod_epoch_difference;
105	} __packed;	105	} __packed;
106		106
107	static inline int ptff_query(unsigned int nr)	107	static inline int ptff_query(unsigned int nr)
@@ -151,9 +151,9 @@ struct ptff_qui { · 43 unmodified lines
151	rc; \	151	rc; \
152	})	152	})
153		153
154	static inline unsigned long long local_tick_disable(void)	154	static inline unsigned long local_tick_disable(void)
155	{	155	{
156	unsigned long long old;	156	unsigned long old;
157		157
158	old = S390_lowcore.clock_comparator;	158	old = S390_lowcore.clock_comparator;
159	S390_lowcore.clock_comparator = clock_comparator_max;	159	S390_lowcore.clock_comparator = clock_comparator_max;
@@ -161,7 +161,7 @@ static inline unsigned long long local_tick_disable(void) · 1 unmodified line
161	return old;	161	return old;
162	}	162	}
163		163
164	static inline void local_tick_enable(unsigned long long comp)	164	static inline void local_tick_enable(unsigned long comp)
165	{	165	{
166	S390_lowcore.clock_comparator = comp;	166	S390_lowcore.clock_comparator = comp;
167	set_clock_comparator(S390_lowcore.clock_comparator);	167	set_clock_comparator(S390_lowcore.clock_comparator);
@@ -169,9 +169,9 @@ static inline void local_tick_enable(unsigned long long comp) · 1 unmodified line
169		169
170	#define CLOCK_TICK_RATE 1193180 /* Underlying HZ */	170	#define CLOCK_TICK_RATE 1193180 /* Underlying HZ */
171		171
172	typedef unsigned long long cycles_t;	172	typedef unsigned long cycles_t;
173		173
174	static inline unsigned long long get_tod_clock(void)	174	static inline unsigned long get_tod_clock(void)
175	{	175	{
176	union tod_clock clk;	176	union tod_clock clk;
177		177
@@ -179,10 +179,10 @@ static inline unsigned long long get_tod_clock(void) · 1 unmodified line
179	return clk.tod;	179	return clk.tod;
180	}	180	}
181		181
182	static inline unsigned long long get_tod_clock_fast(void)	182	static inline unsigned long get_tod_clock_fast(void)
183	{	183	{
184	#ifdef CONFIG_HAVE_MARCH_Z9_109_FEATURES	184	#ifdef CONFIG_HAVE_MARCH_Z9_109_FEATURES
185	unsigned long long clk;	185	unsigned long clk;
186		186
187	asm volatile("stckf %0" : "=Q" (clk) : : "cc");	187	asm volatile("stckf %0" : "=Q" (clk) : : "cc");
188	return clk;	188	return clk;
@@ -208,9 +208,9 @@ extern union tod_clock tod_clock_base; · 19 unmodified lines
208	* Therefore preemption must be disabled, otherwise the returned	208	* Therefore preemption must be disabled, otherwise the returned
209	* value is not guaranteed to be monotonic.	209	* value is not guaranteed to be monotonic.
210	*/	210	*/
211	static inline unsigned long long get_tod_clock_monotonic(void)	211	static inline unsigned long get_tod_clock_monotonic(void)
212	{	212	{
213	unsigned long long tod;	213	unsigned long tod;
214		214
215	preempt_disable_notrace();	215	preempt_disable_notrace();
216	tod = get_tod_clock() - tod_clock_base.tod;	216	tod = get_tod_clock() - tod_clock_base.tod;
@@ -237,7 +237,7 @@ static inline unsigned long long get_tod_clock_monotonic(void) · 20 unmodified lines
237	* -> ns = (th * 125) + ((tl * 125) >> 9);	237	* -> ns = (th * 125) + ((tl * 125) >> 9);
238	*	238	*
239	*/	239	*/
240	static inline unsigned long long tod_to_ns(unsigned long long todval)	240	static inline unsigned long tod_to_ns(unsigned long todval)
241	{	241	{
242	return ((todval >> 9) * 125) + (((todval & 0x1ff) * 125) >> 9);	242	return ((todval >> 9) * 125) + (((todval & 0x1ff) * 125) >> 9);
243	}	243	}
@@ -249,10 +249,10 @@ static inline unsigned long long tod_to_ns(unsigned long long todval) · 5 unmodified lines
249	*	249	*
250	* Returns: true if a is later than b	250	* Returns: true if a is later than b
251	*/	251	*/
252	static inline int tod_after(unsigned long long a, unsigned long long b)	252	static inline int tod_after(unsigned long a, unsigned long b)
253	{	253	{
254	if (MACHINE_HAS_SCC)	254	if (MACHINE_HAS_SCC)
255	return (long long) a > (long long) b;	255	return (long) a > (long) b;
256	return a > b;	256	return a > b;
257	}	257	}
258		258
@@ -263,10 +263,10 @@ static inline int tod_after(unsigned long long a, unsigned long long b) · 4 unmodified lines
263	*	263	*
264	* Returns: true if a is later than b	264	* Returns: true if a is later than b
265	*/	265	*/
266	static inline int tod_after_eq(unsigned long long a, unsigned long long b)	266	static inline int tod_after_eq(unsigned long a, unsigned long b)
267	{	267	{
268	if (MACHINE_HAS_SCC)	268	if (MACHINE_HAS_SCC)
269	return (long long) a >= (long long) b;	269	return (long) a >= (long) b;
270	return a >= b;	270	return a >= b;
271	}	271	}
272		272

arch/s390/include/uapi/asm/hwctrset.hrenamed from arch/s390/include/uapi/asm/perf_cpum_cf_diag.h+0−0

File renamed without changes.

arch/s390/kernel/idle.c+6−6

@@ -47,7 +47,7 @@ void account_idle_time_irq(void) · 46 unmodified lines
47	void arch_cpu_idle(void)	47	void arch_cpu_idle(void)
48	{	48	{
49	struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);	49	struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);
50	unsigned long long idle_time;	50	unsigned long idle_time;
51	unsigned long psw_mask;	51	unsigned long psw_mask;
52		52
53	/* Wait for external, I/O or machine check interrupt. */	53	/* Wait for external, I/O or machine check interrupt. */
@@ -73,7 +73,7 @@ static ssize_t show_idle_count(struct device *dev, · 19 unmodified lines
73	struct device_attribute attr, char buf)	73	struct device_attribute attr, char buf)
74	{	74	{
75	struct s390_idle_data *idle = &per_cpu(s390_idle, dev->id);	75	struct s390_idle_data *idle = &per_cpu(s390_idle, dev->id);
76	unsigned long long idle_count;	76	unsigned long idle_count;
77	unsigned int seq;	77	unsigned int seq;
78		78
79	do {	79	do {
@@ -82,14 +82,14 @@ static ssize_t show_idle_count(struct device *dev, · 2 unmodified lines
82	if (READ_ONCE(idle->clock_idle_enter))	82	if (READ_ONCE(idle->clock_idle_enter))
83	idle_count++;	83	idle_count++;
84	} while (read_seqcount_retry(&idle->seqcount, seq));	84	} while (read_seqcount_retry(&idle->seqcount, seq));
85	return sprintf(buf, "%llu\n", idle_count);	85	return sprintf(buf, "%lu\n", idle_count);
86	}	86	}
87	DEVICE_ATTR(idle_count, 0444, show_idle_count, NULL);	87	DEVICE_ATTR(idle_count, 0444, show_idle_count, NULL);
88		88
89	static ssize_t show_idle_time(struct device *dev,	89	static ssize_t show_idle_time(struct device *dev,
90	struct device_attribute attr, char buf)	90	struct device_attribute attr, char buf)
91	{	91	{
92	unsigned long long now, idle_time, idle_enter, idle_exit, in_idle;	92	unsigned long now, idle_time, idle_enter, idle_exit, in_idle;
93	struct s390_idle_data *idle = &per_cpu(s390_idle, dev->id);	93	struct s390_idle_data *idle = &per_cpu(s390_idle, dev->id);
94	unsigned int seq;	94	unsigned int seq;
95		95
@@ -109,14 +109,14 @@ static ssize_t show_idle_time(struct device *dev, · 13 unmodified lines
109	}	109	}
110	}	110	}
111	idle_time += in_idle;	111	idle_time += in_idle;
112	return sprintf(buf, "%llu\n", idle_time >> 12);	112	return sprintf(buf, "%lu\n", idle_time >> 12);
113	}	113	}
114	DEVICE_ATTR(idle_time_us, 0444, show_idle_time, NULL);	114	DEVICE_ATTR(idle_time_us, 0444, show_idle_time, NULL);
115		115
116	u64 arch_cpu_idle_time(int cpu)	116	u64 arch_cpu_idle_time(int cpu)
117	{	117	{
118	struct s390_idle_data *idle = &per_cpu(s390_idle, cpu);	118	struct s390_idle_data *idle = &per_cpu(s390_idle, cpu);
119	unsigned long long now, idle_enter, idle_exit, in_idle;	119	unsigned long now, idle_enter, idle_exit, in_idle;
120	unsigned int seq;	120	unsigned int seq;
121		121
122	do {	122	do {

arch/s390/kernel/perf_cpum_cf.c+1−1

@@ -269,7 +269,7 @@ static int __hw_perf_event_init(struct perf_event *event, unsigned int type) · 268 unmodified lines
269	case CPUMF_CTR_SET_MAX:	269	case CPUMF_CTR_SET_MAX:
270	/* The counter could not be associated to a counter set */	270	/* The counter could not be associated to a counter set */
271	return -EINVAL;	271	return -EINVAL;
272	};	272	}
273		273
274	/* Initialize for using the CPU-measurement counter facility */	274	/* Initialize for using the CPU-measurement counter facility */
275	if (!atomic_inc_not_zero(&num_events)) {	275	if (!atomic_inc_not_zero(&num_events)) {

arch/s390/kernel/perf_cpum_cf_diag.c+5−18

@@ -26,12 +26,10 @@ · 25 unmodified lines
26	#include <asm/timex.h>	26	#include <asm/timex.h>
27	#include <asm/debug.h>	27	#include <asm/debug.h>
28		28
29	#include <asm/perf_cpum_cf_diag.h>	29	#include <asm/hwctrset.h>
30		30
31	#define CF_DIAG_CTRSET_DEF 0xfeef /* Counter set header mark */	31	#define CF_DIAG_CTRSET_DEF 0xfeef /* Counter set header mark */
32	#define CF_DIAG_MIN_INTERVAL 60 /* Minimum counter set read */
33	/* interval in seconds */	32	/* interval in seconds */
34	static unsigned long cf_diag_interval = CF_DIAG_MIN_INTERVAL;
35	static unsigned int cf_diag_cpu_speed;	33	static unsigned int cf_diag_cpu_speed;
36	static debug_info_t *cf_diag_dbg;	34	static debug_info_t *cf_diag_dbg;
37		35
@@ -729,7 +727,6 @@ static DEFINE_MUTEX(cf_diag_ctrset_mutex); · 691 unmodified lines
729	static struct cf_diag_ctrset {	727	static struct cf_diag_ctrset {
730	unsigned long ctrset; /* Bit mask of counter set to read */	728	unsigned long ctrset; /* Bit mask of counter set to read */
731	cpumask_t mask; /* CPU mask to read from */	729	cpumask_t mask; /* CPU mask to read from */
732	time64_t lastread; /* Epoch counter set last read */
733	} cf_diag_ctrset;	730	} cf_diag_ctrset;
734		731
735	static void cf_diag_ctrset_clear(void)	732	static void cf_diag_ctrset_clear(void)
@@ -866,27 +863,16 @@ static int cf_diag_all_read(unsigned long arg) · 130 unmodified lines
866	{	863	{
867	struct cf_diag_call_on_cpu_parm p;	864	struct cf_diag_call_on_cpu_parm p;
868	cpumask_var_t mask;	865	cpumask_var_t mask;
869	time64_t now;	866	int rc;
870	int rc = 0;
871		867
872	debug_sprintf_event(cf_diag_dbg, 5, "%s\n", __func__);	868	debug_sprintf_event(cf_diag_dbg, 5, "%s\n", __func__);
873	if (!alloc_cpumask_var(&mask, GFP_KERNEL))	869	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
874	return -ENOMEM;	870	return -ENOMEM;
875	now = ktime_get_seconds();	871
876	if (cf_diag_ctrset.lastread + cf_diag_interval > now) {
877	debug_sprintf_event(cf_diag_dbg, 5, "%s now %lld "
878	" lastread %lld\n", __func__, now,
879	cf_diag_ctrset.lastread);
880	rc = -EAGAIN;
881	goto out;
882	} else {
883	cf_diag_ctrset.lastread = now;
884	}
885	p.sets = cf_diag_ctrset.ctrset;	872	p.sets = cf_diag_ctrset.ctrset;
886	cpumask_and(mask, &cf_diag_ctrset.mask, cpu_online_mask);	873	cpumask_and(mask, &cf_diag_ctrset.mask, cpu_online_mask);
887	on_each_cpu_mask(mask, cf_diag_cpu_read, &p, 1);	874	on_each_cpu_mask(mask, cf_diag_cpu_read, &p, 1);
888	rc = cf_diag_all_copy(arg, mask);	875	rc = cf_diag_all_copy(arg, mask);
889	out:
890	free_cpumask_var(mask);	876	free_cpumask_var(mask);
891	debug_sprintf_event(cf_diag_dbg, 5, "%s rc %d\n", __func__, rc);	877	debug_sprintf_event(cf_diag_dbg, 5, "%s rc %d\n", __func__, rc);
892	return rc;	878	return rc;
@@ -982,7 +968,7 @@ static int cf_diag_all_start(void) · 89 unmodified lines
982	*/	968	*/
983	static size_t cf_diag_needspace(unsigned int sets)	969	static size_t cf_diag_needspace(unsigned int sets)
984	{	970	{
985	struct cpu_cf_events *cpuhw = this_cpu_ptr(&cpu_cf_events);	971	struct cpu_cf_events *cpuhw = get_cpu_ptr(&cpu_cf_events);
986	size_t bytes = 0;	972	size_t bytes = 0;
987	int i;	973	int i;
988		974
@@ -998,6 +984,7 @@ static size_t cf_diag_needspace(unsigned int sets) · 9 unmodified lines
998	sizeof(((struct s390_ctrset_cpudata *)0)->no_sets));	984	sizeof(((struct s390_ctrset_cpudata *)0)->no_sets));
999	debug_sprintf_event(cf_diag_dbg, 5, "%s bytes %ld\n", __func__,	985	debug_sprintf_event(cf_diag_dbg, 5, "%s bytes %ld\n", __func__,
1000	bytes);	986	bytes);
		987	put_cpu_ptr(&cpu_cf_events);
1001	return bytes;	988	return bytes;
1002	}	989	}
1003		990

arch/s390/kernel/time.c+14−14

@@ -68,10 +68,10 @@ EXPORT_SYMBOL(s390_epoch_delta_notifier); · 67 unmodified lines
68		68
69	unsigned char ptff_function_mask[16];	69	unsigned char ptff_function_mask[16];
70		70
71	static unsigned long long lpar_offset;	71	static unsigned long lpar_offset;
72	static unsigned long long initial_leap_seconds;	72	static unsigned long initial_leap_seconds;
73	static unsigned long long tod_steering_end;	73	static unsigned long tod_steering_end;
74	static long long tod_steering_delta;	74	static long tod_steering_delta;
75		75
76	/*	76	/*
77	* Get time offsets with PTFF	77	* Get time offsets with PTFF
@@ -96,7 +96,7 @@ void __init time_early_init(void) · 18 unmodified lines
96		96
97	/* get initial leap seconds */	97	/* get initial leap seconds */
98	if (ptff_query(PTFF_QUI) && ptff(&qui, sizeof(qui), PTFF_QUI) == 0)	98	if (ptff_query(PTFF_QUI) && ptff(&qui, sizeof(qui), PTFF_QUI) == 0)
99	initial_leap_seconds = (unsigned long long)	99	initial_leap_seconds = (unsigned long)
100	((long) qui.old_leap * 4096000000L);	100	((long) qui.old_leap * 4096000000L);
101	}	101	}
102		102
@@ -222,7 +222,7 @@ void __init read_persistent_wall_and_boot_offset(struct timespec64 *wall_time, · 119 unmodified lines
222		222
223	static u64 read_tod_clock(struct clocksource *cs)	223	static u64 read_tod_clock(struct clocksource *cs)
224	{	224	{
225	unsigned long long now, adj;	225	unsigned long now, adj;
226		226
227	preempt_disable(); /* protect from changes to steering parameters */	227	preempt_disable(); /* protect from changes to steering parameters */
228	now = get_tod_clock();	228	now = get_tod_clock();
@@ -362,7 +362,7 @@ static inline int check_sync_clock(void) · 133 unmodified lines
362	* Apply clock delta to the global data structures.	362	* Apply clock delta to the global data structures.
363	* This is called once on the CPU that performed the clock sync.	363	* This is called once on the CPU that performed the clock sync.
364	*/	364	*/
365	static void clock_sync_global(unsigned long long delta)	365	static void clock_sync_global(unsigned long delta)
366	{	366	{
367	unsigned long now, adj;	367	unsigned long now, adj;
368	struct ptff_qto qto;	368	struct ptff_qto qto;
@@ -378,7 +378,7 @@ static void clock_sync_global(unsigned long long delta) · 9 unmodified lines
378	-(adj >> 15) : (adj >> 15);	378	-(adj >> 15) : (adj >> 15);
379	tod_steering_delta += delta;	379	tod_steering_delta += delta;
380	if ((abs(tod_steering_delta) >> 48) != 0)	380	if ((abs(tod_steering_delta) >> 48) != 0)
381	panic("TOD clock sync offset %lli is too large to drift\n",	381	panic("TOD clock sync offset %li is too large to drift\n",
382	tod_steering_delta);	382	tod_steering_delta);
383	tod_steering_end = now + (abs(tod_steering_delta) << 15);	383	tod_steering_end = now + (abs(tod_steering_delta) << 15);
384	vdso_data->arch_data.tod_steering_end = tod_steering_end;	384	vdso_data->arch_data.tod_steering_end = tod_steering_end;
@@ -394,7 +394,7 @@ static void clock_sync_global(unsigned long long delta) · 9 unmodified lines
394	* Apply clock delta to the per-CPU data structures of this CPU.	394	* Apply clock delta to the per-CPU data structures of this CPU.
395	* This is called for each online CPU after the call to clock_sync_global.	395	* This is called for each online CPU after the call to clock_sync_global.
396	*/	396	*/
397	static void clock_sync_local(unsigned long long delta)	397	static void clock_sync_local(unsigned long delta)
398	{	398	{
399	/* Add the delta to the clock comparator. */	399	/* Add the delta to the clock comparator. */
400	if (S390_lowcore.clock_comparator != clock_comparator_max) {	400	if (S390_lowcore.clock_comparator != clock_comparator_max) {
@@ -418,7 +418,7 @@ static void __init time_init_wq(void) · 17 unmodified lines
418	struct clock_sync_data {	418	struct clock_sync_data {
419	atomic_t cpus;	419	atomic_t cpus;
420	int in_sync;	420	int in_sync;
421	unsigned long long clock_delta;	421	unsigned long clock_delta;
422	};	422	};
423		423
424	/*	424	/*
@@ -538,7 +538,7 @@ static int stpinfo_valid(void) · 113 unmodified lines
538	static int stp_sync_clock(void *data)	538	static int stp_sync_clock(void *data)
539	{	539	{
540	struct clock_sync_data *sync = data;	540	struct clock_sync_data *sync = data;
541	unsigned long long clock_delta, flags;	541	u64 clock_delta, flags;
542	static int first;	542	static int first;
543	int rc;	543	int rc;
544		544
@@ -720,8 +720,8 @@ static ssize_t ctn_id_show(struct device *dev, · 175 unmodified lines
720		720
721	mutex_lock(&stp_mutex);	721	mutex_lock(&stp_mutex);
722	if (stpinfo_valid())	722	if (stpinfo_valid())
723	ret = sprintf(buf, "%016llx\n",	723	ret = sprintf(buf, "%016lx\n",
724	(unsigned long long ) stp_info.ctnid);	724	(unsigned long ) stp_info.ctnid);
725	mutex_unlock(&stp_mutex);	725	mutex_unlock(&stp_mutex);
726	return ret;	726	return ret;
727	}	727	}
@@ -794,7 +794,7 @@ static ssize_t leap_seconds_scheduled_show(struct device *dev, · 66 unmodified lines
794	if (!stzi.lsoib.p)	794	if (!stzi.lsoib.p)
795	return sprintf(buf, "0,0\n");	795	return sprintf(buf, "0,0\n");
796		796
797	return sprintf(buf, "%llu,%d\n",	797	return sprintf(buf, "%lu,%d\n",
798	tod_to_ns(stzi.lsoib.nlsout - TOD_UNIX_EPOCH) / NSEC_PER_SEC,	798	tod_to_ns(stzi.lsoib.nlsout - TOD_UNIX_EPOCH) / NSEC_PER_SEC,
799	stzi.lsoib.nlso - stzi.lsoib.also);	799	stzi.lsoib.nlso - stzi.lsoib.also);
800	}	800	}

arch/s390/kernel/topology.c+0−2

 			}
 			info = info->next;
 		}
-		if (cpumask_empty(&mask))
-			cpumask_copy(&mask, cpumask_of(cpu));
 		break;
 	case TOPOLOGY_MODE_PACKAGE:
 		cpumask_copy(&mask, cpu_present_mask);

arch/s390/kernel/vtime.c+1−1

@@ -214,7 +214,7 @@ void vtime_flush(struct task_struct *tsk) · 213 unmodified lines
214	avg_steal = S390_lowcore.avg_steal_timer / 2;	214	avg_steal = S390_lowcore.avg_steal_timer / 2;
215	if ((s64) steal > 0) {	215	if ((s64) steal > 0) {
216	S390_lowcore.steal_timer = 0;	216	S390_lowcore.steal_timer = 0;
217	account_steal_time(steal);	217	account_steal_time(cputime_to_nsecs(steal));
218	avg_steal += steal;	218	avg_steal += steal;
219	}	219	}
220	S390_lowcore.avg_steal_timer = avg_steal;	220	S390_lowcore.avg_steal_timer = avg_steal;

arch/s390/kvm/interrupt.c+1−1

@@ -1287,7 +1287,7 @@ static u64 __calculate_sltime(struct kvm_vcpu *vcpu) · 1286 unmodified lines
1287	/* already expired? */	1287	/* already expired? */
1288	if (cputm >> 63)	1288	if (cputm >> 63)
1289	return 0;	1289	return 0;
1290	return min(sltime, tod_to_ns(cputm));	1290	return min_t(u64, sltime, tod_to_ns(cputm));
1291	}	1291	}
1292	} else if (cpu_timer_interrupts_enabled(vcpu)) {	1292	} else if (cpu_timer_interrupts_enabled(vcpu)) {
1293	sltime = kvm_s390_get_cpu_timer(vcpu);	1293	sltime = kvm_s390_get_cpu_timer(vcpu);

arch/s390/pci/pci.c+24−4

 }
 EXPORT_SYMBOL_GPL(zpci_disable_device);
-void zpci_remove_device(struct zpci_dev *zdev)
+/* zpci_remove_device - Removes the given zdev from the PCI core
+ * @zdev: the zdev to be removed from the PCI core
+ * @set_error: if true the device's error state is set to permanent failure
+ *
+ * Sets a zPCI device to a configured but offline state; the zPCI
+ * device is still accessible through its hotplug slot and the zPCI
+ * API but is removed from the common code PCI bus, making it
+ * no longer available to drivers.
+ */
+void zpci_remove_device(struct zpci_dev *zdev, bool set_error)
 {
 	struct zpci_bus *zbus = zdev->zbus;
 	struct pci_dev *pdev;
+	if (!zdev->zbus->bus)
+		return;
 	pdev = pci_get_slot(zbus->bus, zdev->devfn);
 	if (pdev) {
-		if (pdev->is_virtfn)
+		if (set_error)
-			return zpci_iov_remove_virtfn(pdev, zdev->vfn);
+			pdev->error_state = pci_channel_io_perm_failure;
+		if (pdev->is_virtfn) {
+			zpci_iov_remove_virtfn(pdev, zdev->vfn);
+			/* balance pci_get_slot */
+			pci_dev_put(pdev);
+			return;
+		}
 		pci_stop_and_remove_bus_device_locked(pdev);
+		/* balance pci_get_slot */
+		pci_dev_put(pdev);
 	}
 }
 	struct zpci_dev *zdev = container_of(kref, struct zpci_dev, kref);
 	if (zdev->zbus->bus)
-		zpci_remove_device(zdev);
+		zpci_remove_device(zdev, false);
 	switch (zdev->state) {
 	case ZPCI_FN_STATE_ONLINE:

arch/s390/pci/pci_event.c+6−12

 static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
 {
 	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
-	struct pci_dev *pdev = NULL;
 	enum zpci_state state;
+	struct pci_dev *pdev;
 	int ret;
-	if (zdev && zdev->zbus->bus)
-		pdev = pci_get_slot(zdev->zbus->bus, zdev->devfn);
 	zpci_err("avail CCDF:\n");
 	zpci_err_hex(ccdf, sizeof(*ccdf));
 	case 0x0303: /* Deconfiguration requested */
 		if (!zdev)
 			break;
-		if (pdev)
+		zpci_remove_device(zdev, false);
-			zpci_remove_device(zdev);
 		ret = zpci_disable_device(zdev);
 		if (ret)
 	case 0x0304: /* Configured -> Standby|Reserved */
 		if (!zdev)
 			break;
-		if (pdev) {
+		/* Give the driver a hint that the function is
-			/* Give the driver a hint that the function is
+		 * already unusable.
-			 * already unusable. */
+		 */
-			pdev->error_state = pci_channel_io_perm_failure;
+		zpci_remove_device(zdev, true);
-			zpci_remove_device(zdev);
-		}
 		zdev->fh = ccdf->fh;
 		zpci_disable_device(zdev);

arch/x86/entry/common.c+2−1

@@ -128,7 +128,8 @@ static noinstr bool __do_fast_syscall_32(struct pt_regs *regs) · 127 unmodified lines
128	regs->ax = -EFAULT;	128	regs->ax = -EFAULT;
129		129
130	instrumentation_end();	130	instrumentation_end();
131	syscall_exit_to_user_mode(regs);	131	local_irq_disable();
		132	irqentry_exit_to_user_mode(regs);
132	return false;	133	return false;
133	}	134	}
134		135

arch/x86/entry/entry_64_compat.S+2−0

@@ -210,6 +210,8 @@ SYM_CODE_START(entry_SYSCALL_compat) · 209 unmodified lines
210	/* Switch to the kernel stack */	210	/* Switch to the kernel stack */
211	movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp	211	movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp
212		212
		213	SYM_INNER_LABEL(entry_SYSCALL_compat_safe_stack, SYM_L_GLOBAL)
		214
213	/* Construct struct pt_regs on stack */	215	/* Construct struct pt_regs on stack */
214	pushq $__USER32_DS /* pt_regs->ss */	216	pushq $__USER32_DS /* pt_regs->ss */
215	pushq %r8 /* pt_regs->sp */	217	pushq %r8 /* pt_regs->sp */

arch/x86/events/core.c+6−9

 DEFINE_STATIC_CALL_NULL(x86_pmu_drain_pebs,   *x86_pmu.drain_pebs);
 DEFINE_STATIC_CALL_NULL(x86_pmu_pebs_aliases, *x86_pmu.pebs_aliases);
-DEFINE_STATIC_CALL_NULL(x86_pmu_guest_get_msrs,  *x86_pmu.guest_get_msrs);
+/*
+ * This one is magic, it will get called even when PMU init fails (because
+ * there is no PMU), in which case it should simply return NULL.
+ */
+DEFINE_STATIC_CALL_RET0(x86_pmu_guest_get_msrs, *x86_pmu.guest_get_msrs);
 u64 __read_mostly hw_cache_event_ids
 				[PERF_COUNT_HW_CACHE_MAX]
 	x86_perf_event_update(event);
 }
-static inline struct perf_guest_switch_msr *
-perf_guest_get_msrs_nop(int *nr)
-{
-	*nr = 0;
-	return NULL;
-}
 static int __init init_hw_perf_events(void)
 {
 	struct x86_pmu_quirk *quirk;
 		x86_pmu.read = _x86_pmu_read;
 	if (!x86_pmu.guest_get_msrs)
-		x86_pmu.guest_get_msrs = perf_guest_get_msrs_nop;
+		x86_pmu.guest_get_msrs = (void *)&__static_call_return0;
 	x86_pmu_static_call_update();

arch/x86/events/intel/core.c+7−1

 		return ret;
 	if (event->attr.precise_ip) {
+		if ((event->attr.config & INTEL_ARCH_EVENT_MASK) == INTEL_FIXED_VLBR_EVENT)
+			return -EINVAL;
 		if (!(event->attr.freq || (event->attr.wakeup_events && !event->attr.watermark))) {
 			event->hw.flags |= PERF_X86_EVENT_AUTO_RELOAD;
 			if (!(event->attr.sample_type &
-			      ~intel_pmu_large_pebs_flags(event)))
+			      ~intel_pmu_large_pebs_flags(event))) {
 				event->hw.flags |= PERF_X86_EVENT_LARGE_PEBS;
+				event->attach_state |= PERF_ATTACH_SCHED_CB;
+			}
 		}
 		if (x86_pmu.pebs_aliases)
 			x86_pmu.pebs_aliases(event);
 		ret = intel_pmu_setup_lbr_filter(event);
 		if (ret)
 			return ret;
+		event->attach_state |= PERF_ATTACH_SCHED_CB;
 		/*
 		 * BTS is set up earlier in this path, so don't account twice

arch/x86/events/intel/ds.c+1−1

@@ -2010,7 +2010,7 @@ static void intel_pmu_drain_pebs_nhm(struct pt_regs *iregs, struct perf_sample_d · 2009 unmodified lines
2010	*/	2010	*/
2011	if (!pebs_status && cpuc->pebs_enabled &&	2011	if (!pebs_status && cpuc->pebs_enabled &&
2012	!(cpuc->pebs_enabled & (cpuc->pebs_enabled-1)))	2012	!(cpuc->pebs_enabled & (cpuc->pebs_enabled-1)))
2013	pebs_status = cpuc->pebs_enabled;	2013	pebs_status = p->status = cpuc->pebs_enabled;
2014		2014
2015	bit = find_first_bit((unsigned long *)&pebs_status,	2015	bit = find_first_bit((unsigned long *)&pebs_status,
2016	x86_pmu.max_pebs_events);	2016	x86_pmu.max_pebs_events);

arch/x86/include/asm/insn-eval.h+2−0

@@ -23,6 +23,8 @@ unsigned long insn_get_seg_base(struct pt_regs *regs, int seg_reg_idx); · 22 unmodified lines
23	int insn_get_code_seg_params(struct pt_regs *regs);	23	int insn_get_code_seg_params(struct pt_regs *regs);
24	int insn_fetch_from_user(struct pt_regs *regs,	24	int insn_fetch_from_user(struct pt_regs *regs,
25	unsigned char buf[MAX_INSN_SIZE]);	25	unsigned char buf[MAX_INSN_SIZE]);
		26	int insn_fetch_from_user_inatomic(struct pt_regs *regs,
		27	unsigned char buf[MAX_INSN_SIZE]);
26	bool insn_decode(struct insn insn, struct pt_regs regs,	28	bool insn_decode(struct insn insn, struct pt_regs regs,
27	unsigned char buf[MAX_INSN_SIZE], int buf_size);	29	unsigned char buf[MAX_INSN_SIZE], int buf_size);
28		30

arch/x86/include/asm/kvm_host.h+28−10

 	u64 options;
 };
+/* Current state of Hyper-V TSC page clocksource */
+enum hv_tsc_page_status {
+	/* TSC page was not set up or disabled */
+	HV_TSC_PAGE_UNSET = 0,
+	/* TSC page MSR was written by the guest, update pending */
+	HV_TSC_PAGE_GUEST_CHANGED,
+	/* TSC page MSR was written by KVM userspace, update pending */
+	HV_TSC_PAGE_HOST_CHANGED,
+	/* TSC page was properly set up and is currently active  */
+	HV_TSC_PAGE_SET,
+	/* TSC page is currently being updated and therefore is inactive */
+	HV_TSC_PAGE_UPDATING,
+	/* TSC page was set up with an inaccessible GPA */
+	HV_TSC_PAGE_BROKEN,
+};
 /* Hyper-V emulation context */
 struct kvm_hv {
 	struct mutex hv_lock;
 	u64 hv_guest_os_id;
 	u64 hv_hypercall;
 	u64 hv_tsc_page;
+	enum hv_tsc_page_status hv_tsc_page_status;
 	/* Hyper-v based guest crash (NT kernel bugcheck) parameters */
 	u64 hv_crash_param[HV_X64_MSR_CRASH_PARAMS];
 	KVM_IRQCHIP_SPLIT,        /* created with KVM_CAP_SPLIT_IRQCHIP */
 };
+struct kvm_x86_msr_filter {
+	u8 count;
+	bool default_allow:1;
+	struct msr_bitmap_range ranges[16];
+};
 #define APICV_INHIBIT_REASON_DISABLE    0
 #define APICV_INHIBIT_REASON_HYPERV     1
 #define APICV_INHIBIT_REASON_NESTED     2
 	struct kvm_pit *vpit;
 	atomic_t vapics_in_nmi_mode;
 	struct mutex apic_map_lock;
-	struct kvm_apic_map *apic_map;
+	struct kvm_apic_map __rcu *apic_map;
 	atomic_t apic_map_dirty;
 	bool apic_access_page_done;
 	bool guest_can_read_msr_platform_info;
 	bool exception_payload_enabled;
+	bool bus_lock_detection_enabled;
 	/* Deflect RDMSR and WRMSR to user space when they trigger a #GP */
 	u32 user_space_msr_mask;
+	struct kvm_x86_msr_filter __rcu *msr_filter;
-	struct {
+	struct kvm_pmu_event_filter __rcu *pmu_event_filter;
-		u8 count;
-		bool default_allow:1;
-		struct msr_bitmap_range ranges[16];
-	} msr_filter;
-	bool bus_lock_detection_enabled;
-	struct kvm_pmu_event_filter *pmu_event_filter;
 	struct task_struct *nx_lpage_recovery_thread;
 #ifdef CONFIG_X86_64

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

@@ -551,15 +551,6 @@ static inline void arch_thread_struct_whitelist(unsigned long *offset, · 550 unmodified lines
551	*size = fpu_kernel_xstate_size;	551	*size = fpu_kernel_xstate_size;
552	}	552	}
553		553
554	/*
555	* Thread-synchronous status.
556	*
557	* This is different from the flags in that nobody else
558	* ever touches our thread-synchronous status, so we don't
559	* have to worry about atomic accesses.
560	*/
561	#define TS_COMPAT 0x0002 /* 32bit syscall active (64BIT)*/
562
563	static inline void	554	static inline void
564	native_load_sp0(unsigned long sp0)	555	native_load_sp0(unsigned long sp0)
565	{	556	{

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

@@ -25,6 +25,7 @@ void __end_SYSENTER_singlestep_region(void); · 24 unmodified lines
25	void entry_SYSENTER_compat(void);	25	void entry_SYSENTER_compat(void);
26	void __end_entry_SYSENTER_compat(void);	26	void __end_entry_SYSENTER_compat(void);
27	void entry_SYSCALL_compat(void);	27	void entry_SYSCALL_compat(void);
		28	void entry_SYSCALL_compat_safe_stack(void);
28	void entry_INT80_compat(void);	29	void entry_INT80_compat(void);
29	#ifdef CONFIG_XEN_PV	30	#ifdef CONFIG_XEN_PV
30	void xen_entry_INT80_compat(void);	31	void xen_entry_INT80_compat(void);

arch/x86/include/asm/ptrace.h+15−0

@@ -94,6 +94,8 @@ struct pt_regs { · 93 unmodified lines
94	#include <asm/paravirt_types.h>	94	#include <asm/paravirt_types.h>
95	#endif	95	#endif
96		96
		97	#include <asm/proto.h>
		98
97	struct cpuinfo_x86;	99	struct cpuinfo_x86;
98	struct task_struct;	100	struct task_struct;
99		101
@@ -175,6 +177,19 @@ static inline bool any_64bit_mode(struct pt_regs *regs) · 75 unmodified lines
175	#ifdef CONFIG_X86_64	177	#ifdef CONFIG_X86_64
176	#define current_user_stack_pointer() current_pt_regs()->sp	178	#define current_user_stack_pointer() current_pt_regs()->sp
177	#define compat_user_stack_pointer() current_pt_regs()->sp	179	#define compat_user_stack_pointer() current_pt_regs()->sp
		180
		181	static inline bool ip_within_syscall_gap(struct pt_regs *regs)
		182	{
		183	bool ret = (regs->ip >= (unsigned long)entry_SYSCALL_64 &&
		184	regs->ip < (unsigned long)entry_SYSCALL_64_safe_stack);
		185
		186	#ifdef CONFIG_IA32_EMULATION
		187	ret = ret \|\| (regs->ip >= (unsigned long)entry_SYSCALL_compat &&
		188	regs->ip < (unsigned long)entry_SYSCALL_compat_safe_stack);
		189	#endif
		190
		191	return ret;
		192	}
178	#endif	193	#endif
179		194
180	static inline unsigned long kernel_stack_pointer(struct pt_regs *regs)	195	static inline unsigned long kernel_stack_pointer(struct pt_regs *regs)

arch/x86/include/asm/smap.h+4−6

 	unsigned long flags;
 	asm volatile ("# smap_save\n\t"
-		      ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP)
+		      ALTERNATIVE("", "pushf; pop %0; " __ASM_CLAC "\n\t",
-		      "pushf; pop %0; " __ASM_CLAC "\n\t"
+				  X86_FEATURE_SMAP)
-		      "1:"
 		      : "=rm" (flags) : : "memory", "cc");
 	return flags;
 static __always_inline void smap_restore(unsigned long flags)
 {
 	asm volatile ("# smap_restore\n\t"
-		      ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP)
+		      ALTERNATIVE("", "push %0; popf\n\t",
-		      "push %0; popf\n\t"
+				  X86_FEATURE_SMAP)
-		      "1:"
 		      : : "g" (flags) : "memory", "cc");
 }

arch/x86/include/asm/thread_info.h+14−1

@@ -205,10 +205,23 @@ static inline int arch_within_stack_frames(const void * const stack, · 204 unmodified lines
205		205
206	#endif	206	#endif
207		207
		208	/*
		209	* Thread-synchronous status.
		210	*
		211	* This is different from the flags in that nobody else
		212	* ever touches our thread-synchronous status, so we don't
		213	* have to worry about atomic accesses.
		214	*/
		215	#define TS_COMPAT 0x0002 /* 32bit syscall active (64BIT)*/
		216
		217	#ifndef __ASSEMBLY__
208	#ifdef CONFIG_COMPAT	218	#ifdef CONFIG_COMPAT
209	#define TS_I386_REGS_POKED 0x0004 /* regs poked by 32-bit ptracer */	219	#define TS_I386_REGS_POKED 0x0004 /* regs poked by 32-bit ptracer */
		220
		221	#define arch_set_restart_data(restart) \
		222	do { restart->arch_data = current_thread_info()->status; } while (0)
		223
210	#endif	224	#endif
211	#ifndef __ASSEMBLY__
212		225
213	#ifdef CONFIG_X86_32	226	#ifdef CONFIG_X86_32
214	#define in_ia32_syscall() true	227	#define in_ia32_syscall() true

arch/x86/kernel/apic/apic.c+5−0

 	[0 ... NR_CPUS - 1] = -1,
 };
+bool arch_match_cpu_phys_id(int cpu, u64 phys_id)
+{
+	return phys_id == cpuid_to_apicid[cpu];
+}
 #ifdef CONFIG_SMP
 /**
  * apic_id_is_primary_thread - Check whether APIC ID belongs to a primary thread

arch/x86/kernel/apic/io_apic.c+10−0

@@ -1032,6 +1032,16 @@ static int mp_map_pin_to_irq(u32 gsi, int idx, int ioapic, int pin, · 1031 unmodified lines
1032	if (idx >= 0 && test_bit(mp_irqs[idx].srcbus, mp_bus_not_pci)) {	1032	if (idx >= 0 && test_bit(mp_irqs[idx].srcbus, mp_bus_not_pci)) {
1033	irq = mp_irqs[idx].srcbusirq;	1033	irq = mp_irqs[idx].srcbusirq;
1034	legacy = mp_is_legacy_irq(irq);	1034	legacy = mp_is_legacy_irq(irq);
		1035	/*
		1036	* IRQ2 is unusable for historical reasons on systems which
		1037	* have a legacy PIC. See the comment vs. IRQ2 further down.
		1038	*
		1039	* If this gets removed at some point then the related code
		1040	* in lapic_assign_system_vectors() needs to be adjusted as
		1041	* well.
		1042	*/
		1043	if (legacy && irq == PIC_CASCADE_IR)
		1044	return -EINVAL;
1035	}	1045	}
1036		1046
1037	mutex_lock(&ioapic_mutex);	1047	mutex_lock(&ioapic_mutex);

arch/x86/kernel/kprobes/ftrace.c+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12		12
13	#include "common.h"	13	#include "common.h"
14		14
15	/* Ftrace callback handler for kprobes -- called under preepmt disabed */	15	/* Ftrace callback handler for kprobes -- called under preepmt disabled */
16	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,	16	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
17	struct ftrace_ops ops, struct ftrace_regs fregs)	17	struct ftrace_ops ops, struct ftrace_regs fregs)
18	{	18	{

arch/x86/kernel/kvm.c+10−13

 static void kvm_wait(u8 *ptr, u8 val)
 {
-	unsigned long flags;
 	if (in_nmi())
 		return;
-	local_irq_save(flags);
-	if (READ_ONCE(*ptr) != val)
-		goto out;
 	/*
 	 * halt until it's our turn and kicked. Note that we do safe halt
 	 * for irq enabled case to avoid hang when lock info is overwritten
 	 * in irq spinlock slowpath and no spurious interrupt occur to save us.
 	 */
-	if (arch_irqs_disabled_flags(flags))
+	if (irqs_disabled()) {
-		halt();
+		if (READ_ONCE(*ptr) == val)
-	else
+			halt();
-		safe_halt();
+	} else {
+		local_irq_disable();
-out:
+		if (READ_ONCE(*ptr) == val)
-	local_irq_restore(flags);
+			safe_halt();
+		local_irq_enable();
+	}
 }
 #ifdef CONFIG_X86_32

arch/x86/kernel/kvmclock.c+9−10

@@ -268,21 +268,20 @@ static void __init kvmclock_init_mem(void) · 267 unmodified lines
268		268
269	static int __init kvm_setup_vsyscall_timeinfo(void)	269	static int __init kvm_setup_vsyscall_timeinfo(void)
270	{	270	{
271	#ifdef CONFIG_X86_64	271	kvmclock_init_mem();
272	u8 flags;
273		272
274	if (!per_cpu(hv_clock_per_cpu, 0) \|\| !kvmclock_vsyscall)	273	#ifdef CONFIG_X86_64
275	return 0;	274	if (per_cpu(hv_clock_per_cpu, 0) && kvmclock_vsyscall) {
		275	u8 flags;
276		276
277	flags = pvclock_read_flags(&hv_clock_boot[0].pvti);	277	flags = pvclock_read_flags(&hv_clock_boot[0].pvti);
278	if (!(flags & PVCLOCK_TSC_STABLE_BIT))	278	if (!(flags & PVCLOCK_TSC_STABLE_BIT))
279	return 0;	279	return 0;
280		280
281	kvm_clock.vdso_clock_mode = VDSO_CLOCKMODE_PVCLOCK;	281	kvm_clock.vdso_clock_mode = VDSO_CLOCKMODE_PVCLOCK;
		282	}
282	#endif	283	#endif
283		284
284	kvmclock_init_mem();
285
286	return 0;	285	return 0;
287	}	286	}
288	early_initcall(kvm_setup_vsyscall_timeinfo);	287	early_initcall(kvm_setup_vsyscall_timeinfo);

arch/x86/kernel/sev-es.c+17−5

 	cea_set_pte((void *)vaddr, pa, PAGE_KERNEL);
 }
-static __always_inline bool on_vc_stack(unsigned long sp)
+static __always_inline bool on_vc_stack(struct pt_regs *regs)
 {
+	unsigned long sp = regs->sp;
+	/* User-mode RSP is not trusted */
+	if (user_mode(regs))
+		return false;
+	/* SYSCALL gap still has user-mode RSP */
+	if (ip_within_syscall_gap(regs))
+		return false;
 	return ((sp >= __this_cpu_ist_bottom_va(VC)) && (sp < __this_cpu_ist_top_va(VC)));
 }
 	old_ist = __this_cpu_read(cpu_tss_rw.x86_tss.ist[IST_INDEX_VC]);
 	/* Make room on the IST stack */
-	if (on_vc_stack(regs->sp))
+	if (on_vc_stack(regs))
 		new_ist = ALIGN_DOWN(regs->sp, 8) - sizeof(old_ist);
 	else
 		new_ist = old_ist - sizeof(old_ist);
 	int res;
 	if (user_mode(ctxt->regs)) {
-		res = insn_fetch_from_user(ctxt->regs, buffer);
+		res = insn_fetch_from_user_inatomic(ctxt->regs, buffer);
 		if (!res) {
 			ctxt->fi.vector     = X86_TRAP_PF;
 			ctxt->fi.error_code = X86_PF_INSTR | X86_PF_USER;
 DEFINE_IDTENTRY_VC_SAFE_STACK(exc_vmm_communication)
 {
 	struct sev_es_runtime_data *data = this_cpu_read(runtime_data);
+	irqentry_state_t irq_state;
 	struct ghcb_state state;
 	struct es_em_ctxt ctxt;
 	enum es_result result;
 	struct ghcb *ghcb;
-	lockdep_assert_irqs_disabled();
 	/*
 	 * Handle #DB before calling into !noinstr code to avoid recursive #DB.
 	 */
 		return;
 	}
+	irq_state = irqentry_nmi_enter(regs);
+	lockdep_assert_irqs_disabled();
 	instrumentation_begin();
 	/*
 out:
 	instrumentation_end();
+	irqentry_nmi_exit(regs, irq_state);
 	return;

arch/x86/kernel/signal.c+1−23

@@ -766,30 +766,8 @@ handle_signal(struct ksignal ksig, struct pt_regs regs) · 765 unmodified lines
766		766
767	static inline unsigned long get_nr_restart_syscall(const struct pt_regs *regs)	767	static inline unsigned long get_nr_restart_syscall(const struct pt_regs *regs)
768	{	768	{
769	/*
770	* This function is fundamentally broken as currently
771	* implemented.
772	*
773	* The idea is that we want to trigger a call to the
774	* restart_block() syscall and that we want in_ia32_syscall(),
775	* in_x32_syscall(), etc. to match whatever they were in the
776	* syscall being restarted. We assume that the syscall
777	* instruction at (regs->ip - 2) matches whatever syscall
778	* instruction we used to enter in the first place.
779	*
780	* The problem is that we can get here when ptrace pokes
781	* syscall-like values into regs even if we're not in a syscall
782	* at all.
783	*
784	* For now, we maintain historical behavior and guess based on
785	* stored state. We could do better by saving the actual
786	* syscall arch in restart_block or (with caveats on x32) by
787	* checking if regs->ip points to 'int $0x80'. The current
788	* behavior is incorrect if a tracer has a different bitness
789	* than the tracee.
790	*/
791	#ifdef CONFIG_IA32_EMULATION	769	#ifdef CONFIG_IA32_EMULATION
792	if (current_thread_info()->status & (TS_COMPAT\|TS_I386_REGS_POKED))	770	if (current->restart_block.arch_data & TS_COMPAT)
793	return __NR_ia32_restart_syscall;	771	return __NR_ia32_restart_syscall;
794	#endif	772	#endif
795	#ifdef CONFIG_X86_X32_ABI	773	#ifdef CONFIG_X86_X32_ABI

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

 	 * In the SYSCALL entry path the RSP value comes from user-space - don't
 	 * trust it and switch to the current kernel stack
 	 */
-	if (regs->ip >= (unsigned long)entry_SYSCALL_64 &&
+	if (ip_within_syscall_gap(regs)) {
-	    regs->ip <  (unsigned long)entry_SYSCALL_64_safe_stack) {
 		sp = this_cpu_read(cpu_current_top_of_stack);
 		goto sync;
 	}

arch/x86/kernel/unwind_orc.c+7−7

@@ -13,7 +13,7 @@ · 12 unmodified lines
13		13
14	#define orc_warn_current(args...) \	14	#define orc_warn_current(args...) \
15	({ \	15	({ \
16	if (state->task == current) \	16	if (state->task == current && !state->error) \
17	orc_warn(args); \	17	orc_warn(args); \
18	})	18	})
19		19
@@ -367,8 +367,8 @@ static bool deref_stack_regs(struct unwind_state *state, unsigned long addr, · 347 unmodified lines
367	if (!stack_access_ok(state, addr, sizeof(struct pt_regs)))	367	if (!stack_access_ok(state, addr, sizeof(struct pt_regs)))
368	return false;	368	return false;
369		369
370	*ip = regs->ip;	370	*ip = READ_ONCE_NOCHECK(regs->ip);
371	*sp = regs->sp;	371	*sp = READ_ONCE_NOCHECK(regs->sp);
372	return true;	372	return true;
373	}	373	}
374		374
@@ -380,8 +380,8 @@ static bool deref_stack_iret_regs(struct unwind_state *state, unsigned long addr · 5 unmodified lines
380	if (!stack_access_ok(state, addr, IRET_FRAME_SIZE))	380	if (!stack_access_ok(state, addr, IRET_FRAME_SIZE))
381	return false;	381	return false;
382		382
383	*ip = regs->ip;	383	*ip = READ_ONCE_NOCHECK(regs->ip);
384	*sp = regs->sp;	384	*sp = READ_ONCE_NOCHECK(regs->sp);
385	return true;	385	return true;
386	}	386	}
387		387
@@ -402,12 +402,12 @@ static bool get_reg(struct unwind_state *state, unsigned int reg_off, · 14 unmodified lines
402	return false;	402	return false;
403		403
404	if (state->full_regs) {	404	if (state->full_regs) {
405	val = ((unsigned long )state->regs)[reg];	405	val = READ_ONCE_NOCHECK(((unsigned long )state->regs)[reg]);
406	return true;	406	return true;
407	}	407	}
408		408
409	if (state->prev_regs) {	409	if (state->prev_regs) {
410	val = ((unsigned long )state->prev_regs)[reg];	410	val = READ_ONCE_NOCHECK(((unsigned long )state->prev_regs)[reg]);
411	return true;	411	return true;
412	}	412	}
413		413

arch/x86/kvm/hyperv.c+81−10

@@ -520,10 +520,10 @@ static u64 get_time_ref_counter(struct kvm *kvm) · 519 unmodified lines
520	u64 tsc;	520	u64 tsc;
521		521
522	/*	522	/*
523	* The guest has not set up the TSC page or the clock isn't	523	* Fall back to get_kvmclock_ns() when TSC page hasn't been set up,
524	* stable, fall back to get_kvmclock_ns.	524	* is broken, disabled or being updated.
525	*/	525	*/
526	if (!hv->tsc_ref.tsc_sequence)	526	if (hv->hv_tsc_page_status != HV_TSC_PAGE_SET)
527	return div_u64(get_kvmclock_ns(kvm), 100);	527	return div_u64(get_kvmclock_ns(kvm), 100);
528		528
529	vcpu = kvm_get_vcpu(kvm, 0);	529	vcpu = kvm_get_vcpu(kvm, 0);
@@ -1077,6 +1077,21 @@ static bool compute_tsc_page_parameters(struct pvclock_vcpu_time_info *hv_clock, · 547 unmodified lines
1077	return true;	1077	return true;
1078	}	1078	}
1079		1079
		1080	/*
		1081	* Don't touch TSC page values if the guest has opted for TSC emulation after
		1082	* migration. KVM doesn't fully support reenlightenment notifications and TSC
		1083	* access emulation and Hyper-V is known to expect the values in TSC page to
		1084	* stay constant before TSC access emulation is disabled from guest side
		1085	* (HV_X64_MSR_TSC_EMULATION_STATUS). KVM userspace is expected to preserve TSC
		1086	* frequency and guest visible TSC value across migration (and prevent it when
		1087	* TSC scaling is unsupported).
		1088	*/
		1089	static inline bool tsc_page_update_unsafe(struct kvm_hv *hv)
		1090	{
		1091	return (hv->hv_tsc_page_status != HV_TSC_PAGE_GUEST_CHANGED) &&
		1092	hv->hv_tsc_emulation_control;
		1093	}
		1094
1080	void kvm_hv_setup_tsc_page(struct kvm *kvm,	1095	void kvm_hv_setup_tsc_page(struct kvm *kvm,
1081	struct pvclock_vcpu_time_info *hv_clock)	1096	struct pvclock_vcpu_time_info *hv_clock)
1082	{	1097	{
@@ -1087,7 +1102,8 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 4 unmodified lines
1087	BUILD_BUG_ON(sizeof(tsc_seq) != sizeof(hv->tsc_ref.tsc_sequence));	1102	BUILD_BUG_ON(sizeof(tsc_seq) != sizeof(hv->tsc_ref.tsc_sequence));
1088	BUILD_BUG_ON(offsetof(struct ms_hyperv_tsc_page, tsc_sequence) != 0);	1103	BUILD_BUG_ON(offsetof(struct ms_hyperv_tsc_page, tsc_sequence) != 0);
1089		1104
1090	if (!(hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE))	1105	if (hv->hv_tsc_page_status == HV_TSC_PAGE_BROKEN \|\|
		1106	hv->hv_tsc_page_status == HV_TSC_PAGE_UNSET)
1091	return;	1107	return;
1092		1108
1093	mutex_lock(&hv->hv_lock);	1109	mutex_lock(&hv->hv_lock);
@@ -1101,7 +1117,15 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 7 unmodified lines
1101	*/	1117	*/
1102	if (unlikely(kvm_read_guest(kvm, gfn_to_gpa(gfn),	1118	if (unlikely(kvm_read_guest(kvm, gfn_to_gpa(gfn),
1103	&tsc_seq, sizeof(tsc_seq))))	1119	&tsc_seq, sizeof(tsc_seq))))
		1120	goto out_err;
		1121
		1122	if (tsc_seq && tsc_page_update_unsafe(hv)) {
		1123	if (kvm_read_guest(kvm, gfn_to_gpa(gfn), &hv->tsc_ref, sizeof(hv->tsc_ref)))
		1124	goto out_err;
		1125
		1126	hv->hv_tsc_page_status = HV_TSC_PAGE_SET;
1104	goto out_unlock;	1127	goto out_unlock;
		1128	}
1105		1129
1106	/*	1130	/*
1107	* While we're computing and writing the parameters, force the	1131	* While we're computing and writing the parameters, force the
@@ -1110,15 +1134,15 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 2 unmodified lines
1110	hv->tsc_ref.tsc_sequence = 0;	1134	hv->tsc_ref.tsc_sequence = 0;
1111	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),	1135	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),
1112	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))	1136	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))
1113	goto out_unlock;	1137	goto out_err;
1114		1138
1115	if (!compute_tsc_page_parameters(hv_clock, &hv->tsc_ref))	1139	if (!compute_tsc_page_parameters(hv_clock, &hv->tsc_ref))
1116	goto out_unlock;	1140	goto out_err;
1117		1141
1118	/* Ensure sequence is zero before writing the rest of the struct. */	1142	/* Ensure sequence is zero before writing the rest of the struct. */
1119	smp_wmb();	1143	smp_wmb();
1120	if (kvm_write_guest(kvm, gfn_to_gpa(gfn), &hv->tsc_ref, sizeof(hv->tsc_ref)))	1144	if (kvm_write_guest(kvm, gfn_to_gpa(gfn), &hv->tsc_ref, sizeof(hv->tsc_ref)))
1121	goto out_unlock;	1145	goto out_err;
1122		1146
1123	/*	1147	/*
1124	* Now switch to the TSC page mechanism by writing the sequence.	1148	* Now switch to the TSC page mechanism by writing the sequence.
@@ -1131,8 +1155,45 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 6 unmodified lines
1131	smp_wmb();	1155	smp_wmb();
1132		1156
1133	hv->tsc_ref.tsc_sequence = tsc_seq;	1157	hv->tsc_ref.tsc_sequence = tsc_seq;
1134	kvm_write_guest(kvm, gfn_to_gpa(gfn),	1158	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),
1135	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence));	1159	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))
		1160	goto out_err;
		1161
		1162	hv->hv_tsc_page_status = HV_TSC_PAGE_SET;
		1163	goto out_unlock;
		1164
		1165	out_err:
		1166	hv->hv_tsc_page_status = HV_TSC_PAGE_BROKEN;
		1167	out_unlock:
		1168	mutex_unlock(&hv->hv_lock);
		1169	}
		1170
		1171	void kvm_hv_invalidate_tsc_page(struct kvm *kvm)
		1172	{
		1173	struct kvm_hv *hv = to_kvm_hv(kvm);
		1174	u64 gfn;
		1175
		1176	if (hv->hv_tsc_page_status == HV_TSC_PAGE_BROKEN \|\|
		1177	hv->hv_tsc_page_status == HV_TSC_PAGE_UNSET \|\|
		1178	tsc_page_update_unsafe(hv))
		1179	return;
		1180
		1181	mutex_lock(&hv->hv_lock);
		1182
		1183	if (!(hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE))
		1184	goto out_unlock;
		1185
		1186	/* Preserve HV_TSC_PAGE_GUEST_CHANGED/HV_TSC_PAGE_HOST_CHANGED states */
		1187	if (hv->hv_tsc_page_status == HV_TSC_PAGE_SET)
		1188	hv->hv_tsc_page_status = HV_TSC_PAGE_UPDATING;
		1189
		1190	gfn = hv->hv_tsc_page >> HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT;
		1191
		1192	hv->tsc_ref.tsc_sequence = 0;
		1193	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),
		1194	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))
		1195	hv->hv_tsc_page_status = HV_TSC_PAGE_BROKEN;
		1196
1136	out_unlock:	1197	out_unlock:
1137	mutex_unlock(&hv->hv_lock);	1198	mutex_unlock(&hv->hv_lock);
1138	}	1199	}
@@ -1193,8 +1254,15 @@ static int kvm_hv_set_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 data, · 54 unmodified lines
1193	}	1254	}
1194	case HV_X64_MSR_REFERENCE_TSC:	1255	case HV_X64_MSR_REFERENCE_TSC:
1195	hv->hv_tsc_page = data;	1256	hv->hv_tsc_page = data;
1196	if (hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE)	1257	if (hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE) {
		1258	if (!host)
		1259	hv->hv_tsc_page_status = HV_TSC_PAGE_GUEST_CHANGED;
		1260	else
		1261	hv->hv_tsc_page_status = HV_TSC_PAGE_HOST_CHANGED;
1197	kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu);	1262	kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu);
		1263	} else {
		1264	hv->hv_tsc_page_status = HV_TSC_PAGE_UNSET;
		1265	}
1198	break;	1266	break;
1199	case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4:	1267	case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4:
1200	return kvm_hv_msr_set_crash_data(kvm,	1268	return kvm_hv_msr_set_crash_data(kvm,
@@ -1229,6 +1297,9 @@ static int kvm_hv_set_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 data, · 28 unmodified lines
1229	hv->hv_tsc_emulation_control = data;	1297	hv->hv_tsc_emulation_control = data;
1230	break;	1298	break;
1231	case HV_X64_MSR_TSC_EMULATION_STATUS:	1299	case HV_X64_MSR_TSC_EMULATION_STATUS:
		1300	if (data && !host)
		1301	return 1;
		1302
1232	hv->hv_tsc_emulation_status = data;	1303	hv->hv_tsc_emulation_status = data;
1233	break;	1304	break;
1234	case HV_X64_MSR_TIME_REF_COUNT:	1305	case HV_X64_MSR_TIME_REF_COUNT:

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

@@ -133,6 +133,7 @@ void kvm_hv_process_stimers(struct kvm_vcpu *vcpu); · 132 unmodified lines
133		133
134	void kvm_hv_setup_tsc_page(struct kvm *kvm,	134	void kvm_hv_setup_tsc_page(struct kvm *kvm,
135	struct pvclock_vcpu_time_info *hv_clock);	135	struct pvclock_vcpu_time_info *hv_clock);
		136	void kvm_hv_invalidate_tsc_page(struct kvm *kvm);
136		137
137	void kvm_hv_init_vm(struct kvm *kvm);	138	void kvm_hv_init_vm(struct kvm *kvm);
138	void kvm_hv_destroy_vm(struct kvm *kvm);	139	void kvm_hv_destroy_vm(struct kvm *kvm);

arch/x86/kvm/lapic.c+11−1

 	}
 	if (kvm_use_posted_timer_interrupt(apic->vcpu)) {
-		kvm_wait_lapic_expire(vcpu);
+		/*
+		 * Ensure the guest's timer has truly expired before posting an
+		 * interrupt.  Open code the relevant checks to avoid querying
+		 * lapic_timer_int_injected(), which will be false since the
+		 * interrupt isn't yet injected.  Waiting until after injecting
+		 * is not an option since that won't help a posted interrupt.
+		 */
+		if (vcpu->arch.apic->lapic_timer.expired_tscdeadline &&
+		    vcpu->arch.apic->lapic_timer.timer_advance_ns)
+			__kvm_wait_lapic_expire(vcpu);
 		kvm_apic_inject_pending_timer_irqs(apic);
 		return;
 	}
 	apic_update_ppr(apic);
 	hrtimer_cancel(&apic->lapic_timer.timer);
+	apic->lapic_timer.expired_tscdeadline = 0;
 	apic_update_lvtt(apic);
 	apic_manage_nmi_watchdog(apic, kvm_lapic_get_reg(apic, APIC_LVT0));
 	update_divide_count(apic);

arch/x86/kvm/mmu/mmu_internal.h+5−0

 	return to_shadow_page(__pa(sptep));
 }
+static inline int kvm_mmu_page_as_id(struct kvm_mmu_page *sp)
+{
+	return sp->role.smm ? 1 : 0;
+}
 static inline bool kvm_vcpu_ad_need_write_protect(struct kvm_vcpu *vcpu)
 {
 	/*

arch/x86/kvm/mmu/tdp_iter.c+18−12

 	return gfn & -KVM_PAGES_PER_HPAGE(level);
 }
+/*
+ * Return the TDP iterator to the root PT and allow it to continue its
+ * traversal over the paging structure from there.
+ */
+void tdp_iter_restart(struct tdp_iter *iter)
+{
+	iter->yielded_gfn = iter->next_last_level_gfn;
+	iter->level = iter->root_level;
+	iter->gfn = round_gfn_for_level(iter->next_last_level_gfn, iter->level);
+	tdp_iter_refresh_sptep(iter);
+	iter->valid = true;
+}
 /*
  * Sets a TDP iterator to walk a pre-order traversal of the paging structure
  * rooted at root_pt, starting with the walk to translate next_last_level_gfn.
 	WARN_ON(root_level > PT64_ROOT_MAX_LEVEL);
 	iter->next_last_level_gfn = next_last_level_gfn;
-	iter->yielded_gfn = iter->next_last_level_gfn;
 	iter->root_level = root_level;
 	iter->min_level = min_level;
-	iter->level = root_level;
+	iter->pt_path[iter->root_level - 1] = (tdp_ptep_t)root_pt;
-	iter->pt_path[iter->level - 1] = (tdp_ptep_t)root_pt;
+	iter->as_id = kvm_mmu_page_as_id(sptep_to_sp(root_pt));
-	iter->gfn = round_gfn_for_level(iter->next_last_level_gfn, iter->level);
-	tdp_iter_refresh_sptep(iter);
-	iter->valid = true;
+	tdp_iter_restart(iter);
 }
 /*
 	iter->valid = false;
 }
-tdp_ptep_t tdp_iter_root_pt(struct tdp_iter *iter)
-{
-	return iter->pt_path[iter->root_level - 1];
-}

arch/x86/kvm/mmu/tdp_iter.h+3−1

 	int min_level;
 	/* The iterator's current level within the paging structure */
 	int level;
+	/* The address space ID, i.e. SMM vs. regular. */
+	int as_id;
 	/* A snapshot of the value at sptep */
 	u64 old_spte;
 	/*
 void tdp_iter_start(struct tdp_iter *iter, u64 *root_pt, int root_level,
 		    int min_level, gfn_t next_last_level_gfn);
 void tdp_iter_next(struct tdp_iter *iter);
-tdp_ptep_t tdp_iter_root_pt(struct tdp_iter *iter);
+void tdp_iter_restart(struct tdp_iter *iter);
 #endif /* __KVM_X86_MMU_TDP_ITER_H */

arch/x86/kvm/mmu/tdp_mmu.c+26−25

 				u64 old_spte, u64 new_spte, int level,
 				bool shared);
-static int kvm_mmu_page_as_id(struct kvm_mmu_page *sp)
-{
-	return sp->role.smm ? 1 : 0;
-}
 static void handle_changed_spte_acc_track(u64 old_spte, u64 new_spte, int level)
 {
 	bool pfn_changed = spte_to_pfn(old_spte) != spte_to_pfn(new_spte);
  *
  * Given a page table that has been removed from the TDP paging structure,
  * iterates through the page table to clear SPTEs and free child page tables.
+ *
+ * Note that pt is passed in as a tdp_ptep_t, but it does not need RCU
+ * protection. Since this thread removed it from the paging structure,
+ * this thread will be responsible for ensuring the page is freed. Hence the
+ * early rcu_dereferences in the function.
  */
-static void handle_removed_tdp_mmu_page(struct kvm *kvm, u64 *pt,
+static void handle_removed_tdp_mmu_page(struct kvm *kvm, tdp_ptep_t pt,
 					bool shared)
 {
-	struct kvm_mmu_page *sp = sptep_to_sp(pt);
+	struct kvm_mmu_page *sp = sptep_to_sp(rcu_dereference(pt));
 	int level = sp->role.level;
 	gfn_t base_gfn = sp->gfn;
 	u64 old_child_spte;
 	tdp_mmu_unlink_page(kvm, sp, shared);
 	for (i = 0; i < PT64_ENT_PER_PAGE; i++) {
-		sptep = pt + i;
+		sptep = rcu_dereference(pt) + i;
 		gfn = base_gfn + (i * KVM_PAGES_PER_HPAGE(level - 1));
 		if (shared) {
 				cpu_relax();
 			}
 		} else {
+			/*
+			 * If the SPTE is not MMU-present, there is no backing
+			 * page associated with the SPTE and so no side effects
+			 * that need to be recorded, and exclusive ownership of
+			 * mmu_lock ensures the SPTE can't be made present.
+			 * Note, zapping MMIO SPTEs is also unnecessary as they
+			 * are guarded by the memslots generation, not by being
+			 * unreachable.
+			 */
 			old_child_spte = READ_ONCE(*sptep);
+			if (!is_shadow_present_pte(old_child_spte))
+				continue;
 			/*
 			 * Marking the SPTE as a removed SPTE is not
 					   struct tdp_iter *iter,
 					   u64 new_spte)
 {
-	u64 *root_pt = tdp_iter_root_pt(iter);
-	struct kvm_mmu_page *root = sptep_to_sp(root_pt);
-	int as_id = kvm_mmu_page_as_id(root);
 	lockdep_assert_held_read(&kvm->mmu_lock);
 	/*
 		      new_spte) != iter->old_spte)
 		return false;
-	handle_changed_spte(kvm, as_id, iter->gfn, iter->old_spte, new_spte,
+	handle_changed_spte(kvm, iter->as_id, iter->gfn, iter->old_spte,
-			    iter->level, true);
+			    new_spte, iter->level, true);
 	return true;
 }
 	 * here since the SPTE is going from non-present
 	 * to non-present.
 	 */
-	WRITE_ONCE(*iter->sptep, 0);
+	WRITE_ONCE(*rcu_dereference(iter->sptep), 0);
 	return true;
 }
 				      u64 new_spte, bool record_acc_track,
 				      bool record_dirty_log)
 {
-	tdp_ptep_t root_pt = tdp_iter_root_pt(iter);
-	struct kvm_mmu_page *root = sptep_to_sp(root_pt);
-	int as_id = kvm_mmu_page_as_id(root);
 	lockdep_assert_held_write(&kvm->mmu_lock);
 	/*
 	WRITE_ONCE(*rcu_dereference(iter->sptep), new_spte);
-	__handle_changed_spte(kvm, as_id, iter->gfn, iter->old_spte, new_spte,
+	__handle_changed_spte(kvm, iter->as_id, iter->gfn, iter->old_spte,
-			      iter->level, false);
+			      new_spte, iter->level, false);
 	if (record_acc_track)
 		handle_changed_spte_acc_track(iter->old_spte, new_spte,
 					      iter->level);
 	if (record_dirty_log)
-		handle_changed_spte_dirty_log(kvm, as_id, iter->gfn,
+		handle_changed_spte_dirty_log(kvm, iter->as_id, iter->gfn,
 					      iter->old_spte, new_spte,
 					      iter->level);
 }
 		WARN_ON(iter->gfn > iter->next_last_level_gfn);
-		tdp_iter_start(iter, iter->pt_path[iter->root_level - 1],
+		tdp_iter_restart(iter);
-			       iter->root_level, iter->min_level,
-			       iter->next_last_level_gfn);
 		return true;
 	}

arch/x86/kvm/svm/svm.c+13−12

 	{ .index = MSR_INVALID,				.always = false },
 };
-/* enable NPT for AMD64 and X86 with PAE */
-#if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
-bool npt_enabled = true;
-#else
-bool npt_enabled;
-#endif
 /*
  * These 2 parameters are used to config the controls for Pause-Loop Exiting:
  * pause_filter_count: On processors that support Pause filtering(indicated
 static unsigned short pause_filter_count_max = KVM_SVM_DEFAULT_PLE_WINDOW_MAX;
 module_param(pause_filter_count_max, ushort, 0444);
-/* allow nested paging (virtualized MMU) for all guests */
+/*
-static int npt = true;
+ * Use nested page tables by default.  Note, NPT may get forced off by
-module_param(npt, int, S_IRUGO);
+ * svm_hardware_setup() if it's unsupported by hardware or the host kernel.
+ */
+bool npt_enabled = true;
+module_param_named(npt, npt_enabled, bool, 0444);
 /* allow nested virtualization in KVM/SVM */
 static int nested = true;
 			goto err;
 	}
-	if (!boot_cpu_has(X86_FEATURE_NPT))
+	/*
+	 * KVM's MMU doesn't support using 2-level paging for itself, and thus
+	 * NPT isn't supported if the host is using 2-level paging since host
+	 * CR4 is unchanged on VMRUN.
+	 */
+	if (!IS_ENABLED(CONFIG_X86_64) && !IS_ENABLED(CONFIG_X86_PAE))
 		npt_enabled = false;
-	if (npt_enabled && !npt)
+	if (!boot_cpu_has(X86_FEATURE_NPT))
 		npt_enabled = false;
 	kvm_configure_mmu(npt_enabled, get_max_npt_level(), PG_LEVEL_1G);

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

@@ -6580,8 +6580,8 @@ static void atomic_switch_perf_msrs(struct vcpu_vmx *vmx) · 6579 unmodified lines
6580	int i, nr_msrs;	6580	int i, nr_msrs;
6581	struct perf_guest_switch_msr *msrs;	6581	struct perf_guest_switch_msr *msrs;
6582		6582
		6583	/* Note, nr_msrs may be garbage if perf_guest_get_msrs() returns NULL. */
6583	msrs = perf_guest_get_msrs(&nr_msrs);	6584	msrs = perf_guest_get_msrs(&nr_msrs);
6584
6585	if (!msrs)	6585	if (!msrs)
6586	return;	6586	return;
6587		6587

arch/x86/kvm/x86.c+69−46

@@ -1526,35 +1526,44 @@ EXPORT_SYMBOL_GPL(kvm_enable_efer_bits); · 1525 unmodified lines
1526		1526
1527	bool kvm_msr_allowed(struct kvm_vcpu *vcpu, u32 index, u32 type)	1527	bool kvm_msr_allowed(struct kvm_vcpu *vcpu, u32 index, u32 type)
1528	{	1528	{
		1529	struct kvm_x86_msr_filter *msr_filter;
		1530	struct msr_bitmap_range *ranges;
1529	struct kvm *kvm = vcpu->kvm;	1531	struct kvm *kvm = vcpu->kvm;
1530	struct msr_bitmap_range *ranges = kvm->arch.msr_filter.ranges;	1532	bool allowed;
1531	u32 count = kvm->arch.msr_filter.count;
1532	u32 i;
1533	bool r = kvm->arch.msr_filter.default_allow;
1534	int idx;	1533	int idx;
		1534	u32 i;
1535		1535
1536	/* MSR filtering not set up or x2APIC enabled, allow everything */	1536	/* x2APIC MSRs do not support filtering. */
1537	if (!count \|\| (index >= 0x800 && index <= 0x8ff))	1537	if (index >= 0x800 && index <= 0x8ff)
1538	return true;	1538	return true;
1539		1539
1540	/* Prevent collision with set_msr_filter */
1541	idx = srcu_read_lock(&kvm->srcu);	1540	idx = srcu_read_lock(&kvm->srcu);
1542		1541
1543	for (i = 0; i < count; i++) {	1542	msr_filter = srcu_dereference(kvm->arch.msr_filter, &kvm->srcu);
		1543	if (!msr_filter) {
		1544	allowed = true;
		1545	goto out;
		1546	}
		1547
		1548	allowed = msr_filter->default_allow;
		1549	ranges = msr_filter->ranges;
		1550
		1551	for (i = 0; i < msr_filter->count; i++) {
1544	u32 start = ranges[i].base;	1552	u32 start = ranges[i].base;
1545	u32 end = start + ranges[i].nmsrs;	1553	u32 end = start + ranges[i].nmsrs;
1546	u32 flags = ranges[i].flags;	1554	u32 flags = ranges[i].flags;
1547	unsigned long *bitmap = ranges[i].bitmap;	1555	unsigned long *bitmap = ranges[i].bitmap;
1548		1556
1549	if ((index >= start) && (index < end) && (flags & type)) {	1557	if ((index >= start) && (index < end) && (flags & type)) {
1550	r = !!test_bit(index - start, bitmap);	1558	allowed = !!test_bit(index - start, bitmap);
1551	break;	1559	break;
1552	}	1560	}
1553	}	1561	}
1554		1562
		1563	out:
1555	srcu_read_unlock(&kvm->srcu, idx);	1564	srcu_read_unlock(&kvm->srcu, idx);
1556		1565
1557	return r;	1566	return allowed;
1558	}	1567	}
1559	EXPORT_SYMBOL_GPL(kvm_msr_allowed);	1568	EXPORT_SYMBOL_GPL(kvm_msr_allowed);
1560		1569
@@ -2551,6 +2560,8 @@ static void kvm_gen_update_masterclock(struct kvm *kvm) · 990 unmodified lines
2551	struct kvm_vcpu *vcpu;	2560	struct kvm_vcpu *vcpu;
2552	struct kvm_arch *ka = &kvm->arch;	2561	struct kvm_arch *ka = &kvm->arch;
2553		2562
		2563	kvm_hv_invalidate_tsc_page(kvm);
		2564
2554	spin_lock(&ka->pvclock_gtod_sync_lock);	2565	spin_lock(&ka->pvclock_gtod_sync_lock);
2555	kvm_make_mclock_inprogress_request(kvm);	2566	kvm_make_mclock_inprogress_request(kvm);
2556	/* no guest entries from this point */	2567	/* no guest entries from this point */
@@ -5352,25 +5363,34 @@ split_irqchip_unlock: · 2795 unmodified lines
5352	return r;	5363	return r;
5353	}	5364	}
5354		5365
5355	static void kvm_clear_msr_filter(struct kvm *kvm)	5366	static struct kvm_x86_msr_filter *kvm_alloc_msr_filter(bool default_allow)
		5367	{
		5368	struct kvm_x86_msr_filter *msr_filter;
		5369
		5370	msr_filter = kzalloc(sizeof(*msr_filter), GFP_KERNEL_ACCOUNT);
		5371	if (!msr_filter)
		5372	return NULL;
		5373
		5374	msr_filter->default_allow = default_allow;
		5375	return msr_filter;
		5376	}
		5377
		5378	static void kvm_free_msr_filter(struct kvm_x86_msr_filter *msr_filter)
5356	{	5379	{
5357	u32 i;	5380	u32 i;
5358	u32 count = kvm->arch.msr_filter.count;
5359	struct msr_bitmap_range ranges[16];
5360		5381
5361	mutex_lock(&kvm->lock);	5382	if (!msr_filter)
5362	kvm->arch.msr_filter.count = 0;	5383	return;
5363	memcpy(ranges, kvm->arch.msr_filter.ranges, count * sizeof(ranges[0]));	5384
5364	mutex_unlock(&kvm->lock);	5385	for (i = 0; i < msr_filter->count; i++)
5365	synchronize_srcu(&kvm->srcu);	5386	kfree(msr_filter->ranges[i].bitmap);
5366		5387
5367	for (i = 0; i < count; i++)	5388	kfree(msr_filter);
5368	kfree(ranges[i].bitmap);
5369	}	5389	}
5370		5390
5371	static int kvm_add_msr_filter(struct kvm kvm, struct kvm_msr_filter_range user_range)	5391	static int kvm_add_msr_filter(struct kvm_x86_msr_filter *msr_filter,
		5392	struct kvm_msr_filter_range *user_range)
5372	{	5393	{
5373	struct msr_bitmap_range *ranges = kvm->arch.msr_filter.ranges;
5374	struct msr_bitmap_range range;	5394	struct msr_bitmap_range range;
5375	unsigned long *bitmap = NULL;	5395	unsigned long *bitmap = NULL;
5376	size_t bitmap_size;	5396	size_t bitmap_size;
@@ -5404,11 +5424,9 @@ static int kvm_add_msr_filter(struct kvm kvm, struct kvm_msr_filter_range user · 27 unmodified lines
5404	goto err;	5424	goto err;
5405	}	5425	}
5406		5426
5407	/* Everything ok, add this range identifier to our global pool */	5427	/* Everything ok, add this range identifier. */
5408	ranges[kvm->arch.msr_filter.count] = range;	5428	msr_filter->ranges[msr_filter->count] = range;
5409	/* Make sure we filled the array before we tell anyone to walk it */	5429	msr_filter->count++;
5410	smp_wmb();
5411	kvm->arch.msr_filter.count++;
5412		5430
5413	return 0;	5431	return 0;
5414	err:	5432	err:
@@ -5419,10 +5437,11 @@ err: · 4 unmodified lines
5419	static int kvm_vm_ioctl_set_msr_filter(struct kvm kvm, void __user argp)	5437	static int kvm_vm_ioctl_set_msr_filter(struct kvm kvm, void __user argp)
5420	{	5438	{
5421	struct kvm_msr_filter __user *user_msr_filter = argp;	5439	struct kvm_msr_filter __user *user_msr_filter = argp;
		5440	struct kvm_x86_msr_filter new_filter, old_filter;
5422	struct kvm_msr_filter filter;	5441	struct kvm_msr_filter filter;
5423	bool default_allow;	5442	bool default_allow;
5424	int r = 0;
5425	bool empty = true;	5443	bool empty = true;
		5444	int r = 0;
5426	u32 i;	5445	u32 i;
5427		5446
5428	if (copy_from_user(&filter, user_msr_filter, sizeof(filter)))	5447	if (copy_from_user(&filter, user_msr_filter, sizeof(filter)))
@@ -5435,25 +5454,32 @@ static int kvm_vm_ioctl_set_msr_filter(struct kvm kvm, void __user argp) · 6 unmodified lines
5435	if (empty && !default_allow)	5454	if (empty && !default_allow)
5436	return -EINVAL;	5455	return -EINVAL;
5437		5456
5438	kvm_clear_msr_filter(kvm);	5457	new_filter = kvm_alloc_msr_filter(default_allow);
5439		5458	if (!new_filter)
5440	kvm->arch.msr_filter.default_allow = default_allow;	5459	return -ENOMEM;
5441		5460
5442	/*
5443	* Protect from concurrent calls to this function that could trigger
5444	* a TOCTOU violation on kvm->arch.msr_filter.count.
5445	*/
5446	mutex_lock(&kvm->lock);
5447	for (i = 0; i < ARRAY_SIZE(filter.ranges); i++) {	5461	for (i = 0; i < ARRAY_SIZE(filter.ranges); i++) {
5448	r = kvm_add_msr_filter(kvm, &filter.ranges[i]);	5462	r = kvm_add_msr_filter(new_filter, &filter.ranges[i]);
5449	if (r)	5463	if (r) {
5450	break;	5464	kvm_free_msr_filter(new_filter);
		5465	return r;
		5466	}
5451	}	5467	}
5452		5468
		5469	mutex_lock(&kvm->lock);
		5470
		5471	/* The per-VM filter is protected by kvm->lock... */
		5472	old_filter = srcu_dereference_check(kvm->arch.msr_filter, &kvm->srcu, 1);
		5473
		5474	rcu_assign_pointer(kvm->arch.msr_filter, new_filter);
		5475	synchronize_srcu(&kvm->srcu);
		5476
		5477	kvm_free_msr_filter(old_filter);
		5478
5453	kvm_make_all_cpus_request(kvm, KVM_REQ_MSR_FILTER_CHANGED);	5479	kvm_make_all_cpus_request(kvm, KVM_REQ_MSR_FILTER_CHANGED);
5454	mutex_unlock(&kvm->lock);	5480	mutex_unlock(&kvm->lock);
5455		5481
5456	return r;	5482	return 0;
5457	}	5483	}
5458		5484
5459	long kvm_arch_vm_ioctl(struct file *filp,	5485	long kvm_arch_vm_ioctl(struct file *filp,
@@ -6603,7 +6629,7 @@ static int kvm_emulate_wbinvd_noskip(struct kvm_vcpu *vcpu) · 1143 unmodified lines
6603	int cpu = get_cpu();	6629	int cpu = get_cpu();
6604		6630
6605	cpumask_set_cpu(cpu, vcpu->arch.wbinvd_dirty_mask);	6631	cpumask_set_cpu(cpu, vcpu->arch.wbinvd_dirty_mask);
6606	smp_call_function_many(vcpu->arch.wbinvd_dirty_mask,	6632	on_each_cpu_mask(vcpu->arch.wbinvd_dirty_mask,
6607	wbinvd_ipi, NULL, 1);	6633	wbinvd_ipi, NULL, 1);
6608	put_cpu();	6634	put_cpu();
6609	cpumask_clear(vcpu->arch.wbinvd_dirty_mask);	6635	cpumask_clear(vcpu->arch.wbinvd_dirty_mask);
@@ -10601,7 +10627,7 @@ void __user * __x86_set_memory_region(struct kvm *kvm, int id, gpa_t gpa, · 3991 unmodified lines
10601	return (void __user *)hva;	10627	return (void __user *)hva;
10602	} else {	10628	} else {
10603	if (!slot \|\| !slot->npages)	10629	if (!slot \|\| !slot->npages)
10604	return 0;	10630	return NULL;
10605		10631
10606	old_npages = slot->npages;	10632	old_npages = slot->npages;
10607	hva = slot->userspace_addr;	10633	hva = slot->userspace_addr;
@@ -10634,8 +10660,6 @@ void kvm_arch_pre_destroy_vm(struct kvm *kvm) · 26 unmodified lines
10634		10660
10635	void kvm_arch_destroy_vm(struct kvm *kvm)	10661	void kvm_arch_destroy_vm(struct kvm *kvm)
10636	{	10662	{
10637	u32 i;
10638
10639	if (current->mm == kvm->mm) {	10663	if (current->mm == kvm->mm) {
10640	/*	10664	/*
10641	* Free memory regions allocated on behalf of userspace,	10665	* Free memory regions allocated on behalf of userspace,
@@ -10651,8 +10675,7 @@ void kvm_arch_destroy_vm(struct kvm *kvm) · 9 unmodified lines
10651	mutex_unlock(&kvm->slots_lock);	10675	mutex_unlock(&kvm->slots_lock);
10652	}	10676	}
10653	static_call_cond(kvm_x86_vm_destroy)(kvm);	10677	static_call_cond(kvm_x86_vm_destroy)(kvm);
10654	for (i = 0; i < kvm->arch.msr_filter.count; i++)	10678	kvm_free_msr_filter(srcu_dereference_check(kvm->arch.msr_filter, &kvm->srcu, 1));
10655	kfree(kvm->arch.msr_filter.ranges[i].bitmap);
10656	kvm_pic_destroy(kvm);	10679	kvm_pic_destroy(kvm);
10657	kvm_ioapic_destroy(kvm);	10680	kvm_ioapic_destroy(kvm);
10658	kvm_free_vcpus(kvm);	10681	kvm_free_vcpus(kvm);

arch/x86/lib/insn-eval.c+52−14

@@ -1415,6 +1415,25 @@ void __user insn_get_addr_ref(struct insn insn, struct pt_regs *regs) · 1414 unmodified lines
1415	}	1415	}
1416	}	1416	}
1417		1417
		1418	static unsigned long insn_get_effective_ip(struct pt_regs *regs)
		1419	{
		1420	unsigned long seg_base = 0;
		1421
		1422	/*
		1423	* If not in user-space long mode, a custom code segment could be in
		1424	* use. This is true in protected mode (if the process defined a local
		1425	* descriptor table), or virtual-8086 mode. In most of the cases
		1426	* seg_base will be zero as in USER_CS.
		1427	*/
		1428	if (!user_64bit_mode(regs)) {
		1429	seg_base = insn_get_seg_base(regs, INAT_SEG_REG_CS);
		1430	if (seg_base == -1L)
		1431	return 0;
		1432	}
		1433
		1434	return seg_base + regs->ip;
		1435	}
		1436
1418	/**	1437	/**
1419	* insn_fetch_from_user() - Copy instruction bytes from user-space memory	1438	* insn_fetch_from_user() - Copy instruction bytes from user-space memory
1420	* @regs: Structure with register values as seen when entering kernel mode	1439	* @regs: Structure with register values as seen when entering kernel mode
@@ -1431,24 +1450,43 @@ void __user insn_get_addr_ref(struct insn insn, struct pt_regs *regs) · 10 unmodified lines
1431	*/	1450	*/
1432	int insn_fetch_from_user(struct pt_regs *regs, unsigned char buf[MAX_INSN_SIZE])	1451	int insn_fetch_from_user(struct pt_regs *regs, unsigned char buf[MAX_INSN_SIZE])
1433	{	1452	{
1434	unsigned long seg_base = 0;	1453	unsigned long ip;
1435	int not_copied;	1454	int not_copied;
1436		1455
1437	/*	1456	ip = insn_get_effective_ip(regs);
1438	* If not in user-space long mode, a custom code segment could be in	1457	if (!ip)
1439	* use. This is true in protected mode (if the process defined a local	1458	return 0;
1440	* descriptor table), or virtual-8086 mode. In most of the cases	1459
1441	* seg_base will be zero as in USER_CS.	1460	not_copied = copy_from_user(buf, (void __user *)ip, MAX_INSN_SIZE);
1442	*/
1443	if (!user_64bit_mode(regs)) {
1444	seg_base = insn_get_seg_base(regs, INAT_SEG_REG_CS);
1445	if (seg_base == -1L)
1446	return 0;
1447	}
1448		1461
		1462	return MAX_INSN_SIZE - not_copied;
		1463	}
		1464
		1465	/**
		1466	* insn_fetch_from_user_inatomic() - Copy instruction bytes from user-space memory
		1467	* while in atomic code
		1468	* @regs: Structure with register values as seen when entering kernel mode
		1469	* @buf: Array to store the fetched instruction
		1470	*
		1471	* Gets the linear address of the instruction and copies the instruction bytes
		1472	* to the buf. This function must be used in atomic context.
		1473	*
		1474	* Returns:
		1475	*
		1476	* Number of instruction bytes copied.
		1477	*
		1478	* 0 if nothing was copied.
		1479	*/
		1480	int insn_fetch_from_user_inatomic(struct pt_regs *regs, unsigned char buf[MAX_INSN_SIZE])
		1481	{
		1482	unsigned long ip;
		1483	int not_copied;
		1484
		1485	ip = insn_get_effective_ip(regs);
		1486	if (!ip)
		1487	return 0;
1449		1488
1450	not_copied = copy_from_user(buf, (void __user *)(seg_base + regs->ip),	1489	not_copied = __copy_from_user_inatomic(buf, (void __user *)ip, MAX_INSN_SIZE);
1451	MAX_INSN_SIZE);
1452		1490
1453	return MAX_INSN_SIZE - not_copied;	1491	return MAX_INSN_SIZE - not_copied;
1454	}	1492	}

arch/x86/net/bpf_jit_comp.c+25−6

  * add rsp, 8                      // skip eth_type_trans's frame
  * ret                             // return to its caller
  */
-int arch_prepare_bpf_trampoline(void *image, void *image_end,
+int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *image_end,
 				const struct btf_func_model *m, u32 flags,
 				struct bpf_tramp_progs *tprogs,
 				void *orig_call)
 	save_regs(m, &prog, nr_args, stack_size);
+	if (flags & BPF_TRAMP_F_CALL_ORIG) {
+		/* arg1: mov rdi, im */
+		emit_mov_imm64(&prog, BPF_REG_1, (long) im >> 32, (u32) (long) im);
+		if (emit_call(&prog, __bpf_tramp_enter, prog)) {
+			ret = -EINVAL;
+			goto cleanup;
+		}
+	}
 	if (fentry->nr_progs)
 		if (invoke_bpf(m, &prog, fentry, stack_size))
 			return -EINVAL;
 	}
 	if (flags & BPF_TRAMP_F_CALL_ORIG) {
-		if (fentry->nr_progs || fmod_ret->nr_progs)
+		restore_regs(m, &prog, nr_args, stack_size);
-			restore_regs(m, &prog, nr_args, stack_size);
 		/* call original function */
 		if (emit_call(&prog, orig_call, prog)) {
 		}
 		/* remember return value in a stack for bpf prog to access */
 		emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);
+		im->ip_after_call = prog;
+		memcpy(prog, ideal_nops[NOP_ATOMIC5], X86_PATCH_SIZE);
+		prog += X86_PATCH_SIZE;
 	}
 	if (fmod_ret->nr_progs) {
 	 * the return value is only updated on the stack and still needs to be
 	 * restored to R0.
 	 */
-	if (flags & BPF_TRAMP_F_CALL_ORIG)
+	if (flags & BPF_TRAMP_F_CALL_ORIG) {
+		im->ip_epilogue = prog;
+		/* arg1: mov rdi, im */
+		emit_mov_imm64(&prog, BPF_REG_1, (long) im >> 32, (u32) (long) im);
+		if (emit_call(&prog, __bpf_tramp_exit, prog)) {
+			ret = -EINVAL;
+			goto cleanup;
+		}
 		/* restore original return value back into RAX */
 		emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, -8);
+	}
 	EMIT1(0x5B); /* pop rbx */
 	EMIT1(0xC9); /* leave */
 		padding = true;
 		goto skip_init_addrs;
 	}
-	addrs = kmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL);
+	addrs = kvmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL);
 	if (!addrs) {
 		prog = orig_prog;
 		goto out_addrs;
 		if (image)
 			bpf_prog_fill_jited_linfo(prog, addrs + 1);
 out_addrs:
-		kfree(addrs);
+		kvfree(addrs);
 		kfree(jit_data);
 		prog->aux->jit_data = NULL;
 	}

arch/x86/platform/iris/iris.c+0−1

@@ -27,7 +27,6 @@ · 26 unmodified lines
27	MODULE_LICENSE("GPL");	27	MODULE_LICENSE("GPL");
28	MODULE_AUTHOR("Sébastien Hinderer <Sebastien.Hinderer@ens-lyon.org>");	28	MODULE_AUTHOR("Sébastien Hinderer <Sebastien.Hinderer@ens-lyon.org>");
29	MODULE_DESCRIPTION("A power_off handler for Iris devices from EuroBraille");	29	MODULE_DESCRIPTION("A power_off handler for Iris devices from EuroBraille");
30	MODULE_SUPPORTED_DEVICE("Eurobraille/Iris");
31		30
32	static bool force;	31	static bool force;
33		32

arch/x86/xen/p2m.c+2−4

 		map_ops[i].status = GNTST_general_error;
 		unmap[0].host_addr = map_ops[i].host_addr,
 		unmap[0].handle = map_ops[i].handle;
-		map_ops[i].handle = ~0;
+		map_ops[i].handle = INVALID_GRANT_HANDLE;
 		if (map_ops[i].flags & GNTMAP_device_map)
 			unmap[0].dev_bus_addr = map_ops[i].dev_bus_addr;
 		else
 			kmap_ops[i].status = GNTST_general_error;
 			unmap[1].host_addr = kmap_ops[i].host_addr,
 			unmap[1].handle = kmap_ops[i].handle;
-			kmap_ops[i].handle = ~0;
+			kmap_ops[i].handle = INVALID_GRANT_HANDLE;
 			if (kmap_ops[i].flags & GNTMAP_device_map)
 				unmap[1].dev_bus_addr = kmap_ops[i].dev_bus_addr;
 			else
 out:
 	return ret;
 }
-EXPORT_SYMBOL_GPL(set_foreign_p2m_mapping);
 int clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops,
 			      struct gnttab_unmap_grant_ref *kunmap_ops,
 	return ret;
 }
-EXPORT_SYMBOL_GPL(clear_foreign_p2m_mapping);
 #ifdef CONFIG_XEN_DEBUG_FS
 #include <linux/debugfs.h>

block/bio.c+7−7

@@ -33,7 +33,7 @@ static struct biovec_slab { · 32 unmodified lines
33	{ .nr_vecs = 16, .name = "biovec-16" },	33	{ .nr_vecs = 16, .name = "biovec-16" },
34	{ .nr_vecs = 64, .name = "biovec-64" },	34	{ .nr_vecs = 64, .name = "biovec-64" },
35	{ .nr_vecs = 128, .name = "biovec-128" },	35	{ .nr_vecs = 128, .name = "biovec-128" },
36	{ .nr_vecs = BIO_MAX_PAGES, .name = "biovec-max" },	36	{ .nr_vecs = BIO_MAX_VECS, .name = "biovec-max" },
37	};	37	};
38		38
39	static struct biovec_slab *biovec_slab(unsigned short nr_vecs)	39	static struct biovec_slab *biovec_slab(unsigned short nr_vecs)
@@ -46,7 +46,7 @@ static struct biovec_slab *biovec_slab(unsigned short nr_vecs) · 6 unmodified lines
46	return &bvec_slabs[1];	46	return &bvec_slabs[1];
47	case 65 ... 128:	47	case 65 ... 128:
48	return &bvec_slabs[2];	48	return &bvec_slabs[2];
49	case 129 ... BIO_MAX_PAGES:	49	case 129 ... BIO_MAX_VECS:
50	return &bvec_slabs[3];	50	return &bvec_slabs[3];
51	default:	51	default:
52	BUG();	52	BUG();
@@ -151,9 +151,9 @@ out: · 98 unmodified lines
151		151
152	void bvec_free(mempool_t pool, struct bio_vec bv, unsigned short nr_vecs)	152	void bvec_free(mempool_t pool, struct bio_vec bv, unsigned short nr_vecs)
153	{	153	{
154	BIO_BUG_ON(nr_vecs > BIO_MAX_PAGES);	154	BIO_BUG_ON(nr_vecs > BIO_MAX_VECS);
155		155
156	if (nr_vecs == BIO_MAX_PAGES)	156	if (nr_vecs == BIO_MAX_VECS)
157	mempool_free(bv, pool);	157	mempool_free(bv, pool);
158	else if (nr_vecs > BIO_INLINE_VECS)	158	else if (nr_vecs > BIO_INLINE_VECS)
159	kmem_cache_free(biovec_slab(nr_vecs)->slab, bv);	159	kmem_cache_free(biovec_slab(nr_vecs)->slab, bv);
@@ -186,15 +186,15 @@ struct bio_vec bvec_alloc(mempool_t pool, unsigned short *nr_vecs, · 26 unmodified lines
186	/*	186	/*
187	* Try a slab allocation first for all smaller allocations. If that	187	* Try a slab allocation first for all smaller allocations. If that
188	* fails and __GFP_DIRECT_RECLAIM is set retry with the mempool.	188	* fails and __GFP_DIRECT_RECLAIM is set retry with the mempool.
189	* The mempool is sized to handle up to BIO_MAX_PAGES entries.	189	* The mempool is sized to handle up to BIO_MAX_VECS entries.
190	*/	190	*/
191	if (*nr_vecs < BIO_MAX_PAGES) {	191	if (*nr_vecs < BIO_MAX_VECS) {
192	struct bio_vec *bvl;	192	struct bio_vec *bvl;
193		193
194	bvl = kmem_cache_alloc(bvs->slab, bvec_alloc_gfp(gfp_mask));	194	bvl = kmem_cache_alloc(bvs->slab, bvec_alloc_gfp(gfp_mask));
195	if (likely(bvl) \|\| !(gfp_mask & __GFP_DIRECT_RECLAIM))	195	if (likely(bvl) \|\| !(gfp_mask & __GFP_DIRECT_RECLAIM))
196	return bvl;	196	return bvl;
197	*nr_vecs = BIO_MAX_PAGES;	197	*nr_vecs = BIO_MAX_VECS;
198	}	198	}
199		199
200	return mempool_alloc(pool, gfp_mask);	200	return mempool_alloc(pool, gfp_mask);

block/blk-cgroup-rwstat.c+2−1

 	lockdep_assert_held(&blkg->q->queue_lock);
+	memset(sum, 0, sizeof(*sum));
 	rcu_read_lock();
 	blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
 		struct blkg_rwstat *rwstat;
 			rwstat = (void *)pos_blkg + off;
 		for (i = 0; i < BLKG_RWSTAT_NR; i++)
-			sum->cnt[i] = blkg_rwstat_read_counter(rwstat, i);
+			sum->cnt[i] += blkg_rwstat_read_counter(rwstat, i);
 	}
 	rcu_read_unlock();
 }

block/blk-crypto-fallback.c+1−1

@@ -219,7 +219,7 @@ static bool blk_crypto_split_bio_if_needed(struct bio **bio_ptr) · 218 unmodified lines
219		219
220	bio_for_each_segment(bv, bio, iter) {	220	bio_for_each_segment(bv, bio, iter) {
221	num_sectors += bv.bv_len >> SECTOR_SHIFT;	221	num_sectors += bv.bv_len >> SECTOR_SHIFT;
222	if (++i == BIO_MAX_PAGES)	222	if (++i == BIO_MAX_VECS)
223	break;	223	break;
224	}	224	}
225	if (num_sectors < bio_sectors(bio)) {	225	if (num_sectors < bio_sectors(bio)) {

block/blk-lib.c+1−1

@@ -296,7 +296,7 @@ static unsigned int __blkdev_sectors_to_bio_pages(sector_t nr_sects) · 295 unmodified lines
296	{	296	{
297	sector_t pages = DIV_ROUND_UP_SECTOR_T(nr_sects, PAGE_SIZE / 512);	297	sector_t pages = DIV_ROUND_UP_SECTOR_T(nr_sects, PAGE_SIZE / 512);
298		298
299	return min(pages, (sector_t)BIO_MAX_PAGES);	299	return min(pages, (sector_t)BIO_MAX_VECS);
300	}	300	}
301		301
302	static int __blkdev_issue_zero_pages(struct block_device *bdev,	302	static int __blkdev_issue_zero_pages(struct block_device *bdev,

block/blk-map.c+1−1

@@ -249,7 +249,7 @@ static int bio_map_user_iov(struct request rq, struct iov_iter iter, · 248 unmodified lines
249	if (!iov_iter_count(iter))	249	if (!iov_iter_count(iter))
250	return -EINVAL;	250	return -EINVAL;
251		251
252	bio = bio_kmalloc(gfp_mask, iov_iter_npages(iter, BIO_MAX_PAGES));	252	bio = bio_kmalloc(gfp_mask, iov_iter_npages(iter, BIO_MAX_VECS));
253	if (!bio)	253	if (!bio)
254	return -ENOMEM;	254	return -ENOMEM;
255	bio->bi_opf \|= req_op(rq);	255	bio->bi_opf \|= req_op(rq);

block/blk-zoned.c+37−3

@@ -240,7 +240,7 @@ int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op, · 239 unmodified lines
240	*/	240	*/
241	if (op == REQ_OP_ZONE_RESET &&	241	if (op == REQ_OP_ZONE_RESET &&
242	blkdev_allow_reset_all_zones(bdev, sector, nr_sectors)) {	242	blkdev_allow_reset_all_zones(bdev, sector, nr_sectors)) {
243	bio->bi_opf = REQ_OP_ZONE_RESET_ALL;	243	bio->bi_opf = REQ_OP_ZONE_RESET_ALL \| REQ_SYNC;
244	break;	244	break;
245	}	245	}
246		246
@@ -318,6 +318,22 @@ int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode, · 71 unmodified lines
318	return 0;	318	return 0;
319	}	319	}
320		320
		321	static int blkdev_truncate_zone_range(struct block_device *bdev, fmode_t mode,
		322	const struct blk_zone_range *zrange)
		323	{
		324	loff_t start, end;
		325
		326	if (zrange->sector + zrange->nr_sectors <= zrange->sector \|\|
		327	zrange->sector + zrange->nr_sectors > get_capacity(bdev->bd_disk))
		328	/* Out of range */
		329	return -EINVAL;
		330
		331	start = zrange->sector << SECTOR_SHIFT;
		332	end = ((zrange->sector + zrange->nr_sectors) << SECTOR_SHIFT) - 1;
		333
		334	return truncate_bdev_range(bdev, mode, start, end);
		335	}
		336
321	/*	337	/*
322	* BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing.	338	* BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing.
323	* Called from blkdev_ioctl.	339	* Called from blkdev_ioctl.
@@ -329,6 +345,7 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, · 5 unmodified lines
329	struct request_queue *q;	345	struct request_queue *q;
330	struct blk_zone_range zrange;	346	struct blk_zone_range zrange;
331	enum req_opf op;	347	enum req_opf op;
		348	int ret;
332		349
333	if (!argp)	350	if (!argp)
334	return -EINVAL;	351	return -EINVAL;
@@ -352,6 +369,11 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, · 17 unmodified lines
352	switch (cmd) {	369	switch (cmd) {
353	case BLKRESETZONE:	370	case BLKRESETZONE:
354	op = REQ_OP_ZONE_RESET;	371	op = REQ_OP_ZONE_RESET;
		372
		373	/* Invalidate the page cache, including dirty pages. */
		374	ret = blkdev_truncate_zone_range(bdev, mode, &zrange);
		375	if (ret)
		376	return ret;
355	break;	377	break;
356	case BLKOPENZONE:	378	case BLKOPENZONE:
357	op = REQ_OP_ZONE_OPEN;	379	op = REQ_OP_ZONE_OPEN;
@@ -366,8 +388,20 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, · 8 unmodified lines
366	return -ENOTTY;	388	return -ENOTTY;
367	}	389	}
368		390
369	return blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors,	391	ret = blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors,
370	GFP_KERNEL);	392	GFP_KERNEL);
		393
		394	/*
		395	* Invalidate the page cache again for zone reset: writes can only be
		396	* direct for zoned devices so concurrent writes would not add any page
		397	* to the page cache after/during reset. The page cache may be filled
		398	* again due to concurrent reads though and dropping the pages for
		399	* these is fine.
		400	*/
		401	if (!ret && cmd == BLKRESETZONE)
		402	ret = blkdev_truncate_zone_range(bdev, mode, &zrange);
		403
		404	return ret;
371	}	405	}
372		406
373	static inline unsigned long *blk_alloc_zone_bitmap(int node,	407	static inline unsigned long *blk_alloc_zone_bitmap(int node,

block/bounce.c+3−3

block/genhd.c+1−3

@@ -534,10 +534,8 @@ static void register_disk(struct device parent, struct gendisk disk, · 533 unmodified lines
534	kobject_create_and_add("holders", &ddev->kobj);	534	kobject_create_and_add("holders", &ddev->kobj);
535	disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);	535	disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
536		536
537	if (disk->flags & GENHD_FL_HIDDEN) {	537	if (disk->flags & GENHD_FL_HIDDEN)
538	dev_set_uevent_suppress(ddev, 0);
539	return;	538	return;
540	}
541		539
542	disk_scan_partitions(disk);	540	disk_scan_partitions(disk);
543		541

drivers/atm/fore200e.c+0−2

@@ -99,8 +99,6 @@ static LIST_HEAD(fore200e_boards); · 98 unmodified lines
99		99
100	MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");	100	MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");
101	MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);	101	MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);
102	MODULE_SUPPORTED_DEVICE("PCA-200E, SBA-200E");
103
104		102
105	static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {	103	static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
106	{ BUFFER_S1_NBR, BUFFER_L1_NBR },	104	{ BUFFER_S1_NBR, BUFFER_L1_NBR },

drivers/base/power/runtime.c+25−37

@@ -325,22 +325,22 @@ static void rpm_put_suppliers(struct device *dev) · 324 unmodified lines
325	static int __rpm_callback(int (cb)(struct device ), struct device *dev)	325	static int __rpm_callback(int (cb)(struct device ), struct device *dev)
326	__releases(&dev->power.lock) __acquires(&dev->power.lock)	326	__releases(&dev->power.lock) __acquires(&dev->power.lock)
327	{	327	{
328	bool use_links = dev->power.links_count > 0;
329	bool get = false;
330	int retval, idx;	328	int retval, idx;
331	bool put;	329	bool use_links = dev->power.links_count > 0;
332		330
333	if (dev->power.irq_safe) {	331	if (dev->power.irq_safe) {
334	spin_unlock(&dev->power.lock);	332	spin_unlock(&dev->power.lock);
335	} else if (!use_links) {
336	spin_unlock_irq(&dev->power.lock);
337	} else {	333	} else {
338	get = dev->power.runtime_status == RPM_RESUMING;
339
340	spin_unlock_irq(&dev->power.lock);	334	spin_unlock_irq(&dev->power.lock);
341		335
342	/* Resume suppliers if necessary. */	336	/*
343	if (get) {	337	* Resume suppliers if necessary.
		338	*
		339	* The device's runtime PM status cannot change until this
		340	* routine returns, so it is safe to read the status outside of
		341	* the lock.
		342	*/
		343	if (use_links && dev->power.runtime_status == RPM_RESUMING) {
344	idx = device_links_read_lock();	344	idx = device_links_read_lock();
345		345
346	retval = rpm_get_suppliers(dev);	346	retval = rpm_get_suppliers(dev);
@@ -355,36 +355,24 @@ static int __rpm_callback(int (cb)(struct device ), struct device *dev) · 8 unmodified lines
355		355
356	if (dev->power.irq_safe) {	356	if (dev->power.irq_safe) {
357	spin_lock(&dev->power.lock);	357	spin_lock(&dev->power.lock);
358	return retval;	358	} else {
359	}	359	/*
360		360	* If the device is suspending and the callback has returned
361	spin_lock_irq(&dev->power.lock);	361	* success, drop the usage counters of the suppliers that have
362		362	* been reference counted on its resume.
363	if (!use_links)	363	*
364	return retval;	364	* Do that if resume fails too.
365		365	*/
366	/*	366	if (use_links
367	* If the device is suspending and the callback has returned success,	367	&& ((dev->power.runtime_status == RPM_SUSPENDING && !retval)
368	* drop the usage counters of the suppliers that have been reference	368	\|\| (dev->power.runtime_status == RPM_RESUMING && retval))) {
369	* counted on its resume.	369	idx = device_links_read_lock();
370	*
371	* Do that if the resume fails too.
372	*/
373	put = dev->power.runtime_status == RPM_SUSPENDING && !retval;
374	if (put)
375	__update_runtime_status(dev, RPM_SUSPENDED);
376	else
377	put = get && retval;
378
379	if (put) {
380	spin_unlock_irq(&dev->power.lock);
381
382	idx = device_links_read_lock();
383		370
384	fail:	371	fail:
385	rpm_put_suppliers(dev);	372	rpm_put_suppliers(dev);
386		373
387	device_links_read_unlock(idx);	374	device_links_read_unlock(idx);
		375	}
388		376
389	spin_lock_irq(&dev->power.lock);	377	spin_lock_irq(&dev->power.lock);
390	}	378	}

drivers/base/swnode.c+20−9

 	if (software_node_to_swnode(node))
 		return -EEXIST;
+	if (node->parent && !parent)
+		return -EINVAL;
 	return PTR_ERR_OR_ZERO(swnode_register(node, parent, 0));
 }
 EXPORT_SYMBOL_GPL(software_node_register);
 /**
  * device_add_software_node - Assign software node to a device
  * @dev: The device the software node is meant for.
- * @swnode: The software node.
+ * @node: The software node.
  *
- * This function will register @swnode and make it the secondary firmware node
+ * This function will make @node the secondary firmware node pointer of @dev. If
- * pointer of @dev. If @dev has no primary node, then @swnode will become the primary
+ * @dev has no primary node, then @node will become the primary node. The
- * node.
+ * function will register @node automatically if it wasn't already registered.
  */
-int device_add_software_node(struct device *dev, const struct software_node *swnode)
+int device_add_software_node(struct device *dev, const struct software_node *node)
 {
+	struct swnode *swnode;
 	int ret;
 	/* Only one software node per device. */
 	if (dev_to_swnode(dev))
 		return -EBUSY;
-	ret = software_node_register(swnode);
+	swnode = software_node_to_swnode(node);
-	if (ret)
+	if (swnode) {
-		return ret;
+		kobject_get(&swnode->kobj);
+	} else {
+		ret = software_node_register(node);
+		if (ret)
+			return ret;
+		swnode = software_node_to_swnode(node);
+	}
-	set_secondary_fwnode(dev, software_node_fwnode(swnode));
+	set_secondary_fwnode(dev, &swnode->fwnode);
 	return 0;
 }

drivers/block/drbd/drbd_int.h+1−1

@@ -1324,7 +1324,7 @@ struct bm_extent { · 1323 unmodified lines
1324	* A followup commit may allow even bigger BIO sizes,	1324	* A followup commit may allow even bigger BIO sizes,
1325	* once we thought that through. */	1325	* once we thought that through. */
1326	#define DRBD_MAX_BIO_SIZE (1U << 20)	1326	#define DRBD_MAX_BIO_SIZE (1U << 20)
1327	#if DRBD_MAX_BIO_SIZE > (BIO_MAX_PAGES << PAGE_SHIFT)	1327	#if DRBD_MAX_BIO_SIZE > (BIO_MAX_VECS << PAGE_SHIFT)
1328	#error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE	1328	#error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
1329	#endif	1329	#endif
1330	#define DRBD_MAX_BIO_SIZE_SAFE (1U << 12) /* Works always = 4k */	1330	#define DRBD_MAX_BIO_SIZE_SAFE (1U << 12) /* Works always = 4k */

drivers/block/floppy.c+0−1

@@ -5091,7 +5091,6 @@ module_param(floppy, charp, 0); · 5090 unmodified lines
5091	module_param(FLOPPY_IRQ, int, 0);	5091	module_param(FLOPPY_IRQ, int, 0);
5092	module_param(FLOPPY_DMA, int, 0);	5092	module_param(FLOPPY_DMA, int, 0);
5093	MODULE_AUTHOR("Alain L. Knaff");	5093	MODULE_AUTHOR("Alain L. Knaff");
5094	MODULE_SUPPORTED_DEVICE("fd");
5095	MODULE_LICENSE("GPL");	5094	MODULE_LICENSE("GPL");
5096		5095
5097	/* This doesn't actually get used other than for module information */	5096	/* This doesn't actually get used other than for module information */

drivers/block/rsxx/core.c+1−0

@@ -871,6 +871,7 @@ static int rsxx_pci_probe(struct pci_dev *dev, · 870 unmodified lines
871	card->event_wq = create_singlethread_workqueue(DRIVER_NAME"_event");	871	card->event_wq = create_singlethread_workqueue(DRIVER_NAME"_event");
872	if (!card->event_wq) {	872	if (!card->event_wq) {
873	dev_err(CARD_TO_DEV(card), "Failed card event setup.\n");	873	dev_err(CARD_TO_DEV(card), "Failed card event setup.\n");
		874	st = -ENOMEM;
874	goto failed_event_handler;	875	goto failed_event_handler;
875	}	876	}
876		877

drivers/block/umem.c+4−1

 	if (card->mm_pages[0].desc == NULL ||
 	    card->mm_pages[1].desc == NULL) {
 		dev_printk(KERN_ERR, &card->dev->dev, "alloc failed\n");
+		ret = -ENOMEM;
 		goto failed_alloc;
 	}
 	reset_page(&card->mm_pages[0]);
 	spin_lock_init(&card->lock);
 	card->queue = blk_alloc_queue(NUMA_NO_NODE);
-	if (!card->queue)
+	if (!card->queue) {
+		ret = -ENOMEM;
 		goto failed_alloc;
+	}
 	tasklet_init(&card->tasklet, process_page, (unsigned long)card);

drivers/block/zram/zram_drv.c+11−6

 	struct bio_vec bio_vec;
 	struct page *page;
 	ssize_t ret = len;
-	int mode;
+	int mode, err;
 	unsigned long blk_idx = 0;
 	if (sysfs_streq(buf, "idle"))
 		if (strncmp(buf, PAGE_WB_SIG, sizeof(PAGE_WB_SIG) - 1))
 			return -EINVAL;
-		ret = kstrtol(buf + sizeof(PAGE_WB_SIG) - 1, 10, &index);
+		if (kstrtol(buf + sizeof(PAGE_WB_SIG) - 1, 10, &index) ||
-		if (ret || index >= nr_pages)
+				index >= nr_pages)
 			return -EINVAL;
 		nr_pages = 1;
 		goto release_init_lock;
 	}
-	while (nr_pages--) {
+	for (; nr_pages != 0; index++, nr_pages--) {
 		struct bio_vec bvec;
 		bvec.bv_page = page;
 		 * XXX: A single page IO would be inefficient for write
 		 * but it would be not bad as starter.
 		 */
-		ret = submit_bio_wait(&bio);
+		err = submit_bio_wait(&bio);
-		if (ret) {
+		if (err) {
 			zram_slot_lock(zram, index);
 			zram_clear_flag(zram, index, ZRAM_UNDER_WB);
 			zram_clear_flag(zram, index, ZRAM_IDLE);
 			zram_slot_unlock(zram, index);
+			/*
+			 * Return last IO error unless every IO were
+			 * not suceeded.
+			 */
+			ret = err;
 			continue;
 		}

drivers/bluetooth/btrsi.c+0−1

@@ -194,5 +194,4 @@ module_init(rsi_91x_bt_module_init); · 193 unmodified lines
194	module_exit(rsi_91x_bt_module_exit);	194	module_exit(rsi_91x_bt_module_exit);
195	MODULE_AUTHOR("Redpine Signals Inc");	195	MODULE_AUTHOR("Redpine Signals Inc");
196	MODULE_DESCRIPTION("RSI BT driver");	196	MODULE_DESCRIPTION("RSI BT driver");
197	MODULE_SUPPORTED_DEVICE("RSI-BT");
198	MODULE_LICENSE("Dual BSD/GPL");	197	MODULE_LICENSE("Dual BSD/GPL");

drivers/char/applicom.c+0−3

@@ -81,9 +81,6 @@ MODULE_DESCRIPTION("Driver for Applicom Profibus card"); · 80 unmodified lines
81	MODULE_LICENSE("GPL");	81	MODULE_LICENSE("GPL");
82	MODULE_ALIAS_MISCDEV(AC_MINOR);	82	MODULE_ALIAS_MISCDEV(AC_MINOR);
83		83
84	MODULE_SUPPORTED_DEVICE("ac");
85
86
87	static struct applicom_board {	84	static struct applicom_board {
88	unsigned long PhysIO;	85	unsigned long PhysIO;
89	void __iomem *RamIO;	86	void __iomem *RamIO;

drivers/char/toshiba.c+0−1

@@ -64,7 +64,6 @@ · 63 unmodified lines
64	MODULE_LICENSE("GPL");	64	MODULE_LICENSE("GPL");
65	MODULE_AUTHOR("Jonathan Buzzard <jonathan@buzzard.org.uk>");	65	MODULE_AUTHOR("Jonathan Buzzard <jonathan@buzzard.org.uk>");
66	MODULE_DESCRIPTION("Toshiba laptop SMM driver");	66	MODULE_DESCRIPTION("Toshiba laptop SMM driver");
67	MODULE_SUPPORTED_DEVICE("toshiba");
68		67
69	static DEFINE_MUTEX(tosh_mutex);	68	static DEFINE_MUTEX(tosh_mutex);
70	static int tosh_fn;	69	static int tosh_fn;

drivers/clk/qcom/clk-rcg2.c+9−8

@@ -730,7 +730,8 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 729 unmodified lines
730	struct clk_rate_request parent_req = { };	730	struct clk_rate_request parent_req = { };
731	struct clk_rcg2_gfx3d *cgfx = to_clk_rcg2_gfx3d(hw);	731	struct clk_rcg2_gfx3d *cgfx = to_clk_rcg2_gfx3d(hw);
732	struct clk_hw xo, p0, p1, p2;	732	struct clk_hw xo, p0, p1, p2;
733	unsigned long request, p0_rate;	733	unsigned long p0_rate;
		734	u8 mux_div = cgfx->div;
734	int ret;	735	int ret;
735		736
736	p0 = cgfx->hws[0];	737	p0 = cgfx->hws[0];
@@ -750,14 +751,15 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 13 unmodified lines
750	return 0;	751	return 0;
751	}	752	}
752		753
753	request = req->rate;	754	if (mux_div == 0)
754	if (cgfx->div > 1)	755	mux_div = 1;
755	parent_req.rate = request = request * cgfx->div;	756
		757	parent_req.rate = req->rate * mux_div;
756		758
757	/* This has to be a fixed rate PLL */	759	/* This has to be a fixed rate PLL */
758	p0_rate = clk_hw_get_rate(p0);	760	p0_rate = clk_hw_get_rate(p0);
759		761
760	if (request == p0_rate) {	762	if (parent_req.rate == p0_rate) {
761	req->rate = req->best_parent_rate = p0_rate;	763	req->rate = req->best_parent_rate = p0_rate;
762	req->best_parent_hw = p0;	764	req->best_parent_hw = p0;
763	return 0;	765	return 0;
@@ -765,7 +767,7 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 1 unmodified line
765		767
766	if (req->best_parent_hw == p0) {	768	if (req->best_parent_hw == p0) {
767	/* Are we going back to a previously used rate? */	769	/* Are we going back to a previously used rate? */
768	if (clk_hw_get_rate(p2) == request)	770	if (clk_hw_get_rate(p2) == parent_req.rate)
769	req->best_parent_hw = p2;	771	req->best_parent_hw = p2;
770	else	772	else
771	req->best_parent_hw = p1;	773	req->best_parent_hw = p1;
@@ -780,8 +782,7 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 8 unmodified lines
780	return ret;	782	return ret;
781		783
782	req->rate = req->best_parent_rate = parent_req.rate;	784	req->rate = req->best_parent_rate = parent_req.rate;
783	if (cgfx->div > 1)	785	req->rate /= mux_div;
784	req->rate /= cgfx->div;
785		786
786	return 0;	787	return 0;
787	}	788	}

drivers/clk/qcom/clk-rpmh.c+5−2

 	.num_clks = ARRAY_SIZE(sm8350_rpmh_clocks),
 };
+/* Resource name must match resource id present in cmd-db */
+DEFINE_CLK_RPMH_ARC(sc7280, bi_tcxo, bi_tcxo_ao, "xo.lvl", 0x3, 4);
 static struct clk_hw *sc7280_rpmh_clocks[] = {
-	[RPMH_CXO_CLK]      = &sdm845_bi_tcxo.hw,
+	[RPMH_CXO_CLK]      = &sc7280_bi_tcxo.hw,
-	[RPMH_CXO_CLK_A]    = &sdm845_bi_tcxo_ao.hw,
+	[RPMH_CXO_CLK_A]    = &sc7280_bi_tcxo_ao.hw,
 	[RPMH_LN_BB_CLK2]   = &sdm845_ln_bb_clk2.hw,
 	[RPMH_LN_BB_CLK2_A] = &sdm845_ln_bb_clk2_ao.hw,
 	[RPMH_RF_CLK1]      = &sdm845_rf_clk1.hw,

drivers/clk/qcom/gcc-sc7180.c+2−2

@@ -620,7 +620,7 @@ static struct clk_rcg2 gcc_sdcc1_apps_clk_src = { · 619 unmodified lines
620	.name = "gcc_sdcc1_apps_clk_src",	620	.name = "gcc_sdcc1_apps_clk_src",
621	.parent_data = gcc_parent_data_1,	621	.parent_data = gcc_parent_data_1,
622	.num_parents = 5,	622	.num_parents = 5,
623	.ops = &clk_rcg2_ops,	623	.ops = &clk_rcg2_floor_ops,
624	},	624	},
625	};	625	};
626		626
@@ -642,7 +642,7 @@ static struct clk_rcg2 gcc_sdcc1_ice_core_clk_src = { · 15 unmodified lines
642	.name = "gcc_sdcc1_ice_core_clk_src",	642	.name = "gcc_sdcc1_ice_core_clk_src",
643	.parent_data = gcc_parent_data_0,	643	.parent_data = gcc_parent_data_0,
644	.num_parents = 4,	644	.num_parents = 4,
645	.ops = &clk_rcg2_floor_ops,	645	.ops = &clk_rcg2_ops,
646	},	646	},
647	};	647	};
648		648

drivers/counter/stm32-timer-cnt.c+33−22

 	struct counter_device counter;
 	struct regmap *regmap;
 	struct clk *clk;
-	u32 ceiling;
+	u32 max_arr;
 	bool enabled;
 	struct stm32_timer_regs bak;
 };
  * @STM32_COUNT_ENCODER_MODE_3: counts on both TI1FP1 and TI2FP2 edges
  */
 enum stm32_count_function {
-	STM32_COUNT_SLAVE_MODE_DISABLED = -1,
+	STM32_COUNT_SLAVE_MODE_DISABLED,
 	STM32_COUNT_ENCODER_MODE_1,
 	STM32_COUNT_ENCODER_MODE_2,
 	STM32_COUNT_ENCODER_MODE_3,
 };
 static enum counter_count_function stm32_count_functions[] = {
+	[STM32_COUNT_SLAVE_MODE_DISABLED] = COUNTER_COUNT_FUNCTION_INCREASE,
 	[STM32_COUNT_ENCODER_MODE_1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
 	[STM32_COUNT_ENCODER_MODE_2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
 	[STM32_COUNT_ENCODER_MODE_3] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
 			     const unsigned long val)
 {
 	struct stm32_timer_cnt *const priv = counter->priv;
+	u32 ceiling;
-	if (val > priv->ceiling)
+	regmap_read(priv->regmap, TIM_ARR, &ceiling);
+	if (val > ceiling)
 		return -EINVAL;
 	return regmap_write(priv->regmap, TIM_CNT, val);
 	regmap_read(priv->regmap, TIM_SMCR, &smcr);
 	switch (smcr & TIM_SMCR_SMS) {
+	case 0:
+		*function = STM32_COUNT_SLAVE_MODE_DISABLED;
+		return 0;
 	case 1:
 		*function = STM32_COUNT_ENCODER_MODE_1;
 		return 0;
 	case 3:
 		*function = STM32_COUNT_ENCODER_MODE_3;
 		return 0;
+	default:
+		return -EINVAL;
 	}
-	return -EINVAL;
 }
 static int stm32_count_function_set(struct counter_device *counter,
 	u32 cr1, sms;
 	switch (function) {
+	case STM32_COUNT_SLAVE_MODE_DISABLED:
+		sms = 0;
+		break;
 	case STM32_COUNT_ENCODER_MODE_1:
 		sms = 1;
 		break;
 		sms = 3;
 		break;
 	default:
-		sms = 0;
+		return -EINVAL;
-		break;
 	}
 	/* Store enable status */
 	regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_CEN, 0);
-	/* TIMx_ARR register shouldn't be buffered (ARPE=0) */
-	regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_ARPE, 0);
-	regmap_write(priv->regmap, TIM_ARR, priv->ceiling);
 	regmap_update_bits(priv->regmap, TIM_SMCR, TIM_SMCR_SMS, sms);
 	/* Make sure that registers are updated */
 	if (ret)
 		return ret;
+	if (ceiling > priv->max_arr)
+		return -ERANGE;
 	/* TIMx_ARR register shouldn't be buffered (ARPE=0) */
 	regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_ARPE, 0);
 	regmap_write(priv->regmap, TIM_ARR, ceiling);
-	priv->ceiling = ceiling;
 	return len;
 }
 	size_t function;
 	int err;
-	/* Default action mode (e.g. STM32_COUNT_SLAVE_MODE_DISABLED) */
-	*action = STM32_SYNAPSE_ACTION_NONE;
 	err = stm32_count_function_get(counter, count, &function);
 	if (err)
-		return 0;
+		return err;
 	switch (function) {
+	case STM32_COUNT_SLAVE_MODE_DISABLED:
+		/* counts on internal clock when CEN=1 */
+		*action = STM32_SYNAPSE_ACTION_NONE;
+		return 0;
 	case STM32_COUNT_ENCODER_MODE_1:
 		/* counts up/down on TI1FP1 edge depending on TI2FP2 level */
 		if (synapse->signal->id == count->synapses[0].signal->id)
 			*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
-		break;
+		else
+			*action = STM32_SYNAPSE_ACTION_NONE;
+		return 0;
 	case STM32_COUNT_ENCODER_MODE_2:
 		/* counts up/down on TI2FP2 edge depending on TI1FP1 level */
 		if (synapse->signal->id == count->synapses[1].signal->id)
 			*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
-		break;
+		else
+			*action = STM32_SYNAPSE_ACTION_NONE;
+		return 0;
 	case STM32_COUNT_ENCODER_MODE_3:
 		/* counts up/down on both TI1FP1 and TI2FP2 edges */
 		*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
-		break;
+		return 0;
+	default:
+		return -EINVAL;
 	}
-	return 0;
 }
 static const struct counter_ops stm32_timer_cnt_ops = {
 	priv->regmap = ddata->regmap;
 	priv->clk = ddata->clk;
-	priv->ceiling = ddata->max_arr;
+	priv->max_arr = ddata->max_arr;
 	priv->counter.name = dev_name(dev);
 	priv->counter.parent = dev;

drivers/cpufreq/cpufreq-dt-platdev.c+2−0

@@ -103,6 +103,8 @@ static const struct of_device_id whitelist[] __initconst = { · 102 unmodified lines
103	static const struct of_device_id blacklist[] __initconst = {	103	static const struct of_device_id blacklist[] __initconst = {
104	{ .compatible = "allwinner,sun50i-h6", },	104	{ .compatible = "allwinner,sun50i-h6", },
105		105
		106	{ .compatible = "arm,vexpress", },
		107
106	{ .compatible = "calxeda,highbank", },	108	{ .compatible = "calxeda,highbank", },
107	{ .compatible = "calxeda,ecx-2000", },	109	{ .compatible = "calxeda,ecx-2000", },
108		110

drivers/cpufreq/qcom-cpufreq-hw.c+3−3

@@ -317,9 +317,9 @@ static int qcom_cpufreq_hw_cpu_init(struct cpufreq_policy *policy) · 316 unmodified lines
317	}	317	}
318		318
319	base = ioremap(res->start, resource_size(res));	319	base = ioremap(res->start, resource_size(res));
320	if (IS_ERR(base)) {	320	if (!base) {
321	dev_err(dev, "failed to map resource %pR\n", res);	321	dev_err(dev, "failed to map resource %pR\n", res);
322	ret = PTR_ERR(base);	322	ret = -ENOMEM;
323	goto release_region;	323	goto release_region;
324	}	324	}
325		325
@@ -374,7 +374,7 @@ static int qcom_cpufreq_hw_cpu_init(struct cpufreq_policy *policy) · 48 unmodified lines
374	error:	374	error:
375	kfree(data);	375	kfree(data);
376	unmap_base:	376	unmap_base:
377	iounmap(data->base);	377	iounmap(base);
378	release_region:	378	release_region:
379	release_mem_region(res->start, resource_size(res));	379	release_mem_region(res->start, resource_size(res));
380	return ret;	380	return ret;

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

 	}
 	/* first try to find a slot in an existing linked list entry */
-	for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) {
+	for (prsv = efi_memreserve_root->next; prsv; ) {
 		rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB);
 		index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
 		if (index < rsv->size) {
 			memunmap(rsv);
 			return efi_mem_reserve_iomem(addr, size);
 		}
+		prsv = rsv->next;
 		memunmap(rsv);
 	}

drivers/firmware/efi/libstub/arm64-stub.c+1−1

@@ -24,7 +24,7 @@ efi_status_t check_platform_features(void) · 23 unmodified lines
24	return EFI_SUCCESS;	24	return EFI_SUCCESS;
25		25
26	tg = (read_cpuid(ID_AA64MMFR0_EL1) >> ID_AA64MMFR0_TGRAN_SHIFT) & 0xf;	26	tg = (read_cpuid(ID_AA64MMFR0_EL1) >> ID_AA64MMFR0_TGRAN_SHIFT) & 0xf;
27	if (tg != ID_AA64MMFR0_TGRAN_SUPPORTED) {	27	if (tg < ID_AA64MMFR0_TGRAN_SUPPORTED_MIN \|\| tg > ID_AA64MMFR0_TGRAN_SUPPORTED_MAX) {
28	if (IS_ENABLED(CONFIG_ARM64_64K_PAGES))	28	if (IS_ENABLED(CONFIG_ARM64_64K_PAGES))
29	efi_err("This 64 KB granular kernel is not supported by your CPU\n");	29	efi_err("This 64 KB granular kernel is not supported by your CPU\n");
30	else	30	else

drivers/firmware/efi/libstub/efi-stub.c+16−0

@@ -96,6 +96,18 @@ static void install_memreserve_table(void) · 95 unmodified lines
96	efi_err("Failed to install memreserve config table!\n");	96	efi_err("Failed to install memreserve config table!\n");
97	}	97	}
98		98
		99	static u32 get_supported_rt_services(void)
		100	{
		101	const efi_rt_properties_table_t *rt_prop_table;
		102	u32 supported = EFI_RT_SUPPORTED_ALL;
		103
		104	rt_prop_table = get_efi_config_table(EFI_RT_PROPERTIES_TABLE_GUID);
		105	if (rt_prop_table)
		106	supported &= rt_prop_table->runtime_services_supported;
		107
		108	return supported;
		109	}
		110
99	/*	111	/*
100	* EFI entry point for the arm/arm64 EFI stubs. This is the entrypoint	112	* EFI entry point for the arm/arm64 EFI stubs. This is the entrypoint
101	* that is described in the PE/COFF header. Most of the code is the same	113	* that is described in the PE/COFF header. Most of the code is the same
@@ -250,6 +262,10 @@ efi_status_t __efiapi efi_pe_entry(efi_handle_t handle, · 148 unmodified lines
250	(prop_tbl->memory_protection_attribute &	262	(prop_tbl->memory_protection_attribute &
251	EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA);	263	EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA);
252		264
		265	/* force efi_novamap if SetVirtualAddressMap() is unsupported */
		266	efi_novamap \|= !(get_supported_rt_services() &
		267	EFI_RT_SUPPORTED_SET_VIRTUAL_ADDRESS_MAP);
		268
253	/* hibernation expects the runtime regions to stay in the same place */	269	/* hibernation expects the runtime regions to stay in the same place */
254	if (!IS_ENABLED(CONFIG_HIBERNATION) && !efi_nokaslr && !flat_va_mapping) {	270	if (!IS_ENABLED(CONFIG_HIBERNATION) && !efi_nokaslr && !flat_va_mapping) {
255	/*	271	/*

drivers/firmware/efi/vars.c+4−0

 				}
 			}
+			break;
+		case EFI_UNSUPPORTED:
+			err = -EOPNOTSUPP;
+			status = EFI_NOT_FOUND;
 			break;
 		case EFI_NOT_FOUND:
 			break;

drivers/gpio/gpiolib.c+9−1

 			       struct lock_class_key *lock_key,
 			       struct lock_class_key *request_key)
 {
+	struct fwnode_handle *fwnode = gc->parent ? dev_fwnode(gc->parent) : NULL;
 	unsigned long	flags;
 	int		ret = 0;
 	unsigned	i;
 	of_gpio_dev_init(gc, gdev);
+	/*
+	 * Assign fwnode depending on the result of the previous calls,
+	 * if none of them succeed, assign it to the parent's one.
+	 */
+	gdev->dev.fwnode = dev_fwnode(&gdev->dev) ?: fwnode;
 	gdev->id = ida_alloc(&gpio_ida, GFP_KERNEL);
 	if (gdev->id < 0) {
 		ret = gdev->id;
 		return ret;
 	}
-	if (driver_register(&gpio_stub_drv) < 0) {
+	ret = driver_register(&gpio_stub_drv);
+	if (ret < 0) {
 		pr_err("gpiolib: could not register GPIO stub driver\n");
 		bus_unregister(&gpio_bus_type);
 		return ret;

drivers/gpu/drm/Kconfig+1−0

@@ -228,6 +228,7 @@ source "drivers/gpu/drm/arm/Kconfig" · 227 unmodified lines
228	config DRM_RADEON	228	config DRM_RADEON
229	tristate "ATI Radeon"	229	tristate "ATI Radeon"
230	depends on DRM && PCI && MMU	230	depends on DRM && PCI && MMU
		231	depends on AGP \|\| !AGP
231	select FW_LOADER	232	select FW_LOADER
232	select DRM_KMS_HELPER	233	select DRM_KMS_HELPER
233	select DRM_TTM	234	select DRM_TTM

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

@@ -180,6 +180,7 @@ extern uint amdgpu_smu_memory_pool_size; · 179 unmodified lines
180	extern uint amdgpu_dc_feature_mask;	180	extern uint amdgpu_dc_feature_mask;
181	extern uint amdgpu_dc_debug_mask;	181	extern uint amdgpu_dc_debug_mask;
182	extern uint amdgpu_dm_abm_level;	182	extern uint amdgpu_dm_abm_level;
		183	extern int amdgpu_backlight;
183	extern struct amdgpu_mgpu_info mgpu_info;	184	extern struct amdgpu_mgpu_info mgpu_info;
184	extern int amdgpu_ras_enable;	185	extern int amdgpu_ras_enable;
185	extern uint amdgpu_ras_mask;	186	extern uint amdgpu_ras_mask;

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

@@ -903,7 +903,7 @@ void amdgpu_acpi_fini(struct amdgpu_device *adev) · 902 unmodified lines
903	*/	903	*/
904	bool amdgpu_acpi_is_s0ix_supported(struct amdgpu_device *adev)	904	bool amdgpu_acpi_is_s0ix_supported(struct amdgpu_device *adev)
905	{	905	{
906	#if defined(CONFIG_AMD_PMC)	906	#if defined(CONFIG_AMD_PMC) \|\| defined(CONFIG_AMD_PMC_MODULE)
907	if (acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0) {	907	if (acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0) {
908	if (adev->flags & AMD_IS_APU)	908	if (adev->flags & AMD_IS_APU)
909	return true;	909	return true;

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

 MODULE_PARM_DESC(abmlevel, "ABM level (0 = off (default), 1-4 = backlight reduction level) ");
 module_param_named(abmlevel, amdgpu_dm_abm_level, uint, 0444);
+int amdgpu_backlight = -1;
+MODULE_PARM_DESC(backlight, "Backlight control (0 = pwm, 1 = aux, -1 auto (default))");
+module_param_named(backlight, amdgpu_backlight, bint, 0444);
 /**
  * DOC: tmz (int)
  * Trusted Memory Zone (TMZ) is a method to protect data being written

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

@@ -146,7 +146,7 @@ static int amdgpufb_create_pinned_object(struct amdgpu_fbdev *rfbdev, · 145 unmodified lines
146	size = mode_cmd->pitches[0] * height;	146	size = mode_cmd->pitches[0] * height;
147	aligned_size = ALIGN(size, PAGE_SIZE);	147	aligned_size = ALIGN(size, PAGE_SIZE);
148	ret = amdgpu_gem_object_create(adev, aligned_size, 0, domain, flags,	148	ret = amdgpu_gem_object_create(adev, aligned_size, 0, domain, flags,
149	ttm_bo_type_kernel, NULL, &gobj);	149	ttm_bo_type_device, NULL, &gobj);
150	if (ret) {	150	if (ret) {
151	pr_err("failed to allocate framebuffer (%d)\n", aligned_size);	151	pr_err("failed to allocate framebuffer (%d)\n", aligned_size);
152	return -ENOMEM;	152	return -ENOMEM;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+30−20

@@ -2267,6 +2267,11 @@ static void update_connector_ext_caps(struct amdgpu_dm_connector *aconnector) · 2266 unmodified lines
2267	caps->ext_caps->bits.hdr_aux_backlight_control == 1)	2267	caps->ext_caps->bits.hdr_aux_backlight_control == 1)
2268	caps->aux_support = true;	2268	caps->aux_support = true;
2269		2269
		2270	if (amdgpu_backlight == 0)
		2271	caps->aux_support = false;
		2272	else if (amdgpu_backlight == 1)
		2273	caps->aux_support = true;
		2274
2270	/* From the specification (CTA-861-G), for calculating the maximum	2275	/* From the specification (CTA-861-G), for calculating the maximum
2271	* luminance we need to use:	2276	* luminance we need to use:
2272	* Luminance = 502*(CV/32)	2277	* Luminance = 502*(CV/32)
@@ -3185,19 +3190,6 @@ static void amdgpu_dm_update_backlight_caps(struct amdgpu_display_manager *dm) · 912 unmodified lines
3185	#endif	3190	#endif
3186	}	3191	}
3187		3192
3188	static int set_backlight_via_aux(struct dc_link *link, uint32_t brightness)
3189	{
3190	bool rc;
3191
3192	if (!link)
3193	return 1;
3194
3195	rc = dc_link_set_backlight_level_nits(link, true, brightness,
3196	AUX_BL_DEFAULT_TRANSITION_TIME_MS);
3197
3198	return rc ? 0 : 1;
3199	}
3200
3201	static int get_brightness_range(const struct amdgpu_dm_backlight_caps *caps,	3193	static int get_brightness_range(const struct amdgpu_dm_backlight_caps *caps,
3202	unsigned min, unsigned max)	3194	unsigned min, unsigned max)
3203	{	3195	{
@@ -3260,9 +3252,10 @@ static int amdgpu_dm_backlight_update_status(struct backlight_device *bd) · 56 unmodified lines
3260	brightness = convert_brightness_from_user(&caps, bd->props.brightness);	3252	brightness = convert_brightness_from_user(&caps, bd->props.brightness);
3261	// Change brightness based on AUX property	3253	// Change brightness based on AUX property
3262	if (caps.aux_support)	3254	if (caps.aux_support)
3263	return set_backlight_via_aux(link, brightness);	3255	rc = dc_link_set_backlight_level_nits(link, true, brightness,
3264		3256	AUX_BL_DEFAULT_TRANSITION_TIME_MS);
3265	rc = dc_link_set_backlight_level(dm->backlight_link, brightness, 0);	3257	else
		3258	rc = dc_link_set_backlight_level(dm->backlight_link, brightness, 0);
3266		3259
3267	return rc ? 0 : 1;	3260	return rc ? 0 : 1;
3268	}	3261	}
@@ -3270,11 +3263,27 @@ static int amdgpu_dm_backlight_update_status(struct backlight_device *bd) · 1 unmodified line
3270	static int amdgpu_dm_backlight_get_brightness(struct backlight_device *bd)	3263	static int amdgpu_dm_backlight_get_brightness(struct backlight_device *bd)
3271	{	3264	{
3272	struct amdgpu_display_manager *dm = bl_get_data(bd);	3265	struct amdgpu_display_manager *dm = bl_get_data(bd);
3273	int ret = dc_link_get_backlight_level(dm->backlight_link);	3266	struct amdgpu_dm_backlight_caps caps;
		3267
		3268	amdgpu_dm_update_backlight_caps(dm);
		3269	caps = dm->backlight_caps;
		3270
		3271	if (caps.aux_support) {
		3272	struct dc_link link = (struct dc_link )dm->backlight_link;
		3273	u32 avg, peak;
		3274	bool rc;
3274		3275
3275	if (ret == DC_ERROR_UNEXPECTED)	3276	rc = dc_link_get_backlight_level_nits(link, &avg, &peak);
3276	return bd->props.brightness;	3277	if (!rc)
3277	return convert_brightness_to_user(&dm->backlight_caps, ret);	3278	return bd->props.brightness;
		3279	return convert_brightness_to_user(&caps, avg);
		3280	} else {
		3281	int ret = dc_link_get_backlight_level(dm->backlight_link);
		3282
		3283	if (ret == DC_ERROR_UNEXPECTED)
		3284	return bd->props.brightness;
		3285	return convert_brightness_to_user(&caps, ret);
		3286	}
3278	}	3287	}
3279		3288
3280	static const struct backlight_ops amdgpu_dm_backlight_ops = {	3289	static const struct backlight_ops amdgpu_dm_backlight_ops = {
@@ -4716,6 +4725,7 @@ static int fill_dc_plane_attributes(struct amdgpu_device *adev, · 1435 unmodified lines
4716	dc_plane_state->global_alpha_value = plane_info.global_alpha_value;	4725	dc_plane_state->global_alpha_value = plane_info.global_alpha_value;
4717	dc_plane_state->dcc = plane_info.dcc;	4726	dc_plane_state->dcc = plane_info.dcc;
4718	dc_plane_state->layer_index = plane_info.layer_index; // Always returns 0	4727	dc_plane_state->layer_index = plane_info.layer_index; // Always returns 0
		4728	dc_plane_state->flip_int_enabled = true;
4719		4729
4720	/*	4730	/*
4721	* Always set input transfer function, since plane state is refreshed	4731	* Always set input transfer function, since plane state is refreshed

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

@@ -2602,7 +2602,6 @@ bool dc_link_set_backlight_level(const struct dc_link *link, · 2601 unmodified lines
2602	if (pipe_ctx->plane_state == NULL)	2602	if (pipe_ctx->plane_state == NULL)
2603	frame_ramp = 0;	2603	frame_ramp = 0;
2604	} else {	2604	} else {
2605	ASSERT(false);
2606	return false;	2605	return false;
2607	}	2606	}
2608		2607

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

@@ -887,6 +887,7 @@ struct dc_plane_state { · 886 unmodified lines
887	int layer_index;	887	int layer_index;
888		888
889	union surface_update_flags update_flags;	889	union surface_update_flags update_flags;
		890	bool flip_int_enabled;
890	/* private to DC core */	891	/* private to DC core */
891	struct dc_plane_status status;	892	struct dc_plane_status status;
892	struct dc_context *ctx;	893	struct dc_context *ctx;

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c+11−0

 	REG_UPDATE(DCHUBP_CNTL, HUBP_DISABLE, reset ? 1 : 0);
 }
+void hubp1_set_flip_int(struct hubp *hubp)
+{
+	struct dcn10_hubp *hubp1 = TO_DCN10_HUBP(hubp);
+	REG_UPDATE(DCSURF_SURFACE_FLIP_INTERRUPT,
+		SURFACE_FLIP_INT_MASK, 1);
+	return;
+}
 void hubp1_init(struct hubp *hubp)
 {
 	//do nothing
 	.dmdata_load = NULL,
 	.hubp_soft_reset = hubp1_soft_reset,
 	.hubp_in_blank = hubp1_in_blank,
+	.hubp_set_flip_int = hubp1_set_flip_int,
 };
 /*****************************************/

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.h+6−0

 	SRI(DCSURF_SURFACE_EARLIEST_INUSE_C, HUBPREQ, id),\
 	SRI(DCSURF_SURFACE_EARLIEST_INUSE_HIGH_C, HUBPREQ, id),\
 	SRI(DCSURF_SURFACE_CONTROL, HUBPREQ, id),\
+	SRI(DCSURF_SURFACE_FLIP_INTERRUPT, HUBPREQ, id),\
 	SRI(HUBPRET_CONTROL, HUBPRET, id),\
 	SRI(DCN_EXPANSION_MODE, HUBPREQ, id),\
 	SRI(DCHUBP_REQ_SIZE_CONFIG, HUBP, id),\
 	uint32_t DCSURF_SURFACE_EARLIEST_INUSE_C; \
 	uint32_t DCSURF_SURFACE_EARLIEST_INUSE_HIGH_C; \
 	uint32_t DCSURF_SURFACE_CONTROL; \
+	uint32_t DCSURF_SURFACE_FLIP_INTERRUPT; \
 	uint32_t HUBPRET_CONTROL; \
 	uint32_t DCN_EXPANSION_MODE; \
 	uint32_t DCHUBP_REQ_SIZE_CONFIG; \
 	HUBP_SF(HUBPREQ0_DCSURF_SURFACE_CONTROL, SECONDARY_META_SURFACE_TMZ_C, mask_sh),\
 	HUBP_SF(HUBPREQ0_DCSURF_SURFACE_CONTROL, SECONDARY_SURFACE_DCC_EN, mask_sh),\
 	HUBP_SF(HUBPREQ0_DCSURF_SURFACE_CONTROL, SECONDARY_SURFACE_DCC_IND_64B_BLK, mask_sh),\
+	HUBP_SF(HUBPREQ0_DCSURF_SURFACE_FLIP_INTERRUPT, SURFACE_FLIP_INT_MASK, mask_sh),\
 	HUBP_SF(HUBPRET0_HUBPRET_CONTROL, DET_BUF_PLANE1_BASE_ADDRESS, mask_sh),\
 	HUBP_SF(HUBPRET0_HUBPRET_CONTROL, CROSSBAR_SRC_CB_B, mask_sh),\
 	HUBP_SF(HUBPRET0_HUBPRET_CONTROL, CROSSBAR_SRC_CR_R, mask_sh),\
 	type PRIMARY_SURFACE_DCC_IND_64B_BLK;\
 	type SECONDARY_SURFACE_DCC_EN;\
 	type SECONDARY_SURFACE_DCC_IND_64B_BLK;\
+	type SURFACE_FLIP_INT_MASK;\
 	type DET_BUF_PLANE1_BASE_ADDRESS;\
 	type CROSSBAR_SRC_CB_B;\
 	type CROSSBAR_SRC_CR_R;\
 bool hubp1_in_blank(struct hubp *hubp);
 void hubp1_soft_reset(struct hubp *hubp, bool reset);
+void hubp1_set_flip_int(struct hubp *hubp);
 #endif

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

@@ -2196,6 +2196,13 @@ static void dcn10_enable_plane( · 2195 unmodified lines
2196	if (dc->debug.sanity_checks) {	2196	if (dc->debug.sanity_checks) {
2197	hws->funcs.verify_allow_pstate_change_high(dc);	2197	hws->funcs.verify_allow_pstate_change_high(dc);
2198	}	2198	}
		2199
		2200	if (!pipe_ctx->top_pipe
		2201	&& pipe_ctx->plane_state
		2202	&& pipe_ctx->plane_state->flip_int_enabled
		2203	&& pipe_ctx->plane_res.hubp->funcs->hubp_set_flip_int)
		2204	pipe_ctx->plane_res.hubp->funcs->hubp_set_flip_int(pipe_ctx->plane_res.hubp);
		2205
2199	}	2206	}
2200		2207
2201	void dcn10_program_gamut_remap(struct pipe_ctx *pipe_ctx)	2208	void dcn10_program_gamut_remap(struct pipe_ctx *pipe_ctx)

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

@@ -1597,6 +1597,7 @@ static struct hubp_funcs dcn20_hubp_funcs = { · 1596 unmodified lines
1597	.validate_dml_output = hubp2_validate_dml_output,	1597	.validate_dml_output = hubp2_validate_dml_output,
1598	.hubp_in_blank = hubp1_in_blank,	1598	.hubp_in_blank = hubp1_in_blank,
1599	.hubp_soft_reset = hubp1_soft_reset,	1599	.hubp_soft_reset = hubp1_soft_reset,
		1600	.hubp_set_flip_int = hubp1_set_flip_int,
1600	};	1601	};
1601		1602
1602		1603

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hwseq.c+8−32

@@ -1146,6 +1146,12 @@ void dcn20_enable_plane( · 1145 unmodified lines
1146	pipe_ctx->plane_res.hubp->funcs->hubp_set_vm_system_aperture_settings(pipe_ctx->plane_res.hubp, &apt);	1146	pipe_ctx->plane_res.hubp->funcs->hubp_set_vm_system_aperture_settings(pipe_ctx->plane_res.hubp, &apt);
1147	}	1147	}
1148		1148
		1149	if (!pipe_ctx->top_pipe
		1150	&& pipe_ctx->plane_state
		1151	&& pipe_ctx->plane_state->flip_int_enabled
		1152	&& pipe_ctx->plane_res.hubp->funcs->hubp_set_flip_int)
		1153	pipe_ctx->plane_res.hubp->funcs->hubp_set_flip_int(pipe_ctx->plane_res.hubp);
		1154
1149	// if (dc->debug.sanity_checks) {	1155	// if (dc->debug.sanity_checks) {
1150	// dcn10_verify_allow_pstate_change_high(dc);	1156	// dcn10_verify_allow_pstate_change_high(dc);
1151	// }	1157	// }
@@ -1501,38 +1507,8 @@ static void dcn20_update_dchubp_dpp( · 349 unmodified lines
1501	if (pipe_ctx->update_flags.bits.enable \|\| pipe_ctx->update_flags.bits.opp_changed	1507	if (pipe_ctx->update_flags.bits.enable \|\| pipe_ctx->update_flags.bits.opp_changed
1502	\|\| pipe_ctx->stream->update_flags.bits.gamut_remap	1508	\|\| pipe_ctx->stream->update_flags.bits.gamut_remap
1503	\|\| pipe_ctx->stream->update_flags.bits.out_csc) {	1509	\|\| pipe_ctx->stream->update_flags.bits.out_csc) {
1504	struct mpc *mpc = pipe_ctx->stream_res.opp->ctx->dc->res_pool->mpc;	1510	/* dpp/cm gamut remap*/
1505		1511	dc->hwss.program_gamut_remap(pipe_ctx);
1506	if (mpc->funcs->set_gamut_remap) {
1507	int i;
1508	int mpcc_id = hubp->inst;
1509	struct mpc_grph_gamut_adjustment adjust;
1510	bool enable_remap_dpp = false;
1511
1512	memset(&adjust, 0, sizeof(adjust));
1513	adjust.gamut_adjust_type = GRAPHICS_GAMUT_ADJUST_TYPE_BYPASS;
1514
1515	/* save the enablement of gamut remap for dpp */
1516	enable_remap_dpp = pipe_ctx->stream->gamut_remap_matrix.enable_remap;
1517
1518	/* force bypass gamut remap for dpp/cm */
1519	pipe_ctx->stream->gamut_remap_matrix.enable_remap = false;
1520	dc->hwss.program_gamut_remap(pipe_ctx);
1521
1522	/* restore gamut remap flag and use this remap into mpc */
1523	pipe_ctx->stream->gamut_remap_matrix.enable_remap = enable_remap_dpp;
1524
1525	/* build remap matrix for top plane if enabled */
1526	if (enable_remap_dpp && pipe_ctx->top_pipe == NULL) {
1527	adjust.gamut_adjust_type = GRAPHICS_GAMUT_ADJUST_TYPE_SW;
1528	for (i = 0; i < CSC_TEMPERATURE_MATRIX_SIZE; i++)
1529	adjust.temperature_matrix[i] =
1530	pipe_ctx->stream->gamut_remap_matrix.matrix[i];
1531	}
1532	mpc->funcs->set_gamut_remap(mpc, mpcc_id, &adjust);
1533	} else
1534	/* dpp/cm gamut remap*/
1535	dc->hwss.program_gamut_remap(pipe_ctx);
1536		1512
1537	/call the dcn2 method which uses mpc csc/	1513	/call the dcn2 method which uses mpc csc/
1538	dc->hwss.program_output_csc(dc,	1514	dc->hwss.program_output_csc(dc,

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

@@ -838,6 +838,7 @@ static struct hubp_funcs dcn21_hubp_funcs = { · 837 unmodified lines
838	.hubp_set_flip_control_surface_gsl = hubp2_set_flip_control_surface_gsl,	838	.hubp_set_flip_control_surface_gsl = hubp2_set_flip_control_surface_gsl,
839	.hubp_init = hubp21_init,	839	.hubp_init = hubp21_init,
840	.validate_dml_output = hubp21_validate_dml_output,	840	.validate_dml_output = hubp21_validate_dml_output,
		841	.hubp_set_flip_int = hubp1_set_flip_int,
841	};	842	};
842		843
843	bool hubp21_construct(	844	bool hubp21_construct(

drivers/gpu/drm/amd/display/dc/dcn21/dcn21_resource.c+7−6

 	.num_banks = 8,
 	.num_chans = 4,
 	.vmm_page_size_bytes = 4096,
-	.dram_clock_change_latency_us = 11.72,
+	.dram_clock_change_latency_us = 23.84,
 	.return_bus_width_bytes = 64,
 	.dispclk_dppclk_vco_speed_mhz = 3600,
 	.xfc_bus_transport_time_us = 4,
 {
 	int i;
-	DC_FP_START();
 	if (dc->bb_overrides.sr_exit_time_ns) {
 		for (i = 0; i < WM_SET_COUNT; i++) {
 			  dc->clk_mgr->bw_params->wm_table.entries[i].sr_exit_time_us =
 				dc->bb_overrides.dram_clock_change_latency_ns / 1000.0;
 		}
 	}
-	DC_FP_END();
 }
 void dcn21_calculate_wm(
 	int vlevel = 0;
 	int pipe_split_from[MAX_PIPES];
 	int pipe_cnt = 0;
-	display_e2e_pipe_params_st *pipes = kzalloc(dc->res_pool->pipe_count * sizeof(display_e2e_pipe_params_st), GFP_KERNEL);
+	display_e2e_pipe_params_st *pipes = kzalloc(dc->res_pool->pipe_count * sizeof(display_e2e_pipe_params_st), GFP_ATOMIC);
 	DC_LOGGER_INIT(dc->ctx->logger);
 	BW_VAL_TRACE_COUNT();
 	dcn2_1_soc.num_chans = bw_params->num_channels;
 	ASSERT(clk_table->num_entries);
+	/* Copy dcn2_1_soc.clock_limits to clock_limits to avoid copying over null states later */
+	for (i = 0; i < dcn2_1_soc.num_states + 1; i++) {
+		clock_limits[i] = dcn2_1_soc.clock_limits[i];
+	}
 	for (i = 0; i < clk_table->num_entries; i++) {
 		/* loop backwards*/
 		for (closest_clk_lvl = 0, j = dcn2_1_soc.num_states - 1; j >= 0; j--) {

drivers/gpu/drm/amd/display/dc/dcn30/dcn30_cm_common.c+18−8

 	struct pwl_result_data *rgb_resulted;
 	struct pwl_result_data *rgb;
 	struct pwl_result_data *rgb_plus_1;
+	struct pwl_result_data *rgb_minus_1;
 	struct fixed31_32 end_value;
 	int32_t region_start, region_end;
 		region_start = -MAX_LOW_POINT;
 		region_end   = NUMBER_REGIONS - MAX_LOW_POINT;
 	} else {
-		/* 10 segments
+		/* 11 segments
 		 * segment is from 2^-10 to 2^0
 		 * There are less than 256 points, for optimization
 		 */
 		seg_distr[7] = 4;
 		seg_distr[8] = 4;
 		seg_distr[9] = 4;
+		seg_distr[10] = 1;
 		region_start = -10;
-		region_end = 0;
+		region_end = 1;
 	}
 	for (i = region_end - region_start; i < MAX_REGIONS_NUMBER ; i++)
 	rgb_resulted[hw_points - 1].green = output_tf->tf_pts.green[start_index];
 	rgb_resulted[hw_points - 1].blue = output_tf->tf_pts.blue[start_index];
+	rgb_resulted[hw_points].red = rgb_resulted[hw_points - 1].red;
+	rgb_resulted[hw_points].green = rgb_resulted[hw_points - 1].green;
+	rgb_resulted[hw_points].blue = rgb_resulted[hw_points - 1].blue;
 	// All 3 color channels have same x
 	corner_points[0].red.x = dc_fixpt_pow(dc_fixpt_from_int(2),
 					     dc_fixpt_from_int(region_start));
 	rgb = rgb_resulted;
 	rgb_plus_1 = rgb_resulted + 1;
+	rgb_minus_1 = rgb;
 	i = 1;
 	while (i != hw_points + 1) {
-		if (dc_fixpt_lt(rgb_plus_1->red, rgb->red))
+		if (i >= hw_points - 1) {
-			rgb_plus_1->red = rgb->red;
+			if (dc_fixpt_lt(rgb_plus_1->red, rgb->red))
-		if (dc_fixpt_lt(rgb_plus_1->green, rgb->green))
+				rgb_plus_1->red = dc_fixpt_add(rgb->red, rgb_minus_1->delta_red);
-			rgb_plus_1->green = rgb->green;
+			if (dc_fixpt_lt(rgb_plus_1->green, rgb->green))
-		if (dc_fixpt_lt(rgb_plus_1->blue, rgb->blue))
+				rgb_plus_1->green = dc_fixpt_add(rgb->green, rgb_minus_1->delta_green);
-			rgb_plus_1->blue = rgb->blue;
+			if (dc_fixpt_lt(rgb_plus_1->blue, rgb->blue))
+				rgb_plus_1->blue = dc_fixpt_add(rgb->blue, rgb_minus_1->delta_blue);
+		}
 		rgb->delta_red   = dc_fixpt_sub(rgb_plus_1->red,   rgb->red);
 		rgb->delta_green = dc_fixpt_sub(rgb_plus_1->green, rgb->green);
 		}
 		++rgb_plus_1;
+		rgb_minus_1 = rgb;
 		++rgb;
 		++i;
 	}

drivers/gpu/drm/amd/display/dc/dcn30/dcn30_hubp.c+1−0

@@ -511,6 +511,7 @@ static struct hubp_funcs dcn30_hubp_funcs = { · 510 unmodified lines
511	.hubp_init = hubp3_init,	511	.hubp_init = hubp3_init,
512	.hubp_in_blank = hubp1_in_blank,	512	.hubp_in_blank = hubp1_in_blank,
513	.hubp_soft_reset = hubp1_soft_reset,	513	.hubp_soft_reset = hubp1_soft_reset,
		514	.hubp_set_flip_int = hubp1_set_flip_int,
514	};	515	};
515		516
516	bool hubp3_construct(	517	bool hubp3_construct(

drivers/gpu/drm/amd/display/dc/dcn30/dcn30_resource.c+31−0

@@ -2508,6 +2508,19 @@ static const struct resource_funcs dcn30_res_pool_funcs = { · 2507 unmodified lines
2508	.patch_unknown_plane_state = dcn20_patch_unknown_plane_state,	2508	.patch_unknown_plane_state = dcn20_patch_unknown_plane_state,
2509	};	2509	};
2510		2510
		2511	#define CTX ctx
		2512
		2513	#define REG(reg_name) \
		2514	(DCN_BASE.instance[0].segment[mm ## reg_name ## _BASE_IDX] + mm ## reg_name)
		2515
		2516	static uint32_t read_pipe_fuses(struct dc_context *ctx)
		2517	{
		2518	uint32_t value = REG_READ(CC_DC_PIPE_DIS);
		2519	/* Support for max 6 pipes */
		2520	value = value & 0x3f;
		2521	return value;
		2522	}
		2523
2511	static bool dcn30_resource_construct(	2524	static bool dcn30_resource_construct(
2512	uint8_t num_virtual_links,	2525	uint8_t num_virtual_links,
2513	struct dc *dc,	2526	struct dc *dc,
@@ -2517,6 +2530,15 @@ static bool dcn30_resource_construct( · 3 unmodified lines
2517	struct dc_context *ctx = dc->ctx;	2530	struct dc_context *ctx = dc->ctx;
2518	struct irq_service_init_data init_data;	2531	struct irq_service_init_data init_data;
2519	struct ddc_service_init_data ddc_init_data;	2532	struct ddc_service_init_data ddc_init_data;
		2533	uint32_t pipe_fuses = read_pipe_fuses(ctx);
		2534	uint32_t num_pipes = 0;
		2535
		2536	if (!(pipe_fuses == 0 \|\| pipe_fuses == 0x3e)) {
		2537	BREAK_TO_DEBUGGER();
		2538	dm_error("DC: Unexpected fuse recipe for navi2x !\n");
		2539	/* fault to single pipe */
		2540	pipe_fuses = 0x3e;
		2541	}
2520		2542
2521	DC_FP_START();	2543	DC_FP_START();
2522		2544
@@ -2650,6 +2672,15 @@ static bool dcn30_resource_construct( · 127 unmodified lines
2650	/* PP Lib and SMU interfaces */	2672	/* PP Lib and SMU interfaces */
2651	init_soc_bounding_box(dc, pool);	2673	init_soc_bounding_box(dc, pool);
2652		2674
		2675	num_pipes = dcn3_0_ip.max_num_dpp;
		2676
		2677	for (i = 0; i < dcn3_0_ip.max_num_dpp; i++)
		2678	if (pipe_fuses & 1 << i)
		2679	num_pipes--;
		2680
		2681	dcn3_0_ip.max_num_dpp = num_pipes;
		2682	dcn3_0_ip.max_num_otg = num_pipes;
		2683
2653	dml_init_instance(&dc->dml, &dcn3_0_soc, &dcn3_0_ip, DML_PROJECT_DCN30);	2684	dml_init_instance(&dc->dml, &dcn3_0_soc, &dcn3_0_ip, DML_PROJECT_DCN30);
2654		2685
2655	/* IRQ */	2686	/* IRQ */

drivers/gpu/drm/amd/display/dc/dcn301/dcn301_resource.c+95−1

@@ -1619,12 +1619,106 @@ static void dcn301_update_bw_bounding_box(struct dc dc, struct clk_bw_params b · 1618 unmodified lines
1619	dml_init_instance(&dc->dml, &dcn3_01_soc, &dcn3_01_ip, DML_PROJECT_DCN30);	1619	dml_init_instance(&dc->dml, &dcn3_01_soc, &dcn3_01_ip, DML_PROJECT_DCN30);
1620	}	1620	}
1621		1621
		1622	static void calculate_wm_set_for_vlevel(
		1623	int vlevel,
		1624	struct wm_range_table_entry *table_entry,
		1625	struct dcn_watermarks *wm_set,
		1626	struct display_mode_lib *dml,
		1627	display_e2e_pipe_params_st *pipes,
		1628	int pipe_cnt)
		1629	{
		1630	double dram_clock_change_latency_cached = dml->soc.dram_clock_change_latency_us;
		1631
		1632	ASSERT(vlevel < dml->soc.num_states);
		1633	/* only pipe 0 is read for voltage and dcf/soc clocks */
		1634	pipes[0].clks_cfg.voltage = vlevel;
		1635	pipes[0].clks_cfg.dcfclk_mhz = dml->soc.clock_limits[vlevel].dcfclk_mhz;
		1636	pipes[0].clks_cfg.socclk_mhz = dml->soc.clock_limits[vlevel].socclk_mhz;
		1637
		1638	dml->soc.dram_clock_change_latency_us = table_entry->pstate_latency_us;
		1639	dml->soc.sr_exit_time_us = table_entry->sr_exit_time_us;
		1640	dml->soc.sr_enter_plus_exit_time_us = table_entry->sr_enter_plus_exit_time_us;
		1641
		1642	wm_set->urgent_ns = get_wm_urgent(dml, pipes, pipe_cnt) * 1000;
		1643	wm_set->cstate_pstate.cstate_enter_plus_exit_ns = get_wm_stutter_enter_exit(dml, pipes, pipe_cnt) * 1000;
		1644	wm_set->cstate_pstate.cstate_exit_ns = get_wm_stutter_exit(dml, pipes, pipe_cnt) * 1000;
		1645	wm_set->cstate_pstate.pstate_change_ns = get_wm_dram_clock_change(dml, pipes, pipe_cnt) * 1000;
		1646	wm_set->pte_meta_urgent_ns = get_wm_memory_trip(dml, pipes, pipe_cnt) * 1000;
		1647	wm_set->frac_urg_bw_nom = get_fraction_of_urgent_bandwidth(dml, pipes, pipe_cnt) * 1000;
		1648	wm_set->frac_urg_bw_flip = get_fraction_of_urgent_bandwidth_imm_flip(dml, pipes, pipe_cnt) * 1000;
		1649	wm_set->urgent_latency_ns = get_urgent_latency(dml, pipes, pipe_cnt) * 1000;
		1650	dml->soc.dram_clock_change_latency_us = dram_clock_change_latency_cached;
		1651
		1652	}
		1653
		1654	static void dcn301_calculate_wm_and_dlg(
		1655	struct dc dc, struct dc_state context,
		1656	display_e2e_pipe_params_st *pipes,
		1657	int pipe_cnt,
		1658	int vlevel_req)
		1659	{
		1660	int i, pipe_idx;
		1661	int vlevel, vlevel_max;
		1662	struct wm_range_table_entry *table_entry;
		1663	struct clk_bw_params *bw_params = dc->clk_mgr->bw_params;
		1664
		1665	ASSERT(bw_params);
		1666
		1667	vlevel_max = bw_params->clk_table.num_entries - 1;
		1668
		1669	/* WM Set D */
		1670	table_entry = &bw_params->wm_table.entries[WM_D];
		1671	if (table_entry->wm_type == WM_TYPE_RETRAINING)
		1672	vlevel = 0;
		1673	else
		1674	vlevel = vlevel_max;
		1675	calculate_wm_set_for_vlevel(vlevel, table_entry, &context->bw_ctx.bw.dcn.watermarks.d,
		1676	&context->bw_ctx.dml, pipes, pipe_cnt);
		1677	/* WM Set C */
		1678	table_entry = &bw_params->wm_table.entries[WM_C];
		1679	vlevel = min(max(vlevel_req, 2), vlevel_max);
		1680	calculate_wm_set_for_vlevel(vlevel, table_entry, &context->bw_ctx.bw.dcn.watermarks.c,
		1681	&context->bw_ctx.dml, pipes, pipe_cnt);
		1682	/* WM Set B */
		1683	table_entry = &bw_params->wm_table.entries[WM_B];
		1684	vlevel = min(max(vlevel_req, 1), vlevel_max);
		1685	calculate_wm_set_for_vlevel(vlevel, table_entry, &context->bw_ctx.bw.dcn.watermarks.b,
		1686	&context->bw_ctx.dml, pipes, pipe_cnt);
		1687
		1688	/* WM Set A */
		1689	table_entry = &bw_params->wm_table.entries[WM_A];
		1690	vlevel = min(vlevel_req, vlevel_max);
		1691	calculate_wm_set_for_vlevel(vlevel, table_entry, &context->bw_ctx.bw.dcn.watermarks.a,
		1692	&context->bw_ctx.dml, pipes, pipe_cnt);
		1693
		1694	for (i = 0, pipe_idx = 0; i < dc->res_pool->pipe_count; i++) {
		1695	if (!context->res_ctx.pipe_ctx[i].stream)
		1696	continue;
		1697
		1698	pipes[pipe_idx].clks_cfg.dispclk_mhz = get_dispclk_calculated(&context->bw_ctx.dml, pipes, pipe_cnt);
		1699	pipes[pipe_idx].clks_cfg.dppclk_mhz = get_dppclk_calculated(&context->bw_ctx.dml, pipes, pipe_cnt, pipe_idx);
		1700
		1701	if (dc->config.forced_clocks) {
		1702	pipes[pipe_idx].clks_cfg.dispclk_mhz = context->bw_ctx.dml.soc.clock_limits[0].dispclk_mhz;
		1703	pipes[pipe_idx].clks_cfg.dppclk_mhz = context->bw_ctx.dml.soc.clock_limits[0].dppclk_mhz;
		1704	}
		1705	if (dc->debug.min_disp_clk_khz > pipes[pipe_idx].clks_cfg.dispclk_mhz * 1000)
		1706	pipes[pipe_idx].clks_cfg.dispclk_mhz = dc->debug.min_disp_clk_khz / 1000.0;
		1707	if (dc->debug.min_dpp_clk_khz > pipes[pipe_idx].clks_cfg.dppclk_mhz * 1000)
		1708	pipes[pipe_idx].clks_cfg.dppclk_mhz = dc->debug.min_dpp_clk_khz / 1000.0;
		1709
		1710	pipe_idx++;
		1711	}
		1712
		1713	dcn20_calculate_dlg_params(dc, context, pipes, pipe_cnt, vlevel);
		1714	}
		1715
1622	static struct resource_funcs dcn301_res_pool_funcs = {	1716	static struct resource_funcs dcn301_res_pool_funcs = {
1623	.destroy = dcn301_destroy_resource_pool,	1717	.destroy = dcn301_destroy_resource_pool,
1624	.link_enc_create = dcn301_link_encoder_create,	1718	.link_enc_create = dcn301_link_encoder_create,
1625	.panel_cntl_create = dcn301_panel_cntl_create,	1719	.panel_cntl_create = dcn301_panel_cntl_create,
1626	.validate_bandwidth = dcn30_validate_bandwidth,	1720	.validate_bandwidth = dcn30_validate_bandwidth,
1627	.calculate_wm_and_dlg = dcn30_calculate_wm_and_dlg,	1721	.calculate_wm_and_dlg = dcn301_calculate_wm_and_dlg,
1628	.populate_dml_pipes = dcn30_populate_dml_pipes_from_context,	1722	.populate_dml_pipes = dcn30_populate_dml_pipes_from_context,
1629	.acquire_idle_pipe_for_layer = dcn20_acquire_idle_pipe_for_layer,	1723	.acquire_idle_pipe_for_layer = dcn20_acquire_idle_pipe_for_layer,
1630	.add_stream_to_ctx = dcn30_add_stream_to_ctx,	1724	.add_stream_to_ctx = dcn30_add_stream_to_ctx,

drivers/gpu/drm/amd/display/dc/inc/hw/hubp.h+2−0

@@ -191,6 +191,8 @@ struct hubp_funcs { · 190 unmodified lines
191	bool (hubp_in_blank)(struct hubp hubp);	191	bool (hubp_in_blank)(struct hubp hubp);
192	void (hubp_soft_reset)(struct hubp hubp, bool reset);	192	void (hubp_soft_reset)(struct hubp hubp, bool reset);
193		193
		194	void (hubp_set_flip_int)(struct hubp hubp);
		195
194	};	196	};
195		197
196	#endif	198	#endif

drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c+4−4

@@ -5216,10 +5216,10 @@ static int smu7_set_watermarks_for_clocks_ranges(struct pp_hwmgr *hwmgr, · 5215 unmodified lines
5216	for (j = 0; j < dep_sclk_table->count; j++) {	5216	for (j = 0; j < dep_sclk_table->count; j++) {
5217	valid_entry = false;	5217	valid_entry = false;
5218	for (k = 0; k < watermarks->num_wm_sets; k++) {	5218	for (k = 0; k < watermarks->num_wm_sets; k++) {
5219	if (dep_sclk_table->entries[i].clk / 10 >= watermarks->wm_clk_ranges[k].wm_min_eng_clk_in_khz &&	5219	if (dep_sclk_table->entries[i].clk >= watermarks->wm_clk_ranges[k].wm_min_eng_clk_in_khz / 10 &&
5220	dep_sclk_table->entries[i].clk / 10 < watermarks->wm_clk_ranges[k].wm_max_eng_clk_in_khz &&	5220	dep_sclk_table->entries[i].clk < watermarks->wm_clk_ranges[k].wm_max_eng_clk_in_khz / 10 &&
5221	dep_mclk_table->entries[i].clk / 10 >= watermarks->wm_clk_ranges[k].wm_min_mem_clk_in_khz &&	5221	dep_mclk_table->entries[i].clk >= watermarks->wm_clk_ranges[k].wm_min_mem_clk_in_khz / 10 &&
5222	dep_mclk_table->entries[i].clk / 10 < watermarks->wm_clk_ranges[k].wm_max_mem_clk_in_khz) {	5222	dep_mclk_table->entries[i].clk < watermarks->wm_clk_ranges[k].wm_max_mem_clk_in_khz / 10) {
5223	valid_entry = true;	5223	valid_entry = true;
5224	table->DisplayWatermark[i][j] = watermarks->wm_clk_ranges[k].wm_set_id;	5224	table->DisplayWatermark[i][j] = watermarks->wm_clk_ranges[k].wm_set_id;
5225	break;	5225	break;

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c+48−0

@@ -1505,6 +1505,48 @@ static int vega10_populate_single_lclk_level(struct pp_hwmgr *hwmgr, · 1504 unmodified lines
1505	return 0;	1505	return 0;
1506	}	1506	}
1507		1507
		1508	static int vega10_override_pcie_parameters(struct pp_hwmgr *hwmgr)
		1509	{
		1510	struct amdgpu_device adev = (struct amdgpu_device )(hwmgr->adev);
		1511	struct vega10_hwmgr *data =
		1512	(struct vega10_hwmgr *)(hwmgr->backend);
		1513	uint32_t pcie_gen = 0, pcie_width = 0;
		1514	PPTable_t *pp_table = &(data->smc_state_table.pp_table);
		1515	int i;
		1516
		1517	if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN4)
		1518	pcie_gen = 3;
		1519	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN3)
		1520	pcie_gen = 2;
		1521	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2)
		1522	pcie_gen = 1;
		1523	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1)
		1524	pcie_gen = 0;
		1525
		1526	if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X16)
		1527	pcie_width = 6;
		1528	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X12)
		1529	pcie_width = 5;
		1530	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X8)
		1531	pcie_width = 4;
		1532	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X4)
		1533	pcie_width = 3;
		1534	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X2)
		1535	pcie_width = 2;
		1536	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X1)
		1537	pcie_width = 1;
		1538
		1539	for (i = 0; i < NUM_LINK_LEVELS; i++) {
		1540	if (pp_table->PcieGenSpeed[i] > pcie_gen)
		1541	pp_table->PcieGenSpeed[i] = pcie_gen;
		1542
		1543	if (pp_table->PcieLaneCount[i] > pcie_width)
		1544	pp_table->PcieLaneCount[i] = pcie_width;
		1545	}
		1546
		1547	return 0;
		1548	}
		1549
1508	static int vega10_populate_smc_link_levels(struct pp_hwmgr *hwmgr)	1550	static int vega10_populate_smc_link_levels(struct pp_hwmgr *hwmgr)
1509	{	1551	{
1510	int result = -1;	1552	int result = -1;
@@ -2556,6 +2598,11 @@ static int vega10_init_smc_table(struct pp_hwmgr *hwmgr) · 1045 unmodified lines
2556	"Failed to initialize Link Level!",	2598	"Failed to initialize Link Level!",
2557	return result);	2599	return result);
2558		2600
		2601	result = vega10_override_pcie_parameters(hwmgr);
		2602	PP_ASSERT_WITH_CODE(!result,
		2603	"Failed to override pcie parameters!",
		2604	return result);
		2605
2559	result = vega10_populate_all_graphic_levels(hwmgr);	2606	result = vega10_populate_all_graphic_levels(hwmgr);
2560	PP_ASSERT_WITH_CODE(!result,	2607	PP_ASSERT_WITH_CODE(!result,
2561	"Failed to initialize Graphics Level!",	2608	"Failed to initialize Graphics Level!",
@@ -2922,6 +2969,7 @@ static int vega10_start_dpm(struct pp_hwmgr *hwmgr, uint32_t bitmap) · 360 unmodified lines
2922	return 0;	2969	return 0;
2923	}	2970	}
2924		2971
		2972
2925	static int vega10_enable_disable_PCC_limit_feature(struct pp_hwmgr *hwmgr, bool enable)	2973	static int vega10_enable_disable_PCC_limit_feature(struct pp_hwmgr *hwmgr, bool enable)
2926	{	2974	{
2927	struct vega10_hwmgr *data = hwmgr->backend;	2975	struct vega10_hwmgr *data = hwmgr->backend;

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega12_hwmgr.c+66−0

@@ -481,6 +481,67 @@ static void vega12_init_dpm_state(struct vega12_dpm_state *dpm_state) · 480 unmodified lines
481	dpm_state->hard_max_level = 0xffff;	481	dpm_state->hard_max_level = 0xffff;
482	}	482	}
483		483
		484	static int vega12_override_pcie_parameters(struct pp_hwmgr *hwmgr)
		485	{
		486	struct amdgpu_device adev = (struct amdgpu_device )(hwmgr->adev);
		487	struct vega12_hwmgr *data =
		488	(struct vega12_hwmgr *)(hwmgr->backend);
		489	uint32_t pcie_gen = 0, pcie_width = 0, smu_pcie_arg, pcie_gen_arg, pcie_width_arg;
		490	PPTable_t *pp_table = &(data->smc_state_table.pp_table);
		491	int i;
		492	int ret;
		493
		494	if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN4)
		495	pcie_gen = 3;
		496	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN3)
		497	pcie_gen = 2;
		498	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2)
		499	pcie_gen = 1;
		500	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1)
		501	pcie_gen = 0;
		502
		503	if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X16)
		504	pcie_width = 6;
		505	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X12)
		506	pcie_width = 5;
		507	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X8)
		508	pcie_width = 4;
		509	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X4)
		510	pcie_width = 3;
		511	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X2)
		512	pcie_width = 2;
		513	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X1)
		514	pcie_width = 1;
		515
		516	/* Bit 31:16: LCLK DPM level. 0 is DPM0, and 1 is DPM1
		517	* Bit 15:8: PCIE GEN, 0 to 3 corresponds to GEN1 to GEN4
		518	* Bit 7:0: PCIE lane width, 1 to 7 corresponds is x1 to x32
		519	*/
		520	for (i = 0; i < NUM_LINK_LEVELS; i++) {
		521	pcie_gen_arg = (pp_table->PcieGenSpeed[i] > pcie_gen) ? pcie_gen :
		522	pp_table->PcieGenSpeed[i];
		523	pcie_width_arg = (pp_table->PcieLaneCount[i] > pcie_width) ? pcie_width :
		524	pp_table->PcieLaneCount[i];
		525
		526	if (pcie_gen_arg != pp_table->PcieGenSpeed[i] \|\| pcie_width_arg !=
		527	pp_table->PcieLaneCount[i]) {
		528	smu_pcie_arg = (i << 16) \| (pcie_gen_arg << 8) \| pcie_width_arg;
		529	ret = smum_send_msg_to_smc_with_parameter(hwmgr,
		530	PPSMC_MSG_OverridePcieParameters, smu_pcie_arg,
		531	NULL);
		532	PP_ASSERT_WITH_CODE(!ret,
		533	"[OverridePcieParameters] Attempt to override pcie params failed!",
		534	return ret);
		535	}
		536
		537	/* update the pptable */
		538	pp_table->PcieGenSpeed[i] = pcie_gen_arg;
		539	pp_table->PcieLaneCount[i] = pcie_width_arg;
		540	}
		541
		542	return 0;
		543	}
		544
484	static int vega12_get_number_of_dpm_level(struct pp_hwmgr *hwmgr,	545	static int vega12_get_number_of_dpm_level(struct pp_hwmgr *hwmgr,
485	PPCLK_e clk_id, uint32_t *num_of_levels)	546	PPCLK_e clk_id, uint32_t *num_of_levels)
486	{	547	{
@@ -968,6 +1029,11 @@ static int vega12_enable_dpm_tasks(struct pp_hwmgr *hwmgr) · 481 unmodified lines
968	"Failed to enable all smu features!",	1029	"Failed to enable all smu features!",
969	return result);	1030	return result);
970		1031
		1032	result = vega12_override_pcie_parameters(hwmgr);
		1033	PP_ASSERT_WITH_CODE(!result,
		1034	"[EnableDPMTasks] Failed to override pcie parameters!",
		1035	return result);
		1036
971	tmp_result = vega12_power_control_set_level(hwmgr);	1037	tmp_result = vega12_power_control_set_level(hwmgr);
972	PP_ASSERT_WITH_CODE(!tmp_result,	1038	PP_ASSERT_WITH_CODE(!tmp_result,
973	"Failed to power control set level!",	1039	"Failed to power control set level!",

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega20_hwmgr.c+27−21

@@ -831,7 +831,9 @@ static int vega20_override_pcie_parameters(struct pp_hwmgr *hwmgr) · 830 unmodified lines
831	struct amdgpu_device adev = (struct amdgpu_device )(hwmgr->adev);	831	struct amdgpu_device adev = (struct amdgpu_device )(hwmgr->adev);
832	struct vega20_hwmgr *data =	832	struct vega20_hwmgr *data =
833	(struct vega20_hwmgr *)(hwmgr->backend);	833	(struct vega20_hwmgr *)(hwmgr->backend);
834	uint32_t pcie_gen = 0, pcie_width = 0, smu_pcie_arg;	834	uint32_t pcie_gen = 0, pcie_width = 0, smu_pcie_arg, pcie_gen_arg, pcie_width_arg;
		835	PPTable_t *pp_table = &(data->smc_state_table.pp_table);
		836	int i;
835	int ret;	837	int ret;
836		838
837	if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN4)	839	if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN4)
@@ -860,17 +862,27 @@ static int vega20_override_pcie_parameters(struct pp_hwmgr *hwmgr) · 22 unmodified lines
860	* Bit 15:8: PCIE GEN, 0 to 3 corresponds to GEN1 to GEN4	862	* Bit 15:8: PCIE GEN, 0 to 3 corresponds to GEN1 to GEN4
861	* Bit 7:0: PCIE lane width, 1 to 7 corresponds is x1 to x32	863	* Bit 7:0: PCIE lane width, 1 to 7 corresponds is x1 to x32
862	*/	864	*/
863	smu_pcie_arg = (1 << 16) \| (pcie_gen << 8) \| pcie_width;	865	for (i = 0; i < NUM_LINK_LEVELS; i++) {
864	ret = smum_send_msg_to_smc_with_parameter(hwmgr,	866	pcie_gen_arg = (pp_table->PcieGenSpeed[i] > pcie_gen) ? pcie_gen :
865	PPSMC_MSG_OverridePcieParameters, smu_pcie_arg,	867	pp_table->PcieGenSpeed[i];
866	NULL);	868	pcie_width_arg = (pp_table->PcieLaneCount[i] > pcie_width) ? pcie_width :
867	PP_ASSERT_WITH_CODE(!ret,	869	pp_table->PcieLaneCount[i];
868	"[OverridePcieParameters] Attempt to override pcie params failed!",	870
869	return ret);	871	if (pcie_gen_arg != pp_table->PcieGenSpeed[i] \|\| pcie_width_arg !=
		872	pp_table->PcieLaneCount[i]) {
		873	smu_pcie_arg = (i << 16) \| (pcie_gen_arg << 8) \| pcie_width_arg;
		874	ret = smum_send_msg_to_smc_with_parameter(hwmgr,
		875	PPSMC_MSG_OverridePcieParameters, smu_pcie_arg,
		876	NULL);
		877	PP_ASSERT_WITH_CODE(!ret,
		878	"[OverridePcieParameters] Attempt to override pcie params failed!",
		879	return ret);
		880	}
870		881
871	data->pcie_parameters_override = true;	882	/* update the pptable */
872	data->pcie_gen_level1 = pcie_gen;	883	pp_table->PcieGenSpeed[i] = pcie_gen_arg;
873	data->pcie_width_level1 = pcie_width;	884	pp_table->PcieLaneCount[i] = pcie_width_arg;
		885	}
874		886
875	return 0;	887	return 0;
876	}	888	}
@@ -3319,9 +3331,7 @@ static int vega20_print_clock_levels(struct pp_hwmgr *hwmgr, · 2442 unmodified lines
3319	data->od8_settings.od8_settings_array;	3331	data->od8_settings.od8_settings_array;
3320	OverDriveTable_t *od_table =	3332	OverDriveTable_t *od_table =
3321	&(data->smc_state_table.overdrive_table);	3333	&(data->smc_state_table.overdrive_table);
3322	struct phm_ppt_v3_information *pptable_information =	3334	PPTable_t *pptable = &(data->smc_state_table.pp_table);
3323	(struct phm_ppt_v3_information *)hwmgr->pptable;
3324	PPTable_t pptable = (PPTable_t )pptable_information->smc_pptable;
3325	struct pp_clock_levels_with_latency clocks;	3335	struct pp_clock_levels_with_latency clocks;
3326	struct vega20_single_dpm_table *fclk_dpm_table =	3336	struct vega20_single_dpm_table *fclk_dpm_table =
3327	&(data->dpm_table.fclk_table);	3337	&(data->dpm_table.fclk_table);
@@ -3420,13 +3430,9 @@ static int vega20_print_clock_levels(struct pp_hwmgr *hwmgr, · 92 unmodified lines
3420	current_lane_width =	3430	current_lane_width =
3421	vega20_get_current_pcie_link_width_level(hwmgr);	3431	vega20_get_current_pcie_link_width_level(hwmgr);
3422	for (i = 0; i < NUM_LINK_LEVELS; i++) {	3432	for (i = 0; i < NUM_LINK_LEVELS; i++) {
3423	if (i == 1 && data->pcie_parameters_override) {	3433	gen_speed = pptable->PcieGenSpeed[i];
3424	gen_speed = data->pcie_gen_level1;	3434	lane_width = pptable->PcieLaneCount[i];
3425	lane_width = data->pcie_width_level1;	3435
3426	} else {
3427	gen_speed = pptable->PcieGenSpeed[i];
3428	lane_width = pptable->PcieLaneCount[i];
3429	}
3430	size += sprintf(buf + size, "%d: %s %s %dMhz %s\n", i,	3436	size += sprintf(buf + size, "%d: %s %s %dMhz %s\n", i,
3431	(gen_speed == 0) ? "2.5GT/s," :	3437	(gen_speed == 0) ? "2.5GT/s," :
3432	(gen_speed == 1) ? "5.0GT/s," :	3438	(gen_speed == 1) ? "5.0GT/s," :

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

@@ -2048,7 +2048,7 @@ static void drm_fbdev_cleanup(struct drm_fb_helper *fb_helper) · 2047 unmodified lines
2048		2048
2049	if (shadow)	2049	if (shadow)
2050	vfree(shadow);	2050	vfree(shadow);
2051	else	2051	else if (fb_helper->buffer)
2052	drm_client_buffer_vunmap(fb_helper->buffer);	2052	drm_client_buffer_vunmap(fb_helper->buffer);
2053		2053
2054	drm_client_framebuffer_delete(fb_helper->buffer);	2054	drm_client_framebuffer_delete(fb_helper->buffer);

drivers/gpu/drm/drm_gem_shmem_helper.c+22−10

 	if (--shmem->vmap_use_count > 0)
 		return;
-	if (obj->import_attach)
+	if (obj->import_attach) {
 		dma_buf_vunmap(obj->import_attach->dmabuf, map);
-	else
+	} else {
 		vunmap(shmem->vaddr);
+		drm_gem_shmem_put_pages(shmem);
+	}
 	shmem->vaddr = NULL;
-	drm_gem_shmem_put_pages(shmem);
 }
 /*
 	struct drm_gem_object *obj = vma->vm_private_data;
 	struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 	loff_t num_pages = obj->size >> PAGE_SHIFT;
+	vm_fault_t ret;
 	struct page *page;
+	pgoff_t page_offset;
-	if (vmf->pgoff >= num_pages || WARN_ON_ONCE(!shmem->pages))
+	/* We don't use vmf->pgoff since that has the fake offset */
-		return VM_FAULT_SIGBUS;
+	page_offset = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
-	page = shmem->pages[vmf->pgoff];
+	mutex_lock(&shmem->pages_lock);
-	return vmf_insert_page(vma, vmf->address, page);
+	if (page_offset >= num_pages ||
+	    WARN_ON_ONCE(!shmem->pages) ||
+	    shmem->madv < 0) {
+		ret = VM_FAULT_SIGBUS;
+	} else {
+		page = shmem->pages[page_offset];
+		ret = vmf_insert_page(vma, vmf->address, page);
+	}
+	mutex_unlock(&shmem->pages_lock);
+	return ret;
 }
 static void drm_gem_shmem_vm_open(struct vm_area_struct *vma)
 	struct drm_gem_shmem_object *shmem;
 	int ret;
-	/* Remove the fake offset */
-	vma->vm_pgoff -= drm_vma_node_start(&obj->vma_node);
 	if (obj->import_attach) {
 		/* Drop the reference drm_gem_mmap_obj() acquired.*/
 		drm_gem_object_put(obj);

drivers/gpu/drm/drm_ioc32.c+11−0

 	if (copy_from_user(&v32, (void __user *)arg, sizeof(v32)))
 		return -EFAULT;
+	memset(&v, 0, sizeof(v));
 	v = (struct drm_version) {
 		.name_len = v32.name_len,
 		.name = compat_ptr(v32.name),
 	if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32)))
 		return -EFAULT;
+	memset(&uq, 0, sizeof(uq));
 	uq = (struct drm_unique){
 		.unique_len = uq32.unique_len,
 		.unique = compat_ptr(uq32.unique),
 	if (copy_from_user(&c32, argp, sizeof(c32)))
 		return -EFAULT;
+	memset(&client, 0, sizeof(client));
 	client.idx = c32.idx;
 	err = drm_ioctl_kernel(file, drm_getclient, &client, 0);
 	if (copy_from_user(&req32, argp, sizeof(req32)))
 		return -EFAULT;
+	memset(&req, 0, sizeof(req));
 	req.request.type = req32.request.type;
 	req.request.sequence = req32.request.sequence;
 	req.request.signal = req32.request.signal;
 	struct drm_mode_fb_cmd2 req64;
 	int err;
+	memset(&req64, 0, sizeof(req64));
 	if (copy_from_user(&req64, argp,
 			   offsetof(drm_mode_fb_cmd232_t, modifier)))
 		return -EFAULT;

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

 		goto err_status;
 	}
+	err = intel_engine_init_cmd_parser(engine);
+	if (err)
+		goto err_cmd_parser;
 	intel_engine_init_active(engine, ENGINE_PHYSICAL);
 	intel_engine_init_execlists(engine);
-	intel_engine_init_cmd_parser(engine);
 	intel_engine_init__pm(engine);
 	intel_engine_init_retire(engine);
 	return 0;
+err_cmd_parser:
+	intel_breadcrumbs_free(engine->breadcrumbs);
 err_status:
 	cleanup_status_page(engine);
 	return err;

drivers/gpu/drm/i915/i915_cmd_parser.c+13−6

  * struct intel_engine_cs based on whether the platform requires software
  * command parsing.
  */
-void intel_engine_init_cmd_parser(struct intel_engine_cs *engine)
+int intel_engine_init_cmd_parser(struct intel_engine_cs *engine)
 {
 	const struct drm_i915_cmd_table *cmd_tables;
 	int cmd_table_count;
 	if (!IS_GEN(engine->i915, 7) && !(IS_GEN(engine->i915, 9) &&
 					  engine->class == COPY_ENGINE_CLASS))
-		return;
+		return 0;
 	switch (engine->class) {
 	case RENDER_CLASS:
 		break;
 	default:
 		MISSING_CASE(engine->class);
-		return;
+		goto out;
 	}
 	if (!validate_cmds_sorted(engine, cmd_tables, cmd_table_count)) {
 		drm_err(&engine->i915->drm,
 			"%s: command descriptions are not sorted\n",
 			engine->name);
-		return;
+		goto out;
 	}
 	if (!validate_regs_sorted(engine)) {
 		drm_err(&engine->i915->drm,
 			"%s: registers are not sorted\n", engine->name);
-		return;
+		goto out;
 	}
 	ret = init_hash_table(engine, cmd_tables, cmd_table_count);
 		drm_err(&engine->i915->drm,
 			"%s: initialised failed!\n", engine->name);
 		fini_hash_table(engine);
-		return;
+		goto out;
 	}
 	engine->flags |= I915_ENGINE_USING_CMD_PARSER;
+out:
+	if (intel_engine_requires_cmd_parser(engine) &&
+	    !intel_engine_using_cmd_parser(engine))
+		return -EINVAL;
+	return 0;
 }
 /**

drivers/gpu/drm/i915/i915_drv.h+1−1

@@ -1952,7 +1952,7 @@ const char i915_cache_level_str(struct drm_i915_private i915, int type); · 1951 unmodified lines
1952		1952
1953	/* i915_cmd_parser.c */	1953	/* i915_cmd_parser.c */
1954	int i915_cmd_parser_get_version(struct drm_i915_private *dev_priv);	1954	int i915_cmd_parser_get_version(struct drm_i915_private *dev_priv);
1955	void intel_engine_init_cmd_parser(struct intel_engine_cs *engine);	1955	int intel_engine_init_cmd_parser(struct intel_engine_cs *engine);
1956	void intel_engine_cleanup_cmd_parser(struct intel_engine_cs *engine);	1956	void intel_engine_cleanup_cmd_parser(struct intel_engine_cs *engine);
1957	int intel_engine_cmd_parser(struct intel_engine_cs *engine,	1957	int intel_engine_cmd_parser(struct intel_engine_cs *engine,
1958	struct i915_vma *batch,	1958	struct i915_vma *batch,

drivers/gpu/drm/i915/i915_perf.c+5−8

 {
 	int report_size = stream->oa_buffer.format_size;
 	struct drm_i915_perf_record_header header;
-	u32 sample_flags = stream->sample_flags;
 	header.type = DRM_I915_PERF_RECORD_SAMPLE;
 	header.pad = 0;
 		return -EFAULT;
 	buf += sizeof(header);
-	if (sample_flags & SAMPLE_OA_REPORT) {
+	if (copy_to_user(buf, report, report_size))
-		if (copy_to_user(buf, report, report_size))
+		return -EFAULT;
-			return -EFAULT;
-	}
 	(*offset) += header.size;
 	stream->perf->ops.oa_enable(stream);
-	if (stream->periodic)
+	if (stream->sample_flags & SAMPLE_OA_REPORT)
 		hrtimer_start(&stream->poll_check_timer,
 			      ns_to_ktime(stream->poll_oa_period),
 			      HRTIMER_MODE_REL_PINNED);
 {
 	stream->perf->ops.oa_disable(stream);
-	if (stream->periodic)
+	if (stream->sample_flags & SAMPLE_OA_REPORT)
 		hrtimer_cancel(&stream->poll_check_timer);
 }
 	 * disabled stream as an error. In particular it might otherwise lead
 	 * to a deadlock for blocking file descriptors...
 	 */
-	if (!stream->enabled)
+	if (!stream->enabled || !(stream->sample_flags & SAMPLE_OA_REPORT))
 		return -EIO;
 	if (!(file->f_flags & O_NONBLOCK)) {

drivers/gpu/drm/i915/i915_reg.h+22−1

@@ -3316,7 +3316,18 @@ static inline bool i915_mmio_reg_valid(i915_reg_t reg) · 3315 unmodified lines
3316		3316
3317	#define ILK_DISPLAY_CHICKEN1 _MMIO(0x42000)	3317	#define ILK_DISPLAY_CHICKEN1 _MMIO(0x42000)
3318	#define ILK_FBCQ_DIS (1 << 22)	3318	#define ILK_FBCQ_DIS (1 << 22)
3319	#define ILK_PABSTRETCH_DIS (1 << 21)	3319	#define ILK_PABSTRETCH_DIS REG_BIT(21)
		3320	#define ILK_SABSTRETCH_DIS REG_BIT(20)
		3321	#define IVB_PRI_STRETCH_MAX_MASK REG_GENMASK(21, 20)
		3322	#define IVB_PRI_STRETCH_MAX_X8 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 0)
		3323	#define IVB_PRI_STRETCH_MAX_X4 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 1)
		3324	#define IVB_PRI_STRETCH_MAX_X2 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 2)
		3325	#define IVB_PRI_STRETCH_MAX_X1 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 3)
		3326	#define IVB_SPR_STRETCH_MAX_MASK REG_GENMASK(19, 18)
		3327	#define IVB_SPR_STRETCH_MAX_X8 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 0)
		3328	#define IVB_SPR_STRETCH_MAX_X4 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 1)
		3329	#define IVB_SPR_STRETCH_MAX_X2 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 2)
		3330	#define IVB_SPR_STRETCH_MAX_X1 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 3)
3320		3331
3321		3332
3322	/*	3333	/*
@@ -8039,6 +8050,16 @@ enum { · 4716 unmodified lines
8039		8050
8040	#define _CHICKEN_PIPESL_1_A 0x420b0	8051	#define _CHICKEN_PIPESL_1_A 0x420b0
8041	#define _CHICKEN_PIPESL_1_B 0x420b4	8052	#define _CHICKEN_PIPESL_1_B 0x420b4
		8053	#define HSW_PRI_STRETCH_MAX_MASK REG_GENMASK(28, 27)
		8054	#define HSW_PRI_STRETCH_MAX_X8 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 0)
		8055	#define HSW_PRI_STRETCH_MAX_X4 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 1)
		8056	#define HSW_PRI_STRETCH_MAX_X2 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 2)
		8057	#define HSW_PRI_STRETCH_MAX_X1 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 3)
		8058	#define HSW_SPR_STRETCH_MAX_MASK REG_GENMASK(26, 25)
		8059	#define HSW_SPR_STRETCH_MAX_X8 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 0)
		8060	#define HSW_SPR_STRETCH_MAX_X4 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 1)
		8061	#define HSW_SPR_STRETCH_MAX_X2 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 2)
		8062	#define HSW_SPR_STRETCH_MAX_X1 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 3)
8042	#define HSW_FBCQ_DIS (1 << 22)	8063	#define HSW_FBCQ_DIS (1 << 22)
8043	#define BDW_DPRS_MASK_VBLANK_SRD (1 << 0)	8064	#define BDW_DPRS_MASK_VBLANK_SRD (1 << 0)
8044	#define CHICKEN_PIPESL_1(pipe) _MMIO_PIPE(pipe, _CHICKEN_PIPESL_1_A, _CHICKEN_PIPESL_1_B)	8065	#define CHICKEN_PIPESL_1(pipe) _MMIO_PIPE(pipe, _CHICKEN_PIPESL_1_A, _CHICKEN_PIPESL_1_B)

drivers/gpu/drm/i915/intel_pm.c+15−1

 	intel_uncore_write(&dev_priv->uncore, CHICKEN_PAR1_1,
 		   intel_uncore_read(&dev_priv->uncore, CHICKEN_PAR1_1) | DPA_MASK_VBLANK_SRD);
-	/* WaPsrDPRSUnmaskVBlankInSRD:bdw */
 	for_each_pipe(dev_priv, pipe) {
+		/* WaPsrDPRSUnmaskVBlankInSRD:bdw */
 		intel_uncore_write(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe),
 			   intel_uncore_read(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe)) |
 			   BDW_DPRS_MASK_VBLANK_SRD);
+		/* Undocumented but fixes async flip + VT-d corruption */
+		if (intel_vtd_active())
+			intel_uncore_rmw(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe),
+					 HSW_PRI_STRETCH_MAX_MASK, HSW_PRI_STRETCH_MAX_X1);
 	}
 	/* WaVSRefCountFullforceMissDisable:bdw */
 static void hsw_init_clock_gating(struct drm_i915_private *dev_priv)
 {
+	enum pipe pipe;
 	/* WaFbcAsynchFlipDisableFbcQueue:hsw,bdw */
 	intel_uncore_write(&dev_priv->uncore, CHICKEN_PIPESL_1(PIPE_A),
 		   intel_uncore_read(&dev_priv->uncore, CHICKEN_PIPESL_1(PIPE_A)) |
 		   HSW_FBCQ_DIS);
+	for_each_pipe(dev_priv, pipe) {
+		/* Undocumented but fixes async flip + VT-d corruption */
+		if (intel_vtd_active())
+			intel_uncore_rmw(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe),
+					 HSW_PRI_STRETCH_MAX_MASK, HSW_PRI_STRETCH_MAX_X1);
+	}
 	/* This is required by WaCatErrorRejectionIssue:hsw */
 	intel_uncore_write(&dev_priv->uncore, GEN7_SQ_CHICKEN_MBCUNIT_CONFIG,
 		   intel_uncore_read(&dev_priv->uncore, GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) |

drivers/gpu/drm/meson/meson_drv.c+11−0

 	return count;
 }
+static void meson_drv_shutdown(struct platform_device *pdev)
+{
+	struct meson_drm *priv = dev_get_drvdata(&pdev->dev);
+	struct drm_device *drm = priv->drm;
+	DRM_DEBUG_DRIVER("\n");
+	drm_kms_helper_poll_fini(drm);
+	drm_atomic_helper_shutdown(drm);
+}
 static int meson_drv_probe(struct platform_device *pdev)
 {
 	struct component_match *match = NULL;
 static struct platform_driver meson_drm_platform_driver = {
 	.probe      = meson_drv_probe,
+	.shutdown   = meson_drv_shutdown,
 	.driver     = {
 		.name	= "meson-drm",
 		.of_match_table = dt_match,

drivers/gpu/drm/nouveau/nouveau_bo.c+12−2

 	if (!ttm_dma)
 		return;
+	if (!ttm_dma->pages) {
+		NV_DEBUG(drm, "ttm_dma 0x%p: pages NULL\n", ttm_dma);
+		return;
+	}
 	/* Don't waste time looping if the object is coherent */
 	if (nvbo->force_coherent)
 		return;
-	for (i = 0; i < ttm_dma->num_pages; ++i) {
+	i = 0;
+	while (i < ttm_dma->num_pages) {
 		struct page *p = ttm_dma->pages[i];
 		size_t num_pages = 1;
 	if (!ttm_dma)
 		return;
+	if (!ttm_dma->pages) {
+		NV_DEBUG(drm, "ttm_dma 0x%p: pages NULL\n", ttm_dma);
+		return;
+	}
 	/* Don't waste time looping if the object is coherent */
 	if (nvbo->force_coherent)
 		return;
-	for (i = 0; i < ttm_dma->num_pages; ++i) {
+	i = 0;
+	while (i < ttm_dma->num_pages) {
 		struct page *p = ttm_dma->pages[i];
 		size_t num_pages = 1;

drivers/gpu/drm/omapdrm/dss/dsi.c+4−3

 			     const struct mipi_dsi_msg *msg)
 {
 	struct mipi_dsi_packet pkt;
+	int ret;
 	u32 r;
-	r = mipi_dsi_create_packet(&pkt, msg);
+	ret = mipi_dsi_create_packet(&pkt, msg);
-	if (r < 0)
+	if (ret < 0)
-		return r;
+		return ret;
 	WARN_ON(!dsi_bus_is_locked(dsi));

drivers/gpu/drm/qxl/qxl_display.c+1−0

@@ -328,6 +328,7 @@ static void qxl_crtc_update_monitors_config(struct drm_crtc *crtc, · 327 unmodified lines
328		328
329	head.id = i;	329	head.id = i;
330	head.flags = 0;	330	head.flags = 0;
		331	head.surface_id = 0;
331	oldcount = qdev->monitors_config->count;	332	oldcount = qdev->monitors_config->count;
332	if (crtc->state->active) {	333	if (crtc->state->active) {
333	struct drm_display_mode *mode = &crtc->mode;	334	struct drm_display_mode *mode = &crtc->mode;

drivers/gpu/drm/qxl/qxl_release.c+10−2

 				       int type, struct qxl_release **release,
 				       struct qxl_bo **rbo)
 {
-	struct qxl_bo *bo;
+	struct qxl_bo *bo, *free_bo = NULL;
 	int idr_ret;
 	int ret = 0;
 	union qxl_release_info *info;
 	mutex_lock(&qdev->release_mutex);
 	if (qdev->current_release_bo_offset[cur_idx] + 1 >= releases_per_bo[cur_idx]) {
-		qxl_bo_unref(&qdev->current_release_bo[cur_idx]);
+		free_bo = qdev->current_release_bo[cur_idx];
 		qdev->current_release_bo_offset[cur_idx] = 0;
 		qdev->current_release_bo[cur_idx] = NULL;
 	}
 		ret = qxl_release_bo_alloc(qdev, &qdev->current_release_bo[cur_idx]);
 		if (ret) {
 			mutex_unlock(&qdev->release_mutex);
+			if (free_bo) {
+				qxl_bo_unpin(free_bo);
+				qxl_bo_unref(&free_bo);
+			}
 			qxl_release_free(qdev, *release);
 			return ret;
 		}
 		*rbo = bo;
 	mutex_unlock(&qdev->release_mutex);
+	if (free_bo) {
+		qxl_bo_unpin(free_bo);
+		qxl_bo_unref(&free_bo);
+	}
 	ret = qxl_release_list_add(*release, bo);
 	qxl_bo_unref(&bo);

drivers/gpu/drm/radeon/radeon.h+2−0

@@ -574,6 +574,8 @@ struct radeon_gem { · 573 unmodified lines
574	struct list_head objects;	574	struct list_head objects;
575	};	575	};
576		576
		577	extern const struct drm_gem_object_funcs radeon_gem_object_funcs;
		578
577	int radeon_gem_init(struct radeon_device *rdev);	579	int radeon_gem_init(struct radeon_device *rdev);
578	void radeon_gem_fini(struct radeon_device *rdev);	580	void radeon_gem_fini(struct radeon_device *rdev);
579	int radeon_gem_object_create(struct radeon_device *rdev, unsigned long size,	581	int radeon_gem_object_create(struct radeon_device *rdev, unsigned long size,

drivers/gpu/drm/radeon/radeon_gem.c+2−2

@@ -43,7 +43,7 @@ struct sg_table radeon_gem_prime_get_sg_table(struct drm_gem_object obj); · 42 unmodified lines
43	int radeon_gem_prime_pin(struct drm_gem_object *obj);	43	int radeon_gem_prime_pin(struct drm_gem_object *obj);
44	void radeon_gem_prime_unpin(struct drm_gem_object *obj);	44	void radeon_gem_prime_unpin(struct drm_gem_object *obj);
45		45
46	static const struct drm_gem_object_funcs radeon_gem_object_funcs;	46	const struct drm_gem_object_funcs radeon_gem_object_funcs;
47		47
48	static void radeon_gem_object_free(struct drm_gem_object *gobj)	48	static void radeon_gem_object_free(struct drm_gem_object *gobj)
49	{	49	{
@@ -227,7 +227,7 @@ static int radeon_gem_handle_lockup(struct radeon_device *rdev, int r) · 177 unmodified lines
227	return r;	227	return r;
228	}	228	}
229		229
230	static const struct drm_gem_object_funcs radeon_gem_object_funcs = {	230	const struct drm_gem_object_funcs radeon_gem_object_funcs = {
231	.free = radeon_gem_object_free,	231	.free = radeon_gem_object_free,
232	.open = radeon_gem_object_open,	232	.open = radeon_gem_object_open,
233	.close = radeon_gem_object_close,	233	.close = radeon_gem_object_close,

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

@@ -56,6 +56,8 @@ struct drm_gem_object radeon_gem_prime_import_sg_table(struct drm_device dev, · 55 unmodified lines
56	if (ret)	56	if (ret)
57	return ERR_PTR(ret);	57	return ERR_PTR(ret);
58		58
		59	bo->tbo.base.funcs = &radeon_gem_object_funcs;
		60
59	mutex_lock(&rdev->gem.mutex);	61	mutex_lock(&rdev->gem.mutex);
60	list_add_tail(&bo->list, &rdev->gem.objects);	62	list_add_tail(&bo->list, &rdev->gem.objects);
61	mutex_unlock(&rdev->gem.mutex);	63	mutex_unlock(&rdev->gem.mutex);

drivers/gpu/drm/tiny/gm12u320.c+36−8

 struct gm12u320_device {
 	struct drm_device	         dev;
+	struct device                   *dmadev;
 	struct drm_simple_display_pipe   pipe;
 	struct drm_connector	         conn;
 	unsigned char                   *cmd_buf;
 	DRM_FORMAT_MOD_INVALID
 };
+/*
+ * FIXME: Dma-buf sharing requires DMA support by the importing device.
+ *        This function is a workaround to make USB devices work as well.
+ *        See todo.rst for how to fix the issue in the dma-buf framework.
+ */
+static struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev,
+							struct dma_buf *dma_buf)
+{
+	struct gm12u320_device *gm12u320 = to_gm12u320(dev);
+	if (!gm12u320->dmadev)
+		return ERR_PTR(-ENODEV);
+	return drm_gem_prime_import_dev(dev, dma_buf, gm12u320->dmadev);
+}
 DEFINE_DRM_GEM_FOPS(gm12u320_fops);
 static const struct drm_driver gm12u320_drm_driver = {
 	.fops		 = &gm12u320_fops,
 	DRM_GEM_SHMEM_DRIVER_OPS,
+	.gem_prime_import = gm12u320_gem_prime_import,
 };
 static const struct drm_mode_config_funcs gm12u320_mode_config_funcs = {
 				      struct gm12u320_device, dev);
 	if (IS_ERR(gm12u320))
 		return PTR_ERR(gm12u320);
+	dev = &gm12u320->dev;
+	gm12u320->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev));
+	if (!gm12u320->dmadev)
+		drm_warn(dev, "buffer sharing not supported"); /* not an error */
 	INIT_DELAYED_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work);
 	mutex_init(&gm12u320->fb_update.lock);
-	dev = &gm12u320->dev;
 	ret = drmm_mode_config_init(dev);
 	if (ret)
-		return ret;
+		goto err_put_device;
 	dev->mode_config.min_width = GM12U320_USER_WIDTH;
 	dev->mode_config.max_width = GM12U320_USER_WIDTH;
 	ret = gm12u320_usb_alloc(gm12u320);
 	if (ret)
-		return ret;
+		goto err_put_device;
 	ret = gm12u320_set_ecomode(gm12u320);
 	if (ret)
-		return ret;
+		goto err_put_device;
 	ret = gm12u320_conn_init(gm12u320);
 	if (ret)
-		return ret;
+		goto err_put_device;
 	ret = drm_simple_display_pipe_init(&gm12u320->dev,
 					   &gm12u320->pipe,
 					   gm12u320_pipe_modifiers,
 					   &gm12u320->conn);
 	if (ret)
-		return ret;
+		goto err_put_device;
 	drm_mode_config_reset(dev);
 	usb_set_intfdata(interface, dev);
 	ret = drm_dev_register(dev, 0);
 	if (ret)
-		return ret;
+		goto err_put_device;
 	drm_fbdev_generic_setup(dev, 0);
 	return 0;
+err_put_device:
+	put_device(gm12u320->dmadev);
+	return ret;
 }
 static void gm12u320_usb_disconnect(struct usb_interface *interface)
 {
 	struct drm_device *dev = usb_get_intfdata(interface);
+	struct gm12u320_device *gm12u320 = to_gm12u320(dev);
+	put_device(gm12u320->dmadev);
+	gm12u320->dmadev = NULL;
 	drm_dev_unplug(dev);
 	drm_atomic_helper_shutdown(dev);
 }

drivers/gpu/drm/ttm/ttm_bo.c+6−2

 	struct ttm_bo_device *bdev = bo->bdev;
 	struct ttm_resource_manager *man;
-	dma_resv_assert_held(bo->base.resv);
+	if (!bo->deleted)
+		dma_resv_assert_held(bo->base.resv);
 	if (bo->pin_count) {
 		ttm_bo_del_from_lru(bo);
 		 * Make pinned bos immediately available to
 		 * shrinkers, now that they are queued for
 		 * destruction.
+		 *
+		 * FIXME: QXL is triggering this. Can be removed when the
+		 * driver is fixed.
 		 */
-		if (WARN_ON(bo->pin_count)) {
+		if (WARN_ON_ONCE(bo->pin_count)) {
 			bo->pin_count = 0;
 			ttm_bo_move_to_lru_tail(bo, &bo->mem, NULL);
 		}

drivers/gpu/drm/ttm/ttm_pool.c+2−2

@@ -268,13 +268,13 @@ static void ttm_pool_type_init(struct ttm_pool_type pt, struct ttm_pool pool, · 267 unmodified lines
268	/* Remove a pool_type from the global shrinker list and free all pages */	268	/* Remove a pool_type from the global shrinker list and free all pages */
269	static void ttm_pool_type_fini(struct ttm_pool_type *pt)	269	static void ttm_pool_type_fini(struct ttm_pool_type *pt)
270	{	270	{
271	struct page p, tmp;	271	struct page *p;
272		272
273	mutex_lock(&shrinker_lock);	273	mutex_lock(&shrinker_lock);
274	list_del(&pt->shrinker_list);	274	list_del(&pt->shrinker_list);
275	mutex_unlock(&shrinker_lock);	275	mutex_unlock(&shrinker_lock);
276		276
277	list_for_each_entry_safe(p, tmp, &pt->pages, lru)	277	while ((p = ttm_pool_type_take(pt)))
278	ttm_pool_free_page(pt->pool, pt->caching, pt->order, p);	278	ttm_pool_free_page(pt->pool, pt->caching, pt->order, p);
279	}	279	}
280		280

drivers/gpu/drm/udl/udl_drv.c+17−0

@@ -32,6 +32,22 @@ static int udl_usb_resume(struct usb_interface *interface) · 31 unmodified lines
32	return drm_mode_config_helper_resume(dev);	32	return drm_mode_config_helper_resume(dev);
33	}	33	}
34		34
		35	/*
		36	* FIXME: Dma-buf sharing requires DMA support by the importing device.
		37	* This function is a workaround to make USB devices work as well.
		38	* See todo.rst for how to fix the issue in the dma-buf framework.
		39	*/
		40	static struct drm_gem_object udl_driver_gem_prime_import(struct drm_device dev,
		41	struct dma_buf *dma_buf)
		42	{
		43	struct udl_device *udl = to_udl(dev);
		44
		45	if (!udl->dmadev)
		46	return ERR_PTR(-ENODEV);
		47
		48	return drm_gem_prime_import_dev(dev, dma_buf, udl->dmadev);
		49	}
		50
35	DEFINE_DRM_GEM_FOPS(udl_driver_fops);	51	DEFINE_DRM_GEM_FOPS(udl_driver_fops);
36		52
37	static const struct drm_driver driver = {	53	static const struct drm_driver driver = {
@@ -40,6 +56,7 @@ static const struct drm_driver driver = { · 2 unmodified lines
40	/* GEM hooks */	56	/* GEM hooks */
41	.fops = &udl_driver_fops,	57	.fops = &udl_driver_fops,
42	DRM_GEM_SHMEM_DRIVER_OPS,	58	DRM_GEM_SHMEM_DRIVER_OPS,
		59	.gem_prime_import = udl_driver_gem_prime_import,
43		60
44	.name = DRIVER_NAME,	61	.name = DRIVER_NAME,
45	.desc = DRIVER_DESC,	62	.desc = DRIVER_DESC,

drivers/gpu/drm/udl/udl_drv.h+1−0

@@ -50,6 +50,7 @@ struct urb_list { · 49 unmodified lines
50	struct udl_device {	50	struct udl_device {
51	struct drm_device drm;	51	struct drm_device drm;
52	struct device *dev;	52	struct device *dev;
		53	struct device *dmadev;
53		54
54	struct drm_simple_display_pipe display_pipe;	55	struct drm_simple_display_pipe display_pipe;
55		56

drivers/gpu/drm/udl/udl_main.c+10−0

 	DRM_DEBUG("\n");
+	udl->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev));
+	if (!udl->dmadev)
+		drm_warn(dev, "buffer sharing not supported"); /* not an error */
 	mutex_init(&udl->gem_lock);
 	if (!udl_parse_vendor_descriptor(udl)) {
 err:
 	if (udl->urbs.count)
 		udl_free_urb_list(dev);
+	put_device(udl->dmadev);
 	DRM_ERROR("%d\n", ret);
 	return ret;
 }
 int udl_drop_usb(struct drm_device *dev)
 {
+	struct udl_device *udl = to_udl(dev);
 	udl_free_urb_list(dev);
+	put_device(udl->dmadev);
+	udl->dmadev = NULL;
 	return 0;
 }

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c+1−3

 	vm_fault_t ret;
 	pgoff_t fault_page_size;
 	bool write = vmf->flags & FAULT_FLAG_WRITE;
-	bool is_cow_mapping =
-		(vma->vm_flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE;
 	switch (pe_size) {
 	case PE_SIZE_PMD:
 	}
 	/* Always do write dirty-tracking and COW on PTE level. */
-	if (write && (READ_ONCE(vbo->dirty) || is_cow_mapping))
+	if (write && (READ_ONCE(vbo->dirty) || is_cow_mapping(vma->vm_flags)))
 		return VM_FAULT_FALLBACK;
 	ret = ttm_bo_vm_reserve(bo, vmf);

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

@@ -49,7 +49,7 @@ int vmw_mmap(struct file filp, struct vm_area_struct vma) · 48 unmodified lines
49	vma->vm_ops = &vmw_vm_ops;	49	vma->vm_ops = &vmw_vm_ops;
50		50
51	/* Use VM_PFNMAP rather than VM_MIXEDMAP if not a COW mapping */	51	/* Use VM_PFNMAP rather than VM_MIXEDMAP if not a COW mapping */
52	if ((vma->vm_flags & (VM_SHARED \| VM_MAYWRITE)) != VM_MAYWRITE)	52	if (!is_cow_mapping(vma->vm_flags))
53	vma->vm_flags = (vma->vm_flags & ~VM_MIXEDMAP) \| VM_PFNMAP;	53	vma->vm_flags = (vma->vm_flags & ~VM_MIXEDMAP) \| VM_PFNMAP;
54		54
55	return 0;	55	return 0;

drivers/iio/adc/Kconfig+3−0

 	select IIO_BUFFER
 	select IIO_BUFFER_HW_CONSUMER
 	select IIO_BUFFER_DMAENGINE
+	depends on HAS_IOMEM
+	depends on OF
 	help
 	  Say yes here to build support for Analog Devices Generic
 	  AXI ADC IP core. The IP core is used for interfacing with
 	depends on ARCH_STM32 || COMPILE_TEST
 	depends on OF
 	depends on REGULATOR
+	depends on HAS_IOMEM
 	select IIO_BUFFER
 	select MFD_STM32_TIMERS
 	select IIO_STM32_TIMER_TRIGGER

drivers/iio/adc/ab8500-gpadc.c+1−1

@@ -918,7 +918,7 @@ static int ab8500_gpadc_read_raw(struct iio_dev *indio_dev, · 917 unmodified lines
918	return processed;	918	return processed;
919		919
920	/* Return millivolt or milliamps or millicentigrades */	920	/* Return millivolt or milliamps or millicentigrades */
921	val = processed 1000;	921	*val = processed;
922	return IIO_VAL_INT;	922	return IIO_VAL_INT;
923	}	923	}
924		924

drivers/iio/adc/ad7949.c+1−1

@@ -91,7 +91,7 @@ static int ad7949_spi_read_channel(struct ad7949_adc_chip ad7949_adc, int val, · 90 unmodified lines
91	int ret;	91	int ret;
92	int i;	92	int i;
93	int bits_per_word = ad7949_adc->resolution;	93	int bits_per_word = ad7949_adc->resolution;
94	int mask = GENMASK(ad7949_adc->resolution, 0);	94	int mask = GENMASK(ad7949_adc->resolution - 1, 0);
95	struct spi_message msg;	95	struct spi_message msg;
96	struct spi_transfer tx[] = {	96	struct spi_transfer tx[] = {
97	{	97	{

drivers/iio/adc/qcom-spmi-vadc.c+1−1

@@ -597,7 +597,7 @@ static const struct vadc_channels vadc_chans[] = { · 596 unmodified lines
597	VADC_CHAN_NO_SCALE(P_MUX16_1_3, 1)	597	VADC_CHAN_NO_SCALE(P_MUX16_1_3, 1)
598		598
599	VADC_CHAN_NO_SCALE(LR_MUX1_BAT_THERM, 0)	599	VADC_CHAN_NO_SCALE(LR_MUX1_BAT_THERM, 0)
600	VADC_CHAN_NO_SCALE(LR_MUX2_BAT_ID, 0)	600	VADC_CHAN_VOLT(LR_MUX2_BAT_ID, 0, SCALE_DEFAULT)
601	VADC_CHAN_NO_SCALE(LR_MUX3_XO_THERM, 0)	601	VADC_CHAN_NO_SCALE(LR_MUX3_XO_THERM, 0)
602	VADC_CHAN_NO_SCALE(LR_MUX4_AMUX_THM1, 0)	602	VADC_CHAN_NO_SCALE(LR_MUX4_AMUX_THM1, 0)
603	VADC_CHAN_NO_SCALE(LR_MUX5_AMUX_THM2, 0)	603	VADC_CHAN_NO_SCALE(LR_MUX5_AMUX_THM2, 0)

drivers/iio/gyro/mpu3050-core.c+2−0

@@ -551,6 +551,8 @@ static irqreturn_t mpu3050_trigger_handler(int irq, void *p) · 550 unmodified lines
551	MPU3050_FIFO_R,	551	MPU3050_FIFO_R,
552	&fifo_values[offset],	552	&fifo_values[offset],
553	toread);	553	toread);
		554	if (ret)
		555	goto out_trigger_unlock;
554		556
555	dev_dbg(mpu3050->dev,	557	dev_dbg(mpu3050->dev,
556	"%04x %04x %04x %04x %04x\n",	558	"%04x %04x %04x %04x %04x\n",

drivers/iio/humidity/hid-sensor-humidity.c+7−5

 struct hid_humidity_state {
 	struct hid_sensor_common common_attributes;
 	struct hid_sensor_hub_attribute_info humidity_attr;
-	s32 humidity_data;
+	struct {
+		s32 humidity_data;
+		u64 timestamp __aligned(8);
+	} scan;
 	int scale_pre_decml;
 	int scale_post_decml;
 	int scale_precision;
 	struct hid_humidity_state *humid_st = iio_priv(indio_dev);
 	if (atomic_read(&humid_st->common_attributes.data_ready))
-		iio_push_to_buffers_with_timestamp(indio_dev,
+		iio_push_to_buffers_with_timestamp(indio_dev, &humid_st->scan,
-					&humid_st->humidity_data,
+						   iio_get_time_ns(indio_dev));
-					iio_get_time_ns(indio_dev));
 	return 0;
 }
 	switch (usage_id) {
 	case HID_USAGE_SENSOR_ATMOSPHERIC_HUMIDITY:
-		humid_st->humidity_data = *(s32 *)raw_data;
+		humid_st->scan.humidity_data = *(s32 *)raw_data;
 		return 0;
 	default:

drivers/iio/imu/adis16400.c+1−2

@@ -462,8 +462,7 @@ static int adis16400_initial_setup(struct iio_dev *indio_dev) · 461 unmodified lines
462	if (ret)	462	if (ret)
463	goto err_ret;	463	goto err_ret;
464		464
465	ret = sscanf(indio_dev->name, "adis%u\n", &device_id);	465	if (sscanf(indio_dev->name, "adis%u\n", &device_id) != 1) {
466	if (ret != 1) {
467	ret = -EINVAL;	466	ret = -EINVAL;
468	goto err_ret;	467	goto err_ret;
469	}	468	}

drivers/iio/light/hid-sensor-prox.c+11−2

 	struct hid_sensor_common common_attributes;
 	struct hid_sensor_hub_attribute_info prox_attr;
 	u32 human_presence;
+	int scale_pre_decml;
+	int scale_post_decml;
+	int scale_precision;
 };
 /* Channel definitions */
 		ret_type = IIO_VAL_INT;
 		break;
 	case IIO_CHAN_INFO_SCALE:
-		*val = prox_state->prox_attr.units;
+		*val = prox_state->scale_pre_decml;
-		ret_type = IIO_VAL_INT;
+		*val2 = prox_state->scale_post_decml;
+		ret_type = prox_state->scale_precision;
 		break;
 	case IIO_CHAN_INFO_OFFSET:
 		*val = hid_sensor_convert_exponent(
 			HID_USAGE_SENSOR_HUMAN_PRESENCE,
 			&st->common_attributes.sensitivity);
+	st->scale_precision = hid_sensor_format_scale(
+				hsdev->usage,
+				&st->prox_attr,
+				&st->scale_pre_decml, &st->scale_post_decml);
 	return ret;
 }

drivers/iio/temperature/hid-sensor-temperature.c+8−6

 struct temperature_state {
 	struct hid_sensor_common common_attributes;
 	struct hid_sensor_hub_attribute_info temperature_attr;
-	s32 temperature_data;
+	struct {
+		s32 temperature_data;
+		u64 timestamp __aligned(8);
+	} scan;
 	int scale_pre_decml;
 	int scale_post_decml;
 	int scale_precision;
 			BIT(IIO_CHAN_INFO_SAMP_FREQ) |
 			BIT(IIO_CHAN_INFO_HYSTERESIS),
 	},
-	IIO_CHAN_SOFT_TIMESTAMP(3),
+	IIO_CHAN_SOFT_TIMESTAMP(1),
 };
 /* Adjust channel real bits based on report descriptor */
 	struct temperature_state *temp_st = iio_priv(indio_dev);
 	if (atomic_read(&temp_st->common_attributes.data_ready))
-		iio_push_to_buffers_with_timestamp(indio_dev,
+		iio_push_to_buffers_with_timestamp(indio_dev, &temp_st->scan,
-				&temp_st->temperature_data,
+						   iio_get_time_ns(indio_dev));
-				iio_get_time_ns(indio_dev));
 	return 0;
 }
 	switch (usage_id) {
 	case HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_TEMPERATURE:
-		temp_st->temperature_data = *(s32 *)raw_data;
+		temp_st->scan.temperature_data = *(s32 *)raw_data;
 		return 0;
 	default:
 		return -EINVAL;

drivers/infiniband/hw/cxgb4/cm.c+2−2

@@ -3610,13 +3610,13 @@ int c4iw_destroy_listen(struct iw_cm_id *cm_id) · 3609 unmodified lines
3610	ep->com.local_addr.ss_family == AF_INET) {	3610	ep->com.local_addr.ss_family == AF_INET) {
3611	err = cxgb4_remove_server_filter(	3611	err = cxgb4_remove_server_filter(
3612	ep->com.dev->rdev.lldi.ports[0], ep->stid,	3612	ep->com.dev->rdev.lldi.ports[0], ep->stid,
3613	ep->com.dev->rdev.lldi.rxq_ids[0], 0);	3613	ep->com.dev->rdev.lldi.rxq_ids[0], false);
3614	} else {	3614	} else {
3615	struct sockaddr_in6 *sin6;	3615	struct sockaddr_in6 *sin6;
3616	c4iw_init_wr_wait(ep->com.wr_waitp);	3616	c4iw_init_wr_wait(ep->com.wr_waitp);
3617	err = cxgb4_remove_server(	3617	err = cxgb4_remove_server(
3618	ep->com.dev->rdev.lldi.ports[0], ep->stid,	3618	ep->com.dev->rdev.lldi.ports[0], ep->stid,
3619	ep->com.dev->rdev.lldi.rxq_ids[0], 0);	3619	ep->com.dev->rdev.lldi.rxq_ids[0], true);
3620	if (err)	3620	if (err)
3621	goto done;	3621	goto done;
3622	err = c4iw_wait_for_reply(&ep->com.dev->rdev, ep->com.wr_waitp,	3622	err = c4iw_wait_for_reply(&ep->com.dev->rdev, ep->com.wr_waitp,

drivers/infiniband/hw/hns/hns_roce_hw_v2.c+3−1

@@ -1194,8 +1194,10 @@ static void hns_roce_cmq_init_regs(struct hns_roce_dev *hr_dev, bool ring_type) · 1193 unmodified lines
1194	upper_32_bits(dma));	1194	upper_32_bits(dma));
1195	roce_write(hr_dev, ROCEE_TX_CMQ_DEPTH_REG,	1195	roce_write(hr_dev, ROCEE_TX_CMQ_DEPTH_REG,
1196	(u32)ring->desc_num >> HNS_ROCE_CMQ_DESC_NUM_S);	1196	(u32)ring->desc_num >> HNS_ROCE_CMQ_DESC_NUM_S);
1197	roce_write(hr_dev, ROCEE_TX_CMQ_HEAD_REG, 0);	1197
		1198	/* Make sure to write tail first and then head */
1198	roce_write(hr_dev, ROCEE_TX_CMQ_TAIL_REG, 0);	1199	roce_write(hr_dev, ROCEE_TX_CMQ_TAIL_REG, 0);
		1200	roce_write(hr_dev, ROCEE_TX_CMQ_HEAD_REG, 0);
1199	} else {	1201	} else {
1200	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_L_REG, (u32)dma);	1202	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_L_REG, (u32)dma);
1201	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_H_REG,	1203	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_H_REG,

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

@@ -1116,7 +1116,7 @@ static void devx_obj_build_destroy_cmd(void in, void out, void *din, · 1115 unmodified lines
1116	case MLX5_CMD_OP_CREATE_MKEY:	1116	case MLX5_CMD_OP_CREATE_MKEY:
1117	MLX5_SET(destroy_mkey_in, din, opcode,	1117	MLX5_SET(destroy_mkey_in, din, opcode,
1118	MLX5_CMD_OP_DESTROY_MKEY);	1118	MLX5_CMD_OP_DESTROY_MKEY);
1119	MLX5_SET(destroy_mkey_in, in, mkey_index, *obj_id);	1119	MLX5_SET(destroy_mkey_in, din, mkey_index, *obj_id);
1120	break;	1120	break;
1121	case MLX5_CMD_OP_CREATE_CQ:	1121	case MLX5_CMD_OP_CREATE_CQ:
1122	MLX5_SET(destroy_cq_in, din, opcode, MLX5_CMD_OP_DESTROY_CQ);	1122	MLX5_SET(destroy_cq_in, din, opcode, MLX5_CMD_OP_DESTROY_CQ);

drivers/infiniband/hw/mlx5/qp.c+14−4

 	qpc = MLX5_ADDR_OF(create_qp_in, *in, qpc);
 	MLX5_SET(qpc, qpc, uar_page, uar_index);
-	MLX5_SET(qpc, qpc, ts_format, MLX5_QPC_TIMESTAMP_FORMAT_DEFAULT);
+	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(dev->mdev));
 	MLX5_SET(qpc, qpc, log_page_size, qp->buf.page_shift - MLX5_ADAPTER_PAGE_SHIFT);
 	/* Set "fast registration enabled" for all kernel QPs */
 		}
 		return MLX5_RQC_TIMESTAMP_FORMAT_FREE_RUNNING;
 	}
-	return MLX5_RQC_TIMESTAMP_FORMAT_DEFAULT;
+	return fr_supported ? MLX5_RQC_TIMESTAMP_FORMAT_FREE_RUNNING :
+			      MLX5_RQC_TIMESTAMP_FORMAT_DEFAULT;
 }
 static int get_sq_ts_format(struct mlx5_ib_dev *dev, struct mlx5_ib_cq *send_cq)
 		}
 		return MLX5_SQC_TIMESTAMP_FORMAT_FREE_RUNNING;
 	}
-	return MLX5_SQC_TIMESTAMP_FORMAT_DEFAULT;
+	return fr_supported ? MLX5_SQC_TIMESTAMP_FORMAT_FREE_RUNNING :
+			      MLX5_SQC_TIMESTAMP_FORMAT_DEFAULT;
 }
 static int get_qp_ts_format(struct mlx5_ib_dev *dev, struct mlx5_ib_cq *send_cq,
 			MLX5_QP_TIMESTAMP_FORMAT_CAP_FREE_RUNNING ||
 		MLX5_CAP_ROCE(dev->mdev, qp_ts_format) ==
 			MLX5_QP_TIMESTAMP_FORMAT_CAP_FREE_RUNNING_AND_REAL_TIME;
-	int ts_format = MLX5_QPC_TIMESTAMP_FORMAT_DEFAULT;
+	int ts_format = fr_supported ? MLX5_QPC_TIMESTAMP_FORMAT_FREE_RUNNING :
+				       MLX5_QPC_TIMESTAMP_FORMAT_DEFAULT;
 	if (recv_cq &&
 	    recv_cq->create_flags & IB_UVERBS_CQ_FLAGS_TIMESTAMP_COMPLETION)
 	if (qp->flags & IB_QP_CREATE_MANAGED_RECV)
 		MLX5_SET(qpc, qpc, cd_slave_receive, 1);
+	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(dev->mdev));
 	MLX5_SET(qpc, qpc, rq_type, MLX5_SRQ_RQ);
 	MLX5_SET(qpc, qpc, no_sq, 1);
 	MLX5_SET(qpc, qpc, cqn_rcv, to_mcq(devr->c0)->mcq.cqn);
 	struct mlx5_ib_dev *dev;
 	int has_net_offloads;
 	__be64 *rq_pas0;
+	int ts_format;
 	void *in;
 	void *rqc;
 	void *wq;
 	dev = to_mdev(pd->device);
+	ts_format = get_rq_ts_format(dev, to_mcq(init_attr->cq));
+	if (ts_format < 0)
+		return ts_format;
 	inlen = MLX5_ST_SZ_BYTES(create_rq_in) + sizeof(u64) * rwq->rq_num_pas;
 	in = kvzalloc(inlen, GFP_KERNEL);
 	if (!in)
 	rqc = MLX5_ADDR_OF(create_rq_in, in, ctx);
 	MLX5_SET(rqc,  rqc, mem_rq_type,
 		 MLX5_RQC_MEM_RQ_TYPE_MEMORY_RQ_INLINE);
+	MLX5_SET(rqc, rqc, ts_format, ts_format);
 	MLX5_SET(rqc, rqc, user_index, rwq->user_index);
 	MLX5_SET(rqc,  rqc, cqn, to_mcq(init_attr->cq)->mcq.cqn);
 	MLX5_SET(rqc,  rqc, state, MLX5_RQC_STATE_RST);

drivers/input/joydev.c+0−1

@@ -26,7 +26,6 @@ · 25 unmodified lines
26		26
27	MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");	27	MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
28	MODULE_DESCRIPTION("Joystick device interfaces");	28	MODULE_DESCRIPTION("Joystick device interfaces");
29	MODULE_SUPPORTED_DEVICE("input/js");
30	MODULE_LICENSE("GPL");	29	MODULE_LICENSE("GPL");
31		30
32	#define JOYDEV_MINOR_BASE 0	31	#define JOYDEV_MINOR_BASE 0

drivers/iommu/amd/init.c+20−16

 	struct acpi_table_header *ivrs_base;
 	int i, remap_cache_sz, ret;
 	acpi_status status;
-	u32 pci_id;
 	if (!amd_iommu_detected)
 		return -ENODEV;
 	if (ret)
 		goto out;
-	/* Disable IOMMU if there's Stoney Ridge graphics */
-	for (i = 0; i < 32; i++) {
-		pci_id = read_pci_config(0, i, 0, 0);
-		if ((pci_id & 0xffff) == 0x1002 && (pci_id >> 16) == 0x98e4) {
-			pr_info("Disable IOMMU on Stoney Ridge\n");
-			amd_iommu_disabled = true;
-			break;
-		}
-	}
 	/* Disable any previously enabled IOMMUs */
 	if (!is_kdump_kernel() || amd_iommu_disabled)
 		disable_iommus();
 {
 	struct acpi_table_header *ivrs_base;
 	acpi_status status;
+	int i;
 	status = acpi_get_table("IVRS", 0, &ivrs_base);
 	if (status == AE_NOT_FOUND)
 	acpi_put_table(ivrs_base);
+	/* Don't use IOMMU if there is Stoney Ridge graphics */
+	for (i = 0; i < 32; i++) {
+		u32 pci_id;
+		pci_id = read_pci_config(0, i, 0, 0);
+		if ((pci_id & 0xffff) == 0x1002 && (pci_id >> 16) == 0x98e4) {
+			pr_info("Disable IOMMU on Stoney Ridge\n");
+			return false;
+		}
+	}
 	/* Make sure ACS will be enabled during PCI probe */
 	pci_request_acs();
 		}
 		break;
 	case IOMMU_IVRS_DETECTED:
-		ret = early_amd_iommu_init();
+		if (amd_iommu_disabled) {
-		init_state = ret ? IOMMU_INIT_ERROR : IOMMU_ACPI_FINISHED;
-		if (init_state == IOMMU_ACPI_FINISHED && amd_iommu_disabled) {
-			pr_info("AMD IOMMU disabled\n");
 			init_state = IOMMU_CMDLINE_DISABLED;
 			ret = -EINVAL;
+		} else {
+			ret = early_amd_iommu_init();
+			init_state = ret ? IOMMU_INIT_ERROR : IOMMU_ACPI_FINISHED;
 		}
 		break;
 	case IOMMU_ACPI_FINISHED:
 	amd_iommu_irq_remap = true;
 	ret = iommu_go_to_state(IOMMU_ACPI_FINISHED);
-	if (ret)
+	if (ret) {
+		amd_iommu_irq_remap = false;
 		return ret;
+	}
 	return amd_iommu_irq_remap ? 0 : -ENODEV;
 }

drivers/iommu/tegra-smmu.c+3−4

@@ -849,12 +849,11 @@ static struct iommu_device tegra_smmu_probe_device(struct device dev) · 848 unmodified lines
849	smmu = tegra_smmu_find(args.np);	849	smmu = tegra_smmu_find(args.np);
850	if (smmu) {	850	if (smmu) {
851	err = tegra_smmu_configure(smmu, dev, &args);	851	err = tegra_smmu_configure(smmu, dev, &args);
852	of_node_put(args.np);
853		852
854	if (err < 0)	853	if (err < 0) {
		854	of_node_put(args.np);
855	return ERR_PTR(err);	855	return ERR_PTR(err);
856		856	}
857	break;
858	}	857	}
859		858
860	of_node_put(args.np);	859	of_node_put(args.np);

drivers/irqchip/Kconfig+0−9

 config ARM_GIC
 	bool
 	select IRQ_DOMAIN_HIERARCHY
-	select GENERIC_IRQ_MULTI_HANDLER
 	select GENERIC_IRQ_EFFECTIVE_AFF_MASK
 config ARM_GIC_PM
 config ARM_GIC_V3
 	bool
-	select GENERIC_IRQ_MULTI_HANDLER
 	select IRQ_DOMAIN_HIERARCHY
 	select PARTITION_PERCPU
 	select GENERIC_IRQ_EFFECTIVE_AFF_MASK
 config ARM_VIC
 	bool
 	select IRQ_DOMAIN
-	select GENERIC_IRQ_MULTI_HANDLER
 config ARM_VIC_NR
 	int
 	bool
 	select GENERIC_IRQ_CHIP
 	select IRQ_DOMAIN
-	select GENERIC_IRQ_MULTI_HANDLER
 	select SPARSE_IRQ
 config ATMEL_AIC5_IRQ
 	bool
 	select GENERIC_IRQ_CHIP
 	select IRQ_DOMAIN
-	select GENERIC_IRQ_MULTI_HANDLER
 	select SPARSE_IRQ
 config I8259
 config FARADAY_FTINTC010
 	bool
 	select IRQ_DOMAIN
-	select GENERIC_IRQ_MULTI_HANDLER
 	select SPARSE_IRQ
 config HISILICON_IRQ_MBIGEN
 config IXP4XX_IRQ
 	bool
 	select IRQ_DOMAIN
-	select GENERIC_IRQ_MULTI_HANDLER
 	select SPARSE_IRQ
 config MADERA_IRQ
 	bool
 	depends on ARCH_CLPS711X
 	select IRQ_DOMAIN
-	select GENERIC_IRQ_MULTI_HANDLER
 	select SPARSE_IRQ
 	default y
 config ORION_IRQCHIP
 	bool
 	select IRQ_DOMAIN
-	select GENERIC_IRQ_MULTI_HANDLER
 config PIC32_EVIC
 	bool

drivers/irqchip/irq-ingenic-tcu.c+1−0

@@ -179,5 +179,6 @@ err_free_tcu: · 178 unmodified lines
179	}	179	}
180	IRQCHIP_DECLARE(jz4740_tcu_irq, "ingenic,jz4740-tcu", ingenic_tcu_irq_init);	180	IRQCHIP_DECLARE(jz4740_tcu_irq, "ingenic,jz4740-tcu", ingenic_tcu_irq_init);
181	IRQCHIP_DECLARE(jz4725b_tcu_irq, "ingenic,jz4725b-tcu", ingenic_tcu_irq_init);	181	IRQCHIP_DECLARE(jz4725b_tcu_irq, "ingenic,jz4725b-tcu", ingenic_tcu_irq_init);
		182	IRQCHIP_DECLARE(jz4760_tcu_irq, "ingenic,jz4760-tcu", ingenic_tcu_irq_init);
182	IRQCHIP_DECLARE(jz4770_tcu_irq, "ingenic,jz4770-tcu", ingenic_tcu_irq_init);	183	IRQCHIP_DECLARE(jz4770_tcu_irq, "ingenic,jz4770-tcu", ingenic_tcu_irq_init);
183	IRQCHIP_DECLARE(x1000_tcu_irq, "ingenic,x1000-tcu", ingenic_tcu_irq_init);	184	IRQCHIP_DECLARE(x1000_tcu_irq, "ingenic,x1000-tcu", ingenic_tcu_irq_init);

drivers/irqchip/irq-ingenic.c+1−0

@@ -155,6 +155,7 @@ static int __init intc_2chip_of_init(struct device_node *node, · 154 unmodified lines
155	{	155	{
156	return ingenic_intc_of_init(node, 2);	156	return ingenic_intc_of_init(node, 2);
157	}	157	}
		158	IRQCHIP_DECLARE(jz4760_intc, "ingenic,jz4760-intc", intc_2chip_of_init);
158	IRQCHIP_DECLARE(jz4770_intc, "ingenic,jz4770-intc", intc_2chip_of_init);	159	IRQCHIP_DECLARE(jz4770_intc, "ingenic,jz4770-intc", intc_2chip_of_init);
159	IRQCHIP_DECLARE(jz4775_intc, "ingenic,jz4775-intc", intc_2chip_of_init);	160	IRQCHIP_DECLARE(jz4775_intc, "ingenic,jz4775-intc", intc_2chip_of_init);
160	IRQCHIP_DECLARE(jz4780_intc, "ingenic,jz4780-intc", intc_2chip_of_init);	161	IRQCHIP_DECLARE(jz4780_intc, "ingenic,jz4780-intc", intc_2chip_of_init);

drivers/isdn/capi/kcapi.c+2−2

@@ -721,7 +721,7 @@ u16 capi20_put_message(struct capi20_appl ap, struct sk_buff skb) · 720 unmodified lines
721	* Return value: CAPI result code	721	* Return value: CAPI result code
722	*/	722	*/
723		723
724	u16 capi20_get_manufacturer(u32 contr, u8 *buf)	724	u16 capi20_get_manufacturer(u32 contr, u8 buf[CAPI_MANUFACTURER_LEN])
725	{	725	{
726	struct capi_ctr *ctr;	726	struct capi_ctr *ctr;
727	u16 ret;	727	u16 ret;
@@ -787,7 +787,7 @@ u16 capi20_get_version(u32 contr, struct capi_version *verp) · 59 unmodified lines
787	* Return value: CAPI result code	787	* Return value: CAPI result code
788	*/	788	*/
789		789
790	u16 capi20_get_serial(u32 contr, u8 *serial)	790	u16 capi20_get_serial(u32 contr, u8 serial[CAPI_SERIAL_LEN])
791	{	791	{
792	struct capi_ctr *ctr;	792	struct capi_ctr *ctr;
793	u16 ret;	793	u16 ret;

drivers/isdn/hardware/mISDN/mISDNipac.c+1−1

@@ -694,7 +694,7 @@ isac_release(struct isac_hw *isac) · 693 unmodified lines
694	{	694	{
695	if (isac->type & IPAC_TYPE_ISACX)	695	if (isac->type & IPAC_TYPE_ISACX)
696	WriteISAC(isac, ISACX_MASK, 0xff);	696	WriteISAC(isac, ISACX_MASK, 0xff);
697	else	697	else if (isac->type != 0)
698	WriteISAC(isac, ISAC_MASK, 0xff);	698	WriteISAC(isac, ISAC_MASK, 0xff);
699	if (isac->dch.timer.function != NULL) {	699	if (isac->dch.timer.function != NULL) {
700	del_timer(&isac->dch.timer);	700	del_timer(&isac->dch.timer);

drivers/leds/trigger/ledtrig-tty.c+4−7

 	if (size) {
 		ttyname = kmemdup_nul(buf, size, GFP_KERNEL);
-		if (!ttyname) {
+		if (!ttyname)
-			ret = -ENOMEM;
+			return -ENOMEM;
-			goto out_unlock;
-		}
 	} else {
 		ttyname = NULL;
 	}
 	trigger_data->ttyname = ttyname;
-out_unlock:
 	mutex_unlock(&trigger_data->mutex);
 	if (ttyname && !running)
 	if (icount.rx != trigger_data->rx ||
 	    icount.tx != trigger_data->tx) {
-		led_set_brightness(trigger_data->led_cdev, LED_ON);
+		led_set_brightness_sync(trigger_data->led_cdev, LED_ON);
 		trigger_data->rx = icount.rx;
 		trigger_data->tx = icount.tx;
 	} else {
-		led_set_brightness(trigger_data->led_cdev, LED_OFF);
+		led_set_brightness_sync(trigger_data->led_cdev, LED_OFF);
 	}
 out:

drivers/md/bcache/super.c+1−1

@@ -965,7 +965,7 @@ static int bcache_device_init(struct bcache_device *d, unsigned int block_size, · 964 unmodified lines
965	q->limits.max_hw_sectors = UINT_MAX;	965	q->limits.max_hw_sectors = UINT_MAX;
966	q->limits.max_sectors = UINT_MAX;	966	q->limits.max_sectors = UINT_MAX;
967	q->limits.max_segment_size = UINT_MAX;	967	q->limits.max_segment_size = UINT_MAX;
968	q->limits.max_segments = BIO_MAX_PAGES;	968	q->limits.max_segments = BIO_MAX_VECS;
969	blk_queue_max_discard_sectors(q, UINT_MAX);	969	blk_queue_max_discard_sectors(q, UINT_MAX);
970	q->limits.discard_granularity = 512;	970	q->limits.discard_granularity = 512;
971	q->limits.io_min = block_size;	971	q->limits.io_min = block_size;

drivers/md/dm-crypt.c+4−4

drivers/md/dm-writecache.c+2−2

@@ -1892,10 +1892,10 @@ restart: · 1891 unmodified lines
1892	list_add(&g->lru, &wbl.list);	1892	list_add(&g->lru, &wbl.list);
1893	wbl.size++;	1893	wbl.size++;
1894	g->write_in_progress = true;	1894	g->write_in_progress = true;
1895	g->wc_list_contiguous = BIO_MAX_PAGES;	1895	g->wc_list_contiguous = BIO_MAX_VECS;
1896	f = g;	1896	f = g;
1897	e->wc_list_contiguous++;	1897	e->wc_list_contiguous++;
1898	if (unlikely(e->wc_list_contiguous == BIO_MAX_PAGES)) {	1898	if (unlikely(e->wc_list_contiguous == BIO_MAX_VECS)) {
1899	if (unlikely(wc->writeback_all)) {	1899	if (unlikely(wc->writeback_all)) {
1900	next_node = rb_next(&f->rb_node);	1900	next_node = rb_next(&f->rb_node);
1901	if (likely(next_node))	1901	if (likely(next_node))

drivers/md/raid5-cache.c+2−2

@@ -735,7 +735,7 @@ static void r5l_submit_current_io(struct r5l_log *log) · 734 unmodified lines
735		735
736	static struct bio r5l_bio_alloc(struct r5l_log log)	736	static struct bio r5l_bio_alloc(struct r5l_log log)
737	{	737	{
738	struct bio *bio = bio_alloc_bioset(GFP_NOIO, BIO_MAX_PAGES, &log->bs);	738	struct bio *bio = bio_alloc_bioset(GFP_NOIO, BIO_MAX_VECS, &log->bs);
739		739
740	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);	740	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
741	bio_set_dev(bio, log->rdev->bdev);	741	bio_set_dev(bio, log->rdev->bdev);
@@ -1634,7 +1634,7 @@ static int r5l_recovery_allocate_ra_pool(struct r5l_log *log, · 892 unmodified lines
1634	{	1634	{
1635	struct page *page;	1635	struct page *page;
1636		1636
1637	ctx->ra_bio = bio_alloc_bioset(GFP_KERNEL, BIO_MAX_PAGES, &log->bs);	1637	ctx->ra_bio = bio_alloc_bioset(GFP_KERNEL, BIO_MAX_VECS, &log->bs);
1638	if (!ctx->ra_bio)	1638	if (!ctx->ra_bio)
1639	return -ENOMEM;	1639	return -ENOMEM;
1640		1640

drivers/md/raid5-ppl.c+1−1

@@ -496,7 +496,7 @@ static void ppl_submit_iounit(struct ppl_io_unit *io) · 495 unmodified lines
496	if (!bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0)) {	496	if (!bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0)) {
497	struct bio *prev = bio;	497	struct bio *prev = bio;
498		498
499	bio = bio_alloc_bioset(GFP_NOIO, BIO_MAX_PAGES,	499	bio = bio_alloc_bioset(GFP_NOIO, BIO_MAX_VECS,
500	&ppl_conf->bs);	500	&ppl_conf->bs);
501	bio->bi_opf = prev->bi_opf;	501	bio->bi_opf = prev->bi_opf;
502	bio->bi_write_hint = prev->bi_write_hint;	502	bio->bi_write_hint = prev->bi_write_hint;

drivers/media/firewire/firedtv-fw.c+0−1

@@ -430,4 +430,3 @@ MODULE_AUTHOR("Andreas Monitzer <andy@monitzer.com>"); · 429 unmodified lines
430	MODULE_AUTHOR("Ben Backx <ben@bbackx.com>");	430	MODULE_AUTHOR("Ben Backx <ben@bbackx.com>");
431	MODULE_DESCRIPTION("FireDTV DVB Driver");	431	MODULE_DESCRIPTION("FireDTV DVB Driver");
432	MODULE_LICENSE("GPL");	432	MODULE_LICENSE("GPL");
433	MODULE_SUPPORTED_DEVICE("FireDTV DVB");

drivers/media/pci/cx18/cx18-alsa-main.c+0−1

@@ -41,7 +41,6 @@ MODULE_PARM_DESC(debug, · 40 unmodified lines
41		41
42	MODULE_AUTHOR("Andy Walls");	42	MODULE_AUTHOR("Andy Walls");
43	MODULE_DESCRIPTION("CX23418 ALSA Interface");	43	MODULE_DESCRIPTION("CX23418 ALSA Interface");
44	MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
45	MODULE_LICENSE("GPL");	44	MODULE_LICENSE("GPL");
46		45
47	MODULE_VERSION(CX18_VERSION);	46	MODULE_VERSION(CX18_VERSION);

drivers/media/pci/cx18/cx18-driver.c+0−1

@@ -232,7 +232,6 @@ MODULE_PARM_DESC(cx18_first_minor, · 231 unmodified lines
232		232
233	MODULE_AUTHOR("Hans Verkuil");	233	MODULE_AUTHOR("Hans Verkuil");
234	MODULE_DESCRIPTION("CX23418 driver");	234	MODULE_DESCRIPTION("CX23418 driver");
235	MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
236	MODULE_LICENSE("GPL");	235	MODULE_LICENSE("GPL");
237		236
238	MODULE_VERSION(CX18_VERSION);	237	MODULE_VERSION(CX18_VERSION);

drivers/media/pci/cx25821/cx25821-alsa.c+0−1

@@ -104,7 +104,6 @@ MODULE_PARM_DESC(index, "Index value for cx25821 capture interface(s)."); · 103 unmodified lines
104	MODULE_DESCRIPTION("ALSA driver module for cx25821 based capture cards");	104	MODULE_DESCRIPTION("ALSA driver module for cx25821 based capture cards");
105	MODULE_AUTHOR("Hiep Huynh");	105	MODULE_AUTHOR("Hiep Huynh");
106	MODULE_LICENSE("GPL");	106	MODULE_LICENSE("GPL");
107	MODULE_SUPPORTED_DEVICE("{{Conexant,25821}"); /* "{{Conexant,23881}," */
108		107
109	static unsigned int debug;	108	static unsigned int debug;
110	module_param(debug, int, 0644);	109	module_param(debug, int, 0644);

drivers/media/pci/cx88/cx88-alsa.c+0−1

@@ -98,7 +98,6 @@ MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@kernel.org>"); · 97 unmodified lines
98	MODULE_LICENSE("GPL v2");	98	MODULE_LICENSE("GPL v2");
99	MODULE_VERSION(CX88_VERSION);	99	MODULE_VERSION(CX88_VERSION);
100		100
101	MODULE_SUPPORTED_DEVICE("{{Conexant,23881},{{Conexant,23882},{{Conexant,23883}");
102	static unsigned int debug;	101	static unsigned int debug;
103	module_param(debug, int, 0644);	102	module_param(debug, int, 0644);
104	MODULE_PARM_DESC(debug, "enable debug messages");	103	MODULE_PARM_DESC(debug, "enable debug messages");

drivers/media/pci/ivtv/ivtv-alsa-main.c+0−1

@@ -38,7 +38,6 @@ MODULE_PARM_DESC(index, · 37 unmodified lines
38		38
39	MODULE_AUTHOR("Andy Walls");	39	MODULE_AUTHOR("Andy Walls");
40	MODULE_DESCRIPTION("CX23415/CX23416 ALSA Interface");	40	MODULE_DESCRIPTION("CX23415/CX23416 ALSA Interface");
41	MODULE_SUPPORTED_DEVICE("CX23415/CX23416 MPEG2 encoder");
42	MODULE_LICENSE("GPL");	41	MODULE_LICENSE("GPL");
43		42
44	MODULE_VERSION(IVTV_VERSION);	43	MODULE_VERSION(IVTV_VERSION);

drivers/media/pci/ivtv/ivtv-driver.c+0−3

@@ -275,9 +275,6 @@ MODULE_PARM_DESC(ivtv_first_minor, "Set device node number assigned to first car · 274 unmodified lines
275		275
276	MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");	276	MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
277	MODULE_DESCRIPTION("CX23415/CX23416 driver");	277	MODULE_DESCRIPTION("CX23415/CX23416 driver");
278	MODULE_SUPPORTED_DEVICE
279	("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
280	"\t\t\tYuan MPG series and similar)");
281	MODULE_LICENSE("GPL");	278	MODULE_LICENSE("GPL");
282		279
283	MODULE_VERSION(IVTV_VERSION);	280	MODULE_VERSION(IVTV_VERSION);

drivers/media/pci/sta2x11/sta2x11_vip.c+0−1

@@ -1269,6 +1269,5 @@ late_initcall_sync(sta2x11_vip_init_module); · 1268 unmodified lines
1269	MODULE_DESCRIPTION("STA2X11 Video Input Port driver");	1269	MODULE_DESCRIPTION("STA2X11 Video Input Port driver");
1270	MODULE_AUTHOR("Wind River");	1270	MODULE_AUTHOR("Wind River");
1271	MODULE_LICENSE("GPL v2");	1271	MODULE_LICENSE("GPL v2");
1272	MODULE_SUPPORTED_DEVICE("sta2x11 video input");
1273	MODULE_VERSION(DRV_VERSION);	1272	MODULE_VERSION(DRV_VERSION);
1274	MODULE_DEVICE_TABLE(pci, sta2x11_vip_pci_tbl);	1273	MODULE_DEVICE_TABLE(pci, sta2x11_vip_pci_tbl);

drivers/media/platform/atmel/atmel-isi.c+0−1

@@ -1363,4 +1363,3 @@ module_platform_driver(atmel_isi_driver); · 1362 unmodified lines
1363	MODULE_AUTHOR("Josh Wu <josh.wu@atmel.com>");	1363	MODULE_AUTHOR("Josh Wu <josh.wu@atmel.com>");
1364	MODULE_DESCRIPTION("The V4L2 driver for Atmel Linux");	1364	MODULE_DESCRIPTION("The V4L2 driver for Atmel Linux");
1365	MODULE_LICENSE("GPL");	1365	MODULE_LICENSE("GPL");
1366	MODULE_SUPPORTED_DEVICE("video");

drivers/media/platform/atmel/atmel-sama5d2-isc.c+0−1

@@ -330,4 +330,3 @@ module_platform_driver(atmel_isc_driver); · 329 unmodified lines
330	MODULE_AUTHOR("Songjun Wu");	330	MODULE_AUTHOR("Songjun Wu");
331	MODULE_DESCRIPTION("The V4L2 driver for Atmel-ISC");	331	MODULE_DESCRIPTION("The V4L2 driver for Atmel-ISC");
332	MODULE_LICENSE("GPL v2");	332	MODULE_LICENSE("GPL v2");
333	MODULE_SUPPORTED_DEVICE("video");

drivers/media/platform/marvell-ccic/cafe-driver.c+0−4

@@ -44,10 +44,6 @@ · 43 unmodified lines
44	MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");	44	MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
45	MODULE_DESCRIPTION("Marvell 88ALP01 CMOS Camera Controller driver");	45	MODULE_DESCRIPTION("Marvell 88ALP01 CMOS Camera Controller driver");
46	MODULE_LICENSE("GPL");	46	MODULE_LICENSE("GPL");
47	MODULE_SUPPORTED_DEVICE("Video");
48
49
50
51		47
52	struct cafe_camera {	48	struct cafe_camera {
53	int registered; /* Fully initialized? */	49	int registered; /* Fully initialized? */

drivers/media/platform/rockchip/rkisp1/rkisp1-params.c+0−1

@@ -1288,7 +1288,6 @@ static void rkisp1_params_config_parameter(struct rkisp1_params *params) · 1287 unmodified lines
1288	memset(hst.hist_weight, 0x01, sizeof(hst.hist_weight));	1288	memset(hst.hist_weight, 0x01, sizeof(hst.hist_weight));
1289	rkisp1_hst_config(params, &hst);	1289	rkisp1_hst_config(params, &hst);
1290	rkisp1_param_set_bits(params, RKISP1_CIF_ISP_HIST_PROP,	1290	rkisp1_param_set_bits(params, RKISP1_CIF_ISP_HIST_PROP,
1291	~RKISP1_CIF_ISP_HIST_PROP_MODE_MASK \|
1292	rkisp1_hst_params_default_config.mode);	1291	rkisp1_hst_params_default_config.mode);
1293		1292
1294	/* set the range */	1293	/* set the range */

drivers/media/platform/stm32/stm32-dcmi.c+0−1

@@ -2149,4 +2149,3 @@ MODULE_AUTHOR("Yannick Fertre <yannick.fertre@st.com>"); · 2148 unmodified lines
2149	MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");	2149	MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");
2150	MODULE_DESCRIPTION("STMicroelectronics STM32 Digital Camera Memory Interface driver");	2150	MODULE_DESCRIPTION("STMicroelectronics STM32 Digital Camera Memory Interface driver");
2151	MODULE_LICENSE("GPL");	2151	MODULE_LICENSE("GPL");
2152	MODULE_SUPPORTED_DEVICE("video");

drivers/media/platform/vsp1/vsp1_drm.c+3−3

@@ -245,7 +245,7 @@ static int vsp1_du_pipeline_setup_brx(struct vsp1_device *vsp1, · 244 unmodified lines
245	brx = &vsp1->bru->entity;	245	brx = &vsp1->bru->entity;
246	else if (pipe->brx && !drm_pipe->force_brx_release)	246	else if (pipe->brx && !drm_pipe->force_brx_release)
247	brx = pipe->brx;	247	brx = pipe->brx;
248	else if (!vsp1->bru->entity.pipe)	248	else if (vsp1_feature(vsp1, VSP1_HAS_BRU) && !vsp1->bru->entity.pipe)
249	brx = &vsp1->bru->entity;	249	brx = &vsp1->bru->entity;
250	else	250	else
251	brx = &vsp1->brs->entity;	251	brx = &vsp1->brs->entity;
@@ -462,9 +462,9 @@ static int vsp1_du_pipeline_setup_inputs(struct vsp1_device *vsp1, · 210 unmodified lines
462	* make sure it is present in the pipeline's list of entities if it	462	* make sure it is present in the pipeline's list of entities if it
463	* wasn't already.	463	* wasn't already.
464	*/	464	*/
465	if (!use_uif) {	465	if (drm_pipe->uif && !use_uif) {
466	drm_pipe->uif->pipe = NULL;	466	drm_pipe->uif->pipe = NULL;
467	} else if (!drm_pipe->uif->pipe) {	467	} else if (drm_pipe->uif && !drm_pipe->uif->pipe) {
468	drm_pipe->uif->pipe = pipe;	468	drm_pipe->uif->pipe = pipe;
469	list_add_tail(&drm_pipe->uif->list_pipe, &pipe->entities);	469	list_add_tail(&drm_pipe->uif->list_pipe, &pipe->entities);
470	}	470	}

drivers/media/rc/Makefile+1−0

@@ -5,6 +5,7 @@ obj-y += keymaps/ · 4 unmodified lines
5	obj-$(CONFIG_RC_CORE) += rc-core.o	5	obj-$(CONFIG_RC_CORE) += rc-core.o
6	rc-core-y := rc-main.o rc-ir-raw.o	6	rc-core-y := rc-main.o rc-ir-raw.o
7	rc-core-$(CONFIG_LIRC) += lirc_dev.o	7	rc-core-$(CONFIG_LIRC) += lirc_dev.o
		8	rc-core-$(CONFIG_MEDIA_CEC_RC) += keymaps/rc-cec.o
8	rc-core-$(CONFIG_BPF_LIRC_MODE2) += bpf-lirc.o	9	rc-core-$(CONFIG_BPF_LIRC_MODE2) += bpf-lirc.o
9	obj-$(CONFIG_IR_NEC_DECODER) += ir-nec-decoder.o	10	obj-$(CONFIG_IR_NEC_DECODER) += ir-nec-decoder.o
10	obj-$(CONFIG_IR_RC5_DECODER) += ir-rc5-decoder.o	11	obj-$(CONFIG_IR_RC5_DECODER) += ir-rc5-decoder.o

drivers/media/rc/keymaps/Makefile+0−1

@@ -21,7 +21,6 @@ obj-$(CONFIG_RC_MAP) += rc-adstech-dvb-t-pci.o \ · 20 unmodified lines
21	rc-behold.o \	21	rc-behold.o \
22	rc-behold-columbus.o \	22	rc-behold-columbus.o \
23	rc-budget-ci-old.o \	23	rc-budget-ci-old.o \
24	rc-cec.o \
25	rc-cinergy-1400.o \	24	rc-cinergy-1400.o \
26	rc-cinergy.o \	25	rc-cinergy.o \
27	rc-d680-dmb.o \	26	rc-d680-dmb.o \

drivers/media/rc/keymaps/rc-cec.c+11−17

 // SPDX-License-Identifier: GPL-2.0-or-later
 /* Keytable for the CEC remote control
+ *
+ * This keymap is unusual in that it can't be built as a module,
+ * instead it is registered directly in rc-main.c if CONFIG_MEDIA_CEC_RC
+ * is set. This is because it can be called from drm_dp_cec_set_edid() via
+ * cec_register_adapter() in an asynchronous context, and it is not
+ * allowed to use request_module() to load rc-cec.ko in that case.
+ *
+ * Since this keymap is only used if CONFIG_MEDIA_CEC_RC is set, we
+ * just compile this keymap into the rc-core module and never as a
+ * separate module.
  *
  * Copyright (c) 2015 by Kamil Debski
  */
 	/* 0x77-0xff: Reserved */
 };
-static struct rc_map_list cec_map = {
+struct rc_map_list cec_map = {
 	.map = {
 		.scan		= cec,
 		.size		= ARRAY_SIZE(cec),
 		.name		= RC_MAP_CEC,
 	}
 };
-static int __init init_rc_map_cec(void)
-{
-	return rc_map_register(&cec_map);
-}
-static void __exit exit_rc_map_cec(void)
-{
-	rc_map_unregister(&cec_map);
-}
-module_init(init_rc_map_cec);
-module_exit(exit_rc_map_cec);
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Kamil Debski");

drivers/media/rc/rc-main.c+6−0

 	led_trigger_register_simple("rc-feedback", &led_feedback);
 	rc_map_register(&empty_map);
+#ifdef CONFIG_MEDIA_CEC_RC
+	rc_map_register(&cec_map);
+#endif
 	return 0;
 }
 	lirc_dev_exit();
 	class_unregister(&rc_class);
 	led_trigger_unregister_simple(led_feedback);
+#ifdef CONFIG_MEDIA_CEC_RC
+	rc_map_unregister(&cec_map);
+#endif
 	rc_map_unregister(&empty_map);
 }

drivers/media/usb/cpia2/cpia2_v4l.c+0−1

@@ -56,7 +56,6 @@ MODULE_PARM_DESC(flicker_mode, "Flicker frequency (0 (disabled), " __stringify(5 · 55 unmodified lines
56		56
57	MODULE_AUTHOR("Steve Miller (STMicroelectronics) <steve.miller@st.com>");	57	MODULE_AUTHOR("Steve Miller (STMicroelectronics) <steve.miller@st.com>");
58	MODULE_DESCRIPTION("V4L-driver for STMicroelectronics CPiA2 based cameras");	58	MODULE_DESCRIPTION("V4L-driver for STMicroelectronics CPiA2 based cameras");
59	MODULE_SUPPORTED_DEVICE("video");
60	MODULE_LICENSE("GPL");	59	MODULE_LICENSE("GPL");
61	MODULE_VERSION(CPIA_VERSION);	60	MODULE_VERSION(CPIA_VERSION);
62		61

drivers/media/usb/tm6000/tm6000-alsa.c+0−1

@@ -51,7 +51,6 @@ MODULE_PARM_DESC(index, "Index value for tm6000x capture interface(s)."); · 50 unmodified lines
51	MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");	51	MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");
52	MODULE_AUTHOR("Mauro Carvalho Chehab");	52	MODULE_AUTHOR("Mauro Carvalho Chehab");
53	MODULE_LICENSE("GPL v2");	53	MODULE_LICENSE("GPL v2");
54	MODULE_SUPPORTED_DEVICE("{{Trident,tm5600},{{Trident,tm6000},{{Trident,tm6010}");
55	static unsigned int debug;	54	static unsigned int debug;
56	module_param(debug, int, 0644);	55	module_param(debug, int, 0644);
57	MODULE_PARM_DESC(debug, "enable debug messages");	56	MODULE_PARM_DESC(debug, "enable debug messages");

drivers/media/usb/tm6000/tm6000-dvb.c+0−2

@@ -23,8 +23,6 @@ MODULE_DESCRIPTION("DVB driver extension module for tm5600/6000/6010 based TV ca · 22 unmodified lines
23	MODULE_AUTHOR("Mauro Carvalho Chehab");	23	MODULE_AUTHOR("Mauro Carvalho Chehab");
24	MODULE_LICENSE("GPL");	24	MODULE_LICENSE("GPL");
25		25
26	MODULE_SUPPORTED_DEVICE("{{Trident, tm5600},{{Trident, tm6000},{{Trident, tm6010}");
27
28	static int debug;	26	static int debug;
29		27
30	module_param(debug, int, 0644);	28	module_param(debug, int, 0644);

drivers/media/usb/usbtv/usbtv-audio.c+1−1

@@ -371,7 +371,7 @@ void usbtv_audio_free(struct usbtv *usbtv) · 370 unmodified lines
371	cancel_work_sync(&usbtv->snd_trigger);	371	cancel_work_sync(&usbtv->snd_trigger);
372		372
373	if (usbtv->snd && usbtv->udev) {	373	if (usbtv->snd && usbtv->udev) {
374	snd_card_free(usbtv->snd);	374	snd_card_free_when_closed(usbtv->snd);
375	usbtv->snd = NULL;	375	usbtv->snd = NULL;
376	}	376	}
377	}	377	}

drivers/mfd/intel_quark_i2c_gpio.c+4−2

 	{}
 };
-static const struct resource intel_quark_i2c_res[] = {
+/* This is used as a place holder and will be modified at run-time */
+static struct resource intel_quark_i2c_res[] = {
 	[INTEL_QUARK_IORES_MEM] = {
 		.flags = IORESOURCE_MEM,
 	},
 	.adr = MFD_ACPI_MATCH_I2C,
 };
-static const struct resource intel_quark_gpio_res[] = {
+/* This is used as a place holder and will be modified at run-time */
+static struct resource intel_quark_gpio_res[] = {
 	[INTEL_QUARK_IORES_MEM] = {
 		.flags = IORESOURCE_MEM,
 	},

drivers/misc/fastrpc.c+5−0

 	if (!fl->cctx->rpdev)
 		return -EPIPE;
+	if (handle == FASTRPC_INIT_HANDLE && !kernel) {
+		dev_warn_ratelimited(fl->sctx->dev, "user app trying to send a kernel RPC message (%d)\n",  handle);
+		return -EPERM;
+	}
 	ctx = fastrpc_context_alloc(fl, kernel, sc, args);
 	if (IS_ERR(ctx))
 		return PTR_ERR(ctx);

drivers/misc/habanalabs/common/debugfs.c+1−4

@@ -992,7 +992,6 @@ void hl_debugfs_add_device(struct hl_device *hdev) · 991 unmodified lines
992	struct hl_dbg_device_entry *dev_entry = &hdev->hl_debugfs;	992	struct hl_dbg_device_entry *dev_entry = &hdev->hl_debugfs;
993	int count = ARRAY_SIZE(hl_debugfs_list);	993	int count = ARRAY_SIZE(hl_debugfs_list);
994	struct hl_debugfs_entry *entry;	994	struct hl_debugfs_entry *entry;
995	struct dentry *ent;
996	int i;	995	int i;
997		996
998	dev_entry->hdev = hdev;	997	dev_entry->hdev = hdev;
@@ -1105,13 +1104,11 @@ void hl_debugfs_add_device(struct hl_device *hdev) · 106 unmodified lines
1105	&hl_security_violations_fops);	1104	&hl_security_violations_fops);
1106		1105
1107	for (i = 0, entry = dev_entry->entry_arr ; i < count ; i++, entry++) {	1106	for (i = 0, entry = dev_entry->entry_arr ; i < count ; i++, entry++) {
1108		1107	debugfs_create_file(hl_debugfs_list[i].name,
1109	ent = debugfs_create_file(hl_debugfs_list[i].name,
1110	0444,	1108	0444,
1111	dev_entry->root,	1109	dev_entry->root,
1112	entry,	1110	entry,
1113	&hl_debugfs_fops);	1111	&hl_debugfs_fops);
1114	entry->dent = ent;
1115	entry->info_ent = &hl_debugfs_list[i];	1112	entry->info_ent = &hl_debugfs_list[i];
1116	entry->dev_entry = dev_entry;	1113	entry->dev_entry = dev_entry;
1117	}	1114	}

drivers/misc/habanalabs/common/device.c+35−5

 static int hl_device_release(struct inode *inode, struct file *filp)
 {
 	struct hl_fpriv *hpriv = filp->private_data;
+	struct hl_device *hdev = hpriv->hdev;
+	filp->private_data = NULL;
+	if (!hdev) {
+		pr_crit("Closing FD after device was removed. Memory leak will occur and it is advised to reboot.\n");
+		put_pid(hpriv->taskpid);
+		return 0;
+	}
 	hl_cb_mgr_fini(hpriv->hdev, &hpriv->cb_mgr);
 	hl_ctx_mgr_fini(hpriv->hdev, &hpriv->ctx_mgr);
-	filp->private_data = NULL;
 	hl_hpriv_put(hpriv);
 	return 0;
 static int hl_device_release_ctrl(struct inode *inode, struct file *filp)
 {
 	struct hl_fpriv *hpriv = filp->private_data;
-	struct hl_device *hdev;
+	struct hl_device *hdev = hpriv->hdev;
 	filp->private_data = NULL;
-	hdev = hpriv->hdev;
+	if (!hdev) {
+		pr_err("Closing FD after device was removed\n");
+		goto out;
+	}
 	mutex_lock(&hdev->fpriv_list_lock);
 	list_del(&hpriv->dev_node);
 	mutex_unlock(&hdev->fpriv_list_lock);
+out:
+	put_pid(hpriv->taskpid);
 	kfree(hpriv);
 static int hl_mmap(struct file *filp, struct vm_area_struct *vma)
 {
 	struct hl_fpriv *hpriv = filp->private_data;
+	struct hl_device *hdev = hpriv->hdev;
 	unsigned long vm_pgoff;
+	if (!hdev) {
+		pr_err_ratelimited("Trying to mmap after device was removed! Please close FD\n");
+		return -ENODEV;
+	}
 	vm_pgoff = vma->vm_pgoff;
 	vma->vm_pgoff = HL_MMAP_OFFSET_VALUE_GET(vm_pgoff);
 	return -EBUSY;
 }
+static void device_disable_open_processes(struct hl_device *hdev)
+{
+	struct hl_fpriv *hpriv;
+	mutex_lock(&hdev->fpriv_list_lock);
+	list_for_each_entry(hpriv, &hdev->fpriv_list, dev_node)
+		hpriv->hdev = NULL;
+	mutex_unlock(&hdev->fpriv_list_lock);
+}
 /*
  * hl_device_reset - reset the device
  *
 		HL_PENDING_RESET_LONG_SEC);
 	rc = device_kill_open_processes(hdev, HL_PENDING_RESET_LONG_SEC);
-	if (rc)
+	if (rc) {
 		dev_crit(hdev->dev, "Failed to kill all open processes\n");
+		device_disable_open_processes(hdev);
+	}
 	hl_cb_pool_fini(hdev);

drivers/misc/habanalabs/common/habanalabs.h+0−2

 /**
  * struct hl_debugfs_entry - debugfs dentry wrapper.
- * @dent: base debugfs entry structure.
  * @info_ent: dentry realted ops.
  * @dev_entry: ASIC specific debugfs manager.
  */
 struct hl_debugfs_entry {
-	struct dentry			*dent;
 	const struct hl_info_list	*info_ent;
 	struct hl_dbg_device_entry	*dev_entry;
 };

drivers/misc/habanalabs/common/habanalabs_ioctl.c+12−0

  * All Rights Reserved.
  */
+#define pr_fmt(fmt)	"habanalabs: " fmt
 #include <uapi/misc/habanalabs.h>
 #include "habanalabs.h"
 	const struct hl_ioctl_desc *ioctl = NULL;
 	unsigned int nr = _IOC_NR(cmd);
+	if (!hdev) {
+		pr_err_ratelimited("Sending ioctl after device was removed! Please close FD\n");
+		return -ENODEV;
+	}
 	if ((nr >= HL_COMMAND_START) && (nr < HL_COMMAND_END)) {
 		ioctl = &hl_ioctls[nr];
 	} else {
 	const struct hl_ioctl_desc *ioctl = NULL;
 	unsigned int nr = _IOC_NR(cmd);
+	if (!hdev) {
+		pr_err_ratelimited("Sending ioctl after device was removed! Please close FD\n");
+		return -ENODEV;
+	}
 	if (nr == _IOC_NR(HL_IOCTL_INFO)) {
 		ioctl = &hl_ioctls_control[nr];
 	} else {

drivers/misc/habanalabs/common/irq.c+1−1

@@ -47,7 +47,7 @@ inline u32 hl_cq_inc_ptr(u32 ptr) · 46 unmodified lines
47	* Increment ptr by 1. If it reaches the number of event queue	47	* Increment ptr by 1. If it reaches the number of event queue
48	* entries, set it to 0	48	* entries, set it to 0
49	*/	49	*/
50	inline u32 hl_eq_inc_ptr(u32 ptr)	50	static inline u32 hl_eq_inc_ptr(u32 ptr)
51	{	51	{
52	ptr++;	52	ptr++;
53	if (unlikely(ptr == HL_EQ_LENGTH))	53	if (unlikely(ptr == HL_EQ_LENGTH))

drivers/misc/habanalabs/common/mmu/mmu.c+26−12

@@ -499,18 +499,32 @@ static void hl_mmu_pa_page_with_offset(struct hl_ctx *ctx, u64 virt_addr, · 498 unmodified lines
499	else /* HL_VA_RANGE_TYPE_DRAM */	499	else /* HL_VA_RANGE_TYPE_DRAM */
500	p = &prop->dmmu;	500	p = &prop->dmmu;
501		501
502	/*	502	if ((hops->range_type == HL_VA_RANGE_TYPE_DRAM) &&
503	* find the correct hop shift field in hl_mmu_properties structure	503	!is_power_of_2(prop->dram_page_size)) {
504	* in order to determine the right maks for the page offset.	504	u32 bit;
505	*/	505	u64 page_offset_mask;
506	hop0_shift_off = offsetof(struct hl_mmu_properties, hop0_shift);	506	u64 phys_addr_mask;
507	p = (char *)p + hop0_shift_off;	507
508	p = (char )p + ((hops->used_hops - 1) sizeof(u64));	508	bit = __ffs64((u64)prop->dram_page_size);
509	hop_shift = (u64 )p;	509	page_offset_mask = ((1ull << bit) - 1);
510	offset_mask = (1ull << hop_shift) - 1;	510	phys_addr_mask = ~page_offset_mask;
511	addr_mask = ~(offset_mask);	511	*phys_addr = (tmp_phys_addr & phys_addr_mask) \|
512	*phys_addr = (tmp_phys_addr & addr_mask) \|	512	(virt_addr & page_offset_mask);
513	(virt_addr & offset_mask);	513	} else {
		514	/*
		515	* find the correct hop shift field in hl_mmu_properties
		516	* structure in order to determine the right masks
		517	* for the page offset.
		518	*/
		519	hop0_shift_off = offsetof(struct hl_mmu_properties, hop0_shift);
		520	p = (char *)p + hop0_shift_off;
		521	p = (char )p + ((hops->used_hops - 1) sizeof(u64));
		522	hop_shift = (u64 )p;
		523	offset_mask = (1ull << hop_shift) - 1;
		524	addr_mask = ~(offset_mask);
		525	*phys_addr = (tmp_phys_addr & addr_mask) \|
		526	(virt_addr & offset_mask);
		527	}
514	}	528	}
515		529
516	int hl_mmu_va_to_pa(struct hl_ctx ctx, u64 virt_addr, u64 phys_addr)	530	int hl_mmu_va_to_pa(struct hl_ctx ctx, u64 virt_addr, u64 phys_addr)

drivers/misc/pvpanic.c+1−0

@@ -140,6 +140,7 @@ static const struct of_device_id pvpanic_mmio_match[] = { · 139 unmodified lines
140	{ .compatible = "qemu,pvpanic-mmio", },	140	{ .compatible = "qemu,pvpanic-mmio", },
141	{}	141	{}
142	};	142	};
		143	MODULE_DEVICE_TABLE(of, pvpanic_mmio_match);
143		144
144	static const struct acpi_device_id pvpanic_device_ids[] = {	145	static const struct acpi_device_id pvpanic_device_ids[] = {
145	{ "QEMU0001", 0 },	146	{ "QEMU0001", 0 },

drivers/mmc/core/bus.c+5−6

 	mmc_remove_card_debugfs(card);
 #endif
-	if (host->cqe_enabled) {
-		host->cqe_ops->cqe_disable(host);
-		host->cqe_enabled = false;
-	}
 	if (mmc_card_present(card)) {
 		if (mmc_host_is_spi(card->host)) {
 			pr_info("%s: SPI card removed\n",
 		of_node_put(card->dev.of_node);
 	}
+	if (host->cqe_enabled) {
+		host->cqe_ops->cqe_disable(host);
+		host->cqe_enabled = false;
+	}
 	put_device(&card->dev);
 }

drivers/mmc/core/mmc.c+11−4

 		/* EXT_CSD value is in units of 10ms, but we store in ms */
 		card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
-		/* Some eMMC set the value too low so set a minimum */
-		if (card->ext_csd.part_time &&
-		    card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME)
-			card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME;
 		/* Sleep / awake timeout in 100ns units */
 		if (sa_shift > 0 && sa_shift <= 0x17)
 		card->ext_csd.data_sector_size = 512;
 	}
+	/*
+	 * GENERIC_CMD6_TIME is to be used "unless a specific timeout is defined
+	 * when accessing a specific field", so use it here if there is no
+	 * PARTITION_SWITCH_TIME.
+	 */
+	if (!card->ext_csd.part_time)
+		card->ext_csd.part_time = card->ext_csd.generic_cmd6_time;
+	/* Some eMMC set the value too low so set a minimum */
+	if (card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME)
+		card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME;
 	/* eMMC v5 or later */
 	if (card->ext_csd.rev >= 7) {
 		memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],

drivers/mmc/host/mmci.c+9−1

 		if (!cmd->busy_timeout)
 			cmd->busy_timeout = 10 * MSEC_PER_SEC;
-		clks = (unsigned long long)cmd->busy_timeout * host->cclk;
+		if (cmd->busy_timeout > host->mmc->max_busy_timeout)
+			clks = (unsigned long long)host->mmc->max_busy_timeout * host->cclk;
+		else
+			clks = (unsigned long long)cmd->busy_timeout * host->cclk;
 		do_div(clks, MSEC_PER_SEC);
 		writel_relaxed(clks, host->base + MMCIDATATIMER);
 	}
 		mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 	}
+	/* Variants with mandatory busy timeout in HW needs R1B responses. */
+	if (variant->busy_timeout)
+		mmc->caps |= MMC_CAP_NEED_RSP_BUSY;
 	/* Prepare a CMD12 - needed to clear the DPSM on some variants. */
 	host->stop_abort.opcode = MMC_STOP_TRANSMISSION;
 	host->stop_abort.arg = 0;

drivers/mtd/maps/sun_uflash.c+0−1

@@ -32,7 +32,6 @@ · 31 unmodified lines
32		32
33	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");	33	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
34	MODULE_DESCRIPTION("User-programmable flash device on Sun Microsystems boardsets");	34	MODULE_DESCRIPTION("User-programmable flash device on Sun Microsystems boardsets");
35	MODULE_SUPPORTED_DEVICE(DRIVER_NAME);
36	MODULE_LICENSE("GPL");	35	MODULE_LICENSE("GPL");
37	MODULE_VERSION("2.1");	36	MODULE_VERSION("2.1");
38		37

drivers/net/arcnet/com20020-pci.c+19−15

@@ -127,6 +127,8 @@ static int com20020pci_probe(struct pci_dev *pdev, · 126 unmodified lines
127	int i, ioaddr, ret;	127	int i, ioaddr, ret;
128	struct resource *r;	128	struct resource *r;
129		129
		130	ret = 0;
		131
130	if (pci_enable_device(pdev))	132	if (pci_enable_device(pdev))
131	return -EIO;	133	return -EIO;
132		134
@@ -139,6 +141,8 @@ static int com20020pci_probe(struct pci_dev *pdev, · 6 unmodified lines
139	priv->ci = ci;	141	priv->ci = ci;
140	mm = &ci->misc_map;	142	mm = &ci->misc_map;
141		143
		144	pci_set_drvdata(pdev, priv);
		145
142	INIT_LIST_HEAD(&priv->list_dev);	146	INIT_LIST_HEAD(&priv->list_dev);
143		147
144	if (mm->size) {	148	if (mm->size) {
@@ -161,7 +165,7 @@ static int com20020pci_probe(struct pci_dev *pdev, · 16 unmodified lines
161	dev = alloc_arcdev(device);	165	dev = alloc_arcdev(device);
162	if (!dev) {	166	if (!dev) {
163	ret = -ENOMEM;	167	ret = -ENOMEM;
164	goto out_port;	168	break;
165	}	169	}
166	dev->dev_port = i;	170	dev->dev_port = i;
167		171
@@ -178,7 +182,7 @@ static int com20020pci_probe(struct pci_dev *pdev, · 10 unmodified lines
178	pr_err("IO region %xh-%xh already allocated\n",	182	pr_err("IO region %xh-%xh already allocated\n",
179	ioaddr, ioaddr + cm->size - 1);	183	ioaddr, ioaddr + cm->size - 1);
180	ret = -EBUSY;	184	ret = -EBUSY;
181	goto out_port;	185	goto err_free_arcdev;
182	}	186	}
183		187
184	/* Dummy access after Reset	188	/* Dummy access after Reset
@@ -216,18 +220,18 @@ static int com20020pci_probe(struct pci_dev *pdev, · 31 unmodified lines
216	if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) {	220	if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) {
217	pr_err("IO address %Xh is empty!\n", ioaddr);	221	pr_err("IO address %Xh is empty!\n", ioaddr);
218	ret = -EIO;	222	ret = -EIO;
219	goto out_port;	223	goto err_free_arcdev;
220	}	224	}
221	if (com20020_check(dev)) {	225	if (com20020_check(dev)) {
222	ret = -EIO;	226	ret = -EIO;
223	goto out_port;	227	goto err_free_arcdev;
224	}	228	}
225		229
226	card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev),	230	card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev),
227	GFP_KERNEL);	231	GFP_KERNEL);
228	if (!card) {	232	if (!card) {
229	ret = -ENOMEM;	233	ret = -ENOMEM;
230	goto out_port;	234	goto err_free_arcdev;
231	}	235	}
232		236
233	card->index = i;	237	card->index = i;
@@ -253,29 +257,29 @@ static int com20020pci_probe(struct pci_dev *pdev, · 19 unmodified lines
253		257
254	ret = devm_led_classdev_register(&pdev->dev, &card->tx_led);	258	ret = devm_led_classdev_register(&pdev->dev, &card->tx_led);
255	if (ret)	259	if (ret)
256	goto out_port;	260	goto err_free_arcdev;
257		261
258	ret = devm_led_classdev_register(&pdev->dev, &card->recon_led);	262	ret = devm_led_classdev_register(&pdev->dev, &card->recon_led);
259	if (ret)	263	if (ret)
260	goto out_port;	264	goto err_free_arcdev;
261		265
262	dev_set_drvdata(&dev->dev, card);	266	dev_set_drvdata(&dev->dev, card);
263		267
264	ret = com20020_found(dev, IRQF_SHARED);	268	ret = com20020_found(dev, IRQF_SHARED);
265	if (ret)	269	if (ret)
266	goto out_port;	270	goto err_free_arcdev;
267		271
268	devm_arcnet_led_init(dev, dev->dev_id, i);	272	devm_arcnet_led_init(dev, dev->dev_id, i);
269		273
270	list_add(&card->list, &priv->list_dev);	274	list_add(&card->list, &priv->list_dev);
271	}	275	continue;
272		276
273	pci_set_drvdata(pdev, priv);	277	err_free_arcdev:
274		278	free_arcdev(dev);
275	return 0;	279	break;
276		280	}
277	out_port:	281	if (ret)
278	com20020pci_remove(pdev);	282	com20020pci_remove(pdev);
279	return ret;	283	return ret;
280	}	284	}
281		285

drivers/net/bonding/bond_main.c+2−6

 	rcu_read_lock();
 	slave = bond_first_slave_rcu(bond);
-	if (!slave) {
+	if (!slave)
-		ret = -EINVAL;
 		goto out;
-	}
 	slave_ops = slave->dev->netdev_ops;
-	if (!slave_ops->ndo_neigh_setup) {
+	if (!slave_ops->ndo_neigh_setup)
-		ret = -EINVAL;
 		goto out;
-	}
 	/* TODO: find another way [1] to implement this.
 	 * Passing a zeroed structure is fragile,

drivers/net/can/c_can/c_can.c+1−23

 	.brp_inc = 1,
 };
-static inline void c_can_pm_runtime_enable(const struct c_can_priv *priv)
-{
-	if (priv->device)
-		pm_runtime_enable(priv->device);
-}
-static inline void c_can_pm_runtime_disable(const struct c_can_priv *priv)
-{
-	if (priv->device)
-		pm_runtime_disable(priv->device);
-}
 static inline void c_can_pm_runtime_get_sync(const struct c_can_priv *priv)
 {
 	if (priv->device)
 int register_c_can_dev(struct net_device *dev)
 {
-	struct c_can_priv *priv = netdev_priv(dev);
 	int err;
 	/* Deactivate pins to prevent DRA7 DCAN IP from being
 	 */
 	pinctrl_pm_select_sleep_state(dev->dev.parent);
-	c_can_pm_runtime_enable(priv);
 	dev->flags |= IFF_ECHO;	/* we support local echo */
 	dev->netdev_ops = &c_can_netdev_ops;
 	err = register_candev(dev);
-	if (err)
+	if (!err)
-		c_can_pm_runtime_disable(priv);
-	else
 		devm_can_led_init(dev);
 	return err;
 }
 EXPORT_SYMBOL_GPL(register_c_can_dev);
 void unregister_c_can_dev(struct net_device *dev)
 {
-	struct c_can_priv *priv = netdev_priv(dev);
 	unregister_candev(dev);
-	c_can_pm_runtime_disable(priv);
 }
 EXPORT_SYMBOL_GPL(unregister_c_can_dev);

drivers/net/can/c_can/c_can_pci.c+2−1

 {
 	struct net_device *dev = pci_get_drvdata(pdev);
 	struct c_can_priv *priv = netdev_priv(dev);
+	void __iomem *addr = priv->base;
 	unregister_c_can_dev(dev);
 	free_c_can_dev(dev);
-	pci_iounmap(pdev, priv->base);
+	pci_iounmap(pdev, addr);
 	pci_disable_msi(pdev);
 	pci_clear_master(pdev);
 	pci_release_regions(pdev);

drivers/net/can/c_can/c_can_platform.c+5−1

@@ -29,6 +29,7 @@ · 28 unmodified lines
29	#include <linux/list.h>	29	#include <linux/list.h>
30	#include <linux/io.h>	30	#include <linux/io.h>
31	#include <linux/platform_device.h>	31	#include <linux/platform_device.h>
		32	#include <linux/pm_runtime.h>
32	#include <linux/clk.h>	33	#include <linux/clk.h>
33	#include <linux/of.h>	34	#include <linux/of.h>
34	#include <linux/of_device.h>	35	#include <linux/of_device.h>
@@ -386,6 +387,7 @@ static int c_can_plat_probe(struct platform_device *pdev) · 351 unmodified lines
386	platform_set_drvdata(pdev, dev);	387	platform_set_drvdata(pdev, dev);
387	SET_NETDEV_DEV(dev, &pdev->dev);	388	SET_NETDEV_DEV(dev, &pdev->dev);
388		389
		390	pm_runtime_enable(priv->device);
389	ret = register_c_can_dev(dev);	391	ret = register_c_can_dev(dev);
390	if (ret) {	392	if (ret) {
391	dev_err(&pdev->dev, "registering %s failed (err=%d)\n",	393	dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
@@ -398,6 +400,7 @@ static int c_can_plat_probe(struct platform_device *pdev) · 6 unmodified lines
398	return 0;	400	return 0;
399		401
400	exit_free_device:	402	exit_free_device:
		403	pm_runtime_disable(priv->device);
401	free_c_can_dev(dev);	404	free_c_can_dev(dev);
402	exit:	405	exit:
403	dev_err(&pdev->dev, "probe failed\n");	406	dev_err(&pdev->dev, "probe failed\n");
@@ -408,9 +411,10 @@ exit: · 4 unmodified lines
408	static int c_can_plat_remove(struct platform_device *pdev)	411	static int c_can_plat_remove(struct platform_device *pdev)
409	{	412	{
410	struct net_device *dev = platform_get_drvdata(pdev);	413	struct net_device *dev = platform_get_drvdata(pdev);
		414	struct c_can_priv *priv = netdev_priv(dev);
411		415
412	unregister_c_can_dev(dev);	416	unregister_c_can_dev(dev);
413		417	pm_runtime_disable(priv->device);
414	free_c_can_dev(dev);	418	free_c_can_dev(dev);
415		419
416	return 0;	420	return 0;

drivers/net/can/dev/netlink.c+1−0

@@ -355,6 +355,7 @@ static void can_dellink(struct net_device dev, struct list_head head) · 354 unmodified lines
355		355
356	struct rtnl_link_ops can_link_ops __read_mostly = {	356	struct rtnl_link_ops can_link_ops __read_mostly = {
357	.kind = "can",	357	.kind = "can",
		358	.netns_refund = true,
358	.maxtype = IFLA_CAN_MAX,	359	.maxtype = IFLA_CAN_MAX,
359	.policy = can_policy,	360	.policy = can_policy,
360	.setup = can_setup,	361	.setup = can_setup,

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

 static int flexcan_chip_freeze(struct flexcan_priv *priv)
 {
 	struct flexcan_regs __iomem *regs = priv->regs;
-	unsigned int timeout = 1000 * 1000 * 10 / priv->can.bittiming.bitrate;
+	unsigned int timeout;
+	u32 bitrate = priv->can.bittiming.bitrate;
 	u32 reg;
+	if (bitrate)
+		timeout = 1000 * 1000 * 10 / bitrate;
+	else
+		timeout = FLEXCAN_TIMEOUT_US / 10;
 	reg = priv->read(&regs->mcr);
 	reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT;
 	priv->write(reg, &regs->mcr);

drivers/net/can/kvaser_pciefd.c+4−0

 #define KVASER_PCIEFD_KCAN_STAT_REG 0x418
 #define KVASER_PCIEFD_KCAN_MODE_REG 0x41c
 #define KVASER_PCIEFD_KCAN_BTRN_REG 0x420
+#define KVASER_PCIEFD_KCAN_BUS_LOAD_REG 0x424
 #define KVASER_PCIEFD_KCAN_BTRD_REG 0x428
 #define KVASER_PCIEFD_KCAN_PWM_REG 0x430
 /* Loopback control register */
 		timer_setup(&can->bec_poll_timer, kvaser_pciefd_bec_poll_timer,
 			    0);
+		/* Disable Bus load reporting */
+		iowrite32(0, can->reg_base + KVASER_PCIEFD_KCAN_BUS_LOAD_REG);
 		tx_npackets = ioread32(can->reg_base +
 				       KVASER_PCIEFD_KCAN_TX_NPACKETS_REG);
 		if (((tx_npackets >> KVASER_PCIEFD_KCAN_TX_NPACKETS_MAX_SHIFT) &

drivers/net/can/m_can/m_can.c+1−4

 	}
 	while ((rxfs & RXFS_FFL_MASK) && (quota > 0)) {
-		if (rxfs & RXFS_RFL)
-			netdev_warn(dev, "Rx FIFO 0 Message Lost\n");
 		m_can_read_fifo(dev, rxfs);
 		quota--;
 {
 	struct m_can_classdev *cdev = netdev_priv(dev);
-	m_can_rx_handler(dev, 1);
+	m_can_rx_handler(dev, M_CAN_NAPI_WEIGHT);
 	m_can_enable_all_interrupts(cdev);

drivers/net/can/peak_canfd/peak_pciefd_main.c+0−1

@@ -21,7 +21,6 @@ · 20 unmodified lines
21		21
22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");	22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
23	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCIe/M.2 FD family cards");	23	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCIe/M.2 FD family cards");
24	MODULE_SUPPORTED_DEVICE("PEAK PCAN PCIe/M.2 FD CAN cards");
25	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
26		25
27	#define PCIEFD_DRV_NAME "peak_pciefd"	26	#define PCIEFD_DRV_NAME "peak_pciefd"

drivers/net/can/sja1000/ems_pci.c+0−1

@@ -21,7 +21,6 @@ · 20 unmodified lines
21		21
22	MODULE_AUTHOR("Sebastian Haas <haas@ems-wuenche.com>");	22	MODULE_AUTHOR("Sebastian Haas <haas@ems-wuenche.com>");
23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-PCI/PCIe/104P CAN cards");	23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-PCI/PCIe/104P CAN cards");
24	MODULE_SUPPORTED_DEVICE("EMS CPC-PCI/PCIe/104P CAN card");
25	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
26		25
27	#define EMS_PCI_V1_MAX_CHAN 2	26	#define EMS_PCI_V1_MAX_CHAN 2

drivers/net/can/sja1000/ems_pcmcia.c+0−1

@@ -21,7 +21,6 @@ · 20 unmodified lines
21		21
22	MODULE_AUTHOR("Markus Plessing <plessing@ems-wuensche.com>");	22	MODULE_AUTHOR("Markus Plessing <plessing@ems-wuensche.com>");
23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-CARD cards");	23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-CARD cards");
24	MODULE_SUPPORTED_DEVICE("EMS CPC-CARD CAN card");
25	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
26		25
27	#define EMS_PCMCIA_MAX_CHAN 2	26	#define EMS_PCMCIA_MAX_CHAN 2

drivers/net/can/sja1000/kvaser_pci.c+0−1

@@ -33,7 +33,6 @@ · 32 unmodified lines
33		33
34	MODULE_AUTHOR("Per Dalen <per.dalen@cnw.se>");	34	MODULE_AUTHOR("Per Dalen <per.dalen@cnw.se>");
35	MODULE_DESCRIPTION("Socket-CAN driver for KVASER PCAN PCI cards");	35	MODULE_DESCRIPTION("Socket-CAN driver for KVASER PCAN PCI cards");
36	MODULE_SUPPORTED_DEVICE("KVASER PCAN PCI CAN card");
37	MODULE_LICENSE("GPL v2");	36	MODULE_LICENSE("GPL v2");
38		37
39	#define MAX_NO_OF_CHANNELS 4 /* max no of channels on a single card */	38	#define MAX_NO_OF_CHANNELS 4 /* max no of channels on a single card */

drivers/net/can/sja1000/peak_pci.c+0−2

@@ -24,8 +24,6 @@ · 23 unmodified lines
24		24
25	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");	25	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
26	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards");	26	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards");
27	MODULE_SUPPORTED_DEVICE("PEAK PCAN PCI/PCIe/PCIeC miniPCI CAN cards");
28	MODULE_SUPPORTED_DEVICE("PEAK PCAN miniPCIe/cPCI PC/104+ PCI/104e CAN Cards");
29	MODULE_LICENSE("GPL v2");	27	MODULE_LICENSE("GPL v2");
30		28
31	#define DRV_NAME "peak_pci"	29	#define DRV_NAME "peak_pci"

drivers/net/can/sja1000/peak_pcmcia.c+0−1

@@ -22,7 +22,6 @@ · 21 unmodified lines
22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");	22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
23	MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");	23	MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");
24	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
25	MODULE_SUPPORTED_DEVICE("PEAK PCAN-PC Card");
26		25
27	/* PEAK-System PCMCIA driver name */	26	/* PEAK-System PCMCIA driver name */
28	#define PCC_NAME "peak_pcmcia"	27	#define PCC_NAME "peak_pcmcia"

drivers/net/can/sja1000/plx_pci.c+0−12

@@ -25,18 +25,6 @@ · 24 unmodified lines
25	MODULE_AUTHOR("Pavel Cheblakov <P.B.Cheblakov@inp.nsk.su>");	25	MODULE_AUTHOR("Pavel Cheblakov <P.B.Cheblakov@inp.nsk.su>");
26	MODULE_DESCRIPTION("Socket-CAN driver for PLX90xx PCI-bridge cards with "	26	MODULE_DESCRIPTION("Socket-CAN driver for PLX90xx PCI-bridge cards with "
27	"the SJA1000 chips");	27	"the SJA1000 chips");
28	MODULE_SUPPORTED_DEVICE("Adlink PCI-7841/cPCI-7841, "
29	"Adlink PCI-7841/cPCI-7841 SE, "
30	"Marathon CAN-bus-PCI, "
31	"Marathon CAN-bus-PCIe, "
32	"TEWS TECHNOLOGIES TPMC810, "
33	"esd CAN-PCI/CPCI/PCI104/200, "
34	"esd CAN-PCI/PMC/266, "
35	"esd CAN-PCIe/2000, "
36	"Connect Tech Inc. CANpro/104-Plus Opto (CRG001), "
37	"IXXAT PC-I 04/PCI, "
38	"ELCUS CAN-200-PCI, "
39	"ASEM DUAL CAN-RAW")
40	MODULE_LICENSE("GPL v2");	28	MODULE_LICENSE("GPL v2");
41		29
42	#define PLX_PCI_MAX_CHAN 2	30	#define PLX_PCI_MAX_CHAN 2

drivers/net/can/usb/Kconfig+1−0

@@ -73,6 +73,7 @@ config CAN_KVASER_USB · 72 unmodified lines
73	- Kvaser Memorator Pro 5xHS	73	- Kvaser Memorator Pro 5xHS
74	- Kvaser USBcan Light 4xHS	74	- Kvaser USBcan Light 4xHS
75	- Kvaser USBcan Pro 2xHS v2	75	- Kvaser USBcan Pro 2xHS v2
		76	- Kvaser USBcan Pro 4xHS
76	- Kvaser USBcan Pro 5xHS	77	- Kvaser USBcan Pro 5xHS
77	- Kvaser U100	78	- Kvaser U100
78	- Kvaser U100P	79	- Kvaser U100P

drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c+3−1

 #define USB_U100_PRODUCT_ID			273
 #define USB_U100P_PRODUCT_ID			274
 #define USB_U100S_PRODUCT_ID			275
+#define USB_USBCAN_PRO_4HS_PRODUCT_ID		276
 #define USB_HYDRA_PRODUCT_ID_END \
-	USB_U100S_PRODUCT_ID
+	USB_USBCAN_PRO_4HS_PRODUCT_ID
 static inline bool kvaser_is_leaf(const struct usb_device_id *id)
 {
 	{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID) },
 	{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID) },
 	{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID) },
+	{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_4HS_PRODUCT_ID) },
 	{ }
 };
 MODULE_DEVICE_TABLE(usb, kvaser_usb_table);

drivers/net/can/usb/peak_usb/pcan_usb.c+0−2

@@ -18,8 +18,6 @@ · 17 unmodified lines
18		18
19	#include "pcan_usb_core.h"	19	#include "pcan_usb_core.h"
20		20
21	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB adapter");
22
23	/* PCAN-USB Endpoints */	21	/* PCAN-USB Endpoints */
24	#define PCAN_USB_EP_CMDOUT 1	22	#define PCAN_USB_EP_CMDOUT 1
25	#define PCAN_USB_EP_CMDIN (PCAN_USB_EP_CMDOUT \| USB_DIR_IN)	23	#define PCAN_USB_EP_CMDIN (PCAN_USB_EP_CMDOUT \| USB_DIR_IN)

drivers/net/can/usb/peak_usb/pcan_usb_fd.c+0−3

@@ -16,9 +16,6 @@ · 15 unmodified lines
16	#include "pcan_usb_core.h"	16	#include "pcan_usb_core.h"
17	#include "pcan_usb_pro.h"	17	#include "pcan_usb_pro.h"
18		18
19	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB FD adapter");
20	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB Pro FD adapter");
21
22	#define PCAN_USBPROFD_CHANNEL_COUNT 2	19	#define PCAN_USBPROFD_CHANNEL_COUNT 2
23	#define PCAN_USBFD_CHANNEL_COUNT 1	20	#define PCAN_USBFD_CHANNEL_COUNT 1
24		21

drivers/net/can/usb/peak_usb/pcan_usb_pro.c+0−2

@@ -17,8 +17,6 @@ · 16 unmodified lines
17	#include "pcan_usb_core.h"	17	#include "pcan_usb_core.h"
18	#include "pcan_usb_pro.h"	18	#include "pcan_usb_pro.h"
19		19
20	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB Pro adapter");
21
22	#define PCAN_USBPRO_CHANNEL_COUNT 2	20	#define PCAN_USBPRO_CHANNEL_COUNT 2
23		21
24	/* PCAN-USB Pro adapter internal clock (MHz) */	22	/* PCAN-USB Pro adapter internal clock (MHz) */

drivers/net/dsa/b53/b53_common.c+7−7

 			b53_disable_port(ds, port);
 	}
-	/* Let DSA handle the case were multiple bridges span the same switch
-	 * device and different VLAN awareness settings are requested, which
-	 * would be breaking filtering semantics for any of the other bridge
-	 * devices. (not hardware supported)
-	 */
-	ds->vlan_filtering_is_global = true;
 	return b53_setup_devlink_resources(ds);
 }
 	ds->ops = &b53_switch_ops;
 	ds->untag_bridge_pvid = true;
 	dev->vlan_enabled = true;
+	/* Let DSA handle the case were multiple bridges span the same switch
+	 * device and different VLAN awareness settings are requested, which
+	 * would be breaking filtering semantics for any of the other bridge
+	 * devices. (not hardware supported)
+	 */
+	ds->vlan_filtering_is_global = true;
 	mutex_init(&dev->reg_mutex);
 	mutex_init(&dev->stats_mutex);

drivers/net/dsa/bcm_sf2.c+8−3

@@ -144,7 +144,10 @@ static void bcm_sf2_imp_setup(struct dsa_switch *ds, int port) · 143 unmodified lines
144	/* Force link status for IMP port */	144	/* Force link status for IMP port */
145	reg = core_readl(priv, offset);	145	reg = core_readl(priv, offset);
146	reg \|= (MII_SW_OR \| LINK_STS);	146	reg \|= (MII_SW_OR \| LINK_STS);
147	reg &= ~GMII_SPEED_UP_2G;	147	if (priv->type == BCM4908_DEVICE_ID)
		148	reg \|= GMII_SPEED_UP_2G;
		149	else
		150	reg &= ~GMII_SPEED_UP_2G;
148	core_writel(priv, reg, offset);	151	core_writel(priv, reg, offset);
149		152
150	/* Enable Broadcast, Multicast, Unicast forwarding to IMP port */	153	/* Enable Broadcast, Multicast, Unicast forwarding to IMP port */
@@ -661,8 +664,10 @@ static u32 bcm_sf2_sw_get_phy_flags(struct dsa_switch *ds, int port) · 510 unmodified lines
661	* in bits 15:8 and the patch level in bits 7:0 which is exactly what	664	* in bits 15:8 and the patch level in bits 7:0 which is exactly what
662	* the REG_PHY_REVISION register layout is.	665	* the REG_PHY_REVISION register layout is.
663	*/	666	*/
664		667	if (priv->int_phy_mask & BIT(port))
665	return priv->hw_params.gphy_rev;	668	return priv->hw_params.gphy_rev;
		669	else
		670	return 0;
666	}	671	}
667		672
668	static void bcm_sf2_sw_validate(struct dsa_switch *ds, int port,	673	static void bcm_sf2_sw_validate(struct dsa_switch *ds, int port,

drivers/net/dsa/mt7530.c+25−27

@@ -436,34 +436,32 @@ mt7530_pad_clk_setup(struct dsa_switch *ds, phy_interface_t interface) · 435 unmodified lines
436	TD_DM_DRVP(8) \| TD_DM_DRVN(8));	436	TD_DM_DRVP(8) \| TD_DM_DRVN(8));
437		437
438	/* Setup core clock for MT7530 */	438	/* Setup core clock for MT7530 */
439	if (!trgint) {	439	/* Disable MT7530 core clock */
440	/* Disable MT7530 core clock */	440	core_clear(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);
441	core_clear(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);
442
443	/* Disable PLL, since phy_device has not yet been created
444	* provided for phy_[read,write]_mmd_indirect is called, we
445	* provide our own core_write_mmd_indirect to complete this
446	* function.
447	*/
448	core_write_mmd_indirect(priv,
449	CORE_GSWPLL_GRP1,
450	MDIO_MMD_VEND2,
451	0);
452
453	/* Set core clock into 500Mhz */
454	core_write(priv, CORE_GSWPLL_GRP2,
455	RG_GSWPLL_POSDIV_500M(1) \|
456	RG_GSWPLL_FBKDIV_500M(25));
457		441
458	/* Enable PLL */	442	/* Disable PLL, since phy_device has not yet been created
459	core_write(priv, CORE_GSWPLL_GRP1,	443	* provided for phy_[read,write]_mmd_indirect is called, we
460	RG_GSWPLL_EN_PRE \|	444	* provide our own core_write_mmd_indirect to complete this
461	RG_GSWPLL_POSDIV_200M(2) \|	445	* function.
462	RG_GSWPLL_FBKDIV_200M(32));	446	*/
463		447	core_write_mmd_indirect(priv,
464	/* Enable MT7530 core clock */	448	CORE_GSWPLL_GRP1,
465	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);	449	MDIO_MMD_VEND2,
466	}	450	0);
		451
		452	/* Set core clock into 500Mhz */
		453	core_write(priv, CORE_GSWPLL_GRP2,
		454	RG_GSWPLL_POSDIV_500M(1) \|
		455	RG_GSWPLL_FBKDIV_500M(25));
		456
		457	/* Enable PLL */
		458	core_write(priv, CORE_GSWPLL_GRP1,
		459	RG_GSWPLL_EN_PRE \|
		460	RG_GSWPLL_POSDIV_200M(2) \|
		461	RG_GSWPLL_FBKDIV_200M(32));
		462
		463	/* Enable MT7530 core clock */
		464	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);
467		465
468	/* Setup the MT7530 TRGMII Tx Clock */	466	/* Setup the MT7530 TRGMII Tx Clock */
469	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);	467	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);

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

@@ -54,7 +54,7 @@ config B44_PCI · 53 unmodified lines
54	config BCM4908_ENET	54	config BCM4908_ENET
55	tristate "Broadcom BCM4908 internal mac support"	55	tristate "Broadcom BCM4908 internal mac support"
56	depends on ARCH_BCM4908 \|\| COMPILE_TEST	56	depends on ARCH_BCM4908 \|\| COMPILE_TEST
57	default y	57	default y if ARCH_BCM4908
58	help	58	help
59	This driver supports Ethernet controller integrated into Broadcom	59	This driver supports Ethernet controller integrated into Broadcom
60	BCM4908 family SoCs.	60	BCM4908 family SoCs.

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c+1−1

@@ -722,7 +722,7 @@ static int chcr_ktls_cpl_set_tcb_rpl(struct adapter adap, unsigned char input) · 721 unmodified lines
722	kvfree(tx_info);	722	kvfree(tx_info);
723	return 0;	723	return 0;
724	}	724	}
725	tx_info->open_state = false;	725	tx_info->open_state = CH_KTLS_OPEN_SUCCESS;
726	spin_unlock(&tx_info->lock);	726	spin_unlock(&tx_info->lock);
727		727
728	complete(&tx_info->completion);	728	complete(&tx_info->completion);

drivers/net/ethernet/faraday/ftgmac100.c+1−0

@@ -1337,6 +1337,7 @@ static int ftgmac100_poll(struct napi_struct *napi, int budget) · 1336 unmodified lines
1337	*/	1337	*/
1338	if (unlikely(priv->need_mac_restart)) {	1338	if (unlikely(priv->need_mac_restart)) {
1339	ftgmac100_start_hw(priv);	1339	ftgmac100_start_hw(priv);
		1340	priv->need_mac_restart = false;
1340		1341
1341	/* Re-enable "bad" interrupts */	1342	/* Re-enable "bad" interrupts */
1342	iowrite32(FTGMAC100_INT_BAD,	1343	iowrite32(FTGMAC100_INT_BAD,

drivers/net/ethernet/intel/e1000e/82571.c+2−0

 	} else {
 		data &= ~IGP02E1000_PM_D0_LPLU;
 		ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data);
+		if (ret_val)
+			return ret_val;
 		/* LPLU and SmartSpeed are mutually exclusive.  LPLU is used
 		 * during Dx states where the power conservation is most
 		 * important.  During driver activity we should enable

drivers/net/ethernet/intel/e1000e/hw.h+3−3

@@ -1,8 +1,8 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/* Copyright(c) 1999 - 2018 Intel Corporation. */	2	/* Copyright(c) 1999 - 2018 Intel Corporation. */
3		3
4	#ifndef _E1000_HW_H_	4	#ifndef _E1000E_HW_H_
5	#define _E1000_HW_H_	5	#define _E1000E_HW_H_
6		6
7	#include "regs.h"	7	#include "regs.h"
8	#include "defines.h"	8	#include "defines.h"
@@ -714,4 +714,4 @@ struct e1000_hw { · 705 unmodified lines
714	#include "80003es2lan.h"	714	#include "80003es2lan.h"
715	#include "ich8lan.h"	715	#include "ich8lan.h"
716		716
717	#endif	717	#endif /* _E1000E_HW_H_ */

drivers/net/ethernet/intel/e1000e/netdev.c+5−1

 	struct e1000_adapter *adapter;
 	adapter = container_of(work, struct e1000_adapter, reset_task);
+	rtnl_lock();
 	/* don't run the task if already down */
-	if (test_bit(__E1000_DOWN, &adapter->state))
+	if (test_bit(__E1000_DOWN, &adapter->state)) {
+		rtnl_unlock();
 		return;
+	}
 	if (!(adapter->flags & FLAG_RESTART_NOW)) {
 		e1000e_dump(adapter);
 		e_err("Reset adapter unexpectedly\n");
 	}
 	e1000e_reinit_locked(adapter);
+	rtnl_unlock();
 }
 /**

drivers/net/ethernet/intel/i40e/i40e_main.c+13−0

@@ -3258,6 +3258,17 @@ static int i40e_configure_tx_ring(struct i40e_ring *ring) · 3257 unmodified lines
3258	return 0;	3258	return 0;
3259	}	3259	}
3260		3260
		3261	/**
		3262	* i40e_rx_offset - Return expected offset into page to access data
		3263	* @rx_ring: Ring we are requesting offset of
		3264	*
		3265	* Returns the offset value for ring into the data buffer.
		3266	*/
		3267	static unsigned int i40e_rx_offset(struct i40e_ring *rx_ring)
		3268	{
		3269	return ring_uses_build_skb(rx_ring) ? I40E_SKB_PAD : 0;
		3270	}
		3271
3261	/**	3272	/**
3262	* i40e_configure_rx_ring - Configure a receive ring context	3273	* i40e_configure_rx_ring - Configure a receive ring context
3263	* @ring: The Rx ring to configure	3274	* @ring: The Rx ring to configure
@@ -3369,6 +3380,8 @@ static int i40e_configure_rx_ring(struct i40e_ring *ring) · 105 unmodified lines
3369	else	3380	else
3370	set_ring_build_skb_enabled(ring);	3381	set_ring_build_skb_enabled(ring);
3371		3382
		3383	ring->rx_offset = i40e_rx_offset(ring);
		3384
3372	/* cache tail for quicker writes, and clear the reg before use */	3385	/* cache tail for quicker writes, and clear the reg before use */
3373	ring->tail = hw->hw_addr + I40E_QRX_TAIL(pf_q);	3386	ring->tail = hw->hw_addr + I40E_QRX_TAIL(pf_q);
3374	writel(0, ring->tail);	3387	writel(0, ring->tail);

drivers/net/ethernet/intel/i40e/i40e_txrx.c+0−12

 	}
 }
-/**
- * i40e_rx_offset - Return expected offset into page to access data
- * @rx_ring: Ring we are requesting offset of
- *
- * Returns the offset value for ring into the data buffer.
- */
-static unsigned int i40e_rx_offset(struct i40e_ring *rx_ring)
-{
-	return ring_uses_build_skb(rx_ring) ? I40E_SKB_PAD : 0;
-}
 /**
  * i40e_setup_rx_descriptors - Allocate Rx descriptors
  * @rx_ring: Rx descriptor ring (for a specific queue) to setup
 	rx_ring->next_to_alloc = 0;
 	rx_ring->next_to_clean = 0;
 	rx_ring->next_to_use = 0;
-	rx_ring->rx_offset = i40e_rx_offset(rx_ring);
 	/* XDP RX-queue info only needed for RX rings exposed to XDP */
 	if (rx_ring->vsi->type == I40E_VSI_MAIN) {

drivers/net/ethernet/intel/ice/ice_base.c+22−2

 	tlan_ctx->legacy_int = ICE_TX_LEGACY;
 }
+/**
+ * ice_rx_offset - Return expected offset into page to access data
+ * @rx_ring: Ring we are requesting offset of
+ *
+ * Returns the offset value for ring into the data buffer.
+ */
+static unsigned int ice_rx_offset(struct ice_ring *rx_ring)
+{
+	if (ice_ring_uses_build_skb(rx_ring))
+		return ICE_SKB_PAD;
+	else if (ice_is_xdp_ena_vsi(rx_ring->vsi))
+		return XDP_PACKET_HEADROOM;
+	return 0;
+}
 /**
  * ice_setup_rx_ctx - Configure a receive ring context
  * @ring: The Rx ring to configure
 	else
 		ice_set_ring_build_skb_ena(ring);
+	ring->rx_offset = ice_rx_offset(ring);
 	/* init queue specific tail register */
 	ring->tail = hw->hw_addr + QRX_TAIL(pf_q);
 	writel(0, ring->tail);
 	if (ring->xsk_pool) {
+		bool ok;
 		if (!xsk_buff_can_alloc(ring->xsk_pool, num_bufs)) {
 			dev_warn(dev, "XSK buffer pool does not provide enough addresses to fill %d buffers on Rx ring %d\n",
 				 num_bufs, ring->q_index);
 			return 0;
 		}
-		err = ice_alloc_rx_bufs_zc(ring, num_bufs);
+		ok = ice_alloc_rx_bufs_zc(ring, num_bufs);
-		if (err)
+		if (!ok)
 			dev_info(dev, "Failed to allocate some buffers on XSK buffer pool enabled Rx ring %d (pf_q %d)\n",
 				 ring->q_index, pf_q);
 		return 0;

drivers/net/ethernet/intel/ice/ice_txrx.c+0−17

@@ -443,22 +443,6 @@ void ice_free_rx_ring(struct ice_ring *rx_ring) · 442 unmodified lines
443	}	443	}
444	}	444	}
445		445
446	/**
447	* ice_rx_offset - Return expected offset into page to access data
448	* @rx_ring: Ring we are requesting offset of
449	*
450	* Returns the offset value for ring into the data buffer.
451	*/
452	static unsigned int ice_rx_offset(struct ice_ring *rx_ring)
453	{
454	if (ice_ring_uses_build_skb(rx_ring))
455	return ICE_SKB_PAD;
456	else if (ice_is_xdp_ena_vsi(rx_ring->vsi))
457	return XDP_PACKET_HEADROOM;
458
459	return 0;
460	}
461
462	/**	446	/**
463	* ice_setup_rx_ring - Allocate the Rx descriptors	447	* ice_setup_rx_ring - Allocate the Rx descriptors
464	* @rx_ring: the Rx ring to set up	448	* @rx_ring: the Rx ring to set up
@@ -493,7 +477,6 @@ int ice_setup_rx_ring(struct ice_ring *rx_ring) · 28 unmodified lines
493		477
494	rx_ring->next_to_use = 0;	478	rx_ring->next_to_use = 0;
495	rx_ring->next_to_clean = 0;	479	rx_ring->next_to_clean = 0;
496	rx_ring->rx_offset = ice_rx_offset(rx_ring);
497		480
498	if (ice_is_xdp_ena_vsi(rx_ring->vsi))	481	if (ice_is_xdp_ena_vsi(rx_ring->vsi))
499	WRITE_ONCE(rx_ring->xdp_prog, rx_ring->vsi->xdp_prog);	482	WRITE_ONCE(rx_ring->xdp_prog, rx_ring->vsi->xdp_prog);

drivers/net/ethernet/intel/ice/ice_xsk.c+5−5

@@ -358,18 +358,18 @@ xsk_pool_if_up: · 357 unmodified lines
358	* This function allocates a number of Rx buffers from the fill ring	358	* This function allocates a number of Rx buffers from the fill ring
359	* or the internal recycle mechanism and places them on the Rx ring.	359	* or the internal recycle mechanism and places them on the Rx ring.
360	*	360	*
361	* Returns false if all allocations were successful, true if any fail.	361	* Returns true if all allocations were successful, false if any fail.
362	*/	362	*/
363	bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count)	363	bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count)
364	{	364	{
365	union ice_32b_rx_flex_desc *rx_desc;	365	union ice_32b_rx_flex_desc *rx_desc;
366	u16 ntu = rx_ring->next_to_use;	366	u16 ntu = rx_ring->next_to_use;
367	struct ice_rx_buf *rx_buf;	367	struct ice_rx_buf *rx_buf;
368	bool ret = false;	368	bool ok = true;
369	dma_addr_t dma;	369	dma_addr_t dma;
370		370
371	if (!count)	371	if (!count)
372	return false;	372	return true;
373		373
374	rx_desc = ICE_RX_DESC(rx_ring, ntu);	374	rx_desc = ICE_RX_DESC(rx_ring, ntu);
375	rx_buf = &rx_ring->rx_buf[ntu];	375	rx_buf = &rx_ring->rx_buf[ntu];
@@ -377,7 +377,7 @@ bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count) · 1 unmodified line
377	do {	377	do {
378	rx_buf->xdp = xsk_buff_alloc(rx_ring->xsk_pool);	378	rx_buf->xdp = xsk_buff_alloc(rx_ring->xsk_pool);
379	if (!rx_buf->xdp) {	379	if (!rx_buf->xdp) {
380	ret = true;	380	ok = false;
381	break;	381	break;
382	}	382	}
383		383
@@ -402,7 +402,7 @@ bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count) · 18 unmodified lines
402	ice_release_rx_desc(rx_ring, ntu);	402	ice_release_rx_desc(rx_ring, ntu);
403	}	403	}
404		404
405	return ret;	405	return ok;
406	}	406	}
407		407
408	/**	408	/**

drivers/net/ethernet/intel/igb/e1000_hw.h+3−3

@@ -1,8 +1,8 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/* Copyright(c) 2007 - 2018 Intel Corporation. */	2	/* Copyright(c) 2007 - 2018 Intel Corporation. */
3		3
4	#ifndef _E1000_HW_H_	4	#ifndef _E1000_IGB_HW_H_
5	#define _E1000_HW_H_	5	#define _E1000_IGB_HW_H_
6		6
7	#include <linux/types.h>	7	#include <linux/types.h>
8	#include <linux/delay.h>	8	#include <linux/delay.h>
@@ -551,4 +551,4 @@ s32 igb_write_pcie_cap_reg(struct e1000_hw hw, u32 reg, u16 value); · 542 unmodified lines
551		551
552	void igb_read_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);	552	void igb_read_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);
553	void igb_write_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);	553	void igb_write_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);
554	#endif /* _E1000_HW_H_ */	554	#endif /* _E1000_IGB_HW_H_ */

drivers/net/ethernet/intel/igb/igb.h+2−2

@@ -748,8 +748,8 @@ void igb_ptp_suspend(struct igb_adapter *adapter); · 747 unmodified lines
748	void igb_ptp_rx_hang(struct igb_adapter *adapter);	748	void igb_ptp_rx_hang(struct igb_adapter *adapter);
749	void igb_ptp_tx_hang(struct igb_adapter *adapter);	749	void igb_ptp_tx_hang(struct igb_adapter *adapter);
750	void igb_ptp_rx_rgtstamp(struct igb_q_vector q_vector, struct sk_buff skb);	750	void igb_ptp_rx_rgtstamp(struct igb_q_vector q_vector, struct sk_buff skb);
751	void igb_ptp_rx_pktstamp(struct igb_q_vector q_vector, void va,	751	int igb_ptp_rx_pktstamp(struct igb_q_vector q_vector, void va,
752	struct sk_buff *skb);	752	struct sk_buff *skb);
753	int igb_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);	753	int igb_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);
754	int igb_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);	754	int igb_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);
755	void igb_set_flag_queue_pairs(struct igb_adapter *, const u32);	755	void igb_set_flag_queue_pairs(struct igb_adapter *, const u32);

drivers/net/ethernet/intel/igb/igb_main.c+21−12

 	new_buff->pagecnt_bias	= old_buff->pagecnt_bias;
 }
-static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer)
+static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer,
+				  int rx_buf_pgcnt)
 {
 	unsigned int pagecnt_bias = rx_buffer->pagecnt_bias;
 	struct page *page = rx_buffer->page;
 #if (PAGE_SIZE < 8192)
 	/* if we are only owner of page we can reuse it */
-	if (unlikely((page_ref_count(page) - pagecnt_bias) > 1))
+	if (unlikely((rx_buf_pgcnt - pagecnt_bias) > 1))
 		return false;
 #else
 #define IGB_LAST_OFFSET \
 		return NULL;
 	if (unlikely(igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP))) {
-		igb_ptp_rx_pktstamp(rx_ring->q_vector, xdp->data, skb);
+		if (!igb_ptp_rx_pktstamp(rx_ring->q_vector, xdp->data, skb)) {
-		xdp->data += IGB_TS_HDR_LEN;
+			xdp->data += IGB_TS_HDR_LEN;
-		size -= IGB_TS_HDR_LEN;
+			size -= IGB_TS_HDR_LEN;
+		}
 	}
 	/* Determine available headroom for copy */
 	/* pull timestamp out of packet data */
 	if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) {
-		igb_ptp_rx_pktstamp(rx_ring->q_vector, skb->data, skb);
+		if (!igb_ptp_rx_pktstamp(rx_ring->q_vector, skb->data, skb))
-		__skb_pull(skb, IGB_TS_HDR_LEN);
+			__skb_pull(skb, IGB_TS_HDR_LEN);
 	}
 	/* update buffer offset */
 }
 static struct igb_rx_buffer *igb_get_rx_buffer(struct igb_ring *rx_ring,
-					       const unsigned int size)
+					       const unsigned int size, int *rx_buf_pgcnt)
 {
 	struct igb_rx_buffer *rx_buffer;
 	rx_buffer = &rx_ring->rx_buffer_info[rx_ring->next_to_clean];
+	*rx_buf_pgcnt =
+#if (PAGE_SIZE < 8192)
+		page_count(rx_buffer->page);
+#else
+		0;
+#endif
 	prefetchw(rx_buffer->page);
 	/* we are reusing so sync this buffer for CPU use */
 }
 static void igb_put_rx_buffer(struct igb_ring *rx_ring,
-			      struct igb_rx_buffer *rx_buffer)
+			      struct igb_rx_buffer *rx_buffer, int rx_buf_pgcnt)
 {
-	if (igb_can_reuse_rx_page(rx_buffer)) {
+	if (igb_can_reuse_rx_page(rx_buffer, rx_buf_pgcnt)) {
 		/* hand second half of page back to the ring */
 		igb_reuse_rx_page(rx_ring, rx_buffer);
 	} else {
 	unsigned int xdp_xmit = 0;
 	struct xdp_buff xdp;
 	u32 frame_sz = 0;
+	int rx_buf_pgcnt;
 	/* Frame size depend on rx_ring setup when PAGE_SIZE=4K */
 #if (PAGE_SIZE < 8192)
 		 */
 		dma_rmb();
-		rx_buffer = igb_get_rx_buffer(rx_ring, size);
+		rx_buffer = igb_get_rx_buffer(rx_ring, size, &rx_buf_pgcnt);
 		/* retrieve a buffer from the ring */
 		if (!skb) {
 			break;
 		}
-		igb_put_rx_buffer(rx_ring, rx_buffer);
+		igb_put_rx_buffer(rx_ring, rx_buffer, rx_buf_pgcnt);
 		cleaned_count++;
 		/* fetch next buffer in frame if non-eop */

drivers/net/ethernet/intel/igb/igb_ptp.c+24−7

 	dev_kfree_skb_any(skb);
 }
+#define IGB_RET_PTP_DISABLED 1
+#define IGB_RET_PTP_INVALID 2
 /**
  * igb_ptp_rx_pktstamp - retrieve Rx per packet timestamp
  * @q_vector: Pointer to interrupt specific structure
  *
  * This function is meant to retrieve a timestamp from the first buffer of an
  * incoming frame.  The value is stored in little endian format starting on
- * byte 8.
+ * byte 8
+ *
+ * Returns: 0 if success, nonzero if failure
  **/
-void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, void *va,
+int igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, void *va,
-			 struct sk_buff *skb)
+			struct sk_buff *skb)
 {
-	__le64 *regval = (__le64 *)va;
 	struct igb_adapter *adapter = q_vector->adapter;
+	__le64 *regval = (__le64 *)va;
 	int adjust = 0;
+	if (!(adapter->ptp_flags & IGB_PTP_ENABLED))
+		return IGB_RET_PTP_DISABLED;
 	/* The timestamp is recorded in little endian format.
 	 * DWORD: 0        1        2        3
 	 * Field: Reserved Reserved SYSTIML  SYSTIMH
 	 */
+	/* check reserved dwords are zero, be/le doesn't matter for zero */
+	if (regval[0])
+		return IGB_RET_PTP_INVALID;
 	igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb),
 				   le64_to_cpu(regval[1]));
 	}
 	skb_hwtstamps(skb)->hwtstamp =
 		ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);
+	return 0;
 }
 /**
  * This function is meant to retrieve a timestamp from the internal registers
  * of the adapter and store it in the skb.
  **/
-void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector,
+void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector, struct sk_buff *skb)
-			 struct sk_buff *skb)
 {
 	struct igb_adapter *adapter = q_vector->adapter;
 	struct e1000_hw *hw = &adapter->hw;
-	u64 regval;
 	int adjust = 0;
+	u64 regval;
+	if (!(adapter->ptp_flags & IGB_PTP_ENABLED))
+		return;
 	/* If this bit is set, then the RX registers contain the time stamp. No
 	 * other packet will be time stamped until we read these registers, so

drivers/net/ethernet/intel/igc/igc.h+1−1

@@ -547,7 +547,7 @@ void igc_ptp_init(struct igc_adapter *adapter); · 546 unmodified lines
547	void igc_ptp_reset(struct igc_adapter *adapter);	547	void igc_ptp_reset(struct igc_adapter *adapter);
548	void igc_ptp_suspend(struct igc_adapter *adapter);	548	void igc_ptp_suspend(struct igc_adapter *adapter);
549	void igc_ptp_stop(struct igc_adapter *adapter);	549	void igc_ptp_stop(struct igc_adapter *adapter);
550	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, void va,	550	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, __le32 va,
551	struct sk_buff *skb);	551	struct sk_buff *skb);
552	int igc_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);	552	int igc_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);
553	int igc_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);	553	int igc_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);

drivers/net/ethernet/intel/igc/igc_ethtool.c+4−3

 						     Autoneg);
 	}
+	/* Set pause flow control settings */
+	ethtool_link_ksettings_add_link_mode(cmd, supported, Pause);
 	switch (hw->fc.requested_mode) {
 	case igc_fc_full:
 		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
 						     Asym_Pause);
 		break;
 	default:
-		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
+		break;
-		ethtool_link_ksettings_add_link_mode(cmd, advertising,
-						     Asym_Pause);
 	}
 	status = pm_runtime_suspended(&adapter->pdev->dev) ?

drivers/net/ethernet/intel/igc/igc_main.c+9−0

 	adapter = container_of(work, struct igc_adapter, reset_task);
+	rtnl_lock();
+	/* If we're already down or resetting, just bail */
+	if (test_bit(__IGC_DOWN, &adapter->state) ||
+	    test_bit(__IGC_RESETTING, &adapter->state)) {
+		rtnl_unlock();
+		return;
+	}
 	igc_rings_dump(adapter);
 	igc_regs_dump(adapter);
 	netdev_err(adapter->netdev, "Reset adapter\n");
 	igc_reinit_locked(adapter);
+	rtnl_unlock();
 }
 /**

drivers/net/ethernet/intel/igc/igc_ptp.c+40−32

@@ -152,46 +152,54 @@ static void igc_ptp_systim_to_hwtstamp(struct igc_adapter *adapter, · 151 unmodified lines
152	}	152	}
153		153
154	/**	154	/**
155	* igc_ptp_rx_pktstamp - retrieve Rx per packet timestamp	155	* igc_ptp_rx_pktstamp - Retrieve timestamp from Rx packet buffer
156	* @q_vector: Pointer to interrupt specific structure	156	* @q_vector: Pointer to interrupt specific structure
157	* @va: Pointer to address containing Rx buffer	157	* @va: Pointer to address containing Rx buffer
158	* @skb: Buffer containing timestamp and packet	158	* @skb: Buffer containing timestamp and packet
159	*	159	*
160	* This function is meant to retrieve the first timestamp from the	160	* This function retrieves the timestamp saved in the beginning of packet
161	* first buffer of an incoming frame. The value is stored in little	161	* buffer. While two timestamps are available, one in timer0 reference and the
162	* endian format starting on byte 0. There's a second timestamp	162	* other in timer1 reference, this function considers only the timestamp in
163	* starting on byte 8.	163	* timer0 reference.
164	**/	164	*/
165	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, void va,	165	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, __le32 va,
166	struct sk_buff *skb)	166	struct sk_buff *skb)
167	{	167	{
168	struct igc_adapter *adapter = q_vector->adapter;	168	struct igc_adapter *adapter = q_vector->adapter;
169	__le64 regval = (__le64 )va;	169	u64 regval;
170	int adjust = 0;	170	int adjust;
171		171
172	/* The timestamp is recorded in little endian format.	172	/* Timestamps are saved in little endian at the beginning of the packet
173	* DWORD: \| 0 \| 1 \| 2 \| 3	173	* buffer following the layout:
174	* Field: \| Timer0 Low \| Timer0 High \| Timer1 Low \| Timer1 High	174	*
		175	* DWORD: \| 0 \| 1 \| 2 \| 3 \|
		176	* Field: \| Timer1 SYSTIML \| Timer1 SYSTIMH \| Timer0 SYSTIML \| Timer0 SYSTIMH \|
		177	*
		178	* SYSTIML holds the nanoseconds part while SYSTIMH holds the seconds
		179	* part of the timestamp.
175	*/	180	*/
176	igc_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb),	181	regval = le32_to_cpu(va[2]);
177	le64_to_cpu(regval[0]));	182	regval \|= (u64)le32_to_cpu(va[3]) << 32;
178		183	igc_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), regval);
179	/* adjust timestamp for the RX latency based on link speed */	184
180	if (adapter->hw.mac.type == igc_i225) {	185	/* Adjust timestamp for the RX latency based on link speed */
181	switch (adapter->link_speed) {	186	switch (adapter->link_speed) {
182	case SPEED_10:	187	case SPEED_10:
183	adjust = IGC_I225_RX_LATENCY_10;	188	adjust = IGC_I225_RX_LATENCY_10;
184	break;	189	break;
185	case SPEED_100:	190	case SPEED_100:
186	adjust = IGC_I225_RX_LATENCY_100;	191	adjust = IGC_I225_RX_LATENCY_100;
187	break;	192	break;
188	case SPEED_1000:	193	case SPEED_1000:
189	adjust = IGC_I225_RX_LATENCY_1000;	194	adjust = IGC_I225_RX_LATENCY_1000;
190	break;	195	break;
191	case SPEED_2500:	196	case SPEED_2500:
192	adjust = IGC_I225_RX_LATENCY_2500;	197	adjust = IGC_I225_RX_LATENCY_2500;
193	break;	198	break;
194	}	199	default:
		200	adjust = 0;
		201	netdev_warn_once(adapter->netdev, "Imprecise timestamp\n");
		202	break;
195	}	203	}
196	skb_hwtstamps(skb)->hwtstamp =	204	skb_hwtstamps(skb)->hwtstamp =
197	ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);	205	ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+2−1

 #endif
 	}
+	ring->rx_offset = ixgbe_rx_offset(ring);
 	if (ring->xsk_pool && hw->mac.type != ixgbe_mac_82599EB) {
 		u32 xsk_buf_len = xsk_pool_get_rx_frame_size(ring->xsk_pool);
 	rx_ring->next_to_clean = 0;
 	rx_ring->next_to_use = 0;
-	rx_ring->rx_offset = ixgbe_rx_offset(rx_ring);
 	/* XDP RX-queue info */
 	if (xdp_rxq_info_reg(&rx_ring->xdp_rxq, adapter->netdev,

drivers/net/ethernet/marvell/Kconfig+2−2

@@ -6,7 +6,7 @@ · 5 unmodified lines
6	config NET_VENDOR_MARVELL	6	config NET_VENDOR_MARVELL
7	bool "Marvell devices"	7	bool "Marvell devices"
8	default y	8	default y
9	depends on PCI \|\| CPU_PXA168 \|\| MV64X60 \|\| PPC32 \|\| PLAT_ORION \|\| INET \|\| COMPILE_TEST	9	depends on PCI \|\| CPU_PXA168 \|\| PPC32 \|\| PLAT_ORION \|\| INET \|\| COMPILE_TEST
10	help	10	help
11	If you have a network (Ethernet) card belonging to this class, say Y.	11	If you have a network (Ethernet) card belonging to this class, say Y.
12		12
@@ -19,7 +19,7 @@ if NET_VENDOR_MARVELL · 6 unmodified lines
19		19
20	config MV643XX_ETH	20	config MV643XX_ETH
21	tristate "Marvell Discovery (643XX) and Orion ethernet support"	21	tristate "Marvell Discovery (643XX) and Orion ethernet support"
22	depends on MV64X60 \|\| PPC32 \|\| PLAT_ORION \|\| COMPILE_TEST	22	depends on PPC32 \|\| PLAT_ORION \|\| COMPILE_TEST
23	depends on INET	23	depends on INET
24	select PHYLIB	24	select PHYLIB
25	select MVMDIO	25	select MVMDIO

drivers/net/ethernet/marvell/mv643xx_eth.c+1−1

@@ -2684,7 +2684,7 @@ static const struct of_device_id mv643xx_eth_shared_ids[] = { · 2683 unmodified lines
2684	MODULE_DEVICE_TABLE(of, mv643xx_eth_shared_ids);	2684	MODULE_DEVICE_TABLE(of, mv643xx_eth_shared_ids);
2685	#endif	2685	#endif
2686		2686
2687	#if defined(CONFIG_OF_IRQ) && !defined(CONFIG_MV64X60)	2687	#ifdef CONFIG_OF_IRQ
2688	#define mv643xx_eth_property(_np, _name, _v) \	2688	#define mv643xx_eth_property(_np, _name, _v) \
2689	do { \	2689	do { \
2690	u32 tmp; \	2690	u32 tmp; \

drivers/net/ethernet/marvell/octeontx2/af/npc_profile.h+0−2

 			[NPC_LT_LC_IP] = {
 				/* SIP+DIP: 8 bytes, KW2[63:0] */
 				KEX_LD_CFG(0x07, 0xc, 0x1, 0x0, 0x10),
-				/* TOS: 1 byte, KW1[63:56] */
-				KEX_LD_CFG(0x0, 0x1, 0x1, 0x0, 0xf),
 			},
 			/* Layer C: IPv6 */
 			[NPC_LT_LC_IP6] = {

drivers/net/ethernet/marvell/octeontx2/af/rvu.c+4−2

 		    INTR_MASK(rvu->hw->total_pfs) & ~1ULL);
 	for (irq = 0; irq < rvu->num_vec; irq++) {
-		if (rvu->irq_allocated[irq])
+		if (rvu->irq_allocated[irq]) {
 			free_irq(pci_irq_vector(rvu->pdev, irq), rvu);
+			rvu->irq_allocated[irq] = false;
+		}
 	}
 	pci_free_irq_vectors(rvu->pdev);
 	struct rvu *rvu = pci_get_drvdata(pdev);
 	rvu_dbg_exit(rvu);
-	rvu_unregister_interrupts(rvu);
 	rvu_unregister_dl(rvu);
+	rvu_unregister_interrupts(rvu);
 	rvu_flr_wq_destroy(rvu);
 	rvu_cgx_exit(rvu);
 	rvu_fwdata_exit(rvu);

drivers/net/ethernet/marvell/octeontx2/af/rvu.h+1−0

@@ -682,6 +682,7 @@ void npc_read_mcam_entry(struct rvu rvu, struct npc_mcam mcam, · 681 unmodified lines
682	u8 intf, u8 ena);	682	u8 intf, u8 ena);
683	bool is_mac_feature_supported(struct rvu *rvu, int pf, int feature);	683	bool is_mac_feature_supported(struct rvu *rvu, int pf, int feature);
684	u32 rvu_cgx_get_fifolen(struct rvu *rvu);	684	u32 rvu_cgx_get_fifolen(struct rvu *rvu);
		685	void rvu_first_cgx_pdata(struct rvu rvu);
685		686
686	int npc_get_nixlf_mcam_index(struct npc_mcam *mcam, u16 pcifunc, int nixlf,	687	int npc_get_nixlf_mcam_index(struct npc_mcam *mcam, u16 pcifunc, int nixlf,
687	int type);	688	int type);

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c+16−2

 	return rvu->cgx_idmap[cgx_id];
 }
+/* Return first enabled CGX instance if none are enabled then return NULL */
+void *rvu_first_cgx_pdata(struct rvu *rvu)
+{
+	int first_enabled_cgx = 0;
+	void *cgxd = NULL;
+	for (; first_enabled_cgx < rvu->cgx_cnt_max; first_enabled_cgx++) {
+		cgxd = rvu_cgx_pdata(first_enabled_cgx, rvu);
+		if (cgxd)
+			break;
+	}
+	return cgxd;
+}
 /* Based on P2X connectivity find mapped NIX block for a PF */
 static void rvu_map_cgx_nix_block(struct rvu *rvu, int pf,
 				  int cgx_id, int lmac_id)
 u32 rvu_cgx_get_fifolen(struct rvu *rvu)
 {
 	struct mac_ops *mac_ops;
-	int rvu_def_cgx_id = 0;
 	u32 fifo_len;
-	mac_ops = get_mac_ops(rvu_cgx_pdata(rvu_def_cgx_id, rvu));
+	mac_ops = get_mac_ops(rvu_first_cgx_pdata(rvu));
 	fifo_len = mac_ops ? mac_ops->fifo_len : 0;
 	return fifo_len;

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c+36−21

@@ -234,12 +234,14 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 233 unmodified lines
234	char __user *buffer,	234	char __user *buffer,
235	size_t count, loff_t *ppos)	235	size_t count, loff_t *ppos)
236	{	236	{
237	int index, off = 0, flag = 0, go_back = 0, off_prev;	237	int index, off = 0, flag = 0, go_back = 0, len = 0;
238	struct rvu *rvu = filp->private_data;	238	struct rvu *rvu = filp->private_data;
239	int lf, pf, vf, pcifunc;	239	int lf, pf, vf, pcifunc;
240	struct rvu_block block;	240	struct rvu_block block;
241	int bytes_not_copied;	241	int bytes_not_copied;
		242	int lf_str_size = 12;
242	int buf_size = 2048;	243	int buf_size = 2048;
		244	char *lfs;
243	char *buf;	245	char *buf;
244		246
245	/* don't allow partial reads */	247	/* don't allow partial reads */
@@ -249,12 +251,20 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 3 unmodified lines
249	buf = kzalloc(buf_size, GFP_KERNEL);	251	buf = kzalloc(buf_size, GFP_KERNEL);
250	if (!buf)	252	if (!buf)
251	return -ENOSPC;	253	return -ENOSPC;
252	off += scnprintf(&buf[off], buf_size - 1 - off, "\npcifunc\t\t");	254
		255	lfs = kzalloc(lf_str_size, GFP_KERNEL);
		256	if (!lfs) {
		257	kfree(buf);
		258	return -ENOMEM;
		259	}
		260	off += scnprintf(&buf[off], buf_size - 1 - off, "%-*s", lf_str_size,
		261	"pcifunc");
253	for (index = 0; index < BLK_COUNT; index++)	262	for (index = 0; index < BLK_COUNT; index++)
254	if (strlen(rvu->hw->block[index].name))	263	if (strlen(rvu->hw->block[index].name)) {
255	off += scnprintf(&buf[off], buf_size - 1 - off,	264	off += scnprintf(&buf[off], buf_size - 1 - off,
256	"%s\t", (index - 1) 2,	265	"%-*s", lf_str_size,
257	rvu->hw->block[index].name);	266	rvu->hw->block[index].name);
		267	}
258	off += scnprintf(&buf[off], buf_size - 1 - off, "\n");	268	off += scnprintf(&buf[off], buf_size - 1 - off, "\n");
259	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {	269	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {
260	for (vf = 0; vf <= rvu->hw->total_vfs; vf++) {	270	for (vf = 0; vf <= rvu->hw->total_vfs; vf++) {
@@ -263,14 +273,15 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 2 unmodified lines
263	continue;	273	continue;
264		274
265	if (vf) {	275	if (vf) {
		276	sprintf(lfs, "PF%d:VF%d", pf, vf - 1);
266	go_back = scnprintf(&buf[off],	277	go_back = scnprintf(&buf[off],
267	buf_size - 1 - off,	278	buf_size - 1 - off,
268	"PF%d:VF%d\t\t", pf,	279	"%-*s", lf_str_size, lfs);
269	vf - 1);
270	} else {	280	} else {
		281	sprintf(lfs, "PF%d", pf);
271	go_back = scnprintf(&buf[off],	282	go_back = scnprintf(&buf[off],
272	buf_size - 1 - off,	283	buf_size - 1 - off,
273	"PF%d\t\t", pf);	284	"%-*s", lf_str_size, lfs);
274	}	285	}
275		286
276	off += go_back;	287	off += go_back;
@@ -278,20 +289,22 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 1 unmodified line
278	block = rvu->hw->block[index];	289	block = rvu->hw->block[index];
279	if (!strlen(block.name))	290	if (!strlen(block.name))
280	continue;	291	continue;
281	off_prev = off;	292	len = 0;
		293	lfs[len] = '\0';
282	for (lf = 0; lf < block.lf.max; lf++) {	294	for (lf = 0; lf < block.lf.max; lf++) {
283	if (block.fn_map[lf] != pcifunc)	295	if (block.fn_map[lf] != pcifunc)
284	continue;	296	continue;
285	flag = 1;	297	flag = 1;
286	off += scnprintf(&buf[off], buf_size - 1	298	len += sprintf(&lfs[len], "%d,", lf);
287	- off, "%3d,", lf);
288	}	299	}
289	if (flag && off_prev != off)	300
290	off--;	301	if (flag)
291	else	302	len--;
292	go_back++;	303	lfs[len] = '\0';
293	off += scnprintf(&buf[off], buf_size - 1 - off,	304	off += scnprintf(&buf[off], buf_size - 1 - off,
294	"\t");	305	"%-*s", lf_str_size, lfs);
		306	if (!strlen(lfs))
		307	go_back += lf_str_size;
295	}	308	}
296	if (!flag)	309	if (!flag)
297	off -= go_back;	310	off -= go_back;
@@ -303,6 +316,7 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 5 unmodified lines
303	}	316	}
304		317
305	bytes_not_copied = copy_to_user(buffer, buf, off);	318	bytes_not_copied = copy_to_user(buffer, buf, off);
		319	kfree(lfs);
306	kfree(buf);	320	kfree(buf);
307		321
308	if (bytes_not_copied)	322	if (bytes_not_copied)
@@ -319,7 +333,6 @@ static int rvu_dbg_rvu_pf_cgx_map_display(struct seq_file filp, void unused) · 10 unmodified lines
319	struct rvu *rvu = filp->private;	333	struct rvu *rvu = filp->private;
320	struct pci_dev *pdev = NULL;	334	struct pci_dev *pdev = NULL;
321	struct mac_ops *mac_ops;	335	struct mac_ops *mac_ops;
322	int rvu_def_cgx_id = 0;
323	char cgx[10], lmac[10];	336	char cgx[10], lmac[10];
324	struct rvu_pfvf *pfvf;	337	struct rvu_pfvf *pfvf;
325	int pf, domain, blkid;	338	int pf, domain, blkid;
@@ -327,7 +340,10 @@ static int rvu_dbg_rvu_pf_cgx_map_display(struct seq_file filp, void unused) · 1 unmodified line
327	u16 pcifunc;	340	u16 pcifunc;
328		341
329	domain = 2;	342	domain = 2;
330	mac_ops = get_mac_ops(rvu_cgx_pdata(rvu_def_cgx_id, rvu));	343	mac_ops = get_mac_ops(rvu_first_cgx_pdata(rvu));
		344	/* There can be no CGX devices at all */
		345	if (!mac_ops)
		346	return 0;
331	seq_printf(filp, "PCI dev\t\tRVU PF Func\tNIX block\t%s\tLMAC\n",	347	seq_printf(filp, "PCI dev\t\tRVU PF Func\tNIX block\t%s\tLMAC\n",
332	mac_ops->name);	348	mac_ops->name);
333	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {	349	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {
@@ -1818,7 +1834,6 @@ static void rvu_dbg_cgx_init(struct rvu *rvu) · 1484 unmodified lines
1818	{	1834	{
1819	struct mac_ops *mac_ops;	1835	struct mac_ops *mac_ops;
1820	unsigned long lmac_bmap;	1836	unsigned long lmac_bmap;
1821	int rvu_def_cgx_id = 0;
1822	int i, lmac_id;	1837	int i, lmac_id;
1823	char dname[20];	1838	char dname[20];
1824	void *cgx;	1839	void *cgx;
@@ -1826,7 +1841,7 @@ static void rvu_dbg_cgx_init(struct rvu *rvu) · 1 unmodified line
1826	if (!cgx_get_cgxcnt_max())	1841	if (!cgx_get_cgxcnt_max())
1827	return;	1842	return;
1828		1843
1829	mac_ops = get_mac_ops(rvu_cgx_pdata(rvu_def_cgx_id, rvu));	1844	mac_ops = get_mac_ops(rvu_first_cgx_pdata(rvu));
1830	if (!mac_ops)	1845	if (!mac_ops)
1831	return;	1846	return;
1832		1847

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c+1−1

@@ -2630,7 +2630,7 @@ static int set_flowkey_fields(struct nix_rx_flowkey_alg *alg, u32 flow_cfg) · 2629 unmodified lines
2630	struct nix_rx_flowkey_alg *field;	2630	struct nix_rx_flowkey_alg *field;
2631	struct nix_rx_flowkey_alg tmp;	2631	struct nix_rx_flowkey_alg tmp;
2632	u32 key_type, valid_key;	2632	u32 key_type, valid_key;
2633	int l4_key_offset;	2633	int l4_key_offset = 0;
2634		2634
2635	if (!alg)	2635	if (!alg)
2636	return -EINVAL;	2636	return -EINVAL;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc.c+1−1

 		index = find_next_bit(mcam->bmap, mcam->bmap_entries, entry);
 		if (index >= mcam->bmap_entries)
 			break;
+		entry = index + 1;
 		if (mcam->entry2cntr_map[index] != req->cntr)
 			continue;
-		entry = index + 1;
 		npc_unmap_mcam_entry_and_cntr(rvu, mcam, blkaddr,
 					      index, req->cntr);
 	}

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c+3−1

 int otx2_get_all_flows(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,
 		       u32 *rule_locs)
 {
+	u32 rule_cnt = nfc->rule_cnt;
 	u32 location = 0;
 	int idx = 0;
 	int err = 0;
 	nfc->data = pfvf->flow_cfg->ntuple_max_flows;
-	while ((!err || err == -ENOENT) && idx < nfc->rule_cnt) {
+	while ((!err || err == -ENOENT) && idx < rule_cnt) {
 		err = otx2_get_flow(pfvf, nfc, location);
 		if (!err)
 			rule_locs[idx++] = location;
 		location++;
 	}
+	nfc->rule_cnt = rule_cnt;
 	return err;
 }

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c+5−0

 	struct otx2_nic *pf = netdev_priv(netdev);
 	struct otx2_cq_poll *cq_poll = NULL;
 	struct otx2_qset *qset = &pf->qset;
+	struct otx2_rss_info *rss;
 	int qidx, vec, wrk;
 	netif_carrier_off(netdev);
 	/* First stop packet Rx/Tx */
 	otx2_rxtx_enable(pf, false);
+	/* Clear RSS enable flag */
+	rss = &pf->hw.rss_info;
+	rss->enable = false;
 	/* Cleanup Queue IRQ */
 	vec = pci_irq_vector(pf->pdev,
 			     pf->hw.nix_msixoff + NIX_LF_QINT_VEC_START);

drivers/net/ethernet/marvell/pxa168_eth.c+1−1

 	clk_disable_unprepare(pep->clk);
 	mdiobus_unregister(pep->smi_bus);
 	mdiobus_free(pep->smi_bus);
-	unregister_netdev(dev);
 	cancel_work_sync(&pep->tx_timeout_task);
+	unregister_netdev(dev);
 	free_netdev(dev);
 	return 0;
 }

drivers/net/ethernet/mellanox/mlx5/core/en.h+4−3

 				    MLX5_MPWRQ_LOG_WQE_SZ - PAGE_SHIFT : 0)
 #define MLX5_MPWRQ_PAGES_PER_WQE		BIT(MLX5_MPWRQ_WQE_PAGE_ORDER)
-#define MLX5_MTT_OCTW(npages) (ALIGN(npages, 8) / 2)
+#define MLX5_ALIGN_MTTS(mtts)		(ALIGN(mtts, 8))
+#define MLX5_ALIGNED_MTTS_OCTW(mtts)	((mtts) / 2)
+#define MLX5_MTT_OCTW(mtts)		(MLX5_ALIGNED_MTTS_OCTW(MLX5_ALIGN_MTTS(mtts)))
 /* Add another page to MLX5E_REQUIRED_WQE_MTTS as a buffer between
  * WQEs, This page will absorb write overflow by the hardware, when
  * receiving packets larger than MTU. These oversize packets are
  * dropped by the driver at a later stage.
  */
-#define MLX5E_REQUIRED_WQE_MTTS		(ALIGN(MLX5_MPWRQ_PAGES_PER_WQE + 1, 8))
+#define MLX5E_REQUIRED_WQE_MTTS		(MLX5_ALIGN_MTTS(MLX5_MPWRQ_PAGES_PER_WQE + 1))
-#define MLX5E_LOG_ALIGNED_MPWQE_PPW	(ilog2(MLX5E_REQUIRED_WQE_MTTS))
 #define MLX5E_REQUIRED_MTTS(wqes)	(wqes * MLX5E_REQUIRED_WQE_MTTS)
 #define MLX5E_MAX_RQ_NUM_MTTS	\
 	((1 << 16) * 2) /* So that MLX5_MTT_OCTW(num_mtts) fits into u16 */

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

@@ -1181,7 +1181,8 @@ int mlx5_tc_ct_add_no_trk_match(struct mlx5_flow_spec *spec) · 1180 unmodified lines
1181		1181
1182	mlx5e_tc_match_to_reg_get_match(spec, CTSTATE_TO_REG,	1182	mlx5e_tc_match_to_reg_get_match(spec, CTSTATE_TO_REG,
1183	&ctstate, &ctstate_mask);	1183	&ctstate, &ctstate_mask);
1184	if (ctstate_mask)	1184
		1185	if ((ctstate & ctstate_mask) == MLX5_CT_STATE_TRK_BIT)
1185	return -EOPNOTSUPP;	1186	return -EOPNOTSUPP;
1186		1187
1187	ctstate_mask \|= MLX5_CT_STATE_TRK_BIT;	1188	ctstate_mask \|= MLX5_CT_STATE_TRK_BIT;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c+4−4

@@ -685,14 +685,14 @@ int mlx5e_tc_tun_route_lookup(struct mlx5e_priv *priv, · 684 unmodified lines
685	u16 vport_num;	685	u16 vport_num;
686	int err = 0;	686	int err = 0;
687		687
688	if (flow_attr->ip_version == 4) {	688	if (flow_attr->tun_ip_version == 4) {
689	/* Addresses are swapped for decap */	689	/* Addresses are swapped for decap */
690	attr.fl.fl4.saddr = esw_attr->rx_tun_attr->dst_ip.v4;	690	attr.fl.fl4.saddr = esw_attr->rx_tun_attr->dst_ip.v4;
691	attr.fl.fl4.daddr = esw_attr->rx_tun_attr->src_ip.v4;	691	attr.fl.fl4.daddr = esw_attr->rx_tun_attr->src_ip.v4;
692	err = mlx5e_route_lookup_ipv4_get(priv, priv->netdev, &attr);	692	err = mlx5e_route_lookup_ipv4_get(priv, priv->netdev, &attr);
693	}	693	}
694	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)	694	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)
695	else if (flow_attr->ip_version == 6) {	695	else if (flow_attr->tun_ip_version == 6) {
696	/* Addresses are swapped for decap */	696	/* Addresses are swapped for decap */
697	attr.fl.fl6.saddr = esw_attr->rx_tun_attr->dst_ip.v6;	697	attr.fl.fl6.saddr = esw_attr->rx_tun_attr->dst_ip.v6;
698	attr.fl.fl6.daddr = esw_attr->rx_tun_attr->src_ip.v6;	698	attr.fl.fl6.daddr = esw_attr->rx_tun_attr->src_ip.v6;
@@ -718,10 +718,10 @@ int mlx5e_tc_tun_route_lookup(struct mlx5e_priv *priv, · 19 unmodified lines
718	esw_attr->rx_tun_attr->decap_vport = vport_num;	718	esw_attr->rx_tun_attr->decap_vport = vport_num;
719		719
720	out:	720	out:
721	if (flow_attr->ip_version == 4)	721	if (flow_attr->tun_ip_version == 4)
722	mlx5e_route_lookup_ipv4_put(&attr);	722	mlx5e_route_lookup_ipv4_put(&attr);
723	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)	723	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)
724	else if (flow_attr->ip_version == 6)	724	else if (flow_attr->tun_ip_version == 6)
725	mlx5e_route_lookup_ipv6_put(&attr);	725	mlx5e_route_lookup_ipv6_put(&attr);
726	#endif	726	#endif
727	return err;	727	return err;

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

 	 * required to establish routing.
 	 */
 	flow_flag_set(flow, TUN_RX);
+	flow->attr->tun_ip_version = ip_version;
 	return 0;
 }
 	if (err || !esw_attr->rx_tun_attr->decap_vport)
 		goto out;
-	key.ip_version = attr->ip_version;
+	key.ip_version = attr->tun_ip_version;
 	if (key.ip_version == 4)
 		key.endpoint_ip.v4 = esw_attr->rx_tun_attr->dst_ip.v4;
 	else

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_geneve.c+4−0

 	option_key = (struct geneve_opt *)&enc_opts.key->data[0];
 	option_mask = (struct geneve_opt *)&enc_opts.mask->data[0];
+	if (option_mask->opt_class == 0 && option_mask->type == 0 &&
+	    !memchr_inv(option_mask->opt_data, 0, option_mask->length * 4))
+		return 0;
 	if (option_key->length > max_tlv_option_data_len) {
 		NL_SET_ERR_MSG_MOD(extack,
 				   "Matching on GENEVE options: unsupported option len");

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+10−1

 {
 	struct mlx5e_priv *priv = netdev_priv(netdev);
 	struct mlx5_core_dev *mdev = priv->mdev;
+	int err;
 	if (!MLX5_CAP_GEN(mdev, cqe_compression))
 		return -EOPNOTSUPP;
 		return -EINVAL;
 	}
-	mlx5e_modify_rx_cqe_compression_locked(priv, enable);
+	err = mlx5e_modify_rx_cqe_compression_locked(priv, enable);
+	if (err)
+		return err;
 	priv->channels.params.rx_cqe_compress_def = enable;
 	return 0;
 	 */
 	if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
+		struct mlx5e_params old_params;
+		old_params = priv->channels.params;
 		priv->channels.params = new_channels.params;
 		err = mlx5e_num_channels_changed(priv);
+		if (err)
+			priv->channels.params = old_params;
 		goto out;
 	}

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+57−24

 				     rq->wqe_overflow.addr);
 }
-static inline u64 mlx5e_get_mpwqe_offset(struct mlx5e_rq *rq, u16 wqe_ix)
+static u64 mlx5e_get_mpwqe_offset(u16 wqe_ix)
 {
-	return (wqe_ix << MLX5E_LOG_ALIGNED_MPWQE_PPW) << PAGE_SHIFT;
+	return MLX5E_REQUIRED_MTTS(wqe_ix) << PAGE_SHIFT;
 }
 static void mlx5e_init_frags_partition(struct mlx5e_rq *rq)
 				mlx5_wq_ll_get_wqe(&rq->mpwqe.wq, i);
 			u32 byte_count =
 				rq->mpwqe.num_strides << rq->mpwqe.log_stride_sz;
-			u64 dma_offset = mlx5e_get_mpwqe_offset(rq, i);
+			u64 dma_offset = mlx5e_get_mpwqe_offset(i);
 			wqe->data[0].addr = cpu_to_be64(dma_offset + rq->buff.headroom);
 			wqe->data[0].byte_count = cpu_to_be32(byte_count);
 {
 	switch (params->rq_wq_type) {
 	case MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ:
-		return order_base_2(MLX5E_UMR_WQEBBS) +
+		return max_t(u8, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE,
-			mlx5e_get_rq_log_wq_sz(rqp->rqc);
+			     order_base_2(MLX5E_UMR_WQEBBS) +
+			     mlx5e_get_rq_log_wq_sz(rqp->rqc));
 	default: /* MLX5_WQ_TYPE_CYCLIC */
 		return MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE;
 	}
 {
 	int i;
-	if (chs->port_ptp)
+	if (chs->port_ptp) {
 		mlx5e_port_ptp_close(chs->port_ptp);
+		chs->port_ptp = NULL;
+	}
 	for (i = 0; i < chs->num; i++)
 		mlx5e_close_channel(chs->c[i]);
 		for (j = 0; j < priv->max_opened_tc; j++) {
 			struct mlx5e_sq_stats *sq_stats = &channel_stats->sq[j];
+			s->tx_packets    += sq_stats->packets;
+			s->tx_bytes      += sq_stats->bytes;
+			s->tx_dropped    += sq_stats->dropped;
+		}
+	}
+	if (priv->port_ptp_opened) {
+		for (i = 0; i < priv->max_opened_tc; i++) {
+			struct mlx5e_sq_stats *sq_stats = &priv->port_ptp_stats.sq[i];
 			s->tx_packets    += sq_stats->packets;
 			s->tx_bytes      += sq_stats->bytes;
 			s->tx_dropped    += sq_stats->dropped;
 	}
 	if (mlx5e_is_uplink_rep(priv)) {
+		struct mlx5e_vport_stats *vstats = &priv->stats.vport;
 		stats->rx_packets = PPORT_802_3_GET(pstats, a_frames_received_ok);
 		stats->rx_bytes   = PPORT_802_3_GET(pstats, a_octets_received_ok);
 		stats->tx_packets = PPORT_802_3_GET(pstats, a_frames_transmitted_ok);
 		stats->tx_bytes   = PPORT_802_3_GET(pstats, a_octets_transmitted_ok);
+		/* vport multicast also counts packets that are dropped due to steering
+		 * or rx out of buffer
+		 */
+		stats->multicast = VPORT_COUNTER_GET(vstats, received_eth_multicast.packets);
 	} else {
 		mlx5e_fold_sw_stats64(priv, stats);
 	}
 		struct mlx5e_channel *c = priv->channels.c[i];
 		mlx5e_rq_replace_xdp_prog(&c->rq, prog);
-		if (test_bit(MLX5E_CHANNEL_STATE_XSK, c->state))
+		if (test_bit(MLX5E_CHANNEL_STATE_XSK, c->state)) {
+			bpf_prog_inc(prog);
 			mlx5e_rq_replace_xdp_prog(&c->xskrq, prog);
+		}
 	}
 unlock:
 				     priv->max_nch);
 	params->num_tc       = 1;
+	/* Set an initial non-zero value, so that mlx5e_select_queue won't
+	 * divide by zero if called before first activating channels.
+	 */
+	priv->num_tc_x_num_ch = params->num_channels * params->num_tc;
 	/* SQ */
 	params->log_sq_size = is_kdump_kernel() ?
 		MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE :
 		    struct net_device *netdev,
 		    struct mlx5_core_dev *mdev)
 {
-	memset(priv, 0, sizeof(*priv));
 	/* priv init */
 	priv->mdev        = mdev;
 	priv->netdev      = netdev;
 {
 	int i;
+	/* bail if change profile failed and also rollback failed */
+	if (!priv->mdev)
+		return;
 	destroy_workqueue(priv->wq);
 	free_cpumask_var(priv->scratchpad.cpumask);
 	for (i = 0; i < priv->htb.max_qos_sqs; i++)
 		kfree(priv->htb.qos_sq_stats[i]);
 	kvfree(priv->htb.qos_sq_stats);
+	memset(priv, 0, sizeof(*priv));
 }
 struct net_device *
 }
 static int
-mlx5e_netdev_attach_profile(struct mlx5e_priv *priv,
+mlx5e_netdev_attach_profile(struct net_device *netdev, struct mlx5_core_dev *mdev,
 			    const struct mlx5e_profile *new_profile, void *new_ppriv)
 {
-	struct net_device *netdev = priv->netdev;
+	struct mlx5e_priv *priv = netdev_priv(netdev);
-	struct mlx5_core_dev *mdev = priv->mdev;
 	int err;
 	err = mlx5e_priv_init(priv, netdev, mdev);
 	priv->ppriv = new_ppriv;
 	err = new_profile->init(priv->mdev, priv->netdev);
 	if (err)
-		return err;
+		goto priv_cleanup;
 	err = mlx5e_attach_netdev(priv);
 	if (err)
-		new_profile->cleanup(priv);
+		goto profile_cleanup;
+	return err;
+profile_cleanup:
+	new_profile->cleanup(priv);
+priv_cleanup:
+	mlx5e_priv_cleanup(priv);
 	return err;
 }
 {
 	unsigned int new_max_nch = mlx5e_calc_max_nch(priv, new_profile);
 	const struct mlx5e_profile *orig_profile = priv->profile;
+	struct net_device *netdev = priv->netdev;
+	struct mlx5_core_dev *mdev = priv->mdev;
 	void *orig_ppriv = priv->ppriv;
 	int err, rollback_err;
 	/* sanity */
 	if (new_max_nch != priv->max_nch) {
-		netdev_warn(priv->netdev,
+		netdev_warn(netdev, "%s: Replacing profile with different max channels\n",
-			    "%s: Replacing profile with different max channels\n",
 			    __func__);
 		return -EINVAL;
 	}
 	priv->profile->cleanup(priv);
 	mlx5e_priv_cleanup(priv);
-	err = mlx5e_netdev_attach_profile(priv, new_profile, new_ppriv);
+	err = mlx5e_netdev_attach_profile(netdev, mdev, new_profile, new_ppriv);
 	if (err) { /* roll back to original profile */
-		netdev_warn(priv->netdev, "%s: new profile init failed, %d\n",
+		netdev_warn(netdev, "%s: new profile init failed, %d\n", __func__, err);
-			    __func__, err);
 		goto rollback;
 	}
 	return 0;
 rollback:
-	rollback_err = mlx5e_netdev_attach_profile(priv, orig_profile, orig_ppriv);
+	rollback_err = mlx5e_netdev_attach_profile(netdev, mdev, orig_profile, orig_ppriv);
-	if (rollback_err) {
+	if (rollback_err)
-		netdev_err(priv->netdev,
+		netdev_err(netdev, "%s: failed to rollback to orig profile, %d\n",
-			   "%s: failed to rollback to orig profile, %d\n",
 			   __func__, rollback_err);
-	}
 	return err;
 }

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

 	struct mlx5e_icosq *sq = rq->icosq;
 	struct mlx5_wq_cyc *wq = &sq->wq;
 	struct mlx5e_umr_wqe *umr_wqe;
-	u16 xlt_offset = ix << (MLX5E_LOG_ALIGNED_MPWQE_PPW - 1);
 	u16 pi;
 	int err;
 	int i;
 	umr_wqe->ctrl.opmod_idx_opcode =
 		cpu_to_be32((sq->pc << MLX5_WQE_CTRL_WQE_INDEX_SHIFT) |
 			    MLX5_OPCODE_UMR);
-	umr_wqe->uctrl.xlt_offset = cpu_to_be16(xlt_offset);
+	umr_wqe->uctrl.xlt_offset =
+		cpu_to_be16(MLX5_ALIGNED_MTTS_OCTW(MLX5E_REQUIRED_MTTS(ix)));
 	sq->db.wqe_info[pi] = (struct mlx5e_icosq_wqe_info) {
 		.wqe_type   = MLX5E_ICOSQ_WQE_UMR_RX,

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+45−12

@@ -2357,6 +2357,16 @@ static int __parse_cls_flower(struct mlx5e_priv *priv, · 2356 unmodified lines
2357	spec->match_criteria_enable \|= MLX5_MATCH_MISC_PARAMETERS_3;	2357	spec->match_criteria_enable \|= MLX5_MATCH_MISC_PARAMETERS_3;
2358	}	2358	}
2359	}	2359	}
		2360	/* Currenlty supported only for MPLS over UDP */
		2361	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_MPLS) &&
		2362	!netif_is_bareudp(filter_dev)) {
		2363	NL_SET_ERR_MSG_MOD(extack,
		2364	"Matching on MPLS is supported only for MPLS over UDP");
		2365	netdev_err(priv->netdev,
		2366	"Matching on MPLS is supported only for MPLS over UDP\n");
		2367	return -EOPNOTSUPP;
		2368	}
		2369
2360	return 0;	2370	return 0;
2361	}	2371	}
2362		2372
@@ -2960,6 +2970,37 @@ static int is_action_keys_supported(const struct flow_action_entry *act, · 597 unmodified lines
2960	return 0;	2970	return 0;
2961	}	2971	}
2962		2972
		2973	static bool modify_tuple_supported(bool modify_tuple, bool ct_clear,
		2974	bool ct_flow, struct netlink_ext_ack *extack,
		2975	struct mlx5e_priv *priv,
		2976	struct mlx5_flow_spec *spec)
		2977	{
		2978	if (!modify_tuple \|\| ct_clear)
		2979	return true;
		2980
		2981	if (ct_flow) {
		2982	NL_SET_ERR_MSG_MOD(extack,
		2983	"can't offload tuple modification with non-clear ct()");
		2984	netdev_info(priv->netdev,
		2985	"can't offload tuple modification with non-clear ct()");
		2986	return false;
		2987	}
		2988
		2989	/* Add ct_state=-trk match so it will be offloaded for non ct flows
		2990	* (or after clear action), as otherwise, since the tuple is changed,
		2991	* we can't restore ct state
		2992	*/
		2993	if (mlx5_tc_ct_add_no_trk_match(spec)) {
		2994	NL_SET_ERR_MSG_MOD(extack,
		2995	"can't offload tuple modification with ct matches and no ct(clear) action");
		2996	netdev_info(priv->netdev,
		2997	"can't offload tuple modification with ct matches and no ct(clear) action");
		2998	return false;
		2999	}
		3000
		3001	return true;
		3002	}
		3003
2963	static bool modify_header_match_supported(struct mlx5e_priv *priv,	3004	static bool modify_header_match_supported(struct mlx5e_priv *priv,
2964	struct mlx5_flow_spec *spec,	3005	struct mlx5_flow_spec *spec,
2965	struct flow_action *flow_action,	3006	struct flow_action *flow_action,
@@ -2998,18 +3039,9 @@ static bool modify_header_match_supported(struct mlx5e_priv *priv, · 32 unmodified lines
2998	return err;	3039	return err;
2999	}	3040	}
3000		3041
3001	/* Add ct_state=-trk match so it will be offloaded for non ct flows	3042	if (!modify_tuple_supported(modify_tuple, ct_clear, ct_flow, extack,
3002	* (or after clear action), as otherwise, since the tuple is changed,	3043	priv, spec))
3003	* we can't restore ct state
3004	*/
3005	if (!ct_clear && modify_tuple &&
3006	mlx5_tc_ct_add_no_trk_match(spec)) {
3007	NL_SET_ERR_MSG_MOD(extack,
3008	"can't offload tuple modify header with ct matches");
3009	netdev_info(priv->netdev,
3010	"can't offload tuple modify header with ct matches");
3011	return false;	3044	return false;
3012	}
3013		3045
3014	ip_proto = MLX5_GET(fte_match_set_lyr_2_4, headers_v, ip_protocol);	3046	ip_proto = MLX5_GET(fte_match_set_lyr_2_4, headers_v, ip_protocol);
3015	if (modify_ip_header && ip_proto != IPPROTO_TCP &&	3047	if (modify_ip_header && ip_proto != IPPROTO_TCP &&
@@ -4512,7 +4544,8 @@ static int apply_police_params(struct mlx5e_priv *priv, u64 rate, · 1496 unmodified lines
4512	*/	4544	*/
4513	if (rate) {	4545	if (rate) {
4514	rate = (rate * BITS_PER_BYTE) + 500000;	4546	rate = (rate * BITS_PER_BYTE) + 500000;
4515	rate_mbps = max_t(u64, do_div(rate, 1000000), 1);	4547	do_div(rate, 1000000);
		4548	rate_mbps = max_t(u32, rate, 1);
4516	}	4549	}
4517		4550
4518	err = mlx5_esw_modify_vport_rate(esw, vport_num, rate_mbps);	4551	err = mlx5_esw_modify_vport_rate(esw, vport_num, rate_mbps);

drivers/net/ethernet/mellanox/mlx5/core/en_tc.h+1−0

@@ -79,6 +79,7 @@ struct mlx5_flow_attr { · 78 unmodified lines
79	u8 inner_match_level;	79	u8 inner_match_level;
80	u8 outer_match_level;	80	u8 outer_match_level;
81	u8 ip_version;	81	u8 ip_version;
		82	u8 tun_ip_version;
82	u32 flags;	83	u32 flags;
83	union {	84	union {
84	struct mlx5_esw_flow_attr esw_attr[0];	85	struct mlx5_esw_flow_attr esw_attr[0];

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

@@ -550,7 +550,8 @@ esw_setup_dests(struct mlx5_flow_destination *dest, · 549 unmodified lines
550		550
551	if (!mlx5_eswitch_termtbl_required(esw, attr, flow_act, spec) &&	551	if (!mlx5_eswitch_termtbl_required(esw, attr, flow_act, spec) &&
552	MLX5_CAP_GEN(esw_attr->in_mdev, reg_c_preserve) &&	552	MLX5_CAP_GEN(esw_attr->in_mdev, reg_c_preserve) &&
553	mlx5_eswitch_vport_match_metadata_enabled(esw))	553	mlx5_eswitch_vport_match_metadata_enabled(esw) &&
		554	MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, ignore_flow_level))
554	attr->flags \|= MLX5_ESW_ATTR_FLAG_SRC_REWRITE;	555	attr->flags \|= MLX5_ESW_ATTR_FLAG_SRC_REWRITE;
555		556
556	if (attr->dest_ft) {	557	if (attr->dest_ft) {

drivers/net/ethernet/mellanox/mlx5/core/fpga/conn.c+1−0

@@ -575,6 +575,7 @@ static int mlx5_fpga_conn_create_qp(struct mlx5_fpga_conn *conn, · 574 unmodified lines
575	MLX5_SET(qpc, qpc, log_sq_size, ilog2(conn->qp.sq.size));	575	MLX5_SET(qpc, qpc, log_sq_size, ilog2(conn->qp.sq.size));
576	MLX5_SET(qpc, qpc, cqn_snd, conn->cq.mcq.cqn);	576	MLX5_SET(qpc, qpc, cqn_snd, conn->cq.mcq.cqn);
577	MLX5_SET(qpc, qpc, cqn_rcv, conn->cq.mcq.cqn);	577	MLX5_SET(qpc, qpc, cqn_rcv, conn->cq.mcq.cqn);
		578	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(mdev));
578	MLX5_SET64(qpc, qpc, dbr_addr, conn->qp.wq_ctrl.db.dma);	579	MLX5_SET64(qpc, qpc, dbr_addr, conn->qp.wq_ctrl.db.dma);
579	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)	580	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)
580	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);	581	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);

drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c+3−1

 	}
 	qpc = MLX5_ADDR_OF(create_qp_in, in, qpc);
+	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(priv->mdev));
 	MLX5_SET(qpc, qpc, st, MLX5_QP_ST_UD);
 	MLX5_SET(qpc, qpc, pm_state, MLX5_QP_PM_MIGRATED);
 	MLX5_SET(qpc, qpc, ulp_stateless_offload_mode,
 static void mlx5_rdma_netdev_free(struct net_device *netdev)
 {
 	struct mlx5e_priv *priv = mlx5i_epriv(netdev);
+	struct mlx5_core_dev *mdev = priv->mdev;
 	struct mlx5i_priv *ipriv = priv->ppriv;
 	const struct mlx5e_profile *profile = priv->profile;
 	if (!ipriv->sub_interface) {
 		mlx5i_pkey_qpn_ht_cleanup(netdev);
-		mlx5e_destroy_mdev_resources(priv->mdev);
+		mlx5e_destroy_mdev_resources(mdev);
 	}
 }

drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c+4−4

 		return -EINVAL;
 	field_select = MLX5_MTPPS_FS_ENABLE;
+	pin = ptp_find_pin(clock->ptp, PTP_PF_PEROUT, rq->perout.index);
+	if (pin < 0)
+		return -EBUSY;
 	if (on) {
 		bool rt_mode = mlx5_real_time_mode(mdev);
 		u32 nsec;
 		s64 sec;
-		pin = ptp_find_pin(clock->ptp, PTP_PF_PEROUT, rq->perout.index);
-		if (pin < 0)
-			return -EBUSY;
 		pin_mode = MLX5_PIN_MODE_OUT;
 		pattern = MLX5_OUT_PATTERN_PERIODIC;
 		ts.tv_sec = rq->perout.period.sec;

drivers/net/ethernet/mellanox/mlx5/core/sf/dev/dev.c+1−3

 	u16 max_functions;
 	u16 function_id;
 	int err = 0;
-	bool ecpu;
 	int i;
 	max_functions = mlx5_sf_max_functions(dev);
 	function_id = MLX5_CAP_GEN(dev, sf_base_id);
-	ecpu = mlx5_read_embedded_cpu(dev);
 	/* Arm the vhca context as the vhca event notifier */
 	for (i = 0; i < max_functions; i++) {
-		err = mlx5_vhca_event_arm(dev, function_id, ecpu);
+		err = mlx5_vhca_event_arm(dev, function_id);
 		if (err)
 			return err;

drivers/net/ethernet/mellanox/mlx5/core/sf/hw_table.c+5−5

 #include "sf.h"
 #include "mlx5_ifc_vhca_event.h"
 #include "ecpf.h"
+#include "vhca_event.h"
+#include "mlx5_core.h"
 struct mlx5_sf_hw {
 	u32 usr_sfnum;
 	struct mlx5_core_dev *dev;
 	struct mlx5_sf_hw *sfs;
 	int max_local_functions;
-	u8 ecpu: 1;
 	struct mutex table_lock; /* Serializes sf deletion and vhca state change handler. */
 	struct notifier_block vhca_nb;
 };
 	}
 	if (sw_id == -ENOSPC) {
 		err = -ENOSPC;
-		goto err;
+		goto exist_err;
 	}
 	hw_fn_id = mlx5_sf_sw_to_hw_id(table->dev, sw_id);
 	if (err)
 		goto err;
-	err = mlx5_modify_vhca_sw_id(dev, hw_fn_id, table->ecpu, usr_sfnum);
+	err = mlx5_modify_vhca_sw_id(dev, hw_fn_id, usr_sfnum);
 	if (err)
 		goto vhca_err;
 	hw_fn_id = mlx5_sf_sw_to_hw_id(dev, id);
 	mutex_lock(&table->table_lock);
-	err = mlx5_cmd_query_vhca_state(dev, hw_fn_id, table->ecpu, out, sizeof(out));
+	err = mlx5_cmd_query_vhca_state(dev, hw_fn_id, out, sizeof(out));
 	if (err)
 		goto err;
 	state = MLX5_GET(query_vhca_state_out, out, vhca_state_context.vhca_state);
 	table->dev = dev;
 	table->sfs = sfs;
 	table->max_local_functions = max_functions;
-	table->ecpu = mlx5_read_embedded_cpu(dev);
 	dev->priv.sf_hw_table = table;
 	mlx5_core_dbg(dev, "SF HW table: max sfs = %d\n", max_functions);
 	return 0;

drivers/net/ethernet/mellanox/mlx5/core/sf/mlx5_ifc_vhca_event.h+1−1

@@ -20,7 +20,7 @@ struct mlx5_ifc_vhca_state_context_bits { · 19 unmodified lines
20		20
21	u8 sw_function_id[0x20];	21	u8 sw_function_id[0x20];
22		22
23	u8 reserved_at_40[0x80];	23	u8 reserved_at_40[0x40];
24	};	24	};
25		25
26	struct mlx5_ifc_query_vhca_state_out_bits {	26	struct mlx5_ifc_query_vhca_state_out_bits {

drivers/net/ethernet/mellanox/mlx5/core/sf/vhca_event.c+11−12

 	struct mlx5_vhca_state_event event;
 };
-int mlx5_cmd_query_vhca_state(struct mlx5_core_dev *dev, u16 function_id,
+int mlx5_cmd_query_vhca_state(struct mlx5_core_dev *dev, u16 function_id, u32 *out, u32 outlen)
-			      bool ecpu, u32 *out, u32 outlen)
 {
 	u32 in[MLX5_ST_SZ_DW(query_vhca_state_in)] = {};
 	MLX5_SET(query_vhca_state_in, in, opcode, MLX5_CMD_OP_QUERY_VHCA_STATE);
 	MLX5_SET(query_vhca_state_in, in, function_id, function_id);
-	MLX5_SET(query_vhca_state_in, in, embedded_cpu_function, ecpu);
+	MLX5_SET(query_vhca_state_in, in, embedded_cpu_function, 0);
 	return mlx5_cmd_exec(dev, in, sizeof(in), out, outlen);
 }
 static int mlx5_cmd_modify_vhca_state(struct mlx5_core_dev *dev, u16 function_id,
-				      bool ecpu, u32 *in, u32 inlen)
+				      u32 *in, u32 inlen)
 {
 	u32 out[MLX5_ST_SZ_DW(modify_vhca_state_out)] = {};
 	MLX5_SET(modify_vhca_state_in, in, opcode, MLX5_CMD_OP_MODIFY_VHCA_STATE);
 	MLX5_SET(modify_vhca_state_in, in, function_id, function_id);
-	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, ecpu);
+	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, 0);
 	return mlx5_cmd_exec(dev, in, inlen, out, sizeof(out));
 }
-int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, bool ecpu, u32 sw_fn_id)
+int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, u32 sw_fn_id)
 {
 	u32 out[MLX5_ST_SZ_DW(modify_vhca_state_out)] = {};
 	u32 in[MLX5_ST_SZ_DW(modify_vhca_state_in)] = {};
 	MLX5_SET(modify_vhca_state_in, in, opcode, MLX5_CMD_OP_MODIFY_VHCA_STATE);
 	MLX5_SET(modify_vhca_state_in, in, function_id, function_id);
-	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, ecpu);
+	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, 0);
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_field_select.sw_function_id, 1);
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_context.sw_function_id, sw_fn_id);
 	return mlx5_cmd_exec_inout(dev, modify_vhca_state, in, out);
 }
-int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id, bool ecpu)
+int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id)
 {
 	u32 in[MLX5_ST_SZ_DW(modify_vhca_state_in)] = {};
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_context.arm_change_event, 1);
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_field_select.arm_change_event, 1);
-	return mlx5_cmd_modify_vhca_state(dev, function_id, ecpu, in, sizeof(in));
+	return mlx5_cmd_modify_vhca_state(dev, function_id, in, sizeof(in));
 }
 static void
 	u32 out[MLX5_ST_SZ_DW(query_vhca_state_out)] = {};
 	int err;
-	err = mlx5_cmd_query_vhca_state(dev, event->function_id, event->ecpu, out, sizeof(out));
+	err = mlx5_cmd_query_vhca_state(dev, event->function_id, out, sizeof(out));
 	if (err)
 		return;
 	event->new_vhca_state = MLX5_GET(query_vhca_state_out, out,
 					 vhca_state_context.vhca_state);
-	mlx5_vhca_event_arm(dev, event->function_id, event->ecpu);
+	mlx5_vhca_event_arm(dev, event->function_id);
 	blocking_notifier_call_chain(&dev->priv.vhca_state_notifier->n_head, 0, event);
 }
 	struct mlx5_core_dev *dev = notifier->dev;
 	mlx5_vhca_event_notify(dev, &work->event);
+	kfree(work);
 }
 static int
 	INIT_WORK(&work->work, &mlx5_vhca_state_work_handler);
 	work->notifier = notifier;
 	work->event.function_id = be16_to_cpu(eqe->data.vhca_state.function_id);
-	work->event.ecpu = be16_to_cpu(eqe->data.vhca_state.ec_function);
 	mlx5_events_work_enqueue(notifier->dev, &work->work);
 	return NOTIFY_OK;
 }

drivers/net/ethernet/mellanox/mlx5/core/sf/vhca_event.h+3−4

 	u16 function_id;
 	u16 sw_function_id;
 	u8 new_vhca_state;
-	bool ecpu;
 };
 static inline bool mlx5_vhca_event_supported(const struct mlx5_core_dev *dev)
 void mlx5_vhca_event_stop(struct mlx5_core_dev *dev);
 int mlx5_vhca_event_notifier_register(struct mlx5_core_dev *dev, struct notifier_block *nb);
 void mlx5_vhca_event_notifier_unregister(struct mlx5_core_dev *dev, struct notifier_block *nb);
-int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, bool ecpu, u32 sw_fn_id);
+int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, u32 sw_fn_id);
-int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id, bool ecpu);
+int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id);
 int mlx5_cmd_query_vhca_state(struct mlx5_core_dev *dev, u16 function_id,
-			      bool ecpu, u32 *out, u32 outlen);
+			      u32 *out, u32 outlen);
 #else
 static inline void mlx5_vhca_state_cap_handle(struct mlx5_core_dev *dev, void *set_hca_cap)

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

@@ -169,6 +169,7 @@ static struct mlx5dr_qp dr_create_rc_qp(struct mlx5_core_dev mdev, · 168 unmodified lines
169	MLX5_SET(qpc, qpc, log_rq_size, ilog2(dr_qp->rq.wqe_cnt));	169	MLX5_SET(qpc, qpc, log_rq_size, ilog2(dr_qp->rq.wqe_cnt));
170	MLX5_SET(qpc, qpc, rq_type, MLX5_NON_ZERO_RQ);	170	MLX5_SET(qpc, qpc, rq_type, MLX5_NON_ZERO_RQ);
171	MLX5_SET(qpc, qpc, log_sq_size, ilog2(dr_qp->sq.wqe_cnt));	171	MLX5_SET(qpc, qpc, log_sq_size, ilog2(dr_qp->sq.wqe_cnt));
		172	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(mdev));
172	MLX5_SET64(qpc, qpc, dbr_addr, dr_qp->wq_ctrl.db.dma);	173	MLX5_SET64(qpc, qpc, dbr_addr, dr_qp->wq_ctrl.db.dma);
173	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)	174	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)
174	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);	175	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);

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

@@ -264,8 +264,8 @@ static void dr_ste_v1_set_miss_addr(u8 *hw_ste_p, u64 miss_addr) · 263 unmodified lines
264	static u64 dr_ste_v1_get_miss_addr(u8 *hw_ste_p)	264	static u64 dr_ste_v1_get_miss_addr(u8 *hw_ste_p)
265	{	265	{
266	u64 index =	266	u64 index =
267	(MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_31_6) \|	267	((u64)MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_31_6) \|
268	MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_39_32) << 26);	268	((u64)MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_39_32)) << 26);
269		269
270	return index << 6;	270	return index << 6;
271	}	271	}

drivers/net/ethernet/netronome/nfp/flower/metadata.c+17−7

 		goto err_free_ctx_entry;
 	}
+	/* Do net allocate a mask-id for pre_tun_rules. These flows are used to
+	 * configure the pre_tun table and are never actually send to the
+	 * firmware as an add-flow message. This causes the mask-id allocation
+	 * on the firmware to get out of sync if allocated here.
+	 */
 	new_mask_id = 0;
-	if (!nfp_check_mask_add(app, nfp_flow->mask_data,
+	if (!nfp_flow->pre_tun_rule.dev &&
+	    !nfp_check_mask_add(app, nfp_flow->mask_data,
 				nfp_flow->meta.mask_len,
 				&nfp_flow->meta.flags, &new_mask_id)) {
 		NL_SET_ERR_MSG_MOD(extack, "invalid entry: cannot allocate a new mask id");
 			goto err_remove_mask;
 		}
-		if (!nfp_check_mask_remove(app, nfp_flow->mask_data,
+		if (!nfp_flow->pre_tun_rule.dev &&
+		    !nfp_check_mask_remove(app, nfp_flow->mask_data,
 					   nfp_flow->meta.mask_len,
 					   NULL, &new_mask_id)) {
 			NL_SET_ERR_MSG_MOD(extack, "invalid entry: cannot release mask id");
 	return 0;
 err_remove_mask:
-	nfp_check_mask_remove(app, nfp_flow->mask_data, nfp_flow->meta.mask_len,
+	if (!nfp_flow->pre_tun_rule.dev)
-			      NULL, &new_mask_id);
+		nfp_check_mask_remove(app, nfp_flow->mask_data,
+				      nfp_flow->meta.mask_len,
+				      NULL, &new_mask_id);
 err_remove_rhash:
 	WARN_ON_ONCE(rhashtable_remove_fast(&priv->stats_ctx_table,
 					    &ctx_entry->ht_node,
 	__nfp_modify_flow_metadata(priv, nfp_flow);
-	nfp_check_mask_remove(app, nfp_flow->mask_data,
+	if (!nfp_flow->pre_tun_rule.dev)
-			      nfp_flow->meta.mask_len, &nfp_flow->meta.flags,
+		nfp_check_mask_remove(app, nfp_flow->mask_data,
-			      &new_mask_id);
+				      nfp_flow->meta.mask_len, &nfp_flow->meta.flags,
+				      &new_mask_id);
 	/* Update flow payload with mask ids. */
 	nfp_flow->unmasked_data[NFP_FL_MASK_ID_LOCATION] = new_mask_id;

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

 		return -EOPNOTSUPP;
 	}
+	if (!(key_layer & NFP_FLOWER_LAYER_IPV4) &&
+	    !(key_layer & NFP_FLOWER_LAYER_IPV6)) {
+		NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: match on ipv4/ipv6 eth_type must be present");
+		return -EOPNOTSUPP;
+	}
 	/* Skip fields known to exist. */
 	mask += sizeof(struct nfp_flower_meta_tci);
 	ext += sizeof(struct nfp_flower_meta_tci);
 	mask += sizeof(struct nfp_flower_in_port);
 	ext += sizeof(struct nfp_flower_in_port);
+	/* Ensure destination MAC address matches pre_tun_dev. */
+	mac = (struct nfp_flower_mac_mpls *)ext;
+	if (memcmp(&mac->mac_dst[0], flow->pre_tun_rule.dev->dev_addr, 6)) {
+		NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: dest MAC must match output dev MAC");
+		return -EOPNOTSUPP;
+	}
 	/* Ensure destination MAC address is fully matched. */
 	mac = (struct nfp_flower_mac_mpls *)mask;
 	if (!is_broadcast_ether_addr(&mac->mac_dst[0])) {
 		return -EOPNOTSUPP;
 	}
+	if (mac->mpls_lse) {
+		NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: MPLS not supported");
+		return -EOPNOTSUPP;
+	}
 	mask += sizeof(struct nfp_flower_mac_mpls);
 	ext += sizeof(struct nfp_flower_mac_mpls);
 	if (key_layer & NFP_FLOWER_LAYER_IPV4 ||

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c+13−2

 #define NFP_FL_MAX_ROUTES               32
 #define NFP_TUN_PRE_TUN_RULE_LIMIT	32
-#define NFP_TUN_PRE_TUN_RULE_DEL	0x1
+#define NFP_TUN_PRE_TUN_RULE_DEL	BIT(0)
-#define NFP_TUN_PRE_TUN_IDX_BIT		0x8
+#define NFP_TUN_PRE_TUN_IDX_BIT		BIT(3)
+#define NFP_TUN_PRE_TUN_IPV6_BIT	BIT(7)
 /**
  * struct nfp_tun_pre_run_rule - rule matched before decap
 {
 	struct nfp_flower_priv *app_priv = app->priv;
 	struct nfp_tun_offloaded_mac *mac_entry;
+	struct nfp_flower_meta_tci *key_meta;
 	struct nfp_tun_pre_tun_rule payload;
 	struct net_device *internal_dev;
 	int err;
 	if (!mac_entry)
 		return -ENOENT;
+	/* Set/clear IPV6 bit. cpu_to_be16() swap will lead to MSB being
+	 * set/clear for port_idx.
+	 */
+	key_meta = (struct nfp_flower_meta_tci *)flow->unmasked_data;
+	if (key_meta->nfp_flow_key_layer & NFP_FLOWER_LAYER_IPV6)
+		mac_entry->index |= NFP_TUN_PRE_TUN_IPV6_BIT;
+	else
+		mac_entry->index &= ~NFP_TUN_PRE_TUN_IPV6_BIT;
 	payload.port_idx = cpu_to_be16(mac_entry->index);
 	/* Copy mac id and vlan to flow - dev may not exist at delete time. */

drivers/net/ethernet/pensando/ionic/ionic_txrx.c+7−5

 static int ionic_tx_descs_needed(struct ionic_queue *q, struct sk_buff *skb)
 {
 	struct ionic_tx_stats *stats = q_to_tx_stats(q);
+	int ndescs;
 	int err;
-	/* If TSO, need roundup(skb->len/mss) descs */
+	/* Each desc is mss long max, so a descriptor for each gso_seg */
 	if (skb_is_gso(skb))
-		return (skb->len / skb_shinfo(skb)->gso_size) + 1;
+		ndescs = skb_shinfo(skb)->gso_segs;
+	else
+		ndescs = 1;
 	/* If non-TSO, just need 1 desc and nr_frags sg elems */
 	if (skb_shinfo(skb)->nr_frags <= q->max_sg_elems)
-		return 1;
+		return ndescs;
 	/* Too many frags, so linearize */
 	err = skb_linearize(skb);
 	stats->linearize++;
-	/* Need 1 desc and zero sg elems */
+	return ndescs;
-	return 1;
 }
 static int ionic_maybe_stop_tx(struct ionic_queue *q, int ndescs)

drivers/net/ethernet/qlogic/qlcnic/qlcnic_minidump.c+3−0

 	if (fw_dump->tmpl_hdr == NULL || current_version > prev_version) {
 		vfree(fw_dump->tmpl_hdr);
+		fw_dump->tmpl_hdr = NULL;
 		if (qlcnic_83xx_md_check_extended_dump_capability(adapter))
 			extended = !qlcnic_83xx_extend_md_capab(adapter);
 			struct qlcnic_83xx_dump_template_hdr *hdr;
 			hdr = fw_dump->tmpl_hdr;
+			if (!hdr)
+				return;
 			hdr->drv_cap_mask = 0x1f;
 			fw_dump->cap_mask = 0x1f;
 			dev_info(&pdev->dev,

drivers/net/ethernet/realtek/r8169_main.c+4−2

 	rtl8169_update_counters(tp);
+	pci_clear_master(tp->pci_dev);
+	rtl_pci_commit(tp);
 	rtl8169_cleanup(tp, true);
 	rtl_prepare_power_down(tp);
 static void rtl8169_up(struct rtl8169_private *tp)
 {
+	pci_set_master(tp->pci_dev);
 	phy_resume(tp->phydev);
 	rtl8169_init_phy(tp);
 	napi_enable(&tp->napi);
 	rtl_hw_reset(tp);
-	pci_set_master(pdev);
 	rc = rtl_alloc_irq(tp);
 	if (rc < 0) {
 		dev_err(&pdev->dev, "Can't allocate interrupt\n");

drivers/net/ethernet/socionext/netsec.c+6−3

 		goto err1;
 	/* set phy power down */
-	data = netsec_phy_read(priv->mii_bus, priv->phy_addr, MII_BMCR) |
+	data = netsec_phy_read(priv->mii_bus, priv->phy_addr, MII_BMCR);
-		BMCR_PDOWN;
+	netsec_phy_write(priv->mii_bus, priv->phy_addr, MII_BMCR,
-	netsec_phy_write(priv->mii_bus, priv->phy_addr, MII_BMCR, data);
+			 data | BMCR_PDOWN);
 	ret = netsec_reset_hardware(priv, true);
 	if (ret)
 		goto err2;
+	/* Restore phy power state */
+	netsec_phy_write(priv->mii_bus, priv->phy_addr, MII_BMCR, data);
 	spin_lock_init(&priv->desc_ring[NETSEC_RING_TX].lock);
 	spin_lock_init(&priv->desc_ring[NETSEC_RING_RX].lock);

drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c+2−0

@@ -1214,6 +1214,8 @@ static int sun8i_dwmac_probe(struct platform_device *pdev) · 1213 unmodified lines
1214	plat_dat->init = sun8i_dwmac_init;	1214	plat_dat->init = sun8i_dwmac_init;
1215	plat_dat->exit = sun8i_dwmac_exit;	1215	plat_dat->exit = sun8i_dwmac_exit;
1216	plat_dat->setup = sun8i_dwmac_setup;	1216	plat_dat->setup = sun8i_dwmac_setup;
		1217	plat_dat->tx_fifo_size = 4096;
		1218	plat_dat->rx_fifo_size = 16384;
1217		1219
1218	ret = sun8i_dwmac_set_syscon(&pdev->dev, plat_dat);	1220	ret = sun8i_dwmac_set_syscon(&pdev->dev, plat_dat);
1219	if (ret)	1221	if (ret)

drivers/net/ethernet/xilinx/xilinx_axienet_main.c+25−12

 	if (IS_ERR(lp->regs)) {
 		dev_err(&pdev->dev, "could not map Axi Ethernet regs.\n");
 		ret = PTR_ERR(lp->regs);
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	lp->regs_start = ethres->start;
 			break;
 		default:
 			ret = -EINVAL;
-			goto free_netdev;
+			goto cleanup_clk;
 		}
 	} else {
 		ret = of_get_phy_mode(pdev->dev.of_node, &lp->phy_mode);
 		if (ret)
-			goto free_netdev;
+			goto cleanup_clk;
 	}
 	if (lp->switch_x_sgmii && lp->phy_mode != PHY_INTERFACE_MODE_SGMII &&
 	    lp->phy_mode != PHY_INTERFACE_MODE_1000BASEX) {
 		dev_err(&pdev->dev, "xlnx,switch-x-sgmii only supported with SGMII or 1000BaseX\n");
 		ret = -EINVAL;
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	/* Find the DMA node, map the DMA registers, and decode the DMA IRQs */
 			dev_err(&pdev->dev,
 				"unable to get DMA resource\n");
 			of_node_put(np);
-			goto free_netdev;
+			goto cleanup_clk;
 		}
 		lp->dma_regs = devm_ioremap_resource(&pdev->dev,
 						     &dmares);
 	if (IS_ERR(lp->dma_regs)) {
 		dev_err(&pdev->dev, "could not map DMA regs\n");
 		ret = PTR_ERR(lp->dma_regs);
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	if ((lp->rx_irq <= 0) || (lp->tx_irq <= 0)) {
 		dev_err(&pdev->dev, "could not determine irqs\n");
 		ret = -ENOMEM;
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	/* Autodetect the need for 64-bit DMA pointers.
 	ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(addr_width));
 	if (ret) {
 		dev_err(&pdev->dev, "No suitable DMA available\n");
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	/* Check for Ethernet core IRQ (optional) */
 		if (!lp->phy_node) {
 			dev_err(&pdev->dev, "phy-handle required for 1000BaseX/SGMII\n");
 			ret = -EINVAL;
-			goto free_netdev;
+			goto cleanup_mdio;
 		}
 		lp->pcs_phy = of_mdio_find_device(lp->phy_node);
 		if (!lp->pcs_phy) {
 			ret = -EPROBE_DEFER;
-			goto free_netdev;
+			goto cleanup_mdio;
 		}
 		lp->phylink_config.pcs_poll = true;
 	}
 	if (IS_ERR(lp->phylink)) {
 		ret = PTR_ERR(lp->phylink);
 		dev_err(&pdev->dev, "phylink_create error (%i)\n", ret);
-		goto free_netdev;
+		goto cleanup_mdio;
 	}
 	ret = register_netdev(lp->ndev);
 	if (ret) {
 		dev_err(lp->dev, "register_netdev() error (%i)\n", ret);
-		goto free_netdev;
+		goto cleanup_phylink;
 	}
 	return 0;
+cleanup_phylink:
+	phylink_destroy(lp->phylink);
+cleanup_mdio:
+	if (lp->pcs_phy)
+		put_device(&lp->pcs_phy->dev);
+	if (lp->mii_bus)
+		axienet_mdio_teardown(lp);
+	of_node_put(lp->phy_node);
+cleanup_clk:
+	clk_disable_unprepare(lp->clk);
 free_netdev:
 	free_netdev(ndev);

drivers/net/hamradio/scc.c+0−1

@@ -2167,7 +2167,6 @@ static void __exit scc_cleanup_driver(void) · 2166 unmodified lines
2167		2167
2168	MODULE_AUTHOR("Joerg Reuter <jreuter@yaina.de>");	2168	MODULE_AUTHOR("Joerg Reuter <jreuter@yaina.de>");
2169	MODULE_DESCRIPTION("AX.25 Device Driver for Z8530 based HDLC cards");	2169	MODULE_DESCRIPTION("AX.25 Device Driver for Z8530 based HDLC cards");
2170	MODULE_SUPPORTED_DEVICE("Z8530 based SCC cards for Amateur Radio");
2171	MODULE_LICENSE("GPL");	2170	MODULE_LICENSE("GPL");
2172	module_init(scc_init_driver);	2171	module_init(scc_init_driver);
2173	module_exit(scc_cleanup_driver);	2172	module_exit(scc_cleanup_driver);

drivers/net/ipa/ipa_cmd.c+33−17

@@ -174,21 +174,23 @@ bool ipa_cmd_table_valid(struct ipa ipa, const struct ipa_mem mem, · 173 unmodified lines
174	: field_max(IP_FLTRT_FLAGS_NHASH_ADDR_FMASK);	174	: field_max(IP_FLTRT_FLAGS_NHASH_ADDR_FMASK);
175	if (mem->offset > offset_max \|\|	175	if (mem->offset > offset_max \|\|
176	ipa->mem_offset > offset_max - mem->offset) {	176	ipa->mem_offset > offset_max - mem->offset) {
177	dev_err(dev, "IPv%c %s%s table region offset too large "	177	dev_err(dev, "IPv%c %s%s table region offset too large\n",
178	"(0x%04x + 0x%04x > 0x%04x)\n",	178	ipv6 ? '6' : '4', hashed ? "hashed " : "",
179	ipv6 ? '6' : '4', hashed ? "hashed " : "",	179	route ? "route" : "filter");
180	route ? "route" : "filter",	180	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
181	ipa->mem_offset, mem->offset, offset_max);	181	ipa->mem_offset, mem->offset, offset_max);
		182
182	return false;	183	return false;
183	}	184	}
184		185
185	if (mem->offset > ipa->mem_size \|\|	186	if (mem->offset > ipa->mem_size \|\|
186	mem->size > ipa->mem_size - mem->offset) {	187	mem->size > ipa->mem_size - mem->offset) {
187	dev_err(dev, "IPv%c %s%s table region out of range "	188	dev_err(dev, "IPv%c %s%s table region out of range\n",
188	"(0x%04x + 0x%04x > 0x%04x)\n",	189	ipv6 ? '6' : '4', hashed ? "hashed " : "",
189	ipv6 ? '6' : '4', hashed ? "hashed " : "",	190	route ? "route" : "filter");
190	route ? "route" : "filter",	191	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
191	mem->offset, mem->size, ipa->mem_size);	192	mem->offset, mem->size, ipa->mem_size);
		193
192	return false;	194	return false;
193	}	195	}
194		196
@@ -204,22 +206,36 @@ static bool ipa_cmd_header_valid(struct ipa *ipa) · 9 unmodified lines
204	u32 size_max;	206	u32 size_max;
205	u32 size;	207	u32 size;
206		208
		209	/* In ipa_cmd_hdr_init_local_add() we record the offset and size
		210	* of the header table memory area. Make sure the offset and size
		211	* fit in the fields that need to hold them, and that the entire
		212	* range is within the overall IPA memory range.
		213	*/
207	offset_max = field_max(HDR_INIT_LOCAL_FLAGS_HDR_ADDR_FMASK);	214	offset_max = field_max(HDR_INIT_LOCAL_FLAGS_HDR_ADDR_FMASK);
208	if (mem->offset > offset_max \|\|	215	if (mem->offset > offset_max \|\|
209	ipa->mem_offset > offset_max - mem->offset) {	216	ipa->mem_offset > offset_max - mem->offset) {
210	dev_err(dev, "header table region offset too large "	217	dev_err(dev, "header table region offset too large\n");
211	"(0x%04x + 0x%04x > 0x%04x)\n",	218	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
212	ipa->mem_offset + mem->offset, offset_max);	219	ipa->mem_offset, mem->offset, offset_max);
		220
213	return false;	221	return false;
214	}	222	}
215		223
216	size_max = field_max(HDR_INIT_LOCAL_FLAGS_TABLE_SIZE_FMASK);	224	size_max = field_max(HDR_INIT_LOCAL_FLAGS_TABLE_SIZE_FMASK);
217	size = ipa->mem[IPA_MEM_MODEM_HEADER].size;	225	size = ipa->mem[IPA_MEM_MODEM_HEADER].size;
218	size += ipa->mem[IPA_MEM_AP_HEADER].size;	226	size += ipa->mem[IPA_MEM_AP_HEADER].size;
219	if (mem->offset > ipa->mem_size \|\| size > ipa->mem_size - mem->offset) {	227
220	dev_err(dev, "header table region out of range "	228	if (size > size_max) {
221	"(0x%04x + 0x%04x > 0x%04x)\n",	229	dev_err(dev, "header table region size too large\n");
222	mem->offset, size, ipa->mem_size);	230	dev_err(dev, " (0x%04x > 0x%08x)\n", size, size_max);
		231
		232	return false;
		233	}
		234	if (size > ipa->mem_size \|\| mem->offset > ipa->mem_size - size) {
		235	dev_err(dev, "header table region out of range\n");
		236	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
		237	mem->offset, size, ipa->mem_size);
		238
223	return false;	239	return false;
224	}	240	}
225		241

drivers/net/ipa/ipa_qmi.c+2−0

 		.decoded_size	= IPA_QMI_DRIVER_INIT_COMPLETE_REQ_SZ,
 		.fn		= ipa_server_driver_init_complete,
 	},
+	{ },
 };
 /* Handle an INIT_DRIVER response message from the modem. */
 		.decoded_size	= IPA_QMI_INIT_DRIVER_RSP_SZ,
 		.fn		= ipa_client_init_driver,
 	},
+	{ },
 };
 /* Return a pointer to an init modem driver request structure, which contains

drivers/net/phy/broadcom.c+9−0

 	bcm54xx_adjust_rxrefclk(phydev);
 	switch (BRCM_PHY_MODEL(phydev)) {
+	case PHY_ID_BCM50610:
+	case PHY_ID_BCM50610M:
+		err = bcm54xx_config_clock_delay(phydev);
+		break;
 	case PHY_ID_BCM54210E:
 		err = bcm54210e_config_init(phydev);
 		break;
 	if (ret < 0)
 		return ret;
+	/* Upon exiting power down, the PHY remains in an internal reset state
+	 * for 40us
+	 */
+	fsleep(40);
 	return bcm54xx_config_init(phydev);
 }

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

@@ -477,7 +477,7 @@ static void phylink_major_config(struct phylink *pl, bool restart, · 476 unmodified lines
477	err = pl->mac_ops->mac_finish(pl->config, pl->cur_link_an_mode,	477	err = pl->mac_ops->mac_finish(pl->config, pl->cur_link_an_mode,
478	state->interface);	478	state->interface);
479	if (err < 0)	479	if (err < 0)
480	phylink_err(pl, "mac_prepare failed: %pe\n",	480	phylink_err(pl, "mac_finish failed: %pe\n",
481	ERR_PTR(err));	481	ERR_PTR(err));
482	}	482	}
483	}	483	}

drivers/net/usb/cdc-phonet.c+2−0

@@ -387,6 +387,8 @@ static int usbpn_probe(struct usb_interface intf, const struct usb_device_id i · 386 unmodified lines
387		387
388	err = register_netdev(dev);	388	err = register_netdev(dev);
389	if (err) {	389	if (err) {
		390	/* Set disconnected flag so that disconnect() returns early. */
		391	pnd->disconnected = 1;
390	usb_driver_release_interface(&usbpn_driver, data_intf);	392	usb_driver_release_interface(&usbpn_driver, data_intf);
391	goto out;	393	goto out;
392	}	394	}

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

 		ops->in_nway		= rtl8153_in_nway;
 		ops->hw_phy_cfg		= r8153_hw_phy_cfg;
 		ops->autosuspend_en	= rtl8153_runtime_enable;
-		tp->rx_buf_sz		= 32 * 1024;
+		if (tp->udev->speed < USB_SPEED_SUPER)
+			tp->rx_buf_sz	= 16 * 1024;
+		else
+			tp->rx_buf_sz	= 32 * 1024;
 		tp->eee_en		= true;
 		tp->eee_adv		= MDIO_EEE_1000T | MDIO_EEE_100TX;
 		break;

drivers/net/veth.c+1−2

@@ -302,8 +302,7 @@ static netdev_tx_t veth_xmit(struct sk_buff skb, struct net_device dev) · 301 unmodified lines
302	if (rxq < rcv->real_num_rx_queues) {	302	if (rxq < rcv->real_num_rx_queues) {
303	rq = &rcv_priv->rq[rxq];	303	rq = &rcv_priv->rq[rxq];
304	rcv_xdp = rcu_access_pointer(rq->xdp_prog);	304	rcv_xdp = rcu_access_pointer(rq->xdp_prog);
305	if (rcv_xdp)	305	skb_record_rx_queue(skb, rxq);
306	skb_record_rx_queue(skb, rxq);
307	}	306	}
308		307
309	skb_tx_timestamp(skb);	308	skb_tx_timestamp(skb);

drivers/net/wan/hdlc_x25.c+41−1

 struct x25_state {
 	x25_hdlc_proto settings;
+	bool up;
+	spinlock_t up_lock; /* Protects "up" */
 };
 static int x25_ioctl(struct net_device *dev, struct ifreq *ifr);
 static netdev_tx_t x25_xmit(struct sk_buff *skb, struct net_device *dev)
 {
+	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
 	int result;
 	/* There should be a pseudo header of 1 byte added by upper layers.
 		return NETDEV_TX_OK;
 	}
+	spin_lock_bh(&x25st->up_lock);
+	if (!x25st->up) {
+		spin_unlock_bh(&x25st->up_lock);
+		kfree_skb(skb);
+		return NETDEV_TX_OK;
+	}
 	switch (skb->data[0]) {
 	case X25_IFACE_DATA:	/* Data to be transmitted */
 		skb_pull(skb, 1);
 		if ((result = lapb_data_request(dev, skb)) != LAPB_OK)
 			dev_kfree_skb(skb);
+		spin_unlock_bh(&x25st->up_lock);
 		return NETDEV_TX_OK;
 	case X25_IFACE_CONNECT:
 		break;
 	}
+	spin_unlock_bh(&x25st->up_lock);
 	dev_kfree_skb(skb);
 	return NETDEV_TX_OK;
 }
 		.data_transmit = x25_data_transmit,
 	};
 	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
 	struct lapb_parms_struct params;
 	int result;
 	if (result != LAPB_OK)
 		return -EINVAL;
+	spin_lock_bh(&x25st->up_lock);
+	x25st->up = true;
+	spin_unlock_bh(&x25st->up_lock);
 	return 0;
 }
 static void x25_close(struct net_device *dev)
 {
+	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
+	spin_lock_bh(&x25st->up_lock);
+	x25st->up = false;
+	spin_unlock_bh(&x25st->up_lock);
 	lapb_unregister(dev);
 }
 static int x25_rx(struct sk_buff *skb)
 {
 	struct net_device *dev = skb->dev;
+	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
 	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
 		dev->stats.rx_dropped++;
 		return NET_RX_DROP;
 	}
-	if (lapb_data_received(dev, skb) == LAPB_OK)
+	spin_lock_bh(&x25st->up_lock);
+	if (!x25st->up) {
+		spin_unlock_bh(&x25st->up_lock);
+		kfree_skb(skb);
+		dev->stats.rx_dropped++;
+		return NET_RX_DROP;
+	}
+	if (lapb_data_received(dev, skb) == LAPB_OK) {
+		spin_unlock_bh(&x25st->up_lock);
 		return NET_RX_SUCCESS;
+	}
+	spin_unlock_bh(&x25st->up_lock);
 	dev->stats.rx_errors++;
 	dev_kfree_skb_any(skb);
 	return NET_RX_DROP;
 			return result;
 		memcpy(&state(hdlc)->settings, &new_settings, size);
+		state(hdlc)->up = false;
+		spin_lock_init(&state(hdlc)->up_lock);
 		/* There's no header_ops so hard_header_len should be 0. */
 		dev->hard_header_len = 0;

drivers/net/wireless/admtek/adm8211.c+0−1

@@ -28,7 +28,6 @@ · 27 unmodified lines
28	MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");	28	MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
29	MODULE_AUTHOR("Jouni Malinen <j@w1.fi>");	29	MODULE_AUTHOR("Jouni Malinen <j@w1.fi>");
30	MODULE_DESCRIPTION("Driver for IEEE 802.11b wireless cards based on ADMtek ADM8211");	30	MODULE_DESCRIPTION("Driver for IEEE 802.11b wireless cards based on ADMtek ADM8211");
31	MODULE_SUPPORTED_DEVICE("ADM8211");
32	MODULE_LICENSE("GPL");	31	MODULE_LICENSE("GPL");
33		32
34	static unsigned int tx_ring_size __read_mostly = 16;	33	static unsigned int tx_ring_size __read_mostly = 16;

drivers/net/wireless/ath/ath5k/base.c+0−1

@@ -90,7 +90,6 @@ MODULE_PARM_DESC(no_hw_rfkill_switch, "Ignore the GPIO RFKill switch state"); · 89 unmodified lines
90	MODULE_AUTHOR("Jiri Slaby");	90	MODULE_AUTHOR("Jiri Slaby");
91	MODULE_AUTHOR("Nick Kossifidis");	91	MODULE_AUTHOR("Nick Kossifidis");
92	MODULE_DESCRIPTION("Support for 5xxx series of Atheros 802.11 wireless LAN cards.");	92	MODULE_DESCRIPTION("Support for 5xxx series of Atheros 802.11 wireless LAN cards.");
93	MODULE_SUPPORTED_DEVICE("Atheros 5xxx WLAN cards");
94	MODULE_LICENSE("Dual BSD/GPL");	93	MODULE_LICENSE("Dual BSD/GPL");
95		94
96	static int ath5k_init(struct ieee80211_hw *hw);	95	static int ath5k_init(struct ieee80211_hw *hw);

drivers/net/wireless/ath/ath9k/hw.c+0−1

@@ -34,7 +34,6 @@ static bool ath9k_hw_set_reset_reg(struct ath_hw *ah, u32 type); · 33 unmodified lines
34		34
35	MODULE_AUTHOR("Atheros Communications");	35	MODULE_AUTHOR("Atheros Communications");
36	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");	36	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
37	MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
38	MODULE_LICENSE("Dual BSD/GPL");	37	MODULE_LICENSE("Dual BSD/GPL");
39		38
40	static void ath9k_hw_set_clockrate(struct ath_hw *ah)	39	static void ath9k_hw_set_clockrate(struct ath_hw *ah)

drivers/net/wireless/ath/ath9k/init.c+0−1

@@ -37,7 +37,6 @@ static char *dev_info = "ath9k"; · 36 unmodified lines
37		37
38	MODULE_AUTHOR("Atheros Communications");	38	MODULE_AUTHOR("Atheros Communications");
39	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");	39	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
40	MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
41	MODULE_LICENSE("Dual BSD/GPL");	40	MODULE_LICENSE("Dual BSD/GPL");
42		41
43	static unsigned int ath9k_debug = ATH_DBG_DEFAULT;	42	static unsigned int ath9k_debug = ATH_DBG_DEFAULT;

drivers/net/wireless/atmel/atmel.c+0−1

@@ -75,7 +75,6 @@ · 74 unmodified lines
75	MODULE_AUTHOR("Simon Kelley");	75	MODULE_AUTHOR("Simon Kelley");
76	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");	76	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
77	MODULE_LICENSE("GPL");	77	MODULE_LICENSE("GPL");
78	MODULE_SUPPORTED_DEVICE("Atmel at76c50x wireless cards");
79		78
80	/* The name of the firmware file to be loaded	79	/* The name of the firmware file to be loaded
81	over-rides any automatic selection */	80	over-rides any automatic selection */

drivers/net/wireless/atmel/atmel_cs.c+0−1

@@ -57,7 +57,6 @@ · 56 unmodified lines
57	MODULE_AUTHOR("Simon Kelley");	57	MODULE_AUTHOR("Simon Kelley");
58	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");	58	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
59	MODULE_LICENSE("GPL");	59	MODULE_LICENSE("GPL");
60	MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards");
61		60
62	/====================================================================/	61	/====================================================================/
63		62

drivers/net/wireless/atmel/atmel_pci.c+0−1

@@ -16,7 +16,6 @@ · 15 unmodified lines
16	MODULE_AUTHOR("Simon Kelley");	16	MODULE_AUTHOR("Simon Kelley");
17	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");	17	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
18	MODULE_LICENSE("GPL");	18	MODULE_LICENSE("GPL");
19	MODULE_SUPPORTED_DEVICE("Atmel at76c506 PCI wireless cards");
20		19
21	static const struct pci_device_id card_ids[] = {	20	static const struct pci_device_id card_ids[] = {
22	{ 0x1114, 0x0506, PCI_ANY_ID, PCI_ANY_ID },	21	{ 0x1114, 0x0506, PCI_ANY_ID, PCI_ANY_ID },

drivers/net/wireless/broadcom/brcm80211/brcmsmac/mac80211_if.c+0−1

@@ -87,7 +87,6 @@ static int n_adapters_found; · 86 unmodified lines
87		87
88	MODULE_AUTHOR("Broadcom Corporation");	88	MODULE_AUTHOR("Broadcom Corporation");
89	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver.");	89	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver.");
90	MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards");
91	MODULE_LICENSE("Dual BSD/GPL");	90	MODULE_LICENSE("Dual BSD/GPL");
92	/* This needs to be adjusted when brcms_firmwares changes */	91	/* This needs to be adjusted when brcms_firmwares changes */
93	MODULE_FIRMWARE("brcm/bcm43xx-0.fw");	92	MODULE_FIRMWARE("brcm/bcm43xx-0.fw");

drivers/net/wireless/broadcom/brcm80211/brcmutil/utils.c+0−1

@@ -12,7 +12,6 @@ · 11 unmodified lines
12		12
13	MODULE_AUTHOR("Broadcom Corporation");	13	MODULE_AUTHOR("Broadcom Corporation");
14	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver utilities.");	14	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver utilities.");
15	MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards");
16	MODULE_LICENSE("Dual BSD/GPL");	15	MODULE_LICENSE("Dual BSD/GPL");
17		16
18	struct sk_buff *brcmu_pkt_buf_get_skb(uint len)	17	struct sk_buff *brcmu_pkt_buf_get_skb(uint len)

drivers/net/wireless/cisco/airo.c+0−1

@@ -251,7 +251,6 @@ MODULE_AUTHOR("Benjamin Reed"); · 250 unmodified lines
251	MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet cards. "	251	MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet cards. "
252	"Direct support for ISA/PCI/MPI cards and support for PCMCIA when used with airo_cs.");	252	"Direct support for ISA/PCI/MPI cards and support for PCMCIA when used with airo_cs.");
253	MODULE_LICENSE("Dual BSD/GPL");	253	MODULE_LICENSE("Dual BSD/GPL");
254	MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
255	module_param_hw_array(io, int, ioport, NULL, 0);	254	module_param_hw_array(io, int, ioport, NULL, 0);
256	module_param_hw_array(irq, int, irq, NULL, 0);	255	module_param_hw_array(irq, int, irq, NULL, 0);
257	module_param_array(rates, int, NULL, 0);	256	module_param_array(rates, int, NULL, 0);

drivers/net/wireless/cisco/airo_cs.c+0−1

@@ -47,7 +47,6 @@ MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet " · 46 unmodified lines
47	"cards. This is the module that links the PCMCIA card "	47	"cards. This is the module that links the PCMCIA card "
48	"with the airo module.");	48	"with the airo module.");
49	MODULE_LICENSE("Dual BSD/GPL");	49	MODULE_LICENSE("Dual BSD/GPL");
50	MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
51		50
52	/====================================================================/	51	/====================================================================/
53		52

drivers/net/wireless/intersil/hostap/hostap_cs.c+0−1

@@ -26,7 +26,6 @@ static char *dev_info = "hostap_cs"; · 25 unmodified lines
26	MODULE_AUTHOR("Jouni Malinen");	26	MODULE_AUTHOR("Jouni Malinen");
27	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "	27	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "
28	"cards (PC Card).");	28	"cards (PC Card).");
29	MODULE_SUPPORTED_DEVICE("Intersil Prism2-based WLAN cards (PC Card)");
30	MODULE_LICENSE("GPL");	29	MODULE_LICENSE("GPL");
31		30
32		31

drivers/net/wireless/intersil/hostap/hostap_pci.c+0−1

@@ -27,7 +27,6 @@ static char *dev_info = "hostap_pci"; · 26 unmodified lines
27	MODULE_AUTHOR("Jouni Malinen");	27	MODULE_AUTHOR("Jouni Malinen");
28	MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "	28	MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "
29	"PCI cards.");	29	"PCI cards.");
30	MODULE_SUPPORTED_DEVICE("Intersil Prism2.5-based WLAN PCI cards");
31	MODULE_LICENSE("GPL");	30	MODULE_LICENSE("GPL");
32		31
33		32

drivers/net/wireless/intersil/hostap/hostap_plx.c+0−1

@@ -30,7 +30,6 @@ static char *dev_info = "hostap_plx"; · 29 unmodified lines
30	MODULE_AUTHOR("Jouni Malinen");	30	MODULE_AUTHOR("Jouni Malinen");
31	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "	31	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "
32	"cards (PLX).");	32	"cards (PLX).");
33	MODULE_SUPPORTED_DEVICE("Intersil Prism2-based WLAN cards (PLX)");
34	MODULE_LICENSE("GPL");	33	MODULE_LICENSE("GPL");
35		34
36		35

drivers/net/wireless/ralink/rt2x00/rt2400pci.c+0−1

@@ -1821,7 +1821,6 @@ static const struct pci_device_id rt2400pci_device_table[] = { · 1820 unmodified lines
1821	MODULE_AUTHOR(DRV_PROJECT);	1821	MODULE_AUTHOR(DRV_PROJECT);
1822	MODULE_VERSION(DRV_VERSION);	1822	MODULE_VERSION(DRV_VERSION);
1823	MODULE_DESCRIPTION("Ralink RT2400 PCI & PCMCIA Wireless LAN driver.");	1823	MODULE_DESCRIPTION("Ralink RT2400 PCI & PCMCIA Wireless LAN driver.");
1824	MODULE_SUPPORTED_DEVICE("Ralink RT2460 PCI & PCMCIA chipset based cards");
1825	MODULE_DEVICE_TABLE(pci, rt2400pci_device_table);	1824	MODULE_DEVICE_TABLE(pci, rt2400pci_device_table);
1826	MODULE_LICENSE("GPL");	1825	MODULE_LICENSE("GPL");
1827		1826

drivers/net/wireless/ralink/rt2x00/rt2500pci.c+0−1

@@ -2119,7 +2119,6 @@ static const struct pci_device_id rt2500pci_device_table[] = { · 2118 unmodified lines
2119	MODULE_AUTHOR(DRV_PROJECT);	2119	MODULE_AUTHOR(DRV_PROJECT);
2120	MODULE_VERSION(DRV_VERSION);	2120	MODULE_VERSION(DRV_VERSION);
2121	MODULE_DESCRIPTION("Ralink RT2500 PCI & PCMCIA Wireless LAN driver.");	2121	MODULE_DESCRIPTION("Ralink RT2500 PCI & PCMCIA Wireless LAN driver.");
2122	MODULE_SUPPORTED_DEVICE("Ralink RT2560 PCI & PCMCIA chipset based cards");
2123	MODULE_DEVICE_TABLE(pci, rt2500pci_device_table);	2122	MODULE_DEVICE_TABLE(pci, rt2500pci_device_table);
2124	MODULE_LICENSE("GPL");	2123	MODULE_LICENSE("GPL");
2125		2124

drivers/net/wireless/ralink/rt2x00/rt2500usb.c+0−1

@@ -1956,7 +1956,6 @@ static const struct usb_device_id rt2500usb_device_table[] = { · 1955 unmodified lines
1956	MODULE_AUTHOR(DRV_PROJECT);	1956	MODULE_AUTHOR(DRV_PROJECT);
1957	MODULE_VERSION(DRV_VERSION);	1957	MODULE_VERSION(DRV_VERSION);
1958	MODULE_DESCRIPTION("Ralink RT2500 USB Wireless LAN driver.");	1958	MODULE_DESCRIPTION("Ralink RT2500 USB Wireless LAN driver.");
1959	MODULE_SUPPORTED_DEVICE("Ralink RT2570 USB chipset based cards");
1960	MODULE_DEVICE_TABLE(usb, rt2500usb_device_table);	1959	MODULE_DEVICE_TABLE(usb, rt2500usb_device_table);
1961	MODULE_LICENSE("GPL");	1960	MODULE_LICENSE("GPL");
1962		1961

drivers/net/wireless/ralink/rt2x00/rt2800pci.c+0−1

@@ -439,7 +439,6 @@ static const struct pci_device_id rt2800pci_device_table[] = { · 438 unmodified lines
439	MODULE_AUTHOR(DRV_PROJECT);	439	MODULE_AUTHOR(DRV_PROJECT);
440	MODULE_VERSION(DRV_VERSION);	440	MODULE_VERSION(DRV_VERSION);
441	MODULE_DESCRIPTION("Ralink RT2800 PCI & PCMCIA Wireless LAN driver.");	441	MODULE_DESCRIPTION("Ralink RT2800 PCI & PCMCIA Wireless LAN driver.");
442	MODULE_SUPPORTED_DEVICE("Ralink RT2860 PCI & PCMCIA chipset based cards");
443	MODULE_FIRMWARE(FIRMWARE_RT2860);	442	MODULE_FIRMWARE(FIRMWARE_RT2860);
444	MODULE_DEVICE_TABLE(pci, rt2800pci_device_table);	443	MODULE_DEVICE_TABLE(pci, rt2800pci_device_table);
445	MODULE_LICENSE("GPL");	444	MODULE_LICENSE("GPL");

drivers/net/wireless/ralink/rt2x00/rt2800usb.c+0−1

@@ -1248,7 +1248,6 @@ static const struct usb_device_id rt2800usb_device_table[] = { · 1247 unmodified lines
1248	MODULE_AUTHOR(DRV_PROJECT);	1248	MODULE_AUTHOR(DRV_PROJECT);
1249	MODULE_VERSION(DRV_VERSION);	1249	MODULE_VERSION(DRV_VERSION);
1250	MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver.");	1250	MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver.");
1251	MODULE_SUPPORTED_DEVICE("Ralink RT2870 USB chipset based cards");
1252	MODULE_DEVICE_TABLE(usb, rt2800usb_device_table);	1251	MODULE_DEVICE_TABLE(usb, rt2800usb_device_table);
1253	MODULE_FIRMWARE(FIRMWARE_RT2870);	1252	MODULE_FIRMWARE(FIRMWARE_RT2870);
1254	MODULE_LICENSE("GPL");	1253	MODULE_LICENSE("GPL");

drivers/net/wireless/ralink/rt2x00/rt61pci.c+0−2

 MODULE_AUTHOR(DRV_PROJECT);
 MODULE_VERSION(DRV_VERSION);
 MODULE_DESCRIPTION("Ralink RT61 PCI & PCMCIA Wireless LAN driver.");
-MODULE_SUPPORTED_DEVICE("Ralink RT2561, RT2561s & RT2661 "
-			"PCI & PCMCIA chipset based cards");
 MODULE_DEVICE_TABLE(pci, rt61pci_device_table);
 MODULE_FIRMWARE(FIRMWARE_RT2561);
 MODULE_FIRMWARE(FIRMWARE_RT2561s);

drivers/net/wireless/ralink/rt2x00/rt73usb.c+0−1

@@ -2513,7 +2513,6 @@ static const struct usb_device_id rt73usb_device_table[] = { · 2512 unmodified lines
2513	MODULE_AUTHOR(DRV_PROJECT);	2513	MODULE_AUTHOR(DRV_PROJECT);
2514	MODULE_VERSION(DRV_VERSION);	2514	MODULE_VERSION(DRV_VERSION);
2515	MODULE_DESCRIPTION("Ralink RT73 USB Wireless LAN driver.");	2515	MODULE_DESCRIPTION("Ralink RT73 USB Wireless LAN driver.");
2516	MODULE_SUPPORTED_DEVICE("Ralink RT2571W & RT2671 USB chipset based cards");
2517	MODULE_DEVICE_TABLE(usb, rt73usb_device_table);	2516	MODULE_DEVICE_TABLE(usb, rt73usb_device_table);
2518	MODULE_FIRMWARE(FIRMWARE_RT2571);	2517	MODULE_FIRMWARE(FIRMWARE_RT2571);
2519	MODULE_LICENSE("GPL");	2518	MODULE_LICENSE("GPL");

drivers/net/wireless/rsi/rsi_91x_main.c+0−1

@@ -441,6 +441,5 @@ module_init(rsi_91x_hal_module_init); · 440 unmodified lines
441	module_exit(rsi_91x_hal_module_exit);	441	module_exit(rsi_91x_hal_module_exit);
442	MODULE_AUTHOR("Redpine Signals Inc");	442	MODULE_AUTHOR("Redpine Signals Inc");
443	MODULE_DESCRIPTION("Station driver for RSI 91x devices");	443	MODULE_DESCRIPTION("Station driver for RSI 91x devices");
444	MODULE_SUPPORTED_DEVICE("RSI-91x");
445	MODULE_VERSION("0.1");	444	MODULE_VERSION("0.1");
446	MODULE_LICENSE("Dual BSD/GPL");	445	MODULE_LICENSE("Dual BSD/GPL");

drivers/net/wireless/rsi/rsi_91x_sdio.c+0−1

@@ -1571,7 +1571,6 @@ module_exit(rsi_module_exit); · 1570 unmodified lines
1571		1571
1572	MODULE_AUTHOR("Redpine Signals Inc");	1572	MODULE_AUTHOR("Redpine Signals Inc");
1573	MODULE_DESCRIPTION("Common SDIO layer for RSI drivers");	1573	MODULE_DESCRIPTION("Common SDIO layer for RSI drivers");
1574	MODULE_SUPPORTED_DEVICE("RSI-91x");
1575	MODULE_DEVICE_TABLE(sdio, rsi_dev_table);	1574	MODULE_DEVICE_TABLE(sdio, rsi_dev_table);
1576	MODULE_FIRMWARE(FIRMWARE_RSI9113);	1575	MODULE_FIRMWARE(FIRMWARE_RSI9113);
1577	MODULE_VERSION("0.1");	1576	MODULE_VERSION("0.1");

drivers/net/wireless/rsi/rsi_91x_usb.c+0−1

@@ -928,7 +928,6 @@ module_usb_driver(rsi_driver); · 927 unmodified lines
928		928
929	MODULE_AUTHOR("Redpine Signals Inc");	929	MODULE_AUTHOR("Redpine Signals Inc");
930	MODULE_DESCRIPTION("Common USB layer for RSI drivers");	930	MODULE_DESCRIPTION("Common USB layer for RSI drivers");
931	MODULE_SUPPORTED_DEVICE("RSI-91x");
932	MODULE_DEVICE_TABLE(usb, rsi_dev_table);	931	MODULE_DEVICE_TABLE(usb, rsi_dev_table);
933	MODULE_FIRMWARE(FIRMWARE_RSI9113);	932	MODULE_FIRMWARE(FIRMWARE_RSI9113);
934	MODULE_VERSION("0.1");	933	MODULE_VERSION("0.1");

drivers/nvme/host/core.c+32−47

@@ -380,6 +380,7 @@ bool nvme_cancel_request(struct request req, void data, bool reserved) · 379 unmodified lines
380	return true;	380	return true;
381		381
382	nvme_req(req)->status = NVME_SC_HOST_ABORTED_CMD;	382	nvme_req(req)->status = NVME_SC_HOST_ABORTED_CMD;
		383	nvme_req(req)->flags \|= NVME_REQ_CANCELLED;
383	blk_mq_complete_request(req);	384	blk_mq_complete_request(req);
384	return true;	385	return true;
385	}	386	}
@@ -1225,28 +1226,12 @@ static void nvme_keep_alive_end_io(struct request *rq, blk_status_t status) · 839 unmodified lines
1225	queue_delayed_work(nvme_wq, &ctrl->ka_work, ctrl->kato * HZ);	1226	queue_delayed_work(nvme_wq, &ctrl->ka_work, ctrl->kato * HZ);
1226	}	1227	}
1227		1228
1228	static int nvme_keep_alive(struct nvme_ctrl *ctrl)
1229	{
1230	struct request *rq;
1231
1232	rq = nvme_alloc_request(ctrl->admin_q, &ctrl->ka_cmd,
1233	BLK_MQ_REQ_RESERVED);
1234	if (IS_ERR(rq))
1235	return PTR_ERR(rq);
1236
1237	rq->timeout = ctrl->kato * HZ;
1238	rq->end_io_data = ctrl;
1239
1240	blk_execute_rq_nowait(NULL, rq, 0, nvme_keep_alive_end_io);
1241
1242	return 0;
1243	}
1244
1245	static void nvme_keep_alive_work(struct work_struct *work)	1229	static void nvme_keep_alive_work(struct work_struct *work)
1246	{	1230	{
1247	struct nvme_ctrl *ctrl = container_of(to_delayed_work(work),	1231	struct nvme_ctrl *ctrl = container_of(to_delayed_work(work),
1248	struct nvme_ctrl, ka_work);	1232	struct nvme_ctrl, ka_work);
1249	bool comp_seen = ctrl->comp_seen;	1233	bool comp_seen = ctrl->comp_seen;
		1234	struct request *rq;
1250		1235
1251	if ((ctrl->ctratt & NVME_CTRL_ATTR_TBKAS) && comp_seen) {	1236	if ((ctrl->ctratt & NVME_CTRL_ATTR_TBKAS) && comp_seen) {
1252	dev_dbg(ctrl->device,	1237	dev_dbg(ctrl->device,
@@ -1256,12 +1241,18 @@ static void nvme_keep_alive_work(struct work_struct *work) · 3 unmodified lines
1256	return;	1241	return;
1257	}	1242	}
1258		1243
1259	if (nvme_keep_alive(ctrl)) {	1244	rq = nvme_alloc_request(ctrl->admin_q, &ctrl->ka_cmd,
		1245	BLK_MQ_REQ_RESERVED \| BLK_MQ_REQ_NOWAIT);
		1246	if (IS_ERR(rq)) {
1260	/* allocation failure, reset the controller */	1247	/* allocation failure, reset the controller */
1261	dev_err(ctrl->device, "keep-alive failed\n");	1248	dev_err(ctrl->device, "keep-alive failed: %ld\n", PTR_ERR(rq));
1262	nvme_reset_ctrl(ctrl);	1249	nvme_reset_ctrl(ctrl);
1263	return;	1250	return;
1264	}	1251	}
		1252
		1253	rq->timeout = ctrl->kato * HZ;
		1254	rq->end_io_data = ctrl;
		1255	blk_execute_rq_nowait(NULL, rq, 0, nvme_keep_alive_end_io);
1265	}	1256	}
1266		1257
1267	static void nvme_start_keep_alive(struct nvme_ctrl *ctrl)	1258	static void nvme_start_keep_alive(struct nvme_ctrl *ctrl)
@@ -1440,7 +1431,7 @@ static int nvme_identify_ns(struct nvme_ctrl *ctrl, unsigned nsid, · 172 unmodified lines
1440	goto out_free_id;	1431	goto out_free_id;
1441	}	1432	}
1442		1433
1443	error = -ENODEV;	1434	error = NVME_SC_INVALID_NS \| NVME_SC_DNR;
1444	if ((id)->ncap == 0) / namespace not allocated or attached */	1435	if ((id)->ncap == 0) / namespace not allocated or attached */
1445	goto out_free_id;	1436	goto out_free_id;
1446		1437
@@ -1963,30 +1954,18 @@ static void nvme_config_discard(struct gendisk disk, struct nvme_ns ns) · 516 unmodified lines
1963	blk_queue_max_write_zeroes_sectors(queue, UINT_MAX);	1954	blk_queue_max_write_zeroes_sectors(queue, UINT_MAX);
1964	}	1955	}
1965		1956
1966	static void nvme_config_write_zeroes(struct gendisk disk, struct nvme_ns ns)	1957	/*
		1958	* Even though NVMe spec explicitly states that MDTS is not applicable to the
		1959	* write-zeroes, we are cautious and limit the size to the controllers
		1960	* max_hw_sectors value, which is based on the MDTS field and possibly other
		1961	* limiting factors.
		1962	*/
		1963	static void nvme_config_write_zeroes(struct request_queue *q,
		1964	struct nvme_ctrl *ctrl)
1967	{	1965	{
1968	u64 max_blocks;	1966	if ((ctrl->oncs & NVME_CTRL_ONCS_WRITE_ZEROES) &&
1969		1967	!(ctrl->quirks & NVME_QUIRK_DISABLE_WRITE_ZEROES))
1970	if (!(ns->ctrl->oncs & NVME_CTRL_ONCS_WRITE_ZEROES) \|\|	1968	blk_queue_max_write_zeroes_sectors(q, ctrl->max_hw_sectors);
1971	(ns->ctrl->quirks & NVME_QUIRK_DISABLE_WRITE_ZEROES))
1972	return;
1973	/*
1974	* Even though NVMe spec explicitly states that MDTS is not
1975	* applicable to the write-zeroes:- "The restriction does not apply to
1976	* commands that do not transfer data between the host and the
1977	* controller (e.g., Write Uncorrectable ro Write Zeroes command).".
1978	* In order to be more cautious use controller's max_hw_sectors value
1979	* to configure the maximum sectors for the write-zeroes which is
1980	* configured based on the controller's MDTS field in the
1981	* nvme_init_identify() if available.
1982	*/
1983	if (ns->ctrl->max_hw_sectors == UINT_MAX)
1984	max_blocks = (u64)USHRT_MAX + 1;
1985	else
1986	max_blocks = ns->ctrl->max_hw_sectors + 1;
1987
1988	blk_queue_max_write_zeroes_sectors(disk->queue,
1989	nvme_lba_to_sect(ns, max_blocks));
1990	}	1969	}
1991		1970
1992	static bool nvme_ns_ids_valid(struct nvme_ns_ids *ids)	1971	static bool nvme_ns_ids_valid(struct nvme_ns_ids *ids)
@@ -2158,7 +2137,7 @@ static void nvme_update_disk_info(struct gendisk *disk, · 165 unmodified lines
2158	set_capacity_and_notify(disk, capacity);	2137	set_capacity_and_notify(disk, capacity);
2159		2138
2160	nvme_config_discard(disk, ns);	2139	nvme_config_discard(disk, ns);
2161	nvme_config_write_zeroes(disk, ns);	2140	nvme_config_write_zeroes(disk->queue, ns->ctrl);
2162		2141
2163	set_disk_ro(disk, (id->nsattr & NVME_NS_ATTR_RO) \|\|	2142	set_disk_ro(disk, (id->nsattr & NVME_NS_ATTR_RO) \|\|
2164	test_bit(NVME_NS_FORCE_RO, &ns->flags));	2143	test_bit(NVME_NS_FORCE_RO, &ns->flags));
@@ -4038,7 +4017,7 @@ static void nvme_ns_remove_by_nsid(struct nvme_ctrl *ctrl, u32 nsid) · 1873 unmodified lines
4038	static void nvme_validate_ns(struct nvme_ns ns, struct nvme_ns_ids ids)	4017	static void nvme_validate_ns(struct nvme_ns ns, struct nvme_ns_ids ids)
4039	{	4018	{
4040	struct nvme_id_ns *id;	4019	struct nvme_id_ns *id;
4041	int ret = -ENODEV;	4020	int ret = NVME_SC_INVALID_NS \| NVME_SC_DNR;
4042		4021
4043	if (test_bit(NVME_NS_DEAD, &ns->flags))	4022	if (test_bit(NVME_NS_DEAD, &ns->flags))
4044	goto out;	4023	goto out;
@@ -4047,7 +4026,7 @@ static void nvme_validate_ns(struct nvme_ns ns, struct nvme_ns_ids ids) · 2 unmodified lines
4047	if (ret)	4026	if (ret)
4048	goto out;	4027	goto out;
4049		4028
4050	ret = -ENODEV;	4029	ret = NVME_SC_INVALID_NS \| NVME_SC_DNR;
4051	if (!nvme_ns_ids_equal(&ns->head->ids, ids)) {	4030	if (!nvme_ns_ids_equal(&ns->head->ids, ids)) {
4052	dev_err(ns->ctrl->device,	4031	dev_err(ns->ctrl->device,
4053	"identifiers changed for nsid %d\n", ns->head->ns_id);	4032	"identifiers changed for nsid %d\n", ns->head->ns_id);
@@ -4065,7 +4044,7 @@ out: · 11 unmodified lines
4065	*	4044	*
4066	* TODO: we should probably schedule a delayed retry here.	4045	* TODO: we should probably schedule a delayed retry here.
4067	*/	4046	*/
4068	if (ret && ret != -ENOMEM && !(ret > 0 && !(ret & NVME_SC_DNR)))	4047	if (ret > 0 && (ret & NVME_SC_DNR))
4069	nvme_ns_remove(ns);	4048	nvme_ns_remove(ns);
4070	}	4049	}
4071		4050
@@ -4095,6 +4074,12 @@ static void nvme_validate_or_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid) · 23 unmodified lines
4095	nsid);	4074	nsid);
4096	break;	4075	break;
4097	}	4076	}
		4077	if (!nvme_multi_css(ctrl)) {
		4078	dev_warn(ctrl->device,
		4079	"command set not reported for nsid: %d\n",
		4080	nsid);
		4081	break;
		4082	}
4098	nvme_alloc_ns(ctrl, nsid, &ids);	4083	nvme_alloc_ns(ctrl, nsid, &ids);
4099	break;	4084	break;
4100	default:	4085	default:

drivers/nvme/host/fabrics.h+7−0

@@ -18,6 +18,13 @@ · 17 unmodified lines
18	/* default is -1: the fail fast mechanism is disabled */	18	/* default is -1: the fail fast mechanism is disabled */
19	#define NVMF_DEF_FAIL_FAST_TMO -1	19	#define NVMF_DEF_FAIL_FAST_TMO -1
20		20
		21	/*
		22	* Reserved one command for internal usage. This command is used for sending
		23	* the connect command, as well as for the keep alive command on the admin
		24	* queue once live.
		25	*/
		26	#define NVMF_RESERVED_TAGS 1
		27
21	/*	28	/*
22	* Define a host as seen by the target. We allocate one at boot, but also	29	* Define a host as seen by the target. We allocate one at boot, but also
23	* allow the override it when creating controllers. This is both to provide	30	* allow the override it when creating controllers. This is both to provide

drivers/nvme/host/fc.c+5−4

 				sizeof(op->rsp_iu), DMA_FROM_DEVICE);
 	if (opstate == FCPOP_STATE_ABORTED)
-		status = cpu_to_le16(NVME_SC_HOST_PATH_ERROR << 1);
+		status = cpu_to_le16(NVME_SC_HOST_ABORTED_CMD << 1);
 	else if (freq->status) {
 		status = cpu_to_le16(NVME_SC_HOST_PATH_ERROR << 1);
 		dev_info(ctrl->ctrl.device,
 		nvme_fc_complete_rq(rq);
 check_error:
-	if (terminate_assoc)
+	if (terminate_assoc && ctrl->ctrl.state != NVME_CTRL_RESETTING)
 		queue_work(nvme_reset_wq, &ctrl->ioerr_work);
 }
 	struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);
 	struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(req);
+	op->nreq.flags |= NVME_REQ_CANCELLED;
 	__nvme_fc_abort_op(ctrl, op);
 	return true;
 }
 	memset(&ctrl->tag_set, 0, sizeof(ctrl->tag_set));
 	ctrl->tag_set.ops = &nvme_fc_mq_ops;
 	ctrl->tag_set.queue_depth = ctrl->ctrl.opts->queue_size;
-	ctrl->tag_set.reserved_tags = 1; /* fabric connect */
+	ctrl->tag_set.reserved_tags = NVMF_RESERVED_TAGS;
 	ctrl->tag_set.numa_node = ctrl->ctrl.numa_node;
 	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
 	ctrl->tag_set.cmd_size =
 	memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));
 	ctrl->admin_tag_set.ops = &nvme_fc_admin_mq_ops;
 	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;
-	ctrl->admin_tag_set.reserved_tags = 2; /* fabric connect + Keep-Alive */
+	ctrl->admin_tag_set.reserved_tags = NVMF_RESERVED_TAGS;
 	ctrl->admin_tag_set.numa_node = ctrl->ctrl.numa_node;
 	ctrl->admin_tag_set.cmd_size =
 		struct_size((struct nvme_fcp_op_w_sgl *)NULL, priv,

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

@@ -3246,6 +3246,7 @@ static const struct pci_device_id nvme_id_table[] = { · 3245 unmodified lines
3246	.driver_data = NVME_QUIRK_DELAY_BEFORE_CHK_RDY, },	3246	.driver_data = NVME_QUIRK_DELAY_BEFORE_CHK_RDY, },
3247	{ PCI_DEVICE(0x144d, 0xa822), /* Samsung PM1725a */	3247	{ PCI_DEVICE(0x144d, 0xa822), /* Samsung PM1725a */
3248	.driver_data = NVME_QUIRK_DELAY_BEFORE_CHK_RDY \|	3248	.driver_data = NVME_QUIRK_DELAY_BEFORE_CHK_RDY \|
		3249	NVME_QUIRK_DISABLE_WRITE_ZEROES\|
3249	NVME_QUIRK_IGNORE_DEV_SUBNQN, },	3250	NVME_QUIRK_IGNORE_DEV_SUBNQN, },
3250	{ PCI_DEVICE(0x1987, 0x5016), /* Phison E16 */	3251	{ PCI_DEVICE(0x1987, 0x5016), /* Phison E16 */
3251	.driver_data = NVME_QUIRK_IGNORE_DEV_SUBNQN, },	3252	.driver_data = NVME_QUIRK_IGNORE_DEV_SUBNQN, },

drivers/nvme/host/rdma.c+7−4

 		return ret;
 	ctrl->ctrl.queue_count = nr_io_queues + 1;
-	if (ctrl->ctrl.queue_count < 2)
+	if (ctrl->ctrl.queue_count < 2) {
-		return 0;
+		dev_err(ctrl->ctrl.device,
+			"unable to set any I/O queues\n");
+		return -ENOMEM;
+	}
 	dev_info(ctrl->ctrl.device,
 		"creating %d I/O queues.\n", nr_io_queues);
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_rdma_admin_mq_ops;
 		set->queue_depth = NVME_AQ_MQ_TAG_DEPTH;
-		set->reserved_tags = 2; /* connect + keep-alive */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->cmd_size = sizeof(struct nvme_rdma_request) +
 				NVME_RDMA_DATA_SGL_SIZE;
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_rdma_mq_ops;
 		set->queue_depth = nctrl->sqsize + 1;
-		set->reserved_tags = 1; /* fabric connect */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->flags = BLK_MQ_F_SHOULD_MERGE;
 		set->cmd_size = sizeof(struct nvme_rdma_request) +

drivers/nvme/host/tcp.c+15−5

 	 * directly, otherwise queue io_work. Also, only do that if we
 	 * are on the same cpu, so we don't introduce contention.
 	 */
-	if (queue->io_cpu == __smp_processor_id() &&
+	if (queue->io_cpu == raw_smp_processor_id() &&
 	    sync && empty && mutex_trylock(&queue->send_mutex)) {
 		queue->more_requests = !last;
 		nvme_tcp_send_all(queue);
 	req->pdu_len = le32_to_cpu(pdu->r2t_length);
 	req->pdu_sent = 0;
+	if (unlikely(!req->pdu_len)) {
+		dev_err(queue->ctrl->ctrl.device,
+			"req %d r2t len is %u, probably a bug...\n",
+			rq->tag, req->pdu_len);
+		return -EPROTO;
+	}
 	if (unlikely(req->data_sent + req->pdu_len > req->data_len)) {
 		dev_err(queue->ctrl->ctrl.device,
 			"req %d r2t len %u exceeded data len %u (%zu sent)\n",
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_tcp_admin_mq_ops;
 		set->queue_depth = NVME_AQ_MQ_TAG_DEPTH;
-		set->reserved_tags = 2; /* connect + keep-alive */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->flags = BLK_MQ_F_BLOCKING;
 		set->cmd_size = sizeof(struct nvme_tcp_request);
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_tcp_mq_ops;
 		set->queue_depth = nctrl->sqsize + 1;
-		set->reserved_tags = 1; /* fabric connect */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
 		set->cmd_size = sizeof(struct nvme_tcp_request);
 		return ret;
 	ctrl->queue_count = nr_io_queues + 1;
-	if (ctrl->queue_count < 2)
+	if (ctrl->queue_count < 2) {
-		return 0;
+		dev_err(ctrl->device,
+			"unable to set any I/O queues\n");
+		return -ENOMEM;
+	}
 	dev_info(ctrl->device,
 		"creating %d I/O queues.\n", nr_io_queues);

drivers/nvme/host/zns.c+7−2

 int nvme_revalidate_zones(struct nvme_ns *ns)
 {
-	return blk_revalidate_disk_zones(ns->disk, NULL);
+	struct request_queue *q = ns->queue;
+	int ret;
+	ret = blk_revalidate_disk_zones(ns->disk, NULL);
+	if (!ret)
+		blk_queue_max_zone_append_sectors(q, ns->ctrl->max_zone_append);
+	return ret;
 }
 static int nvme_set_max_append(struct nvme_ctrl *ctrl)
 	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);
 	blk_queue_max_open_zones(q, le32_to_cpu(id->mor) + 1);
 	blk_queue_max_active_zones(q, le32_to_cpu(id->mar) + 1);
-	blk_queue_max_zone_append_sectors(q, ns->ctrl->max_zone_append);
 free_data:
 	kfree(id);
 	return status;

drivers/nvme/target/core.c+14−3

@@ -1118,9 +1118,20 @@ static void nvmet_start_ctrl(struct nvmet_ctrl *ctrl) · 1117 unmodified lines
1118	{	1118	{
1119	lockdep_assert_held(&ctrl->lock);	1119	lockdep_assert_held(&ctrl->lock);
1120		1120
1121	if (nvmet_cc_iosqes(ctrl->cc) != NVME_NVM_IOSQES \|\|	1121	/*
1122	nvmet_cc_iocqes(ctrl->cc) != NVME_NVM_IOCQES \|\|	1122	* Only I/O controllers should verify iosqes,iocqes.
1123	nvmet_cc_mps(ctrl->cc) != 0 \|\|	1123	* Strictly speaking, the spec says a discovery controller
		1124	* should verify iosqes,iocqes are zeroed, however that
		1125	* would break backwards compatibility, so don't enforce it.
		1126	*/
		1127	if (ctrl->subsys->type != NVME_NQN_DISC &&
		1128	(nvmet_cc_iosqes(ctrl->cc) != NVME_NVM_IOSQES \|\|
		1129	nvmet_cc_iocqes(ctrl->cc) != NVME_NVM_IOCQES)) {
		1130	ctrl->csts = NVME_CSTS_CFS;
		1131	return;
		1132	}
		1133
		1134	if (nvmet_cc_mps(ctrl->cc) != 0 \|\|
1124	nvmet_cc_ams(ctrl->cc) != 0 \|\|	1135	nvmet_cc_ams(ctrl->cc) != 0 \|\|
1125	nvmet_cc_css(ctrl->cc) != 0) {	1136	nvmet_cc_css(ctrl->cc) != 0) {
1126	ctrl->csts = NVME_CSTS_CFS;	1137	ctrl->csts = NVME_CSTS_CFS;

drivers/nvme/target/loop.c+2−2

drivers/nvme/target/passthru.c+3−3

@@ -50,9 +50,9 @@ static u16 nvmet_passthru_override_id_ctrl(struct nvmet_req *req) · 49 unmodified lines
50		50
51	/*	51	/*
52	* nvmet_passthru_map_sg is limitted to using a single bio so limit	52	* nvmet_passthru_map_sg is limitted to using a single bio so limit
53	* the mdts based on BIO_MAX_PAGES as well	53	* the mdts based on BIO_MAX_VECS as well
54	*/	54	*/
55	max_hw_sectors = min_not_zero(BIO_MAX_PAGES << (PAGE_SHIFT - 9),	55	max_hw_sectors = min_not_zero(BIO_MAX_VECS << (PAGE_SHIFT - 9),
56	max_hw_sectors);	56	max_hw_sectors);
57		57
58	page_shift = NVME_CAP_MPSMIN(ctrl->cap) + 12;	58	page_shift = NVME_CAP_MPSMIN(ctrl->cap) + 12;
@@ -191,7 +191,7 @@ static int nvmet_passthru_map_sg(struct nvmet_req req, struct request rq) · 132 unmodified lines
191	struct bio *bio;	191	struct bio *bio;
192	int i;	192	int i;
193		193
194	if (req->sg_cnt > BIO_MAX_PAGES)	194	if (req->sg_cnt > BIO_MAX_VECS)
195	return -EINVAL;	195	return -EINVAL;
196		196
197	if (req->transfer_len <= NVMET_MAX_INLINE_DATA_LEN) {	197	if (req->transfer_len <= NVMET_MAX_INLINE_DATA_LEN) {

drivers/nvme/target/rdma.c+2−3

 		nvmet_req_uninit(&rsp->req);
 		nvmet_rdma_release_rsp(rsp);
 		if (wc->status != IB_WC_WR_FLUSH_ERR) {
-			pr_info("RDMA WRITE for CQE 0x%p failed with status %s (%d).\n",
+			pr_info("RDMA WRITE for CQE failed with status %s (%d).\n",
-				wc->wr_cqe, ib_wc_status_msg(wc->status),
+				ib_wc_status_msg(wc->status), wc->status);
-				wc->status);
 			nvmet_rdma_error_comp(queue);
 		}
 		return;

drivers/nvme/target/tcp.c+1−1

 		cmd->rbytes_done += ret;
 	}
+	nvmet_tcp_unmap_pdu_iovec(cmd);
 	if (queue->data_digest) {
 		nvmet_tcp_prep_recv_ddgst(cmd);
 		return 0;
 	}
-	nvmet_tcp_unmap_pdu_iovec(cmd);
 	if (!(cmd->flags & NVMET_TCP_F_INIT_FAILED) &&
 	    cmd->rbytes_done == cmd->req.transfer_len) {

drivers/opp/core.c+25−23

 	mutex_lock(&opp_table->lock);
 	list_for_each_entry(temp, &opp_table->opp_list, node) {
-		if (dynamic == temp->dynamic) {
+		/*
+		 * Refcount must be dropped only once for each OPP by OPP core,
+		 * do that with help of "removed" flag.
+		 */
+		if (!temp->removed && dynamic == temp->dynamic) {
 			opp = temp;
 			break;
 		}
 	return opp;
 }
-bool _opp_remove_all_static(struct opp_table *opp_table)
+/*
+ * Can't call dev_pm_opp_put() from under the lock as debugfs removal needs to
+ * happen lock less to avoid circular dependency issues. This routine must be
+ * called without the opp_table->lock held.
+ */
+static void _opp_remove_all(struct opp_table *opp_table, bool dynamic)
 {
 	struct dev_pm_opp *opp;
+	while ((opp = _opp_get_next(opp_table, dynamic))) {
+		opp->removed = true;
+		dev_pm_opp_put(opp);
+		/* Drop the references taken by dev_pm_opp_add() */
+		if (dynamic)
+			dev_pm_opp_put_opp_table(opp_table);
+	}
+}
+bool _opp_remove_all_static(struct opp_table *opp_table)
+{
 	mutex_lock(&opp_table->lock);
 	if (!opp_table->parsed_static_opps) {
 	mutex_unlock(&opp_table->lock);
-	/*
+	_opp_remove_all(opp_table, false);
-	 * Can't remove the OPP from under the lock, debugfs removal needs to
-	 * happen lock less to avoid circular dependency issues.
-	 */
-	while ((opp = _opp_get_next(opp_table, false)))
-		dev_pm_opp_put(opp);
 	return true;
 }
 void dev_pm_opp_remove_all_dynamic(struct device *dev)
 {
 	struct opp_table *opp_table;
-	struct dev_pm_opp *opp;
-	int count = 0;
 	opp_table = _find_opp_table(dev);
 	if (IS_ERR(opp_table))
 		return;
-	/*
+	_opp_remove_all(opp_table, true);
-	 * Can't remove the OPP from under the lock, debugfs removal needs to
-	 * happen lock less to avoid circular dependency issues.
-	 */
-	while ((opp = _opp_get_next(opp_table, true))) {
-		dev_pm_opp_put(opp);
-		count++;
-	}
-	/* Drop the references taken by dev_pm_opp_add() */
-	while (count--)
-		dev_pm_opp_put_opp_table(opp_table);
 	/* Drop the reference taken by _find_opp_table() */
 	dev_pm_opp_put_opp_table(opp_table);

drivers/opp/opp.h+2−0

  * @dynamic:	not-created from static DT entries.
  * @turbo:	true if turbo (boost) OPP
  * @suspend:	true if suspend OPP
+ * @removed:	flag indicating that OPP's reference is dropped by OPP core.
  * @pstate: Device's power domain's performance state.
  * @rate:	Frequency in hertz
  * @level:	Performance level
 	bool dynamic;
 	bool turbo;
 	bool suspend;
+	bool removed;
 	unsigned int pstate;
 	unsigned long rate;
 	unsigned int level;

drivers/parport/parport_amiga.c+0−1

@@ -241,6 +241,5 @@ module_platform_driver_probe(amiga_parallel_driver, amiga_parallel_probe); · 240 unmodified lines
241		241
242	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");	242	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");
243	MODULE_DESCRIPTION("Parport Driver for Amiga builtin Port");	243	MODULE_DESCRIPTION("Parport Driver for Amiga builtin Port");
244	MODULE_SUPPORTED_DEVICE("Amiga builtin Parallel Port");
245	MODULE_LICENSE("GPL");	244	MODULE_LICENSE("GPL");
246	MODULE_ALIAS("platform:amiga-parallel");	245	MODULE_ALIAS("platform:amiga-parallel");

drivers/parport/parport_atari.c+0−1

@@ -218,7 +218,6 @@ static void __exit parport_atari_exit(void) · 217 unmodified lines
218		218
219	MODULE_AUTHOR("Andreas Schwab");	219	MODULE_AUTHOR("Andreas Schwab");
220	MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");	220	MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");
221	MODULE_SUPPORTED_DEVICE("Atari builtin Parallel Port");
222	MODULE_LICENSE("GPL");	221	MODULE_LICENSE("GPL");
223		222
224	module_init(parport_atari_init)	223	module_init(parport_atari_init)

drivers/parport/parport_gsc.c+0−1

@@ -41,7 +41,6 @@ · 40 unmodified lines
41		41
42	MODULE_AUTHOR("Helge Deller <deller@gmx.de>");	42	MODULE_AUTHOR("Helge Deller <deller@gmx.de>");
43	MODULE_DESCRIPTION("HP-PARISC PC-style parallel port driver");	43	MODULE_DESCRIPTION("HP-PARISC PC-style parallel port driver");
44	MODULE_SUPPORTED_DEVICE("integrated PC-style parallel port");
45	MODULE_LICENSE("GPL");	44	MODULE_LICENSE("GPL");
46		45
47		46

drivers/parport/parport_mfc3.c+0−1

@@ -359,7 +359,6 @@ static void __exit parport_mfc3_exit(void) · 358 unmodified lines
359		359
360	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");	360	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");
361	MODULE_DESCRIPTION("Parport Driver for Multiface 3 expansion cards Parallel Port");	361	MODULE_DESCRIPTION("Parport Driver for Multiface 3 expansion cards Parallel Port");
362	MODULE_SUPPORTED_DEVICE("Multiface 3 Parallel Port");
363	MODULE_LICENSE("GPL");	362	MODULE_LICENSE("GPL");
364		363
365	module_init(parport_mfc3_init)	364	module_init(parport_mfc3_init)

drivers/parport/parport_sunbpp.c+0−1

@@ -377,6 +377,5 @@ module_platform_driver(bpp_sbus_driver); · 376 unmodified lines
377		377
378	MODULE_AUTHOR("Derrick J Brashear");	378	MODULE_AUTHOR("Derrick J Brashear");
379	MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");	379	MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
380	MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
381	MODULE_VERSION("2.0");	380	MODULE_VERSION("2.0");
382	MODULE_LICENSE("GPL");	381	MODULE_LICENSE("GPL");

drivers/pci/hotplug/rpadlpar_sysfs.c+6−8

 	if (nbytes >= MAX_DRC_NAME_LEN)
 		return 0;
-	memcpy(drc_name, buf, nbytes);
+	strscpy(drc_name, buf, nbytes + 1);
 	end = strchr(drc_name, '\n');
-	if (!end)
+	if (end)
-		end = &drc_name[nbytes];
+		*end = '\0';
-	*end = '\0';
 	rc = dlpar_add_slot(drc_name);
 	if (rc)
 	if (nbytes >= MAX_DRC_NAME_LEN)
 		return 0;
-	memcpy(drc_name, buf, nbytes);
+	strscpy(drc_name, buf, nbytes + 1);
 	end = strchr(drc_name, '\n');
-	if (!end)
+	if (end)
-		end = &drc_name[nbytes];
+		*end = '\0';
-	*end = '\0';
 	rc = dlpar_remove_slot(drc_name);
 	if (rc)

drivers/pci/hotplug/s390_pci_hpc.c+2−1

@@ -93,8 +93,9 @@ static int disable_slot(struct hotplug_slot *hotplug_slot) · 92 unmodified lines
93	pci_dev_put(pdev);	93	pci_dev_put(pdev);
94	return -EBUSY;	94	return -EBUSY;
95	}	95	}
		96	pci_dev_put(pdev);
96		97
97	zpci_remove_device(zdev);	98	zpci_remove_device(zdev, false);
98		99
99	rc = zpci_disable_device(zdev);	100	rc = zpci_disable_device(zdev);
100	if (rc)	101	if (rc)

drivers/pci/xen-pcifront.c+2−2

@@ -26,7 +26,7 @@ · 25 unmodified lines
26	#include <xen/platform_pci.h>	26	#include <xen/platform_pci.h>
27		27
28	#include <asm/xen/swiotlb-xen.h>	28	#include <asm/xen/swiotlb-xen.h>
29	#define INVALID_GRANT_REF (0)	29
30	#define INVALID_EVTCHN (-1)	30	#define INVALID_EVTCHN (-1)
31		31
32	struct pci_bus_entry {	32	struct pci_bus_entry {
@@ -42,7 +42,7 @@ struct pcifront_device { · 9 unmodified lines
42	struct list_head root_buses;	42	struct list_head root_buses;
43		43
44	int evtchn;	44	int evtchn;
45	int gnt_ref;	45	grant_ref_t gnt_ref;
46		46
47	int irq;	47	int irq;
48		48

drivers/perf/arm_dmc620_pmu.c+1−0

@@ -681,6 +681,7 @@ static int dmc620_pmu_device_probe(struct platform_device *pdev) · 680 unmodified lines
681	if (!name) {	681	if (!name) {
682	dev_err(&pdev->dev,	682	dev_err(&pdev->dev,
683	"Create name failed, PMU @%pa\n", &res->start);	683	"Create name failed, PMU @%pa\n", &res->start);
		684	ret = -ENOMEM;
684	goto out_teardown_dev;	685	goto out_teardown_dev;
685	}	686	}
686		687

drivers/platform/x86/Kconfig+8−3

 	depends on PCI
 	help
 	  The Intel Platform Controller Hub for Intel Core SoCs provides access
-	  to Power Management Controller registers via a PCI interface. This
+	  to Power Management Controller registers via various interfaces. This
 	  driver can utilize debugging capabilities and supported features as
-	  exposed by the Power Management Controller.
+	  exposed by the Power Management Controller. It also may perform some
+	  tasks in the PMC in order to enable transition into the SLPS0 state.
+	  It should be selected on all Intel platforms supported by the driver.
 	  Supported features:
 		- SLP_S0_RESIDENCY counter
 		- PCH IP Power Gating status
-		- LTR Ignore
+		- LTR Ignore / LTR Show
 		- MPHY/PLL gating status (Sunrisepoint PCH only)
+		- SLPS0 Debug registers (Cannonlake/Icelake PCH)
+		- Low Power Mode registers (Tigerlake and beyond)
+		- PMC quirks as needed to enable SLPS0/S0ix
 config INTEL_PMT_CLASS
 	tristate

drivers/platform/x86/dell/dell-wmi-sysman/enum-attributes.c+3−0

@@ -185,5 +185,8 @@ void exit_enum_attributes(void) · 184 unmodified lines
185	sysfs_remove_group(wmi_priv.enumeration_data[instance_id].attr_name_kobj,	185	sysfs_remove_group(wmi_priv.enumeration_data[instance_id].attr_name_kobj,
186	&enumeration_attr_group);	186	&enumeration_attr_group);
187	}	187	}
		188	wmi_priv.enumeration_instances_count = 0;
		189
188	kfree(wmi_priv.enumeration_data);	190	kfree(wmi_priv.enumeration_data);
		191	wmi_priv.enumeration_data = NULL;
189	}	192	}

drivers/platform/x86/dell/dell-wmi-sysman/int-attributes.c+3−0

@@ -175,5 +175,8 @@ void exit_int_attributes(void) · 174 unmodified lines
175	sysfs_remove_group(wmi_priv.integer_data[instance_id].attr_name_kobj,	175	sysfs_remove_group(wmi_priv.integer_data[instance_id].attr_name_kobj,
176	&integer_attr_group);	176	&integer_attr_group);
177	}	177	}
		178	wmi_priv.integer_instances_count = 0;
		179
178	kfree(wmi_priv.integer_data);	180	kfree(wmi_priv.integer_data);
		181	wmi_priv.integer_data = NULL;
179	}	182	}

drivers/platform/x86/dell/dell-wmi-sysman/passobj-attributes.c+3−0

@@ -183,5 +183,8 @@ void exit_po_attributes(void) · 182 unmodified lines
183	sysfs_remove_group(wmi_priv.po_data[instance_id].attr_name_kobj,	183	sysfs_remove_group(wmi_priv.po_data[instance_id].attr_name_kobj,
184	&po_attr_group);	184	&po_attr_group);
185	}	185	}
		186	wmi_priv.po_instances_count = 0;
		187
186	kfree(wmi_priv.po_data);	188	kfree(wmi_priv.po_data);
		189	wmi_priv.po_data = NULL;
187	}	190	}

drivers/platform/x86/dell/dell-wmi-sysman/string-attributes.c+3−0

@@ -155,5 +155,8 @@ void exit_str_attributes(void) · 154 unmodified lines
155	sysfs_remove_group(wmi_priv.str_data[instance_id].attr_name_kobj,	155	sysfs_remove_group(wmi_priv.str_data[instance_id].attr_name_kobj,
156	&str_attr_group);	156	&str_attr_group);
157	}	157	}
		158	wmi_priv.str_instances_count = 0;
		159
158	kfree(wmi_priv.str_data);	160	kfree(wmi_priv.str_data);
		161	wmi_priv.str_data = NULL;
159	}	162	}

drivers/platform/x86/dell/dell-wmi-sysman/sysman.c+32−52

@@ -210,25 +210,17 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot); · 209 unmodified lines
210	*/	210	*/
211	static int create_attributes_level_sysfs_files(void)	211	static int create_attributes_level_sysfs_files(void)
212	{	212	{
213	int ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);	213	int ret;
214		214
215	if (ret) {	215	ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
216	pr_debug("could not create reset_bios file\n");	216	if (ret)
217	return ret;	217	return ret;
218	}
219		218
220	ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);	219	ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);
221	if (ret) {	220	if (ret)
222	pr_debug("could not create changing_pending_reboot file\n");	221	return ret;
223	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
224	}
225	return ret;
226	}
227		222
228	static void release_reset_bios_data(void)	223	return 0;
229	{
230	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
231	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);
232	}	224	}
233		225
234	static ssize_t wmi_sysman_attr_show(struct kobject kobj, struct attribute attr,	226	static ssize_t wmi_sysman_attr_show(struct kobject kobj, struct attribute attr,
@@ -373,8 +365,6 @@ static void destroy_attribute_objs(struct kset *kset) · 138 unmodified lines
373	*/	365	*/
374	static void release_attributes_data(void)	366	static void release_attributes_data(void)
375	{	367	{
376	release_reset_bios_data();
377
378	mutex_lock(&wmi_priv.mutex);	368	mutex_lock(&wmi_priv.mutex);
379	exit_enum_attributes();	369	exit_enum_attributes();
380	exit_int_attributes();	370	exit_int_attributes();
@@ -386,11 +376,13 @@ static void release_attributes_data(void) · 5 unmodified lines
386	wmi_priv.authentication_dir_kset = NULL;	376	wmi_priv.authentication_dir_kset = NULL;
387	}	377	}
388	if (wmi_priv.main_dir_kset) {	378	if (wmi_priv.main_dir_kset) {
		379	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
		380	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);
389	destroy_attribute_objs(wmi_priv.main_dir_kset);	381	destroy_attribute_objs(wmi_priv.main_dir_kset);
390	kset_unregister(wmi_priv.main_dir_kset);	382	kset_unregister(wmi_priv.main_dir_kset);
		383	wmi_priv.main_dir_kset = NULL;
391	}	384	}
392	mutex_unlock(&wmi_priv.mutex);	385	mutex_unlock(&wmi_priv.mutex);
393
394	}	386	}
395		387
396	/**	388	/**
@@ -497,7 +489,6 @@ nextobj: · 100 unmodified lines
497		489
498	err_attr_init:	490	err_attr_init:
499	mutex_unlock(&wmi_priv.mutex);	491	mutex_unlock(&wmi_priv.mutex);
500	release_attributes_data();
501	kfree(obj);	492	kfree(obj);
502	return retval;	493	return retval;
503	}	494	}
@@ -513,102 +504,91 @@ static int __init sysman_init(void) · 9 unmodified lines
513	}	504	}
514		505
515	ret = init_bios_attr_set_interface();	506	ret = init_bios_attr_set_interface();
516	if (ret \|\| !wmi_priv.bios_attr_wdev) {	507	if (ret)
517	pr_debug("failed to initialize set interface\n");	508	return ret;
518	goto fail_set_interface;
519	}
520		509
521	ret = init_bios_attr_pass_interface();	510	ret = init_bios_attr_pass_interface();
522	if (ret \|\| !wmi_priv.password_attr_wdev) {	511	if (ret)
523	pr_debug("failed to initialize pass interface\n");	512	goto err_exit_bios_attr_set_interface;
524	goto fail_pass_interface;	513
		514	if (!wmi_priv.bios_attr_wdev \|\| !wmi_priv.password_attr_wdev) {
		515	pr_debug("failed to find set or pass interface\n");
		516	ret = -ENODEV;
		517	goto err_exit_bios_attr_pass_interface;
525	}	518	}
526		519
527	ret = class_register(&firmware_attributes_class);	520	ret = class_register(&firmware_attributes_class);
528	if (ret)	521	if (ret)
529	goto fail_class;	522	goto err_exit_bios_attr_pass_interface;
530		523
531	wmi_priv.class_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),	524	wmi_priv.class_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
532	NULL, "%s", DRIVER_NAME);	525	NULL, "%s", DRIVER_NAME);
533	if (IS_ERR(wmi_priv.class_dev)) {	526	if (IS_ERR(wmi_priv.class_dev)) {
534	ret = PTR_ERR(wmi_priv.class_dev);	527	ret = PTR_ERR(wmi_priv.class_dev);
535	goto fail_classdev;	528	goto err_unregister_class;
536	}	529	}
537		530
538	wmi_priv.main_dir_kset = kset_create_and_add("attributes", NULL,	531	wmi_priv.main_dir_kset = kset_create_and_add("attributes", NULL,
539	&wmi_priv.class_dev->kobj);	532	&wmi_priv.class_dev->kobj);
540	if (!wmi_priv.main_dir_kset) {	533	if (!wmi_priv.main_dir_kset) {
541	ret = -ENOMEM;	534	ret = -ENOMEM;
542	goto fail_main_kset;	535	goto err_destroy_classdev;
543	}	536	}
544		537
545	wmi_priv.authentication_dir_kset = kset_create_and_add("authentication", NULL,	538	wmi_priv.authentication_dir_kset = kset_create_and_add("authentication", NULL,
546	&wmi_priv.class_dev->kobj);	539	&wmi_priv.class_dev->kobj);
547	if (!wmi_priv.authentication_dir_kset) {	540	if (!wmi_priv.authentication_dir_kset) {
548	ret = -ENOMEM;	541	ret = -ENOMEM;
549	goto fail_authentication_kset;	542	goto err_release_attributes_data;
550	}	543	}
551		544
552	ret = create_attributes_level_sysfs_files();	545	ret = create_attributes_level_sysfs_files();
553	if (ret) {	546	if (ret) {
554	pr_debug("could not create reset BIOS attribute\n");	547	pr_debug("could not create reset BIOS attribute\n");
555	goto fail_reset_bios;	548	goto err_release_attributes_data;
556	}	549	}
557		550
558	ret = init_bios_attributes(ENUM, DELL_WMI_BIOS_ENUMERATION_ATTRIBUTE_GUID);	551	ret = init_bios_attributes(ENUM, DELL_WMI_BIOS_ENUMERATION_ATTRIBUTE_GUID);
559	if (ret) {	552	if (ret) {
560	pr_debug("failed to populate enumeration type attributes\n");	553	pr_debug("failed to populate enumeration type attributes\n");
561	goto fail_create_group;	554	goto err_release_attributes_data;
562	}	555	}
563		556
564	ret = init_bios_attributes(INT, DELL_WMI_BIOS_INTEGER_ATTRIBUTE_GUID);	557	ret = init_bios_attributes(INT, DELL_WMI_BIOS_INTEGER_ATTRIBUTE_GUID);
565	if (ret) {	558	if (ret) {
566	pr_debug("failed to populate integer type attributes\n");	559	pr_debug("failed to populate integer type attributes\n");
567	goto fail_create_group;	560	goto err_release_attributes_data;
568	}	561	}
569		562
570	ret = init_bios_attributes(STR, DELL_WMI_BIOS_STRING_ATTRIBUTE_GUID);	563	ret = init_bios_attributes(STR, DELL_WMI_BIOS_STRING_ATTRIBUTE_GUID);
571	if (ret) {	564	if (ret) {
572	pr_debug("failed to populate string type attributes\n");	565	pr_debug("failed to populate string type attributes\n");
573	goto fail_create_group;	566	goto err_release_attributes_data;
574	}	567	}
575		568
576	ret = init_bios_attributes(PO, DELL_WMI_BIOS_PASSOBJ_ATTRIBUTE_GUID);	569	ret = init_bios_attributes(PO, DELL_WMI_BIOS_PASSOBJ_ATTRIBUTE_GUID);
577	if (ret) {	570	if (ret) {
578	pr_debug("failed to populate pass object type attributes\n");	571	pr_debug("failed to populate pass object type attributes\n");
579	goto fail_create_group;	572	goto err_release_attributes_data;
580	}	573	}
581		574
582	return 0;	575	return 0;
583		576
584	fail_create_group:	577	err_release_attributes_data:
585	release_attributes_data();	578	release_attributes_data();
586		579
587	fail_reset_bios:	580	err_destroy_classdev:
588	if (wmi_priv.authentication_dir_kset) {
589	kset_unregister(wmi_priv.authentication_dir_kset);
590	wmi_priv.authentication_dir_kset = NULL;
591	}
592
593	fail_authentication_kset:
594	if (wmi_priv.main_dir_kset) {
595	kset_unregister(wmi_priv.main_dir_kset);
596	wmi_priv.main_dir_kset = NULL;
597	}
598
599	fail_main_kset:
600	device_destroy(&firmware_attributes_class, MKDEV(0, 0));	581	device_destroy(&firmware_attributes_class, MKDEV(0, 0));
601		582
602	fail_classdev:	583	err_unregister_class:
603	class_unregister(&firmware_attributes_class);	584	class_unregister(&firmware_attributes_class);
604		585
605	fail_class:	586	err_exit_bios_attr_pass_interface:
606	exit_bios_attr_pass_interface();	587	exit_bios_attr_pass_interface();
607		588
608	fail_pass_interface:	589	err_exit_bios_attr_set_interface:
609	exit_bios_attr_set_interface();	590	exit_bios_attr_set_interface();
610		591
611	fail_set_interface:
612	return ret;	592	return ret;
613	}	593	}
614		594

drivers/platform/x86/intel-hid.c+7−0

@@ -90,6 +90,13 @@ static const struct dmi_system_id button_array_table[] = { · 89 unmodified lines
90	DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x2 Detachable"),	90	DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x2 Detachable"),
91	},	91	},
92	},	92	},
		93	{
		94	.ident = "Lenovo ThinkPad X1 Tablet Gen 2",
		95	.matches = {
		96	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		97	DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Tablet Gen 2"),
		98	},
		99	},
93	{ }	100	{ }
94	};	101	};
95		102

drivers/platform/x86/intel-vbtn.c+10−2

 };
 static const struct key_entry intel_vbtn_switchmap[] = {
-	{ KE_SW,     0xCA, { .sw = { SW_DOCK, 1 } } },		/* Docked */
+	/*
-	{ KE_SW,     0xCB, { .sw = { SW_DOCK, 0 } } },		/* Undocked */
+	 * SW_DOCK should only be reported for docking stations, but DSDTs using the
+	 * intel-vbtn code, always seem to use this for 2-in-1s / convertibles and set
+	 * SW_DOCK=1 when in laptop-mode (in tandem with setting SW_TABLET_MODE=0).
+	 * This causes userspace to think the laptop is docked to a port-replicator
+	 * and to disable suspend-on-lid-close, which is undesirable.
+	 * Map the dock events to KEY_IGNORE to avoid this broken SW_DOCK reporting.
+	 */
+	{ KE_IGNORE, 0xCA, { .sw = { SW_DOCK, 1 } } },		/* Docked */
+	{ KE_IGNORE, 0xCB, { .sw = { SW_DOCK, 0 } } },		/* Undocked */
 	{ KE_SW,     0xCC, { .sw = { SW_TABLET_MODE, 1 } } },	/* Tablet */
 	{ KE_SW,     0xCD, { .sw = { SW_TABLET_MODE, 0 } } },	/* Laptop */
 	{ KE_END }

drivers/platform/x86/intel_pmc_core.c+35−15

 }
 DEFINE_SHOW_ATTRIBUTE(pmc_core_pll);
-static ssize_t pmc_core_ltr_ignore_write(struct file *file,
+static int pmc_core_send_ltr_ignore(u32 value)
-					 const char __user *userbuf,
-					 size_t count, loff_t *ppos)
 {
 	struct pmc_dev *pmcdev = &pmc;
 	const struct pmc_reg_map *map = pmcdev->map;
-	u32 val, buf_size, fd;
+	u32 reg;
-	int err;
+	int err = 0;
-	buf_size = count < 64 ? count : 64;
-	err = kstrtou32_from_user(userbuf, buf_size, 10, &val);
-	if (err)
-		return err;
 	mutex_lock(&pmcdev->lock);
-	if (val > map->ltr_ignore_max) {
+	if (value > map->ltr_ignore_max) {
 		err = -EINVAL;
 		goto out_unlock;
 	}
-	fd = pmc_core_reg_read(pmcdev, map->ltr_ignore_offset);
+	reg = pmc_core_reg_read(pmcdev, map->ltr_ignore_offset);
-	fd |= (1U << val);
+	reg |= BIT(value);
-	pmc_core_reg_write(pmcdev, map->ltr_ignore_offset, fd);
+	pmc_core_reg_write(pmcdev, map->ltr_ignore_offset, reg);
 out_unlock:
 	mutex_unlock(&pmcdev->lock);
+	return err;
+}
+static ssize_t pmc_core_ltr_ignore_write(struct file *file,
+					 const char __user *userbuf,
+					 size_t count, loff_t *ppos)
+{
+	u32 buf_size, value;
+	int err;
+	buf_size = min_t(u32, count, 64);
+	err = kstrtou32_from_user(userbuf, buf_size, 10, &value);
+	if (err)
+		return err;
+	err = pmc_core_send_ltr_ignore(value);
 	return err == 0 ? count : err;
 }
 	pmcdev->pmc_xram_read_bit = pmc_core_check_read_lock_bit();
 	dmi_check_system(pmc_core_dmi_table);
+	/*
+	 * On TGL, due to a hardware limitation, the GBE LTR blocks PC10 when
+	 * a cable is attached. Tell the PMC to ignore it.
+	 */
+	if (pmcdev->map == &tgl_reg_map) {
+		dev_dbg(&pdev->dev, "ignoring GBE LTR\n");
+		pmc_core_send_ltr_ignore(3);
+	}
 	pmc_core_dbgfs_register(pmcdev);
 	device_initialized = true;

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

@@ -173,7 +173,7 @@ static int intel_pmt_dev_register(struct intel_pmt_entry *entry, · 172 unmodified lines
173	struct intel_pmt_namespace *ns,	173	struct intel_pmt_namespace *ns,
174	struct device *parent)	174	struct device *parent)
175	{	175	{
176	struct resource res;	176	struct resource res = {0};
177	struct device *dev;	177	struct device *dev;
178	int ret;	178	int ret;
179		179

drivers/platform/x86/intel_pmt_crashlog.c+6−7

 #define CRASH_TYPE_OOBMSM	1
 /* Control Flags */
-#define CRASHLOG_FLAG_DISABLE		BIT(27)
+#define CRASHLOG_FLAG_DISABLE		BIT(28)
 /*
- * Bits 28 and 29 control the state of bit 31.
+ * Bits 29 and 30 control the state of bit 31.
  *
- * Bit 28 will clear bit 31, if set, allowing a new crashlog to be captured.
+ * Bit 29 will clear bit 31, if set, allowing a new crashlog to be captured.
- * Bit 29 will immediately trigger a crashlog to be generated, setting bit 31.
+ * Bit 30 will immediately trigger a crashlog to be generated, setting bit 31.
- * Bit 30 is read-only and reserved as 0.
  * Bit 31 is the read-only status with a 1 indicating log is complete.
  */
-#define CRASHLOG_FLAG_TRIGGER_CLEAR	BIT(28)
+#define CRASHLOG_FLAG_TRIGGER_CLEAR	BIT(29)
-#define CRASHLOG_FLAG_TRIGGER_EXECUTE	BIT(29)
+#define CRASHLOG_FLAG_TRIGGER_EXECUTE	BIT(30)
 #define CRASHLOG_FLAG_TRIGGER_COMPLETE	BIT(31)
 #define CRASHLOG_FLAG_TRIGGER_MASK	GENMASK(31, 28)

drivers/platform/x86/thinkpad_acpi.c+79−29

@@ -4081,13 +4081,19 @@ static bool hotkey_notify_6xxx(const u32 hkey, · 4080 unmodified lines
4081		4081
4082	case TP_HKEY_EV_KEY_NUMLOCK:	4082	case TP_HKEY_EV_KEY_NUMLOCK:
4083	case TP_HKEY_EV_KEY_FN:	4083	case TP_HKEY_EV_KEY_FN:
4084	case TP_HKEY_EV_KEY_FN_ESC:
4085	/* key press events, we just ignore them as long as the EC	4084	/* key press events, we just ignore them as long as the EC
4086	* is still reporting them in the normal keyboard stream */	4085	* is still reporting them in the normal keyboard stream */
4087	*send_acpi_ev = false;	4086	*send_acpi_ev = false;
4088	*ignore_acpi_ev = true;	4087	*ignore_acpi_ev = true;
4089	return true;	4088	return true;
4090		4089
		4090	case TP_HKEY_EV_KEY_FN_ESC:
		4091	/* Get the media key status to foce the status LED to update */
		4092	acpi_evalf(hkey_handle, NULL, "GMKS", "v");
		4093	*send_acpi_ev = false;
		4094	*ignore_acpi_ev = true;
		4095	return true;
		4096
4091	case TP_HKEY_EV_TABLET_CHANGED:	4097	case TP_HKEY_EV_TABLET_CHANGED:
4092	tpacpi_input_send_tabletsw();	4098	tpacpi_input_send_tabletsw();
4093	hotkey_tablet_mode_notify_change();	4099	hotkey_tablet_mode_notify_change();
@@ -9845,6 +9851,11 @@ static struct ibm_struct lcdshadow_driver_data = { · 5751 unmodified lines
9845	* Thinkpad sensor interfaces	9851	* Thinkpad sensor interfaces
9846	*/	9852	*/
9847		9853
		9854	#define DYTC_CMD_QUERY 0 /* To get DYTC status - enable/revision */
		9855	#define DYTC_QUERY_ENABLE_BIT 8 /* Bit 8 - 0 = disabled, 1 = enabled */
		9856	#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */
		9857	#define DYTC_QUERY_REV_BIT 28 /* Bits 28 - 31 - revision */
		9858
9848	#define DYTC_CMD_GET 2 /* To get current IC function and mode */	9859	#define DYTC_CMD_GET 2 /* To get current IC function and mode */
9849	#define DYTC_GET_LAPMODE_BIT 17 /* Set when in lapmode */	9860	#define DYTC_GET_LAPMODE_BIT 17 /* Set when in lapmode */
9850		9861
@@ -9855,6 +9866,7 @@ static bool has_palmsensor; · 4 unmodified lines
9855	static bool has_lapsensor;	9866	static bool has_lapsensor;
9856	static bool palm_state;	9867	static bool palm_state;
9857	static bool lap_state;	9868	static bool lap_state;
		9869	static int dytc_version;
9858		9870
9859	static int dytc_command(int command, int *output)	9871	static int dytc_command(int command, int *output)
9860	{	9872	{
@@ -9869,6 +9881,33 @@ static int dytc_command(int command, int *output) · 8 unmodified lines
9869	return 0;	9881	return 0;
9870	}	9882	}
9871		9883
		9884	static int dytc_get_version(void)
		9885	{
		9886	int err, output;
		9887
		9888	/* Check if we've been called before - and just return cached value */
		9889	if (dytc_version)
		9890	return dytc_version;
		9891
		9892	/* Otherwise query DYTC and extract version information */
		9893	err = dytc_command(DYTC_CMD_QUERY, &output);
		9894	/*
		9895	* If support isn't available (ENODEV) then don't return an error
		9896	* and don't create the sysfs group
		9897	*/
		9898	if (err == -ENODEV)
		9899	return 0;
		9900	/* For all other errors we can flag the failure */
		9901	if (err)
		9902	return err;
		9903
		9904	/* Check DYTC is enabled and supports mode setting */
		9905	if (output & BIT(DYTC_QUERY_ENABLE_BIT))
		9906	dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF;
		9907
		9908	return 0;
		9909	}
		9910
9872	static int lapsensor_get(bool present, bool state)	9911	static int lapsensor_get(bool present, bool state)
9873	{	9912	{
9874	int output, err;	9913	int output, err;
@@ -9974,7 +10013,18 @@ static int tpacpi_proxsensor_init(struct ibm_init_struct *iibm) · 99 unmodified lines
9974	if (err)	10013	if (err)
9975	return err;	10014	return err;
9976	}	10015	}
9977	if (has_lapsensor) {	10016
		10017	/* Check if we know the DYTC version, if we don't then get it */
		10018	if (!dytc_version) {
		10019	err = dytc_get_version();
		10020	if (err)
		10021	return err;
		10022	}
		10023	/*
		10024	* Platforms before DYTC version 5 claim to have a lap sensor, but it doesn't work, so we
		10025	* ignore them
		10026	*/
		10027	if (has_lapsensor && (dytc_version >= 5)) {
9978	err = sysfs_create_file(&tpacpi_pdev->dev.kobj, &dev_attr_dytc_lapmode.attr);	10028	err = sysfs_create_file(&tpacpi_pdev->dev.kobj, &dev_attr_dytc_lapmode.attr);
9979	if (err)	10029	if (err)
9980	return err;	10030	return err;
@@ -9999,14 +10049,9 @@ static struct ibm_struct proxsensor_driver_data = { · 18 unmodified lines
9999	* DYTC Platform Profile interface	10049	* DYTC Platform Profile interface
10000	*/	10050	*/
10001		10051
10002	#define DYTC_CMD_QUERY 0 /* To get DYTC status - enable/revision */
10003	#define DYTC_CMD_SET 1 /* To enable/disable IC function mode */	10052	#define DYTC_CMD_SET 1 /* To enable/disable IC function mode */
10004	#define DYTC_CMD_RESET 0x1ff /* To reset back to default */	10053	#define DYTC_CMD_RESET 0x1ff /* To reset back to default */
10005		10054
10006	#define DYTC_QUERY_ENABLE_BIT 8 /* Bit 8 - 0 = disabled, 1 = enabled */
10007	#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */
10008	#define DYTC_QUERY_REV_BIT 28 /* Bits 28 - 31 - revision */
10009
10010	#define DYTC_GET_FUNCTION_BIT 8 /* Bits 8-11 - function setting */	10055	#define DYTC_GET_FUNCTION_BIT 8 /* Bits 8-11 - function setting */
10011	#define DYTC_GET_MODE_BIT 12 /* Bits 12-15 - mode setting */	10056	#define DYTC_GET_MODE_BIT 12 /* Bits 12-15 - mode setting */
10012		10057
@@ -10142,8 +10187,13 @@ static int dytc_profile_set(struct platform_profile_handler *pprof, · 129 unmodified lines
10142	return err;	10187	return err;
10143		10188
10144	if (profile == PLATFORM_PROFILE_BALANCED) {	10189	if (profile == PLATFORM_PROFILE_BALANCED) {
10145	/* To get back to balanced mode we just issue a reset command */	10190	/*
10146	err = dytc_command(DYTC_CMD_RESET, &output);	10191	* To get back to balanced mode we need to issue a reset command.
		10192	* Note we still need to disable CQL mode before hand and re-enable
		10193	* it afterwards, otherwise dytc_lapmode gets reset to 0 and stays
		10194	* stuck at 0 for aprox. 30 minutes.
		10195	*/
		10196	err = dytc_cql_command(DYTC_CMD_RESET, &output);
10147	if (err)	10197	if (err)
10148	goto unlock;	10198	goto unlock;
10149	} else {	10199	} else {
@@ -10211,28 +10261,28 @@ static int tpacpi_dytc_profile_init(struct ibm_init_struct *iibm) · 61 unmodified lines
10211	if (err)	10261	if (err)
10212	return err;	10262	return err;
10213		10263
		10264	/* Check if we know the DYTC version, if we don't then get it */
		10265	if (!dytc_version) {
		10266	err = dytc_get_version();
		10267	if (err)
		10268	return err;
		10269	}
10214	/* Check DYTC is enabled and supports mode setting */	10270	/* Check DYTC is enabled and supports mode setting */
10215	if (output & BIT(DYTC_QUERY_ENABLE_BIT)) {	10271	if (dytc_version >= 5) {
10216	/* Only DYTC v5.0 and later has this feature. */	10272	dbg_printk(TPACPI_DBG_INIT,
10217	int dytc_version;	10273	"DYTC version %d: thermal mode available\n", dytc_version);
10218		10274	/* Create platform_profile structure and register */
10219	dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF;	10275	err = platform_profile_register(&dytc_profile);
10220	if (dytc_version >= 5) {	10276	/*
10221	dbg_printk(TPACPI_DBG_INIT,	10277	* If for some reason platform_profiles aren't enabled
10222	"DYTC version %d: thermal mode available\n", dytc_version);	10278	* don't quit terminally.
10223	/* Create platform_profile structure and register */	10279	*/
10224	err = platform_profile_register(&dytc_profile);	10280	if (err)
10225	/*	10281	return 0;
10226	* If for some reason platform_profiles aren't enabled
10227	* don't quit terminally.
10228	*/
10229	if (err)
10230	return 0;
10231		10282
10232	dytc_profile_available = true;	10283	dytc_profile_available = true;
10233	/* Ensure initial values are correct */	10284	/* Ensure initial values are correct */
10234	dytc_profile_refresh();	10285	dytc_profile_refresh();
10235	}
10236	}	10286	}
10237	return 0;	10287	return 0;
10238	}	10288	}

drivers/ptp/ptp_qoriq.c+7−6

 	tmr_add = ptp_qoriq->tmr_add;
 	adj = tmr_add;
-	/* calculate diff as adj*(scaled_ppm/65536)/1000000
+	/*
-	 * and round() to the nearest integer
+	 * Calculate diff and round() to the nearest integer
+	 *
+	 * diff = adj * (ppb / 1000000000)
+	 *      = adj * scaled_ppm / 65536000000
 	 */
-	adj *= scaled_ppm;
+	diff = mul_u64_u64_div_u64(adj, scaled_ppm, 32768000000);
-	diff = div_u64(adj, 8000000);
+	diff = DIV64_U64_ROUND_UP(diff, 2);
-	diff = (diff >> 13) + ((diff >> 12) & 1);
 	tmr_add = neg_adj ? tmr_add - diff : tmr_add + diff;
 	ptp_qoriq->write(&regs->ctrl_regs->tmr_add, tmr_add);
 	return 0;

drivers/regulator/mt6315-regulator.c+2−2

@@ -41,7 +41,7 @@ struct mt6315_chip { · 40 unmodified lines
41	.type = REGULATOR_VOLTAGE, \	41	.type = REGULATOR_VOLTAGE, \
42	.id = _bid, \	42	.id = _bid, \
43	.owner = THIS_MODULE, \	43	.owner = THIS_MODULE, \
44	.n_voltages = 0xbf, \	44	.n_voltages = 0xc0, \
45	.linear_ranges = mt_volt_range1, \	45	.linear_ranges = mt_volt_range1, \
46	.n_linear_ranges = ARRAY_SIZE(mt_volt_range1), \	46	.n_linear_ranges = ARRAY_SIZE(mt_volt_range1), \
47	.vsel_reg = _vsel, \	47	.vsel_reg = _vsel, \
@@ -69,7 +69,7 @@ static unsigned int mt6315_map_mode(u32 mode) · 21 unmodified lines
69	case MT6315_BUCK_MODE_LP:	69	case MT6315_BUCK_MODE_LP:
70	return REGULATOR_MODE_IDLE;	70	return REGULATOR_MODE_IDLE;
71	default:	71	default:
72	return -EINVAL;	72	return REGULATOR_MODE_INVALID;
73	}	73	}
74	}	74	}
75		75

drivers/regulator/pca9450-regulator.c+9−1

 		return ret;
 	}
+	/* Clear PRESET_EN bit in BUCK123_DVS to use DVS registers */
+	ret = regmap_clear_bits(pca9450->regmap, PCA9450_REG_BUCK123_DVS,
+				BUCK123_PRESET_EN);
+	if (ret) {
+		dev_err(&i2c->dev, "Failed to clear PRESET_EN bit: %d\n", ret);
+		return ret;
+	}
 	/* Set reset behavior on assertion of WDOG_B signal */
 	ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL,
 				WDOG_B_CFG_MASK, WDOG_B_CFG_COLD_LDO12);
 	if (IS_ERR(pca9450->sd_vsel_gpio)) {
 		dev_err(&i2c->dev, "Failed to get SD_VSEL GPIO\n");
-		return ret;
+		return PTR_ERR(pca9450->sd_vsel_gpio);
 	}
 	dev_info(&i2c->dev, "%s probed.\n",

drivers/regulator/qcom-rpmh-regulator.c+3−3

@@ -726,8 +726,8 @@ static const struct rpmh_vreg_hw_data pmic5_ftsmps510 = { · 725 unmodified lines
726	static const struct rpmh_vreg_hw_data pmic5_hfsmps515 = {	726	static const struct rpmh_vreg_hw_data pmic5_hfsmps515 = {
727	.regulator_type = VRM,	727	.regulator_type = VRM,
728	.ops = &rpmh_regulator_vrm_ops,	728	.ops = &rpmh_regulator_vrm_ops,
729	.voltage_range = REGULATOR_LINEAR_RANGE(2800000, 0, 4, 16000),	729	.voltage_range = REGULATOR_LINEAR_RANGE(320000, 0, 235, 16000),
730	.n_voltages = 5,	730	.n_voltages = 236,
731	.pmic_mode_map = pmic_mode_map_pmic5_smps,	731	.pmic_mode_map = pmic_mode_map_pmic5_smps,
732	.of_map_mode = rpmh_regulator_pmic4_smps_of_map_mode,	732	.of_map_mode = rpmh_regulator_pmic4_smps_of_map_mode,
733	};	733	};
@@ -901,7 +901,7 @@ static const struct rpmh_vreg_init_data pm8350_vreg_data[] = { · 167 unmodified lines
901	};	901	};
902		902
903	static const struct rpmh_vreg_init_data pm8350c_vreg_data[] = {	903	static const struct rpmh_vreg_init_data pm8350c_vreg_data[] = {
904	RPMH_VREG("smps1", "smp%s1", &pmic5_hfsmps510, "vdd-s1"),	904	RPMH_VREG("smps1", "smp%s1", &pmic5_hfsmps515, "vdd-s1"),
905	RPMH_VREG("smps2", "smp%s2", &pmic5_ftsmps510, "vdd-s2"),	905	RPMH_VREG("smps2", "smp%s2", &pmic5_ftsmps510, "vdd-s2"),
906	RPMH_VREG("smps3", "smp%s3", &pmic5_ftsmps510, "vdd-s3"),	906	RPMH_VREG("smps3", "smp%s3", &pmic5_ftsmps510, "vdd-s3"),
907	RPMH_VREG("smps4", "smp%s4", &pmic5_ftsmps510, "vdd-s4"),	907	RPMH_VREG("smps4", "smp%s4", &pmic5_ftsmps510, "vdd-s4"),

drivers/regulator/rt4831-regulator.c+2−2

@@ -153,9 +153,9 @@ static int rt4831_regulator_probe(struct platform_device *pdev) · 152 unmodified lines
153	int i, ret;	153	int i, ret;
154		154
155	regmap = dev_get_regmap(pdev->dev.parent, NULL);	155	regmap = dev_get_regmap(pdev->dev.parent, NULL);
156	if (IS_ERR(regmap)) {	156	if (!regmap) {
157	dev_err(&pdev->dev, "Failed to init regmap\n");	157	dev_err(&pdev->dev, "Failed to init regmap\n");
158	return PTR_ERR(regmap);	158	return -ENODEV;
159	}	159	}
160		160
161	/* Configure DSV mode to normal by default */	161	/* Configure DSV mode to normal by default */

drivers/s390/block/dasd.c+3−4

 MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>");
 MODULE_DESCRIPTION("Linux on S/390 DASD device driver,"
 		   " Copyright IBM Corp. 2000");
-MODULE_SUPPORTED_DEVICE("dasd");
 MODULE_LICENSE("GPL");
 /*
 	basedev = block->base;
 	spin_lock_irq(&dq->lock);
-	if (basedev->state < DASD_STATE_READY) {
+	if (basedev->state < DASD_STATE_READY ||
+	    test_bit(DASD_FLAG_OFFLINE, &basedev->flags)) {
 		DBF_DEV_EVENT(DBF_ERR, basedev,
 			      "device not ready for request %p", req);
 		rc = BLK_STS_IOERR;
 	struct dasd_device *device;
 	struct dasd_block *block;
-	cdev->handler = NULL;
 	device = dasd_device_from_cdev(cdev);
 	if (IS_ERR(device)) {
 		dasd_remove_sysfs_files(cdev);
 	 * no quite down yet.
 	 */
 	dasd_set_target_state(device, DASD_STATE_NEW);
+	cdev->handler = NULL;
 	/* dasd_delete_device destroys the device reference. */
 	block = device->block;
 	dasd_delete_device(device);

drivers/s390/char/tty3270.c+4−2

 			 * last output position matches the start address
 			 * of this line.
 			 */
-			if (s->string[1] == sba[0] && s->string[2] == sba[1])
+			if (s->string[1] == sba[0] && s->string[2] == sba[1]) {
-				str += 3, len -= 3;
+				str += 3;
+				len -= 3;
+			}
 			if (raw3270_request_add_data(wrq, str, len) != 0)
 				break;
 			list_del_init(&s->update);

drivers/s390/char/zcore.c+27−17

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include <linux/init.h>	15	#include <linux/init.h>
16	#include <linux/slab.h>	16	#include <linux/slab.h>
17	#include <linux/debugfs.h>	17	#include <linux/debugfs.h>
		18	#include <linux/reboot.h>
18		19
19	#include <asm/asm-offsets.h>	20	#include <asm/asm-offsets.h>
20	#include <asm/ipl.h>	21	#include <asm/ipl.h>
@@ -238,6 +239,28 @@ static int __init zcore_reipl_init(void) · 217 unmodified lines
238	return 0;	239	return 0;
239	}	240	}
240		241
		242	static int zcore_reboot_and_on_panic_handler(struct notifier_block *self,
		243	unsigned long event,
		244	void *data)
		245	{
		246	if (hsa_available)
		247	release_hsa();
		248
		249	return NOTIFY_OK;
		250	}
		251
		252	static struct notifier_block zcore_reboot_notifier = {
		253	.notifier_call = zcore_reboot_and_on_panic_handler,
		254	/* we need to be notified before reipl and kdump */
		255	.priority = INT_MAX,
		256	};
		257
		258	static struct notifier_block zcore_on_panic_notifier = {
		259	.notifier_call = zcore_reboot_and_on_panic_handler,
		260	/* we need to be notified before reipl and kdump */
		261	.priority = INT_MAX,
		262	};
		263
241	static int __init zcore_init(void)	264	static int __init zcore_init(void)
242	{	265	{
243	unsigned char arch;	266	unsigned char arch;
@@ -293,28 +316,15 @@ static int __init zcore_init(void) · 49 unmodified lines
293	goto fail;	316	goto fail;
294		317
295	zcore_dir = debugfs_create_dir("zcore" , NULL);	318	zcore_dir = debugfs_create_dir("zcore" , NULL);
296	if (!zcore_dir) {
297	rc = -ENOMEM;
298	goto fail;
299	}
300	zcore_reipl_file = debugfs_create_file("reipl", S_IRUSR, zcore_dir,	319	zcore_reipl_file = debugfs_create_file("reipl", S_IRUSR, zcore_dir,
301	NULL, &zcore_reipl_fops);	320	NULL, &zcore_reipl_fops);
302	if (!zcore_reipl_file) {
303	rc = -ENOMEM;
304	goto fail_dir;
305	}
306	zcore_hsa_file = debugfs_create_file("hsa", S_IRUSR\|S_IWUSR, zcore_dir,	321	zcore_hsa_file = debugfs_create_file("hsa", S_IRUSR\|S_IWUSR, zcore_dir,
307	NULL, &zcore_hsa_fops);	322	NULL, &zcore_hsa_fops);
308	if (!zcore_hsa_file) {
309	rc = -ENOMEM;
310	goto fail_reipl_file;
311	}
312	return 0;
313		323
314	fail_reipl_file:	324	register_reboot_notifier(&zcore_reboot_notifier);
315	debugfs_remove(zcore_reipl_file);	325	atomic_notifier_chain_register(&panic_notifier_list, &zcore_on_panic_notifier);
316	fail_dir:	326
317	debugfs_remove(zcore_dir);	327	return 0;
318	fail:	328	fail:
319	diag308(DIAG308_REL_HSA, NULL);	329	diag308(DIAG308_REL_HSA, NULL);
320	return rc;	330	return rc;

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

@@ -47,7 +47,7 @@ static void ccw_timeout_log(struct ccw_device *cdev) · 46 unmodified lines
47	orb = &private->orb;	47	orb = &private->orb;
48	cc = stsch(sch->schid, &schib);	48	cc = stsch(sch->schid, &schib);
49		49
50	printk(KERN_WARNING "cio: ccw device timeout occurred at %llx, "	50	printk(KERN_WARNING "cio: ccw device timeout occurred at %lx, "
51	"device information:\n", get_tod_clock());	51	"device information:\n", get_tod_clock());
52	printk(KERN_WARNING "cio: orb:\n");	52	printk(KERN_WARNING "cio: orb:\n");
53	print_hex_dump(KERN_WARNING, "cio: ", DUMP_PREFIX_NONE, 16, 1,	53	print_hex_dump(KERN_WARNING, "cio: ", DUMP_PREFIX_NONE, 16, 1,

drivers/s390/cio/vfio_ccw_ops.c+3−3

@@ -543,7 +543,7 @@ static ssize_t vfio_ccw_mdev_ioctl(struct mdev_device *mdev, · 542 unmodified lines
543	if (ret)	543	if (ret)
544	return ret;	544	return ret;
545		545
546	return copy_to_user((void __user *)arg, &info, minsz);	546	return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
547	}	547	}
548	case VFIO_DEVICE_GET_REGION_INFO:	548	case VFIO_DEVICE_GET_REGION_INFO:
549	{	549	{
@@ -561,7 +561,7 @@ static ssize_t vfio_ccw_mdev_ioctl(struct mdev_device *mdev, · 11 unmodified lines
561	if (ret)	561	if (ret)
562	return ret;	562	return ret;
563		563
564	return copy_to_user((void __user *)arg, &info, minsz);	564	return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
565	}	565	}
566	case VFIO_DEVICE_GET_IRQ_INFO:	566	case VFIO_DEVICE_GET_IRQ_INFO:
567	{	567	{
@@ -582,7 +582,7 @@ static ssize_t vfio_ccw_mdev_ioctl(struct mdev_device *mdev, · 14 unmodified lines
582	if (info.count == -1)	582	if (info.count == -1)
583	return -EINVAL;	583	return -EINVAL;
584		584
585	return copy_to_user((void __user *)arg, &info, minsz);	585	return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
586	}	586	}
587	case VFIO_DEVICE_SET_IRQS:	587	case VFIO_DEVICE_SET_IRQS:
588	{	588	{

drivers/s390/crypto/vfio_ap_ops.c+1−1

@@ -1286,7 +1286,7 @@ static int vfio_ap_mdev_get_device_info(unsigned long arg) · 1285 unmodified lines
1286	info.num_regions = 0;	1286	info.num_regions = 0;
1287	info.num_irqs = 0;	1287	info.num_irqs = 0;
1288		1288
1289	return copy_to_user((void __user *)arg, &info, minsz);	1289	return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
1290	}	1290	}
1291		1291
1292	static ssize_t vfio_ap_mdev_ioctl(struct mdev_device *mdev,	1292	static ssize_t vfio_ap_mdev_ioctl(struct mdev_device *mdev,

drivers/sbus/char/display7seg.c+0−1

@@ -50,7 +50,6 @@ MODULE_PARM_DESC(sol_compat, · 49 unmodified lines
50	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");	50	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
51	MODULE_DESCRIPTION("7-Segment Display driver for Sun Microsystems CP1400/1500");	51	MODULE_DESCRIPTION("7-Segment Display driver for Sun Microsystems CP1400/1500");
52	MODULE_LICENSE("GPL");	52	MODULE_LICENSE("GPL");
53	MODULE_SUPPORTED_DEVICE("d7s");
54		53
55	struct d7s {	54	struct d7s {
56	void __iomem *regs;	55	void __iomem *regs;

drivers/scsi/hpsa.c+0−1

@@ -80,7 +80,6 @@ · 79 unmodified lines
80	MODULE_AUTHOR("Hewlett-Packard Company");	80	MODULE_AUTHOR("Hewlett-Packard Company");
81	MODULE_DESCRIPTION("Driver for HP Smart Array Controller version " \	81	MODULE_DESCRIPTION("Driver for HP Smart Array Controller version " \
82	HPSA_DRIVER_VERSION);	82	HPSA_DRIVER_VERSION);
83	MODULE_SUPPORTED_DEVICE("HP Smart Array Controllers");
84	MODULE_VERSION(HPSA_DRIVER_VERSION);	83	MODULE_VERSION(HPSA_DRIVER_VERSION);
85	MODULE_LICENSE("GPL");	84	MODULE_LICENSE("GPL");
86	MODULE_ALIAS("cciss");	85	MODULE_ALIAS("cciss");

drivers/scsi/ibmvscsi/ibmvfc.c+38−26

@@ -21,6 +21,7 @@ · 20 unmodified lines
21	#include <linux/bsg-lib.h>	21	#include <linux/bsg-lib.h>
22	#include <asm/firmware.h>	22	#include <asm/firmware.h>
23	#include <asm/irq.h>	23	#include <asm/irq.h>
		24	#include <asm/rtas.h>
24	#include <asm/vio.h>	25	#include <asm/vio.h>
25	#include <scsi/scsi.h>	26	#include <scsi/scsi.h>
26	#include <scsi/scsi_cmnd.h>	27	#include <scsi/scsi_cmnd.h>
@@ -158,6 +159,9 @@ static void ibmvfc_npiv_logout(struct ibmvfc_host *); · 131 unmodified lines
158	static void ibmvfc_tgt_implicit_logout_and_del(struct ibmvfc_target *);	159	static void ibmvfc_tgt_implicit_logout_and_del(struct ibmvfc_target *);
159	static void ibmvfc_tgt_move_login(struct ibmvfc_target *);	160	static void ibmvfc_tgt_move_login(struct ibmvfc_target *);
160		161
		162	static void ibmvfc_release_sub_crqs(struct ibmvfc_host *);
		163	static void ibmvfc_init_sub_crqs(struct ibmvfc_host *);
		164
161	static const char *unknown_error = "unknown error";	165	static const char *unknown_error = "unknown error";
162		166
163	static long h_reg_sub_crq(unsigned long unit_address, unsigned long ioba,	167	static long h_reg_sub_crq(unsigned long unit_address, unsigned long ioba,
@@ -899,6 +903,9 @@ static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost) · 735 unmodified lines
899	{	903	{
900	int rc = 0;	904	int rc = 0;
901	struct vio_dev *vdev = to_vio_dev(vhost->dev);	905	struct vio_dev *vdev = to_vio_dev(vhost->dev);
		906	unsigned long flags;
		907
		908	ibmvfc_release_sub_crqs(vhost);
902		909
903	/* Re-enable the CRQ */	910	/* Re-enable the CRQ */
904	do {	911	do {
@@ -910,6 +917,15 @@ static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost) · 5 unmodified lines
910	if (rc)	917	if (rc)
911	dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);	918	dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);
912		919
		920	spin_lock_irqsave(vhost->host->host_lock, flags);
		921	spin_lock(vhost->crq.q_lock);
		922	vhost->do_enquiry = 1;
		923	vhost->using_channels = 0;
		924	spin_unlock(vhost->crq.q_lock);
		925	spin_unlock_irqrestore(vhost->host->host_lock, flags);
		926
		927	ibmvfc_init_sub_crqs(vhost);
		928
913	return rc;	929	return rc;
914	}	930	}
915		931
@@ -926,8 +942,8 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost) · 10 unmodified lines
926	unsigned long flags;	942	unsigned long flags;
927	struct vio_dev *vdev = to_vio_dev(vhost->dev);	943	struct vio_dev *vdev = to_vio_dev(vhost->dev);
928	struct ibmvfc_queue *crq = &vhost->crq;	944	struct ibmvfc_queue *crq = &vhost->crq;
929	struct ibmvfc_queue *scrq;	945
930	int i;	946	ibmvfc_release_sub_crqs(vhost);
931		947
932	/* Close the CRQ */	948	/* Close the CRQ */
933	do {	949	do {
@@ -947,16 +963,6 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost) · 13 unmodified lines
947	memset(crq->msgs.crq, 0, PAGE_SIZE);	963	memset(crq->msgs.crq, 0, PAGE_SIZE);
948	crq->cur = 0;	964	crq->cur = 0;
949		965
950	if (vhost->scsi_scrqs.scrqs) {
951	for (i = 0; i < nr_scsi_hw_queues; i++) {
952	scrq = &vhost->scsi_scrqs.scrqs[i];
953	spin_lock(scrq->q_lock);
954	memset(scrq->msgs.scrq, 0, PAGE_SIZE);
955	scrq->cur = 0;
956	spin_unlock(scrq->q_lock);
957	}
958	}
959
960	/* And re-open it again */	966	/* And re-open it again */
961	rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,	967	rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
962	crq->msg_token, PAGE_SIZE);	968	crq->msg_token, PAGE_SIZE);
@@ -966,9 +972,12 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost) · 3 unmodified lines
966	dev_warn(vhost->dev, "Partner adapter not ready\n");	972	dev_warn(vhost->dev, "Partner adapter not ready\n");
967	else if (rc != 0)	973	else if (rc != 0)
968	dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);	974	dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);
		975
969	spin_unlock(vhost->crq.q_lock);	976	spin_unlock(vhost->crq.q_lock);
970	spin_unlock_irqrestore(vhost->host->host_lock, flags);	977	spin_unlock_irqrestore(vhost->host->host_lock, flags);
971		978
		979	ibmvfc_init_sub_crqs(vhost);
		980
972	return rc;	981	return rc;
973	}	982	}
974		983
@@ -5642,7 +5651,8 @@ static int ibmvfc_register_scsi_channel(struct ibmvfc_host *vhost, · 4667 unmodified lines
5642	rc = h_reg_sub_crq(vdev->unit_address, scrq->msg_token, PAGE_SIZE,	5651	rc = h_reg_sub_crq(vdev->unit_address, scrq->msg_token, PAGE_SIZE,
5643	&scrq->cookie, &scrq->hw_irq);	5652	&scrq->cookie, &scrq->hw_irq);
5644		5653
5645	if (rc) {	5654	/* H_CLOSED indicates successful register, but no CRQ partner */
		5655	if (rc && rc != H_CLOSED) {
5646	dev_warn(dev, "Error registering sub-crq: %d\n", rc);	5656	dev_warn(dev, "Error registering sub-crq: %d\n", rc);
5647	if (rc == H_PARAMETER)	5657	if (rc == H_PARAMETER)
5648	dev_warn_once(dev, "Firmware may not support MQ\n");	5658	dev_warn_once(dev, "Firmware may not support MQ\n");
@@ -5675,8 +5685,8 @@ static int ibmvfc_register_scsi_channel(struct ibmvfc_host *vhost, · 26 unmodified lines
5675		5685
5676	irq_failed:	5686	irq_failed:
5677	do {	5687	do {
5678	plpar_hcall_norets(H_FREE_SUB_CRQ, vdev->unit_address, scrq->cookie);	5688	rc = plpar_hcall_norets(H_FREE_SUB_CRQ, vdev->unit_address, scrq->cookie);
5679	} while (rc == H_BUSY \|\| H_IS_LONG_BUSY(rc));	5689	} while (rtas_busy_delay(rc));
5680	reg_failed:	5690	reg_failed:
5681	ibmvfc_free_queue(vhost, scrq);	5691	ibmvfc_free_queue(vhost, scrq);
5682	LEAVE;	5692	LEAVE;
@@ -5694,6 +5704,7 @@ static void ibmvfc_deregister_scsi_channel(struct ibmvfc_host *vhost, int index) · 11 unmodified lines
5694		5704
5695	free_irq(scrq->irq, scrq);	5705	free_irq(scrq->irq, scrq);
5696	irq_dispose_mapping(scrq->irq);	5706	irq_dispose_mapping(scrq->irq);
		5707	scrq->irq = 0;
5697		5708
5698	do {	5709	do {
5699	rc = plpar_hcall_norets(H_FREE_SUB_CRQ, vdev->unit_address,	5710	rc = plpar_hcall_norets(H_FREE_SUB_CRQ, vdev->unit_address,
@@ -5707,17 +5718,21 @@ static void ibmvfc_deregister_scsi_channel(struct ibmvfc_host *vhost, int index) · 7 unmodified lines
5707	LEAVE;	5718	LEAVE;
5708	}	5719	}
5709		5720
5710	static int ibmvfc_init_sub_crqs(struct ibmvfc_host *vhost)	5721	static void ibmvfc_init_sub_crqs(struct ibmvfc_host *vhost)
5711	{	5722	{
5712	int i, j;	5723	int i, j;
5713		5724
5714	ENTER;	5725	ENTER;
		5726	if (!vhost->mq_enabled)
		5727	return;
5715		5728
5716	vhost->scsi_scrqs.scrqs = kcalloc(nr_scsi_hw_queues,	5729	vhost->scsi_scrqs.scrqs = kcalloc(nr_scsi_hw_queues,
5717	sizeof(*vhost->scsi_scrqs.scrqs),	5730	sizeof(*vhost->scsi_scrqs.scrqs),
5718	GFP_KERNEL);	5731	GFP_KERNEL);
5719	if (!vhost->scsi_scrqs.scrqs)	5732	if (!vhost->scsi_scrqs.scrqs) {
5720	return -1;	5733	vhost->do_enquiry = 0;
		5734	return;
		5735	}
5721		5736
5722	for (i = 0; i < nr_scsi_hw_queues; i++) {	5737	for (i = 0; i < nr_scsi_hw_queues; i++) {
5723	if (ibmvfc_register_scsi_channel(vhost, i)) {	5738	if (ibmvfc_register_scsi_channel(vhost, i)) {
@@ -5726,13 +5741,12 @@ static int ibmvfc_init_sub_crqs(struct ibmvfc_host *vhost) · 2 unmodified lines
5726	kfree(vhost->scsi_scrqs.scrqs);	5741	kfree(vhost->scsi_scrqs.scrqs);
5727	vhost->scsi_scrqs.scrqs = NULL;	5742	vhost->scsi_scrqs.scrqs = NULL;
5728	vhost->scsi_scrqs.active_queues = 0;	5743	vhost->scsi_scrqs.active_queues = 0;
5729	LEAVE;	5744	vhost->do_enquiry = 0;
5730	return -1;	5745	break;
5731	}	5746	}
5732	}	5747	}
5733		5748
5734	LEAVE;	5749	LEAVE;
5735	return 0;
5736	}	5750	}
5737		5751
5738	static void ibmvfc_release_sub_crqs(struct ibmvfc_host *vhost)	5752	static void ibmvfc_release_sub_crqs(struct ibmvfc_host *vhost)
@@ -5770,6 +5784,8 @@ static void ibmvfc_free_mem(struct ibmvfc_host *vhost) · 31 unmodified lines
5770	vhost->disc_buf_dma);	5784	vhost->disc_buf_dma);
5771	dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),	5785	dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),
5772	vhost->login_buf, vhost->login_buf_dma);	5786	vhost->login_buf, vhost->login_buf_dma);
		5787	dma_free_coherent(vhost->dev, sizeof(*vhost->channel_setup_buf),
		5788	vhost->channel_setup_buf, vhost->channel_setup_dma);
5773	dma_pool_destroy(vhost->sg_pool);	5789	dma_pool_destroy(vhost->sg_pool);
5774	ibmvfc_free_queue(vhost, async_q);	5790	ibmvfc_free_queue(vhost, async_q);
5775	LEAVE;	5791	LEAVE;
@@ -5999,11 +6015,7 @@ static int ibmvfc_probe(struct vio_dev vdev, const struct vio_device_id id) · 223 unmodified lines
5999	goto remove_shost;	6015	goto remove_shost;
6000	}	6016	}
6001		6017
6002	if (vhost->mq_enabled) {	6018	ibmvfc_init_sub_crqs(vhost);
6003	rc = ibmvfc_init_sub_crqs(vhost);
6004	if (rc)
6005	dev_warn(dev, "Failed to allocate Sub-CRQs. rc=%d\n", rc);
6006	}
6007		6019
6008	if (shost_to_fc_host(shost)->rqst_q)	6020	if (shost_to_fc_host(shost)->rqst_q)
6009	blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);	6021	blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);

drivers/scsi/lpfc/lpfc_debugfs.c+2−2

@@ -2421,7 +2421,7 @@ lpfc_debugfs_dif_err_write(struct file file, const char __user buf, · 2420 unmodified lines
2421	memset(dstbuf, 0, 33);	2421	memset(dstbuf, 0, 33);
2422	size = (nbytes < 32) ? nbytes : 32;	2422	size = (nbytes < 32) ? nbytes : 32;
2423	if (copy_from_user(dstbuf, buf, size))	2423	if (copy_from_user(dstbuf, buf, size))
2424	return 0;	2424	return -EFAULT;
2425		2425
2426	if (dent == phba->debug_InjErrLBA) {	2426	if (dent == phba->debug_InjErrLBA) {
2427	if ((dstbuf[0] == 'o') && (dstbuf[1] == 'f') &&	2427	if ((dstbuf[0] == 'o') && (dstbuf[1] == 'f') &&
@@ -2430,7 +2430,7 @@ lpfc_debugfs_dif_err_write(struct file file, const char __user buf, · 2 unmodified lines
2430	}	2430	}
2431		2431
2432	if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))	2432	if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))
2433	return 0;	2433	return -EINVAL;
2434		2434
2435	if (dent == phba->debug_writeGuard)	2435	if (dent == phba->debug_writeGuard)
2436	phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;	2436	phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;

drivers/scsi/mpt3sas/mpt3sas_scsih.c+1−1

@@ -413,7 +413,7 @@ mpt3sas_get_port_by_id(struct MPT3SAS_ADAPTER *ioc, · 412 unmodified lines
413	* And add this object to port_table_list.	413	* And add this object to port_table_list.
414	*/	414	*/
415	if (!ioc->multipath_on_hba) {	415	if (!ioc->multipath_on_hba) {
416	port = kzalloc(sizeof(struct hba_port), GFP_KERNEL);	416	port = kzalloc(sizeof(struct hba_port), GFP_ATOMIC);
417	if (!port)	417	if (!port)
418	return NULL;	418	return NULL;
419		419

drivers/scsi/myrs.c+1−1

 	if (cs->mmio_base) {
 		cs->disable_intr(cs);
 		iounmap(cs->mmio_base);
+		cs->mmio_base = NULL;
 	}
 	if (cs->irq)
 		free_irq(cs->irq, cs);
 	if (cs->io_addr)
 		release_region(cs->io_addr, 0x80);
-	iounmap(cs->mmio_base);
 	pci_set_drvdata(pdev, NULL);
 	pci_disable_device(pdev);
 	scsi_host_put(cs->host);

drivers/scsi/pcmcia/nsp_cs.c+0−1

@@ -55,7 +55,6 @@ · 54 unmodified lines
55		55
56	MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>");	56	MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>");
57	MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module");	57	MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module");
58	MODULE_SUPPORTED_DEVICE("sd,sr,sg,st");
59	MODULE_LICENSE("GPL");	58	MODULE_LICENSE("GPL");
60		59
61	#include "nsp_io.h"	60	#include "nsp_io.h"

drivers/scsi/qla2xxx/qla_target.h+1−1

 	(min(1270, ((ql) > 0) ? (QLA_TGT_DATASEGS_PER_CMD_24XX + \
 		QLA_TGT_DATASEGS_PER_CONT_24XX*((ql) - 1)) : 0))
 #endif
-#endif
 #define GET_TARGET_ID(ha, iocb) ((HAS_EXTENDED_IDS(ha))			\
 			 ? le16_to_cpu((iocb)->u.isp2x.target.extended)	\
 #ifndef CTIO_RET_TYPE
 #define CTIO_RET_TYPE	0x17		/* CTIO return entry */
 #define ATIO_TYPE7 0x06 /* Accept target I/O entry for 24xx */
+#endif
 struct fcp_hdr {
 	uint8_t  r_ctl;

drivers/scsi/sd_zbc.c+11−8

 static void sd_zbc_update_wp_offset_workfn(struct work_struct *work)
 {
 	struct scsi_disk *sdkp;
+	unsigned long flags;
 	unsigned int zno;
 	int ret;
 	sdkp = container_of(work, struct scsi_disk, zone_wp_offset_work);
-	spin_lock_bh(&sdkp->zones_wp_offset_lock);
+	spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 	for (zno = 0; zno < sdkp->nr_zones; zno++) {
 		if (sdkp->zones_wp_offset[zno] != SD_ZBC_UPDATING_WP_OFST)
 			continue;
-		spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+		spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 		ret = sd_zbc_do_report_zones(sdkp, sdkp->zone_wp_update_buf,
 					     SD_BUF_SIZE,
 					     zno * sdkp->zone_blocks, true);
-		spin_lock_bh(&sdkp->zones_wp_offset_lock);
+		spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 		if (!ret)
 			sd_zbc_parse_report(sdkp, sdkp->zone_wp_update_buf + 64,
 					    zno, sd_zbc_update_wp_offset_cb,
 					    sdkp);
 	}
-	spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+	spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 	scsi_device_put(sdkp->device);
 }
 	struct request *rq = cmd->request;
 	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 	unsigned int wp_offset, zno = blk_rq_zone_no(rq);
+	unsigned long flags;
 	blk_status_t ret;
 	ret = sd_zbc_cmnd_checks(cmd);
 	if (!blk_req_zone_write_trylock(rq))
 		return BLK_STS_ZONE_RESOURCE;
-	spin_lock_bh(&sdkp->zones_wp_offset_lock);
+	spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 	wp_offset = sdkp->zones_wp_offset[zno];
 	switch (wp_offset) {
 	case SD_ZBC_INVALID_WP_OFST:
 		*lba += wp_offset;
 	}
-	spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+	spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 	if (ret)
 		blk_req_zone_write_unlock(rq);
 	return ret;
 	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 	unsigned int zno = blk_rq_zone_no(rq);
 	enum req_opf op = req_op(rq);
+	unsigned long flags;
 	/*
 	 * If we got an error for a command that needs updating the write
 	 * invalid to force an update from disk the next time a zone append
 	 * command is issued.
 	 */
-	spin_lock_bh(&sdkp->zones_wp_offset_lock);
+	spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 	if (result && op != REQ_OP_ZONE_RESET_ALL) {
 		if (op == REQ_OP_ZONE_APPEND) {
 	}
 unlock_wp_offset:
-	spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+	spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 	return good_bytes;
 }

drivers/scsi/smartpqi/smartpqi_init.c+0−1

@@ -48,7 +48,6 @@ · 47 unmodified lines
48	MODULE_AUTHOR("Microsemi");	48	MODULE_AUTHOR("Microsemi");
49	MODULE_DESCRIPTION("Driver for Microsemi Smart Family Controller version "	49	MODULE_DESCRIPTION("Driver for Microsemi Smart Family Controller version "
50	DRIVER_VERSION);	50	DRIVER_VERSION);
51	MODULE_SUPPORTED_DEVICE("Microsemi Smart Family Controllers");
52	MODULE_VERSION(DRIVER_VERSION);	51	MODULE_VERSION(DRIVER_VERSION);
53	MODULE_LICENSE("GPL");	52	MODULE_LICENSE("GPL");
54		53

drivers/scsi/st.c+1−1

 	spin_lock(&st_use_lock);
 	if (STp->in_use) {
 		spin_unlock(&st_use_lock);
-		scsi_tape_put(STp);
 		DEBC_printk(STp, "Device already in use.\n");
+		scsi_tape_put(STp);
 		return (-EBUSY);
 	}

drivers/scsi/ufs/ufs-mediatek.c+1−1

@@ -911,7 +911,7 @@ static void ufs_mtk_vreg_set_lpm(struct ufs_hba *hba, bool lpm) · 910 unmodified lines
911	if (!hba->vreg_info.vccq2 \|\| !hba->vreg_info.vcc)	911	if (!hba->vreg_info.vccq2 \|\| !hba->vreg_info.vcc)
912	return;	912	return;
913		913
914	if (lpm & !hba->vreg_info.vcc->enabled)	914	if (lpm && !hba->vreg_info.vcc->enabled)
915	regulator_set_mode(hba->vreg_info.vccq2->reg,	915	regulator_set_mode(hba->vreg_info.vccq2->reg,
916	REGULATOR_MODE_IDLE);	916	REGULATOR_MODE_IDLE);
917	else if (!lpm)	917	else if (!lpm)

drivers/scsi/ufs/ufs-qcom.c+10−0

 {
 	int ret = 0;
 	struct ufs_qcom_host *host = ufshcd_get_variant(hba);
+	bool reenable_intr = false;
 	if (!host->core_reset) {
 		dev_warn(hba->dev, "%s: reset control not set\n", __func__);
 		goto out;
 	}
+	reenable_intr = hba->is_irq_enabled;
+	disable_irq(hba->irq);
+	hba->is_irq_enabled = false;
 	ret = reset_control_assert(host->core_reset);
 	if (ret) {
 		dev_err(hba->dev, "%s: core_reset assert failed, err = %d\n",
 	usleep_range(1000, 1100);
+	if (reenable_intr) {
+		enable_irq(hba->irq);
+		hba->is_irq_enabled = true;
+	}
 out:
 	return ret;
 }

drivers/scsi/ufs/ufshcd.c+13−28

 		       16, 4, buf, __len, false);                        \
 } while (0)
-static bool early_suspend;
 int ufshcd_dump_regs(struct ufs_hba *hba, size_t offset, size_t len,
 		     const char *prefix)
 {
 {
 	struct ufs_hba *hba = dev_get_drvdata(dev);
-	return snprintf(buf, PAGE_SIZE, "%d\n", hba->clk_scaling.is_enabled);
+	return sysfs_emit(buf, "%d\n", hba->clk_scaling.is_enabled);
 }
 static ssize_t ufshcd_clkscale_enable_store(struct device *dev,
 			 * UFS device needs urgent BKOPs.
 			 */
 			if (!hba->pm_op_in_progress &&
+			    !ufshcd_eh_in_progress(hba) &&
 			    ufshcd_is_exception_event(lrbp->ucd_rsp_ptr) &&
 			    schedule_work(&hba->eeh_work)) {
 				/*
 			ufshcd_suspend_clkscaling(hba);
 		ufshcd_clk_scaling_allow(hba, false);
 	}
+	ufshcd_scsi_block_requests(hba);
+	/* Drain ufshcd_queuecommand() */
+	down_write(&hba->clk_scaling_lock);
+	up_write(&hba->clk_scaling_lock);
+	cancel_work_sync(&hba->eeh_work);
 }
 static void ufshcd_err_handling_unprepare(struct ufs_hba *hba)
 {
+	ufshcd_scsi_unblock_requests(hba);
 	ufshcd_release(hba);
 	if (ufshcd_is_clkscaling_supported(hba))
 		ufshcd_clk_scaling_suspend(hba, false);
+	ufshcd_clear_ua_wluns(hba);
 	pm_runtime_put(hba->dev);
 }
 	spin_unlock_irqrestore(hba->host->host_lock, flags);
 	ufshcd_err_handling_prepare(hba);
 	spin_lock_irqsave(hba->host->host_lock, flags);
-	ufshcd_scsi_block_requests(hba);
+	if (hba->ufshcd_state != UFSHCD_STATE_ERROR)
-	hba->ufshcd_state = UFSHCD_STATE_RESET;
+		hba->ufshcd_state = UFSHCD_STATE_RESET;
 	/* Complete requests that have door-bell cleared by h/w */
 	ufshcd_complete_requests(hba);
 	}
 	ufshcd_clear_eh_in_progress(hba);
 	spin_unlock_irqrestore(hba->host->host_lock, flags);
-	ufshcd_scsi_unblock_requests(hba);
 	ufshcd_err_handling_unprepare(hba);
 	up(&hba->host_sem);
-	if (!err && needs_reset)
-		ufshcd_clear_ua_wluns(hba);
 }
 /**
 	unsigned long flags;
 	ktime_t start = ktime_get();
+	hba->ufshcd_state = UFSHCD_STATE_RESET;
 	ret = ufshcd_link_startup(hba);
 	if (ret)
 		goto out;
 	int ret = 0;
 	ktime_t start = ktime_get();
-	if (!hba) {
-		early_suspend = true;
-		return 0;
-	}
 	down(&hba->host_sem);
 	if (!hba->is_powered)
 	int ret = 0;
 	ktime_t start = ktime_get();
-	if (!hba)
-		return -EINVAL;
-	if (unlikely(early_suspend)) {
-		early_suspend = false;
-		down(&hba->host_sem);
-	}
 	if (!hba->is_powered || pm_runtime_suspended(hba->dev))
 		/*
 		 * Let the runtime resume take care of resuming
 	int ret = 0;
 	ktime_t start = ktime_get();
-	if (!hba)
-		return -EINVAL;
 	if (!hba->is_powered)
 		goto out;
 	else
 	int ret = 0;
 	ktime_t start = ktime_get();
-	if (!hba)
-		return -EINVAL;
 	if (!hba->is_powered)
 		goto out;
 	else

drivers/scsi/vmw_pvscsi.c+0−2

@@ -17,8 +17,6 @@ · 16 unmodified lines
17	* along with this program; if not, write to the Free Software	17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19	*	19	*
20	* Maintained by: Jim Gill <jgill@vmware.com>
21	*
22	*/	20	*/
23		21
24	#include <linux/kernel.h>	22	#include <linux/kernel.h>

drivers/scsi/vmw_pvscsi.h+0−2

@@ -17,8 +17,6 @@ · 16 unmodified lines
17	* along with this program; if not, write to the Free Software	17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19	*	19	*
20	* Maintained by: Jim Gill <jgill@vmware.com>
21	*
22	*/	20	*/
23		21
24	#ifndef _VMW_PVSCSI_H_	22	#ifndef _VMW_PVSCSI_H_

drivers/sh/maple/maple.c+0−1

@@ -30,7 +30,6 @@ · 29 unmodified lines
30	MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>");	30	MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>");
31	MODULE_DESCRIPTION("Maple bus driver for Dreamcast");	31	MODULE_DESCRIPTION("Maple bus driver for Dreamcast");
32	MODULE_LICENSE("GPL v2");	32	MODULE_LICENSE("GPL v2");
33	MODULE_SUPPORTED_DEVICE("{{SEGA, Dreamcast/Maple}}");
34		33
35	static void maple_dma_handler(struct work_struct *work);	34	static void maple_dma_handler(struct work_struct *work);
36	static void maple_vblank_handler(struct work_struct *work);	35	static void maple_vblank_handler(struct work_struct *work);

drivers/spi/spi-cadence-quadspi.c+1−0

@@ -1433,6 +1433,7 @@ static int cqspi_probe(struct platform_device *pdev) · 1432 unmodified lines
1433	cqspi = spi_master_get_devdata(master);	1433	cqspi = spi_master_get_devdata(master);
1434		1434
1435	cqspi->pdev = pdev;	1435	cqspi->pdev = pdev;
		1436	platform_set_drvdata(pdev, cqspi);
1436		1437
1437	/* Obtain configuration from OF. */	1438	/* Obtain configuration from OF. */
1438	ret = cqspi_of_get_pdata(cqspi);	1439	ret = cqspi_of_get_pdata(cqspi);

drivers/staging/comedi/drivers/addi_apci_1032.c+3−1

 	struct apci1032_private *devpriv = dev->private;
 	struct comedi_subdevice *s = dev->read_subdev;
 	unsigned int ctrl;
+	unsigned short val;
 	/* check interrupt is from this device */
 	if ((inl(devpriv->amcc_iobase + AMCC_OP_REG_INTCSR) &
 	outl(ctrl & ~APCI1032_CTRL_INT_ENA, dev->iobase + APCI1032_CTRL_REG);
 	s->state = inl(dev->iobase + APCI1032_STATUS_REG) & 0xffff;
-	comedi_buf_write_samples(s, &s->state, 1);
+	val = s->state;
+	comedi_buf_write_samples(s, &val, 1);
 	comedi_handle_events(dev, s);
 	/* enable the interrupt */

drivers/staging/comedi/drivers/addi_apci_1500.c+9−9

@@ -208,7 +208,7 @@ static irqreturn_t apci1500_interrupt(int irq, void *d) · 207 unmodified lines
208	struct comedi_device *dev = d;	208	struct comedi_device *dev = d;
209	struct apci1500_private *devpriv = dev->private;	209	struct apci1500_private *devpriv = dev->private;
210	struct comedi_subdevice *s = dev->read_subdev;	210	struct comedi_subdevice *s = dev->read_subdev;
211	unsigned int status = 0;	211	unsigned short status = 0;
212	unsigned int val;	212	unsigned int val;
213		213
214	val = inl(devpriv->amcc + AMCC_OP_REG_INTCSR);	214	val = inl(devpriv->amcc + AMCC_OP_REG_INTCSR);
@@ -238,14 +238,14 @@ static irqreturn_t apci1500_interrupt(int irq, void *d) · 23 unmodified lines
238	*	238	*
239	* Mask Meaning	239	* Mask Meaning
240	* ---------- ------------------------------------------	240	* ---------- ------------------------------------------
241	* 0x00000001 Event 1 has occurred	241	* 0b00000001 Event 1 has occurred
242	* 0x00000010 Event 2 has occurred	242	* 0b00000010 Event 2 has occurred
243	* 0x00000100 Counter/timer 1 has run down (not implemented)	243	* 0b00000100 Counter/timer 1 has run down (not implemented)
244	* 0x00001000 Counter/timer 2 has run down (not implemented)	244	* 0b00001000 Counter/timer 2 has run down (not implemented)
245	* 0x00010000 Counter 3 has run down (not implemented)	245	* 0b00010000 Counter 3 has run down (not implemented)
246	* 0x00100000 Watchdog has run down (not implemented)	246	* 0b00100000 Watchdog has run down (not implemented)
247	* 0x01000000 Voltage error	247	* 0b01000000 Voltage error
248	* 0x10000000 Short-circuit error	248	* 0b10000000 Short-circuit error
249	*/	249	*/
250	comedi_buf_write_samples(s, &status, 1);	250	comedi_buf_write_samples(s, &status, 1);
251	comedi_handle_events(dev, s);	251	comedi_handle_events(dev, s);

drivers/staging/comedi/drivers/adv_pci1710.c+5−5

@@ -300,11 +300,11 @@ static int pci1710_ai_eoc(struct comedi_device *dev, · 299 unmodified lines
300	static int pci1710_ai_read_sample(struct comedi_device *dev,	300	static int pci1710_ai_read_sample(struct comedi_device *dev,
301	struct comedi_subdevice *s,	301	struct comedi_subdevice *s,
302	unsigned int cur_chan,	302	unsigned int cur_chan,
303	unsigned int *val)	303	unsigned short *val)
304	{	304	{
305	const struct boardtype *board = dev->board_ptr;	305	const struct boardtype *board = dev->board_ptr;
306	struct pci1710_private *devpriv = dev->private;	306	struct pci1710_private *devpriv = dev->private;
307	unsigned int sample;	307	unsigned short sample;
308	unsigned int chan;	308	unsigned int chan;
309		309
310	sample = inw(dev->iobase + PCI171X_AD_DATA_REG);	310	sample = inw(dev->iobase + PCI171X_AD_DATA_REG);
@@ -345,7 +345,7 @@ static int pci1710_ai_insn_read(struct comedi_device *dev, · 34 unmodified lines
345	pci1710_ai_setup_chanlist(dev, s, &insn->chanspec, 1, 1);	345	pci1710_ai_setup_chanlist(dev, s, &insn->chanspec, 1, 1);
346		346
347	for (i = 0; i < insn->n; i++) {	347	for (i = 0; i < insn->n; i++) {
348	unsigned int val;	348	unsigned short val;
349		349
350	/* start conversion */	350	/* start conversion */
351	outw(0, dev->iobase + PCI171X_SOFTTRG_REG);	351	outw(0, dev->iobase + PCI171X_SOFTTRG_REG);
@@ -395,7 +395,7 @@ static void pci1710_handle_every_sample(struct comedi_device *dev, · 43 unmodified lines
395	{	395	{
396	struct comedi_cmd *cmd = &s->async->cmd;	396	struct comedi_cmd *cmd = &s->async->cmd;
397	unsigned int status;	397	unsigned int status;
398	unsigned int val;	398	unsigned short val;
399	int ret;	399	int ret;
400		400
401	status = inw(dev->iobase + PCI171X_STATUS_REG);	401	status = inw(dev->iobase + PCI171X_STATUS_REG);
@@ -455,7 +455,7 @@ static void pci1710_handle_fifo(struct comedi_device *dev, · 53 unmodified lines
455	}	455	}
456		456
457	for (i = 0; i < devpriv->max_samples; i++) {	457	for (i = 0; i < devpriv->max_samples; i++) {
458	unsigned int val;	458	unsigned short val;
459	int ret;	459	int ret;
460		460
461	ret = pci1710_ai_read_sample(dev, s, s->async->cur_chan, &val);	461	ret = pci1710_ai_read_sample(dev, s, s->async->cur_chan, &val);

drivers/staging/comedi/drivers/amplc_pc236_common.c+3−1

@@ -126,7 +126,9 @@ static irqreturn_t pc236_interrupt(int irq, void *d) · 125 unmodified lines
126		126
127	handled = pc236_intr_check(dev);	127	handled = pc236_intr_check(dev);
128	if (dev->attached && handled) {	128	if (dev->attached && handled) {
129	comedi_buf_write_samples(s, &s->state, 1);	129	unsigned short val = 0;
		130
		131	comedi_buf_write_samples(s, &val, 1);
130	comedi_handle_events(dev, s);	132	comedi_handle_events(dev, s);
131	}	133	}
132	return IRQ_RETVAL(handled);	134	return IRQ_RETVAL(handled);

drivers/staging/comedi/drivers/cb_pcidas.c+1−1

@@ -1281,7 +1281,7 @@ static int cb_pcidas_auto_attach(struct comedi_device *dev, · 1280 unmodified lines
1281	devpriv->amcc + AMCC_OP_REG_INTCSR);	1281	devpriv->amcc + AMCC_OP_REG_INTCSR);
1282		1282
1283	ret = request_irq(pcidev->irq, cb_pcidas_interrupt, IRQF_SHARED,	1283	ret = request_irq(pcidev->irq, cb_pcidas_interrupt, IRQF_SHARED,
1284	dev->board_name, dev);	1284	"cb_pcidas", dev);
1285	if (ret) {	1285	if (ret) {
1286	dev_dbg(dev->class_dev, "unable to allocate irq %d\n",	1286	dev_dbg(dev->class_dev, "unable to allocate irq %d\n",
1287	pcidev->irq);	1287	pcidev->irq);

drivers/staging/comedi/drivers/cb_pcidas64.c+1−1

@@ -4035,7 +4035,7 @@ static int auto_attach(struct comedi_device *dev, · 4034 unmodified lines
4035	init_stc_registers(dev);	4035	init_stc_registers(dev);
4036		4036
4037	retval = request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED,	4037	retval = request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED,
4038	dev->board_name, dev);	4038	"cb_pcidas64", dev);
4039	if (retval) {	4039	if (retval) {
4040	dev_dbg(dev->class_dev, "unable to allocate irq %u\n",	4040	dev_dbg(dev->class_dev, "unable to allocate irq %u\n",
4041	pcidev->irq);	4041	pcidev->irq);

drivers/staging/comedi/drivers/comedi_parport.c+2−1

 	struct comedi_device *dev = d;
 	struct comedi_subdevice *s = dev->read_subdev;
 	unsigned int ctrl;
+	unsigned short val = 0;
 	ctrl = inb(dev->iobase + PARPORT_CTRL_REG);
 	if (!(ctrl & PARPORT_CTRL_IRQ_ENA))
 		return IRQ_NONE;
-	comedi_buf_write_samples(s, &s->state, 1);
+	comedi_buf_write_samples(s, &val, 1);
 	comedi_handle_events(dev, s);
 	return IRQ_HANDLED;

drivers/staging/comedi/drivers/das6402.c+1−1

@@ -186,7 +186,7 @@ static irqreturn_t das6402_interrupt(int irq, void *d) · 185 unmodified lines
186	if (status & DAS6402_STATUS_FFULL) {	186	if (status & DAS6402_STATUS_FFULL) {
187	async->events \|= COMEDI_CB_OVERFLOW;	187	async->events \|= COMEDI_CB_OVERFLOW;
188	} else if (status & DAS6402_STATUS_FFNE) {	188	} else if (status & DAS6402_STATUS_FFNE) {
189	unsigned int val;	189	unsigned short val;
190		190
191	val = das6402_ai_read_sample(dev, s);	191	val = das6402_ai_read_sample(dev, s);
192	comedi_buf_write_samples(s, &val, 1);	192	comedi_buf_write_samples(s, &val, 1);

drivers/staging/comedi/drivers/das800.c+1−1

@@ -427,7 +427,7 @@ static irqreturn_t das800_interrupt(int irq, void *d) · 426 unmodified lines
427	struct comedi_cmd *cmd;	427	struct comedi_cmd *cmd;
428	unsigned long irq_flags;	428	unsigned long irq_flags;
429	unsigned int status;	429	unsigned int status;
430	unsigned int val;	430	unsigned short val;
431	bool fifo_empty;	431	bool fifo_empty;
432	bool fifo_overflow;	432	bool fifo_overflow;
433	int i;	433	int i;

drivers/staging/comedi/drivers/dmm32at.c+1−1

@@ -404,7 +404,7 @@ static irqreturn_t dmm32at_isr(int irq, void *d) · 403 unmodified lines
404	{	404	{
405	struct comedi_device *dev = d;	405	struct comedi_device *dev = d;
406	unsigned char intstat;	406	unsigned char intstat;
407	unsigned int val;	407	unsigned short val;
408	int i;	408	int i;
409		409
410	if (!dev->attached) {	410	if (!dev->attached) {

drivers/staging/comedi/drivers/me4000.c+1−1

@@ -924,7 +924,7 @@ static irqreturn_t me4000_ai_isr(int irq, void *dev_id) · 923 unmodified lines
924	struct comedi_subdevice *s = dev->read_subdev;	924	struct comedi_subdevice *s = dev->read_subdev;
925	int i;	925	int i;
926	int c = 0;	926	int c = 0;
927	unsigned int lval;	927	unsigned short lval;
928		928
929	if (!dev->attached)	929	if (!dev->attached)
930	return IRQ_NONE;	930	return IRQ_NONE;

drivers/staging/comedi/drivers/ni_6527.c+3−1

@@ -195,7 +195,9 @@ static irqreturn_t ni6527_interrupt(int irq, void *d) · 194 unmodified lines
195	return IRQ_NONE;	195	return IRQ_NONE;
196		196
197	if (status & NI6527_STATUS_EDGE) {	197	if (status & NI6527_STATUS_EDGE) {
198	comedi_buf_write_samples(s, &s->state, 1);	198	unsigned short val = 0;
		199
		200	comedi_buf_write_samples(s, &val, 1);
199	comedi_handle_events(dev, s);	201	comedi_handle_events(dev, s);
200	}	202	}
201		203

drivers/staging/comedi/drivers/ni_65xx.c+2−1

 	struct comedi_device *dev = d;
 	struct comedi_subdevice *s = dev->read_subdev;
 	unsigned int status;
+	unsigned short val = 0;
 	status = readb(dev->mmio + NI_65XX_STATUS_REG);
 	if ((status & NI_65XX_STATUS_INT) == 0)
 	writeb(NI_65XX_CLR_EDGE_INT | NI_65XX_CLR_OVERFLOW_INT,
 	       dev->mmio + NI_65XX_CLR_REG);
-	comedi_buf_write_samples(s, &s->state, 1);
+	comedi_buf_write_samples(s, &val, 1);
 	comedi_handle_events(dev, s);
 	return IRQ_HANDLED;

drivers/staging/comedi/drivers/pcl711.c+1−1

@@ -184,7 +184,7 @@ static irqreturn_t pcl711_interrupt(int irq, void *d) · 183 unmodified lines
184	struct comedi_device *dev = d;	184	struct comedi_device *dev = d;
185	struct comedi_subdevice *s = dev->read_subdev;	185	struct comedi_subdevice *s = dev->read_subdev;
186	struct comedi_cmd *cmd = &s->async->cmd;	186	struct comedi_cmd *cmd = &s->async->cmd;
187	unsigned int data;	187	unsigned short data;
188		188
189	if (!dev->attached) {	189	if (!dev->attached) {
190	dev_err(dev->class_dev, "spurious interrupt\n");	190	dev_err(dev->class_dev, "spurious interrupt\n");

drivers/staging/comedi/drivers/pcl726.c+3−1

@@ -220,9 +220,11 @@ static irqreturn_t pcl726_interrupt(int irq, void *d) · 219 unmodified lines
220	struct pcl726_private *devpriv = dev->private;	220	struct pcl726_private *devpriv = dev->private;
221		221
222	if (devpriv->cmd_running) {	222	if (devpriv->cmd_running) {
		223	unsigned short val = 0;
		224
223	pcl726_intr_cancel(dev, s);	225	pcl726_intr_cancel(dev, s);
224		226
225	comedi_buf_write_samples(s, &s->state, 1);	227	comedi_buf_write_samples(s, &val, 1);
226	comedi_handle_events(dev, s);	228	comedi_handle_events(dev, s);
227	}	229	}
228		230

drivers/staging/comedi/drivers/pcl818.c+1−1

@@ -423,7 +423,7 @@ static int pcl818_ai_eoc(struct comedi_device *dev, · 422 unmodified lines
423		423
424	static bool pcl818_ai_write_sample(struct comedi_device *dev,	424	static bool pcl818_ai_write_sample(struct comedi_device *dev,
425	struct comedi_subdevice *s,	425	struct comedi_subdevice *s,
426	unsigned int chan, unsigned int val)	426	unsigned int chan, unsigned short val)
427	{	427	{
428	struct pcl818_private *devpriv = dev->private;	428	struct pcl818_private *devpriv = dev->private;
429	struct comedi_cmd *cmd = &s->async->cmd;	429	struct comedi_cmd *cmd = &s->async->cmd;

drivers/staging/comedi/drivers/vmk80xx.c+0−1

@@ -877,5 +877,4 @@ module_comedi_usb_driver(vmk80xx_driver, vmk80xx_usb_driver); · 876 unmodified lines
877		877
878	MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");	878	MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
879	MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");	879	MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
880	MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
881	MODULE_LICENSE("GPL");	880	MODULE_LICENSE("GPL");

drivers/staging/ks7010/ks_wlan_net.c+4−2

 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	struct iw_scan_req *req = NULL;
+	int len;
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	if (wrqu->data.length == sizeof(struct iw_scan_req) &&
 	    wrqu->data.flags & IW_SCAN_THIS_ESSID) {
 		req = (struct iw_scan_req *)extra;
-		priv->scan_ssid_len = req->essid_len;
+		len = min_t(int, req->essid_len, IW_ESSID_MAX_SIZE);
-		memcpy(priv->scan_ssid, req->essid, priv->scan_ssid_len);
+		priv->scan_ssid_len = len;
+		memcpy(priv->scan_ssid, req->essid, len);
 	} else {
 		priv->scan_ssid_len = 0;
 	}

drivers/staging/rtl8188eu/core/rtw_ap.c+5−0

 	p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, WLAN_EID_SSID, &ie_len,
 		       pbss_network->ie_length - _BEACON_IE_OFFSET_);
 	if (p && ie_len > 0) {
+		ie_len = min_t(int, ie_len, sizeof(pbss_network->ssid.ssid));
 		memset(&pbss_network->ssid, 0, sizeof(struct ndis_802_11_ssid));
 		memcpy(pbss_network->ssid.ssid, p + 2, ie_len);
 		pbss_network->ssid.ssid_length = ie_len;
 	p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, WLAN_EID_SUPP_RATES, &ie_len,
 		       pbss_network->ie_length - _BEACON_IE_OFFSET_);
 	if (p) {
+		ie_len = min_t(int, ie_len, NDIS_802_11_LENGTH_RATES_EX);
 		memcpy(supportRate, p + 2, ie_len);
 		supportRateNum = ie_len;
 	}
 	p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, WLAN_EID_EXT_SUPP_RATES,
 		       &ie_len, pbss_network->ie_length - _BEACON_IE_OFFSET_);
 	if (p) {
+		ie_len = min_t(int, ie_len,
+			       NDIS_802_11_LENGTH_RATES_EX - supportRateNum);
 		memcpy(supportRate + supportRateNum, p + 2, ie_len);
 		supportRateNum += ie_len;
 	}
 		pht_cap->mcs.rx_mask[0] = 0xff;
 		pht_cap->mcs.rx_mask[1] = 0x0;
+		ie_len = min_t(int, ie_len, sizeof(pmlmepriv->htpriv.ht_cap));
 		memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len);
 	}

drivers/staging/rtl8188eu/os_dep/ioctl_linux.c+4−2

 						break;
 					}
 					sec_len = *(pos++); len -= 1;
-					if (sec_len > 0 && sec_len <= len) {
+					if (sec_len > 0 &&
+					    sec_len <= len &&
+					    sec_len <= 32) {
 						ssid[ssid_index].ssid_length = sec_len;
-						memcpy(ssid[ssid_index].ssid, pos, ssid[ssid_index].ssid_length);
+						memcpy(ssid[ssid_index].ssid, pos, sec_len);
 						ssid_index++;
 					}
 					pos += sec_len;

drivers/staging/rtl8192e/Kconfig+1−0

@@ -27,6 +27,7 @@ config RTLLIB_CRYPTO_CCMP · 26 unmodified lines
27	config RTLLIB_CRYPTO_TKIP	27	config RTLLIB_CRYPTO_TKIP
28	tristate "Support for rtllib TKIP crypto"	28	tristate "Support for rtllib TKIP crypto"
29	depends on RTLLIB	29	depends on RTLLIB
		30	select CRYPTO
30	select CRYPTO_LIB_ARC4	31	select CRYPTO_LIB_ARC4
31	select CRYPTO_MICHAEL_MIC	32	select CRYPTO_MICHAEL_MIC
32	default y	33	default y

drivers/staging/rtl8192e/rtl8192e/rtl_wx.c+4−3

@@ -406,9 +406,10 @@ static int _rtl92e_wx_set_scan(struct net_device *dev, · 405 unmodified lines
406	struct iw_scan_req req = (struct iw_scan_req )b;	406	struct iw_scan_req req = (struct iw_scan_req )b;
407		407
408	if (req->essid_len) {	408	if (req->essid_len) {
409	ieee->current_network.ssid_len = req->essid_len;	409	int len = min_t(int, req->essid_len, IW_ESSID_MAX_SIZE);
410	memcpy(ieee->current_network.ssid, req->essid,	410
411	req->essid_len);	411	ieee->current_network.ssid_len = len;
		412	memcpy(ieee->current_network.ssid, req->essid, len);
412	}	413	}
413	}	414	}
414		415

drivers/staging/rtl8192u/r8192U_wx.c+4−2

@@ -331,8 +331,10 @@ static int r8192_wx_set_scan(struct net_device dev, struct iw_request_info a, · 330 unmodified lines
331	struct iw_scan_req req = (struct iw_scan_req )b;	331	struct iw_scan_req req = (struct iw_scan_req )b;
332		332
333	if (req->essid_len) {	333	if (req->essid_len) {
334	ieee->current_network.ssid_len = req->essid_len;	334	int len = min_t(int, req->essid_len, IW_ESSID_MAX_SIZE);
335	memcpy(ieee->current_network.ssid, req->essid, req->essid_len);	335
		336	ieee->current_network.ssid_len = len;
		337	memcpy(ieee->current_network.ssid, req->essid, len);
336	}	338	}
337	}	339	}
338		340

drivers/staging/rtl8712/rtl871x_cmd.c+4−2

@@ -192,8 +192,10 @@ u8 r8712_sitesurvey_cmd(struct _adapter *padapter, · 191 unmodified lines
192	psurveyPara->ss_ssidlen = 0;	192	psurveyPara->ss_ssidlen = 0;
193	memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1);	193	memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1);
194	if (pssid && pssid->SsidLength) {	194	if (pssid && pssid->SsidLength) {
195	memcpy(psurveyPara->ss_ssid, pssid->Ssid, pssid->SsidLength);	195	int len = min_t(int, pssid->SsidLength, IW_ESSID_MAX_SIZE);
196	psurveyPara->ss_ssidlen = cpu_to_le32(pssid->SsidLength);	196
		197	memcpy(psurveyPara->ss_ssid, pssid->Ssid, len);
		198	psurveyPara->ss_ssidlen = cpu_to_le32(len);
197	}	199	}
198	set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);	200	set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
199	r8712_enqueue_cmd(pcmdpriv, ph2c);	201	r8712_enqueue_cmd(pcmdpriv, ph2c);

drivers/staging/rtl8712/rtl871x_ioctl_linux.c+1−1

@@ -924,7 +924,7 @@ static int r871x_wx_set_priv(struct net_device *dev, · 923 unmodified lines
924	struct iw_point dwrq = (struct iw_point )awrq;	924	struct iw_point dwrq = (struct iw_point )awrq;
925		925
926	len = dwrq->length;	926	len = dwrq->length;
927	ext = memdup_user(dwrq->pointer, len);	927	ext = strndup_user(dwrq->pointer, len);
928	if (IS_ERR(ext))	928	if (IS_ERR(ext))
929	return PTR_ERR(ext);	929	return PTR_ERR(ext);
930		930

drivers/staging/vt6655/rxtx.h+2−2

@@ -150,7 +150,7 @@ struct vnt_cts { · 149 unmodified lines
150	u16 reserved;	150	u16 reserved;
151	struct ieee80211_cts data;	151	struct ieee80211_cts data;
152	u16 reserved2;	152	u16 reserved2;
153	} __packed;	153	} __packed __aligned(2);
154		154
155	struct vnt_cts_fb {	155	struct vnt_cts_fb {
156	struct vnt_phy_field b;	156	struct vnt_phy_field b;
@@ -160,7 +160,7 @@ struct vnt_cts_fb { · 3 unmodified lines
160	__le16 cts_duration_ba_f1;	160	__le16 cts_duration_ba_f1;
161	struct ieee80211_cts data;	161	struct ieee80211_cts data;
162	u16 reserved2;	162	u16 reserved2;
163	} __packed;	163	} __packed __aligned(2);
164		164
165	struct vnt_tx_fifo_head {	165	struct vnt_tx_fifo_head {
166	u8 tx_key[WLAN_KEY_LEN_CCMP];	166	u8 tx_key[WLAN_KEY_LEN_CCMP];

drivers/staging/wfx/bh.c+1−0

@@ -5,6 +5,7 @@ · 4 unmodified lines
5	* Copyright (c) 2017-2020, Silicon Laboratories, Inc.	5	* Copyright (c) 2017-2020, Silicon Laboratories, Inc.
6	* Copyright (c) 2010, ST-Ericsson	6	* Copyright (c) 2010, ST-Ericsson
7	*/	7	*/
		8	#include <linux/gpio/consumer.h>
8	#include <net/mac80211.h>	9	#include <net/mac80211.h>
9		10
10	#include "bh.h"	11	#include "bh.h"

drivers/staging/wfx/bh.h+4−0

@@ -8,6 +8,10 @@ · 7 unmodified lines
8	#ifndef WFX_BH_H	8	#ifndef WFX_BH_H
9	#define WFX_BH_H	9	#define WFX_BH_H
10		10
		11	#include <linux/atomic.h>
		12	#include <linux/wait.h>
		13	#include <linux/workqueue.h>
		14
11	struct wfx_dev;	15	struct wfx_dev;
12		16
13	struct wfx_hif {	17	struct wfx_hif {

drivers/staging/wfx/bus.h+3−0

@@ -8,6 +8,9 @@ · 7 unmodified lines
8	#ifndef WFX_BUS_H	8	#ifndef WFX_BUS_H
9	#define WFX_BUS_H	9	#define WFX_BUS_H
10		10
		11	#include <linux/mmc/sdio_func.h>
		12	#include <linux/spi/spi.h>
		13
11	#define WFX_REG_CONFIG 0x0	14	#define WFX_REG_CONFIG 0x0
12	#define WFX_REG_CONTROL 0x1	15	#define WFX_REG_CONTROL 0x1
13	#define WFX_REG_IN_OUT_QUEUE 0x2	16	#define WFX_REG_IN_OUT_QUEUE 0x2

drivers/staging/wfx/bus_sdio.c+6−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/module.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sdio_func.h>
 #include <linux/mmc/card.h>
+#include <linux/interrupt.h>
 #include <linux/of_irq.h>
+#include <linux/irq.h>
 #include "bus.h"
 #include "wfx.h"
+#include "hwio.h"
+#include "main.h"
+#include "bh.h"
 static const struct wfx_platform_data wfx_sdio_pdata = {
 	.file_fw = "wfm_wf200",

drivers/staging/wfx/bus_spi.c+7−0

  * Copyright (c) 2011, Sagrad Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/gpio/consumer.h>
 #include <linux/spi/spi.h>
+#include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/of.h>
 #include "bus.h"
 #include "wfx.h"
+#include "hwio.h"
+#include "main.h"
+#include "bh.h"
 #define SET_WRITE 0x7FFF        /* usage: and operation */
 #define SET_READ 0x8000         /* usage: or operation */

drivers/staging/wfx/data_rx.c+5−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/etherdevice.h>
+#include <net/mac80211.h>
 #include "data_rx.h"
 #include "wfx.h"
+#include "bh.h"
+#include "sta.h"
 static void wfx_rx_handle_ba(struct wfx_vif *wvif, struct ieee80211_mgmt *mgmt)
 {

drivers/staging/wfx/data_tx.c+5−0

  * Copyright (c) 2010, ST-Ericsson
  */
 #include <net/mac80211.h>
+#include <linux/etherdevice.h>
+#include "data_tx.h"
 #include "wfx.h"
+#include "bh.h"
 #include "sta.h"
+#include "queue.h"
+#include "debug.h"
 #include "traces.h"
 #include "hif_tx_mib.h"

drivers/staging/wfx/data_tx.h+3−0

@@ -8,6 +8,9 @@ · 7 unmodified lines
8	#ifndef WFX_DATA_TX_H	8	#ifndef WFX_DATA_TX_H
9	#define WFX_DATA_TX_H	9	#define WFX_DATA_TX_H
10		10
		11	#include <linux/list.h>
		12	#include <net/mac80211.h>
		13
11	#include "hif_api_cmd.h"	14	#include "hif_api_cmd.h"
12	#include "hif_api_mib.h"	15	#include "hif_api_mib.h"
13		16

drivers/staging/wfx/debug.c+6−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/crc32.h>
 #include "debug.h"
 #include "wfx.h"
 #include "sta.h"
+#include "main.h"
+#include "hif_tx.h"
 #include "hif_tx_mib.h"
 #define CREATE_TRACE_POINTS

drivers/staging/wfx/fwio.c+2−0

@@ -6,6 +6,8 @@ · 5 unmodified lines
6	* Copyright (c) 2010, ST-Ericsson	6	* Copyright (c) 2010, ST-Ericsson
7	*/	7	*/
8	#include <linux/firmware.h>	8	#include <linux/firmware.h>
		9	#include <linux/slab.h>
		10	#include <linux/mm.h>
9	#include <linux/bitfield.h>	11	#include <linux/bitfield.h>
10		12
11	#include "fwio.h"	13	#include "fwio.h"

drivers/staging/wfx/hif_api_cmd.h+4−0

@@ -8,6 +8,10 @@ · 7 unmodified lines
8	#ifndef WFX_HIF_API_CMD_H	8	#ifndef WFX_HIF_API_CMD_H
9	#define WFX_HIF_API_CMD_H	9	#define WFX_HIF_API_CMD_H
10		10
		11	#include <linux/ieee80211.h>
		12
		13	#include "hif_api_general.h"
		14
11	enum hif_requests_ids {	15	enum hif_requests_ids {
12	HIF_REQ_ID_RESET = 0x0a,	16	HIF_REQ_ID_RESET = 0x0a,
13	HIF_REQ_ID_READ_MIB = 0x05,	17	HIF_REQ_ID_READ_MIB = 0x05,

drivers/staging/wfx/hif_api_general.h+9−0

@@ -8,6 +8,15 @@ · 7 unmodified lines
8	#ifndef WFX_HIF_API_GENERAL_H	8	#ifndef WFX_HIF_API_GENERAL_H
9	#define WFX_HIF_API_GENERAL_H	9	#define WFX_HIF_API_GENERAL_H
10		10
		11	#ifdef __KERNEL__
		12	#include <linux/types.h>
		13	#include <linux/if_ether.h>
		14	#else
		15	#include <net/ethernet.h>
		16	#include <stdint.h>
		17	#define __packed __attribute__((__packed__))
		18	#endif
		19
11	#define HIF_ID_IS_INDICATION 0x80	20	#define HIF_ID_IS_INDICATION 0x80
12	#define HIF_COUNTER_MAX 7	21	#define HIF_COUNTER_MAX 7
13		22

drivers/staging/wfx/hif_tx.c+4−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/etherdevice.h>
+#include "hif_tx.h"
 #include "wfx.h"
+#include "bh.h"
 #include "hwio.h"
 #include "debug.h"
 #include "sta.h"

drivers/staging/wfx/hif_tx_mib.c+5−0

  * Copyright (c) 2010, ST-Ericsson
  * Copyright (C) 2010, ST-Ericsson SA
  */
+#include <linux/etherdevice.h>
 #include "wfx.h"
+#include "hif_tx.h"
 #include "hif_tx_mib.h"
+#include "hif_api_mib.h"
 int hif_set_output_power(struct wfx_vif *wvif, int val)
 {

drivers/staging/wfx/hwio.c+3−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/kernel.h>
+#include <linux/delay.h>
 #include <linux/slab.h>
 #include "hwio.h"
 #include "wfx.h"
+#include "bus.h"
 #include "traces.h"
 /*

drivers/staging/wfx/hwio.h+2−0

@@ -8,6 +8,8 @@ · 7 unmodified lines
8	#ifndef WFX_HWIO_H	8	#ifndef WFX_HWIO_H
9	#define WFX_HWIO_H	9	#define WFX_HWIO_H
10		10
		11	#include <linux/types.h>
		12
11	struct wfx_dev;	13	struct wfx_dev;
12		14
13	int wfx_data_read(struct wfx_dev wdev, void buf, size_t buf_len);	15	int wfx_data_read(struct wfx_dev wdev, void buf, size_t buf_len);

drivers/staging/wfx/key.c+2−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/etherdevice.h>
 #include <net/mac80211.h>
 #include "key.h"
 #include "wfx.h"
+#include "hif_tx_mib.h"
 static int wfx_alloc_key(struct wfx_dev *wdev)
 {

drivers/staging/wfx/key.h+2−0

@@ -8,6 +8,8 @@ · 7 unmodified lines
8	#ifndef WFX_KEY_H	8	#ifndef WFX_KEY_H
9	#define WFX_KEY_H	9	#define WFX_KEY_H
10		10
		11	#include <net/mac80211.h>
		12
11	struct wfx_dev;	13	struct wfx_dev;
12	struct wfx_vif;	14	struct wfx_vif;
13		15

drivers/staging/wfx/main.c+7−0

  * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
  * Copyright (c) 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
  */
+#include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_net.h>
+#include <linux/gpio/consumer.h>
 #include <linux/mmc/sdio_func.h>
 #include <linux/spi/spi.h>
+#include <linux/etherdevice.h>
 #include <linux/firmware.h>
+#include "main.h"
 #include "wfx.h"
 #include "fwio.h"
 #include "hwio.h"
 #include "bus.h"
+#include "bh.h"
 #include "sta.h"
 #include "key.h"
 #include "scan.h"
 #include "debug.h"
+#include "data_tx.h"
 #include "hif_tx_mib.h"
+#include "hif_api_cmd.h"
 #define WFX_PDS_MAX_SIZE 1500

drivers/staging/wfx/main.h+3−0

@@ -10,8 +10,11 @@ · 9 unmodified lines
10	#ifndef WFX_MAIN_H	10	#ifndef WFX_MAIN_H
11	#define WFX_MAIN_H	11	#define WFX_MAIN_H
12		12
		13	#include <linux/device.h>
13	#include <linux/gpio/consumer.h>	14	#include <linux/gpio/consumer.h>
14		15
		16	#include "hif_api_general.h"
		17
15	struct wfx_dev;	18	struct wfx_dev;
16	struct hwbus_ops;	19	struct hwbus_ops;
17		20

drivers/staging/wfx/queue.c+4−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/sched.h>
 #include <net/mac80211.h>
+#include "queue.h"
 #include "wfx.h"
+#include "sta.h"
+#include "data_tx.h"
 #include "traces.h"
 void wfx_tx_lock(struct wfx_dev *wdev)

drivers/staging/wfx/queue.h+3−0

@@ -8,6 +8,9 @@ · 7 unmodified lines
8	#ifndef WFX_QUEUE_H	8	#ifndef WFX_QUEUE_H
9	#define WFX_QUEUE_H	9	#define WFX_QUEUE_H
10		10
		11	#include <linux/skbuff.h>
		12	#include <linux/atomic.h>
		13
11	struct wfx_dev;	14	struct wfx_dev;
12	struct wfx_vif;	15	struct wfx_vif;
13		16

drivers/staging/wfx/scan.h+2−0

@@ -8,6 +8,8 @@ · 7 unmodified lines
8	#ifndef WFX_SCAN_H	8	#ifndef WFX_SCAN_H
9	#define WFX_SCAN_H	9	#define WFX_SCAN_H
10		10
		11	#include <net/mac80211.h>
		12
11	struct wfx_dev;	13	struct wfx_dev;
12	struct wfx_vif;	14	struct wfx_vif;
13		15

drivers/staging/wfx/sta.c+6−0

  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
  * Copyright (c) 2010, ST-Ericsson
  */
+#include <linux/etherdevice.h>
 #include <net/mac80211.h>
 #include "sta.h"
 #include "wfx.h"
+#include "fwio.h"
+#include "bh.h"
+#include "key.h"
 #include "scan.h"
+#include "debug.h"
+#include "hif_tx.h"
 #include "hif_tx_mib.h"
 #define HIF_MAX_ARP_IP_ADDRTABLE_ENTRIES 2

drivers/staging/wfx/sta.h+2−0

@@ -8,6 +8,8 @@ · 7 unmodified lines
8	#ifndef WFX_STA_H	8	#ifndef WFX_STA_H
9	#define WFX_STA_H	9	#define WFX_STA_H
10		10
		11	#include <net/mac80211.h>
		12
11	struct wfx_dev;	13	struct wfx_dev;
12	struct wfx_vif;	14	struct wfx_vif;
13		15

drivers/staging/wfx/traces.h+3−0

 #define _WFX_TRACE_H
 #include <linux/tracepoint.h>
+#include <net/mac80211.h>
 #include "bus.h"
+#include "hif_api_cmd.h"
+#include "hif_api_mib.h"
 /* The hell below need some explanations. For each symbolic number, we need to
  * define it with TRACE_DEFINE_ENUM() and in a list for __print_symbolic.

drivers/staging/wfx/wfx.h+3−0

@@ -10,6 +10,9 @@ · 9 unmodified lines
10	#ifndef WFX_H	10	#ifndef WFX_H
11	#define WFX_H	11	#define WFX_H
12		12
		13	#include <linux/completion.h>
		14	#include <linux/workqueue.h>
		15	#include <linux/mutex.h>
13	#include <linux/nospec.h>	16	#include <linux/nospec.h>
14	#include <net/mac80211.h>	17	#include <net/mac80211.h>
15		18

drivers/tee/optee/core.c+0−1

@@ -747,7 +747,6 @@ module_platform_driver(optee_driver); · 746 unmodified lines
747		747
748	MODULE_AUTHOR("Linaro");	748	MODULE_AUTHOR("Linaro");
749	MODULE_DESCRIPTION("OP-TEE driver");	749	MODULE_DESCRIPTION("OP-TEE driver");
750	MODULE_SUPPORTED_DEVICE("");
751	MODULE_VERSION("1.0");	750	MODULE_VERSION("1.0");
752	MODULE_LICENSE("GPL v2");	751	MODULE_LICENSE("GPL v2");
753	MODULE_ALIAS("platform:optee");	752	MODULE_ALIAS("platform:optee");

drivers/thermal/thermal_sysfs.c+3−0

@@ -674,6 +674,9 @@ void thermal_cooling_device_stats_update(struct thermal_cooling_device *cdev, · 673 unmodified lines
674	{	674	{
675	struct cooling_dev_stats *stats = cdev->stats;	675	struct cooling_dev_stats *stats = cdev->stats;
676		676
		677	if (!stats)
		678	return;
		679
677	spin_lock(&stats->lock);	680	spin_lock(&stats->lock);
678		681
679	if (stats->state == new_state)	682	if (stats->state == new_state)

drivers/thunderbolt/switch.c+8−10

 	tb_dump_port(port->sw->tb, &port->config);
-	/* Control port does not need HopID allocation */
-	if (port->port) {
-		ida_init(&port->in_hopids);
-		ida_init(&port->out_hopids);
-	}
 	INIT_LIST_HEAD(&port->list);
 	return 0;
 	dma_port_free(sw->dma_port);
 	tb_switch_for_each_port(sw, port) {
-		if (!port->disabled) {
+		ida_destroy(&port->in_hopids);
-			ida_destroy(&port->in_hopids);
+		ida_destroy(&port->out_hopids);
-			ida_destroy(&port->out_hopids);
-		}
 	}
 	kfree(sw->uuid);
 		/* minimum setup for tb_find_cap and tb_drom_read to work */
 		sw->ports[i].sw = sw;
 		sw->ports[i].port = i;
+		/* Control port does not need HopID allocation */
+		if (i) {
+			ida_init(&sw->ports[i].in_hopids);
+			ida_init(&sw->ports[i].out_hopids);
+		}
 	}
 	ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_PLUG_EVENTS);

drivers/thunderbolt/tb.c+4−0

 				parent->boot = true;
 				parent = tb_switch_parent(parent);
 			}
+		} else if (tb_tunnel_is_dp(tunnel)) {
+			/* Keep the domain from powering down */
+			pm_runtime_get_sync(&tunnel->src_port->sw->dev);
+			pm_runtime_get_sync(&tunnel->dst_port->sw->dev);
 		}
 		list_add_tail(&tunnel->list, &tcm->tunnel_list);

drivers/tty/pty.c+2−13

@@ -66,8 +66,7 @@ static void pty_close(struct tty_struct tty, struct file filp) · 65 unmodified lines
66	wake_up_interruptible(&tty->link->read_wait);	66	wake_up_interruptible(&tty->link->read_wait);
67	wake_up_interruptible(&tty->link->write_wait);	67	wake_up_interruptible(&tty->link->write_wait);
68	if (tty->driver->subtype == PTY_TYPE_MASTER) {	68	if (tty->driver->subtype == PTY_TYPE_MASTER) {
69	struct file *f;	69	set_bit(TTY_OTHER_CLOSED, &tty->flags);
70
71	#ifdef CONFIG_UNIX98_PTYS	70	#ifdef CONFIG_UNIX98_PTYS
72	if (tty->driver == ptm_driver) {	71	if (tty->driver == ptm_driver) {
73	mutex_lock(&devpts_mutex);	72	mutex_lock(&devpts_mutex);
@@ -76,17 +75,7 @@ static void pty_close(struct tty_struct tty, struct file filp) · 2 unmodified lines
76	mutex_unlock(&devpts_mutex);	75	mutex_unlock(&devpts_mutex);
77	}	76	}
78	#endif	77	#endif
79		78	tty_vhangup(tty->link);
80	/*
81	* This hack is required because a program can open a
82	* pty and redirect a console to it, but if the pty is
83	* closed and the console is not released, then the
84	* slave side will never close. So release the
85	* redirect when the master closes.
86	*/
87	f = tty_release_redirect(tty->link);
88	if (f)
89	fput(f);
90	}	79	}
91	}	80	}
92		81

drivers/tty/serial/icom.c+0−2

@@ -1639,8 +1639,6 @@ module_exit(icom_exit); · 1638 unmodified lines
1639		1639
1640	MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");	1640	MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
1641	MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");	1641	MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
1642	MODULE_SUPPORTED_DEVICE
1643	("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
1644	MODULE_LICENSE("GPL");	1642	MODULE_LICENSE("GPL");
1645	MODULE_FIRMWARE("icom_call_setup.bin");	1643	MODULE_FIRMWARE("icom_call_setup.bin");
1646	MODULE_FIRMWARE("icom_res_dce.bin");	1644	MODULE_FIRMWARE("icom_res_dce.bin");

drivers/tty/serial/jsm/jsm_driver.c+0−1

@@ -19,7 +19,6 @@ · 18 unmodified lines
19	MODULE_AUTHOR("Digi International, https://www.digi.com");	19	MODULE_AUTHOR("Digi International, https://www.digi.com");
20	MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");	20	MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");
21	MODULE_LICENSE("GPL");	21	MODULE_LICENSE("GPL");
22	MODULE_SUPPORTED_DEVICE("jsm");
23		22
24	#define JSM_DRIVER_NAME "jsm"	23	#define JSM_DRIVER_NAME "jsm"
25	#define NR_PORTS 32	24	#define NR_PORTS 32

drivers/tty/serial/max310x.c+5−24

@@ -1056,9 +1056,9 @@ static int max310x_startup(struct uart_port *port) · 1055 unmodified lines
1056	max310x_port_update(port, MAX310X_MODE1_REG,	1056	max310x_port_update(port, MAX310X_MODE1_REG,
1057	MAX310X_MODE1_TRNSCVCTRL_BIT, 0);	1057	MAX310X_MODE1_TRNSCVCTRL_BIT, 0);
1058		1058
1059	/* Reset FIFOs */	1059	/* Configure MODE2 register & Reset FIFOs*/
1060	max310x_port_write(port, MAX310X_MODE2_REG,	1060	val = MAX310X_MODE2_RXEMPTINV_BIT \| MAX310X_MODE2_FIFORST_BIT;
1061	MAX310X_MODE2_FIFORST_BIT);	1061	max310x_port_write(port, MAX310X_MODE2_REG, val);
1062	max310x_port_update(port, MAX310X_MODE2_REG,	1062	max310x_port_update(port, MAX310X_MODE2_REG,
1063	MAX310X_MODE2_FIFORST_BIT, 0);	1063	MAX310X_MODE2_FIFORST_BIT, 0);
1064		1064
@@ -1086,27 +1086,8 @@ static int max310x_startup(struct uart_port *port) · 21 unmodified lines
1086	/* Clear IRQ status register */	1086	/* Clear IRQ status register */
1087	max310x_port_read(port, MAX310X_IRQSTS_REG);	1087	max310x_port_read(port, MAX310X_IRQSTS_REG);
1088		1088
1089	/*	1089	/* Enable RX, TX, CTS change interrupts */
1090	* Let's ask for an interrupt after a timeout equivalent to	1090	val = MAX310X_IRQ_RXEMPTY_BIT \| MAX310X_IRQ_TXEMPTY_BIT;
1091	* the receiving time of 4 characters after the last character
1092	* has been received.
1093	*/
1094	max310x_port_write(port, MAX310X_RXTO_REG, 4);
1095
1096	/*
1097	* Make sure we also get RX interrupts when the RX FIFO is
1098	* filling up quickly, so get an interrupt when half of the RX
1099	* FIFO has been filled in.
1100	*/
1101	max310x_port_write(port, MAX310X_FIFOTRIGLVL_REG,
1102	MAX310X_FIFOTRIGLVL_RX(MAX310X_FIFO_SIZE / 2));
1103
1104	/* Enable RX timeout interrupt in LSR */
1105	max310x_port_write(port, MAX310X_LSR_IRQEN_REG,
1106	MAX310X_LSR_RXTO_BIT);
1107
1108	/* Enable LSR, RX FIFO trigger, CTS change interrupts */
1109	val = MAX310X_IRQ_LSR_BIT \| MAX310X_IRQ_RXFIFO_BIT \| MAX310X_IRQ_TXEMPTY_BIT;
1110	max310x_port_write(port, MAX310X_IRQEN_REG, val \| MAX310X_IRQ_CTS_BIT);	1091	max310x_port_write(port, MAX310X_IRQEN_REG, val \| MAX310X_IRQ_CTS_BIT);
1111		1092
1112	return 0;	1093	return 0;

drivers/tty/tty_io.c+2−3

  *	@tty: tty device
  *
  *	This is available to the pty code so if the master closes, if the
- *	slave is a redirect it can release the redirect.  It returns the
+ *	slave is a redirect it can release the redirect.
- *	filp for the redirect, which must be fput when the operations on
- *	the tty are completed.
  */
 struct file *tty_release_redirect(struct tty_struct *tty)
 {
 	return f;
 }
+EXPORT_SYMBOL_GPL(tty_release_redirect);
 /**
  *	__tty_hangup		-	actual handler for hangup events

drivers/usb/cdns3/cdnsp-ring.c+4−1

 	 * inverted in the first TDs isoc TRB.
 	 */
 	field = TRB_TYPE(TRB_ISOC) | TRB_TLBPC(last_burst_pkt) |
-		start_cycle ? 0 : 1 | TRB_SIA | TRB_TBC(burst_count);
+		TRB_SIA | TRB_TBC(burst_count);
+	if (!start_cycle)
+		field |= TRB_CYCLE;
 	/* Fill the rest of the TRB fields, and remaining normal TRBs. */
 	for (i = 0; i < trbs_per_td; i++) {

drivers/usb/class/cdc-acm.c+5−0

 	.driver_info = SEND_ZERO_PACKET,
 	},
+	/* Exclude Goodix Fingerprint Reader */
+	{ USB_DEVICE(0x27c6, 0x5395),
+	.driver_info = IGNORE_DEVICE,
+	},
 	/* control interfaces without any protocol set */
 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
 		USB_CDC_PROTO_NONE) },

drivers/usb/class/usblp.c+12−4

 /* No kernel lock - fine */
 static __poll_t usblp_poll(struct file *file, struct poll_table_struct *wait)
 {
-	__poll_t ret;
+	struct usblp *usblp = file->private_data;
+	__poll_t ret = 0;
 	unsigned long flags;
-	struct usblp *usblp = file->private_data;
 	/* Should we check file->f_mode & FMODE_WRITE before poll_wait()? */
 	poll_wait(file, &usblp->rwait, wait);
 	poll_wait(file, &usblp->wwait, wait);
+	mutex_lock(&usblp->mut);
+	if (!usblp->present)
+		ret |= EPOLLHUP;
+	mutex_unlock(&usblp->mut);
 	spin_lock_irqsave(&usblp->lock, flags);
-	ret = ((usblp->bidir && usblp->rcomplete) ? EPOLLIN  | EPOLLRDNORM : 0) |
+	if (usblp->bidir && usblp->rcomplete)
-	   ((usblp->no_paper || usblp->wcomplete) ? EPOLLOUT | EPOLLWRNORM : 0);
+		ret |= EPOLLIN  | EPOLLRDNORM;
+	if (usblp->no_paper || usblp->wcomplete)
+		ret |= EPOLLOUT | EPOLLWRNORM;
 	spin_unlock_irqrestore(&usblp->lock, flags);
 	return ret;
 }

drivers/usb/core/usb.c+32−0

@@ -748,6 +748,38 @@ void usb_put_intf(struct usb_interface *intf) · 747 unmodified lines
748	}	748	}
749	EXPORT_SYMBOL_GPL(usb_put_intf);	749	EXPORT_SYMBOL_GPL(usb_put_intf);
750		750
		751	/**
		752	* usb_intf_get_dma_device - acquire a reference on the usb interface's DMA endpoint
		753	* @intf: the usb interface
		754	*
		755	* While a USB device cannot perform DMA operations by itself, many USB
		756	* controllers can. A call to usb_intf_get_dma_device() returns the DMA endpoint
		757	* for the given USB interface, if any. The returned device structure must be
		758	* released with put_device().
		759	*
		760	* See also usb_get_dma_device().
		761	*
		762	* Returns: A reference to the usb interface's DMA endpoint; or NULL if none
		763	* exists.
		764	*/
		765	struct device usb_intf_get_dma_device(struct usb_interface intf)
		766	{
		767	struct usb_device *udev = interface_to_usbdev(intf);
		768	struct device *dmadev;
		769
		770	if (!udev->bus)
		771	return NULL;
		772
		773	dmadev = get_device(udev->bus->sysdev);
		774	if (!dmadev \|\| !dmadev->dma_mask) {
		775	put_device(dmadev);
		776	return NULL;
		777	}
		778
		779	return dmadev;
		780	}
		781	EXPORT_SYMBOL_GPL(usb_intf_get_dma_device);
		782
751	/* USB device locking	783	/* USB device locking
752	*	784	*
753	* USB devices and interfaces are locked using the semaphore in their	785	* USB devices and interfaces are locked using the semaphore in their

drivers/usb/dwc3/dwc3-qcom.c+13−5

 	if (ret)
 		dev_warn(qcom->dev, "failed to disable interconnect: %d\n", ret);
+	if (device_may_wakeup(qcom->dev))
+		dwc3_qcom_enable_interrupts(qcom);
 	qcom->is_suspended = true;
-	dwc3_qcom_enable_interrupts(qcom);
 	return 0;
 }
 	if (!qcom->is_suspended)
 		return 0;
-	dwc3_qcom_disable_interrupts(qcom);
+	if (device_may_wakeup(qcom->dev))
+		dwc3_qcom_disable_interrupts(qcom);
 	for (i = 0; i < qcom->num_clocks; i++) {
 		ret = clk_prepare_enable(qcom->clks[i]);
 	ret = of_platform_populate(np, NULL, NULL, dev);
 	if (ret) {
 		dev_err(dev, "failed to register dwc3 core - %d\n", ret);
-		return ret;
+		goto node_put;
 	}
 	qcom->dwc3 = of_find_device_by_node(dwc3_np);
 	if (!qcom->dwc3) {
+		ret = -ENODEV;
 		dev_err(dev, "failed to get dwc3 platform device\n");
-		return -ENODEV;
 	}
-	return 0;
+node_put:
+	of_node_put(dwc3_np);
+	return ret;
 }
 static struct platform_device *
 static const struct acpi_device_id dwc3_qcom_acpi_match[] = {
 	{ "QCOM2430", (unsigned long)&sdm845_acpi_pdata },
 	{ "QCOM0304", (unsigned long)&sdm845_acpi_urs_pdata },
+	{ "QCOM0497", (unsigned long)&sdm845_acpi_urs_pdata },
+	{ "QCOM04A6", (unsigned long)&sdm845_acpi_pdata },
 	{ },
 };
 MODULE_DEVICE_TABLE(acpi, dwc3_qcom_acpi_match);

drivers/usb/dwc3/gadget.c+5−6

 	trace_dwc3_gadget_ep_disable(dep);
-	dwc3_remove_requests(dwc, dep);
 	/* make sure HW endpoint isn't stalled */
 	if (dep->flags & DWC3_EP_STALL)
 		__dwc3_gadget_ep_set_halt(dep, 0, false);
 		dep->endpoint.desc = NULL;
 	}
+	dwc3_remove_requests(dwc, dep);
 	return 0;
 }
 {
 	struct dwc3		*dwc = dep->dwc;
-	if (!dep->endpoint.desc || !dwc->pullups_connected) {
+	if (!dep->endpoint.desc || !dwc->pullups_connected || !dwc->connected) {
 		dev_err(dwc->dev, "%s: can't queue to disabled endpoint\n",
 				dep->name);
 		return -ESHUTDOWN;
 	if (!is_on) {
 		u32 count;
+		dwc->connected = false;
 		/*
 		 * In the Synopsis DesignWare Cores USB3 Databook Rev. 3.30a
 		 * Section 4.1.8 Table 4-7, it states that for a device-initiated
 			dwc->ev_buf->lpos = (dwc->ev_buf->lpos + count) %
 						dwc->ev_buf->length;
 		}
-		dwc->connected = false;
 	} else {
 		__dwc3_gadget_start(dwc);
 	}
 {
 	u32			reg;
-	dwc->connected = true;
 	/*
 	 * WORKAROUND: DWC3 revisions <1.88a have an issue which
 	 * would cause a missing Disconnect Event if there's a
 	 * transfers."
 	 */
 	dwc3_stop_active_transfers(dwc);
+	dwc->connected = true;
 	reg = dwc3_readl(dwc->regs, DWC3_DCTL);
 	reg &= ~DWC3_DCTL_TSTCTRL_MASK;

drivers/usb/gadget/configfs.c+10−4

 	struct list_head list;
 };
+#define USB_MAX_STRING_WITH_NULL_LEN	(USB_MAX_STRING_LEN+1)
 static int usb_string_copy(const char *s, char **s_copy)
 {
 	int ret;
 	if (ret > USB_MAX_STRING_LEN)
 		return -EOVERFLOW;
-	str = kstrdup(s, GFP_KERNEL);
+	if (copy) {
-	if (!str)
+		str = copy;
-		return -ENOMEM;
+	} else {
+		str = kmalloc(USB_MAX_STRING_WITH_NULL_LEN, GFP_KERNEL);
+		if (!str)
+			return -ENOMEM;
+	}
+	strcpy(str, s);
 	if (str[ret - 1] == '\n')
 		str[ret - 1] = '\0';
-	kfree(copy);
 	*s_copy = str;
 	return 0;
 }

drivers/usb/gadget/function/f_uac1.c+1−0

@@ -499,6 +499,7 @@ static void f_audio_disable(struct usb_function *f) · 498 unmodified lines
499	uac1->as_out_alt = 0;	499	uac1->as_out_alt = 0;
500	uac1->as_in_alt = 0;	500	uac1->as_in_alt = 0;
501		501
		502	u_audio_stop_playback(&uac1->g_audio);
502	u_audio_stop_capture(&uac1->g_audio);	503	u_audio_stop_capture(&uac1->g_audio);
503	}	504	}
504		505

drivers/usb/gadget/function/f_uac2.c+1−1

@@ -478,7 +478,7 @@ static int set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts, · 477 unmodified lines
478	}	478	}
479		479
480	max_size_bw = num_channels(chmask) * ssize *	480	max_size_bw = num_channels(chmask) * ssize *
481	DIV_ROUND_UP(srate, factor / (1 << (ep_desc->bInterval - 1)));	481	((srate / (factor / (1 << (ep_desc->bInterval - 1)))) + 1);
482	ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_size_bw,	482	ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_size_bw,
483	max_size_ep));	483	max_size_ep));
484		484

drivers/usb/gadget/function/u_ether_configfs.h+2−3

 						size_t len)		\
 	{								\
 		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
-		int ret;						\
+		int ret = -EINVAL;					\
 		u8 val;							\
 									\
 		mutex_lock(&opts->lock);				\
-		ret = sscanf(page, "%02hhx", &val);			\
+		if (sscanf(page, "%02hhx", &val) > 0) {			\
-		if (ret > 0) {						\
 			opts->_n_ = val;				\
 			ret = len;					\
 		}							\

drivers/usb/gadget/udc/s3c2410_udc.c+2−2

@@ -1773,8 +1773,8 @@ static int s3c2410_udc_probe(struct platform_device *pdev) · 1772 unmodified lines
1773	udc_info = dev_get_platdata(&pdev->dev);	1773	udc_info = dev_get_platdata(&pdev->dev);
1774		1774
1775	base_addr = devm_platform_ioremap_resource(pdev, 0);	1775	base_addr = devm_platform_ioremap_resource(pdev, 0);
1776	if (!base_addr) {	1776	if (IS_ERR(base_addr)) {
1777	retval = -ENOMEM;	1777	retval = PTR_ERR(base_addr);
1778	goto err_mem;	1778	goto err_mem;
1779	}	1779	}
1780		1780

drivers/usb/host/xhci-pci.c+11−2

 #define PCI_DEVICE_ID_ASMEDIA_1042A_XHCI		0x1142
 #define PCI_DEVICE_ID_ASMEDIA_1142_XHCI			0x1242
 #define PCI_DEVICE_ID_ASMEDIA_2142_XHCI			0x2142
+#define PCI_DEVICE_ID_ASMEDIA_3242_XHCI			0x3242
 static const char hcd_name[] = "xhci_hcd";
 		pdev->device == PCI_DEVICE_ID_ASMEDIA_1042_XHCI)
 		xhci->quirks |= XHCI_BROKEN_STREAMS;
 	if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA &&
-		pdev->device == PCI_DEVICE_ID_ASMEDIA_1042A_XHCI)
+		pdev->device == PCI_DEVICE_ID_ASMEDIA_1042A_XHCI) {
 		xhci->quirks |= XHCI_TRUST_TX_LENGTH;
+		xhci->quirks |= XHCI_NO_64BIT_SUPPORT;
+	}
 	if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA &&
 	    (pdev->device == PCI_DEVICE_ID_ASMEDIA_1142_XHCI ||
-	     pdev->device == PCI_DEVICE_ID_ASMEDIA_2142_XHCI))
+	     pdev->device == PCI_DEVICE_ID_ASMEDIA_2142_XHCI ||
+	     pdev->device == PCI_DEVICE_ID_ASMEDIA_3242_XHCI))
 		xhci->quirks |= XHCI_NO_64BIT_SUPPORT;
 	if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA &&
 	     pdev->device == 0x9026)
 		xhci->quirks |= XHCI_RESET_PLL_ON_DISCONNECT;
+	if (pdev->vendor == PCI_VENDOR_ID_AMD &&
+	    (pdev->device == PCI_DEVICE_ID_AMD_PROMONTORYA_2 ||
+	     pdev->device == PCI_DEVICE_ID_AMD_PROMONTORYA_4))
+		xhci->quirks |= XHCI_NO_SOFT_RETRY;
 	if (xhci->quirks & XHCI_RESET_ON_RESUME)
 		xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
 				"QUIRK: Resetting on resume");

drivers/usb/host/xhci-ring.c+2−1

@@ -2484,7 +2484,8 @@ static int process_bulk_intr_td(struct xhci_hcd xhci, struct xhci_td td, · 2483 unmodified lines
2484	remaining = 0;	2484	remaining = 0;
2485	break;	2485	break;
2486	case COMP_USB_TRANSACTION_ERROR:	2486	case COMP_USB_TRANSACTION_ERROR:
2487	if ((ep_ring->err_count++ > MAX_SOFT_RETRY) \|\|	2487	if (xhci->quirks & XHCI_NO_SOFT_RETRY \|\|
		2488	(ep_ring->err_count++ > MAX_SOFT_RETRY) \|\|
2488	le32_to_cpu(slot_ctx->tt_info) & TT_SLOT)	2489	le32_to_cpu(slot_ctx->tt_info) & TT_SLOT)
2489	break;	2490	break;
2490		2491

drivers/usb/host/xhci.c+43−35

@@ -883,44 +883,42 @@ static void xhci_clear_command_ring(struct xhci_hcd *xhci) · 882 unmodified lines
883	xhci_set_cmd_ring_deq(xhci);	883	xhci_set_cmd_ring_deq(xhci);
884	}	884	}
885		885
886	static void xhci_disable_port_wake_on_bits(struct xhci_hcd *xhci)	886	/*
		887	* Disable port wake bits if do_wakeup is not set.
		888	*
		889	* Also clear a possible internal port wake state left hanging for ports that
		890	* detected termination but never successfully enumerated (trained to 0U).
		891	* Internal wake causes immediate xHCI wake after suspend. PORT_CSC write done
		892	* at enumeration clears this wake, force one here as well for unconnected ports
		893	*/
		894
		895	static void xhci_disable_hub_port_wake(struct xhci_hcd *xhci,
		896	struct xhci_hub *rhub,
		897	bool do_wakeup)
887	{	898	{
888	struct xhci_port **ports;
889	int port_index;
890	unsigned long flags;	899	unsigned long flags;
891	u32 t1, t2, portsc;	900	u32 t1, t2, portsc;
		901	int i;
892		902
893	spin_lock_irqsave(&xhci->lock, flags);	903	spin_lock_irqsave(&xhci->lock, flags);
894		904
895	/* disable usb3 ports Wake bits */	905	for (i = 0; i < rhub->num_ports; i++) {
896	port_index = xhci->usb3_rhub.num_ports;	906	portsc = readl(rhub->ports[i]->addr);
897	ports = xhci->usb3_rhub.ports;	907	t1 = xhci_port_state_to_neutral(portsc);
898	while (port_index--) {	908	t2 = t1;
899	t1 = readl(ports[port_index]->addr);	909
900	portsc = t1;	910	/* clear wake bits if do_wake is not set */
901	t1 = xhci_port_state_to_neutral(t1);	911	if (!do_wakeup)
902	t2 = t1 & ~PORT_WAKE_BITS;	912	t2 &= ~PORT_WAKE_BITS;
903	if (t1 != t2) {	913
904	writel(t2, ports[port_index]->addr);	914	/* Don't touch csc bit if connected or connect change is set */
905	xhci_dbg(xhci, "disable wake bits port %d-%d, portsc: 0x%x, write: 0x%x\n",	915	if (!(portsc & (PORT_CSC \| PORT_CONNECT)))
906	xhci->usb3_rhub.hcd->self.busnum,	916	t2 \|= PORT_CSC;
907	port_index + 1, portsc, t2);
908	}
909	}
910		917
911	/* disable usb2 ports Wake bits */
912	port_index = xhci->usb2_rhub.num_ports;
913	ports = xhci->usb2_rhub.ports;
914	while (port_index--) {
915	t1 = readl(ports[port_index]->addr);
916	portsc = t1;
917	t1 = xhci_port_state_to_neutral(t1);
918	t2 = t1 & ~PORT_WAKE_BITS;
919	if (t1 != t2) {	918	if (t1 != t2) {
920	writel(t2, ports[port_index]->addr);	919	writel(t2, rhub->ports[i]->addr);
921	xhci_dbg(xhci, "disable wake bits port %d-%d, portsc: 0x%x, write: 0x%x\n",	920	xhci_dbg(xhci, "config port %d-%d wake bits, portsc: 0x%x, write: 0x%x\n",
922	xhci->usb2_rhub.hcd->self.busnum,	921	rhub->hcd->self.busnum, i + 1, portsc, t2);
923	port_index + 1, portsc, t2);
924	}	922	}
925	}	923	}
926	spin_unlock_irqrestore(&xhci->lock, flags);	924	spin_unlock_irqrestore(&xhci->lock, flags);
@@ -983,8 +981,8 @@ int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup) · 56 unmodified lines
983	return -EINVAL;	981	return -EINVAL;
984		982
985	/* Clear root port wake on bits if wakeup not allowed. */	983	/* Clear root port wake on bits if wakeup not allowed. */
986	if (!do_wakeup)	984	xhci_disable_hub_port_wake(xhci, &xhci->usb3_rhub, do_wakeup);
987	xhci_disable_port_wake_on_bits(xhci);	985	xhci_disable_hub_port_wake(xhci, &xhci->usb2_rhub, do_wakeup);
988		986
989	if (!HCD_HW_ACCESSIBLE(hcd))	987	if (!HCD_HW_ACCESSIBLE(hcd))
990	return 0;	988	return 0;
@@ -1088,6 +1086,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) · 97 unmodified lines
1088	struct usb_hcd *secondary_hcd;	1086	struct usb_hcd *secondary_hcd;
1089	int retval = 0;	1087	int retval = 0;
1090	bool comp_timer_running = false;	1088	bool comp_timer_running = false;
		1089	bool pending_portevent = false;
1091		1090
1092	if (!hcd->state)	1091	if (!hcd->state)
1093	return 0;	1092	return 0;
@@ -1226,13 +1225,22 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) · 132 unmodified lines
1226		1225
1227	done:	1226	done:
1228	if (retval == 0) {	1227	if (retval == 0) {
1229	/* Resume root hubs only when have pending events. */	1228	/*
1230	if (xhci_pending_portevent(xhci)) {	1229	* Resume roothubs only if there are pending events.
		1230	* USB 3 devices resend U3 LFPS wake after a 100ms delay if
		1231	* the first wake signalling failed, give it that chance.
		1232	*/
		1233	pending_portevent = xhci_pending_portevent(xhci);
		1234	if (!pending_portevent) {
		1235	msleep(120);
		1236	pending_portevent = xhci_pending_portevent(xhci);
		1237	}
		1238
		1239	if (pending_portevent) {
1231	usb_hcd_resume_root_hub(xhci->shared_hcd);	1240	usb_hcd_resume_root_hub(xhci->shared_hcd);
1232	usb_hcd_resume_root_hub(hcd);	1241	usb_hcd_resume_root_hub(hcd);
1233	}	1242	}
1234	}	1243	}
1235
1236	/*	1244	/*
1237	* If system is subject to the Quirk, Compliance Mode Timer needs to	1245	* If system is subject to the Quirk, Compliance Mode Timer needs to
1238	* be re-initialized Always after a system resume. Ports are subject	1246	* be re-initialized Always after a system resume. Ports are subject

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

@@ -1891,6 +1891,7 @@ struct xhci_hcd { · 1890 unmodified lines
1891	#define XHCI_SKIP_PHY_INIT BIT_ULL(37)	1891	#define XHCI_SKIP_PHY_INIT BIT_ULL(37)
1892	#define XHCI_DISABLE_SPARSE BIT_ULL(38)	1892	#define XHCI_DISABLE_SPARSE BIT_ULL(38)
1893	#define XHCI_SG_TRB_CACHE_SIZE_QUIRK BIT_ULL(39)	1893	#define XHCI_SG_TRB_CACHE_SIZE_QUIRK BIT_ULL(39)
		1894	#define XHCI_NO_SOFT_RETRY BIT_ULL(40)
1894		1895
1895	unsigned int num_active_eps;	1896	unsigned int num_active_eps;
1896	unsigned int limit_active_eps;	1897	unsigned int limit_active_eps;

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

@@ -117,7 +117,6 @@ MODULE_DEVICE_TABLE(usb, ld_usb_table); · 116 unmodified lines
117	MODULE_AUTHOR("Michael Hund <mhund@ld-didactic.de>");	117	MODULE_AUTHOR("Michael Hund <mhund@ld-didactic.de>");
118	MODULE_DESCRIPTION("LD USB Driver");	118	MODULE_DESCRIPTION("LD USB Driver");
119	MODULE_LICENSE("GPL");	119	MODULE_LICENSE("GPL");
120	MODULE_SUPPORTED_DEVICE("LD USB Devices");
121		120
122	/* All interrupt in transfers are collected in a ring buffer to	121	/* All interrupt in transfers are collected in a ring buffer to
123	* avoid racing conditions and get better performance of the driver.	122	* avoid racing conditions and get better performance of the driver.

drivers/usb/renesas_usbhs/pipe.c+2−0

@@ -746,6 +746,8 @@ struct usbhs_pipe usbhs_pipe_malloc(struct usbhs_priv priv, · 745 unmodified lines
746		746
747	void usbhs_pipe_free(struct usbhs_pipe *pipe)	747	void usbhs_pipe_free(struct usbhs_pipe *pipe)
748	{	748	{
		749	usbhsp_pipe_select(pipe);
		750	usbhsp_pipe_cfg_set(pipe, 0xFFFF, 0);
749	usbhsp_put_pipe(pipe);	751	usbhsp_put_pipe(pipe);
750	}	752	}
751		753

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

@@ -86,6 +86,7 @@ static const struct usb_device_id id_table[] = { · 85 unmodified lines
86	{ USB_DEVICE(0x1a86, 0x7522) },	86	{ USB_DEVICE(0x1a86, 0x7522) },
87	{ USB_DEVICE(0x1a86, 0x7523) },	87	{ USB_DEVICE(0x1a86, 0x7523) },
88	{ USB_DEVICE(0x4348, 0x5523) },	88	{ USB_DEVICE(0x4348, 0x5523) },
		89	{ USB_DEVICE(0x9986, 0x7523) },
89	{ },	90	{ },
90	};	91	};
91	MODULE_DEVICE_TABLE(usb, id_table);	92	MODULE_DEVICE_TABLE(usb, id_table);

drivers/usb/serial/cp210x.c+3−0

 	{ USB_DEVICE(0x10C4, 0x8857) },	/* CEL EM357 ZigBee USB Stick */
 	{ USB_DEVICE(0x10C4, 0x88A4) }, /* MMB Networks ZigBee USB Device */
 	{ USB_DEVICE(0x10C4, 0x88A5) }, /* Planet Innovation Ingeni ZigBee USB Device */
+	{ USB_DEVICE(0x10C4, 0x88D8) }, /* Acuity Brands nLight Air Adapter */
 	{ USB_DEVICE(0x10C4, 0x88FB) }, /* CESINEL MEDCAL STII Network Analyzer */
 	{ USB_DEVICE(0x10C4, 0x8938) }, /* CESINEL MEDCAL S II Network Analyzer */
 	{ USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
 	{ USB_DEVICE(0x1901, 0x0194) },	/* GE Healthcare Remote Alarm Box */
 	{ USB_DEVICE(0x1901, 0x0195) },	/* GE B850/B650/B450 CP2104 DP UART interface */
 	{ USB_DEVICE(0x1901, 0x0196) },	/* GE B850 CP2105 DP UART interface */
+	{ USB_DEVICE(0x1901, 0x0197) }, /* GE CS1000 Display serial interface */
+	{ USB_DEVICE(0x1901, 0x0198) }, /* GE CS1000 M.2 Key E serial interface */
 	{ USB_DEVICE(0x199B, 0xBA30) }, /* LORD WSDA-200-USB */
 	{ USB_DEVICE(0x19CF, 0x3000) }, /* Parrot NMEA GPS Flight Recorder */
 	{ USB_DEVICE(0x1ADB, 0x0001) }, /* Schweitzer Engineering C662 Cable */

drivers/usb/serial/io_edgeport.c+16−10

 				response = -ENODEV;
 			}
-			usb_free_urb(edge_serial->interrupt_read_urb);
+			goto error;
-			kfree(edge_serial->interrupt_in_buffer);
-			usb_free_urb(edge_serial->read_urb);
-			kfree(edge_serial->bulk_in_buffer);
-			kfree(edge_serial);
-			return response;
 		}
 		/* start interrupt read for this edgeport this interrupt will
 		 * continue as long as the edgeport is connected */
 		response = usb_submit_urb(edge_serial->interrupt_read_urb,
 								GFP_KERNEL);
-		if (response)
+		if (response) {
 			dev_err(ddev, "%s - Error %d submitting control urb\n",
 				__func__, response);
+			goto error;
+		}
 	}
 	return response;
+error:
+	usb_free_urb(edge_serial->interrupt_read_urb);
+	kfree(edge_serial->interrupt_in_buffer);
+	usb_free_urb(edge_serial->read_urb);
+	kfree(edge_serial->bulk_in_buffer);
+	kfree(edge_serial);
+	return response;
 }

drivers/usb/serial/xr_serial.c+0−25

@@ -545,37 +545,13 @@ static void xr_close(struct usb_serial_port *port) · 544 unmodified lines
545		545
546	static int xr_probe(struct usb_serial serial, const struct usb_device_id id)	546	static int xr_probe(struct usb_serial serial, const struct usb_device_id id)
547	{	547	{
548	struct usb_driver *driver = serial->type->usb_driver;
549	struct usb_interface *control_interface;
550	int ret;
551
552	/* Don't bind to control interface */	548	/* Don't bind to control interface */
553	if (serial->interface->cur_altsetting->desc.bInterfaceNumber == 0)	549	if (serial->interface->cur_altsetting->desc.bInterfaceNumber == 0)
554	return -ENODEV;	550	return -ENODEV;
555		551
556	/* But claim the control interface during data interface probe */
557	control_interface = usb_ifnum_to_if(serial->dev, 0);
558	if (!control_interface)
559	return -ENODEV;
560
561	ret = usb_driver_claim_interface(driver, control_interface, NULL);
562	if (ret) {
563	dev_err(&serial->interface->dev, "Failed to claim control interface\n");
564	return ret;
565	}
566
567	return 0;	552	return 0;
568	}	553	}
569		554
570	static void xr_disconnect(struct usb_serial *serial)
571	{
572	struct usb_driver *driver = serial->type->usb_driver;
573	struct usb_interface *control_interface;
574
575	control_interface = usb_ifnum_to_if(serial->dev, 0);
576	usb_driver_release_interface(driver, control_interface);
577	}
578
579	static const struct usb_device_id id_table[] = {	555	static const struct usb_device_id id_table[] = {
580	{ USB_DEVICE(0x04e2, 0x1410) }, /* XR21V141X */	556	{ USB_DEVICE(0x04e2, 0x1410) }, /* XR21V141X */
581	{ }	557	{ }
@@ -590,7 +566,6 @@ static struct usb_serial_driver xr_device = { · 8 unmodified lines
590	.id_table = id_table,	566	.id_table = id_table,
591	.num_ports = 1,	567	.num_ports = 1,
592	.probe = xr_probe,	568	.probe = xr_probe,
593	.disconnect = xr_disconnect,
594	.open = xr_open,	569	.open = xr_open,
595	.close = xr_close,	570	.close = xr_close,
596	.break_ctl = xr_break_ctl,	571	.break_ctl = xr_break_ctl,

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

@@ -656,6 +656,13 @@ void usb_stor_invoke_transport(struct scsi_cmnd srb, struct us_data us) · 655 unmodified lines
656	need_auto_sense = 1;	656	need_auto_sense = 1;
657	}	657	}
658		658
		659	/* Some devices (Kindle) require another command after SYNC CACHE */
		660	if ((us->fflags & US_FL_SENSE_AFTER_SYNC) &&
		661	srb->cmnd[0] == SYNCHRONIZE_CACHE) {
		662	usb_stor_dbg(us, "-- sense after SYNC CACHE\n");
		663	need_auto_sense = 1;
		664	}
		665
659	/*	666	/*
660	* If we have a failure, we're going to do a REQUEST_SENSE	667	* If we have a failure, we're going to do a REQUEST_SENSE
661	* automatically. Note that we differentiate between a command	668	* automatically. Note that we differentiate between a command

drivers/usb/storage/unusual_devs.h+12−0

@@ -2211,6 +2211,18 @@ UNUSUAL_DEV( 0x1908, 0x3335, 0x0200, 0x0200, · 2210 unmodified lines
2211	USB_SC_DEVICE, USB_PR_DEVICE, NULL,	2211	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
2212	US_FL_NO_READ_DISC_INFO ),	2212	US_FL_NO_READ_DISC_INFO ),
2213		2213
		2214	/*
		2215	* Reported by Matthias Schwarzott <zzam@gentoo.org>
		2216	* The Amazon Kindle treats SYNCHRONIZE CACHE as an indication that
		2217	* the host may be finished with it, and automatically ejects its
		2218	* emulated media unless it receives another command within one second.
		2219	*/
		2220	UNUSUAL_DEV( 0x1949, 0x0004, 0x0000, 0x9999,
		2221	"Amazon",
		2222	"Kindle",
		2223	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
		2224	US_FL_SENSE_AFTER_SYNC ),
		2225
2214	/*	2226	/*
2215	* Reported by Oliver Neukum <oneukum@suse.com>	2227	* Reported by Oliver Neukum <oneukum@suse.com>
2216	* This device morphes spontaneously into another device if the access	2228	* This device morphes spontaneously into another device if the access

drivers/usb/typec/tcpm/tcpm.c+9−2

@@ -942,6 +942,7 @@ static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv) · 941 unmodified lines
942		942
943	port->supply_voltage = mv;	943	port->supply_voltage = mv;
944	port->current_limit = max_ma;	944	port->current_limit = max_ma;
		945	power_supply_changed(port->psy);
945		946
946	if (port->tcpc->set_current_limit)	947	if (port->tcpc->set_current_limit)
947	ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv);	948	ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv);
@@ -2928,6 +2929,7 @@ static int tcpm_pd_select_pdo(struct tcpm_port port, int sink_pdo, · 1980 unmodified lines
2928		2929
2929	port->pps_data.supported = false;	2930	port->pps_data.supported = false;
2930	port->usb_type = POWER_SUPPLY_USB_TYPE_PD;	2931	port->usb_type = POWER_SUPPLY_USB_TYPE_PD;
		2932	power_supply_changed(port->psy);
2931		2933
2932	/*	2934	/*
2933	* Select the source PDO providing the most power which has a	2935	* Select the source PDO providing the most power which has a
@@ -2952,6 +2954,7 @@ static int tcpm_pd_select_pdo(struct tcpm_port port, int sink_pdo, · 18 unmodified lines
2952	port->pps_data.supported = true;	2954	port->pps_data.supported = true;
2953	port->usb_type =	2955	port->usb_type =
2954	POWER_SUPPLY_USB_TYPE_PD_PPS;	2956	POWER_SUPPLY_USB_TYPE_PD_PPS;
		2957	power_supply_changed(port->psy);
2955	}	2958	}
2956	continue;	2959	continue;
2957	default:	2960	default:
@@ -3109,6 +3112,7 @@ static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port) · 151 unmodified lines
3109	port->pps_data.out_volt));	3112	port->pps_data.out_volt));
3110	port->pps_data.op_curr = min(port->pps_data.max_curr,	3113	port->pps_data.op_curr = min(port->pps_data.max_curr,
3111	port->pps_data.op_curr);	3114	port->pps_data.op_curr);
		3115	power_supply_changed(port->psy);
3112	}	3116	}
3113		3117
3114	return src_pdo;	3118	return src_pdo;
@@ -3344,6 +3348,7 @@ static int tcpm_set_charge(struct tcpm_port *port, bool charge) · 229 unmodified lines
3344	return ret;	3348	return ret;
3345	}	3349	}
3346	port->vbus_charge = charge;	3350	port->vbus_charge = charge;
		3351	power_supply_changed(port->psy);
3347	return 0;	3352	return 0;
3348	}	3353	}
3349		3354
@@ -3523,6 +3528,7 @@ static void tcpm_reset_port(struct tcpm_port *port) · 173 unmodified lines
3523	port->try_src_count = 0;	3528	port->try_src_count = 0;
3524	port->try_snk_count = 0;	3529	port->try_snk_count = 0;
3525	port->usb_type = POWER_SUPPLY_USB_TYPE_C;	3530	port->usb_type = POWER_SUPPLY_USB_TYPE_C;
		3531	power_supply_changed(port->psy);
3526	port->nr_sink_caps = 0;	3532	port->nr_sink_caps = 0;
3527	port->sink_cap_done = false;	3533	port->sink_cap_done = false;
3528	if (port->tcpc->enable_frs)	3534	if (port->tcpc->enable_frs)
@@ -5167,7 +5173,7 @@ static void tcpm_enable_frs_work(struct kthread_work *work) · 1638 unmodified lines
5167	goto unlock;	5173	goto unlock;
5168		5174
5169	/* Send when the state machine is idle */	5175	/* Send when the state machine is idle */
5170	if (port->state != SNK_READY \|\| port->vdm_state != VDM_STATE_DONE \|\| port->send_discover)	5176	if (port->state != SNK_READY \|\| port->vdm_sm_running \|\| port->send_discover)
5171	goto resched;	5177	goto resched;
5172		5178
5173	port->upcoming_state = GET_SINK_CAP;	5179	port->upcoming_state = GET_SINK_CAP;
@@ -5905,7 +5911,7 @@ static int tcpm_psy_set_prop(struct power_supply *psy, · 731 unmodified lines
5905	ret = -EINVAL;	5911	ret = -EINVAL;
5906	break;	5912	break;
5907	}	5913	}
5908		5914	power_supply_changed(port->psy);
5909	return ret;	5915	return ret;
5910	}	5916	}
5911		5917
@@ -6058,6 +6064,7 @@ struct tcpm_port tcpm_register_port(struct device dev, struct tcpc_dev *tcpc) · 146 unmodified lines
6058	err = devm_tcpm_psy_register(port);	6064	err = devm_tcpm_psy_register(port);
6059	if (err)	6065	if (err)
6060	goto out_role_sw_put;	6066	goto out_role_sw_put;
		6067	power_supply_changed(port->psy);
6061		6068
6062	port->typec_port = typec_register_port(port->dev, &port->typec_caps);	6069	port->typec_port = typec_register_port(port->dev, &port->typec_caps);
6063	if (IS_ERR(port->typec_port)) {	6070	if (IS_ERR(port->typec_port)) {

drivers/usb/typec/tps6598x.c+0−1

@@ -64,7 +64,6 @@ enum { · 63 unmodified lines
64	struct tps6598x_rx_identity_reg {	64	struct tps6598x_rx_identity_reg {
65	u8 status;	65	u8 status;
66	struct usb_pd_identity identity;	66	struct usb_pd_identity identity;
67	u32 vdo[3];
68	} __packed;	67	} __packed;
69		68
70	/* Standard Task return codes */	69	/* Standard Task return codes */

drivers/usb/usbip/stub_dev.c+35−7

 	int sockfd = 0;
 	struct socket *socket;
 	int rv;
+	struct task_struct *tcp_rx = NULL;
+	struct task_struct *tcp_tx = NULL;
 	if (!sdev) {
 		dev_err(dev, "sdev is null\n");
 		}
 		socket = sockfd_lookup(sockfd, &err);
-		if (!socket)
+		if (!socket) {
+			dev_err(dev, "failed to lookup sock");
 			goto err;
+		}
-		sdev->ud.tcp_socket = socket;
+		if (socket->type != SOCK_STREAM) {
-		sdev->ud.sockfd = sockfd;
+			dev_err(dev, "Expecting SOCK_STREAM - found %d",
+				socket->type);
+			goto sock_err;
+		}
+		/* unlock and create threads and get tasks */
 		spin_unlock_irq(&sdev->ud.lock);
+		tcp_rx = kthread_create(stub_rx_loop, &sdev->ud, "stub_rx");
+		if (IS_ERR(tcp_rx)) {
+			sockfd_put(socket);
+			return -EINVAL;
+		}
+		tcp_tx = kthread_create(stub_tx_loop, &sdev->ud, "stub_tx");
+		if (IS_ERR(tcp_tx)) {
+			kthread_stop(tcp_rx);
+			sockfd_put(socket);
+			return -EINVAL;
+		}
-		sdev->ud.tcp_rx = kthread_get_run(stub_rx_loop, &sdev->ud,
+		/* get task structs now */
-						  "stub_rx");
+		get_task_struct(tcp_rx);
-		sdev->ud.tcp_tx = kthread_get_run(stub_tx_loop, &sdev->ud,
+		get_task_struct(tcp_tx);
-						  "stub_tx");
+		/* lock and update sdev->ud state */
 		spin_lock_irq(&sdev->ud.lock);
+		sdev->ud.tcp_socket = socket;
+		sdev->ud.sockfd = sockfd;
+		sdev->ud.tcp_rx = tcp_rx;
+		sdev->ud.tcp_tx = tcp_tx;
 		sdev->ud.status = SDEV_ST_USED;
 		spin_unlock_irq(&sdev->ud.lock);
+		wake_up_process(sdev->ud.tcp_rx);
+		wake_up_process(sdev->ud.tcp_tx);
 	} else {
 		dev_info(dev, "stub down\n");
 	return count;
+sock_err:
+	sockfd_put(socket);
 err:
 	spin_unlock_irq(&sdev->ud.lock);
 	return -EINVAL;

drivers/usb/usbip/vhci_sysfs.c+34−5

 	struct vhci *vhci;
 	int err;
 	unsigned long flags;
+	struct task_struct *tcp_rx = NULL;
+	struct task_struct *tcp_tx = NULL;
 	/*
 	 * @rhport: port number of vhci_hcd
 	/* Extract socket from fd. */
 	socket = sockfd_lookup(sockfd, &err);
-	if (!socket)
+	if (!socket) {
+		dev_err(dev, "failed to lookup sock");
 		return -EINVAL;
+	}
+	if (socket->type != SOCK_STREAM) {
+		dev_err(dev, "Expecting SOCK_STREAM - found %d",
+			socket->type);
+		sockfd_put(socket);
+		return -EINVAL;
+	}
+	/* create threads before locking */
+	tcp_rx = kthread_create(vhci_rx_loop, &vdev->ud, "vhci_rx");
+	if (IS_ERR(tcp_rx)) {
+		sockfd_put(socket);
+		return -EINVAL;
+	}
+	tcp_tx = kthread_create(vhci_tx_loop, &vdev->ud, "vhci_tx");
+	if (IS_ERR(tcp_tx)) {
+		kthread_stop(tcp_rx);
+		sockfd_put(socket);
+		return -EINVAL;
+	}
-	/* now need lock until setting vdev status as used */
+	/* get task structs now */
+	get_task_struct(tcp_rx);
+	get_task_struct(tcp_tx);
-	/* begin a lock */
+	/* now begin lock until setting vdev status set */
 	spin_lock_irqsave(&vhci->lock, flags);
 	spin_lock(&vdev->ud.lock);
 		spin_unlock_irqrestore(&vhci->lock, flags);
 		sockfd_put(socket);
+		kthread_stop_put(tcp_rx);
+		kthread_stop_put(tcp_tx);
 		dev_err(dev, "port %d already used\n", rhport);
 		/*
 	vdev->speed         = speed;
 	vdev->ud.sockfd     = sockfd;
 	vdev->ud.tcp_socket = socket;
+	vdev->ud.tcp_rx     = tcp_rx;
+	vdev->ud.tcp_tx     = tcp_tx;
 	vdev->ud.status     = VDEV_ST_NOTASSIGNED;
 	usbip_kcov_handle_init(&vdev->ud);
 	spin_unlock_irqrestore(&vhci->lock, flags);
 	/* end the lock */
-	vdev->ud.tcp_rx = kthread_get_run(vhci_rx_loop, &vdev->ud, "vhci_rx");
+	wake_up_process(vdev->ud.tcp_rx);
-	vdev->ud.tcp_tx = kthread_get_run(vhci_tx_loop, &vdev->ud, "vhci_tx");
+	wake_up_process(vdev->ud.tcp_tx);
 	rh_port_connect(vdev, speed);

drivers/usb/usbip/vudc_sysfs.c+42−7

 }
 static BIN_ATTR_RO(dev_desc, sizeof(struct usb_device_descriptor));
-static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *attr,
+static ssize_t usbip_sockfd_store(struct device *dev,
-		     const char *in, size_t count)
+				  struct device_attribute *attr,
+				  const char *in, size_t count)
 {
 	struct vudc *udc = (struct vudc *) dev_get_drvdata(dev);
 	int rv;
 	struct socket *socket;
 	unsigned long flags;
 	int ret;
+	struct task_struct *tcp_rx = NULL;
+	struct task_struct *tcp_tx = NULL;
 	rv = kstrtoint(in, 0, &sockfd);
 	if (rv != 0)
 			goto unlock_ud;
 		}
-		udc->ud.tcp_socket = socket;
+		if (socket->type != SOCK_STREAM) {
+			dev_err(dev, "Expecting SOCK_STREAM - found %d",
+				socket->type);
+			ret = -EINVAL;
+			goto sock_err;
+		}
+		/* unlock and create threads and get tasks */
 		spin_unlock_irq(&udc->ud.lock);
 		spin_unlock_irqrestore(&udc->lock, flags);
-		udc->ud.tcp_rx = kthread_get_run(&v_rx_loop,
+		tcp_rx = kthread_create(&v_rx_loop, &udc->ud, "vudc_rx");
-						    &udc->ud, "vudc_rx");
+		if (IS_ERR(tcp_rx)) {
-		udc->ud.tcp_tx = kthread_get_run(&v_tx_loop,
+			sockfd_put(socket);
-						    &udc->ud, "vudc_tx");
+			return -EINVAL;
+		}
+		tcp_tx = kthread_create(&v_tx_loop, &udc->ud, "vudc_tx");
+		if (IS_ERR(tcp_tx)) {
+			kthread_stop(tcp_rx);
+			sockfd_put(socket);
+			return -EINVAL;
+		}
+		/* get task structs now */
+		get_task_struct(tcp_rx);
+		get_task_struct(tcp_tx);
+		/* lock and update udc->ud state */
 		spin_lock_irqsave(&udc->lock, flags);
 		spin_lock_irq(&udc->ud.lock);
+		udc->ud.tcp_socket = socket;
+		udc->ud.tcp_rx = tcp_rx;
+		udc->ud.tcp_tx = tcp_tx;
 		udc->ud.status = SDEV_ST_USED;
 		spin_unlock_irq(&udc->ud.lock);
 		ktime_get_ts64(&udc->start_time);
 		v_start_timer(udc);
 		udc->connected = 1;
+		spin_unlock_irqrestore(&udc->lock, flags);
+		wake_up_process(udc->ud.tcp_rx);
+		wake_up_process(udc->ud.tcp_tx);
+		return count;
 	} else {
 		if (!udc->connected) {
 			dev_err(dev, "Device not connected");
 	return count;
+sock_err:
+	sockfd_put(socket);
 unlock_ud:
 	spin_unlock_irq(&udc->ud.lock);
 unlock:

drivers/vdpa/ifcvf/ifcvf_main.c+2−3

 	}
 	adapter = vdpa_alloc_device(struct ifcvf_adapter, vdpa,
-				    dev, &ifc_vdpa_ops,
+				    dev, &ifc_vdpa_ops, NULL);
-				    IFCVF_MAX_QUEUE_PAIRS * 2, NULL);
 	if (adapter == NULL) {
 		IFCVF_ERR(pdev, "Failed to allocate vDPA structure");
 		return -ENOMEM;
 	for (i = 0; i < IFCVF_MAX_QUEUE_PAIRS * 2; i++)
 		vf->vring[i].irq = -EINVAL;
-	ret = vdpa_register_device(&adapter->vdpa);
+	ret = vdpa_register_device(&adapter->vdpa, IFCVF_MAX_QUEUE_PAIRS * 2);
 	if (ret) {
 		IFCVF_ERR(pdev, "Failed to register ifcvf to vdpa bus");
 		goto err;

drivers/vdpa/mlx5/net/mlx5_vnet.c+2−2

@@ -1982,7 +1982,7 @@ static int mlx5v_probe(struct auxiliary_device *adev, · 1981 unmodified lines
1982	max_vqs = min_t(u32, max_vqs, MLX5_MAX_SUPPORTED_VQS);	1982	max_vqs = min_t(u32, max_vqs, MLX5_MAX_SUPPORTED_VQS);
1983		1983
1984	ndev = vdpa_alloc_device(struct mlx5_vdpa_net, mvdev.vdev, mdev->device, &mlx5_vdpa_ops,	1984	ndev = vdpa_alloc_device(struct mlx5_vdpa_net, mvdev.vdev, mdev->device, &mlx5_vdpa_ops,
1985	2 * mlx5_vdpa_max_qps(max_vqs), NULL);	1985	NULL);
1986	if (IS_ERR(ndev))	1986	if (IS_ERR(ndev))
1987	return PTR_ERR(ndev);	1987	return PTR_ERR(ndev);
1988		1988
@@ -2009,7 +2009,7 @@ static int mlx5v_probe(struct auxiliary_device *adev, · 20 unmodified lines
2009	if (err)	2009	if (err)
2010	goto err_res;	2010	goto err_res;
2011		2011
2012	err = vdpa_register_device(&mvdev->vdev);	2012	err = vdpa_register_device(&mvdev->vdev, 2 * mlx5_vdpa_max_qps(max_vqs));
2013	if (err)	2013	if (err)
2014	goto err_reg;	2014	goto err_reg;
2015		2015

drivers/vdpa/vdpa.c+10−8

  * initialized but before registered.
  * @parent: the parent device
  * @config: the bus operations that is supported by this device
- * @nvqs: number of virtqueues supported by this device
  * @size: size of the parent structure that contains private data
  * @name: name of the vdpa device; optional.
  *
  */
 struct vdpa_device *__vdpa_alloc_device(struct device *parent,
 					const struct vdpa_config_ops *config,
-					int nvqs, size_t size, const char *name)
+					size_t size, const char *name)
 {
 	struct vdpa_device *vdev;
 	int err = -EINVAL;
 	vdev->index = err;
 	vdev->config = config;
 	vdev->features_valid = false;
-	vdev->nvqs = nvqs;
 	if (name)
 		err = dev_set_name(&vdev->dev, "%s", name);
 	return (strcmp(dev_name(&vdev->dev), data) == 0);
 }
-static int __vdpa_register_device(struct vdpa_device *vdev)
+static int __vdpa_register_device(struct vdpa_device *vdev, int nvqs)
 {
 	struct device *dev;
+	vdev->nvqs = nvqs;
 	lockdep_assert_held(&vdpa_dev_mutex);
 	dev = bus_find_device(&vdpa_bus, NULL, dev_name(&vdev->dev), vdpa_name_match);
 	if (dev) {
  * Caller must invoke this routine in the management device dev_add()
  * callback after setting up valid mgmtdev for this vdpa device.
  * @vdev: the vdpa device to be registered to vDPA bus
+ * @nvqs: number of virtqueues supported by this device
  *
  * Returns an error when fail to add device to vDPA bus
  */
-int _vdpa_register_device(struct vdpa_device *vdev)
+int _vdpa_register_device(struct vdpa_device *vdev, int nvqs)
 {
 	if (!vdev->mdev)
 		return -EINVAL;
-	return __vdpa_register_device(vdev);
+	return __vdpa_register_device(vdev, nvqs);
 }
 EXPORT_SYMBOL_GPL(_vdpa_register_device);
  * vdpa_register_device - register a vDPA device
  * Callers must have a succeed call of vdpa_alloc_device() before.
  * @vdev: the vdpa device to be registered to vDPA bus
+ * @nvqs: number of virtqueues supported by this device
  *
  * Returns an error when fail to add to vDPA bus
  */
-int vdpa_register_device(struct vdpa_device *vdev)
+int vdpa_register_device(struct vdpa_device *vdev, int nvqs)
 {
 	int err;
 	mutex_lock(&vdpa_dev_mutex);
-	err = __vdpa_register_device(vdev);
+	err = __vdpa_register_device(vdev, nvqs);
 	mutex_unlock(&vdpa_dev_mutex);
 	return err;
 }

drivers/vdpa/vdpa_sim/vdpa_sim.c+1−1

@@ -235,7 +235,7 @@ struct vdpasim vdpasim_create(struct vdpasim_dev_attr dev_attr) · 234 unmodified lines
235	ops = &vdpasim_config_ops;	235	ops = &vdpasim_config_ops;
236		236
237	vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL, ops,	237	vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL, ops,
238	dev_attr->nvqs, dev_attr->name);	238	dev_attr->name);
239	if (!vdpasim)	239	if (!vdpasim)
240	goto err_alloc;	240	goto err_alloc;
241		241

drivers/vdpa/vdpa_sim/vdpa_sim_net.c+2−3

 static void vdpasim_net_get_config(struct vdpasim *vdpasim, void *config)
 {
-	struct virtio_net_config *net_config =
+	struct virtio_net_config *net_config = config;
-		(struct virtio_net_config *)config;
 	net_config->mtu = cpu_to_vdpasim16(vdpasim, 1500);
 	net_config->status = cpu_to_vdpasim16(vdpasim, VIRTIO_NET_S_LINK_UP);
 	if (IS_ERR(simdev))
 		return PTR_ERR(simdev);
-	ret = _vdpa_register_device(&simdev->vdpa);
+	ret = _vdpa_register_device(&simdev->vdpa, VDPASIM_NET_VQ_NUM);
 	if (ret)
 		goto reg_err;

drivers/vfio/Kconfig+2−2

@@ -21,8 +21,8 @@ config VFIO_VIRQFD · 20 unmodified lines
21		21
22	menuconfig VFIO	22	menuconfig VFIO
23	tristate "VFIO Non-Privileged userspace driver framework"	23	tristate "VFIO Non-Privileged userspace driver framework"
24	depends on IOMMU_API	24	select IOMMU_API
25	select VFIO_IOMMU_TYPE1 if (X86 \|\| S390 \|\| ARM \|\| ARM64)	25	select VFIO_IOMMU_TYPE1 if MMU && (X86 \|\| S390 \|\| ARM \|\| ARM64)
26	help	26	help
27	VFIO provides a framework for secure userspace device drivers.	27	VFIO provides a framework for secure userspace device drivers.
28	See Documentation/driver-api/vfio.rst for more details.	28	See Documentation/driver-api/vfio.rst for more details.

drivers/vfio/platform/Kconfig+2−2

@@ -1,7 +1,7 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	config VFIO_PLATFORM	2	config VFIO_PLATFORM
3	tristate "VFIO support for platform devices"	3	tristate "VFIO support for platform devices"
4	depends on VFIO && EVENTFD && (ARM \|\| ARM64)	4	depends on VFIO && EVENTFD && (ARM \|\| ARM64 \|\| COMPILE_TEST)
5	select VFIO_VIRQFD	5	select VFIO_VIRQFD
6	help	6	help
7	Support for platform devices with VFIO. This is required to make	7	Support for platform devices with VFIO. This is required to make
@@ -12,7 +12,7 @@ config VFIO_PLATFORM · 4 unmodified lines
12		12
13	config VFIO_AMBA	13	config VFIO_AMBA
14	tristate "VFIO support for AMBA devices"	14	tristate "VFIO support for AMBA devices"
15	depends on VFIO_PLATFORM && ARM_AMBA	15	depends on VFIO_PLATFORM && (ARM_AMBA \|\| COMPILE_TEST)
16	help	16	help
17	Support for ARM AMBA devices with VFIO. This is required to make	17	Support for ARM AMBA devices with VFIO. This is required to make
18	use of ARM AMBA devices present on the system using the VFIO	18	use of ARM AMBA devices present on the system using the VFIO

drivers/vfio/vfio_iommu_type1.c+12−8

 }
 static struct rb_node *vfio_find_dma_first_node(struct vfio_iommu *iommu,
-						dma_addr_t start, size_t size)
+						dma_addr_t start, u64 size)
 {
 	struct rb_node *res = NULL;
 	struct rb_node *node = iommu->dma_list.rb_node;
 		return -ENODEV;
 	ret = vaddr_get_pfns(mm, vaddr, 1, dma->prot, pfn_base, pages);
-	if (ret == 1 && do_accounting && !is_invalid_reserved_pfn(*pfn_base)) {
+	if (ret != 1)
+		goto out;
+	ret = 0;
+	if (do_accounting && !is_invalid_reserved_pfn(*pfn_base)) {
 		ret = vfio_lock_acct(dma, 1, true);
 		if (ret) {
 			put_pfn(*pfn_base, dma->prot);
 		}
 	}
+out:
 	mmput(mm);
 	return ret;
 }
 	int ret = -EINVAL, retries = 0;
 	unsigned long pgshift;
 	dma_addr_t iova = unmap->iova;
-	unsigned long size = unmap->size;
+	u64 size = unmap->size;
 	bool unmap_all = unmap->flags & VFIO_DMA_UNMAP_FLAG_ALL;
 	bool invalidate_vaddr = unmap->flags & VFIO_DMA_UNMAP_FLAG_VADDR;
 	struct rb_node *n, *first_n;
 	if (unmap_all) {
 		if (iova || size)
 			goto unlock;
-		size = SIZE_MAX;
+		size = U64_MAX;
-	} else if (!size || size & (pgsize - 1)) {
+	} else if (!size || size & (pgsize - 1) ||
+		   iova + size - 1 < iova || size > SIZE_MAX) {
 		goto unlock;
 	}
-	if (iova + size - 1 < iova || size > SIZE_MAX)
-		goto unlock;
 	/* When dirty tracking is enabled, allow only min supported pgsize */
 	if ((unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) &&
 	    (!iommu->dirty_page_tracking || (bitmap->pgsize != pgsize))) {

drivers/vhost/vdpa.c+11−9

 static void vhost_vdpa_config_put(struct vhost_vdpa *v)
 {
-	if (v->config_ctx)
+	if (v->config_ctx) {
 		eventfd_ctx_put(v->config_ctx);
+		v->config_ctx = NULL;
+	}
 }
 static long vhost_vdpa_set_config_call(struct vhost_vdpa *v, u32 __user *argp)
 	if (!IS_ERR_OR_NULL(ctx))
 		eventfd_ctx_put(ctx);
-	if (IS_ERR(v->config_ctx))
+	if (IS_ERR(v->config_ctx)) {
-		return PTR_ERR(v->config_ctx);
+		long ret = PTR_ERR(v->config_ctx);
+		v->config_ctx = NULL;
+		return ret;
+	}
 	v->vdpa->config->set_config_cb(v->vdpa, &cb);
 static void vhost_vdpa_clean_irq(struct vhost_vdpa *v)
 {
-	struct vhost_virtqueue *vq;
 	int i;
-	for (i = 0; i < v->nvqs; i++) {
+	for (i = 0; i < v->nvqs; i++)
-		vq = &v->vqs[i];
+		vhost_vdpa_unsetup_vq_irq(v, i);
-		if (vq->call_ctx.producer.irq)
-			irq_bypass_unregister_producer(&vq->call_ctx.producer);
-	}
 }
 static int vhost_vdpa_release(struct inode *inode, struct file *filep)

drivers/vhost/vhost.c+1−1

 	vq->error_ctx = NULL;
 	vq->kick = NULL;
 	vq->log_ctx = NULL;
-	vhost_reset_is_le(vq);
 	vhost_disable_cross_endian(vq);
+	vhost_reset_is_le(vq);
 	vq->busyloop_timeout = 0;
 	vq->umem = NULL;
 	vq->iotlb = NULL;

drivers/video/fbdev/aty/atyfb.h+0−3

 #endif
 }
-#if defined(CONFIG_PMAC_BACKLIGHT) || defined (CONFIG_FB_ATY_GENERIC_LCD) || \
-defined (CONFIG_FB_ATY_BACKLIGHT)
 extern void aty_st_lcd(int index, u32 val, const struct atyfb_par *par);
 extern u32 aty_ld_lcd(int index, const struct atyfb_par *par);
-#endif
     /*
      *  DAC operations

drivers/video/fbdev/aty/atyfb_base.c+5−4

 #define PRINTKE(fmt, args...)	printk(KERN_ERR "atyfb: " fmt, ## args)
 #if defined(CONFIG_PMAC_BACKLIGHT) || defined(CONFIG_FB_ATY_GENERIC_LCD) || \
-defined(CONFIG_FB_ATY_BACKLIGHT)
+defined(CONFIG_FB_ATY_BACKLIGHT) || defined (CONFIG_PPC_PMAC)
 static const u32 lt_lcd_regs[] = {
 	CNFG_PANEL_LG,
 	LCD_GEN_CNTL_LG,
 		return aty_ld_le32(LCD_DATA, par);
 	}
 }
-#else /* defined(CONFIG_PMAC_BACKLIGHT) || defined(CONFIG_FB_ATY_BACKLIGHT) \
+#else /* defined(CONFIG_PMAC_BACKLIGHT) || defined(CONFIG_FB_ATY_BACKLIGHT) ||
-	 defined(CONFIG_FB_ATY_GENERIC_LCD) */
+	 defined(CONFIG_FB_ATY_GENERIC_LCD) || defined(CONFIG_PPC_PMAC) */
 void aty_st_lcd(int index, u32 val, const struct atyfb_par *par)
 { }
 {
 	return 0;
 }
-#endif /* defined(CONFIG_PMAC_BACKLIGHT) || defined (CONFIG_FB_ATY_GENERIC_LCD) */
+#endif /* defined(CONFIG_PMAC_BACKLIGHT) || defined(CONFIG_FB_ATY_BACKLIGHT) ||
+	  defined (CONFIG_FB_ATY_GENERIC_LCD) || defined(CONFIG_PPC_PMAC) */
 #ifdef CONFIG_FB_ATY_GENERIC_LCD
 /*

drivers/virt/acrn/hsm.c+10−1

 		acrn_ioreq_request_clear(vm);
 		break;
 	case ACRN_IOCTL_PM_GET_CPU_STATE:
-		if (copy_from_user(&cstate_cmd, (void *)ioctl_param,
+		if (copy_from_user(&cstate_cmd, (void __user *)ioctl_param,
 				   sizeof(cstate_cmd)))
 			return -EFAULT;
 }
 static DEVICE_ATTR_WO(remove_cpu);
+static umode_t acrn_attr_visible(struct kobject *kobj, struct attribute *a, int n)
+{
+       if (a == &dev_attr_remove_cpu.attr)
+               return IS_ENABLED(CONFIG_HOTPLUG_CPU) ? a->mode : 0;
+       return a->mode;
+}
 static struct attribute *acrn_attrs[] = {
 	&dev_attr_remove_cpu.attr,
 	NULL
 static struct attribute_group acrn_attr_group = {
 	.attrs = acrn_attrs,
+	.is_visible = acrn_attr_visible,
 };
 static const struct attribute_group *acrn_attr_groups[] = {

drivers/virt/acrn/irqfd.c+3−3

@@ -112,7 +112,7 @@ static int acrn_irqfd_assign(struct acrn_vm vm, struct acrn_irqfd args) · 111 unmodified lines
112	{	112	{
113	struct eventfd_ctx *eventfd = NULL;	113	struct eventfd_ctx *eventfd = NULL;
114	struct hsm_irqfd irqfd, tmp;	114	struct hsm_irqfd irqfd, tmp;
115	unsigned int events;	115	__poll_t events;
116	struct fd f;	116	struct fd f;
117	int ret = 0;	117	int ret = 0;
118		118
@@ -158,9 +158,9 @@ static int acrn_irqfd_assign(struct acrn_vm vm, struct acrn_irqfd args) · 39 unmodified lines
158	mutex_unlock(&vm->irqfds_lock);	158	mutex_unlock(&vm->irqfds_lock);
159		159
160	/* Check the pending event in this stage */	160	/* Check the pending event in this stage */
161	events = f.file->f_op->poll(f.file, &irqfd->pt);	161	events = vfs_poll(f.file, &irqfd->pt);
162		162
163	if (events & POLLIN)	163	if (events & EPOLLIN)
164	acrn_irqfd_inject(irqfd);	164	acrn_irqfd_inject(irqfd);
165		165
166	fdput(f);	166	fdput(f);

drivers/virtio/virtio.c+2−4

 }
 EXPORT_SYMBOL_GPL(virtio_config_changed);
-void virtio_config_disable(struct virtio_device *dev)
+static void virtio_config_disable(struct virtio_device *dev)
 {
 	spin_lock_irq(&dev->config_lock);
 	dev->config_enabled = false;
 	spin_unlock_irq(&dev->config_lock);
 }
-EXPORT_SYMBOL_GPL(virtio_config_disable);
-void virtio_config_enable(struct virtio_device *dev)
+static void virtio_config_enable(struct virtio_device *dev)
 {
 	spin_lock_irq(&dev->config_lock);
 	dev->config_enabled = true;
 	dev->config_change_pending = false;
 	spin_unlock_irq(&dev->config_lock);
 }
-EXPORT_SYMBOL_GPL(virtio_config_enable);
 void virtio_add_status(struct virtio_device *dev, unsigned int status)
 {

drivers/virtio/virtio_mmio.c+1−2

@@ -548,8 +548,7 @@ static void virtio_mmio_release_dev(struct device *_d) · 547 unmodified lines
548	{	548	{
549	struct virtio_device *vdev =	549	struct virtio_device *vdev =
550	container_of(_d, struct virtio_device, dev);	550	container_of(_d, struct virtio_device, dev);
551	struct virtio_mmio_device *vm_dev =	551	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
552	container_of(vdev, struct virtio_mmio_device, vdev);
553	struct platform_device *pdev = vm_dev->pdev;	552	struct platform_device *pdev = vm_dev->pdev;
554		553
555	devm_kfree(&pdev->dev, vm_dev);	554	devm_kfree(&pdev->dev, vm_dev);

drivers/watchdog/cpu5wdt.c+0−1

@@ -273,7 +273,6 @@ module_exit(cpu5wdt_exit_module); · 272 unmodified lines
273		273
274	MODULE_AUTHOR("Heiko Ronsdorf <hero@ihg.uni-duisburg.de>");	274	MODULE_AUTHOR("Heiko Ronsdorf <hero@ihg.uni-duisburg.de>");
275	MODULE_DESCRIPTION("sma cpu5 watchdog driver");	275	MODULE_DESCRIPTION("sma cpu5 watchdog driver");
276	MODULE_SUPPORTED_DEVICE("sma cpu5 watchdog");
277	MODULE_LICENSE("GPL");	276	MODULE_LICENSE("GPL");
278		277
279	module_param_hw(port, int, ioport, 0);	278	module_param_hw(port, int, ioport, 0);

drivers/watchdog/cpwd.c+0−1

@@ -172,7 +172,6 @@ MODULE_PARM_DESC(wd2_timeout, "Default watchdog2 timeout in 1/10secs"); · 171 unmodified lines
172	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");	172	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
173	MODULE_DESCRIPTION("Hardware watchdog driver for Sun Microsystems CP1400/1500");	173	MODULE_DESCRIPTION("Hardware watchdog driver for Sun Microsystems CP1400/1500");
174	MODULE_LICENSE("GPL");	174	MODULE_LICENSE("GPL");
175	MODULE_SUPPORTED_DEVICE("watchdog");
176		175
177	static void cpwd_writew(u16 val, void __iomem *addr)	176	static void cpwd_writew(u16 val, void __iomem *addr)
178	{	177	{

drivers/watchdog/riowd.c+0−1

@@ -46,7 +46,6 @@ · 45 unmodified lines
46		46
47	MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");	47	MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
48	MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");	48	MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
49	MODULE_SUPPORTED_DEVICE("watchdog");
50	MODULE_LICENSE("GPL");	49	MODULE_LICENSE("GPL");
51		50
52	#define DRIVER_NAME "riowd"	51	#define DRIVER_NAME "riowd"

drivers/xen/events/events_2l.c+15−7

 	return EVTCHN_2L_NR_CHANNELS;
 }
+static void evtchn_2l_remove(evtchn_port_t evtchn, unsigned int cpu)
+{
+	clear_bit(evtchn, BM(per_cpu(cpu_evtchn_mask, cpu)));
+}
 static void evtchn_2l_bind_to_cpu(evtchn_port_t evtchn, unsigned int cpu,
 				  unsigned int old_cpu)
 {
 	return sync_test_bit(port, BM(&s->evtchn_pending[0]));
 }
-static bool evtchn_2l_test_and_set_mask(evtchn_port_t port)
-{
-	struct shared_info *s = HYPERVISOR_shared_info;
-	return sync_test_and_set_bit(port, BM(&s->evtchn_mask[0]));
-}
 static void evtchn_2l_mask(evtchn_port_t port)
 {
 	struct shared_info *s = HYPERVISOR_shared_info;
 				EVTCHN_2L_NR_CHANNELS/BITS_PER_EVTCHN_WORD);
 }
+static int evtchn_2l_percpu_deinit(unsigned int cpu)
+{
+	memset(per_cpu(cpu_evtchn_mask, cpu), 0, sizeof(xen_ulong_t) *
+			EVTCHN_2L_NR_CHANNELS/BITS_PER_EVTCHN_WORD);
+	return 0;
+}
 static const struct evtchn_ops evtchn_ops_2l = {
 	.max_channels      = evtchn_2l_max_channels,
 	.nr_channels       = evtchn_2l_max_channels,
+	.remove            = evtchn_2l_remove,
 	.bind_to_cpu       = evtchn_2l_bind_to_cpu,
 	.clear_pending     = evtchn_2l_clear_pending,
 	.set_pending       = evtchn_2l_set_pending,
 	.is_pending        = evtchn_2l_is_pending,
-	.test_and_set_mask = evtchn_2l_test_and_set_mask,
 	.mask              = evtchn_2l_mask,
 	.unmask            = evtchn_2l_unmask,
 	.handle_events     = evtchn_2l_handle_events,
 	.resume	           = evtchn_2l_resume,
+	.percpu_deinit     = evtchn_2l_percpu_deinit,
 };
 void __init xen_evtchn_2l_init(void)

drivers/xen/events/events_base.c+100−30

 	short refcnt;
 	u8 spurious_cnt;
 	u8 is_accounted;
-	enum xen_irq_type type; /* type */
+	short type;		/* type: IRQT_* */
+	u8 mask_reason;		/* Why is event channel masked */
+#define EVT_MASK_REASON_EXPLICIT	0x01
+#define EVT_MASK_REASON_TEMPORARY	0x02
+#define EVT_MASK_REASON_EOI_PENDING	0x04
+	u8 is_active;		/* Is event just being handled? */
 	unsigned irq;
 	evtchn_port_t evtchn;   /* event channel */
 	unsigned short cpu;     /* cpu bound */
 	unsigned short eoi_cpu; /* EOI must happen on this cpu-1 */
 	unsigned int irq_epoch; /* If eoi_cpu valid: irq_epoch of event */
 	u64 eoi_time;           /* Time in jiffies when to EOI. */
+	spinlock_t lock;
 	union {
 		unsigned short virq;
  *   evtchn_rwlock
  *     IRQ-desc lock
  *       percpu eoi_list_lock
+ *         irq_info->lock
  */
 static LIST_HEAD(xen_irq_list_head);
 	info->irq = irq;
 	info->evtchn = evtchn;
 	info->cpu = cpu;
+	info->mask_reason = EVT_MASK_REASON_EXPLICIT;
+	spin_lock_init(&info->lock);
 	ret = set_evtchn_to_irq(evtchn, irq);
 	if (ret < 0)
 static void xen_irq_info_cleanup(struct irq_info *info)
 {
 	set_evtchn_to_irq(info->evtchn, -1);
+	xen_evtchn_port_remove(info->evtchn, info->cpu);
 	info->evtchn = 0;
 	channels_on_cpu_dec(info);
 }
 	return ret;
 }
+static void do_mask(struct irq_info *info, u8 reason)
+{
+	unsigned long flags;
+	spin_lock_irqsave(&info->lock, flags);
+	if (!info->mask_reason)
+		mask_evtchn(info->evtchn);
+	info->mask_reason |= reason;
+	spin_unlock_irqrestore(&info->lock, flags);
+}
+static void do_unmask(struct irq_info *info, u8 reason)
+{
+	unsigned long flags;
+	spin_lock_irqsave(&info->lock, flags);
+	info->mask_reason &= ~reason;
+	if (!info->mask_reason)
+		unmask_evtchn(info->evtchn);
+	spin_unlock_irqrestore(&info->lock, flags);
+}
 #ifdef CONFIG_X86
 static bool pirq_check_eoi_map(unsigned irq)
 {
 	}
 	info->eoi_time = 0;
-	unmask_evtchn(evtchn);
+	do_unmask(info, EVT_MASK_REASON_EOI_PENDING);
 }
 static void xen_irq_lateeoi_worker(struct work_struct *work)
 		BUG();
 }
+static void event_handler_exit(struct irq_info *info)
+{
+	smp_store_release(&info->is_active, 0);
+	clear_evtchn(info->evtchn);
+}
 static void pirq_query_unmask(int irq)
 {
 	struct physdev_irq_status_query irq_status;
 static void eoi_pirq(struct irq_data *data)
 {
-	evtchn_port_t evtchn = evtchn_from_irq(data->irq);
+	struct irq_info *info = info_for_irq(data->irq);
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
 	struct physdev_eoi eoi = { .irq = pirq_from_irq(data->irq) };
 	int rc = 0;
 	if (!VALID_EVTCHN(evtchn))
 		return;
-	clear_evtchn(evtchn);
+	event_handler_exit(info);
 	if (pirq_needs_eoi(data->irq)) {
 		rc = HYPERVISOR_physdev_op(PHYSDEVOP_eoi, &eoi);
 		goto err;
 out:
-	unmask_evtchn(evtchn);
+	do_unmask(info, EVT_MASK_REASON_EXPLICIT);
 	eoi_pirq(irq_get_irq_data(irq));
 	return 0;
 	if (!VALID_EVTCHN(evtchn))
 		return;
-	mask_evtchn(evtchn);
+	do_mask(info, EVT_MASK_REASON_EXPLICIT);
 	xen_evtchn_close(evtchn);
 	xen_irq_info_cleanup(info);
 }
 	}
 	info = info_for_irq(irq);
+	if (xchg_acquire(&info->is_active, 1))
+		return;
 	dev = (info->type == IRQT_EVTCHN) ? info->u.interdomain : NULL;
 	if (dev)
 }
 /* Rebind an evtchn so that it gets delivered to a specific cpu */
-static int xen_rebind_evtchn_to_cpu(evtchn_port_t evtchn, unsigned int tcpu)
+static int xen_rebind_evtchn_to_cpu(struct irq_info *info, unsigned int tcpu)
 {
 	struct evtchn_bind_vcpu bind_vcpu;
-	int masked;
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
 	if (!VALID_EVTCHN(evtchn))
 		return -1;
 	 * Mask the event while changing the VCPU binding to prevent
 	 * it being delivered on an unexpected VCPU.
 	 */
-	masked = test_and_set_mask(evtchn);
+	do_mask(info, EVT_MASK_REASON_TEMPORARY);
 	/*
 	 * If this fails, it usually just indicates that we're dealing with a
 	if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_vcpu, &bind_vcpu) >= 0)
 		bind_evtchn_to_cpu(evtchn, tcpu, false);
-	if (!masked)
+	do_unmask(info, EVT_MASK_REASON_TEMPORARY);
-		unmask_evtchn(evtchn);
 	return 0;
 }
 	unsigned int tcpu = select_target_cpu(dest);
 	int ret;
-	ret = xen_rebind_evtchn_to_cpu(evtchn_from_irq(data->irq), tcpu);
+	ret = xen_rebind_evtchn_to_cpu(info_for_irq(data->irq), tcpu);
 	if (!ret)
 		irq_data_update_effective_affinity(data, cpumask_of(tcpu));
 static void enable_dynirq(struct irq_data *data)
 {
-	evtchn_port_t evtchn = evtchn_from_irq(data->irq);
+	struct irq_info *info = info_for_irq(data->irq);
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
 	if (VALID_EVTCHN(evtchn))
-		unmask_evtchn(evtchn);
+		do_unmask(info, EVT_MASK_REASON_EXPLICIT);
 }
 static void disable_dynirq(struct irq_data *data)
 {
-	evtchn_port_t evtchn = evtchn_from_irq(data->irq);
+	struct irq_info *info = info_for_irq(data->irq);
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
 	if (VALID_EVTCHN(evtchn))
-		mask_evtchn(evtchn);
+		do_mask(info, EVT_MASK_REASON_EXPLICIT);
 }
 static void ack_dynirq(struct irq_data *data)
 {
-	evtchn_port_t evtchn = evtchn_from_irq(data->irq);
+	struct irq_info *info = info_for_irq(data->irq);
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
-	if (!VALID_EVTCHN(evtchn))
+	if (VALID_EVTCHN(evtchn))
-		return;
+		event_handler_exit(info);
-	clear_evtchn(evtchn);
 }
 static void mask_ack_dynirq(struct irq_data *data)
 	ack_dynirq(data);
 }
+static void lateeoi_ack_dynirq(struct irq_data *data)
+{
+	struct irq_info *info = info_for_irq(data->irq);
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
+	if (VALID_EVTCHN(evtchn)) {
+		do_mask(info, EVT_MASK_REASON_EOI_PENDING);
+		event_handler_exit(info);
+	}
+}
+static void lateeoi_mask_ack_dynirq(struct irq_data *data)
+{
+	struct irq_info *info = info_for_irq(data->irq);
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
+	if (VALID_EVTCHN(evtchn)) {
+		do_mask(info, EVT_MASK_REASON_EXPLICIT);
+		event_handler_exit(info);
+	}
+}
 static int retrigger_dynirq(struct irq_data *data)
 {
-	evtchn_port_t evtchn = evtchn_from_irq(data->irq);
+	struct irq_info *info = info_for_irq(data->irq);
-	int masked;
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
 	if (!VALID_EVTCHN(evtchn))
 		return 0;
-	masked = test_and_set_mask(evtchn);
+	do_mask(info, EVT_MASK_REASON_TEMPORARY);
 	set_evtchn(evtchn);
-	if (!masked)
+	do_unmask(info, EVT_MASK_REASON_TEMPORARY);
-		unmask_evtchn(evtchn);
 	return 1;
 }
 /* Clear an irq's pending state, in preparation for polling on it */
 void xen_clear_irq_pending(int irq)
 {
-	evtchn_port_t evtchn = evtchn_from_irq(irq);
+	struct irq_info *info = info_for_irq(irq);
+	evtchn_port_t evtchn = info ? info->evtchn : 0;
 	if (VALID_EVTCHN(evtchn))
-		clear_evtchn(evtchn);
+		event_handler_exit(info);
 }
 EXPORT_SYMBOL(xen_clear_irq_pending);
 void xen_set_irq_pending(int irq)
 	.irq_mask		= disable_dynirq,
 	.irq_unmask		= enable_dynirq,
-	.irq_ack		= mask_ack_dynirq,
+	.irq_ack		= lateeoi_ack_dynirq,
-	.irq_mask_ack		= mask_ack_dynirq,
+	.irq_mask_ack		= lateeoi_mask_ack_dynirq,
 	.irq_set_affinity	= set_affinity_irq,
 	.irq_retrigger		= retrigger_dynirq,

drivers/xen/events/events_fifo.c+0−7

 	return sync_test_bit(EVTCHN_FIFO_BIT(PENDING, word), BM(word));
 }
-static bool evtchn_fifo_test_and_set_mask(evtchn_port_t port)
-{
-	event_word_t *word = event_word_from_port(port);
-	return sync_test_and_set_bit(EVTCHN_FIFO_BIT(MASKED, word), BM(word));
-}
 static void evtchn_fifo_mask(evtchn_port_t port)
 {
 	event_word_t *word = event_word_from_port(port);
 	.clear_pending     = evtchn_fifo_clear_pending,
 	.set_pending       = evtchn_fifo_set_pending,
 	.is_pending        = evtchn_fifo_is_pending,
-	.test_and_set_mask = evtchn_fifo_test_and_set_mask,
 	.mask              = evtchn_fifo_mask,
 	.unmask            = evtchn_fifo_unmask,
 	.handle_events     = evtchn_fifo_handle_events,

drivers/xen/events/events_internal.h+8−6

 	unsigned (*nr_channels)(void);
 	int (*setup)(evtchn_port_t port);
+	void (*remove)(evtchn_port_t port, unsigned int cpu);
 	void (*bind_to_cpu)(evtchn_port_t evtchn, unsigned int cpu,
 			    unsigned int old_cpu);
 	void (*clear_pending)(evtchn_port_t port);
 	void (*set_pending)(evtchn_port_t port);
 	bool (*is_pending)(evtchn_port_t port);
-	bool (*test_and_set_mask)(evtchn_port_t port);
 	void (*mask)(evtchn_port_t port);
 	void (*unmask)(evtchn_port_t port);
 	return 0;
 }
+static inline void xen_evtchn_port_remove(evtchn_port_t evtchn,
+					  unsigned int cpu)
+{
+	if (evtchn_ops->remove)
+		evtchn_ops->remove(evtchn, cpu);
+}
 static inline void xen_evtchn_port_bind_to_cpu(evtchn_port_t evtchn,
 					       unsigned int cpu,
 					       unsigned int old_cpu)
 	return evtchn_ops->is_pending(port);
 }
-static inline bool test_and_set_mask(evtchn_port_t port)
-{
-	return evtchn_ops->test_and_set_mask(port);
-}
 static inline void mask_evtchn(evtchn_port_t port)
 {
 	return evtchn_ops->mask(port);

drivers/xen/gntdev.c+33−21

 	if (NULL == add)
 		return NULL;
-	add->grants    = kvcalloc(count, sizeof(add->grants[0]), GFP_KERNEL);
+	add->grants    = kvmalloc_array(count, sizeof(add->grants[0]),
-	add->map_ops   = kvcalloc(count, sizeof(add->map_ops[0]), GFP_KERNEL);
+					GFP_KERNEL);
-	add->unmap_ops = kvcalloc(count, sizeof(add->unmap_ops[0]), GFP_KERNEL);
+	add->map_ops   = kvmalloc_array(count, sizeof(add->map_ops[0]),
-	add->kmap_ops  = kvcalloc(count, sizeof(add->kmap_ops[0]), GFP_KERNEL);
+					GFP_KERNEL);
-	add->kunmap_ops = kvcalloc(count,
+	add->unmap_ops = kvmalloc_array(count, sizeof(add->unmap_ops[0]),
-				   sizeof(add->kunmap_ops[0]), GFP_KERNEL);
+					GFP_KERNEL);
 	add->pages     = kvcalloc(count, sizeof(add->pages[0]), GFP_KERNEL);
 	if (NULL == add->grants    ||
 	    NULL == add->map_ops   ||
 	    NULL == add->unmap_ops ||
-	    NULL == add->kmap_ops  ||
-	    NULL == add->kunmap_ops ||
 	    NULL == add->pages)
 		goto err;
+	if (use_ptemod) {
+		add->kmap_ops   = kvmalloc_array(count, sizeof(add->kmap_ops[0]),
+						 GFP_KERNEL);
+		add->kunmap_ops = kvmalloc_array(count, sizeof(add->kunmap_ops[0]),
+						 GFP_KERNEL);
+		if (NULL == add->kmap_ops || NULL == add->kunmap_ops)
+			goto err;
+	}
 #ifdef CONFIG_XEN_GRANT_DMA_ALLOC
 	add->dma_flags = dma_flags;
 		goto err;
 	for (i = 0; i < count; i++) {
-		add->map_ops[i].handle = -1;
+		add->grants[i].domid = DOMID_INVALID;
-		add->unmap_ops[i].handle = -1;
+		add->grants[i].ref = INVALID_GRANT_REF;
-		add->kmap_ops[i].handle = -1;
+		add->map_ops[i].handle = INVALID_GRANT_HANDLE;
-		add->kunmap_ops[i].handle = -1;
+		add->unmap_ops[i].handle = INVALID_GRANT_HANDLE;
+		if (use_ptemod) {
+			add->kmap_ops[i].handle = INVALID_GRANT_HANDLE;
+			add->kunmap_ops[i].handle = INVALID_GRANT_HANDLE;
+		}
 	}
 	add->index = 0;
 			  map->grants[pgnr].ref,
 			  map->grants[pgnr].domid);
 	gnttab_set_unmap_op(&map->unmap_ops[pgnr], pte_maddr, flags,
-			    -1 /* handle */);
+			    INVALID_GRANT_HANDLE);
 	return 0;
 }
 	if (!use_ptemod) {
 		/* Note: it could already be mapped */
-		if (map->map_ops[0].handle != -1)
+		if (map->map_ops[0].handle != INVALID_GRANT_HANDLE)
 			return 0;
 		for (i = 0; i < map->count; i++) {
 			unsigned long addr = (unsigned long)
 				map->grants[i].ref,
 				map->grants[i].domid);
 			gnttab_set_unmap_op(&map->unmap_ops[i], addr,
-				map->flags, -1 /* handle */);
+				map->flags, INVALID_GRANT_HANDLE);
 		}
 	} else {
 		/*
 				map->grants[i].ref,
 				map->grants[i].domid);
 			gnttab_set_unmap_op(&map->kunmap_ops[i], address,
-				flags, -1);
+				flags, INVALID_GRANT_HANDLE);
 		}
 	}
 	pr_debug("map %d+%d\n", map->index, map->count);
-	err = gnttab_map_refs(map->map_ops, use_ptemod ? map->kmap_ops : NULL,
+	err = gnttab_map_refs(map->map_ops, map->kmap_ops, map->pages,
-			map->pages, map->count);
+			map->count);
 	for (i = 0; i < map->count; i++) {
 		if (map->map_ops[i].status == GNTST_okay)
 		pr_debug("unmap handle=%d st=%d\n",
 			map->unmap_ops[offset+i].handle,
 			map->unmap_ops[offset+i].status);
-		map->unmap_ops[offset+i].handle = -1;
+		map->unmap_ops[offset+i].handle = INVALID_GRANT_HANDLE;
 	}
 	return err;
 }
 	 * already unmapped some of the grants. Only unmap valid ranges.
 	 */
 	while (pages && !err) {
-		while (pages && map->unmap_ops[offset].handle == -1) {
+		while (pages &&
+		       map->unmap_ops[offset].handle == INVALID_GRANT_HANDLE) {
 			offset++;
 			pages--;
 		}
 		range = 0;
 		while (range < pages) {
-			if (map->unmap_ops[offset+range].handle == -1)
+			if (map->unmap_ops[offset + range].handle ==
+			    INVALID_GRANT_HANDLE)
 				break;
 			range++;
 		}

fs/Kconfig+1−1

@@ -203,7 +203,7 @@ config TMPFS_XATTR · 202 unmodified lines
203		203
204	config TMPFS_INODE64	204	config TMPFS_INODE64
205	bool "Use 64-bit ino_t by default in tmpfs"	205	bool "Use 64-bit ino_t by default in tmpfs"
206	depends on TMPFS && 64BIT && !(S390 \|\| ALPHA)	206	depends on TMPFS && 64BIT
207	default n	207	default n
208	help	208	help
209	tmpfs has historically used only inode numbers as wide as an unsigned	209	tmpfs has historically used only inode numbers as wide as an unsigned

fs/afs/dir.c+0−1

@@ -70,7 +70,6 @@ const struct inode_operations afs_dir_inode_operations = { · 69 unmodified lines
70	.permission = afs_permission,	70	.permission = afs_permission,
71	.getattr = afs_getattr,	71	.getattr = afs_getattr,
72	.setattr = afs_setattr,	72	.setattr = afs_setattr,
73	.listxattr = afs_listxattr,
74	};	73	};
75		74
76	const struct address_space_operations afs_dir_aops = {	75	const struct address_space_operations afs_dir_aops = {

fs/afs/file.c+0−1

@@ -43,7 +43,6 @@ const struct inode_operations afs_file_inode_operations = { · 42 unmodified lines
43	.getattr = afs_getattr,	43	.getattr = afs_getattr,
44	.setattr = afs_setattr,	44	.setattr = afs_setattr,
45	.permission = afs_permission,	45	.permission = afs_permission,
46	.listxattr = afs_listxattr,
47	};	46	};
48		47
49	const struct address_space_operations afs_fs_aops = {	48	const struct address_space_operations afs_fs_aops = {

fs/afs/fs_operation.c+5−2

 		if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&
 		    op->ops->issue_yfs_rpc)
 			op->ops->issue_yfs_rpc(op);
-		else
+		else if (op->ops->issue_afs_rpc)
 			op->ops->issue_afs_rpc(op);
+		else
+			op->ac.error = -ENOTSUPP;
-		op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
+		if (op->call)
+			op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
 	}
 	switch (op->error) {

fs/afs/inode.c+0−1

@@ -27,7 +27,6 @@ · 26 unmodified lines
27		27
28	static const struct inode_operations afs_symlink_inode_operations = {	28	static const struct inode_operations afs_symlink_inode_operations = {
29	.get_link = page_get_link,	29	.get_link = page_get_link,
30	.listxattr = afs_listxattr,
31	};	30	};
32		31
33	static noinline void dump_vnode(struct afs_vnode vnode, struct afs_vnode parent_vnode)	32	static noinline void dump_vnode(struct afs_vnode vnode, struct afs_vnode parent_vnode)

fs/afs/internal.h+0−1

@@ -1509,7 +1509,6 @@ extern int afs_launder_page(struct page *); · 1508 unmodified lines
1509	* xattr.c	1509	* xattr.c
1510	*/	1510	*/
1511	extern const struct xattr_handler *afs_xattr_handlers[];	1511	extern const struct xattr_handler *afs_xattr_handlers[];
1512	extern ssize_t afs_listxattr(struct dentry , char , size_t);
1513		1512
1514	/*	1513	/*
1515	* yfsclient.c	1514	* yfsclient.c

fs/afs/mntpt.c+0−1

@@ -32,7 +32,6 @@ const struct inode_operations afs_mntpt_inode_operations = { · 31 unmodified lines
32	.lookup = afs_mntpt_lookup,	32	.lookup = afs_mntpt_lookup,
33	.readlink = page_readlink,	33	.readlink = page_readlink,
34	.getattr = afs_getattr,	34	.getattr = afs_getattr,
35	.listxattr = afs_listxattr,
36	};	35	};
37		36
38	const struct inode_operations afs_autocell_inode_operations = {	37	const struct inode_operations afs_autocell_inode_operations = {

fs/afs/write.c+1−2

@@ -851,8 +851,7 @@ vm_fault_t afs_page_mkwrite(struct vm_fault *vmf) · 850 unmodified lines
851	fscache_wait_on_page_write(vnode->cache, vmf->page);	851	fscache_wait_on_page_write(vnode->cache, vmf->page);
852	#endif	852	#endif
853		853
854	if (PageWriteback(vmf->page) &&	854	if (wait_on_page_writeback_killable(vmf->page))
855	wait_on_page_bit_killable(vmf->page, PG_writeback) < 0)
856	return VM_FAULT_RETRY;	855	return VM_FAULT_RETRY;
857		856
858	if (lock_page_killable(vmf->page) < 0)	857	if (lock_page_killable(vmf->page) < 0)

fs/afs/xattr.c+7−24

 #include <linux/xattr.h>
 #include "internal.h"
-static const char afs_xattr_list[] =
-	"afs.acl\0"
-	"afs.cell\0"
-	"afs.fid\0"
-	"afs.volume\0"
-	"afs.yfs.acl\0"
-	"afs.yfs.acl_inherited\0"
-	"afs.yfs.acl_num_cleaned\0"
-	"afs.yfs.vol_acl";
-/*
- * Retrieve a list of the supported xattrs.
- */
-ssize_t afs_listxattr(struct dentry *dentry, char *buffer, size_t size)
-{
-	if (size == 0)
-		return sizeof(afs_xattr_list);
-	if (size < sizeof(afs_xattr_list))
-		return -ERANGE;
-	memcpy(buffer, afs_xattr_list, sizeof(afs_xattr_list));
-	return sizeof(afs_xattr_list);
-}
 /*
  * Deal with the result of a successful fetch ACL operation.
  */
 			else
 				ret = -ERANGE;
 		}
+	} else if (ret == -ENOTSUPP) {
+		ret = -ENODATA;
 	}
 error_yacl:
 {
 	struct afs_operation *op;
 	struct afs_vnode *vnode = AFS_FS_I(inode);
+	int ret;
 	if (flags == XATTR_CREATE ||
 	    strcmp(name, "acl") != 0)
 		return afs_put_operation(op);
 	op->ops = &yfs_store_opaque_acl2_operation;
-	return afs_do_sync_operation(op);
+	ret = afs_do_sync_operation(op);
+	if (ret == -ENOTSUPP)
+		ret = -ENODATA;
+	return ret;
 }
 static const struct xattr_handler afs_xattr_yfs_handler = {

fs/binfmt_misc.c+14−15

 	struct super_block *sb = file_inode(file)->i_sb;
 	struct dentry *root = sb->s_root, *dentry;
 	int err = 0;
+	struct file *f = NULL;
 	e = create_entry(buffer, count);
 	if (IS_ERR(e))
 		return PTR_ERR(e);
+	if (e->flags & MISC_FMT_OPEN_FILE) {
+		f = open_exec(e->interpreter);
+		if (IS_ERR(f)) {
+			pr_notice("register: failed to install interpreter file %s\n",
+				 e->interpreter);
+			kfree(e);
+			return PTR_ERR(f);
+		}
+		e->interp_file = f;
+	}
 	inode_lock(d_inode(root));
 	dentry = lookup_one_len(e->name, root, strlen(e->name));
 	err = PTR_ERR(dentry);
 		goto out2;
 	}
-	if (e->flags & MISC_FMT_OPEN_FILE) {
-		struct file *f;
-		f = open_exec(e->interpreter);
-		if (IS_ERR(f)) {
-			err = PTR_ERR(f);
-			pr_notice("register: failed to install interpreter file %s\n", e->interpreter);
-			simple_release_fs(&bm_mnt, &entry_count);
-			iput(inode);
-			inode = NULL;
-			goto out2;
-		}
-		e->interp_file = f;
-	}
 	e->dentry = dget(dentry);
 	inode->i_private = e;
 	inode->i_fop = &bm_entry_operations;
 	inode_unlock(d_inode(root));
 	if (err) {
+		if (f)
+			filp_close(f, NULL);
 		kfree(e);
 		return err;
 	}

fs/block_dev.c+13−4

 	if (!(mode & FMODE_EXCL)) {
 		int err = bd_prepare_to_claim(bdev, truncate_bdev_range);
 		if (err)
-			return err;
+			goto invalidate;
 	}
 	truncate_inode_pages_range(bdev->bd_inode->i_mapping, lstart, lend);
 	if (!(mode & FMODE_EXCL))
 		bd_abort_claiming(bdev, truncate_bdev_range);
 	return 0;
+invalidate:
+	/*
+	 * Someone else has handle exclusively open. Try invalidating instead.
+	 * The 'end' argument is inclusive so the rounding is safe.
+	 */
+	return invalidate_inode_pages2_range(bdev->bd_inode->i_mapping,
+					     lstart >> PAGE_SHIFT,
+					     lend >> PAGE_SHIFT);
 }
 static void set_init_blocksize(struct block_device *bdev)
 		dio->size += bio->bi_iter.bi_size;
 		pos += bio->bi_iter.bi_size;
-		nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_PAGES);
+		nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS);
 		if (!nr_pages) {
 			bool polled = false;
 	if (!iov_iter_count(iter))
 		return 0;
-	nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_PAGES + 1);
+	nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS + 1);
-	if (is_sync_kiocb(iocb) && nr_pages <= BIO_MAX_PAGES)
+	if (is_sync_kiocb(iocb) && nr_pages <= BIO_MAX_VECS)
 		return __blkdev_direct_IO_simple(iocb, iter, nr_pages);
 	return __blkdev_direct_IO(iocb, iter, bio_max_segs(nr_pages));

fs/btrfs/ctree.c+2−0

 				   "failed to read tree block %llu from get_old_root",
 				   logical);
 		} else {
+			btrfs_tree_read_lock(old);
 			eb = btrfs_clone_extent_buffer(old);
+			btrfs_tree_read_unlock(old);
 			free_extent_buffer(old);
 		}
 	} else if (old_root) {

fs/btrfs/extent-tree.c+22−1

@@ -3323,6 +3323,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, · 3322 unmodified lines
3323		3323
3324	if (last_ref && btrfs_header_generation(buf) == trans->transid) {	3324	if (last_ref && btrfs_header_generation(buf) == trans->transid) {
3325	struct btrfs_block_group *cache;	3325	struct btrfs_block_group *cache;
		3326	bool must_pin = false;
3326		3327
3327	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {	3328	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
3328	ret = check_ref_cleanup(trans, buf->start);	3329	ret = check_ref_cleanup(trans, buf->start);
@@ -3340,7 +3341,27 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, · 11 unmodified lines
3340	goto out;	3341	goto out;
3341	}	3342	}
3342		3343
3343	if (btrfs_is_zoned(fs_info)) {	3344	/*
		3345	* If this is a leaf and there are tree mod log users, we may
		3346	* have recorded mod log operations that point to this leaf.
		3347	* So we must make sure no one reuses this leaf's extent before
		3348	* mod log operations are applied to a node, otherwise after
		3349	* rewinding a node using the mod log operations we get an
		3350	* inconsistent btree, as the leaf's extent may now be used as
		3351	* a node or leaf for another different btree.
		3352	* We are safe from races here because at this point no other
		3353	* node or root points to this extent buffer, so if after this
		3354	* check a new tree mod log user joins, it will not be able to
		3355	* find a node pointing to this leaf and record operations that
		3356	* point to this leaf.
		3357	*/
		3358	if (btrfs_header_level(buf) == 0) {
		3359	read_lock(&fs_info->tree_mod_log_lock);
		3360	must_pin = !list_empty(&fs_info->tree_mod_seq_list);
		3361	read_unlock(&fs_info->tree_mod_log_lock);
		3362	}
		3363
		3364	if (must_pin \|\| btrfs_is_zoned(fs_info)) {
3344	btrfs_redirty_list_add(trans->transaction, buf);	3365	btrfs_redirty_list_add(trans->transaction, buf);
3345	pin_down_extent(trans, cache, buf->start, buf->len, 1);	3366	pin_down_extent(trans, cache, buf->start, buf->len, 1);
3346	btrfs_put_block_group(cache);	3367	btrfs_put_block_group(cache);

fs/btrfs/extent_io.c+32−3

@@ -2885,6 +2885,35 @@ static void end_page_read(struct page *page, bool uptodate, u64 start, u32 len) · 2884 unmodified lines
2885	btrfs_subpage_end_reader(fs_info, page, start, len);	2885	btrfs_subpage_end_reader(fs_info, page, start, len);
2886	}	2886	}
2887		2887
		2888	/*
		2889	* Find extent buffer for a givne bytenr.
		2890	*
		2891	* This is for end_bio_extent_readpage(), thus we can't do any unsafe locking
		2892	* in endio context.
		2893	*/
		2894	static struct extent_buffer *find_extent_buffer_readpage(
		2895	struct btrfs_fs_info fs_info, struct page page, u64 bytenr)
		2896	{
		2897	struct extent_buffer *eb;
		2898
		2899	/*
		2900	* For regular sectorsize, we can use page->private to grab extent
		2901	* buffer
		2902	*/
		2903	if (fs_info->sectorsize == PAGE_SIZE) {
		2904	ASSERT(PagePrivate(page) && page->private);
		2905	return (struct extent_buffer *)page->private;
		2906	}
		2907
		2908	/* For subpage case, we need to lookup buffer radix tree */
		2909	rcu_read_lock();
		2910	eb = radix_tree_lookup(&fs_info->buffer_radix,
		2911	bytenr >> fs_info->sectorsize_bits);
		2912	rcu_read_unlock();
		2913	ASSERT(eb);
		2914	return eb;
		2915	}
		2916
2888	/*	2917	/*
2889	* after a readpage IO is done, we need to:	2918	* after a readpage IO is done, we need to:
2890	* clear the uptodate bits on error	2919	* clear the uptodate bits on error
@@ -2996,7 +3025,7 @@ static void end_bio_extent_readpage(struct bio *bio) · 105 unmodified lines
2996	} else {	3025	} else {
2997	struct extent_buffer *eb;	3026	struct extent_buffer *eb;
2998		3027
2999	eb = (struct extent_buffer *)page->private;	3028	eb = find_extent_buffer_readpage(fs_info, page, start);
3000	set_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);	3029	set_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
3001	eb->read_mirror = mirror;	3030	eb->read_mirror = mirror;
3002	atomic_dec(&eb->io_pages);	3031	atomic_dec(&eb->io_pages);
@@ -3020,7 +3049,7 @@ readpage_ok: · 17 unmodified lines
3020	*/	3049	*/
3021	if (page->index == end_index && i_size <= end) {	3050	if (page->index == end_index && i_size <= end) {
3022	u32 zero_start = max(offset_in_page(i_size),	3051	u32 zero_start = max(offset_in_page(i_size),
3023	offset_in_page(end));	3052	offset_in_page(start));
3024		3053
3025	zero_user_segment(page, zero_start,	3054	zero_user_segment(page, zero_start,
3026	offset_in_page(end) + 1);	3055	offset_in_page(end) + 1);
@@ -3059,7 +3088,7 @@ struct bio *btrfs_bio_alloc(u64 first_byte) · 32 unmodified lines
3059	{	3088	{
3060	struct bio *bio;	3089	struct bio *bio;
3061		3090
3062	bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &btrfs_bioset);	3091	bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_VECS, &btrfs_bioset);
3063	bio->bi_iter.bi_sector = first_byte >> 9;	3092	bio->bi_iter.bi_sector = first_byte >> 9;
3064	btrfs_io_bio_init(btrfs_io_bio(bio));	3093	btrfs_io_bio_init(btrfs_io_bio(bio));
3065	return bio;	3094	return bio;

fs/btrfs/inode.c+26−11

 	btrfs_free_space_bitmap_cachep = kmem_cache_create("btrfs_free_space_bitmap",
 							PAGE_SIZE, PAGE_SIZE,
-							SLAB_RED_ZONE, NULL);
+							SLAB_MEM_SPREAD, NULL);
 	if (!btrfs_free_space_bitmap_cachep)
 		goto fail;
 	struct btrfs_path *path;
 	u64 start = ins->objectid;
 	u64 len = ins->offset;
+	int qgroup_released;
 	int ret;
 	memset(&stack_fi, 0, sizeof(stack_fi));
 	btrfs_set_stack_file_extent_compression(&stack_fi, BTRFS_COMPRESS_NONE);
 	/* Encryption and other encoding is reserved and all 0 */
-	ret = btrfs_qgroup_release_data(inode, file_offset, len);
+	qgroup_released = btrfs_qgroup_release_data(inode, file_offset, len);
-	if (ret < 0)
+	if (qgroup_released < 0)
-		return ERR_PTR(ret);
+		return ERR_PTR(qgroup_released);
 	if (trans) {
 		ret = insert_reserved_file_extent(trans, inode,
 						  file_offset, &stack_fi,
-						  true, ret);
+						  true, qgroup_released);
 		if (ret)
-			return ERR_PTR(ret);
+			goto free_qgroup;
 		return trans;
 	}
 	extent_info.file_offset = file_offset;
 	extent_info.extent_buf = (char *)&stack_fi;
 	extent_info.is_new_extent = true;
-	extent_info.qgroup_reserved = ret;
+	extent_info.qgroup_reserved = qgroup_released;
 	extent_info.insertions = 0;
 	path = btrfs_alloc_path();
-	if (!path)
+	if (!path) {
-		return ERR_PTR(-ENOMEM);
+		ret = -ENOMEM;
+		goto free_qgroup;
+	}
 	ret = btrfs_replace_file_extents(&inode->vfs_inode, path, file_offset,
 				     file_offset + len - 1, &extent_info,
 				     &trans);
 	btrfs_free_path(path);
 	if (ret)
-		return ERR_PTR(ret);
+		goto free_qgroup;
 	return trans;
+free_qgroup:
+	/*
+	 * We have released qgroup data range at the beginning of the function,
+	 * and normally qgroup_released bytes will be freed when committing
+	 * transaction.
+	 * But if we error out early, we have to free what we have released
+	 * or we leak qgroup data reservation.
+	 */
+	btrfs_qgroup_free_refroot(inode->root->fs_info,
+			inode->root->root_key.objectid, qgroup_released,
+			BTRFS_QGROUP_RSV_DATA);
+	return ERR_PTR(ret);
 }
 static int __btrfs_prealloc_file_range(struct inode *inode, int mode,

fs/btrfs/reada.c+18−17

 	/* find extent */
 	spin_lock(&fs_info->reada_lock);
 	re = radix_tree_lookup(&fs_info->reada_tree,
-			       eb->start >> PAGE_SHIFT);
+			       eb->start >> fs_info->sectorsize_bits);
 	if (re)
 		re->refcnt++;
 	spin_unlock(&fs_info->reada_lock);
 	zone = NULL;
 	spin_lock(&fs_info->reada_lock);
 	ret = radix_tree_gang_lookup(&dev->reada_zones, (void **)&zone,
-				     logical >> PAGE_SHIFT, 1);
+				     logical >> fs_info->sectorsize_bits, 1);
 	if (ret == 1 && logical >= zone->start && logical <= zone->end) {
 		kref_get(&zone->refcnt);
 		spin_unlock(&fs_info->reada_lock);
 	spin_lock(&fs_info->reada_lock);
 	ret = radix_tree_insert(&dev->reada_zones,
-				(unsigned long)(zone->end >> PAGE_SHIFT),
+			(unsigned long)(zone->end >> fs_info->sectorsize_bits),
-				zone);
+			zone);
 	if (ret == -EEXIST) {
 		kfree(zone);
 		ret = radix_tree_gang_lookup(&dev->reada_zones, (void **)&zone,
-					     logical >> PAGE_SHIFT, 1);
+					logical >> fs_info->sectorsize_bits, 1);
 		if (ret == 1 && logical >= zone->start && logical <= zone->end)
 			kref_get(&zone->refcnt);
 		else
 	u64 length;
 	int real_stripes;
 	int nzones = 0;
-	unsigned long index = logical >> PAGE_SHIFT;
+	unsigned long index = logical >> fs_info->sectorsize_bits;
 	int dev_replace_is_ongoing;
 	int have_zone = 0;
 			     struct reada_extent *re)
 {
 	int i;
-	unsigned long index = re->logical >> PAGE_SHIFT;
+	unsigned long index = re->logical >> fs_info->sectorsize_bits;
 	spin_lock(&fs_info->reada_lock);
 	if (--re->refcnt) {
 static void reada_zone_release(struct kref *kref)
 {
 	struct reada_zone *zone = container_of(kref, struct reada_zone, refcnt);
+	struct btrfs_fs_info *fs_info = zone->device->fs_info;
-	lockdep_assert_held(&zone->device->fs_info->reada_lock);
+	lockdep_assert_held(&fs_info->reada_lock);
 	radix_tree_delete(&zone->device->reada_zones,
-			  zone->end >> PAGE_SHIFT);
+			  zone->end >> fs_info->sectorsize_bits);
 	kfree(zone);
 }
 static void reada_peer_zones_set_lock(struct reada_zone *zone, int lock)
 {
 	int i;
-	unsigned long index = zone->end >> PAGE_SHIFT;
+	unsigned long index = zone->end >> zone->device->fs_info->sectorsize_bits;
 	for (i = 0; i < zone->ndevs; ++i) {
 		struct reada_zone *peer;
 					     (void **)&zone, index, 1);
 		if (ret == 0)
 			break;
-		index = (zone->end >> PAGE_SHIFT) + 1;
+		index = (zone->end >> dev->fs_info->sectorsize_bits) + 1;
 		if (zone->locked) {
 			if (zone->elems > top_locked_elems) {
 				top_locked_elems = zone->elems;
 	 * plugging to speed things up
 	 */
 	ret = radix_tree_gang_lookup(&dev->reada_extents, (void **)&re,
-				     dev->reada_next >> PAGE_SHIFT, 1);
+				dev->reada_next >> fs_info->sectorsize_bits, 1);
 	if (ret == 0 || re->logical > dev->reada_curr_zone->end) {
 		ret = reada_pick_zone(dev);
 		if (!ret) {
 		}
 		re = NULL;
 		ret = radix_tree_gang_lookup(&dev->reada_extents, (void **)&re,
-					dev->reada_next >> PAGE_SHIFT, 1);
+				dev->reada_next >> fs_info->sectorsize_bits, 1);
 	}
 	if (ret == 0) {
 		spin_unlock(&fs_info->reada_lock);
 				pr_cont(" curr off %llu",
 					device->reada_next - zone->start);
 			pr_cont("\n");
-			index = (zone->end >> PAGE_SHIFT) + 1;
+			index = (zone->end >> fs_info->sectorsize_bits) + 1;
 		}
 		cnt = 0;
 		index = 0;
 				}
 			}
 			pr_cont("\n");
-			index = (re->logical >> PAGE_SHIFT) + 1;
+			index = (re->logical >> fs_info->sectorsize_bits) + 1;
 			if (++cnt > 15)
 				break;
 		}
 		if (ret == 0)
 			break;
 		if (!re->scheduled) {
-			index = (re->logical >> PAGE_SHIFT) + 1;
+			index = (re->logical >> fs_info->sectorsize_bits) + 1;
 			continue;
 		}
 		pr_debug("re: logical %llu size %u list empty %d scheduled %d",
 			}
 		}
 		pr_cont("\n");
-		index = (re->logical >> PAGE_SHIFT) + 1;
+		index = (re->logical >> fs_info->sectorsize_bits) + 1;
 	}
 	spin_unlock(&fs_info->reada_lock);
 }

fs/btrfs/scrub.c+1−1

@@ -1428,7 +1428,7 @@ static void scrub_recheck_block_on_raid56(struct btrfs_fs_info *fs_info, · 1427 unmodified lines
1428	if (!first_page->dev->bdev)	1428	if (!first_page->dev->bdev)
1429	goto out;	1429	goto out;
1430		1430
1431	bio = btrfs_io_bio_alloc(BIO_MAX_PAGES);	1431	bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
1432	bio_set_dev(bio, first_page->dev->bdev);	1432	bio_set_dev(bio, first_page->dev->bdev);
1433		1433
1434	for (page_num = 0; page_num < sblock->page_count; page_num++) {	1434	for (page_num = 0; page_num < sblock->page_count; page_num++) {

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

 	mutex_lock(&log_root_tree->log_mutex);
-	index2 = log_root_tree->log_transid % 2;
-	list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
-	root_log_ctx.log_transid = log_root_tree->log_transid;
 	if (btrfs_is_zoned(fs_info)) {
 		if (!log_root_tree->node) {
 			ret = btrfs_alloc_log_tree_node(trans, log_root_tree);
 		}
 	}
+	index2 = log_root_tree->log_transid % 2;
+	list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
+	root_log_ctx.log_transid = log_root_tree->log_transid;
 	/*
 	 * Now we are safe to update the log_root_tree because we're under the
 	 * log_mutex, and we're a current writer so we're holding the commit

fs/cachefiles/bind.c+6−0

 	cache->mnt = path.mnt;
 	root = path.dentry;
+	ret = -EINVAL;
+	if (mnt_user_ns(path.mnt) != &init_user_ns) {
+		pr_warn("File cache on idmapped mounts not supported");
+		goto error_unsupported;
+	}
 	/* check parameters */
 	ret = -EOPNOTSUPP;
 	if (d_is_negative(root) ||

fs/cachefiles/rdwr.c+3−4

 		container_of(wait, struct cachefiles_one_read, monitor);
 	struct cachefiles_object *object;
 	struct fscache_retrieval *op = monitor->op;
-	struct wait_bit_key *key = _key;
+	struct wait_page_key *key = _key;
 	struct page *page = wait->private;
 	ASSERT(key);
 	_enter("{%lu},%u,%d,{%p,%u}",
 	       monitor->netfs_page->index, mode, sync,
-	       key->flags, key->bit_nr);
+	       key->page, key->bit_nr);
-	if (key->flags != &page->flags ||
+	if (key->page != page || key->bit_nr != PG_locked)
-	    key->bit_nr != PG_locked)
 		return 0;
 	_debug("--- monitor %p %lx ---", page, page->flags);

fs/cifs/cifs_debug.c+1−1

@@ -207,7 +207,7 @@ static int cifs_debug_files_proc_show(struct seq_file m, void v) · 206 unmodified lines
207	from_kuid(&init_user_ns, cfile->uid),	207	from_kuid(&init_user_ns, cfile->uid),
208	cfile->dentry);	208	cfile->dentry);
209	#ifdef CONFIG_CIFS_DEBUG2	209	#ifdef CONFIG_CIFS_DEBUG2
210	seq_printf(m, " 0x%llx\n", cfile->fid.mid);	210	seq_printf(m, " %llu\n", cfile->fid.mid);
211	#else	211	#else
212	seq_printf(m, "\n");	212	seq_printf(m, "\n");
213	#endif /* CIFS_DEBUG2 */	213	#endif /* CIFS_DEBUG2 */

fs/cifs/cifs_swn.c+1−1

@@ -248,7 +248,7 @@ nlmsg_fail: · 247 unmodified lines
248		248
249	/*	249	/*
250	* Try to find a matching registration for the tcon's server name and share name.	250	* Try to find a matching registration for the tcon's server name and share name.
251	* Calls to this funciton must be protected by cifs_swnreg_idr_mutex.	251	* Calls to this function must be protected by cifs_swnreg_idr_mutex.
252	* TODO Try to avoid memory allocations	252	* TODO Try to avoid memory allocations
253	*/	253	*/
254	static struct cifs_swn_reg cifs_find_swn_reg(struct cifs_tcon tcon)	254	static struct cifs_swn_reg cifs_find_swn_reg(struct cifs_tcon tcon)

fs/cifs/cifsacl.c+6−3

 	/* Retain old ACEs which we can retain */
 	for (i = 0; i < src_num_aces; ++i) {
 		pntace = (struct cifs_ace *) (acl_base + size);
-		pnntace = (struct cifs_ace *) (nacl_base + nsize);
 		if (!new_aces_set && (pntace->flags & INHERITED_ACE)) {
 			/* Place the new ACEs in between existing explicit and inherited */
 		}
 		/* If it's any one of the ACE we're replacing, skip! */
-		if ((compare_sids(&pntace->sid, &sid_unix_NFS_mode) == 0) ||
+		if (!mode_from_sid &&
+				((compare_sids(&pntace->sid, &sid_unix_NFS_mode) == 0) ||
 				(compare_sids(&pntace->sid, pownersid) == 0) ||
 				(compare_sids(&pntace->sid, pgrpsid) == 0) ||
 				(compare_sids(&pntace->sid, &sid_everyone) == 0) ||
-				(compare_sids(&pntace->sid, &sid_authusers) == 0)) {
+				(compare_sids(&pntace->sid, &sid_authusers) == 0))) {
 			goto next_ace;
 		}
+		/* update the pointer to the next ACE to populate*/
+		pnntace = (struct cifs_ace *) (nacl_base + nsize);
 		nsize += cifs_copy_ace(pnntace, pntace, NULL);
 		num_aces++;

fs/cifs/cifsfs.c+1−1

@@ -290,7 +290,7 @@ cifs_statfs(struct dentry dentry, struct kstatfs buf) · 289 unmodified lines
290	rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);	290	rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
291		291
292	free_xid(xid);	292	free_xid(xid);
293	return 0;	293	return rc;
294	}	294	}
295		295
296	static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)	296	static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)

fs/cifs/cifsglob.h+10−9

fs/cifs/connect.c+7−7

 		spin_lock(&GlobalMid_Lock);
 		list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-			cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
+			cifs_dbg(FYI, "Clearing mid %llu\n", mid_entry->mid);
 			kref_get(&mid_entry->refcount);
 			mid_entry->mid_state = MID_SHUTDOWN;
 			list_move(&mid_entry->qhead, &dispose_list);
 		/* now walk dispose list and issue callbacks */
 		list_for_each_safe(tmp, tmp2, &dispose_list) {
 			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-			cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
+			cifs_dbg(FYI, "Callback mid %llu\n", mid_entry->mid);
 			list_del_init(&mid_entry->qhead);
 			mid_entry->callback(mid_entry);
 			cifs_mid_q_entry_release(mid_entry);
 	tcp_ses->min_offload = ctx->min_offload;
 	tcp_ses->tcpStatus = CifsNeedNegotiate;
+	if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
+		tcp_ses->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
+	else
+		tcp_ses->max_credits = ctx->max_credits;
 	tcp_ses->nr_targets = 1;
 	tcp_ses->ignore_signature = ctx->ignore_signature;
 	/* thread spawned, put it on the list */
 	*nserver = server;
-	if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
-		server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
-	else
-		server->max_credits = ctx->max_credits;
 	/* get a reference to a SMB session */
 	ses = cifs_get_smb_ses(server, ctx);
 	if (IS_ERR(ses)) {

fs/cifs/fs_context.c+4−2

 		pr_warn_once("Witness protocol support is experimental\n");
 		break;
 	case Opt_rootfs:
-#ifdef CONFIG_CIFS_ROOT
+#ifndef CONFIG_CIFS_ROOT
-		ctx->rootfs = true;
+		cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
+		goto cifs_parse_mount_err;
 #endif
+		ctx->rootfs = true;
 		break;
 	case Opt_posixpaths:
 		if (result.negated)

fs/cifs/inode.c+9−1

 	 * We need to be sure that all dirty pages are written and the server
 	 * has actual ctime, mtime and file length.
 	 */
-	if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
+	if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
 	    !CIFS_CACHE_READ(CIFS_I(inode)) &&
 	    inode->i_mapping && inode->i_mapping->nrpages != 0) {
 		rc = filemap_fdatawait(inode->i_mapping);
 	if (rc == 0) {
 		cifsInode->server_eof = attrs->ia_size;
 		cifs_setsize(inode, attrs->ia_size);
+		/*
+		 * i_blocks is not related to (i_size / i_blksize), but instead
+		 * 512 byte (2**9) size is required for calculating num blocks.
+		 * Until we can query the server for actual allocation size,
+		 * this is best estimate we have for blocks allocated for a file
+		 * Number of blocks must be rounded up so size 1 is not 0 blocks
+		 */
+		inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
 		/*
 		 * The man page of truncate says if the size changed,

fs/cifs/sess.c+1−0

@@ -230,6 +230,7 @@ cifs_ses_add_channel(struct cifs_sb_info cifs_sb, struct cifs_ses ses, · 229 unmodified lines
230	ctx.noautotune = ses->server->noautotune;	230	ctx.noautotune = ses->server->noautotune;
231	ctx.sockopt_tcp_nodelay = ses->server->tcp_nodelay;	231	ctx.sockopt_tcp_nodelay = ses->server->tcp_nodelay;
232	ctx.echo_interval = ses->server->echo_interval / HZ;	232	ctx.echo_interval = ses->server->echo_interval / HZ;
		233	ctx.max_credits = ses->server->max_credits;
233		234
234	/*	235	/*
235	* This will be used for encoding/decoding user/domain/pw	236	* This will be used for encoding/decoding user/domain/pw

fs/cifs/smb2inode.c+1−0

@@ -358,6 +358,7 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon, · 357 unmodified lines
358	if (cfile)	358	if (cfile)
359	goto after_close;	359	goto after_close;
360	/* Close */	360	/* Close */
		361	flags \|= CIFS_CP_CREATE_CLOSE_OP;
361	rqst[num_rqst].rq_iov = &vars->close_iov[0];	362	rqst[num_rqst].rq_iov = &vars->close_iov[0];
362	rqst[num_rqst].rq_nvec = 1;	363	rqst[num_rqst].rq_nvec = 1;
363	rc = SMB2_close_init(tcon, server,	364	rc = SMB2_close_init(tcon, server,

fs/cifs/smb2misc.c+5−5

@@ -767,7 +767,7 @@ smb2_cancelled_close_fid(struct work_struct *work) · 766 unmodified lines
767	int rc;	767	int rc;
768		768
769	if (cancelled->mid)	769	if (cancelled->mid)
770	cifs_tcon_dbg(VFS, "Close unmatched open for MID:%llx\n",	770	cifs_tcon_dbg(VFS, "Close unmatched open for MID:%llu\n",
771	cancelled->mid);	771	cancelled->mid);
772	else	772	else
773	cifs_tcon_dbg(VFS, "Close interrupted close\n");	773	cifs_tcon_dbg(VFS, "Close interrupted close\n");
@@ -844,14 +844,14 @@ smb2_handle_cancelled_close(struct cifs_tcon *tcon, __u64 persistent_fid, · 70 unmodified lines
844	}	844	}
845		845
846	int	846	int
847	smb2_handle_cancelled_mid(char buffer, struct TCP_Server_Info server)	847	smb2_handle_cancelled_mid(struct mid_q_entry mid, struct TCP_Server_Info server)
848	{	848	{
849	struct smb2_sync_hdr sync_hdr = (struct smb2_sync_hdr )buffer;	849	struct smb2_sync_hdr *sync_hdr = mid->resp_buf;
850	struct smb2_create_rsp rsp = (struct smb2_create_rsp )buffer;	850	struct smb2_create_rsp *rsp = mid->resp_buf;
851	struct cifs_tcon *tcon;	851	struct cifs_tcon *tcon;
852	int rc;	852	int rc;
853		853
854	if (sync_hdr->Command != SMB2_CREATE \|\|	854	if ((mid->optype & CIFS_CP_CREATE_CLOSE_OP) \|\| sync_hdr->Command != SMB2_CREATE \|\|
855	sync_hdr->Status != STATUS_SUCCESS)	855	sync_hdr->Status != STATUS_SUCCESS)
856	return 0;	856	return 0;
857		857

fs/cifs/smb2ops.c+5−5

@@ -1195,7 +1195,7 @@ smb2_set_ea(const unsigned int xid, struct cifs_tcon *tcon, · 1194 unmodified lines
1195	struct TCP_Server_Info *server = cifs_pick_channel(ses);	1195	struct TCP_Server_Info *server = cifs_pick_channel(ses);
1196	__le16 *utf16_path = NULL;	1196	__le16 *utf16_path = NULL;
1197	int ea_name_len = strlen(ea_name);	1197	int ea_name_len = strlen(ea_name);
1198	int flags = 0;	1198	int flags = CIFS_CP_CREATE_CLOSE_OP;
1199	int len;	1199	int len;
1200	struct smb_rqst rqst[3];	1200	struct smb_rqst rqst[3];
1201	int resp_buftype[3];	1201	int resp_buftype[3];
@@ -1573,7 +1573,7 @@ smb2_ioctl_query_info(const unsigned int xid, · 371 unmodified lines
1573	struct smb_query_info qi;	1573	struct smb_query_info qi;
1574	struct smb_query_info __user *pqi;	1574	struct smb_query_info __user *pqi;
1575	int rc = 0;	1575	int rc = 0;
1576	int flags = 0;	1576	int flags = CIFS_CP_CREATE_CLOSE_OP;
1577	struct smb2_query_info_rsp *qi_rsp = NULL;	1577	struct smb2_query_info_rsp *qi_rsp = NULL;
1578	struct smb2_ioctl_rsp *io_rsp = NULL;	1578	struct smb2_ioctl_rsp *io_rsp = NULL;
1579	void *buffer = NULL;	1579	void *buffer = NULL;
@@ -2577,7 +2577,7 @@ smb2_query_info_compound(const unsigned int xid, struct cifs_tcon *tcon, · 997 unmodified lines
2577	{	2577	{
2578	struct cifs_ses *ses = tcon->ses;	2578	struct cifs_ses *ses = tcon->ses;
2579	struct TCP_Server_Info *server = cifs_pick_channel(ses);	2579	struct TCP_Server_Info *server = cifs_pick_channel(ses);
2580	int flags = 0;	2580	int flags = CIFS_CP_CREATE_CLOSE_OP;
2581	struct smb_rqst rqst[3];	2581	struct smb_rqst rqst[3];
2582	int resp_buftype[3];	2582	int resp_buftype[3];
2583	struct kvec rsp_iov[3];	2583	struct kvec rsp_iov[3];
@@ -2975,7 +2975,7 @@ smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon, · 391 unmodified lines
2975	unsigned int sub_offset;	2975	unsigned int sub_offset;
2976	unsigned int print_len;	2976	unsigned int print_len;
2977	unsigned int print_offset;	2977	unsigned int print_offset;
2978	int flags = 0;	2978	int flags = CIFS_CP_CREATE_CLOSE_OP;
2979	struct smb_rqst rqst[3];	2979	struct smb_rqst rqst[3];
2980	int resp_buftype[3];	2980	int resp_buftype[3];
2981	struct kvec rsp_iov[3];	2981	struct kvec rsp_iov[3];
@@ -3157,7 +3157,7 @@ smb2_query_reparse_tag(const unsigned int xid, struct cifs_tcon *tcon, · 175 unmodified lines
3157	struct cifs_open_parms oparms;	3157	struct cifs_open_parms oparms;
3158	struct cifs_fid fid;	3158	struct cifs_fid fid;
3159	struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);	3159	struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
3160	int flags = 0;	3160	int flags = CIFS_CP_CREATE_CLOSE_OP;
3161	struct smb_rqst rqst[3];	3161	struct smb_rqst rqst[3];
3162	int resp_buftype[3];	3162	int resp_buftype[3];
3163	struct kvec rsp_iov[3];	3163	struct kvec rsp_iov[3];

fs/cifs/smb2pdu.c+2−4

 	if (rdata->credits.value > 0) {
 		shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(rdata->bytes,
 						SMB2_MAX_BUFFER_SIZE));
-		shdr->CreditRequest =
+		shdr->CreditRequest = cpu_to_le16(le16_to_cpu(shdr->CreditCharge) + 8);
-			cpu_to_le16(le16_to_cpu(shdr->CreditCharge) + 1);
 		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
 		if (rc)
 	if (wdata->credits.value > 0) {
 		shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(wdata->bytes,
 						    SMB2_MAX_BUFFER_SIZE));
-		shdr->CreditRequest =
+		shdr->CreditRequest = cpu_to_le16(le16_to_cpu(shdr->CreditCharge) + 8);
-			cpu_to_le16(le16_to_cpu(shdr->CreditCharge) + 1);
 		rc = adjust_credits(server, &wdata->credits, wdata->bytes);
 		if (rc)

fs/cifs/smb2proto.h+1−2

 extern int smb2_handle_cancelled_close(struct cifs_tcon *tcon,
 				       __u64 persistent_fid,
 				       __u64 volatile_fid);
-extern int smb2_handle_cancelled_mid(char *buffer,
+extern int smb2_handle_cancelled_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server);
-					struct TCP_Server_Info *server);
 void smb2_cancelled_close_fid(struct work_struct *work);
 extern int SMB2_QFS_info(const unsigned int xid, struct cifs_tcon *tcon,
 			 u64 persistent_file_id, u64 volatile_file_id,

fs/cifs/transport.c+8−3

 	if (midEntry->resp_buf && (midEntry->mid_flags & MID_WAIT_CANCELLED) &&
 	    midEntry->mid_state == MID_RESPONSE_RECEIVED &&
 	    server->ops->handle_cancelled_mid)
-		server->ops->handle_cancelled_mid(midEntry->resp_buf, server);
+		server->ops->handle_cancelled_mid(midEntry, server);
 	midEntry->mid_state = MID_FREE;
 	atomic_dec(&midCount);
 	/*
 	 * Compounding is never used during session establish.
 	 */
-	if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP))
+	if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP)) {
+		mutex_lock(&server->srv_mutex);
 		smb311_update_preauth_hash(ses, rqst[0].rq_iov,
 					   rqst[0].rq_nvec);
+		mutex_unlock(&server->srv_mutex);
+	}
 	for (i = 0; i < num_rqst; i++) {
 		rc = wait_for_response(server, midQ[i]);
 	}
 	if (rc != 0) {
 		for (; i < num_rqst; i++) {
-			cifs_server_dbg(VFS, "Cancelling wait for mid %llu cmd: %d\n",
+			cifs_server_dbg(FYI, "Cancelling wait for mid %llu cmd: %d\n",
 				 midQ[i]->mid, le16_to_cpu(midQ[i]->command));
 			send_cancel(server, &rqst[i], midQ[i]);
 			spin_lock(&GlobalMid_Lock);
 			.iov_base = resp_iov[0].iov_base,
 			.iov_len = resp_iov[0].iov_len
 		};
+		mutex_lock(&server->srv_mutex);
 		smb311_update_preauth_hash(ses, &iov, 1);
+		mutex_unlock(&server->srv_mutex);
 	}
 out:

fs/configfs/file.c+2−4

 	attr = to_attr(dentry);
 	if (!attr)
-		goto out_put_item;
+		goto out_free_buffer;
 	if (type & CONFIGFS_ITEM_BIN_ATTR) {
 		buffer->bin_attr = to_bin_attr(dentry);
 	/* Grab the module reference for this attribute if we have one */
 	error = -ENODEV;
 	if (!try_module_get(buffer->owner))
-		goto out_put_item;
+		goto out_free_buffer;
 	error = -EACCES;
 	if (!buffer->item->ci_type)
 out_put_module:
 	module_put(buffer->owner);
-out_put_item:
-	config_item_put(buffer->item);
 out_free_buffer:
 	up_read(&frag->frag_sem);
 	kfree(buffer);

fs/crypto/bio.c+3−3

@@ -52,7 +52,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode, · 51 unmodified lines
52	int num_pages = 0;	52	int num_pages = 0;
53		53
54	/* This always succeeds since __GFP_DIRECT_RECLAIM is set. */	54	/* This always succeeds since __GFP_DIRECT_RECLAIM is set. */
55	bio = bio_alloc(GFP_NOFS, BIO_MAX_PAGES);	55	bio = bio_alloc(GFP_NOFS, BIO_MAX_VECS);
56		56
57	while (len) {	57	while (len) {
58	unsigned int blocks_this_page = min(len, blocks_per_page);	58	unsigned int blocks_this_page = min(len, blocks_per_page);
@@ -74,7 +74,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode, · 15 unmodified lines
74	len -= blocks_this_page;	74	len -= blocks_this_page;
75	lblk += blocks_this_page;	75	lblk += blocks_this_page;
76	pblk += blocks_this_page;	76	pblk += blocks_this_page;
77	if (num_pages == BIO_MAX_PAGES \|\| !len \|\|	77	if (num_pages == BIO_MAX_VECS \|\| !len \|\|
78	!fscrypt_mergeable_bio(bio, inode, lblk)) {	78	!fscrypt_mergeable_bio(bio, inode, lblk)) {
79	err = submit_bio_wait(bio);	79	err = submit_bio_wait(bio);
80	if (err)	80	if (err)
@@ -126,7 +126,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk, · 45 unmodified lines
126	return fscrypt_zeroout_range_inline_crypt(inode, lblk, pblk,	126	return fscrypt_zeroout_range_inline_crypt(inode, lblk, pblk,
127	len);	127	len);
128		128
129	BUILD_BUG_ON(ARRAY_SIZE(pages) > BIO_MAX_PAGES);	129	BUILD_BUG_ON(ARRAY_SIZE(pages) > BIO_MAX_VECS);
130	nr_pages = min_t(unsigned int, ARRAY_SIZE(pages),	130	nr_pages = min_t(unsigned int, ARRAY_SIZE(pages),
131	(len + blocks_per_page - 1) >> blocks_per_page_bits);	131	(len + blocks_per_page - 1) >> blocks_per_page_bits);
132		132

fs/erofs/data.c+11−17

@@ -129,6 +129,7 @@ static inline struct bio erofs_read_raw_page(struct bio bio, · 128 unmodified lines
129	struct page *page,	129	struct page *page,
130	erofs_off_t *last_block,	130	erofs_off_t *last_block,
131	unsigned int nblocks,	131	unsigned int nblocks,
		132	unsigned int *eblks,
132	bool ra)	133	bool ra)
133	{	134	{
134	struct inode *const inode = mapping->host;	135	struct inode *const inode = mapping->host;
@@ -145,8 +146,7 @@ static inline struct bio erofs_read_raw_page(struct bio bio, · 10 unmodified lines
145		146
146	/* note that for readpage case, bio also equals to NULL */	147	/* note that for readpage case, bio also equals to NULL */
147	if (bio &&	148	if (bio &&
148	/* not continuous */	149	(last_block + 1 != current_block \|\| !eblks)) {
149	*last_block + 1 != current_block) {
150	submit_bio_retry:	150	submit_bio_retry:
151	submit_bio(bio);	151	submit_bio(bio);
152	bio = NULL;	152	bio = NULL;
@@ -216,7 +216,8 @@ submit_bio_retry: · 63 unmodified lines
216	if (nblocks > DIV_ROUND_UP(map.m_plen, PAGE_SIZE))	216	if (nblocks > DIV_ROUND_UP(map.m_plen, PAGE_SIZE))
217	nblocks = DIV_ROUND_UP(map.m_plen, PAGE_SIZE);	217	nblocks = DIV_ROUND_UP(map.m_plen, PAGE_SIZE);
218		218
219	bio = bio_alloc(GFP_NOIO, bio_max_segs(nblocks));	219	*eblks = bio_max_segs(nblocks);
		220	bio = bio_alloc(GFP_NOIO, *eblks);
220		221
221	bio->bi_end_io = erofs_readendio;	222	bio->bi_end_io = erofs_readendio;
222	bio_set_dev(bio, sb->s_bdev);	223	bio_set_dev(bio, sb->s_bdev);
@@ -229,16 +230,8 @@ submit_bio_retry: · 6 unmodified lines
229	/* out of the extent or bio is full */	230	/* out of the extent or bio is full */
230	if (err < PAGE_SIZE)	231	if (err < PAGE_SIZE)
231	goto submit_bio_retry;	232	goto submit_bio_retry;
232		233	--*eblks;
233	*last_block = current_block;	234	*last_block = current_block;
234
235	/* shift in advance in case of it followed by too many gaps */
236	if (bio->bi_iter.bi_size >= bio->bi_max_vecs * PAGE_SIZE) {
237	/* err should reassign to 0 after submitting */
238	err = 0;
239	goto submit_bio_out;
240	}
241
242	return bio;	235	return bio;
243		236
244	err_out:	237	err_out:
@@ -252,7 +245,6 @@ has_updated: · 7 unmodified lines
252		245
253	/* if updated manually, continuous pages has a gap */	246	/* if updated manually, continuous pages has a gap */
254	if (bio)	247	if (bio)
255	submit_bio_out:
256	submit_bio(bio);	248	submit_bio(bio);
257	return err ? ERR_PTR(err) : NULL;	249	return err ? ERR_PTR(err) : NULL;
258	}	250	}
@@ -264,23 +256,26 @@ submit_bio_out: · 5 unmodified lines
264	static int erofs_raw_access_readpage(struct file file, struct page page)	256	static int erofs_raw_access_readpage(struct file file, struct page page)
265	{	257	{
266	erofs_off_t last_block;	258	erofs_off_t last_block;
		259	unsigned int eblks;
267	struct bio *bio;	260	struct bio *bio;
268		261
269	trace_erofs_readpage(page, true);	262	trace_erofs_readpage(page, true);
270		263
271	bio = erofs_read_raw_page(NULL, page->mapping,	264	bio = erofs_read_raw_page(NULL, page->mapping,
272	page, &last_block, 1, false);	265	page, &last_block, 1, &eblks, false);
273		266
274	if (IS_ERR(bio))	267	if (IS_ERR(bio))
275	return PTR_ERR(bio);	268	return PTR_ERR(bio);
276		269
277	DBG_BUGON(bio); /* since we have only one bio -- must be NULL */	270	if (bio)
		271	submit_bio(bio);
278	return 0;	272	return 0;
279	}	273	}
280		274
281	static void erofs_raw_access_readahead(struct readahead_control *rac)	275	static void erofs_raw_access_readahead(struct readahead_control *rac)
282	{	276	{
283	erofs_off_t last_block;	277	erofs_off_t last_block;
		278	unsigned int eblks;
284	struct bio *bio = NULL;	279	struct bio *bio = NULL;
285	struct page *page;	280	struct page *page;
286		281
@@ -291,7 +286,7 @@ static void erofs_raw_access_readahead(struct readahead_control *rac) · 4 unmodified lines
291	prefetchw(&page->flags);	286	prefetchw(&page->flags);
292		287
293	bio = erofs_read_raw_page(bio, rac->mapping, page, &last_block,	288	bio = erofs_read_raw_page(bio, rac->mapping, page, &last_block,
294	readahead_count(rac), true);	289	readahead_count(rac), &eblks, true);
295		290
296	/* all the page errors are ignored when readahead */	291	/* all the page errors are ignored when readahead */
297	if (IS_ERR(bio)) {	292	if (IS_ERR(bio)) {
@@ -305,7 +300,6 @@ static void erofs_raw_access_readahead(struct readahead_control *rac) · 7 unmodified lines
305	put_page(page);	300	put_page(page);
306	}	301	}
307		302
308	/* the rare case (end in gaps) */
309	if (bio)	303	if (bio)
310	submit_bio(bio);	304	submit_bio(bio);
311	}	305	}

fs/erofs/zdata.c+1−1

@@ -1235,7 +1235,7 @@ submit_bio_retry: · 1234 unmodified lines
1235	}	1235	}
1236		1236
1237	if (!bio) {	1237	if (!bio) {
1238	bio = bio_alloc(GFP_NOIO, BIO_MAX_PAGES);	1238	bio = bio_alloc(GFP_NOIO, BIO_MAX_VECS);
1239		1239
1240	bio->bi_end_io = z_erofs_decompressqueue_endio;	1240	bio->bi_end_io = z_erofs_decompressqueue_endio;
1241	bio_set_dev(bio, sb->s_bdev);	1241	bio_set_dev(bio, sb->s_bdev);

fs/ext4/balloc.c+26−12

@@ -626,27 +626,41 @@ int ext4_claim_free_clusters(struct ext4_sb_info *sbi, · 625 unmodified lines
626		626
627	/**	627	/**
628	* ext4_should_retry_alloc() - check if a block allocation should be retried	628	* ext4_should_retry_alloc() - check if a block allocation should be retried
629	* @sb: super block	629	* @sb: superblock
630	* @retries: number of attemps has been made	630	* @retries: number of retry attempts made so far
631	*	631	*
632	* ext4_should_retry_alloc() is called when ENOSPC is returned, and if	632	* ext4_should_retry_alloc() is called when ENOSPC is returned while
633	* it is profitable to retry the operation, this function will wait	633	* attempting to allocate blocks. If there's an indication that a pending
634	* for the current or committing transaction to complete, and then	634	* journal transaction might free some space and allow another attempt to
635	* return TRUE. We will only retry once.	635	* succeed, this function will wait for the current or committing transaction
		636	* to complete and then return TRUE.
636	*/	637	*/
637	int ext4_should_retry_alloc(struct super_block sb, int retries)	638	int ext4_should_retry_alloc(struct super_block sb, int retries)
638	{	639	{
639	if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) \|\|	640	struct ext4_sb_info *sbi = EXT4_SB(sb);
640	(*retries)++ > 1 \|\|	641
641	!EXT4_SB(sb)->s_journal)	642	if (!sbi->s_journal)
642	return 0;	643	return 0;
643		644
644	smp_mb();	645	if (++(*retries) > 3) {
645	if (EXT4_SB(sb)->s_mb_free_pending == 0)	646	percpu_counter_inc(&sbi->s_sra_exceeded_retry_limit);
646	return 0;	647	return 0;
		648	}
647		649
		650	/*
		651	* if there's no indication that blocks are about to be freed it's
		652	* possible we just missed a transaction commit that did so
		653	*/
		654	smp_mb();
		655	if (sbi->s_mb_free_pending == 0)
		656	return ext4_has_free_clusters(sbi, 1, 0);
		657
		658	/*
		659	* it's possible we've just missed a transaction commit here,
		660	* so ignore the returned status
		661	*/
648	jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);	662	jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
649	jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);	663	(void) jbd2_journal_force_commit_nested(sbi->s_journal);
650	return 1;	664	return 1;
651	}	665	}
652		666

fs/ext4/ext4.h+3−0

 	struct percpu_counter s_freeinodes_counter;
 	struct percpu_counter s_dirs_counter;
 	struct percpu_counter s_dirtyclusters_counter;
+	struct percpu_counter s_sra_exceeded_retry_limit;
 	struct blockgroup_lock *s_blockgroup_lock;
 	struct proc_dir_entry *s_proc;
 	struct kobject s_kobj;
 	struct dentry *dentry);
 void ext4_fc_track_unlink(handle_t *handle, struct dentry *dentry);
 void ext4_fc_track_link(handle_t *handle, struct dentry *dentry);
+void __ext4_fc_track_create(handle_t *handle, struct inode *inode,
+			    struct dentry *dentry);
 void ext4_fc_track_create(handle_t *handle, struct dentry *dentry);
 void ext4_fc_track_inode(handle_t *handle, struct inode *inode);
 void ext4_fc_mark_ineligible(struct super_block *sb, int reason);

fs/ext4/extents.c+1−1

@@ -4382,7 +4382,7 @@ static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset, · 4381 unmodified lines
4382	{	4382	{
4383	struct inode *inode = file_inode(file);	4383	struct inode *inode = file_inode(file);
4384	handle_t *handle;	4384	handle_t *handle;
4385	int ret, ret2 = 0, ret3 = 0;	4385	int ret = 0, ret2 = 0, ret3 = 0;
4386	int retries = 0;	4386	int retries = 0;
4387	int depth = 0;	4387	int depth = 0;
4388	struct ext4_map_blocks map;	4388	struct ext4_map_blocks map;

fs/ext4/fast_commit.c+7−2

 	__ext4_fc_track_link(handle, d_inode(dentry), dentry);
 }
-void ext4_fc_track_create(handle_t *handle, struct dentry *dentry)
+void __ext4_fc_track_create(handle_t *handle, struct inode *inode,
+			  struct dentry *dentry)
 {
 	struct __track_dentry_update_args args;
-	struct inode *inode = d_inode(dentry);
 	int ret;
 	args.dentry = dentry;
 	trace_ext4_fc_track_create(inode, dentry, ret);
 }
+void ext4_fc_track_create(handle_t *handle, struct dentry *dentry)
+{
+	__ext4_fc_track_create(handle, d_inode(dentry), dentry);
+}
 /* __track_fn for inode tracking */
 static int __track_inode(struct inode *inode, void *arg, bool update)
 {

fs/ext4/inode.c+10−8

 	if (!ret)
 		ret = err;
-	if (!ext4_has_inline_data(inode))
-		ext4_walk_page_buffers(NULL, page_bufs, 0, len,
-				       NULL, bput_one);
 	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
 out:
 	unlock_page(page);
 out_no_pagelock:
+	if (!inline_data && page_bufs)
+		ext4_walk_page_buffers(NULL, page_bufs, 0, len,
+				       NULL, bput_one);
 	brelse(inode_bh);
 	return ret;
 }
 	struct ext4_inode_info *ei = EXT4_I(inode);
 	struct buffer_head *bh = iloc->bh;
 	struct super_block *sb = inode->i_sb;
-	int err = 0, rc, block;
+	int err = 0, block;
 	int need_datasync = 0, set_large_file = 0;
 	uid_t i_uid;
 	gid_t i_gid;
 					      bh->b_data);
 	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
-	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
+	err = ext4_handle_dirty_metadata(handle, NULL, bh);
-	if (!err)
+	if (err)
-		err = rc;
+		goto out_brelse;
 	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
 	if (set_large_file) {
 		BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access");
 			inode->i_gid = attr->ia_gid;
 		error = ext4_mark_inode_dirty(handle, inode);
 		ext4_journal_stop(handle);
-		if (unlikely(error))
+		if (unlikely(error)) {
+			ext4_fc_stop_update(inode);
 			return error;
+		}
 	}
 	if (attr->ia_valid & ATTR_SIZE) {

fs/ext4/mballoc.c+9−2

 	}
 	if (ext4_has_feature_flex_bg(sb)) {
-		/* a single flex group is supposed to be read by a single IO */
+		/* a single flex group is supposed to be read by a single IO.
-		sbi->s_mb_prefetch = min(1 << sbi->s_es->s_log_groups_per_flex,
+		 * 2 ^ s_log_groups_per_flex != UINT_MAX as s_mb_prefetch is
+		 * unsigned integer, so the maximum shift is 32.
+		 */
+		if (sbi->s_es->s_log_groups_per_flex >= 32) {
+			ext4_msg(sb, KERN_ERR, "too many log groups per flexible block group");
+			goto err_freesgi;
+		}
+		sbi->s_mb_prefetch = min_t(uint, 1 << sbi->s_es->s_log_groups_per_flex,
 			BLK_MAX_SEGMENT_SIZE >> (sb->s_blocksize_bits - 9));
 		sbi->s_mb_prefetch *= 8; /* 8 prefetch IOs in flight at most */
 	} else {

fs/ext4/namei.c+39−11

@@ -3613,6 +3613,31 @@ static int ext4_setent(handle_t handle, struct ext4_renament ent, · 3612 unmodified lines
3613	return retval;	3613	return retval;
3614	}	3614	}
3615		3615
		3616	static void ext4_resetent(handle_t handle, struct ext4_renament ent,
		3617	unsigned ino, unsigned file_type)
		3618	{
		3619	struct ext4_renament old = *ent;
		3620	int retval = 0;
		3621
		3622	/*
		3623	* old->de could have moved from under us during make indexed dir,
		3624	* so the old->de may no longer valid and need to find it again
		3625	* before reset old inode info.
		3626	*/
		3627	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
		3628	if (IS_ERR(old.bh))
		3629	retval = PTR_ERR(old.bh);
		3630	if (!old.bh)
		3631	retval = -ENOENT;
		3632	if (retval) {
		3633	ext4_std_error(old.dir->i_sb, retval);
		3634	return;
		3635	}
		3636
		3637	ext4_setent(handle, &old, ino, file_type);
		3638	brelse(old.bh);
		3639	}
		3640
3616	static int ext4_find_delete_entry(handle_t handle, struct inode dir,	3641	static int ext4_find_delete_entry(handle_t handle, struct inode dir,
3617	const struct qstr *d_name)	3642	const struct qstr *d_name)
3618	{	3643	{
@@ -3774,14 +3799,14 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 155 unmodified lines
3774	*/	3799	*/
3775	retval = -ENOENT;	3800	retval = -ENOENT;
3776	if (!old.bh \|\| le32_to_cpu(old.de->inode) != old.inode->i_ino)	3801	if (!old.bh \|\| le32_to_cpu(old.de->inode) != old.inode->i_ino)
3777	goto end_rename;	3802	goto release_bh;
3778		3803
3779	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,	3804	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3780	&new.de, &new.inlined);	3805	&new.de, &new.inlined);
3781	if (IS_ERR(new.bh)) {	3806	if (IS_ERR(new.bh)) {
3782	retval = PTR_ERR(new.bh);	3807	retval = PTR_ERR(new.bh);
3783	new.bh = NULL;	3808	new.bh = NULL;
3784	goto end_rename;	3809	goto release_bh;
3785	}	3810	}
3786	if (new.bh) {	3811	if (new.bh) {
3787	if (!new.inode) {	3812	if (!new.inode) {
@@ -3798,15 +3823,13 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 10 unmodified lines
3798	handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);	3823	handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3799	if (IS_ERR(handle)) {	3824	if (IS_ERR(handle)) {
3800	retval = PTR_ERR(handle);	3825	retval = PTR_ERR(handle);
3801	handle = NULL;	3826	goto release_bh;
3802	goto end_rename;
3803	}	3827	}
3804	} else {	3828	} else {
3805	whiteout = ext4_whiteout_for_rename(mnt_userns, &old, credits, &handle);	3829	whiteout = ext4_whiteout_for_rename(mnt_userns, &old, credits, &handle);
3806	if (IS_ERR(whiteout)) {	3830	if (IS_ERR(whiteout)) {
3807	retval = PTR_ERR(whiteout);	3831	retval = PTR_ERR(whiteout);
3808	whiteout = NULL;	3832	goto release_bh;
3809	goto end_rename;
3810	}	3833	}
3811	}	3834	}
3812		3835
@@ -3850,6 +3873,7 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 37 unmodified lines
3850	retval = ext4_mark_inode_dirty(handle, whiteout);	3873	retval = ext4_mark_inode_dirty(handle, whiteout);
3851	if (unlikely(retval))	3874	if (unlikely(retval))
3852	goto end_rename;	3875	goto end_rename;
		3876
3853	}	3877	}
3854	if (!new.bh) {	3878	if (!new.bh) {
3855	retval = ext4_add_entry(handle, new.dentry, old.inode);	3879	retval = ext4_add_entry(handle, new.dentry, old.inode);
@@ -3923,6 +3947,8 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 67 unmodified lines
3923	ext4_fc_track_unlink(handle, new.dentry);	3947	ext4_fc_track_unlink(handle, new.dentry);
3924	__ext4_fc_track_link(handle, old.inode, new.dentry);	3948	__ext4_fc_track_link(handle, old.inode, new.dentry);
3925	__ext4_fc_track_unlink(handle, old.inode, old.dentry);	3949	__ext4_fc_track_unlink(handle, old.inode, old.dentry);
		3950	if (whiteout)
		3951	__ext4_fc_track_create(handle, whiteout, old.dentry);
3926	}	3952	}
3927		3953
3928	if (new.inode) {	3954	if (new.inode) {
@@ -3937,19 +3963,21 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 8 unmodified lines
3937	end_rename:	3963	end_rename:
3938	if (whiteout) {	3964	if (whiteout) {
3939	if (retval) {	3965	if (retval) {
3940	ext4_setent(handle, &old,	3966	ext4_resetent(handle, &old,
3941	old.inode->i_ino, old_file_type);	3967	old.inode->i_ino, old_file_type);
3942	drop_nlink(whiteout);	3968	drop_nlink(whiteout);
		3969	ext4_orphan_add(handle, whiteout);
3943	}	3970	}
3944	unlock_new_inode(whiteout);	3971	unlock_new_inode(whiteout);
		3972	ext4_journal_stop(handle);
3945	iput(whiteout);	3973	iput(whiteout);
3946		3974	} else {
		3975	ext4_journal_stop(handle);
3947	}	3976	}
		3977	release_bh:
3948	brelse(old.dir_bh);	3978	brelse(old.dir_bh);
3949	brelse(old.bh);	3979	brelse(old.bh);
3950	brelse(new.bh);	3980	brelse(new.bh);
3951	if (handle)
3952	ext4_journal_stop(handle);
3953	return retval;	3981	return retval;
3954	}	3982	}
3955		3983

fs/ext4/page-io.c+1−1

@@ -398,7 +398,7 @@ static void io_submit_init_bio(struct ext4_io_submit *io, · 397 unmodified lines
398	* bio_alloc will _always_ be able to allocate a bio if	398	* bio_alloc will _always_ be able to allocate a bio if
399	* __GFP_DIRECT_RECLAIM is set, see comments for bio_alloc_bioset().	399	* __GFP_DIRECT_RECLAIM is set, see comments for bio_alloc_bioset().
400	*/	400	*/
401	bio = bio_alloc(GFP_NOIO, BIO_MAX_PAGES);	401	bio = bio_alloc(GFP_NOIO, BIO_MAX_VECS);
402	fscrypt_set_bio_crypt_ctx_bh(bio, bh, GFP_NOIO);	402	fscrypt_set_bio_crypt_ctx_bh(bio, bh, GFP_NOIO);
403	bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);	403	bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
404	bio_set_dev(bio, bh->b_bdev);	404	bio_set_dev(bio, bh->b_bdev);

fs/ext4/super.c+6−1

 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
 	percpu_counter_destroy(&sbi->s_dirs_counter);
 	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
+	percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
 	percpu_free_rwsem(&sbi->s_writepages_rwsem);
 #ifdef CONFIG_QUOTA
 	for (i = 0; i < EXT4_MAXQUOTAS; i++)
 	if (!err)
 		err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
 					  GFP_KERNEL);
+	if (!err)
+		err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
+					  GFP_KERNEL);
 	if (!err)
 		err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
 	percpu_counter_destroy(&sbi->s_dirs_counter);
 	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
+	percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
 	percpu_free_rwsem(&sbi->s_writepages_rwsem);
 failed_mount5:
 	ext4_ext_release(sb);
 failed_mount3a:
 	ext4_es_unregister_shrinker(sbi);
 failed_mount3:
-	del_timer_sync(&sbi->s_err_report);
 	flush_work(&sbi->s_error_work);
+	del_timer_sync(&sbi->s_err_report);
 	if (sbi->s_mmp_tsk)
 		kthread_stop(sbi->s_mmp_tsk);
 failed_mount2:

fs/ext4/sysfs.c+7−0

 	attr_session_write_kbytes,
 	attr_lifetime_write_kbytes,
 	attr_reserved_clusters,
+	attr_sra_exceeded_retry_limit,
 	attr_inode_readahead,
 	attr_trigger_test_error,
 	attr_first_error_time,
 EXT4_ATTR_FUNC(session_write_kbytes, 0444);
 EXT4_ATTR_FUNC(lifetime_write_kbytes, 0444);
 EXT4_ATTR_FUNC(reserved_clusters, 0644);
+EXT4_ATTR_FUNC(sra_exceeded_retry_limit, 0444);
 EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, inode_readahead,
 		 ext4_sb_info, s_inode_readahead_blks);
 	ATTR_LIST(session_write_kbytes),
 	ATTR_LIST(lifetime_write_kbytes),
 	ATTR_LIST(reserved_clusters),
+	ATTR_LIST(sra_exceeded_retry_limit),
 	ATTR_LIST(inode_readahead_blks),
 	ATTR_LIST(inode_goal),
 	ATTR_LIST(mb_stats),
 		return snprintf(buf, PAGE_SIZE, "%llu\n",
 				(unsigned long long)
 				atomic64_read(&sbi->s_resv_clusters));
+	case attr_sra_exceeded_retry_limit:
+		return snprintf(buf, PAGE_SIZE, "%llu\n",
+				(unsigned long long)
+			percpu_counter_sum(&sbi->s_sra_exceeded_retry_limit));
 	case attr_inode_readahead:
 	case attr_pointer_ui:
 		if (!ptr)

fs/ext4/verity.c+55−34

@@ -201,55 +201,76 @@ static int ext4_end_enable_verity(struct file filp, const void desc, · 200 unmodified lines
201	struct inode *inode = file_inode(filp);	201	struct inode *inode = file_inode(filp);
202	const int credits = 2; /* superblock and inode for ext4_orphan_del() */	202	const int credits = 2; /* superblock and inode for ext4_orphan_del() */
203	handle_t *handle;	203	handle_t *handle;
		204	struct ext4_iloc iloc;
204	int err = 0;	205	int err = 0;
205	int err2;
206		206
207	if (desc != NULL) {	207	/*
208	/* Succeeded; write the verity descriptor. */	208	* If an error already occurred (which fs/verity/ signals by passing
209	err = ext4_write_verity_descriptor(inode, desc, desc_size,	209	* desc == NULL), then only clean-up is needed.
210	merkle_tree_size);	210	*/
211		211	if (desc == NULL)
212	/* Write all pages before clearing VERITY_IN_PROGRESS. */	212	goto cleanup;
213	if (!err)
214	err = filemap_write_and_wait(inode->i_mapping);
215	}
216		213
217	/* If we failed, truncate anything we wrote past i_size. */	214	/* Append the verity descriptor. */
218	if (desc == NULL \|\| err)	215	err = ext4_write_verity_descriptor(inode, desc, desc_size,
219	ext4_truncate(inode);	216	merkle_tree_size);
		217	if (err)
		218	goto cleanup;
220		219
221	/*	220	/*
222	* We must always clean up by clearing EXT4_STATE_VERITY_IN_PROGRESS and	221	* Write all pages (both data and verity metadata). Note that this must
223	* deleting the inode from the orphan list, even if something failed.	222	* happen before clearing EXT4_STATE_VERITY_IN_PROGRESS; otherwise pages
224	* If everything succeeded, we'll also set the verity bit in the same	223	* beyond i_size won't be written properly. For crash consistency, this
225	* transaction.	224	* also must happen before the verity inode flag gets persisted.
226	*/	225	*/
		226	err = filemap_write_and_wait(inode->i_mapping);
		227	if (err)
		228	goto cleanup;
227		229
228	ext4_clear_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);	230	/*
		231	* Finally, set the verity inode flag and remove the inode from the
		232	* orphan list (in a single transaction).
		233	*/
229		234
230	handle = ext4_journal_start(inode, EXT4_HT_INODE, credits);	235	handle = ext4_journal_start(inode, EXT4_HT_INODE, credits);
231	if (IS_ERR(handle)) {	236	if (IS_ERR(handle)) {
232	ext4_orphan_del(NULL, inode);	237	err = PTR_ERR(handle);
233	return PTR_ERR(handle);	238	goto cleanup;
234	}	239	}
235		240
236	err2 = ext4_orphan_del(handle, inode);	241	err = ext4_orphan_del(handle, inode);
237	if (err2)	242	if (err)
238	goto out_stop;	243	goto stop_and_cleanup;
239		244
240	if (desc != NULL && !err) {	245	err = ext4_reserve_inode_write(handle, inode, &iloc);
241	struct ext4_iloc iloc;	246	if (err)
		247	goto stop_and_cleanup;
242		248
243	err = ext4_reserve_inode_write(handle, inode, &iloc);	249	ext4_set_inode_flag(inode, EXT4_INODE_VERITY);
244	if (err)	250	ext4_set_inode_flags(inode, false);
245	goto out_stop;	251	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
246	ext4_set_inode_flag(inode, EXT4_INODE_VERITY);	252	if (err)
247	ext4_set_inode_flags(inode, false);	253	goto stop_and_cleanup;
248	err = ext4_mark_iloc_dirty(handle, inode, &iloc);	254
249	}	255	ext4_journal_stop(handle);
250	out_stop:	256
		257	ext4_clear_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);
		258	return 0;
		259
		260	stop_and_cleanup:
251	ext4_journal_stop(handle);	261	ext4_journal_stop(handle);
252	return err ?: err2;	262	cleanup:
		263	/*
		264	* Verity failed to be enabled, so clean up by truncating any verity
		265	* metadata that was written beyond i_size (both from cache and from
		266	* disk), removing the inode from the orphan list (if it wasn't done
		267	* already), and clearing EXT4_STATE_VERITY_IN_PROGRESS.
		268	*/
		269	truncate_inode_pages(inode->i_mapping, inode->i_size);
		270	ext4_truncate(inode);
		271	ext4_orphan_del(NULL, inode);
		272	ext4_clear_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);
		273	return err;
253	}	274	}
254		275
255	static int ext4_get_verity_descriptor_location(struct inode *inode,	276	static int ext4_get_verity_descriptor_location(struct inode *inode,

fs/ext4/xattr.c+5−1

 	if (!ce)
 		return NULL;
+	WARN_ON_ONCE(ext4_handle_valid(journal_current_handle()) &&
+		     !(current->flags & PF_MEMALLOC_NOFS));
 	ea_data = kvmalloc(value_len, GFP_KERNEL);
 	if (!ea_data) {
 		mb_cache_entry_put(ea_inode_cache, ce);
 			error = -ENOSPC;
 			goto cleanup;
 		}
+		WARN_ON_ONCE(!(current->flags & PF_MEMALLOC_NOFS));
 	}
 	error = ext4_reserve_inode_write(handle, inode, &is.iloc);
 				 * external inode if possible.
 				 */
 				if (ext4_has_feature_ea_inode(inode->i_sb) &&
-				    !i.in_inode) {
+				    i.value_len && !i.in_inode) {
 					i.in_inode = 1;
 					goto retry_inode;
 				}

fs/f2fs/checkpoint.c+1−1

@@ -292,7 +292,7 @@ void f2fs_ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index) · 291 unmodified lines
292	f2fs_put_page(page, 0);	292	f2fs_put_page(page, 0);
293		293
294	if (readahead)	294	if (readahead)
295	f2fs_ra_meta_pages(sbi, index, BIO_MAX_PAGES, META_POR, true);	295	f2fs_ra_meta_pages(sbi, index, BIO_MAX_VECS, META_POR, true);
296	}	296	}
297		297
298	static int __f2fs_write_meta_page(struct page *page,	298	static int __f2fs_write_meta_page(struct page *page,

fs/f2fs/data.c+2−2

@@ -857,7 +857,7 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio) · 856 unmodified lines
857	f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL);	857	f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL);
858	alloc_new:	858	alloc_new:
859	if (!bio) {	859	if (!bio) {
860	bio = __bio_alloc(fio, BIO_MAX_PAGES);	860	bio = __bio_alloc(fio, BIO_MAX_VECS);
861	__attach_io_flag(fio);	861	__attach_io_flag(fio);
862	f2fs_set_bio_crypt_ctx(bio, fio->page->mapping->host,	862	f2fs_set_bio_crypt_ctx(bio, fio->page->mapping->host,
863	fio->page->index, fio, GFP_NOIO);	863	fio->page->index, fio, GFP_NOIO);
@@ -932,7 +932,7 @@ alloc_new: · 68 unmodified lines
932	fio->retry = true;	932	fio->retry = true;
933	goto skip;	933	goto skip;
934	}	934	}
935	io->bio = __bio_alloc(fio, BIO_MAX_PAGES);	935	io->bio = __bio_alloc(fio, BIO_MAX_VECS);
936	f2fs_set_bio_crypt_ctx(io->bio, fio->page->mapping->host,	936	f2fs_set_bio_crypt_ctx(io->bio, fio->page->mapping->host,
937	bio_page->index, fio, GFP_NOIO);	937	bio_page->index, fio, GFP_NOIO);
938	io->fio = *fio;	938	io->fio = *fio;

fs/f2fs/segment.c+1−1

@@ -4381,7 +4381,7 @@ static int build_sit_entries(struct f2fs_sb_info *sbi) · 4380 unmodified lines
4381	block_t total_node_blocks = 0;	4381	block_t total_node_blocks = 0;
4382		4382
4383	do {	4383	do {
4384	readed = f2fs_ra_meta_pages(sbi, start_blk, BIO_MAX_PAGES,	4384	readed = f2fs_ra_meta_pages(sbi, start_blk, BIO_MAX_VECS,
4385	META_SIT, true);	4385	META_SIT, true);
4386		4386
4387	start = start_blk * sit_i->sents_per_block;	4387	start = start_blk * sit_i->sents_per_block;

fs/f2fs/segment.h+2−2

@@ -851,7 +851,7 @@ static inline int nr_pages_to_skip(struct f2fs_sb_info *sbi, int type) · 850 unmodified lines
851	else if (type == NODE)	851	else if (type == NODE)
852	return 8 * sbi->blocks_per_seg;	852	return 8 * sbi->blocks_per_seg;
853	else if (type == META)	853	else if (type == META)
854	return 8 * BIO_MAX_PAGES;	854	return 8 * BIO_MAX_VECS;
855	else	855	else
856	return 0;	856	return 0;
857	}	857	}
@@ -868,7 +868,7 @@ static inline long nr_pages_to_write(struct f2fs_sb_info *sbi, int type, · 10 unmodified lines
868	return 0;	868	return 0;
869		869
870	nr_to_write = wbc->nr_to_write;	870	nr_to_write = wbc->nr_to_write;
871	desired = BIO_MAX_PAGES;	871	desired = BIO_MAX_VECS;
872	if (type == NODE)	872	if (type == NODE)
873	desired <<= 1;	873	desired <<= 1;
874		874

fs/f2fs/super.c+2−2

@@ -753,9 +753,9 @@ static int parse_options(struct super_block sb, char options, bool is_remount) · 752 unmodified lines
753	case Opt_io_size_bits:	753	case Opt_io_size_bits:
754	if (args->from && match_int(args, &arg))	754	if (args->from && match_int(args, &arg))
755	return -EINVAL;	755	return -EINVAL;
756	if (arg <= 0 \|\| arg > __ilog2_u32(BIO_MAX_PAGES)) {	756	if (arg <= 0 \|\| arg > __ilog2_u32(BIO_MAX_VECS)) {
757	f2fs_warn(sbi, "Not support %d, larger than %d",	757	f2fs_warn(sbi, "Not support %d, larger than %d",
758	1 << arg, BIO_MAX_PAGES);	758	1 << arg, BIO_MAX_VECS);
759	return -EINVAL;	759	return -EINVAL;
760	}	760	}
761	F2FS_OPTION(sbi).write_io_size_bits = arg;	761	F2FS_OPTION(sbi).write_io_size_bits = arg;

fs/fuse/dev.c+16−10

 static long fuse_dev_ioctl(struct file *file, unsigned int cmd,
 			   unsigned long arg)
 {
-	int err = -ENOTTY;
+	int res;
+	int oldfd;
+	struct fuse_dev *fud = NULL;
-	if (cmd == FUSE_DEV_IOC_CLONE) {
+	if (_IOC_TYPE(cmd) != FUSE_DEV_IOC_MAGIC)
-		int oldfd;
+		return -ENOTTY;
-		err = -EFAULT;
+	switch (_IOC_NR(cmd)) {
-		if (!get_user(oldfd, (__u32 __user *) arg)) {
+	case _IOC_NR(FUSE_DEV_IOC_CLONE):
+		res = -EFAULT;
+		if (!get_user(oldfd, (__u32 __user *)arg)) {
 			struct file *old = fget(oldfd);
-			err = -EINVAL;
+			res = -EINVAL;
 			if (old) {
-				struct fuse_dev *fud = NULL;
 				/*
 				 * Check against file->f_op because CUSE
 				 * uses the same ioctl handler.
 				if (fud) {
 					mutex_lock(&fuse_mutex);
-					err = fuse_device_clone(fud->fc, file);
+					res = fuse_device_clone(fud->fc, file);
 					mutex_unlock(&fuse_mutex);
 				}
 				fput(old);
 			}
 		}
+		break;
+	default:
+		res = -ENOTTY;
+		break;
 	}
-	return err;
+	return res;
 }
 const struct file_operations fuse_dev_operations = {

fs/fuse/fuse_i.h+1−0

@@ -863,6 +863,7 @@ static inline u64 fuse_get_attr_version(struct fuse_conn *fc) · 862 unmodified lines
863		863
864	static inline void fuse_make_bad(struct inode *inode)	864	static inline void fuse_make_bad(struct inode *inode)
865	{	865	{
		866	remove_inode_hash(inode);
866	set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state);	867	set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state);
867	}	868	}
868		869

fs/fuse/virtio_fs.c+8−1

 	/* virtiofs allocates and installs its own fuse devices */
 	ctx->fudptr = NULL;
-	if (ctx->dax)
+	if (ctx->dax) {
+		if (!fs->dax_dev) {
+			err = -EINVAL;
+			pr_err("virtio-fs: dax can't be enabled as filesystem"
+			       " device does not support it.\n");
+			goto err_free_fuse_devs;
+		}
 		ctx->dax_dev = fs->dax_dev;
+	}
 	err = fuse_fill_super_common(sb, ctx);
 	if (err < 0)
 		goto err_free_fuse_devs;

fs/gfs2/log.c+5−1

 	while (!list_empty(head)) {
 		bd = list_first_entry(head, struct gfs2_bufdata, bd_list);
 		list_del_init(&bd->bd_list);
+		if (!list_empty(&bd->bd_ail_st_list))
+			gfs2_remove_from_ail(bd);
 		kmem_cache_free(gfs2_bufdata_cachep, bd);
 	}
 	head = &tr->tr_databuf;
 	while (!list_empty(head)) {
 		bd = list_first_entry(head, struct gfs2_bufdata, bd_list);
 		list_del_init(&bd->bd_list);
+		if (!list_empty(&bd->bd_ail_st_list))
+			gfs2_remove_from_ail(bd);
 		kmem_cache_free(gfs2_bufdata_cachep, bd);
 	}
 }
 	 * Do this check while holding the log_flush_lock to prevent new
 	 * buffers from being added to the ail via gfs2_pin()
 	 */
-	if (gfs2_withdrawn(sdp))
+	if (gfs2_withdrawn(sdp) || !test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
 		goto out;
 	/* Log might have been flushed while we waited for the flush lock */

fs/gfs2/lops.c+1−1

@@ -267,7 +267,7 @@ static struct bio gfs2_log_alloc_bio(struct gfs2_sbd sdp, u64 blkno, · 266 unmodified lines
267	bio_end_io_t *end_io)	267	bio_end_io_t *end_io)
268	{	268	{
269	struct super_block *sb = sdp->sd_vfs;	269	struct super_block *sb = sdp->sd_vfs;
270	struct bio *bio = bio_alloc(GFP_NOIO, BIO_MAX_PAGES);	270	struct bio *bio = bio_alloc(GFP_NOIO, BIO_MAX_VECS);
271		271
272	bio->bi_iter.bi_sector = blkno << sdp->sd_fsb2bb_shift;	272	bio->bi_iter.bi_sector = blkno << sdp->sd_fsb2bb_shift;
273	bio_set_dev(bio, sb->s_bdev);	273	bio_set_dev(bio, sb->s_bdev);

fs/gfs2/ops_fstype.c+1−3

 			return -EINVAL;
 		if (fc->sb_flags & SB_RDONLY) {
-			error = gfs2_make_fs_ro(sdp);
+			gfs2_make_fs_ro(sdp);
-			if (error)
-				errorfc(fc, "unable to remount read-only");
 		} else {
 			error = gfs2_make_fs_rw(sdp);
 			if (error)

fs/gfs2/super.c+2−8

  * Returns: errno
  */
-int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
+void gfs2_make_fs_ro(struct gfs2_sbd *sdp)
 {
-	int error = 0;
 	int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 	gfs2_flush_delete_work(sdp);
 	if (!log_write_allowed)
 		sdp->sd_vfs->s_flags |= SB_RDONLY;
-	return error;
 }
 /**
 static void gfs2_put_super(struct super_block *sb)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
-	int error;
 	struct gfs2_jdesc *jd;
 	/* No more recovery requests */
 	spin_unlock(&sdp->sd_jindex_spin);
 	if (!sb_rdonly(sb)) {
-		error = gfs2_make_fs_ro(sdp);
+		gfs2_make_fs_ro(sdp);
-		if (error)
-			gfs2_io_error(sdp);
 	}
 	WARN_ON(gfs2_withdrawing(sdp));

fs/gfs2/super.h+1−1

@@ -34,7 +34,7 @@ extern int gfs2_lookup_in_master_dir(struct gfs2_sbd sdp, char filename, · 33 unmodified lines
34	struct gfs2_inode **ipp);	34	struct gfs2_inode **ipp);
35		35
36	extern int gfs2_make_fs_rw(struct gfs2_sbd *sdp);	36	extern int gfs2_make_fs_rw(struct gfs2_sbd *sdp);
37	extern int gfs2_make_fs_ro(struct gfs2_sbd *sdp);	37	extern void gfs2_make_fs_ro(struct gfs2_sbd *sdp);
38	extern void gfs2_online_uevent(struct gfs2_sbd *sdp);	38	extern void gfs2_online_uevent(struct gfs2_sbd *sdp);
39	extern int gfs2_statfs_init(struct gfs2_sbd *sdp);	39	extern int gfs2_statfs_init(struct gfs2_sbd *sdp);
40	extern void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,	40	extern void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,

fs/gfs2/trans.c+2−0

 	bd->bd_bh = bh;
 	bd->bd_gl = gl;
 	INIT_LIST_HEAD(&bd->bd_list);
+	INIT_LIST_HEAD(&bd->bd_ail_st_list);
+	INIT_LIST_HEAD(&bd->bd_ail_gl_list);
 	bh->b_private = bd;
 	return bd;
 }

fs/gfs2/util.c+11−6

 static void signal_our_withdraw(struct gfs2_sbd *sdp)
 {
 	struct gfs2_glock *live_gl = sdp->sd_live_gh.gh_gl;
-	struct inode *inode = sdp->sd_jdesc->jd_inode;
+	struct inode *inode;
-	struct gfs2_inode *ip = GFS2_I(inode);
+	struct gfs2_inode *ip;
-	struct gfs2_glock *i_gl = ip->i_gl;
+	struct gfs2_glock *i_gl;
-	u64 no_formal_ino = ip->i_no_formal_ino;
+	u64 no_formal_ino;
 	int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 	int ret = 0;
 	int tries;
-	if (test_bit(SDF_NORECOVERY, &sdp->sd_flags))
+	if (test_bit(SDF_NORECOVERY, &sdp->sd_flags) || !sdp->sd_jdesc)
 		return;
+	inode = sdp->sd_jdesc->jd_inode;
+	ip = GFS2_I(inode);
+	i_gl = ip->i_gl;
+	no_formal_ino = ip->i_no_formal_ino;
 	/* Prevent any glock dq until withdraw recovery is complete */
 	set_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
 	/*
 				ret = 0;
 		}
 		if (!ret)
-			ret = gfs2_make_fs_ro(sdp);
+			gfs2_make_fs_ro(sdp);
 		gfs2_freeze_unlock(&freeze_gh);
 	}

fs/io-wq.c+22−15

 	io_wq_work_fn *do_work;
 	struct task_struct *manager;
-	struct user_struct *user;
 	struct io_wq_hash *hash;
 	return NULL;
 }
-static void io_flush_signals(void)
+static bool io_flush_signals(void)
 {
 	if (unlikely(test_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL))) {
+		__set_current_state(TASK_RUNNING);
 		if (current->task_works)
 			task_work_run();
 		clear_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL);
+		return true;
 	}
+	return false;
 }
 static void io_assign_current_work(struct io_worker *worker,
 	set_task_comm(current, buf);
 	while (!test_bit(IO_WQ_BIT_EXIT, &wq->state)) {
+		long ret;
 		set_current_state(TASK_INTERRUPTIBLE);
 loop:
 		raw_spin_lock_irq(&wqe->lock);
 		}
 		__io_worker_idle(wqe, worker);
 		raw_spin_unlock_irq(&wqe->lock);
-		io_flush_signals();
+		if (io_flush_signals())
-		if (schedule_timeout(WORKER_IDLE_TIMEOUT))
+			continue;
+		ret = schedule_timeout(WORKER_IDLE_TIMEOUT);
+		if (try_to_freeze() || ret)
 			continue;
 		if (fatal_signal_pending(current))
 			break;
 	tsk->pf_io_worker = worker;
 	worker->task = tsk;
 	set_cpus_allowed_ptr(tsk, cpumask_of_node(wqe->node));
-	tsk->flags |= PF_NOFREEZE | PF_NO_SETAFFINITY;
+	tsk->flags |= PF_NO_SETAFFINITY;
 	raw_spin_lock_irq(&wqe->lock);
 	hlist_nulls_add_head_rcu(&worker->nulls_node, &wqe->free_list);
 		io_wq_for_each_worker(wq->wqes[node], io_wq_worker_wake, NULL);
 	rcu_read_unlock();
-	/* we might not ever have created any workers */
+	if (atomic_dec_and_test(&wq->worker_refs))
-	if (atomic_read(&wq->worker_refs))
+		complete(&wq->worker_done);
-		wait_for_completion(&wq->worker_done);
+	wait_for_completion(&wq->worker_done);
 	spin_lock_irq(&wq->hash->wait.lock);
 	for_each_node(node)
 	if (wq->manager)
 		return 0;
-	reinit_completion(&wq->worker_done);
+	WARN_ON_ONCE(test_bit(IO_WQ_BIT_EXIT, &wq->state));
+	init_completion(&wq->worker_done);
+	atomic_set(&wq->worker_refs, 1);
 	tsk = create_io_thread(io_wq_manager, wq, NUMA_NO_NODE);
 	if (!IS_ERR(tsk)) {
 		wq->manager = get_task_struct(tsk);
 		return 0;
 	}
+	if (atomic_dec_and_test(&wq->worker_refs))
+		complete(&wq->worker_done);
 	return PTR_ERR(tsk);
 }
 	/* Can only happen if manager creation fails after exec */
 	if (io_wq_fork_manager(wqe->wq) ||
 	    test_bit(IO_WQ_BIT_EXIT, &wqe->wq->state)) {
-		work->flags |= IO_WQ_WORK_CANCEL;
+		io_run_cancel(work, wqe);
-		wqe->wq->do_work(work);
 		return;
 	}
 	init_completion(&wq->exited);
 	refcount_set(&wq->refs, 1);
-	init_completion(&wq->worker_done);
-	atomic_set(&wq->worker_refs, 0);
 	ret = io_wq_fork_manager(wq);
 	if (!ret)
 		return wq;
 err:
 	io_wq_put_hash(data->hash);
 	cpuhp_state_remove_instance_nocalls(io_wq_online, &wq->cpuhp_node);

fs/io-wq.h+10−2

 #define INTERNAL_IO_WQ_H
 #include <linux/refcount.h>
-#include <linux/io_uring.h>
 struct io_wq;
 	IO_WQ_CANCEL_NOTFOUND,	/* work not found */
 };
+struct io_wq_work_node {
+	struct io_wq_work_node *next;
+};
+struct io_wq_work_list {
+	struct io_wq_work_node *first;
+	struct io_wq_work_node *last;
+};
 static inline void wq_list_add_after(struct io_wq_work_node *node,
 				     struct io_wq_work_node *pos,
 				     struct io_wq_work_list *list)
 struct io_wq_work {
 	struct io_wq_work_node list;
+	const struct cred *creds;
 	unsigned flags;
-	unsigned short personality;
 };
 static inline struct io_wq_work *wq_next_work(struct io_wq_work *work)

fs/io_uring.c+551−436

@@ -258,12 +258,11 @@ enum { · 257 unmodified lines
258		258
259	struct io_sq_data {	259	struct io_sq_data {
260	refcount_t refs;	260	refcount_t refs;
		261	atomic_t park_pending;
261	struct mutex lock;	262	struct mutex lock;
262		263
263	/* ctx's that are using this sqd */	264	/* ctx's that are using this sqd */
264	struct list_head ctx_list;	265	struct list_head ctx_list;
265	struct list_head ctx_new_list;
266	struct mutex ctx_lock;
267		266
268	struct task_struct *thread;	267	struct task_struct *thread;
269	struct wait_queue_head wait;	268	struct wait_queue_head wait;
@@ -271,11 +270,11 @@ struct io_sq_data { · 1 unmodified line
271	unsigned sq_thread_idle;	270	unsigned sq_thread_idle;
272	int sq_cpu;	271	int sq_cpu;
273	pid_t task_pid;	272	pid_t task_pid;
		273	pid_t task_tgid;
274		274
275	unsigned long state;	275	unsigned long state;
276	struct completion startup;
277	struct completion parked;
278	struct completion exited;	276	struct completion exited;
		277	struct callback_head *park_task_work;
279	};	278	};
280		279
281	#define IO_IOPOLL_BATCH 8	280	#define IO_IOPOLL_BATCH 8
@@ -336,7 +335,6 @@ struct io_ring_ctx { · 54 unmodified lines
336	unsigned int drain_next: 1;	335	unsigned int drain_next: 1;
337	unsigned int eventfd_async: 1;	336	unsigned int eventfd_async: 1;
338	unsigned int restricted: 1;	337	unsigned int restricted: 1;
339	unsigned int sqo_exec: 1;
340		338
341	/*	339	/*
342	* Ring buffer of indices into array of io_uring_sqe, which is	340	* Ring buffer of indices into array of io_uring_sqe, which is
@@ -380,6 +378,7 @@ struct io_ring_ctx { · 37 unmodified lines
380	/* Only used for accounting purposes */	378	/* Only used for accounting purposes */
381	struct mm_struct *mm_account;	379	struct mm_struct *mm_account;
382		380
		381	const struct cred sq_creds; / cred used for __io_sq_thread() */
383	struct io_sq_data sq_data; / if using sq thread polling */	382	struct io_sq_data sq_data; / if using sq thread polling */
384		383
385	struct wait_queue_head sqo_sq_wait;	384	struct wait_queue_head sqo_sq_wait;
@@ -400,15 +399,15 @@ struct io_ring_ctx { · 14 unmodified lines
400	struct user_struct *user;	399	struct user_struct *user;
401		400
402	struct completion ref_comp;	401	struct completion ref_comp;
403	struct completion sq_thread_comp;
404		402
405	#if defined(CONFIG_UNIX)	403	#if defined(CONFIG_UNIX)
406	struct socket *ring_sock;	404	struct socket *ring_sock;
407	#endif	405	#endif
408		406
409	struct idr io_buffer_idr;	407	struct xarray io_buffers;
410		408
411	struct idr personality_idr;	409	struct xarray personalities;
		410	u32 pers_next;
412		411
413	struct {	412	struct {
414	unsigned cached_cq_tail;	413	unsigned cached_cq_tail;
@@ -454,6 +453,23 @@ struct io_ring_ctx { · 39 unmodified lines
454		453
455	/* Keep this last, we don't need it for the fast path */	454	/* Keep this last, we don't need it for the fast path */
456	struct work_struct exit_work;	455	struct work_struct exit_work;
		456	struct list_head tctx_list;
		457	};
		458
		459	struct io_uring_task {
		460	/* submission side */
		461	struct xarray xa;
		462	struct wait_queue_head wait;
		463	const struct io_ring_ctx *last;
		464	struct io_wq *io_wq;
		465	struct percpu_counter inflight;
		466	atomic_t in_idle;
		467	bool sqpoll;
		468
		469	spinlock_t task_lock;
		470	struct io_wq_work_list task_list;
		471	unsigned long task_state;
		472	struct callback_head task_work;
457	};	473	};
458		474
459	/*	475	/*
@@ -805,6 +821,12 @@ struct io_kiocb { · 345 unmodified lines
805	struct io_wq_work work;	821	struct io_wq_work work;
806	};	822	};
807		823
		824	struct io_tctx_node {
		825	struct list_head ctx_node;
		826	struct task_struct *task;
		827	struct io_ring_ctx *ctx;
		828	};
		829
808	struct io_defer_entry {	830	struct io_defer_entry {
809	struct list_head list;	831	struct list_head list;
810	struct io_kiocb *req;	832	struct io_kiocb *req;
@@ -979,6 +1001,8 @@ static const struct io_op_def io_op_defs[] = { · 168 unmodified lines
979	[IORING_OP_UNLINKAT] = {},	1001	[IORING_OP_UNLINKAT] = {},
980	};	1002	};
981		1003
		1004	static bool io_disarm_next(struct io_kiocb *req);
		1005	static void io_uring_del_task_file(unsigned long index);
982	static void io_uring_try_cancel_requests(struct io_ring_ctx *ctx,	1006	static void io_uring_try_cancel_requests(struct io_ring_ctx *ctx,
983	struct task_struct *task,	1007	struct task_struct *task,
984	struct files_struct *files);	1008	struct files_struct *files);
@@ -1129,9 +1153,8 @@ static struct io_ring_ctx io_ring_ctx_alloc(struct io_uring_params p) · 144 unmodified lines
1129	init_waitqueue_head(&ctx->cq_wait);	1153	init_waitqueue_head(&ctx->cq_wait);
1130	INIT_LIST_HEAD(&ctx->cq_overflow_list);	1154	INIT_LIST_HEAD(&ctx->cq_overflow_list);
1131	init_completion(&ctx->ref_comp);	1155	init_completion(&ctx->ref_comp);
1132	init_completion(&ctx->sq_thread_comp);	1156	xa_init_flags(&ctx->io_buffers, XA_FLAGS_ALLOC1);
1133	idr_init(&ctx->io_buffer_idr);	1157	xa_init_flags(&ctx->personalities, XA_FLAGS_ALLOC1);
1134	idr_init(&ctx->personality_idr);
1135	mutex_init(&ctx->uring_lock);	1158	mutex_init(&ctx->uring_lock);
1136	init_waitqueue_head(&ctx->wait);	1159	init_waitqueue_head(&ctx->wait);
1137	spin_lock_init(&ctx->completion_lock);	1160	spin_lock_init(&ctx->completion_lock);
@@ -1144,6 +1167,7 @@ static struct io_ring_ctx io_ring_ctx_alloc(struct io_uring_params p) · 6 unmodified lines
1144	INIT_LIST_HEAD(&ctx->rsrc_ref_list);	1167	INIT_LIST_HEAD(&ctx->rsrc_ref_list);
1145	INIT_DELAYED_WORK(&ctx->rsrc_put_work, io_rsrc_put_work);	1168	INIT_DELAYED_WORK(&ctx->rsrc_put_work, io_rsrc_put_work);
1146	init_llist_head(&ctx->rsrc_put_llist);	1169	init_llist_head(&ctx->rsrc_put_llist);
		1170	INIT_LIST_HEAD(&ctx->tctx_list);
1147	INIT_LIST_HEAD(&ctx->submit_state.comp.free_list);	1171	INIT_LIST_HEAD(&ctx->submit_state.comp.free_list);
1148	INIT_LIST_HEAD(&ctx->submit_state.comp.locked_free_list);	1172	INIT_LIST_HEAD(&ctx->submit_state.comp.locked_free_list);
1149	return ctx;	1173	return ctx;
@@ -1183,6 +1207,9 @@ static void io_prep_async_work(struct io_kiocb *req) · 33 unmodified lines
1183	const struct io_op_def *def = &io_op_defs[req->opcode];	1207	const struct io_op_def *def = &io_op_defs[req->opcode];
1184	struct io_ring_ctx *ctx = req->ctx;	1208	struct io_ring_ctx *ctx = req->ctx;
1185		1209
		1210	if (!req->work.creds)
		1211	req->work.creds = get_current_cred();
		1212
1186	if (req->flags & REQ_F_FORCE_ASYNC)	1213	if (req->flags & REQ_F_FORCE_ASYNC)
1187	req->work.flags \|= IO_WQ_WORK_CONCURRENT;	1214	req->work.flags \|= IO_WQ_WORK_CONCURRENT;
1188		1215
@@ -1514,15 +1541,14 @@ static void io_cqring_fill_event(struct io_kiocb *req, long res) · 325 unmodified lines
1514	__io_cqring_fill_event(req, res, 0);	1541	__io_cqring_fill_event(req, res, 0);
1515	}	1542	}
1516		1543
1517	static inline void io_req_complete_post(struct io_kiocb *req, long res,	1544	static void io_req_complete_post(struct io_kiocb *req, long res,
1518	unsigned int cflags)	1545	unsigned int cflags)
1519	{	1546	{
1520	struct io_ring_ctx *ctx = req->ctx;	1547	struct io_ring_ctx *ctx = req->ctx;
1521	unsigned long flags;	1548	unsigned long flags;
1522		1549
1523	spin_lock_irqsave(&ctx->completion_lock, flags);	1550	spin_lock_irqsave(&ctx->completion_lock, flags);
1524	__io_cqring_fill_event(req, res, cflags);	1551	__io_cqring_fill_event(req, res, cflags);
1525	io_commit_cqring(ctx);
1526	/*	1552	/*
1527	* If we're the last reference to this request, add to our locked	1553	* If we're the last reference to this request, add to our locked
1528	* free_list cache.	1554	* free_list cache.
@@ -1530,17 +1556,27 @@ static inline void io_req_complete_post(struct io_kiocb *req, long res, · 1 unmodified line
1530	if (refcount_dec_and_test(&req->refs)) {	1556	if (refcount_dec_and_test(&req->refs)) {
1531	struct io_comp_state *cs = &ctx->submit_state.comp;	1557	struct io_comp_state *cs = &ctx->submit_state.comp;
1532		1558
		1559	if (req->flags & (REQ_F_LINK \| REQ_F_HARDLINK)) {
		1560	if (req->flags & (REQ_F_LINK_TIMEOUT \| REQ_F_FAIL_LINK))
		1561	io_disarm_next(req);
		1562	if (req->link) {
		1563	io_req_task_queue(req->link);
		1564	req->link = NULL;
		1565	}
		1566	}
1533	io_dismantle_req(req);	1567	io_dismantle_req(req);
1534	io_put_task(req->task, 1);	1568	io_put_task(req->task, 1);
1535	list_add(&req->compl.list, &cs->locked_free_list);	1569	list_add(&req->compl.list, &cs->locked_free_list);
1536	cs->locked_free_nr++;	1570	cs->locked_free_nr++;
1537	} else	1571	} else {
1538	req = NULL;	1572	if (!percpu_ref_tryget(&ctx->refs))
		1573	req = NULL;
		1574	}
		1575	io_commit_cqring(ctx);
1539	spin_unlock_irqrestore(&ctx->completion_lock, flags);	1576	spin_unlock_irqrestore(&ctx->completion_lock, flags);
1540		1577
1541	io_cqring_ev_posted(ctx);
1542	if (req) {	1578	if (req) {
1543	io_queue_next(req);	1579	io_cqring_ev_posted(ctx);
1544	percpu_ref_put(&ctx->refs);	1580	percpu_ref_put(&ctx->refs);
1545	}	1581	}
1546	}	1582	}
@@ -1648,6 +1684,10 @@ static void io_dismantle_req(struct io_kiocb *req) · 101 unmodified lines
1648	io_put_file(req, req->file, (req->flags & REQ_F_FIXED_FILE));	1684	io_put_file(req, req->file, (req->flags & REQ_F_FIXED_FILE));
1649	if (req->fixed_rsrc_refs)	1685	if (req->fixed_rsrc_refs)
1650	percpu_ref_put(req->fixed_rsrc_refs);	1686	percpu_ref_put(req->fixed_rsrc_refs);
		1687	if (req->work.creds) {
		1688	put_cred(req->work.creds);
		1689	req->work.creds = NULL;
		1690	}
1651		1691
1652	if (req->flags & REQ_F_INFLIGHT) {	1692	if (req->flags & REQ_F_INFLIGHT) {
1653	struct io_ring_ctx *ctx = req->ctx;	1693	struct io_ring_ctx *ctx = req->ctx;
@@ -1690,15 +1730,11 @@ static inline void io_remove_next_linked(struct io_kiocb *req) · 36 unmodified lines
1690	nxt->link = NULL;	1730	nxt->link = NULL;
1691	}	1731	}
1692		1732
1693	static void io_kill_linked_timeout(struct io_kiocb *req)	1733	static bool io_kill_linked_timeout(struct io_kiocb *req)
		1734	__must_hold(&req->ctx->completion_lock)
1694	{	1735	{
1695	struct io_ring_ctx *ctx = req->ctx;	1736	struct io_kiocb *link = req->link;
1696	struct io_kiocb *link;
1697	bool cancelled = false;	1737	bool cancelled = false;
1698	unsigned long flags;
1699
1700	spin_lock_irqsave(&ctx->completion_lock, flags);
1701	link = req->link;
1702		1738
1703	/*	1739	/*
1704	* Can happen if a linked timeout fired and link had been like	1740	* Can happen if a linked timeout fired and link had been like
@@ -1713,50 +1749,48 @@ static void io_kill_linked_timeout(struct io_kiocb *req) · 8 unmodified lines
1713	ret = hrtimer_try_to_cancel(&io->timer);	1749	ret = hrtimer_try_to_cancel(&io->timer);
1714	if (ret != -1) {	1750	if (ret != -1) {
1715	io_cqring_fill_event(link, -ECANCELED);	1751	io_cqring_fill_event(link, -ECANCELED);
1716	io_commit_cqring(ctx);	1752	io_put_req_deferred(link, 1);
1717	cancelled = true;	1753	cancelled = true;
1718	}	1754	}
1719	}	1755	}
1720	req->flags &= ~REQ_F_LINK_TIMEOUT;	1756	req->flags &= ~REQ_F_LINK_TIMEOUT;
1721	spin_unlock_irqrestore(&ctx->completion_lock, flags);	1757	return cancelled;
1722
1723	if (cancelled) {
1724	io_cqring_ev_posted(ctx);
1725	io_put_req(link);
1726	}
1727	}	1758	}
1728		1759
1729
1730	static void io_fail_links(struct io_kiocb *req)	1760	static void io_fail_links(struct io_kiocb *req)
		1761	__must_hold(&req->ctx->completion_lock)
1731	{	1762	{
1732	struct io_kiocb link, nxt;	1763	struct io_kiocb nxt, link = req->link;
1733	struct io_ring_ctx *ctx = req->ctx;
1734	unsigned long flags;
1735		1764
1736	spin_lock_irqsave(&ctx->completion_lock, flags);
1737	link = req->link;
1738	req->link = NULL;	1765	req->link = NULL;
1739
1740	while (link) {	1766	while (link) {
1741	nxt = link->link;	1767	nxt = link->link;
1742	link->link = NULL;	1768	link->link = NULL;
1743		1769
1744	trace_io_uring_fail_link(req, link);	1770	trace_io_uring_fail_link(req, link);
1745	io_cqring_fill_event(link, -ECANCELED);	1771	io_cqring_fill_event(link, -ECANCELED);
1746
1747	io_put_req_deferred(link, 2);	1772	io_put_req_deferred(link, 2);
1748	link = nxt;	1773	link = nxt;
1749	}	1774	}
1750	io_commit_cqring(ctx);	1775	}
1751	spin_unlock_irqrestore(&ctx->completion_lock, flags);
1752		1776
1753	io_cqring_ev_posted(ctx);	1777	static bool io_disarm_next(struct io_kiocb *req)
		1778	__must_hold(&req->ctx->completion_lock)
		1779	{
		1780	bool posted = false;
		1781
		1782	if (likely(req->flags & REQ_F_LINK_TIMEOUT))
		1783	posted = io_kill_linked_timeout(req);
		1784	if (unlikely(req->flags & REQ_F_FAIL_LINK)) {
		1785	posted \|= (req->link != NULL);
		1786	io_fail_links(req);
		1787	}
		1788	return posted;
1754	}	1789	}
1755		1790
1756	static struct io_kiocb __io_req_find_next(struct io_kiocb req)	1791	static struct io_kiocb __io_req_find_next(struct io_kiocb req)
1757	{	1792	{
1758	if (req->flags & REQ_F_LINK_TIMEOUT)	1793	struct io_kiocb *nxt;
1759	io_kill_linked_timeout(req);
1760		1794
1761	/*	1795	/*
1762	* If LINK is set, we have dependent requests in this chain. If we	1796	* If LINK is set, we have dependent requests in this chain. If we
@@ -1764,14 +1798,22 @@ static struct io_kiocb __io_req_find_next(struct io_kiocb req) · 1 unmodified line
1764	* dependencies to the next request. In case of failure, fail the rest	1798	* dependencies to the next request. In case of failure, fail the rest
1765	* of the chain.	1799	* of the chain.
1766	*/	1800	*/
1767	if (likely(!(req->flags & REQ_F_FAIL_LINK))) {	1801	if (req->flags & (REQ_F_LINK_TIMEOUT \| REQ_F_FAIL_LINK)) {
1768	struct io_kiocb *nxt = req->link;	1802	struct io_ring_ctx *ctx = req->ctx;
		1803	unsigned long flags;
		1804	bool posted;
1769		1805
1770	req->link = NULL;	1806	spin_lock_irqsave(&ctx->completion_lock, flags);
1771	return nxt;	1807	posted = io_disarm_next(req);
		1808	if (posted)
		1809	io_commit_cqring(req->ctx);
		1810	spin_unlock_irqrestore(&ctx->completion_lock, flags);
		1811	if (posted)
		1812	io_cqring_ev_posted(ctx);
1772	}	1813	}
1773	io_fail_links(req);	1814	nxt = req->link;
1774	return NULL;	1815	req->link = NULL;
		1816	return nxt;
1775	}	1817	}
1776		1818
1777	static inline struct io_kiocb io_req_find_next(struct io_kiocb req)	1819	static inline struct io_kiocb io_req_find_next(struct io_kiocb req)
@@ -1904,17 +1946,44 @@ static int io_req_task_work_add(struct io_kiocb *req) · 126 unmodified lines
1904	return ret;	1946	return ret;
1905	}	1947	}
1906		1948
1907	static void io_req_task_work_add_fallback(struct io_kiocb *req,	1949	static bool io_run_task_work_head(struct callback_head **work_head)
1908	task_work_func_t cb)	1950	{
		1951	struct callback_head work, next;
		1952	bool executed = false;
		1953
		1954	do {
		1955	work = xchg(work_head, NULL);
		1956	if (!work)
		1957	break;
		1958
		1959	do {
		1960	next = work->next;
		1961	work->func(work);
		1962	work = next;
		1963	cond_resched();
		1964	} while (work);
		1965	executed = true;
		1966	} while (1);
		1967
		1968	return executed;
		1969	}
		1970
		1971	static void io_task_work_add_head(struct callback_head **work_head,
		1972	struct callback_head *task_work)
1909	{	1973	{
1910	struct io_ring_ctx *ctx = req->ctx;
1911	struct callback_head *head;	1974	struct callback_head *head;
1912		1975
1913	init_task_work(&req->task_work, cb);
1914	do {	1976	do {
1915	head = READ_ONCE(ctx->exit_task_work);	1977	head = READ_ONCE(*work_head);
1916	req->task_work.next = head;	1978	task_work->next = head;
1917	} while (cmpxchg(&ctx->exit_task_work, head, &req->task_work) != head);	1979	} while (cmpxchg(work_head, head, task_work) != head);
		1980	}
		1981
		1982	static void io_req_task_work_add_fallback(struct io_kiocb *req,
		1983	task_work_func_t cb)
		1984	{
		1985	init_task_work(&req->task_work, cb);
		1986	io_task_work_add_head(&req->ctx->exit_task_work, &req->task_work);
1918	}	1987	}
1919		1988
1920	static void __io_req_task_cancel(struct io_kiocb *req, int error)	1989	static void __io_req_task_cancel(struct io_kiocb *req, int error)
@@ -2822,7 +2891,7 @@ static struct io_buffer io_buffer_select(struct io_kiocb req, size_t *len, · 901 unmodified lines
2822		2891
2823	lockdep_assert_held(&req->ctx->uring_lock);	2892	lockdep_assert_held(&req->ctx->uring_lock);
2824		2893
2825	head = idr_find(&req->ctx->io_buffer_idr, bgid);	2894	head = xa_load(&req->ctx->io_buffers, bgid);
2826	if (head) {	2895	if (head) {
2827	if (!list_empty(&head->list)) {	2896	if (!list_empty(&head->list)) {
2828	kbuf = list_last_entry(&head->list, struct io_buffer,	2897	kbuf = list_last_entry(&head->list, struct io_buffer,
@@ -2830,7 +2899,7 @@ static struct io_buffer io_buffer_select(struct io_kiocb req, size_t *len, · 1 unmodified line
2830	list_del(&kbuf->list);	2899	list_del(&kbuf->list);
2831	} else {	2900	} else {
2832	kbuf = head;	2901	kbuf = head;
2833	idr_remove(&req->ctx->io_buffer_idr, bgid);	2902	xa_erase(&req->ctx->io_buffers, bgid);
2834	}	2903	}
2835	if (*len > kbuf->len)	2904	if (*len > kbuf->len)
2836	*len = kbuf->len;	2905	*len = kbuf->len;
@@ -3871,7 +3940,7 @@ static int __io_remove_buffers(struct io_ring_ctx ctx, struct io_buffer buf, · 1034 unmodified lines
3871	}	3940	}
3872	i++;	3941	i++;
3873	kfree(buf);	3942	kfree(buf);
3874	idr_remove(&ctx->io_buffer_idr, bgid);	3943	xa_erase(&ctx->io_buffers, bgid);
3875		3944
3876	return i;	3945	return i;
3877	}	3946	}
@@ -3889,7 +3958,7 @@ static int io_remove_buffers(struct io_kiocb *req, unsigned int issue_flags) · 11 unmodified lines
3889	lockdep_assert_held(&ctx->uring_lock);	3958	lockdep_assert_held(&ctx->uring_lock);
3890		3959
3891	ret = -ENOENT;	3960	ret = -ENOENT;
3892	head = idr_find(&ctx->io_buffer_idr, p->bgid);	3961	head = xa_load(&ctx->io_buffers, p->bgid);
3893	if (head)	3962	if (head)
3894	ret = __io_remove_buffers(ctx, head, p->bgid, p->nbufs);	3963	ret = __io_remove_buffers(ctx, head, p->bgid, p->nbufs);
3895	if (ret < 0)	3964	if (ret < 0)
@@ -3972,21 +4041,14 @@ static int io_provide_buffers(struct io_kiocb *req, unsigned int issue_flags) · 76 unmodified lines
3972		4041
3973	lockdep_assert_held(&ctx->uring_lock);	4042	lockdep_assert_held(&ctx->uring_lock);
3974		4043
3975	list = head = idr_find(&ctx->io_buffer_idr, p->bgid);	4044	list = head = xa_load(&ctx->io_buffers, p->bgid);
3976		4045
3977	ret = io_add_buffers(p, &head);	4046	ret = io_add_buffers(p, &head);
3978	if (ret < 0)	4047	if (ret >= 0 && !list) {
3979	goto out;	4048	ret = xa_insert(&ctx->io_buffers, p->bgid, head, GFP_KERNEL);
3980		4049	if (ret < 0)
3981	if (!list) {
3982	ret = idr_alloc(&ctx->io_buffer_idr, head, p->bgid, p->bgid + 1,
3983	GFP_KERNEL);
3984	if (ret < 0) {
3985	__io_remove_buffers(ctx, head, p->bgid, -1U);	4050	__io_remove_buffers(ctx, head, p->bgid, -1U);
3986	goto out;
3987	}
3988	}	4051	}
3989	out:
3990	if (ret < 0)	4052	if (ret < 0)
3991	req_set_fail_links(req);	4053	req_set_fail_links(req);
3992		4054
@@ -4324,6 +4386,7 @@ static int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags) · 331 unmodified lines
4324	struct io_async_msghdr iomsg, *kmsg;	4386	struct io_async_msghdr iomsg, *kmsg;
4325	struct socket *sock;	4387	struct socket *sock;
4326	unsigned flags;	4388	unsigned flags;
		4389	int min_ret = 0;
4327	int ret;	4390	int ret;
4328		4391
4329	sock = sock_from_file(req->file);	4392	sock = sock_from_file(req->file);
@@ -4338,12 +4401,15 @@ static int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags) · 8 unmodified lines
4338	kmsg = &iomsg;	4401	kmsg = &iomsg;
4339	}	4402	}
4340		4403
4341	flags = req->sr_msg.msg_flags;	4404	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4342	if (flags & MSG_DONTWAIT)	4405	if (flags & MSG_DONTWAIT)
4343	req->flags \|= REQ_F_NOWAIT;	4406	req->flags \|= REQ_F_NOWAIT;
4344	else if (issue_flags & IO_URING_F_NONBLOCK)	4407	else if (issue_flags & IO_URING_F_NONBLOCK)
4345	flags \|= MSG_DONTWAIT;	4408	flags \|= MSG_DONTWAIT;
4346		4409
		4410	if (flags & MSG_WAITALL)
		4411	min_ret = iov_iter_count(&kmsg->msg.msg_iter);
		4412
4347	ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);	4413	ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
4348	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)	4414	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)
4349	return io_setup_async_msg(req, kmsg);	4415	return io_setup_async_msg(req, kmsg);
@@ -4354,7 +4420,7 @@ static int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags) · 4 unmodified lines
4354	if (kmsg->free_iov)	4420	if (kmsg->free_iov)
4355	kfree(kmsg->free_iov);	4421	kfree(kmsg->free_iov);
4356	req->flags &= ~REQ_F_NEED_CLEANUP;	4422	req->flags &= ~REQ_F_NEED_CLEANUP;
4357	if (ret < 0)	4423	if (ret < min_ret)
4358	req_set_fail_links(req);	4424	req_set_fail_links(req);
4359	__io_req_complete(req, issue_flags, ret, 0);	4425	__io_req_complete(req, issue_flags, ret, 0);
4360	return 0;	4426	return 0;
@@ -4367,6 +4433,7 @@ static int io_send(struct io_kiocb *req, unsigned int issue_flags) · 6 unmodified lines
4367	struct iovec iov;	4433	struct iovec iov;
4368	struct socket *sock;	4434	struct socket *sock;
4369	unsigned flags;	4435	unsigned flags;
		4436	int min_ret = 0;
4370	int ret;	4437	int ret;
4371		4438
4372	sock = sock_from_file(req->file);	4439	sock = sock_from_file(req->file);
@@ -4382,12 +4449,15 @@ static int io_send(struct io_kiocb *req, unsigned int issue_flags) · 9 unmodified lines
4382	msg.msg_controllen = 0;	4449	msg.msg_controllen = 0;
4383	msg.msg_namelen = 0;	4450	msg.msg_namelen = 0;
4384		4451
4385	flags = req->sr_msg.msg_flags;	4452	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4386	if (flags & MSG_DONTWAIT)	4453	if (flags & MSG_DONTWAIT)
4387	req->flags \|= REQ_F_NOWAIT;	4454	req->flags \|= REQ_F_NOWAIT;
4388	else if (issue_flags & IO_URING_F_NONBLOCK)	4455	else if (issue_flags & IO_URING_F_NONBLOCK)
4389	flags \|= MSG_DONTWAIT;	4456	flags \|= MSG_DONTWAIT;
4390		4457
		4458	if (flags & MSG_WAITALL)
		4459	min_ret = iov_iter_count(&msg.msg_iter);
		4460
4391	msg.msg_flags = flags;	4461	msg.msg_flags = flags;
4392	ret = sock_sendmsg(sock, &msg);	4462	ret = sock_sendmsg(sock, &msg);
4393	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)	4463	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)
@@ -4395,7 +4465,7 @@ static int io_send(struct io_kiocb *req, unsigned int issue_flags) · 1 unmodified line
4395	if (ret == -ERESTARTSYS)	4465	if (ret == -ERESTARTSYS)
4396	ret = -EINTR;	4466	ret = -EINTR;
4397		4467
4398	if (ret < 0)	4468	if (ret < min_ret)
4399	req_set_fail_links(req);	4469	req_set_fail_links(req);
4400	__io_req_complete(req, issue_flags, ret, 0);	4470	__io_req_complete(req, issue_flags, ret, 0);
4401	return 0;	4471	return 0;
@@ -4547,6 +4617,7 @@ static int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags) · 145 unmodified lines
4547	struct socket *sock;	4617	struct socket *sock;
4548	struct io_buffer *kbuf;	4618	struct io_buffer *kbuf;
4549	unsigned flags;	4619	unsigned flags;
		4620	int min_ret = 0;
4550	int ret, cflags = 0;	4621	int ret, cflags = 0;
4551	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;	4622	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
4552		4623
@@ -4572,12 +4643,15 @@ static int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags) · 19 unmodified lines
4572	1, req->sr_msg.len);	4643	1, req->sr_msg.len);
4573	}	4644	}
4574		4645
4575	flags = req->sr_msg.msg_flags;	4646	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4576	if (flags & MSG_DONTWAIT)	4647	if (flags & MSG_DONTWAIT)
4577	req->flags \|= REQ_F_NOWAIT;	4648	req->flags \|= REQ_F_NOWAIT;
4578	else if (force_nonblock)	4649	else if (force_nonblock)
4579	flags \|= MSG_DONTWAIT;	4650	flags \|= MSG_DONTWAIT;
4580		4651
		4652	if (flags & MSG_WAITALL)
		4653	min_ret = iov_iter_count(&kmsg->msg.msg_iter);
		4654
4581	ret = __sys_recvmsg_sock(sock, &kmsg->msg, req->sr_msg.umsg,	4655	ret = __sys_recvmsg_sock(sock, &kmsg->msg, req->sr_msg.umsg,
4582	kmsg->uaddr, flags);	4656	kmsg->uaddr, flags);
4583	if (force_nonblock && ret == -EAGAIN)	4657	if (force_nonblock && ret == -EAGAIN)
@@ -4591,7 +4665,7 @@ static int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags) · 7 unmodified lines
4591	if (kmsg->free_iov)	4665	if (kmsg->free_iov)
4592	kfree(kmsg->free_iov);	4666	kfree(kmsg->free_iov);
4593	req->flags &= ~REQ_F_NEED_CLEANUP;	4667	req->flags &= ~REQ_F_NEED_CLEANUP;
4594	if (ret < 0)	4668	if (ret < min_ret \|\| ((flags & MSG_WAITALL) && (kmsg->msg.msg_flags & (MSG_TRUNC \| MSG_CTRUNC))))
4595	req_set_fail_links(req);	4669	req_set_fail_links(req);
4596	__io_req_complete(req, issue_flags, ret, cflags);	4670	__io_req_complete(req, issue_flags, ret, cflags);
4597	return 0;	4671	return 0;
@@ -4606,6 +4680,7 @@ static int io_recv(struct io_kiocb *req, unsigned int issue_flags) · 8 unmodified lines
4606	struct socket *sock;	4680	struct socket *sock;
4607	struct iovec iov;	4681	struct iovec iov;
4608	unsigned flags;	4682	unsigned flags;
		4683	int min_ret = 0;
4609	int ret, cflags = 0;	4684	int ret, cflags = 0;
4610	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;	4685	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
4611		4686
@@ -4631,12 +4706,15 @@ static int io_recv(struct io_kiocb *req, unsigned int issue_flags) · 19 unmodified lines
4631	msg.msg_iocb = NULL;	4706	msg.msg_iocb = NULL;
4632	msg.msg_flags = 0;	4707	msg.msg_flags = 0;
4633		4708
4634	flags = req->sr_msg.msg_flags;	4709	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4635	if (flags & MSG_DONTWAIT)	4710	if (flags & MSG_DONTWAIT)
4636	req->flags \|= REQ_F_NOWAIT;	4711	req->flags \|= REQ_F_NOWAIT;
4637	else if (force_nonblock)	4712	else if (force_nonblock)
4638	flags \|= MSG_DONTWAIT;	4713	flags \|= MSG_DONTWAIT;
4639		4714
		4715	if (flags & MSG_WAITALL)
		4716	min_ret = iov_iter_count(&msg.msg_iter);
		4717
4640	ret = sock_recvmsg(sock, &msg, flags);	4718	ret = sock_recvmsg(sock, &msg, flags);
4641	if (force_nonblock && ret == -EAGAIN)	4719	if (force_nonblock && ret == -EAGAIN)
4642	return -EAGAIN;	4720	return -EAGAIN;
@@ -4645,7 +4723,7 @@ static int io_recv(struct io_kiocb *req, unsigned int issue_flags) · 2 unmodified lines
4645	out_free:	4723	out_free:
4646	if (req->flags & REQ_F_BUFFER_SELECTED)	4724	if (req->flags & REQ_F_BUFFER_SELECTED)
4647	cflags = io_put_recv_kbuf(req);	4725	cflags = io_put_recv_kbuf(req);
4648	if (ret < 0)	4726	if (ret < min_ret \|\| ((flags & MSG_WAITALL) && (msg.msg_flags & (MSG_TRUNC \| MSG_CTRUNC))))
4649	req_set_fail_links(req);	4727	req_set_fail_links(req);
4650	__io_req_complete(req, issue_flags, ret, cflags);	4728	__io_req_complete(req, issue_flags, ret, cflags);
4651	return 0;	4729	return 0;
@@ -5559,22 +5637,30 @@ add: · 907 unmodified lines
5559	return 0;	5637	return 0;
5560	}	5638	}
5561		5639
		5640	struct io_cancel_data {
		5641	struct io_ring_ctx *ctx;
		5642	u64 user_data;
		5643	};
		5644
5562	static bool io_cancel_cb(struct io_wq_work work, void data)	5645	static bool io_cancel_cb(struct io_wq_work work, void data)
5563	{	5646	{
5564	struct io_kiocb *req = container_of(work, struct io_kiocb, work);	5647	struct io_kiocb *req = container_of(work, struct io_kiocb, work);
		5648	struct io_cancel_data *cd = data;
5565		5649
5566	return req->user_data == (unsigned long) data;	5650	return req->ctx == cd->ctx && req->user_data == cd->user_data;
5567	}	5651	}
5568		5652
5569	static int io_async_cancel_one(struct io_uring_task tctx, void sqe_addr)	5653	static int io_async_cancel_one(struct io_uring_task *tctx, u64 user_data,
		5654	struct io_ring_ctx *ctx)
5570	{	5655	{
		5656	struct io_cancel_data data = { .ctx = ctx, .user_data = user_data, };
5571	enum io_wq_cancel cancel_ret;	5657	enum io_wq_cancel cancel_ret;
5572	int ret = 0;	5658	int ret = 0;
5573		5659
5574	if (!tctx->io_wq)	5660	if (!tctx \|\| !tctx->io_wq)
5575	return -ENOENT;	5661	return -ENOENT;
5576		5662
5577	cancel_ret = io_wq_cancel_cb(tctx->io_wq, io_cancel_cb, sqe_addr, false);	5663	cancel_ret = io_wq_cancel_cb(tctx->io_wq, io_cancel_cb, &data, false);
5578	switch (cancel_ret) {	5664	switch (cancel_ret) {
5579	case IO_WQ_CANCEL_OK:	5665	case IO_WQ_CANCEL_OK:
5580	ret = 0;	5666	ret = 0;
@@ -5597,8 +5683,7 @@ static void io_async_find_and_cancel(struct io_ring_ctx *ctx, · 16 unmodified lines
5597	unsigned long flags;	5683	unsigned long flags;
5598	int ret;	5684	int ret;
5599		5685
5600	ret = io_async_cancel_one(req->task->io_uring,	5686	ret = io_async_cancel_one(req->task->io_uring, sqe_addr, ctx);
5601	(void *) (unsigned long) sqe_addr);
5602	if (ret != -ENOENT) {	5687	if (ret != -ENOENT) {
5603	spin_lock_irqsave(&ctx->completion_lock, flags);	5688	spin_lock_irqsave(&ctx->completion_lock, flags);
5604	goto done;	5689	goto done;
@@ -5639,8 +5724,47 @@ static int io_async_cancel_prep(struct io_kiocb *req, · 34 unmodified lines
5639	static int io_async_cancel(struct io_kiocb *req, unsigned int issue_flags)	5724	static int io_async_cancel(struct io_kiocb *req, unsigned int issue_flags)
5640	{	5725	{
5641	struct io_ring_ctx *ctx = req->ctx;	5726	struct io_ring_ctx *ctx = req->ctx;
		5727	u64 sqe_addr = req->cancel.addr;
		5728	struct io_tctx_node *node;
		5729	int ret;
5642		5730
5643	io_async_find_and_cancel(ctx, req, req->cancel.addr, 0);	5731	/* tasks should wait for their io-wq threads, so safe w/o sync */
		5732	ret = io_async_cancel_one(req->task->io_uring, sqe_addr, ctx);
		5733	spin_lock_irq(&ctx->completion_lock);
		5734	if (ret != -ENOENT)
		5735	goto done;
		5736	ret = io_timeout_cancel(ctx, sqe_addr);
		5737	if (ret != -ENOENT)
		5738	goto done;
		5739	ret = io_poll_cancel(ctx, sqe_addr);
		5740	if (ret != -ENOENT)
		5741	goto done;
		5742	spin_unlock_irq(&ctx->completion_lock);
		5743
		5744	/* slow path, try all io-wq's */
		5745	io_ring_submit_lock(ctx, !(issue_flags & IO_URING_F_NONBLOCK));
		5746	ret = -ENOENT;
		5747	list_for_each_entry(node, &ctx->tctx_list, ctx_node) {
		5748	struct io_uring_task *tctx = node->task->io_uring;
		5749
		5750	if (!tctx \|\| !tctx->io_wq)
		5751	continue;
		5752	ret = io_async_cancel_one(tctx, req->cancel.addr, ctx);
		5753	if (ret != -ENOENT)
		5754	break;
		5755	}
		5756	io_ring_submit_unlock(ctx, !(issue_flags & IO_URING_F_NONBLOCK));
		5757
		5758	spin_lock_irq(&ctx->completion_lock);
		5759	done:
		5760	io_cqring_fill_event(req, ret);
		5761	io_commit_cqring(ctx);
		5762	spin_unlock_irq(&ctx->completion_lock);
		5763	io_cqring_ev_posted(ctx);
		5764
		5765	if (ret < 0)
		5766	req_set_fail_links(req);
		5767	io_put_req(req);
5644	return 0;	5768	return 0;
5645	}	5769	}
5646		5770
@@ -5916,18 +6040,8 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags) · 269 unmodified lines
5916	const struct cred *creds = NULL;	6040	const struct cred *creds = NULL;
5917	int ret;	6041	int ret;
5918		6042
5919	if (req->work.personality) {	6043	if (req->work.creds && req->work.creds != current_cred())
5920	const struct cred *new_creds;	6044	creds = override_creds(req->work.creds);
5921
5922	if (!(issue_flags & IO_URING_F_NONBLOCK))
5923	mutex_lock(&ctx->uring_lock);
5924	new_creds = idr_find(&ctx->personality_idr, req->work.personality);
5925	if (!(issue_flags & IO_URING_F_NONBLOCK))
5926	mutex_unlock(&ctx->uring_lock);
5927	if (!new_creds)
5928	return -EINVAL;
5929	creds = override_creds(new_creds);
5930	}
5931		6045
5932	switch (req->opcode) {	6046	switch (req->opcode) {
5933	case IORING_OP_NOP:	6047	case IORING_OP_NOP:
@@ -6147,7 +6261,6 @@ static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer) · 213 unmodified lines
6147	spin_unlock_irqrestore(&ctx->completion_lock, flags);	6261	spin_unlock_irqrestore(&ctx->completion_lock, flags);
6148		6262
6149	if (prev) {	6263	if (prev) {
6150	req_set_fail_links(prev);
6151	io_async_find_and_cancel(ctx, req, prev->user_data, -ETIME);	6264	io_async_find_and_cancel(ctx, req, prev->user_data, -ETIME);
6152	io_put_req_deferred(prev, 1);	6265	io_put_req_deferred(prev, 1);
6153	} else {	6266	} else {
@@ -6291,7 +6404,7 @@ static int io_init_req(struct io_ring_ctx ctx, struct io_kiocb req, · 137 unmodified lines
6291	{	6404	{
6292	struct io_submit_state *state;	6405	struct io_submit_state *state;
6293	unsigned int sqe_flags;	6406	unsigned int sqe_flags;
6294	int ret = 0;	6407	int personality, ret = 0;
6295		6408
6296	req->opcode = READ_ONCE(sqe->opcode);	6409	req->opcode = READ_ONCE(sqe->opcode);
6297	/* same numerical values with corresponding REQ_F_, safe to copy /	6410	/* same numerical values with corresponding REQ_F_, safe to copy /
@@ -6306,6 +6419,9 @@ static int io_init_req(struct io_ring_ctx ctx, struct io_kiocb req, · 8 unmodified lines
6306	refcount_set(&req->refs, 2);	6419	refcount_set(&req->refs, 2);
6307	req->task = current;	6420	req->task = current;
6308	req->result = 0;	6421	req->result = 0;
		6422	req->work.list.next = NULL;
		6423	req->work.creds = NULL;
		6424	req->work.flags = 0;
6309		6425
6310	/* enforce forwards compatibility on users */	6426	/* enforce forwards compatibility on users */
6311	if (unlikely(sqe_flags & ~SQE_VALID_FLAGS)) {	6427	if (unlikely(sqe_flags & ~SQE_VALID_FLAGS)) {
@@ -6323,9 +6439,13 @@ static int io_init_req(struct io_ring_ctx ctx, struct io_kiocb req, · 11 unmodified lines
6323	!io_op_defs[req->opcode].buffer_select)	6439	!io_op_defs[req->opcode].buffer_select)
6324	return -EOPNOTSUPP;	6440	return -EOPNOTSUPP;
6325		6441
6326	req->work.list.next = NULL;	6442	personality = READ_ONCE(sqe->personality);
6327	req->work.flags = 0;	6443	if (personality) {
6328	req->work.personality = READ_ONCE(sqe->personality);	6444	req->work.creds = xa_load(&ctx->personalities, personality);
		6445	if (!req->work.creds)
		6446	return -EINVAL;
		6447	get_cred(req->work.creds);
		6448	}
6329	state = &ctx->submit_state;	6449	state = &ctx->submit_state;
6330		6450
6331	/*	6451	/*
@@ -6587,7 +6707,8 @@ static int __io_sq_thread(struct io_ring_ctx *ctx, bool cap_entries) · 255 unmodified lines
6587	if (!list_empty(&ctx->iopoll_list))	6707	if (!list_empty(&ctx->iopoll_list))
6588	io_do_iopoll(ctx, &nr_events, 0);	6708	io_do_iopoll(ctx, &nr_events, 0);
6589		6709
6590	if (to_submit && likely(!percpu_ref_is_dying(&ctx->refs)))	6710	if (to_submit && likely(!percpu_ref_is_dying(&ctx->refs)) &&
		6711	!(ctx->flags & IORING_SETUP_R_DISABLED))
6591	ret = io_submit_sqes(ctx, to_submit);	6712	ret = io_submit_sqes(ctx, to_submit);
6592	mutex_unlock(&ctx->uring_lock);	6713	mutex_unlock(&ctx->uring_lock);
6593	}	6714	}
@@ -6611,58 +6732,6 @@ static void io_sqd_update_thread_idle(struct io_sq_data *sqd) · 17 unmodified lines
6611	sqd->sq_thread_idle = sq_thread_idle;	6732	sqd->sq_thread_idle = sq_thread_idle;
6612	}	6733	}
6613		6734
6614	static void io_sqd_init_new(struct io_sq_data *sqd)
6615	{
6616	struct io_ring_ctx *ctx;
6617
6618	while (!list_empty(&sqd->ctx_new_list)) {
6619	ctx = list_first_entry(&sqd->ctx_new_list, struct io_ring_ctx, sqd_list);
6620	list_move_tail(&ctx->sqd_list, &sqd->ctx_list);
6621	complete(&ctx->sq_thread_comp);
6622	}
6623
6624	io_sqd_update_thread_idle(sqd);
6625	}
6626
6627	static bool io_sq_thread_should_stop(struct io_sq_data *sqd)
6628	{
6629	return test_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);
6630	}
6631
6632	static bool io_sq_thread_should_park(struct io_sq_data *sqd)
6633	{
6634	return test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
6635	}
6636
6637	static void io_sq_thread_parkme(struct io_sq_data *sqd)
6638	{
6639	for (;;) {
6640	/*
6641	* TASK_PARKED is a special state; we must serialize against
6642	* possible pending wakeups to avoid store-store collisions on
6643	* task->state.
6644	*
6645	* Such a collision might possibly result in the task state
6646	* changin from TASK_PARKED and us failing the
6647	* wait_task_inactive() in kthread_park().
6648	*/
6649	set_special_state(TASK_PARKED);
6650	if (!test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state))
6651	break;
6652
6653	/*
6654	* Thread is going to call schedule(), do not preempt it,
6655	* or the caller of kthread_park() may spend more time in
6656	* wait_task_inactive().
6657	*/
6658	preempt_disable();
6659	complete(&sqd->parked);
6660	schedule_preempt_disabled();
6661	preempt_enable();
6662	}
6663	__set_current_state(TASK_RUNNING);
6664	}
6665
6666	static int io_sq_thread(void *data)	6735	static int io_sq_thread(void *data)
6667	{	6736	{
6668	struct io_sq_data *sqd = data;	6737	struct io_sq_data *sqd = data;
@@ -6681,31 +6750,32 @@ static int io_sq_thread(void *data) · 12 unmodified lines
6681	set_cpus_allowed_ptr(current, cpu_online_mask);	6750	set_cpus_allowed_ptr(current, cpu_online_mask);
6682	current->flags \|= PF_NO_SETAFFINITY;	6751	current->flags \|= PF_NO_SETAFFINITY;
6683		6752
6684	wait_for_completion(&sqd->startup);	6753	mutex_lock(&sqd->lock);
6685		6754	while (!test_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state)) {
6686	while (!io_sq_thread_should_stop(sqd)) {
6687	int ret;	6755	int ret;
6688	bool cap_entries, sqt_spin, needs_sched;	6756	bool cap_entries, sqt_spin, needs_sched;
6689		6757
6690	/*	6758	if (test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state)) {
6691	* Any changes to the sqd lists are synchronized through the	6759	mutex_unlock(&sqd->lock);
6692	* thread parking. This synchronizes the thread vs users,	6760	cond_resched();
6693	* the users are synchronized on the sqd->ctx_lock.	6761	mutex_lock(&sqd->lock);
6694	*/	6762	io_run_task_work();
6695	if (io_sq_thread_should_park(sqd)) {	6763	io_run_task_work_head(&sqd->park_task_work);
6696	io_sq_thread_parkme(sqd);
6697	continue;
6698	}
6699	if (unlikely(!list_empty(&sqd->ctx_new_list))) {
6700	io_sqd_init_new(sqd);
6701	timeout = jiffies + sqd->sq_thread_idle;	6764	timeout = jiffies + sqd->sq_thread_idle;
		6765	continue;
6702	}	6766	}
6703	if (fatal_signal_pending(current))	6767	if (fatal_signal_pending(current))
6704	break;	6768	break;
6705	sqt_spin = false;	6769	sqt_spin = false;
6706	cap_entries = !list_is_singular(&sqd->ctx_list);	6770	cap_entries = !list_is_singular(&sqd->ctx_list);
6707	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {	6771	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {
		6772	const struct cred *creds = NULL;
		6773
		6774	if (ctx->sq_creds != current_cred())
		6775	creds = override_creds(ctx->sq_creds);
6708	ret = __io_sq_thread(ctx, cap_entries);	6776	ret = __io_sq_thread(ctx, cap_entries);
		6777	if (creds)
		6778	revert_creds(creds);
6709	if (!sqt_spin && (ret > 0 \|\| !list_empty(&ctx->iopoll_list)))	6779	if (!sqt_spin && (ret > 0 \|\| !list_empty(&ctx->iopoll_list)))
6710	sqt_spin = true;	6780	sqt_spin = true;
6711	}	6781	}
@@ -6732,45 +6802,33 @@ static int io_sq_thread(void *data) · 20 unmodified lines
6732	}	6802	}
6733	}	6803	}
6734		6804
6735	if (needs_sched && !io_sq_thread_should_park(sqd)) {	6805	if (needs_sched && !test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state)) {
6736	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)	6806	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6737	io_ring_set_wakeup_flag(ctx);	6807	io_ring_set_wakeup_flag(ctx);
6738		6808
		6809	mutex_unlock(&sqd->lock);
6739	schedule();	6810	schedule();
6740	try_to_freeze();	6811	try_to_freeze();
		6812	mutex_lock(&sqd->lock);
6741	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)	6813	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6742	io_ring_clear_wakeup_flag(ctx);	6814	io_ring_clear_wakeup_flag(ctx);
6743	}	6815	}
6744		6816
6745	finish_wait(&sqd->wait, &wait);	6817	finish_wait(&sqd->wait, &wait);
		6818	io_run_task_work_head(&sqd->park_task_work);
6746	timeout = jiffies + sqd->sq_thread_idle;	6819	timeout = jiffies + sqd->sq_thread_idle;
6747	}	6820	}
6748		6821
6749	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)	6822	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6750	io_uring_cancel_sqpoll(ctx);	6823	io_uring_cancel_sqpoll(ctx);
6751
6752	io_run_task_work();
6753
6754	/*
6755	* Ensure that we park properly if racing with someone trying to park
6756	* while we're exiting. If we fail to grab the lock, check park and
6757	* park if necessary. The ordering with the park bit and the lock
6758	* ensures that we catch this reliably.
6759	*/
6760	if (!mutex_trylock(&sqd->lock)) {
6761	if (io_sq_thread_should_park(sqd))
6762	io_sq_thread_parkme(sqd);
6763	mutex_lock(&sqd->lock);
6764	}
6765
6766	sqd->thread = NULL;	6824	sqd->thread = NULL;
6767	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {	6825	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6768	ctx->sqo_exec = 1;
6769	io_ring_set_wakeup_flag(ctx);	6826	io_ring_set_wakeup_flag(ctx);
6770	}	6827	mutex_unlock(&sqd->lock);
6771		6828
		6829	io_run_task_work();
		6830	io_run_task_work_head(&sqd->park_task_work);
6772	complete(&sqd->exited);	6831	complete(&sqd->exited);
6773	mutex_unlock(&sqd->lock);
6774	do_exit(0);	6832	do_exit(0);
6775	}	6833	}
6776		6834
@@ -7071,47 +7129,47 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx) · 294 unmodified lines
7071	static void io_sq_thread_unpark(struct io_sq_data *sqd)	7129	static void io_sq_thread_unpark(struct io_sq_data *sqd)
7072	__releases(&sqd->lock)	7130	__releases(&sqd->lock)
7073	{	7131	{
7074	if (sqd->thread == current)	7132	WARN_ON_ONCE(sqd->thread == current);
7075	return;	7133
		7134	/*
		7135	* Do the dance but not conditional clear_bit() because it'd race with
		7136	* other threads incrementing park_pending and setting the bit.
		7137	*/
7076	clear_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);	7138	clear_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
7077	if (sqd->thread)	7139	if (atomic_dec_return(&sqd->park_pending))
7078	wake_up_state(sqd->thread, TASK_PARKED);	7140	set_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
7079	mutex_unlock(&sqd->lock);	7141	mutex_unlock(&sqd->lock);
7080	}	7142	}
7081		7143
7082	static void io_sq_thread_park(struct io_sq_data *sqd)	7144	static void io_sq_thread_park(struct io_sq_data *sqd)
7083	__acquires(&sqd->lock)	7145	__acquires(&sqd->lock)
7084	{	7146	{
7085	if (sqd->thread == current)	7147	WARN_ON_ONCE(sqd->thread == current);
7086	return;	7148
		7149	atomic_inc(&sqd->park_pending);
7087	set_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);	7150	set_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
7088	mutex_lock(&sqd->lock);	7151	mutex_lock(&sqd->lock);
7089	if (sqd->thread) {	7152	if (sqd->thread)
7090	wake_up_process(sqd->thread);	7153	wake_up_process(sqd->thread);
7091	wait_for_completion(&sqd->parked);
7092	}
7093	}	7154	}
7094		7155
7095	static void io_sq_thread_stop(struct io_sq_data *sqd)	7156	static void io_sq_thread_stop(struct io_sq_data *sqd)
7096	{	7157	{
7097	if (test_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state))	7158	WARN_ON_ONCE(sqd->thread == current);
7098	return;	7159
7099	mutex_lock(&sqd->lock);	7160	mutex_lock(&sqd->lock);
7100	if (sqd->thread) {	7161	set_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);
7101	set_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);	7162	if (sqd->thread)
7102	WARN_ON_ONCE(test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state));
7103	wake_up_process(sqd->thread);	7163	wake_up_process(sqd->thread);
7104	mutex_unlock(&sqd->lock);	7164	mutex_unlock(&sqd->lock);
7105	wait_for_completion(&sqd->exited);	7165	wait_for_completion(&sqd->exited);
7106	WARN_ON_ONCE(sqd->thread);
7107	} else {
7108	mutex_unlock(&sqd->lock);
7109	}
7110	}	7166	}
7111		7167
7112	static void io_put_sq_data(struct io_sq_data *sqd)	7168	static void io_put_sq_data(struct io_sq_data *sqd)
7113	{	7169	{
7114	if (refcount_dec_and_test(&sqd->refs)) {	7170	if (refcount_dec_and_test(&sqd->refs)) {
		7171	WARN_ON_ONCE(atomic_read(&sqd->park_pending));
		7172
7115	io_sq_thread_stop(sqd);	7173	io_sq_thread_stop(sqd);
7116	kfree(sqd);	7174	kfree(sqd);
7117	}	7175	}
@@ -7122,22 +7180,15 @@ static void io_sq_thread_finish(struct io_ring_ctx *ctx) · 4 unmodified lines
7122	struct io_sq_data *sqd = ctx->sq_data;	7180	struct io_sq_data *sqd = ctx->sq_data;
7123		7181
7124	if (sqd) {	7182	if (sqd) {
7125	complete(&sqd->startup);	7183	io_sq_thread_park(sqd);
7126	if (sqd->thread) {	7184	list_del_init(&ctx->sqd_list);
7127	wait_for_completion(&ctx->sq_thread_comp);
7128	io_sq_thread_park(sqd);
7129	}
7130
7131	mutex_lock(&sqd->ctx_lock);
7132	list_del(&ctx->sqd_list);
7133	io_sqd_update_thread_idle(sqd);	7185	io_sqd_update_thread_idle(sqd);
7134	mutex_unlock(&sqd->ctx_lock);	7186	io_sq_thread_unpark(sqd);
7135
7136	if (sqd->thread)
7137	io_sq_thread_unpark(sqd);
7138		7187
7139	io_put_sq_data(sqd);	7188	io_put_sq_data(sqd);
7140	ctx->sq_data = NULL;	7189	ctx->sq_data = NULL;
		7190	if (ctx->sq_creds)
		7191	put_cred(ctx->sq_creds);
7141	}	7192	}
7142	}	7193	}
7143		7194
@@ -7161,31 +7212,42 @@ static struct io_sq_data io_attach_sq_data(struct io_uring_params p) · 17 unmodified lines
7161	fdput(f);	7212	fdput(f);
7162	return ERR_PTR(-EINVAL);	7213	return ERR_PTR(-EINVAL);
7163	}	7214	}
		7215	if (sqd->task_tgid != current->tgid) {
		7216	fdput(f);
		7217	return ERR_PTR(-EPERM);
		7218	}
7164		7219
7165	refcount_inc(&sqd->refs);	7220	refcount_inc(&sqd->refs);
7166	fdput(f);	7221	fdput(f);
7167	return sqd;	7222	return sqd;
7168	}	7223	}
7169		7224
7170	static struct io_sq_data io_get_sq_data(struct io_uring_params p)	7225	static struct io_sq_data io_get_sq_data(struct io_uring_params p,
		7226	bool *attached)
7171	{	7227	{
7172	struct io_sq_data *sqd;	7228	struct io_sq_data *sqd;
7173		7229
7174	if (p->flags & IORING_SETUP_ATTACH_WQ)	7230	*attached = false;
7175	return io_attach_sq_data(p);	7231	if (p->flags & IORING_SETUP_ATTACH_WQ) {
		7232	sqd = io_attach_sq_data(p);
		7233	if (!IS_ERR(sqd)) {
		7234	*attached = true;
		7235	return sqd;
		7236	}
		7237	/* fall through for EPERM case, setup new sqd/task */
		7238	if (PTR_ERR(sqd) != -EPERM)
		7239	return sqd;
		7240	}
7176		7241
7177	sqd = kzalloc(sizeof(*sqd), GFP_KERNEL);	7242	sqd = kzalloc(sizeof(*sqd), GFP_KERNEL);
7178	if (!sqd)	7243	if (!sqd)
7179	return ERR_PTR(-ENOMEM);	7244	return ERR_PTR(-ENOMEM);
7180		7245
		7246	atomic_set(&sqd->park_pending, 0);
7181	refcount_set(&sqd->refs, 1);	7247	refcount_set(&sqd->refs, 1);
7182	INIT_LIST_HEAD(&sqd->ctx_list);	7248	INIT_LIST_HEAD(&sqd->ctx_list);
7183	INIT_LIST_HEAD(&sqd->ctx_new_list);
7184	mutex_init(&sqd->ctx_lock);
7185	mutex_init(&sqd->lock);	7249	mutex_init(&sqd->lock);
7186	init_waitqueue_head(&sqd->wait);	7250	init_waitqueue_head(&sqd->wait);
7187	init_completion(&sqd->startup);
7188	init_completion(&sqd->parked);
7189	init_completion(&sqd->exited);	7251	init_completion(&sqd->exited);
7190	return sqd;	7252	return sqd;
7191	}	7253	}
@@ -7802,7 +7864,6 @@ static int io_uring_alloc_task_context(struct task_struct *task, · 610 unmodified lines
7802	init_waitqueue_head(&tctx->wait);	7864	init_waitqueue_head(&tctx->wait);
7803	tctx->last = NULL;	7865	tctx->last = NULL;
7804	atomic_set(&tctx->in_idle, 0);	7866	atomic_set(&tctx->in_idle, 0);
7805	tctx->sqpoll = false;
7806	task->io_uring = tctx;	7867	task->io_uring = tctx;
7807	spin_lock_init(&tctx->task_lock);	7868	spin_lock_init(&tctx->task_lock);
7808	INIT_WQ_LIST(&tctx->task_list);	7869	INIT_WQ_LIST(&tctx->task_list);
@@ -7823,26 +7884,6 @@ void __io_uring_free(struct task_struct *tsk) · 14 unmodified lines
7823	tsk->io_uring = NULL;	7884	tsk->io_uring = NULL;
7824	}	7885	}
7825		7886
7826	static int io_sq_thread_fork(struct io_sq_data sqd, struct io_ring_ctx ctx)
7827	{
7828	struct task_struct *tsk;
7829	int ret;
7830
7831	clear_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);
7832	reinit_completion(&sqd->parked);
7833	ctx->sqo_exec = 0;
7834	sqd->task_pid = current->pid;
7835	tsk = create_io_thread(io_sq_thread, sqd, NUMA_NO_NODE);
7836	if (IS_ERR(tsk))
7837	return PTR_ERR(tsk);
7838	ret = io_uring_alloc_task_context(tsk, ctx);
7839	if (ret)
7840	set_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);
7841	sqd->thread = tsk;
7842	wake_up_new_task(tsk);
7843	return ret;
7844	}
7845
7846	static int io_sq_offload_create(struct io_ring_ctx *ctx,	7887	static int io_sq_offload_create(struct io_ring_ctx *ctx,
7847	struct io_uring_params *p)	7888	struct io_uring_params *p)
7848	{	7889	{
@@ -7865,29 +7906,36 @@ static int io_sq_offload_create(struct io_ring_ctx *ctx, · 16 unmodified lines
7865	if (ctx->flags & IORING_SETUP_SQPOLL) {	7906	if (ctx->flags & IORING_SETUP_SQPOLL) {
7866	struct task_struct *tsk;	7907	struct task_struct *tsk;
7867	struct io_sq_data *sqd;	7908	struct io_sq_data *sqd;
		7909	bool attached;
7868		7910
7869	ret = -EPERM;	7911	ret = -EPERM;
7870	if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_NICE))	7912	if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_NICE))
7871	goto err;	7913	goto err;
7872		7914
7873	sqd = io_get_sq_data(p);	7915	sqd = io_get_sq_data(p, &attached);
7874	if (IS_ERR(sqd)) {	7916	if (IS_ERR(sqd)) {
7875	ret = PTR_ERR(sqd);	7917	ret = PTR_ERR(sqd);
7876	goto err;	7918	goto err;
7877	}	7919	}
7878		7920
		7921	ctx->sq_creds = get_current_cred();
7879	ctx->sq_data = sqd;	7922	ctx->sq_data = sqd;
7880	io_sq_thread_park(sqd);
7881	mutex_lock(&sqd->ctx_lock);
7882	list_add(&ctx->sqd_list, &sqd->ctx_new_list);
7883	mutex_unlock(&sqd->ctx_lock);
7884	io_sq_thread_unpark(sqd);
7885
7886	ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);	7923	ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
7887	if (!ctx->sq_thread_idle)	7924	if (!ctx->sq_thread_idle)
7888	ctx->sq_thread_idle = HZ;	7925	ctx->sq_thread_idle = HZ;
7889		7926
7890	if (sqd->thread)	7927	ret = 0;
		7928	io_sq_thread_park(sqd);
		7929	list_add(&ctx->sqd_list, &sqd->ctx_list);
		7930	io_sqd_update_thread_idle(sqd);
		7931	/* don't attach to a dying SQPOLL thread, would be racy */
		7932	if (attached && !sqd->thread)
		7933	ret = -ENXIO;
		7934	io_sq_thread_unpark(sqd);
		7935
		7936	if (ret < 0)
		7937	goto err;
		7938	if (attached)
7891	return 0;	7939	return 0;
7892		7940
7893	if (p->flags & IORING_SETUP_SQ_AFF) {	7941	if (p->flags & IORING_SETUP_SQ_AFF) {
@@ -7895,9 +7943,9 @@ static int io_sq_offload_create(struct io_ring_ctx *ctx, · 1 unmodified line
7895		7943
7896	ret = -EINVAL;	7944	ret = -EINVAL;
7897	if (cpu >= nr_cpu_ids)	7945	if (cpu >= nr_cpu_ids)
7898	goto err;	7946	goto err_sqpoll;
7899	if (!cpu_online(cpu))	7947	if (!cpu_online(cpu))
7900	goto err;	7948	goto err_sqpoll;
7901		7949
7902	sqd->sq_cpu = cpu;	7950	sqd->sq_cpu = cpu;
7903	} else {	7951	} else {
@@ -7905,15 +7953,15 @@ static int io_sq_offload_create(struct io_ring_ctx *ctx, · 1 unmodified line
7905	}	7953	}
7906		7954
7907	sqd->task_pid = current->pid;	7955	sqd->task_pid = current->pid;
		7956	sqd->task_tgid = current->tgid;
7908	tsk = create_io_thread(io_sq_thread, sqd, NUMA_NO_NODE);	7957	tsk = create_io_thread(io_sq_thread, sqd, NUMA_NO_NODE);
7909	if (IS_ERR(tsk)) {	7958	if (IS_ERR(tsk)) {
7910	ret = PTR_ERR(tsk);	7959	ret = PTR_ERR(tsk);
7911	goto err;	7960	goto err_sqpoll;
7912	}	7961	}
7913	ret = io_uring_alloc_task_context(tsk, ctx);	7962
7914	if (ret)
7915	set_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);
7916	sqd->thread = tsk;	7963	sqd->thread = tsk;
		7964	ret = io_uring_alloc_task_context(tsk, ctx);
7917	wake_up_new_task(tsk);	7965	wake_up_new_task(tsk);
7918	if (ret)	7966	if (ret)
7919	goto err;	7967	goto err;
@@ -7927,15 +7975,9 @@ static int io_sq_offload_create(struct io_ring_ctx *ctx, · 7 unmodified lines
7927	err:	7975	err:
7928	io_sq_thread_finish(ctx);	7976	io_sq_thread_finish(ctx);
7929	return ret;	7977	return ret;
7930	}	7978	err_sqpoll:
7931		7979	complete(&ctx->sq_data->exited);
7932	static void io_sq_offload_start(struct io_ring_ctx *ctx)	7980	goto err;
7933	{
7934	struct io_sq_data *sqd = ctx->sq_data;
7935
7936	ctx->flags &= ~IORING_SETUP_R_DISABLED;
7937	if (ctx->flags & IORING_SETUP_SQPOLL)
7938	complete(&sqd->startup);
7939	}	7981	}
7940		7982
7941	static inline void __io_unaccount_mem(struct user_struct *user,	7983	static inline void __io_unaccount_mem(struct user_struct *user,
@@ -8345,19 +8387,13 @@ static int io_eventfd_unregister(struct io_ring_ctx *ctx) · 403 unmodified lines
8345	return -ENXIO;	8387	return -ENXIO;
8346	}	8388	}
8347		8389
8348	static int __io_destroy_buffers(int id, void p, void data)
8349	{
8350	struct io_ring_ctx *ctx = data;
8351	struct io_buffer *buf = p;
8352
8353	__io_remove_buffers(ctx, buf, id, -1U);
8354	return 0;
8355	}
8356
8357	static void io_destroy_buffers(struct io_ring_ctx *ctx)	8390	static void io_destroy_buffers(struct io_ring_ctx *ctx)
8358	{	8391	{
8359	idr_for_each(&ctx->io_buffer_idr, __io_destroy_buffers, ctx);	8392	struct io_buffer *buf;
8360	idr_destroy(&ctx->io_buffer_idr);	8393	unsigned long index;
		8394
		8395	xa_for_each(&ctx->io_buffers, index, buf)
		8396	__io_remove_buffers(ctx, buf, index, -1U);
8361	}	8397	}
8362		8398
8363	static void io_req_cache_free(struct list_head list, struct task_struct tsk)	8399	static void io_req_cache_free(struct list_head list, struct task_struct tsk)
@@ -8399,11 +8435,13 @@ static void io_ring_ctx_free(struct io_ring_ctx *ctx) · 35 unmodified lines
8399	{	8435	{
8400	/*	8436	/*
8401	* Some may use context even when all refs and requests have been put,	8437	* Some may use context even when all refs and requests have been put,
8402	* and they are free to do so while still holding uring_lock, see	8438	* and they are free to do so while still holding uring_lock or
8403	* __io_req_task_submit(). Wait for them to finish.	8439	* completion_lock, see __io_req_task_submit(). Wait for them to finish.
8404	*/	8440	*/
8405	mutex_lock(&ctx->uring_lock);	8441	mutex_lock(&ctx->uring_lock);
8406	mutex_unlock(&ctx->uring_lock);	8442	mutex_unlock(&ctx->uring_lock);
		8443	spin_lock_irq(&ctx->completion_lock);
		8444	spin_unlock_irq(&ctx->completion_lock);
8407		8445
8408	io_sq_thread_finish(ctx);	8446	io_sq_thread_finish(ctx);
8409	io_sqe_buffers_unregister(ctx);	8447	io_sqe_buffers_unregister(ctx);
@@ -8418,7 +8456,6 @@ static void io_ring_ctx_free(struct io_ring_ctx *ctx) · 8 unmodified lines
8418	mutex_unlock(&ctx->uring_lock);	8456	mutex_unlock(&ctx->uring_lock);
8419	io_eventfd_unregister(ctx);	8457	io_eventfd_unregister(ctx);
8420	io_destroy_buffers(ctx);	8458	io_destroy_buffers(ctx);
8421	idr_destroy(&ctx->personality_idr);
8422		8459
8423	#if defined(CONFIG_UNIX)	8460	#if defined(CONFIG_UNIX)
8424	if (ctx->ring_sock) {	8461	if (ctx->ring_sock) {
@@ -8483,7 +8520,7 @@ static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id) · 58 unmodified lines
8483	{	8520	{
8484	const struct cred *creds;	8521	const struct cred *creds;
8485		8522
8486	creds = idr_remove(&ctx->personality_idr, id);	8523	creds = xa_erase(&ctx->personalities, id);
8487	if (creds) {	8524	if (creds) {
8488	put_cred(creds);	8525	put_cred(creds);
8489	return 0;	8526	return 0;
@@ -8492,40 +8529,39 @@ static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id) · 2 unmodified lines
8492	return -EINVAL;	8529	return -EINVAL;
8493	}	8530	}
8494		8531
8495	static int io_remove_personalities(int id, void p, void data)	8532	static inline bool io_run_ctx_fallback(struct io_ring_ctx *ctx)
8496	{	8533	{
8497	struct io_ring_ctx *ctx = data;	8534	return io_run_task_work_head(&ctx->exit_task_work);
8498
8499	io_unregister_personality(ctx, id);
8500	return 0;
8501	}	8535	}
8502		8536
8503	static bool io_run_ctx_fallback(struct io_ring_ctx *ctx)	8537	struct io_tctx_exit {
8504	{	8538	struct callback_head task_work;
8505	struct callback_head work, next;	8539	struct completion completion;
8506	bool executed = false;	8540	struct io_ring_ctx *ctx;
8507		8541	};
8508	do {
8509	work = xchg(&ctx->exit_task_work, NULL);
8510	if (!work)
8511	break;
8512		8542
8513	do {	8543	static void io_tctx_exit_cb(struct callback_head *cb)
8514	next = work->next;	8544	{
8515	work->func(work);	8545	struct io_uring_task *tctx = current->io_uring;
8516	work = next;	8546	struct io_tctx_exit *work;
8517	cond_resched();
8518	} while (work);
8519	executed = true;
8520	} while (1);
8521		8547
8522	return executed;	8548	work = container_of(cb, struct io_tctx_exit, task_work);
		8549	/*
		8550	* When @in_idle, we're in cancellation and it's racy to remove the
		8551	* node. It'll be removed by the end of cancellation, just ignore it.
		8552	*/
		8553	if (!atomic_read(&tctx->in_idle))
		8554	io_uring_del_task_file((unsigned long)work->ctx);
		8555	complete(&work->completion);
8523	}	8556	}
8524		8557
8525	static void io_ring_exit_work(struct work_struct *work)	8558	static void io_ring_exit_work(struct work_struct *work)
8526	{	8559	{
8527	struct io_ring_ctx *ctx = container_of(work, struct io_ring_ctx,	8560	struct io_ring_ctx *ctx = container_of(work, struct io_ring_ctx, exit_work);
8528	exit_work);	8561	unsigned long timeout = jiffies + HZ * 60 * 5;
		8562	struct io_tctx_exit exit;
		8563	struct io_tctx_node *node;
		8564	int ret;
8529		8565
8530	/*	8566	/*
8531	* If we're doing polled IO and end up having requests being	8567	* If we're doing polled IO and end up having requests being
@@ -8535,21 +8571,57 @@ static void io_ring_exit_work(struct work_struct *work) · 3 unmodified lines
8535	*/	8571	*/
8536	do {	8572	do {
8537	io_uring_try_cancel_requests(ctx, NULL, NULL);	8573	io_uring_try_cancel_requests(ctx, NULL, NULL);
		8574
		8575	WARN_ON_ONCE(time_after(jiffies, timeout));
8538	} while (!wait_for_completion_timeout(&ctx->ref_comp, HZ/20));	8576	} while (!wait_for_completion_timeout(&ctx->ref_comp, HZ/20));
		8577
		8578	mutex_lock(&ctx->uring_lock);
		8579	while (!list_empty(&ctx->tctx_list)) {
		8580	WARN_ON_ONCE(time_after(jiffies, timeout));
		8581
		8582	node = list_first_entry(&ctx->tctx_list, struct io_tctx_node,
		8583	ctx_node);
		8584	exit.ctx = ctx;
		8585	init_completion(&exit.completion);
		8586	init_task_work(&exit.task_work, io_tctx_exit_cb);
		8587	ret = task_work_add(node->task, &exit.task_work, TWA_SIGNAL);
		8588	if (WARN_ON_ONCE(ret))
		8589	continue;
		8590	wake_up_process(node->task);
		8591
		8592	mutex_unlock(&ctx->uring_lock);
		8593	wait_for_completion(&exit.completion);
		8594	cond_resched();
		8595	mutex_lock(&ctx->uring_lock);
		8596	}
		8597	mutex_unlock(&ctx->uring_lock);
		8598
8539	io_ring_ctx_free(ctx);	8599	io_ring_ctx_free(ctx);
8540	}	8600	}
8541		8601
8542	static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)	8602	static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
8543	{	8603	{
		8604	unsigned long index;
		8605	struct creds *creds;
		8606
8544	mutex_lock(&ctx->uring_lock);	8607	mutex_lock(&ctx->uring_lock);
8545	percpu_ref_kill(&ctx->refs);	8608	percpu_ref_kill(&ctx->refs);
8546	/* if force is set, the ring is going away. always drop after that */	8609	/* if force is set, the ring is going away. always drop after that */
8547	ctx->cq_overflow_flushed = 1;	8610	ctx->cq_overflow_flushed = 1;
8548	if (ctx->rings)	8611	if (ctx->rings)
8549	__io_cqring_overflow_flush(ctx, true, NULL, NULL);	8612	__io_cqring_overflow_flush(ctx, true, NULL, NULL);
8550	idr_for_each(&ctx->personality_idr, io_remove_personalities, ctx);	8613	xa_for_each(&ctx->personalities, index, creds)
		8614	io_unregister_personality(ctx, index);
8551	mutex_unlock(&ctx->uring_lock);	8615	mutex_unlock(&ctx->uring_lock);
8552		8616
		8617	/* prevent SQPOLL from submitting new requests */
		8618	if (ctx->sq_data) {
		8619	io_sq_thread_park(ctx->sq_data);
		8620	list_del_init(&ctx->sqd_list);
		8621	io_sqd_update_thread_idle(ctx->sq_data);
		8622	io_sq_thread_unpark(ctx->sq_data);
		8623	}
		8624
8553	io_kill_timeouts(ctx, NULL, NULL);	8625	io_kill_timeouts(ctx, NULL, NULL);
8554	io_poll_remove_all(ctx, NULL, NULL);	8626	io_poll_remove_all(ctx, NULL, NULL);
8555		8627
@@ -8600,11 +8672,11 @@ static bool io_cancel_task_cb(struct io_wq_work work, void data) · 44 unmodified lines
8600	return ret;	8672	return ret;
8601	}	8673	}
8602		8674
8603	static void io_cancel_defer_files(struct io_ring_ctx *ctx,	8675	static bool io_cancel_defer_files(struct io_ring_ctx *ctx,
8604	struct task_struct *task,	8676	struct task_struct *task,
8605	struct files_struct *files)	8677	struct files_struct *files)
8606	{	8678	{
8607	struct io_defer_entry *de = NULL;	8679	struct io_defer_entry *de;
8608	LIST_HEAD(list);	8680	LIST_HEAD(list);
8609		8681
8610	spin_lock_irq(&ctx->completion_lock);	8682	spin_lock_irq(&ctx->completion_lock);
@@ -8615,6 +8687,8 @@ static void io_cancel_defer_files(struct io_ring_ctx *ctx, · 4 unmodified lines
8615	}	8687	}
8616	}	8688	}
8617	spin_unlock_irq(&ctx->completion_lock);	8689	spin_unlock_irq(&ctx->completion_lock);
		8690	if (list_empty(&list))
		8691	return false;
8618		8692
8619	while (!list_empty(&list)) {	8693	while (!list_empty(&list)) {
8620	de = list_first_entry(&list, struct io_defer_entry, list);	8694	de = list_first_entry(&list, struct io_defer_entry, list);
@@ -8624,6 +8698,38 @@ static void io_cancel_defer_files(struct io_ring_ctx *ctx, · 3 unmodified lines
8624	io_req_complete(de->req, -ECANCELED);	8698	io_req_complete(de->req, -ECANCELED);
8625	kfree(de);	8699	kfree(de);
8626	}	8700	}
		8701	return true;
		8702	}
		8703
		8704	static bool io_cancel_ctx_cb(struct io_wq_work work, void data)
		8705	{
		8706	struct io_kiocb *req = container_of(work, struct io_kiocb, work);
		8707
		8708	return req->ctx == data;
		8709	}
		8710
		8711	static bool io_uring_try_cancel_iowq(struct io_ring_ctx *ctx)
		8712	{
		8713	struct io_tctx_node *node;
		8714	enum io_wq_cancel cret;
		8715	bool ret = false;
		8716
		8717	mutex_lock(&ctx->uring_lock);
		8718	list_for_each_entry(node, &ctx->tctx_list, ctx_node) {
		8719	struct io_uring_task *tctx = node->task->io_uring;
		8720
		8721	/*
		8722	* io_wq will stay alive while we hold uring_lock, because it's
		8723	* killed after ctx nodes, which requires to take the lock.
		8724	*/
		8725	if (!tctx \|\| !tctx->io_wq)
		8726	continue;
		8727	cret = io_wq_cancel_cb(tctx->io_wq, io_cancel_ctx_cb, ctx, true);
		8728	ret \|= (cret != IO_WQ_CANCEL_NOTFOUND);
		8729	}
		8730	mutex_unlock(&ctx->uring_lock);
		8731
		8732	return ret;
8627	}	8733	}
8628		8734
8629	static void io_uring_try_cancel_requests(struct io_ring_ctx *ctx,	8735	static void io_uring_try_cancel_requests(struct io_ring_ctx *ctx,
@@ -8631,27 +8737,34 @@ static void io_uring_try_cancel_requests(struct io_ring_ctx *ctx, · 1 unmodified line
8631	struct files_struct *files)	8737	struct files_struct *files)
8632	{	8738	{
8633	struct io_task_cancel cancel = { .task = task, .files = files, };	8739	struct io_task_cancel cancel = { .task = task, .files = files, };
8634	struct task_struct *tctx_task = task ?: current;	8740	struct io_uring_task *tctx = task ? task->io_uring : NULL;
8635	struct io_uring_task *tctx = tctx_task->io_uring;
8636		8741
8637	while (1) {	8742	while (1) {
8638	enum io_wq_cancel cret;	8743	enum io_wq_cancel cret;
8639	bool ret = false;	8744	bool ret = false;
8640		8745
8641	if (tctx && tctx->io_wq) {	8746	if (!task) {
		8747	ret \|= io_uring_try_cancel_iowq(ctx);
		8748	} else if (tctx && tctx->io_wq) {
		8749	/*
		8750	* Cancels requests of all rings, not only @ctx, but
		8751	* it's fine as the task is in exit/exec.
		8752	*/
8642	cret = io_wq_cancel_cb(tctx->io_wq, io_cancel_task_cb,	8753	cret = io_wq_cancel_cb(tctx->io_wq, io_cancel_task_cb,
8643	&cancel, true);	8754	&cancel, true);
8644	ret \|= (cret != IO_WQ_CANCEL_NOTFOUND);	8755	ret \|= (cret != IO_WQ_CANCEL_NOTFOUND);
8645	}	8756	}
8646		8757
8647	/* SQPOLL thread does its own polling */	8758	/* SQPOLL thread does its own polling */
8648	if (!(ctx->flags & IORING_SETUP_SQPOLL) && !files) {	8759	if ((!(ctx->flags & IORING_SETUP_SQPOLL) && !files) \|\|
		8760	(ctx->sq_data && ctx->sq_data->thread == current)) {
8649	while (!list_empty_careful(&ctx->iopoll_list)) {	8761	while (!list_empty_careful(&ctx->iopoll_list)) {
8650	io_iopoll_try_reap_events(ctx);	8762	io_iopoll_try_reap_events(ctx);
8651	ret = true;	8763	ret = true;
8652	}	8764	}
8653	}	8765	}
8654		8766
		8767	ret \|= io_cancel_defer_files(ctx, task, files);
8655	ret \|= io_poll_remove_all(ctx, task, files);	8768	ret \|= io_poll_remove_all(ctx, task, files);
8656	ret \|= io_kill_timeouts(ctx, task, files);	8769	ret \|= io_kill_timeouts(ctx, task, files);
8657	ret \|= io_run_task_work();	8770	ret \|= io_run_task_work();
@@ -8691,58 +8804,21 @@ static void io_uring_cancel_files(struct io_ring_ctx *ctx, · 33 unmodified lines
8691		8804
8692	io_uring_try_cancel_requests(ctx, task, files);	8805	io_uring_try_cancel_requests(ctx, task, files);
8693		8806
8694	if (ctx->sq_data)
8695	io_sq_thread_unpark(ctx->sq_data);
8696	prepare_to_wait(&task->io_uring->wait, &wait,	8807	prepare_to_wait(&task->io_uring->wait, &wait,
8697	TASK_UNINTERRUPTIBLE);	8808	TASK_UNINTERRUPTIBLE);
8698	if (inflight == io_uring_count_inflight(ctx, task, files))	8809	if (inflight == io_uring_count_inflight(ctx, task, files))
8699	schedule();	8810	schedule();
8700	finish_wait(&task->io_uring->wait, &wait);	8811	finish_wait(&task->io_uring->wait, &wait);
8701	if (ctx->sq_data)
8702	io_sq_thread_park(ctx->sq_data);
8703	}
8704	}
8705
8706	/*
8707	* We need to iteratively cancel requests, in case a request has dependent
8708	* hard links. These persist even for failure of cancelations, hence keep
8709	* looping until none are found.
8710	*/
8711	static void io_uring_cancel_task_requests(struct io_ring_ctx *ctx,
8712	struct files_struct *files)
8713	{
8714	struct task_struct *task = current;
8715
8716	if ((ctx->flags & IORING_SETUP_SQPOLL) && ctx->sq_data) {
8717	/* never started, nothing to cancel */
8718	if (ctx->flags & IORING_SETUP_R_DISABLED) {
8719	io_sq_offload_start(ctx);
8720	return;
8721	}
8722	io_sq_thread_park(ctx->sq_data);
8723	task = ctx->sq_data->thread;
8724	if (task)
8725	atomic_inc(&task->io_uring->in_idle);
8726	}	8812	}
8727
8728	io_cancel_defer_files(ctx, task, files);
8729
8730	io_uring_cancel_files(ctx, task, files);
8731	if (!files)
8732	io_uring_try_cancel_requests(ctx, task, NULL);
8733
8734	if (task)
8735	atomic_dec(&task->io_uring->in_idle);
8736	if (ctx->sq_data)
8737	io_sq_thread_unpark(ctx->sq_data);
8738	}	8813	}
8739		8814
8740	/*	8815	/*
8741	* Note that this task has used io_uring. We use it for cancelation purposes.	8816	* Note that this task has used io_uring. We use it for cancelation purposes.
8742	*/	8817	*/
8743	static int io_uring_add_task_file(struct io_ring_ctx ctx, struct file file)	8818	static int io_uring_add_task_file(struct io_ring_ctx *ctx)
8744	{	8819	{
8745	struct io_uring_task *tctx = current->io_uring;	8820	struct io_uring_task *tctx = current->io_uring;
		8821	struct io_tctx_node *node;
8746	int ret;	8822	int ret;
8747		8823
8748	if (unlikely(!tctx)) {	8824	if (unlikely(!tctx)) {
@@ -8751,102 +8827,151 @@ static int io_uring_add_task_file(struct io_ring_ctx ctx, struct file file) · 2 unmodified lines
8751	return ret;	8827	return ret;
8752	tctx = current->io_uring;	8828	tctx = current->io_uring;
8753	}	8829	}
8754	if (tctx->last != file) {	8830	if (tctx->last != ctx) {
8755	void *old = xa_load(&tctx->xa, (unsigned long)file);	8831	void *old = xa_load(&tctx->xa, (unsigned long)ctx);
8756		8832
8757	if (!old) {	8833	if (!old) {
8758	get_file(file);	8834	node = kmalloc(sizeof(*node), GFP_KERNEL);
8759	ret = xa_err(xa_store(&tctx->xa, (unsigned long)file,	8835	if (!node)
8760	file, GFP_KERNEL));	8836	return -ENOMEM;
		8837	node->ctx = ctx;
		8838	node->task = current;
		8839
		8840	ret = xa_err(xa_store(&tctx->xa, (unsigned long)ctx,
		8841	node, GFP_KERNEL));
8761	if (ret) {	8842	if (ret) {
8762	fput(file);	8843	kfree(node);
8763	return ret;	8844	return ret;
8764	}	8845	}
		8846
		8847	mutex_lock(&ctx->uring_lock);
		8848	list_add(&node->ctx_node, &ctx->tctx_list);
		8849	mutex_unlock(&ctx->uring_lock);
8765	}	8850	}
8766	tctx->last = file;	8851	tctx->last = ctx;
8767	}	8852	}
8768
8769	/*
8770	* This is race safe in that the task itself is doing this, hence it
8771	* cannot be going through the exit/cancel paths at the same time.
8772	* This cannot be modified while exit/cancel is running.
8773	*/
8774	if (!tctx->sqpoll && (ctx->flags & IORING_SETUP_SQPOLL))
8775	tctx->sqpoll = true;
8776
8777	return 0;	8853	return 0;
8778	}	8854	}
8779		8855
8780	/*	8856	/*
8781	* Remove this io_uring_file -> task mapping.	8857	* Remove this io_uring_file -> task mapping.
8782	*/	8858	*/
8783	static void io_uring_del_task_file(struct file *file)	8859	static void io_uring_del_task_file(unsigned long index)
8784	{	8860	{
8785	struct io_uring_task *tctx = current->io_uring;	8861	struct io_uring_task *tctx = current->io_uring;
		8862	struct io_tctx_node *node;
		8863
		8864	if (!tctx)
		8865	return;
		8866	node = xa_erase(&tctx->xa, index);
		8867	if (!node)
		8868	return;
		8869
		8870	WARN_ON_ONCE(current != node->task);
		8871	WARN_ON_ONCE(list_empty(&node->ctx_node));
		8872
		8873	mutex_lock(&node->ctx->uring_lock);
		8874	list_del(&node->ctx_node);
		8875	mutex_unlock(&node->ctx->uring_lock);
8786		8876
8787	if (tctx->last == file)	8877	if (tctx->last == node->ctx)
8788	tctx->last = NULL;	8878	tctx->last = NULL;
8789	file = xa_erase(&tctx->xa, (unsigned long)file);	8879	kfree(node);
8790	if (file)
8791	fput(file);
8792	}	8880	}
8793		8881
8794	static void io_uring_clean_tctx(struct io_uring_task *tctx)	8882	static void io_uring_clean_tctx(struct io_uring_task *tctx)
8795	{	8883	{
8796	struct file *file;	8884	struct io_tctx_node *node;
8797	unsigned long index;	8885	unsigned long index;
8798		8886
8799	xa_for_each(&tctx->xa, index, file)	8887	xa_for_each(&tctx->xa, index, node)
8800	io_uring_del_task_file(file);	8888	io_uring_del_task_file(index);
8801	if (tctx->io_wq) {	8889	if (tctx->io_wq) {
8802	io_wq_put_and_exit(tctx->io_wq);	8890	io_wq_put_and_exit(tctx->io_wq);
8803	tctx->io_wq = NULL;	8891	tctx->io_wq = NULL;
8804	}	8892	}
8805	}	8893	}
8806		8894
		8895	static s64 tctx_inflight(struct io_uring_task *tctx)
		8896	{
		8897	return percpu_counter_sum(&tctx->inflight);
		8898	}
		8899
		8900	static void io_sqpoll_cancel_cb(struct callback_head *cb)
		8901	{
		8902	struct io_tctx_exit *work = container_of(cb, struct io_tctx_exit, task_work);
		8903	struct io_ring_ctx *ctx = work->ctx;
		8904	struct io_sq_data *sqd = ctx->sq_data;
		8905
		8906	if (sqd->thread)
		8907	io_uring_cancel_sqpoll(ctx);
		8908	complete(&work->completion);
		8909	}
		8910
		8911	static void io_sqpoll_cancel_sync(struct io_ring_ctx *ctx)
		8912	{
		8913	struct io_sq_data *sqd = ctx->sq_data;
		8914	struct io_tctx_exit work = { .ctx = ctx, };
		8915	struct task_struct *task;
		8916
		8917	io_sq_thread_park(sqd);
		8918	list_del_init(&ctx->sqd_list);
		8919	io_sqd_update_thread_idle(sqd);
		8920	task = sqd->thread;
		8921	if (task) {
		8922	init_completion(&work.completion);
		8923	init_task_work(&work.task_work, io_sqpoll_cancel_cb);
		8924	io_task_work_add_head(&sqd->park_task_work, &work.task_work);
		8925	wake_up_process(task);
		8926	}
		8927	io_sq_thread_unpark(sqd);
		8928
		8929	if (task)
		8930	wait_for_completion(&work.completion);
		8931	}
		8932
8807	void __io_uring_files_cancel(struct files_struct *files)	8933	void __io_uring_files_cancel(struct files_struct *files)
8808	{	8934	{
8809	struct io_uring_task *tctx = current->io_uring;	8935	struct io_uring_task *tctx = current->io_uring;
8810	struct file *file;	8936	struct io_tctx_node *node;
8811	unsigned long index;	8937	unsigned long index;
8812		8938
8813	/* make sure overflow events are dropped */	8939	/* make sure overflow events are dropped */
8814	atomic_inc(&tctx->in_idle);	8940	atomic_inc(&tctx->in_idle);
8815	xa_for_each(&tctx->xa, index, file)	8941	xa_for_each(&tctx->xa, index, node) {
8816	io_uring_cancel_task_requests(file->private_data, files);	8942	struct io_ring_ctx *ctx = node->ctx;
		8943
		8944	if (ctx->sq_data) {
		8945	io_sqpoll_cancel_sync(ctx);
		8946	continue;
		8947	}
		8948	io_uring_cancel_files(ctx, current, files);
		8949	if (!files)
		8950	io_uring_try_cancel_requests(ctx, current, NULL);
		8951	}
8817	atomic_dec(&tctx->in_idle);	8952	atomic_dec(&tctx->in_idle);
8818		8953
8819	if (files)	8954	if (files)
8820	io_uring_clean_tctx(tctx);	8955	io_uring_clean_tctx(tctx);
8821	}	8956	}
8822		8957
8823	static s64 tctx_inflight(struct io_uring_task *tctx)	8958	/* should only be called by SQPOLL task */
8824	{
8825	return percpu_counter_sum(&tctx->inflight);
8826	}
8827
8828	static void io_uring_cancel_sqpoll(struct io_ring_ctx *ctx)	8959	static void io_uring_cancel_sqpoll(struct io_ring_ctx *ctx)
8829	{	8960	{
8830	struct io_sq_data *sqd = ctx->sq_data;	8961	struct io_sq_data *sqd = ctx->sq_data;
8831	struct io_uring_task *tctx;	8962	struct io_uring_task *tctx = current->io_uring;
8832	s64 inflight;	8963	s64 inflight;
8833	DEFINE_WAIT(wait);	8964	DEFINE_WAIT(wait);
8834		8965
8835	if (!sqd)	8966	WARN_ON_ONCE(!sqd \|\| ctx->sq_data->thread != current);
8836	return;	8967
8837	io_sq_thread_park(sqd);
8838	if (!sqd->thread \|\| !sqd->thread->io_uring) {
8839	io_sq_thread_unpark(sqd);
8840	return;
8841	}
8842	tctx = ctx->sq_data->thread->io_uring;
8843	atomic_inc(&tctx->in_idle);	8968	atomic_inc(&tctx->in_idle);
8844	do {	8969	do {
8845	/* read completions before cancelations */	8970	/* read completions before cancelations */
8846	inflight = tctx_inflight(tctx);	8971	inflight = tctx_inflight(tctx);
8847	if (!inflight)	8972	if (!inflight)
8848	break;	8973	break;
8849	io_uring_cancel_task_requests(ctx, NULL);	8974	io_uring_try_cancel_requests(ctx, current, NULL);
8850		8975
8851	prepare_to_wait(&tctx->wait, &wait, TASK_UNINTERRUPTIBLE);	8976	prepare_to_wait(&tctx->wait, &wait, TASK_UNINTERRUPTIBLE);
8852	/*	8977	/*
@@ -8859,7 +8984,6 @@ static void io_uring_cancel_sqpoll(struct io_ring_ctx *ctx) · 6 unmodified lines
8859	finish_wait(&tctx->wait, &wait);	8984	finish_wait(&tctx->wait, &wait);
8860	} while (1);	8985	} while (1);
8861	atomic_dec(&tctx->in_idle);	8986	atomic_dec(&tctx->in_idle);
8862	io_sq_thread_unpark(sqd);
8863	}	8987	}
8864		8988
8865	/*	8989	/*
@@ -8874,15 +8998,6 @@ void __io_uring_task_cancel(void) · 8 unmodified lines
8874		8998
8875	/* make sure overflow events are dropped */	8999	/* make sure overflow events are dropped */
8876	atomic_inc(&tctx->in_idle);	9000	atomic_inc(&tctx->in_idle);
8877
8878	if (tctx->sqpoll) {
8879	struct file *file;
8880	unsigned long index;
8881
8882	xa_for_each(&tctx->xa, index, file)
8883	io_uring_cancel_sqpoll(file->private_data);
8884	}
8885
8886	do {	9001	do {
8887	/* read completions before cancelations */	9002	/* read completions before cancelations */
8888	inflight = tctx_inflight(tctx);	9003	inflight = tctx_inflight(tctx);
@@ -8981,7 +9096,6 @@ static unsigned long io_uring_nommu_get_unmapped_area(struct file *file, · 92 unmodified lines
8981		9096
8982	static int io_sqpoll_wait_sq(struct io_ring_ctx *ctx)	9097	static int io_sqpoll_wait_sq(struct io_ring_ctx *ctx)
8983	{	9098	{
8984	int ret = 0;
8985	DEFINE_WAIT(wait);	9099	DEFINE_WAIT(wait);
8986		9100
8987	do {	9101	do {
@@ -8995,7 +9109,7 @@ static int io_sqpoll_wait_sq(struct io_ring_ctx *ctx) · 7 unmodified lines
8995	} while (!signal_pending(current));	9109	} while (!signal_pending(current));
8996		9110
8997	finish_wait(&ctx->sqo_sq_wait, &wait);	9111	finish_wait(&ctx->sqo_sq_wait, &wait);
8998	return ret;	9112	return 0;
8999	}	9113	}
9000		9114
9001	static int io_get_ext_arg(unsigned flags, const void __user argp, size_t argsz,	9115	static int io_get_ext_arg(unsigned flags, const void __user argp, size_t argsz,
@@ -9069,13 +9183,10 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit, · 67 unmodified lines
9069	if (ctx->flags & IORING_SETUP_SQPOLL) {	9183	if (ctx->flags & IORING_SETUP_SQPOLL) {
9070	io_cqring_overflow_flush(ctx, false, NULL, NULL);	9184	io_cqring_overflow_flush(ctx, false, NULL, NULL);
9071		9185
9072	if (unlikely(ctx->sqo_exec)) {
9073	ret = io_sq_thread_fork(ctx->sq_data, ctx);
9074	if (ret)
9075	goto out;
9076	ctx->sqo_exec = 0;
9077	}
9078	ret = -EOWNERDEAD;	9186	ret = -EOWNERDEAD;
		9187	if (unlikely(ctx->sq_data->thread == NULL)) {
		9188	goto out;
		9189	}
9079	if (flags & IORING_ENTER_SQ_WAKEUP)	9190	if (flags & IORING_ENTER_SQ_WAKEUP)
9080	wake_up(&ctx->sq_data->wait);	9191	wake_up(&ctx->sq_data->wait);
9081	if (flags & IORING_ENTER_SQ_WAIT) {	9192	if (flags & IORING_ENTER_SQ_WAIT) {
@@ -9085,7 +9196,7 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit, · 3 unmodified lines
9085	}	9196	}
9086	submitted = to_submit;	9197	submitted = to_submit;
9087	} else if (to_submit) {	9198	} else if (to_submit) {
9088	ret = io_uring_add_task_file(ctx, f.file);	9199	ret = io_uring_add_task_file(ctx);
9089	if (unlikely(ret))	9200	if (unlikely(ret))
9090	goto out;	9201	goto out;
9091	mutex_lock(&ctx->uring_lock);	9202	mutex_lock(&ctx->uring_lock);
@@ -9127,10 +9238,9 @@ out_fput: · 35 unmodified lines
9127	}	9238	}
9128		9239
9129	#ifdef CONFIG_PROC_FS	9240	#ifdef CONFIG_PROC_FS
9130	static int io_uring_show_cred(int id, void p, void data)	9241	static int io_uring_show_cred(struct seq_file *m, unsigned int id,
		9242	const struct cred *cred)
9131	{	9243	{
9132	const struct cred *cred = p;
9133	struct seq_file *m = data;
9134	struct user_namespace *uns = seq_user_ns(m);	9244	struct user_namespace *uns = seq_user_ns(m);
9135	struct group_info *gi;	9245	struct group_info *gi;
9136	kernel_cap_t cap;	9246	kernel_cap_t cap;
@@ -9198,9 +9308,13 @@ static void __io_uring_show_fdinfo(struct io_ring_ctx ctx, struct seq_file m) · 61 unmodified lines
9198	seq_printf(m, "%5u: 0x%llx/%u\n", i, buf->ubuf,	9308	seq_printf(m, "%5u: 0x%llx/%u\n", i, buf->ubuf,
9199	(unsigned int) buf->len);	9309	(unsigned int) buf->len);
9200	}	9310	}
9201	if (has_lock && !idr_is_empty(&ctx->personality_idr)) {	9311	if (has_lock && !xa_empty(&ctx->personalities)) {
		9312	unsigned long index;
		9313	const struct cred *cred;
		9314
9202	seq_printf(m, "Personalities:\n");	9315	seq_printf(m, "Personalities:\n");
9203	idr_for_each(&ctx->personality_idr, io_uring_show_cred, m);	9316	xa_for_each(&ctx->personalities, index, cred)
		9317	io_uring_show_cred(m, index, cred);
9204	}	9318	}
9205	seq_printf(m, "PollList:\n");	9319	seq_printf(m, "PollList:\n");
9206	spin_lock_irq(&ctx->completion_lock);	9320	spin_lock_irq(&ctx->completion_lock);
@@ -9294,7 +9408,7 @@ static int io_uring_install_fd(struct io_ring_ctx ctx, struct file file) · 87 unmodified lines
9294	if (fd < 0)	9408	if (fd < 0)
9295	return fd;	9409	return fd;
9296		9410
9297	ret = io_uring_add_task_file(ctx, file);	9411	ret = io_uring_add_task_file(ctx);
9298	if (ret) {	9412	if (ret) {
9299	put_unused_fd(fd);	9413	put_unused_fd(fd);
9300	return ret;	9414	return ret;
@@ -9402,9 +9516,6 @@ static int io_uring_create(unsigned entries, struct io_uring_params *p, · 101 unmodified lines
9402	if (ret)	9516	if (ret)
9403	goto err;	9517	goto err;
9404		9518
9405	if (!(p->flags & IORING_SETUP_R_DISABLED))
9406	io_sq_offload_start(ctx);
9407
9408	memset(&p->sq_off, 0, sizeof(p->sq_off));	9519	memset(&p->sq_off, 0, sizeof(p->sq_off));
9409	p->sq_off.head = offsetof(struct io_rings, sq.head);	9520	p->sq_off.head = offsetof(struct io_rings, sq.head);
9410	p->sq_off.tail = offsetof(struct io_rings, sq.tail);	9521	p->sq_off.tail = offsetof(struct io_rings, sq.tail);
@@ -9532,14 +9643,16 @@ out: · 121 unmodified lines
9532	static int io_register_personality(struct io_ring_ctx *ctx)	9643	static int io_register_personality(struct io_ring_ctx *ctx)
9533	{	9644	{
9534	const struct cred *creds;	9645	const struct cred *creds;
		9646	u32 id;
9535	int ret;	9647	int ret;
9536		9648
9537	creds = get_current_cred();	9649	creds = get_current_cred();
9538		9650
9539	ret = idr_alloc_cyclic(&ctx->personality_idr, (void *) creds, 1,	9651	ret = xa_alloc_cyclic(&ctx->personalities, &id, (void *)creds,
9540	USHRT_MAX, GFP_KERNEL);	9652	XA_LIMIT(0, USHRT_MAX), &ctx->pers_next, GFP_KERNEL);
9541	if (ret < 0)	9653	if (!ret)
9542	put_cred(creds);	9654	return id;
		9655	put_cred(creds);
9543	return ret;	9656	return ret;
9544	}	9657	}
9545		9658
@@ -9621,7 +9734,9 @@ static int io_register_enable_rings(struct io_ring_ctx *ctx) · 75 unmodified lines
9621	if (ctx->restrictions.registered)	9734	if (ctx->restrictions.registered)
9622	ctx->restricted = 1;	9735	ctx->restricted = 1;
9623		9736
9624	io_sq_offload_start(ctx);	9737	ctx->flags &= ~IORING_SETUP_R_DISABLED;
		9738	if (ctx->sq_data && wq_has_sleeper(&ctx->sq_data->wait))
		9739	wake_up(&ctx->sq_data->wait);
9625	return 0;	9740	return 0;
9626	}	9741	}
9627		9742

fs/iomap/buffered-io.c+2−2

@@ -1221,7 +1221,7 @@ iomap_alloc_ioend(struct inode inode, struct iomap_writepage_ctx wpc, · 1220 unmodified lines
1221	struct iomap_ioend *ioend;	1221	struct iomap_ioend *ioend;
1222	struct bio *bio;	1222	struct bio *bio;
1223		1223
1224	bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &iomap_ioend_bioset);	1224	bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_VECS, &iomap_ioend_bioset);
1225	bio_set_dev(bio, wpc->iomap.bdev);	1225	bio_set_dev(bio, wpc->iomap.bdev);
1226	bio->bi_iter.bi_sector = sector;	1226	bio->bi_iter.bi_sector = sector;
1227	bio->bi_opf = REQ_OP_WRITE \| wbc_to_write_flags(wbc);	1227	bio->bi_opf = REQ_OP_WRITE \| wbc_to_write_flags(wbc);
@@ -1252,7 +1252,7 @@ iomap_chain_bio(struct bio *prev) · 24 unmodified lines
1252	{	1252	{
1253	struct bio *new;	1253	struct bio *new;
1254		1254
1255	new = bio_alloc(GFP_NOFS, BIO_MAX_PAGES);	1255	new = bio_alloc(GFP_NOFS, BIO_MAX_VECS);
1256	bio_copy_dev(new, prev);/* also copies over blkcg information */	1256	bio_copy_dev(new, prev);/* also copies over blkcg information */
1257	new->bi_iter.bi_sector = bio_end_sector(prev);	1257	new->bi_iter.bi_sector = bio_end_sector(prev);
1258	new->bi_opf = prev->bi_opf;	1258	new->bi_opf = prev->bi_opf;

fs/iomap/direct-io.c+2−2

@@ -296,7 +296,7 @@ iomap_dio_bio_actor(struct inode *inode, loff_t pos, loff_t length, · 295 unmodified lines
296	*/	296	*/
297	bio_opf = iomap_dio_bio_opflags(dio, iomap, use_fua);	297	bio_opf = iomap_dio_bio_opflags(dio, iomap, use_fua);
298		298
299	nr_pages = bio_iov_vecs_to_alloc(dio->submit.iter, BIO_MAX_PAGES);	299	nr_pages = bio_iov_vecs_to_alloc(dio->submit.iter, BIO_MAX_VECS);
300	do {	300	do {
301	size_t n;	301	size_t n;
302	if (dio->error) {	302	if (dio->error) {
@@ -338,7 +338,7 @@ iomap_dio_bio_actor(struct inode *inode, loff_t pos, loff_t length, · 35 unmodified lines
338	copied += n;	338	copied += n;
339		339
340	nr_pages = bio_iov_vecs_to_alloc(dio->submit.iter,	340	nr_pages = bio_iov_vecs_to_alloc(dio->submit.iter,
341	BIO_MAX_PAGES);	341	BIO_MAX_VECS);
342	iomap_dio_submit_bio(dio, iomap, bio, pos);	342	iomap_dio_submit_bio(dio, iomap, bio, pos);
343	pos += n;	343	pos += n;
344	} while (nr_pages);	344	} while (nr_pages);

fs/iomap/swapfile.c+10−0

@@ -170,6 +170,16 @@ int iomap_swapfile_activate(struct swap_info_struct *sis, · 169 unmodified lines
170	return ret;	170	return ret;
171	}	171	}
172		172
		173	/*
		174	* If this swapfile doesn't contain even a single page-aligned
		175	* contiguous range of blocks, reject this useless swapfile to
		176	* prevent confusion later on.
		177	*/
		178	if (isi.nr_pages == 0) {
		179	pr_warn("swapon: Cannot find a single usable page in file.\n");
		180	return -EINVAL;
		181	}
		182
173	*pagespan = 1 + isi.highest_ppage - isi.lowest_ppage;	183	*pagespan = 1 + isi.highest_ppage - isi.lowest_ppage;
174	sis->max = isi.nr_pages;	184	sis->max = isi.nr_pages;
175	sis->pages = isi.nr_pages - 1;	185	sis->pages = isi.nr_pages - 1;

fs/locks.c+0−3

@@ -1808,9 +1808,6 @@ check_conflicting_open(struct file *filp, const long arg, int flags) · 1807 unmodified lines
1808		1808
1809	if (flags & FL_LAYOUT)	1809	if (flags & FL_LAYOUT)
1810	return 0;	1810	return 0;
1811	if (flags & FL_DELEG)
1812	/* We leave these checks to the caller. */
1813	return 0;
1814		1811
1815	if (arg == F_RDLCK)	1812	if (arg == F_RDLCK)
1816	return inode_is_open_for_write(inode) ? -EAGAIN : 0;	1813	return inode_is_open_for_write(inode) ? -EAGAIN : 0;

fs/mpage.c+1−1

@@ -616,7 +616,7 @@ alloc_new: · 615 unmodified lines
616	goto out;	616	goto out;
617	}	617	}
618	bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),	618	bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),
619	BIO_MAX_PAGES, GFP_NOFS\|__GFP_HIGH);	619	BIO_MAX_VECS, GFP_NOFS\|__GFP_HIGH);
620	if (bio == NULL)	620	if (bio == NULL)
621	goto confused;	621	goto confused;
622		622

fs/nfs/Kconfig+1−1

@@ -127,7 +127,7 @@ config PNFS_BLOCK · 126 unmodified lines
127	config PNFS_FLEXFILE_LAYOUT	127	config PNFS_FLEXFILE_LAYOUT
128	tristate	128	tristate
129	depends on NFS_V4_1 && NFS_V3	129	depends on NFS_V4_1 && NFS_V3
130	default m	130	default NFS_V4
131		131
132	config NFS_V4_1_IMPLEMENTATION_ID_DOMAIN	132	config NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
133	string "NFSv4.1 Implementation ID Domain"	133	string "NFSv4.1 Implementation ID Domain"

fs/nfs/dir.c+33−25

 		spin_lock(&dir->i_lock);
 		if (list_empty(&nfsi->open_files) &&
 		    (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
-			nfsi->cache_validity |= NFS_INO_INVALID_DATA |
+			nfs_set_cache_invalid(dir,
-				NFS_INO_REVAL_FORCED;
+					      NFS_INO_INVALID_DATA |
+						      NFS_INO_REVAL_FORCED);
 		list_add(&ctx->list, &nfsi->open_files);
 		spin_unlock(&dir->i_lock);
 		return ctx;
 	goto out;
 }
+static void nfs_mark_dir_for_revalidate(struct inode *inode)
+{
+	spin_lock(&inode->i_lock);
+	nfs_set_cache_invalid(inode, NFS_INO_REVAL_PAGECACHE);
+	spin_unlock(&inode->i_lock);
+}
 /*
  * We judge how long we want to trust negative
  * dentries by looking at the parent inode mtime.
 			__func__, dentry);
 		return 1;
 	case 0:
-		nfs_mark_for_revalidate(dir);
+		/*
-		if (inode && S_ISDIR(inode->i_mode)) {
+		 * We can't d_drop the root of a disconnected tree:
-			/* Purge readdir caches. */
+		 * its d_hash is on the s_anon list and d_drop() would hide
-			nfs_zap_caches(inode);
+		 * it from shrink_dcache_for_unmount(), leading to busy
-			/*
+		 * inodes on unmount and further oopses.
-			 * We can't d_drop the root of a disconnected tree:
+		 */
-			 * its d_hash is on the s_anon list and d_drop() would hide
+		if (inode && IS_ROOT(dentry))
-			 * it from shrink_dcache_for_unmount(), leading to busy
+			return 1;
-			 * inodes on unmount and further oopses.
-			 */
-			if (IS_ROOT(dentry))
-				return 1;
-		}
 		dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
 				__func__, dentry);
 		return 0;
 	nfs_free_fattr(fattr);
 	nfs_free_fhandle(fhandle);
 	nfs4_label_free(label);
+	/*
+	 * If the lookup failed despite the dentry change attribute being
+	 * a match, then we should revalidate the directory cache.
+	 */
+	if (!ret && nfs_verify_change_attribute(dir, dentry->d_time))
+		nfs_mark_dir_for_revalidate(dir);
 	return nfs_lookup_revalidate_done(dir, dentry, inode, ret);
 }
 		error = nfs_lookup_verify_inode(inode, flags);
 		if (error) {
 			if (error == -ESTALE)
-				nfs_zap_caches(dir);
+				nfs_mark_dir_for_revalidate(dir);
 			goto out_bad;
 		}
 		nfs_advise_use_readdirplus(dir);
 	if (inode->i_nlink > 0)
 		drop_nlink(inode);
 	NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
-	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE
+	nfs_set_cache_invalid(
-		| NFS_INO_INVALID_CTIME
+		inode, NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
-		| NFS_INO_INVALID_OTHER
+			       NFS_INO_INVALID_OTHER | NFS_INO_REVAL_FORCED);
-		| NFS_INO_REVAL_FORCED;
 	spin_unlock(&inode->i_lock);
 }
 {
 	if (S_ISDIR(inode->i_mode))
 		/* drop any readdir cache as it could easily be old */
-		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
+		nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
 		nfs_complete_unlink(dentry, inode);
 	dput(parent);
 	return d;
 out_error:
-	nfs_mark_for_revalidate(dir);
 	d = ERR_PTR(error);
 	goto out;
 }
 	if (error == 0) {
 		spin_lock(&old_inode->i_lock);
 		NFS_I(old_inode)->attr_gencount = nfs_inc_attr_generation_counter();
-		NFS_I(old_inode)->cache_validity |= NFS_INO_INVALID_CHANGE
+		nfs_set_cache_invalid(old_inode, NFS_INO_INVALID_CHANGE |
-			| NFS_INO_INVALID_CTIME
+							 NFS_INO_INVALID_CTIME |
-			| NFS_INO_REVAL_FORCED;
+							 NFS_INO_REVAL_FORCED);
 		spin_unlock(&old_inode->i_lock);
 	}
 out:

fs/nfs/inode.c+4−3

 }
 #endif
-static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
+void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
 {
 	struct nfs_inode *nfsi = NFS_I(inode);
 	bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ);
 	if (flags & NFS_INO_INVALID_DATA)
 		nfs_fscache_invalidate(inode);
 }
+EXPORT_SYMBOL_GPL(nfs_set_cache_invalid);
 /*
  * Invalidate the local caches
 	spin_lock(&inode->i_lock);
 	if (list_empty(&nfsi->open_files) &&
 	    (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
-		nfsi->cache_validity |= NFS_INO_INVALID_DATA |
+		nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
-			NFS_INO_REVAL_FORCED;
+						     NFS_INO_REVAL_FORCED);
 	list_add_tail_rcu(&ctx->list, &nfsi->open_files);
 	spin_unlock(&inode->i_lock);
 }

fs/nfs/internal.h+2−1

 extern int nfs_drop_inode(struct inode *);
 extern void nfs_clear_inode(struct inode *);
 extern void nfs_evict_inode(struct inode *);
-void nfs_zap_acl_cache(struct inode *inode);
+extern void nfs_zap_acl_cache(struct inode *inode);
+extern void nfs_set_cache_invalid(struct inode *inode, unsigned long flags);
 extern bool nfs_check_cache_invalid(struct inode *, unsigned long);
 extern int nfs_wait_bit_killable(struct wait_bit_key *key, int mode);
 extern int nfs_wait_atomic_killable(atomic_t *p, unsigned int mode);

fs/nfs/nfs3xdr.c+2−1

 #define NFS3_pagepad_sz		(1) /* Page padding */
 #define NFS3_fhandle_sz		(1+16)
 #define NFS3_fh_sz		(NFS3_fhandle_sz)	/* shorthand */
+#define NFS3_post_op_fh_sz	(1+NFS3_fh_sz)
 #define NFS3_sattr_sz		(15)
 #define NFS3_filename_sz	(1+(NFS3_MAXNAMLEN>>2))
 #define NFS3_path_sz		(1+(NFS3_MAXPATHLEN>>2))
 #define NFS3_readlinkres_sz	(1+NFS3_post_op_attr_sz+1+NFS3_pagepad_sz)
 #define NFS3_readres_sz		(1+NFS3_post_op_attr_sz+3+NFS3_pagepad_sz)
 #define NFS3_writeres_sz	(1+NFS3_wcc_data_sz+4)
-#define NFS3_createres_sz	(1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
+#define NFS3_createres_sz	(1+NFS3_post_op_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
 #define NFS3_renameres_sz	(1+(2 * NFS3_wcc_data_sz))
 #define NFS3_linkres_sz		(1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
 #define NFS3_readdirres_sz	(1+NFS3_post_op_attr_sz+2+NFS3_pagepad_sz)

fs/nfs/nfs42proc.c+7−5

 	truncate_pagecache_range(dst_inode, pos_dst,
 				 pos_dst + res->write_res.count);
 	spin_lock(&dst_inode->i_lock);
-	NFS_I(dst_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE |
+	nfs_set_cache_invalid(
-			NFS_INO_REVAL_FORCED | NFS_INO_INVALID_SIZE |
+		dst_inode, NFS_INO_REVAL_PAGECACHE | NFS_INO_REVAL_FORCED |
-			NFS_INO_INVALID_ATTR | NFS_INO_INVALID_DATA);
+				   NFS_INO_INVALID_SIZE | NFS_INO_INVALID_ATTR |
+				   NFS_INO_INVALID_DATA);
 	spin_unlock(&dst_inode->i_lock);
 	spin_lock(&src_inode->i_lock);
-	NFS_I(src_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE |
+	nfs_set_cache_invalid(src_inode, NFS_INO_REVAL_PAGECACHE |
-			NFS_INO_REVAL_FORCED | NFS_INO_INVALID_ATIME);
+						 NFS_INO_REVAL_FORCED |
+						 NFS_INO_INVALID_ATIME);
 	spin_unlock(&src_inode->i_lock);
 	status = res->write_res.count;
 out:

fs/nfs/nfs4proc.c+16−17

 static void
 nfs4_inc_nlink_locked(struct inode *inode)
 {
-	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_OTHER;
+	nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
 	inc_nlink(inode);
 }
 static void
 nfs4_dec_nlink_locked(struct inode *inode)
 {
-	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_OTHER;
+	nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
 	drop_nlink(inode);
 }
 {
 	struct nfs_inode *nfsi = NFS_I(inode);
-	nfsi->cache_validity |= NFS_INO_INVALID_CTIME
+	cache_validity |= NFS_INO_INVALID_CTIME | NFS_INO_INVALID_MTIME;
-		| NFS_INO_INVALID_MTIME
-		| cache_validity;
 	if (cinfo->atomic && cinfo->before == inode_peek_iversion_raw(inode)) {
 		nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
 		nfsi->attrtimeo_timestamp = jiffies;
 	} else {
 		if (S_ISDIR(inode->i_mode)) {
-			nfsi->cache_validity |= NFS_INO_INVALID_DATA;
+			cache_validity |= NFS_INO_INVALID_DATA;
 			nfs_force_lookup_revalidate(inode);
 		} else {
 			if (!NFS_PROTO(inode)->have_delegation(inode,
 							       FMODE_READ))
-				nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE;
+				cache_validity |= NFS_INO_REVAL_PAGECACHE;
 		}
 		if (cinfo->before != inode_peek_iversion_raw(inode))
-			nfsi->cache_validity |= NFS_INO_INVALID_ACCESS |
+			cache_validity |= NFS_INO_INVALID_ACCESS |
-						NFS_INO_INVALID_ACL |
+					  NFS_INO_INVALID_ACL |
-						NFS_INO_INVALID_XATTR;
+					  NFS_INO_INVALID_XATTR;
 	}
 	inode_set_iversion_raw(inode, cinfo->after);
 	nfsi->read_cache_jiffies = timestamp;
 	nfsi->attr_gencount = nfs_inc_attr_generation_counter();
+	nfs_set_cache_invalid(inode, cache_validity);
 	nfsi->cache_validity &= ~NFS_INO_INVALID_CHANGE;
-	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
-		nfs_fscache_invalidate(inode);
 }
 void
 	unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
 	int ret, i;
+	/* You can't remove system.nfs4_acl: */
+	if (buflen == 0)
+		return -EINVAL;
 	if (!nfs4_server_supports_acls(server))
 		return -EOPNOTSUPP;
 	if (npages > ARRAY_SIZE(pages))
 	 * so mark the attribute cache invalid.
 	 */
 	spin_lock(&inode->i_lock);
-	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE
+	nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE |
-		| NFS_INO_INVALID_CTIME
+					     NFS_INO_INVALID_CTIME |
-		| NFS_INO_REVAL_FORCED;
+					     NFS_INO_REVAL_FORCED);
 	spin_unlock(&inode->i_lock);
 	nfs_access_zap_cache(inode);
 	nfs_zap_acl_cache(inode);
 		return ret;
 	if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
 		return -ENOENT;
-	return 0;
+	return label.len;
 }
 static int nfs4_get_security_label(struct inode *inode, void *buf,

fs/nfs/unlink.c+3−3

@@ -500,9 +500,9 @@ nfs_sillyrename(struct inode dir, struct dentry dentry) · 499 unmodified lines
500	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));	500	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
501	spin_lock(&inode->i_lock);	501	spin_lock(&inode->i_lock);
502	NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();	502	NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
503	NFS_I(inode)->cache_validity \|= NFS_INO_INVALID_CHANGE	503	nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE \|
504	\| NFS_INO_INVALID_CTIME	504	NFS_INO_INVALID_CTIME \|
505	\| NFS_INO_REVAL_FORCED;	505	NFS_INO_REVAL_FORCED);
506	spin_unlock(&inode->i_lock);	506	spin_unlock(&inode->i_lock);
507	d_move(dentry, sdentry);	507	d_move(dentry, sdentry);
508	break;	508	break;

fs/nfs/write.c+4−4

@@ -303,9 +303,9 @@ static void nfs_set_pageerror(struct address_space *mapping) · 302 unmodified lines
303	nfs_zap_mapping(mapping->host, mapping);	303	nfs_zap_mapping(mapping->host, mapping);
304	/* Force file size revalidation */	304	/* Force file size revalidation */
305	spin_lock(&inode->i_lock);	305	spin_lock(&inode->i_lock);
306	NFS_I(inode)->cache_validity \|= NFS_INO_REVAL_FORCED \|	306	nfs_set_cache_invalid(inode, NFS_INO_REVAL_FORCED \|
307	NFS_INO_REVAL_PAGECACHE \|	307	NFS_INO_REVAL_PAGECACHE \|
308	NFS_INO_INVALID_SIZE;	308	NFS_INO_INVALID_SIZE);
309	spin_unlock(&inode->i_lock);	309	spin_unlock(&inode->i_lock);
310	}	310	}
311		311
@@ -1604,7 +1604,7 @@ static int nfs_writeback_done(struct rpc_task *task, · 1292 unmodified lines
1604	/* Deal with the suid/sgid bit corner case */	1604	/* Deal with the suid/sgid bit corner case */
1605	if (nfs_should_remove_suid(inode)) {	1605	if (nfs_should_remove_suid(inode)) {
1606	spin_lock(&inode->i_lock);	1606	spin_lock(&inode->i_lock);
1607	NFS_I(inode)->cache_validity \|= NFS_INO_INVALID_OTHER;	1607	nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
1608	spin_unlock(&inode->i_lock);	1608	spin_unlock(&inode->i_lock);
1609	}	1609	}
1610	return 0;	1610	return 0;

fs/nfsd/Kconfig+1−0

@@ -73,6 +73,7 @@ config NFSD_V4 · 72 unmodified lines
73	select NFSD_V3	73	select NFSD_V3
74	select FS_POSIX_ACL	74	select FS_POSIX_ACL
75	select SUNRPC_GSS	75	select SUNRPC_GSS
		76	select CRYPTO
76	select CRYPTO_MD5	77	select CRYPTO_MD5
77	select CRYPTO_SHA256	78	select CRYPTO_SHA256
78	select GRACE_PERIOD	79	select GRACE_PERIOD

fs/nfsd/filecache.c+2−0

 			continue;
 		if (!nfsd_match_cred(nf->nf_cred, current_cred()))
 			continue;
+		if (!test_bit(NFSD_FILE_HASHED, &nf->nf_flags))
+			continue;
 		if (nfsd_file_get(nf) != NULL)
 			return nf;
 	}

fs/nfsd/nfs4callback.c+1−0

@@ -1189,6 +1189,7 @@ static void nfsd4_cb_done(struct rpc_task task, void calldata) · 1188 unmodified lines
1189	switch (task->tk_status) {	1189	switch (task->tk_status) {
1190	case -EIO:	1190	case -EIO:
1191	case -ETIMEDOUT:	1191	case -ETIMEDOUT:
		1192	case -EACCES:
1192	nfsd4_mark_cb_down(clp, task->tk_status);	1193	nfsd4_mark_cb_down(clp, task->tk_status);
1193	}	1194	}
1194	break;	1195	break;

fs/nfsd/nfs4proc.c+1−1

@@ -1302,7 +1302,7 @@ nfsd4_cleanup_inter_ssc(struct vfsmount ss_mnt, struct nfsd_file src, · 1301 unmodified lines
1302	struct nfsd_file *dst)	1302	struct nfsd_file *dst)
1303	{	1303	{
1304	nfs42_ssc_close(src->nf_file);	1304	nfs42_ssc_close(src->nf_file);
1305	/* 'src' is freed by nfsd4_do_async_copy */	1305	fput(src->nf_file);
1306	nfsd_file_put(dst);	1306	nfsd_file_put(dst);
1307	mntput(ss_mnt);	1307	mntput(ss_mnt);
1308	}	1308	}

fs/nfsd/nfs4state.c+15−40

 	return fl;
 }
-static int nfsd4_check_conflicting_opens(struct nfs4_client *clp,
-						struct nfs4_file *fp)
-{
-	struct nfs4_clnt_odstate *co;
-	struct file *f = fp->fi_deleg_file->nf_file;
-	struct inode *ino = locks_inode(f);
-	int writes = atomic_read(&ino->i_writecount);
-	if (fp->fi_fds[O_WRONLY])
-		writes--;
-	if (fp->fi_fds[O_RDWR])
-		writes--;
-	if (writes > 0)
-		return -EAGAIN;
-	spin_lock(&fp->fi_lock);
-	list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
-		if (co->co_client != clp) {
-			spin_unlock(&fp->fi_lock);
-			return -EAGAIN;
-		}
-	}
-	spin_unlock(&fp->fi_lock);
-	return 0;
-}
 static struct nfs4_delegation *
 nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh,
 		    struct nfs4_file *fp, struct nfs4_clnt_odstate *odstate)
 	nf = find_readable_file(fp);
 	if (!nf) {
-		/*
+		/* We should always have a readable file here */
-		 * We probably could attempt another open and get a read
+		WARN_ON_ONCE(1);
-		 * delegation, but for now, don't bother until the
+		return ERR_PTR(-EBADF);
-		 * client actually sends us one.
-		 */
-		return ERR_PTR(-EAGAIN);
 	}
 	spin_lock(&state_lock);
 	spin_lock(&fp->fi_lock);
 	if (!fl)
 		goto out_clnt_odstate;
-	status = nfsd4_check_conflicting_opens(clp, fp);
-	if (status) {
-		locks_free_lock(fl);
-		goto out_clnt_odstate;
-	}
 	status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_type, &fl, NULL);
 	if (fl)
 		locks_free_lock(fl);
 	if (status)
 		goto out_clnt_odstate;
-	status = nfsd4_check_conflicting_opens(clp, fp);
-	if (status)
-		goto out_clnt_odstate;
 	spin_lock(&state_lock);
 	spin_lock(&fp->fi_lock);
 				goto out_no_deleg;
 			if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
 				goto out_no_deleg;
+			/*
+			 * Also, if the file was opened for write or
+			 * create, there's a good chance the client's
+			 * about to write to it, resulting in an
+			 * immediate recall (since we don't support
+			 * write delegations):
+			 */
+			if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
+				goto out_no_deleg;
+			if (open->op_create == NFS4_OPEN_CREATE)
+				goto out_no_deleg;
 			break;
 		default:
 			goto out_no_deleg;
 	idr_for_each_entry(&nn->s2s_cp_stateids, cps_t, i) {
 		cps = container_of(cps_t, struct nfs4_cpntf_state, cp_stateid);
 		if (cps->cp_stateid.sc_type == NFS4_COPYNOTIFY_STID &&
-				cps->cpntf_time > cutoff)
+				cps->cpntf_time < cutoff)
 			_free_cpntf_state_locked(nn, cps);
 	}
 	spin_unlock(&nn->s2s_cp_lock);

fs/nilfs2/segbuf.c+1−1

@@ -399,7 +399,7 @@ static void nilfs_segbuf_prepare_write(struct nilfs_segment_buffer *segbuf, · 398 unmodified lines
399	{	399	{
400	wi->bio = NULL;	400	wi->bio = NULL;
401	wi->rest_blocks = segbuf->sb_sum.nblocks;	401	wi->rest_blocks = segbuf->sb_sum.nblocks;
402	wi->max_pages = BIO_MAX_PAGES;	402	wi->max_pages = BIO_MAX_VECS;
403	wi->nr_vecs = min(wi->max_pages, wi->rest_blocks);	403	wi->nr_vecs = min(wi->max_pages, wi->rest_blocks);
404	wi->start = wi->end = 0;	404	wi->start = wi->end = 0;
405	wi->blocknr = segbuf->sb_pseg_start;	405	wi->blocknr = segbuf->sb_pseg_start;

fs/pnode.h+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12		12
13	#define IS_MNT_SHARED(m) ((m)->mnt.mnt_flags & MNT_SHARED)	13	#define IS_MNT_SHARED(m) ((m)->mnt.mnt_flags & MNT_SHARED)
14	#define IS_MNT_SLAVE(m) ((m)->mnt_master)	14	#define IS_MNT_SLAVE(m) ((m)->mnt_master)
15	#define IS_MNT_NEW(m) (!(m)->mnt_ns)	15	#define IS_MNT_NEW(m) (!(m)->mnt_ns \|\| is_anon_ns((m)->mnt_ns))
16	#define CLEAR_MNT_SHARED(m) ((m)->mnt.mnt_flags &= ~MNT_SHARED)	16	#define CLEAR_MNT_SHARED(m) ((m)->mnt.mnt_flags &= ~MNT_SHARED)
17	#define IS_MNT_UNBINDABLE(m) ((m)->mnt.mnt_flags & MNT_UNBINDABLE)	17	#define IS_MNT_UNBINDABLE(m) ((m)->mnt.mnt_flags & MNT_UNBINDABLE)
18	#define IS_MNT_MARKED(m) ((m)->mnt.mnt_flags & MNT_MARKED)	18	#define IS_MNT_MARKED(m) ((m)->mnt.mnt_flags & MNT_MARKED)

fs/proc/task_mmu.c+0−2

@@ -1036,8 +1036,6 @@ struct clear_refs_private { · 1035 unmodified lines
1036		1036
1037	#ifdef CONFIG_MEM_SOFT_DIRTY	1037	#ifdef CONFIG_MEM_SOFT_DIRTY
1038		1038
1039	#define is_cow_mapping(flags) (((flags) & (VM_SHARED \| VM_MAYWRITE)) == VM_MAYWRITE)
1040
1041	static inline bool pte_is_pinned(struct vm_area_struct *vma, unsigned long addr, pte_t pte)	1039	static inline bool pte_is_pinned(struct vm_area_struct *vma, unsigned long addr, pte_t pte)
1042	{	1040	{
1043	struct page *page;	1041	struct page *page;

fs/select.c+4−6

@@ -1055,10 +1055,9 @@ static long do_restart_poll(struct restart_block *restart_block) · 1054 unmodified lines
1055		1055
1056	ret = do_sys_poll(ufds, nfds, to);	1056	ret = do_sys_poll(ufds, nfds, to);
1057		1057
1058	if (ret == -ERESTARTNOHAND) {	1058	if (ret == -ERESTARTNOHAND)
1059	restart_block->fn = do_restart_poll;	1059	ret = set_restart_fn(restart_block, do_restart_poll);
1060	ret = -ERESTART_RESTARTBLOCK;	1060
1061	}
1062	return ret;	1061	return ret;
1063	}	1062	}
1064		1063
@@ -1080,7 +1079,6 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds, · 15 unmodified lines
1080	struct restart_block *restart_block;	1079	struct restart_block *restart_block;
1081		1080
1082	restart_block = &current->restart_block;	1081	restart_block = &current->restart_block;
1083	restart_block->fn = do_restart_poll;
1084	restart_block->poll.ufds = ufds;	1082	restart_block->poll.ufds = ufds;
1085	restart_block->poll.nfds = nfds;	1083	restart_block->poll.nfds = nfds;
1086		1084
@@ -1091,7 +1089,7 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds, · 4 unmodified lines
1091	} else	1089	} else
1092	restart_block->poll.has_timeout = 0;	1090	restart_block->poll.has_timeout = 0;
1093		1091
1094	ret = -ERESTART_RESTARTBLOCK;	1092	ret = set_restart_fn(restart_block, do_restart_poll);
1095	}	1093	}
1096	return ret;	1094	return ret;
1097	}	1095	}

fs/squashfs/block.c+1−1

@@ -87,7 +87,7 @@ static int squashfs_bio_read(struct super_block *sb, u64 index, int length, · 86 unmodified lines
87	int error, i;	87	int error, i;
88	struct bio *bio;	88	struct bio *bio;
89		89
90	if (page_count <= BIO_MAX_PAGES)	90	if (page_count <= BIO_MAX_VECS)
91	bio = bio_alloc(GFP_NOIO, page_count);	91	bio = bio_alloc(GFP_NOIO, page_count);
92	else	92	else
93	bio = bio_kmalloc(GFP_NOIO, page_count);	93	bio = bio_kmalloc(GFP_NOIO, page_count);

fs/squashfs/export.c+6−2

 		start = le64_to_cpu(table[n]);
 		end = le64_to_cpu(table[n + 1]);
-		if (start >= end || (end - start) > SQUASHFS_METADATA_SIZE) {
+		if (start >= end
+		    || (end - start) >
+		    (SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 			kfree(table);
 			return ERR_PTR(-EINVAL);
 		}
 	}
 	start = le64_to_cpu(table[indexes - 1]);
-	if (start >= lookup_table_start || (lookup_table_start - start) > SQUASHFS_METADATA_SIZE) {
+	if (start >= lookup_table_start ||
+	    (lookup_table_start - start) >
+	    (SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 		kfree(table);
 		return ERR_PTR(-EINVAL);
 	}

fs/squashfs/id.c+4−2

 		start = le64_to_cpu(table[n]);
 		end = le64_to_cpu(table[n + 1]);
-		if (start >= end || (end - start) > SQUASHFS_METADATA_SIZE) {
+		if (start >= end || (end - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 			kfree(table);
 			return ERR_PTR(-EINVAL);
 		}
 	}
 	start = le64_to_cpu(table[indexes - 1]);
-	if (start >= id_table_start || (id_table_start - start) > SQUASHFS_METADATA_SIZE) {
+	if (start >= id_table_start || (id_table_start - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 		kfree(table);
 		return ERR_PTR(-EINVAL);
 	}

fs/squashfs/squashfs_fs.h+1−0

@@ -17,6 +17,7 @@ · 16 unmodified lines
17		17
18	/* size of metadata (inode and directory) blocks */	18	/* size of metadata (inode and directory) blocks */
19	#define SQUASHFS_METADATA_SIZE 8192	19	#define SQUASHFS_METADATA_SIZE 8192
		20	#define SQUASHFS_BLOCK_OFFSET 2
20		21
21	/* default size of block device I/O */	22	/* default size of block device I/O */
22	#ifdef CONFIG_SQUASHFS_4K_DEVBLK_SIZE	23	#ifdef CONFIG_SQUASHFS_4K_DEVBLK_SIZE

fs/squashfs/xattr_id.c+4−2

 		start = le64_to_cpu(table[n]);
 		end = le64_to_cpu(table[n + 1]);
-		if (start >= end || (end - start) > SQUASHFS_METADATA_SIZE) {
+		if (start >= end || (end - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 			kfree(table);
 			return ERR_PTR(-EINVAL);
 		}
 	}
 	start = le64_to_cpu(table[indexes - 1]);
-	if (start >= table_start || (table_start - start) > SQUASHFS_METADATA_SIZE) {
+	if (start >= table_start || (table_start - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 		kfree(table);
 		return ERR_PTR(-EINVAL);
 	}

fs/xfs/xfs_inode.c+8−6

 	/*
 	 * Make sure that we have allocated dquot(s) on disk.
 	 */
-	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
+	error = xfs_qm_vop_dqalloc(dp, fsuid_into_mnt(mnt_userns),
-					XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			fsgid_into_mnt(mnt_userns), prid,
-					&udqp, &gdqp, &pdqp);
+			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			&udqp, &gdqp, &pdqp);
 	if (error)
 		return error;
 	/*
 	 * Make sure that we have allocated dquot(s) on disk.
 	 */
-	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
+	error = xfs_qm_vop_dqalloc(dp, fsuid_into_mnt(mnt_userns),
-				XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			fsgid_into_mnt(mnt_userns), prid,
-				&udqp, &gdqp, &pdqp);
+			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			&udqp, &gdqp, &pdqp);
 	if (error)
 		return error;

fs/xfs/xfs_itable.c+6−0

 	};
 	int			error;
+	if (breq->mnt_userns != &init_user_ns) {
+		xfs_warn_ratelimited(breq->mp,
+			"bulkstat not supported inside of idmapped mounts.");
+		return -EINVAL;
+	}
 	ASSERT(breq->icount == 1);
 	bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),

fs/xfs/xfs_mount.c+44−46

@@ -634,6 +634,47 @@ xfs_check_summary_counts( · 633 unmodified lines
634	return xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);	634	return xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);
635	}	635	}
636		636
		637	/*
		638	* Flush and reclaim dirty inodes in preparation for unmount. Inodes and
		639	* internal inode structures can be sitting in the CIL and AIL at this point,
		640	* so we need to unpin them, write them back and/or reclaim them before unmount
		641	* can proceed.
		642	*
		643	* An inode cluster that has been freed can have its buffer still pinned in
		644	* memory because the transaction is still sitting in a iclog. The stale inodes
		645	* on that buffer will be pinned to the buffer until the transaction hits the
		646	* disk and the callbacks run. Pushing the AIL will skip the stale inodes and
		647	* may never see the pinned buffer, so nothing will push out the iclog and
		648	* unpin the buffer.
		649	*
		650	* Hence we need to force the log to unpin everything first. However, log
		651	* forces don't wait for the discards they issue to complete, so we have to
		652	* explicitly wait for them to complete here as well.
		653	*
		654	* Then we can tell the world we are unmounting so that error handling knows
		655	* that the filesystem is going away and we should error out anything that we
		656	* have been retrying in the background. This will prevent never-ending
		657	* retries in AIL pushing from hanging the unmount.
		658	*
		659	* Finally, we can push the AIL to clean all the remaining dirty objects, then
		660	* reclaim the remaining inodes that are still in memory at this point in time.
		661	*/
		662	static void
		663	xfs_unmount_flush_inodes(
		664	struct xfs_mount *mp)
		665	{
		666	xfs_log_force(mp, XFS_LOG_SYNC);
		667	xfs_extent_busy_wait_all(mp);
		668	flush_workqueue(xfs_discard_wq);
		669
		670	mp->m_flags \|= XFS_MOUNT_UNMOUNTING;
		671
		672	xfs_ail_push_all_sync(mp->m_ail);
		673	cancel_delayed_work_sync(&mp->m_reclaim_work);
		674	xfs_reclaim_inodes(mp);
		675	xfs_health_unmount(mp);
		676	}
		677
637	/*	678	/*
638	* This function does the following on an initial mount of a file system:	679	* This function does the following on an initial mount of a file system:
639	* - reads the superblock from disk and init the mount struct	680	* - reads the superblock from disk and init the mount struct
@@ -1008,7 +1049,7 @@ xfs_mountfs( · 368 unmodified lines
1008	/* Clean out dquots that might be in memory after quotacheck. */	1049	/* Clean out dquots that might be in memory after quotacheck. */
1009	xfs_qm_unmount(mp);	1050	xfs_qm_unmount(mp);
1010	/*	1051	/*
1011	* Cancel all delayed reclaim work and reclaim the inodes directly.	1052	* Flush all inode reclamation work and flush the log.

65 more lines aren’t shown here.

fs/xfs/xfs_symlink.c+2−1

This diff is large: its 10 lines aren’t shown here.

fs/zonefs/super.c+88−15

This diff is large: its 177 lines aren’t shown here.

include/drm/ttm/ttm_bo_api.h+4−2

This diff is large: its 14 lines aren’t shown here.

include/kvm/arm_pmu.h+7−2

This diff is large: its 30 lines aren’t shown here.

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

This diff is large: its 20 lines aren’t shown here.

include/linux/bio.h+2−2

This diff is large: its 14 lines aren’t shown here.

include/linux/bpf.h+25−8

This diff is large: its 106 lines aren’t shown here.

include/linux/compiler-clang.h+6−0

This diff is large: its 13 lines aren’t shown here.

include/linux/compiler-version.h+14−0

This diff is large: its 15 lines aren’t shown here.

include/linux/cpu.h+3−0

This diff is large: its 17 lines aren’t shown here.

include/linux/efi.h+4−2

This diff is large: its 13 lines aren’t shown here.

include/linux/hugetlb_cgroup.h+13−2

This diff is large: its 43 lines aren’t shown here.

include/linux/if_macvlan.h+2−1

This diff is large: its 16 lines aren’t shown here.

include/linux/io_uring.h+0−25

This diff is large: its 32 lines aren’t shown here.

include/linux/irqdomain.h+0−4

This diff is large: its 18 lines aren’t shown here.

include/linux/kconfig.h+0−2

This diff is large: its 9 lines aren’t shown here.

include/linux/memblock.h+2−2

This diff is large: its 18 lines aren’t shown here.

include/linux/memcontrol.h+2−4

This diff is large: its 20 lines aren’t shown here.

include/linux/mlx5/qp.h+7−0

This diff is large: its 12 lines aren’t shown here.

include/linux/mm.h+36−3

This diff is large: its 60 lines aren’t shown here.

include/linux/mm_types.h+1−0

This diff is large: its 8 lines aren’t shown here.

include/linux/mmu_notifier.h+5−5

This diff is large: its 17 lines aren’t shown here.

include/linux/module.h+0−3

This diff is large: its 10 lines aren’t shown here.

include/linux/netdevice.h+2−0

This diff is large: its 16 lines aren’t shown here.

include/linux/netfilter/x_tables.h+2−5

This diff is large: its 28 lines aren’t shown here.

include/linux/pagemap.h+1−1

This diff is large: its 16 lines aren’t shown here.

include/linux/perf_event.h+2−0

This diff is large: its 16 lines aren’t shown here.

include/linux/pgtable.h+4−0

This diff is large: its 11 lines aren’t shown here.

include/linux/property.h+1−1

This diff is large: its 9 lines aren’t shown here.

include/linux/regulator/pca9450.h+3−0

This diff is large: its 10 lines aren’t shown here.

include/linux/restart_block.h+1−0

This diff is large: its 8 lines aren’t shown here.

include/linux/sched/mm.h+2−1

This diff is large: its 10 lines aren’t shown here.

include/linux/seqlock.h+1−4

This diff is large: its 12 lines aren’t shown here.

include/linux/skbuff.h+1−0

This diff is large: its 8 lines aren’t shown here.

include/linux/stop_machine.h+6−5

This diff is large: its 29 lines aren’t shown here.

include/linux/sunrpc/svc_rdma.h+0−1

This diff is large: its 8 lines aren’t shown here.

include/linux/thread_info.h+13−0

This diff is large: its 27 lines aren’t shown here.

include/linux/u64_stats_sync.h+4−3

This diff is large: its 17 lines aren’t shown here.

include/linux/usb.h+2−0

This diff is large: its 9 lines aren’t shown here.

include/linux/usb_usual.h+2−0

This diff is large: its 9 lines aren’t shown here.

include/linux/usermode_driver.h+1−0

This diff is large: its 7 lines aren’t shown here.

include/linux/vdpa.h+5−5

This diff is large: its 26 lines aren’t shown here.

include/linux/virtio.h+0−2

This diff is large: its 9 lines aren’t shown here.

include/linux/ww_mutex.h+3−2

This diff is large: its 13 lines aren’t shown here.

include/media/rc-map.h+7−0

This diff is large: its 14 lines aren’t shown here.

include/net/dst.h+11−0

This diff is large: its 16 lines aren’t shown here.

include/net/inet_connection_sock.h+1−1

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 17 lines aren’t shown here.

include/net/nexthop.h+24−0

This diff is large: its 38 lines aren’t shown here.

include/net/red.h+10−2

This diff is large: its 33 lines aren’t shown here.

include/net/rtnetlink.h+2−0

This diff is large: its 16 lines aren’t shown here.

include/net/sock.h+1−1

This diff is large: its 9 lines aren’t shown here.

include/trace/events/workqueue.h+3−3

This diff is large: its 25 lines aren’t shown here.

include/uapi/linux/bpf.h+11−5

This diff is large: its 38 lines aren’t shown here.

include/uapi/linux/fuse.h+2−1

This diff is large: its 10 lines aren’t shown here.

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

This diff is large: its 20 lines aren’t shown here.

include/xen/grant_table.h+7−0

This diff is large: its 14 lines aren’t shown here.

include/xen/xenbus.h+0−1

This diff is large: its 8 lines aren’t shown here.

init/Kconfig+5−6

This diff is large: its 25 lines aren’t shown here.

kernel/bpf/bpf_inode_storage.c+1−1

This diff is large: its 9 lines aren’t shown here.

kernel/bpf/bpf_struct_ops.c+1−1

This diff is large: its 9 lines aren’t shown here.

kernel/bpf/core.c+2−2

This diff is large: its 18 lines aren’t shown here.

kernel/bpf/preload/bpf_preload_kern.c+15−4

This diff is large: its 36 lines aren’t shown here.

kernel/bpf/syscall.c+5−0

This diff is large: its 12 lines aren’t shown here.

kernel/bpf/trampoline.c+168−50

This diff is large: its 293 lines aren’t shown here.

kernel/bpf/verifier.c+25−12

This diff is large: its 108 lines aren’t shown here.

kernel/events/core.c+38−4

This diff is large: its 109 lines aren’t shown here.

kernel/fork.c+8−0

This diff is large: its 22 lines aren’t shown here.

kernel/freezer.c+1−1

This diff is large: its 9 lines aren’t shown here.

kernel/futex.c+1−2

This diff is large: its 16 lines aren’t shown here.

kernel/gcov/clang.c+69−0

This diff is large: its 127 lines aren’t shown here.

kernel/irq/irq_sim.c+2−2

This diff is large: its 18 lines aren’t shown here.

kernel/irq/irqdomain.c+4−5

This diff is large: its 21 lines aren’t shown here.

kernel/irq/manage.c+4−0

This diff is large: its 16 lines aren’t shown here.

kernel/jump_label.c+8−0

This diff is large: its 15 lines aren’t shown here.

kernel/locking/mutex.c+14−11

This diff is large: its 104 lines aren’t shown here.

kernel/reboot.c+0−2

This diff is large: its 9 lines aren’t shown here.

kernel/sched/core.c+62−64

This diff is large: its 263 lines aren’t shown here.

kernel/sched/membarrier.c+1−3

This diff is large: its 11 lines aren’t shown here.

kernel/signal.c+5−1

This diff is large: its 20 lines aren’t shown here.

kernel/static_call.c+27−20

This diff is large: its 112 lines aren’t shown here.

kernel/sys.c+1−1

This diff is large: its 9 lines aren’t shown here.

kernel/time/alarmtimer.c+1−1

This diff is large: its 11 lines aren’t shown here.

kernel/time/hrtimer.c+40−22

This diff is large: its 99 lines aren’t shown here.

kernel/time/posix-cpu-timers.c+1−1

This diff is large: its 10 lines aren’t shown here.

kernel/trace/ftrace.c+38−5

This diff is large: its 82 lines aren’t shown here.

kernel/usermode_driver.c+15−6

This diff is large: its 29 lines aren’t shown here.

lib/Kconfig.kasan+1−0

This diff is large: its 8 lines aren’t shown here.

lib/math/div64.c+1−0

This diff is large: its 6 lines aren’t shown here.

mm/highmem.c+14−7

This diff is large: its 60 lines aren’t shown here.

mm/huge_memory.c+3−7

This diff is large: its 31 lines aren’t shown here.

mm/hugetlb.c+128−36

This diff is large: its 304 lines aren’t shown here.

mm/hugetlb_cgroup.c+8−2

This diff is large: its 24 lines aren’t shown here.

mm/internal.h+0−5

This diff is large: its 12 lines aren’t shown here.

mm/kfence/core.c+9−0

This diff is large: its 23 lines aren’t shown here.

mm/kfence/report.c+18−12

This diff is large: its 89 lines aren’t shown here.

mm/kmemleak.c+2−1

This diff is large: its 17 lines aren’t shown here.

mm/madvise.c+12−1

This diff is large: its 32 lines aren’t shown here.

mm/memcontrol.c+6−9

This diff is large: its 31 lines aren’t shown here.

mm/memory.c+9−7

This diff is large: its 39 lines aren’t shown here.

mm/memory_hotplug.c+1−1

This diff is large: its 9 lines aren’t shown here.

mm/mmu_notifier.c+23−0

This diff is large: its 34 lines aren’t shown here.

mm/page-writeback.c+16−0

This diff is large: its 23 lines aren’t shown here.

mm/page_alloc.c+82−85

This diff is large: its 223 lines aren’t shown here.

mm/slab.c+1−1

This diff is large: its 9 lines aren’t shown here.

mm/slub.c+1−1

This diff is large: its 9 lines aren’t shown here.

mm/z3fold.c+15−1

This diff is large: its 24 lines aren’t shown here.

net/batman-adv/main.c+0−1

This diff is large: its 8 lines aren’t shown here.

net/bridge/br_switchdev.c+2−0

This diff is large: its 9 lines aren’t shown here.

net/can/isotp.c+8−10

This diff is large: its 67 lines aren’t shown here.

net/core/dev.c+31−2

This diff is large: its 77 lines aren’t shown here.

net/core/drop_monitor.c+23−0

This diff is large: its 37 lines aren’t shown here.

net/core/dst.c+42−17

This diff is large: its 80 lines aren’t shown here.

net/core/filter.c+10−2

This diff is large: its 33 lines aren’t shown here.

net/core/flow_dissector.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/core/sock.c+28−16

This diff is large: its 58 lines aren’t shown here.

net/dccp/ipv6.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/dsa/dsa2.c+7−4

This diff is large: its 29 lines aren’t shown here.

net/ipv4/inet_connection_sock.c+5−2

This diff is large: its 18 lines aren’t shown here.

net/ipv4/ipconfig.c+8−6

This diff is large: its 33 lines aren’t shown here.

net/ipv4/netfilter/arp_tables.c+8−8

This diff is large: its 72 lines aren’t shown here.

net/ipv4/netfilter/ip_tables.c+8−8

This diff is large: its 72 lines aren’t shown here.

net/ipv4/route.c+8−37

This diff is large: its 53 lines aren’t shown here.

net/ipv4/tcp_minisocks.c+5−2

This diff is large: its 14 lines aren’t shown here.

net/ipv6/ip6_fib.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/ipv6/ip6_input.c+0−10

This diff is large: its 17 lines aren’t shown here.

net/ipv6/netfilter/ip6_tables.c+8−8

This diff is large: its 72 lines aren’t shown here.

net/ipv6/route.c+9−27

This diff is large: its 44 lines aren’t shown here.

net/ipv6/tcp_ipv6.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/mac80211/aead_api.c+3−2

This diff is large: its 21 lines aren’t shown here.

net/mac80211/aes_gmac.c+3−2

This diff is large: its 21 lines aren’t shown here.

net/mac80211/cfg.c+2−2

This diff is large: its 17 lines aren’t shown here.

net/mac80211/ibss.c+2−0

This diff is large: its 9 lines aren’t shown here.

net/mac80211/main.c+12−1

This diff is large: its 21 lines aren’t shown here.

net/mac80211/mlme.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/mac80211/rc80211_minstrel_ht.c+0−2

This diff is large: its 16 lines aren’t shown here.

net/mac80211/util.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/mptcp/options.c+14−10

This diff is large: its 75 lines aren’t shown here.

net/mptcp/protocol.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/mptcp/subflow.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/netfilter/nf_conntrack_netlink.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/netfilter/nf_conntrack_proto_gre.c+0−3

This diff is large: its 10 lines aren’t shown here.

net/netfilter/nf_flow_table_core.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/netfilter/nf_tables_api.c+21−1

This diff is large: its 65 lines aren’t shown here.

net/netfilter/x_tables.c+34−15

This diff is large: its 99 lines aren’t shown here.

net/openvswitch/conntrack.c+5−3

This diff is large: its 23 lines aren’t shown here.

net/openvswitch/conntrack.h+4−2

This diff is large: its 20 lines aren’t shown here.

net/openvswitch/flow.c+3−1

This diff is large: its 25 lines aren’t shown here.

net/qrtr/qrtr.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/sched/act_ct.c+4−2

This diff is large: its 27 lines aren’t shown here.

net/sched/cls_api.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/sched/cls_flower.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sched/sch_choke.c+4−3

This diff is large: its 28 lines aren’t shown here.

net/sched/sch_gred.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sched/sch_htb.c+13−6

This diff is large: its 60 lines aren’t shown here.

net/sched/sch_red.c+5−2

This diff is large: its 28 lines aren’t shown here.

net/sched/sch_sfq.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sctp/output.c+0−7

This diff is large: its 14 lines aren’t shown here.

net/sctp/outqueue.c+7−0

This diff is large: its 21 lines aren’t shown here.

net/sunrpc/auth_gss/svcauth_gss.c+7−4

This diff is large: its 30 lines aren’t shown here.

net/sunrpc/sched.c+4−1

This diff is large: its 13 lines aren’t shown here.

net/sunrpc/svc.c+4−2

This diff is large: its 27 lines aren’t shown here.

net/sunrpc/svc_xprt.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/sunrpc/xprtrdma/svc_rdma_backchannel.c+3−3

This diff is large: its 13 lines aren’t shown here.

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c+39−43

This diff is large: its 136 lines aren’t shown here.

net/tipc/node.c+8−3

This diff is large: its 26 lines aren’t shown here.

net/vmw_vsock/af_vsock.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/wireless/nl80211.c+8−4

This diff is large: its 47 lines aren’t shown here.

scripts/Makefile.lib+2−2

This diff is large: its 18 lines aren’t shown here.

scripts/dummy-tools/gcc+16−2

This diff is large: its 37 lines aren’t shown here.

scripts/gcc-plugins/Makefile+1−0

This diff is large: its 8 lines aren’t shown here.

scripts/ld-version.sh+14−8

This diff is large: its 37 lines aren’t shown here.

security/commoncap.c+1−11

This diff is large: its 26 lines aren’t shown here.

security/selinux/include/security.h+11−4

This diff is large: its 26 lines aren’t shown here.

security/selinux/selinuxfs.c+9−13

This diff is large: its 59 lines aren’t shown here.

security/selinux/ss/services.c+39−24

This diff is large: its 145 lines aren’t shown here.

sound/drivers/aloop.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/dummy.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/mtpav.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/mts64.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/pcsp/pcsp.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/portman2x4.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/serial-u16550.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/virmidi.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/firewire/dice/dice-stream.c+2−3

This diff is large: its 14 lines aren’t shown here.

sound/hda/intel-nhlt.c+5−0

This diff is large: its 12 lines aren’t shown here.

sound/isa/ad1816a/ad1816a.c+0−7

This diff is large: its 14 lines aren’t shown here.

sound/isa/ad1848/ad1848.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/isa/als100.c+0−11

This diff is large: its 18 lines aren’t shown here.

sound/isa/azt2320.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/isa/cmi8330.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/cs423x/cs4231.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/cs423x/cs4236.c+0−34

This diff is large: its 41 lines aren’t shown here.

sound/isa/es1688/es1688.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/isa/es18xx.c+1−9

This diff is large: its 19 lines aren’t shown here.

sound/isa/gus/gusclassic.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/gus/gusextreme.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/gus/gusmax.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/gus/interwave.c+0−6

This diff is large: its 15 lines aren’t shown here.

sound/isa/opl3sa2.c+0−5

This diff is large: its 12 lines aren’t shown here.

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

This diff is large: its 10 lines aren’t shown here.

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

This diff is large: its 18 lines aren’t shown here.

sound/isa/sb/jazz16.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/isa/sb/sb16.c+0−8

This diff is large: its 17 lines aren’t shown here.

sound/isa/sb/sb8.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/sc6000.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/isa/wavefront/wavefront.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/mips/sgio2audio.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ad1889.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ali5451/ali5451.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/als300.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/als4000.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/atiixp.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/atiixp_modem.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/au88x0/au88x0.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/azt3328.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/bt87x.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/ca0106/ca0106_main.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/cmipci.c+0−4

This diff is large: its 11 lines aren’t shown here.

sound/pci/cs4281.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/cs46xx/cs46xx.c+0−7

This diff is large: its 14 lines aren’t shown here.

sound/pci/cs5535audio/cs5535audio.c+0−1

This diff is large: its 5 lines aren’t shown here.

sound/pci/ctxfi/xfi.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/echoaudio/echoaudio.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/emu10k1/emu10k1.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/emu10k1/emu10k1x.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ens1370.c+0−8

This diff is large: its 18 lines aren’t shown here.

sound/pci/es1938.c+0−4

This diff is large: its 11 lines aren’t shown here.

sound/pci/es1968.c+0−4

This diff is large: its 11 lines aren’t shown here.

sound/pci/fm801.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/hda/hda_bind.c+4−0

This diff is large: its 11 lines aren’t shown here.

sound/pci/hda/hda_controller.c+0−7

This diff is large: its 14 lines aren’t shown here.

sound/pci/hda/hda_generic.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/pci/hda/hda_intel.c+2−34

This diff is large: its 50 lines aren’t shown here.

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

This diff is large: its 8 lines aren’t shown here.

sound/pci/hda/patch_conexant.c+45−17

This diff is large: its 119 lines aren’t shown here.

sound/pci/hda/patch_hdmi.c+13−0

This diff is large: its 27 lines aren’t shown here.

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

This diff is large: its 55 lines aren’t shown here.

sound/pci/ice1712/ice1712.c+0−6

This diff is large: its 13 lines aren’t shown here.

sound/pci/ice1712/ice1724.c+0−19

This diff is large: its 26 lines aren’t shown here.

sound/pci/intel8x0.c+0−23

This diff is large: its 30 lines aren’t shown here.

sound/pci/intel8x0m.c+0−15

This diff is large: its 22 lines aren’t shown here.

sound/pci/korg1212/korg1212.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/lola/lola.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/lx6464es/lx6464es.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/maestro3.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/pci/mixart/mixart.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/nm256/nm256.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/oxygen/oxygen.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/pci/oxygen/se6x.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/oxygen/virtuoso.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/pcxhr/pcxhr.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/riptide/riptide.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/rme32.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/rme96.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/pci/rme9652/hdsp.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/pci/rme9652/hdspm.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/rme9652/rme9652.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/sis7019.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/sonicvibes.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/trident/trident.c+0−12

This diff is large: its 19 lines aren’t shown here.

sound/pci/via82xx.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/via82xx_modem.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/vx222/vx222.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ymfpci/ymfpci.c+0−6

This diff is large: its 13 lines aren’t shown here.

sound/pcmcia/pdaudiocf/pdaudiocf.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pcmcia/vx/vxpocket.c+0−4

This diff is large: its 14 lines aren’t shown here.

sound/ppc/powermac.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sh/aica.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sh/sh_dac_audio.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/Kconfig+0−5

This diff is large: its 19 lines aren’t shown here.

sound/soc/codecs/ak4458.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/ak5558.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/cs42l42.c+34−78

This diff is large: its 195 lines aren’t shown here.

sound/soc/codecs/cs42l42.h+7−6

This diff is large: its 34 lines aren’t shown here.

sound/soc/codecs/es8316.c+2−7

This diff is large: its 16 lines aren’t shown here.

sound/soc/codecs/lpass-rx-macro.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/codecs/lpass-va-macro.c+13−15

This diff is large: its 52 lines aren’t shown here.

sound/soc/codecs/lpass-wsa-macro.c+11−9

This diff is large: its 49 lines aren’t shown here.

sound/soc/codecs/rt1015.c+2−0

This diff is large: its 16 lines aren’t shown here.

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

This diff is large: its 12 lines aren’t shown here.

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

This diff is large: its 12 lines aren’t shown here.

sound/soc/codecs/rt5659.c+5−0

This diff is large: its 18 lines aren’t shown here.

sound/soc/codecs/rt5670.c+96−14

This diff is large: its 157 lines aren’t shown here.

sound/soc/codecs/rt5670.h+5−4

This diff is large: its 25 lines aren’t shown here.

sound/soc/codecs/rt711.c+8−0

This diff is large: its 22 lines aren’t shown here.

sound/soc/codecs/sgtl5000.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/codecs/sirf-audio-codec.h+0−124

This diff is large: its 125 lines aren’t shown here.

sound/soc/codecs/wcd934x.c+6−0

This diff is large: its 13 lines aren’t shown here.

sound/soc/fsl/fsl_ssi.c+4−2

This diff is large: its 22 lines aren’t shown here.

sound/soc/generic/simple-card-utils.c+7−6

This diff is large: its 23 lines aren’t shown here.

sound/soc/intel/boards/bytcr_rt5640.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/mediatek/mt8192/mt8192-dai-tdm.c+3−1

This diff is large: its 11 lines aren’t shown here.

sound/soc/mediatek/mt8192/mt8192-reg.h+5−3

This diff is large: its 22 lines aren’t shown here.

sound/soc/qcom/lpass-cpu.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/qcom/sdm845.c+3−3

This diff is large: its 22 lines aren’t shown here.

sound/soc/soc-core.c+4−0

This diff is large: its 18 lines aren’t shown here.

sound/soc/sof/intel/hda-dsp.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/sof/intel/hda.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/sparc/amd7930.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sparc/cs4231.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sparc/dbri.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/usb/6fire/chip.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/usb/caiaq/device.c+0−14

This diff is large: its 21 lines aren’t shown here.

sound/usb/card.c+6−2

This diff is large: its 29 lines aren’t shown here.

sound/usb/hiface/chip.c+0−17

This diff is large: its 24 lines aren’t shown here.

sound/usb/misc/ua101.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/usb/mixer_quirks.c+2−2

This diff is large: its 18 lines aren’t shown here.

sound/usb/quirks.c+10−1

This diff is large: its 32 lines aren’t shown here.

sound/usb/usbaudio.h+1−0

This diff is large: its 8 lines aren’t shown here.

sound/usb/usx2y/usbusx2y.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/x86/intel_hdmi_audio.c+0−1

This diff is large: its 5 lines aren’t shown here.

sound/xen/xen_snd_front.c+0−1

This diff is large: its 5 lines aren’t shown here.

tools/lib/bpf/Makefile+1−1

This diff is large: its 9 lines aren’t shown here.

tools/lib/bpf/btf_dump.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/lib/bpf/libbpf.c+2−1

This diff is large: its 10 lines aren’t shown here.

tools/lib/bpf/netlink.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/objtool/check.c+3−0

This diff is large: its 10 lines aren’t shown here.

tools/testing/kunit/configs/broken_on_uml.config+2−0

This diff is large: its 6 lines aren’t shown here.

tools/testing/kunit/kunit_config.py+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/arm64/fp/sve-ptrace.c+1−1

This diff is large: its 7 lines aren’t shown here.

tools/testing/selftests/arm64/fp/sve-test.S+17−5

This diff is large: its 34 lines aren’t shown here.

tools/testing/selftests/bpf/prog_tests/check_mtu.c+4−0

This diff is large: its 18 lines aren’t shown here.

tools/testing/selftests/bpf/prog_tests/fexit_sleep.c+82−0

This diff is large: its 83 lines aren’t shown here.

tools/testing/selftests/bpf/progs/btf_dump_test_case_syntax.c+8−0

This diff is large: its 22 lines aren’t shown here.

tools/testing/selftests/bpf/progs/fexit_sleep.c+31−0

This diff is large: its 32 lines aren’t shown here.

tools/testing/selftests/bpf/progs/test_check_mtu.c+92−0

This diff is large: its 103 lines aren’t shown here.

tools/testing/selftests/bpf/progs/test_tunnel_kern.c+2−4

This diff is large: its 13 lines aren’t shown here.

tools/testing/selftests/bpf/verifier/bounds_deduction.c+19−8

This diff is large: its 103 lines aren’t shown here.

tools/testing/selftests/bpf/verifier/map_ptr.c+4−0

This diff is large: its 17 lines aren’t shown here.

tools/testing/selftests/bpf/verifier/unpriv.c+14−1

This diff is large: its 29 lines aren’t shown here.

tools/testing/selftests/bpf/verifier/value_ptr_arith.c+22−1

This diff is large: its 37 lines aren’t shown here.

tools/testing/selftests/kvm/.gitignore+3−0

This diff is large: its 14 lines aren’t shown here.

tools/testing/selftests/kvm/Makefile+3−0

This diff is large: its 16 lines aren’t shown here.

tools/testing/selftests/kvm/include/kvm_util.h+2−0

This diff is large: its 16 lines aren’t shown here.

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

This diff is large: its 18 lines aren’t shown here.

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

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/get_msr_index_features.c+134−0

This diff is large: its 135 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/hyperv_clock.c+260−0

This diff is large: its 261 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/set_boot_cpu_id.c+166−0

This diff is large: its 167 lines aren’t shown here.

tools/testing/selftests/net/forwarding/vxlan_bridge_1d.sh+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/net/mptcp/mptcp_join.sh+20−10

This diff is large: its 71 lines aren’t shown here.

tools/testing/selftests/net/reuseaddr_ports_exhausted.c+16−16

This diff is large: its 42 lines aren’t shown here.

tools/testing/selftests/vm/Makefile+2−2

This diff is large: its 18 lines aren’t shown here.

Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -195,7 +195,7 @@ static inline void regs_set_return_value(struct pt_regs *regs, unsigned long rc) · 194 unmodified lines
195	#define TRAP_FLAGS_MASK 0x11	195	#define TRAP_FLAGS_MASK 0x11
196	#define TRAP(regs) ((regs)->trap & ~TRAP_FLAGS_MASK)	196	#define TRAP(regs) ((regs)->trap & ~TRAP_FLAGS_MASK)
197	#define FULL_REGS(regs) (((regs)->trap & 1) == 0)	197	#define FULL_REGS(regs) (((regs)->trap & 1) == 0)
198	#define SET_FULL_REGS(regs) ((regs)->trap \|= 1)	198	#define SET_FULL_REGS(regs) ((regs)->trap &= ~1)
199	#endif	199	#endif
200	#define CHECK_FULL_REGS(regs) BUG_ON(!FULL_REGS(regs))	200	#define CHECK_FULL_REGS(regs) BUG_ON(!FULL_REGS(regs))
201	#define NV_REG_POISON 0xdeadbeefdeadbeefUL	201	#define NV_REG_POISON 0xdeadbeefdeadbeefUL
@@ -210,7 +210,7 @@ static inline void regs_set_return_value(struct pt_regs *regs, unsigned long rc) · 8 unmodified lines
210	#define TRAP_FLAGS_MASK 0x1F	210	#define TRAP_FLAGS_MASK 0x1F
211	#define TRAP(regs) ((regs)->trap & ~TRAP_FLAGS_MASK)	211	#define TRAP(regs) ((regs)->trap & ~TRAP_FLAGS_MASK)
212	#define FULL_REGS(regs) (((regs)->trap & 1) == 0)	212	#define FULL_REGS(regs) (((regs)->trap & 1) == 0)
213	#define SET_FULL_REGS(regs) ((regs)->trap \|= 1)	213	#define SET_FULL_REGS(regs) ((regs)->trap &= ~1)
214	#define IS_CRITICAL_EXC(regs) (((regs)->trap & 2) != 0)	214	#define IS_CRITICAL_EXC(regs) (((regs)->trap & 2) != 0)
215	#define IS_MCHECK_EXC(regs) (((regs)->trap & 4) != 0)	215	#define IS_MCHECK_EXC(regs) (((regs)->trap & 4) != 0)
216	#define IS_DEBUG_EXC(regs) (((regs)->trap & 8) != 0)	216	#define IS_DEBUG_EXC(regs) (((regs)->trap & 8) != 0)

@@ -229,10 +229,10 @@ static struct bio bounce_clone_bio(struct bio bio_src) · 228 unmodified lines
229	* - The point of cloning the biovec is to produce a bio with a biovec	229	* - The point of cloning the biovec is to produce a bio with a biovec
230	* the caller can modify: bi_idx and bi_bvec_done should be 0.	230	* the caller can modify: bi_idx and bi_bvec_done should be 0.
231	*	231	*
232	* - The original bio could've had more than BIO_MAX_PAGES biovecs; if	232	* - The original bio could've had more than BIO_MAX_VECS biovecs; if
233	* we tried to clone the whole thing bio_alloc_bioset() would fail.	233	* we tried to clone the whole thing bio_alloc_bioset() would fail.
234	* But the clone should succeed as long as the number of biovecs we	234	* But the clone should succeed as long as the number of biovecs we
235	* actually need to allocate is fewer than BIO_MAX_PAGES.	235	* actually need to allocate is fewer than BIO_MAX_VECS.
236	*	236	*
237	* - Lastly, bi_vcnt should not be looked at or relied upon by code	237	* - Lastly, bi_vcnt should not be looked at or relied upon by code
238	* that does not own the bio - reason being drivers don't use it for	238	* that does not own the bio - reason being drivers don't use it for
@@ -299,7 +299,7 @@ static void __blk_queue_bounce(struct request_queue q, struct bio *bio_orig, · 60 unmodified lines
299	int sectors = 0;	299	int sectors = 0;
300		300
301	bio_for_each_segment(from, *bio_orig, iter) {	301	bio_for_each_segment(from, *bio_orig, iter) {
302	if (i++ < BIO_MAX_PAGES)	302	if (i++ < BIO_MAX_VECS)
303	sectors += from.bv_len >> 9;	303	sectors += from.bv_len >> 9;
304	if (page_to_pfn(from.bv_page) > q->limits.bounce_pfn)	304	if (page_to_pfn(from.bv_page) > q->limits.bounce_pfn)
305	bounce = true;	305	bounce = true;

@@ -229,7 +229,7 @@ static DEFINE_SPINLOCK(dm_crypt_clients_lock); · 228 unmodified lines
229	static unsigned dm_crypt_clients_n = 0;	229	static unsigned dm_crypt_clients_n = 0;
230	static volatile unsigned long dm_crypt_pages_per_client;	230	static volatile unsigned long dm_crypt_pages_per_client;
231	#define DM_CRYPT_MEMORY_PERCENT 2	231	#define DM_CRYPT_MEMORY_PERCENT 2
232	#define DM_CRYPT_MIN_PAGES_PER_CLIENT (BIO_MAX_PAGES * 16)	232	#define DM_CRYPT_MIN_PAGES_PER_CLIENT (BIO_MAX_VECS * 16)
233		233
234	static void clone_init(struct dm_crypt_io , struct bio );	234	static void clone_init(struct dm_crypt_io , struct bio );
235	static void kcryptd_queue_crypt(struct dm_crypt_io *io);	235	static void kcryptd_queue_crypt(struct dm_crypt_io *io);
@@ -3246,7 +3246,7 @@ static int crypt_ctr(struct dm_target ti, unsigned int argc, char *argv) · 3010 unmodified lines
3246	ALIGN(sizeof(struct dm_crypt_io) + cc->dmreq_start + additional_req_size,	3246	ALIGN(sizeof(struct dm_crypt_io) + cc->dmreq_start + additional_req_size,
3247	ARCH_KMALLOC_MINALIGN);	3247	ARCH_KMALLOC_MINALIGN);
3248		3248
3249	ret = mempool_init(&cc->page_pool, BIO_MAX_PAGES, crypt_page_alloc, crypt_page_free, cc);	3249	ret = mempool_init(&cc->page_pool, BIO_MAX_VECS, crypt_page_alloc, crypt_page_free, cc);
3250	if (ret) {	3250	if (ret) {
3251	ti->error = "Cannot allocate page mempool";	3251	ti->error = "Cannot allocate page mempool";
3252	goto bad;	3252	goto bad;
@@ -3373,9 +3373,9 @@ static int crypt_map(struct dm_target ti, struct bio bio) · 120 unmodified lines
3373	/*	3373	/*
3374	* Check if bio is too large, split as needed.	3374	* Check if bio is too large, split as needed.
3375	*/	3375	*/
3376	if (unlikely(bio->bi_iter.bi_size > (BIO_MAX_PAGES << PAGE_SHIFT)) &&	3376	if (unlikely(bio->bi_iter.bi_size > (BIO_MAX_VECS << PAGE_SHIFT)) &&
3377	(bio_data_dir(bio) == WRITE \|\| cc->on_disk_tag_size))	3377	(bio_data_dir(bio) == WRITE \|\| cc->on_disk_tag_size))
3378	dm_accept_partial_bio(bio, ((BIO_MAX_PAGES << PAGE_SHIFT) >> SECTOR_SHIFT));	3378	dm_accept_partial_bio(bio, ((BIO_MAX_VECS << PAGE_SHIFT) >> SECTOR_SHIFT));
3379		3379
3380	/*	3380	/*
3381	* Ensure that bio is a multiple of internal sector encryption size	3381	* Ensure that bio is a multiple of internal sector encryption size

@@ -349,7 +349,7 @@ static int nvme_loop_configure_admin_queue(struct nvme_loop_ctrl *ctrl) · 348 unmodified lines
349	memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));	349	memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));
350	ctrl->admin_tag_set.ops = &nvme_loop_admin_mq_ops;	350	ctrl->admin_tag_set.ops = &nvme_loop_admin_mq_ops;
351	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;	351	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;
352	ctrl->admin_tag_set.reserved_tags = 2; /* connect + keep-alive */	352	ctrl->admin_tag_set.reserved_tags = NVMF_RESERVED_TAGS;
353	ctrl->admin_tag_set.numa_node = ctrl->ctrl.numa_node;	353	ctrl->admin_tag_set.numa_node = ctrl->ctrl.numa_node;
354	ctrl->admin_tag_set.cmd_size = sizeof(struct nvme_loop_iod) +	354	ctrl->admin_tag_set.cmd_size = sizeof(struct nvme_loop_iod) +
355	NVME_INLINE_SG_CNT * sizeof(struct scatterlist);	355	NVME_INLINE_SG_CNT * sizeof(struct scatterlist);
@@ -520,7 +520,7 @@ static int nvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl) · 164 unmodified lines
520	memset(&ctrl->tag_set, 0, sizeof(ctrl->tag_set));	520	memset(&ctrl->tag_set, 0, sizeof(ctrl->tag_set));
521	ctrl->tag_set.ops = &nvme_loop_mq_ops;	521	ctrl->tag_set.ops = &nvme_loop_mq_ops;
522	ctrl->tag_set.queue_depth = ctrl->ctrl.opts->queue_size;	522	ctrl->tag_set.queue_depth = ctrl->ctrl.opts->queue_size;
523	ctrl->tag_set.reserved_tags = 1; /* fabric connect */	523	ctrl->tag_set.reserved_tags = NVMF_RESERVED_TAGS;
524	ctrl->tag_set.numa_node = ctrl->ctrl.numa_node;	524	ctrl->tag_set.numa_node = ctrl->ctrl.numa_node;
525	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;	525	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
526	ctrl->tag_set.cmd_size = sizeof(struct nvme_loop_iod) +	526	ctrl->tag_set.cmd_size = sizeof(struct nvme_loop_iod) +

@@ -257,7 +257,7 @@ struct smb_version_operations { · 256 unmodified lines
257	/* verify the message */	257	/* verify the message */
258	int (check_message)(char , unsigned int, struct TCP_Server_Info *);	258	int (check_message)(char , unsigned int, struct TCP_Server_Info *);
259	bool (is_oplock_break)(char , struct TCP_Server_Info *);	259	bool (is_oplock_break)(char , struct TCP_Server_Info *);
260	int (handle_cancelled_mid)(char , struct TCP_Server_Info *);	260	int (handle_cancelled_mid)(struct mid_q_entry , struct TCP_Server_Info *);
261	void (downgrade_oplock)(struct TCP_Server_Info server,	261	void (downgrade_oplock)(struct TCP_Server_Info server,
262	struct cifsInodeInfo *cinode, __u32 oplock,	262	struct cifsInodeInfo *cinode, __u32 oplock,
263	unsigned int epoch, bool *purge_cache);	263	unsigned int epoch, bool *purge_cache);
@@ -1705,16 +1705,17 @@ static inline bool is_retryable_error(int error) · 1441 unmodified lines
1705	#define CIFS_NO_RSP_BUF 0x040 /* no response buffer required */	1705	#define CIFS_NO_RSP_BUF 0x040 /* no response buffer required */
1706		1706
1707	/* Type of request operation */	1707	/* Type of request operation */
1708	#define CIFS_ECHO_OP 0x080 /* echo request */	1708	#define CIFS_ECHO_OP 0x080 /* echo request */
1709	#define CIFS_OBREAK_OP 0x0100 /* oplock break request */	1709	#define CIFS_OBREAK_OP 0x0100 /* oplock break request */
1710	#define CIFS_NEG_OP 0x0200 /* negotiate request */	1710	#define CIFS_NEG_OP 0x0200 /* negotiate request */
		1711	#define CIFS_CP_CREATE_CLOSE_OP 0x0400 /* compound create+close request */
1711	/* Lower bitmask values are reserved by others below. */	1712	/* Lower bitmask values are reserved by others below. */
1712	#define CIFS_SESS_OP 0x2000 /* session setup request */	1713	#define CIFS_SESS_OP 0x2000 /* session setup request */
1713	#define CIFS_OP_MASK 0x2380 /* mask request type */	1714	#define CIFS_OP_MASK 0x2780 /* mask request type */
1714		1715
1715	#define CIFS_HAS_CREDITS 0x0400 /* already has credits */	1716	#define CIFS_HAS_CREDITS 0x0400 /* already has credits */
1716	#define CIFS_TRANSFORM_REQ 0x0800 /* transform request before sending */	1717	#define CIFS_TRANSFORM_REQ 0x0800 /* transform request before sending */
1717	#define CIFS_NO_SRV_RSP 0x1000 /* there is no server response */	1718	#define CIFS_NO_SRV_RSP 0x1000 /* there is no server response */
1718		1719
1719	/* Security Flags: indicate type of session setup needed */	1720	/* Security Flags: indicate type of session setup needed */
1720	#define CIFSSEC_MAY_SIGN 0x00001	1721	#define CIFSSEC_MAY_SIGN 0x00001