lael-labs/linux

.clang-format+21−4

   - 'bio_for_each_segment_all'
   - 'bio_list_for_each'
   - 'bip_for_each_vec'
+  - 'bitmap_for_each_clear_region'
+  - 'bitmap_for_each_set_region'
   - 'blkg_for_each_descendant_post'
   - 'blkg_for_each_descendant_pre'
   - 'blk_queue_for_each_rl'
   - 'drm_client_for_each_connector_iter'
   - 'drm_client_for_each_modeset'
   - 'drm_connector_for_each_possible_encoder'
+  - 'drm_for_each_bridge_in_chain'
   - 'drm_for_each_connector_iter'
   - 'drm_for_each_crtc'
   - 'drm_for_each_encoder'
   - 'for_each_bio'
   - 'for_each_board_func_rsrc'
   - 'for_each_bvec'
+  - 'for_each_card_auxs'
+  - 'for_each_card_auxs_safe'
   - 'for_each_card_components'
-  - 'for_each_card_links'
+  - 'for_each_card_pre_auxs'
-  - 'for_each_card_links_safe'
   - 'for_each_card_prelinks'
   - 'for_each_card_rtds'
   - 'for_each_card_rtds_safe'
   - 'for_each_dpcm_fe'
   - 'for_each_drhd_unit'
   - 'for_each_dss_dev'
+  - 'for_each_efi_handle'
   - 'for_each_efi_memory_desc'
   - 'for_each_efi_memory_desc_in_map'
   - 'for_each_element'
   - 'for_each_lru'
   - 'for_each_matching_node'
   - 'for_each_matching_node_and_match'
+  - 'for_each_member'
   - 'for_each_memblock'
   - 'for_each_memblock_type'
   - 'for_each_memcg_cache_index'
   - 'for_each_msi_entry'
   - 'for_each_msi_entry_safe'
   - 'for_each_net'
+  - 'for_each_net_continue_reverse'
   - 'for_each_netdev'
   - 'for_each_netdev_continue'
   - 'for_each_netdev_continue_rcu'
+  - 'for_each_netdev_continue_reverse'
   - 'for_each_netdev_feature'
   - 'for_each_netdev_in_bond_rcu'
   - 'for_each_netdev_rcu'
   - 'for_each_reserved_mem_region'
   - 'for_each_rtd_codec_dai'
   - 'for_each_rtd_codec_dai_rollback'
-  - 'for_each_rtdcom'
+  - 'for_each_rtd_components'
-  - 'for_each_rtdcom_safe'
   - 'for_each_set_bit'
   - 'for_each_set_bit_from'
+  - 'for_each_set_clump8'
   - 'for_each_sg'
   - 'for_each_sg_dma_page'
   - 'for_each_sg_page'
   - 'for_each_subelement_id'
   - '__for_each_thread'
   - 'for_each_thread'
+  - 'for_each_wakeup_source'
   - 'for_each_zone'
   - 'for_each_zone_zonelist'
   - 'for_each_zone_zonelist_nodemask'
   - 'list_for_each'
   - 'list_for_each_codec'
   - 'list_for_each_codec_safe'
+  - 'list_for_each_continue'
   - 'list_for_each_entry'
   - 'list_for_each_entry_continue'
   - 'list_for_each_entry_continue_rcu'
   - 'llist_for_each_entry'
   - 'llist_for_each_entry_safe'
   - 'llist_for_each_safe'
+  - 'mci_for_each_dimm'
   - 'media_device_for_each_entity'
   - 'media_device_for_each_intf'
   - 'media_device_for_each_link'
   - 'virtio_device_for_each_vq'
   - 'xa_for_each'
   - 'xa_for_each_marked'
+  - 'xa_for_each_range'
   - 'xa_for_each_start'
   - 'xas_for_each'
   - 'xas_for_each_conflict'
   - 'xas_for_each_marked'
+  - 'xbc_array_for_each_value'
+  - 'xbc_for_each_key_value'
+  - 'xbc_node_for_each_array_value'
+  - 'xbc_node_for_each_child'
+  - 'xbc_node_for_each_key_value'
   - 'zorro_for_each_dev'
 #IncludeBlocks: Preserve # Unknown to clang-format-5.0

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

 +----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX GICv3  | #23154          | CAVIUM_ERRATUM_23154        |
 +----------------+-----------------+-----------------+-----------------------------+
+| Cavium         | ThunderX GICv3  | #38539          | N/A                         |
++----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX Core   | #27456          | CAVIUM_ERRATUM_27456        |
 +----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX Core   | #30115          | CAVIUM_ERRATUM_30115        |

Documentation/devicetree/bindings/net/fsl-fman.txt+7−0

@@ -110,6 +110,13 @@ PROPERTIES · 109 unmodified lines
110	Usage: required	110	Usage: required
111	Definition: See soc/fsl/qman.txt and soc/fsl/bman.txt	111	Definition: See soc/fsl/qman.txt and soc/fsl/bman.txt
112		112
		113	- fsl,erratum-a050385
		114	Usage: optional
		115	Value type: boolean
		116	Definition: A boolean property. Indicates the presence of the
		117	erratum A050385 which indicates that DMA transactions that are
		118	split can result in a FMan lock.
		119
113	=============================================================================	120	=============================================================================
114	FMan MURAM Node	121	FMan MURAM Node
115		122

Documentation/filesystems/porting.rst+8−0

@@ -850,3 +850,11 @@ business doing so. · 849 unmodified lines
850	d_alloc_pseudo() is internal-only; uses outside of alloc_file_pseudo() are	850	d_alloc_pseudo() is internal-only; uses outside of alloc_file_pseudo() are
851	very suspect (and won't work in modules). Such uses are very likely to	851	very suspect (and won't work in modules). Such uses are very likely to
852	be misspelled d_alloc_anon().	852	be misspelled d_alloc_anon().
		853
		854	---
		855
		856	mandatory
		857
		858	[should've been added in 2016] stale comment in finish_open() nonwithstanding,
		859	failure exits in ->atomic_open() instances should NOT fput() the file,
		860	no matter what. Everything is handled by the caller.

Documentation/kbuild/kbuild.rst+1−1

@@ -237,7 +237,7 @@ This is solely useful to speed up test compiles. · 236 unmodified lines
237	KBUILD_EXTRA_SYMBOLS	237	KBUILD_EXTRA_SYMBOLS
238	--------------------	238	--------------------
239	For modules that use symbols from other modules.	239	For modules that use symbols from other modules.
240	See more details in modules.txt.	240	See more details in modules.rst.
241		241
242	ALLSOURCE_ARCHS	242	ALLSOURCE_ARCHS
243	---------------	243	---------------

Documentation/kbuild/kconfig-macro-language.rst+1−1

@@ -44,7 +44,7 @@ intermediate:: · 43 unmodified lines
44	def_bool y	44	def_bool y
45		45
46	Then, Kconfig moves onto the evaluation stage to resolve inter-symbol	46	Then, Kconfig moves onto the evaluation stage to resolve inter-symbol
47	dependency as explained in kconfig-language.txt.	47	dependency as explained in kconfig-language.rst.
48		48
49		49
50	Variables	50	Variables

Documentation/kbuild/makefiles.rst+3−3

@@ -924,7 +924,7 @@ When kbuild executes, the following steps are followed (roughly): · 923 unmodified lines
924	$(KBUILD_AFLAGS_MODULE) is used to add arch-specific options that	924	$(KBUILD_AFLAGS_MODULE) is used to add arch-specific options that
925	are used for assembler.	925	are used for assembler.
926		926
927	From commandline AFLAGS_MODULE shall be used (see kbuild.txt).	927	From commandline AFLAGS_MODULE shall be used (see kbuild.rst).
928		928
929	KBUILD_CFLAGS_KERNEL	929	KBUILD_CFLAGS_KERNEL
930	$(CC) options specific for built-in	930	$(CC) options specific for built-in
@@ -937,7 +937,7 @@ When kbuild executes, the following steps are followed (roughly): · 6 unmodified lines
937		937
938	$(KBUILD_CFLAGS_MODULE) is used to add arch-specific options that	938	$(KBUILD_CFLAGS_MODULE) is used to add arch-specific options that
939	are used for $(CC).	939	are used for $(CC).
940	From commandline CFLAGS_MODULE shall be used (see kbuild.txt).	940	From commandline CFLAGS_MODULE shall be used (see kbuild.rst).
941		941
942	KBUILD_LDFLAGS_MODULE	942	KBUILD_LDFLAGS_MODULE
943	Options for $(LD) when linking modules	943	Options for $(LD) when linking modules
@@ -945,7 +945,7 @@ When kbuild executes, the following steps are followed (roughly): · 1 unmodified line
945	$(KBUILD_LDFLAGS_MODULE) is used to add arch-specific options	945	$(KBUILD_LDFLAGS_MODULE) is used to add arch-specific options
946	used when linking modules. This is often a linker script.	946	used when linking modules. This is often a linker script.
947		947
948	From commandline LDFLAGS_MODULE shall be used (see kbuild.txt).	948	From commandline LDFLAGS_MODULE shall be used (see kbuild.rst).
949		949
950	KBUILD_LDS	950	KBUILD_LDS
951		951

Documentation/kbuild/modules.rst+2−2

@@ -470,9 +470,9 @@ build. · 469 unmodified lines
470		470
471	The syntax of the Module.symvers file is::	471	The syntax of the Module.symvers file is::
472		472
473	<CRC> <Symbol> <Namespace> <Module> <Export Type>	473	<CRC> <Symbol> <Module> <Export Type> <Namespace>
474		474
475	0xe1cc2a05 usb_stor_suspend USB_STORAGE drivers/usb/storage/usb-storage EXPORT_SYMBOL_GPL	475	0xe1cc2a05 usb_stor_suspend drivers/usb/storage/usb-storage EXPORT_SYMBOL_GPL USB_STORAGE
476		476
477	The fields are separated by tabs and values may be empty (e.g.	477	The fields are separated by tabs and values may be empty (e.g.
478	if no namespace is defined for an exported symbol).	478	if no namespace is defined for an exported symbol).

Documentation/networking/devlink/devlink-region.rst+0−3

@@ -40,9 +40,6 @@ example usage · 39 unmodified lines
40	# Delete a snapshot using:	40	# Delete a snapshot using:
41	$ devlink region del pci/0000:00:05.0/cr-space snapshot 1	41	$ devlink region del pci/0000:00:05.0/cr-space snapshot 1
42		42
43	# Trigger (request) a snapshot be taken:
44	$ devlink region trigger pci/0000:00:05.0/cr-space
45
46	# Dump a snapshot:	43	# Dump a snapshot:
47	$ devlink region dump pci/0000:00:05.0/fw-health snapshot 1	44	$ devlink region dump pci/0000:00:05.0/fw-health snapshot 1
48	0000000000000000 0014 95dc 0014 9514 0035 1670 0034 db30	45	0000000000000000 0014 95dc 0014 9514 0035 1670 0034 db30

Documentation/networking/net_failover.rst+3−3

@@ -8,9 +8,9 @@ Overview · 7 unmodified lines
8	========	8	========
9		9
10	The net_failover driver provides an automated failover mechanism via APIs	10	The net_failover driver provides an automated failover mechanism via APIs
11	to create and destroy a failover master netdev and mananges a primary and	11	to create and destroy a failover master netdev and manages a primary and
12	standby slave netdevs that get registered via the generic failover	12	standby slave netdevs that get registered via the generic failover
13	infrastructrure.	13	infrastructure.
14		14
15	The failover netdev acts a master device and controls 2 slave devices. The	15	The failover netdev acts a master device and controls 2 slave devices. The
16	original paravirtual interface is registered as 'standby' slave netdev and	16	original paravirtual interface is registered as 'standby' slave netdev and
@@ -29,7 +29,7 @@ virtio-net accelerated datapath: STANDBY mode · 12 unmodified lines
29	=============================================	29	=============================================
30		30
31	net_failover enables hypervisor controlled accelerated datapath to virtio-net	31	net_failover enables hypervisor controlled accelerated datapath to virtio-net
32	enabled VMs in a transparent manner with no/minimal guest userspace chanages.	32	enabled VMs in a transparent manner with no/minimal guest userspace changes.
33		33
34	To support this, the hypervisor needs to enable VIRTIO_NET_F_STANDBY	34	To support this, the hypervisor needs to enable VIRTIO_NET_F_STANDBY
35	feature on the virtio-net interface and assign the same MAC address to both	35	feature on the virtio-net interface and assign the same MAC address to both

Documentation/networking/rds.txt+1−1

@@ -159,7 +159,7 @@ Socket Interface · 158 unmodified lines
159	set SO_RDS_TRANSPORT on a socket for which the transport has	159	set SO_RDS_TRANSPORT on a socket for which the transport has
160	been previously attached explicitly (by SO_RDS_TRANSPORT) or	160	been previously attached explicitly (by SO_RDS_TRANSPORT) or
161	implicitly (via bind(2)) will return an error of EOPNOTSUPP.	161	implicitly (via bind(2)) will return an error of EOPNOTSUPP.
162	An attempt to set SO_RDS_TRANSPPORT to RDS_TRANS_NONE will	162	An attempt to set SO_RDS_TRANSPORT to RDS_TRANS_NONE will
163	always return EINVAL.	163	always return EINVAL.
164		164
165	RDMA for RDS	165	RDMA for RDS

MAINTAINERS+2−4

 CISCO VIC ETHERNET NIC DRIVER
 M:	Christian Benvenuti <benve@cisco.com>
 M:	Govindarajulu Varadarajan <_govind@gmx.com>
-M:	Parvi Kaustubhi <pkaustub@cisco.com>
 S:	Supported
 F:	drivers/net/ethernet/cisco/enic/
 F:	include/uapi/rdma/cxgb4-abi.h
 CXGB4VF ETHERNET DRIVER (CXGB4VF)
-M:	Casey Leedom <leedom@chelsio.com>
+M:	Vishal Kulkarni <vishal@gmail.com>
 L:	netdev@vger.kernel.org
 W:	http://www.chelsio.com
 S:	Supported
 F:	drivers/scsi/be2iscsi/
 Emulex 10Gbps NIC BE2, BE3-R, Lancer, Skyhawk-R DRIVER (be2net)
-M:	Sathya Perla <sathya.perla@broadcom.com>
 M:	Ajit Khaparde <ajit.khaparde@broadcom.com>
 M:	Sriharsha Basavapatna <sriharsha.basavapatna@broadcom.com>
 M:	Somnath Kotur <somnath.kotur@broadcom.com>
 L:	linux-mips@vger.kernel.org
 W:	http://www.linux-mips.org/
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mips/linux.git
-Q:	http://patchwork.linux-mips.org/project/linux-mips/list/
+Q:	https://patchwork.kernel.org/project/linux-mips/list/
 S:	Maintained
 F:	Documentation/devicetree/bindings/mips/
 F:	Documentation/mips/

Makefile+2−2

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 6	3	PATCHLEVEL = 6
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc5	5	EXTRAVERSION = -rc7
6	NAME = Kleptomaniac Octopus	6	NAME = Kleptomaniac Octopus
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION
@@ -1804,7 +1804,7 @@ existing-targets := $(wildcard $(sort $(targets))) · 1795 unmodified lines
1804		1804
1805	-include $(foreach f,$(existing-targets),$(dir $(f)).$(notdir $(f)).cmd)	1805	-include $(foreach f,$(existing-targets),$(dir $(f)).$(notdir $(f)).cmd)
1806		1806
1807	endif # config-targets	1807	endif # config-build
1808	endif # mixed-build	1808	endif # mixed-build
1809	endif # need-sub-make	1809	endif # need-sub-make
1810		1810

arch/arc/Kconfig+2−2

@@ -154,7 +154,7 @@ config ARC_CPU_HS · 153 unmodified lines
154	help	154	help
155	Support for ARC HS38x Cores based on ARCv2 ISA	155	Support for ARC HS38x Cores based on ARCv2 ISA
156	The notable features are:	156	The notable features are:
157	- SMP configurations of upto 4 core with coherency	157	- SMP configurations of up to 4 cores with coherency
158	- Optional L2 Cache and IO-Coherency	158	- Optional L2 Cache and IO-Coherency
159	- Revised Interrupt Architecture (multiple priorites, reg banks,	159	- Revised Interrupt Architecture (multiple priorites, reg banks,
160	auto stack switch, auto regfile save/restore)	160	auto stack switch, auto regfile save/restore)
@@ -192,7 +192,7 @@ config ARC_SMP_HALT_ON_RESET · 31 unmodified lines
192	help	192	help
193	In SMP configuration cores can be configured as Halt-on-reset	193	In SMP configuration cores can be configured as Halt-on-reset
194	or they could all start at same time. For Halt-on-reset, non	194	or they could all start at same time. For Halt-on-reset, non
195	masters are parked until Master kicks them so they can start of	195	masters are parked until Master kicks them so they can start off
196	at designated entry point. For other case, all jump to common	196	at designated entry point. For other case, all jump to common
197	entry point and spin wait for Master's signal.	197	entry point and spin wait for Master's signal.
198		198

arch/arc/configs/nps_defconfig+0−2

 CONFIG_MODULE_FORCE_LOAD=y
 CONFIG_MODULE_UNLOAD=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ARC_PLAT_EZNPS=y
 CONFIG_SMP=y
 CONFIG_NR_CPUS=4096

arch/arc/configs/nsimosci_defconfig+0−2

 CONFIG_KPROBES=y
 CONFIG_MODULES=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ARC_BUILTIN_DTB_NAME="nsimosci"
 # CONFIG_COMPACTION is not set
 CONFIG_NET=y

arch/arc/configs/nsimosci_hs_defconfig+0−2

 CONFIG_KPROBES=y
 CONFIG_MODULES=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ISA_ARCV2=y
 CONFIG_ARC_BUILTIN_DTB_NAME="nsimosci_hs"
 # CONFIG_COMPACTION is not set

arch/arc/configs/nsimosci_hs_smp_defconfig+0−2

 CONFIG_KPROBES=y
 CONFIG_MODULES=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ISA_ARCV2=y
 CONFIG_SMP=y
 # CONFIG_ARC_TIMERS_64BIT is not set

arch/arc/include/asm/fpu.h+2−0

@@ -43,6 +43,8 @@ extern void fpu_init_task(struct pt_regs *regs); · 42 unmodified lines
43		43
44	#endif /* !CONFIG_ISA_ARCOMPACT */	44	#endif /* !CONFIG_ISA_ARCOMPACT */
45		45
		46	struct task_struct;
		47
46	extern void fpu_save_restore(struct task_struct p, struct task_struct n);	48	extern void fpu_save_restore(struct task_struct p, struct task_struct n);
47		49
48	#else /* !CONFIG_ARC_FPU_SAVE_RESTORE */	50	#else /* !CONFIG_ARC_FPU_SAVE_RESTORE */

arch/arc/include/asm/linkage.h+2−0

@@ -29,6 +29,8 @@ · 28 unmodified lines
29	.endm	29	.endm
30		30
31	#define ASM_NL ` /* use '`' to mark new line in macro */	31	#define ASM_NL ` /* use '`' to mark new line in macro */
		32	#define __ALIGN .align 4
		33	#define __ALIGN_STR __stringify(__ALIGN)
32		34
33	/* annotation for data we want in DCCM - if enabled in .config */	35	/* annotation for data we want in DCCM - if enabled in .config */
34	.macro ARCFP_DATA nm	36	.macro ARCFP_DATA nm

arch/arc/kernel/setup.c+1−1

 #include <linux/delay.h>
 #include <linux/root_dev.h>
 #include <linux/clk.h>
-#include <linux/clk-provider.h>
 #include <linux/clocksource.h>
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/cpu.h>
+#include <linux/of_clk.h>
 #include <linux/of_fdt.h>
 #include <linux/of.h>
 #include <linux/cache.h>

arch/arc/kernel/troubleshoot.c+12−15

 			if (IS_ERR(nm))
 				nm = "?";
 		}
-		pr_info("    @off 0x%lx in [%s]\n"
+		pr_info("  @off 0x%lx in [%s]  VMA: 0x%08lx to 0x%08lx\n",
-			"    VMA: 0x%08lx to 0x%08lx\n",
 			vma->vm_start < TASK_UNMAPPED_BASE ?
 				address : address - vma->vm_start,
 			nm, vma->vm_start, vma->vm_end);
 	unsigned int vec, cause_code;
 	unsigned long address;
-	pr_info("\n[ECR   ]: 0x%08lx => ", regs->event);
 	/* For Data fault, this is data address not instruction addr */
 	address = current->thread.fault_address;
 	/* For DTLB Miss or ProtV, display the memory involved too */
 	if (vec == ECR_V_DTLB_MISS) {
-		pr_cont("Invalid %s @ 0x%08lx by insn @ 0x%08lx\n",
+		pr_cont("Invalid %s @ 0x%08lx by insn @ %pS\n",
 		       (cause_code == 0x01) ? "Read" :
 		       ((cause_code == 0x02) ? "Write" : "EX"),
-		       address, regs->ret);
+		       address, (void *)regs->ret);
 	} else if (vec == ECR_V_ITLB_MISS) {
 		pr_cont("Insn could not be fetched\n");
 	} else if (vec == ECR_V_MACH_CHK) {
 	show_ecr_verbose(regs);
-	pr_info("[EFA   ]: 0x%08lx\n[BLINK ]: %pS\n[ERET  ]: %pS\n",
-		current->thread.fault_address,
-		(void *)regs->blink, (void *)regs->ret);
 	if (user_mode(regs))
 		show_faulting_vma(regs->ret); /* faulting code, not data */
-	pr_info("[STAT32]: 0x%08lx", regs->status32);
+	pr_info("ECR: 0x%08lx EFA: 0x%08lx ERET: 0x%08lx\n",
+		regs->event, current->thread.fault_address, regs->ret);
+	pr_info("STAT32: 0x%08lx", regs->status32);
 #define STS_BIT(r, bit)	r->status32 & STATUS_##bit##_MASK ? #bit" " : ""
 #ifdef CONFIG_ISA_ARCOMPACT
-	pr_cont(" : %2s%2s%2s%2s%2s%2s%2s\n",
+	pr_cont(" [%2s%2s%2s%2s%2s%2s%2s]",
 			(regs->status32 & STATUS_U_MASK) ? "U " : "K ",
 			STS_BIT(regs, DE), STS_BIT(regs, AE),
 			STS_BIT(regs, A2), STS_BIT(regs, A1),
 			STS_BIT(regs, E2), STS_BIT(regs, E1));
 #else
-	pr_cont(" : %2s%2s%2s%2s\n",
+	pr_cont(" [%2s%2s%2s%2s]",
 			STS_BIT(regs, IE),
 			(regs->status32 & STATUS_U_MASK) ? "U " : "K ",
 			STS_BIT(regs, DE), STS_BIT(regs, AE));
 #endif
-	pr_info("BTA: 0x%08lx\t SP: 0x%08lx\t FP: 0x%08lx\n",
+	pr_cont("  BTA: 0x%08lx\n", regs->bta);
-		regs->bta, regs->sp, regs->fp);
+	pr_info("BLK: %pS\n SP: 0x%08lx  FP: 0x%08lx\n",
+		(void *)regs->blink, regs->sp, regs->fp);
 	pr_info("LPS: 0x%08lx\tLPE: 0x%08lx\tLPC: 0x%08lx\n",
 	       regs->lp_start, regs->lp_end, regs->lp_count);

arch/arm/Makefile+3−1

 ifeq ($(CONFIG_STACKPROTECTOR_PER_TASK),y)
 prepare: stack_protector_prepare
 stack_protector_prepare: prepare0
-	$(eval KBUILD_CFLAGS += \
+	$(eval SSP_PLUGIN_CFLAGS := \
 		-fplugin-arg-arm_ssp_per_task_plugin-tso=$(shell	\
 			awk '{if ($$2 == "THREAD_SZ_ORDER") print $$3;}'\
 				include/generated/asm-offsets.h)	\
 		-fplugin-arg-arm_ssp_per_task_plugin-offset=$(shell	\
 			awk '{if ($$2 == "TI_STACK_CANARY") print $$3;}'\
 				include/generated/asm-offsets.h))
+	$(eval KBUILD_CFLAGS += $(SSP_PLUGIN_CFLAGS))
+	$(eval GCC_PLUGINS_CFLAGS += $(SSP_PLUGIN_CFLAGS))
 endif
 all:	$(notdir $(KBUILD_IMAGE))

arch/arm/boot/compressed/Makefile+2−2

 		$(libfdt) $(libfdt_hdrs) hyp-stub.S
 KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
-KBUILD_CFLAGS += $(DISABLE_ARM_SSP_PER_TASK_PLUGIN)
 ifeq ($(CONFIG_FUNCTION_TRACER),y)
 ORIG_CFLAGS := $(KBUILD_CFLAGS)
 CFLAGS_fdt_rw.o := $(nossp-flags-y)
 CFLAGS_fdt_wip.o := $(nossp-flags-y)
-ccflags-y := -fpic $(call cc-option,-mno-single-pic-base,) -fno-builtin -I$(obj)
+ccflags-y := -fpic $(call cc-option,-mno-single-pic-base,) -fno-builtin \
+	     -I$(obj) $(DISABLE_ARM_SSP_PER_TASK_PLUGIN)
 asflags-y := -DZIMAGE
 # Supply kernel BSS size to the decompressor via a linker symbol.

arch/arm/kernel/vdso.c+2−0

@@ -94,6 +94,8 @@ static bool __init cntvct_functional(void) · 93 unmodified lines
94	* this.	94	* this.
95	*/	95	*/
96	np = of_find_compatible_node(NULL, NULL, "arm,armv7-timer");	96	np = of_find_compatible_node(NULL, NULL, "arm,armv7-timer");
		97	if (!np)
		98	np = of_find_compatible_node(NULL, NULL, "arm,armv8-timer");
97	if (!np)	99	if (!np)
98	goto out_put;	100	goto out_put;
99		101

arch/arm/lib/copy_from_user.S+1−1

@@ -118,7 +118,7 @@ ENTRY(arm_copy_from_user) · 117 unmodified lines
118		118
119	ENDPROC(arm_copy_from_user)	119	ENDPROC(arm_copy_from_user)
120		120
121	.pushsection .fixup,"ax"	121	.pushsection .text.fixup,"ax"
122	.align 0	122	.align 0
123	copy_abort_preamble	123	copy_abort_preamble
124	ldmfd sp!, {r1, r2, r3}	124	ldmfd sp!, {r1, r2, r3}

arch/arm64/boot/dts/freescale/fsl-ls1043-post.dtsi+2−0

@@ -20,6 +20,8 @@ · 19 unmodified lines
20	};	20	};
21		21
22	&fman0 {	22	&fman0 {
		23	fsl,erratum-a050385;
		24
23	/* these aliases provide the FMan ports mapping */	25	/* these aliases provide the FMan ports mapping */
24	enet0: ethernet@e0000 {	26	enet0: ethernet@e0000 {
25	};	27	};

arch/arm64/include/asm/mmu.h+1−3

  */
 #define ASID(mm)	((mm)->context.id.counter & 0xffff)
-extern bool arm64_use_ng_mappings;
 static inline bool arm64_kernel_unmapped_at_el0(void)
 {
-	return arm64_use_ng_mappings;
+	return cpus_have_const_cap(ARM64_UNMAP_KERNEL_AT_EL0);
 }
 typedef void (*bp_hardening_cb_t)(void);

arch/arm64/include/asm/pgtable-prot.h+4−2

 #include <asm/pgtable-types.h>
+extern bool arm64_use_ng_mappings;
 #define _PROT_DEFAULT		(PTE_TYPE_PAGE | PTE_AF | PTE_SHARED)
 #define _PROT_SECT_DEFAULT	(PMD_TYPE_SECT | PMD_SECT_AF | PMD_SECT_S)
-#define PTE_MAYBE_NG		(arm64_kernel_unmapped_at_el0() ? PTE_NG : 0)
+#define PTE_MAYBE_NG		(arm64_use_ng_mappings ? PTE_NG : 0)
-#define PMD_MAYBE_NG		(arm64_kernel_unmapped_at_el0() ? PMD_SECT_NG : 0)
+#define PMD_MAYBE_NG		(arm64_use_ng_mappings ? PMD_SECT_NG : 0)
 #define PROT_DEFAULT		(_PROT_DEFAULT | PTE_MAYBE_NG)
 #define PROT_SECT_DEFAULT	(_PROT_SECT_DEFAULT | PMD_MAYBE_NG)

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

 #define __NR_compat_gettimeofday	78
 #define __NR_compat_sigreturn		119
 #define __NR_compat_rt_sigreturn	173
-#define __NR_compat_clock_getres	247
 #define __NR_compat_clock_gettime	263
+#define __NR_compat_clock_getres	264
 #define __NR_compat_clock_gettime64	403
 #define __NR_compat_clock_getres_time64	406

arch/arm64/kernel/smp.c+20−5

 }
 #endif
+/*
+ * The number of CPUs online, not counting this CPU (which may not be
+ * fully online and so not counted in num_online_cpus()).
+ */
+static inline unsigned int num_other_online_cpus(void)
+{
+	unsigned int this_cpu_online = cpu_online(smp_processor_id());
+	return num_online_cpus() - this_cpu_online;
+}
 void smp_send_stop(void)
 {
 	unsigned long timeout;
-	if (num_online_cpus() > 1) {
+	if (num_other_online_cpus()) {
 		cpumask_t mask;
 		cpumask_copy(&mask, cpu_online_mask);
 	/* Wait up to one second for other CPUs to stop */
 	timeout = USEC_PER_SEC;
-	while (num_online_cpus() > 1 && timeout--)
+	while (num_other_online_cpus() && timeout--)
 		udelay(1);
-	if (num_online_cpus() > 1)
+	if (num_other_online_cpus())
 		pr_warn("SMP: failed to stop secondary CPUs %*pbl\n",
 			cpumask_pr_args(cpu_online_mask));
 	cpus_stopped = 1;
-	if (num_online_cpus() == 1) {
+	/*
+	 * If this cpu is the only one alive at this point in time, online or
+	 * not, there are no stop messages to be sent around, so just back out.
+	 */
+	if (num_other_online_cpus() == 0) {
 		sdei_mask_local_cpu();
 		return;
 	}
 	cpumask_copy(&mask, cpu_online_mask);
 	cpumask_clear_cpu(smp_processor_id(), &mask);
-	atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
+	atomic_set(&waiting_for_crash_ipi, num_other_online_cpus());
 	pr_crit("SMP: stopping secondary CPUs\n");
 	smp_cross_call(&mask, IPI_CPU_CRASH_STOP);

arch/mips/boot/dts/ingenic/ci20.dts+28−16

@@ -4,6 +4,8 @@ · 3 unmodified lines
4	#include "jz4780.dtsi"	4	#include "jz4780.dtsi"
5	#include <dt-bindings/clock/ingenic,tcu.h>	5	#include <dt-bindings/clock/ingenic,tcu.h>
6	#include <dt-bindings/gpio/gpio.h>	6	#include <dt-bindings/gpio/gpio.h>
		7	#include <dt-bindings/interrupt-controller/irq.h>
		8	#include <dt-bindings/regulator/active-semi,8865-regulator.h>
7		9
8	/ {	10	/ {
9	compatible = "img,ci20", "ingenic,jz4780";	11	compatible = "img,ci20", "ingenic,jz4780";
@@ -163,63 +165,71 @@ · 153 unmodified lines
163		165
164	regulators {	166	regulators {
165	vddcore: SUDCDC1 {	167	vddcore: SUDCDC1 {
166	regulator-name = "VDDCORE";	168	regulator-name = "DCDC_REG1";
167	regulator-min-microvolt = <1100000>;	169	regulator-min-microvolt = <1100000>;
168	regulator-max-microvolt = <1100000>;	170	regulator-max-microvolt = <1100000>;
169	regulator-always-on;	171	regulator-always-on;
170	};	172	};
171	vddmem: SUDCDC2 {	173	vddmem: SUDCDC2 {
172	regulator-name = "VDDMEM";	174	regulator-name = "DCDC_REG2";
173	regulator-min-microvolt = <1500000>;	175	regulator-min-microvolt = <1500000>;
174	regulator-max-microvolt = <1500000>;	176	regulator-max-microvolt = <1500000>;
175	regulator-always-on;	177	regulator-always-on;
176	};	178	};
177	vcc_33: SUDCDC3 {	179	vcc_33: SUDCDC3 {
178	regulator-name = "VCC33";	180	regulator-name = "DCDC_REG3";
179	regulator-min-microvolt = <3300000>;	181	regulator-min-microvolt = <3300000>;
180	regulator-max-microvolt = <3300000>;	182	regulator-max-microvolt = <3300000>;
181	regulator-always-on;	183	regulator-always-on;
182	};	184	};
183	vcc_50: SUDCDC4 {	185	vcc_50: SUDCDC4 {
184	regulator-name = "VCC50";	186	regulator-name = "SUDCDC_REG4";
185	regulator-min-microvolt = <5000000>;	187	regulator-min-microvolt = <5000000>;
186	regulator-max-microvolt = <5000000>;	188	regulator-max-microvolt = <5000000>;
187	regulator-always-on;	189	regulator-always-on;
188	};	190	};
189	vcc_25: LDO_REG5 {	191	vcc_25: LDO_REG5 {
190	regulator-name = "VCC25";	192	regulator-name = "LDO_REG5";
191	regulator-min-microvolt = <2500000>;	193	regulator-min-microvolt = <2500000>;
192	regulator-max-microvolt = <2500000>;	194	regulator-max-microvolt = <2500000>;
193	regulator-always-on;	195	regulator-always-on;
194	};	196	};
195	wifi_io: LDO_REG6 {	197	wifi_io: LDO_REG6 {
196	regulator-name = "WIFIIO";	198	regulator-name = "LDO_REG6";
197	regulator-min-microvolt = <2500000>;	199	regulator-min-microvolt = <2500000>;
198	regulator-max-microvolt = <2500000>;	200	regulator-max-microvolt = <2500000>;
199	regulator-always-on;	201	regulator-always-on;
200	};	202	};
201	vcc_28: LDO_REG7 {	203	vcc_28: LDO_REG7 {
202	regulator-name = "VCC28";	204	regulator-name = "LDO_REG7";
203	regulator-min-microvolt = <2800000>;	205	regulator-min-microvolt = <2800000>;
204	regulator-max-microvolt = <2800000>;	206	regulator-max-microvolt = <2800000>;
205	regulator-always-on;	207	regulator-always-on;
206	};	208	};
207	vcc_15: LDO_REG8 {	209	vcc_15: LDO_REG8 {
208	regulator-name = "VCC15";	210	regulator-name = "LDO_REG8";
209	regulator-min-microvolt = <1500000>;	211	regulator-min-microvolt = <1500000>;
210	regulator-max-microvolt = <1500000>;	212	regulator-max-microvolt = <1500000>;
211	regulator-always-on;	213	regulator-always-on;
212	};	214	};
213	vcc_18: LDO_REG9 {	215	vrtc_18: LDO_REG9 {
214	regulator-name = "VCC18";	216	regulator-name = "LDO_REG9";
215	regulator-min-microvolt = <1800000>;	217	/* Despite the datasheet stating 3.3V
216	regulator-max-microvolt = <1800000>;	218	* for REG9 and the driver expecting that,
		219	* REG9 outputs 1.8V.
		220	* Likely the CI20 uses a proprietary
		221	* factory programmed chip variant.
		222	* Since this is a simple on/off LDO the
		223	* exact values do not matter.
		224	*/
		225	regulator-min-microvolt = <3300000>;
		226	regulator-max-microvolt = <3300000>;
217	regulator-always-on;	227	regulator-always-on;
218	};	228	};
219	vcc_11: LDO_REG10 {	229	vcc_11: LDO_REG10 {
220	regulator-name = "VCC11";	230	regulator-name = "LDO_REG10";
221	regulator-min-microvolt = <1100000>;	231	regulator-min-microvolt = <1200000>;
222	regulator-max-microvolt = <1100000>;	232	regulator-max-microvolt = <1200000>;
223	regulator-always-on;	233	regulator-always-on;
224	};	234	};
225	};	235	};
@@ -261,7 +271,9 @@ · 35 unmodified lines
261	rtc@51 {	271	rtc@51 {
262	compatible = "nxp,pcf8563";	272	compatible = "nxp,pcf8563";
263	reg = <0x51>;	273	reg = <0x51>;
264	interrupts = <110>;	274
		275	interrupt-parent = <&gpf>;
		276	interrupts = <30 IRQ_TYPE_LEVEL_LOW>;
265	};	277	};
266	};	278	};
267		279

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

@@ -605,7 +605,8 @@ static void __init bootcmdline_init(char **cmdline_p) · 604 unmodified lines
605	* If we're configured to take boot arguments from DT, look for those	605	* If we're configured to take boot arguments from DT, look for those
606	* now.	606	* now.
607	*/	607	*/
608	if (IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB))	608	if (IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB) \|\|
		609	IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND))
609	of_scan_flat_dt(bootcmdline_scan_chosen, &dt_bootargs);	610	of_scan_flat_dt(bootcmdline_scan_chosen, &dt_bootargs);
610	#endif	611	#endif
611		612

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

@@ -1817,6 +1817,7 @@ static void kvmppc_core_vcpu_free_pr(struct kvm_vcpu *vcpu) · 1816 unmodified lines
1817	{	1817	{
1818	struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);	1818	struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
1819		1819
		1820	kvmppc_mmu_destroy_pr(vcpu);
1820	free_page((unsigned long)vcpu->arch.shared & PAGE_MASK);	1821	free_page((unsigned long)vcpu->arch.shared & PAGE_MASK);
1821	#ifdef CONFIG_KVM_BOOK3S_32_HANDLER	1822	#ifdef CONFIG_KVM_BOOK3S_32_HANDLER
1822	kfree(vcpu->arch.shadow_vcpu);	1823	kfree(vcpu->arch.shadow_vcpu);

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

 	return 0;
 out_vcpu_uninit:
-	kvmppc_mmu_destroy(vcpu);
 	kvmppc_subarch_vcpu_uninit(vcpu);
 	return err;
 }
 	kvmppc_core_vcpu_free(vcpu);
-	kvmppc_mmu_destroy(vcpu);
 	kvmppc_subarch_vcpu_uninit(vcpu);
 }

arch/powerpc/mm/kasan/kasan_init_32.c+2−7

 	unsigned long k_cur;
 	phys_addr_t pa = __pa(kasan_early_shadow_page);
-	if (!early_mmu_has_feature(MMU_FTR_HPTE_TABLE)) {
-		int ret = kasan_init_shadow_page_tables(k_start, k_end);
-		if (ret)
-			panic("kasan: kasan_init_shadow_page_tables() failed");
-	}
 	for (k_cur = k_start & PAGE_MASK; k_cur < k_end; k_cur += PAGE_SIZE) {
 		pmd_t *pmd = pmd_offset(pud_offset(pgd_offset_k(k_cur), k_cur), k_cur);
 		pte_t *ptep = pte_offset_kernel(pmd, k_cur);
 	int ret;
 	struct memblock_region *reg;
-	if (early_mmu_has_feature(MMU_FTR_HPTE_TABLE)) {
+	if (early_mmu_has_feature(MMU_FTR_HPTE_TABLE) ||
+	    IS_ENABLED(CONFIG_KASAN_VMALLOC)) {
 		ret = kasan_init_shadow_page_tables(KASAN_SHADOW_START, KASAN_SHADOW_END);
 		if (ret)

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

@@ -3268,7 +3268,10 @@ static void kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) · 3267 unmodified lines
3268	/* Initial reset is a superset of the normal reset */	3268	/* Initial reset is a superset of the normal reset */
3269	kvm_arch_vcpu_ioctl_normal_reset(vcpu);	3269	kvm_arch_vcpu_ioctl_normal_reset(vcpu);
3270		3270
3271	/* this equals initial cpu reset in pop, but we don't switch to ESA */	3271	/*
		3272	* This equals initial cpu reset in pop, but we don't switch to ESA.
		3273	* We do not only reset the internal data, but also ...
		3274	*/
3272	vcpu->arch.sie_block->gpsw.mask = 0;	3275	vcpu->arch.sie_block->gpsw.mask = 0;
3273	vcpu->arch.sie_block->gpsw.addr = 0;	3276	vcpu->arch.sie_block->gpsw.addr = 0;
3274	kvm_s390_set_prefix(vcpu, 0);	3277	kvm_s390_set_prefix(vcpu, 0);
@@ -3278,6 +3281,19 @@ static void kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) · 3 unmodified lines
3278	memset(vcpu->arch.sie_block->gcr, 0, sizeof(vcpu->arch.sie_block->gcr));	3281	memset(vcpu->arch.sie_block->gcr, 0, sizeof(vcpu->arch.sie_block->gcr));
3279	vcpu->arch.sie_block->gcr[0] = CR0_INITIAL_MASK;	3282	vcpu->arch.sie_block->gcr[0] = CR0_INITIAL_MASK;
3280	vcpu->arch.sie_block->gcr[14] = CR14_INITIAL_MASK;	3283	vcpu->arch.sie_block->gcr[14] = CR14_INITIAL_MASK;
		3284
		3285	/* ... the data in sync regs */
		3286	memset(vcpu->run->s.regs.crs, 0, sizeof(vcpu->run->s.regs.crs));
		3287	vcpu->run->s.regs.ckc = 0;
		3288	vcpu->run->s.regs.crs[0] = CR0_INITIAL_MASK;
		3289	vcpu->run->s.regs.crs[14] = CR14_INITIAL_MASK;
		3290	vcpu->run->psw_addr = 0;
		3291	vcpu->run->psw_mask = 0;
		3292	vcpu->run->s.regs.todpr = 0;
		3293	vcpu->run->s.regs.cputm = 0;
		3294	vcpu->run->s.regs.ckc = 0;
		3295	vcpu->run->s.regs.pp = 0;
		3296	vcpu->run->s.regs.gbea = 1;
3281	vcpu->run->s.regs.fpc = 0;	3297	vcpu->run->s.regs.fpc = 0;
3282	vcpu->arch.sie_block->gbea = 1;	3298	vcpu->arch.sie_block->gbea = 1;
3283	vcpu->arch.sie_block->pp = 0;	3299	vcpu->arch.sie_block->pp = 0;

arch/x86/Makefile+3−2

@@ -194,9 +194,10 @@ avx2_instr :=$(call as-instr,vpbroadcastb %xmm0$(comma)%ymm1,-DCONFIG_AS_AVX2=1) · 193 unmodified lines
194	avx512_instr :=$(call as-instr,vpmovm2b %k1$(comma)%zmm5,-DCONFIG_AS_AVX512=1)	194	avx512_instr :=$(call as-instr,vpmovm2b %k1$(comma)%zmm5,-DCONFIG_AS_AVX512=1)
195	sha1_ni_instr :=$(call as-instr,sha1msg1 %xmm0$(comma)%xmm1,-DCONFIG_AS_SHA1_NI=1)	195	sha1_ni_instr :=$(call as-instr,sha1msg1 %xmm0$(comma)%xmm1,-DCONFIG_AS_SHA1_NI=1)
196	sha256_ni_instr :=$(call as-instr,sha256msg1 %xmm0$(comma)%xmm1,-DCONFIG_AS_SHA256_NI=1)	196	sha256_ni_instr :=$(call as-instr,sha256msg1 %xmm0$(comma)%xmm1,-DCONFIG_AS_SHA256_NI=1)
		197	adx_instr := $(call as-instr,adox %r10$(comma)%r10,-DCONFIG_AS_ADX=1)
197		198
198	KBUILD_AFLAGS += $(cfi) $(cfi-sigframe) $(cfi-sections) $(asinstr) $(avx_instr) $(avx2_instr) $(avx512_instr) $(sha1_ni_instr) $(sha256_ni_instr)	199	KBUILD_AFLAGS += $(cfi) $(cfi-sigframe) $(cfi-sections) $(asinstr) $(avx_instr) $(avx2_instr) $(avx512_instr) $(sha1_ni_instr) $(sha256_ni_instr) $(adx_instr)
199	KBUILD_CFLAGS += $(cfi) $(cfi-sigframe) $(cfi-sections) $(asinstr) $(avx_instr) $(avx2_instr) $(avx512_instr) $(sha1_ni_instr) $(sha256_ni_instr)	200	KBUILD_CFLAGS += $(cfi) $(cfi-sigframe) $(cfi-sections) $(asinstr) $(avx_instr) $(avx2_instr) $(avx512_instr) $(sha1_ni_instr) $(sha256_ni_instr) $(adx_instr)
200		201
201	KBUILD_LDFLAGS := -m elf_$(UTS_MACHINE)	202	KBUILD_LDFLAGS := -m elf_$(UTS_MACHINE)
202		203

arch/x86/crypto/Makefile+6−1

@@ -11,6 +11,7 @@ avx2_supported := $(call as-instr,vpgatherdd %ymm0$(comma)(%eax$(comma)%ymm1\ · 10 unmodified lines
11	avx512_supported :=$(call as-instr,vpmovm2b %k1$(comma)%zmm5,yes,no)	11	avx512_supported :=$(call as-instr,vpmovm2b %k1$(comma)%zmm5,yes,no)
12	sha1_ni_supported :=$(call as-instr,sha1msg1 %xmm0$(comma)%xmm1,yes,no)	12	sha1_ni_supported :=$(call as-instr,sha1msg1 %xmm0$(comma)%xmm1,yes,no)
13	sha256_ni_supported :=$(call as-instr,sha256msg1 %xmm0$(comma)%xmm1,yes,no)	13	sha256_ni_supported :=$(call as-instr,sha256msg1 %xmm0$(comma)%xmm1,yes,no)
		14	adx_supported := $(call as-instr,adox %r10$(comma)%r10,yes,no)
14		15
15	obj-$(CONFIG_CRYPTO_GLUE_HELPER_X86) += glue_helper.o	16	obj-$(CONFIG_CRYPTO_GLUE_HELPER_X86) += glue_helper.o
16		17
@@ -39,7 +40,11 @@ obj-$(CONFIG_CRYPTO_AEGIS128_AESNI_SSE2) += aegis128-aesni.o · 22 unmodified lines
39		40
40	obj-$(CONFIG_CRYPTO_NHPOLY1305_SSE2) += nhpoly1305-sse2.o	41	obj-$(CONFIG_CRYPTO_NHPOLY1305_SSE2) += nhpoly1305-sse2.o
41	obj-$(CONFIG_CRYPTO_NHPOLY1305_AVX2) += nhpoly1305-avx2.o	42	obj-$(CONFIG_CRYPTO_NHPOLY1305_AVX2) += nhpoly1305-avx2.o
42	obj-$(CONFIG_CRYPTO_CURVE25519_X86) += curve25519-x86_64.o	43
		44	# These modules require the assembler to support ADX.
		45	ifeq ($(adx_supported),yes)
		46	obj-$(CONFIG_CRYPTO_CURVE25519_X86) += curve25519-x86_64.o
		47	endif
43		48
44	# These modules require assembler to support AVX.	49	# These modules require assembler to support AVX.
45	ifeq ($(avx_supported),yes)	50	ifeq ($(avx_supported),yes)

arch/x86/events/amd/uncore.c+7−10

 	/*
 	 * NB and Last level cache counters (MSRs) are shared across all cores
-	 * that share the same NB / Last level cache. Interrupts can be directed
+	 * that share the same NB / Last level cache.  On family 16h and below,
-	 * to a single target core, however, event counts generated by processes
+	 * Interrupts can be directed to a single target core, however, event
-	 * running on other cores cannot be masked out. So we do not support
+	 * counts generated by processes running on other cores cannot be masked
-	 * sampling and per-thread events.
+	 * out. So we do not support sampling and per-thread events via
+	 * CAP_NO_INTERRUPT, and we do not enable counter overflow interrupts:
 	 */
-	if (is_sampling_event(event) || event->attach_state & PERF_ATTACH_TASK)
-		return -EINVAL;
-	/* and we do not enable counter overflow interrupts */
 	hwc->config = event->attr.config & AMD64_RAW_EVENT_MASK_NB;
 	hwc->idx = -1;
 	.start		= amd_uncore_start,
 	.stop		= amd_uncore_stop,
 	.read		= amd_uncore_read,
-	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE,
+	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE | PERF_PMU_CAP_NO_INTERRUPT,
 };
 static struct pmu amd_llc_pmu = {
 	.start		= amd_uncore_start,
 	.stop		= amd_uncore_stop,
 	.read		= amd_uncore_read,
-	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE,
+	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE | PERF_PMU_CAP_NO_INTERRUPT,
 };
 static struct amd_uncore *amd_uncore_alloc(unsigned int cpu)

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

@@ -360,7 +360,6 @@ struct x86_emulate_ctxt { · 359 unmodified lines
360	u64 d;	360	u64 d;
361	unsigned long _eip;	361	unsigned long _eip;
362	struct operand memop;	362	struct operand memop;
363	/* Fields above regs are cleared together. */
364	unsigned long _regs[NR_VCPU_REGS];	363	unsigned long _regs[NR_VCPU_REGS];
365	struct operand *memopp;	364	struct operand *memopp;
366	struct fetch_cache fetch;	365	struct fetch_cache fetch;

arch/x86/kernel/apic/vector.c+8−6

 	bool managed = apicd->is_managed;
 	/*
-	 * This should never happen. Managed interrupts are not
+	 * Managed interrupts are usually not migrated away
-	 * migrated except on CPU down, which does not involve the
+	 * from an online CPU, but CPU isolation 'managed_irq'
-	 * cleanup vector. But try to keep the accounting correct
+	 * can make that happen.
-	 * nevertheless.
+	 * 1) Activation does not take the isolation into account
+	 *    to keep the code simple
+	 * 2) Migration away from an isolated CPU can happen when
+	 *    a non-isolated CPU which is in the calculated
+	 *    affinity mask comes online.
 	 */
-	WARN_ON_ONCE(managed);
 	trace_vector_free_moved(apicd->irq, cpu, vector, managed);
 	irq_matrix_free(vector_matrix, cpu, vector, managed);
 	per_cpu(vector_irq, cpu)[vector] = VECTOR_UNUSED;

arch/x86/kernel/cpu/mce/intel.c+5−4

 			return;
 		if ((val & 3UL) == 1UL) {
-			/* PPIN available but disabled: */
+			/* PPIN locked in disabled mode */
 			return;
 		}
-		/* If PPIN is disabled, but not locked, try to enable: */
+		/* If PPIN is disabled, try to enable */
-		if (!(val & 3UL)) {
+		if (!(val & 2UL)) {
 			wrmsrl_safe(MSR_PPIN_CTL,  val | 2UL);
 			rdmsrl_safe(MSR_PPIN_CTL, &val);
 		}
-		if ((val & 3UL) == 2UL)
+		/* Is the enable bit set? */
+		if (val & 2UL)
 			set_cpu_cap(c, X86_FEATURE_INTEL_PPIN);
 	}
 }

arch/x86/kernel/cpu/mce/therm_throt.c+7−2

 {
 	struct thermal_state *state = &per_cpu(thermal_state, cpu);
 	struct device *dev = get_cpu_device(cpu);
+	u32 l;
+	/* Mask the thermal vector before draining evtl. pending work */
+	l = apic_read(APIC_LVTTHMR);
+	apic_write(APIC_LVTTHMR, l | APIC_LVT_MASKED);
-	cancel_delayed_work(&state->package_throttle.therm_work);
+	cancel_delayed_work_sync(&state->package_throttle.therm_work);
-	cancel_delayed_work(&state->core_throttle.therm_work);
+	cancel_delayed_work_sync(&state->core_throttle.therm_work);
 	state->package_throttle.rate_control_active = false;
 	state->core_throttle.rate_control_active = false;

arch/x86/kvm/Kconfig+1−1

@@ -68,7 +68,7 @@ config KVM_WERROR · 67 unmodified lines
68	depends on (X86_64 && !KASAN) \|\| !COMPILE_TEST	68	depends on (X86_64 && !KASAN) \|\| !COMPILE_TEST
69	depends on EXPERT	69	depends on EXPERT
70	help	70	help
71	Add -Werror to the build flags for (and only for) i915.ko.	71	Add -Werror to the build flags for KVM.
72		72
73	If in doubt, say "N".	73	If in doubt, say "N".
74		74

arch/x86/kvm/emulate.c+1−0

@@ -5173,6 +5173,7 @@ int x86_decode_insn(struct x86_emulate_ctxt ctxt, void insn, int insn_len) · 5172 unmodified lines
5173	ctxt->fetch.ptr = ctxt->fetch.data;	5173	ctxt->fetch.ptr = ctxt->fetch.data;
5174	ctxt->fetch.end = ctxt->fetch.data + insn_len;	5174	ctxt->fetch.end = ctxt->fetch.data + insn_len;
5175	ctxt->opcode_len = 1;	5175	ctxt->opcode_len = 1;
		5176	ctxt->intercept = x86_intercept_none;
5176	if (insn_len > 0)	5177	if (insn_len > 0)
5177	memcpy(ctxt->fetch.data, insn, insn_len);	5178	memcpy(ctxt->fetch.data, insn, insn_len);
5178	else {	5179	else {

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

 		if (e->fields.delivery_mode == APIC_DM_FIXED) {
 			struct kvm_lapic_irq irq;
-			irq.shorthand = APIC_DEST_NOSHORT;
 			irq.vector = e->fields.vector;
 			irq.delivery_mode = e->fields.delivery_mode << 8;
-			irq.dest_id = e->fields.dest_id;
 			irq.dest_mode =
 			    kvm_lapic_irq_dest_mode(!!e->fields.dest_mode);
+			irq.level = false;
+			irq.trig_mode = e->fields.trig_mode;
+			irq.shorthand = APIC_DEST_NOSHORT;
+			irq.dest_id = e->fields.dest_id;
+			irq.msi_redir_hint = false;
 			bitmap_zero(&vcpu_bitmap, 16);
 			kvm_bitmap_or_dest_vcpus(ioapic->kvm, &irq,
 						 &vcpu_bitmap);

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

@@ -6312,7 +6312,8 @@ static void svm_handle_exit_irqoff(struct kvm_vcpu *vcpu, · 6311 unmodified lines
6312	enum exit_fastpath_completion *exit_fastpath)	6312	enum exit_fastpath_completion *exit_fastpath)
6313	{	6313	{
6314	if (!is_guest_mode(vcpu) &&	6314	if (!is_guest_mode(vcpu) &&
6315	to_svm(vcpu)->vmcb->control.exit_code == EXIT_REASON_MSR_WRITE)	6315	to_svm(vcpu)->vmcb->control.exit_code == SVM_EXIT_MSR &&
		6316	to_svm(vcpu)->vmcb->control.exit_info_1)
6316	*exit_fastpath = handle_fastpath_set_msr_irqoff(vcpu);	6317	*exit_fastpath = handle_fastpath_set_msr_irqoff(vcpu);
6317	}	6318	}
6318		6319

arch/x86/kvm/vmx/nested.c+3−2

 		return;
 	kvm_vcpu_unmap(vcpu, &vmx->nested.hv_evmcs_map, true);
-	vmx->nested.hv_evmcs_vmptr = -1ull;
+	vmx->nested.hv_evmcs_vmptr = 0;
 	vmx->nested.hv_evmcs = NULL;
 }
 	if (!nested_enlightened_vmentry(vcpu, &evmcs_gpa))
 		return 1;
-	if (unlikely(evmcs_gpa != vmx->nested.hv_evmcs_vmptr)) {
+	if (unlikely(!vmx->nested.hv_evmcs ||
+		     evmcs_gpa != vmx->nested.hv_evmcs_vmptr)) {
 		if (!vmx->nested.hv_evmcs)
 			vmx->nested.current_vmptr = -1ull;

arch/x86/kvm/vmx/vmx.c+14−2

 	kvm_cpu_vmxoff();
 }
+/*
+ * There is no X86_FEATURE for SGX yet, but anyway we need to query CPUID
+ * directly instead of going through cpu_has(), to ensure KVM is trapping
+ * ENCLS whenever it's supported in hardware.  It does not matter whether
+ * the host OS supports or has enabled SGX.
+ */
+static bool cpu_has_sgx(void)
+{
+	return cpuid_eax(0) >= 0x12 && (cpuid_eax(0x12) & BIT(0));
+}
 static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt,
 				      u32 msr, u32 *result)
 {
 			SECONDARY_EXEC_ENABLE_USR_WAIT_PAUSE |
 			SECONDARY_EXEC_PT_USE_GPA |
 			SECONDARY_EXEC_PT_CONCEAL_VMX |
-			SECONDARY_EXEC_ENABLE_VMFUNC |
+			SECONDARY_EXEC_ENABLE_VMFUNC;
-			SECONDARY_EXEC_ENCLS_EXITING;
+		if (cpu_has_sgx())
+			opt2 |= SECONDARY_EXEC_ENCLS_EXITING;
 		if (adjust_vmx_controls(min2, opt2,
 					MSR_IA32_VMX_PROCBASED_CTLS2,
 					&_cpu_based_2nd_exec_control) < 0)

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

 		cpu = get_cpu();
 		policy = cpufreq_cpu_get(cpu);
-		if (policy && policy->cpuinfo.max_freq)
+		if (policy) {
-			max_tsc_khz = policy->cpuinfo.max_freq;
+			if (policy->cpuinfo.max_freq)
+				max_tsc_khz = policy->cpuinfo.max_freq;
+			cpufreq_cpu_put(policy);
+		}
 		put_cpu();
-		cpufreq_cpu_put(policy);
 #endif
 		cpufreq_register_notifier(&kvmclock_cpufreq_notifier_block,
 					  CPUFREQ_TRANSITION_NOTIFIER);

arch/x86/mm/fault.c+24−2

 	return pmd_k;
 }
-void vmalloc_sync_all(void)
+static void vmalloc_sync(void)
 {
 	unsigned long address;
 	}
 }
+void vmalloc_sync_mappings(void)
+{
+	vmalloc_sync();
+}
+void vmalloc_sync_unmappings(void)
+{
+	vmalloc_sync();
+}
 /*
  * 32-bit:
  *
 #else /* CONFIG_X86_64: */
-void vmalloc_sync_all(void)
+void vmalloc_sync_mappings(void)
 {
+	/*
+	 * 64-bit mappings might allocate new p4d/pud pages
+	 * that need to be propagated to all tasks' PGDs.
+	 */
 	sync_global_pgds(VMALLOC_START & PGDIR_MASK, VMALLOC_END);
 }
+void vmalloc_sync_unmappings(void)
+{
+	/*
+	 * Unmappings never allocate or free p4d/pud pages.
+	 * No work is required here.
+	 */
+}
 /*
  * 64-bit:
  *

arch/x86/mm/ioremap.c+18−0

 	return 0;
 }
+/*
+ * The EFI runtime services data area is not covered by walk_mem_res(), but must
+ * be mapped encrypted when SEV is active.
+ */
+static void __ioremap_check_other(resource_size_t addr, struct ioremap_desc *desc)
+{
+	if (!sev_active())
+		return;
+	if (efi_mem_type(addr) == EFI_RUNTIME_SERVICES_DATA)
+		desc->flags |= IORES_MAP_ENCRYPTED;
+}
 static int __ioremap_collect_map_flags(struct resource *res, void *arg)
 {
 	struct ioremap_desc *desc = arg;
  * To avoid multiple resource walks, this function walks resources marked as
  * IORESOURCE_MEM and IORESOURCE_BUSY and looking for system RAM and/or a
  * resource described not as IORES_DESC_NONE (e.g. IORES_DESC_ACPI_TABLES).
+ *
+ * After that, deal with misc other ranges in __ioremap_check_other() which do
+ * not fall into the above category.
  */
 static void __ioremap_check_mem(resource_size_t addr, unsigned long size,
 				struct ioremap_desc *desc)
 	memset(desc, 0, sizeof(struct ioremap_desc));
 	walk_mem_res(start, end, desc, __ioremap_collect_map_flags);
+	__ioremap_check_other(addr, desc);
 }
 /*

block/blk-iocost.c+1−1

@@ -1318,7 +1318,7 @@ static bool iocg_is_idle(struct ioc_gq *iocg) · 1317 unmodified lines
1318	return false;	1318	return false;
1319		1319
1320	/* is something in flight? */	1320	/* is something in flight? */
1321	if (atomic64_read(&iocg->done_vtime) < atomic64_read(&iocg->vtime))	1321	if (atomic64_read(&iocg->done_vtime) != atomic64_read(&iocg->vtime))
1322	return false;	1322	return false;
1323		1323
1324	return true;	1324	return true;

block/blk-mq-sched.c+22−0

@@ -398,6 +398,28 @@ void blk_mq_sched_insert_request(struct request *rq, bool at_head, · 397 unmodified lines
398	WARN_ON(e && (rq->tag != -1));	398	WARN_ON(e && (rq->tag != -1));
399		399
400	if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) {	400	if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) {
		401	/*
		402	* Firstly normal IO request is inserted to scheduler queue or
		403	* sw queue, meantime we add flush request to dispatch queue(
		404	* hctx->dispatch) directly and there is at most one in-flight
		405	* flush request for each hw queue, so it doesn't matter to add
		406	* flush request to tail or front of the dispatch queue.
		407	*
		408	* Secondly in case of NCQ, flush request belongs to non-NCQ
		409	* command, and queueing it will fail when there is any
		410	* in-flight normal IO request(NCQ command). When adding flush
		411	* rq to the front of hctx->dispatch, it is easier to introduce
		412	* extra time to flush rq's latency because of S_SCHED_RESTART
		413	* compared with adding to the tail of dispatch queue, then
		414	* chance of flush merge is increased, and less flush requests
		415	* will be issued to controller. It is observed that ~10% time
		416	* is saved in blktests block/004 on disk attached to AHCI/NCQ
		417	* drive when adding flush rq to the front of hctx->dispatch.
		418	*
		419	* Simply queue flush rq to the front of hctx->dispatch so that
		420	* intensive flush workloads can benefit in case of NCQ HW.
		421	*/
		422	at_head = (rq->rq_flags & RQF_FLUSH_SEQ) ? true : at_head;
401	blk_mq_request_bypass_insert(rq, at_head, false);	423	blk_mq_request_bypass_insert(rq, at_head, false);
402	goto run;	424	goto run;
403	}	425	}

block/genhd.c+36−0

@@ -301,6 +301,42 @@ struct hd_struct disk_map_sector_rcu(struct gendisk disk, sector_t sector) · 300 unmodified lines
301	}	301	}
302	EXPORT_SYMBOL_GPL(disk_map_sector_rcu);	302	EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
303		303
		304	/**
		305	* disk_has_partitions
		306	* @disk: gendisk of interest
		307	*
		308	* Walk through the partition table and check if valid partition exists.
		309	*
		310	* CONTEXT:
		311	* Don't care.
		312	*
		313	* RETURNS:
		314	* True if the gendisk has at least one valid non-zero size partition.
		315	* Otherwise false.
		316	*/
		317	bool disk_has_partitions(struct gendisk *disk)
		318	{
		319	struct disk_part_tbl *ptbl;
		320	int i;
		321	bool ret = false;
		322
		323	rcu_read_lock();
		324	ptbl = rcu_dereference(disk->part_tbl);
		325
		326	/* Iterate partitions skipping the whole device at index 0 */
		327	for (i = 1; i < ptbl->len; i++) {
		328	if (rcu_dereference(ptbl->part[i])) {
		329	ret = true;
		330	break;
		331	}
		332	}
		333
		334	rcu_read_unlock();
		335
		336	return ret;
		337	}
		338	EXPORT_SYMBOL_GPL(disk_has_partitions);
		339
304	/*	340	/*
305	* Can be deleted altogether. Later.	341	* Can be deleted altogether. Later.
306	*	342	*

drivers/acpi/apei/ghes.c+1−1

@@ -171,7 +171,7 @@ int ghes_estatus_pool_init(int num_ghes) · 170 unmodified lines
171	* New allocation must be visible in all pgd before it can be found by	171	* New allocation must be visible in all pgd before it can be found by
172	* an NMI allocating from the pool.	172	* an NMI allocating from the pool.
173	*/	173	*/
174	vmalloc_sync_all();	174	vmalloc_sync_mappings();
175		175
176	rc = gen_pool_add(ghes_estatus_pool, addr, PAGE_ALIGN(len), -1);	176	rc = gen_pool_add(ghes_estatus_pool, addr, PAGE_ALIGN(len), -1);
177	if (rc)	177	if (rc)

drivers/android/binderfs.c+1−0

@@ -439,6 +439,7 @@ static int binderfs_binder_ctl_create(struct super_block *sb) · 438 unmodified lines
439	inode->i_uid = info->root_uid;	439	inode->i_uid = info->root_uid;
440	inode->i_gid = info->root_gid;	440	inode->i_gid = info->root_gid;
441		441
		442	refcount_set(&device->ref, 1);
442	device->binderfs_inode = inode;	443	device->binderfs_inode = inode;
443	device->miscdev.minor = minor;	444	device->miscdev.minor = minor;
444		445

drivers/atm/nicstar.c+1−1

@@ -91,7 +91,7 @@ · 90 unmodified lines
91	#ifdef GENERAL_DEBUG	91	#ifdef GENERAL_DEBUG
92	#define PRINTK(args...) printk(args)	92	#define PRINTK(args...) printk(args)
93	#else	93	#else
94	#define PRINTK(args...)	94	#define PRINTK(args...) do {} while (0)
95	#endif /* GENERAL_DEBUG */	95	#endif /* GENERAL_DEBUG */
96		96
97	#ifdef EXTRA_DEBUG	97	#ifdef EXTRA_DEBUG

drivers/auxdisplay/Kconfig+8−8

@@ -111,7 +111,7 @@ config CFAG12864B · 110 unmodified lines
111	If unsure, say N.	111	If unsure, say N.
112		112
113	config CFAG12864B_RATE	113	config CFAG12864B_RATE
114	int "Refresh rate (hertz)"	114	int "Refresh rate (hertz)"
115	depends on CFAG12864B	115	depends on CFAG12864B
116	default "20"	116	default "20"
117	---help---	117	---help---
@@ -329,7 +329,7 @@ config PANEL_LCD_PROTO · 211 unmodified lines
329		329
330	config PANEL_LCD_PIN_E	330	config PANEL_LCD_PIN_E
331	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO="0"	331	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO="0"
332	int "Parallel port pin number & polarity connected to the LCD E signal (-17...17) "	332	int "Parallel port pin number & polarity connected to the LCD E signal (-17...17) "
333	range -17 17	333	range -17 17
334	default 14	334	default 14
335	---help---	335	---help---
@@ -344,7 +344,7 @@ config PANEL_LCD_PIN_E · 8 unmodified lines
344		344
345	config PANEL_LCD_PIN_RS	345	config PANEL_LCD_PIN_RS
346	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO="0"	346	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO="0"
347	int "Parallel port pin number & polarity connected to the LCD RS signal (-17...17) "	347	int "Parallel port pin number & polarity connected to the LCD RS signal (-17...17) "
348	range -17 17	348	range -17 17
349	default 17	349	default 17
350	---help---	350	---help---
@@ -359,7 +359,7 @@ config PANEL_LCD_PIN_RS · 8 unmodified lines
359		359
360	config PANEL_LCD_PIN_RW	360	config PANEL_LCD_PIN_RW
361	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO="0"	361	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO="0"
362	int "Parallel port pin number & polarity connected to the LCD RW signal (-17...17) "	362	int "Parallel port pin number & polarity connected to the LCD RW signal (-17...17) "
363	range -17 17	363	range -17 17
364	default 16	364	default 16
365	---help---	365	---help---
@@ -374,7 +374,7 @@ config PANEL_LCD_PIN_RW · 8 unmodified lines
374		374
375	config PANEL_LCD_PIN_SCL	375	config PANEL_LCD_PIN_SCL
376	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO!="0"	376	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO!="0"
377	int "Parallel port pin number & polarity connected to the LCD SCL signal (-17...17) "	377	int "Parallel port pin number & polarity connected to the LCD SCL signal (-17...17) "
378	range -17 17	378	range -17 17
379	default 1	379	default 1
380	---help---	380	---help---
@@ -389,7 +389,7 @@ config PANEL_LCD_PIN_SCL · 8 unmodified lines
389		389
390	config PANEL_LCD_PIN_SDA	390	config PANEL_LCD_PIN_SDA
391	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO!="0"	391	depends on PANEL_PROFILE="0" && PANEL_LCD="1" && PANEL_LCD_PROTO!="0"
392	int "Parallel port pin number & polarity connected to the LCD SDA signal (-17...17) "	392	int "Parallel port pin number & polarity connected to the LCD SDA signal (-17...17) "
393	range -17 17	393	range -17 17
394	default 2	394	default 2
395	---help---	395	---help---
@@ -404,12 +404,12 @@ config PANEL_LCD_PIN_SDA · 8 unmodified lines
404		404
405	config PANEL_LCD_PIN_BL	405	config PANEL_LCD_PIN_BL
406	depends on PANEL_PROFILE="0" && PANEL_LCD="1"	406	depends on PANEL_PROFILE="0" && PANEL_LCD="1"
407	int "Parallel port pin number & polarity connected to the LCD backlight signal (-17...17) "	407	int "Parallel port pin number & polarity connected to the LCD backlight signal (-17...17) "
408	range -17 17	408	range -17 17
409	default 0	409	default 0
410	---help---	410	---help---
411	This describes the number of the parallel port pin to which the LCD 'BL' signal	411	This describes the number of the parallel port pin to which the LCD 'BL' signal
412	has been connected. It can be :	412	has been connected. It can be :
413		413
414	0 : no connection (eg: connected to ground)	414	0 : no connection (eg: connected to ground)
415	1..17 : directly connected to any of these pins on the DB25 plug	415	1..17 : directly connected to any of these pins on the DB25 plug

drivers/auxdisplay/charlcd.c+1−1

@@ -86,7 +86,7 @@ struct charlcd_priv { · 85 unmodified lines
86	int len;	86	int len;
87	} esc_seq;	87	} esc_seq;
88		88
89	unsigned long long drvdata[0];	89	unsigned long long drvdata[];
90	};	90	};
91		91
92	#define charlcd_to_priv(p) container_of(p, struct charlcd_priv, lcd)	92	#define charlcd_to_priv(p) container_of(p, struct charlcd_priv, lcd)

drivers/auxdisplay/img-ascii-lcd.c+1−3

 	const struct of_device_id *match;
 	const struct img_ascii_lcd_config *cfg;
 	struct img_ascii_lcd_ctx *ctx;
-	struct resource *res;
 	int err;
 	match = of_match_device(img_ascii_lcd_matches, &pdev->dev);
 					 &ctx->offset))
 			return -EINVAL;
 	} else {
-		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+		ctx->base = devm_platform_ioremap_resource(pdev, 0);
-		ctx->base = devm_ioremap_resource(&pdev->dev, res);
 		if (IS_ERR(ctx->base))
 			return PTR_ERR(ctx->base);
 	}

drivers/base/platform.c+6−19

 {
 	if (!pdev->dev.coherent_dma_mask)
 		pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
-	if (!pdev->dma_mask)
+	if (!pdev->dev.dma_mask) {
-		pdev->dma_mask = DMA_BIT_MASK(32);
+		pdev->platform_dma_mask = DMA_BIT_MASK(32);
-	if (!pdev->dev.dma_mask)
+		pdev->dev.dma_mask = &pdev->platform_dma_mask;
-		pdev->dev.dma_mask = &pdev->dma_mask;
+	}
 };
 /**
 	pdev->dev.of_node_reused = pdevinfo->of_node_reused;
 	if (pdevinfo->dma_mask) {
-		/*
+		pdev->platform_dma_mask = pdevinfo->dma_mask;
-		 * This memory isn't freed when the device is put,
+		pdev->dev.dma_mask = &pdev->platform_dma_mask;
-		 * I don't have a nice idea for that though.  Conceptually
-		 * dma_mask in struct device should not be a pointer.
-		 * See http://thread.gmane.org/gmane.linux.kernel.pci/9081
-		 */
-		pdev->dev.dma_mask =
-			kmalloc(sizeof(*pdev->dev.dma_mask), GFP_KERNEL);
-		if (!pdev->dev.dma_mask)
-			goto err;
-		kmemleak_ignore(pdev->dev.dma_mask);
-		*pdev->dev.dma_mask = pdevinfo->dma_mask;
 		pdev->dev.coherent_dma_mask = pdevinfo->dma_mask;
 	}
 	if (ret) {
 err:
 		ACPI_COMPANION_SET(&pdev->dev, NULL);
-		kfree(pdev->dev.dma_mask);
 		platform_device_put(pdev);
 		return ERR_PTR(ret);
 	}

drivers/block/virtio_blk.c+12−5

 	err = virtblk_add_req(vblk->vqs[qid].vq, vbr, vbr->sg, num);
 	if (err) {
 		virtqueue_kick(vblk->vqs[qid].vq);
-		blk_mq_stop_hw_queue(hctx);
+		/* Don't stop the queue if -ENOMEM: we may have failed to
+		 * bounce the buffer due to global resource outage.
+		 */
+		if (err == -ENOSPC)
+			blk_mq_stop_hw_queue(hctx);
 		spin_unlock_irqrestore(&vblk->vqs[qid].lock, flags);
-		/* Out of mem doesn't actually happen, since we fall back
+		switch (err) {
-		 * to direct descriptors */
+		case -ENOSPC:
-		if (err == -ENOMEM || err == -ENOSPC)
 			return BLK_STS_DEV_RESOURCE;
-		return BLK_STS_IOERR;
+		case -ENOMEM:
+			return BLK_STS_RESOURCE;
+		default:
+			return BLK_STS_IOERR;
+		}
 	}
 	if (bd->last && virtqueue_kick_prepare(vblk->vqs[qid].vq))

drivers/char/ipmi/ipmi_si_platform.c+2−2

@@ -194,7 +194,7 @@ static int platform_ipmi_probe(struct platform_device *pdev) · 193 unmodified lines
194	else	194	else
195	io.slave_addr = slave_addr;	195	io.slave_addr = slave_addr;
196		196
197	io.irq = platform_get_irq(pdev, 0);	197	io.irq = platform_get_irq_optional(pdev, 0);
198	if (io.irq > 0)	198	if (io.irq > 0)
199	io.irq_setup = ipmi_std_irq_setup;	199	io.irq_setup = ipmi_std_irq_setup;
200	else	200	else
@@ -378,7 +378,7 @@ static int acpi_ipmi_probe(struct platform_device *pdev) · 177 unmodified lines
378	io.irq = tmp;	378	io.irq = tmp;
379	io.irq_setup = acpi_gpe_irq_setup;	379	io.irq_setup = acpi_gpe_irq_setup;
380	} else {	380	} else {
381	int irq = platform_get_irq(pdev, 0);	381	int irq = platform_get_irq_optional(pdev, 0);
382		382
383	if (irq > 0) {	383	if (irq > 0) {
384	io.irq = irq;	384	io.irq = irq;

drivers/clk/clk.c+2−2

@@ -4713,7 +4713,7 @@ EXPORT_SYMBOL(of_clk_get_by_name); · 4712 unmodified lines
4713	*	4713	*
4714	* Returns: The number of clocks that are possible parents of this node	4714	* Returns: The number of clocks that are possible parents of this node
4715	*/	4715	*/
4716	unsigned int of_clk_get_parent_count(struct device_node *np)	4716	unsigned int of_clk_get_parent_count(const struct device_node *np)
4717	{	4717	{
4718	int count;	4718	int count;
4719		4719
@@ -4725,7 +4725,7 @@ unsigned int of_clk_get_parent_count(struct device_node *np) · 5 unmodified lines
4725	}	4725	}
4726	EXPORT_SYMBOL_GPL(of_clk_get_parent_count);	4726	EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
4727		4727
4728	const char of_clk_get_parent_name(struct device_node np, int index)	4728	const char of_clk_get_parent_name(const struct device_node np, int index)
4729	{	4729	{
4730	struct of_phandle_args clkspec;	4730	struct of_phandle_args clkspec;
4731	struct property *prop;	4731	struct property *prop;

drivers/clk/qcom/dispcc-sc7180.c+0−19

@@ -592,24 +592,6 @@ static struct clk_branch disp_cc_mdss_rot_clk = { · 591 unmodified lines
592	},	592	},
593	};	593	};
594		594
595	static struct clk_branch disp_cc_mdss_rscc_ahb_clk = {
596	.halt_reg = 0x400c,
597	.halt_check = BRANCH_HALT,
598	.clkr = {
599	.enable_reg = 0x400c,
600	.enable_mask = BIT(0),
601	.hw.init = &(struct clk_init_data){
602	.name = "disp_cc_mdss_rscc_ahb_clk",
603	.parent_data = &(const struct clk_parent_data){
604	.hw = &disp_cc_mdss_ahb_clk_src.clkr.hw,
605	},
606	.num_parents = 1,
607	.flags = CLK_IS_CRITICAL \| CLK_SET_RATE_PARENT,
608	.ops = &clk_branch2_ops,
609	},
610	},
611	};
612
613	static struct clk_branch disp_cc_mdss_rscc_vsync_clk = {	595	static struct clk_branch disp_cc_mdss_rscc_vsync_clk = {
614	.halt_reg = 0x4008,	596	.halt_reg = 0x4008,
615	.halt_check = BRANCH_HALT,	597	.halt_check = BRANCH_HALT,
@@ -687,7 +669,6 @@ static struct clk_regmap *disp_cc_sc7180_clocks[] = { · 71 unmodified lines
687	[DISP_CC_MDSS_PCLK0_CLK_SRC] = &disp_cc_mdss_pclk0_clk_src.clkr,	669	[DISP_CC_MDSS_PCLK0_CLK_SRC] = &disp_cc_mdss_pclk0_clk_src.clkr,
688	[DISP_CC_MDSS_ROT_CLK] = &disp_cc_mdss_rot_clk.clkr,	670	[DISP_CC_MDSS_ROT_CLK] = &disp_cc_mdss_rot_clk.clkr,
689	[DISP_CC_MDSS_ROT_CLK_SRC] = &disp_cc_mdss_rot_clk_src.clkr,	671	[DISP_CC_MDSS_ROT_CLK_SRC] = &disp_cc_mdss_rot_clk_src.clkr,
690	[DISP_CC_MDSS_RSCC_AHB_CLK] = &disp_cc_mdss_rscc_ahb_clk.clkr,
691	[DISP_CC_MDSS_RSCC_VSYNC_CLK] = &disp_cc_mdss_rscc_vsync_clk.clkr,	672	[DISP_CC_MDSS_RSCC_VSYNC_CLK] = &disp_cc_mdss_rscc_vsync_clk.clkr,
692	[DISP_CC_MDSS_VSYNC_CLK] = &disp_cc_mdss_vsync_clk.clkr,	673	[DISP_CC_MDSS_VSYNC_CLK] = &disp_cc_mdss_vsync_clk.clkr,
693	[DISP_CC_MDSS_VSYNC_CLK_SRC] = &disp_cc_mdss_vsync_clk_src.clkr,	674	[DISP_CC_MDSS_VSYNC_CLK_SRC] = &disp_cc_mdss_vsync_clk_src.clkr,

drivers/clk/qcom/videocc-sc7180.c+1−1

@@ -97,7 +97,7 @@ static struct clk_branch video_cc_vcodec0_axi_clk = { · 96 unmodified lines
97		97
98	static struct clk_branch video_cc_vcodec0_core_clk = {	98	static struct clk_branch video_cc_vcodec0_core_clk = {
99	.halt_reg = 0x890,	99	.halt_reg = 0x890,
100	.halt_check = BRANCH_HALT,	100	.halt_check = BRANCH_HALT_VOTED,
101	.clkr = {	101	.clkr = {
102	.enable_reg = 0x890,	102	.enable_reg = 0x890,
103	.enable_mask = BIT(0),	103	.enable_mask = BIT(0),

drivers/firmware/efi/efivars.c+23−9

 efivar_attr_read(struct efivar_entry *entry, char *buf)
 {
 	struct efi_variable *var = &entry->var;
+	unsigned long size = sizeof(var->Data);
 	char *str = buf;
+	int ret;
 	if (!entry || !buf)
 		return -EINVAL;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &size, var->Data);
-	if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+	var->DataSize = size;
+	if (ret)
 		return -EIO;
 	if (var->Attributes & EFI_VARIABLE_NON_VOLATILE)
 efivar_size_read(struct efivar_entry *entry, char *buf)
 {
 	struct efi_variable *var = &entry->var;
+	unsigned long size = sizeof(var->Data);
 	char *str = buf;
+	int ret;
 	if (!entry || !buf)
 		return -EINVAL;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &size, var->Data);
-	if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+	var->DataSize = size;
+	if (ret)
 		return -EIO;
 	str += sprintf(str, "0x%lx\n", var->DataSize);
 efivar_data_read(struct efivar_entry *entry, char *buf)
 {
 	struct efi_variable *var = &entry->var;
+	unsigned long size = sizeof(var->Data);
+	int ret;
 	if (!entry || !buf)
 		return -EINVAL;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &size, var->Data);
-	if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+	var->DataSize = size;
+	if (ret)
 		return -EIO;
 	memcpy(buf, var->Data, var->DataSize);
 	u8 *data;
 	int err;
+	if (!entry || !buf)
+		return -EINVAL;
 	if (in_compat_syscall()) {
 		struct compat_efi_variable *compat;
 {
 	struct efi_variable *var = &entry->var;
 	struct compat_efi_variable *compat;
+	unsigned long datasize = sizeof(var->Data);
 	size_t size;
+	int ret;
 	if (!entry || !buf)
 		return 0;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &datasize, var->Data);
-	if (efivar_entry_get(entry, &entry->var.Attributes,
+	var->DataSize = datasize;
-			     &entry->var.DataSize, entry->var.Data))
+	if (ret)
 		return -EIO;
 	if (in_compat_syscall()) {

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c+3−3

@@ -781,11 +781,11 @@ static ssize_t amdgpu_debugfs_gpr_read(struct file f, char __user buf, · 780 unmodified lines
781	ssize_t result = 0;	781	ssize_t result = 0;
782	uint32_t offset, se, sh, cu, wave, simd, thread, bank, *data;	782	uint32_t offset, se, sh, cu, wave, simd, thread, bank, *data;
783		783
784	if (size & 3 \|\| *pos & 3)	784	if (size > 4096 \|\| size & 3 \|\| *pos & 3)
785	return -EINVAL;	785	return -EINVAL;
786		786
787	/* decode offset */	787	/* decode offset */
788	offset = *pos & GENMASK_ULL(11, 0);	788	offset = (*pos & GENMASK_ULL(11, 0)) >> 2;
789	se = (*pos & GENMASK_ULL(19, 12)) >> 12;	789	se = (*pos & GENMASK_ULL(19, 12)) >> 12;
790	sh = (*pos & GENMASK_ULL(27, 20)) >> 20;	790	sh = (*pos & GENMASK_ULL(27, 20)) >> 20;
791	cu = (*pos & GENMASK_ULL(35, 28)) >> 28;	791	cu = (*pos & GENMASK_ULL(35, 28)) >> 28;
@@ -823,7 +823,7 @@ static ssize_t amdgpu_debugfs_gpr_read(struct file f, char __user buf, · 31 unmodified lines
823	while (size) {	823	while (size) {
824	uint32_t value;	824	uint32_t value;
825		825
826	value = data[offset++];	826	value = data[result >> 2];
827	r = put_user(value, (uint32_t *)buf);	827	r = put_user(value, (uint32_t *)buf);
828	if (r) {	828	if (r) {
829	result = r;	829	result = r;

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

 				if (r)
 					goto out;
+				amdgpu_fbdev_set_suspend(tmp_adev, 0);
 				/* must succeed. */
 				amdgpu_ras_resume(tmp_adev);
 		 */
 		amdgpu_unregister_gpu_instance(tmp_adev);
+		amdgpu_fbdev_set_suspend(adev, 1);
 		/* disable ras on ALL IPs */
 		if (!(in_ras_intr && !use_baco) &&
 		      amdgpu_device_ip_need_full_reset(tmp_adev))

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

@@ -693,7 +693,7 @@ static int jpeg_v2_0_set_clockgating_state(void *handle, · 692 unmodified lines
693	bool enable = (state == AMD_CG_STATE_GATE);	693	bool enable = (state == AMD_CG_STATE_GATE);
694		694
695	if (enable) {	695	if (enable) {
696	if (jpeg_v2_0_is_idle(handle))	696	if (!jpeg_v2_0_is_idle(handle))
697	return -EBUSY;	697	return -EBUSY;
698	jpeg_v2_0_enable_clock_gating(adev);	698	jpeg_v2_0_enable_clock_gating(adev);
699	} else {	699	} else {

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

@@ -477,7 +477,7 @@ static int jpeg_v2_5_set_clockgating_state(void *handle, · 476 unmodified lines
477	continue;	477	continue;
478		478
479	if (enable) {	479	if (enable) {
480	if (jpeg_v2_5_is_idle(handle))	480	if (!jpeg_v2_5_is_idle(handle))
481	return -EBUSY;	481	return -EBUSY;
482	jpeg_v2_5_enable_clock_gating(adev, i);	482	jpeg_v2_5_enable_clock_gating(adev, i);
483	} else {	483	} else {

drivers/gpu/drm/amd/amdgpu/soc15.c+23−2

 #define HDP_MEM_POWER_CTRL__RC_MEM_POWER_CTRL_EN_MASK	0x00010000L
 #define HDP_MEM_POWER_CTRL__RC_MEM_POWER_LS_EN_MASK		0x00020000L
 #define mmHDP_MEM_POWER_CTRL_BASE_IDX	0
+/* for Vega20/arcturus regiter offset change */
+#define	mmROM_INDEX_VG20				0x00e4
+#define	mmROM_INDEX_VG20_BASE_IDX			0
+#define	mmROM_DATA_VG20					0x00e5
+#define	mmROM_DATA_VG20_BASE_IDX			0
 /*
  * Indirect registers accessor
  */
 {
 	u32 *dw_ptr;
 	u32 i, length_dw;
+	uint32_t rom_index_offset;
+	uint32_t rom_data_offset;
 	if (bios == NULL)
 		return false;
 	dw_ptr = (u32 *)bios;
 	length_dw = ALIGN(length_bytes, 4) / 4;
+	switch (adev->asic_type) {
+	case CHIP_VEGA20:
+	case CHIP_ARCTURUS:
+		rom_index_offset = SOC15_REG_OFFSET(SMUIO, 0, mmROM_INDEX_VG20);
+		rom_data_offset = SOC15_REG_OFFSET(SMUIO, 0, mmROM_DATA_VG20);
+		break;
+	default:
+		rom_index_offset = SOC15_REG_OFFSET(SMUIO, 0, mmROM_INDEX);
+		rom_data_offset = SOC15_REG_OFFSET(SMUIO, 0, mmROM_DATA);
+		break;
+	}
 	/* set rom index to 0 */
-	WREG32(SOC15_REG_OFFSET(SMUIO, 0, mmROM_INDEX), 0);
+	WREG32(rom_index_offset, 0);
 	/* read out the rom data */
 	for (i = 0; i < length_dw; i++)
-		dw_ptr[i] = RREG32(SOC15_REG_OFFSET(SMUIO, 0, mmROM_DATA));
+		dw_ptr[i] = RREG32(rom_data_offset);
 	return true;
 }

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

@@ -1352,7 +1352,7 @@ static int vcn_v1_0_set_clockgating_state(void *handle, · 1351 unmodified lines
1352		1352
1353	if (enable) {	1353	if (enable) {
1354	/* wait for STATUS to clear */	1354	/* wait for STATUS to clear */
1355	if (vcn_v1_0_is_idle(handle))	1355	if (!vcn_v1_0_is_idle(handle))
1356	return -EBUSY;	1356	return -EBUSY;
1357	vcn_v1_0_enable_clock_gating(adev);	1357	vcn_v1_0_enable_clock_gating(adev);
1358	} else {	1358	} else {

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

@@ -1217,7 +1217,7 @@ static int vcn_v2_0_set_clockgating_state(void *handle, · 1216 unmodified lines
1217		1217
1218	if (enable) {	1218	if (enable) {
1219	/* wait for STATUS to clear */	1219	/* wait for STATUS to clear */
1220	if (vcn_v2_0_is_idle(handle))	1220	if (!vcn_v2_0_is_idle(handle))
1221	return -EBUSY;	1221	return -EBUSY;
1222	vcn_v2_0_enable_clock_gating(adev);	1222	vcn_v2_0_enable_clock_gating(adev);
1223	} else {	1223	} else {

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

@@ -1672,7 +1672,7 @@ static int vcn_v2_5_set_clockgating_state(void *handle, · 1671 unmodified lines
1672	return 0;	1672	return 0;
1673		1673
1674	if (enable) {	1674	if (enable) {
1675	if (vcn_v2_5_is_idle(handle))	1675	if (!vcn_v2_5_is_idle(handle))
1676	return -EBUSY;	1676	return -EBUSY;
1677	vcn_v2_5_enable_clock_gating(adev);	1677	vcn_v2_5_enable_clock_gating(adev);
1678	} else {	1678	} else {

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

 	acrtc_state = to_dm_crtc_state(acrtc->base.state);
-	DRM_DEBUG_DRIVER("crtc:%d, vupdate-vrr:%d\n", acrtc->crtc_id,
+	DRM_DEBUG_DRIVER("crtc:%d, vupdate-vrr:%d, planes:%d\n", acrtc->crtc_id,
-				amdgpu_dm_vrr_active(acrtc_state));
+			 amdgpu_dm_vrr_active(acrtc_state),
+			 acrtc_state->active_planes);
 	amdgpu_dm_crtc_handle_crc_irq(&acrtc->base);
 	drm_crtc_handle_vblank(&acrtc->base);
 			&acrtc_state->vrr_params.adjust);
 	}
-	if (acrtc->pflip_status == AMDGPU_FLIP_SUBMITTED) {
+	/*
+	 * If there aren't any active_planes then DCH HUBP may be clock-gated.
+	 * In that case, pageflip completion interrupts won't fire and pageflip
+	 * completion events won't get delivered. Prevent this by sending
+	 * pending pageflip events from here if a flip is still pending.
+	 *
+	 * If any planes are enabled, use dm_pflip_high_irq() instead, to
+	 * avoid race conditions between flip programming and completion,
+	 * which could cause too early flip completion events.
+	 */
+	if (acrtc->pflip_status == AMDGPU_FLIP_SUBMITTED &&
+	    acrtc_state->active_planes == 0) {
 		if (acrtc->event) {
 			drm_crtc_send_vblank_event(&acrtc->base, acrtc->event);
 			acrtc->event = NULL;

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

@@ -3401,6 +3401,17 @@ static bool retrieve_link_cap(struct dc_link *link) · 3400 unmodified lines
3401	sink_id.ieee_device_id,	3401	sink_id.ieee_device_id,
3402	sizeof(sink_id.ieee_device_id));	3402	sizeof(sink_id.ieee_device_id));
3403		3403
		3404	/* Quirk Apple MBP 2017 15" Retina panel: Wrong DP_MAX_LINK_RATE */
		3405	{
		3406	uint8_t str_mbp_2017[] = { 101, 68, 21, 101, 98, 97 };
		3407
		3408	if ((link->dpcd_caps.sink_dev_id == 0x0010fa) &&
		3409	!memcmp(link->dpcd_caps.sink_dev_id_str, str_mbp_2017,
		3410	sizeof(str_mbp_2017))) {
		3411	link->reported_link_cap.link_rate = 0x0c;
		3412	}
		3413	}
		3414
3404	core_link_read_dpcd(	3415	core_link_read_dpcd(
3405	link,	3416	link,
3406	DP_SINK_HW_REVISION_START,	3417	DP_SINK_HW_REVISION_START,

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

@@ -108,7 +108,6 @@ static const struct hwseq_private_funcs dcn20_private_funcs = { · 107 unmodified lines
108	.enable_power_gating_plane = dcn20_enable_power_gating_plane,	108	.enable_power_gating_plane = dcn20_enable_power_gating_plane,
109	.dpp_pg_control = dcn20_dpp_pg_control,	109	.dpp_pg_control = dcn20_dpp_pg_control,
110	.hubp_pg_control = dcn20_hubp_pg_control,	110	.hubp_pg_control = dcn20_hubp_pg_control,
111	.dsc_pg_control = NULL,
112	.update_odm = dcn20_update_odm,	111	.update_odm = dcn20_update_odm,
113	.dsc_pg_control = dcn20_dsc_pg_control,	112	.dsc_pg_control = dcn20_dsc_pg_control,
114	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,	113	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c+114−0

@@ -335,6 +335,117 @@ struct _vcs_dpi_soc_bounding_box_st dcn2_0_soc = { · 334 unmodified lines
335	.use_urgent_burst_bw = 0	335	.use_urgent_burst_bw = 0
336	};	336	};
337		337
		338	struct _vcs_dpi_soc_bounding_box_st dcn2_0_nv14_soc = {
		339	.clock_limits = {
		340	{
		341	.state = 0,
		342	.dcfclk_mhz = 560.0,
		343	.fabricclk_mhz = 560.0,
		344	.dispclk_mhz = 513.0,
		345	.dppclk_mhz = 513.0,
		346	.phyclk_mhz = 540.0,
		347	.socclk_mhz = 560.0,
		348	.dscclk_mhz = 171.0,
		349	.dram_speed_mts = 8960.0,
		350	},
		351	{
		352	.state = 1,
		353	.dcfclk_mhz = 694.0,
		354	.fabricclk_mhz = 694.0,
		355	.dispclk_mhz = 642.0,
		356	.dppclk_mhz = 642.0,
		357	.phyclk_mhz = 600.0,
		358	.socclk_mhz = 694.0,
		359	.dscclk_mhz = 214.0,
		360	.dram_speed_mts = 11104.0,
		361	},
		362	{
		363	.state = 2,
		364	.dcfclk_mhz = 875.0,
		365	.fabricclk_mhz = 875.0,
		366	.dispclk_mhz = 734.0,
		367	.dppclk_mhz = 734.0,
		368	.phyclk_mhz = 810.0,
		369	.socclk_mhz = 875.0,
		370	.dscclk_mhz = 245.0,
		371	.dram_speed_mts = 14000.0,
		372	},
		373	{
		374	.state = 3,
		375	.dcfclk_mhz = 1000.0,
		376	.fabricclk_mhz = 1000.0,
		377	.dispclk_mhz = 1100.0,
		378	.dppclk_mhz = 1100.0,
		379	.phyclk_mhz = 810.0,
		380	.socclk_mhz = 1000.0,
		381	.dscclk_mhz = 367.0,
		382	.dram_speed_mts = 16000.0,
		383	},
		384	{
		385	.state = 4,
		386	.dcfclk_mhz = 1200.0,
		387	.fabricclk_mhz = 1200.0,
		388	.dispclk_mhz = 1284.0,
		389	.dppclk_mhz = 1284.0,
		390	.phyclk_mhz = 810.0,
		391	.socclk_mhz = 1200.0,
		392	.dscclk_mhz = 428.0,
		393	.dram_speed_mts = 16000.0,
		394	},
		395	/Extra state, no dispclk ramping/
		396	{
		397	.state = 5,
		398	.dcfclk_mhz = 1200.0,
		399	.fabricclk_mhz = 1200.0,
		400	.dispclk_mhz = 1284.0,
		401	.dppclk_mhz = 1284.0,
		402	.phyclk_mhz = 810.0,
		403	.socclk_mhz = 1200.0,
		404	.dscclk_mhz = 428.0,
		405	.dram_speed_mts = 16000.0,
		406	},
		407	},
		408	.num_states = 5,
		409	.sr_exit_time_us = 8.6,
		410	.sr_enter_plus_exit_time_us = 10.9,
		411	.urgent_latency_us = 4.0,
		412	.urgent_latency_pixel_data_only_us = 4.0,
		413	.urgent_latency_pixel_mixed_with_vm_data_us = 4.0,
		414	.urgent_latency_vm_data_only_us = 4.0,
		415	.urgent_out_of_order_return_per_channel_pixel_only_bytes = 4096,
		416	.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes = 4096,
		417	.urgent_out_of_order_return_per_channel_vm_only_bytes = 4096,
		418	.pct_ideal_dram_sdp_bw_after_urgent_pixel_only = 40.0,
		419	.pct_ideal_dram_sdp_bw_after_urgent_pixel_and_vm = 40.0,
		420	.pct_ideal_dram_sdp_bw_after_urgent_vm_only = 40.0,
		421	.max_avg_sdp_bw_use_normal_percent = 40.0,
		422	.max_avg_dram_bw_use_normal_percent = 40.0,
		423	.writeback_latency_us = 12.0,
		424	.ideal_dram_bw_after_urgent_percent = 40.0,
		425	.max_request_size_bytes = 256,
		426	.dram_channel_width_bytes = 2,
		427	.fabric_datapath_to_dcn_data_return_bytes = 64,
		428	.dcn_downspread_percent = 0.5,
		429	.downspread_percent = 0.38,
		430	.dram_page_open_time_ns = 50.0,
		431	.dram_rw_turnaround_time_ns = 17.5,
		432	.dram_return_buffer_per_channel_bytes = 8192,
		433	.round_trip_ping_latency_dcfclk_cycles = 131,
		434	.urgent_out_of_order_return_per_channel_bytes = 256,
		435	.channel_interleave_bytes = 256,
		436	.num_banks = 8,
		437	.num_chans = 8,
		438	.vmm_page_size_bytes = 4096,
		439	.dram_clock_change_latency_us = 404.0,
		440	.dummy_pstate_latency_us = 5.0,
		441	.writeback_dram_clock_change_latency_us = 23.0,
		442	.return_bus_width_bytes = 64,
		443	.dispclk_dppclk_vco_speed_mhz = 3850,
		444	.xfc_bus_transport_time_us = 20,
		445	.xfc_xbuf_latency_tolerance_us = 4,
		446	.use_urgent_burst_bw = 0
		447	};
		448
338	struct _vcs_dpi_soc_bounding_box_st dcn2_0_nv12_soc = { 0 };	449	struct _vcs_dpi_soc_bounding_box_st dcn2_0_nv12_soc = { 0 };
339		450
340	#ifndef mmDP0_DP_DPHY_INTERNAL_CTRL	451	#ifndef mmDP0_DP_DPHY_INTERNAL_CTRL
@@ -3291,6 +3402,9 @@ void dcn20_patch_bounding_box(struct dc *dc, struct _vcs_dpi_soc_bounding_box_st · 2950 unmodified lines
3291	static struct _vcs_dpi_soc_bounding_box_st *get_asic_rev_soc_bb(	3402	static struct _vcs_dpi_soc_bounding_box_st *get_asic_rev_soc_bb(
3292	uint32_t hw_internal_rev)	3403	uint32_t hw_internal_rev)
3293	{	3404	{
		3405	if (ASICREV_IS_NAVI14_M(hw_internal_rev))
		3406	return &dcn2_0_nv14_soc;
		3407
3294	if (ASICREV_IS_NAVI12_P(hw_internal_rev))	3408	if (ASICREV_IS_NAVI12_P(hw_internal_rev))
3295	return &dcn2_0_nv12_soc;	3409	return &dcn2_0_nv12_soc;
3296		3410

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

@@ -116,7 +116,6 @@ static const struct hwseq_private_funcs dcn21_private_funcs = { · 115 unmodified lines
116	.enable_power_gating_plane = dcn20_enable_power_gating_plane,	116	.enable_power_gating_plane = dcn20_enable_power_gating_plane,
117	.dpp_pg_control = dcn20_dpp_pg_control,	117	.dpp_pg_control = dcn20_dpp_pg_control,
118	.hubp_pg_control = dcn20_hubp_pg_control,	118	.hubp_pg_control = dcn20_hubp_pg_control,
119	.dsc_pg_control = NULL,
120	.update_odm = dcn20_update_odm,	119	.update_odm = dcn20_update_odm,
121	.dsc_pg_control = dcn20_dsc_pg_control,	120	.dsc_pg_control = dcn20_dsc_pg_control,
122	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,	121	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,

drivers/gpu/drm/amd/powerplay/amdgpu_smu.c+5−2

@@ -2006,8 +2006,11 @@ int smu_set_watermarks_for_clock_ranges(struct smu_context *smu, · 2005 unmodified lines
2006	smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT) &&	2006	smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT) &&
2007	smu_feature_is_enabled(smu, SMU_FEATURE_DPM_SOCCLK_BIT)) {	2007	smu_feature_is_enabled(smu, SMU_FEATURE_DPM_SOCCLK_BIT)) {
2008	smu_set_watermarks_table(smu, table, clock_ranges);	2008	smu_set_watermarks_table(smu, table, clock_ranges);
2009	smu->watermarks_bitmap \|= WATERMARKS_EXIST;	2009
2010	smu->watermarks_bitmap &= ~WATERMARKS_LOADED;	2010	if (!(smu->watermarks_bitmap & WATERMARKS_EXIST)) {
		2011	smu->watermarks_bitmap \|= WATERMARKS_EXIST;
		2012	smu->watermarks_bitmap &= ~WATERMARKS_LOADED;
		2013	}
2011	}	2014	}
2012		2015
2013	mutex_unlock(&smu->mutex);	2016	mutex_unlock(&smu->mutex);

drivers/gpu/drm/amd/powerplay/navi10_ppt.c+13−9

 {
 	int ret = 0;
-	if ((smu->watermarks_bitmap & WATERMARKS_EXIST) &&
-	    !(smu->watermarks_bitmap & WATERMARKS_LOADED)) {
-		ret = smu_write_watermarks_table(smu);
-		if (ret)
-			return ret;
-		smu->watermarks_bitmap |= WATERMARKS_LOADED;
-	}
 	if ((smu->watermarks_bitmap & WATERMARKS_EXIST) &&
 	    smu_feature_is_supported(smu, SMU_FEATURE_DPM_DCEFCLK_BIT) &&
 	    smu_feature_is_supported(smu, SMU_FEATURE_DPM_SOCCLK_BIT)) {
 				       *clock_ranges)
 {
 	int i;
+	int ret = 0;
 	Watermarks_t *table = watermarks;
 	if (!table || !clock_ranges)
 				clock_ranges->wm_mcif_clocks_ranges[i].wm_set_id;
 	}
+	smu->watermarks_bitmap |= WATERMARKS_EXIST;
+	/* pass data to smu controller */
+	if (!(smu->watermarks_bitmap & WATERMARKS_LOADED)) {
+		ret = smu_write_watermarks_table(smu);
+		if (ret) {
+			pr_err("Failed to update WMTABLE!");
+			return ret;
+		}
+		smu->watermarks_bitmap |= WATERMARKS_LOADED;
+	}
 	return 0;
 }

drivers/gpu/drm/amd/powerplay/renoir_ppt.c+3−2

 				clock_ranges->wm_mcif_clocks_ranges[i].wm_set_id;
 	}
+	smu->watermarks_bitmap |= WATERMARKS_EXIST;
 	/* pass data to smu controller */
-	if ((smu->watermarks_bitmap & WATERMARKS_EXIST) &&
+	if (!(smu->watermarks_bitmap & WATERMARKS_LOADED)) {
-			!(smu->watermarks_bitmap & WATERMARKS_LOADED)) {
 		ret = smu_write_watermarks_table(smu);
 		if (ret) {
 			pr_err("Failed to update WMTABLE!");

drivers/gpu/drm/arm/display/komeda/komeda_drv.c+2−2

@@ -146,14 +146,14 @@ static const struct of_device_id komeda_of_match[] = { · 145 unmodified lines
146		146
147	MODULE_DEVICE_TABLE(of, komeda_of_match);	147	MODULE_DEVICE_TABLE(of, komeda_of_match);
148		148
149	static int komeda_rt_pm_suspend(struct device *dev)	149	static int __maybe_unused komeda_rt_pm_suspend(struct device *dev)
150	{	150	{
151	struct komeda_drv *mdrv = dev_get_drvdata(dev);	151	struct komeda_drv *mdrv = dev_get_drvdata(dev);
152		152
153	return komeda_dev_suspend(mdrv->mdev);	153	return komeda_dev_suspend(mdrv->mdev);
154	}	154	}
155		155
156	static int komeda_rt_pm_resume(struct device *dev)	156	static int __maybe_unused komeda_rt_pm_resume(struct device *dev)
157	{	157	{
158	struct komeda_drv *mdrv = dev_get_drvdata(dev);	158	struct komeda_drv *mdrv = dev_get_drvdata(dev);
159		159

drivers/gpu/drm/bochs/bochs_hw.c+2−4

 		size = min(size, mem);
 	}
-	if (pci_request_region(pdev, 0, "bochs-drm") != 0) {
+	if (pci_request_region(pdev, 0, "bochs-drm") != 0)
-		DRM_ERROR("Cannot request framebuffer\n");
+		DRM_WARN("Cannot request framebuffer, boot fb still active?\n");
-		return -EBUSY;
-	}
 	bochs->fb_map = ioremap(addr, size);
 	if (bochs->fb_map == NULL) {

drivers/gpu/drm/bridge/synopsys/dw-hdmi.c+26−20

 		frame.colorspace = HDMI_COLORSPACE_RGB;
 	/* Set up colorimetry */
-	switch (hdmi->hdmi_data.enc_out_encoding) {
+	if (!hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_out_bus_format)) {
-	case V4L2_YCBCR_ENC_601:
+		switch (hdmi->hdmi_data.enc_out_encoding) {
-		if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV601)
+		case V4L2_YCBCR_ENC_601:
-			frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
+			if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV601)
-		else
+				frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
+			else
+				frame.colorimetry = HDMI_COLORIMETRY_ITU_601;
+			frame.extended_colorimetry =
+					HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+			break;
+		case V4L2_YCBCR_ENC_709:
+			if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV709)
+				frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
+			else
+				frame.colorimetry = HDMI_COLORIMETRY_ITU_709;
+			frame.extended_colorimetry =
+					HDMI_EXTENDED_COLORIMETRY_XV_YCC_709;
+			break;
+		default: /* Carries no data */
 			frame.colorimetry = HDMI_COLORIMETRY_ITU_601;
+			frame.extended_colorimetry =
+					HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+			break;
+		}
+	} else {
+		frame.colorimetry = HDMI_COLORIMETRY_NONE;
 		frame.extended_colorimetry =
-				HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+			HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
-		break;
-	case V4L2_YCBCR_ENC_709:
-		if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV709)
-			frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
-		else
-			frame.colorimetry = HDMI_COLORIMETRY_ITU_709;
-		frame.extended_colorimetry =
-				HDMI_EXTENDED_COLORIMETRY_XV_YCC_709;
-		break;
-	default: /* Carries no data */
-		frame.colorimetry = HDMI_COLORIMETRY_ITU_601;
-		frame.extended_colorimetry =
-				HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
-		break;
 	}
 	frame.scan_mode = HDMI_SCAN_MODE_NONE;

drivers/gpu/drm/drm_dp_mst_topology.c+126−58

@@ -1935,7 +1935,7 @@ static u8 drm_dp_calculate_rad(struct drm_dp_mst_port *port, · 1934 unmodified lines
1935	return parent_lct + 1;	1935	return parent_lct + 1;
1936	}	1936	}
1937		1937
1938	static bool drm_dp_mst_is_dp_mst_end_device(u8 pdt, bool mcs)	1938	static bool drm_dp_mst_is_end_device(u8 pdt, bool mcs)
1939	{	1939	{
1940	switch (pdt) {	1940	switch (pdt) {
1941	case DP_PEER_DEVICE_DP_LEGACY_CONV:	1941	case DP_PEER_DEVICE_DP_LEGACY_CONV:
@@ -1965,13 +1965,13 @@ drm_dp_port_set_pdt(struct drm_dp_mst_port *port, u8 new_pdt, · 23 unmodified lines
1965		1965
1966	/* Teardown the old pdt, if there is one */	1966	/* Teardown the old pdt, if there is one */
1967	if (port->pdt != DP_PEER_DEVICE_NONE) {	1967	if (port->pdt != DP_PEER_DEVICE_NONE) {
1968	if (drm_dp_mst_is_dp_mst_end_device(port->pdt, port->mcs)) {	1968	if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) {
1969	/*	1969	/*
1970	* If the new PDT would also have an i2c bus,	1970	* If the new PDT would also have an i2c bus,
1971	* don't bother with reregistering it	1971	* don't bother with reregistering it
1972	*/	1972	*/
1973	if (new_pdt != DP_PEER_DEVICE_NONE &&	1973	if (new_pdt != DP_PEER_DEVICE_NONE &&
1974	drm_dp_mst_is_dp_mst_end_device(new_pdt, new_mcs)) {	1974	drm_dp_mst_is_end_device(new_pdt, new_mcs)) {
1975	port->pdt = new_pdt;	1975	port->pdt = new_pdt;
1976	port->mcs = new_mcs;	1976	port->mcs = new_mcs;
1977	return 0;	1977	return 0;
@@ -1991,7 +1991,7 @@ drm_dp_port_set_pdt(struct drm_dp_mst_port *port, u8 new_pdt, · 13 unmodified lines
1991	port->mcs = new_mcs;	1991	port->mcs = new_mcs;
1992		1992
1993	if (port->pdt != DP_PEER_DEVICE_NONE) {	1993	if (port->pdt != DP_PEER_DEVICE_NONE) {
1994	if (drm_dp_mst_is_dp_mst_end_device(port->pdt, port->mcs)) {	1994	if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) {
1995	/* add i2c over sideband */	1995	/* add i2c over sideband */
1996	ret = drm_dp_mst_register_i2c_bus(&port->aux);	1996	ret = drm_dp_mst_register_i2c_bus(&port->aux);
1997	} else {	1997	} else {
@@ -2172,7 +2172,7 @@ drm_dp_mst_port_add_connector(struct drm_dp_mst_branch *mstb, · 174 unmodified lines
2172	}	2172	}
2173		2173
2174	if (port->pdt != DP_PEER_DEVICE_NONE &&	2174	if (port->pdt != DP_PEER_DEVICE_NONE &&
2175	drm_dp_mst_is_dp_mst_end_device(port->pdt, port->mcs)) {	2175	drm_dp_mst_is_end_device(port->pdt, port->mcs)) {
2176	port->cached_edid = drm_get_edid(port->connector,	2176	port->cached_edid = drm_get_edid(port->connector,
2177	&port->aux.ddc);	2177	&port->aux.ddc);
2178	drm_connector_set_tile_property(port->connector);	2178	drm_connector_set_tile_property(port->connector);
@@ -2302,14 +2302,18 @@ drm_dp_mst_handle_link_address_port(struct drm_dp_mst_branch *mstb, · 123 unmodified lines
2302	mutex_unlock(&mgr->lock);	2302	mutex_unlock(&mgr->lock);
2303	}	2303	}
2304		2304
2305	if (old_ddps != port->ddps) {	2305	/*
2306	if (port->ddps) {	2306	* Reprobe PBN caps on both hotplug, and when re-probing the link
2307	if (!port->input) {	2307	* for our parent mstb
2308	drm_dp_send_enum_path_resources(mgr, mstb,	2308	*/
2309	port);	2309	if (old_ddps != port->ddps \|\| !created) {
2310	}	2310	if (port->ddps && !port->input) {
		2311	ret = drm_dp_send_enum_path_resources(mgr, mstb,
		2312	port);
		2313	if (ret == 1)
		2314	changed = true;
2311	} else {	2315	} else {
2312	port->available_pbn = 0;	2316	port->full_pbn = 0;
2313	}	2317	}
2314	}	2318	}
2315		2319
@@ -2401,11 +2405,10 @@ drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch *mstb, · 85 unmodified lines
2401	port->ddps = conn_stat->displayport_device_plug_status;	2405	port->ddps = conn_stat->displayport_device_plug_status;
2402		2406
2403	if (old_ddps != port->ddps) {	2407	if (old_ddps != port->ddps) {
2404	if (port->ddps) {	2408	if (port->ddps && !port->input)
2405	dowork = true;	2409	drm_dp_send_enum_path_resources(mgr, mstb, port);
2406	} else {	2410	else
2407	port->available_pbn = 0;	2411	port->full_pbn = 0;
2408	}
2409	}	2412	}
2410		2413
2411	new_pdt = port->input ? DP_PEER_DEVICE_NONE : conn_stat->peer_device_type;	2414	new_pdt = port->input ? DP_PEER_DEVICE_NONE : conn_stat->peer_device_type;
@@ -2556,13 +2559,6 @@ static int drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr *mg · 144 unmodified lines
2556	if (port->input \|\| !port->ddps)	2559	if (port->input \|\| !port->ddps)
2557	continue;	2560	continue;
2558		2561
2559	if (!port->available_pbn) {
2560	drm_modeset_lock(&mgr->base.lock, NULL);
2561	drm_dp_send_enum_path_resources(mgr, mstb, port);
2562	drm_modeset_unlock(&mgr->base.lock);
2563	changed = true;
2564	}
2565
2566	if (port->mstb)	2562	if (port->mstb)
2567	mstb_child = drm_dp_mst_topology_get_mstb_validated(	2563	mstb_child = drm_dp_mst_topology_get_mstb_validated(
2568	mgr, port->mstb);	2564	mgr, port->mstb);
@@ -2990,6 +2986,7 @@ drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr, · 421 unmodified lines
2990		2986
2991	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);	2987	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
2992	if (ret > 0) {	2988	if (ret > 0) {
		2989	ret = 0;
2993	path_res = &txmsg->reply.u.path_resources;	2990	path_res = &txmsg->reply.u.path_resources;
2994		2991
2995	if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {	2992	if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {
@@ -3002,14 +2999,22 @@ drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr, · 6 unmodified lines
3002	path_res->port_number,	2999	path_res->port_number,
3003	path_res->full_payload_bw_number,	3000	path_res->full_payload_bw_number,
3004	path_res->avail_payload_bw_number);	3001	path_res->avail_payload_bw_number);
3005	port->available_pbn =	3002
3006	path_res->avail_payload_bw_number;	3003	/*
		3004	* If something changed, make sure we send a
		3005	* hotplug
		3006	*/
		3007	if (port->full_pbn != path_res->full_payload_bw_number \|\|
		3008	port->fec_capable != path_res->fec_capable)
		3009	ret = 1;
		3010
		3011	port->full_pbn = path_res->full_payload_bw_number;
3007	port->fec_capable = path_res->fec_capable;	3012	port->fec_capable = path_res->fec_capable;
3008	}	3013	}
3009	}	3014	}
3010		3015
3011	kfree(txmsg);	3016	kfree(txmsg);
3012	return 0;	3017	return ret;
3013	}	3018	}
3014		3019
3015	static struct drm_dp_mst_port drm_dp_get_last_connected_port_to_mstb(struct drm_dp_mst_branch mstb)	3020	static struct drm_dp_mst_port drm_dp_get_last_connected_port_to_mstb(struct drm_dp_mst_branch mstb)
@@ -3596,13 +3601,9 @@ drm_dp_mst_topology_mgr_invalidate_mstb(struct drm_dp_mst_branch *mstb) · 580 unmodified lines
3596	/* The link address will need to be re-sent on resume */	3601	/* The link address will need to be re-sent on resume */
3597	mstb->link_address_sent = false;	3602	mstb->link_address_sent = false;
3598		3603
3599	list_for_each_entry(port, &mstb->ports, next) {	3604	list_for_each_entry(port, &mstb->ports, next)
3600	/* The PBN for each port will also need to be re-probed */
3601	port->available_pbn = 0;
3602
3603	if (port->mstb)	3605	if (port->mstb)
3604	drm_dp_mst_topology_mgr_invalidate_mstb(port->mstb);	3606	drm_dp_mst_topology_mgr_invalidate_mstb(port->mstb);
3605	}
3606	}	3607	}
3607		3608
3608	/**	3609	/**
@@ -4829,41 +4830,102 @@ static bool drm_dp_mst_port_downstream_of_branch(struct drm_dp_mst_port *port, · 1220 unmodified lines
4829	return false;	4830	return false;
4830	}	4831	}
4831		4832
4832	static inline	4833	static int
4833	int drm_dp_mst_atomic_check_bw_limit(struct drm_dp_mst_branch *branch,	4834	drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port,
4834	struct drm_dp_mst_topology_state *mst_state)	4835	struct drm_dp_mst_topology_state *state);
		4836
		4837	static int
		4838	drm_dp_mst_atomic_check_mstb_bw_limit(struct drm_dp_mst_branch *mstb,
		4839	struct drm_dp_mst_topology_state *state)
4835	{	4840	{
4836	struct drm_dp_mst_port *port;
4837	struct drm_dp_vcpi_allocation *vcpi;	4841	struct drm_dp_vcpi_allocation *vcpi;
4838	int pbn_limit = 0, pbn_used = 0;	4842	struct drm_dp_mst_port *port;
		4843	int pbn_used = 0, ret;
		4844	bool found = false;
4839		4845
4840	list_for_each_entry(port, &branch->ports, next) {	4846	/* Check that we have at least one port in our state that's downstream
4841	if (port->mstb)	4847	* of this branch, otherwise we can skip this branch
4842	if (drm_dp_mst_atomic_check_bw_limit(port->mstb, mst_state))	4848	*/
4843	return -ENOSPC;	4849	list_for_each_entry(vcpi, &state->vcpis, next) {
		4850	if (!vcpi->pbn \|\|
		4851	!drm_dp_mst_port_downstream_of_branch(vcpi->port, mstb))
		4852	continue;
4844		4853
4845	if (port->available_pbn > 0)	4854	found = true;
4846	pbn_limit = port->available_pbn;	4855	break;
4847	}	4856	}
4848	DRM_DEBUG_ATOMIC("[MST BRANCH:%p] branch has %d PBN available\n",	4857	if (!found)
4849	branch, pbn_limit);	4858	return 0;
4850		4859
4851	list_for_each_entry(vcpi, &mst_state->vcpis, next) {	4860	if (mstb->port_parent)
4852	if (!vcpi->pbn)	4861	DRM_DEBUG_ATOMIC("[MSTB:%p] [MST PORT:%p] Checking bandwidth limits on [MSTB:%p]\n",
4853	continue;	4862	mstb->port_parent->parent, mstb->port_parent,
		4863	mstb);
		4864	else
		4865	DRM_DEBUG_ATOMIC("[MSTB:%p] Checking bandwidth limits\n",
		4866	mstb);
		4867
		4868	list_for_each_entry(port, &mstb->ports, next) {
		4869	ret = drm_dp_mst_atomic_check_port_bw_limit(port, state);
		4870	if (ret < 0)
		4871	return ret;
4854		4872
4855	if (drm_dp_mst_port_downstream_of_branch(vcpi->port, branch))	4873	pbn_used += ret;
4856	pbn_used += vcpi->pbn;
4857	}	4874	}
4858	DRM_DEBUG_ATOMIC("[MST BRANCH:%p] branch used %d PBN\n",
4859	branch, pbn_used);
4860		4875
4861	if (pbn_used > pbn_limit) {	4876	return pbn_used;
4862	DRM_DEBUG_ATOMIC("[MST BRANCH:%p] No available bandwidth\n",	4877	}
4863	branch);	4878
		4879	static int
		4880	drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port,
		4881	struct drm_dp_mst_topology_state *state)
		4882	{
		4883	struct drm_dp_vcpi_allocation *vcpi;
		4884	int pbn_used = 0;
		4885
		4886	if (port->pdt == DP_PEER_DEVICE_NONE)
		4887	return 0;
		4888
		4889	if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) {
		4890	bool found = false;
		4891
		4892	list_for_each_entry(vcpi, &state->vcpis, next) {
		4893	if (vcpi->port != port)
		4894	continue;
		4895	if (!vcpi->pbn)
		4896	return 0;
		4897
		4898	found = true;
		4899	break;
		4900	}
		4901	if (!found)
		4902	return 0;
		4903
		4904	/* This should never happen, as it means we tried to
		4905	* set a mode before querying the full_pbn
		4906	*/
		4907	if (WARN_ON(!port->full_pbn))
		4908	return -EINVAL;
		4909
		4910	pbn_used = vcpi->pbn;
		4911	} else {
		4912	pbn_used = drm_dp_mst_atomic_check_mstb_bw_limit(port->mstb,
		4913	state);
		4914	if (pbn_used <= 0)
		4915	return pbn_used;
		4916	}
		4917
		4918	if (pbn_used > port->full_pbn) {
		4919	DRM_DEBUG_ATOMIC("[MSTB:%p] [MST PORT:%p] required PBN of %d exceeds port limit of %d\n",
		4920	port->parent, port, pbn_used,
		4921	port->full_pbn);
4864	return -ENOSPC;	4922	return -ENOSPC;
4865	}	4923	}
4866	return 0;	4924
		4925	DRM_DEBUG_ATOMIC("[MSTB:%p] [MST PORT:%p] uses %d out of %d PBN\n",
		4926	port->parent, port, pbn_used, port->full_pbn);
		4927
		4928	return pbn_used;
4867	}	4929	}
4868		4930
4869	static inline int	4931	static inline int
@@ -5061,9 +5123,15 @@ int drm_dp_mst_atomic_check(struct drm_atomic_state *state) · 191 unmodified lines
5061	ret = drm_dp_mst_atomic_check_vcpi_alloc_limit(mgr, mst_state);	5123	ret = drm_dp_mst_atomic_check_vcpi_alloc_limit(mgr, mst_state);
5062	if (ret)	5124	if (ret)
5063	break;	5125	break;
5064	ret = drm_dp_mst_atomic_check_bw_limit(mgr->mst_primary, mst_state);	5126
5065	if (ret)	5127	mutex_lock(&mgr->lock);
		5128	ret = drm_dp_mst_atomic_check_mstb_bw_limit(mgr->mst_primary,
		5129	mst_state);
		5130	mutex_unlock(&mgr->lock);
		5131	if (ret < 0)
5066	break;	5132	break;
		5133	else
		5134	ret = 0;
5067	}	5135	}
5068		5136
5069	return ret;	5137	return ret;

drivers/gpu/drm/drm_lease.c+2−1

 	}
 	DRM_DEBUG_LEASE("Creating lease\n");
+	/* lessee will take the ownership of leases */
 	lessee = drm_lease_create(lessor, &leases);
 	if (IS_ERR(lessee)) {
 		ret = PTR_ERR(lessee);
+		idr_destroy(&leases);
 		goto out_leases;
 	}
 out_leases:
 	put_unused_fd(fd);
-	idr_destroy(&leases);
 	DRM_DEBUG_LEASE("drm_mode_create_lease_ioctl failed: %d\n", ret);
 	return ret;

drivers/gpu/drm/exynos/exynos5433_drm_decon.c+3−2

 struct decon_context {
 	struct device			*dev;
 	struct drm_device		*drm_dev;
+	void				*dma_priv;
 	struct exynos_drm_crtc		*crtc;
 	struct exynos_drm_plane		planes[WINDOWS_NR];
 	struct exynos_drm_plane_config	configs[WINDOWS_NR];
 	decon_clear_channels(ctx->crtc);
-	return exynos_drm_register_dma(drm_dev, dev);
+	return exynos_drm_register_dma(drm_dev, dev, &ctx->dma_priv);
 }
 static void decon_unbind(struct device *dev, struct device *master, void *data)
 	decon_atomic_disable(ctx->crtc);
 	/* detach this sub driver from iommu mapping if supported. */
-	exynos_drm_unregister_dma(ctx->drm_dev, ctx->dev);
+	exynos_drm_unregister_dma(ctx->drm_dev, ctx->dev, &ctx->dma_priv);
 }
 static const struct component_ops decon_component_ops = {

drivers/gpu/drm/exynos/exynos7_drm_decon.c+3−2

 struct decon_context {
 	struct device			*dev;
 	struct drm_device		*drm_dev;
+	void				*dma_priv;
 	struct exynos_drm_crtc		*crtc;
 	struct exynos_drm_plane		planes[WINDOWS_NR];
 	struct exynos_drm_plane_config	configs[WINDOWS_NR];
 	decon_clear_channels(ctx->crtc);
-	return exynos_drm_register_dma(drm_dev, ctx->dev);
+	return exynos_drm_register_dma(drm_dev, ctx->dev, &ctx->dma_priv);
 }
 static void decon_ctx_remove(struct decon_context *ctx)
 {
 	/* detach this sub driver from iommu mapping if supported. */
-	exynos_drm_unregister_dma(ctx->drm_dev, ctx->dev);
+	exynos_drm_unregister_dma(ctx->drm_dev, ctx->dev, &ctx->dma_priv);
 }
 static u32 decon_calc_clkdiv(struct decon_context *ctx,

drivers/gpu/drm/exynos/exynos_drm_dma.c+19−9

  * mapping.
  */
 static int drm_iommu_attach_device(struct drm_device *drm_dev,
-				struct device *subdrv_dev)
+				struct device *subdrv_dev, void **dma_priv)
 {
 	struct exynos_drm_private *priv = drm_dev->dev_private;
 	int ret;
 		return ret;
 	if (IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU)) {
-		if (to_dma_iommu_mapping(subdrv_dev))
+		/*
+		 * Keep the original DMA mapping of the sub-device and
+		 * restore it on Exynos DRM detach, otherwise the DMA
+		 * framework considers it as IOMMU-less during the next
+		 * probe (in case of deferred probe or modular build)
+		 */
+		*dma_priv = to_dma_iommu_mapping(subdrv_dev);
+		if (*dma_priv)
 			arm_iommu_detach_device(subdrv_dev);
 		ret = arm_iommu_attach_device(subdrv_dev, priv->mapping);
  * mapping
  */
 static void drm_iommu_detach_device(struct drm_device *drm_dev,
-				struct device *subdrv_dev)
+				    struct device *subdrv_dev, void **dma_priv)
 {
 	struct exynos_drm_private *priv = drm_dev->dev_private;
-	if (IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU))
+	if (IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU)) {
 		arm_iommu_detach_device(subdrv_dev);
-	else if (IS_ENABLED(CONFIG_IOMMU_DMA))
+		arm_iommu_attach_device(subdrv_dev, *dma_priv);
+	} else if (IS_ENABLED(CONFIG_IOMMU_DMA))
 		iommu_detach_device(priv->mapping, subdrv_dev);
 	clear_dma_max_seg_size(subdrv_dev);
 }
-int exynos_drm_register_dma(struct drm_device *drm, struct device *dev)
+int exynos_drm_register_dma(struct drm_device *drm, struct device *dev,
+			    void **dma_priv)
 {
 	struct exynos_drm_private *priv = drm->dev_private;
 		priv->mapping = mapping;
 	}
-	return drm_iommu_attach_device(drm, dev);
+	return drm_iommu_attach_device(drm, dev, dma_priv);
 }
-void exynos_drm_unregister_dma(struct drm_device *drm, struct device *dev)
+void exynos_drm_unregister_dma(struct drm_device *drm, struct device *dev,
+			       void **dma_priv)
 {
 	if (IS_ENABLED(CONFIG_EXYNOS_IOMMU))
-		drm_iommu_detach_device(drm, dev);
+		drm_iommu_detach_device(drm, dev, dma_priv);
 }
 void exynos_drm_cleanup_dma(struct drm_device *drm)

drivers/gpu/drm/exynos/exynos_drm_drv.h+4−2

 	return priv->mapping ? true : false;
 }
-int exynos_drm_register_dma(struct drm_device *drm, struct device *dev);
+int exynos_drm_register_dma(struct drm_device *drm, struct device *dev,
-void exynos_drm_unregister_dma(struct drm_device *drm, struct device *dev);
+			    void **dma_priv);
+void exynos_drm_unregister_dma(struct drm_device *drm, struct device *dev,
+			       void **dma_priv);
 void exynos_drm_cleanup_dma(struct drm_device *drm);
 #ifdef CONFIG_DRM_EXYNOS_DPI

drivers/gpu/drm/exynos/exynos_drm_fimc.c+3−2

 struct fimc_context {
 	struct exynos_drm_ipp ipp;
 	struct drm_device *drm_dev;
+	void		*dma_priv;
 	struct device	*dev;
 	struct exynos_drm_ipp_task	*task;
 	struct exynos_drm_ipp_formats	*formats;
 	ctx->drm_dev = drm_dev;
 	ipp->drm_dev = drm_dev;
-	exynos_drm_register_dma(drm_dev, dev);
+	exynos_drm_register_dma(drm_dev, dev, &ctx->dma_priv);
 	exynos_drm_ipp_register(dev, ipp, &ipp_funcs,
 			DRM_EXYNOS_IPP_CAP_CROP | DRM_EXYNOS_IPP_CAP_ROTATE |
 	struct exynos_drm_ipp *ipp = &ctx->ipp;
 	exynos_drm_ipp_unregister(dev, ipp);
-	exynos_drm_unregister_dma(drm_dev, dev);
+	exynos_drm_unregister_dma(drm_dev, dev, &ctx->dma_priv);
 }
 static const struct component_ops fimc_component_ops = {

drivers/gpu/drm/exynos/exynos_drm_fimd.c+3−2

 struct fimd_context {
 	struct device			*dev;
 	struct drm_device		*drm_dev;
+	void				*dma_priv;
 	struct exynos_drm_crtc		*crtc;
 	struct exynos_drm_plane		planes[WINDOWS_NR];
 	struct exynos_drm_plane_config	configs[WINDOWS_NR];
 	if (is_drm_iommu_supported(drm_dev))
 		fimd_clear_channels(ctx->crtc);
-	return exynos_drm_register_dma(drm_dev, dev);
+	return exynos_drm_register_dma(drm_dev, dev, &ctx->dma_priv);
 }
 static void fimd_unbind(struct device *dev, struct device *master,
 	fimd_atomic_disable(ctx->crtc);
-	exynos_drm_unregister_dma(ctx->drm_dev, ctx->dev);
+	exynos_drm_unregister_dma(ctx->drm_dev, ctx->dev, &ctx->dma_priv);
 	if (ctx->encoder)
 		exynos_dpi_remove(ctx->encoder);

drivers/gpu/drm/exynos/exynos_drm_g2d.c+3−2

 struct g2d_data {
 	struct device			*dev;
+	void				*dma_priv;
 	struct clk			*gate_clk;
 	void __iomem			*regs;
 	int				irq;
 		return ret;
 	}
-	ret = exynos_drm_register_dma(drm_dev, dev);
+	ret = exynos_drm_register_dma(drm_dev, dev, &g2d->dma_priv);
 	if (ret < 0) {
 		dev_err(dev, "failed to enable iommu.\n");
 		g2d_fini_cmdlist(g2d);
 	priv->g2d_dev = NULL;
 	cancel_work_sync(&g2d->runqueue_work);
-	exynos_drm_unregister_dma(g2d->drm_dev, dev);
+	exynos_drm_unregister_dma(g2d->drm_dev, dev, &g2d->dma_priv);
 }
 static const struct component_ops g2d_component_ops = {

drivers/gpu/drm/exynos/exynos_drm_gsc.c+3−2

 struct gsc_context {
 	struct exynos_drm_ipp ipp;
 	struct drm_device *drm_dev;
+	void		*dma_priv;
 	struct device	*dev;
 	struct exynos_drm_ipp_task	*task;
 	struct exynos_drm_ipp_formats	*formats;
 	ctx->drm_dev = drm_dev;
 	ctx->drm_dev = drm_dev;
-	exynos_drm_register_dma(drm_dev, dev);
+	exynos_drm_register_dma(drm_dev, dev, &ctx->dma_priv);
 	exynos_drm_ipp_register(dev, ipp, &ipp_funcs,
 			DRM_EXYNOS_IPP_CAP_CROP | DRM_EXYNOS_IPP_CAP_ROTATE |
 	struct exynos_drm_ipp *ipp = &ctx->ipp;
 	exynos_drm_ipp_unregister(dev, ipp);
-	exynos_drm_unregister_dma(drm_dev, dev);
+	exynos_drm_unregister_dma(drm_dev, dev, &ctx->dma_priv);
 }
 static const struct component_ops gsc_component_ops = {

drivers/gpu/drm/exynos/exynos_drm_rotator.c+3−2

 struct rot_context {
 	struct exynos_drm_ipp ipp;
 	struct drm_device *drm_dev;
+	void		*dma_priv;
 	struct device	*dev;
 	void __iomem	*regs;
 	struct clk	*clock;
 	rot->drm_dev = drm_dev;
 	ipp->drm_dev = drm_dev;
-	exynos_drm_register_dma(drm_dev, dev);
+	exynos_drm_register_dma(drm_dev, dev, &rot->dma_priv);
 	exynos_drm_ipp_register(dev, ipp, &ipp_funcs,
 			   DRM_EXYNOS_IPP_CAP_CROP | DRM_EXYNOS_IPP_CAP_ROTATE,
 	struct exynos_drm_ipp *ipp = &rot->ipp;
 	exynos_drm_ipp_unregister(dev, ipp);
-	exynos_drm_unregister_dma(rot->drm_dev, rot->dev);
+	exynos_drm_unregister_dma(rot->drm_dev, rot->dev, &rot->dma_priv);
 }
 static const struct component_ops rotator_component_ops = {

drivers/gpu/drm/exynos/exynos_drm_scaler.c+4−2

 struct scaler_context {
 	struct exynos_drm_ipp		ipp;
 	struct drm_device		*drm_dev;
+	void				*dma_priv;
 	struct device			*dev;
 	void __iomem			*regs;
 	struct clk			*clock[SCALER_MAX_CLK];
 	scaler->drm_dev = drm_dev;
 	ipp->drm_dev = drm_dev;
-	exynos_drm_register_dma(drm_dev, dev);
+	exynos_drm_register_dma(drm_dev, dev, &scaler->dma_priv);
 	exynos_drm_ipp_register(dev, ipp, &ipp_funcs,
 			DRM_EXYNOS_IPP_CAP_CROP | DRM_EXYNOS_IPP_CAP_ROTATE |
 	struct exynos_drm_ipp *ipp = &scaler->ipp;
 	exynos_drm_ipp_unregister(dev, ipp);
-	exynos_drm_unregister_dma(scaler->drm_dev, scaler->dev);
+	exynos_drm_unregister_dma(scaler->drm_dev, scaler->dev,
+				  &scaler->dma_priv);
 }
 static const struct component_ops scaler_component_ops = {

drivers/gpu/drm/exynos/exynos_mixer.c+5−2

 	struct platform_device *pdev;
 	struct device		*dev;
 	struct drm_device	*drm_dev;
+	void			*dma_priv;
 	struct exynos_drm_crtc	*crtc;
 	struct exynos_drm_plane	planes[MIXER_WIN_NR];
 	unsigned long		flags;
 		}
 	}
-	return exynos_drm_register_dma(drm_dev, mixer_ctx->dev);
+	return exynos_drm_register_dma(drm_dev, mixer_ctx->dev,
+				       &mixer_ctx->dma_priv);
 }
 static void mixer_ctx_remove(struct mixer_context *mixer_ctx)
 {
-	exynos_drm_unregister_dma(mixer_ctx->drm_dev, mixer_ctx->dev);
+	exynos_drm_unregister_dma(mixer_ctx->drm_dev, mixer_ctx->dev,
+				  &mixer_ctx->dma_priv);
 }
 static int mixer_enable_vblank(struct exynos_drm_crtc *crtc)

drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c+2−1

@@ -423,7 +423,8 @@ eb_validate_vma(struct i915_execbuffer *eb, · 422 unmodified lines
423	if (unlikely(entry->flags & eb->invalid_flags))	423	if (unlikely(entry->flags & eb->invalid_flags))
424	return -EINVAL;	424	return -EINVAL;
425		425
426	if (unlikely(entry->alignment && !is_power_of_2(entry->alignment)))	426	if (unlikely(entry->alignment &&
		427	!is_power_of_2_u64(entry->alignment)))
427	return -EINVAL;	428	return -EINVAL;
428		429
429	/*	430	/*

drivers/gpu/drm/i915/gt/intel_lrc.c+30−51

@@ -1600,17 +1600,6 @@ static void virtual_xfer_breadcrumbs(struct virtual_engine *ve, · 1599 unmodified lines
1600	spin_unlock(&old->breadcrumbs.irq_lock);	1600	spin_unlock(&old->breadcrumbs.irq_lock);
1601	}	1601	}
1602		1602
1603	static struct i915_request *
1604	last_active(const struct intel_engine_execlists *execlists)
1605	{
1606	struct i915_request * const *last = READ_ONCE(execlists->active);
1607
1608	while (last && i915_request_completed(last))
1609	last++;
1610
1611	return *last;
1612	}
1613
1614	#define for_each_waiter(p__, rq__) \	1603	#define for_each_waiter(p__, rq__) \
1615	list_for_each_entry_lockless(p__, \	1604	list_for_each_entry_lockless(p__, \
1616	&(rq__)->sched.waiters_list, \	1605	&(rq__)->sched.waiters_list, \
@@ -1679,11 +1668,9 @@ need_timeslice(struct intel_engine_cs engine, const struct i915_request rq) · 62 unmodified lines
1679	if (!intel_engine_has_timeslices(engine))	1668	if (!intel_engine_has_timeslices(engine))
1680	return false;	1669	return false;
1681		1670
1682	if (list_is_last(&rq->sched.link, &engine->active.requests))	1671	hint = engine->execlists.queue_priority_hint;
1683	return false;	1672	if (!list_is_last(&rq->sched.link, &engine->active.requests))
1684		1673	hint = max(hint, rq_prio(list_next_entry(rq, sched.link)));
1685	hint = max(rq_prio(list_next_entry(rq, sched.link)),
1686	engine->execlists.queue_priority_hint);
1687		1674
1688	return hint >= effective_prio(rq);	1675	return hint >= effective_prio(rq);
1689	}	1676	}
@@ -1725,16 +1712,26 @@ static void set_timeslice(struct intel_engine_cs *engine) · 35 unmodified lines
1725	set_timer_ms(&engine->execlists.timer, active_timeslice(engine));	1712	set_timer_ms(&engine->execlists.timer, active_timeslice(engine));
1726	}	1713	}
1727		1714
		1715	static void start_timeslice(struct intel_engine_cs *engine)
		1716	{
		1717	struct intel_engine_execlists *execlists = &engine->execlists;
		1718
		1719	execlists->switch_priority_hint = execlists->queue_priority_hint;
		1720
		1721	if (timer_pending(&execlists->timer))
		1722	return;
		1723
		1724	set_timer_ms(&execlists->timer, timeslice(engine));
		1725	}
		1726
1728	static void record_preemption(struct intel_engine_execlists *execlists)	1727	static void record_preemption(struct intel_engine_execlists *execlists)
1729	{	1728	{
1730	(void)I915_SELFTEST_ONLY(execlists->preempt_hang.count++);	1729	(void)I915_SELFTEST_ONLY(execlists->preempt_hang.count++);
1731	}	1730	}
1732		1731
1733	static unsigned long active_preempt_timeout(struct intel_engine_cs *engine)	1732	static unsigned long active_preempt_timeout(struct intel_engine_cs *engine,
		1733	const struct i915_request *rq)
1734	{	1734	{
1735	struct i915_request *rq;
1736
1737	rq = last_active(&engine->execlists);
1738	if (!rq)	1735	if (!rq)
1739	return 0;	1736	return 0;
1740		1737
@@ -1745,13 +1742,14 @@ static unsigned long active_preempt_timeout(struct intel_engine_cs *engine) · 4 unmodified lines
1745	return READ_ONCE(engine->props.preempt_timeout_ms);	1742	return READ_ONCE(engine->props.preempt_timeout_ms);
1746	}	1743	}
1747		1744
1748	static void set_preempt_timeout(struct intel_engine_cs *engine)	1745	static void set_preempt_timeout(struct intel_engine_cs *engine,
		1746	const struct i915_request *rq)
1749	{	1747	{
1750	if (!intel_engine_has_preempt_reset(engine))	1748	if (!intel_engine_has_preempt_reset(engine))
1751	return;	1749	return;
1752		1750
1753	set_timer_ms(&engine->execlists.preempt,	1751	set_timer_ms(&engine->execlists.preempt,
1754	active_preempt_timeout(engine));	1752	active_preempt_timeout(engine, rq));
1755	}	1753	}
1756		1754
1757	static inline void clear_ports(struct i915_request **ports, int count)	1755	static inline void clear_ports(struct i915_request **ports, int count)
@@ -1764,6 +1762,7 @@ static void execlists_dequeue(struct intel_engine_cs *engine) · 6 unmodified lines
1764	struct intel_engine_execlists * const execlists = &engine->execlists;	1762	struct intel_engine_execlists * const execlists = &engine->execlists;
1765	struct i915_request **port = execlists->pending;	1763	struct i915_request **port = execlists->pending;
1766	struct i915_request ** const last_port = port + execlists->port_mask;	1764	struct i915_request ** const last_port = port + execlists->port_mask;
		1765	struct i915_request * const *active;
1767	struct i915_request *last;	1766	struct i915_request *last;
1768	struct rb_node *rb;	1767	struct rb_node *rb;
1769	bool submit = false;	1768	bool submit = false;
@@ -1818,7 +1817,10 @@ static void execlists_dequeue(struct intel_engine_cs *engine) · 48 unmodified lines
1818	* i.e. we will retrigger preemption following the ack in case	1817	* i.e. we will retrigger preemption following the ack in case
1819	* of trouble.	1818	* of trouble.
1820	*/	1819	*/
1821	last = last_active(execlists);	1820	active = READ_ONCE(execlists->active);
		1821	while ((last = *active) && i915_request_completed(last))
		1822	active++;
		1823
1822	if (last) {	1824	if (last) {
1823	if (need_preempt(engine, last, rb)) {	1825	if (need_preempt(engine, last, rb)) {
1824	ENGINE_TRACE(engine,	1826	ENGINE_TRACE(engine,
@@ -1888,11 +1890,7 @@ static void execlists_dequeue(struct intel_engine_cs *engine) · 63 unmodified lines
1888	* Even if ELSP[1] is occupied and not worthy	1890	* Even if ELSP[1] is occupied and not worthy
1889	* of timeslices, our queue might be.	1891	* of timeslices, our queue might be.
1890	*/	1892	*/
1891	if (!execlists->timer.expires &&	1893	start_timeslice(engine);
1892	need_timeslice(engine, last))
1893	set_timer_ms(&execlists->timer,
1894	timeslice(engine));
1895
1896	return;	1894	return;
1897	}	1895	}
1898	}	1896	}
@@ -1927,7 +1925,8 @@ static void execlists_dequeue(struct intel_engine_cs *engine) · 28 unmodified lines
1927		1925
1928	if (last && !can_merge_rq(last, rq)) {	1926	if (last && !can_merge_rq(last, rq)) {
1929	spin_unlock(&ve->base.active.lock);	1927	spin_unlock(&ve->base.active.lock);
1930	return; /* leave this for another */	1928	start_timeslice(engine);
		1929	return; /* leave this for another sibling */
1931	}	1930	}
1932		1931
1933	ENGINE_TRACE(engine,	1932	ENGINE_TRACE(engine,
@@ -2103,7 +2102,7 @@ done: · 169 unmodified lines
2103	* Skip if we ended up with exactly the same set of requests,	2102	* Skip if we ended up with exactly the same set of requests,
2104	* e.g. trying to timeslice a pair of ordered contexts	2103	* e.g. trying to timeslice a pair of ordered contexts
2105	*/	2104	*/
2106	if (!memcmp(execlists->active, execlists->pending,	2105	if (!memcmp(active, execlists->pending,
2107	(port - execlists->pending + 1) * sizeof(*port))) {	2106	(port - execlists->pending + 1) * sizeof(*port))) {
2108	do	2107	do
2109	execlists_schedule_out(fetch_and_zero(port));	2108	execlists_schedule_out(fetch_and_zero(port));
@@ -2114,7 +2113,7 @@ done: · 4 unmodified lines
2114	clear_ports(port + 1, last_port - port);	2113	clear_ports(port + 1, last_port - port);
2115		2114
2116	execlists_submit_ports(engine);	2115	execlists_submit_ports(engine);
2117	set_preempt_timeout(engine);	2116	set_preempt_timeout(engine, *active);
2118	} else {	2117	} else {
2119	skip_submit:	2118	skip_submit:
2120	ring_set_paused(engine, 0);	2119	ring_set_paused(engine, 0);
@@ -4001,26 +4000,6 @@ static int gen12_emit_flush_render(struct i915_request *request, · 1880 unmodified lines
4001		4000
4002	*cs++ = preparser_disable(false);	4001	*cs++ = preparser_disable(false);
4003	intel_ring_advance(request, cs);	4002	intel_ring_advance(request, cs);
4004
4005	/*
4006	* Wa_1604544889:tgl
4007	*/
4008	if (IS_TGL_REVID(request->i915, TGL_REVID_A0, TGL_REVID_A0)) {
4009	flags = 0;
4010	flags \|= PIPE_CONTROL_CS_STALL;
4011	flags \|= PIPE_CONTROL_HDC_PIPELINE_FLUSH;
4012
4013	flags \|= PIPE_CONTROL_STORE_DATA_INDEX;
4014	flags \|= PIPE_CONTROL_QW_WRITE;
4015
4016	cs = intel_ring_begin(request, 6);
4017	if (IS_ERR(cs))
4018	return PTR_ERR(cs);
4019
4020	cs = gen8_emit_pipe_control(cs, flags,
4021	LRC_PPHWSP_SCRATCH_ADDR);
4022	intel_ring_advance(request, cs);
4023	}
4024	}	4003	}
4025		4004
4026	return 0;	4005	return 0;

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

 static void cacheline_free(struct intel_timeline_cacheline *cl)
 {
+	if (!i915_active_acquire_if_busy(&cl->active)) {
+		__idle_cacheline_free(cl);
+		return;
+	}
 	GEM_BUG_ON(ptr_test_bit(cl->vaddr, CACHELINE_FREE));
 	cl->vaddr = ptr_set_bit(cl->vaddr, CACHELINE_FREE);
-	if (i915_active_is_idle(&cl->active))
+	i915_active_release(&cl->active);
-		__idle_cacheline_free(cl);
 }
 int intel_timeline_init(struct intel_timeline *timeline,

drivers/gpu/drm/i915/gt/intel_workarounds.c+22−3

@@ -1529,15 +1529,34 @@ err_obj: · 1528 unmodified lines
1529	return ERR_PTR(err);	1529	return ERR_PTR(err);
1530	}	1530	}
1531		1531
		1532	static const struct {
		1533	u32 start;
		1534	u32 end;
		1535	} mcr_ranges_gen8[] = {
		1536	{ .start = 0x5500, .end = 0x55ff },
		1537	{ .start = 0x7000, .end = 0x7fff },
		1538	{ .start = 0x9400, .end = 0x97ff },
		1539	{ .start = 0xb000, .end = 0xb3ff },
		1540	{ .start = 0xe000, .end = 0xe7ff },
		1541	{},
		1542	};
		1543
1532	static bool mcr_range(struct drm_i915_private *i915, u32 offset)	1544	static bool mcr_range(struct drm_i915_private *i915, u32 offset)
1533	{	1545	{
		1546	int i;
		1547
		1548	if (INTEL_GEN(i915) < 8)
		1549	return false;
		1550
1534	/*	1551	/*
1535	* Registers in this range are affected by the MCR selector	1552	* Registers in these ranges are affected by the MCR selector
1536	* which only controls CPU initiated MMIO. Routing does not	1553	* which only controls CPU initiated MMIO. Routing does not
1537	* work for CS access so we cannot verify them on this path.	1554	* work for CS access so we cannot verify them on this path.
1538	*/	1555	*/
1539	if (INTEL_GEN(i915) >= 8 && (offset >= 0xb000 && offset <= 0xb4ff))	1556	for (i = 0; mcr_ranges_gen8[i].start; i++)
1540	return true;	1557	if (offset >= mcr_ranges_gen8[i].start &&
		1558	offset <= mcr_ranges_gen8[i].end)
		1559	return true;
1541		1560
1542	return false;	1561	return false;
1543	}	1562	}

drivers/gpu/drm/i915/gvt/display.c+2−1

@@ -457,7 +457,8 @@ void intel_vgpu_emulate_hotplug(struct intel_vgpu *vgpu, bool connected) · 456 unmodified lines
457	struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;	457	struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
458		458
459	/* TODO: add more platforms support */	459	/* TODO: add more platforms support */
460	if (IS_SKYLAKE(dev_priv) \|\| IS_KABYLAKE(dev_priv)) {	460	if (IS_SKYLAKE(dev_priv) \|\| IS_KABYLAKE(dev_priv) \|\|
		461	IS_COFFEELAKE(dev_priv)) {
461	if (connected) {	462	if (connected) {
462	vgpu_vreg_t(vgpu, SFUSE_STRAP) \|=	463	vgpu_vreg_t(vgpu, SFUSE_STRAP) \|=
463	SFUSE_STRAP_DDID_DETECTED;	464	SFUSE_STRAP_DDID_DETECTED;

drivers/gpu/drm/i915/gvt/opregion.c+2−3

 	/* there's features depending on version! */
 	v->header.version = 155;
 	v->header.header_size = sizeof(v->header);
-	v->header.vbt_size = sizeof(struct vbt) - sizeof(v->header);
+	v->header.vbt_size = sizeof(struct vbt);
 	v->header.bdb_offset = offsetof(struct vbt, bdb_header);
 	strcpy(&v->bdb_header.signature[0], "BIOS_DATA_BLOCK");
 	v->bdb_header.version = 186; /* child_dev_size = 33 */
 	v->bdb_header.header_size = sizeof(v->bdb_header);
-	v->bdb_header.bdb_size = sizeof(struct vbt) - sizeof(struct vbt_header)
+	v->bdb_header.bdb_size = sizeof(struct vbt) - sizeof(struct vbt_header);
-		- sizeof(struct bdb_header);
 	/* general features */
 	v->general_features_header.id = BDB_GENERAL_FEATURES;

drivers/gpu/drm/i915/gvt/vgpu.c+9−3

 {
 	struct intel_gvt *gvt = vgpu->gvt;
-	mutex_lock(&vgpu->vgpu_lock);
 	WARN(vgpu->active, "vGPU is still active!\n");
+	/*
+	 * remove idr first so later clean can judge if need to stop
+	 * service if no active vgpu.
+	 */
+	mutex_lock(&gvt->lock);
+	idr_remove(&gvt->vgpu_idr, vgpu->id);
+	mutex_unlock(&gvt->lock);
+	mutex_lock(&vgpu->vgpu_lock);
 	intel_gvt_debugfs_remove_vgpu(vgpu);
 	intel_vgpu_clean_sched_policy(vgpu);
 	intel_vgpu_clean_submission(vgpu);
 	mutex_unlock(&vgpu->vgpu_lock);
 	mutex_lock(&gvt->lock);
-	idr_remove(&gvt->vgpu_idr, vgpu->id);
 	if (idr_is_empty(&gvt->vgpu_idr))
 		intel_gvt_clean_irq(gvt);
 	intel_gvt_update_vgpu_types(gvt);

drivers/gpu/drm/i915/i915_request.c+20−8

 	return NOTIFY_DONE;
 }
+static void irq_semaphore_cb(struct irq_work *wrk)
+{
+	struct i915_request *rq =
+		container_of(wrk, typeof(*rq), semaphore_work);
+	i915_schedule_bump_priority(rq, I915_PRIORITY_NOSEMAPHORE);
+	i915_request_put(rq);
+}
 static int __i915_sw_fence_call
 semaphore_notify(struct i915_sw_fence *fence, enum i915_sw_fence_notify state)
 {
-	struct i915_request *request =
+	struct i915_request *rq = container_of(fence, typeof(*rq), semaphore);
-		container_of(fence, typeof(*request), semaphore);
 	switch (state) {
 	case FENCE_COMPLETE:
-		i915_schedule_bump_priority(request, I915_PRIORITY_NOSEMAPHORE);
+		if (!(READ_ONCE(rq->sched.attr.priority) & I915_PRIORITY_NOSEMAPHORE)) {
+			i915_request_get(rq);
+			init_irq_work(&rq->semaphore_work, irq_semaphore_cb);
+			irq_work_queue(&rq->semaphore_work);
+		}
 		break;
 	case FENCE_FREE:
-		i915_request_put(request);
+		i915_request_put(rq);
 		break;
 	}
 	struct dma_fence *fence;
 	int err;
-	GEM_BUG_ON(i915_request_timeline(rq) ==
+	if (i915_request_timeline(rq) == rcu_access_pointer(signal->timeline))
-		   rcu_access_pointer(signal->timeline));
+		return 0;
 	if (i915_request_started(signal))
 		return 0;
 		return 0;
 	err = 0;
-	if (intel_timeline_sync_is_later(i915_request_timeline(rq), fence))
+	if (!intel_timeline_sync_is_later(i915_request_timeline(rq), fence))
 		err = i915_sw_fence_await_dma_fence(&rq->submit,
 						    fence, 0,
 						    I915_FENCE_GFP);
 	 * decide whether to preempt the entire chain so that it is ready to
 	 * run at the earliest possible convenience.
 	 */
-	i915_sw_fence_commit(&rq->semaphore);
 	if (attr && rq->engine->schedule)
 		rq->engine->schedule(rq, attr);
+	i915_sw_fence_commit(&rq->semaphore);
 	i915_sw_fence_commit(&rq->submit);
 }

drivers/gpu/drm/i915/i915_request.h+2−0

 #define I915_REQUEST_H
 #include <linux/dma-fence.h>
+#include <linux/irq_work.h>
 #include <linux/lockdep.h>
 #include "gem/i915_gem_context_types.h"
 	};
 	struct list_head execute_cb;
 	struct i915_sw_fence semaphore;
+	struct irq_work semaphore_work;
 	/*
 	 * A list of everyone we wait upon, and everyone who waits upon us.

drivers/gpu/drm/i915/i915_utils.h+5−0

 	__idx;								\
 })
+static inline bool is_power_of_2_u64(u64 n)
+{
+	return (n != 0 && ((n & (n - 1)) == 0));
+}
 static inline void __list_del_many(struct list_head *head,
 				   struct list_head *first)
 {

drivers/hid/hid-google-hammer.c+2−0

 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) },
+	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
+		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,

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

 #define USB_DEVICE_ID_GOOGLE_WHISKERS	0x5030
 #define USB_DEVICE_ID_GOOGLE_MASTERBALL	0x503c
 #define USB_DEVICE_ID_GOOGLE_MAGNEMITE	0x503d
+#define USB_DEVICE_ID_GOOGLE_MOONBALL	0x5044
 #define USB_VENDOR_ID_GOTOP		0x08f2
 #define USB_DEVICE_ID_SUPER_Q2		0x007f
 #define USB_DEVICE_ID_LENOVO_X1_COVER	0x6085
 #define USB_DEVICE_ID_LENOVO_X1_TAB	0x60a3
 #define USB_DEVICE_ID_LENOVO_X1_TAB3	0x60b5
+#define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D	0x608d
 #define USB_VENDOR_ID_LG		0x1fd2
 #define USB_DEVICE_ID_LG_MULTITOUCH	0x0064

drivers/hid/hid-picolcd_fb.c+2−2

@@ -458,9 +458,9 @@ static ssize_t picolcd_fb_update_rate_show(struct device *dev, · 457 unmodified lines
458	if (ret >= PAGE_SIZE)	458	if (ret >= PAGE_SIZE)
459	break;	459	break;
460	else if (i == fb_update_rate)	460	else if (i == fb_update_rate)
461	ret += snprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);	461	ret += scnprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);
462	else	462	else
463	ret += snprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);	463	ret += scnprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);
464	if (ret > 0)	464	if (ret > 0)
465	buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';	465	buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';
466	return ret;	466	return ret;

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

@@ -103,6 +103,7 @@ static const struct hid_device_id hid_quirks[] = { · 102 unmodified lines
103	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912), HID_QUIRK_MULTI_INPUT },	103	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912), HID_QUIRK_MULTI_INPUT },
104	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M406XE), HID_QUIRK_MULTI_INPUT },	104	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M406XE), HID_QUIRK_MULTI_INPUT },
105	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2), HID_QUIRK_ALWAYS_POLL },	105	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2), HID_QUIRK_ALWAYS_POLL },
		106	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D), HID_QUIRK_ALWAYS_POLL },
106	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C007), HID_QUIRK_ALWAYS_POLL },	107	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C007), HID_QUIRK_ALWAYS_POLL },
107	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C077), HID_QUIRK_ALWAYS_POLL },	108	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C077), HID_QUIRK_ALWAYS_POLL },
108	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KEYBOARD_G710_PLUS), HID_QUIRK_NOGET },	109	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KEYBOARD_G710_PLUS), HID_QUIRK_NOGET },

drivers/hid/hid-sensor-custom.c+3−3

@@ -313,7 +313,7 @@ static ssize_t show_value(struct device dev, struct device_attribute attr, · 312 unmodified lines
313		313
314	while (i < ret) {	314	while (i < ret) {
315	if (i + attribute->size > ret) {	315	if (i + attribute->size > ret) {
316	len += snprintf(&buf[len],	316	len += scnprintf(&buf[len],
317	PAGE_SIZE - len,	317	PAGE_SIZE - len,
318	"%d ", values[i]);	318	"%d ", values[i]);
319	break;	319	break;
@@ -336,10 +336,10 @@ static ssize_t show_value(struct device dev, struct device_attribute attr, · 16 unmodified lines
336	++i;	336	++i;
337	break;	337	break;
338	}	338	}
339	len += snprintf(&buf[len], PAGE_SIZE - len,	339	len += scnprintf(&buf[len], PAGE_SIZE - len,
340	"%lld ", value);	340	"%lld ", value);
341	}	341	}
342	len += snprintf(&buf[len], PAGE_SIZE - len, "\n");	342	len += scnprintf(&buf[len], PAGE_SIZE - len, "\n");
343		343
344	return len;	344	return len;
345	} else if (input)	345	} else if (input)

drivers/hwtracing/intel_th/msu.c+7−6

 	if (old != expect) {
 		ret = -EINVAL;
-		dev_warn_ratelimited(msc_dev(win->msc),
-				     "expected lockout state %d, got %d\n",
-				     expect, old);
 		goto unlock;
 	}
 		/* from intel_th_msc_window_unlock(), don't warn if not locked */
 		if (expect == WIN_LOCKED && old == new)
 			return 0;
+		dev_warn_ratelimited(msc_dev(win->msc),
+				     "expected lockout state %d, got %d\n",
+				     expect, old);
 	}
 	return ret;
 	lockdep_assert_held(&msc->buf_mutex);
 	if (msc->mode > MSC_MODE_MULTI)
-		return -ENOTSUPP;
+		return -EINVAL;
 	if (msc->mode == MSC_MODE_MULTI) {
 		if (msc_win_set_lockout(msc->cur_win, WIN_READY, WIN_INUSE))
 	} else if (msc->mode == MSC_MODE_MULTI) {
 		ret = msc_buffer_multi_alloc(msc, nr_pages, nr_wins);
 	} else {
-		ret = -ENOTSUPP;
+		ret = -EINVAL;
 	}
 	if (!ret) {
 		if (ret >= 0)
 			*ppos = iter->offset;
 	} else {
-		ret = -ENOTSUPP;
+		ret = -EINVAL;
 	}
 put_count:

drivers/hwtracing/intel_th/pci.c+5−0

 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4da6),
 		.driver_data = (kernel_ulong_t)&intel_th_2x,
 	},
+	{
+		/* Elkhart Lake CPU */
+		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4529),
+		.driver_data = (kernel_ulong_t)&intel_th_2x,
+	},
 	{
 		/* Elkhart Lake */
 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4b26),

drivers/hwtracing/stm/p_sys-t.c+3−3

@@ -238,7 +238,7 @@ static struct configfs_attribute *sys_t_policy_attrs[] = { · 237 unmodified lines
238	static inline bool sys_t_need_ts(struct sys_t_output *op)	238	static inline bool sys_t_need_ts(struct sys_t_output *op)
239	{	239	{
240	if (op->node.ts_interval &&	240	if (op->node.ts_interval &&
241	time_after(op->ts_jiffies + op->node.ts_interval, jiffies)) {	241	time_after(jiffies, op->ts_jiffies + op->node.ts_interval)) {
242	op->ts_jiffies = jiffies;	242	op->ts_jiffies = jiffies;
243		243
244	return true;	244	return true;
@@ -250,8 +250,8 @@ static inline bool sys_t_need_ts(struct sys_t_output *op) · 5 unmodified lines
250	static bool sys_t_need_clock_sync(struct sys_t_output *op)	250	static bool sys_t_need_clock_sync(struct sys_t_output *op)
251	{	251	{
252	if (op->node.clocksync_interval &&	252	if (op->node.clocksync_interval &&
253	time_after(op->clocksync_jiffies + op->node.clocksync_interval,	253	time_after(jiffies,
254	jiffies)) {	254	op->clocksync_jiffies + op->node.clocksync_interval)) {
255	op->clocksync_jiffies = jiffies;	255	op->clocksync_jiffies = jiffies;
256		256
257	return true;	257	return true;

drivers/i2c/busses/i2c-designware-pcidrv.c+1−0

@@ -313,6 +313,7 @@ static void i2c_dw_pci_remove(struct pci_dev *pdev) · 312 unmodified lines
313	pm_runtime_get_noresume(&pdev->dev);	313	pm_runtime_get_noresume(&pdev->dev);
314		314
315	i2c_del_adapter(&dev->adapter);	315	i2c_del_adapter(&dev->adapter);
		316	devm_free_irq(&pdev->dev, dev->irq, dev);
316	pci_free_irq_vectors(pdev);	317	pci_free_irq_vectors(pdev);
317	}	318	}
318		319

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

@@ -348,7 +348,7 @@ static struct gpio_desc i2c_gpio_get_desc(struct device dev, · 347 unmodified lines
348	if (ret == -ENOENT)	348	if (ret == -ENOENT)
349	retdesc = ERR_PTR(-EPROBE_DEFER);	349	retdesc = ERR_PTR(-EPROBE_DEFER);
350		350
351	if (ret != -EPROBE_DEFER)	351	if (PTR_ERR(retdesc) != -EPROBE_DEFER)
352	dev_err(dev, "error trying to get descriptor: %d\n", ret);	352	dev_err(dev, "error trying to get descriptor: %d\n", ret);
353		353
354	return retdesc;	354	return retdesc;

drivers/i2c/busses/i2c-i801.c+12−33

@@ -132,11 +132,6 @@ · 131 unmodified lines
132	#define TCOBASE 0x050	132	#define TCOBASE 0x050
133	#define TCOCTL 0x054	133	#define TCOCTL 0x054
134		134
135	#define ACPIBASE 0x040
136	#define ACPIBASE_SMI_OFF 0x030
137	#define ACPICTRL 0x044
138	#define ACPICTRL_EN 0x080
139
140	#define SBREG_BAR 0x10	135	#define SBREG_BAR 0x10
141	#define SBREG_SMBCTRL 0xc6000c	136	#define SBREG_SMBCTRL 0xc6000c
142	#define SBREG_SMBCTRL_DNV 0xcf000c	137	#define SBREG_SMBCTRL_DNV 0xcf000c
@@ -1553,7 +1548,7 @@ i801_add_tco_spt(struct i801_priv priv, struct pci_dev pci_dev, · 1410 unmodified lines
1553	pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, hidden);	1548	pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, hidden);
1554	spin_unlock(&p2sb_spinlock);	1549	spin_unlock(&p2sb_spinlock);
1555		1550
1556	res = &tco_res[ICH_RES_MEM_OFF];	1551	res = &tco_res[1];
1557	if (pci_dev->device == PCI_DEVICE_ID_INTEL_DNV_SMBUS)	1552	if (pci_dev->device == PCI_DEVICE_ID_INTEL_DNV_SMBUS)
1558	res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL_DNV;	1553	res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL_DNV;
1559	else	1554	else
@@ -1563,7 +1558,7 @@ i801_add_tco_spt(struct i801_priv priv, struct pci_dev pci_dev, · 3 unmodified lines
1563	res->flags = IORESOURCE_MEM;	1558	res->flags = IORESOURCE_MEM;
1564		1559
1565	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,	1560	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,
1566	tco_res, 3, &spt_tco_platform_data,	1561	tco_res, 2, &spt_tco_platform_data,
1567	sizeof(spt_tco_platform_data));	1562	sizeof(spt_tco_platform_data));
1568	}	1563	}
1569		1564
@@ -1576,17 +1571,16 @@ static struct platform_device * · 6 unmodified lines
1576	i801_add_tco_cnl(struct i801_priv priv, struct pci_dev pci_dev,	1571	i801_add_tco_cnl(struct i801_priv priv, struct pci_dev pci_dev,
1577	struct resource *tco_res)	1572	struct resource *tco_res)
1578	{	1573	{
1579	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,	1574	return platform_device_register_resndata(&pci_dev->dev,
1580	tco_res, 2, &cnl_tco_platform_data,	1575	"iTCO_wdt", -1, tco_res, 1, &cnl_tco_platform_data,
1581	sizeof(cnl_tco_platform_data));	1576	sizeof(cnl_tco_platform_data));
1582	}	1577	}
1583		1578
1584	static void i801_add_tco(struct i801_priv *priv)	1579	static void i801_add_tco(struct i801_priv *priv)
1585	{	1580	{
1586	u32 base_addr, tco_base, tco_ctl, ctrl_val;
1587	struct pci_dev *pci_dev = priv->pci_dev;	1581	struct pci_dev *pci_dev = priv->pci_dev;
1588	struct resource tco_res[3], *res;	1582	struct resource tco_res[2], *res;
1589	unsigned int devfn;	1583	u32 tco_base, tco_ctl;
1590		1584
1591	/* If we have ACPI based watchdog use that instead */	1585	/* If we have ACPI based watchdog use that instead */
1592	if (acpi_has_watchdog())	1586	if (acpi_has_watchdog())
@@ -1601,30 +1595,15 @@ static void i801_add_tco(struct i801_priv *priv) · 8 unmodified lines
1601	return;	1595	return;
1602		1596
1603	memset(tco_res, 0, sizeof(tco_res));	1597	memset(tco_res, 0, sizeof(tco_res));
1604
1605	res = &tco_res[ICH_RES_IO_TCO];
1606	res->start = tco_base & ~1;
1607	res->end = res->start + 32 - 1;
1608	res->flags = IORESOURCE_IO;
1609
1610	/*	1598	/*
1611	* Power Management registers.	1599	* Always populate the main iTCO IO resource here. The second entry
		1600	* for NO_REBOOT MMIO is filled by the SPT specific function.
1612	*/	1601	*/
1613	devfn = PCI_DEVFN(PCI_SLOT(pci_dev->devfn), 2);	1602	res = &tco_res[0];
1614	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPIBASE, &base_addr);	1603	res->start = tco_base & ~1;
1615		1604	res->end = res->start + 32 - 1;
1616	res = &tco_res[ICH_RES_IO_SMI];
1617	res->start = (base_addr & ~1) + ACPIBASE_SMI_OFF;
1618	res->end = res->start + 3;
1619	res->flags = IORESOURCE_IO;	1605	res->flags = IORESOURCE_IO;
1620		1606
1621	/*
1622	* Enable the ACPI I/O space.
1623	*/
1624	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPICTRL, &ctrl_val);
1625	ctrl_val \|= ACPICTRL_EN;
1626	pci_bus_write_config_dword(pci_dev->bus, devfn, ACPICTRL, ctrl_val);
1627
1628	if (priv->features & FEATURE_TCO_CNL)	1607	if (priv->features & FEATURE_TCO_CNL)
1629	priv->tco_pdev = i801_add_tco_cnl(priv, pci_dev, tco_res);	1608	priv->tco_pdev = i801_add_tco_cnl(priv, pci_dev, tco_res);
1630	else	1609	else

drivers/i2c/i2c-core-acpi.c+9−1

 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
 {
 	struct device *dev;
+	struct i2c_client *client;
 	dev = bus_find_device_by_acpi_dev(&i2c_bus_type, adev);
-	return dev ? i2c_verify_client(dev) : NULL;
+	if (!dev)
+		return NULL;
+	client = i2c_verify_client(dev);
+	if (!client)
+		put_device(dev);
+	return client;
 }
 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,

drivers/iio/accel/adxl372.c+1−0

@@ -237,6 +237,7 @@ static const struct adxl372_axis_lookup adxl372_axis_lookup_table[] = { · 236 unmodified lines
237	.realbits = 12, \	237	.realbits = 12, \
238	.storagebits = 16, \	238	.storagebits = 16, \
239	.shift = 4, \	239	.shift = 4, \
		240	.endianness = IIO_BE, \
240	}, \	241	}, \
241	}	242	}
242		243

drivers/iio/accel/st_accel_i2c.c+1−1

@@ -110,7 +110,7 @@ MODULE_DEVICE_TABLE(of, st_accel_of_match); · 109 unmodified lines
110		110
111	#ifdef CONFIG_ACPI	111	#ifdef CONFIG_ACPI
112	static const struct acpi_device_id st_accel_acpi_match[] = {	112	static const struct acpi_device_id st_accel_acpi_match[] = {
113	{"SMO8840", (kernel_ulong_t)LNG2DM_ACCEL_DEV_NAME},	113	{"SMO8840", (kernel_ulong_t)LIS2DH12_ACCEL_DEV_NAME},
114	{"SMO8A90", (kernel_ulong_t)LNG2DM_ACCEL_DEV_NAME},	114	{"SMO8A90", (kernel_ulong_t)LNG2DM_ACCEL_DEV_NAME},
115	{ },	115	{ },
116	};	116	};

drivers/iio/adc/at91-sama5d2_adc.c+15−0

@@ -723,6 +723,7 @@ static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state) · 722 unmodified lines
723		723
724	for_each_set_bit(bit, indio->active_scan_mask, indio->num_channels) {	724	for_each_set_bit(bit, indio->active_scan_mask, indio->num_channels) {
725	struct iio_chan_spec const *chan = at91_adc_chan_get(indio, bit);	725	struct iio_chan_spec const *chan = at91_adc_chan_get(indio, bit);
		726	u32 cor;
726		727
727	if (!chan)	728	if (!chan)
728	continue;	729	continue;
@@ -731,6 +732,20 @@ static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state) · 2 unmodified lines
731	chan->type == IIO_PRESSURE)	732	chan->type == IIO_PRESSURE)
732	continue;	733	continue;
733		734
		735	if (state) {
		736	cor = at91_adc_readl(st, AT91_SAMA5D2_COR);
		737
		738	if (chan->differential)
		739	cor \|= (BIT(chan->channel) \|
		740	BIT(chan->channel2)) <<
		741	AT91_SAMA5D2_COR_DIFF_OFFSET;
		742	else
		743	cor &= ~(BIT(chan->channel) <<
		744	AT91_SAMA5D2_COR_DIFF_OFFSET);
		745
		746	at91_adc_writel(st, AT91_SAMA5D2_COR, cor);
		747	}
		748
734	if (state) {	749	if (state) {
735	at91_adc_writel(st, AT91_SAMA5D2_CHER,	750	at91_adc_writel(st, AT91_SAMA5D2_CHER,
736	BIT(chan->channel));	751	BIT(chan->channel));

drivers/iio/adc/stm32-dfsdm-adc.c+10−33

 	}
 }
-static irqreturn_t stm32_dfsdm_adc_trigger_handler(int irq, void *p)
-{
-	struct iio_poll_func *pf = p;
-	struct iio_dev *indio_dev = pf->indio_dev;
-	struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
-	int available = stm32_dfsdm_adc_dma_residue(adc);
-	while (available >= indio_dev->scan_bytes) {
-		s32 *buffer = (s32 *)&adc->rx_buf[adc->bufi];
-		stm32_dfsdm_process_data(adc, buffer);
-		iio_push_to_buffers_with_timestamp(indio_dev, buffer,
-						   pf->timestamp);
-		available -= indio_dev->scan_bytes;
-		adc->bufi += indio_dev->scan_bytes;
-		if (adc->bufi >= adc->buf_sz)
-			adc->bufi = 0;
-	}
-	iio_trigger_notify_done(indio_dev->trig);
-	return IRQ_HANDLED;
-}
 static void stm32_dfsdm_dma_buffer_done(void *data)
 {
 	struct iio_dev *indio_dev = data;
 	int available = stm32_dfsdm_adc_dma_residue(adc);
 	size_t old_pos;
-	if (indio_dev->currentmode & INDIO_BUFFER_TRIGGERED) {
-		iio_trigger_poll_chained(indio_dev->trig);
-		return;
-	}
 	/*
 	 * FIXME: In Kernel interface does not support cyclic DMA buffer,and
 	 * offers only an interface to push data samples per samples.
 			adc->bufi = 0;
 			old_pos = 0;
 		}
-		/* regular iio buffer without trigger */
+		/*
+		 * In DMA mode the trigger services of IIO are not used
+		 * (e.g. no call to iio_trigger_poll).
+		 * Calling irq handler associated to the hardware trigger is not
+		 * relevant as the conversions have already been done. Data
+		 * transfers are performed directly in DMA callback instead.
+		 * This implementation avoids to call trigger irq handler that
+		 * may sleep, in an atomic context (DMA irq handler context).
+		 */
 		if (adc->dev_data->type == DFSDM_IIO)
 			iio_push_to_buffers(indio_dev, buffer);
 	}
 	}
 	ret = iio_triggered_buffer_setup(indio_dev,
-					 &iio_pollfunc_store_time,
+					 &iio_pollfunc_store_time, NULL,
-					 &stm32_dfsdm_adc_trigger_handler,
 					 &stm32_dfsdm_buffer_setup_ops);
 	if (ret) {
 		stm32_dfsdm_dma_release(indio_dev);

drivers/iio/chemical/Kconfig+2−0

 	tristate "SPS30 particulate matter sensor"
 	depends on I2C
 	select CRC8
+	select IIO_BUFFER
+	select IIO_TRIGGERED_BUFFER
 	help
 	  Say Y here to build support for the Sensirion SPS30 particulate
 	  matter sensor.

drivers/iio/light/vcnl4000.c+8−7

@@ -167,16 +167,17 @@ static int vcnl4200_init(struct vcnl4000_data *data) · 166 unmodified lines
167	data->vcnl4200_ps.reg = VCNL4200_PS_DATA;	167	data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
168	switch (id) {	168	switch (id) {
169	case VCNL4200_PROD_ID:	169	case VCNL4200_PROD_ID:
170	/* Integration time is 50ms, but the experiments */	170	/* Default wait time is 50ms, add 20% tolerance. */
171	/* show 54ms in total. */	171	data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000);
172	data->vcnl4200_al.sampling_rate = ktime_set(0, 54000 * 1000);	172	/* Default wait time is 4.8ms, add 20% tolerance. */
173	data->vcnl4200_ps.sampling_rate = ktime_set(0, 4200 * 1000);	173	data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000);
174	data->al_scale = 24000;	174	data->al_scale = 24000;
175	break;	175	break;
176	case VCNL4040_PROD_ID:	176	case VCNL4040_PROD_ID:
177	/* Integration time is 80ms, add 10ms. */	177	/* Default wait time is 80ms, add 20% tolerance. */
178	data->vcnl4200_al.sampling_rate = ktime_set(0, 100000 * 1000);	178	data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000);
179	data->vcnl4200_ps.sampling_rate = ktime_set(0, 100000 * 1000);	179	/* Default wait time is 5ms, add 20% tolerance. */
		180	data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000);
180	data->al_scale = 120000;	181	data->al_scale = 120000;
181	break;	182	break;
182	}	183	}

drivers/iio/magnetometer/ak8974.c+1−1

@@ -564,7 +564,7 @@ static int ak8974_read_raw(struct iio_dev *indio_dev, · 563 unmodified lines
564	* We read all axes and discard all but one, for optimized	564	* We read all axes and discard all but one, for optimized
565	* reading, use the triggered buffer.	565	* reading, use the triggered buffer.
566	*/	566	*/
567	*val = le16_to_cpu(hw_values[chan->address]);	567	*val = (s16)le16_to_cpu(hw_values[chan->address]);
568		568
569	ret = IIO_VAL_INT;	569	ret = IIO_VAL_INT;
570	}	570	}

drivers/iio/proximity/ping.c+1−1

@@ -269,7 +269,7 @@ static const struct iio_chan_spec ping_chan_spec[] = { · 268 unmodified lines
269		269
270	static const struct of_device_id of_ping_match[] = {	270	static const struct of_device_id of_ping_match[] = {
271	{ .compatible = "parallax,ping", .data = &pa_ping_cfg},	271	{ .compatible = "parallax,ping", .data = &pa_ping_cfg},
272	{ .compatible = "parallax,laserping", .data = &pa_ping_cfg},	272	{ .compatible = "parallax,laserping", .data = &pa_laser_ping_cfg},
273	{},	273	{},
274	};	274	};
275		275

drivers/iio/trigger/stm32-timer-trigger.c+9−2

 	return 0;
 }
-static void stm32_timer_stop(struct stm32_timer_trigger *priv)
+static void stm32_timer_stop(struct stm32_timer_trigger *priv,
+			     struct iio_trigger *trig)
 {
 	u32 ccer, cr1;
 	regmap_write(priv->regmap, TIM_PSC, 0);
 	regmap_write(priv->regmap, TIM_ARR, 0);
+	/* Force disable master mode */
+	if (stm32_timer_is_trgo2_name(trig->name))
+		regmap_update_bits(priv->regmap, TIM_CR2, TIM_CR2_MMS2, 0);
+	else
+		regmap_update_bits(priv->regmap, TIM_CR2, TIM_CR2_MMS, 0);
 	/* Make sure that registers are updated */
 	regmap_update_bits(priv->regmap, TIM_EGR, TIM_EGR_UG, TIM_EGR_UG);
 }
 		return ret;
 	if (freq == 0) {
-		stm32_timer_stop(priv);
+		stm32_timer_stop(priv, trig);
 	} else {
 		ret = stm32_timer_start(priv, trig, freq);
 		if (ret)

drivers/iommu/amd_iommu.c+2−2

@@ -3826,7 +3826,7 @@ int amd_iommu_activate_guest_mode(void *data) · 3825 unmodified lines
3826	entry->lo.fields_vapic.ga_tag = ir_data->ga_tag;	3826	entry->lo.fields_vapic.ga_tag = ir_data->ga_tag;
3827		3827
3828	return modify_irte_ga(ir_data->irq_2_irte.devid,	3828	return modify_irte_ga(ir_data->irq_2_irte.devid,
3829	ir_data->irq_2_irte.index, entry, NULL);	3829	ir_data->irq_2_irte.index, entry, ir_data);
3830	}	3830	}
3831	EXPORT_SYMBOL(amd_iommu_activate_guest_mode);	3831	EXPORT_SYMBOL(amd_iommu_activate_guest_mode);
3832		3832
@@ -3852,7 +3852,7 @@ int amd_iommu_deactivate_guest_mode(void *data) · 19 unmodified lines
3852	APICID_TO_IRTE_DEST_HI(cfg->dest_apicid);	3852	APICID_TO_IRTE_DEST_HI(cfg->dest_apicid);
3853		3853
3854	return modify_irte_ga(ir_data->irq_2_irte.devid,	3854	return modify_irte_ga(ir_data->irq_2_irte.devid,
3855	ir_data->irq_2_irte.index, entry, NULL);	3855	ir_data->irq_2_irte.index, entry, ir_data);
3856	}	3856	}
3857	EXPORT_SYMBOL(amd_iommu_deactivate_guest_mode);	3857	EXPORT_SYMBOL(amd_iommu_deactivate_guest_mode);
3858		3858

drivers/iommu/dma-iommu.c+8−8

@@ -177,15 +177,15 @@ static int cookie_init_hw_msi_region(struct iommu_dma_cookie *cookie, · 176 unmodified lines
177	start -= iova_offset(iovad, start);	177	start -= iova_offset(iovad, start);
178	num_pages = iova_align(iovad, end - start) >> iova_shift(iovad);	178	num_pages = iova_align(iovad, end - start) >> iova_shift(iovad);
179		179
180	msi_page = kcalloc(num_pages, sizeof(*msi_page), GFP_KERNEL);
181	if (!msi_page)
182	return -ENOMEM;
183
184	for (i = 0; i < num_pages; i++) {	180	for (i = 0; i < num_pages; i++) {
185	msi_page[i].phys = start;	181	msi_page = kmalloc(sizeof(*msi_page), GFP_KERNEL);
186	msi_page[i].iova = start;	182	if (!msi_page)
187	INIT_LIST_HEAD(&msi_page[i].list);	183	return -ENOMEM;
188	list_add(&msi_page[i].list, &cookie->msi_page_list);	184
		185	msi_page->phys = start;
		186	msi_page->iova = start;
		187	INIT_LIST_HEAD(&msi_page->list);
		188	list_add(&msi_page->list, &cookie->msi_page_list);
189	start += iovad->granule;	189	start += iovad->granule;
190	}	190	}
191		191

drivers/iommu/dmar.c+17−7

 #include <linux/slab.h>
 #include <linux/iommu.h>
 #include <linux/numa.h>
+#include <linux/limits.h>
 #include <asm/irq_remapping.h>
 #include <asm/iommu_table.h>
 	BUG_ON(dev->is_virtfn);
+	/*
+	 * Ignore devices that have a domain number higher than what can
+	 * be looked up in DMAR, e.g. VMD subdevices with domain 0x10000
+	 */
+	if (pci_domain_nr(dev->bus) > U16_MAX)
+		return NULL;
 	/* Only generate path[] for device addition event */
 	if (event == BUS_NOTIFY_ADD_DEVICE)
 		for (tmp = dev; tmp; tmp = tmp->bus->self)
 {
 	struct dmar_drhd_unit *dmaru;
-	list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list)
+	list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list,
+				dmar_rcu_check())
 		if (dmaru->segment == drhd->segment &&
 		    dmaru->reg_base_addr == drhd->address)
 			return dmaru;
 	/* Check for NUL termination within the designated length */
 	if (strnlen(andd->device_name, header->length - 8) == header->length - 8) {
-		WARN_TAINT(1, TAINT_FIRMWARE_WORKAROUND,
+		pr_warn(FW_BUG
 			   "Your BIOS is broken; ANDD object name is not NUL-terminated\n"
 			   "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
 			   dmi_get_system_info(DMI_BIOS_VENDOR),
 			   dmi_get_system_info(DMI_BIOS_VERSION),
 			   dmi_get_system_info(DMI_PRODUCT_VERSION));
+		add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 		return -EINVAL;
 	}
 	pr_info("ANDD device: %x name: %s\n", andd->device_number,
 			return 0;
 		}
 	}
-	WARN_TAINT(
+	pr_warn(FW_BUG
-		1, TAINT_FIRMWARE_WORKAROUND,
 		"Your BIOS is broken; RHSA refers to non-existent DMAR unit at %llx\n"
 		"BIOS vendor: %s; Ver: %s; Product Version: %s\n",
-		drhd->reg_base_addr,
+		rhsa->base_address,
 		dmi_get_system_info(DMI_BIOS_VENDOR),
 		dmi_get_system_info(DMI_BIOS_VERSION),
 		dmi_get_system_info(DMI_PRODUCT_VERSION));
+	add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 	return 0;
 }
 static void warn_invalid_dmar(u64 addr, const char *message)
 {
-	WARN_TAINT_ONCE(
+	pr_warn_once(FW_BUG
-		1, TAINT_FIRMWARE_WORKAROUND,
 		"Your BIOS is broken; DMAR reported at address %llx%s!\n"
 		"BIOS vendor: %s; Ver: %s; Product Version: %s\n",
 		addr, message,
 		dmi_get_system_info(DMI_BIOS_VENDOR),
 		dmi_get_system_info(DMI_BIOS_VERSION),
 		dmi_get_system_info(DMI_PRODUCT_VERSION));
+	add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 }
 static int __ref

drivers/iommu/intel-iommu-debugfs.c+35−16

@@ -33,38 +33,42 @@ struct iommu_regset { · 32 unmodified lines
33		33
34	#define IOMMU_REGSET_ENTRY(_reg_) \	34	#define IOMMU_REGSET_ENTRY(_reg_) \
35	{ DMAR_##_reg_##_REG, __stringify(_reg_) }	35	{ DMAR_##_reg_##_REG, __stringify(_reg_) }
36	static const struct iommu_regset iommu_regs[] = {	36
		37	static const struct iommu_regset iommu_regs_32[] = {
37	IOMMU_REGSET_ENTRY(VER),	38	IOMMU_REGSET_ENTRY(VER),
38	IOMMU_REGSET_ENTRY(CAP),
39	IOMMU_REGSET_ENTRY(ECAP),
40	IOMMU_REGSET_ENTRY(GCMD),	39	IOMMU_REGSET_ENTRY(GCMD),
41	IOMMU_REGSET_ENTRY(GSTS),	40	IOMMU_REGSET_ENTRY(GSTS),
42	IOMMU_REGSET_ENTRY(RTADDR),
43	IOMMU_REGSET_ENTRY(CCMD),
44	IOMMU_REGSET_ENTRY(FSTS),	41	IOMMU_REGSET_ENTRY(FSTS),
45	IOMMU_REGSET_ENTRY(FECTL),	42	IOMMU_REGSET_ENTRY(FECTL),
46	IOMMU_REGSET_ENTRY(FEDATA),	43	IOMMU_REGSET_ENTRY(FEDATA),
47	IOMMU_REGSET_ENTRY(FEADDR),	44	IOMMU_REGSET_ENTRY(FEADDR),
48	IOMMU_REGSET_ENTRY(FEUADDR),	45	IOMMU_REGSET_ENTRY(FEUADDR),
49	IOMMU_REGSET_ENTRY(AFLOG),
50	IOMMU_REGSET_ENTRY(PMEN),	46	IOMMU_REGSET_ENTRY(PMEN),
51	IOMMU_REGSET_ENTRY(PLMBASE),	47	IOMMU_REGSET_ENTRY(PLMBASE),
52	IOMMU_REGSET_ENTRY(PLMLIMIT),	48	IOMMU_REGSET_ENTRY(PLMLIMIT),
		49	IOMMU_REGSET_ENTRY(ICS),
		50	IOMMU_REGSET_ENTRY(PRS),
		51	IOMMU_REGSET_ENTRY(PECTL),
		52	IOMMU_REGSET_ENTRY(PEDATA),
		53	IOMMU_REGSET_ENTRY(PEADDR),
		54	IOMMU_REGSET_ENTRY(PEUADDR),
		55	};
		56
		57	static const struct iommu_regset iommu_regs_64[] = {
		58	IOMMU_REGSET_ENTRY(CAP),
		59	IOMMU_REGSET_ENTRY(ECAP),
		60	IOMMU_REGSET_ENTRY(RTADDR),
		61	IOMMU_REGSET_ENTRY(CCMD),
		62	IOMMU_REGSET_ENTRY(AFLOG),
53	IOMMU_REGSET_ENTRY(PHMBASE),	63	IOMMU_REGSET_ENTRY(PHMBASE),
54	IOMMU_REGSET_ENTRY(PHMLIMIT),	64	IOMMU_REGSET_ENTRY(PHMLIMIT),
55	IOMMU_REGSET_ENTRY(IQH),	65	IOMMU_REGSET_ENTRY(IQH),
56	IOMMU_REGSET_ENTRY(IQT),	66	IOMMU_REGSET_ENTRY(IQT),
57	IOMMU_REGSET_ENTRY(IQA),	67	IOMMU_REGSET_ENTRY(IQA),
58	IOMMU_REGSET_ENTRY(ICS),
59	IOMMU_REGSET_ENTRY(IRTA),	68	IOMMU_REGSET_ENTRY(IRTA),
60	IOMMU_REGSET_ENTRY(PQH),	69	IOMMU_REGSET_ENTRY(PQH),
61	IOMMU_REGSET_ENTRY(PQT),	70	IOMMU_REGSET_ENTRY(PQT),
62	IOMMU_REGSET_ENTRY(PQA),	71	IOMMU_REGSET_ENTRY(PQA),
63	IOMMU_REGSET_ENTRY(PRS),
64	IOMMU_REGSET_ENTRY(PECTL),
65	IOMMU_REGSET_ENTRY(PEDATA),
66	IOMMU_REGSET_ENTRY(PEADDR),
67	IOMMU_REGSET_ENTRY(PEUADDR),
68	IOMMU_REGSET_ENTRY(MTRRCAP),	72	IOMMU_REGSET_ENTRY(MTRRCAP),
69	IOMMU_REGSET_ENTRY(MTRRDEF),	73	IOMMU_REGSET_ENTRY(MTRRDEF),
70	IOMMU_REGSET_ENTRY(MTRR_FIX64K_00000),	74	IOMMU_REGSET_ENTRY(MTRR_FIX64K_00000),
@@ -127,10 +131,16 @@ static int iommu_regset_show(struct seq_file m, void unused) · 56 unmodified lines
127	* by adding the offset to the pointer (virtual address).	131	* by adding the offset to the pointer (virtual address).
128	*/	132	*/
129	raw_spin_lock_irqsave(&iommu->register_lock, flag);	133	raw_spin_lock_irqsave(&iommu->register_lock, flag);
130	for (i = 0 ; i < ARRAY_SIZE(iommu_regs); i++) {	134	for (i = 0 ; i < ARRAY_SIZE(iommu_regs_32); i++) {
131	value = dmar_readq(iommu->reg + iommu_regs[i].offset);	135	value = dmar_readl(iommu->reg + iommu_regs_32[i].offset);
		136	seq_printf(m, "%-16s\t0x%02x\t\t0x%016llx\n",
		137	iommu_regs_32[i].regs, iommu_regs_32[i].offset,
		138	value);
		139	}
		140	for (i = 0 ; i < ARRAY_SIZE(iommu_regs_64); i++) {
		141	value = dmar_readq(iommu->reg + iommu_regs_64[i].offset);
132	seq_printf(m, "%-16s\t0x%02x\t\t0x%016llx\n",	142	seq_printf(m, "%-16s\t0x%02x\t\t0x%016llx\n",
133	iommu_regs[i].regs, iommu_regs[i].offset,	143	iommu_regs_64[i].regs, iommu_regs_64[i].offset,
134	value);	144	value);
135	}	145	}
136	raw_spin_unlock_irqrestore(&iommu->register_lock, flag);	146	raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
@@ -272,9 +282,16 @@ static int dmar_translation_struct_show(struct seq_file m, void unused) · 135 unmodified lines
272	{	282	{
273	struct dmar_drhd_unit *drhd;	283	struct dmar_drhd_unit *drhd;
274	struct intel_iommu *iommu;	284	struct intel_iommu *iommu;
		285	u32 sts;
275		286
276	rcu_read_lock();	287	rcu_read_lock();
277	for_each_active_iommu(iommu, drhd) {	288	for_each_active_iommu(iommu, drhd) {
		289	sts = dmar_readl(iommu->reg + DMAR_GSTS_REG);
		290	if (!(sts & DMA_GSTS_TES)) {
		291	seq_printf(m, "DMA Remapping is not enabled on %s\n",
		292	iommu->name);
		293	continue;
		294	}
278	root_tbl_walk(m, iommu);	295	root_tbl_walk(m, iommu);
279	seq_putc(m, '\n');	296	seq_putc(m, '\n');
280	}	297	}
@@ -415,6 +432,7 @@ static int ir_translation_struct_show(struct seq_file m, void unused) · 134 unmodified lines
415	struct dmar_drhd_unit *drhd;	432	struct dmar_drhd_unit *drhd;
416	struct intel_iommu *iommu;	433	struct intel_iommu *iommu;
417	u64 irta;	434	u64 irta;
		435	u32 sts;
418		436
419	rcu_read_lock();	437	rcu_read_lock();
420	for_each_active_iommu(iommu, drhd) {	438	for_each_active_iommu(iommu, drhd) {
@@ -424,7 +442,8 @@ static int ir_translation_struct_show(struct seq_file m, void unused) · 3 unmodified lines
424	seq_printf(m, "Remapped Interrupt supported on IOMMU: %s\n",	442	seq_printf(m, "Remapped Interrupt supported on IOMMU: %s\n",
425	iommu->name);	443	iommu->name);
426		444
427	if (iommu->ir_table) {	445	sts = dmar_readl(iommu->reg + DMAR_GSTS_REG);
		446	if (iommu->ir_table && (sts & DMA_GSTS_IRES)) {
428	irta = virt_to_phys(iommu->ir_table->base);	447	irta = virt_to_phys(iommu->ir_table->base);
429	seq_printf(m, " IR table address:%llx\n", irta);	448	seq_printf(m, " IR table address:%llx\n", irta);
430	ir_tbl_remap_entry_show(m, iommu);	449	ir_tbl_remap_entry_show(m, iommu);

drivers/iommu/intel-iommu.c+19−9

 	/* we know that the this iommu should be at offset 0xa000 from vtbar */
 	drhd = dmar_find_matched_drhd_unit(pdev);
-	if (WARN_TAINT_ONCE(!drhd || drhd->reg_base_addr - vtbar != 0xa000,
+	if (!drhd || drhd->reg_base_addr - vtbar != 0xa000) {
-			    TAINT_FIRMWARE_WORKAROUND,
+		pr_warn_once(FW_BUG "BIOS assigned incorrect VT-d unit for Intel(R) QuickData Technology device\n");
-			    "BIOS assigned incorrect VT-d unit for Intel(R) QuickData Technology device\n"))
+		add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 		pdev->dev.archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO;
+	}
 }
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB, quirk_ioat_snb_local_iommu);
 	struct dmar_rmrr_unit *rmrru;
 	rmrr = (struct acpi_dmar_reserved_memory *)header;
-	if (rmrr_sanity_check(rmrr))
+	if (rmrr_sanity_check(rmrr)) {
-		WARN_TAINT(1, TAINT_FIRMWARE_WORKAROUND,
+		pr_warn(FW_BUG
 			   "Your BIOS is broken; bad RMRR [%#018Lx-%#018Lx]\n"
 			   "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
 			   rmrr->base_address, rmrr->end_address,
 			   dmi_get_system_info(DMI_BIOS_VENDOR),
 			   dmi_get_system_info(DMI_BIOS_VERSION),
 			   dmi_get_system_info(DMI_PRODUCT_VERSION));
+		add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
+	}
 	rmrru = kzalloc(sizeof(*rmrru), GFP_KERNEL);
 	if (!rmrru)
 	down_write(&dmar_global_lock);
+	if (!no_iommu)
+		intel_iommu_debugfs_init();
 	if (no_iommu || dmar_disabled) {
 		/*
 		 * We exit the function here to ensure IOMMU's remapping and
 	init_iommu_pm_ops();
+	down_read(&dmar_global_lock);
 	for_each_active_iommu(iommu, drhd) {
 		iommu_device_sysfs_add(&iommu->iommu, NULL,
 				       intel_iommu_groups,
 		iommu_device_set_ops(&iommu->iommu, &intel_iommu_ops);
 		iommu_device_register(&iommu->iommu);
 	}
+	up_read(&dmar_global_lock);
 	bus_set_iommu(&pci_bus_type, &intel_iommu_ops);
 	if (si_domain && !hw_pass_through)
 	down_read(&dmar_global_lock);
 	if (probe_acpi_namespace_devices())
 		pr_warn("ACPI name space devices didn't probe correctly\n");
-	up_read(&dmar_global_lock);
 	/* Finally, we enable the DMA remapping hardware. */
 	for_each_iommu(iommu, drhd) {
 		iommu_disable_protect_mem_regions(iommu);
 	}
+	up_read(&dmar_global_lock);
 	pr_info("Intel(R) Virtualization Technology for Directed I/O\n");
 	intel_iommu_enabled = 1;
-	intel_iommu_debugfs_init();
 	return 0;
 	u64 phys = 0;
 	pte = pfn_to_dma_pte(dmar_domain, iova >> VTD_PAGE_SHIFT, &level);
-	if (pte)
+	if (pte && dma_pte_present(pte))
-		phys = dma_pte_addr(pte);
+		phys = dma_pte_addr(pte) +
+			(iova & (BIT_MASK(level_to_offset_bits(level) +
+						VTD_PAGE_SHIFT) - 1));
 	return phys;
 }

drivers/iommu/io-pgtable-arm.c+2−2

@@ -468,7 +468,7 @@ static int arm_lpae_map(struct io_pgtable_ops *ops, unsigned long iova, · 467 unmodified lines
468	arm_lpae_iopte *ptep = data->pgd;	468	arm_lpae_iopte *ptep = data->pgd;
469	int ret, lvl = data->start_level;	469	int ret, lvl = data->start_level;
470	arm_lpae_iopte prot;	470	arm_lpae_iopte prot;
471	long iaext = (long)iova >> cfg->ias;	471	long iaext = (s64)iova >> cfg->ias;
472		472
473	/* If no access, then nothing to do */	473	/* If no access, then nothing to do */
474	if (!(iommu_prot & (IOMMU_READ \| IOMMU_WRITE)))	474	if (!(iommu_prot & (IOMMU_READ \| IOMMU_WRITE)))
@@ -645,7 +645,7 @@ static size_t arm_lpae_unmap(struct io_pgtable_ops *ops, unsigned long iova, · 170 unmodified lines
645	struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);	645	struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);
646	struct io_pgtable_cfg *cfg = &data->iop.cfg;	646	struct io_pgtable_cfg *cfg = &data->iop.cfg;
647	arm_lpae_iopte *ptep = data->pgd;	647	arm_lpae_iopte *ptep = data->pgd;
648	long iaext = (long)iova >> cfg->ias;	648	long iaext = (s64)iova >> cfg->ias;
649		649
650	if (WARN_ON(!size \|\| (size & cfg->pgsize_bitmap) != size))	650	if (WARN_ON(!size \|\| (size & cfg->pgsize_bitmap) != size))
651	return 0;	651	return 0;

drivers/irqchip/irq-gic-v3.c+29−1

@@ -34,6 +34,7 @@ · 33 unmodified lines
34	#define GICD_INT_NMI_PRI (GICD_INT_DEF_PRI & ~0x80)	34	#define GICD_INT_NMI_PRI (GICD_INT_DEF_PRI & ~0x80)
35		35
36	#define FLAGS_WORKAROUND_GICR_WAKER_MSM8996 (1ULL << 0)	36	#define FLAGS_WORKAROUND_GICR_WAKER_MSM8996 (1ULL << 0)
		37	#define FLAGS_WORKAROUND_CAVIUM_ERRATUM_38539 (1ULL << 1)
37		38
38	struct redist_region {	39	struct redist_region {
39	void __iomem *redist_base;	40	void __iomem *redist_base;
@@ -1464,6 +1465,15 @@ static bool gic_enable_quirk_msm8996(void *data) · 1424 unmodified lines
1464	return true;	1465	return true;
1465	}	1466	}
1466		1467
		1468	static bool gic_enable_quirk_cavium_38539(void *data)
		1469	{
		1470	struct gic_chip_data *d = data;
		1471
		1472	d->flags \|= FLAGS_WORKAROUND_CAVIUM_ERRATUM_38539;
		1473
		1474	return true;
		1475	}
		1476
1467	static bool gic_enable_quirk_hip06_07(void *data)	1477	static bool gic_enable_quirk_hip06_07(void *data)
1468	{	1478	{
1469	struct gic_chip_data *d = data;	1479	struct gic_chip_data *d = data;
@@ -1502,6 +1512,19 @@ static const struct gic_quirk gic_quirks[] = { · 32 unmodified lines
1502	.mask = 0xffffffff,	1512	.mask = 0xffffffff,
1503	.init = gic_enable_quirk_hip06_07,	1513	.init = gic_enable_quirk_hip06_07,
1504	},	1514	},
		1515	{
		1516	/*
		1517	* Reserved register accesses generate a Synchronous
		1518	* External Abort. This erratum applies to:
		1519	* - ThunderX: CN88xx
		1520	* - OCTEON TX: CN83xx, CN81xx
		1521	* - OCTEON TX2: CN93xx, CN96xx, CN98xx, CNF95xx*
		1522	*/
		1523	.desc = "GICv3: Cavium erratum 38539",
		1524	.iidr = 0xa000034c,
		1525	.mask = 0xe8f00fff,
		1526	.init = gic_enable_quirk_cavium_38539,
		1527	},
1505	{	1528	{
1506	}	1529	}
1507	};	1530	};
@@ -1577,7 +1600,12 @@ static int __init gic_init_bases(void __iomem *dist_base, · 69 unmodified lines
1577	pr_info("%d SPIs implemented\n", GIC_LINE_NR - 32);	1600	pr_info("%d SPIs implemented\n", GIC_LINE_NR - 32);
1578	pr_info("%d Extended SPIs implemented\n", GIC_ESPI_NR);	1601	pr_info("%d Extended SPIs implemented\n", GIC_ESPI_NR);
1579		1602
1580	gic_data.rdists.gicd_typer2 = readl_relaxed(gic_data.dist_base + GICD_TYPER2);	1603	/*
		1604	* ThunderX1 explodes on reading GICD_TYPER2, in violation of the
		1605	* architecture spec (which says that reserved registers are RES0).
		1606	*/
		1607	if (!(gic_data.flags & FLAGS_WORKAROUND_CAVIUM_ERRATUM_38539))
		1608	gic_data.rdists.gicd_typer2 = readl_relaxed(gic_data.dist_base + GICD_TYPER2);
1581		1609
1582	gic_data.domain = irq_domain_create_tree(handle, &gic_irq_domain_ops,	1610	gic_data.domain = irq_domain_create_tree(handle, &gic_irq_domain_ops,
1583	&gic_data);	1611	&gic_data);

drivers/macintosh/windfarm_ad7417_sensor.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_ad7417_id);
+static const struct of_device_id wf_ad7417_of_id[] = {
+	{ .compatible = "ad7417", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_ad7417_of_id);
 static struct i2c_driver wf_ad7417_driver = {
 	.driver = {
 		.name	= "wf_ad7417",
+		.of_match_table = wf_ad7417_of_id,
 	},
 	.probe		= wf_ad7417_probe,
 	.remove		= wf_ad7417_remove,

drivers/macintosh/windfarm_fcu_controls.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_fcu_id);
+static const struct of_device_id wf_fcu_of_id[] = {
+	{ .compatible = "fcu", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_fcu_of_id);
 static struct i2c_driver wf_fcu_driver = {
 	.driver = {
 		.name	= "wf_fcu",
+		.of_match_table = wf_fcu_of_id,
 	},
 	.probe		= wf_fcu_probe,
 	.remove		= wf_fcu_remove,

drivers/macintosh/windfarm_lm75_sensor.c+15−1

 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/i2c.h>
+#include <linux/of_device.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
 			 const struct i2c_device_id *id)
 {
 	struct wf_lm75_sensor *lm;
-	int rc, ds1775 = id->driver_data;
+	int rc, ds1775;
 	const char *name, *loc;
+	if (id)
+		ds1775 = id->driver_data;
+	else
+		ds1775 = !!of_device_get_match_data(&client->dev);
 	DBG("wf_lm75: creating  %s device at address 0x%02x\n",
 	    ds1775 ? "ds1775" : "lm75", client->addr);
 };
 MODULE_DEVICE_TABLE(i2c, wf_lm75_id);
+static const struct of_device_id wf_lm75_of_id[] = {
+	{ .compatible = "lm75", .data = (void *)0},
+	{ .compatible = "ds1775", .data = (void *)1 },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_lm75_of_id);
 static struct i2c_driver wf_lm75_driver = {
 	.driver = {
 		.name	= "wf_lm75",
+		.of_match_table = wf_lm75_of_id,
 	},
 	.probe		= wf_lm75_probe,
 	.remove		= wf_lm75_remove,

drivers/macintosh/windfarm_lm87_sensor.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_lm87_id);
+static const struct of_device_id wf_lm87_of_id[] = {
+	{ .compatible = "lm87cimt", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_lm87_of_id);
 static struct i2c_driver wf_lm87_driver = {
 	.driver = {
 		.name	= "wf_lm87",
+		.of_match_table = wf_lm87_of_id,
 	},
 	.probe		= wf_lm87_probe,
 	.remove		= wf_lm87_remove,

drivers/macintosh/windfarm_max6690_sensor.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_max6690_id);
+static const struct of_device_id wf_max6690_of_id[] = {
+	{ .compatible = "max6690", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_max6690_of_id);
 static struct i2c_driver wf_max6690_driver = {
 	.driver = {
 		.name		= "wf_max6690",
+		.of_match_table = wf_max6690_of_id,
 	},
 	.probe		= wf_max6690_probe,
 	.remove		= wf_max6690_remove,

drivers/macintosh/windfarm_smu_sat.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_sat_id);
+static const struct of_device_id wf_sat_of_id[] = {
+	{ .compatible = "smu-sat", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_sat_of_id);
 static struct i2c_driver wf_sat_driver = {
 	.driver = {
 		.name		= "wf_smu_sat",
+		.of_match_table = wf_sat_of_id,
 	},
 	.probe		= wf_sat_probe,
 	.remove		= wf_sat_remove,

drivers/misc/cardreader/rts5227.c+1−1

@@ -394,7 +394,7 @@ static const struct pcr_ops rts522a_pcr_ops = { · 393 unmodified lines
394	void rts522a_init_params(struct rtsx_pcr *pcr)	394	void rts522a_init_params(struct rtsx_pcr *pcr)
395	{	395	{
396	rts5227_init_params(pcr);	396	rts5227_init_params(pcr);
397		397	pcr->tx_initial_phase = SET_CLOCK_PHASE(20, 20, 11);
398	pcr->reg_pm_ctrl3 = RTS522A_PM_CTRL3;	398	pcr->reg_pm_ctrl3 = RTS522A_PM_CTRL3;
399		399
400	pcr->option.ocp_en = 1;	400	pcr->option.ocp_en = 1;

drivers/misc/cardreader/rts5249.c+2−0

 void rts524a_init_params(struct rtsx_pcr *pcr)
 {
 	rts5249_init_params(pcr);
+	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 29, 11);
 	pcr->option.ltr_l1off_sspwrgate = LTR_L1OFF_SSPWRGATE_5250_DEF;
 	pcr->option.ltr_l1off_snooze_sspwrgate =
 		LTR_L1OFF_SNOOZE_SSPWRGATE_5250_DEF;
 void rts525a_init_params(struct rtsx_pcr *pcr)
 {
 	rts5249_init_params(pcr);
+	pcr->tx_initial_phase = SET_CLOCK_PHASE(25, 29, 11);
 	pcr->option.ltr_l1off_sspwrgate = LTR_L1OFF_SSPWRGATE_5250_DEF;
 	pcr->option.ltr_l1off_snooze_sspwrgate =
 		LTR_L1OFF_SNOOZE_SSPWRGATE_5250_DEF;

drivers/misc/cardreader/rts5260.c+1−1

@@ -662,7 +662,7 @@ void rts5260_init_params(struct rtsx_pcr *pcr) · 661 unmodified lines
662	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;	662	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
663	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;	663	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
664	pcr->aspm_en = ASPM_L1_EN;	664	pcr->aspm_en = ASPM_L1_EN;
665	pcr->tx_initial_phase = SET_CLOCK_PHASE(1, 29, 16);	665	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 29, 11);
666	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	666	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
667		667
668	pcr->ic_version = rts5260_get_ic_version(pcr);	668	pcr->ic_version = rts5260_get_ic_version(pcr);

drivers/misc/cardreader/rts5261.c+1−1

@@ -764,7 +764,7 @@ void rts5261_init_params(struct rtsx_pcr *pcr) · 763 unmodified lines
764	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;	764	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
765	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;	765	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
766	pcr->aspm_en = ASPM_L1_EN;	766	pcr->aspm_en = ASPM_L1_EN;
767	pcr->tx_initial_phase = SET_CLOCK_PHASE(20, 27, 16);	767	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 11);
768	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	768	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
769		769
770	pcr->ic_version = rts5261_get_ic_version(pcr);	770	pcr->ic_version = rts5261_get_ic_version(pcr);

drivers/misc/eeprom/at24.c+2−1

 	 * chip is functional.
 	 */
 	err = at24_read(at24, 0, &test_byte, 1);
-	pm_runtime_idle(dev);
 	if (err) {
 		pm_runtime_disable(dev);
 		regulator_disable(at24->vcc_reg);
 		return -ENODEV;
 	}
+	pm_runtime_idle(dev);
 	if (writable)
 		dev_info(dev, "%u byte %s EEPROM, writable, %u bytes/write\n",
 			 byte_len, client->name, at24->write_max);

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

 	 * the erase operation does not exceed the max_busy_timeout, we should
 	 * use R1B response. Or we need to prevent the host from doing hw busy
 	 * detection, which is done by converting to a R1 response instead.
+	 * Note, some hosts requires R1B, which also means they are on their own
+	 * when it comes to deal with the busy timeout.
 	 */
-	if (card->host->max_busy_timeout &&
+	if (!(card->host->caps & MMC_CAP_NEED_RSP_BUSY) &&
+	    card->host->max_busy_timeout &&
 	    busy_timeout > card->host->max_busy_timeout) {
 		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
 	} else {

drivers/mmc/core/mmc.c+5−2

 	 * If the max_busy_timeout of the host is specified, validate it against
 	 * the sleep cmd timeout. A failure means we need to prevent the host
 	 * from doing hw busy detection, which is done by converting to a R1
-	 * response instead of a R1B.
+	 * response instead of a R1B. Note, some hosts requires R1B, which also
+	 * means they are on their own when it comes to deal with the busy
+	 * timeout.
 	 */
-	if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
+	if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
+	    (timeout_ms > host->max_busy_timeout)) {
 		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 	} else {
 		cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;

drivers/mmc/core/mmc_ops.c+4−2

 	 * If the max_busy_timeout of the host is specified, make sure it's
 	 * enough to fit the used timeout_ms. In case it's not, let's instruct
 	 * the host to avoid HW busy detection, by converting to a R1 response
-	 * instead of a R1B.
+	 * instead of a R1B. Note, some hosts requires R1B, which also means
+	 * they are on their own when it comes to deal with the busy timeout.
 	 */
-	if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout))
+	if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
+	    (timeout_ms > host->max_busy_timeout))
 		use_r1b_resp = false;
 	cmd.opcode = MMC_SWITCH;

drivers/mmc/host/rtsx_pci_sdmmc.c+8−5

@@ -606,19 +606,22 @@ static int sd_change_phase(struct realtek_pci_sdmmc *host, · 605 unmodified lines
606	u8 sample_point, bool rx)	606	u8 sample_point, bool rx)
607	{	607	{
608	struct rtsx_pcr *pcr = host->pcr;	608	struct rtsx_pcr *pcr = host->pcr;
609		609	u16 SD_VP_CTL = 0;
610	dev_dbg(sdmmc_dev(host), "%s(%s): sample_point = %d\n",	610	dev_dbg(sdmmc_dev(host), "%s(%s): sample_point = %d\n",
611	__func__, rx ? "RX" : "TX", sample_point);	611	__func__, rx ? "RX" : "TX", sample_point);
612		612
613	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, CHANGE_CLK);	613	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, CHANGE_CLK);
614	if (rx)	614	if (rx) {
		615	SD_VP_CTL = SD_VPRX_CTL;
615	rtsx_pci_write_register(pcr, SD_VPRX_CTL,	616	rtsx_pci_write_register(pcr, SD_VPRX_CTL,
616	PHASE_SELECT_MASK, sample_point);	617	PHASE_SELECT_MASK, sample_point);
617	else	618	} else {
		619	SD_VP_CTL = SD_VPTX_CTL;
618	rtsx_pci_write_register(pcr, SD_VPTX_CTL,	620	rtsx_pci_write_register(pcr, SD_VPTX_CTL,
619	PHASE_SELECT_MASK, sample_point);	621	PHASE_SELECT_MASK, sample_point);
620	rtsx_pci_write_register(pcr, SD_VPCLK0_CTL, PHASE_NOT_RESET, 0);	622	}
621	rtsx_pci_write_register(pcr, SD_VPCLK0_CTL, PHASE_NOT_RESET,	623	rtsx_pci_write_register(pcr, SD_VP_CTL, PHASE_NOT_RESET, 0);
		624	rtsx_pci_write_register(pcr, SD_VP_CTL, PHASE_NOT_RESET,
622	PHASE_NOT_RESET);	625	PHASE_NOT_RESET);
623	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, 0);	626	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, 0);
624	rtsx_pci_write_register(pcr, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0);	627	rtsx_pci_write_register(pcr, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0);

drivers/mmc/host/sdhci-acpi.c+82−2

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	#include <linux/pm.h>	23	#include <linux/pm.h>
24	#include <linux/pm_runtime.h>	24	#include <linux/pm_runtime.h>
25	#include <linux/delay.h>	25	#include <linux/delay.h>
		26	#include <linux/dmi.h>
26		27
27	#include <linux/mmc/host.h>	28	#include <linux/mmc/host.h>
28	#include <linux/mmc/pm.h>	29	#include <linux/mmc/pm.h>
@@ -72,9 +73,16 @@ struct sdhci_acpi_host { · 43 unmodified lines
72	const struct sdhci_acpi_slot *slot;	73	const struct sdhci_acpi_slot *slot;
73	struct platform_device *pdev;	74	struct platform_device *pdev;
74	bool use_runtime_pm;	75	bool use_runtime_pm;
		76	bool is_intel;
		77	bool reset_signal_volt_on_suspend;
75	unsigned long private[0] ____cacheline_aligned;	78	unsigned long private[0] ____cacheline_aligned;
76	};	79	};
77		80
		81	enum {
		82	DMI_QUIRK_RESET_SD_SIGNAL_VOLT_ON_SUSP = BIT(0),
		83	DMI_QUIRK_SD_NO_WRITE_PROTECT = BIT(1),
		84	};
		85
78	static inline void sdhci_acpi_priv(struct sdhci_acpi_host c)	86	static inline void sdhci_acpi_priv(struct sdhci_acpi_host c)
79	{	87	{
80	return (void *)c->private;	88	return (void *)c->private;
@@ -391,6 +399,8 @@ static int intel_probe_slot(struct platform_device pdev, struct acpi_device ad · 310 unmodified lines
391	host->mmc_host_ops.start_signal_voltage_switch =	399	host->mmc_host_ops.start_signal_voltage_switch =
392	intel_start_signal_voltage_switch;	400	intel_start_signal_voltage_switch;
393		401
		402	c->is_intel = true;
		403
394	return 0;	404	return 0;
395	}	405	}
396		406
@@ -647,6 +657,36 @@ static const struct acpi_device_id sdhci_acpi_ids[] = { · 250 unmodified lines
647	};	657	};
648	MODULE_DEVICE_TABLE(acpi, sdhci_acpi_ids);	658	MODULE_DEVICE_TABLE(acpi, sdhci_acpi_ids);
649		659
		660	static const struct dmi_system_id sdhci_acpi_quirks[] = {
		661	{
		662	/*
		663	* The Lenovo Miix 320-10ICR has a bug in the _PS0 method of
		664	* the SHC1 ACPI device, this bug causes it to reprogram the
		665	* wrong LDO (DLDO3) to 1.8V if 1.8V modes are used and the
		666	* card is (runtime) suspended + resumed. DLDO3 is used for
		667	* the LCD and setting it to 1.8V causes the LCD to go black.
		668	*/
		669	.matches = {
		670	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		671	DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
		672	},
		673	.driver_data = (void *)DMI_QUIRK_RESET_SD_SIGNAL_VOLT_ON_SUSP,
		674	},
		675	{
		676	/*
		677	* The Acer Aspire Switch 10 (SW5-012) microSD slot always
		678	* reports the card being write-protected even though microSD
		679	* cards do not have a write-protect switch at all.
		680	*/
		681	.matches = {
		682	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
		683	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"),
		684	},
		685	.driver_data = (void *)DMI_QUIRK_SD_NO_WRITE_PROTECT,
		686	},
		687	{} /* Terminating entry */
		688	};
		689
650	static const struct sdhci_acpi_slot sdhci_acpi_get_slot(struct acpi_device adev)	690	static const struct sdhci_acpi_slot sdhci_acpi_get_slot(struct acpi_device adev)
651	{	691	{
652	const struct sdhci_acpi_uid_slot *u;	692	const struct sdhci_acpi_uid_slot *u;
@@ -663,17 +703,23 @@ static int sdhci_acpi_probe(struct platform_device *pdev) · 10 unmodified lines
663	struct device *dev = &pdev->dev;	703	struct device *dev = &pdev->dev;
664	const struct sdhci_acpi_slot *slot;	704	const struct sdhci_acpi_slot *slot;
665	struct acpi_device device, child;	705	struct acpi_device device, child;
		706	const struct dmi_system_id *id;
666	struct sdhci_acpi_host *c;	707	struct sdhci_acpi_host *c;
667	struct sdhci_host *host;	708	struct sdhci_host *host;
668	struct resource *iomem;	709	struct resource *iomem;
669	resource_size_t len;	710	resource_size_t len;
670	size_t priv_size;	711	size_t priv_size;
		712	int quirks = 0;
671	int err;	713	int err;
672		714
673	device = ACPI_COMPANION(dev);	715	device = ACPI_COMPANION(dev);
674	if (!device)	716	if (!device)
675	return -ENODEV;	717	return -ENODEV;
676		718
		719	id = dmi_first_match(sdhci_acpi_quirks);
		720	if (id)
		721	quirks = (long)id->driver_data;
		722
677	slot = sdhci_acpi_get_slot(device);	723	slot = sdhci_acpi_get_slot(device);
678		724
679	/* Power on the SDHCI controller and its children */	725	/* Power on the SDHCI controller and its children */
@@ -759,6 +805,12 @@ static int sdhci_acpi_probe(struct platform_device *pdev) · 79 unmodified lines
759	dev_warn(dev, "failed to setup card detect gpio\n");	805	dev_warn(dev, "failed to setup card detect gpio\n");
760	c->use_runtime_pm = false;	806	c->use_runtime_pm = false;
761	}	807	}
		808
		809	if (quirks & DMI_QUIRK_RESET_SD_SIGNAL_VOLT_ON_SUSP)
		810	c->reset_signal_volt_on_suspend = true;
		811
		812	if (quirks & DMI_QUIRK_SD_NO_WRITE_PROTECT)
		813	host->mmc->caps2 \|= MMC_CAP2_NO_WRITE_PROTECT;
762	}	814	}
763		815
764	err = sdhci_setup_host(host);	816	err = sdhci_setup_host(host);
@@ -823,17 +875,39 @@ static int sdhci_acpi_remove(struct platform_device *pdev) · 58 unmodified lines
823	return 0;	875	return 0;
824	}	876	}
825		877
		878	static void __maybe_unused sdhci_acpi_reset_signal_voltage_if_needed(
		879	struct device *dev)
		880	{
		881	struct sdhci_acpi_host *c = dev_get_drvdata(dev);
		882	struct sdhci_host *host = c->host;
		883
		884	if (c->is_intel && c->reset_signal_volt_on_suspend &&
		885	host->mmc->ios.signal_voltage != MMC_SIGNAL_VOLTAGE_330) {
		886	struct intel_host *intel_host = sdhci_acpi_priv(c);
		887	unsigned int fn = INTEL_DSM_V33_SWITCH;
		888	u32 result = 0;
		889
		890	intel_dsm(intel_host, dev, fn, &result);
		891	}
		892	}
		893
826	#ifdef CONFIG_PM_SLEEP	894	#ifdef CONFIG_PM_SLEEP
827		895
828	static int sdhci_acpi_suspend(struct device *dev)	896	static int sdhci_acpi_suspend(struct device *dev)
829	{	897	{
830	struct sdhci_acpi_host *c = dev_get_drvdata(dev);	898	struct sdhci_acpi_host *c = dev_get_drvdata(dev);
831	struct sdhci_host *host = c->host;	899	struct sdhci_host *host = c->host;
		900	int ret;
832		901
833	if (host->tuning_mode != SDHCI_TUNING_MODE_3)	902	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
834	mmc_retune_needed(host->mmc);	903	mmc_retune_needed(host->mmc);
835		904
836	return sdhci_suspend_host(host);	905	ret = sdhci_suspend_host(host);
		906	if (ret)
		907	return ret;
		908
		909	sdhci_acpi_reset_signal_voltage_if_needed(dev);
		910	return 0;
837	}	911	}
838		912
839	static int sdhci_acpi_resume(struct device *dev)	913	static int sdhci_acpi_resume(struct device *dev)
@@ -853,11 +927,17 @@ static int sdhci_acpi_runtime_suspend(struct device *dev) · 13 unmodified lines
853	{	927	{
854	struct sdhci_acpi_host *c = dev_get_drvdata(dev);	928	struct sdhci_acpi_host *c = dev_get_drvdata(dev);
855	struct sdhci_host *host = c->host;	929	struct sdhci_host *host = c->host;
		930	int ret;
856		931
857	if (host->tuning_mode != SDHCI_TUNING_MODE_3)	932	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
858	mmc_retune_needed(host->mmc);	933	mmc_retune_needed(host->mmc);
859		934
860	return sdhci_runtime_suspend_host(host);	935	ret = sdhci_runtime_suspend_host(host);
		936	if (ret)
		937	return ret;
		938
		939	sdhci_acpi_reset_signal_voltage_if_needed(dev);
		940	return 0;
861	}	941	}
862		942
863	static int sdhci_acpi_runtime_resume(struct device *dev)	943	static int sdhci_acpi_runtime_resume(struct device *dev)

drivers/mmc/host/sdhci-cadence.c+16−2

 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
 #include <linux/of.h>
+#include <linux/of_device.h>
 #include "sdhci-pltfm.h"
 	.set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
 };
+static const struct sdhci_pltfm_data sdhci_cdns_uniphier_pltfm_data = {
+	.ops = &sdhci_cdns_ops,
+	.quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
+};
 static const struct sdhci_pltfm_data sdhci_cdns_pltfm_data = {
 	.ops = &sdhci_cdns_ops,
 };
 static int sdhci_cdns_probe(struct platform_device *pdev)
 {
 	struct sdhci_host *host;
+	const struct sdhci_pltfm_data *data;
 	struct sdhci_pltfm_host *pltfm_host;
 	struct sdhci_cdns_priv *priv;
 	struct clk *clk;
 	if (ret)
 		return ret;
+	data = of_device_get_match_data(dev);
+	if (!data)
+		data = &sdhci_cdns_pltfm_data;
 	nr_phy_params = sdhci_cdns_phy_param_count(dev->of_node);
-	host = sdhci_pltfm_init(pdev, &sdhci_cdns_pltfm_data,
+	host = sdhci_pltfm_init(pdev, data,
 				struct_size(priv, phy_params, nr_phy_params));
 	if (IS_ERR(host)) {
 		ret = PTR_ERR(host);
 };
 static const struct of_device_id sdhci_cdns_match[] = {
-	{ .compatible = "socionext,uniphier-sd4hc" },
+	{
+		.compatible = "socionext,uniphier-sd4hc",
+		.data = &sdhci_cdns_uniphier_pltfm_data,
+	},
 	{ .compatible = "cdns,sd4hc" },
 	{ /* sentinel */ }
 };

drivers/mmc/host/sdhci-msm.c+1−1

@@ -1590,7 +1590,7 @@ static u32 sdhci_msm_cqe_irq(struct sdhci_host *host, u32 intmask) · 1589 unmodified lines
1590	return 0;	1590	return 0;
1591	}	1591	}
1592		1592
1593	void sdhci_msm_cqe_disable(struct mmc_host *mmc, bool recovery)	1593	static void sdhci_msm_cqe_disable(struct mmc_host *mmc, bool recovery)
1594	{	1594	{
1595	struct sdhci_host *host = mmc_priv(mmc);	1595	struct sdhci_host *host = mmc_priv(mmc);
1596	unsigned long flags;	1596	unsigned long flags;

drivers/mmc/host/sdhci-of-at91.c+6−2

 	sdhci_reset(host, mask);
-	if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	if ((host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	    || mmc_gpio_get_cd(host->mmc) >= 0)
 		sdhci_at91_set_force_card_detect(host);
 	if (priv->cal_always_on && (mask & SDHCI_RESET_ALL))
 	 * detection procedure using the SDMCC_CD signal is bypassed.
 	 * This bit is reset when a software reset for all command is performed
 	 * so we need to implement our own reset function to set back this bit.
+	 *
+	 * WA: SAMA5D2 doesn't drive CMD if using CD GPIO line.
 	 */
-	if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	if ((host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	    || mmc_gpio_get_cd(host->mmc) >= 0)
 		sdhci_at91_set_force_card_detect(host);
 	pm_runtime_put_autosuspend(&pdev->dev);

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

@@ -1192,6 +1192,9 @@ static int sdhci_omap_probe(struct platform_device *pdev) · 1191 unmodified lines
1192	if (of_find_property(dev->of_node, "dmas", NULL))	1192	if (of_find_property(dev->of_node, "dmas", NULL))
1193	sdhci_switch_external_dma(host, true);	1193	sdhci_switch_external_dma(host, true);
1194		1194
		1195	/* R1B responses is required to properly manage HW busy detection. */
		1196	mmc->caps \|= MMC_CAP_NEED_RSP_BUSY;
		1197
1195	ret = sdhci_setup_host(host);	1198	ret = sdhci_setup_host(host);
1196	if (ret)	1199	if (ret)
1197	goto err_put_sync;	1200	goto err_put_sync;

drivers/mmc/host/sdhci-pci-gli.c+17−0

@@ -262,10 +262,26 @@ static int gl9750_execute_tuning(struct sdhci_host *host, u32 opcode) · 261 unmodified lines
262	return 0;	262	return 0;
263	}	263	}
264		264
		265	static void gli_pcie_enable_msi(struct sdhci_pci_slot *slot)
		266	{
		267	int ret;
		268
		269	ret = pci_alloc_irq_vectors(slot->chip->pdev, 1, 1,
		270	PCI_IRQ_MSI \| PCI_IRQ_MSIX);
		271	if (ret < 0) {
		272	pr_warn("%s: enable PCI MSI failed, error=%d\n",
		273	mmc_hostname(slot->host->mmc), ret);
		274	return;
		275	}
		276
		277	slot->host->irq = pci_irq_vector(slot->chip->pdev, 0);
		278	}
		279
265	static int gli_probe_slot_gl9750(struct sdhci_pci_slot *slot)	280	static int gli_probe_slot_gl9750(struct sdhci_pci_slot *slot)
266	{	281	{
267	struct sdhci_host *host = slot->host;	282	struct sdhci_host *host = slot->host;
268		283
		284	gli_pcie_enable_msi(slot);
269	slot->host->mmc->caps2 \|= MMC_CAP2_NO_SDIO;	285	slot->host->mmc->caps2 \|= MMC_CAP2_NO_SDIO;
270	sdhci_enable_v4_mode(host);	286	sdhci_enable_v4_mode(host);
271		287
@@ -276,6 +292,7 @@ static int gli_probe_slot_gl9755(struct sdhci_pci_slot *slot) · 4 unmodified lines
276	{	292	{
277	struct sdhci_host *host = slot->host;	293	struct sdhci_host *host = slot->host;
278		294
		295	gli_pcie_enable_msi(slot);
279	slot->host->mmc->caps2 \|= MMC_CAP2_NO_SDIO;	296	slot->host->mmc->caps2 \|= MMC_CAP2_NO_SDIO;
280	sdhci_enable_v4_mode(host);	297	sdhci_enable_v4_mode(host);
281		298

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

@@ -1552,6 +1552,9 @@ static int sdhci_tegra_probe(struct platform_device *pdev) · 1551 unmodified lines
1552	if (tegra_host->soc_data->nvquirks & NVQUIRK_ENABLE_DDR50)	1552	if (tegra_host->soc_data->nvquirks & NVQUIRK_ENABLE_DDR50)
1553	host->mmc->caps \|= MMC_CAP_1_8V_DDR;	1553	host->mmc->caps \|= MMC_CAP_1_8V_DDR;
1554		1554
		1555	/* R1B responses is required to properly manage HW busy detection. */
		1556	host->mmc->caps \|= MMC_CAP_NEED_RSP_BUSY;
		1557
1555	tegra_sdhci_parse_dt(host);	1558	tegra_sdhci_parse_dt(host);
1556		1559
1557	tegra_host->power_gpio = devm_gpiod_get_optional(&pdev->dev, "power",	1560	tegra_host->power_gpio = devm_gpiod_get_optional(&pdev->dev, "power",

drivers/net/bonding/bond_alb.c+10−10

 };
 #pragma pack()
-static inline struct arp_pkt *arp_pkt(const struct sk_buff *skb)
-{
-	return (struct arp_pkt *)skb_network_header(skb);
-}
 /* Forward declaration */
 static void alb_send_learning_packets(struct slave *slave, u8 mac_addr[],
 				      bool strict_match);
 	spin_unlock(&bond->mode_lock);
 }
-static struct slave *rlb_choose_channel(struct sk_buff *skb, struct bonding *bond)
+static struct slave *rlb_choose_channel(struct sk_buff *skb,
+					struct bonding *bond,
+					const struct arp_pkt *arp)
 {
 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
-	struct arp_pkt *arp = arp_pkt(skb);
 	struct slave *assigned_slave, *curr_active_slave;
 	struct rlb_client_info *client_info;
 	u32 hash_index = 0;
  */
 static struct slave *rlb_arp_xmit(struct sk_buff *skb, struct bonding *bond)
 {
-	struct arp_pkt *arp = arp_pkt(skb);
 	struct slave *tx_slave = NULL;
+	struct arp_pkt *arp;
+	if (!pskb_network_may_pull(skb, sizeof(*arp)))
+		return NULL;
+	arp = (struct arp_pkt *)skb_network_header(skb);
 	/* Don't modify or load balance ARPs that do not originate locally
 	 * (e.g.,arrive via a bridge).
 	if (arp->op_code == htons(ARPOP_REPLY)) {
 		/* the arp must be sent on the selected rx channel */
-		tx_slave = rlb_choose_channel(skb, bond);
+		tx_slave = rlb_choose_channel(skb, bond, arp);
 		if (tx_slave)
 			bond_hw_addr_copy(arp->mac_src, tx_slave->dev->dev_addr,
 					  tx_slave->dev->addr_len);
 		 * When the arp reply is received the entry will be updated
 		 * with the correct unicast address of the client.
 		 */
-		tx_slave = rlb_choose_channel(skb, bond);
+		tx_slave = rlb_choose_channel(skb, bond, arp);
 		/* The ARP reply packets must be delayed so that
 		 * they can cancel out the influence of the ARP request.

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

@@ -883,6 +883,7 @@ static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = { · 882 unmodified lines
883	= { .len = sizeof(struct can_bittiming) },	883	= { .len = sizeof(struct can_bittiming) },
884	[IFLA_CAN_DATA_BITTIMING_CONST]	884	[IFLA_CAN_DATA_BITTIMING_CONST]
885	= { .len = sizeof(struct can_bittiming_const) },	885	= { .len = sizeof(struct can_bittiming_const) },
		886	[IFLA_CAN_TERMINATION] = { .type = NLA_U16 },
886	};	887	};
887		888
888	static int can_validate(struct nlattr tb[], struct nlattr data[],	889	static int can_validate(struct nlattr tb[], struct nlattr data[],

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

@@ -2769,6 +2769,8 @@ static u64 mv88e6xxx_devlink_atu_bin_get(struct mv88e6xxx_chip *chip, · 2768 unmodified lines
2769	goto unlock;	2769	goto unlock;
2770	}	2770	}
2771		2771
		2772	occupancy &= MV88E6XXX_G2_ATU_STATS_MASK;
		2773
2772	unlock:	2774	unlock:
2773	mv88e6xxx_reg_unlock(chip);	2775	mv88e6xxx_reg_unlock(chip);
2774		2776

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

 {
 	int err, irq, virq;
+	chip->g2_irq.masked = ~0;
+	mv88e6xxx_reg_lock(chip);
+	err = mv88e6xxx_g2_int_mask(chip, ~chip->g2_irq.masked);
+	mv88e6xxx_reg_unlock(chip);
+	if (err)
+		return err;
 	chip->g2_irq.domain = irq_domain_add_simple(
 		chip->dev->of_node, 16, 0, &mv88e6xxx_g2_irq_domain_ops, chip);
 	if (!chip->g2_irq.domain)
 		irq_create_mapping(chip->g2_irq.domain, irq);
 	chip->g2_irq.chip = mv88e6xxx_g2_irq_chip;
-	chip->g2_irq.masked = ~0;
 	chip->device_irq = irq_find_mapping(chip->g1_irq.domain,
 					    MV88E6XXX_G1_STS_IRQ_DEVICE);

drivers/net/dsa/sja1105/sja1105_main.c+2−1

@@ -1741,7 +1741,8 @@ static void sja1105_teardown(struct dsa_switch *ds) · 1740 unmodified lines
1741	if (!dsa_is_user_port(ds, port))	1741	if (!dsa_is_user_port(ds, port))
1742	continue;	1742	continue;
1743		1743
1744	kthread_destroy_worker(sp->xmit_worker);	1744	if (sp->xmit_worker)
		1745	kthread_destroy_worker(sp->xmit_worker);
1745	}	1746	}
1746		1747
1747	sja1105_tas_teardown(ds);	1748	sja1105_tas_teardown(ds);

drivers/net/ethernet/broadcom/bcmsysport.c+1−1

@@ -2135,7 +2135,7 @@ static int bcm_sysport_rule_set(struct bcm_sysport_priv *priv, · 2134 unmodified lines
2135	return -ENOSPC;	2135	return -ENOSPC;
2136		2136
2137	index = find_first_zero_bit(priv->filters, RXCHK_BRCM_TAG_MAX);	2137	index = find_first_zero_bit(priv->filters, RXCHK_BRCM_TAG_MAX);
2138	if (index > RXCHK_BRCM_TAG_MAX)	2138	if (index >= RXCHK_BRCM_TAG_MAX)
2139	return -ENOSPC;	2139	return -ENOSPC;
2140		2140
2141	/* Location is the classification ID, and index is the position	2141	/* Location is the classification ID, and index is the position

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

@@ -10982,13 +10982,13 @@ static int bnxt_change_mtu(struct net_device *dev, int new_mtu) · 10981 unmodified lines
10982	struct bnxt *bp = netdev_priv(dev);	10982	struct bnxt *bp = netdev_priv(dev);
10983		10983
10984	if (netif_running(dev))	10984	if (netif_running(dev))
10985	bnxt_close_nic(bp, false, false);	10985	bnxt_close_nic(bp, true, false);
10986		10986
10987	dev->mtu = new_mtu;	10987	dev->mtu = new_mtu;
10988	bnxt_set_ring_params(bp);	10988	bnxt_set_ring_params(bp);
10989		10989
10990	if (netif_running(dev))	10990	if (netif_running(dev))
10991	return bnxt_open_nic(bp, false, false);	10991	return bnxt_open_nic(bp, true, false);
10992		10992
10993	return 0;	10993	return 0;
10994	}	10994	}

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c+11−13

 	struct hwrm_nvm_install_update_output *resp = bp->hwrm_cmd_resp_addr;
 	struct hwrm_nvm_install_update_input install = {0};
 	const struct firmware *fw;
-	int rc, hwrm_err = 0;
 	u32 item_len;
+	int rc = 0;
 	u16 index;
 	bnxt_hwrm_fw_set_time(bp);
 			memcpy(kmem, fw->data, fw->size);
 			modify.host_src_addr = cpu_to_le64(dma_handle);
-			hwrm_err = hwrm_send_message(bp, &modify,
+			rc = hwrm_send_message(bp, &modify, sizeof(modify),
-						     sizeof(modify),
+					       FLASH_PACKAGE_TIMEOUT);
-						     FLASH_PACKAGE_TIMEOUT);
 			dma_free_coherent(&bp->pdev->dev, fw->size, kmem,
 					  dma_handle);
 		}
 	}
 	release_firmware(fw);
-	if (rc || hwrm_err)
+	if (rc)
 		goto err_exit;
 	if ((install_type & 0xffff) == 0)
 	install.install_type = cpu_to_le32(install_type);
 	mutex_lock(&bp->hwrm_cmd_lock);
-	hwrm_err = _hwrm_send_message(bp, &install, sizeof(install),
+	rc = _hwrm_send_message(bp, &install, sizeof(install),
-				      INSTALL_PACKAGE_TIMEOUT);
+				INSTALL_PACKAGE_TIMEOUT);
-	if (hwrm_err) {
+	if (rc) {
 		u8 error_code = ((struct hwrm_err_output *)resp)->cmd_err;
 		if (resp->error_code && error_code ==
 		    NVM_INSTALL_UPDATE_CMD_ERR_CODE_FRAG_ERR) {
 			install.flags |= cpu_to_le16(
 			       NVM_INSTALL_UPDATE_REQ_FLAGS_ALLOWED_TO_DEFRAG);
-			hwrm_err = _hwrm_send_message(bp, &install,
+			rc = _hwrm_send_message(bp, &install, sizeof(install),
-						      sizeof(install),
+						INSTALL_PACKAGE_TIMEOUT);
-						      INSTALL_PACKAGE_TIMEOUT);
 		}
-		if (hwrm_err)
+		if (rc)
 			goto flash_pkg_exit;
 	}
 flash_pkg_exit:
 	mutex_unlock(&bp->hwrm_cmd_lock);
 err_exit:
-	if (hwrm_err == -EACCES)
+	if (rc == -EACCES)
 		bnxt_print_admin_err(bp);
 	return rc;
 }

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c+27−22

 static int cfg_queues(struct adapter *adap)
 {
 	u32 avail_qsets, avail_eth_qsets, avail_uld_qsets;
+	u32 i, n10g = 0, qidx = 0, n1g = 0;
+	u32 ncpus = num_online_cpus();
 	u32 niqflint, neq, num_ulds;
 	struct sge *s = &adap->sge;
-	u32 i, n10g = 0, qidx = 0;
+	u32 q10g = 0, q1g;
-#ifndef CONFIG_CHELSIO_T4_DCB
-	int q10g = 0;
-#endif
 	/* Reduce memory usage in kdump environment, disable all offload. */
 	if (is_kdump_kernel() || (is_uld(adap) && t4_uld_mem_alloc(adap))) {
 		n10g += is_x_10g_port(&adap2pinfo(adap, i)->link_cfg);
 	avail_eth_qsets = min_t(u32, avail_qsets, MAX_ETH_QSETS);
+	/* We default to 1 queue per non-10G port and up to # of cores queues
+	 * per 10G port.
+	 */
+	if (n10g)
+		q10g = (avail_eth_qsets - (adap->params.nports - n10g)) / n10g;
+	n1g = adap->params.nports - n10g;
 #ifdef CONFIG_CHELSIO_T4_DCB
 	/* For Data Center Bridging support we need to be able to support up
 	 * to 8 Traffic Priorities; each of which will be assigned to its
 	 * own TX Queue in order to prevent Head-Of-Line Blocking.
 	 */
+	q1g = 8;
 	if (adap->params.nports * 8 > avail_eth_qsets) {
 		dev_err(adap->pdev_dev, "DCB avail_eth_qsets=%d < %d!\n",
 			avail_eth_qsets, adap->params.nports * 8);
 		return -ENOMEM;
 	}
-	for_each_port(adap, i) {
+	if (adap->params.nports * ncpus < avail_eth_qsets)
-		struct port_info *pi = adap2pinfo(adap, i);
+		q10g = max(8U, ncpus);
+	else
+		q10g = max(8U, q10g);
-		pi->first_qset = qidx;
+	while ((q10g * n10g) > (avail_eth_qsets - n1g * q1g))
-		pi->nqsets = is_kdump_kernel() ? 1 : 8;
+		q10g--;
-		qidx += pi->nqsets;
-	}
-#else /* !CONFIG_CHELSIO_T4_DCB */
-	/* We default to 1 queue per non-10G port and up to # of cores queues
-	 * per 10G port.
-	 */
-	if (n10g)
-		q10g = (avail_eth_qsets - (adap->params.nports - n10g)) / n10g;
-	if (q10g > netif_get_num_default_rss_queues())
-		q10g = netif_get_num_default_rss_queues();
-	if (is_kdump_kernel())
+#else /* !CONFIG_CHELSIO_T4_DCB */
+	q1g = 1;
+	q10g = min(q10g, ncpus);
+#endif /* !CONFIG_CHELSIO_T4_DCB */
+	if (is_kdump_kernel()) {
 		q10g = 1;
+		q1g = 1;
+	}
 	for_each_port(adap, i) {
 		struct port_info *pi = adap2pinfo(adap, i);
 		pi->first_qset = qidx;
-		pi->nqsets = is_x_10g_port(&pi->link_cfg) ? q10g : 1;
+		pi->nqsets = is_x_10g_port(&pi->link_cfg) ? q10g : q1g;
 		qidx += pi->nqsets;
 	}
-#endif /* !CONFIG_CHELSIO_T4_DCB */
 	s->ethqsets = qidx;
 	s->max_ethqsets = qidx;   /* MSI-X may lower it later */
 		 * capped by the number of available cores.
 		 */
 		num_ulds = adap->num_uld + adap->num_ofld_uld;
-		i = min_t(u32, MAX_OFLD_QSETS, num_online_cpus());
+		i = min_t(u32, MAX_OFLD_QSETS, ncpus);
 		avail_uld_qsets = roundup(i, adap->params.nports);
 		if (avail_qsets < num_ulds * adap->params.nports) {
 			adap->params.offload = 0;

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c+108−6

@@ -1,4 +1,5 @@
1	/* Copyright 2008 - 2016 Freescale Semiconductor Inc.	1	/* Copyright 2008 - 2016 Freescale Semiconductor Inc.
		2	* Copyright 2020 NXP
2	*	3	*
3	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
4	* modification, are permitted provided that the following conditions are met:	5	* modification, are permitted provided that the following conditions are met:
@@ -123,7 +124,22 @@ MODULE_PARM_DESC(tx_timeout, "The Tx timeout in ms"); · 118 unmodified lines
123	#define FSL_QMAN_MAX_OAL 127	124	#define FSL_QMAN_MAX_OAL 127
124		125
125	/* Default alignment for start of data in an Rx FD */	126	/* Default alignment for start of data in an Rx FD */
		127	#ifdef CONFIG_DPAA_ERRATUM_A050385
		128	/* aligning data start to 64 avoids DMA transaction splits, unless the buffer
		129	* is crossing a 4k page boundary
		130	*/
		131	#define DPAA_FD_DATA_ALIGNMENT (fman_has_errata_a050385() ? 64 : 16)
		132	/* aligning to 256 avoids DMA transaction splits caused by 4k page boundary
		133	* crossings; also, all SG fragments except the last must have a size multiple
		134	* of 256 to avoid DMA transaction splits
		135	*/
		136	#define DPAA_A050385_ALIGN 256
		137	#define DPAA_FD_RX_DATA_ALIGNMENT (fman_has_errata_a050385() ? \
		138	DPAA_A050385_ALIGN : 16)
		139	#else
126	#define DPAA_FD_DATA_ALIGNMENT 16	140	#define DPAA_FD_DATA_ALIGNMENT 16
		141	#define DPAA_FD_RX_DATA_ALIGNMENT DPAA_FD_DATA_ALIGNMENT
		142	#endif
127		143
128	/* The DPAA requires 256 bytes reserved and mapped for the SGT */	144	/* The DPAA requires 256 bytes reserved and mapped for the SGT */
129	#define DPAA_SGT_SIZE 256	145	#define DPAA_SGT_SIZE 256
@@ -158,8 +174,13 @@ MODULE_PARM_DESC(tx_timeout, "The Tx timeout in ms"); · 28 unmodified lines
158	#define DPAA_PARSE_RESULTS_SIZE sizeof(struct fman_prs_result)	174	#define DPAA_PARSE_RESULTS_SIZE sizeof(struct fman_prs_result)
159	#define DPAA_TIME_STAMP_SIZE 8	175	#define DPAA_TIME_STAMP_SIZE 8
160	#define DPAA_HASH_RESULTS_SIZE 8	176	#define DPAA_HASH_RESULTS_SIZE 8
		177	#ifdef CONFIG_DPAA_ERRATUM_A050385
		178	#define DPAA_RX_PRIV_DATA_SIZE (DPAA_A050385_ALIGN - (DPAA_PARSE_RESULTS_SIZE\
		179	+ DPAA_TIME_STAMP_SIZE + DPAA_HASH_RESULTS_SIZE))
		180	#else
161	#define DPAA_RX_PRIV_DATA_SIZE (u16)(DPAA_TX_PRIV_DATA_SIZE + \	181	#define DPAA_RX_PRIV_DATA_SIZE (u16)(DPAA_TX_PRIV_DATA_SIZE + \
162	dpaa_rx_extra_headroom)	182	dpaa_rx_extra_headroom)
		183	#endif
163		184
164	#define DPAA_ETH_PCD_RXQ_NUM 128	185	#define DPAA_ETH_PCD_RXQ_NUM 128
165		186
@@ -180,7 +201,12 @@ static struct dpaa_bp *dpaa_bp_array[BM_MAX_NUM_OF_POOLS]; · 14 unmodified lines
180		201
181	#define DPAA_BP_RAW_SIZE 4096	202	#define DPAA_BP_RAW_SIZE 4096
182		203
		204	#ifdef CONFIG_DPAA_ERRATUM_A050385
		205	#define dpaa_bp_size(raw_size) (SKB_WITH_OVERHEAD(raw_size) & \
		206	~(DPAA_A050385_ALIGN - 1))
		207	#else
183	#define dpaa_bp_size(raw_size) SKB_WITH_OVERHEAD(raw_size)	208	#define dpaa_bp_size(raw_size) SKB_WITH_OVERHEAD(raw_size)
		209	#endif
184		210
185	static int dpaa_max_frm;	211	static int dpaa_max_frm;
186		212
@@ -1192,7 +1218,7 @@ static int dpaa_eth_init_rx_port(struct fman_port port, struct dpaa_bp bp, · 1005 unmodified lines
1192	buf_prefix_content.pass_prs_result = true;	1218	buf_prefix_content.pass_prs_result = true;
1193	buf_prefix_content.pass_hash_result = true;	1219	buf_prefix_content.pass_hash_result = true;
1194	buf_prefix_content.pass_time_stamp = true;	1220	buf_prefix_content.pass_time_stamp = true;
1195	buf_prefix_content.data_align = DPAA_FD_DATA_ALIGNMENT;	1221	buf_prefix_content.data_align = DPAA_FD_RX_DATA_ALIGNMENT;
1196		1222
1197	rx_p = &params.specific_params.rx_params;	1223	rx_p = &params.specific_params.rx_params;
1198	rx_p->err_fqid = errq->fqid;	1224	rx_p->err_fqid = errq->fqid;
@@ -1662,6 +1688,8 @@ static u8 rx_csum_offload(const struct dpaa_priv priv, const struct qm_fd fd) · 463 unmodified lines
1662	return CHECKSUM_NONE;	1688	return CHECKSUM_NONE;
1663	}	1689	}
1664		1690
		1691	#define PTR_IS_ALIGNED(x, a) (IS_ALIGNED((unsigned long)(x), (a)))
		1692
1665	/* Build a linear skb around the received buffer.	1693	/* Build a linear skb around the received buffer.
1666	* We are guaranteed there is enough room at the end of the data buffer to	1694	* We are guaranteed there is enough room at the end of the data buffer to
1667	* accommodate the shared info area of the skb.	1695	* accommodate the shared info area of the skb.
@@ -1733,8 +1761,7 @@ static struct sk_buff sg_fd_to_skb(const struct dpaa_priv priv, · 65 unmodified lines
1733		1761
1734	sg_addr = qm_sg_addr(&sgt[i]);	1762	sg_addr = qm_sg_addr(&sgt[i]);
1735	sg_vaddr = phys_to_virt(sg_addr);	1763	sg_vaddr = phys_to_virt(sg_addr);
1736	WARN_ON(!IS_ALIGNED((unsigned long)sg_vaddr,	1764	WARN_ON(!PTR_IS_ALIGNED(sg_vaddr, SMP_CACHE_BYTES));
1737	SMP_CACHE_BYTES));
1738		1765
1739	dma_unmap_page(priv->rx_dma_dev, sg_addr,	1766	dma_unmap_page(priv->rx_dma_dev, sg_addr,
1740	DPAA_BP_RAW_SIZE, DMA_FROM_DEVICE);	1767	DPAA_BP_RAW_SIZE, DMA_FROM_DEVICE);
@@ -2022,6 +2049,75 @@ static inline int dpaa_xmit(struct dpaa_priv *priv, · 281 unmodified lines
2022	return 0;	2049	return 0;
2023	}	2050	}
2024		2051
		2052	#ifdef CONFIG_DPAA_ERRATUM_A050385
		2053	int dpaa_a050385_wa(struct net_device net_dev, struct sk_buff *s)
		2054	{
		2055	struct dpaa_priv *priv = netdev_priv(net_dev);
		2056	struct sk_buff new_skb, skb = *s;
		2057	unsigned char *start, i;
		2058
		2059	/* check linear buffer alignment */
		2060	if (!PTR_IS_ALIGNED(skb->data, DPAA_A050385_ALIGN))
		2061	goto workaround;
		2062
		2063	/* linear buffers just need to have an aligned start */
		2064	if (!skb_is_nonlinear(skb))
		2065	return 0;
		2066
		2067	/* linear data size for nonlinear skbs needs to be aligned */
		2068	if (!IS_ALIGNED(skb_headlen(skb), DPAA_A050385_ALIGN))
		2069	goto workaround;
		2070
		2071	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
		2072	skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
		2073
		2074	/* all fragments need to have aligned start addresses */
		2075	if (!IS_ALIGNED(skb_frag_off(frag), DPAA_A050385_ALIGN))
		2076	goto workaround;
		2077
		2078	/* all but last fragment need to have aligned sizes */
		2079	if (!IS_ALIGNED(skb_frag_size(frag), DPAA_A050385_ALIGN) &&
		2080	(i < skb_shinfo(skb)->nr_frags - 1))
		2081	goto workaround;
		2082	}
		2083
		2084	return 0;
		2085
		2086	workaround:
		2087	/* copy all the skb content into a new linear buffer */
		2088	new_skb = netdev_alloc_skb(net_dev, skb->len + DPAA_A050385_ALIGN - 1 +
		2089	priv->tx_headroom);
		2090	if (!new_skb)
		2091	return -ENOMEM;
		2092
		2093	/* NET_SKB_PAD bytes already reserved, adding up to tx_headroom */
		2094	skb_reserve(new_skb, priv->tx_headroom - NET_SKB_PAD);
		2095
		2096	/* Workaround for DPAA_A050385 requires data start to be aligned */
		2097	start = PTR_ALIGN(new_skb->data, DPAA_A050385_ALIGN);
		2098	if (start - new_skb->data != 0)
		2099	skb_reserve(new_skb, start - new_skb->data);
		2100
		2101	skb_put(new_skb, skb->len);
		2102	skb_copy_bits(skb, 0, new_skb->data, skb->len);
		2103	skb_copy_header(new_skb, skb);
		2104	new_skb->dev = skb->dev;
		2105
		2106	/* We move the headroom when we align it so we have to reset the
		2107	* network and transport header offsets relative to the new data
		2108	* pointer. The checksum offload relies on these offsets.
		2109	*/
		2110	skb_set_network_header(new_skb, skb_network_offset(skb));
		2111	skb_set_transport_header(new_skb, skb_transport_offset(skb));
		2112
		2113	/* TODO: does timestamping need the result in the old skb? */
		2114	dev_kfree_skb(skb);
		2115	*s = new_skb;
		2116
		2117	return 0;
		2118	}
		2119	#endif
		2120
2025	static netdev_tx_t	2121	static netdev_tx_t
2026	dpaa_start_xmit(struct sk_buff skb, struct net_device net_dev)	2122	dpaa_start_xmit(struct sk_buff skb, struct net_device net_dev)
2027	{	2123	{
@@ -2068,6 +2164,14 @@ dpaa_start_xmit(struct sk_buff skb, struct net_device net_dev) · 40 unmodified lines
2068	nonlinear = skb_is_nonlinear(skb);	2164	nonlinear = skb_is_nonlinear(skb);
2069	}	2165	}
2070		2166
		2167	#ifdef CONFIG_DPAA_ERRATUM_A050385
		2168	if (unlikely(fman_has_errata_a050385())) {
		2169	if (dpaa_a050385_wa(net_dev, &skb))
		2170	goto enomem;
		2171	nonlinear = skb_is_nonlinear(skb);
		2172	}
		2173	#endif
		2174
2071	if (nonlinear) {	2175	if (nonlinear) {
2072	/* Just create a S/G fd based on the skb */	2176	/* Just create a S/G fd based on the skb */
2073	err = skb_to_sg_fd(priv, skb, &fd);	2177	err = skb_to_sg_fd(priv, skb, &fd);
@@ -2741,9 +2845,7 @@ static inline u16 dpaa_get_headroom(struct dpaa_buffer_layout *bl) · 667 unmodified lines
2741	headroom = (u16)(bl->priv_data_size + DPAA_PARSE_RESULTS_SIZE +	2845	headroom = (u16)(bl->priv_data_size + DPAA_PARSE_RESULTS_SIZE +
2742	DPAA_TIME_STAMP_SIZE + DPAA_HASH_RESULTS_SIZE);	2846	DPAA_TIME_STAMP_SIZE + DPAA_HASH_RESULTS_SIZE);
2743		2847
2744	return DPAA_FD_DATA_ALIGNMENT ? ALIGN(headroom,	2848	return ALIGN(headroom, DPAA_FD_DATA_ALIGNMENT);
2745	DPAA_FD_DATA_ALIGNMENT) :
2746	headroom;
2747	}	2849	}
2748		2850
2749	static int dpaa_eth_probe(struct platform_device *pdev)	2851	static int dpaa_eth_probe(struct platform_device *pdev)

drivers/net/ethernet/freescale/fec_main.c+3−3

@@ -2529,15 +2529,15 @@ fec_enet_set_coalesce(struct net_device ndev, struct ethtool_coalesce ec) · 2528 unmodified lines
2529	return -EINVAL;	2529	return -EINVAL;
2530	}	2530	}
2531		2531
2532	cycle = fec_enet_us_to_itr_clock(ndev, fep->rx_time_itr);	2532	cycle = fec_enet_us_to_itr_clock(ndev, ec->rx_coalesce_usecs);
2533	if (cycle > 0xFFFF) {	2533	if (cycle > 0xFFFF) {
2534	dev_err(dev, "Rx coalesced usec exceed hardware limitation\n");	2534	dev_err(dev, "Rx coalesced usec exceed hardware limitation\n");
2535	return -EINVAL;	2535	return -EINVAL;
2536	}	2536	}
2537		2537
2538	cycle = fec_enet_us_to_itr_clock(ndev, fep->tx_time_itr);	2538	cycle = fec_enet_us_to_itr_clock(ndev, ec->tx_coalesce_usecs);
2539	if (cycle > 0xFFFF) {	2539	if (cycle > 0xFFFF) {
2540	dev_err(dev, "Rx coalesced usec exceed hardware limitation\n");	2540	dev_err(dev, "Tx coalesced usec exceed hardware limitation\n");
2541	return -EINVAL;	2541	return -EINVAL;
2542	}	2542	}
2543		2543

drivers/net/ethernet/freescale/fman/Kconfig+28−0

@@ -8,3 +8,31 @@ config FSL_FMAN · 7 unmodified lines
8	help	8	help
9	Freescale Data-Path Acceleration Architecture Frame Manager	9	Freescale Data-Path Acceleration Architecture Frame Manager
10	(FMan) support	10	(FMan) support
		11
		12	config DPAA_ERRATUM_A050385
		13	bool
		14	depends on ARM64 && FSL_DPAA
		15	default y
		16	help
		17	DPAA FMan erratum A050385 software workaround implementation:
		18	align buffers, data start, SG fragment length to avoid FMan DMA
		19	splits.
		20	FMAN DMA read or writes under heavy traffic load may cause FMAN
		21	internal resource leak thus stopping further packet processing.
		22	The FMAN internal queue can overflow when FMAN splits single
		23	read or write transactions into multiple smaller transactions
		24	such that more than 17 AXI transactions are in flight from FMAN
		25	to interconnect. When the FMAN internal queue overflows, it can
		26	stall further packet processing. The issue can occur with any
		27	one of the following three conditions:
		28	1. FMAN AXI transaction crosses 4K address boundary (Errata
		29	A010022)
		30	2. FMAN DMA address for an AXI transaction is not 16 byte
		31	aligned, i.e. the last 4 bits of an address are non-zero
		32	3. Scatter Gather (SG) frames have more than one SG buffer in
		33	the SG list and any one of the buffers, except the last
		34	buffer in the SG list has data size that is not a multiple
		35	of 16 bytes, i.e., other than 16, 32, 48, 64, etc.
		36	With any one of the above three conditions present, there is
		37	likelihood of stalled FMAN packet processing, especially under
		38	stress with multiple ports injecting line-rate traffic.

drivers/net/ethernet/freescale/fman/fman.c+18−0

 /*
  * Copyright 2008-2015 Freescale Semiconductor Inc.
+ * Copyright 2020 NXP
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
 	u32 qmi_def_tnums_thresh;
 };
+#ifdef CONFIG_DPAA_ERRATUM_A050385
+static bool fman_has_err_a050385;
+#endif
 static irqreturn_t fman_exceptions(struct fman *fman,
 				   enum fman_exceptions exception)
 {
 }
 EXPORT_SYMBOL(fman_bind);
+#ifdef CONFIG_DPAA_ERRATUM_A050385
+bool fman_has_errata_a050385(void)
+{
+	return fman_has_err_a050385;
+}
+EXPORT_SYMBOL(fman_has_errata_a050385);
+#endif
 static irqreturn_t fman_err_irq(int irq, void *handle)
 {
 	struct fman *fman = (struct fman *)handle;
 		goto fman_free;
 	}
+#ifdef CONFIG_DPAA_ERRATUM_A050385
+	fman_has_err_a050385 =
+		of_property_read_bool(fm_node, "fsl,erratum-a050385");
+#endif
 	return fman;
 fman_node_put:

drivers/net/ethernet/freescale/fman/fman.h+5−0

 /*
  * Copyright 2008-2015 Freescale Semiconductor Inc.
+ * Copyright 2020 NXP
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
 int fman_get_rx_extra_headroom(void);
+#ifdef CONFIG_DPAA_ERRATUM_A050385
+bool fman_has_errata_a050385(void);
+#endif
 struct fman *fman_bind(struct device *dev);
 #endif /* __FM_H */

drivers/net/ethernet/hisilicon/hns3/hclge_mbx.h+1−0

@@ -46,6 +46,7 @@ enum HCLGE_MBX_OPCODE { · 45 unmodified lines
46	HCLGE_MBX_PUSH_VLAN_INFO, /* (PF -> VF) push port base vlan */	46	HCLGE_MBX_PUSH_VLAN_INFO, /* (PF -> VF) push port base vlan */
47	HCLGE_MBX_GET_MEDIA_TYPE, /* (VF -> PF) get media type */	47	HCLGE_MBX_GET_MEDIA_TYPE, /* (VF -> PF) get media type */
48	HCLGE_MBX_PUSH_PROMISC_INFO, /* (PF -> VF) push vf promisc info */	48	HCLGE_MBX_PUSH_PROMISC_INFO, /* (PF -> VF) push vf promisc info */
		49	HCLGE_MBX_VF_UNINIT, /* (VF -> PF) vf is unintializing */
49		50
50	HCLGE_MBX_GET_VF_FLR_STATUS = 200, /* (M7 -> PF) get vf flr status */	51	HCLGE_MBX_GET_VF_FLR_STATUS = 200, /* (M7 -> PF) get vf flr status */
51	HCLGE_MBX_PUSH_LINK_STATUS, /* (M7 -> PF) get port link status */	52	HCLGE_MBX_PUSH_LINK_STATUS, /* (M7 -> PF) get port link status */

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c+1−1

@@ -1711,7 +1711,7 @@ static int hns3_setup_tc(struct net_device netdev, void type_data) · 1710 unmodified lines
1711	netif_dbg(h, drv, netdev, "setup tc: num_tc=%u\n", tc);	1711	netif_dbg(h, drv, netdev, "setup tc: num_tc=%u\n", tc);
1712		1712
1713	return (kinfo->dcb_ops && kinfo->dcb_ops->setup_tc) ?	1713	return (kinfo->dcb_ops && kinfo->dcb_ops->setup_tc) ?
1714	kinfo->dcb_ops->setup_tc(h, tc, prio_tc) : -EOPNOTSUPP;	1714	kinfo->dcb_ops->setup_tc(h, tc ? tc : 1, prio_tc) : -EOPNOTSUPP;
1715	}	1715	}
1716		1716
1717	static int hns3_nic_setup_tc(struct net_device *dev, enum tc_setup_type type,	1717	static int hns3_nic_setup_tc(struct net_device *dev, enum tc_setup_type type,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c+42−5

@@ -2446,10 +2446,12 @@ static int hclge_cfg_mac_speed_dup_hw(struct hclge_dev *hdev, int speed, · 2445 unmodified lines
2446		2446
2447	int hclge_cfg_mac_speed_dup(struct hclge_dev *hdev, int speed, u8 duplex)	2447	int hclge_cfg_mac_speed_dup(struct hclge_dev *hdev, int speed, u8 duplex)
2448	{	2448	{
		2449	struct hclge_mac *mac = &hdev->hw.mac;
2449	int ret;	2450	int ret;
2450		2451
2451	duplex = hclge_check_speed_dup(duplex, speed);	2452	duplex = hclge_check_speed_dup(duplex, speed);
2452	if (hdev->hw.mac.speed == speed && hdev->hw.mac.duplex == duplex)	2453	if (!mac->support_autoneg && mac->speed == speed &&
		2454	mac->duplex == duplex)
2453	return 0;	2455	return 0;
2454		2456
2455	ret = hclge_cfg_mac_speed_dup_hw(hdev, speed, duplex);	2457	ret = hclge_cfg_mac_speed_dup_hw(hdev, speed, duplex);
@@ -7743,16 +7745,27 @@ static int hclge_set_vlan_filter_ctrl(struct hclge_dev *hdev, u8 vlan_type, · 5287 unmodified lines
7743	struct hclge_desc desc;	7745	struct hclge_desc desc;
7744	int ret;	7746	int ret;
7745		7747
7746	hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_VLAN_FILTER_CTRL, false);	7748	/* read current vlan filter parameter */
7747		7749	hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_VLAN_FILTER_CTRL, true);
7748	req = (struct hclge_vlan_filter_ctrl_cmd *)desc.data;	7750	req = (struct hclge_vlan_filter_ctrl_cmd *)desc.data;
7749	req->vlan_type = vlan_type;	7751	req->vlan_type = vlan_type;
7750	req->vlan_fe = filter_en ? fe_type : 0;
7751	req->vf_id = vf_id;	7752	req->vf_id = vf_id;
7752		7753
		7754	ret = hclge_cmd_send(&hdev->hw, &desc, 1);
		7755	if (ret) {
		7756	dev_err(&hdev->pdev->dev,
		7757	"failed to get vlan filter config, ret = %d.\n", ret);
		7758	return ret;
		7759	}
		7760
		7761	/* modify and write new config parameter */
		7762	hclge_cmd_reuse_desc(&desc, false);
		7763	req->vlan_fe = filter_en ?
		7764	(req->vlan_fe \| fe_type) : (req->vlan_fe & ~fe_type);
		7765
7753	ret = hclge_cmd_send(&hdev->hw, &desc, 1);	7766	ret = hclge_cmd_send(&hdev->hw, &desc, 1);
7754	if (ret)	7767	if (ret)
7755	dev_err(&hdev->pdev->dev, "set vlan filter fail, ret =%d.\n",	7768	dev_err(&hdev->pdev->dev, "failed to set vlan filter, ret = %d.\n",
7756	ret);	7769	ret);
7757		7770
7758	return ret;	7771	return ret;
@@ -8270,6 +8283,7 @@ void hclge_rm_vport_all_vlan_table(struct hclge_vport *vport, bool is_del_list) · 511 unmodified lines
8270	kfree(vlan);	8283	kfree(vlan);
8271	}	8284	}
8272	}	8285	}
		8286	clear_bit(vport->vport_id, hdev->vf_vlan_full);
8273	}	8287	}
8274		8288
8275	void hclge_uninit_vport_vlan_table(struct hclge_dev *hdev)	8289	void hclge_uninit_vport_vlan_table(struct hclge_dev *hdev)
@@ -8486,6 +8500,28 @@ static int hclge_set_vf_vlan_filter(struct hnae3_handle *handle, int vfid, · 210 unmodified lines
8486	}	8500	}
8487	}	8501	}
8488		8502
		8503	static void hclge_clear_vf_vlan(struct hclge_dev *hdev)
		8504	{
		8505	struct hclge_vlan_info *vlan_info;
		8506	struct hclge_vport *vport;
		8507	int ret;
		8508	int vf;
		8509
		8510	/* clear port base vlan for all vf */
		8511	for (vf = HCLGE_VF_VPORT_START_NUM; vf < hdev->num_alloc_vport; vf++) {
		8512	vport = &hdev->vport[vf];
		8513	vlan_info = &vport->port_base_vlan_cfg.vlan_info;
		8514
		8515	ret = hclge_set_vlan_filter_hw(hdev, htons(ETH_P_8021Q),
		8516	vport->vport_id,
		8517	vlan_info->vlan_tag, true);
		8518	if (ret)
		8519	dev_err(&hdev->pdev->dev,
		8520	"failed to clear vf vlan for vf%d, ret = %d\n",
		8521	vf - HCLGE_VF_VPORT_START_NUM, ret);
		8522	}
		8523	}
		8524
8489	int hclge_set_vlan_filter(struct hnae3_handle *handle, __be16 proto,	8525	int hclge_set_vlan_filter(struct hnae3_handle *handle, __be16 proto,
8490	u16 vlan_id, bool is_kill)	8526	u16 vlan_id, bool is_kill)
8491	{	8527	{
@@ -9895,6 +9931,7 @@ static void hclge_uninit_ae_dev(struct hnae3_ae_dev *ae_dev) · 1403 unmodified lines
9895	struct hclge_mac *mac = &hdev->hw.mac;	9931	struct hclge_mac *mac = &hdev->hw.mac;
9896		9932
9897	hclge_reset_vf_rate(hdev);	9933	hclge_reset_vf_rate(hdev);
		9934	hclge_clear_vf_vlan(hdev);
9898	hclge_misc_affinity_teardown(hdev);	9935	hclge_misc_affinity_teardown(hdev);
9899	hclge_state_uninit(hdev);	9936	hclge_state_uninit(hdev);
9900		9937

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c+1−0

@@ -799,6 +799,7 @@ void hclge_mbx_handler(struct hclge_dev *hdev) · 798 unmodified lines
799	hclge_get_link_mode(vport, req);	799	hclge_get_link_mode(vport, req);
800	break;	800	break;
801	case HCLGE_MBX_GET_VF_FLR_STATUS:	801	case HCLGE_MBX_GET_VF_FLR_STATUS:
		802	case HCLGE_MBX_VF_UNINIT:
802	hclge_rm_vport_all_mac_table(vport, true,	803	hclge_rm_vport_all_mac_table(vport, true,
803	HCLGE_MAC_ADDR_UC);	804	HCLGE_MAC_ADDR_UC);
804	hclge_rm_vport_all_mac_table(vport, true,	805	hclge_rm_vport_all_mac_table(vport, true,

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c+3−0

@@ -2803,6 +2803,9 @@ static void hclgevf_uninit_hdev(struct hclgevf_dev *hdev) · 2802 unmodified lines
2803	{	2803	{
2804	hclgevf_state_uninit(hdev);	2804	hclgevf_state_uninit(hdev);
2805		2805
		2806	hclgevf_send_mbx_msg(hdev, HCLGE_MBX_VF_UNINIT, 0, NULL, 0,
		2807	false, NULL, 0);
		2808
2806	if (test_bit(HCLGEVF_STATE_IRQ_INITED, &hdev->state)) {	2809	if (test_bit(HCLGEVF_STATE_IRQ_INITED, &hdev->state)) {
2807	hclgevf_misc_irq_uninit(hdev);	2810	hclgevf_misc_irq_uninit(hdev);
2808	hclgevf_uninit_msi(hdev);	2811	hclgevf_uninit_msi(hdev);

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

 {
 	struct ibmvnic_rwi *rwi;
 	struct ibmvnic_adapter *adapter;
+	bool saved_state = false;
+	unsigned long flags;
 	u32 reset_state;
 	int rc = 0;
 		return;
 	}
-	reset_state = adapter->state;
 	rwi = get_next_rwi(adapter);
 	while (rwi) {
+		spin_lock_irqsave(&adapter->state_lock, flags);
 		if (adapter->state == VNIC_REMOVING ||
 		    adapter->state == VNIC_REMOVED) {
+			spin_unlock_irqrestore(&adapter->state_lock, flags);
 			kfree(rwi);
 			rc = EBUSY;
 			break;
 		}
+		if (!saved_state) {
+			reset_state = adapter->state;
+			adapter->state = VNIC_RESETTING;
+			saved_state = true;
+		}
+		spin_unlock_irqrestore(&adapter->state_lock, flags);
 		if (rwi->reset_reason == VNIC_RESET_CHANGE_PARAM) {
 			/* CHANGE_PARAM requestor holds rtnl_lock */
 			rc = do_change_param_reset(adapter, rwi, reset_state);
 			  __ibmvnic_delayed_reset);
 	INIT_LIST_HEAD(&adapter->rwi_list);
 	spin_lock_init(&adapter->rwi_lock);
+	spin_lock_init(&adapter->state_lock);
 	mutex_init(&adapter->fw_lock);
 	init_completion(&adapter->init_done);
 	init_completion(&adapter->fw_done);
 {
 	struct net_device *netdev = dev_get_drvdata(&dev->dev);
 	struct ibmvnic_adapter *adapter = netdev_priv(netdev);
+	unsigned long flags;
+	spin_lock_irqsave(&adapter->state_lock, flags);
+	if (adapter->state == VNIC_RESETTING) {
+		spin_unlock_irqrestore(&adapter->state_lock, flags);
+		return -EBUSY;
+	}
 	adapter->state = VNIC_REMOVING;
+	spin_unlock_irqrestore(&adapter->state_lock, flags);
 	rtnl_lock();
 	unregister_netdevice(netdev);

drivers/net/ethernet/ibm/ibmvnic.h+5−1

 		 VNIC_CLOSING,
 		 VNIC_CLOSED,
 		 VNIC_REMOVING,
-		 VNIC_REMOVED};
+		 VNIC_REMOVED,
+		 VNIC_RESETTING};
 enum ibmvnic_reset_reason {VNIC_RESET_FAILOVER = 1,
 			   VNIC_RESET_MOBILITY,
 	struct ibmvnic_tunables desired;
 	struct ibmvnic_tunables fallback;
+	/* Used for serializatin of state field */
+	spinlock_t state_lock;
 };

drivers/net/ethernet/marvell/mvmdio.c+3−3

@@ -347,7 +347,7 @@ static int orion_mdio_probe(struct platform_device *pdev) · 346 unmodified lines
347	}	347	}
348		348
349		349
350	dev->err_interrupt = platform_get_irq(pdev, 0);	350	dev->err_interrupt = platform_get_irq_optional(pdev, 0);
351	if (dev->err_interrupt > 0 &&	351	if (dev->err_interrupt > 0 &&
352	resource_size(r) < MVMDIO_ERR_INT_MASK + 4) {	352	resource_size(r) < MVMDIO_ERR_INT_MASK + 4) {
353	dev_err(&pdev->dev,	353	dev_err(&pdev->dev,
@@ -364,8 +364,8 @@ static int orion_mdio_probe(struct platform_device *pdev) · 10 unmodified lines
364	writel(MVMDIO_ERR_INT_SMI_DONE,	364	writel(MVMDIO_ERR_INT_SMI_DONE,
365	dev->regs + MVMDIO_ERR_INT_MASK);	365	dev->regs + MVMDIO_ERR_INT_MASK);
366		366
367	} else if (dev->err_interrupt == -EPROBE_DEFER) {	367	} else if (dev->err_interrupt < 0) {
368	ret = -EPROBE_DEFER;	368	ret = dev->err_interrupt;
369	goto out_mdio;	369	goto out_mdio;
370	}	370	}
371		371

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

 	return 0;
 }
-static void ocelot_port_set_mtu(struct ocelot *ocelot, int port, size_t mtu)
+/* Configure the maximum SDU (L2 payload) on RX to the value specified in @sdu.
+ * The length of VLAN tags is accounted for automatically via DEV_MAC_TAGS_CFG.
+ */
+static void ocelot_port_set_maxlen(struct ocelot *ocelot, int port, size_t sdu)
 {
 	struct ocelot_port *ocelot_port = ocelot->ports[port];
+	int maxlen = sdu + ETH_HLEN + ETH_FCS_LEN;
 	int atop_wm;
-	ocelot_port_writel(ocelot_port, mtu, DEV_MAC_MAXLEN_CFG);
+	ocelot_port_writel(ocelot_port, maxlen, DEV_MAC_MAXLEN_CFG);
 	/* Set Pause WM hysteresis
-	 * 152 = 6 * mtu / OCELOT_BUFFER_CELL_SZ
+	 * 152 = 6 * maxlen / OCELOT_BUFFER_CELL_SZ
-	 * 101 = 4 * mtu / OCELOT_BUFFER_CELL_SZ
+	 * 101 = 4 * maxlen / OCELOT_BUFFER_CELL_SZ
 	 */
 	ocelot_write_rix(ocelot, SYS_PAUSE_CFG_PAUSE_ENA |
 			 SYS_PAUSE_CFG_PAUSE_STOP(101) |
 			 SYS_PAUSE_CFG_PAUSE_START(152), SYS_PAUSE_CFG, port);
 	/* Tail dropping watermark */
-	atop_wm = (ocelot->shared_queue_sz - 9 * mtu) / OCELOT_BUFFER_CELL_SZ;
+	atop_wm = (ocelot->shared_queue_sz - 9 * maxlen) /
-	ocelot_write_rix(ocelot, ocelot_wm_enc(9 * mtu),
+		   OCELOT_BUFFER_CELL_SZ;
+	ocelot_write_rix(ocelot, ocelot_wm_enc(9 * maxlen),
 			 SYS_ATOP, port);
 	ocelot_write(ocelot, ocelot_wm_enc(atop_wm), SYS_ATOP_TOT_CFG);
 }
 			   DEV_MAC_HDX_CFG);
 	/* Set Max Length and maximum tags allowed */
-	ocelot_port_set_mtu(ocelot, port, VLAN_ETH_FRAME_LEN);
+	ocelot_port_set_maxlen(ocelot, port, ETH_DATA_LEN);
 	ocelot_port_writel(ocelot_port, DEV_MAC_TAGS_CFG_TAG_ID(ETH_P_8021AD) |
 			   DEV_MAC_TAGS_CFG_VLAN_AWR_ENA |
+			   DEV_MAC_TAGS_CFG_VLAN_DBL_AWR_ENA |
 			   DEV_MAC_TAGS_CFG_VLAN_LEN_AWR_ENA,
 			   DEV_MAC_TAGS_CFG);
 	 * Only one port can be an NPI at the same time.
 	 */
 	if (cpu < ocelot->num_phys_ports) {
-		int mtu = VLAN_ETH_FRAME_LEN + OCELOT_TAG_LEN;
+		int sdu = ETH_DATA_LEN + OCELOT_TAG_LEN;
 		ocelot_write(ocelot, QSYS_EXT_CPU_CFG_EXT_CPUQ_MSK_M |
 			     QSYS_EXT_CPU_CFG_EXT_CPU_PORT(cpu),
 			     QSYS_EXT_CPU_CFG);
 		if (injection == OCELOT_TAG_PREFIX_SHORT)
-			mtu += OCELOT_SHORT_PREFIX_LEN;
+			sdu += OCELOT_SHORT_PREFIX_LEN;
 		else if (injection == OCELOT_TAG_PREFIX_LONG)
-			mtu += OCELOT_LONG_PREFIX_LEN;
+			sdu += OCELOT_LONG_PREFIX_LEN;
-		ocelot_port_set_mtu(ocelot, cpu, mtu);
+		ocelot_port_set_maxlen(ocelot, cpu, sdu);
 	}
 	/* CPU port Injection/Extraction configuration */

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

@@ -1688,7 +1688,7 @@ static int ionic_set_vf_mac(struct net_device netdev, int vf, u8 mac) · 1687 unmodified lines
1688	if (!(is_zero_ether_addr(mac) \|\| is_valid_ether_addr(mac)))	1688	if (!(is_zero_ether_addr(mac) \|\| is_valid_ether_addr(mac)))
1689	return -EINVAL;	1689	return -EINVAL;
1690		1690
1691	down_read(&ionic->vf_op_lock);	1691	down_write(&ionic->vf_op_lock);
1692		1692
1693	if (vf >= pci_num_vf(ionic->pdev) \|\| !ionic->vfs) {	1693	if (vf >= pci_num_vf(ionic->pdev) \|\| !ionic->vfs) {
1694	ret = -EINVAL;	1694	ret = -EINVAL;
@@ -1698,7 +1698,7 @@ static int ionic_set_vf_mac(struct net_device netdev, int vf, u8 mac) · 3 unmodified lines
1698	ether_addr_copy(ionic->vfs[vf].macaddr, mac);	1698	ether_addr_copy(ionic->vfs[vf].macaddr, mac);
1699	}	1699	}
1700		1700
1701	up_read(&ionic->vf_op_lock);	1701	up_write(&ionic->vf_op_lock);
1702	return ret;	1702	return ret;
1703	}	1703	}
1704		1704
@@ -1719,7 +1719,7 @@ static int ionic_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, · 14 unmodified lines
1719	if (proto != htons(ETH_P_8021Q))	1719	if (proto != htons(ETH_P_8021Q))
1720	return -EPROTONOSUPPORT;	1720	return -EPROTONOSUPPORT;
1721		1721
1722	down_read(&ionic->vf_op_lock);	1722	down_write(&ionic->vf_op_lock);
1723		1723
1724	if (vf >= pci_num_vf(ionic->pdev) \|\| !ionic->vfs) {	1724	if (vf >= pci_num_vf(ionic->pdev) \|\| !ionic->vfs) {
1725	ret = -EINVAL;	1725	ret = -EINVAL;
@@ -1730,7 +1730,7 @@ static int ionic_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, · 4 unmodified lines
1730	ionic->vfs[vf].vlanid = vlan;	1730	ionic->vfs[vf].vlanid = vlan;
1731	}	1731	}
1732		1732
1733	up_read(&ionic->vf_op_lock);	1733	up_write(&ionic->vf_op_lock);
1734	return ret;	1734	return ret;
1735	}	1735	}
1736		1736

drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c+1−1

@@ -2277,7 +2277,7 @@ static int __init sxgbe_cmdline_opt(char *str) · 2276 unmodified lines
2277	if (!str \|\| !*str)	2277	if (!str \|\| !*str)
2278	return -EINVAL;	2278	return -EINVAL;
2279	while ((opt = strsep(&str, ",")) != NULL) {	2279	while ((opt = strsep(&str, ",")) != NULL) {
2280	if (!strncmp(opt, "eee_timer:", 6)) {	2280	if (!strncmp(opt, "eee_timer:", 10)) {
2281	if (kstrtoint(opt + 10, 0, &eee_timer))	2281	if (kstrtoint(opt + 10, 0, &eee_timer))
2282	goto err;	2282	goto err;
2283	}	2283	}

drivers/net/ethernet/sfc/ef10.c+17−15

 	}
 	/* Transmit timestamps are only available for 8XXX series. They result
-	 * in three events per packet. These occur in order, and are:
+	 * in up to three events per packet. These occur in order, and are:
-	 *  - the normal completion event
+	 *  - the normal completion event (may be omitted)
 	 *  - the low part of the timestamp
 	 *  - the high part of the timestamp
 	 *
+	 * It's possible for multiple completion events to appear before the
+	 * corresponding timestamps. So we can for example get:
+	 *  COMP N
+	 *  COMP N+1
+	 *  TS_LO N
+	 *  TS_HI N
+	 *  TS_LO N+1
+	 *  TS_HI N+1
+	 *
+	 * In addition it's also possible for the adjacent completions to be
+	 * merged, so we may not see COMP N above. As such, the completion
+	 * events are not very useful here.
+	 *
 	 * Each part of the timestamp is itself split across two 16 bit
 	 * fields in the event.
 	 */
 	switch (tx_ev_type) {
 	case TX_TIMESTAMP_EVENT_TX_EV_COMPLETION:
-		/* In case of Queue flush or FLR, we might have received
+		/* Ignore this event - see above. */
-		 * the previous TX completion event but not the Timestamp
-		 * events.
-		 */
-		if (tx_queue->completed_desc_ptr != tx_queue->ptr_mask)
-			efx_xmit_done(tx_queue, tx_queue->completed_desc_ptr);
-		tx_ev_desc_ptr = EFX_QWORD_FIELD(*event,
-						 ESF_DZ_TX_DESCR_INDX);
-		tx_queue->completed_desc_ptr =
-					tx_ev_desc_ptr & tx_queue->ptr_mask;
 		break;
 	case TX_TIMESTAMP_EVENT_TX_EV_TSTAMP_LO:
 		ts_part = efx_ef10_extract_event_ts(event);
 		tx_queue->completed_timestamp_major = ts_part;
-		efx_xmit_done(tx_queue, tx_queue->completed_desc_ptr);
+		efx_xmit_done_single(tx_queue);
-		tx_queue->completed_desc_ptr = tx_queue->ptr_mask;
 		break;
 	default:

drivers/net/ethernet/sfc/efx.h+1−0

@@ -20,6 +20,7 @@ netdev_tx_t efx_hard_start_xmit(struct sk_buff *skb, · 19 unmodified lines
20	struct net_device *net_dev);	20	struct net_device *net_dev);
21	netdev_tx_t efx_enqueue_skb(struct efx_tx_queue tx_queue, struct sk_buff skb);	21	netdev_tx_t efx_enqueue_skb(struct efx_tx_queue tx_queue, struct sk_buff skb);
22	void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index);	22	void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index);
		23	void efx_xmit_done_single(struct efx_tx_queue *tx_queue);
23	int efx_setup_tc(struct net_device *net_dev, enum tc_setup_type type,	24	int efx_setup_tc(struct net_device *net_dev, enum tc_setup_type type,
24	void *type_data);	25	void *type_data);
25	extern unsigned int efx_piobuf_size;	26	extern unsigned int efx_piobuf_size;

drivers/net/ethernet/sfc/efx_channels.c+1−0

@@ -583,6 +583,7 @@ struct efx_channel efx_copy_channel(const struct efx_channel old_channel) · 582 unmodified lines
583	if (tx_queue->channel)	583	if (tx_queue->channel)
584	tx_queue->channel = channel;	584	tx_queue->channel = channel;
585	tx_queue->buffer = NULL;	585	tx_queue->buffer = NULL;
		586	tx_queue->cb_page = NULL;
586	memset(&tx_queue->txd, 0, sizeof(tx_queue->txd));	587	memset(&tx_queue->txd, 0, sizeof(tx_queue->txd));
587	}	588	}
588		589

drivers/net/ethernet/sfc/net_driver.h+0−3

  *	avoid cache-line ping-pong between the xmit path and the
  *	completion path.
  * @merge_events: Number of TX merged completion events
- * @completed_desc_ptr: Most recent completed pointer - only used with
- *      timestamping.
  * @completed_timestamp_major: Top part of the most recent tx timestamp.
  * @completed_timestamp_minor: Low part of the most recent tx timestamp.
  * @insert_count: Current insert pointer
 	unsigned int merge_events;
 	unsigned int bytes_compl;
 	unsigned int pkts_compl;
-	unsigned int completed_desc_ptr;
 	u32 completed_timestamp_major;
 	u32 completed_timestamp_minor;

drivers/net/ethernet/sfc/tx.c+38−0

@@ -535,6 +535,44 @@ netdev_tx_t efx_hard_start_xmit(struct sk_buff *skb, · 534 unmodified lines
535	return efx_enqueue_skb(tx_queue, skb);	535	return efx_enqueue_skb(tx_queue, skb);
536	}	536	}
537		537
		538	void efx_xmit_done_single(struct efx_tx_queue *tx_queue)
		539	{
		540	unsigned int pkts_compl = 0, bytes_compl = 0;
		541	unsigned int read_ptr;
		542	bool finished = false;
		543
		544	read_ptr = tx_queue->read_count & tx_queue->ptr_mask;
		545
		546	while (!finished) {
		547	struct efx_tx_buffer *buffer = &tx_queue->buffer[read_ptr];
		548
		549	if (!efx_tx_buffer_in_use(buffer)) {
		550	struct efx_nic *efx = tx_queue->efx;
		551
		552	netif_err(efx, hw, efx->net_dev,
		553	"TX queue %d spurious single TX completion\n",
		554	tx_queue->queue);
		555	efx_schedule_reset(efx, RESET_TYPE_TX_SKIP);
		556	return;
		557	}
		558
		559	/* Need to check the flag before dequeueing. */
		560	if (buffer->flags & EFX_TX_BUF_SKB)
		561	finished = true;
		562	efx_dequeue_buffer(tx_queue, buffer, &pkts_compl, &bytes_compl);
		563
		564	++tx_queue->read_count;
		565	read_ptr = tx_queue->read_count & tx_queue->ptr_mask;
		566	}
		567
		568	tx_queue->pkts_compl += pkts_compl;
		569	tx_queue->bytes_compl += bytes_compl;
		570
		571	EFX_WARN_ON_PARANOID(pkts_compl != 1);
		572
		573	efx_xmit_done_check_empty(tx_queue);
		574	}
		575
538	void efx_init_tx_queue_core_txq(struct efx_tx_queue *tx_queue)	576	void efx_init_tx_queue_core_txq(struct efx_tx_queue *tx_queue)
539	{	577	{
540	struct efx_nic *efx = tx_queue->efx;	578	struct efx_nic *efx = tx_queue->efx;

drivers/net/ethernet/sfc/tx_common.c+16−13

 	tx_queue->xmit_more_available = false;
 	tx_queue->timestamping = (efx_ptp_use_mac_tx_timestamps(efx) &&
 				  tx_queue->channel == efx_ptp_channel(efx));
-	tx_queue->completed_desc_ptr = tx_queue->ptr_mask;
 	tx_queue->completed_timestamp_major = 0;
 	tx_queue->completed_timestamp_minor = 0;
 	while (read_ptr != stop_index) {
 		struct efx_tx_buffer *buffer = &tx_queue->buffer[read_ptr];
-		if (!(buffer->flags & EFX_TX_BUF_OPTION) &&
+		if (!efx_tx_buffer_in_use(buffer)) {
-		    unlikely(buffer->len == 0)) {
 			netif_err(efx, tx_err, efx->net_dev,
-				  "TX queue %d spurious TX completion id %x\n",
+				  "TX queue %d spurious TX completion id %d\n",
 				  tx_queue->queue, read_ptr);
 			efx_schedule_reset(efx, RESET_TYPE_TX_SKIP);
 			return;
 	}
 }
+void efx_xmit_done_check_empty(struct efx_tx_queue *tx_queue)
+{
+	if ((int)(tx_queue->read_count - tx_queue->old_write_count) >= 0) {
+		tx_queue->old_write_count = READ_ONCE(tx_queue->write_count);
+		if (tx_queue->read_count == tx_queue->old_write_count) {
+			/* Ensure that read_count is flushed. */
+			smp_mb();
+			tx_queue->empty_read_count =
+				tx_queue->read_count | EFX_EMPTY_COUNT_VALID;
+		}
+	}
+}
 void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index)
 {
 	unsigned int fill_level, pkts_compl = 0, bytes_compl = 0;
 			netif_tx_wake_queue(tx_queue->core_txq);
 	}
-	/* Check whether the hardware queue is now empty */
+	efx_xmit_done_check_empty(tx_queue);
-	if ((int)(tx_queue->read_count - tx_queue->old_write_count) >= 0) {
-		tx_queue->old_write_count = READ_ONCE(tx_queue->write_count);
-		if (tx_queue->read_count == tx_queue->old_write_count) {
-			smp_mb();
-			tx_queue->empty_read_count =
-				tx_queue->read_count | EFX_EMPTY_COUNT_VALID;
-		}
-	}
 }
 /* Remove buffers put into a tx_queue for the current packet.

drivers/net/ethernet/sfc/tx_common.h+6−0

 			unsigned int *pkts_compl,
 			unsigned int *bytes_compl);
+static inline bool efx_tx_buffer_in_use(struct efx_tx_buffer *buffer)
+{
+	return buffer->len || (buffer->flags & EFX_TX_BUF_OPTION);
+}
+void efx_xmit_done_check_empty(struct efx_tx_queue *tx_queue);
 void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index);
 void efx_enqueue_unwind(struct efx_tx_queue *tx_queue,

drivers/net/ethernet/stmicro/stmmac/dwmac1000_core.c+2−1

 static void dwmac1000_core_init(struct mac_device_info *hw,
 				struct net_device *dev)
 {
+	struct stmmac_priv *priv = netdev_priv(dev);
 	void __iomem *ioaddr = hw->pcsr;
 	u32 value = readl(ioaddr + GMAC_CONTROL);
 	int mtu = dev->mtu;
 	 * Broadcom tags can look like invalid LLC/SNAP packets and cause the
 	 * hardware to truncate packets on reception.
 	 */
-	if (netdev_uses_dsa(dev))
+	if (netdev_uses_dsa(dev) || !priv->plat->enh_desc)
 		value &= ~GMAC_CONTROL_ACS;
 	if (mtu > 1500)

drivers/net/ipvlan/ipvlan_core.c+11−8

 		}
 		if (dev)
 			dev_put(dev);
+		cond_resched();
 	}
 }
 	struct ethhdr *ethh = eth_hdr(skb);
 	int ret = NET_XMIT_DROP;
-	/* In this mode we dont care about multicast and broadcast traffic */
-	if (is_multicast_ether_addr(ethh->h_dest)) {
-		pr_debug_ratelimited("Dropped {multi|broad}cast of type=[%x]\n",
-				     ntohs(skb->protocol));
-		kfree_skb(skb);
-		goto out;
-	}
 	/* The ipvlan is a pseudo-L2 device, so the packets that we receive
 	 * will have L2; which need to discarded and processed further
 	 * in the net-ns of the main-device.
 	 */
 	if (skb_mac_header_was_set(skb)) {
+		/* In this mode we dont care about
+		 * multicast and broadcast traffic */
+		if (is_multicast_ether_addr(ethh->h_dest)) {
+			pr_debug_ratelimited(
+				"Dropped {multi|broad}cast of type=[%x]\n",
+				ntohs(skb->protocol));
+			kfree_skb(skb);
+			goto out;
+		}
 		skb_pull(skb, sizeof(*ethh));
 		skb->mac_header = (typeof(skb->mac_header))~0U;
 		skb_reset_network_header(skb);

drivers/net/ipvlan/ipvlan_main.c+1−4

 static int ipvlan_open(struct net_device *dev)
 {
 	struct ipvl_dev *ipvlan = netdev_priv(dev);
-	struct net_device *phy_dev = ipvlan->phy_dev;
 	struct ipvl_addr *addr;
 	if (ipvlan->port->mode == IPVLAN_MODE_L3 ||
 		ipvlan_ht_addr_add(ipvlan, addr);
 	rcu_read_unlock();
-	return dev_uc_add(phy_dev, phy_dev->dev_addr);
+	return 0;
 }
 static int ipvlan_stop(struct net_device *dev)
 	dev_uc_unsync(phy_dev, dev);
 	dev_mc_unsync(phy_dev, dev);
-	dev_uc_del(phy_dev, phy_dev->dev_addr);
 	rcu_read_lock();
 	list_for_each_entry_rcu(addr, &ipvlan->addrs, anode)
 		ipvlan_ht_addr_del(addr);

drivers/net/macsec.c+20−5

 	return (struct macsec_eth_header *)skb_mac_header(skb);
 }
+static sci_t dev_to_sci(struct net_device *dev, __be16 port)
+{
+	return make_sci(dev->dev_addr, port);
+}
 static void __macsec_pn_wrapped(struct macsec_secy *secy,
 				struct macsec_tx_sa *tx_sa)
 {
 out:
 	ether_addr_copy(dev->dev_addr, addr->sa_data);
+	macsec->secy.sci = dev_to_sci(dev, MACSEC_PORT_ES);
+	/* If h/w offloading is available, propagate to the device */
+	if (macsec_is_offloaded(macsec)) {
+		const struct macsec_ops *ops;
+		struct macsec_context ctx;
+		ops = macsec_get_ops(macsec, &ctx);
+		if (ops) {
+			ctx.secy = &macsec->secy;
+			macsec_offload(ops->mdo_upd_secy, &ctx);
+		}
+	}
 	return 0;
 }
 static const struct nla_policy macsec_rtnl_policy[IFLA_MACSEC_MAX + 1] = {
 	[IFLA_MACSEC_SCI] = { .type = NLA_U64 },
+	[IFLA_MACSEC_PORT] = { .type = NLA_U16 },
 	[IFLA_MACSEC_ICV_LEN] = { .type = NLA_U8 },
 	[IFLA_MACSEC_CIPHER_SUITE] = { .type = NLA_U64 },
 	[IFLA_MACSEC_WINDOW] = { .type = NLA_U32 },
 	return false;
 }
-static sci_t dev_to_sci(struct net_device *dev, __be16 port)
-{
-	return make_sci(dev->dev_addr, port);
-}
 static int macsec_add_dev(struct net_device *dev, sci_t sci, u8 icv_len)
 {
 	struct macsec_dev *macsec = macsec_priv(dev);

drivers/net/macvlan.c+2−0

@@ -334,6 +334,8 @@ static void macvlan_process_broadcast(struct work_struct *w) · 333 unmodified lines
334	if (src)	334	if (src)
335	dev_put(src->dev);	335	dev_put(src->dev);
336	consume_skb(skb);	336	consume_skb(skb);
		337
		338	cond_resched();
337	}	339	}
338	}	340	}
339		341

drivers/net/phy/bcm63xx.c+1−0

@@ -73,6 +73,7 @@ static struct phy_driver bcm63xx_driver[] = { · 72 unmodified lines
73	/* same phy as above, with just a different OUI */	73	/* same phy as above, with just a different OUI */
74	.phy_id = 0x002bdc00,	74	.phy_id = 0x002bdc00,
75	.phy_id_mask = 0xfffffc00,	75	.phy_id_mask = 0xfffffc00,
		76	.name = "Broadcom BCM63XX (2)",
76	/* PHY_BASIC_FEATURES */	77	/* PHY_BASIC_FEATURES */
77	.flags = PHY_IS_INTERNAL,	78	.flags = PHY_IS_INTERNAL,
78	.config_init = bcm63xx_config_init,	79	.config_init = bcm63xx_config_init,

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

@@ -727,7 +727,8 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat) · 726 unmodified lines
727	phy_trigger_machine(phydev);	727	phy_trigger_machine(phydev);
728	}	728	}
729		729
730	if (phy_clear_interrupt(phydev))	730	/* did_interrupt() may have cleared the interrupt already */
		731	if (!phydev->drv->did_interrupt && phy_clear_interrupt(phydev))
731	goto phy_err;	732	goto phy_err;
732	return IRQ_HANDLED;	733	return IRQ_HANDLED;
733		734

drivers/net/phy/phy_device.c+5−1

 	if (!mdio_bus_phy_may_suspend(phydev))
 		return 0;
+	phydev->suspended_by_mdio_bus = 1;
 	return phy_suspend(phydev);
 }
 	struct phy_device *phydev = to_phy_device(dev);
 	int ret;
-	if (!mdio_bus_phy_may_suspend(phydev))
+	if (!phydev->suspended_by_mdio_bus)
 		goto no_resume;
+	phydev->suspended_by_mdio_bus = 0;
 	ret = phy_resume(phydev);
 	if (ret < 0)
 		return ret;

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

 		config.interface = interface;
 	ret = phylink_validate(pl, supported, &config);
-	if (ret)
+	if (ret) {
+		phylink_warn(pl, "validation of %s with support %*pb and advertisement %*pb failed: %d\n",
+			     phy_modes(config.interface),
+			     __ETHTOOL_LINK_MODE_MASK_NBITS, phy->supported,
+			     __ETHTOOL_LINK_MODE_MASK_NBITS, config.advertising,
+			     ret);
 		return ret;
+	}
 	phy->phylink = pl;
 	phy->phy_link_change = phylink_phy_change;

drivers/net/slip/slhc.c+10−4

 	struct cstate *cs = lcs->next;
 	unsigned long deltaS, deltaA;
 	short changes = 0;
-	int hlen;
+	int nlen, hlen;
 	unsigned char new_seq[16];
 	unsigned char *cp = new_seq;
 	struct iphdr *ip;
 		return isize;
 	ip = (struct iphdr *) icp;
+	if (ip->version != 4 || ip->ihl < 5)
+		return isize;
 	/* Bail if this packet isn't TCP, or is an IP fragment */
 	if (ip->protocol != IPPROTO_TCP || (ntohs(ip->frag_off) & 0x3fff)) {
 			comp->sls_o_tcp++;
 		return isize;
 	}
-	/* Extract TCP header */
+	nlen = ip->ihl * 4;
+	if (isize < nlen + sizeof(*th))
+		return isize;
-	th = (struct tcphdr *)(((unsigned char *)ip) + ip->ihl*4);
+	th = (struct tcphdr *)(icp + nlen);
-	hlen = ip->ihl*4 + th->doff*4;
+	if (th->doff < sizeof(struct tcphdr) / 4)
+		return isize;
+	hlen = nlen + th->doff * 4;
 	/*  Bail if the TCP packet isn't `compressible' (i.e., ACK isn't set or
 	 *  some other control bit is set). Also uncompressible if

drivers/net/team/team.c+2−0

@@ -2240,6 +2240,8 @@ team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = { · 2239 unmodified lines
2240	[TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG },	2240	[TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG },
2241	[TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 },	2241	[TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 },
2242	[TEAM_ATTR_OPTION_DATA] = { .type = NLA_BINARY },	2242	[TEAM_ATTR_OPTION_DATA] = { .type = NLA_BINARY },
		2243	[TEAM_ATTR_OPTION_PORT_IFINDEX] = { .type = NLA_U32 },
		2244	[TEAM_ATTR_OPTION_ARRAY_INDEX] = { .type = NLA_U32 },
2243	};	2245	};
2244		2246
2245	static int team_nl_cmd_noop(struct sk_buff skb, struct genl_info info)	2247	static int team_nl_cmd_noop(struct sk_buff skb, struct genl_info info)

drivers/net/usb/r8152.c+8−0

 		}
 		msleep(20);
+		if (test_bit(RTL8152_UNPLUG, &tp->flags))
+			break;
 	}
 	return data;
 		if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
 		    AUTOLOAD_DONE)
 			break;
 		msleep(20);
+		if (test_bit(RTL8152_UNPLUG, &tp->flags))
+			break;
 	}
 	data = r8153_phy_status(tp, 0);
 		if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
 		    AUTOLOAD_DONE)
 			break;
 		msleep(20);
+		if (test_bit(RTL8152_UNPLUG, &tp->flags))
+			break;
 	}
 	data = r8153_phy_status(tp, 0);

drivers/net/veth.c+1−1

@@ -328,7 +328,7 @@ static void veth_get_stats64(struct net_device *dev, · 327 unmodified lines
328	rcu_read_lock();	328	rcu_read_lock();
329	peer = rcu_dereference(priv->peer);	329	peer = rcu_dereference(priv->peer);
330	if (peer) {	330	if (peer) {
331	tot->rx_dropped += veth_stats_tx(peer, &packets, &bytes);	331	veth_stats_tx(peer, &packets, &bytes);
332	tot->rx_bytes += bytes;	332	tot->rx_bytes += bytes;
333	tot->rx_packets += packets;	333	tot->rx_packets += packets;
334		334

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

@@ -308,7 +308,8 @@ iwl_parse_nvm_sections(struct iwl_mvm *mvm) · 307 unmodified lines
308	}	308	}
309		309
310	/* PHY_SKU section is mandatory in B0 */	310	/* PHY_SKU section is mandatory in B0 */
311	if (!mvm->nvm_sections[NVM_SECTION_TYPE_PHY_SKU].data) {	311	if (mvm->trans->cfg->nvm_type == IWL_NVM_EXT &&
		312	!mvm->nvm_sections[NVM_SECTION_TYPE_PHY_SKU].data) {
312	IWL_ERR(mvm,	313	IWL_ERR(mvm,
313	"Can't parse phy_sku in B0, empty sections\n");	314	"Can't parse phy_sku in B0, empty sections\n");
314	return NULL;	315	return NULL;

drivers/net/wireless/mediatek/mt76/dma.c+6−3

 	struct page *page = virt_to_head_page(data);
 	int offset = data - page_address(page);
 	struct sk_buff *skb = q->rx_head;
+	struct skb_shared_info *shinfo = skb_shinfo(skb);
-	offset += q->buf_offset;
+	if (shinfo->nr_frags < ARRAY_SIZE(shinfo->frags)) {
-	skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page, offset, len,
+		offset += q->buf_offset;
-			q->buf_size);
+		skb_add_rx_frag(skb, shinfo->nr_frags, page, offset, len,
+				q->buf_size);
+	}
 	if (more)
 		return;

drivers/nvme/host/rdma.c+5−3

 	if (new)
 		blk_mq_free_tag_set(ctrl->ctrl.admin_tagset);
 out_free_async_qe:
-	nvme_rdma_free_qe(ctrl->device->dev, &ctrl->async_event_sqe,
+	if (ctrl->async_event_sqe.data) {
-		sizeof(struct nvme_command), DMA_TO_DEVICE);
+		nvme_rdma_free_qe(ctrl->device->dev, &ctrl->async_event_sqe,
-	ctrl->async_event_sqe.data = NULL;
+			sizeof(struct nvme_command), DMA_TO_DEVICE);
+		ctrl->async_event_sqe.data = NULL;
+	}
 out_free_queue:
 	nvme_rdma_free_queue(&ctrl->queues[0]);
 	return error;

drivers/nvme/target/tcp.c+9−3

 	return 1;
 }
-static int nvmet_try_send_data(struct nvmet_tcp_cmd *cmd)
+static int nvmet_try_send_data(struct nvmet_tcp_cmd *cmd, bool last_in_batch)
 {
 	struct nvmet_tcp_queue *queue = cmd->queue;
 	int ret;
 	while (cmd->cur_sg) {
 		struct page *page = sg_page(cmd->cur_sg);
 		u32 left = cmd->cur_sg->length - cmd->offset;
+		int flags = MSG_DONTWAIT;
+		if ((!last_in_batch && cmd->queue->send_list_len) ||
+		    cmd->wbytes_done + left < cmd->req.transfer_len ||
+		    queue->data_digest || !queue->nvme_sq.sqhd_disabled)
+			flags |= MSG_MORE;
 		ret = kernel_sendpage(cmd->queue->sock, page, cmd->offset,
-					left, MSG_DONTWAIT | MSG_MORE);
+					left, flags);
 		if (ret <= 0)
 			return ret;
 	}
 	if (cmd->state == NVMET_TCP_SEND_DATA) {
-		ret = nvmet_try_send_data(cmd);
+		ret = nvmet_try_send_data(cmd, last_in_batch);
 		if (ret <= 0)
 			goto done_send;
 	}

drivers/of/of_mdio.c+1−0

@@ -306,6 +306,7 @@ int of_mdiobus_register(struct mii_bus mdio, struct device_node np) · 305 unmodified lines
306	rc = of_mdiobus_register_phy(mdio, child, addr);	306	rc = of_mdiobus_register_phy(mdio, child, addr);
307	if (rc && rc != -ENODEV)	307	if (rc && rc != -ENODEV)
308	goto unregister;	308	goto unregister;
		309	break;
309	}	310	}
310	}	311	}
311	}	312	}

drivers/pinctrl/cirrus/pinctrl-madera-core.c+13−0

 		return ret;
 	}
+	platform_set_drvdata(pdev, priv);
 	dev_dbg(priv->dev, "pinctrl probed ok\n");
 	return 0;
 }
+static int madera_pin_remove(struct platform_device *pdev)
+{
+	struct madera_pin_private *priv = platform_get_drvdata(pdev);
+	if (priv->madera->pdata.gpio_configs)
+		pinctrl_unregister_mappings(priv->madera->pdata.gpio_configs);
+	return 0;
+}
 static struct platform_driver madera_pin_driver = {
 	.probe = madera_pin_probe,
+	.remove = madera_pin_remove,
 	.driver = {
 		.name = "madera-pinctrl",
 	},

drivers/pinctrl/core.c+0−1

@@ -2021,7 +2021,6 @@ static int pinctrl_claim_hogs(struct pinctrl_dev *pctldev) · 2020 unmodified lines
2021	return PTR_ERR(pctldev->p);	2021	return PTR_ERR(pctldev->p);
2022	}	2022	}
2023		2023
2024	kref_get(&pctldev->p->users);
2025	pctldev->hog_default =	2024	pctldev->hog_default =
2026	pinctrl_lookup_state(pctldev->p, PINCTRL_STATE_DEFAULT);	2025	pinctrl_lookup_state(pctldev->p, PINCTRL_STATE_DEFAULT);
2027	if (IS_ERR(pctldev->hog_default)) {	2026	if (IS_ERR(pctldev->hog_default)) {

drivers/pinctrl/freescale/pinctrl-scu.c+2−2

@@ -23,12 +23,12 @@ struct imx_sc_msg_req_pad_set { · 22 unmodified lines
23	struct imx_sc_rpc_msg hdr;	23	struct imx_sc_rpc_msg hdr;
24	u32 val;	24	u32 val;
25	u16 pad;	25	u16 pad;
26	} __packed;	26	} __packed __aligned(4);
27		27
28	struct imx_sc_msg_req_pad_get {	28	struct imx_sc_msg_req_pad_get {
29	struct imx_sc_rpc_msg hdr;	29	struct imx_sc_rpc_msg hdr;
30	u16 pad;	30	u16 pad;
31	} __packed;	31	} __packed __aligned(4);
32		32
33	struct imx_sc_msg_resp_pad_get {	33	struct imx_sc_msg_resp_pad_get {
34	struct imx_sc_rpc_msg hdr;	34	struct imx_sc_rpc_msg hdr;

drivers/pinctrl/meson/pinctrl-meson-gxl.c+2−2

@@ -147,8 +147,8 @@ static const unsigned int sdio_d0_pins[] = { GPIOX_0 }; · 146 unmodified lines
147	static const unsigned int sdio_d1_pins[] = { GPIOX_1 };	147	static const unsigned int sdio_d1_pins[] = { GPIOX_1 };
148	static const unsigned int sdio_d2_pins[] = { GPIOX_2 };	148	static const unsigned int sdio_d2_pins[] = { GPIOX_2 };
149	static const unsigned int sdio_d3_pins[] = { GPIOX_3 };	149	static const unsigned int sdio_d3_pins[] = { GPIOX_3 };
150	static const unsigned int sdio_cmd_pins[] = { GPIOX_4 };	150	static const unsigned int sdio_clk_pins[] = { GPIOX_4 };
151	static const unsigned int sdio_clk_pins[] = { GPIOX_5 };	151	static const unsigned int sdio_cmd_pins[] = { GPIOX_5 };
152	static const unsigned int sdio_irq_pins[] = { GPIOX_7 };	152	static const unsigned int sdio_irq_pins[] = { GPIOX_7 };
153		153
154	static const unsigned int nand_ce0_pins[] = { BOOT_8 };	154	static const unsigned int nand_ce0_pins[] = { BOOT_8 };

drivers/pinctrl/pinctrl-falcon.c+1−1

@@ -451,7 +451,7 @@ static int pinctrl_falcon_probe(struct platform_device *pdev) · 450 unmodified lines
451	falcon_info.clk[*bank] = clk_get(&ppdev->dev, NULL);	451	falcon_info.clk[*bank] = clk_get(&ppdev->dev, NULL);
452	if (IS_ERR(falcon_info.clk[*bank])) {	452	if (IS_ERR(falcon_info.clk[*bank])) {
453	dev_err(&ppdev->dev, "failed to get clock\n");	453	dev_err(&ppdev->dev, "failed to get clock\n");
454	of_node_put(np)	454	of_node_put(np);
455	return PTR_ERR(falcon_info.clk[*bank]);	455	return PTR_ERR(falcon_info.clk[*bank]);
456	}	456	}
457	falcon_info.membase[*bank] = devm_ioremap_resource(&pdev->dev,	457	falcon_info.membase[*bank] = devm_ioremap_resource(&pdev->dev,

drivers/pinctrl/qcom/pinctrl-msm.c+1−2

drivers/pinctrl/qcom/pinctrl-ssbi-gpio.c+1−1

@@ -794,7 +794,7 @@ static int pm8xxx_gpio_probe(struct platform_device *pdev) · 793 unmodified lines
794	girq->fwnode = of_node_to_fwnode(pctrl->dev->of_node);	794	girq->fwnode = of_node_to_fwnode(pctrl->dev->of_node);
795	girq->parent_domain = parent_domain;	795	girq->parent_domain = parent_domain;
796	girq->child_to_parent_hwirq = pm8xxx_child_to_parent_hwirq;	796	girq->child_to_parent_hwirq = pm8xxx_child_to_parent_hwirq;
797	girq->populate_parent_alloc_arg = gpiochip_populate_parent_fwspec_fourcell;	797	girq->populate_parent_alloc_arg = gpiochip_populate_parent_fwspec_twocell;
798	girq->child_offset_to_irq = pm8xxx_child_offset_to_irq;	798	girq->child_offset_to_irq = pm8xxx_child_offset_to_irq;
799	girq->child_irq_domain_ops.translate = pm8xxx_domain_translate;	799	girq->child_irq_domain_ops.translate = pm8xxx_domain_translate;
800		800

drivers/rtc/Kconfig+1−0

@@ -327,6 +327,7 @@ config RTC_DRV_MAX6900 · 326 unmodified lines
327	config RTC_DRV_MAX8907	327	config RTC_DRV_MAX8907
328	tristate "Maxim MAX8907"	328	tristate "Maxim MAX8907"
329	depends on MFD_MAX8907 \|\| COMPILE_TEST	329	depends on MFD_MAX8907 \|\| COMPILE_TEST
		330	select REGMAP_IRQ
330	help	331	help
331	If you say yes here you will get support for the	332	If you say yes here you will get support for the
332	RTC of Maxim MAX8907 PMIC.	333	RTC of Maxim MAX8907 PMIC.

drivers/s390/block/dasd.c+24−3

 		     (unsigned long) block);
 	INIT_LIST_HEAD(&block->ccw_queue);
 	spin_lock_init(&block->queue_lock);
+	INIT_LIST_HEAD(&block->format_list);
+	spin_lock_init(&block->format_lock);
 	timer_setup(&block->timer, dasd_block_timeout, 0);
 	spin_lock_init(&block->profile.lock);
 	if (dasd_ese_needs_format(cqr->block, irb)) {
 		if (rq_data_dir((struct request *)cqr->callback_data) == READ) {
-			device->discipline->ese_read(cqr);
+			device->discipline->ese_read(cqr, irb);
 			cqr->status = DASD_CQR_SUCCESS;
 			cqr->stopclk = now;
 			dasd_device_clear_timer(device);
 			dasd_schedule_device_bh(device);
 			return;
 		}
-		fcqr = device->discipline->ese_format(device, cqr);
+		fcqr = device->discipline->ese_format(device, cqr, irb);
 		if (IS_ERR(fcqr)) {
+			if (PTR_ERR(fcqr) == -EINVAL) {
+				cqr->status = DASD_CQR_ERROR;
+				return;
+			}
 			/*
 			 * If we can't format now, let the request go
 			 * one extra round. Maybe we can format later.
 			 */
 			cqr->status = DASD_CQR_QUEUED;
+			dasd_schedule_device_bh(device);
+			return;
 		} else {
 			fcqr->status = DASD_CQR_QUEUED;
 			cqr->status = DASD_CQR_QUEUED;
 {
 	struct request *req;
 	blk_status_t error = BLK_STS_OK;
+	unsigned int proc_bytes;
 	int status;
 	req = (struct request *) cqr->callback_data;
 	dasd_profile_end(cqr->block, cqr, req);
+	proc_bytes = cqr->proc_bytes;
 	status = cqr->block->base->discipline->free_cp(cqr, req);
 	if (status < 0)
 		error = errno_to_blk_status(status);
 		blk_mq_end_request(req, error);
 		blk_mq_run_hw_queues(req->q, true);
 	} else {
-		blk_mq_complete_request(req);
+		/*
+		 * Partial completed requests can happen with ESE devices.
+		 * During read we might have gotten a NRF error and have to
+		 * complete a request partially.
+		 */
+		if (proc_bytes) {
+			blk_update_request(req, BLK_STS_OK,
+					   blk_rq_bytes(req) - proc_bytes);
+			blk_mq_requeue_request(req, true);
+		} else {
+			blk_mq_complete_request(req);
+		}
 	}
 }

drivers/s390/block/dasd_eckd.c+156−7

@@ -207,6 +207,45 @@ static void set_ch_t(struct ch_t *geo, __u32 cyl, __u8 head) · 206 unmodified lines
207	geo->head \|= head;	207	geo->head \|= head;
208	}	208	}
209		209
		210	/*
		211	* calculate failing track from sense data depending if
		212	* it is an EAV device or not
		213	*/
		214	static int dasd_eckd_track_from_irb(struct irb irb, struct dasd_device device,
		215	sector_t *track)
		216	{
		217	struct dasd_eckd_private *private = device->private;
		218	u8 *sense = NULL;
		219	u32 cyl;
		220	u8 head;
		221
		222	sense = dasd_get_sense(irb);
		223	if (!sense) {
		224	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
		225	"ESE error no sense data\n");
		226	return -EINVAL;
		227	}
		228	if (!(sense[27] & DASD_SENSE_BIT_2)) {
		229	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
		230	"ESE error no valid track data\n");
		231	return -EINVAL;
		232	}
		233
		234	if (sense[27] & DASD_SENSE_BIT_3) {
		235	/* enhanced addressing */
		236	cyl = sense[30] << 20;
		237	cyl \|= (sense[31] & 0xF0) << 12;
		238	cyl \|= sense[28] << 8;
		239	cyl \|= sense[29];
		240	} else {
		241	cyl = sense[29] << 8;
		242	cyl \|= sense[30];
		243	}
		244	head = sense[31] & 0x0F;
		245	track = cyl private->rdc_data.trk_per_cyl + head;
		246	return 0;
		247	}
		248
210	static int set_timestamp(struct ccw1 ccw, struct DE_eckd_data data,	249	static int set_timestamp(struct ccw1 ccw, struct DE_eckd_data data,
211	struct dasd_device *device)	250	struct dasd_device *device)
212	{	251	{
@@ -2986,6 +3025,37 @@ static int dasd_eckd_format_device(struct dasd_device *base, · 2773 unmodified lines
2986	0, NULL);	3025	0, NULL);
2987	}	3026	}
2988		3027
		3028	static bool test_and_set_format_track(struct dasd_format_entry *to_format,
		3029	struct dasd_block *block)
		3030	{
		3031	struct dasd_format_entry *format;
		3032	unsigned long flags;
		3033	bool rc = false;
		3034
		3035	spin_lock_irqsave(&block->format_lock, flags);
		3036	list_for_each_entry(format, &block->format_list, list) {
		3037	if (format->track == to_format->track) {
		3038	rc = true;
		3039	goto out;
		3040	}
		3041	}
		3042	list_add_tail(&to_format->list, &block->format_list);
		3043
		3044	out:
		3045	spin_unlock_irqrestore(&block->format_lock, flags);
		3046	return rc;
		3047	}
		3048
		3049	static void clear_format_track(struct dasd_format_entry *format,
		3050	struct dasd_block *block)
		3051	{
		3052	unsigned long flags;
		3053
		3054	spin_lock_irqsave(&block->format_lock, flags);
		3055	list_del_init(&format->list);
		3056	spin_unlock_irqrestore(&block->format_lock, flags);
		3057	}
		3058
2989	/*	3059	/*
2990	* Callback function to free ESE format requests.	3060	* Callback function to free ESE format requests.
2991	*/	3061	*/
@@ -2993,15 +3063,19 @@ static void dasd_eckd_ese_format_cb(struct dasd_ccw_req cqr, void data) · 1 unmodified line
2993	{	3063	{
2994	struct dasd_device *device = cqr->startdev;	3064	struct dasd_device *device = cqr->startdev;
2995	struct dasd_eckd_private *private = device->private;	3065	struct dasd_eckd_private *private = device->private;
		3066	struct dasd_format_entry *format = data;
2996		3067
		3068	clear_format_track(format, cqr->basedev->block);
2997	private->count--;	3069	private->count--;
2998	dasd_ffree_request(cqr, device);	3070	dasd_ffree_request(cqr, device);
2999	}	3071	}
3000		3072
3001	static struct dasd_ccw_req *	3073	static struct dasd_ccw_req *
3002	dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr)	3074	dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr,
		3075	struct irb *irb)
3003	{	3076	{
3004	struct dasd_eckd_private *private;	3077	struct dasd_eckd_private *private;
		3078	struct dasd_format_entry *format;
3005	struct format_data_t fdata;	3079	struct format_data_t fdata;
3006	unsigned int recs_per_trk;	3080	unsigned int recs_per_trk;
3007	struct dasd_ccw_req *fcqr;	3081	struct dasd_ccw_req *fcqr;
@@ -3011,23 +3085,39 @@ dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr) · 3 unmodified lines
3011	struct request *req;	3085	struct request *req;
3012	sector_t first_trk;	3086	sector_t first_trk;
3013	sector_t last_trk;	3087	sector_t last_trk;
		3088	sector_t curr_trk;
3014	int rc;	3089	int rc;
3015		3090
3016	req = cqr->callback_data;	3091	req = cqr->callback_data;
3017	base = cqr->block->base;	3092	block = cqr->block;
		3093	base = block->base;
3018	private = base->private;	3094	private = base->private;
3019	block = base->block;
3020	blksize = block->bp_block;	3095	blksize = block->bp_block;
3021	recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);	3096	recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
		3097	format = &startdev->format_entry;
3022		3098
3023	first_trk = blk_rq_pos(req) >> block->s2b_shift;	3099	first_trk = blk_rq_pos(req) >> block->s2b_shift;
3024	sector_div(first_trk, recs_per_trk);	3100	sector_div(first_trk, recs_per_trk);
3025	last_trk =	3101	last_trk =
3026	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;	3102	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
3027	sector_div(last_trk, recs_per_trk);	3103	sector_div(last_trk, recs_per_trk);
		3104	rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
		3105	if (rc)
		3106	return ERR_PTR(rc);
3028		3107
3029	fdata.start_unit = first_trk;	3108	if (curr_trk < first_trk \|\| curr_trk > last_trk) {
3030	fdata.stop_unit = last_trk;	3109	DBF_DEV_EVENT(DBF_WARNING, startdev,
		3110	"ESE error track %llu not within range %llu - %llu\n",
		3111	curr_trk, first_trk, last_trk);
		3112	return ERR_PTR(-EINVAL);
		3113	}
		3114	format->track = curr_trk;
		3115	/* test if track is already in formatting by another thread */
		3116	if (test_and_set_format_track(format, block))
		3117	return ERR_PTR(-EEXIST);
		3118
		3119	fdata.start_unit = curr_trk;
		3120	fdata.stop_unit = curr_trk;
3031	fdata.blksize = blksize;	3121	fdata.blksize = blksize;
3032	fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0;	3122	fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0;
3033		3123
@@ -3044,6 +3134,7 @@ dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr) · 10 unmodified lines
3044	return fcqr;	3134	return fcqr;
3045		3135
3046	fcqr->callback = dasd_eckd_ese_format_cb;	3136	fcqr->callback = dasd_eckd_ese_format_cb;
		3137	fcqr->callback_data = (void *) format;
3047		3138
3048	return fcqr;	3139	return fcqr;
3049	}	3140	}
@@ -3051,29 +3142,87 @@ dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr) · 1 unmodified line
3051	/*	3142	/*
3052	* When data is read from an unformatted area of an ESE volume, this function	3143	* When data is read from an unformatted area of an ESE volume, this function
3053	* returns zeroed data and thereby mimics a read of zero data.	3144	* returns zeroed data and thereby mimics a read of zero data.
		3145	*
		3146	* The first unformatted track is the one that got the NRF error, the address is
		3147	* encoded in the sense data.
		3148	*
		3149	* All tracks before have returned valid data and should not be touched.
		3150	* All tracks after the unformatted track might be formatted or not. This is
		3151	* currently not known, remember the processed data and return the remainder of
		3152	* the request to the blocklayer in __dasd_cleanup_cqr().
3054	*/	3153	*/
3055	static void dasd_eckd_ese_read(struct dasd_ccw_req *cqr)	3154	static int dasd_eckd_ese_read(struct dasd_ccw_req cqr, struct irb irb)
3056	{	3155	{
		3156	struct dasd_eckd_private *private;
		3157	sector_t first_trk, last_trk;
		3158	sector_t first_blk, last_blk;
3057	unsigned int blksize, off;	3159	unsigned int blksize, off;
		3160	unsigned int recs_per_trk;
3058	struct dasd_device *base;	3161	struct dasd_device *base;
3059	struct req_iterator iter;	3162	struct req_iterator iter;
		3163	struct dasd_block *block;
		3164	unsigned int skip_block;
		3165	unsigned int blk_count;
3060	struct request *req;	3166	struct request *req;
3061	struct bio_vec bv;	3167	struct bio_vec bv;
		3168	sector_t curr_trk;
		3169	sector_t end_blk;
3062	char *dst;	3170	char *dst;
		3171	int rc;
3063		3172
3064	req = (struct request *) cqr->callback_data;	3173	req = (struct request *) cqr->callback_data;
3065	base = cqr->block->base;	3174	base = cqr->block->base;
3066	blksize = base->block->bp_block;	3175	blksize = base->block->bp_block;
		3176	block = cqr->block;
		3177	private = base->private;
		3178	skip_block = 0;
		3179	blk_count = 0;
		3180
		3181	recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
		3182	first_trk = first_blk = blk_rq_pos(req) >> block->s2b_shift;
		3183	sector_div(first_trk, recs_per_trk);
		3184	last_trk = last_blk =
		3185	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
		3186	sector_div(last_trk, recs_per_trk);
		3187	rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
		3188	if (rc)
		3189	return rc;
		3190
		3191	/* sanity check if the current track from sense data is valid */
		3192	if (curr_trk < first_trk \|\| curr_trk > last_trk) {
		3193	DBF_DEV_EVENT(DBF_WARNING, base,
		3194	"ESE error track %llu not within range %llu - %llu\n",
		3195	curr_trk, first_trk, last_trk);
		3196	return -EINVAL;
		3197	}
		3198
		3199	/*
		3200	* if not the first track got the NRF error we have to skip over valid
		3201	* blocks
		3202	*/
		3203	if (curr_trk != first_trk)
		3204	skip_block = curr_trk * recs_per_trk - first_blk;
		3205
		3206	/* we have no information beyond the current track */
		3207	end_blk = (curr_trk + 1) * recs_per_trk;
3067		3208
3068	rq_for_each_segment(bv, req, iter) {	3209	rq_for_each_segment(bv, req, iter) {
3069	dst = page_address(bv.bv_page) + bv.bv_offset;	3210	dst = page_address(bv.bv_page) + bv.bv_offset;
3070	for (off = 0; off < bv.bv_len; off += blksize) {	3211	for (off = 0; off < bv.bv_len; off += blksize) {
3071	if (dst && rq_data_dir(req) == READ) {	3212	if (first_blk + blk_count >= end_blk) {
		3213	cqr->proc_bytes = blk_count * blksize;
		3214	return 0;
		3215	}
		3216	if (dst && !skip_block) {
3072	dst += off;	3217	dst += off;
3073	memset(dst, 0, blksize);	3218	memset(dst, 0, blksize);
		3219	} else {
		3220	skip_block--;
3074	}	3221	}
		3222	blk_count++;
3075	}	3223	}
3076	}	3224	}
		3225	return 0;
3077	}	3226	}
3078		3227
3079	/*	3228	/*

drivers/s390/block/dasd_int.h+13−2

 	void (*callback)(struct dasd_ccw_req *, void *data);
 	void *callback_data;
+	unsigned int proc_bytes;	/* bytes for partial completion */
 };
 /*
 	int (*ext_pool_warn_thrshld)(struct dasd_device *);
 	int (*ext_pool_oos)(struct dasd_device *);
 	int (*ext_pool_exhaust)(struct dasd_device *, struct dasd_ccw_req *);
-	struct dasd_ccw_req *(*ese_format)(struct dasd_device *, struct dasd_ccw_req *);
+	struct dasd_ccw_req *(*ese_format)(struct dasd_device *,
-	void (*ese_read)(struct dasd_ccw_req *);
+					   struct dasd_ccw_req *, struct irb *);
+	int (*ese_read)(struct dasd_ccw_req *, struct irb *);
 };
 extern struct dasd_discipline *dasd_diag_discipline_pointer;
 	spinlock_t lock;
 };
+struct dasd_format_entry {
+	struct list_head list;
+	sector_t track;
+};
 struct dasd_device {
 	/* Block device stuff. */
 	struct dasd_block *block;
 	struct dentry *debugfs_dentry;
 	struct dentry *hosts_dentry;
 	struct dasd_profile profile;
+	struct dasd_format_entry format_entry;
 };
 struct dasd_block {
 	struct dentry *debugfs_dentry;
 	struct dasd_profile profile;
+	struct list_head format_list;
+	spinlock_t format_lock;
 };
 struct dasd_attention_data {

drivers/s390/net/qeth_core.h+2−2

@@ -369,7 +369,7 @@ enum qeth_qdio_info_states { · 368 unmodified lines
369	struct qeth_buffer_pool_entry {	369	struct qeth_buffer_pool_entry {
370	struct list_head list;	370	struct list_head list;
371	struct list_head init_list;	371	struct list_head init_list;
372	void *elements[QDIO_MAX_ELEMENTS_PER_BUFFER];	372	struct page *elements[QDIO_MAX_ELEMENTS_PER_BUFFER];
373	};	373	};
374		374
375	struct qeth_qdio_buffer_pool {	375	struct qeth_qdio_buffer_pool {
@@ -983,7 +983,7 @@ extern const struct attribute_group qeth_device_blkt_group; · 607 unmodified lines
983	extern const struct device_type qeth_generic_devtype;	983	extern const struct device_type qeth_generic_devtype;
984		984
985	const char qeth_get_cardname_short(struct qeth_card );	985	const char qeth_get_cardname_short(struct qeth_card );
986	int qeth_realloc_buffer_pool(struct qeth_card *, int);	986	int qeth_resize_buffer_pool(struct qeth_card *card, unsigned int count);
987	int qeth_core_load_discipline(struct qeth_card *, enum qeth_discipline_id);	987	int qeth_core_load_discipline(struct qeth_card *, enum qeth_discipline_id);
988	void qeth_core_free_discipline(struct qeth_card *);	988	void qeth_core_free_discipline(struct qeth_card *);
989		989

drivers/s390/net/qeth_core_main.c+118−58

@@ -65,7 +65,6 @@ static struct lock_class_key qdio_out_skb_queue_key; · 64 unmodified lines
65	static void qeth_issue_next_read_cb(struct qeth_card *card,	65	static void qeth_issue_next_read_cb(struct qeth_card *card,
66	struct qeth_cmd_buffer *iob,	66	struct qeth_cmd_buffer *iob,
67	unsigned int data_length);	67	unsigned int data_length);
68	static void qeth_free_buffer_pool(struct qeth_card *);
69	static int qeth_qdio_establish(struct qeth_card *);	68	static int qeth_qdio_establish(struct qeth_card *);
70	static void qeth_free_qdio_queues(struct qeth_card *card);	69	static void qeth_free_qdio_queues(struct qeth_card *card);
71	static void qeth_notify_skbs(struct qeth_qdio_out_q *queue,	70	static void qeth_notify_skbs(struct qeth_qdio_out_q *queue,
@@ -212,49 +211,121 @@ void qeth_clear_working_pool_list(struct qeth_card *card) · 140 unmodified lines
212	}	211	}
213	EXPORT_SYMBOL_GPL(qeth_clear_working_pool_list);	212	EXPORT_SYMBOL_GPL(qeth_clear_working_pool_list);
214		213
		214	static void qeth_free_pool_entry(struct qeth_buffer_pool_entry *entry)
		215	{
		216	unsigned int i;
		217
		218	for (i = 0; i < ARRAY_SIZE(entry->elements); i++) {
		219	if (entry->elements[i])
		220	__free_page(entry->elements[i]);
		221	}
		222
		223	kfree(entry);
		224	}
		225
		226	static void qeth_free_buffer_pool(struct qeth_card *card)
		227	{
		228	struct qeth_buffer_pool_entry entry, tmp;
		229
		230	list_for_each_entry_safe(entry, tmp, &card->qdio.init_pool.entry_list,
		231	init_list) {
		232	list_del(&entry->init_list);
		233	qeth_free_pool_entry(entry);
		234	}
		235	}
		236
		237	static struct qeth_buffer_pool_entry *qeth_alloc_pool_entry(unsigned int pages)
		238	{
		239	struct qeth_buffer_pool_entry *entry;
		240	unsigned int i;
		241
		242	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
		243	if (!entry)
		244	return NULL;
		245
		246	for (i = 0; i < pages; i++) {
		247	entry->elements[i] = alloc_page(GFP_KERNEL);
		248
		249	if (!entry->elements[i]) {
		250	qeth_free_pool_entry(entry);
		251	return NULL;
		252	}
		253	}
		254
		255	return entry;
		256	}
		257
215	static int qeth_alloc_buffer_pool(struct qeth_card *card)	258	static int qeth_alloc_buffer_pool(struct qeth_card *card)
216	{	259	{
217	struct qeth_buffer_pool_entry *pool_entry;	260	unsigned int buf_elements = QETH_MAX_BUFFER_ELEMENTS(card);
218	void *ptr;	261	unsigned int i;
219	int i, j;
220		262
221	QETH_CARD_TEXT(card, 5, "alocpool");	263	QETH_CARD_TEXT(card, 5, "alocpool");
222	for (i = 0; i < card->qdio.init_pool.buf_count; ++i) {	264	for (i = 0; i < card->qdio.init_pool.buf_count; ++i) {
223	pool_entry = kzalloc(sizeof(*pool_entry), GFP_KERNEL);	265	struct qeth_buffer_pool_entry *entry;
224	if (!pool_entry) {	266
		267	entry = qeth_alloc_pool_entry(buf_elements);
		268	if (!entry) {
225	qeth_free_buffer_pool(card);	269	qeth_free_buffer_pool(card);
226	return -ENOMEM;	270	return -ENOMEM;
227	}	271	}
228	for (j = 0; j < QETH_MAX_BUFFER_ELEMENTS(card); ++j) {	272
229	ptr = (void *) __get_free_page(GFP_KERNEL);	273	list_add(&entry->init_list, &card->qdio.init_pool.entry_list);
230	if (!ptr) {
231	while (j > 0)
232	free_page((unsigned long)
233	pool_entry->elements[--j]);
234	kfree(pool_entry);
235	qeth_free_buffer_pool(card);
236	return -ENOMEM;
237	}
238	pool_entry->elements[j] = ptr;
239	}
240	list_add(&pool_entry->init_list,
241	&card->qdio.init_pool.entry_list);
242	}	274	}
243	return 0;	275	return 0;
244	}	276	}
245		277
246	int qeth_realloc_buffer_pool(struct qeth_card *card, int bufcnt)	278	int qeth_resize_buffer_pool(struct qeth_card *card, unsigned int count)
247	{	279	{
		280	unsigned int buf_elements = QETH_MAX_BUFFER_ELEMENTS(card);
		281	struct qeth_qdio_buffer_pool *pool = &card->qdio.init_pool;
		282	struct qeth_buffer_pool_entry entry, tmp;
		283	int delta = count - pool->buf_count;
		284	LIST_HEAD(entries);
		285
248	QETH_CARD_TEXT(card, 2, "realcbp");	286	QETH_CARD_TEXT(card, 2, "realcbp");
249		287
250	/* TODO: steel/add buffers from/to a running card's buffer pool (?) */	288	/* Defer until queue is allocated: */
251	qeth_clear_working_pool_list(card);	289	if (!card->qdio.in_q)
252	qeth_free_buffer_pool(card);	290	goto out;
253	card->qdio.in_buf_pool.buf_count = bufcnt;	291
254	card->qdio.init_pool.buf_count = bufcnt;	292	/* Remove entries from the pool: */
255	return qeth_alloc_buffer_pool(card);	293	while (delta < 0) {
		294	entry = list_first_entry(&pool->entry_list,
		295	struct qeth_buffer_pool_entry,
		296	init_list);
		297	list_del(&entry->init_list);
		298	qeth_free_pool_entry(entry);
		299
		300	delta++;
		301	}
		302
		303	/* Allocate additional entries: */
		304	while (delta > 0) {
		305	entry = qeth_alloc_pool_entry(buf_elements);
		306	if (!entry) {
		307	list_for_each_entry_safe(entry, tmp, &entries,
		308	init_list) {
		309	list_del(&entry->init_list);
		310	qeth_free_pool_entry(entry);
		311	}
		312
		313	return -ENOMEM;
		314	}
		315
		316	list_add(&entry->init_list, &entries);
		317
		318	delta--;
		319	}
		320
		321	list_splice(&entries, &pool->entry_list);
		322
		323	out:
		324	card->qdio.in_buf_pool.buf_count = count;
		325	pool->buf_count = count;
		326	return 0;
256	}	327	}
257	EXPORT_SYMBOL_GPL(qeth_realloc_buffer_pool);	328	EXPORT_SYMBOL_GPL(qeth_resize_buffer_pool);
258		329
259	static void qeth_free_qdio_queue(struct qeth_qdio_q *q)	330	static void qeth_free_qdio_queue(struct qeth_qdio_q *q)
260	{	331	{
@@ -1170,19 +1241,6 @@ void qeth_drain_output_queues(struct qeth_card *card) · 909 unmodified lines
1170	}	1241	}
1171	EXPORT_SYMBOL_GPL(qeth_drain_output_queues);	1242	EXPORT_SYMBOL_GPL(qeth_drain_output_queues);
1172		1243
1173	static void qeth_free_buffer_pool(struct qeth_card *card)
1174	{
1175	struct qeth_buffer_pool_entry pool_entry, tmp;
1176	int i = 0;
1177	list_for_each_entry_safe(pool_entry, tmp,
1178	&card->qdio.init_pool.entry_list, init_list){
1179	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i)
1180	free_page((unsigned long)pool_entry->elements[i]);
1181	list_del(&pool_entry->init_list);
1182	kfree(pool_entry);
1183	}
1184	}
1185
1186	static int qeth_osa_set_output_queues(struct qeth_card *card, bool single)	1244	static int qeth_osa_set_output_queues(struct qeth_card *card, bool single)
1187	{	1245	{
1188	unsigned int count = single ? 1 : card->dev->num_tx_queues;	1246	unsigned int count = single ? 1 : card->dev->num_tx_queues;
@@ -1204,7 +1262,6 @@ static int qeth_osa_set_output_queues(struct qeth_card *card, bool single) · 15 unmodified lines
1204	if (count == 1)	1262	if (count == 1)
1205	dev_info(&card->gdev->dev, "Priority Queueing not supported\n");	1263	dev_info(&card->gdev->dev, "Priority Queueing not supported\n");
1206		1264
1207	card->qdio.default_out_queue = single ? 0 : QETH_DEFAULT_QUEUE;
1208	card->qdio.no_out_queues = count;	1265	card->qdio.no_out_queues = count;
1209	return 0;	1266	return 0;
1210	}	1267	}
@@ -2393,7 +2450,6 @@ static void qeth_free_qdio_queues(struct qeth_card *card) · 1182 unmodified lines
2393	return;	2450	return;
2394		2451
2395	qeth_free_cq(card);	2452	qeth_free_cq(card);
2396	cancel_delayed_work_sync(&card->buffer_reclaim_work);
2397	for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) {	2453	for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) {
2398	if (card->qdio.in_q->bufs[j].rx_skb)	2454	if (card->qdio.in_q->bufs[j].rx_skb)
2399	dev_kfree_skb_any(card->qdio.in_q->bufs[j].rx_skb);	2455	dev_kfree_skb_any(card->qdio.in_q->bufs[j].rx_skb);
@@ -2575,7 +2631,6 @@ static struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry( · 175 unmodified lines
2575	struct list_head *plh;	2631	struct list_head *plh;
2576	struct qeth_buffer_pool_entry *entry;	2632	struct qeth_buffer_pool_entry *entry;
2577	int i, free;	2633	int i, free;
2578	struct page *page;
2579		2634
2580	if (list_empty(&card->qdio.in_buf_pool.entry_list))	2635	if (list_empty(&card->qdio.in_buf_pool.entry_list))
2581	return NULL;	2636	return NULL;
@@ -2584,7 +2639,7 @@ static struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry( · 2 unmodified lines
2584	entry = list_entry(plh, struct qeth_buffer_pool_entry, list);	2639	entry = list_entry(plh, struct qeth_buffer_pool_entry, list);
2585	free = 1;	2640	free = 1;
2586	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) {	2641	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) {
2587	if (page_count(virt_to_page(entry->elements[i])) > 1) {	2642	if (page_count(entry->elements[i]) > 1) {
2588	free = 0;	2643	free = 0;
2589	break;	2644	break;
2590	}	2645	}
@@ -2599,15 +2654,15 @@ static struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry( · 8 unmodified lines
2599	entry = list_entry(card->qdio.in_buf_pool.entry_list.next,	2654	entry = list_entry(card->qdio.in_buf_pool.entry_list.next,
2600	struct qeth_buffer_pool_entry, list);	2655	struct qeth_buffer_pool_entry, list);
2601	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) {	2656	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) {
2602	if (page_count(virt_to_page(entry->elements[i])) > 1) {	2657	if (page_count(entry->elements[i]) > 1) {
2603	page = alloc_page(GFP_ATOMIC);	2658	struct page *page = alloc_page(GFP_ATOMIC);
2604	if (!page) {	2659
		2660	if (!page)
2605	return NULL;	2661	return NULL;
2606	} else {	2662
2607	free_page((unsigned long)entry->elements[i]);	2663	__free_page(entry->elements[i]);
2608	entry->elements[i] = page_address(page);	2664	entry->elements[i] = page;
2609	QETH_CARD_STAT_INC(card, rx_sg_alloc_page);	2665	QETH_CARD_STAT_INC(card, rx_sg_alloc_page);
2610	}
2611	}	2666	}
2612	}	2667	}
2613	list_del_init(&entry->list);	2668	list_del_init(&entry->list);
@@ -2625,12 +2680,12 @@ static int qeth_init_input_buffer(struct qeth_card *card, · 11 unmodified lines
2625	ETH_HLEN +	2680	ETH_HLEN +
2626	sizeof(struct ipv6hdr));	2681	sizeof(struct ipv6hdr));
2627	if (!buf->rx_skb)	2682	if (!buf->rx_skb)
2628	return 1;	2683	return -ENOMEM;
2629	}	2684	}
2630		2685
2631	pool_entry = qeth_find_free_buffer_pool_entry(card);	2686	pool_entry = qeth_find_free_buffer_pool_entry(card);
2632	if (!pool_entry)	2687	if (!pool_entry)
2633	return 1;	2688	return -ENOBUFS;
2634		2689
2635	/*	2690	/*
2636	* since the buffer is accessed only from the input_tasklet	2691	* since the buffer is accessed only from the input_tasklet
@@ -2643,7 +2698,7 @@ static int qeth_init_input_buffer(struct qeth_card *card, · 6 unmodified lines
2643	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) {	2698	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) {
2644	buf->buffer->element[i].length = PAGE_SIZE;	2699	buf->buffer->element[i].length = PAGE_SIZE;
2645	buf->buffer->element[i].addr =	2700	buf->buffer->element[i].addr =
2646	virt_to_phys(pool_entry->elements[i]);	2701	page_to_phys(pool_entry->elements[i]);
2647	if (i == QETH_MAX_BUFFER_ELEMENTS(card) - 1)	2702	if (i == QETH_MAX_BUFFER_ELEMENTS(card) - 1)
2648	buf->buffer->element[i].eflags = SBAL_EFLAGS_LAST_ENTRY;	2703	buf->buffer->element[i].eflags = SBAL_EFLAGS_LAST_ENTRY;
2649	else	2704	else
@@ -2675,10 +2730,15 @@ static int qeth_init_qdio_queues(struct qeth_card *card) · 25 unmodified lines
2675	/* inbound queue */	2730	/* inbound queue */
2676	qdio_reset_buffers(card->qdio.in_q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q);	2731	qdio_reset_buffers(card->qdio.in_q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q);
2677	memset(&card->rx, 0, sizeof(struct qeth_rx));	2732	memset(&card->rx, 0, sizeof(struct qeth_rx));
		2733
2678	qeth_initialize_working_pool_list(card);	2734	qeth_initialize_working_pool_list(card);
2679	/give only as many buffers to hardware as we have buffer pool entries/	2735	/give only as many buffers to hardware as we have buffer pool entries/
2680	for (i = 0; i < card->qdio.in_buf_pool.buf_count - 1; ++i)	2736	for (i = 0; i < card->qdio.in_buf_pool.buf_count - 1; i++) {
2681	qeth_init_input_buffer(card, &card->qdio.in_q->bufs[i]);	2737	rc = qeth_init_input_buffer(card, &card->qdio.in_q->bufs[i]);
		2738	if (rc)
		2739	return rc;
		2740	}
		2741
2682	card->qdio.in_q->next_buf_to_init =	2742	card->qdio.in_q->next_buf_to_init =
2683	card->qdio.in_buf_pool.buf_count - 1;	2743	card->qdio.in_buf_pool.buf_count - 1;
2684	rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 0, 0,	2744	rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 0, 0,

drivers/s390/net/qeth_core_sys.c+4−5

@@ -247,8 +247,8 @@ static ssize_t qeth_dev_bufcnt_store(struct device *dev, · 246 unmodified lines
247	struct device_attribute attr, const char buf, size_t count)	247	struct device_attribute attr, const char buf, size_t count)
248	{	248	{
249	struct qeth_card *card = dev_get_drvdata(dev);	249	struct qeth_card *card = dev_get_drvdata(dev);
		250	unsigned int cnt;
250	char *tmp;	251	char *tmp;
251	int cnt, old_cnt;
252	int rc = 0;	252	int rc = 0;
253		253
254	mutex_lock(&card->conf_mutex);	254	mutex_lock(&card->conf_mutex);
@@ -257,13 +257,12 @@ static ssize_t qeth_dev_bufcnt_store(struct device *dev, · 2 unmodified lines
257	goto out;	257	goto out;
258	}	258	}
259		259
260	old_cnt = card->qdio.in_buf_pool.buf_count;
261	cnt = simple_strtoul(buf, &tmp, 10);	260	cnt = simple_strtoul(buf, &tmp, 10);
262	cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :	261	cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
263	((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);	262	((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
264	if (old_cnt != cnt) {	263
265	rc = qeth_realloc_buffer_pool(card, cnt);	264	rc = qeth_resize_buffer_pool(card, cnt);
266	}	265
267	out:	266	out:
268	mutex_unlock(&card->conf_mutex);	267	mutex_unlock(&card->conf_mutex);
269	return rc ? rc : count;	268	return rc ? rc : count;

drivers/s390/net/qeth_l2_main.c+1−0

@@ -284,6 +284,7 @@ static void qeth_l2_stop_card(struct qeth_card *card) · 283 unmodified lines
284	if (card->state == CARD_STATE_SOFTSETUP) {	284	if (card->state == CARD_STATE_SOFTSETUP) {
285	qeth_clear_ipacmd_list(card);	285	qeth_clear_ipacmd_list(card);
286	qeth_drain_output_queues(card);	286	qeth_drain_output_queues(card);
		287	cancel_delayed_work_sync(&card->buffer_reclaim_work);
287	card->state = CARD_STATE_DOWN;	288	card->state = CARD_STATE_DOWN;
288	}	289	}
289		290

drivers/s390/net/qeth_l3_main.c+1−0

@@ -1178,6 +1178,7 @@ static void qeth_l3_stop_card(struct qeth_card *card) · 1177 unmodified lines
1178	qeth_l3_clear_ip_htable(card, 1);	1178	qeth_l3_clear_ip_htable(card, 1);
1179	qeth_clear_ipacmd_list(card);	1179	qeth_clear_ipacmd_list(card);
1180	qeth_drain_output_queues(card);	1180	qeth_drain_output_queues(card);
		1181	cancel_delayed_work_sync(&card->buffer_reclaim_work);
1181	card->state = CARD_STATE_DOWN;	1182	card->state = CARD_STATE_DOWN;
1182	}	1183	}
1183		1184

drivers/s390/net/qeth_l3_sys.c+4−5

 		qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd);
 		if (card->ssqd.qdioac2 & CHSC_AC2_SNIFFER_AVAILABLE) {
 			card->options.sniffer = i;
-			if (card->qdio.init_pool.buf_count !=
+			qeth_resize_buffer_pool(card, QETH_IN_BUF_COUNT_MAX);
-					QETH_IN_BUF_COUNT_MAX)
+		} else {
-				qeth_realloc_buffer_pool(card,
-					QETH_IN_BUF_COUNT_MAX);
-		} else
 			rc = -EPERM;
+		}
 		break;
 	default:
 		rc = -EINVAL;

drivers/scsi/ipr.c+2−1

 	ioa_cfg->max_devs_supported = ipr_max_devs;
 	if (ioa_cfg->sis64) {
+		host->max_channel = IPR_MAX_SIS64_BUSES;
 		host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
 		host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
 		if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
 					   + ((sizeof(struct ipr_config_table_entry64)
 					       * ioa_cfg->max_devs_supported)));
 	} else {
+		host->max_channel = IPR_VSET_BUS;
 		host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
 		host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
 		if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
 					       * ioa_cfg->max_devs_supported)));
 	}
-	host->max_channel = IPR_VSET_BUS;
 	host->unique_id = host->host_no;
 	host->max_cmd_len = IPR_MAX_CDB_LEN;
 	host->can_queue = ioa_cfg->max_cmds;

drivers/scsi/ipr.h+1−0

@@ -1300,6 +1300,7 @@ struct ipr_resource_entry { · 1299 unmodified lines
1300	#define IPR_ARRAY_VIRTUAL_BUS 0x1	1300	#define IPR_ARRAY_VIRTUAL_BUS 0x1
1301	#define IPR_VSET_VIRTUAL_BUS 0x2	1301	#define IPR_VSET_VIRTUAL_BUS 0x2
1302	#define IPR_IOAFP_VIRTUAL_BUS 0x3	1302	#define IPR_IOAFP_VIRTUAL_BUS 0x3
		1303	#define IPR_MAX_SIS64_BUSES 0x4
1303		1304
1304	#define IPR_GET_RES_PHYS_LOC(res) \	1305	#define IPR_GET_RES_PHYS_LOC(res) \
1305	(((res)->bus << 24) \| ((res)->target << 8) \| (res)->lun)	1306	(((res)->bus << 24) \| ((res)->target << 8) \| (res)->lun)

drivers/scsi/ufs/ufshcd.c+14−7

 void ufshcd_auto_hibern8_update(struct ufs_hba *hba, u32 ahit)
 {
 	unsigned long flags;
+	bool update = false;
-	if (!(hba->capabilities & MASK_AUTO_HIBERN8_SUPPORT))
+	if (!ufshcd_is_auto_hibern8_supported(hba))
 		return;
 	spin_lock_irqsave(hba->host->host_lock, flags);
-	if (hba->ahit == ahit)
+	if (hba->ahit != ahit) {
-		goto out_unlock;
+		hba->ahit = ahit;
-	hba->ahit = ahit;
+		update = true;
-	if (!pm_runtime_suspended(hba->dev))
+	}
-		ufshcd_writel(hba, hba->ahit, REG_AUTO_HIBERNATE_IDLE_TIMER);
-out_unlock:
 	spin_unlock_irqrestore(hba->host->host_lock, flags);
+	if (update && !pm_runtime_suspended(hba->dev)) {
+		pm_runtime_get_sync(hba->dev);
+		ufshcd_hold(hba, false);
+		ufshcd_auto_hibern8_enable(hba);
+		ufshcd_release(hba);
+		pm_runtime_put(hba->dev);
+	}
 }
 EXPORT_SYMBOL_GPL(ufshcd_auto_hibern8_update);

drivers/slimbus/qcom-ngd-ctrl.c+3−0

 	{
 		.compatible = "qcom,slim-ngd-v1.5.0",
 		.data = &ngd_v1_5_offset_info,
+	},{
+		.compatible = "qcom,slim-ngd-v2.1.0",
+		.data = &ngd_v1_5_offset_info,
 	},
 	{}
 };

drivers/staging/greybus/tools/loopback_test.c+11−10

 #include <signal.h>
 #define MAX_NUM_DEVICES 10
+#define MAX_SYSFS_PREFIX 0x80
 #define MAX_SYSFS_PATH	0x200
 #define CSV_MAX_LINE	0x1000
 #define SYSFS_MAX_INT	0x20
 };
 struct loopback_device {
-	char name[MAX_SYSFS_PATH];
+	char name[MAX_STR_LEN];
 	char sysfs_entry[MAX_SYSFS_PATH];
 	char debugfs_entry[MAX_SYSFS_PATH];
 	struct loopback_results results;
 	int stop_all;
 	int poll_count;
 	char test_name[MAX_STR_LEN];
-	char sysfs_prefix[MAX_SYSFS_PATH];
+	char sysfs_prefix[MAX_SYSFS_PREFIX];
-	char debugfs_prefix[MAX_SYSFS_PATH];
+	char debugfs_prefix[MAX_SYSFS_PREFIX];
 	struct timespec poll_timeout;
 	struct loopback_device devices[MAX_NUM_DEVICES];
 	struct loopback_results aggregate_results;
 static int open_poll_files(struct loopback_test *t)
 {
 	struct loopback_device *dev;
-	char buf[MAX_STR_LEN];
+	char buf[MAX_SYSFS_PATH + MAX_STR_LEN];
 	char dummy;
 	int fds_idx = 0;
 	int i;
 			goto err;
 		}
 		read(t->fds[fds_idx].fd, &dummy, 1);
-		t->fds[fds_idx].events = EPOLLERR|EPOLLPRI;
+		t->fds[fds_idx].events = POLLERR | POLLPRI;
 		t->fds[fds_idx].revents = 0;
 		fds_idx++;
 	}
 		}
 		for (i = 0; i < t->poll_count; i++) {
-			if (t->fds[i].revents & EPOLLPRI) {
+			if (t->fds[i].revents & POLLPRI) {
 				/* Dummy read to clear the event */
 				read(t->fds[i].fd, &dummy, 1);
 				number_of_events++;
 			t.iteration_max = atoi(optarg);
 			break;
 		case 'S':
-			snprintf(t.sysfs_prefix, MAX_SYSFS_PATH, "%s", optarg);
+			snprintf(t.sysfs_prefix, MAX_SYSFS_PREFIX, "%s", optarg);
 			break;
 		case 'D':
-			snprintf(t.debugfs_prefix, MAX_SYSFS_PATH, "%s", optarg);
+			snprintf(t.debugfs_prefix, MAX_SYSFS_PREFIX, "%s", optarg);
 			break;
 		case 'm':
 			t.mask = atol(optarg);
 	}
 	if (!strcmp(t.sysfs_prefix, ""))
-		snprintf(t.sysfs_prefix, MAX_SYSFS_PATH, "%s", sysfs_prefix);
+		snprintf(t.sysfs_prefix, MAX_SYSFS_PREFIX, "%s", sysfs_prefix);
 	if (!strcmp(t.debugfs_prefix, ""))
-		snprintf(t.debugfs_prefix, MAX_SYSFS_PATH, "%s", debugfs_prefix);
+		snprintf(t.debugfs_prefix, MAX_SYSFS_PREFIX, "%s", debugfs_prefix);
 	ret = find_loopback_devices(&t);
 	if (ret)

drivers/staging/rtl8188eu/os_dep/usb_intf.c+1−0

@@ -38,6 +38,7 @@ static const struct usb_device_id rtw_usb_id_tbl[] = { · 37 unmodified lines
38	{USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */	38	{USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */
39	{USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */	39	{USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */
40	{USB_DEVICE(0x2357, 0x0111)}, /* TP-Link TL-WN727N v5.21 */	40	{USB_DEVICE(0x2357, 0x0111)}, /* TP-Link TL-WN727N v5.21 */
		41	{USB_DEVICE(0x2C4E, 0x0102)}, /* MERCUSYS MW150US v2 */
41	{USB_DEVICE(0x0df6, 0x0076)}, /* Sitecom N150 v2 */	42	{USB_DEVICE(0x0df6, 0x0076)}, /* Sitecom N150 v2 */
42	{USB_DEVICE(USB_VENDER_ID_REALTEK, 0xffef)}, /* Rosewill RNX-N150NUB */	43	{USB_DEVICE(USB_VENDER_ID_REALTEK, 0xffef)}, /* Rosewill RNX-N150NUB */
43	{} /* Terminating entry */	44	{} /* Terminating entry */

drivers/staging/speakup/main.c+1−1

@@ -561,7 +561,7 @@ static u_long get_word(struct vc_data *vc) · 560 unmodified lines
561	return 0;	561	return 0;
562	} else if (tmpx < vc->vc_cols - 2 &&	562	} else if (tmpx < vc->vc_cols - 2 &&
563	(ch == SPACE \|\| ch == 0 \|\| (ch < 0x100 && IS_WDLM(ch))) &&	563	(ch == SPACE \|\| ch == 0 \|\| (ch < 0x100 && IS_WDLM(ch))) &&
564	get_char(vc, (u_short *)&tmp_pos + 1, &temp) > SPACE) {	564	get_char(vc, (u_short *)tmp_pos + 1, &temp) > SPACE) {
565	tmp_pos += 2;	565	tmp_pos += 2;
566	tmpx++;	566	tmpx++;
567	} else {	567	} else {

drivers/staging/wfx/hif_tx.c+8−7

 	else
 		control_reg_write(wdev, 0);
 	mutex_unlock(&wdev->hif_cmd.lock);
+	mutex_unlock(&wdev->hif_cmd.key_renew_lock);
 	kfree(hif);
 	return ret;
 }
 }
 int hif_join(struct wfx_vif *wvif, const struct ieee80211_bss_conf *conf,
-	     const struct ieee80211_channel *channel, const u8 *ssidie)
+	     struct ieee80211_channel *channel, const u8 *ssid, int ssidlen)
 {
 	int ret;
 	struct hif_msg *hif;
 	body->basic_rate_set =
 		cpu_to_le32(wfx_rate_mask_to_hw(wvif->wdev, conf->basic_rates));
 	memcpy(body->bssid, conf->bssid, sizeof(body->bssid));
-	if (!conf->ibss_joined && ssidie) {
+	if (!conf->ibss_joined && ssid) {
-		body->ssid_length = cpu_to_le32(ssidie[1]);
+		body->ssid_length = cpu_to_le32(ssidlen);
-		memcpy(body->ssid, &ssidie[2], ssidie[1]);
+		memcpy(body->ssid, ssid, ssidlen);
 	}
 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_JOIN, sizeof(*body));
 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
 	struct hif_msg *hif;
 	struct hif_req_start *body = wfx_alloc_hif(sizeof(*body), &hif);
-	body->dtim_period = conf->dtim_period,
+	body->dtim_period = conf->dtim_period;
-	body->short_preamble = conf->use_short_preamble,
+	body->short_preamble = conf->use_short_preamble;
-	body->channel_number = cpu_to_le16(channel->hw_value),
+	body->channel_number = cpu_to_le16(channel->hw_value);
 	body->beacon_interval = cpu_to_le32(conf->beacon_int);
 	body->basic_rate_set =
 		cpu_to_le32(wfx_rate_mask_to_hw(wvif->wdev, conf->basic_rates));

drivers/staging/wfx/hif_tx.h+1−1

@@ -46,7 +46,7 @@ int hif_scan(struct wfx_vif wvif, struct cfg80211_scan_request req80211, · 45 unmodified lines
46	int chan_start, int chan_num);	46	int chan_start, int chan_num);
47	int hif_stop_scan(struct wfx_vif *wvif);	47	int hif_stop_scan(struct wfx_vif *wvif);
48	int hif_join(struct wfx_vif wvif, const struct ieee80211_bss_conf conf,	48	int hif_join(struct wfx_vif wvif, const struct ieee80211_bss_conf conf,
49	const struct ieee80211_channel channel, const u8 ssidie);	49	struct ieee80211_channel channel, const u8 ssid, int ssidlen);
50	int hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout);	50	int hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout);
51	int hif_set_bss_params(struct wfx_vif *wvif,	51	int hif_set_bss_params(struct wfx_vif *wvif,
52	const struct hif_req_set_bss_params *arg);	52	const struct hif_req_set_bss_params *arg);

drivers/staging/wfx/hif_tx_mib.h+10−5

 }
 static inline int hif_set_association_mode(struct wfx_vif *wvif,
-					   struct ieee80211_bss_conf *info,
+					   struct ieee80211_bss_conf *info)
-					   struct ieee80211_sta_ht_cap *ht_cap)
 {
 	int basic_rates = wfx_rate_mask_to_hw(wvif->wdev, info->basic_rates);
+	struct ieee80211_sta *sta = NULL;
 	struct hif_mib_set_association_mode val = {
 		.preambtype_use = 1,
 		.mode = 1,
 		.basic_rate_set = cpu_to_le32(basic_rates)
 	};
+	rcu_read_lock(); // protect sta
+	if (info->bssid && !info->ibss_joined)
+		sta = ieee80211_find_sta(wvif->vif, info->bssid);
 	// FIXME: it is strange to not retrieve all information from bss_info
-	if (ht_cap && ht_cap->ht_supported) {
+	if (sta && sta->ht_cap.ht_supported) {
-		val.mpdu_start_spacing = ht_cap->ampdu_density;
+		val.mpdu_start_spacing = sta->ht_cap.ampdu_density;
 		if (!(info->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT))
-			val.greenfield = !!(ht_cap->cap & IEEE80211_HT_CAP_GRN_FLD);
+			val.greenfield = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD);
 	}
+	rcu_read_unlock();
 	return hif_write_mib(wvif->wdev, wvif->id,
 			     HIF_MIB_ID_SET_ASSOCIATION_MODE, &val, sizeof(val));

drivers/staging/wfx/sta.c+15−10

 static void wfx_do_join(struct wfx_vif *wvif)
 {
 	int ret;
-	const u8 *ssidie;
 	struct ieee80211_bss_conf *conf = &wvif->vif->bss_conf;
 	struct cfg80211_bss *bss = NULL;
+	u8 ssid[IEEE80211_MAX_SSID_LEN];
+	const u8 *ssidie = NULL;
+	int ssidlen = 0;
 	wfx_tx_lock_flush(wvif->wdev);
 	if (!wvif->beacon_int)
 		wvif->beacon_int = 1;
-	rcu_read_lock();
+	rcu_read_lock(); // protect ssidie
 	if (!conf->ibss_joined)
 		ssidie = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
-	else
+	if (ssidie) {
-		ssidie = NULL;
+		ssidlen = ssidie[1];
+		memcpy(ssid, &ssidie[2], ssidie[1]);
+	}
+	rcu_read_unlock();
 	wfx_tx_flush(wvif->wdev);
 	wfx_set_mfp(wvif, bss);
-	/* Perform actual join */
 	wvif->wdev->tx_burst_idx = -1;
-	ret = hif_join(wvif, conf, wvif->channel, ssidie);
+	ret = hif_join(wvif, conf, wvif->channel, ssid, ssidlen);
-	rcu_read_unlock();
 	if (ret) {
 		ieee80211_connection_loss(wvif->vif);
 		wvif->join_complete_status = -1;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(sta_priv->buffered); i++)
-		WARN(sta_priv->buffered[i], "release station while Tx is in progress");
+		if (sta_priv->buffered[i])
+			dev_warn(wvif->wdev->dev, "release station while %d pending frame on queue %d",
+				 sta_priv->buffered[i], i);
 	// FIXME: see note in wfx_sta_add()
 	if (vif->type == NL80211_IFTYPE_STATION)
 		return 0;
 			wfx_rate_mask_to_hw(wvif->wdev, sta->supp_rates[wvif->channel->band]);
 	else
 		wvif->bss_params.operational_rate_set = -1;
+	rcu_read_unlock();
 	if (sta &&
 	    info->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)
 		hif_dual_cts_protection(wvif, true);
 	wvif->bss_params.beacon_lost_count = 20;
 	wvif->bss_params.aid = info->aid;
-	hif_set_association_mode(wvif, info, sta ? &sta->ht_cap : NULL);
+	hif_set_association_mode(wvif, info);
-	rcu_read_unlock();
 	if (!info->ibss_joined) {
 		hif_keep_alive_period(wvif, 30 /* sec */);

drivers/thunderbolt/switch.c+1−1

@@ -954,7 +954,7 @@ static bool tb_port_is_width_supported(struct tb_port *port, int width) · 953 unmodified lines
954	ret = tb_port_read(port, &phy, TB_CFG_PORT,	954	ret = tb_port_read(port, &phy, TB_CFG_PORT,
955	port->cap_phy + LANE_ADP_CS_0, 1);	955	port->cap_phy + LANE_ADP_CS_0, 1);
956	if (ret)	956	if (ret)
957	return ret;	957	return false;
958		958
959	widths = (phy & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >>	959	widths = (phy & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >>
960	LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT;	960	LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT;

drivers/tty/tty_io.c+6−8

 	tty_debug_hangup(tty, "freeing structure\n");
 	/*
 	 * The release_tty function takes care of the details of clearing
-	 * the slots and preserving the termios structure. The tty_unlock_pair
+	 * the slots and preserving the termios structure.
-	 * should be safe as we keep a kref while the tty is locked (so the
-	 * unlock never unlocks a freed tty).
 	 */
 	mutex_lock(&tty_mutex);
 	tty_port_set_kopened(tty->port, 0);
 	tty_debug_hangup(tty, "freeing structure\n");
 	/*
 	 * The release_tty function takes care of the details of clearing
-	 * the slots and preserving the termios structure. The tty_unlock_pair
+	 * the slots and preserving the termios structure.
-	 * should be safe as we keep a kref while the tty is locked (so the
-	 * unlock never unlocks a freed tty).
 	 */
 	mutex_lock(&tty_mutex);
 	release_tty(tty, idx);
 	struct serial_struct32 v32;
 	struct serial_struct v;
 	int err;
-	memset(&v, 0, sizeof(struct serial_struct));
-	if (!tty->ops->set_serial)
+	memset(&v, 0, sizeof(v));
+	memset(&v32, 0, sizeof(v32));
+	if (!tty->ops->get_serial)
 		return -ENOTTY;
 	err = tty->ops->get_serial(tty, &v);
 	if (!err) {

drivers/usb/chipidea/udc.c+4−3

 static void ci_hdrc_gadget_connect(struct usb_gadget *_gadget, int is_active)
 {
 	struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
-	unsigned long flags;
 	if (is_active) {
 		pm_runtime_get_sync(&_gadget->dev);
 		hw_device_reset(ci);
-		spin_lock_irqsave(&ci->lock, flags);
+		spin_lock_irq(&ci->lock);
 		if (ci->driver) {
 			hw_device_state(ci, ci->ep0out->qh.dma);
 			usb_gadget_set_state(_gadget, USB_STATE_POWERED);
+			spin_unlock_irq(&ci->lock);
 			usb_udc_vbus_handler(_gadget, true);
+		} else {
+			spin_unlock_irq(&ci->lock);
 		}
-		spin_unlock_irqrestore(&ci->lock, flags);
 	} else {
 		usb_udc_vbus_handler(_gadget, false);
 		if (ci->driver)

drivers/usb/class/cdc-acm.c+21−13

 	ss->xmit_fifo_size = acm->writesize;
 	ss->baud_base = le32_to_cpu(acm->line.dwDTERate);
-	ss->close_delay	= acm->port.close_delay / 10;
+	ss->close_delay	= jiffies_to_msecs(acm->port.close_delay) / 10;
 	ss->closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 				ASYNC_CLOSING_WAIT_NONE :
-				acm->port.closing_wait / 10;
+				jiffies_to_msecs(acm->port.closing_wait) / 10;
 	return 0;
 }
 {
 	struct acm *acm = tty->driver_data;
 	unsigned int closing_wait, close_delay;
+	unsigned int old_closing_wait, old_close_delay;
 	int retval = 0;
-	close_delay = ss->close_delay * 10;
+	close_delay = msecs_to_jiffies(ss->close_delay * 10);
 	closing_wait = ss->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
-			ASYNC_CLOSING_WAIT_NONE : ss->closing_wait * 10;
+			ASYNC_CLOSING_WAIT_NONE :
+			msecs_to_jiffies(ss->closing_wait * 10);
+	/* we must redo the rounding here, so that the values match */
+	old_close_delay	= jiffies_to_msecs(acm->port.close_delay) / 10;
+	old_closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
+				ASYNC_CLOSING_WAIT_NONE :
+				jiffies_to_msecs(acm->port.closing_wait) / 10;
 	mutex_lock(&acm->port.mutex);
-	if (!capable(CAP_SYS_ADMIN)) {
+	if ((ss->close_delay != old_close_delay) ||
-		if ((close_delay != acm->port.close_delay) ||
+            (ss->closing_wait != old_closing_wait)) {
-		    (closing_wait != acm->port.closing_wait))
+		if (!capable(CAP_SYS_ADMIN))
 			retval = -EPERM;
-		else
+		else {
-			retval = -EOPNOTSUPP;
+			acm->port.close_delay  = close_delay;
-	} else {
+			acm->port.closing_wait = closing_wait;
-		acm->port.close_delay  = close_delay;
+		}
-		acm->port.closing_wait = closing_wait;
+	} else
-	}
+		retval = -EOPNOTSUPP;
 	mutex_unlock(&acm->port.mutex);
 	return retval;

drivers/usb/core/quirks.c+6−0

 	{ USB_DEVICE(0x0b05, 0x17e0), .driver_info =
 			USB_QUIRK_IGNORE_REMOTE_WAKEUP },
+	/* Realtek hub in Dell WD19 (Type-C) */
+	{ USB_DEVICE(0x0bda, 0x0487), .driver_info = USB_QUIRK_NO_LPM },
+	/* Generic RTL8153 based ethernet adapters */
+	{ USB_DEVICE(0x0bda, 0x8153), .driver_info = USB_QUIRK_NO_LPM },
 	/* Action Semiconductor flash disk */
 	{ USB_DEVICE(0x10d6, 0x2200), .driver_info =
 			USB_QUIRK_STRING_FETCH_255 },

drivers/usb/host/xhci-pci.c+2−1

@@ -136,7 +136,8 @@ static void xhci_pci_quirks(struct device dev, struct xhci_hcd xhci) · 135 unmodified lines
136	xhci->quirks \|= XHCI_AMD_PLL_FIX;	136	xhci->quirks \|= XHCI_AMD_PLL_FIX;
137		137
138	if (pdev->vendor == PCI_VENDOR_ID_AMD &&	138	if (pdev->vendor == PCI_VENDOR_ID_AMD &&
139	(pdev->device == 0x15e0 \|\|	139	(pdev->device == 0x145c \|\|
		140	pdev->device == 0x15e0 \|\|
140	pdev->device == 0x15e1 \|\|	141	pdev->device == 0x15e1 \|\|
141	pdev->device == 0x43bb))	142	pdev->device == 0x43bb))
142	xhci->quirks \|= XHCI_SUSPEND_DELAY;	143	xhci->quirks \|= XHCI_SUSPEND_DELAY;

drivers/usb/host/xhci-plat.c+1−0

@@ -445,6 +445,7 @@ MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match); · 444 unmodified lines
445	static struct platform_driver usb_xhci_driver = {	445	static struct platform_driver usb_xhci_driver = {
446	.probe = xhci_plat_probe,	446	.probe = xhci_plat_probe,
447	.remove = xhci_plat_remove,	447	.remove = xhci_plat_remove,
		448	.shutdown = usb_hcd_platform_shutdown,
448	.driver = {	449	.driver = {
449	.name = "xhci-hcd",	450	.name = "xhci-hcd",
450	.pm = &xhci_plat_pm_ops,	451	.pm = &xhci_plat_pm_ops,

drivers/usb/host/xhci-trace.h+6−17

 	),
 	TP_printk("ep%d%s-%s: urb %p pipe %u slot %d length %d/%d sgs %d/%d stream %d flags %08x",
 			__entry->epnum, __entry->dir_in ? "in" : "out",
-			({ char *s;
+			__print_symbolic(__entry->type,
-			switch (__entry->type) {
+				   { USB_ENDPOINT_XFER_INT,	"intr" },
-			case USB_ENDPOINT_XFER_INT:
+				   { USB_ENDPOINT_XFER_CONTROL,	"control" },
-				s = "intr";
+				   { USB_ENDPOINT_XFER_BULK,	"bulk" },
-				break;
+				   { USB_ENDPOINT_XFER_ISOC,	"isoc" }),
-			case USB_ENDPOINT_XFER_CONTROL:
+			__entry->urb, __entry->pipe, __entry->slot_id,
-				s = "control";
-				break;
-			case USB_ENDPOINT_XFER_BULK:
-				s = "bulk";
-				break;
-			case USB_ENDPOINT_XFER_ISOC:
-				s = "isoc";
-				break;
-			default:
-				s = "UNKNOWN";
-			} s; }), __entry->urb, __entry->pipe, __entry->slot_id,
 			__entry->actual, __entry->length, __entry->num_mapped_sgs,
 			__entry->num_sgs, __entry->stream, __entry->flags
 		)

drivers/usb/serial/option.c+2−0

 	  .driver_info = NCTRL(0) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x110a, 0xff),	/* Telit ME910G1 */
 	  .driver_info = NCTRL(0) | RSVD(3) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x110b, 0xff),	/* Telit ME910G1 (ECM) */
+	  .driver_info = NCTRL(0) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910),
 	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910_USBCFG4),

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

@@ -99,6 +99,7 @@ static const struct usb_device_id id_table[] = { · 98 unmodified lines
99	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },	99	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
100	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },	100	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
101	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },	101	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
		102	{ USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
102	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },	103	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
103	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },	104	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
104	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },	105	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },

drivers/usb/serial/pl2303.h+1−0

@@ -130,6 +130,7 @@ · 129 unmodified lines
130	#define HP_LM920_PRODUCT_ID 0x026b	130	#define HP_LM920_PRODUCT_ID 0x026b
131	#define HP_TD620_PRODUCT_ID 0x0956	131	#define HP_TD620_PRODUCT_ID 0x0956
132	#define HP_LD960_PRODUCT_ID 0x0b39	132	#define HP_LD960_PRODUCT_ID 0x0b39
		133	#define HP_LD381_PRODUCT_ID 0x0f7f
133	#define HP_LCM220_PRODUCT_ID 0x3139	134	#define HP_LCM220_PRODUCT_ID 0x3139
134	#define HP_LCM960_PRODUCT_ID 0x3239	135	#define HP_LCM960_PRODUCT_ID 0x3239
135	#define HP_LD220_PRODUCT_ID 0x3524	136	#define HP_LD220_PRODUCT_ID 0x3524

drivers/usb/typec/ucsi/displayport.c+11−1

 		return;
 	dp = typec_altmode_get_drvdata(alt);
+	if (!dp)
+		return;
 	dp->data.conf = 0;
 	dp->data.status = 0;
 	dp->initialized = false;
 	struct typec_altmode *alt;
 	struct ucsi_dp *dp;
+	mutex_lock(&con->lock);
 	/* We can't rely on the firmware with the capabilities. */
 	desc->vdo |= DP_CAP_DP_SIGNALING | DP_CAP_RECEPTACLE;
 	desc->vdo |= all_assignments << 16;
 	alt = typec_port_register_altmode(con->port, desc);
-	if (IS_ERR(alt))
+	if (IS_ERR(alt)) {
+		mutex_unlock(&con->lock);
 		return alt;
+	}
 	dp = devm_kzalloc(&alt->dev, sizeof(*dp), GFP_KERNEL);
 	if (!dp) {
 		typec_unregister_altmode(alt);
+		mutex_unlock(&con->lock);
 		return ERR_PTR(-ENOMEM);
 	}
 	alt->ops = &ucsi_displayport_ops;
 	typec_altmode_set_drvdata(alt, dp);
+	mutex_unlock(&con->lock);
 	return alt;
 }

drivers/virtio/virtio_balloon.c+1−1

 	iput(vb->vb_dev_info.inode);
 out_kern_unmount:
 	kern_unmount(balloon_mnt);
-#endif
 out_del_vqs:
+#endif
 	vdev->config->del_vqs(vdev);
 out_free_vb:
 	kfree(vb);

drivers/virtio/virtio_ring.c+2−2

 					 vq->split.queue_size_in_bytes,
 					 vq->split.vring.desc,
 					 vq->split.queue_dma_addr);
-			kfree(vq->split.desc_state);
 		}
 	}
+	if (!vq->packed_ring)
+		kfree(vq->split.desc_state);
 	list_del(&_vq->list);
 	kfree(vq);
 }

drivers/watchdog/iTCO_vendor.h+2−0

 /* SPDX-License-Identifier: GPL-2.0 */
 /* iTCO Vendor Specific Support hooks */
 #ifdef CONFIG_ITCO_VENDOR_SUPPORT
+extern int iTCO_vendorsupport;
 extern void iTCO_vendor_pre_start(struct resource *, unsigned int);
 extern void iTCO_vendor_pre_stop(struct resource *);
 extern int iTCO_vendor_check_noreboot_on(void);
 #else
+#define iTCO_vendorsupport				0
 #define iTCO_vendor_pre_start(acpibase, heartbeat)	{}
 #define iTCO_vendor_pre_stop(acpibase)			{}
 #define iTCO_vendor_check_noreboot_on()			1

drivers/watchdog/iTCO_vendor_support.c+9−7

 /* Broken BIOS */
 #define BROKEN_BIOS		911
-static int vendorsupport;
+int iTCO_vendorsupport;
-module_param(vendorsupport, int, 0);
+EXPORT_SYMBOL(iTCO_vendorsupport);
+module_param_named(vendorsupport, iTCO_vendorsupport, int, 0);
 MODULE_PARM_DESC(vendorsupport, "iTCO vendor specific support mode, default="
 			"0 (none), 1=SuperMicro Pent3, 911=Broken SMI BIOS");
 void iTCO_vendor_pre_start(struct resource *smires,
 			   unsigned int heartbeat)
 {
-	switch (vendorsupport) {
+	switch (iTCO_vendorsupport) {
 	case SUPERMICRO_OLD_BOARD:
 		supermicro_old_pre_start(smires);
 		break;
 void iTCO_vendor_pre_stop(struct resource *smires)
 {
-	switch (vendorsupport) {
+	switch (iTCO_vendorsupport) {
 	case SUPERMICRO_OLD_BOARD:
 		supermicro_old_pre_stop(smires);
 		break;
 int iTCO_vendor_check_noreboot_on(void)
 {
-	switch (vendorsupport) {
+	switch (iTCO_vendorsupport) {
 	case SUPERMICRO_OLD_BOARD:
 		return 0;
 	default:
 static int __init iTCO_vendor_init_module(void)
 {
-	if (vendorsupport == SUPERMICRO_NEW_BOARD) {
+	if (iTCO_vendorsupport == SUPERMICRO_NEW_BOARD) {
 		pr_warn("Option vendorsupport=%d is no longer supported, "
 			"please use the w83627hf_wdt driver instead\n",
 			SUPERMICRO_NEW_BOARD);
 		return -EINVAL;
 	}
-	pr_info("vendor-support=%d\n", vendorsupport);
+	pr_info("vendor-support=%d\n", iTCO_vendorsupport);
 	return 0;
 }

drivers/watchdog/iTCO_wdt.c+16−12

 	if (!p->tco_res)
 		return -ENODEV;
-	p->smi_res = platform_get_resource(pdev, IORESOURCE_IO, ICH_RES_IO_SMI);
-	if (!p->smi_res)
-		return -ENODEV;
 	p->iTCO_version = pdata->version;
 	p->pci_dev = to_pci_dev(dev->parent);
+	p->smi_res = platform_get_resource(pdev, IORESOURCE_IO, ICH_RES_IO_SMI);
+	if (p->smi_res) {
+		/* The TCO logic uses the TCO_EN bit in the SMI_EN register */
+		if (!devm_request_region(dev, p->smi_res->start,
+					 resource_size(p->smi_res),
+					 pdev->name)) {
+			pr_err("I/O address 0x%04llx already in use, device disabled\n",
+			       (u64)SMI_EN(p));
+			return -EBUSY;
+		}
+	} else if (iTCO_vendorsupport ||
+		   turn_SMI_watchdog_clear_off >= p->iTCO_version) {
+		pr_err("SMI I/O resource is missing\n");
+		return -ENODEV;
+	}
 	iTCO_wdt_no_reboot_bit_setup(p, pdata);
 	/*
 	/* Set the NO_REBOOT bit to prevent later reboots, just for sure */
 	p->update_no_reboot_bit(p->no_reboot_priv, true);
-	/* The TCO logic uses the TCO_EN bit in the SMI_EN register */
-	if (!devm_request_region(dev, p->smi_res->start,
-				 resource_size(p->smi_res),
-				 pdev->name)) {
-		pr_err("I/O address 0x%04llx already in use, device disabled\n",
-		       (u64)SMI_EN(p));
-		return -EBUSY;
-	}
 	if (turn_SMI_watchdog_clear_off >= p->iTCO_version) {
 		/*
 		 * Bit 13: TCO_EN -> 0

fs/afs/addr_list.c+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	void afs_put_addrlist(struct afs_addr_list *alist)	19	void afs_put_addrlist(struct afs_addr_list *alist)
20	{	20	{
21	if (alist && refcount_dec_and_test(&alist->usage))	21	if (alist && refcount_dec_and_test(&alist->usage))
22	call_rcu(&alist->rcu, (rcu_callback_t)kfree);	22	kfree_rcu(alist, rcu);
23	}	23	}
24		24
25	/*	25	/*

fs/afs/internal.h+1−1

@@ -81,7 +81,7 @@ enum afs_call_state { · 80 unmodified lines
81	* List of server addresses.	81	* List of server addresses.
82	*/	82	*/
83	struct afs_addr_list {	83	struct afs_addr_list {
84	struct rcu_head rcu; /* Must be first */	84	struct rcu_head rcu;
85	refcount_t usage;	85	refcount_t usage;
86	u32 version; /* Version */	86	u32 version; /* Version */
87	unsigned char max_addrs;	87	unsigned char max_addrs;

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

@@ -856,9 +856,9 @@ static void clear_incompat_bg_bits(struct btrfs_fs_info *fs_info, u64 flags) · 855 unmodified lines
856	found_raid1c34 = true;	856	found_raid1c34 = true;
857	up_read(&sinfo->groups_sem);	857	up_read(&sinfo->groups_sem);
858	}	858	}
859	if (found_raid56)	859	if (!found_raid56)
860	btrfs_clear_fs_incompat(fs_info, RAID56);	860	btrfs_clear_fs_incompat(fs_info, RAID56);
861	if (found_raid1c34)	861	if (!found_raid1c34)
862	btrfs_clear_fs_incompat(fs_info, RAID1C34);	862	btrfs_clear_fs_incompat(fs_info, RAID1C34);
863	}	863	}
864	}	864	}

fs/btrfs/inode.c+4−0

 		ret = btrfs_sync_log(trans, BTRFS_I(old_inode)->root, &ctx);
 		if (ret)
 			commit_transaction = true;
+	} else if (sync_log) {
+		mutex_lock(&root->log_mutex);
+		list_del(&ctx.list);
+		mutex_unlock(&root->log_mutex);
 	}
 	if (commit_transaction) {
 		ret = btrfs_commit_transaction(trans);

fs/cifs/dir.c+0−1

@@ -555,7 +555,6 @@ cifs_atomic_open(struct inode inode, struct dentry direntry, · 554 unmodified lines
555	if (server->ops->close)	555	if (server->ops->close)
556	server->ops->close(xid, tcon, &fid);	556	server->ops->close(xid, tcon, &fid);
557	cifs_del_pending_open(&open);	557	cifs_del_pending_open(&open);
558	fput(file);
559	rc = -ENOMEM;	558	rc = -ENOMEM;
560	}	559	}
561		560

fs/cifs/file.c+2−1

 	rc = posix_lock_file(file, flock, NULL);
 	up_write(&cinode->lock_sem);
 	if (rc == FILE_LOCK_DEFERRED) {
-		rc = wait_event_interruptible(flock->fl_wait, !flock->fl_blocker);
+		rc = wait_event_interruptible(flock->fl_wait,
+					list_empty(&flock->fl_blocked_member));
 		if (!rc)
 			goto try_again;
 		locks_delete_block(flock);

fs/cifs/inode.c+1−1

@@ -2191,7 +2191,7 @@ int cifs_getattr(const struct path path, struct kstat stat, · 2190 unmodified lines
2191	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))	2191	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2192	stat->gid = current_fsgid();	2192	stat->gid = current_fsgid();
2193	}	2193	}
2194	return rc;	2194	return 0;
2195	}	2195	}
2196		2196
2197	int cifs_fiemap(struct inode inode, struct fiemap_extent_info fei, u64 start,	2197	int cifs_fiemap(struct inode inode, struct fiemap_extent_info fei, u64 start,

fs/cifs/smb2ops.c+3−1

 		goto qdf_free;
 	}
+	atomic_inc(&tcon->num_remote_opens);
 	qd_rsp = (struct smb2_query_directory_rsp *)rsp_iov[1].iov_base;
 	if (qd_rsp->sync_hdr.Status == STATUS_NO_MORE_FILES) {
 		trace_smb3_query_dir_done(xid, fid->persistent_fid,
 	if (rc)
 		goto out;
-	if (out_data_len < sizeof(struct file_allocated_range_buffer)) {
+	if (out_data_len && out_data_len < sizeof(struct file_allocated_range_buffer)) {
 		rc = -EINVAL;
 		goto out;
 	}

fs/crypto/keysetup.c+9−0

@@ -538,6 +538,15 @@ int fscrypt_drop_inode(struct inode *inode) · 537 unmodified lines
538	return 0;	538	return 0;
539	mk = ci->ci_master_key->payload.data[0];	539	mk = ci->ci_master_key->payload.data[0];
540		540
		541	/*
		542	* With proper, non-racy use of FS_IOC_REMOVE_ENCRYPTION_KEY, all inodes
		543	* protected by the key were cleaned by sync_filesystem(). But if
		544	* userspace is still using the files, inodes can be dirtied between
		545	* then and now. We mustn't lose any writes, so skip dirty inodes here.
		546	*/
		547	if (inode->i_state & I_DIRTY_ALL)
		548	return 0;
		549
541	/*	550	/*
542	* Note: since we aren't holding ->mk_secret_sem, the result here can	551	* Note: since we aren't holding ->mk_secret_sem, the result here can
543	* immediately become outdated. But there's no correctness problem with	552	* immediately become outdated. But there's no correctness problem with

fs/eventpoll.c+4−4

@@ -1854,9 +1854,9 @@ fetch_events: · 1853 unmodified lines
1854	waiter = true;	1854	waiter = true;
1855	init_waitqueue_entry(&wait, current);	1855	init_waitqueue_entry(&wait, current);
1856		1856
1857	spin_lock_irq(&ep->wq.lock);	1857	write_lock_irq(&ep->lock);
1858	__add_wait_queue_exclusive(&ep->wq, &wait);	1858	__add_wait_queue_exclusive(&ep->wq, &wait);
1859	spin_unlock_irq(&ep->wq.lock);	1859	write_unlock_irq(&ep->lock);
1860	}	1860	}
1861		1861
1862	for (;;) {	1862	for (;;) {
@@ -1904,9 +1904,9 @@ send_events: · 41 unmodified lines
1904	goto fetch_events;	1904	goto fetch_events;
1905		1905
1906	if (waiter) {	1906	if (waiter) {
1907	spin_lock_irq(&ep->wq.lock);	1907	write_lock_irq(&ep->lock);
1908	__remove_wait_queue(&ep->wq, &wait);	1908	__remove_wait_queue(&ep->wq, &wait);
1909	spin_unlock_irq(&ep->wq.lock);	1909	write_unlock_irq(&ep->lock);
1910	}	1910	}
1911		1911
1912	return res;	1912	return res;

fs/file.c+6−1

 	return __alloc_fd(current->files, start, rlimit(RLIMIT_NOFILE), flags);
 }
+int __get_unused_fd_flags(unsigned flags, unsigned long nofile)
+{
+	return __alloc_fd(current->files, 0, nofile, flags);
+}
 int get_unused_fd_flags(unsigned flags)
 {
-	return __alloc_fd(current->files, 0, rlimit(RLIMIT_NOFILE), flags);
+	return __get_unused_fd_flags(flags, rlimit(RLIMIT_NOFILE));
 }
 EXPORT_SYMBOL(get_unused_fd_flags);

fs/fuse/dev.c+3−3

 void fuse_request_end(struct fuse_conn *fc, struct fuse_req *req)
 {
 	struct fuse_iqueue *fiq = &fc->iq;
-	bool async;
 	if (test_and_set_bit(FR_FINISHED, &req->flags))
 		goto put_request;
-	async = req->args->end;
 	/*
 	 * test_and_set_bit() implies smp_mb() between bit
 	 * changing and below intr_entry check. Pairs with
 		wake_up(&req->waitq);
 	}
-	if (async)
+	if (test_bit(FR_ASYNC, &req->flags))
 		req->args->end(fc, req->args, req->out.h.error);
 put_request:
 	fuse_put_request(fc, req);
 	req->in.h.opcode = args->opcode;
 	req->in.h.nodeid = args->nodeid;
 	req->args = args;
+	if (args->end)
+		__set_bit(FR_ASYNC, &req->flags);
 }
 ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args)

fs/fuse/fuse_i.h+2−0

  * FR_SENT:		request is in userspace, waiting for an answer
  * FR_FINISHED:		request is finished
  * FR_PRIVATE:		request is on private list
+ * FR_ASYNC:		request is asynchronous
  */
 enum fuse_req_flag {
 	FR_ISREPLY,
 	FR_SENT,
 	FR_FINISHED,
 	FR_PRIVATE,
+	FR_ASYNC,
 };
 /**

fs/gfs2/inode.c+1−1

@@ -1248,7 +1248,7 @@ static int gfs2_atomic_open(struct inode dir, struct dentry dentry, · 1247 unmodified lines
1248	if (!(file->f_mode & FMODE_OPENED))	1248	if (!(file->f_mode & FMODE_OPENED))
1249	return finish_no_open(file, d);	1249	return finish_no_open(file, d);
1250	dput(d);	1250	dput(d);
1251	return 0;	1251	return excl && (flags & O_CREAT) ? -EEXIST : 0;
1252	}	1252	}
1253		1253
1254	BUG_ON(d != NULL);	1254	BUG_ON(d != NULL);

fs/inode.c+1−0

@@ -138,6 +138,7 @@ int inode_init_always(struct super_block sb, struct inode inode) · 137 unmodified lines
138	inode->i_sb = sb;	138	inode->i_sb = sb;
139	inode->i_blkbits = sb->s_blocksize_bits;	139	inode->i_blkbits = sb->s_blocksize_bits;
140	inode->i_flags = 0;	140	inode->i_flags = 0;
		141	atomic64_set(&inode->i_sequence, 0);
141	atomic_set(&inode->i_count, 1);	142	atomic_set(&inode->i_count, 1);
142	inode->i_op = &empty_iops;	143	inode->i_op = &empty_iops;
143	inode->i_fop = &no_open_fops;	144	inode->i_fop = &no_open_fops;

fs/io_uring.c+29−18

@@ -191,7 +191,6 @@ struct fixed_file_data { · 190 unmodified lines
191	struct llist_head put_llist;	191	struct llist_head put_llist;
192	struct work_struct ref_work;	192	struct work_struct ref_work;
193	struct completion done;	193	struct completion done;
194	struct rcu_head rcu;
195	};	194	};
196		195
197	struct io_ring_ctx {	196	struct io_ring_ctx {
@@ -344,6 +343,7 @@ struct io_accept { · 146 unmodified lines
344	struct sockaddr __user *addr;	343	struct sockaddr __user *addr;
345	int __user *addr_len;	344	int __user *addr_len;
346	int flags;	345	int flags;
		346	unsigned long nofile;
347	};	347	};
348		348
349	struct io_sync {	349	struct io_sync {
@@ -398,6 +398,7 @@ struct io_open { · 48 unmodified lines
398	struct filename *filename;	398	struct filename *filename;
399	struct statx __user *buffer;	399	struct statx __user *buffer;
400	struct open_how how;	400	struct open_how how;
		401	unsigned long nofile;
401	};	402	};
402		403
403	struct io_files_update {	404	struct io_files_update {
@@ -2578,6 +2579,7 @@ static int io_openat_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 2174 unmodified lines
2578	return ret;	2579	return ret;
2579	}	2580	}
2580		2581
		2582	req->open.nofile = rlimit(RLIMIT_NOFILE);
2581	req->flags \|= REQ_F_NEED_CLEANUP;	2583	req->flags \|= REQ_F_NEED_CLEANUP;
2582	return 0;	2584	return 0;
2583	}	2585	}
@@ -2619,6 +2621,7 @@ static int io_openat2_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 35 unmodified lines
2619	return ret;	2621	return ret;
2620	}	2622	}
2621		2623
		2624	req->open.nofile = rlimit(RLIMIT_NOFILE);
2622	req->flags \|= REQ_F_NEED_CLEANUP;	2625	req->flags \|= REQ_F_NEED_CLEANUP;
2623	return 0;	2626	return 0;
2624	}	2627	}
@@ -2637,7 +2640,7 @@ static int io_openat2(struct io_kiocb req, struct io_kiocb *nxt, · 12 unmodified lines
2637	if (ret)	2640	if (ret)
2638	goto err;	2641	goto err;
2639		2642
2640	ret = get_unused_fd_flags(req->open.how.flags);	2643	ret = __get_unused_fd_flags(req->open.how.flags, req->open.nofile);
2641	if (ret < 0)	2644	if (ret < 0)
2642	goto err;	2645	goto err;
2643		2646
@@ -3322,6 +3325,7 @@ static int io_accept_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 678 unmodified lines
3322	accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));	3325	accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
3323	accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));	3326	accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));
3324	accept->flags = READ_ONCE(sqe->accept_flags);	3327	accept->flags = READ_ONCE(sqe->accept_flags);
		3328	accept->nofile = rlimit(RLIMIT_NOFILE);
3325	return 0;	3329	return 0;
3326	#else	3330	#else
3327	return -EOPNOTSUPP;	3331	return -EOPNOTSUPP;
@@ -3338,7 +3342,8 @@ static int __io_accept(struct io_kiocb req, struct io_kiocb *nxt, · 10 unmodified lines
3338		3342
3339	file_flags = force_nonblock ? O_NONBLOCK : 0;	3343	file_flags = force_nonblock ? O_NONBLOCK : 0;
3340	ret = __sys_accept4_file(req->file, file_flags, accept->addr,	3344	ret = __sys_accept4_file(req->file, file_flags, accept->addr,
3341	accept->addr_len, accept->flags);	3345	accept->addr_len, accept->flags,
		3346	accept->nofile);
3342	if (ret == -EAGAIN && force_nonblock)	3347	if (ret == -EAGAIN && force_nonblock)
3343	return -EAGAIN;	3348	return -EAGAIN;
3344	if (ret == -ERESTARTSYS)	3349	if (ret == -ERESTARTSYS)
@@ -4132,6 +4137,9 @@ static int io_req_defer_prep(struct io_kiocb *req, · 787 unmodified lines
4132	{	4137	{
4133	ssize_t ret = 0;	4138	ssize_t ret = 0;
4134		4139
		4140	if (!sqe)
		4141	return 0;
		4142
4135	if (io_op_defs[req->opcode].file_table) {	4143	if (io_op_defs[req->opcode].file_table) {
4136	ret = io_grab_files(req);	4144	ret = io_grab_files(req);
4137	if (unlikely(ret))	4145	if (unlikely(ret))
@@ -4908,6 +4916,11 @@ err_req: · 770 unmodified lines
4908	if (sqe_flags & (IOSQE_IO_LINK\|IOSQE_IO_HARDLINK)) {	4916	if (sqe_flags & (IOSQE_IO_LINK\|IOSQE_IO_HARDLINK)) {
4909	req->flags \|= REQ_F_LINK;	4917	req->flags \|= REQ_F_LINK;
4910	INIT_LIST_HEAD(&req->link_list);	4918	INIT_LIST_HEAD(&req->link_list);
		4919
		4920	if (io_alloc_async_ctx(req)) {
		4921	ret = -EAGAIN;
		4922	goto err_req;
		4923	}
4911	ret = io_req_defer_prep(req, sqe);	4924	ret = io_req_defer_prep(req, sqe);
4912	if (ret)	4925	if (ret)
4913	req->flags \|= REQ_F_FAIL_LINK;	4926	req->flags \|= REQ_F_FAIL_LINK;
@@ -5331,24 +5344,21 @@ static void io_file_ref_kill(struct percpu_ref *ref) · 417 unmodified lines
5331	complete(&data->done);	5344	complete(&data->done);
5332	}	5345	}
5333		5346
5334	static void __io_file_ref_exit_and_free(struct rcu_head *rcu)	5347	static void io_file_ref_exit_and_free(struct work_struct *work)
5335	{	5348	{
5336	struct fixed_file_data *data = container_of(rcu, struct fixed_file_data,	5349	struct fixed_file_data *data;
5337	rcu);	5350
5338	percpu_ref_exit(&data->refs);	5351	data = container_of(work, struct fixed_file_data, ref_work);
5339	kfree(data);
5340	}
5341		5352
5342	static void io_file_ref_exit_and_free(struct rcu_head *rcu)
5343	{
5344	/*	5353	/*
5345	* We need to order our exit+free call against the potentially	5354	* Ensure any percpu-ref atomic switch callback has run, it could have
5346	* existing call_rcu() for switching to atomic. One way to do that	5355	* been in progress when the files were being unregistered. Once
5347	* is to have this rcu callback queue the final put and free, as we	5356	* that's done, we can safely exit and free the ref and containing
5348	* could otherwise have a pre-existing atomic switch complete _after_	5357	* data structure.
5349	* the free callback we queued.
5350	*/	5358	*/
5351	call_rcu(rcu, __io_file_ref_exit_and_free);	5359	rcu_barrier();
		5360	percpu_ref_exit(&data->refs);
		5361	kfree(data);
5352	}	5362	}
5353		5363
5354	static int io_sqe_files_unregister(struct io_ring_ctx *ctx)	5364	static int io_sqe_files_unregister(struct io_ring_ctx *ctx)
@@ -5369,7 +5379,8 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx) · 14 unmodified lines
5369	for (i = 0; i < nr_tables; i++)	5379	for (i = 0; i < nr_tables; i++)
5370	kfree(data->table[i].files);	5380	kfree(data->table[i].files);
5371	kfree(data->table);	5381	kfree(data->table);
5372	call_rcu(&data->rcu, io_file_ref_exit_and_free);	5382	INIT_WORK(&data->ref_work, io_file_ref_exit_and_free);
		5383	queue_work(system_wq, &data->ref_work);
5373	ctx->file_data = NULL;	5384	ctx->file_data = NULL;
5374	ctx->nr_user_files = 0;	5385	ctx->nr_user_files = 0;
5375	return 0;	5386	return 0;

fs/locks.c+48−6

 {
 	locks_delete_global_blocked(waiter);
 	list_del_init(&waiter->fl_blocked_member);
-	waiter->fl_blocker = NULL;
 }
 static void __locks_wake_up_blocks(struct file_lock *blocker)
 			waiter->fl_lmops->lm_notify(waiter);
 		else
 			wake_up(&waiter->fl_wait);
+		/*
+		 * The setting of fl_blocker to NULL marks the "done"
+		 * point in deleting a block. Paired with acquire at the top
+		 * of locks_delete_block().
+		 */
+		smp_store_release(&waiter->fl_blocker, NULL);
 	}
 }
 {
 	int status = -ENOENT;
+	/*
+	 * If fl_blocker is NULL, it won't be set again as this thread "owns"
+	 * the lock and is the only one that might try to claim the lock.
+	 *
+	 * We use acquire/release to manage fl_blocker so that we can
+	 * optimize away taking the blocked_lock_lock in many cases.
+	 *
+	 * The smp_load_acquire guarantees two things:
+	 *
+	 * 1/ that fl_blocked_requests can be tested locklessly. If something
+	 * was recently added to that list it must have been in a locked region
+	 * *before* the locked region when fl_blocker was set to NULL.
+	 *
+	 * 2/ that no other thread is accessing 'waiter', so it is safe to free
+	 * it.  __locks_wake_up_blocks is careful not to touch waiter after
+	 * fl_blocker is released.
+	 *
+	 * If a lockless check of fl_blocker shows it to be NULL, we know that
+	 * no new locks can be inserted into its fl_blocked_requests list, and
+	 * can avoid doing anything further if the list is empty.
+	 */
+	if (!smp_load_acquire(&waiter->fl_blocker) &&
+	    list_empty(&waiter->fl_blocked_requests))
+		return status;
 	spin_lock(&blocked_lock_lock);
 	if (waiter->fl_blocker)
 		status = 0;
 	__locks_wake_up_blocks(waiter);
 	__locks_delete_block(waiter);
+	/*
+	 * The setting of fl_blocker to NULL marks the "done" point in deleting
+	 * a block. Paired with acquire at the top of this function.
+	 */
+	smp_store_release(&waiter->fl_blocker, NULL);
 	spin_unlock(&blocked_lock_lock);
 	return status;
 }
 		error = posix_lock_inode(inode, fl, NULL);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker);
+		error = wait_event_interruptible(fl->fl_wait,
+					list_empty(&fl->fl_blocked_member));
 		if (error)
 			break;
 	}
 		error = posix_lock_inode(inode, &fl, NULL);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl.fl_wait, !fl.fl_blocker);
+		error = wait_event_interruptible(fl.fl_wait,
+					list_empty(&fl.fl_blocked_member));
 		if (!error) {
 			/*
 			 * If we've been sleeping someone might have
 	locks_dispose_list(&dispose);
 	error = wait_event_interruptible_timeout(new_fl->fl_wait,
-						!new_fl->fl_blocker, break_time);
+					list_empty(&new_fl->fl_blocked_member),
+					break_time);
 	percpu_down_read(&file_rwsem);
 	spin_lock(&ctx->flc_lock);
 		error = flock_lock_inode(inode, fl);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker);
+		error = wait_event_interruptible(fl->fl_wait,
+				list_empty(&fl->fl_blocked_member));
 		if (error)
 			break;
 	}
 		error = vfs_lock_file(filp, cmd, fl, NULL);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker);
+		error = wait_event_interruptible(fl->fl_wait,
+					list_empty(&fl->fl_blocked_member));
 		if (error)
 			break;
 	}

fs/nfs/client.c+1−0

@@ -153,6 +153,7 @@ struct nfs_client nfs_alloc_client(const struct nfs_client_initdata cl_init) · 152 unmodified lines
153	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)	153	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
154	goto error_0;	154	goto error_0;
155		155
		156	clp->cl_minorversion = cl_init->minorversion;
156	clp->cl_nfs_mod = cl_init->nfs_mod;	157	clp->cl_nfs_mod = cl_init->nfs_mod;
157	if (!try_module_get(clp->cl_nfs_mod->owner))	158	if (!try_module_get(clp->cl_nfs_mod->owner))
158	goto error_dealloc;	159	goto error_dealloc;

fs/nfs/fs_context.c+9−0

 	if (len > maxnamlen)
 		goto out_hostname;
+	kfree(ctx->nfs_server.hostname);
 	/* N.B. caller will free nfs_server.hostname in all cases */
 	ctx->nfs_server.hostname = kmemdup_nul(dev_name, len, GFP_KERNEL);
 	if (!ctx->nfs_server.hostname)
 		}
 		ctx->nfs_mod = nfs_mod;
 	}
+	/* Ensure the filesystem context has the correct fs_type */
+	if (fc->fs_type != ctx->nfs_mod->nfs_fs) {
+		module_put(fc->fs_type->owner);
+		__module_get(ctx->nfs_mod->nfs_fs->owner);
+		fc->fs_type = ctx->nfs_mod->nfs_fs;
+	}
 	return 0;
 out_no_device_name:

fs/nfs/fscache.c+2−0

 struct nfs_server_key {
 	struct {
 		uint16_t	nfsversion;		/* NFS protocol version */
+		uint32_t	minorversion;		/* NFSv4 minor version */
 		uint16_t	family;			/* address family */
 		__be16		port;			/* IP port */
 	} hdr;
 	memset(&key, 0, sizeof(key));
 	key.hdr.nfsversion = clp->rpc_ops->version;
+	key.hdr.minorversion = clp->cl_minorversion;
 	key.hdr.family = clp->cl_addr.ss_family;
 	switch (clp->cl_addr.ss_family) {

fs/nfs/namespace.c+1−1

@@ -153,7 +153,7 @@ struct vfsmount nfs_d_automount(struct path path) · 152 unmodified lines
153	/* Open a new filesystem context, transferring parameters from the	153	/* Open a new filesystem context, transferring parameters from the
154	* parent superblock, including the network namespace.	154	* parent superblock, including the network namespace.
155	*/	155	*/
156	fc = fs_context_for_submount(&nfs_fs_type, path->dentry);	156	fc = fs_context_for_submount(path->mnt->mnt_sb->s_type, path->dentry);
157	if (IS_ERR(fc))	157	if (IS_ERR(fc))
158	return ERR_CAST(fc);	158	return ERR_CAST(fc);
159		159

fs/nfs/nfs4client.c+0−1

@@ -216,7 +216,6 @@ struct nfs_client nfs4_alloc_client(const struct nfs_client_initdata cl_init) · 215 unmodified lines
216	INIT_LIST_HEAD(&clp->cl_ds_clients);	216	INIT_LIST_HEAD(&clp->cl_ds_clients);
217	rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");	217	rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
218	clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;	218	clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
219	clp->cl_minorversion = cl_init->minorversion;
220	clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];	219	clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];
221	clp->cl_mig_gen = 1;	220	clp->cl_mig_gen = 1;
222	#if IS_ENABLED(CONFIG_NFS_V4_1)	221	#if IS_ENABLED(CONFIG_NFS_V4_1)

fs/open.c+0−3

  * the return value of d_splice_alias(), then the caller needs to perform dput()
  * on it after finish_open().
  *
- * On successful return @file is a fully instantiated open file.  After this, if
- * an error occurs in ->atomic_open(), it needs to clean up with fput().
- *
  * Returns zero on success or -errno if the open failed.
  */
 int finish_open(struct file *file, struct dentry *dentry,

fs/overlayfs/Kconfig+1−0

@@ -93,6 +93,7 @@ config OVERLAY_FS_XINO_AUTO · 92 unmodified lines
93	bool "Overlayfs: auto enable inode number mapping"	93	bool "Overlayfs: auto enable inode number mapping"
94	default n	94	default n
95	depends on OVERLAY_FS	95	depends on OVERLAY_FS
		96	depends on 64BIT
96	help	97	help
97	If this config option is enabled then overlay filesystems will use	98	If this config option is enabled then overlay filesystems will use
98	unused high bits in undelying filesystem inode numbers to map all	99	unused high bits in undelying filesystem inode numbers to map all

fs/overlayfs/file.c+6−0

 	if (iocb->ki_flags & IOCB_WRITE) {
 		struct inode *inode = file_inode(orig_iocb->ki_filp);
+		/* Actually acquired in ovl_write_iter() */
+		__sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb,
+				      SB_FREEZE_WRITE);
 		file_end_write(iocb->ki_filp);
 		ovl_copyattr(ovl_inode_real(inode), inode);
 	}
 			goto out;
 		file_start_write(real.file);
+		/* Pacify lockdep, same trick as done in aio_write() */
+		__sb_writers_release(file_inode(real.file)->i_sb,
+				     SB_FREEZE_WRITE);
 		aio_req->fd = real;
 		real.flags = 0;
 		aio_req->orig_iocb = iocb;

fs/overlayfs/overlayfs.h+6−1

 	return ovl_same_dev(sb) ? OVL_FS(sb)->xino_mode : 0;
 }
-static inline int ovl_inode_lock(struct inode *inode)
+static inline void ovl_inode_lock(struct inode *inode)
+{
+	mutex_lock(&OVL_I(inode)->lock);
+}
+static inline int ovl_inode_lock_interruptible(struct inode *inode)
 {
 	return mutex_lock_interruptible(&OVL_I(inode)->lock);
 }

fs/overlayfs/super.c+8−1

 		if (ofs->config.xino == OVL_XINO_ON)
 			pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n");
 		ofs->xino_mode = 0;
+	} else if (ofs->config.xino == OVL_XINO_OFF) {
+		ofs->xino_mode = -1;
 	} else if (ofs->config.xino == OVL_XINO_ON && ofs->xino_mode < 0) {
 		/*
 		 * This is a roundup of number of bits needed for encoding
 	sb->s_stack_depth = 0;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	/* Assume underlaying fs uses 32bit inodes unless proven otherwise */
-	if (ofs->config.xino != OVL_XINO_OFF)
+	if (ofs->config.xino != OVL_XINO_OFF) {
 		ofs->xino_mode = BITS_PER_LONG - 32;
+		if (!ofs->xino_mode) {
+			pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n");
+			ofs->config.xino = OVL_XINO_OFF;
+		}
+	}
 	/* alloc/destroy_inode needed for setting up traps in inode cache */
 	sb->s_op = &ovl_super_operations;

fs/overlayfs/util.c+2−2

@@ -509,7 +509,7 @@ int ovl_copy_up_start(struct dentry *dentry, int flags) · 508 unmodified lines
509	struct inode *inode = d_inode(dentry);	509	struct inode *inode = d_inode(dentry);
510	int err;	510	int err;
511		511
512	err = ovl_inode_lock(inode);	512	err = ovl_inode_lock_interruptible(inode);
513	if (!err && ovl_already_copied_up_locked(dentry, flags)) {	513	if (!err && ovl_already_copied_up_locked(dentry, flags)) {
514	err = 1; /* Already copied up */	514	err = 1; /* Already copied up */
515	ovl_inode_unlock(inode);	515	ovl_inode_unlock(inode);
@@ -764,7 +764,7 @@ int ovl_nlink_start(struct dentry *dentry) · 248 unmodified lines
764	return err;	764	return err;
765	}	765	}
766		766
767	err = ovl_inode_lock(inode);	767	err = ovl_inode_lock_interruptible(inode);
768	if (err)	768	if (err)
769	return err;	769	return err;
770		770

include/crypto/curve25519.h+4−2

 			     const u8 secret[CURVE25519_KEY_SIZE],
 			     const u8 basepoint[CURVE25519_KEY_SIZE])
 {
-	if (IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_CURVE25519))
+	if (IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_CURVE25519) &&
+	    (!IS_ENABLED(CONFIG_CRYPTO_CURVE25519_X86) || IS_ENABLED(CONFIG_AS_ADX)))
 		curve25519_arch(mypublic, secret, basepoint);
 	else
 		curve25519_generic(mypublic, secret, basepoint);
 				    CURVE25519_KEY_SIZE)))
 		return false;
-	if (IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_CURVE25519))
+	if (IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_CURVE25519) &&
+	    (!IS_ENABLED(CONFIG_CRYPTO_CURVE25519_X86) || IS_ENABLED(CONFIG_AS_ADX)))
 		curve25519_base_arch(pub, secret);
 	else
 		curve25519_generic(pub, secret, curve25519_base_point);

include/drm/drm_dp_mst_helper.h+2−2

@@ -81,7 +81,7 @@ struct drm_dp_vcpi { · 80 unmodified lines
81	* &drm_dp_mst_topology_mgr.base.lock.	81	* &drm_dp_mst_topology_mgr.base.lock.
82	* @num_sdp_stream_sinks: Number of stream sinks. Protected by	82	* @num_sdp_stream_sinks: Number of stream sinks. Protected by
83	* &drm_dp_mst_topology_mgr.base.lock.	83	* &drm_dp_mst_topology_mgr.base.lock.
84	* @available_pbn: Available bandwidth for this port. Protected by	84	* @full_pbn: Max possible bandwidth for this port. Protected by
85	* &drm_dp_mst_topology_mgr.base.lock.	85	* &drm_dp_mst_topology_mgr.base.lock.
86	* @next: link to next port on this branch device	86	* @next: link to next port on this branch device
87	* @aux: i2c aux transport to talk to device connected to this port, protected	87	* @aux: i2c aux transport to talk to device connected to this port, protected
@@ -126,7 +126,7 @@ struct drm_dp_mst_port { · 38 unmodified lines
126	u8 dpcd_rev;	126	u8 dpcd_rev;
127	u8 num_sdp_streams;	127	u8 num_sdp_streams;
128	u8 num_sdp_stream_sinks;	128	u8 num_sdp_stream_sinks;
129	uint16_t available_pbn;	129	uint16_t full_pbn;
130	struct list_head next;	130	struct list_head next;
131	/**	131	/**
132	* @mstb: the branch device connected to this port, if there is one.	132	* @mstb: the branch device connected to this port, if there is one.

include/dt-bindings/clock/imx8mn-clock.h+2−2

@@ -122,8 +122,8 @@ · 121 unmodified lines
122	#define IMX8MN_CLK_I2C1 105	122	#define IMX8MN_CLK_I2C1 105
123	#define IMX8MN_CLK_I2C2 106	123	#define IMX8MN_CLK_I2C2 106
124	#define IMX8MN_CLK_I2C3 107	124	#define IMX8MN_CLK_I2C3 107
125	#define IMX8MN_CLK_I2C4 118	125	#define IMX8MN_CLK_I2C4 108
126	#define IMX8MN_CLK_UART1 119	126	#define IMX8MN_CLK_UART1 109
127	#define IMX8MN_CLK_UART2 110	127	#define IMX8MN_CLK_UART2 110
128	#define IMX8MN_CLK_UART3 111	128	#define IMX8MN_CLK_UART3 111
129	#define IMX8MN_CLK_UART4 112	129	#define IMX8MN_CLK_UART4 112

include/linux/cgroup.h+1−0

@@ -62,6 +62,7 @@ struct css_task_iter { · 61 unmodified lines
62	struct list_head *mg_tasks_head;	62	struct list_head *mg_tasks_head;
63	struct list_head *dying_tasks_head;	63	struct list_head *dying_tasks_head;
64		64
		65	struct list_head *cur_tasks_head;
65	struct css_set *cur_cset;	66	struct css_set *cur_cset;
66	struct css_set *cur_dcset;	67	struct css_set *cur_dcset;
67	struct task_struct *cur_task;	68	struct task_struct *cur_task;

include/linux/dmar.h+9−5

 extern struct rw_semaphore dmar_global_lock;
 extern struct list_head dmar_drhd_units;
-#define for_each_drhd_unit(drhd) \
+#define for_each_drhd_unit(drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())
 #define for_each_active_drhd_unit(drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (drhd->ignored) {} else
 #define for_each_active_iommu(i, drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (i=drhd->iommu, drhd->ignored) {} else
 #define for_each_iommu(i, drhd)						\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (i=drhd->iommu, 0) {} else
 static inline bool dmar_rcu_check(void)

include/linux/file.h+1−0

@@ -85,6 +85,7 @@ extern int f_dupfd(unsigned int from, struct file *file, unsigned flags); · 84 unmodified lines
85	extern int replace_fd(unsigned fd, struct file *file, unsigned flags);	85	extern int replace_fd(unsigned fd, struct file *file, unsigned flags);
86	extern void set_close_on_exec(unsigned int fd, int flag);	86	extern void set_close_on_exec(unsigned int fd, int flag);
87	extern bool get_close_on_exec(unsigned int fd);	87	extern bool get_close_on_exec(unsigned int fd);
		88	extern int __get_unused_fd_flags(unsigned flags, unsigned long nofile);
88	extern int get_unused_fd_flags(unsigned flags);	89	extern int get_unused_fd_flags(unsigned flags);
89	extern void put_unused_fd(unsigned int fd);	90	extern void put_unused_fd(unsigned int fd);
90		91

include/linux/fs.h+1−0

@@ -698,6 +698,7 @@ struct inode { · 697 unmodified lines
698	struct rcu_head i_rcu;	698	struct rcu_head i_rcu;
699	};	699	};
700	atomic64_t i_version;	700	atomic64_t i_version;
		701	atomic64_t i_sequence; /* see futex */
701	atomic_t i_count;	702	atomic_t i_count;
702	atomic_t i_dio_count;	703	atomic_t i_dio_count;
703	atomic_t i_writecount;	704	atomic_t i_writecount;

include/linux/futex.h+10−7

 union futex_key {
 	struct {
+		u64 i_seq;
 		unsigned long pgoff;
-		struct inode *inode;
+		unsigned int offset;
-		int offset;
 	} shared;
 	struct {
+		union {
+			struct mm_struct *mm;
+			u64 __tmp;
+		};
 		unsigned long address;
-		struct mm_struct *mm;
+		unsigned int offset;
-		int offset;
 	} private;
 	struct {
+		u64 ptr;
 		unsigned long word;
-		void *ptr;
+		unsigned int offset;
-		int offset;
 	} both;
 };
-#define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = NULL } }
+#define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = 0ULL } }
 #ifdef CONFIG_FUTEX
 enum {

include/linux/genhd.h+1−12

 		!(disk->flags & GENHD_FL_NO_PART_SCAN);
 }
-static inline bool disk_has_partitions(struct gendisk *disk)
-{
-	bool ret = false;
-	rcu_read_lock();
-	if (rcu_dereference(disk->part_tbl)->len > 1)
-		ret = true;
-	rcu_read_unlock();
-	return ret;
-}
 static inline dev_t disk_devt(struct gendisk *disk)
 {
 	return MKDEV(disk->major, disk->first_minor);
 extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
 					     sector_t sector);
+bool disk_has_partitions(struct gendisk *disk);
 /*
  * Macros to operate on percpu disk statistics:

include/linux/inet_diag.h+12−6

 #ifndef _INET_DIAG_H_
 #define _INET_DIAG_H_ 1
+#include <net/netlink.h>
 #include <uapi/linux/inet_diag.h>
-struct net;
-struct sock;
 struct inet_hashinfo;
-struct nlattr;
-struct nlmsghdr;
-struct sk_buff;
-struct netlink_callback;
 struct inet_diag_handler {
 	void		(*dump)(struct sk_buff *skb,
 void inet_diag_msg_common_fill(struct inet_diag_msg *r, struct sock *sk);
+static inline size_t inet_diag_msg_attrs_size(void)
+{
+	return	  nla_total_size(1)  /* INET_DIAG_SHUTDOWN */
+		+ nla_total_size(1)  /* INET_DIAG_TOS */
+#if IS_ENABLED(CONFIG_IPV6)
+		+ nla_total_size(1)  /* INET_DIAG_TCLASS */
+		+ nla_total_size(1)  /* INET_DIAG_SKV6ONLY */
+#endif
+		+ nla_total_size(4)  /* INET_DIAG_MARK */
+		+ nla_total_size(4); /* INET_DIAG_CLASS_ID */
+}
 int inet_diag_msg_attrs_fill(struct sock *sk, struct sk_buff *skb,
 			     struct inet_diag_msg *r, int ext,
 			     struct user_namespace *user_ns, bool net_admin);

include/linux/intel-iommu.h+2−0

@@ -123,6 +123,8 @@ · 122 unmodified lines
123		123
124	#define dmar_readq(a) readq(a)	124	#define dmar_readq(a) readq(a)
125	#define dmar_writeq(a,v) writeq(v,a)	125	#define dmar_writeq(a,v) writeq(v,a)
		126	#define dmar_readl(a) readl(a)
		127	#define dmar_writel(a, v) writel(v, a)
126		128
127	#define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4)	129	#define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4)
128	#define DMAR_VER_MINOR(v) ((v) & 0x0f)	130	#define DMAR_VER_MINOR(v) ((v) & 0x0f)

include/linux/mmc/host.h+1−0

@@ -333,6 +333,7 @@ struct mmc_host { · 332 unmodified lines
333	MMC_CAP_UHS_SDR50 \| MMC_CAP_UHS_SDR104 \| \	333	MMC_CAP_UHS_SDR50 \| MMC_CAP_UHS_SDR104 \| \
334	MMC_CAP_UHS_DDR50)	334	MMC_CAP_UHS_DDR50)
335	#define MMC_CAP_SYNC_RUNTIME_PM (1 << 21) /* Synced runtime PM suspends. */	335	#define MMC_CAP_SYNC_RUNTIME_PM (1 << 21) /* Synced runtime PM suspends. */
		336	#define MMC_CAP_NEED_RSP_BUSY (1 << 22) /* Commands with R1B can't use R1. */
336	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */	337	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */
337	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */	338	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */
338	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */	339	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */

include/linux/of_clk.h+4−4

@@ -11,17 +11,17 @@ struct of_device_id; · 10 unmodified lines
11		11
12	#if defined(CONFIG_COMMON_CLK) && defined(CONFIG_OF)	12	#if defined(CONFIG_COMMON_CLK) && defined(CONFIG_OF)
13		13
14	unsigned int of_clk_get_parent_count(struct device_node *np);	14	unsigned int of_clk_get_parent_count(const struct device_node *np);
15	const char of_clk_get_parent_name(struct device_node np, int index);	15	const char of_clk_get_parent_name(const struct device_node np, int index);
16	void of_clk_init(const struct of_device_id *matches);	16	void of_clk_init(const struct of_device_id *matches);
17		17
18	#else /* !CONFIG_COMMON_CLK \|\| !CONFIG_OF */	18	#else /* !CONFIG_COMMON_CLK \|\| !CONFIG_OF */
19		19
20	static inline unsigned int of_clk_get_parent_count(struct device_node *np)	20	static inline unsigned int of_clk_get_parent_count(const struct device_node *np)
21	{	21	{
22	return 0;	22	return 0;
23	}	23	}
24	static inline const char of_clk_get_parent_name(struct device_node np,	24	static inline const char of_clk_get_parent_name(const struct device_node np,
25	int index)	25	int index)
26	{	26	{
27	return NULL;	27	return NULL;

include/linux/page-flags.h+1−1

@@ -311,7 +311,7 @@ static inline int TestClearPage##uname(struct page *page) { return 0; } · 310 unmodified lines
311		311
312	__PAGEFLAG(Locked, locked, PF_NO_TAIL)	312	__PAGEFLAG(Locked, locked, PF_NO_TAIL)
313	PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD) __CLEARPAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)	313	PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD) __CLEARPAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)
314	PAGEFLAG(Error, error, PF_NO_COMPOUND) TESTCLEARFLAG(Error, error, PF_NO_COMPOUND)	314	PAGEFLAG(Error, error, PF_NO_TAIL) TESTCLEARFLAG(Error, error, PF_NO_TAIL)
315	PAGEFLAG(Referenced, referenced, PF_HEAD)	315	PAGEFLAG(Referenced, referenced, PF_HEAD)
316	TESTCLEARFLAG(Referenced, referenced, PF_HEAD)	316	TESTCLEARFLAG(Referenced, referenced, PF_HEAD)
317	__SETPAGEFLAG(Referenced, referenced, PF_HEAD)	317	__SETPAGEFLAG(Referenced, referenced, PF_HEAD)

include/linux/phy.h+3−0

  * is_gigabit_capable: Set to true if PHY supports 1000Mbps
  * has_fixups: Set to true if this phy has fixups/quirks.
  * suspended: Set to true if this phy has been suspended successfully.
+ * suspended_by_mdio_bus: Set to true if this phy was suspended by MDIO bus.
  * sysfs_links: Internal boolean tracking sysfs symbolic links setup/removal.
  * loopback_enabled: Set true if this phy has been loopbacked successfully.
  * state: state of the PHY for management purposes
 	unsigned is_gigabit_capable:1;
 	unsigned has_fixups:1;
 	unsigned suspended:1;
+	unsigned suspended_by_mdio_bus:1;
 	unsigned sysfs_links:1;
 	unsigned loopback_enabled:1;
 	/*
 	 * Checks if the PHY generated an interrupt.
 	 * For multi-PHY devices with shared PHY interrupt pin
+	 * Set interrupt bits have to be cleared.
 	 */
 	int (*did_interrupt)(struct phy_device *phydev);

include/linux/platform_device.h+1−1

@@ -24,7 +24,7 @@ struct platform_device { · 23 unmodified lines
24	int id;	24	int id;
25	bool id_auto;	25	bool id_auto;
26	struct device dev;	26	struct device dev;
27	u64 dma_mask;	27	u64 platform_dma_mask;
28	u32 num_resources;	28	u32 num_resources;
29	struct resource *resource;	29	struct resource *resource;
30		30

include/linux/rhashtable.h+1−1

 /**
  * rhashtable_lookup_get_insert_key - lookup and insert object into hash table
  * @ht:		hash table
+ * @key:	key
  * @obj:	pointer to hash head inside object
  * @params:	hash table parameters
- * @data:	pointer to element data already in hashes
  *
  * Just like rhashtable_lookup_insert_key(), but this function returns the
  * object if it exists, NULL if it does not and the insertion was successful,

include/linux/socket.h+2−1

 			int addr_len);
 extern int __sys_accept4_file(struct file *file, unsigned file_flags,
 			struct sockaddr __user *upeer_sockaddr,
-			 int __user *upeer_addrlen, int flags);
+			 int __user *upeer_addrlen, int flags,
+			 unsigned long nofile);
 extern int __sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
 			 int __user *upeer_addrlen, int flags);
 extern int __sys_socket(int family, int type, int protocol);

include/linux/vmalloc.h+3−2

@@ -141,8 +141,9 @@ extern int remap_vmalloc_range_partial(struct vm_area_struct *vma, · 140 unmodified lines
141		141
142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,	142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,
143	unsigned long pgoff);	143	unsigned long pgoff);
144	void vmalloc_sync_all(void);	144	void vmalloc_sync_mappings(void);
145		145	void vmalloc_sync_unmappings(void);
		146
146	/*	147	/*
147	* Lowlevel-APIs (not for driver use!)	148	* Lowlevel-APIs (not for driver use!)
148	*/	149	*/

include/linux/workqueue.h+16−0

@@ -487,6 +487,19 @@ extern void wq_worker_comm(char buf, size_t size, struct task_struct task); · 486 unmodified lines
487	*	487	*
488	* We queue the work to the CPU on which it was submitted, but if the CPU dies	488	* We queue the work to the CPU on which it was submitted, but if the CPU dies
489	* it can be processed by another CPU.	489	* it can be processed by another CPU.
		490	*
		491	* Memory-ordering properties: If it returns %true, guarantees that all stores
		492	* preceding the call to queue_work() in the program order will be visible from
		493	* the CPU which will execute @work by the time such work executes, e.g.,
		494	*
		495	* { x is initially 0 }
		496	*
		497	* CPU0 CPU1
		498	*
		499	* WRITE_ONCE(x, 1); [ @work is being executed ]
		500	* r0 = queue_work(wq, work); r1 = READ_ONCE(x);
		501	*
		502	* Forbids: r0 == true && r1 == 0
490	*/	503	*/
491	static inline bool queue_work(struct workqueue_struct *wq,	504	static inline bool queue_work(struct workqueue_struct *wq,
492	struct work_struct *work)	505	struct work_struct *work)
@@ -546,6 +559,9 @@ static inline bool schedule_work_on(int cpu, struct work_struct *work) · 53 unmodified lines
546	* This puts a job in the kernel-global workqueue if it was not already	559	* This puts a job in the kernel-global workqueue if it was not already
547	* queued and leaves it in the same position on the kernel-global	560	* queued and leaves it in the same position on the kernel-global
548	* workqueue otherwise.	561	* workqueue otherwise.
		562	*
		563	* Shares the same memory-ordering properties of queue_work(), cf. the
		564	* DocBook header of queue_work().
549	*/	565	*/
550	static inline bool schedule_work(struct work_struct *work)	566	static inline bool schedule_work(struct work_struct *work)
551	{	567	{

include/net/fib_rules.h+1−0

@@ -108,6 +108,7 @@ struct fib_rule_notifier_info { · 107 unmodified lines
108	[FRA_OIFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \	108	[FRA_OIFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \
109	[FRA_PRIORITY] = { .type = NLA_U32 }, \	109	[FRA_PRIORITY] = { .type = NLA_U32 }, \
110	[FRA_FWMARK] = { .type = NLA_U32 }, \	110	[FRA_FWMARK] = { .type = NLA_U32 }, \
		111	[FRA_TUN_ID] = { .type = NLA_U64 }, \
111	[FRA_FWMASK] = { .type = NLA_U32 }, \	112	[FRA_FWMASK] = { .type = NLA_U32 }, \
112	[FRA_TABLE] = { .type = NLA_U32 }, \	113	[FRA_TABLE] = { .type = NLA_U32 }, \
113	[FRA_SUPPRESS_PREFIXLEN] = { .type = NLA_U32 }, \	114	[FRA_SUPPRESS_PREFIXLEN] = { .type = NLA_U32 }, \

include/soc/mscc/ocelot_dev.h+1−1

@@ -74,7 +74,7 @@ · 73 unmodified lines
74	#define DEV_MAC_TAGS_CFG_TAG_ID_M GENMASK(31, 16)	74	#define DEV_MAC_TAGS_CFG_TAG_ID_M GENMASK(31, 16)
75	#define DEV_MAC_TAGS_CFG_TAG_ID_X(x) (((x) & GENMASK(31, 16)) >> 16)	75	#define DEV_MAC_TAGS_CFG_TAG_ID_X(x) (((x) & GENMASK(31, 16)) >> 16)
76	#define DEV_MAC_TAGS_CFG_VLAN_LEN_AWR_ENA BIT(2)	76	#define DEV_MAC_TAGS_CFG_VLAN_LEN_AWR_ENA BIT(2)
77	#define DEV_MAC_TAGS_CFG_PB_ENA BIT(1)	77	#define DEV_MAC_TAGS_CFG_VLAN_DBL_AWR_ENA BIT(1)
78	#define DEV_MAC_TAGS_CFG_VLAN_AWR_ENA BIT(0)	78	#define DEV_MAC_TAGS_CFG_VLAN_AWR_ENA BIT(0)
79		79
80	#define DEV_MAC_ADV_CHK_CFG 0x2c	80	#define DEV_MAC_ADV_CHK_CFG 0x2c

include/uapi/linux/in.h+2−0

 #define IPPROTO_UDPLITE		IPPROTO_UDPLITE
   IPPROTO_MPLS = 137,		/* MPLS in IP (RFC 4023)		*/
 #define IPPROTO_MPLS		IPPROTO_MPLS
+  IPPROTO_ETHERNET = 143,	/* Ethernet-within-IPv6 Encapsulation	*/
+#define IPPROTO_ETHERNET	IPPROTO_ETHERNET
   IPPROTO_RAW = 255,		/* Raw IP packets			*/
 #define IPPROTO_RAW		IPPROTO_RAW
   IPPROTO_MPTCP = 262,		/* Multipath TCP connection		*/

init/Kconfig+1−2

@@ -767,8 +767,7 @@ config ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH · 766 unmodified lines
767	bool	767	bool
768		768
769	config CC_HAS_INT128	769	config CC_HAS_INT128
770	def_bool y	770	def_bool !$(cc-option,$(m64-flag) -D__SIZEOF_INT128__=0) && 64BIT
771	depends on !$(cc-option,-D__SIZEOF_INT128__=0)
772		771
773	#	772	#
774	# For architectures that know their GCC __int128 support is sound	773	# For architectures that know their GCC __int128 support is sound

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

 	 */
 	p++;
 	if (p >= end) {
+		(*pos)++;
 		return NULL;
 	} else {
 		*pos = *p;
 	pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
 	agentbuf = kstrdup(cgrp->root->release_agent_path, GFP_KERNEL);
-	if (!pathbuf || !agentbuf)
+	if (!pathbuf || !agentbuf || !strlen(agentbuf))
 		goto out;
 	spin_lock_irq(&css_set_lock);

kernel/cgroup/cgroup.c+30−13

 static int cgroup_io_pressure_show(struct seq_file *seq, void *v)
 {
 	struct cgroup *cgrp = seq_css(seq)->cgroup;
-	struct psi_group *psi = cgroup_id(cgrp) == 1 ? &psi_system : &cgrp->psi;
+	struct psi_group *psi = cgroup_ino(cgrp) == 1 ? &psi_system : &cgrp->psi;
 	return psi_show(seq, psi, PSI_IO);
 }
 static int cgroup_memory_pressure_show(struct seq_file *seq, void *v)
 {
 	struct cgroup *cgrp = seq_css(seq)->cgroup;
-	struct psi_group *psi = cgroup_id(cgrp) == 1 ? &psi_system : &cgrp->psi;
+	struct psi_group *psi = cgroup_ino(cgrp) == 1 ? &psi_system : &cgrp->psi;
 	return psi_show(seq, psi, PSI_MEM);
 }
 static int cgroup_cpu_pressure_show(struct seq_file *seq, void *v)
 {
 	struct cgroup *cgrp = seq_css(seq)->cgroup;
-	struct psi_group *psi = cgroup_id(cgrp) == 1 ? &psi_system : &cgrp->psi;
+	struct psi_group *psi = cgroup_ino(cgrp) == 1 ? &psi_system : &cgrp->psi;
 	return psi_show(seq, psi, PSI_CPU);
 }
 		}
 	} while (!css_set_populated(cset) && list_empty(&cset->dying_tasks));
-	if (!list_empty(&cset->tasks))
+	if (!list_empty(&cset->tasks)) {
 		it->task_pos = cset->tasks.next;
-	else if (!list_empty(&cset->mg_tasks))
+		it->cur_tasks_head = &cset->tasks;
+	} else if (!list_empty(&cset->mg_tasks)) {
 		it->task_pos = cset->mg_tasks.next;
-	else
+		it->cur_tasks_head = &cset->mg_tasks;
+	} else {
 		it->task_pos = cset->dying_tasks.next;
+		it->cur_tasks_head = &cset->dying_tasks;
+	}
 	it->tasks_head = &cset->tasks;
 	it->mg_tasks_head = &cset->mg_tasks;
 		else
 			it->task_pos = it->task_pos->next;
-		if (it->task_pos == it->tasks_head)
+		if (it->task_pos == it->tasks_head) {
 			it->task_pos = it->mg_tasks_head->next;
-		if (it->task_pos == it->mg_tasks_head)
+			it->cur_tasks_head = it->mg_tasks_head;
+		}
+		if (it->task_pos == it->mg_tasks_head) {
 			it->task_pos = it->dying_tasks_head->next;
+			it->cur_tasks_head = it->dying_tasks_head;
+		}
 		if (it->task_pos == it->dying_tasks_head)
 			css_task_iter_advance_css_set(it);
 	} else {
 			goto repeat;
 		/* and dying leaders w/o live member threads */
-		if (!atomic_read(&task->signal->live))
+		if (it->cur_tasks_head == it->dying_tasks_head &&
+		    !atomic_read(&task->signal->live))
 			goto repeat;
 	} else {
 		/* skip all dying ones */
-		if (task->flags & PF_EXITING)
+		if (it->cur_tasks_head == it->dying_tasks_head)
 			goto repeat;
 	}
 }
 	struct kernfs_open_file *of = s->private;
 	struct css_task_iter *it = of->priv;
+	if (pos)
+		(*pos)++;
 	return css_task_iter_next(it);
 }
 	 * from position 0, so we can simply keep iterating on !0 *pos.
 	 */
 	if (!it) {
-		if (WARN_ON_ONCE((*pos)++))
+		if (WARN_ON_ONCE((*pos)))
 			return ERR_PTR(-EINVAL);
 		it = kzalloc(sizeof(*it), GFP_KERNEL);
 			return ERR_PTR(-ENOMEM);
 		of->priv = it;
 		css_task_iter_start(&cgrp->self, iter_flags, it);
-	} else if (!(*pos)++) {
+	} else if (!(*pos)) {
 		css_task_iter_end(it);
 		css_task_iter_start(&cgrp->self, iter_flags, it);
-	}
+	} else
+		return it->cur_task;
 	return cgroup_procs_next(s, NULL, NULL);
 }
 		return;
 	}
+	/* Don't associate the sock with unrelated interrupted task's cgroup. */
+	if (in_interrupt())
+		return;
 	rcu_read_lock();
 	while (true) {

kernel/futex.c+55−38

  */
 static struct futex_hash_bucket *hash_futex(union futex_key *key)
 {
-	u32 hash = jhash2((u32*)&key->both.word,
+	u32 hash = jhash2((u32 *)key, offsetof(typeof(*key), both.offset) / 4,
-			  (sizeof(key->both.word)+sizeof(key->both.ptr))/4,
 			  key->both.offset);
 	return &futex_queues[hash & (futex_hashsize - 1)];
 }
 	switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
 	case FUT_OFF_INODE:
-		ihold(key->shared.inode); /* implies smp_mb(); (B) */
+		smp_mb();		/* explicit smp_mb(); (B) */
 		break;
 	case FUT_OFF_MMSHARED:
 		futex_get_mm(key); /* implies smp_mb(); (B) */
 	switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
 	case FUT_OFF_INODE:
-		iput(key->shared.inode);
 		break;
 	case FUT_OFF_MMSHARED:
 		mmdrop(key->private.mm);
 	return timeout;
 }
+/*
+ * Generate a machine wide unique identifier for this inode.
+ *
+ * This relies on u64 not wrapping in the life-time of the machine; which with
+ * 1ns resolution means almost 585 years.
+ *
+ * This further relies on the fact that a well formed program will not unmap
+ * the file while it has a (shared) futex waiting on it. This mapping will have
+ * a file reference which pins the mount and inode.
+ *
+ * If for some reason an inode gets evicted and read back in again, it will get
+ * a new sequence number and will _NOT_ match, even though it is the exact same
+ * file.
+ *
+ * It is important that match_futex() will never have a false-positive, esp.
+ * for PI futexes that can mess up the state. The above argues that false-negatives
+ * are only possible for malformed programs.
+ */
+static u64 get_inode_sequence_number(struct inode *inode)
+{
+	static atomic64_t i_seq;
+	u64 old;
+	/* Does the inode already have a sequence number? */
+	old = atomic64_read(&inode->i_sequence);
+	if (likely(old))
+		return old;
+	for (;;) {
+		u64 new = atomic64_add_return(1, &i_seq);
+		if (WARN_ON_ONCE(!new))
+			continue;
+		old = atomic64_cmpxchg_relaxed(&inode->i_sequence, 0, new);
+		if (old)
+			return old;
+		return new;
+	}
+}
 /**
  * get_futex_key() - Get parameters which are the keys for a futex
  * @uaddr:	virtual address of the futex
  *
  * The key words are stored in @key on success.
  *
- * For shared mappings, it's (page->index, file_inode(vma->vm_file),
+ * For shared mappings (when @fshared), the key is:
- * offset_within_page).  For private mappings, it's (uaddr, current->mm).
+ *   ( inode->i_sequence, page->index, offset_within_page )
- * We can usually work out the index without swapping in the page.
+ * [ also see get_inode_sequence_number() ]
+ *
+ * For private mappings (or when !@fshared), the key is:
+ *   ( current->mm, address, 0 )
+ *
+ * This allows (cross process, where applicable) identification of the futex
+ * without keeping the page pinned for the duration of the FUTEX_WAIT.
  *
  * lock_page() might sleep, the caller should not hold a spinlock.
  */
 		key->private.mm = mm;
 		key->private.address = address;
-		get_futex_key_refs(key); /* implies smp_mb(); (B) */
 	} else {
 		struct inode *inode;
 			goto again;
 		}
-		/*
-		 * Take a reference unless it is about to be freed. Previously
-		 * this reference was taken by ihold under the page lock
-		 * pinning the inode in place so i_lock was unnecessary. The
-		 * only way for this check to fail is if the inode was
-		 * truncated in parallel which is almost certainly an
-		 * application bug. In such a case, just retry.
-		 *
-		 * We are not calling into get_futex_key_refs() in file-backed
-		 * cases, therefore a successful atomic_inc return below will
-		 * guarantee that get_futex_key() will still imply smp_mb(); (B).
-		 */
-		if (!atomic_inc_not_zero(&inode->i_count)) {
-			rcu_read_unlock();
-			put_page(page);
-			goto again;
-		}
-		/* Should be impossible but lets be paranoid for now */
-		if (WARN_ON_ONCE(inode->i_mapping != mapping)) {
-			err = -EFAULT;
-			rcu_read_unlock();
-			iput(inode);
-			goto out;
-		}
 		key->both.offset |= FUT_OFF_INODE; /* inode-based key */
-		key->shared.inode = inode;
+		key->shared.i_seq = get_inode_sequence_number(inode);
 		key->shared.pgoff = basepage_index(tail);
 		rcu_read_unlock();
 	}
+	get_futex_key_refs(key); /* implies smp_mb(); (B) */
 out:
 	put_page(page);
 	return err;

kernel/notifier.c+1−1

@@ -519,7 +519,7 @@ NOKPROBE_SYMBOL(notify_die); · 518 unmodified lines
519		519
520	int register_die_notifier(struct notifier_block *nb)	520	int register_die_notifier(struct notifier_block *nb)
521	{	521	{
522	vmalloc_sync_all();	522	vmalloc_sync_mappings();
523	return atomic_notifier_chain_register(&die_chain, nb);	523	return atomic_notifier_chain_register(&die_chain, nb);
524	}	524	}
525	EXPORT_SYMBOL_GPL(register_die_notifier);	525	EXPORT_SYMBOL_GPL(register_die_notifier);

kernel/pid.c+10−0

@@ -247,6 +247,16 @@ struct pid alloc_pid(struct pid_namespace ns, pid_t *set_tid, · 246 unmodified lines
247	tmp = tmp->parent;	247	tmp = tmp->parent;
248	}	248	}
249		249
		250	/*
		251	* ENOMEM is not the most obvious choice especially for the case
		252	* where the child subreaper has already exited and the pid
		253	* namespace denies the creation of any new processes. But ENOMEM
		254	* is what we have exposed to userspace for a long time and it is
		255	* documented behavior for pid namespaces. So we can't easily
		256	* change it even if there were an error code better suited.
		257	*/
		258	retval = -ENOMEM;
		259
250	if (unlikely(is_child_reaper(pid))) {	260	if (unlikely(is_child_reaper(pid))) {
251	if (pid_ns_prepare_proc(ns))	261	if (pid_ns_prepare_proc(ns))
252	goto out_free;	262	goto out_free;

kernel/sys.c+2−0

 #include <linux/syscalls.h>
 #include <linux/kprobes.h>
 #include <linux/user_namespace.h>
+#include <linux/time_namespace.h>
 #include <linux/binfmts.h>
 #include <linux/sched.h>
 	memset(info, 0, sizeof(struct sysinfo));
 	ktime_get_boottime_ts64(&tp);
+	timens_add_boottime(&tp);
 	info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
 	get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);

kernel/trace/ftrace.c+2−0

 		rec = bsearch(&key, pg->records, pg->index,
 			      sizeof(struct dyn_ftrace),
 			      ftrace_cmp_recs);
+		if (rec)
+			break;
 	}
 	return rec;
 }

kernel/workqueue.c+8−6

 		return;
 	rcu_read_lock();
 retry:
-	if (req_cpu == WORK_CPU_UNBOUND)
-		cpu = wq_select_unbound_cpu(raw_smp_processor_id());
 	/* pwq which will be used unless @work is executing elsewhere */
-	if (!(wq->flags & WQ_UNBOUND))
+	if (wq->flags & WQ_UNBOUND) {
-		pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);
+		if (req_cpu == WORK_CPU_UNBOUND)
-	else
+			cpu = wq_select_unbound_cpu(raw_smp_processor_id());
 		pwq = unbound_pwq_by_node(wq, cpu_to_node(cpu));
+	} else {
+		if (req_cpu == WORK_CPU_UNBOUND)
+			cpu = raw_smp_processor_id();
+		pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);
+	}
 	/*
 	 * If @work was previously on a different pool, it might still be

mm/madvise.c+9−3

 		}
 		page = pmd_page(orig_pmd);
+		/* Do not interfere with other mappings of this page */
+		if (page_mapcount(page) != 1)
+			goto huge_unlock;
 		if (next - addr != HPAGE_PMD_SIZE) {
 			int err;
-			if (page_mapcount(page) != 1)
-				goto huge_unlock;
 			get_page(page);
 			spin_unlock(ptl);
 			lock_page(page);
 			continue;
 		}
+		/* Do not interfere with other mappings of this page */
+		if (page_mapcount(page) != 1)
+			continue;
 		VM_BUG_ON_PAGE(PageTransCompound(page), page);
 		if (pte_young(ptent)) {

mm/memcontrol.c+68−49

@@ -2297,28 +2297,41 @@ static void high_work_func(struct work_struct *work) · 2296 unmodified lines
2297	#define MEMCG_DELAY_SCALING_SHIFT 14	2297	#define MEMCG_DELAY_SCALING_SHIFT 14
2298		2298
2299	/*	2299	/*
2300	* Scheduled by try_charge() to be executed from the userland return path	2300	* Get the number of jiffies that we should penalise a mischievous cgroup which
2301	* and reclaims memory over the high limit.	2301	* is exceeding its memory.high by checking both it and its ancestors.
2302	*/	2302	*/
2303	void mem_cgroup_handle_over_high(void)	2303	static unsigned long calculate_high_delay(struct mem_cgroup *memcg,
		2304	unsigned int nr_pages)
2304	{	2305	{
2305	unsigned long usage, high, clamped_high;	2306	unsigned long penalty_jiffies;
2306	unsigned long pflags;	2307	u64 max_overage = 0;
2307	unsigned long penalty_jiffies, overage;
2308	unsigned int nr_pages = current->memcg_nr_pages_over_high;
2309	struct mem_cgroup *memcg;
2310		2308
2311	if (likely(!nr_pages))	2309	do {
2312	return;	2310	unsigned long usage, high;
		2311	u64 overage;
2313		2312
2314	memcg = get_mem_cgroup_from_mm(current->mm);	2313	usage = page_counter_read(&memcg->memory);
2315	reclaim_high(memcg, nr_pages, GFP_KERNEL);	2314	high = READ_ONCE(memcg->high);
2316	current->memcg_nr_pages_over_high = 0;	2315
		2316	/*
		2317	* Prevent division by 0 in overage calculation by acting as if
		2318	* it was a threshold of 1 page
		2319	*/
		2320	high = max(high, 1UL);
		2321
		2322	overage = usage - high;
		2323	overage <<= MEMCG_DELAY_PRECISION_SHIFT;
		2324	overage = div64_u64(overage, high);
		2325
		2326	if (overage > max_overage)
		2327	max_overage = overage;
		2328	} while ((memcg = parent_mem_cgroup(memcg)) &&
		2329	!mem_cgroup_is_root(memcg));
		2330
		2331	if (!max_overage)
		2332	return 0;
2317		2333
2318	/*	2334	/*
2319	* memory.high is breached and reclaim is unable to keep up. Throttle
2320	* allocators proactively to slow down excessive growth.
2321	*
2322	* We use overage compared to memory.high to calculate the number of	2335	* We use overage compared to memory.high to calculate the number of
2323	* jiffies to sleep (penalty_jiffies). Ideally this value should be	2336	* jiffies to sleep (penalty_jiffies). Ideally this value should be
2324	* fairly lenient on small overages, and increasingly harsh when the	2337	* fairly lenient on small overages, and increasingly harsh when the
@@ -2326,24 +2339,9 @@ void mem_cgroup_handle_over_high(void) · 1 unmodified line
2326	* its crazy behaviour, so we exponentially increase the delay based on	2339	* its crazy behaviour, so we exponentially increase the delay based on
2327	* overage amount.	2340	* overage amount.
2328	*/	2341	*/
2329		2342	penalty_jiffies = max_overage * max_overage * HZ;
2330	usage = page_counter_read(&memcg->memory);	2343	penalty_jiffies >>= MEMCG_DELAY_PRECISION_SHIFT;
2331	high = READ_ONCE(memcg->high);	2344	penalty_jiffies >>= MEMCG_DELAY_SCALING_SHIFT;
2332
2333	if (usage <= high)
2334	goto out;
2335
2336	/*
2337	* Prevent division by 0 in overage calculation by acting as if it was a
2338	* threshold of 1 page
2339	*/
2340	clamped_high = max(high, 1UL);
2341
2342	overage = div_u64((u64)(usage - high) << MEMCG_DELAY_PRECISION_SHIFT,
2343	clamped_high);
2344
2345	penalty_jiffies = ((u64)overage * overage * HZ)
2346	>> (MEMCG_DELAY_PRECISION_SHIFT + MEMCG_DELAY_SCALING_SHIFT);
2347		2345
2348	/*	2346	/*
2349	* Factor in the task's own contribution to the overage, such that four	2347	* Factor in the task's own contribution to the overage, such that four
@@ -2360,7 +2358,32 @@ void mem_cgroup_handle_over_high(void) · 10 unmodified lines
2360	* application moving forwards and also permit diagnostics, albeit	2358	* application moving forwards and also permit diagnostics, albeit
2361	* extremely slowly.	2359	* extremely slowly.
2362	*/	2360	*/
2363	penalty_jiffies = min(penalty_jiffies, MEMCG_MAX_HIGH_DELAY_JIFFIES);	2361	return min(penalty_jiffies, MEMCG_MAX_HIGH_DELAY_JIFFIES);
		2362	}
		2363
		2364	/*
		2365	* Scheduled by try_charge() to be executed from the userland return path
		2366	* and reclaims memory over the high limit.
		2367	*/
		2368	void mem_cgroup_handle_over_high(void)
		2369	{
		2370	unsigned long penalty_jiffies;
		2371	unsigned long pflags;
		2372	unsigned int nr_pages = current->memcg_nr_pages_over_high;
		2373	struct mem_cgroup *memcg;
		2374
		2375	if (likely(!nr_pages))
		2376	return;
		2377
		2378	memcg = get_mem_cgroup_from_mm(current->mm);
		2379	reclaim_high(memcg, nr_pages, GFP_KERNEL);
		2380	current->memcg_nr_pages_over_high = 0;
		2381
		2382	/*
		2383	* memory.high is breached and reclaim is unable to keep up. Throttle
		2384	* allocators proactively to slow down excessive growth.
		2385	*/
		2386	penalty_jiffies = calculate_high_delay(memcg, nr_pages);
2364		2387
2365	/*	2388	/*
2366	* Don't sleep if the amount of jiffies this memcg owes us is so low	2389	* Don't sleep if the amount of jiffies this memcg owes us is so low
@@ -4027,7 +4050,7 @@ static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg, · 1660 unmodified lines
4027	struct mem_cgroup_thresholds *thresholds;	4050	struct mem_cgroup_thresholds *thresholds;
4028	struct mem_cgroup_threshold_ary *new;	4051	struct mem_cgroup_threshold_ary *new;
4029	unsigned long usage;	4052	unsigned long usage;
4030	int i, j, size;	4053	int i, j, size, entries;
4031		4054
4032	mutex_lock(&memcg->thresholds_lock);	4055	mutex_lock(&memcg->thresholds_lock);
4033		4056
@@ -4047,14 +4070,20 @@ static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg, · 13 unmodified lines
4047	__mem_cgroup_threshold(memcg, type == _MEMSWAP);	4070	__mem_cgroup_threshold(memcg, type == _MEMSWAP);
4048		4071
4049	/* Calculate new number of threshold */	4072	/* Calculate new number of threshold */
4050	size = 0;	4073	size = entries = 0;
4051	for (i = 0; i < thresholds->primary->size; i++) {	4074	for (i = 0; i < thresholds->primary->size; i++) {
4052	if (thresholds->primary->entries[i].eventfd != eventfd)	4075	if (thresholds->primary->entries[i].eventfd != eventfd)
4053	size++;	4076	size++;
		4077	else
		4078	entries++;
4054	}	4079	}
4055		4080
4056	new = thresholds->spare;	4081	new = thresholds->spare;
4057		4082
		4083	/* If no items related to eventfd have been cleared, nothing to do */
		4084	if (!entries)
		4085	goto unlock;
		4086
4058	/* Set thresholds array to NULL if we don't have thresholds */	4087	/* Set thresholds array to NULL if we don't have thresholds */
4059	if (!size) {	4088	if (!size) {
4060	kfree(new);	4089	kfree(new);
@@ -6682,19 +6711,9 @@ void mem_cgroup_sk_alloc(struct sock *sk) · 2621 unmodified lines
6682	if (!mem_cgroup_sockets_enabled)	6711	if (!mem_cgroup_sockets_enabled)
6683	return;	6712	return;
6684		6713
6685	/*	6714	/* Do not associate the sock with unrelated interrupted task's memcg. */
6686	* Socket cloning can throw us here with sk_memcg already	6715	if (in_interrupt())
6687	* filled. It won't however, necessarily happen from
6688	* process context. So the test for root memcg given
6689	* the current task's memcg won't help us in this case.
6690	*
6691	* Respecting the original socket's memcg is a better
6692	* decision in this case.
6693	*/
6694	if (sk->sk_memcg) {
6695	css_get(&sk->sk_memcg->css);
6696	return;	6716	return;
6697	}
6698		6717
6699	rcu_read_lock();	6718	rcu_read_lock();
6700	memcg = mem_cgroup_from_task(current);	6719	memcg = mem_cgroup_from_task(current);

mm/mmu_notifier.c+18−9

 	 * ->release returns.
 	 */
 	id = srcu_read_lock(&srcu);
-	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist)
+	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu))
 		/*
 		 * If ->release runs before mmu_notifier_unregister it must be
 		 * handled, as it's the only way for the driver to flush all
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->clear_flush_young)
 			young |= subscription->ops->clear_flush_young(
 				subscription, mm, start, end);
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->clear_young)
 			young |= subscription->ops->clear_young(subscription,
 								mm, start, end);
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->test_young) {
 			young = subscription->ops->test_young(subscription, mm,
 							      address);
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->change_pte)
 			subscription->ops->change_pte(subscription, mm, address,
 						      pte);
 	int id;
 	id = srcu_read_lock(&srcu);
-	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist) {
+	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		const struct mmu_notifier_ops *ops = subscription->ops;
 		if (ops->invalidate_range_start) {
 	int id;
 	id = srcu_read_lock(&srcu);
-	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist) {
+	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		/*
 		 * Call invalidate_range here too to avoid the need for the
 		 * subsystem of having to register an invalidate_range_end
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->invalidate_range)
 			subscription->ops->invalidate_range(subscription, mm,
 							    start, end);
 	spin_lock(&mm->notifier_subscriptions->lock);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 lockdep_is_held(&mm->notifier_subscriptions->lock)) {
 		if (subscription->ops != ops)
 			continue;

mm/nommu.c+7−3

 EXPORT_SYMBOL_GPL(vm_unmap_aliases);
 /*
- * Implement a stub for vmalloc_sync_all() if the architecture chose not to
+ * Implement a stub for vmalloc_sync_[un]mapping() if the architecture
- * have one.
+ * chose not to have one.
  */
-void __weak vmalloc_sync_all(void)
+void __weak vmalloc_sync_mappings(void)
+{
+}
+void __weak vmalloc_sync_unmappings(void)
 {
 }

mm/slub.c+30−11

@@ -1973,8 +1973,6 @@ static void get_partial(struct kmem_cache s, gfp_t flags, int node, · 1972 unmodified lines
1973		1973
1974	if (node == NUMA_NO_NODE)	1974	if (node == NUMA_NO_NODE)
1975	searchnode = numa_mem_id();	1975	searchnode = numa_mem_id();
1976	else if (!node_present_pages(node))
1977	searchnode = node_to_mem_node(node);
1978		1976
1979	object = get_partial_node(s, get_node(s, searchnode), c, flags);	1977	object = get_partial_node(s, get_node(s, searchnode), c, flags);
1980	if (object \|\| node != NUMA_NO_NODE)	1978	if (object \|\| node != NUMA_NO_NODE)
@@ -2563,17 +2561,27 @@ static void ___slab_alloc(struct kmem_cache s, gfp_t gfpflags, int node, · 582 unmodified lines
2563	struct page *page;	2561	struct page *page;
2564		2562
2565	page = c->page;	2563	page = c->page;
2566	if (!page)	2564	if (!page) {
		2565	/*
		2566	* if the node is not online or has no normal memory, just
		2567	* ignore the node constraint
		2568	*/
		2569	if (unlikely(node != NUMA_NO_NODE &&
		2570	!node_state(node, N_NORMAL_MEMORY)))
		2571	node = NUMA_NO_NODE;
2567	goto new_slab;	2572	goto new_slab;
		2573	}
2568	redo:	2574	redo:
2569		2575
2570	if (unlikely(!node_match(page, node))) {	2576	if (unlikely(!node_match(page, node))) {
2571	int searchnode = node;	2577	/*
2572		2578	* same as above but node_match() being false already
2573	if (node != NUMA_NO_NODE && !node_present_pages(node))	2579	* implies node != NUMA_NO_NODE
2574	searchnode = node_to_mem_node(node);	2580	*/
2575		2581	if (!node_state(node, N_NORMAL_MEMORY)) {
2576	if (unlikely(!node_match(page, searchnode))) {	2582	node = NUMA_NO_NODE;
		2583	goto redo;
		2584	} else {
2577	stat(s, ALLOC_NODE_MISMATCH);	2585	stat(s, ALLOC_NODE_MISMATCH);
2578	deactivate_slab(s, page, c->freelist, c);	2586	deactivate_slab(s, page, c->freelist, c);
2579	goto new_slab;	2587	goto new_slab;
@@ -2997,11 +3005,13 @@ redo: · 417 unmodified lines
2997	barrier();	3005	barrier();
2998		3006
2999	if (likely(page == c->page)) {	3007	if (likely(page == c->page)) {
3000	set_freepointer(s, tail_obj, c->freelist);	3008	void **freelist = READ_ONCE(c->freelist);
		3009
		3010	set_freepointer(s, tail_obj, freelist);
3001		3011
3002	if (unlikely(!this_cpu_cmpxchg_double(	3012	if (unlikely(!this_cpu_cmpxchg_double(
3003	s->cpu_slab->freelist, s->cpu_slab->tid,	3013	s->cpu_slab->freelist, s->cpu_slab->tid,
3004	c->freelist, tid,	3014	freelist, tid,
3005	head, next_tid(tid)))) {	3015	head, next_tid(tid)))) {
3006		3016
3007	note_cmpxchg_failure("slab_free", s, tid);	3017	note_cmpxchg_failure("slab_free", s, tid);
@@ -3174,6 +3184,15 @@ int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, · 166 unmodified lines
3174	void *object = c->freelist;	3184	void *object = c->freelist;
3175		3185
3176	if (unlikely(!object)) {	3186	if (unlikely(!object)) {
		3187	/*
		3188	* We may have removed an object from c->freelist using
		3189	* the fastpath in the previous iteration; in that case,
		3190	* c->tid has not been bumped yet.
		3191	* Since ___slab_alloc() may reenable interrupts while
		3192	* allocating memory, we should bump c->tid now.
		3193	*/
		3194	c->tid = next_tid(c->tid);
		3195
3177	/*	3196	/*
3178	* Invoking slow path likely have side-effect	3197	* Invoking slow path likely have side-effect
3179	* of re-populating per CPU c->freelist	3198	* of re-populating per CPU c->freelist

mm/sparse.c+6−2

 	struct mem_section *ms = __pfn_to_section(pfn);
 	bool section_is_early = early_section(ms);
 	struct page *memmap = NULL;
+	bool empty;
 	unsigned long *subsection_map = ms->usage
 		? &ms->usage->subsection_map[0] : NULL;
 	 * For 2/ and 3/ the SPARSEMEM_VMEMMAP={y,n} cases are unified
 	 */
 	bitmap_xor(subsection_map, map, subsection_map, SUBSECTIONS_PER_SECTION);
-	if (bitmap_empty(subsection_map, SUBSECTIONS_PER_SECTION)) {
+	empty = bitmap_empty(subsection_map, SUBSECTIONS_PER_SECTION);
+	if (empty) {
 		unsigned long section_nr = pfn_to_section_nr(pfn);
 		/*
 			ms->usage = NULL;
 		}
 		memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr);
-		ms->section_mem_map = (unsigned long)NULL;
 	}
 	if (section_is_early && memmap)
 		free_map_bootmem(memmap);
 	else
 		depopulate_section_memmap(pfn, nr_pages, altmap);
+	if (empty)
+		ms->section_mem_map = (unsigned long)NULL;
 }
 static struct page * __meminit section_activate(int nid, unsigned long pfn,

mm/vmalloc.c+7−4

 	 * First make sure the mappings are removed from all page-tables
 	 * before they are freed.
 	 */
-	vmalloc_sync_all();
+	vmalloc_sync_unmappings();
 	/*
 	 * TODO: to calculate a flush range without looping.
 EXPORT_SYMBOL(remap_vmalloc_range);
 /*
- * Implement a stub for vmalloc_sync_all() if the architecture chose not to
+ * Implement stubs for vmalloc_sync_[un]mappings () if the architecture chose
- * have one.
+ * not to have one.
  *
  * The purpose of this function is to make sure the vmalloc area
  * mappings are identical in all page-tables in the system.
  */
-void __weak vmalloc_sync_all(void)
+void __weak vmalloc_sync_mappings(void)
 {
 }
+void __weak vmalloc_sync_unmappings(void)
+{
+}
 static int f(pte_t *pte, unsigned long addr, void *data)
 {

net/batman-adv/bat_iv_ogm.c+4−0

@@ -789,6 +789,10 @@ static void batadv_iv_ogm_schedule_buff(struct batadv_hard_iface *hard_iface) · 788 unmodified lines
789		789
790	lockdep_assert_held(&hard_iface->bat_iv.ogm_buff_mutex);	790	lockdep_assert_held(&hard_iface->bat_iv.ogm_buff_mutex);
791		791
		792	/* interface already disabled by batadv_iv_ogm_iface_disable */
		793	if (!*ogm_buff)
		794	return;
		795
792	/* the interface gets activated here to avoid race conditions between	796	/* the interface gets activated here to avoid race conditions between
793	* the moment of activating the interface in	797	* the moment of activating the interface in
794	* hardif_activate_interface() where the originator mac is set and	798	* hardif_activate_interface() where the originator mac is set and

net/caif/caif_dev.c+2−1

@@ -112,7 +112,8 @@ static struct caif_device_entry caif_get(struct net_device dev) · 111 unmodified lines
112	caif_device_list(dev_net(dev));	112	caif_device_list(dev_net(dev));
113	struct caif_device_entry *caifd;	113	struct caif_device_entry *caifd;
114		114
115	list_for_each_entry_rcu(caifd, &caifdevs->list, list) {	115	list_for_each_entry_rcu(caifd, &caifdevs->list, list,
		116	lockdep_rtnl_is_held()) {
116	if (caifd->netdev == dev)	117	if (caifd->netdev == dev)
117	return caifd;	118	return caifd;
118	}	119	}

net/core/devlink.c+21−12

@@ -3352,34 +3352,41 @@ devlink_param_value_get_from_info(const struct devlink_param *param, · 3351 unmodified lines
3352	struct genl_info *info,	3352	struct genl_info *info,
3353	union devlink_param_value *value)	3353	union devlink_param_value *value)
3354	{	3354	{
		3355	struct nlattr *param_data;
3355	int len;	3356	int len;
3356		3357
3357	if (param->type != DEVLINK_PARAM_TYPE_BOOL &&	3358	param_data = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA];
3358	!info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA])	3359
		3360	if (param->type != DEVLINK_PARAM_TYPE_BOOL && !param_data)
3359	return -EINVAL;	3361	return -EINVAL;
3360		3362
3361	switch (param->type) {	3363	switch (param->type) {
3362	case DEVLINK_PARAM_TYPE_U8:	3364	case DEVLINK_PARAM_TYPE_U8:
3363	value->vu8 = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);	3365	if (nla_len(param_data) != sizeof(u8))
		3366	return -EINVAL;
		3367	value->vu8 = nla_get_u8(param_data);
3364	break;	3368	break;
3365	case DEVLINK_PARAM_TYPE_U16:	3369	case DEVLINK_PARAM_TYPE_U16:
3366	value->vu16 = nla_get_u16(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);	3370	if (nla_len(param_data) != sizeof(u16))
		3371	return -EINVAL;
		3372	value->vu16 = nla_get_u16(param_data);
3367	break;	3373	break;
3368	case DEVLINK_PARAM_TYPE_U32:	3374	case DEVLINK_PARAM_TYPE_U32:
3369	value->vu32 = nla_get_u32(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);	3375	if (nla_len(param_data) != sizeof(u32))
		3376	return -EINVAL;
		3377	value->vu32 = nla_get_u32(param_data);
3370	break;	3378	break;
3371	case DEVLINK_PARAM_TYPE_STRING:	3379	case DEVLINK_PARAM_TYPE_STRING:
3372	len = strnlen(nla_data(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]),	3380	len = strnlen(nla_data(param_data), nla_len(param_data));
3373	nla_len(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]));	3381	if (len == nla_len(param_data) \|\|
3374	if (len == nla_len(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]) \|\|
3375	len >= __DEVLINK_PARAM_MAX_STRING_VALUE)	3382	len >= __DEVLINK_PARAM_MAX_STRING_VALUE)
3376	return -EINVAL;	3383	return -EINVAL;
3377	strcpy(value->vstr,	3384	strcpy(value->vstr, nla_data(param_data));
3378	nla_data(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]));
3379	break;	3385	break;
3380	case DEVLINK_PARAM_TYPE_BOOL:	3386	case DEVLINK_PARAM_TYPE_BOOL:
3381	value->vbool = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA] ?	3387	if (param_data && nla_len(param_data))
3382	true : false;	3388	return -EINVAL;
		3389	value->vbool = nla_get_flag(param_data);
3383	break;	3390	break;
3384	}	3391	}
3385	return 0;	3392	return 0;
@@ -5951,6 +5958,8 @@ static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = { · 2565 unmodified lines
5951	[DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .type = NLA_U8 },	5958	[DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .type = NLA_U8 },
5952	[DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING },	5959	[DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING },
5953	[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32 },	5960	[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32 },
		5961	[DEVLINK_ATTR_REGION_CHUNK_ADDR] = { .type = NLA_U64 },
		5962	[DEVLINK_ATTR_REGION_CHUNK_LEN] = { .type = NLA_U64 },
5954	[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING },	5963	[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING },
5955	[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64 },	5964	[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64 },
5956	[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },	5965	[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },

net/core/netclassid_cgroup.c+37−10

 	kfree(css_cls_state(css));
 }
+/*
+ * To avoid freezing of sockets creation for tasks with big number of threads
+ * and opened sockets lets release file_lock every 1000 iterated descriptors.
+ * New sockets will already have been created with new classid.
+ */
+struct update_classid_context {
+	u32 classid;
+	unsigned int batch;
+};
+#define UPDATE_CLASSID_BATCH 1000
 static int update_classid_sock(const void *v, struct file *file, unsigned n)
 {
 	int err;
+	struct update_classid_context *ctx = (void *)v;
 	struct socket *sock = sock_from_file(file, &err);
 	if (sock) {
 		spin_lock(&cgroup_sk_update_lock);
-		sock_cgroup_set_classid(&sock->sk->sk_cgrp_data,
+		sock_cgroup_set_classid(&sock->sk->sk_cgrp_data, ctx->classid);
-					(unsigned long)v);
 		spin_unlock(&cgroup_sk_update_lock);
 	}
+	if (--ctx->batch == 0) {
+		ctx->batch = UPDATE_CLASSID_BATCH;
+		return n + 1;
+	}
 	return 0;
 }
+static void update_classid_task(struct task_struct *p, u32 classid)
+{
+	struct update_classid_context ctx = {
+		.classid = classid,
+		.batch = UPDATE_CLASSID_BATCH
+	};
+	unsigned int fd = 0;
+	do {
+		task_lock(p);
+		fd = iterate_fd(p->files, fd, update_classid_sock, &ctx);
+		task_unlock(p);
+		cond_resched();
+	} while (fd);
+}
 static void cgrp_attach(struct cgroup_taskset *tset)
 {
 	struct cgroup_subsys_state *css;
 	struct task_struct *p;
 	cgroup_taskset_for_each(p, css, tset) {
-		task_lock(p);
+		update_classid_task(p, css_cls_state(css)->classid);
-		iterate_fd(p->files, 0, update_classid_sock,
-			   (void *)(unsigned long)css_cls_state(css)->classid);
-		task_unlock(p);
 	}
 }
 	css_task_iter_start(css, 0, &it);
 	while ((p = css_task_iter_next(&it))) {
-		task_lock(p);
+		update_classid_task(p, cs->classid);
-		iterate_fd(p->files, 0, update_classid_sock,
-			   (void *)(unsigned long)cs->classid);
-		task_unlock(p);
 		cond_resched();
 	}
 	css_task_iter_end(&it);

net/core/sock.c+4−1

@@ -1830,7 +1830,10 @@ struct sock sk_clone_lock(const struct sock sk, const gfp_t priority) · 1829 unmodified lines
1830	atomic_set(&newsk->sk_zckey, 0);	1830	atomic_set(&newsk->sk_zckey, 0);
1831		1831
1832	sock_reset_flag(newsk, SOCK_DONE);	1832	sock_reset_flag(newsk, SOCK_DONE);
1833	mem_cgroup_sk_alloc(newsk);	1833
		1834	/* sk->sk_memcg will be populated at accept() time */
		1835	newsk->sk_memcg = NULL;
		1836
1834	cgroup_sk_alloc(&newsk->sk_cgrp_data);	1837	cgroup_sk_alloc(&newsk->sk_cgrp_data);
1835		1838
1836	rcu_read_lock();	1839	rcu_read_lock();

net/dsa/dsa_priv.h+2−0

 /* port.c */
 int dsa_port_set_state(struct dsa_port *dp, u8 state,
 		       struct switchdev_trans *trans);
+int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy);
 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy);
+void dsa_port_disable_rt(struct dsa_port *dp);
 void dsa_port_disable(struct dsa_port *dp);
 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br);
 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br);

net/dsa/port.c+35−9

 		pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
 }
-int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
+int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
 {
 	struct dsa_switch *ds = dp->ds;
 	int port = dp->index;
 	if (!dp->bridge_dev)
 		dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
+	if (dp->pl)
+		phylink_start(dp->pl);
 	return 0;
 }
-void dsa_port_disable(struct dsa_port *dp)
+int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
+{
+	int err;
+	rtnl_lock();
+	err = dsa_port_enable_rt(dp, phy);
+	rtnl_unlock();
+	return err;
+}
+void dsa_port_disable_rt(struct dsa_port *dp)
 {
 	struct dsa_switch *ds = dp->ds;
 	int port = dp->index;
+	if (dp->pl)
+		phylink_stop(dp->pl);
 	if (!dp->bridge_dev)
 		dsa_port_set_state_now(dp, BR_STATE_DISABLED);
 		ds->ops->port_disable(ds, port);
 }
+void dsa_port_disable(struct dsa_port *dp)
+{
+	rtnl_lock();
+	dsa_port_disable_rt(dp);
+	rtnl_unlock();
+}
 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br)
 {
 	struct dsa_notifier_bridge_info info = {
 		goto err_phy_connect;
 	}
-	rtnl_lock();
-	phylink_start(dp->pl);
-	rtnl_unlock();
 	return 0;
 err_phy_connect:
 int dsa_port_link_register_of(struct dsa_port *dp)
 {
 	struct dsa_switch *ds = dp->ds;
+	struct device_node *phy_np;
-	if (!ds->ops->adjust_link)
+	if (!ds->ops->adjust_link) {
-		return dsa_port_phylink_register(dp);
+		phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
+		if (of_phy_is_fixed_link(dp->dn) || phy_np)
+			return dsa_port_phylink_register(dp);
+		return 0;
+	}
 	dev_warn(ds->dev,
 		 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
 {
 	struct dsa_switch *ds = dp->ds;
-	if (!ds->ops->adjust_link) {
+	if (!ds->ops->adjust_link && dp->pl) {
 		rtnl_lock();
 		phylink_disconnect_phy(dp->pl);
 		rtnl_unlock();
 		phylink_destroy(dp->pl);
+		dp->pl = NULL;
 		return;
 	}

net/dsa/slave.c+2−6

 			goto clear_allmulti;
 	}
-	err = dsa_port_enable(dp, dev->phydev);
+	err = dsa_port_enable_rt(dp, dev->phydev);
 	if (err)
 		goto clear_promisc;
-	phylink_start(dp->pl);
 	return 0;
 clear_promisc:
 	struct net_device *master = dsa_slave_to_master(dev);
 	struct dsa_port *dp = dsa_slave_to_port(dev);
-	phylink_stop(dp->pl);
+	dsa_port_disable_rt(dp);
-	dsa_port_disable(dp);
 	dev_mc_unsync(master, dev);
 	dev_uc_unsync(master, dev);

net/ieee802154/nl_policy.c+6−0

 	[IEEE802154_ATTR_HW_ADDR] = { .type = NLA_HW_ADDR, },
 	[IEEE802154_ATTR_PAN_ID] = { .type = NLA_U16, },
 	[IEEE802154_ATTR_CHANNEL] = { .type = NLA_U8, },
+	[IEEE802154_ATTR_BCN_ORD] = { .type = NLA_U8, },
+	[IEEE802154_ATTR_SF_ORD] = { .type = NLA_U8, },
+	[IEEE802154_ATTR_PAN_COORD] = { .type = NLA_U8, },
+	[IEEE802154_ATTR_BAT_EXT] = { .type = NLA_U8, },
+	[IEEE802154_ATTR_COORD_REALIGN] = { .type = NLA_U8, },
 	[IEEE802154_ATTR_PAGE] = { .type = NLA_U8, },
+	[IEEE802154_ATTR_DEV_TYPE] = { .type = NLA_U8, },
 	[IEEE802154_ATTR_COORD_SHORT_ADDR] = { .type = NLA_U16, },
 	[IEEE802154_ATTR_COORD_HW_ADDR] = { .type = NLA_HW_ADDR, },
 	[IEEE802154_ATTR_COORD_PAN_ID] = { .type = NLA_U16, },

net/ipv4/gre_demux.c+10−2

 }
 EXPORT_SYMBOL_GPL(gre_del_protocol);
-/* Fills in tpi and returns header length to be pulled. */
+/* Fills in tpi and returns header length to be pulled.
+ * Note that caller must use pskb_may_pull() before pulling GRE header.
+ */
 int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
 		     bool *csum_err, __be16 proto, int nhs)
 {
 	 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
 	 */
 	if (greh->flags == 0 && tpi->proto == htons(ETH_P_WCCP)) {
+		u8 _val, *val;
+		val = skb_header_pointer(skb, nhs + hdr_len,
+					 sizeof(_val), &_val);
+		if (!val)
+			return -EINVAL;
 		tpi->proto = proto;
-		if ((*(u8 *)options & 0xF0) != 0x40)
+		if ((*val & 0xF0) != 0x40)
 			hdr_len += 4;
 	}
 	tpi->hdr_len = hdr_len;

net/ipv4/inet_connection_sock.c+20−0

@@ -482,8 +482,28 @@ struct sock inet_csk_accept(struct sock sk, int flags, int *err, bool kern) · 481 unmodified lines
482	}	482	}
483	spin_unlock_bh(&queue->fastopenq.lock);	483	spin_unlock_bh(&queue->fastopenq.lock);
484	}	484	}
		485
485	out:	486	out:
486	release_sock(sk);	487	release_sock(sk);
		488	if (newsk && mem_cgroup_sockets_enabled) {
		489	int amt;
		490
		491	/* atomically get the memory usage, set and charge the
		492	* newsk->sk_memcg.
		493	*/
		494	lock_sock(newsk);
		495
		496	/* The socket has not been accepted yet, no need to look at
		497	* newsk->sk_wmem_queued.
		498	*/
		499	amt = sk_mem_pages(newsk->sk_forward_alloc +
		500	atomic_read(&newsk->sk_rmem_alloc));
		501	mem_cgroup_sk_alloc(newsk);
		502	if (newsk->sk_memcg && amt)
		503	mem_cgroup_charge_skmem(newsk->sk_memcg, amt);
		504
		505	release_sock(newsk);
		506	}
487	if (req)	507	if (req)
488	reqsk_put(req);	508	reqsk_put(req);
489	return newsk;	509	return newsk;

net/ipv4/inet_diag.c+20−24

 		aux = handler->idiag_get_aux_size(sk, net_admin);
 	return	  nla_total_size(sizeof(struct tcp_info))
-		+ nla_total_size(1) /* INET_DIAG_SHUTDOWN */
-		+ nla_total_size(1) /* INET_DIAG_TOS */
-		+ nla_total_size(1) /* INET_DIAG_TCLASS */
-		+ nla_total_size(4) /* INET_DIAG_MARK */
-		+ nla_total_size(4) /* INET_DIAG_CLASS_ID */
-		+ nla_total_size(sizeof(struct inet_diag_meminfo))
 		+ nla_total_size(sizeof(struct inet_diag_msg))
+		+ inet_diag_msg_attrs_size()
+		+ nla_total_size(sizeof(struct inet_diag_meminfo))
 		+ nla_total_size(SK_MEMINFO_VARS * sizeof(u32))
 		+ nla_total_size(TCP_CA_NAME_MAX)
 		+ nla_total_size(sizeof(struct tcpvegas_info))
 	if (net_admin && nla_put_u32(skb, INET_DIAG_MARK, sk->sk_mark))
 		goto errout;
+	if (ext & (1 << (INET_DIAG_CLASS_ID - 1)) ||
+	    ext & (1 << (INET_DIAG_TCLASS - 1))) {
+		u32 classid = 0;
+#ifdef CONFIG_SOCK_CGROUP_DATA
+		classid = sock_cgroup_classid(&sk->sk_cgrp_data);
+#endif
+		/* Fallback to socket priority if class id isn't set.
+		 * Classful qdiscs use it as direct reference to class.
+		 * For cgroup2 classid is always zero.
+		 */
+		if (!classid)
+			classid = sk->sk_priority;
+		if (nla_put_u32(skb, INET_DIAG_CLASS_ID, classid))
+			goto errout;
+	}
 	r->idiag_uid = from_kuid_munged(user_ns, sock_i_uid(sk));
 	r->idiag_inode = sock_i_ino(sk);
 			goto errout;
 	}
-	if (ext & (1 << (INET_DIAG_CLASS_ID - 1)) ||
-	    ext & (1 << (INET_DIAG_TCLASS - 1))) {
-		u32 classid = 0;
-#ifdef CONFIG_SOCK_CGROUP_DATA
-		classid = sock_cgroup_classid(&sk->sk_cgrp_data);
-#endif
-		/* Fallback to socket priority if class id isn't set.
-		 * Classful qdiscs use it as direct reference to class.
-		 * For cgroup2 classid is always zero.
-		 */
-		if (!classid)
-			classid = sk->sk_priority;
-		if (nla_put_u32(skb, INET_DIAG_CLASS_ID, classid))
-			goto errout;
-	}
 out:
 	nlmsg_end(skb, nlh);
 	return 0;

net/ipv4/raw_diag.c+3−2

 	if (IS_ERR(sk))
 		return PTR_ERR(sk);
-	rep = nlmsg_new(sizeof(struct inet_diag_msg) +
+	rep = nlmsg_new(nla_total_size(sizeof(struct inet_diag_msg)) +
-			sizeof(struct inet_diag_meminfo) + 64,
+			inet_diag_msg_attrs_size() +
+			nla_total_size(sizeof(struct inet_diag_meminfo)) + 64,
 			GFP_KERNEL);
 	if (!rep) {
 		sock_put(sk);

net/ipv4/udp_diag.c+3−2

 		goto out;
 	err = -ENOMEM;
-	rep = nlmsg_new(sizeof(struct inet_diag_msg) +
+	rep = nlmsg_new(nla_total_size(sizeof(struct inet_diag_msg)) +
-			sizeof(struct inet_diag_meminfo) + 64,
+			inet_diag_msg_attrs_size() +
+			nla_total_size(sizeof(struct inet_diag_meminfo)) + 64,
 			GFP_KERNEL);
 	if (!rep)
 		goto out;

net/ipv6/addrconf.c+40−11

 }
 static void
-cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires, bool del_rt)
+cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires,
+		     bool del_rt, bool del_peer)
 {
 	struct fib6_info *f6i;
-	f6i = addrconf_get_prefix_route(&ifp->addr, ifp->prefix_len,
+	f6i = addrconf_get_prefix_route(del_peer ? &ifp->peer_addr : &ifp->addr,
+					ifp->prefix_len,
 					ifp->idev->dev, 0, RTF_DEFAULT, true);
 	if (f6i) {
 		if (del_rt)
 	if (action != CLEANUP_PREFIX_RT_NOP) {
 		cleanup_prefix_route(ifp, expires,
-			action == CLEANUP_PREFIX_RT_DEL);
+			action == CLEANUP_PREFIX_RT_DEL, false);
 	}
 	/* clean up prefsrc entries */
 	    (dev->type != ARPHRD_NONE) &&
 	    (dev->type != ARPHRD_RAWIP)) {
 		/* Alas, we support only Ethernet autoconfiguration. */
+		idev = __in6_dev_get(dev);
+		if (!IS_ERR_OR_NULL(idev) && dev->flags & IFF_UP &&
+		    dev->flags & IFF_MULTICAST)
+			ipv6_mc_up(idev);
 		return;
 	}
 }
 static int modify_prefix_route(struct inet6_ifaddr *ifp,
-			       unsigned long expires, u32 flags)
+			       unsigned long expires, u32 flags,
+			       bool modify_peer)
 {
 	struct fib6_info *f6i;
 	u32 prio;
-	f6i = addrconf_get_prefix_route(&ifp->addr, ifp->prefix_len,
+	f6i = addrconf_get_prefix_route(modify_peer ? &ifp->peer_addr : &ifp->addr,
+					ifp->prefix_len,
 					ifp->idev->dev, 0, RTF_DEFAULT, true);
 	if (!f6i)
 		return -ENOENT;
 		ip6_del_rt(dev_net(ifp->idev->dev), f6i);
 		/* add new one */
-		addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
+		addrconf_prefix_route(modify_peer ? &ifp->peer_addr : &ifp->addr,
+				      ifp->prefix_len,
 				      ifp->rt_priority, ifp->idev->dev,
 				      expires, flags, GFP_KERNEL);
 	} else {
 	unsigned long timeout;
 	bool was_managetempaddr;
 	bool had_prefixroute;
+	bool new_peer = false;
 	ASSERT_RTNL();
 		cfg->preferred_lft = timeout;
 	}
+	if (cfg->peer_pfx &&
+	    memcmp(&ifp->peer_addr, cfg->peer_pfx, sizeof(struct in6_addr))) {
+		if (!ipv6_addr_any(&ifp->peer_addr))
+			cleanup_prefix_route(ifp, expires, true, true);
+		new_peer = true;
+	}
 	spin_lock_bh(&ifp->lock);
 	was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
 	had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
 	if (cfg->rt_priority && cfg->rt_priority != ifp->rt_priority)
 		ifp->rt_priority = cfg->rt_priority;
+	if (new_peer)
+		ifp->peer_addr = *cfg->peer_pfx;
 	spin_unlock_bh(&ifp->lock);
 	if (!(ifp->flags&IFA_F_TENTATIVE))
 		ipv6_ifa_notify(0, ifp);
 		int rc = -ENOENT;
 		if (had_prefixroute)
-			rc = modify_prefix_route(ifp, expires, flags);
+			rc = modify_prefix_route(ifp, expires, flags, false);
 		/* prefix route could have been deleted; if so restore it */
 		if (rc == -ENOENT) {
 					      ifp->rt_priority, ifp->idev->dev,
 					      expires, flags, GFP_KERNEL);
 		}
+		if (had_prefixroute && !ipv6_addr_any(&ifp->peer_addr))
+			rc = modify_prefix_route(ifp, expires, flags, true);
+		if (rc == -ENOENT && !ipv6_addr_any(&ifp->peer_addr)) {
+			addrconf_prefix_route(&ifp->peer_addr, ifp->prefix_len,
+					      ifp->rt_priority, ifp->idev->dev,
+					      expires, flags, GFP_KERNEL);
+		}
 	} else if (had_prefixroute) {
 		enum cleanup_prefix_rt_t action;
 		unsigned long rt_expires;
 		if (action != CLEANUP_PREFIX_RT_NOP) {
 			cleanup_prefix_route(ifp, rt_expires,
-				action == CLEANUP_PREFIX_RT_DEL);
+				action == CLEANUP_PREFIX_RT_DEL, false);
 		}
 	}
 		if (ifp->idev->cnf.forwarding)
 			addrconf_join_anycast(ifp);
 		if (!ipv6_addr_any(&ifp->peer_addr))
-			addrconf_prefix_route(&ifp->peer_addr, 128, 0,
+			addrconf_prefix_route(&ifp->peer_addr, 128,
-					      ifp->idev->dev, 0, 0,
+					      ifp->rt_priority, ifp->idev->dev,
-					      GFP_ATOMIC);
+					      0, 0, GFP_ATOMIC);
 		break;
 	case RTM_DELADDR:
 		if (ifp->idev->cnf.forwarding)

net/ipv6/seg6_iptunnel.c+1−1

@@ -268,7 +268,7 @@ static int seg6_do_srh(struct sk_buff *skb) · 267 unmodified lines
268	skb_mac_header_rebuild(skb);	268	skb_mac_header_rebuild(skb);
269	skb_push(skb, skb->mac_len);	269	skb_push(skb, skb->mac_len);
270		270
271	err = seg6_do_srh_encap(skb, tinfo->srh, NEXTHDR_NONE);	271	err = seg6_do_srh_encap(skb, tinfo->srh, IPPROTO_ETHERNET);
272	if (err)	272	if (err)
273	return err;	273	return err;
274		274

net/ipv6/seg6_local.c+1−1

@@ -282,7 +282,7 @@ static int input_action_end_dx2(struct sk_buff *skb, · 281 unmodified lines
282	struct net_device *odev;	282	struct net_device *odev;
283	struct ethhdr *eth;	283	struct ethhdr *eth;
284		284
285	if (!decap_and_validate(skb, NEXTHDR_NONE))	285	if (!decap_and_validate(skb, IPPROTO_ETHERNET))
286	goto drop;	286	goto drop;
287		287
288	if (!pskb_may_pull(skb, ETH_HLEN))	288	if (!pskb_may_pull(skb, ETH_HLEN))

net/mac80211/mesh_hwmp.c+2−1

@@ -1152,7 +1152,8 @@ int mesh_nexthop_resolve(struct ieee80211_sub_if_data *sdata, · 1151 unmodified lines
1152	}	1152	}
1153	}	1153	}
1154		1154
1155	if (!(mpath->flags & MESH_PATH_RESOLVING))	1155	if (!(mpath->flags & MESH_PATH_RESOLVING) &&
		1156	mesh_path_sel_is_hwmp(sdata))
1156	mesh_queue_preq(mpath, PREQ_Q_F_START);	1157	mesh_queue_preq(mpath, PREQ_Q_F_START);
1157		1158
1158	if (skb_queue_len(&mpath->frame_queue) >= MESH_FRAME_QUEUE_LEN)	1159	if (skb_queue_len(&mpath->frame_queue) >= MESH_FRAME_QUEUE_LEN)

net/mptcp/options.c+17−2

 	struct mptcp_sock *msk;
 	unsigned int ack_size;
 	bool ret = false;
+	bool can_ack;
+	u64 ack_seq;
 	u8 tcp_fin;
 	if (skb) {
 		ret = true;
 	}
+	/* passive sockets msk will set the 'can_ack' after accept(), even
+	 * if the first subflow may have the already the remote key handy
+	 */
+	can_ack = true;
 	opts->ext_copy.use_ack = 0;
 	msk = mptcp_sk(subflow->conn);
-	if (!msk || !READ_ONCE(msk->can_ack)) {
+	if (likely(msk && READ_ONCE(msk->can_ack))) {
+		ack_seq = msk->ack_seq;
+	} else if (subflow->can_ack) {
+		mptcp_crypto_key_sha(subflow->remote_key, NULL, &ack_seq);
+		ack_seq++;
+	} else {
+		can_ack = false;
+	}
+	if (unlikely(!can_ack)) {
 		*size = ALIGN(dss_size, 4);
 		return ret;
 	}
 	dss_size += ack_size;
-	opts->ext_copy.data_ack = msk->ack_seq;
+	opts->ext_copy.data_ack = ack_seq;
 	opts->ext_copy.ack64 = 1;
 	opts->ext_copy.use_ack = 1;

net/netfilter/nf_conntrack_standalone.c+1−1

@@ -411,7 +411,7 @@ static void ct_cpu_seq_next(struct seq_file seq, void v, loff_t pos) · 410 unmodified lines
411	*pos = cpu + 1;	411	*pos = cpu + 1;
412	return per_cpu_ptr(net->ct.stat, cpu);	412	return per_cpu_ptr(net->ct.stat, cpu);
413	}	413	}
414		414	(*pos)++;
415	return NULL;	415	return NULL;
416	}	416	}
417		417

net/netfilter/nf_synproxy_core.c+1−1

@@ -267,7 +267,7 @@ static void synproxy_cpu_seq_next(struct seq_file seq, void v, loff_t pos) · 266 unmodified lines
267	*pos = cpu + 1;	267	*pos = cpu + 1;
268	return per_cpu_ptr(snet->stats, cpu);	268	return per_cpu_ptr(snet->stats, cpu);
269	}	269	}
270		270	(*pos)++;
271	return NULL;	271	return NULL;
272	}	272	}
273		273

net/netfilter/nf_tables_api.c+14−8

 					      lockdep_commit_lock_is_held(net));
 		if (nft_dump_stats(skb, stats))
 			goto nla_put_failure;
+		if ((chain->flags & NFT_CHAIN_HW_OFFLOAD) &&
+		    nla_put_be32(skb, NFTA_CHAIN_FLAGS,
+				 htonl(NFT_CHAIN_HW_OFFLOAD)))
+			goto nla_put_failure;
 	}
 	if (nla_put_be32(skb, NFTA_CHAIN_USE, htonl(chain->use)))
 		goto err4;
 	err = nft_register_flowtable_net_hooks(ctx.net, table, flowtable);
-	if (err < 0)
+	if (err < 0) {
+		list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
+			list_del_rcu(&hook->list);
+			kfree_rcu(hook, rcu);
+		}
 		goto err4;
+	}
 	err = nft_trans_flowtable_add(&ctx, NFT_MSG_NEWFLOWTABLE, flowtable);
 	if (err < 0)
 	list_splice_init(&net->nft.module_list, &module_list);
 	mutex_unlock(&net->nft.commit_mutex);
 	list_for_each_entry_safe(req, next, &module_list, list) {
-		if (req->done) {
+		request_module("%s", req->module);
-			list_del(&req->list);
+		req->done = true;
-			kfree(req);
-		} else {
-			request_module("%s", req->module);
-			req->done = true;
-		}
 	}
 	mutex_lock(&net->nft.commit_mutex);
 	list_splice(&module_list, &net->nft.module_list);
 	__nft_release_tables(net);
 	mutex_unlock(&net->nft.commit_mutex);
 	WARN_ON_ONCE(!list_empty(&net->nft.tables));
+	WARN_ON_ONCE(!list_empty(&net->nft.module_list));
 }
 static struct pernet_operations nf_tables_net_ops = {

net/netfilter/nfnetlink_cthelper.c+2−0

@@ -742,6 +742,8 @@ static const struct nla_policy nfnl_cthelper_policy[NFCTH_MAX+1] = { · 741 unmodified lines
742	[NFCTH_NAME] = { .type = NLA_NUL_STRING,	742	[NFCTH_NAME] = { .type = NLA_NUL_STRING,
743	.len = NF_CT_HELPER_NAME_LEN-1 },	743	.len = NF_CT_HELPER_NAME_LEN-1 },
744	[NFCTH_QUEUE_NUM] = { .type = NLA_U32, },	744	[NFCTH_QUEUE_NUM] = { .type = NLA_U32, },
		745	[NFCTH_PRIV_DATA_LEN] = { .type = NLA_U32, },
		746	[NFCTH_STATUS] = { .type = NLA_U32, },
745	};	747	};
746		748
747	static const struct nfnl_callback nfnl_cthelper_cb[NFNL_MSG_CTHELPER_MAX] = {	749	static const struct nfnl_callback nfnl_cthelper_cb[NFNL_MSG_CTHELPER_MAX] = {

net/netfilter/nft_chain_nat.c+1−0

@@ -89,6 +89,7 @@ static const struct nft_chain_type nft_chain_nat_inet = { · 88 unmodified lines
89	.name = "nat",	89	.name = "nat",
90	.type = NFT_CHAIN_T_NAT,	90	.type = NFT_CHAIN_T_NAT,
91	.family = NFPROTO_INET,	91	.family = NFPROTO_INET,
		92	.owner = THIS_MODULE,
92	.hook_mask = (1 << NF_INET_PRE_ROUTING) \|	93	.hook_mask = (1 << NF_INET_PRE_ROUTING) \|
93	(1 << NF_INET_LOCAL_IN) \|	94	(1 << NF_INET_LOCAL_IN) \|
94	(1 << NF_INET_LOCAL_OUT) \|	95	(1 << NF_INET_LOCAL_OUT) \|

net/netfilter/nft_payload.c+1−0

@@ -129,6 +129,7 @@ static const struct nla_policy nft_payload_policy[NFTA_PAYLOAD_MAX + 1] = { · 128 unmodified lines
129	[NFTA_PAYLOAD_LEN] = { .type = NLA_U32 },	129	[NFTA_PAYLOAD_LEN] = { .type = NLA_U32 },
130	[NFTA_PAYLOAD_CSUM_TYPE] = { .type = NLA_U32 },	130	[NFTA_PAYLOAD_CSUM_TYPE] = { .type = NLA_U32 },
131	[NFTA_PAYLOAD_CSUM_OFFSET] = { .type = NLA_U32 },	131	[NFTA_PAYLOAD_CSUM_OFFSET] = { .type = NLA_U32 },
		132	[NFTA_PAYLOAD_CSUM_FLAGS] = { .type = NLA_U32 },
132	};	133	};
133		134
134	static int nft_payload_init(const struct nft_ctx *ctx,	135	static int nft_payload_init(const struct nft_ctx *ctx,

net/netfilter/nft_tunnel.c+2−0

@@ -339,6 +339,8 @@ static const struct nla_policy nft_tunnel_key_policy[NFTA_TUNNEL_KEY_MAX + 1] = · 338 unmodified lines
339	[NFTA_TUNNEL_KEY_FLAGS] = { .type = NLA_U32, },	339	[NFTA_TUNNEL_KEY_FLAGS] = { .type = NLA_U32, },
340	[NFTA_TUNNEL_KEY_TOS] = { .type = NLA_U8, },	340	[NFTA_TUNNEL_KEY_TOS] = { .type = NLA_U8, },
341	[NFTA_TUNNEL_KEY_TTL] = { .type = NLA_U8, },	341	[NFTA_TUNNEL_KEY_TTL] = { .type = NLA_U8, },
		342	[NFTA_TUNNEL_KEY_SPORT] = { .type = NLA_U16, },
		343	[NFTA_TUNNEL_KEY_DPORT] = { .type = NLA_U16, },
342	[NFTA_TUNNEL_KEY_OPTS] = { .type = NLA_NESTED, },	344	[NFTA_TUNNEL_KEY_OPTS] = { .type = NLA_NESTED, },
343	};	345	};
344		346

net/netfilter/x_tables.c+3−3

 	uint8_t nfproto = (unsigned long)PDE_DATA(file_inode(seq->file));
 	struct nf_mttg_trav *trav = seq->private;
+	if (ppos != NULL)
+		++(*ppos);
 	switch (trav->class) {
 	case MTTG_TRAV_INIT:
 		trav->class = MTTG_TRAV_NFP_UNSPEC;
 	default:
 		return NULL;
 	}
-	if (ppos != NULL)
-		++*ppos;
 	return trav;
 }

net/netfilter/xt_recent.c+1−1

 	const struct recent_entry *e = v;
 	const struct list_head *head = e->list.next;
+	(*pos)++;
 	while (head == &t->iphash[st->bucket]) {
 		if (++st->bucket >= ip_list_hash_size)
 			return NULL;
 		head = t->iphash[st->bucket].next;
 	}
-	(*pos)++;
 	return list_entry(head, struct recent_entry, list);
 }

net/netlink/af_netlink.c+1−1

@@ -2434,7 +2434,7 @@ void netlink_ack(struct sk_buff in_skb, struct nlmsghdr nlh, int err, · 2433 unmodified lines
2434	in_skb->len))	2434	in_skb->len))
2435	WARN_ON(nla_put_u32(skb, NLMSGERR_ATTR_OFFS,	2435	WARN_ON(nla_put_u32(skb, NLMSGERR_ATTR_OFFS,
2436	(u8 *)extack->bad_attr -	2436	(u8 *)extack->bad_attr -
2437	in_skb->data));	2437	(u8 *)nlh));
2438	} else {	2438	} else {
2439	if (extack->cookie_len)	2439	if (extack->cookie_len)
2440	WARN_ON(nla_put(skb, NLMSGERR_ATTR_COOKIE,	2440	WARN_ON(nla_put(skb, NLMSGERR_ATTR_COOKIE,

net/nfc/hci/core.c+16−3

 void nfc_hci_cmd_received(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd,
 			  struct sk_buff *skb)
 {
-	u8 gate = hdev->pipes[pipe].gate;
 	u8 status = NFC_HCI_ANY_OK;
 	struct hci_create_pipe_resp *create_info;
 	struct hci_delete_pipe_noti *delete_info;
 	struct hci_all_pipe_cleared_noti *cleared_info;
+	u8 gate;
-	pr_debug("from gate %x pipe %x cmd %x\n", gate, pipe, cmd);
+	pr_debug("from pipe %x cmd %x\n", pipe, cmd);
+	if (pipe >= NFC_HCI_MAX_PIPES) {
+		status = NFC_HCI_ANY_E_NOK;
+		goto exit;
+	}
+	gate = hdev->pipes[pipe].gate;
 	switch (cmd) {
 	case NFC_HCI_ADM_NOTIFY_PIPE_CREATED:
 			    struct sk_buff *skb)
 {
 	int r = 0;
-	u8 gate = hdev->pipes[pipe].gate;
+	u8 gate;
+	if (pipe >= NFC_HCI_MAX_PIPES) {
+		pr_err("Discarded event %x to invalid pipe %x\n", event, pipe);
+		goto exit;
+	}
+	gate = hdev->pipes[pipe].gate;
 	if (gate == NFC_HCI_INVALID_GATE) {
 		pr_err("Discarded event %x to unopened pipe %x\n", event, pipe);
 		goto exit;

net/nfc/netlink.c+4−0

 	[NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
 				.len = NFC_DEVICE_NAME_MAXSIZE },
 	[NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
+	[NFC_ATTR_TARGET_INDEX] = { .type = NLA_U32 },
 	[NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
 	[NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
 	[NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
 	[NFC_ATTR_LLC_SDP] = { .type = NLA_NESTED },
 	[NFC_ATTR_FIRMWARE_NAME] = { .type = NLA_STRING,
 				     .len = NFC_FIRMWARE_NAME_MAXSIZE },
+	[NFC_ATTR_SE_INDEX] = { .type = NLA_U32 },
 	[NFC_ATTR_SE_APDU] = { .type = NLA_BINARY },
+	[NFC_ATTR_VENDOR_ID] = { .type = NLA_U32 },
+	[NFC_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
 	[NFC_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
 };

net/openvswitch/datapath.c+1−0

@@ -645,6 +645,7 @@ static const struct nla_policy packet_policy[OVS_PACKET_ATTR_MAX + 1] = { · 644 unmodified lines
645	[OVS_PACKET_ATTR_ACTIONS] = { .type = NLA_NESTED },	645	[OVS_PACKET_ATTR_ACTIONS] = { .type = NLA_NESTED },
646	[OVS_PACKET_ATTR_PROBE] = { .type = NLA_FLAG },	646	[OVS_PACKET_ATTR_PROBE] = { .type = NLA_FLAG },
647	[OVS_PACKET_ATTR_MRU] = { .type = NLA_U16 },	647	[OVS_PACKET_ATTR_MRU] = { .type = NLA_U16 },
		648	[OVS_PACKET_ATTR_HASH] = { .type = NLA_U64 },
648	};	649	};
649		650
650	static const struct genl_ops dp_packet_genl_ops[] = {	651	static const struct genl_ops dp_packet_genl_ops[] = {

net/packet/af_packet.c+7−6

 					TP_STATUS_KERNEL, (macoff+snaplen));
 	if (!h.raw)
 		goto drop_n_account;
+	if (do_vnet &&
+	    virtio_net_hdr_from_skb(skb, h.raw + macoff -
+				    sizeof(struct virtio_net_hdr),
+				    vio_le(), true, 0))
+		goto drop_n_account;
 	if (po->tp_version <= TPACKET_V2) {
 		packet_increment_rx_head(po, &po->rx_ring);
 	/*
 			status |= TP_STATUS_LOSING;
 	}
-	if (do_vnet &&
-	    virtio_net_hdr_from_skb(skb, h.raw + macoff -
-				    sizeof(struct virtio_net_hdr),
-				    vio_le(), true, 0))
-		goto drop_n_account;
 	po->stats.stats1.tp_packets++;
 	if (copy_skb) {
 		status |= TP_STATUS_COPY;

net/sched/sch_fq.c+1−0

@@ -744,6 +744,7 @@ static const struct nla_policy fq_policy[TCA_FQ_MAX + 1] = { · 743 unmodified lines
744	[TCA_FQ_FLOW_MAX_RATE] = { .type = NLA_U32 },	744	[TCA_FQ_FLOW_MAX_RATE] = { .type = NLA_U32 },
745	[TCA_FQ_BUCKETS_LOG] = { .type = NLA_U32 },	745	[TCA_FQ_BUCKETS_LOG] = { .type = NLA_U32 },
746	[TCA_FQ_FLOW_REFILL_DELAY] = { .type = NLA_U32 },	746	[TCA_FQ_FLOW_REFILL_DELAY] = { .type = NLA_U32 },
		747	[TCA_FQ_ORPHAN_MASK] = { .type = NLA_U32 },
747	[TCA_FQ_LOW_RATE_THRESHOLD] = { .type = NLA_U32 },	748	[TCA_FQ_LOW_RATE_THRESHOLD] = { .type = NLA_U32 },
748	[TCA_FQ_CE_THRESHOLD] = { .type = NLA_U32 },	749	[TCA_FQ_CE_THRESHOLD] = { .type = NLA_U32 },
749	};	750	};

net/sched/sch_taprio.c+10−3

 		prio = skb->priority;
 		tc = netdev_get_prio_tc_map(dev, prio);
-		if (!(gate_mask & BIT(tc)))
+		if (!(gate_mask & BIT(tc))) {
+			skb = NULL;
 			continue;
+		}
 		len = qdisc_pkt_len(skb);
 		guard = ktime_add_ns(taprio_get_time(q),
 		 * guard band ...
 		 */
 		if (gate_mask != TAPRIO_ALL_GATES_OPEN &&
-		    ktime_after(guard, entry->close_time))
+		    ktime_after(guard, entry->close_time)) {
+			skb = NULL;
 			continue;
+		}
 		/* ... and no budget. */
 		if (gate_mask != TAPRIO_ALL_GATES_OPEN &&
-		    atomic_sub_return(len, &entry->budget) < 0)
+		    atomic_sub_return(len, &entry->budget) < 0) {
+			skb = NULL;
 			continue;
+		}
 		skb = child->ops->dequeue(child);
 		if (unlikely(!skb))
 	[TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME]           = { .type = NLA_S64 },
 	[TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME_EXTENSION] = { .type = NLA_S64 },
 	[TCA_TAPRIO_ATTR_FLAGS]                      = { .type = NLA_U32 },
+	[TCA_TAPRIO_ATTR_TXTIME_DELAY]		     = { .type = NLA_U32 },
 };
 static int fill_sched_entry(struct nlattr **tb, struct sched_entry *entry,

net/sctp/diag.c+2−6

 		addrcnt++;
 	return	  nla_total_size(sizeof(struct sctp_info))
-		+ nla_total_size(1) /* INET_DIAG_SHUTDOWN */
-		+ nla_total_size(1) /* INET_DIAG_TOS */
-		+ nla_total_size(1) /* INET_DIAG_TCLASS */
-		+ nla_total_size(4) /* INET_DIAG_MARK */
-		+ nla_total_size(4) /* INET_DIAG_CLASS_ID */
 		+ nla_total_size(addrlen * asoc->peer.transport_count)
 		+ nla_total_size(addrlen * addrcnt)
-		+ nla_total_size(sizeof(struct inet_diag_meminfo))
 		+ nla_total_size(sizeof(struct inet_diag_msg))
+		+ inet_diag_msg_attrs_size()
+		+ nla_total_size(sizeof(struct inet_diag_meminfo))
 		+ 64;
 }

net/smc/smc_ib.c+1−0

@@ -582,6 +582,7 @@ static void smc_ib_remove_dev(struct ib_device ibdev, void client_data) · 581 unmodified lines
582	smc_smcr_terminate_all(smcibdev);	582	smc_smcr_terminate_all(smcibdev);
583	smc_ib_cleanup_per_ibdev(smcibdev);	583	smc_ib_cleanup_per_ibdev(smcibdev);
584	ib_unregister_event_handler(&smcibdev->event_handler);	584	ib_unregister_event_handler(&smcibdev->event_handler);
		585	cancel_work_sync(&smcibdev->port_event_work);
585	kfree(smcibdev);	586	kfree(smcibdev);
586	}	587	}
587		588

net/socket.c+5−3

 int __sys_accept4_file(struct file *file, unsigned file_flags,
 		       struct sockaddr __user *upeer_sockaddr,
-		       int __user *upeer_addrlen, int flags)
+		       int __user *upeer_addrlen, int flags,
+		       unsigned long nofile)
 {
 	struct socket *sock, *newsock;
 	struct file *newfile;
 	 */
 	__module_get(newsock->ops->owner);
-	newfd = get_unused_fd_flags(flags);
+	newfd = __get_unused_fd_flags(flags, nofile);
 	if (unlikely(newfd < 0)) {
 		err = newfd;
 		sock_release(newsock);
 	f = fdget(fd);
 	if (f.file) {
 		ret = __sys_accept4_file(f.file, 0, upeer_sockaddr,
-						upeer_addrlen, flags);
+						upeer_addrlen, flags,
+						rlimit(RLIMIT_NOFILE));
 		if (f.flags)
 			fput(f.file);
 	}

net/tipc/netlink.c+1−0

@@ -116,6 +116,7 @@ const struct nla_policy tipc_nl_prop_policy[TIPC_NLA_PROP_MAX + 1] = { · 115 unmodified lines
116	[TIPC_NLA_PROP_PRIO] = { .type = NLA_U32 },	116	[TIPC_NLA_PROP_PRIO] = { .type = NLA_U32 },
117	[TIPC_NLA_PROP_TOL] = { .type = NLA_U32 },	117	[TIPC_NLA_PROP_TOL] = { .type = NLA_U32 },
118	[TIPC_NLA_PROP_WIN] = { .type = NLA_U32 },	118	[TIPC_NLA_PROP_WIN] = { .type = NLA_U32 },
		119	[TIPC_NLA_PROP_MTU] = { .type = NLA_U32 },
119	[TIPC_NLA_PROP_BROADCAST] = { .type = NLA_U32 },	120	[TIPC_NLA_PROP_BROADCAST] = { .type = NLA_U32 },
120	[TIPC_NLA_PROP_BROADCAST_RATIO] = { .type = NLA_U32 }	121	[TIPC_NLA_PROP_BROADCAST_RATIO] = { .type = NLA_U32 }
121	};	122	};

net/wireless/nl80211.c+5−0

 	[NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
 	[NL80211_ATTR_STA_PLINK_STATE] =
 		NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1),
+	[NL80211_ATTR_MEASUREMENT_DURATION] = { .type = NLA_U16 },
+	[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY] = { .type = NLA_FLAG },
 	[NL80211_ATTR_MESH_PEER_AID] =
 		NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
 	[NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
 	[NL80211_ATTR_MDID] = { .type = NLA_U16 },
 	[NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
 				  .len = IEEE80211_MAX_DATA_LEN },
+	[NL80211_ATTR_CRIT_PROT_ID] = { .type = NLA_U16 },
+	[NL80211_ATTR_MAX_CRIT_PROT_DURATION] = { .type = NLA_U16 },
 	[NL80211_ATTR_PEER_AID] =
 		NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
 	[NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
 		NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1),
 	[NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
 	[NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
+	[NL80211_ATTR_OPER_CLASS] = { .type = NLA_U8 },
 	[NL80211_ATTR_MAC_MASK] = {
 		.type = NLA_EXACT_LEN_WARN,
 		.len = ETH_ALEN

scripts/Kconfig.include+7−0

@@ -44,3 +44,10 @@ $(error-if,$(success, $(LD) -v \| grep -q gold), gold linker '$(LD)' not supporte · 43 unmodified lines
44		44
45	# gcc version including patch level	45	# gcc version including patch level
46	gcc-version := $(shell,$(srctree)/scripts/gcc-version.sh $(CC))	46	gcc-version := $(shell,$(srctree)/scripts/gcc-version.sh $(CC))
		47
		48	# machine bit flags
		49	# $(m32-flag): -m32 if the compiler supports it, or an empty string otherwise.
		50	# $(m64-flag): -m64 if the compiler supports it, or an empty string otherwise.
		51	cc-option-bit = $(if-success,$(CC) -Werror $(1) -E -x c /dev/null -o /dev/null,$(1))
		52	m32-flag := $(cc-option-bit,-m32)
		53	m64-flag := $(cc-option-bit,-m64)

scripts/Makefile.extrawarn+1−0

@@ -48,6 +48,7 @@ KBUILD_CFLAGS += -Wno-initializer-overrides · 47 unmodified lines
48	KBUILD_CFLAGS += -Wno-format	48	KBUILD_CFLAGS += -Wno-format
49	KBUILD_CFLAGS += -Wno-sign-compare	49	KBUILD_CFLAGS += -Wno-sign-compare
50	KBUILD_CFLAGS += -Wno-format-zero-length	50	KBUILD_CFLAGS += -Wno-format-zero-length
		51	KBUILD_CFLAGS += $(call cc-disable-warning, pointer-to-enum-cast)
51	endif	52	endif
52		53
53	endif	54	endif

scripts/export_report.pl+1−1

@@ -94,7 +94,7 @@ if (defined $opt{'o'}) { · 93 unmodified lines
94	#	94	#
95	while ( <$module_symvers> ) {	95	while ( <$module_symvers> ) {
96	chomp;	96	chomp;
97	my (undef, $symbol, $namespace, $module, $gpl) = split('\t');	97	my (undef, $symbol, $module, $gpl, $namespace) = split('\t');
98	$SYMBOL { $symbol } = [ $module , "0" , $symbol, $gpl];	98	$SYMBOL { $symbol } = [ $module , "0" , $symbol, $gpl];
99	}	99	}
100	close($module_symvers);	100	close($module_symvers);

scripts/kallsyms.c+4−4

 		return NULL;
 	}
-	if (is_ignored_symbol(name, type))
-		return NULL;
-	/* Ignore most absolute/undefined (?) symbols. */
 	if (strcmp(name, "_text") == 0)
 		_text = addr;
+	/* Ignore most absolute/undefined (?) symbols. */
+	if (is_ignored_symbol(name, type))
+		return NULL;
 	check_symbol_range(name, addr, text_ranges, ARRAY_SIZE(text_ranges));
 	check_symbol_range(name, addr, &percpu_range, 1);

scripts/mod/modpost.c+14−13

 static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
 {
-	Elf_Shdr *sechdr = &info->sechdrs[sym->st_shndx];
+	unsigned int secindex = get_secindex(info, sym);
+	Elf_Shdr *sechdr = &info->sechdrs[secindex];
 	unsigned long offset;
 	offset = sym->st_value;
 }
 /* parse Module.symvers file. line format:
- * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
+ * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
  **/
 static void read_dump(const char *fname, unsigned int kernel)
 {
 		return;
 	while ((line = get_next_line(&pos, file, size))) {
-		char *symname, *namespace, *modname, *d, *export, *end;
+		char *symname, *namespace, *modname, *d, *export;
 		unsigned int crc;
 		struct module *mod;
 		struct symbol *s;
 		if (!(symname = strchr(line, '\t')))
 			goto fail;
 		*symname++ = '\0';
-		if (!(namespace = strchr(symname, '\t')))
+		if (!(modname = strchr(symname, '\t')))
-			goto fail;
-		*namespace++ = '\0';
-		if (!(modname = strchr(namespace, '\t')))
 			goto fail;
 		*modname++ = '\0';
-		if ((export = strchr(modname, '\t')) != NULL)
+		if (!(export = strchr(modname, '\t')))
-			*export++ = '\0';
+			goto fail;
-		if (export && ((end = strchr(export, '\t')) != NULL))
+		*export++ = '\0';
-			*end = '\0';
+		if (!(namespace = strchr(export, '\t')))
+			goto fail;
+		*namespace++ = '\0';
 		crc = strtoul(line, &d, 16);
 		if (*symname == '\0' || *modname == '\0' || *d != '\0')
 			goto fail;
 				namespace = symbol->namespace;
 				buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n",
 					   symbol->crc, symbol->name,
-					   namespace ? namespace : "",
 					   symbol->module->name,
-					   export_str(symbol->export));
+					   export_str(symbol->export),
+					   namespace ? namespace : "");
 			}
 			symbol = symbol->next;
 		}

sound/core/oss/pcm_plugin.c+10−2

 		while (plugin->next) {
 			if (plugin->dst_frames)
 				frames = plugin->dst_frames(plugin, frames);
-			if (snd_BUG_ON((snd_pcm_sframes_t)frames <= 0))
+			if ((snd_pcm_sframes_t)frames <= 0)
 				return -ENXIO;
 			plugin = plugin->next;
 			err = snd_pcm_plugin_alloc(plugin, frames);
 		while (plugin->prev) {
 			if (plugin->src_frames)
 				frames = plugin->src_frames(plugin, frames);
-			if (snd_BUG_ON((snd_pcm_sframes_t)frames <= 0))
+			if ((snd_pcm_sframes_t)frames <= 0)
 				return -ENXIO;
 			plugin = plugin->prev;
 			err = snd_pcm_plugin_alloc(plugin, frames);
 	if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 		plugin = snd_pcm_plug_last(plug);
 		while (plugin && drv_frames > 0) {
+			if (drv_frames > plugin->buf_frames)
+				drv_frames = plugin->buf_frames;
 			plugin_prev = plugin->prev;
 			if (plugin->src_frames)
 				drv_frames = plugin->src_frames(plugin, drv_frames);
 			plugin_next = plugin->next;
 			if (plugin->dst_frames)
 				drv_frames = plugin->dst_frames(plugin, drv_frames);
+			if (drv_frames > plugin->buf_frames)
+				drv_frames = plugin->buf_frames;
 			plugin = plugin_next;
 		}
 	} else
 				if (frames < 0)
 					return frames;
 			}
+			if (frames > plugin->buf_frames)
+				frames = plugin->buf_frames;
 			plugin = plugin_next;
 		}
 	} else if (stream == SNDRV_PCM_STREAM_CAPTURE) {
 		plugin = snd_pcm_plug_last(plug);
 		while (plugin) {
+			if (frames > plugin->buf_frames)
+				frames = plugin->buf_frames;
 			plugin_prev = plugin->prev;
 			if (plugin->src_frames) {
 				frames = plugin->src_frames(plugin, frames);

sound/core/seq/oss/seq_oss_midi.c+1−0

@@ -602,6 +602,7 @@ send_midi_event(struct seq_oss_devinfo dp, struct snd_seq_event ev, struct seq · 601 unmodified lines
602	len = snd_seq_oss_timer_start(dp->timer);	602	len = snd_seq_oss_timer_start(dp->timer);
603	if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {	603	if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {
604	snd_seq_oss_readq_sysex(dp->readq, mdev->seq_device, ev);	604	snd_seq_oss_readq_sysex(dp->readq, mdev->seq_device, ev);
		605	snd_midi_event_reset_decode(mdev->coder);
605	} else {	606	} else {
606	len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);	607	len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);
607	if (len > 0)	608	if (len > 0)

sound/core/seq/seq_virmidi.c+1−0

@@ -81,6 +81,7 @@ static int snd_virmidi_dev_receive_event(struct snd_virmidi_dev *rdev, · 80 unmodified lines
81	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)	81	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
82	continue;	82	continue;
83	snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)snd_rawmidi_receive, vmidi->substream);	83	snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)snd_rawmidi_receive, vmidi->substream);
		84	snd_midi_event_reset_decode(vmidi->parser);
84	} else {	85	} else {
85	len = snd_midi_event_decode(vmidi->parser, msg, sizeof(msg), ev);	86	len = snd_midi_event_decode(vmidi->parser, msg, sizeof(msg), ev);
86	if (len > 0)	87	if (len > 0)

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

@@ -8051,6 +8051,8 @@ static int patch_alc269(struct hda_codec *codec) · 8050 unmodified lines
8051	spec->gen.mixer_nid = 0;	8051	spec->gen.mixer_nid = 0;
8052	break;	8052	break;
8053	case 0x10ec0225:	8053	case 0x10ec0225:
		8054	codec->power_save_node = 1;
		8055	/* fall through */
8054	case 0x10ec0295:	8056	case 0x10ec0295:
8055	case 0x10ec0299:	8057	case 0x10ec0299:
8056	spec->codec_variant = ALC269_TYPE_ALC225;	8058	spec->codec_variant = ALC269_TYPE_ALC225;
@@ -8610,6 +8612,8 @@ enum { · 553 unmodified lines
8610	ALC669_FIXUP_ACER_ASPIRE_ETHOS,	8612	ALC669_FIXUP_ACER_ASPIRE_ETHOS,
8611	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,	8613	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
8612	ALC671_FIXUP_HP_HEADSET_MIC2,	8614	ALC671_FIXUP_HP_HEADSET_MIC2,
		8615	ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
		8616	ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
8613	};	8617	};
8614		8618
8615	static const struct hda_fixup alc662_fixups[] = {	8619	static const struct hda_fixup alc662_fixups[] = {
@@ -8955,6 +8959,25 @@ static const struct hda_fixup alc662_fixups[] = { · 339 unmodified lines
8955	.type = HDA_FIXUP_FUNC,	8959	.type = HDA_FIXUP_FUNC,
8956	.v.func = alc671_fixup_hp_headset_mic2,	8960	.v.func = alc671_fixup_hp_headset_mic2,
8957	},	8961	},
		8962	[ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
		8963	.type = HDA_FIXUP_PINS,
		8964	.v.pins = (const struct hda_pintbl[]) {
		8965	{ 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
		8966	{ }
		8967	},
		8968	.chained = true,
		8969	.chain_id = ALC662_FIXUP_USI_FUNC
		8970	},
		8971	[ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
		8972	.type = HDA_FIXUP_PINS,
		8973	.v.pins = (const struct hda_pintbl[]) {
		8974	{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
		8975	{ 0x1b, 0x0221144f },
		8976	{ }
		8977	},
		8978	.chained = true,
		8979	.chain_id = ALC662_FIXUP_USI_FUNC
		8980	},
8958	};	8981	};
8959		8982
8960	static const struct snd_pci_quirk alc662_fixup_tbl[] = {	8983	static const struct snd_pci_quirk alc662_fixup_tbl[] = {
@@ -8966,6 +8989,8 @@ static const struct snd_pci_quirk alc662_fixup_tbl[] = { · 5 unmodified lines
8966	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),	8989	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
8967	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),	8990	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
8968	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),	8991	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
		8992	SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
		8993	SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
8969	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),	8994	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8970	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),	8995	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8971	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),	8996	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),

sound/usb/line6/driver.c+1−1

@@ -305,7 +305,7 @@ static void line6_data_received(struct urb *urb) · 304 unmodified lines
305	line6_midibuf_read(mb, line6->buffer_message,	305	line6_midibuf_read(mb, line6->buffer_message,
306	LINE6_MIDI_MESSAGE_MAXLEN);	306	LINE6_MIDI_MESSAGE_MAXLEN);
307		307
308	if (done == 0)	308	if (done <= 0)
309	break;	309	break;
310		310
311	line6->message_length = done;	311	line6->message_length = done;

sound/usb/line6/midibuf.c+1−1

@@ -159,7 +159,7 @@ int line6_midibuf_read(struct midi_buffer this, unsigned char data, · 158 unmodified lines
159	int midi_length_prev =	159	int midi_length_prev =
160	midibuf_message_length(this->command_prev);	160	midibuf_message_length(this->command_prev);
161		161
162	if (midi_length_prev > 0) {	162	if (midi_length_prev > 1) {
163	midi_length = midi_length_prev - 1;	163	midi_length = midi_length_prev - 1;
164	repeat = 1;	164	repeat = 1;
165	} else	165	} else

tools/include/uapi/asm/errno.h+7−7

@@ -1,18 +1,18 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	#if defined(__i386__) \|\| defined(__x86_64__)	2	#if defined(__i386__) \|\| defined(__x86_64__)
3	#include "../../arch/x86/include/uapi/asm/errno.h"	3	#include "../../../arch/x86/include/uapi/asm/errno.h"
4	#elif defined(__powerpc__)	4	#elif defined(__powerpc__)
5	#include "../../arch/powerpc/include/uapi/asm/errno.h"	5	#include "../../../arch/powerpc/include/uapi/asm/errno.h"
6	#elif defined(__sparc__)	6	#elif defined(__sparc__)
7	#include "../../arch/sparc/include/uapi/asm/errno.h"	7	#include "../../../arch/sparc/include/uapi/asm/errno.h"
8	#elif defined(__alpha__)	8	#elif defined(__alpha__)
9	#include "../../arch/alpha/include/uapi/asm/errno.h"	9	#include "../../../arch/alpha/include/uapi/asm/errno.h"
10	#elif defined(__mips__)	10	#elif defined(__mips__)
11	#include "../../arch/mips/include/uapi/asm/errno.h"	11	#include "../../../arch/mips/include/uapi/asm/errno.h"
12	#elif defined(__ia64__)	12	#elif defined(__ia64__)
13	#include "../../arch/ia64/include/uapi/asm/errno.h"	13	#include "../../../arch/ia64/include/uapi/asm/errno.h"
14	#elif defined(__xtensa__)	14	#elif defined(__xtensa__)
15	#include "../../arch/xtensa/include/uapi/asm/errno.h"	15	#include "../../../arch/xtensa/include/uapi/asm/errno.h"
16	#else	16	#else
17	#include <asm-generic/errno.h>	17	#include <asm-generic/errno.h>
18	#endif	18	#endif

tools/perf/arch/arm64/util/arm-spe.c+10−10

@@ -11,17 +11,17 @@ · 10 unmodified lines
11	#include <linux/zalloc.h>	11	#include <linux/zalloc.h>
12	#include <time.h>	12	#include <time.h>
13		13
14	#include "../../util/cpumap.h"	14	#include "../../../util/cpumap.h"
15	#include "../../util/event.h"	15	#include "../../../util/event.h"
16	#include "../../util/evsel.h"	16	#include "../../../util/evsel.h"
17	#include "../../util/evlist.h"	17	#include "../../../util/evlist.h"
18	#include "../../util/session.h"	18	#include "../../../util/session.h"
19	#include <internal/lib.h> // page_size	19	#include <internal/lib.h> // page_size
20	#include "../../util/pmu.h"	20	#include "../../../util/pmu.h"
21	#include "../../util/debug.h"	21	#include "../../../util/debug.h"
22	#include "../../util/auxtrace.h"	22	#include "../../../util/auxtrace.h"
23	#include "../../util/record.h"	23	#include "../../../util/record.h"
24	#include "../../util/arm-spe.h"	24	#include "../../../util/arm-spe.h"
25		25
26	#define KiB(x) ((x) * 1024)	26	#define KiB(x) ((x) * 1024)
27	#define MiB(x) ((x) * 1024 * 1024)	27	#define MiB(x) ((x) * 1024 * 1024)

tools/perf/arch/arm64/util/perf_regs.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	#include "../../util/perf_regs.h"	2	#include "../../../util/perf_regs.h"
3		3
4	const struct sample_reg sample_reg_masks[] = {	4	const struct sample_reg sample_reg_masks[] = {
5	SMPL_REG_END	5	SMPL_REG_END

tools/perf/arch/powerpc/util/perf_regs.c+2−2

@@ -4,8 +4,8 @@ · 3 unmodified lines
4	#include <regex.h>	4	#include <regex.h>
5	#include <linux/zalloc.h>	5	#include <linux/zalloc.h>
6		6
7	#include "../../util/perf_regs.h"	7	#include "../../../util/perf_regs.h"
8	#include "../../util/debug.h"	8	#include "../../../util/debug.h"
9		9
10	#include <linux/kernel.h>	10	#include <linux/kernel.h>
11		11

tools/perf/arch/x86/util/auxtrace.c+7−7

@@ -7,13 +7,13 @@ · 6 unmodified lines
7	#include <errno.h>	7	#include <errno.h>
8	#include <stdbool.h>	8	#include <stdbool.h>
9		9
10	#include "../../util/header.h"	10	#include "../../../util/header.h"
11	#include "../../util/debug.h"	11	#include "../../../util/debug.h"
12	#include "../../util/pmu.h"	12	#include "../../../util/pmu.h"
13	#include "../../util/auxtrace.h"	13	#include "../../../util/auxtrace.h"
14	#include "../../util/intel-pt.h"	14	#include "../../../util/intel-pt.h"
15	#include "../../util/intel-bts.h"	15	#include "../../../util/intel-bts.h"
16	#include "../../util/evlist.h"	16	#include "../../../util/evlist.h"
17		17
18	static	18	static
19	struct auxtrace_record auxtrace_record__init_intel(struct evlist evlist,	19	struct auxtrace_record auxtrace_record__init_intel(struct evlist evlist,

tools/perf/arch/x86/util/event.c+6−6

@@ -3,12 +3,12 @@ · 2 unmodified lines
3	#include <linux/string.h>	3	#include <linux/string.h>
4	#include <linux/zalloc.h>	4	#include <linux/zalloc.h>
5		5
6	#include "../../util/event.h"	6	#include "../../../util/event.h"
7	#include "../../util/synthetic-events.h"	7	#include "../../../util/synthetic-events.h"
8	#include "../../util/machine.h"	8	#include "../../../util/machine.h"
9	#include "../../util/tool.h"	9	#include "../../../util/tool.h"
10	#include "../../util/map.h"	10	#include "../../../util/map.h"
11	#include "../../util/debug.h"	11	#include "../../../util/debug.h"
12		12
13	#if defined(__x86_64__)	13	#if defined(__x86_64__)
14		14

tools/perf/arch/x86/util/header.c+2−2

@@ -7,8 +7,8 @@ · 6 unmodified lines
7	#include <string.h>	7	#include <string.h>
8	#include <regex.h>	8	#include <regex.h>
9		9
10	#include "../../util/debug.h"	10	#include "../../../util/debug.h"
11	#include "../../util/header.h"	11	#include "../../../util/header.h"
12		12
13	static inline void	13	static inline void
14	cpuid(unsigned int op, unsigned int a, unsigned int b, unsigned int *c,	14	cpuid(unsigned int op, unsigned int a, unsigned int b, unsigned int *c,

tools/perf/arch/x86/util/intel-bts.c+12−12

@@ -11,18 +11,18 @@ · 10 unmodified lines
11	#include <linux/log2.h>	11	#include <linux/log2.h>
12	#include <linux/zalloc.h>	12	#include <linux/zalloc.h>
13		13
14	#include "../../util/cpumap.h"	14	#include "../../../util/cpumap.h"
15	#include "../../util/event.h"	15	#include "../../../util/event.h"
16	#include "../../util/evsel.h"	16	#include "../../../util/evsel.h"
17	#include "../../util/evlist.h"	17	#include "../../../util/evlist.h"
18	#include "../../util/mmap.h"	18	#include "../../../util/mmap.h"
19	#include "../../util/session.h"	19	#include "../../../util/session.h"
20	#include "../../util/pmu.h"	20	#include "../../../util/pmu.h"
21	#include "../../util/debug.h"	21	#include "../../../util/debug.h"
22	#include "../../util/record.h"	22	#include "../../../util/record.h"
23	#include "../../util/tsc.h"	23	#include "../../../util/tsc.h"
24	#include "../../util/auxtrace.h"	24	#include "../../../util/auxtrace.h"
25	#include "../../util/intel-bts.h"	25	#include "../../../util/intel-bts.h"
26	#include <internal/lib.h> // page_size	26	#include <internal/lib.h> // page_size
27		27
28	#define KiB(x) ((x) * 1024)	28	#define KiB(x) ((x) * 1024)

tools/perf/arch/x86/util/intel-pt.c+15−15

@@ -13,23 +13,23 @@ · 12 unmodified lines
13	#include <linux/zalloc.h>	13	#include <linux/zalloc.h>
14	#include <cpuid.h>	14	#include <cpuid.h>
15		15
16	#include "../../util/session.h"	16	#include "../../../util/session.h"
17	#include "../../util/event.h"	17	#include "../../../util/event.h"
18	#include "../../util/evlist.h"	18	#include "../../../util/evlist.h"
19	#include "../../util/evsel.h"	19	#include "../../../util/evsel.h"
20	#include "../../util/evsel_config.h"	20	#include "../../../util/evsel_config.h"
21	#include "../../util/cpumap.h"	21	#include "../../../util/cpumap.h"
22	#include "../../util/mmap.h"	22	#include "../../../util/mmap.h"
23	#include <subcmd/parse-options.h>	23	#include <subcmd/parse-options.h>
24	#include "../../util/parse-events.h"	24	#include "../../../util/parse-events.h"
25	#include "../../util/pmu.h"	25	#include "../../../util/pmu.h"
26	#include "../../util/debug.h"	26	#include "../../../util/debug.h"
27	#include "../../util/auxtrace.h"	27	#include "../../../util/auxtrace.h"
28	#include "../../util/record.h"	28	#include "../../../util/record.h"
29	#include "../../util/target.h"	29	#include "../../../util/target.h"
30	#include "../../util/tsc.h"	30	#include "../../../util/tsc.h"
31	#include <internal/lib.h> // page_size	31	#include <internal/lib.h> // page_size
32	#include "../../util/intel-pt.h"	32	#include "../../../util/intel-pt.h"
33		33
34	#define KiB(x) ((x) * 1024)	34	#define KiB(x) ((x) * 1024)
35	#define MiB(x) ((x) * 1024 * 1024)	35	#define MiB(x) ((x) * 1024 * 1024)

tools/perf/arch/x86/util/machine.c+3−3

@@ -5,9 +5,9 @@ · 4 unmodified lines
5	#include <stdlib.h>	5	#include <stdlib.h>
6		6
7	#include <internal/lib.h> // page_size	7	#include <internal/lib.h> // page_size
8	#include "../../util/machine.h"	8	#include "../../../util/machine.h"
9	#include "../../util/map.h"	9	#include "../../../util/map.h"
10	#include "../../util/symbol.h"	10	#include "../../../util/symbol.h"
11	#include <linux/ctype.h>	11	#include <linux/ctype.h>
12		12
13	#include <symbol/kallsyms.h>	13	#include <symbol/kallsyms.h>

tools/perf/arch/x86/util/perf_regs.c+4−4

@@ -5,10 +5,10 @@ · 4 unmodified lines
5	#include <linux/kernel.h>	5	#include <linux/kernel.h>
6	#include <linux/zalloc.h>	6	#include <linux/zalloc.h>
7		7
8	#include "../../perf-sys.h"	8	#include "../../../perf-sys.h"
9	#include "../../util/perf_regs.h"	9	#include "../../../util/perf_regs.h"
10	#include "../../util/debug.h"	10	#include "../../../util/debug.h"
11	#include "../../util/event.h"	11	#include "../../../util/event.h"
12		12
13	const struct sample_reg sample_reg_masks[] = {	13	const struct sample_reg sample_reg_masks[] = {
14	SMPL_REG(AX, PERF_REG_X86_AX),	14	SMPL_REG(AX, PERF_REG_X86_AX),

tools/perf/arch/x86/util/pmu.c+3−3

@@ -4,9 +4,9 @@ · 3 unmodified lines
4	#include <linux/stddef.h>	4	#include <linux/stddef.h>
5	#include <linux/perf_event.h>	5	#include <linux/perf_event.h>
6		6
7	#include "../../util/intel-pt.h"	7	#include "../../../util/intel-pt.h"
8	#include "../../util/intel-bts.h"	8	#include "../../../util/intel-bts.h"
9	#include "../../util/pmu.h"	9	#include "../../../util/pmu.h"
10		10
11	struct perf_event_attr perf_pmu__get_default_config(struct perf_pmu pmu __maybe_unused)	11	struct perf_event_attr perf_pmu__get_default_config(struct perf_pmu pmu __maybe_unused)
12	{	12	{

tools/perf/bench/bench.h+4−0

@@ -2,6 +2,10 @@ · 1 unmodified line
2	#ifndef BENCH_H	2	#ifndef BENCH_H
3	#define BENCH_H	3	#define BENCH_H
4		4
		5	#include <sys/time.h>
		6
		7	extern struct timeval bench__start, bench__end, bench__runtime;
		8
5	/*	9	/*
6	* The madvise transparent hugepage constants were added in glibc	10	* The madvise transparent hugepage constants were added in glibc
7	* 2.13. For compatibility with older versions of glibc, define these	11	* 2.13. For compatibility with older versions of glibc, define these

tools/perf/bench/epoll-ctl.c+4−4

 static unsigned int nthreads = 0;
 static unsigned int nsecs    = 8;
-struct timeval start, end, runtime;
 static bool done, __verbose, randomize;
 /*
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void nest_epollfd(void)
 		exit(EXIT_FAILURE);
 	}
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	do_threads(worker, cpu);

tools/perf/bench/epoll-wait.c+6−6

 static unsigned int nthreads = 0;
 static unsigned int nsecs    = 8;
-struct timeval start, end, runtime;
 static bool wdone, done, __verbose, randomize, nonblocking;
 /*
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void print_summary(void)
 	printf("\nAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 	       avg, rel_stddev_stats(stddev, avg),
-	       (int) runtime.tv_sec);
+	       (int)bench__runtime.tv_sec);
 }
 static int do_threads(struct worker *worker, struct perf_cpu_map *cpu)
 		exit(EXIT_FAILURE);
 	}
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	do_threads(worker, cpu);
 		qsort(worker, nthreads, sizeof(struct worker), cmpworker);
 	for (i = 0; i < nthreads; i++) {
-		unsigned long t = worker[i].ops/runtime.tv_sec;
+		unsigned long t = worker[i].ops / bench__runtime.tv_sec;
 		update_stats(&throughput_stats, t);

tools/perf/bench/futex-hash.c+7−6

 static bool fshared = false, done = false, silent = false;
 static int futex_flag = 0;
-struct timeval start, end, runtime;
+struct timeval bench__start, bench__end, bench__runtime;
 static pthread_mutex_t thread_lock;
 static unsigned int threads_starting;
 static struct stats throughput_stats;
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void print_summary(void)
 	printf("%sAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 	       !silent ? "\n" : "", avg, rel_stddev_stats(stddev, avg),
-	       (int) runtime.tv_sec);
+	       (int)bench__runtime.tv_sec);
 }
 int bench_futex_hash(int argc, const char **argv)
 	if (!cpu)
 		goto errmem;
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
 	pthread_attr_init(&thread_attr);
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	for (i = 0; i < nthreads; i++) {
 		worker[i].tid = i;
 		worker[i].futex = calloc(nfutexes, sizeof(*worker[i].futex));
 	pthread_mutex_destroy(&thread_lock);
 	for (i = 0; i < nthreads; i++) {
-		unsigned long t = worker[i].ops/runtime.tv_sec;
+		unsigned long t = worker[i].ops / bench__runtime.tv_sec;
 		update_stats(&throughput_stats, t);
 		if (!silent) {
 			if (nfutexes == 1)

tools/perf/bench/futex-lock-pi.c+6−6

 static bool done = false, fshared = false;
 static unsigned int nthreads = 0;
 static int futex_flag = 0;
-struct timeval start, end, runtime;
 static pthread_mutex_t thread_lock;
 static unsigned int threads_starting;
 static struct stats throughput_stats;
 	printf("%sAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 	       !silent ? "\n" : "", avg, rel_stddev_stats(stddev, avg),
-	       (int) runtime.tv_sec);
+	       (int)bench__runtime.tv_sec);
 }
 static void toggle_done(int sig __maybe_unused,
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void *workerfn(void *arg)
 	if (!cpu)
 		err(EXIT_FAILURE, "calloc");
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
 	pthread_attr_init(&thread_attr);
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	create_threads(worker, thread_attr, cpu);
 	pthread_attr_destroy(&thread_attr);
 	pthread_mutex_destroy(&thread_lock);
 	for (i = 0; i < nthreads; i++) {
-		unsigned long t = worker[i].ops/runtime.tv_sec;
+		unsigned long t = worker[i].ops / bench__runtime.tv_sec;
 		update_stats(&throughput_stats, t);
 		if (!silent)

tools/perf/bench/futex-requeue.c+1−0

@@ -128,6 +128,7 @@ int bench_futex_requeue(int argc, const char **argv) · 127 unmodified lines
128	if (!cpu)	128	if (!cpu)
129	err(EXIT_FAILURE, "cpu_map__new");	129	err(EXIT_FAILURE, "cpu_map__new");
130		130
		131	memset(&act, 0, sizeof(act));
131	sigfillset(&act.sa_mask);	132	sigfillset(&act.sa_mask);
132	act.sa_sigaction = toggle_done;	133	act.sa_sigaction = toggle_done;
133	sigaction(SIGINT, &act, NULL);	134	sigaction(SIGINT, &act, NULL);

tools/perf/bench/futex-wake-parallel.c+1−0

@@ -234,6 +234,7 @@ int bench_futex_wake_parallel(int argc, const char **argv) · 233 unmodified lines
234	exit(EXIT_FAILURE);	234	exit(EXIT_FAILURE);
235	}	235	}
236		236
		237	memset(&act, 0, sizeof(act));
237	sigfillset(&act.sa_mask);	238	sigfillset(&act.sa_mask);
238	act.sa_sigaction = toggle_done;	239	act.sa_sigaction = toggle_done;
239	sigaction(SIGINT, &act, NULL);	240	sigaction(SIGINT, &act, NULL);

tools/perf/bench/futex-wake.c+3−2

 static pthread_mutex_t thread_lock;
 static pthread_cond_t thread_parent, thread_worker;
 static struct stats waketime_stats, wakeup_stats;
-static unsigned int ncpus, threads_starting, nthreads = 0;
+static unsigned int threads_starting, nthreads = 0;
 static int futex_flag = 0;
 static const struct option options[] = {
 	if (!cpu)
 		err(EXIT_FAILURE, "calloc");
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	if (!nthreads)
-		nthreads = ncpus;
+		nthreads = cpu->nr;
 	worker = calloc(nthreads, sizeof(*worker));
 	if (!worker)

tools/perf/builtin-diff.c+2−1

@@ -1312,7 +1312,8 @@ static int cycles_printf(struct hist_entry he, struct hist_entry pair, · 1311 unmodified lines
1312	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,	1312	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,
1313	he->ms.sym);	1313	he->ms.sym);
1314		1314
1315	if ((start_line != SRCLINE_UNKNOWN) && (end_line != SRCLINE_UNKNOWN)) {	1315	if ((strncmp(start_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0) &&
		1316	(strncmp(end_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)) {
1316	scnprintf(buf, sizeof(buf), "[%s -> %s] %4ld",	1317	scnprintf(buf, sizeof(buf), "[%s -> %s] %4ld",
1317	start_line, end_line, block_he->diff.cycles);	1318	start_line, end_line, block_he->diff.cycles);
1318	} else {	1319	} else {

tools/perf/builtin-top.c+3−1

 	delay_msecs = top->delay_secs * MSEC_PER_SEC;
 	set_term_quiet_input(&save);
 	/* trash return*/
-	getc(stdin);
+	clearerr(stdin);
+	if (poll(&stdin_poll, 1, 0) > 0)
+		getc(stdin);
 	while (!done) {
 		perf_top__print_sym_table(top);

tools/perf/pmu-events/jevents.c+9−6

@@ -1082,10 +1082,9 @@ static int process_one_file(const char fpath, const struct stat sb, · 1081 unmodified lines
1082	*/	1082	*/
1083	int main(int argc, char *argv[])	1083	int main(int argc, char *argv[])
1084	{	1084	{
1085	int rc;	1085	int rc, ret = 0;
1086	int maxfds;	1086	int maxfds;
1087	char ldirname[PATH_MAX];	1087	char ldirname[PATH_MAX];
1088
1089	const char *arch;	1088	const char *arch;
1090	const char *output_file;	1089	const char *output_file;
1091	const char *start_dirname;	1090	const char *start_dirname;
@@ -1156,7 +1155,8 @@ int main(int argc, char *argv[]) · 64 unmodified lines
1156	/* Make build fail */	1155	/* Make build fail */
1157	fclose(eventsfp);	1156	fclose(eventsfp);
1158	free_arch_std_events();	1157	free_arch_std_events();
1159	return 1;	1158	ret = 1;
		1159	goto out_free_mapfile;
1160	} else if (rc) {	1160	} else if (rc) {
1161	goto empty_map;	1161	goto empty_map;
1162	}	1162	}
@@ -1174,14 +1174,17 @@ int main(int argc, char *argv[]) · 11 unmodified lines
1174	/* Make build fail */	1174	/* Make build fail */
1175	fclose(eventsfp);	1175	fclose(eventsfp);
1176	free_arch_std_events();	1176	free_arch_std_events();
1177	return 1;	1177	ret = 1;
1178	}	1178	}
1179		1179
1180	return 0;	1180
		1181	goto out_free_mapfile;
1181		1182
1182	empty_map:	1183	empty_map:
1183	fclose(eventsfp);	1184	fclose(eventsfp);
1184	create_empty_mapping(output_file);	1185	create_empty_mapping(output_file);
1185	free_arch_std_events();	1186	free_arch_std_events();
1186	return 0;	1187	out_free_mapfile:
		1188	free(mapfile);
		1189	return ret;
1187	}	1190	}

tools/perf/tests/bp_account.c+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	#include "../perf-sys.h"	19	#include "../perf-sys.h"
20	#include "cloexec.h"	20	#include "cloexec.h"
21		21
22	volatile long the_var;	22	static volatile long the_var;
23		23
24	static noinline int test_function(void)	24	static noinline int test_function(void)
25	{	25	{

tools/perf/util/block-info.c+2−1

@@ -295,7 +295,8 @@ static int block_range_entry(struct perf_hpp_fmt fmt, struct perf_hpp hpp, · 294 unmodified lines
295	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,	295	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,
296	he->ms.sym);	296	he->ms.sym);
297		297
298	if ((start_line != SRCLINE_UNKNOWN) && (end_line != SRCLINE_UNKNOWN)) {	298	if ((strncmp(start_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0) &&
		299	(strncmp(end_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)) {
299	scnprintf(buf, sizeof(buf), "[%s -> %s]",	300	scnprintf(buf, sizeof(buf), "[%s -> %s]",
300	start_line, end_line);	301	start_line, end_line);
301	} else {	302	} else {

tools/perf/util/env.c+2−2

 const char *perf_env__arch(struct perf_env *env)
 {
-	struct utsname uts;
 	char *arch_name;
 	if (!env || !env->arch) { /* Assume local operation */
-		if (uname(&uts) < 0)
+		static struct utsname uts = { .machine[0] = '\0', };
+		if (uts.machine[0] == '\0' && uname(&uts) < 0)
 			return NULL;
 		arch_name = uts.machine;
 	} else

tools/perf/util/map.c+1−1

@@ -431,7 +431,7 @@ int map__fprintf_srcline(struct map map, u64 addr, const char prefix, · 430 unmodified lines
431		431
432	if (map && map->dso) {	432	if (map && map->dso) {
433	char *srcline = map__srcline(map, addr, NULL);	433	char *srcline = map__srcline(map, addr, NULL);
434	if (srcline != SRCLINE_UNKNOWN)	434	if (strncmp(srcline, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)
435	ret = fprintf(fp, "%s%s", prefix, srcline);	435	ret = fprintf(fp, "%s%s", prefix, srcline);
436	free_srcline(srcline);	436	free_srcline(srcline);
437	}	437	}

tools/perf/util/parse-events.c+2−8

 				path = zalloc(sizeof(*path));
 				if (!path)
 					return NULL;
-				path->system = malloc(MAX_EVENT_LENGTH);
+				if (asprintf(&path->system, "%.*s", MAX_EVENT_LENGTH, sys_dirent->d_name) < 0) {
-				if (!path->system) {
 					free(path);
 					return NULL;
 				}
-				path->name = malloc(MAX_EVENT_LENGTH);
+				if (asprintf(&path->name, "%.*s", MAX_EVENT_LENGTH, evt_dirent->d_name) < 0) {
-				if (!path->name) {
 					zfree(&path->system);
 					free(path);
 					return NULL;
 				}
-				strncpy(path->system, sys_dirent->d_name,
-					MAX_EVENT_LENGTH);
-				strncpy(path->name, evt_dirent->d_name,
-					MAX_EVENT_LENGTH);
 				return path;
 			}
 		}

tools/perf/util/symbol.c+6−7

 		goto out;
 	}
-	if (dso->kernel) {
+	kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
+		dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
+		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
+		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
+	if (dso->kernel && !kmod) {
 		if (dso->kernel == DSO_TYPE_KERNEL)
 			ret = dso__load_kernel_sym(dso, map);
 		else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 	if (!name)
 		goto out;
-	kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
-		dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
-		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
-		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
 	/*
 	 * Read the build id if possible. This is required for
 	 * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work

tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c+1−1

@@ -82,7 +82,7 @@ static struct pci_access *pci_acc; · 81 unmodified lines
82	static struct pci_dev *amd_fam14h_pci_dev;	82	static struct pci_dev *amd_fam14h_pci_dev;
83	static int nbp1_entered;	83	static int nbp1_entered;
84		84
85	struct timespec start_time;	85	static struct timespec start_time;
86	static unsigned long long timediff;	86	static unsigned long long timediff;
87		87
88	#ifdef DEBUG	88	#ifdef DEBUG

tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c+1−1

@@ -19,7 +19,7 @@ struct cpuidle_monitor cpuidle_sysfs_monitor; · 18 unmodified lines
19		19
20	static unsigned long long **previous_count;	20	static unsigned long long **previous_count;
21	static unsigned long long **current_count;	21	static unsigned long long **current_count;
22	struct timespec start_time;	22	static struct timespec start_time;
23	static unsigned long long timediff;	23	static unsigned long long timediff;
24		24
25	static int cpuidle_get_count_percent(unsigned int id, double *percent,	25	static int cpuidle_get_count_percent(unsigned int id, double *percent,

tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c+2−0

@@ -27,6 +27,8 @@ struct cpuidle_monitor *all_monitors[] = { · 26 unmodified lines
27	0	27	0
28	};	28	};
29		29
		30	int cpu_count;
		31
30	static struct cpuidle_monitor *monitors[MONITORS_MAX];	32	static struct cpuidle_monitor *monitors[MONITORS_MAX];
31	static unsigned int avail_monitors;	33	static unsigned int avail_monitors;
32		34

tools/power/cpupower/utils/idle_monitor/cpupower-monitor.h+1−1

@@ -25,7 +25,7 @@ · 24 unmodified lines
25	#endif	25	#endif
26	#define CSTATE_DESC_LEN 60	26	#define CSTATE_DESC_LEN 60
27		27
28	int cpu_count;	28	extern int cpu_count;
29		29
30	/* Hard to define the right names ...: */	30	/* Hard to define the right names ...: */
31	enum power_range_e {	31	enum power_range_e {

tools/power/x86/turbostat/Makefile+1−1

@@ -16,7 +16,7 @@ override CFLAGS += -D_FORTIFY_SOURCE=2 · 15 unmodified lines
16		16
17	%: %.c	17	%: %.c
18	@mkdir -p $(BUILD_OUTPUT)	18	@mkdir -p $(BUILD_OUTPUT)
19	$(CC) $(CFLAGS) $< -o $(BUILD_OUTPUT)/$@ $(LDFLAGS)	19	$(CC) $(CFLAGS) $< -o $(BUILD_OUTPUT)/$@ $(LDFLAGS) -lcap
20		20
21	.PHONY : clean	21	.PHONY : clean
22	clean :	22	clean :

tools/power/x86/turbostat/turbostat.c+113−29

 #include <sched.h>
 #include <time.h>
 #include <cpuid.h>
-#include <linux/capability.h>
+#include <sys/capability.h>
 #include <errno.h>
 #include <math.h>
 void setup_all_buffers(void);
+char *sys_lpi_file;
+char *sys_lpi_file_sysfs = "/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us";
+char *sys_lpi_file_debugfs = "/sys/kernel/debug/pmc_core/slp_s0_residency_usec";
 int cpu_is_not_present(int cpu)
 {
 	return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
  *
  * record snapshot of
  * /sys/devices/system/cpu/cpuidle/low_power_idle_cpu_residency_us
- *
- * return 1 if config change requires a restart, else return 0
  */
 int snapshot_cpu_lpi_us(void)
 {
 /*
  * snapshot_sys_lpi()
  *
- * record snapshot of
+ * record snapshot of sys_lpi_file
- * /sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us
- *
- * return 1 if config change requires a restart, else return 0
  */
 int snapshot_sys_lpi_us(void)
 {
 	FILE *fp;
 	int retval;
-	fp = fopen_or_die("/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us", "r");
+	fp = fopen_or_die(sys_lpi_file, "r");
 	retval = fscanf(fp, "%lld", &cpuidle_cur_sys_lpi_us);
 	if (retval != 1) {
 			err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
 }
-void check_permissions()
+/*
+ * check for CAP_SYS_RAWIO
+ * return 0 on success
+ * return 1 on fail
+ */
+int check_for_cap_sys_rawio(void)
 {
-	struct __user_cap_header_struct cap_header_data;
+	cap_t caps;
-	cap_user_header_t cap_header = &cap_header_data;
+	cap_flag_value_t cap_flag_value;
-	struct __user_cap_data_struct cap_data_data;
-	cap_user_data_t cap_data = &cap_data_data;
-	extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
-	int do_exit = 0;
-	char pathname[32];
-	/* check for CAP_SYS_RAWIO */
+	caps = cap_get_proc();
-	cap_header->pid = getpid();
+	if (caps == NULL)
-	cap_header->version = _LINUX_CAPABILITY_VERSION;
+		err(-6, "cap_get_proc\n");
-	if (capget(cap_header, cap_data) < 0)
-		err(-6, "capget(2) failed");
-	if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
+	if (cap_get_flag(caps, CAP_SYS_RAWIO, CAP_EFFECTIVE, &cap_flag_value))
-		do_exit++;
+		err(-6, "cap_get\n");
+	if (cap_flag_value != CAP_SET) {
 		warnx("capget(CAP_SYS_RAWIO) failed,"
 			" try \"# setcap cap_sys_rawio=ep %s\"", progname);
+		return 1;
 	}
+	if (cap_free(caps) == -1)
+		err(-6, "cap_free\n");
+	return 0;
+}
+void check_permissions(void)
+{
+	int do_exit = 0;
+	char pathname[32];
+	/* check for CAP_SYS_RAWIO */
+	do_exit += check_for_cap_sys_rawio();
 	/* test file permissions */
 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
 	if (euidaccess(pathname, R_OK)) {
 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
 	case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
 	case INTEL_FAM6_ATOM_GOLDMONT_D:	/* DNV */
+	case INTEL_FAM6_ATOM_TREMONT:	/* EHL */
 		pkg_cstate_limits = glm_pkg_cstate_limits;
 		break;
 	default:
 	}
 	return 0;
 }
+int is_ehl(unsigned int family, unsigned int model)
+{
+	if (!genuine_intel)
+		return 0;
+	switch (model) {
+	case INTEL_FAM6_ATOM_TREMONT:
+		return 1;
+	}
+	return 0;
+}
 int has_turbo_ratio_limit(unsigned int family, unsigned int model)
 {
 	dump_nhm_cst_cfg();
 }
+static void dump_sysfs_file(char *path)
+{
+	FILE *input;
+	char cpuidle_buf[64];
+	input = fopen(path, "r");
+	if (input == NULL) {
+		if (debug)
+			fprintf(outf, "NSFOD %s\n", path);
+		return;
+	}
+	if (!fgets(cpuidle_buf, sizeof(cpuidle_buf), input))
+		err(1, "%s: failed to read file", path);
+	fclose(input);
+	fprintf(outf, "%s: %s", strrchr(path, '/') + 1, cpuidle_buf);
+}
 static void
 dump_sysfs_cstate_config(void)
 {
 	if (!DO_BIC(BIC_sysfs))
 		return;
+	if (access("/sys/devices/system/cpu/cpuidle", R_OK)) {
+		fprintf(outf, "cpuidle not loaded\n");
+		return;
+	}
+	dump_sysfs_file("/sys/devices/system/cpu/cpuidle/current_driver");
+	dump_sysfs_file("/sys/devices/system/cpu/cpuidle/current_governor");
+	dump_sysfs_file("/sys/devices/system/cpu/cpuidle/current_governor_ro");
 	for (state = 0; state < 10; ++state) {
 		sprintf(path, "/sys/devices/system/cpu/cpu%d/cpuidle/state%d/name",
 		else
 			BIC_PRESENT(BIC_PkgWatt);
 		break;
+	case INTEL_FAM6_ATOM_TREMONT:	/* EHL */
+		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_GFX | RAPL_PKG_POWER_INFO;
+		if (rapl_joules) {
+			BIC_PRESENT(BIC_Pkg_J);
+			BIC_PRESENT(BIC_Cor_J);
+			BIC_PRESENT(BIC_RAM_J);
+			BIC_PRESENT(BIC_GFX_J);
+		} else {
+			BIC_PRESENT(BIC_PkgWatt);
+			BIC_PRESENT(BIC_CorWatt);
+			BIC_PRESENT(BIC_RAMWatt);
+			BIC_PRESENT(BIC_GFXWatt);
+		}
+		break;
 	case INTEL_FAM6_SKYLAKE_L:	/* SKL */
 	case INTEL_FAM6_CANNONLAKE_L:	/* CNL */
 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_GFX | RAPL_PKG_POWER_INFO;
 	case INTEL_FAM6_ATOM_GOLDMONT:		/* BXT */
 	case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
 	case INTEL_FAM6_ATOM_GOLDMONT_D:	/* DNV */
+	case INTEL_FAM6_ATOM_TREMONT:		/* EHL */
 		return 1;
 	}
 	return 0;
 	case INTEL_FAM6_CANNONLAKE_L:	/* CNL */
 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
 	case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
+	case INTEL_FAM6_ATOM_TREMONT:	/* EHL */
 		return 1;
 	}
 	return 0;
 	case INTEL_FAM6_SKYLAKE:
 	case INTEL_FAM6_KABYLAKE_L:
 	case INTEL_FAM6_KABYLAKE:
+	case INTEL_FAM6_COMETLAKE_L:
+	case INTEL_FAM6_COMETLAKE:
 		return INTEL_FAM6_SKYLAKE_L;
 	case INTEL_FAM6_ICELAKE_L:
 	case INTEL_FAM6_ICELAKE_NNPI:
+	case INTEL_FAM6_TIGERLAKE_L:
+	case INTEL_FAM6_TIGERLAKE:
 		return INTEL_FAM6_CANNONLAKE_L;
 	case INTEL_FAM6_ATOM_TREMONT_D:
 		return INTEL_FAM6_ATOM_GOLDMONT_D;
+	case INTEL_FAM6_ATOM_TREMONT_L:
+		return INTEL_FAM6_ATOM_TREMONT;
+	case INTEL_FAM6_ICELAKE_X:
+		return INTEL_FAM6_SKYLAKE_X;
 	}
 	return model;
 }
 	do_slm_cstates = is_slm(family, model);
 	do_knl_cstates  = is_knl(family, model);
-	if (do_slm_cstates || do_knl_cstates || is_cnl(family, model))
+	if (do_slm_cstates || do_knl_cstates || is_cnl(family, model) ||
+	    is_ehl(family, model))
 		BIC_NOT_PRESENT(BIC_CPU_c3);
 	if (!quiet)
 	else
 		BIC_NOT_PRESENT(BIC_CPU_LPI);
-	if (!access("/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us", R_OK))
+	if (!access(sys_lpi_file_sysfs, R_OK)) {
+		sys_lpi_file = sys_lpi_file_sysfs;
 		BIC_PRESENT(BIC_SYS_LPI);
-	else
+	} else if (!access(sys_lpi_file_debugfs, R_OK)) {
+		sys_lpi_file = sys_lpi_file_debugfs;
+		BIC_PRESENT(BIC_SYS_LPI);
+	} else {
+		sys_lpi_file_sysfs = NULL;
 		BIC_NOT_PRESENT(BIC_SYS_LPI);
+	}
 	if (!quiet)
 		decode_misc_feature_control();
 }
 void print_version() {
-	fprintf(outf, "turbostat version 19.08.31"
+	fprintf(outf, "turbostat version 20.03.20"
 		" - Len Brown <lenb@kernel.org>\n");
 }
 	}
 	msrp->msr_num = msr_num;
-	strncpy(msrp->name, name, NAME_BYTES);
+	strncpy(msrp->name, name, NAME_BYTES - 1);
 	if (path)
-		strncpy(msrp->path, path, PATH_BYTES);
+		strncpy(msrp->path, path, PATH_BYTES - 1);
 	msrp->width = width;
 	msrp->type = type;
 	msrp->format = format;

tools/testing/ktest/ktest.pl+8−8

@@ -30,7 +30,7 @@ my %default = ( · 29 unmodified lines
30	"EMAIL_WHEN_STARTED" => 0,	30	"EMAIL_WHEN_STARTED" => 0,
31	"NUM_TESTS" => 1,	31	"NUM_TESTS" => 1,
32	"TEST_TYPE" => "build",	32	"TEST_TYPE" => "build",
33	"BUILD_TYPE" => "randconfig",	33	"BUILD_TYPE" => "oldconfig",
34	"MAKE_CMD" => "make",	34	"MAKE_CMD" => "make",
35	"CLOSE_CONSOLE_SIGNAL" => "INT",	35	"CLOSE_CONSOLE_SIGNAL" => "INT",
36	"TIMEOUT" => 120,	36	"TIMEOUT" => 120,
@@ -1030,7 +1030,7 @@ sub __read_config { · 993 unmodified lines
1030	}	1030	}
1031		1031
1032	if (!$skip && $rest !~ /^\s*$/) {	1032	if (!$skip && $rest !~ /^\s*$/) {
1033	die "$name: $.: Gargbage found after $type\n$_";	1033	die "$name: $.: Garbage found after $type\n$_";
1034	}	1034	}
1035		1035
1036	if ($skip && $type eq "TEST_START") {	1036	if ($skip && $type eq "TEST_START") {
@@ -1063,7 +1063,7 @@ sub __read_config { · 26 unmodified lines
1063	}	1063	}
1064		1064
1065	if ($rest !~ /^\s*$/) {	1065	if ($rest !~ /^\s*$/) {
1066	die "$name: $.: Gargbage found after DEFAULTS\n$_";	1066	die "$name: $.: Garbage found after DEFAULTS\n$_";
1067	}	1067	}
1068		1068
1069	} elsif (/^\s*INCLUDE\s+(\S+)/) {	1069	} elsif (/^\s*INCLUDE\s+(\S+)/) {
@@ -1154,7 +1154,7 @@ sub __read_config { · 84 unmodified lines
1154	# on of these sections that have SKIP defined.	1154	# on of these sections that have SKIP defined.
1155	# The save variable can be	1155	# The save variable can be
1156	# defined multiple times and the new one simply overrides	1156	# defined multiple times and the new one simply overrides
1157	# the prevous one.	1157	# the previous one.
1158	set_variable($lvalue, $rvalue);	1158	set_variable($lvalue, $rvalue);
1159		1159
1160	} else {	1160	} else {
@@ -1234,7 +1234,7 @@ sub read_config { · 73 unmodified lines
1234	foreach my $option (keys %not_used) {	1234	foreach my $option (keys %not_used) {
1235	print "$option\n";	1235	print "$option\n";
1236	}	1236	}
1237	print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";	1237	print "Set IGNORE_UNUSED = 1 to have ktest ignore unused variables\n";
1238	if (!read_yn "Do you want to continue?") {	1238	if (!read_yn "Do you want to continue?") {
1239	exit -1;	1239	exit -1;
1240	}	1240	}
@@ -1345,7 +1345,7 @@ sub eval_option { · 104 unmodified lines
1345	# Check for recursive evaluations.	1345	# Check for recursive evaluations.
1346	# 100 deep should be more than enough.	1346	# 100 deep should be more than enough.
1347	if ($r++ > 100) {	1347	if ($r++ > 100) {
1348	die "Over 100 evaluations accurred with $option\n" .	1348	die "Over 100 evaluations occurred with $option\n" .
1349	"Check for recursive variables\n";	1349	"Check for recursive variables\n";
1350	}	1350	}
1351	$prev = $option;	1351	$prev = $option;
@@ -1383,7 +1383,7 @@ sub reboot { · 31 unmodified lines
1383		1383
1384	} else {	1384	} else {
1385	# Make sure everything has been written to disk	1385	# Make sure everything has been written to disk
1386	run_ssh("sync");	1386	run_ssh("sync", 10);
1387		1387
1388	if (defined($time)) {	1388	if (defined($time)) {
1389	start_monitor;	1389	start_monitor;
@@ -1461,7 +1461,7 @@ sub get_test_name() { · 71 unmodified lines
1461		1461
1462	sub dodie {	1462	sub dodie {
1463		1463
1464	# avoid recusion	1464	# avoid recursion
1465	return if ($in_die);	1465	return if ($in_die);
1466	$in_die = 1;	1466	$in_die = 1;
1467		1467

tools/testing/ktest/sample.conf+11−11

tools/testing/selftests/net/fib_tests.sh+31−3

@@ -1041,6 +1041,27 @@ ipv6_addr_metric_test() · 1040 unmodified lines
1041	fi	1041	fi
1042	log_test $rc 0 "Prefix route with metric on link up"	1042	log_test $rc 0 "Prefix route with metric on link up"
1043		1043
		1044	# verify peer metric added correctly
		1045	set -e
		1046	run_cmd "$IP -6 addr flush dev dummy2"
		1047	run_cmd "$IP -6 addr add dev dummy2 2001:db8:104::1 peer 2001:db8:104::2 metric 260"
		1048	set +e
		1049
		1050	check_route6 "2001:db8:104::1 dev dummy2 proto kernel metric 260"
		1051	log_test $? 0 "Set metric with peer route on local side"
		1052	log_test $? 0 "User specified metric on local address"
		1053	check_route6 "2001:db8:104::2 dev dummy2 proto kernel metric 260"
		1054	log_test $? 0 "Set metric with peer route on peer side"
		1055
		1056	set -e
		1057	run_cmd "$IP -6 addr change dev dummy2 2001:db8:104::1 peer 2001:db8:104::3 metric 261"
		1058	set +e
		1059
		1060	check_route6 "2001:db8:104::1 dev dummy2 proto kernel metric 261"
		1061	log_test $? 0 "Modify metric and peer address on local side"
		1062	check_route6 "2001:db8:104::3 dev dummy2 proto kernel metric 261"
		1063	log_test $? 0 "Modify metric and peer address on peer side"
		1064
1044	$IP li del dummy1	1065	$IP li del dummy1
1045	$IP li del dummy2	1066	$IP li del dummy2
1046	cleanup	1067	cleanup
@@ -1457,13 +1478,20 @@ ipv4_addr_metric_test() · 410 unmodified lines
1457		1478
1458	run_cmd "$IP addr flush dev dummy2"	1479	run_cmd "$IP addr flush dev dummy2"
1459	run_cmd "$IP addr add dev dummy2 172.16.104.1/32 peer 172.16.104.2 metric 260"	1480	run_cmd "$IP addr add dev dummy2 172.16.104.1/32 peer 172.16.104.2 metric 260"
1460	run_cmd "$IP addr change dev dummy2 172.16.104.1/32 peer 172.16.104.2 metric 261"
1461	rc=$?	1481	rc=$?
1462	if [ $rc -eq 0 ]; then	1482	if [ $rc -eq 0 ]; then
1463	check_route "172.16.104.2 dev dummy2 proto kernel scope link src 172.16.104.1 metric 261"	1483	check_route "172.16.104.2 dev dummy2 proto kernel scope link src 172.16.104.1 metric 260"
		1484	rc=$?
		1485	fi
		1486	log_test $rc 0 "Set metric of address with peer route"
		1487
		1488	run_cmd "$IP addr change dev dummy2 172.16.104.1/32 peer 172.16.104.3 metric 261"
		1489	rc=$?
		1490	if [ $rc -eq 0 ]; then
		1491	check_route "172.16.104.3 dev dummy2 proto kernel scope link src 172.16.104.1 metric 261"
1464	rc=$?	1492	rc=$?
1465	fi	1493	fi
1466	log_test $rc 0 "Modify metric of address with peer route"	1494	log_test $rc 0 "Modify metric and peer address for peer route"
1467		1495
1468	$IP li del dummy1	1496	$IP li del dummy1
1469	$IP li del dummy2	1497	$IP li del dummy2

tools/testing/selftests/tc-testing/config+1−0

@@ -57,3 +57,4 @@ CONFIG_NET_IFE_SKBMARK=m · 56 unmodified lines
57	CONFIG_NET_IFE_SKBPRIO=m	57	CONFIG_NET_IFE_SKBPRIO=m
58	CONFIG_NET_IFE_SKBTCINDEX=m	58	CONFIG_NET_IFE_SKBTCINDEX=m
59	CONFIG_NET_SCH_FIFO=y	59	CONFIG_NET_SCH_FIFO=y
		60	CONFIG_NET_SCH_ETS=m

usr/Kconfig+11−11

 	  If in doubt, select 'None'
-config INITRAMFS_COMPRESSION_NONE
-	bool "None"
-	help
-	  Do not compress the built-in initramfs at all. This may sound wasteful
-	  in space, but, you should be aware that the built-in initramfs will be
-	  compressed at a later stage anyways along with the rest of the kernel,
-	  on those architectures that support this. However, not compressing the
-	  initramfs may lead to slightly higher memory consumption during a
-	  short time at boot, while both the cpio image and the unpacked
-	  filesystem image will be present in memory simultaneously
 config INITRAMFS_COMPRESSION_GZIP
 	bool "Gzip"
 	depends on RD_GZIP
 	  If you choose this, keep in mind that most distros don't provide lz4
 	  by default which could cause a build failure.
+config INITRAMFS_COMPRESSION_NONE
+	bool "None"
+	help
+	  Do not compress the built-in initramfs at all. This may sound wasteful
+	  in space, but, you should be aware that the built-in initramfs will be
+	  compressed at a later stage anyways along with the rest of the kernel,
+	  on those architectures that support this. However, not compressing the
+	  initramfs may lead to slightly higher memory consumption during a
+	  short time at boot, while both the cpio image and the unpacked
+	  filesystem image will be present in memory simultaneously
 endchoice

@@ -1104,7 +1104,6 @@ static int msm_gpio_init(struct msm_pinctrl *pctrl) · 1103 unmodified lines
1104	pctrl->irq_chip.irq_mask = msm_gpio_irq_mask;	1104	pctrl->irq_chip.irq_mask = msm_gpio_irq_mask;
1105	pctrl->irq_chip.irq_unmask = msm_gpio_irq_unmask;	1105	pctrl->irq_chip.irq_unmask = msm_gpio_irq_unmask;
1106	pctrl->irq_chip.irq_ack = msm_gpio_irq_ack;	1106	pctrl->irq_chip.irq_ack = msm_gpio_irq_ack;
1107	pctrl->irq_chip.irq_eoi = irq_chip_eoi_parent;
1108	pctrl->irq_chip.irq_set_type = msm_gpio_irq_set_type;	1107	pctrl->irq_chip.irq_set_type = msm_gpio_irq_set_type;
1109	pctrl->irq_chip.irq_set_wake = msm_gpio_irq_set_wake;	1108	pctrl->irq_chip.irq_set_wake = msm_gpio_irq_set_wake;
1110	pctrl->irq_chip.irq_request_resources = msm_gpio_irq_reqres;	1109	pctrl->irq_chip.irq_request_resources = msm_gpio_irq_reqres;
@@ -1118,7 +1117,7 @@ static int msm_gpio_init(struct msm_pinctrl *pctrl) · 7 unmodified lines
1118	if (!chip->irq.parent_domain)	1117	if (!chip->irq.parent_domain)
1119	return -EPROBE_DEFER;	1118	return -EPROBE_DEFER;
1120	chip->irq.child_to_parent_hwirq = msm_gpio_wakeirq;	1119	chip->irq.child_to_parent_hwirq = msm_gpio_wakeirq;
1121		1120	pctrl->irq_chip.irq_eoi = irq_chip_eoi_parent;
1122	/*	1121	/*
1123	* Let's skip handling the GPIOs, if the parent irqchip	1122	* Let's skip handling the GPIOs, if the parent irqchip
1124	* is handling the direct connect IRQ of the GPIO.	1123	* is handling the direct connect IRQ of the GPIO.

@@ -10,7 +10,7 @@ · 9 unmodified lines
10	#	10	#
11		11
12	# Options set in the beginning of the file are considered to be	12	# Options set in the beginning of the file are considered to be
13	# default options. These options can be overriden by test specific	13	# default options. These options can be overridden by test specific
14	# options, with the following exceptions:	14	# options, with the following exceptions:
15	#	15	#
16	# LOG_FILE	16	# LOG_FILE
@@ -204,7 +204,7 @@ · 187 unmodified lines
204	#	204	#
205	# This config file can also contain "config variables".	205	# This config file can also contain "config variables".
206	# These are assigned with ":=" instead of the ktest option	206	# These are assigned with ":=" instead of the ktest option
207	# assigment "=".	207	# assignment "=".
208	#	208	#
209	# The difference between ktest options and config variables	209	# The difference between ktest options and config variables
210	# is that config variables can be used multiple times,	210	# is that config variables can be used multiple times,
@@ -263,7 +263,7 @@ · 52 unmodified lines
263	#### Using options in other options ####	263	#### Using options in other options ####
264	#	264	#
265	# Options that are defined in the config file may also be used	265	# Options that are defined in the config file may also be used
266	# by other options. All options are evaulated at time of	266	# by other options. All options are evaluated at time of
267	# use (except that config variables are evaluated at config	267	# use (except that config variables are evaluated at config
268	# processing time).	268	# processing time).
269	#	269	#
@@ -505,7 +505,7 @@ · 235 unmodified lines
505	#TEST = ssh user@machine /root/run_test	505	#TEST = ssh user@machine /root/run_test
506		506
507	# The build type is any make config type or special command	507	# The build type is any make config type or special command
508	# (default randconfig)	508	# (default oldconfig)
509	# nobuild - skip the clean and build step	509	# nobuild - skip the clean and build step
510	# useconfig:/path/to/config - use the given config and run	510	# useconfig:/path/to/config - use the given config and run
511	# oldconfig on it.	511	# oldconfig on it.
@@ -707,7 +707,7 @@ · 195 unmodified lines
707		707
708	# Line to define a successful boot up in console output.	708	# Line to define a successful boot up in console output.
709	# This is what the line contains, not the entire line. If you need	709	# This is what the line contains, not the entire line. If you need
710	# the entire line to match, then use regural expression syntax like:	710	# the entire line to match, then use regular expression syntax like:
711	# (do not add any quotes around it)	711	# (do not add any quotes around it)
712	#	712	#
713	# SUCCESS_LINE = ^MyBox Login:$	713	# SUCCESS_LINE = ^MyBox Login:$
@@ -839,7 +839,7 @@ · 125 unmodified lines
839	# (ignored if POWEROFF_ON_SUCCESS is set)	839	# (ignored if POWEROFF_ON_SUCCESS is set)
840	#REBOOT_ON_SUCCESS = 1	840	#REBOOT_ON_SUCCESS = 1
841		841
842	# In case there are isses with rebooting, you can specify this	842	# In case there are issues with rebooting, you can specify this
843	# to always powercycle after this amount of time after calling	843	# to always powercycle after this amount of time after calling
844	# reboot.	844	# reboot.
845	# Note, POWERCYCLE_AFTER_REBOOT = 0 does NOT disable it. It just	845	# Note, POWERCYCLE_AFTER_REBOOT = 0 does NOT disable it. It just
@@ -848,7 +848,7 @@ · 2 unmodified lines
848	# (default undefined)	848	# (default undefined)
849	#POWERCYCLE_AFTER_REBOOT = 5	849	#POWERCYCLE_AFTER_REBOOT = 5
850		850
851	# In case there's isses with halting, you can specify this	851	# In case there's issues with halting, you can specify this
852	# to always poweroff after this amount of time after calling	852	# to always poweroff after this amount of time after calling
853	# halt.	853	# halt.
854	# Note, POWEROFF_AFTER_HALT = 0 does NOT disable it. It just	854	# Note, POWEROFF_AFTER_HALT = 0 does NOT disable it. It just
@@ -972,7 +972,7 @@ · 117 unmodified lines
972	#	972	#
973	# PATCHCHECK_START is required and is the first patch to	973	# PATCHCHECK_START is required and is the first patch to
974	# test (the SHA1 of the commit). You may also specify anything	974	# test (the SHA1 of the commit). You may also specify anything
975	# that git checkout allows (branch name, tage, HEAD~3).	975	# that git checkout allows (branch name, tag, HEAD~3).
976	#	976	#
977	# PATCHCHECK_END is the last patch to check (default HEAD)	977	# PATCHCHECK_END is the last patch to check (default HEAD)
978	#	978	#
@@ -994,7 +994,7 @@ · 15 unmodified lines
994	# IGNORE_WARNINGS is set for the given commit's sha1	994	# IGNORE_WARNINGS is set for the given commit's sha1
995	#	995	#
996	# IGNORE_WARNINGS can be used to disable the failure of patchcheck	996	# IGNORE_WARNINGS can be used to disable the failure of patchcheck
997	# on a particuler commit (SHA1). You can add more than one commit	997	# on a particular commit (SHA1). You can add more than one commit
998	# by adding a list of SHA1s that are space delimited.	998	# by adding a list of SHA1s that are space delimited.
999	#	999	#
1000	# If BUILD_NOCLEAN is set, then make mrproper will not be run on	1000	# If BUILD_NOCLEAN is set, then make mrproper will not be run on
@@ -1093,7 +1093,7 @@ · 92 unmodified lines
1093	# whatever reason. (Can't reboot, want to inspect each iteration)	1093	# whatever reason. (Can't reboot, want to inspect each iteration)
1094	# Doing a BISECT_MANUAL will have the test wait for you to	1094	# Doing a BISECT_MANUAL will have the test wait for you to
1095	# tell it if the test passed or failed after each iteration.	1095	# tell it if the test passed or failed after each iteration.
1096	# This is basicall the same as running git bisect yourself	1096	# This is basically the same as running git bisect yourself
1097	# but ktest will rebuild and install the kernel for you.	1097	# but ktest will rebuild and install the kernel for you.
1098	#	1098	#
1099	# BISECT_CHECK = 1 (optional, default 0)	1099	# BISECT_CHECK = 1 (optional, default 0)
@@ -1239,7 +1239,7 @@ · 139 unmodified lines
1239	#	1239	#
1240	# CONFIG_BISECT_EXEC (optional)	1240	# CONFIG_BISECT_EXEC (optional)
1241	# The config bisect is a separate program that comes with ktest.pl.	1241	# The config bisect is a separate program that comes with ktest.pl.
1242	# By befault, it will look for:	1242	# By default, it will look for:
1243	# `pwd`/config-bisect.pl # the location ktest.pl was executed from.	1243	# `pwd`/config-bisect.pl # the location ktest.pl was executed from.
1244	# If it does not find it there, it will look for:	1244	# If it does not find it there, it will look for:
1245	# `dirname <ktest.pl>`/config-bisect.pl # The directory that holds ktest.pl	1245	# `dirname <ktest.pl>`/config-bisect.pl # The directory that holds ktest.pl