lael-labs/linux

.mailmap+1−0

@@ -69,6 +69,7 @@ Jean Tourrilhes <jt@hpl.hp.com> · 68 unmodified lines
69	Jeff Garzik <jgarzik@pretzel.yyz.us>	69	Jeff Garzik <jgarzik@pretzel.yyz.us>
70	Jens Axboe <axboe@suse.de>	70	Jens Axboe <axboe@suse.de>
71	Jens Osterkamp <Jens.Osterkamp@de.ibm.com>	71	Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
		72	John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
72	John Stultz <johnstul@us.ibm.com>	73	John Stultz <johnstul@us.ibm.com>
73	<josh@joshtriplett.org> <josh@freedesktop.org>	74	<josh@joshtriplett.org> <josh@freedesktop.org>
74	<josh@joshtriplett.org> <josh@kernel.org>	75	<josh@joshtriplett.org> <josh@kernel.org>

Documentation/devicetree/bindings/ata/ahci-platform.txt+4−0

 - target-supply     : regulator for SATA target power
 - phys              : reference to the SATA PHY node
 - phy-names         : must be "sata-phy"
+- ports-implemented : Mask that indicates which ports that the HBA supports
+		      are available for software to use. Useful if PORTS_IMPL
+		      is not programmed by the BIOS, which is true with
+		      some embedded SOC's.
 Required properties when using sub-nodes:
 - #address-cells    : number of cells to encode an address

Documentation/networking/checksum-offloads.txt+7−7

MAINTAINERS+27−27

@@ -872,9 +872,9 @@ F: drivers/perf/arm_pmu.c · 871 unmodified lines
872	F: include/linux/perf/arm_pmu.h	872	F: include/linux/perf/arm_pmu.h
873		873
874	ARM PORT	874	ARM PORT
875	M: Russell King <linux@arm.linux.org.uk>	875	M: Russell King <linux@armlinux.org.uk>
876	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	876	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
877	W: http://www.arm.linux.org.uk/	877	W: http://www.armlinux.org.uk/
878	S: Maintained	878	S: Maintained
879	F: arch/arm/	879	F: arch/arm/
880		880
@@ -886,35 +886,35 @@ F: arch/arm/plat-*/ · 5 unmodified lines
886	T: git git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc.git	886	T: git git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc.git
887		887
888	ARM PRIMECELL AACI PL041 DRIVER	888	ARM PRIMECELL AACI PL041 DRIVER
889	M: Russell King <linux@arm.linux.org.uk>	889	M: Russell King <linux@armlinux.org.uk>
890	S: Maintained	890	S: Maintained
891	F: sound/arm/aaci.*	891	F: sound/arm/aaci.*
892		892
893	ARM PRIMECELL CLCD PL110 DRIVER	893	ARM PRIMECELL CLCD PL110 DRIVER
894	M: Russell King <linux@arm.linux.org.uk>	894	M: Russell King <linux@armlinux.org.uk>
895	S: Maintained	895	S: Maintained
896	F: drivers/video/fbdev/amba-clcd.*	896	F: drivers/video/fbdev/amba-clcd.*
897		897
898	ARM PRIMECELL KMI PL050 DRIVER	898	ARM PRIMECELL KMI PL050 DRIVER
899	M: Russell King <linux@arm.linux.org.uk>	899	M: Russell King <linux@armlinux.org.uk>
900	S: Maintained	900	S: Maintained
901	F: drivers/input/serio/ambakmi.*	901	F: drivers/input/serio/ambakmi.*
902	F: include/linux/amba/kmi.h	902	F: include/linux/amba/kmi.h
903		903
904	ARM PRIMECELL MMCI PL180/1 DRIVER	904	ARM PRIMECELL MMCI PL180/1 DRIVER
905	M: Russell King <linux@arm.linux.org.uk>	905	M: Russell King <linux@armlinux.org.uk>
906	S: Maintained	906	S: Maintained
907	F: drivers/mmc/host/mmci.*	907	F: drivers/mmc/host/mmci.*
908	F: include/linux/amba/mmci.h	908	F: include/linux/amba/mmci.h
909		909
910	ARM PRIMECELL UART PL010 AND PL011 DRIVERS	910	ARM PRIMECELL UART PL010 AND PL011 DRIVERS
911	M: Russell King <linux@arm.linux.org.uk>	911	M: Russell King <linux@armlinux.org.uk>
912	S: Maintained	912	S: Maintained
913	F: drivers/tty/serial/amba-pl01*.c	913	F: drivers/tty/serial/amba-pl01*.c
914	F: include/linux/amba/serial.h	914	F: include/linux/amba/serial.h
915		915
916	ARM PRIMECELL BUS SUPPORT	916	ARM PRIMECELL BUS SUPPORT
917	M: Russell King <linux@arm.linux.org.uk>	917	M: Russell King <linux@armlinux.org.uk>
918	S: Maintained	918	S: Maintained
919	F: drivers/amba/	919	F: drivers/amba/
920	F: include/linux/amba/bus.h	920	F: include/linux/amba/bus.h
@@ -1036,7 +1036,7 @@ L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) · 115 unmodified lines
1036	S: Maintained	1036	S: Maintained
1037		1037
1038	ARM/CLKDEV SUPPORT	1038	ARM/CLKDEV SUPPORT
1039	M: Russell King <linux@arm.linux.org.uk>	1039	M: Russell King <linux@armlinux.org.uk>
1040	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	1040	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1041	S: Maintained	1041	S: Maintained
1042	F: arch/arm/include/asm/clkdev.h	1042	F: arch/arm/include/asm/clkdev.h
@@ -1093,9 +1093,9 @@ F: arch/arm/boot/dts/cx92755* · 50 unmodified lines
1093	N: digicolor	1093	N: digicolor
1094		1094
1095	ARM/EBSA110 MACHINE SUPPORT	1095	ARM/EBSA110 MACHINE SUPPORT
1096	M: Russell King <linux@arm.linux.org.uk>	1096	M: Russell King <linux@armlinux.org.uk>
1097	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	1097	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1098	W: http://www.arm.linux.org.uk/	1098	W: http://www.armlinux.org.uk/
1099	S: Maintained	1099	S: Maintained
1100	F: arch/arm/mach-ebsa110/	1100	F: arch/arm/mach-ebsa110/
1101	F: drivers/net/ethernet/amd/am79c961a.*	1101	F: drivers/net/ethernet/amd/am79c961a.*
@@ -1124,9 +1124,9 @@ T: git git://git.berlios.de/gemini-board · 22 unmodified lines
1124	F: arch/arm/mm/-fa	1124	F: arch/arm/mm/-fa
1125		1125
1126	ARM/FOOTBRIDGE ARCHITECTURE	1126	ARM/FOOTBRIDGE ARCHITECTURE
1127	M: Russell King <linux@arm.linux.org.uk>	1127	M: Russell King <linux@armlinux.org.uk>
1128	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	1128	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1129	W: http://www.arm.linux.org.uk/	1129	W: http://www.armlinux.org.uk/
1130	S: Maintained	1130	S: Maintained
1131	F: arch/arm/include/asm/hardware/dec21285.h	1131	F: arch/arm/include/asm/hardware/dec21285.h
1132	F: arch/arm/mach-footbridge/	1132	F: arch/arm/mach-footbridge/
@@ -1457,7 +1457,7 @@ S: Maintained · 324 unmodified lines
1457	ARM/PT DIGITAL BOARD PORT	1457	ARM/PT DIGITAL BOARD PORT
1458	M: Stefan Eletzhofer <stefan.eletzhofer@eletztrick.de>	1458	M: Stefan Eletzhofer <stefan.eletzhofer@eletztrick.de>
1459	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	1459	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1460	W: http://www.arm.linux.org.uk/	1460	W: http://www.armlinux.org.uk/
1461	S: Maintained	1461	S: Maintained
1462		1462
1463	ARM/QUALCOMM SUPPORT	1463	ARM/QUALCOMM SUPPORT
@@ -1493,9 +1493,9 @@ S: Supported · 29 unmodified lines
1493	F: arch/arm64/boot/dts/renesas/	1493	F: arch/arm64/boot/dts/renesas/
1494		1494
1495	ARM/RISCPC ARCHITECTURE	1495	ARM/RISCPC ARCHITECTURE
1496	M: Russell King <linux@arm.linux.org.uk>	1496	M: Russell King <linux@armlinux.org.uk>
1497	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	1497	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1498	W: http://www.arm.linux.org.uk/	1498	W: http://www.armlinux.org.uk/
1499	S: Maintained	1499	S: Maintained
1500	F: arch/arm/include/asm/hardware/entry-macro-iomd.S	1500	F: arch/arm/include/asm/hardware/entry-macro-iomd.S
1501	F: arch/arm/include/asm/hardware/ioc.h	1501	F: arch/arm/include/asm/hardware/ioc.h
@@ -1773,9 +1773,9 @@ F: drivers/clk/versatile/clk-vexpress-osc.c · 271 unmodified lines
1773	F: drivers/clocksource/versatile.c	1773	F: drivers/clocksource/versatile.c
1774		1774
1775	ARM/VFP SUPPORT	1775	ARM/VFP SUPPORT
1776	M: Russell King <linux@arm.linux.org.uk>	1776	M: Russell King <linux@armlinux.org.uk>
1777	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	1777	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1778	W: http://www.arm.linux.org.uk/	1778	W: http://www.armlinux.org.uk/
1779	S: Maintained	1779	S: Maintained
1780	F: arch/arm/vfp/	1780	F: arch/arm/vfp/
1781		1781
@@ -2924,7 +2924,7 @@ F: mm/cleancache.c · 1142 unmodified lines
2924	F: include/linux/cleancache.h	2924	F: include/linux/cleancache.h
2925		2925
2926	CLK API	2926	CLK API
2927	M: Russell King <linux@arm.linux.org.uk>	2927	M: Russell King <linux@armlinux.org.uk>
2928	L: linux-clk@vger.kernel.org	2928	L: linux-clk@vger.kernel.org
2929	S: Maintained	2929	S: Maintained
2930	F: include/linux/clk.h	2930	F: include/linux/clk.h
@@ -3358,9 +3358,9 @@ S: Supported · 427 unmodified lines
3358	F: drivers/net/ethernet/stmicro/stmmac/	3358	F: drivers/net/ethernet/stmicro/stmmac/
3359		3359
3360	CYBERPRO FB DRIVER	3360	CYBERPRO FB DRIVER
3361	M: Russell King <linux@arm.linux.org.uk>	3361	M: Russell King <linux@armlinux.org.uk>
3362	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	3362	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
3363	W: http://www.arm.linux.org.uk/	3363	W: http://www.armlinux.org.uk/
3364	S: Maintained	3364	S: Maintained
3365	F: drivers/video/fbdev/cyber2000fb.*	3365	F: drivers/video/fbdev/cyber2000fb.*
3366		3366
@@ -3885,7 +3885,7 @@ F: Documentation/devicetree/bindings/display/st,stih4xx.txt · 518 unmodified lines
3885		3885
3886	DRM DRIVERS FOR VIVANTE GPU IP	3886	DRM DRIVERS FOR VIVANTE GPU IP
3887	M: Lucas Stach <l.stach@pengutronix.de>	3887	M: Lucas Stach <l.stach@pengutronix.de>
3888	R: Russell King <linux+etnaviv@arm.linux.org.uk>	3888	R: Russell King <linux+etnaviv@armlinux.org.uk>
3889	R: Christian Gmeiner <christian.gmeiner@gmail.com>	3889	R: Christian Gmeiner <christian.gmeiner@gmail.com>
3890	L: dri-devel@lists.freedesktop.org	3890	L: dri-devel@lists.freedesktop.org
3891	S: Maintained	3891	S: Maintained
@@ -4227,8 +4227,8 @@ F: Documentation/efi-stub.txt · 335 unmodified lines
4227	F: arch/ia64/kernel/efi.c	4227	F: arch/ia64/kernel/efi.c
4228	F: arch/x86/boot/compressed/eboot.[ch]	4228	F: arch/x86/boot/compressed/eboot.[ch]
4229	F: arch/x86/include/asm/efi.h	4229	F: arch/x86/include/asm/efi.h
4230	F: arch/x86/platform/efi/*	4230	F: arch/x86/platform/efi/
4231	F: drivers/firmware/efi/*	4231	F: drivers/firmware/efi/
4232	F: include/linux/efi*.h	4232	F: include/linux/efi*.h
4233		4233
4234	EFI VARIABLE FILESYSTEM	4234	EFI VARIABLE FILESYSTEM
@@ -6902,7 +6902,7 @@ L: linux-man@vger.kernel.org · 2667 unmodified lines
6902	S: Maintained	6902	S: Maintained
6903		6903
6904	MARVELL ARMADA DRM SUPPORT	6904	MARVELL ARMADA DRM SUPPORT
6905	M: Russell King <rmk+kernel@arm.linux.org.uk>	6905	M: Russell King <rmk+kernel@armlinux.org.uk>
6906	S: Maintained	6906	S: Maintained
6907	F: drivers/gpu/drm/armada/	6907	F: drivers/gpu/drm/armada/
6908		6908
@@ -7902,7 +7902,7 @@ S: Supported · 993 unmodified lines
7902	F: drivers/nfc/nxp-nci	7902	F: drivers/nfc/nxp-nci
7903		7903
7904	NXP TDA998X DRM DRIVER	7904	NXP TDA998X DRM DRIVER
7905	M: Russell King <rmk+kernel@arm.linux.org.uk>	7905	M: Russell King <rmk+kernel@armlinux.org.uk>
7906	S: Supported	7906	S: Supported
7907	F: drivers/gpu/drm/i2c/tda998x_drv.c	7907	F: drivers/gpu/drm/i2c/tda998x_drv.c
7908	F: include/drm/i2c/tda998x.h	7908	F: include/drm/i2c/tda998x.h
@@ -7975,7 +7975,7 @@ F: arch/arm/omap/pm · 66 unmodified lines
7975	F: drivers/cpufreq/omap-cpufreq.c	7975	F: drivers/cpufreq/omap-cpufreq.c
7976		7976
7977	OMAP POWERDOMAIN SOC ADAPTATION LAYER SUPPORT	7977	OMAP POWERDOMAIN SOC ADAPTATION LAYER SUPPORT
7978	M: Rajendra Nayak <rnayak@ti.com>	7978	M: Rajendra Nayak <rnayak@codeaurora.org>
7979	M: Paul Walmsley <paul@pwsan.com>	7979	M: Paul Walmsley <paul@pwsan.com>
7980	L: linux-omap@vger.kernel.org	7980	L: linux-omap@vger.kernel.org
7981	S: Maintained	7981	S: Maintained

Makefile+1−1

@@ -1,7 +1,7 @@
1	VERSION = 4	1	VERSION = 4
2	PATCHLEVEL = 6	2	PATCHLEVEL = 6
3	SUBLEVEL = 0	3	SUBLEVEL = 0
4	EXTRAVERSION = -rc6	4	EXTRAVERSION = -rc7
5	NAME = Charred Weasel	5	NAME = Charred Weasel
6		6
7	# DOCUMENTATION	7	# DOCUMENTATION

arch/arc/Kconfig+13−0

 config RWSEM_GENERIC_SPINLOCK
 	def_bool y
+config ARCH_DISCONTIGMEM_ENABLE
+	def_bool y
 config ARCH_FLATMEM_ENABLE
 	def_bool y
 endchoice
+config NODES_SHIFT
+	int "Maximum NUMA Nodes (as a power of 2)"
+	default "1" if !DISCONTIGMEM
+	default "2" if DISCONTIGMEM
+	depends on NEED_MULTIPLE_NODES
+	---help---
+	  Accessing memory beyond 1GB (with or w/o PAE) requires 2 memory
+	  zones.
 if ISA_ARCOMPACT
 config ARC_COMPACT_IRQ_LEVELS
 config HIGHMEM
 	bool "High Memory Support"
+	select DISCONTIGMEM
 	help
 	  With ARC 2G:2G address split, only upper 2G is directly addressable by
 	  kernel. Enable this to potentially allow access to rest of 2G and PAE

arch/arc/include/asm/io.h+18−9

 #include <asm/byteorder.h>
 #include <asm/page.h>
+#ifdef CONFIG_ISA_ARCV2
+#include <asm/barrier.h>
+#define __iormb()		rmb()
+#define __iowmb()		wmb()
+#else
+#define __iormb()		do { } while (0)
+#define __iowmb()		do { } while (0)
+#endif
 extern void __iomem *ioremap(phys_addr_t paddr, unsigned long size);
 extern void __iomem *ioremap_prot(phys_addr_t paddr, unsigned long size,
 				  unsigned long flags);
 #define ioremap_wc(phy, sz)		ioremap(phy, sz)
 #define ioremap_wt(phy, sz)		ioremap(phy, sz)
+/*
+ * io{read,write}{16,32}be() macros
+ */
+#define ioread16be(p)		({ u16 __v = be16_to_cpu((__force __be16)__raw_readw(p)); __iormb(); __v; })
+#define ioread32be(p)		({ u32 __v = be32_to_cpu((__force __be32)__raw_readl(p)); __iormb(); __v; })
+#define iowrite16be(v,p)	({ __iowmb(); __raw_writew((__force u16)cpu_to_be16(v), p); })
+#define iowrite32be(v,p)	({ __iowmb(); __raw_writel((__force u32)cpu_to_be32(v), p); })
 /* Change struct page to physical address */
 #define page_to_phys(page)		(page_to_pfn(page) << PAGE_SHIFT)
 }
-#ifdef CONFIG_ISA_ARCV2
-#include <asm/barrier.h>
-#define __iormb()		rmb()
-#define __iowmb()		wmb()
-#else
-#define __iormb()		do { } while (0)
-#define __iowmb()		do { } while (0)
-#endif
 /*
  * MMIO can also get buffered/optimized in micro-arch, so barriers needed
  * Based on ARM model for the typical use case

arch/arc/include/asm/mmzone.h+43−0

@@ -0,0 +1,43 @@
	1	/*
	2	* Copyright (C) 2016 Synopsys, Inc. (www.synopsys.com)
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*/
	8
	9	#ifndef _ASM_ARC_MMZONE_H
	10	#define _ASM_ARC_MMZONE_H
	11
	12	#ifdef CONFIG_DISCONTIGMEM
	13
	14	extern struct pglist_data node_data[];
	15	#define NODE_DATA(nid) (&node_data[nid])
	16
	17	static inline int pfn_to_nid(unsigned long pfn)
	18	{
	19	int is_end_low = 1;
	20
	21	if (IS_ENABLED(CONFIG_ARC_HAS_PAE40))
	22	is_end_low = pfn <= virt_to_pfn(0xFFFFFFFFUL);
	23
	24	/*
	25	* node 0: lowmem: 0x8000_0000 to 0xFFFF_FFFF
	26	* node 1: HIGHMEM w/o PAE40: 0x0 to 0x7FFF_FFFF
	27	* HIGHMEM with PAE40: 0x1_0000_0000 to ...
	28	*/
	29	if (pfn >= ARCH_PFN_OFFSET && is_end_low)
	30	return 0;
	31
	32	return 1;
	33	}
	34
	35	static inline int pfn_valid(unsigned long pfn)
	36	{
	37	int nid = pfn_to_nid(pfn);
	38
	39	return (pfn <= node_end_pfn(nid));
	40	}
	41	#endif /* CONFIG_DISCONTIGMEM */
	42
	43	#endif

arch/arc/include/asm/page.h+11−4

 typedef pte_t * pgtable_t;
+/*
+ * Use virt_to_pfn with caution:
+ * If used in pte or paddr related macros, it could cause truncation
+ * in PAE40 builds
+ * As a rule of thumb, only use it in helpers starting with virt_
+ * You have been warned !
+ */
 #define virt_to_pfn(kaddr)	(__pa(kaddr) >> PAGE_SHIFT)
 #define ARCH_PFN_OFFSET		virt_to_pfn(CONFIG_LINUX_LINK_BASE)
+#ifdef CONFIG_FLATMEM
 #define pfn_valid(pfn)		(((pfn) - ARCH_PFN_OFFSET) < max_mapnr)
+#endif
 /*
  * __pa, __va, virt_to_page (ALERT: deprecated, don't use them)
  * virt here means link-address/program-address as embedded in object code.
  * And for ARC, link-addr = physical address
  */
-#define __pa(vaddr)  ((unsigned long)vaddr)
+#define __pa(vaddr)  ((unsigned long)(vaddr))
 #define __va(paddr)  ((void *)((unsigned long)(paddr)))
-#define virt_to_page(kaddr)	\
+#define virt_to_page(kaddr)	pfn_to_page(virt_to_pfn(kaddr))
-	(mem_map + virt_to_pfn((kaddr) - CONFIG_LINUX_LINK_BASE))
 #define virt_addr_valid(kaddr)  pfn_valid(virt_to_pfn(kaddr))
 /* Default Permissions for stack/heaps pages (Non Executable) */

arch/arc/include/asm/pgtable.h+6−7

@@ -278,14 +278,13 @@ static inline void pmd_set(pmd_t pmdp, pte_t ptep) · 277 unmodified lines
278	#define pmd_present(x) (pmd_val(x))	278	#define pmd_present(x) (pmd_val(x))
279	#define pmd_clear(xp) do { pmd_val(*(xp)) = 0; } while (0)	279	#define pmd_clear(xp) do { pmd_val(*(xp)) = 0; } while (0)
280		280
281	#define pte_page(pte) \	281	#define pte_page(pte) pfn_to_page(pte_pfn(pte))
282	(mem_map + virt_to_pfn(pte_val(pte) - CONFIG_LINUX_LINK_BASE))
283
284	#define mk_pte(page, prot) pfn_pte(page_to_pfn(page), prot)	282	#define mk_pte(page, prot) pfn_pte(page_to_pfn(page), prot)
285	#define pte_pfn(pte) virt_to_pfn(pte_val(pte))	283	#define pfn_pte(pfn, prot) (__pte(((pte_t)(pfn) << PAGE_SHIFT) \| pgprot_val(prot)))
286	#define pfn_pte(pfn, prot) (__pte(((pte_t)(pfn) << PAGE_SHIFT) \| \	284
287	pgprot_val(prot)))	285	/* Don't use virt_to_pfn for macros below: could cause truncations for PAE40*/
288	#define __pte_index(addr) (virt_to_pfn(addr) & (PTRS_PER_PTE - 1))	286	#define pte_pfn(pte) (pte_val(pte) >> PAGE_SHIFT)
		287	#define __pte_index(addr) (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
289		288
290	/*	289	/*
291	* pte_offset gets a @ptr to PMD entry (PGD in our 2-tier paging system)	290	* pte_offset gets a @ptr to PMD entry (PGD in our 2-tier paging system)

arch/arc/mm/init.c+39−15

 static unsigned long low_mem_sz;
 #ifdef CONFIG_HIGHMEM
-static unsigned long min_high_pfn;
+static unsigned long min_high_pfn, max_high_pfn;
 static u64 high_mem_start;
 static u64 high_mem_sz;
 #endif
+#ifdef CONFIG_DISCONTIGMEM
+struct pglist_data node_data[MAX_NUMNODES] __read_mostly;
+EXPORT_SYMBOL(node_data);
+#endif
 /* User can over-ride above with "mem=nnn[KkMm]" in cmdline */
 static int __init setup_mem_sz(char *str)
 {
 	/* Last usable page of low mem */
 	max_low_pfn = max_pfn = PFN_DOWN(low_mem_start + low_mem_sz);
-#ifdef CONFIG_HIGHMEM
+#ifdef CONFIG_FLATMEM
-	min_high_pfn = PFN_DOWN(high_mem_start);
+	/* pfn_valid() uses this */
-	max_pfn = PFN_DOWN(high_mem_start + high_mem_sz);
+	max_mapnr = max_low_pfn - min_low_pfn;
 #endif
-	max_mapnr = max_pfn - min_low_pfn;
 	/*------------- bootmem allocator setup -----------------------*/
 	/*
 	 * the crash
 	 */
-	memblock_add(low_mem_start, low_mem_sz);
+	memblock_add_node(low_mem_start, low_mem_sz, 0);
 	memblock_reserve(low_mem_start, __pa(_end) - low_mem_start);
 #ifdef CONFIG_BLK_DEV_INITRD
 	zones_size[ZONE_NORMAL] = max_low_pfn - min_low_pfn;
 	zones_holes[ZONE_NORMAL] = 0;
-#ifdef CONFIG_HIGHMEM
-	zones_size[ZONE_HIGHMEM] = max_pfn - max_low_pfn;
-	/* This handles the peripheral address space hole */
-	zones_holes[ZONE_HIGHMEM] = min_high_pfn - max_low_pfn;
-#endif
 	/*
 	 * We can't use the helper free_area_init(zones[]) because it uses
 	 * PAGE_OFFSET to compute the @min_low_pfn which would be wrong
 			    zones_holes);	/* holes */
 #ifdef CONFIG_HIGHMEM
+	/*
+	 * Populate a new node with highmem
+	 *
+	 * On ARC (w/o PAE) HIGHMEM addresses are actually smaller (0 based)
+	 * than addresses in normal ala low memory (0x8000_0000 based).
+	 * Even with PAE, the huge peripheral space hole would waste a lot of
+	 * mem with single mem_map[]. This warrants a mem_map per region design.
+	 * Thus HIGHMEM on ARC is imlemented with DISCONTIGMEM.
+	 *
+	 * DISCONTIGMEM in turns requires multiple nodes. node 0 above is
+	 * populated with normal memory zone while node 1 only has highmem
+	 */
+	node_set_online(1);
+	min_high_pfn = PFN_DOWN(high_mem_start);
+	max_high_pfn = PFN_DOWN(high_mem_start + high_mem_sz);
+	zones_size[ZONE_NORMAL] = 0;
+	zones_holes[ZONE_NORMAL] = 0;
+	zones_size[ZONE_HIGHMEM] = max_high_pfn - min_high_pfn;
+	zones_holes[ZONE_HIGHMEM] = 0;
+	free_area_init_node(1,			/* node-id */
+			    zones_size,		/* num pages per zone */
+			    min_high_pfn,	/* first pfn of node */
+			    zones_holes);	/* holes */
 	high_memory = (void *)(min_high_pfn << PAGE_SHIFT);
 	kmap_init();
 #endif
 	unsigned long tmp;
 	reset_all_zones_managed_pages();
-	for (tmp = min_high_pfn; tmp < max_pfn; tmp++)
+	for (tmp = min_high_pfn; tmp < max_high_pfn; tmp++)
 		free_highmem_page(pfn_to_page(tmp));
 #endif

arch/arm/boot/dts/omap3-n900.dts+9−0

 	regulator-name = "V28";
 	regulator-min-microvolt = <2800000>;
 	regulator-max-microvolt = <2800000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 	regulator-always-on; /* due to battery cover sensor */
 };
 	regulator-name = "VCSI";
 	regulator-min-microvolt = <1800000>;
 	regulator-max-microvolt = <1800000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 };
 &vaux3 {
 	regulator-name = "VMMC2_30";
 	regulator-min-microvolt = <2800000>;
 	regulator-max-microvolt = <3000000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 };
 &vaux4 {
 	regulator-name = "VCAM_ANA_28";
 	regulator-min-microvolt = <2800000>;
 	regulator-max-microvolt = <2800000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 };
 &vmmc1 {
 	regulator-name = "VMMC1";
 	regulator-min-microvolt = <1850000>;
 	regulator-max-microvolt = <3150000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 };
 &vmmc2 {
 	regulator-name = "V28_A";
 	regulator-min-microvolt = <2800000>;
 	regulator-max-microvolt = <3000000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 	regulator-always-on; /* due VIO leak to AIC34 VDDs */
 };
 	regulator-name = "VPLL";
 	regulator-min-microvolt = <1800000>;
 	regulator-max-microvolt = <1800000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 	regulator-always-on;
 };
 	regulator-name = "VSDI_CSI";
 	regulator-min-microvolt = <1800000>;
 	regulator-max-microvolt = <1800000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 	regulator-always-on;
 };
 	regulator-name = "VMMC2_IO_18";
 	regulator-min-microvolt = <1800000>;
 	regulator-max-microvolt = <1800000>;
+	regulator-initial-mode = <0x0e>; /* RES_STATE_ACTIVE */
 };
 &vio {

arch/arm/boot/dts/omap34xx.dtsi+1−1

@@ -46,7 +46,7 @@ · 45 unmodified lines
46	0x480bd800 0x017c>;	46	0x480bd800 0x017c>;
47	interrupts = <24>;	47	interrupts = <24>;
48	iommus = <&mmu_isp>;	48	iommus = <&mmu_isp>;
49	syscon = <&scm_conf 0xdc>;	49	syscon = <&scm_conf 0x6c>;
50	ti,phy-type = <OMAP3ISP_PHY_TYPE_COMPLEX_IO>;	50	ti,phy-type = <OMAP3ISP_PHY_TYPE_COMPLEX_IO>;
51	#clock-cells = <1>;	51	#clock-cells = <1>;
52	ports {	52	ports {

arch/arm/boot/dts/omap5-board-common.dtsi+2−2

@@ -472,7 +472,7 @@ · 471 unmodified lines
472	ldo1_reg: ldo1 {	472	ldo1_reg: ldo1 {
473	/* VDDAPHY_CAM: vdda_csiport */	473	/* VDDAPHY_CAM: vdda_csiport */
474	regulator-name = "ldo1";	474	regulator-name = "ldo1";
475	regulator-min-microvolt = <1500000>;	475	regulator-min-microvolt = <1800000>;
476	regulator-max-microvolt = <1800000>;	476	regulator-max-microvolt = <1800000>;
477	};	477	};
478		478
@@ -498,7 +498,7 @@ · 19 unmodified lines
498	ldo4_reg: ldo4 {	498	ldo4_reg: ldo4 {
499	/* VDDAPHY_DISP: vdda_dsiport/hdmi */	499	/* VDDAPHY_DISP: vdda_dsiport/hdmi */
500	regulator-name = "ldo4";	500	regulator-name = "ldo4";
501	regulator-min-microvolt = <1500000>;	501	regulator-min-microvolt = <1800000>;
502	regulator-max-microvolt = <1800000>;	502	regulator-max-microvolt = <1800000>;
503	};	503	};
504		504

arch/arm/boot/dts/omap5-cm-t54.dts+2−2

@@ -513,7 +513,7 @@ · 512 unmodified lines
513	ldo1_reg: ldo1 {	513	ldo1_reg: ldo1 {
514	/* VDDAPHY_CAM: vdda_csiport */	514	/* VDDAPHY_CAM: vdda_csiport */
515	regulator-name = "ldo1";	515	regulator-name = "ldo1";
516	regulator-min-microvolt = <1500000>;	516	regulator-min-microvolt = <1800000>;
517	regulator-max-microvolt = <1800000>;	517	regulator-max-microvolt = <1800000>;
518	};	518	};
519		519
@@ -537,7 +537,7 @@ · 17 unmodified lines
537	ldo4_reg: ldo4 {	537	ldo4_reg: ldo4 {
538	/* VDDAPHY_DISP: vdda_dsiport/hdmi */	538	/* VDDAPHY_DISP: vdda_dsiport/hdmi */
539	regulator-name = "ldo4";	539	regulator-name = "ldo4";
540	regulator-min-microvolt = <1500000>;	540	regulator-min-microvolt = <1800000>;
541	regulator-max-microvolt = <1800000>;	541	regulator-max-microvolt = <1800000>;
542	};	542	};
543		543

arch/arm/boot/dts/omap5.dtsi+1−1

@@ -269,7 +269,7 @@ · 268 unmodified lines
269	omap5_pmx_wkup: pinmux@c840 {	269	omap5_pmx_wkup: pinmux@c840 {
270	compatible = "ti,omap5-padconf",	270	compatible = "ti,omap5-padconf",
271	"pinctrl-single";	271	"pinctrl-single";
272	reg = <0xc840 0x0038>;	272	reg = <0xc840 0x003c>;
273	#address-cells = <1>;	273	#address-cells = <1>;
274	#size-cells = <0>;	274	#size-cells = <0>;
275	#interrupt-cells = <1>;	275	#interrupt-cells = <1>;

arch/arm/boot/dts/qcom-apq8064.dtsi+2−1

 		};
 		sata0: sata@29000000 {
-			compatible		= "generic-ahci";
+			compatible		= "qcom,apq8064-ahci", "generic-ahci";
 			status			= "disabled";
 			reg			= <0x29000000 0x180>;
 			interrupts		= <GIC_SPI 209 IRQ_TYPE_NONE>;
 			phys			= <&sata_phy0>;
 			phy-names		= "sata-phy";
+			ports-implemented	= <0x1>;
 		};
 		/* Temporary fixed regulator */

arch/arm/boot/dts/sun8i-q8-common.dtsi+0−2

@@ -125,8 +125,6 @@ · 124 unmodified lines
125	};	125	};
126		126
127	&reg_dc1sw {	127	&reg_dc1sw {
128	regulator-min-microvolt = <3000000>;
129	regulator-max-microvolt = <3000000>;
130	regulator-name = "vcc-lcd";	128	regulator-name = "vcc-lcd";
131	};	129	};
132		130

arch/arm/include/asm/domain.h+11−0

 #ifndef __ASSEMBLY__
+#ifdef CONFIG_CPU_CP15_MMU
 static inline unsigned int get_domain(void)
 {
 	unsigned int domain;
 	  : : "r" (val) : "memory");
 	isb();
 }
+#else
+static inline unsigned int get_domain(void)
+{
+	return 0;
+}
+static inline void set_domain(unsigned val)
+{
+}
+#endif
 #ifdef CONFIG_CPU_USE_DOMAINS
 #define modify_domain(dom,type)					\

arch/arm/kernel/head-nommu.S+1−1

@@ -236,7 +236,7 @@ ENTRY(__setup_mpu) · 235 unmodified lines
236	mov r0, #CONFIG_VECTORS_BASE @ Cover from VECTORS_BASE	236	mov r0, #CONFIG_VECTORS_BASE @ Cover from VECTORS_BASE
237	ldr r5,=(MPU_AP_PL1RW_PL0NA \| MPU_RGN_NORMAL)	237	ldr r5,=(MPU_AP_PL1RW_PL0NA \| MPU_RGN_NORMAL)
238	/* Writing N to bits 5:1 (RSR_SZ) --> region size 2^N+1 */	238	/* Writing N to bits 5:1 (RSR_SZ) --> region size 2^N+1 */
239	mov r6, #(((PAGE_SHIFT - 1) << MPU_RSR_SZ) \| 1 << MPU_RSR_EN)	239	mov r6, #(((2 * PAGE_SHIFT - 1) << MPU_RSR_SZ) \| 1 << MPU_RSR_EN)
240		240
241	setup_region r0, r5, r6, MPU_DATA_SIDE @ VECTORS_BASE, PL0 NA, enabled	241	setup_region r0, r5, r6, MPU_DATA_SIDE @ VECTORS_BASE, PL0 NA, enabled
242	beq 3f @ Memory-map not unified	242	beq 3f @ Memory-map not unified

arch/arm/kvm/mmu.c+1−1

@@ -1004,7 +1004,7 @@ static bool transparent_hugepage_adjust(kvm_pfn_t pfnp, phys_addr_t ipap) · 1003 unmodified lines
1004	kvm_pfn_t pfn = *pfnp;	1004	kvm_pfn_t pfn = *pfnp;
1005	gfn_t gfn = *ipap >> PAGE_SHIFT;	1005	gfn_t gfn = *ipap >> PAGE_SHIFT;
1006		1006
1007	if (PageTransCompound(pfn_to_page(pfn))) {	1007	if (PageTransCompoundMap(pfn_to_page(pfn))) {
1008	unsigned long mask;	1008	unsigned long mask;
1009	/*	1009	/*
1010	* The address we faulted on is backed by a transparent huge	1010	* The address we faulted on is backed by a transparent huge

arch/arm/mach-davinci/board-mityomapl138.c+5−0

 	const char *partnum = NULL;
 	struct davinci_soc_info *soc_info = &davinci_soc_info;
+	if (!IS_BUILTIN(CONFIG_NVMEM)) {
+		pr_warn("Factory Config not available without CONFIG_NVMEM\n");
+		goto bad_config;
+	}
 	ret = nvmem_device_read(nvmem, 0, sizeof(factory_config),
 				&factory_config);
 	if (ret != sizeof(struct factory_config)) {

arch/arm/mach-davinci/common.c+5−0

 	char *mac_addr = davinci_soc_info.emac_pdata->mac_addr;
 	off_t offset = (off_t)context;
+	if (!IS_BUILTIN(CONFIG_NVMEM)) {
+		pr_warn("Cannot read MAC addr from EEPROM without CONFIG_NVMEM\n");
+		return;
+	}
 	/* Read MAC addr from EEPROM */
 	if (nvmem_device_read(nvmem, offset, ETH_ALEN, mac_addr) == ETH_ALEN)
 		pr_info("Read MAC addr from EEPROM: %pM\n", mac_addr);

arch/arm/mach-exynos/pm_domains.c+1−1

@@ -92,7 +92,7 @@ static int exynos_pd_power(struct generic_pm_domain *domain, bool power_on) · 91 unmodified lines
92	if (IS_ERR(pd->clk[i]))	92	if (IS_ERR(pd->clk[i]))
93	break;	93	break;
94		94
95	if (IS_ERR(pd->clk[i]))	95	if (IS_ERR(pd->pclk[i]))
96	continue; /* Skip on first power up */	96	continue; /* Skip on first power up */
97	if (clk_set_parent(pd->clk[i], pd->pclk[i]))	97	if (clk_set_parent(pd->clk[i], pd->pclk[i]))
98	pr_err("%s: error setting parent to clock%d\n",	98	pr_err("%s: error setting parent to clock%d\n",

arch/arm/mach-socfpga/headsmp.S+1−0

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	#include <asm/assembler.h>	13	#include <asm/assembler.h>
14		14
15	.arch armv7-a	15	.arch armv7-a
		16	.arm
16		17
17	ENTRY(secondary_trampoline)	18	ENTRY(secondary_trampoline)
18	/* CPU1 will always fetch from 0x0 when it is brought out of reset.	19	/* CPU1 will always fetch from 0x0 when it is brought out of reset.

arch/arm/mm/nommu.c+8−7

 /* MPU initialisation functions */
 void __init sanity_check_meminfo_mpu(void)
 {
-	int i;
 	phys_addr_t phys_offset = PHYS_OFFSET;
 	phys_addr_t aligned_region_size, specified_mem_size, rounded_mem_size;
 	struct memblock_region *reg;
 		} else {
 			/*
 			 * memblock auto merges contiguous blocks, remove
-			 * all blocks afterwards
+			 * all blocks afterwards in one go (we can't remove
+			 * blocks separately while iterating)
 			 */
 			pr_notice("Ignoring RAM after %pa, memory at %pa ignored\n",
-				  &mem_start, &reg->base);
+				  &mem_end, &reg->base);
-			memblock_remove(reg->base, reg->size);
+			memblock_remove(reg->base, 0 - reg->base);
+			break;
 		}
 	}
 		pr_warn("Truncating memory from %pa to %pa (MPU region constraints)",
 				&specified_mem_size, &aligned_region_size);
 		memblock_remove(mem_start + aligned_region_size,
-				specified_mem_size - aligned_round_size);
+				specified_mem_size - aligned_region_size);
 		mem_end = mem_start + aligned_region_size;
 	}
 		return;
 	region_err = mpu_setup_region(MPU_RAM_REGION, PHYS_OFFSET,
-					ilog2(meminfo.bank[0].size),
+					ilog2(memblock.memory.regions[0].size),
 					MPU_AP_PL1RW_PL0RW | MPU_RGN_NORMAL);
 	if (region_err) {
 		panic("MPU region initialization failure! %d", region_err);
 	 * some architectures which the DRAM is the exception vector to trap,
 	 * alloc_page breaks with error, although it is not NULL, but "0."
 	 */
-	memblock_reserve(CONFIG_VECTORS_BASE, PAGE_SIZE);
+	memblock_reserve(CONFIG_VECTORS_BASE, 2 * PAGE_SIZE);
 #else /* ifndef CONFIG_CPU_V7M */
 	/*
 	 * There is no dedicated vector page on V7-M. So nothing needs to be

arch/arm64/boot/dts/renesas/r8a7795.dtsi+0−1

@@ -120,7 +120,6 @@ · 119 unmodified lines
120	compatible = "fixed-clock";	120	compatible = "fixed-clock";
121	#clock-cells = <0>;	121	#clock-cells = <0>;
122	clock-frequency = <0>;	122	clock-frequency = <0>;
123	status = "disabled";
124	};	123	};
125		124
126	soc {	125	soc {

arch/parisc/kernel/syscall.S+1−1

@@ -344,7 +344,7 @@ tracesys_next: · 343 unmodified lines
344	#endif	344	#endif
345		345
346	cmpib,COND(=),n -1,%r20,tracesys_exit /* seccomp may have returned -1 */	346	cmpib,COND(=),n -1,%r20,tracesys_exit /* seccomp may have returned -1 */
347	comiclr,>>= __NR_Linux_syscalls, %r20, %r0	347	comiclr,>> __NR_Linux_syscalls, %r20, %r0
348	b,n .Ltracesys_nosys	348	b,n .Ltracesys_nosys
349		349
350	LDREGX %r20(%r19), %r19	350	LDREGX %r20(%r19), %r19

arch/powerpc/include/asm/word-at-a-time.h+1−1

@@ -82,7 +82,7 @@ static inline unsigned long create_zero_mask(unsigned long bits) · 81 unmodified lines
82	"andc %1,%1,%2\n\t"	82	"andc %1,%1,%2\n\t"
83	"popcntd %0,%1"	83	"popcntd %0,%1"
84	: "=r" (leading_zero_bits), "=&r" (trailing_zero_bit_mask)	84	: "=r" (leading_zero_bits), "=&r" (trailing_zero_bit_mask)
85	: "r" (bits));	85	: "b" (bits));
86		86
87	return leading_zero_bits;	87	return leading_zero_bits;
88	}	88	}

arch/x86/events/amd/iommu.c+1−0

@@ -474,6 +474,7 @@ static __init int _init_perf_amd_iommu( · 473 unmodified lines
474		474
475	static struct perf_amd_iommu __perf_iommu = {	475	static struct perf_amd_iommu __perf_iommu = {
476	.pmu = {	476	.pmu = {
		477	.task_ctx_nr = perf_invalid_context,
477	.event_init = perf_iommu_event_init,	478	.event_init = perf_iommu_event_init,
478	.add = perf_iommu_add,	479	.add = perf_iommu_add,
479	.del = perf_iommu_del,	480	.del = perf_iommu_del,

arch/x86/events/intel/core.c+2−0

@@ -3637,6 +3637,8 @@ __init int intel_pmu_init(void) · 3636 unmodified lines
3637	pr_cont("Knights Landing events, ");	3637	pr_cont("Knights Landing events, ");
3638	break;	3638	break;
3639		3639
		3640	case 142: /* 14nm Kabylake Mobile */
		3641	case 158: /* 14nm Kabylake Desktop */
3640	case 78: /* 14nm Skylake Mobile */	3642	case 78: /* 14nm Skylake Mobile */
3641	case 94: /* 14nm Skylake Desktop */	3643	case 94: /* 14nm Skylake Desktop */
3642	case 85: /* 14nm Skylake Server */	3644	case 85: /* 14nm Skylake Server */

arch/x86/kernel/apic/x2apic_uv_x.c+1−3

@@ -891,9 +891,7 @@ void __init uv_system_init(void) · 890 unmodified lines
891	}	891	}
892	pr_info("UV: Found %s hub\n", hub);	892	pr_info("UV: Found %s hub\n", hub);
893		893
894	/* We now only need to map the MMRs on UV1 */	894	map_low_mmrs();
895	if (is_uv1_hub())
896	map_low_mmrs();
897		895
898	m_n_config.v = uv_read_local_mmr(UVH_RH_GAM_CONFIG_MMR );	896	m_n_config.v = uv_read_local_mmr(UVH_RH_GAM_CONFIG_MMR );
899	m_val = m_n_config.s.m_skt;	897	m_val = m_n_config.s.m_skt;

arch/x86/kernel/sysfb_efi.c+12−2

 					continue;
 				for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
 					resource_size_t start, end;
+					unsigned long flags;
+					flags = pci_resource_flags(dev, i);
+					if (!(flags & IORESOURCE_MEM))
+						continue;
+					if (flags & IORESOURCE_UNSET)
+						continue;
+					if (pci_resource_len(dev, i) == 0)
+						continue;
 					start = pci_resource_start(dev, i);
-					if (start == 0)
-						break;
 					end = pci_resource_end(dev, i);
 					if (screen_info.lfb_base >= start &&
 					    screen_info.lfb_base < end) {
 						found_bar = 1;
+						break;
 					}
 				}
 			}

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

@@ -92,7 +92,7 @@ unsigned long try_msr_calibrate_tsc(void) · 91 unmodified lines
92		92
93	if (freq_desc_tables[cpu_index].msr_plat) {	93	if (freq_desc_tables[cpu_index].msr_plat) {
94	rdmsr(MSR_PLATFORM_INFO, lo, hi);	94	rdmsr(MSR_PLATFORM_INFO, lo, hi);
95	ratio = (lo >> 8) & 0x1f;	95	ratio = (lo >> 8) & 0xff;
96	} else {	96	} else {
97	rdmsr(MSR_IA32_PERF_STATUS, lo, hi);	97	rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
98	ratio = (hi >> 8) & 0x1f;	98	ratio = (hi >> 8) & 0x1f;

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

@@ -2823,7 +2823,7 @@ static void transparent_hugepage_adjust(struct kvm_vcpu *vcpu, · 2822 unmodified lines
2823	*/	2823	*/
2824	if (!is_error_noslot_pfn(pfn) && !kvm_is_reserved_pfn(pfn) &&	2824	if (!is_error_noslot_pfn(pfn) && !kvm_is_reserved_pfn(pfn) &&
2825	level == PT_PAGE_TABLE_LEVEL &&	2825	level == PT_PAGE_TABLE_LEVEL &&
2826	PageTransCompound(pfn_to_page(pfn)) &&	2826	PageTransCompoundMap(pfn_to_page(pfn)) &&
2827	!mmu_gfn_lpage_is_disallowed(vcpu, gfn, PT_DIRECTORY_LEVEL)) {	2827	!mmu_gfn_lpage_is_disallowed(vcpu, gfn, PT_DIRECTORY_LEVEL)) {
2828	unsigned long mask;	2828	unsigned long mask;
2829	/*	2829	/*
@@ -4785,7 +4785,7 @@ restart: · 1955 unmodified lines
4785	*/	4785	*/
4786	if (sp->role.direct &&	4786	if (sp->role.direct &&
4787	!kvm_is_reserved_pfn(pfn) &&	4787	!kvm_is_reserved_pfn(pfn) &&
4788	PageTransCompound(pfn_to_page(pfn))) {	4788	PageTransCompoundMap(pfn_to_page(pfn))) {
4789	drop_spte(kvm, sptep);	4789	drop_spte(kvm, sptep);
4790	need_tlb_flush = 1;	4790	need_tlb_flush = 1;
4791	goto restart;	4791	goto restart;

arch/x86/platform/efi/efi-bgrt.c+9−9

@@ -43,40 +43,40 @@ void __init efi_bgrt_init(void) · 42 unmodified lines
43	return;	43	return;
44		44
45	if (bgrt_tab->header.length < sizeof(*bgrt_tab)) {	45	if (bgrt_tab->header.length < sizeof(*bgrt_tab)) {
46	pr_err("Ignoring BGRT: invalid length %u (expected %zu)\n",	46	pr_notice("Ignoring BGRT: invalid length %u (expected %zu)\n",
47	bgrt_tab->header.length, sizeof(*bgrt_tab));	47	bgrt_tab->header.length, sizeof(*bgrt_tab));
48	return;	48	return;
49	}	49	}
50	if (bgrt_tab->version != 1) {	50	if (bgrt_tab->version != 1) {
51	pr_err("Ignoring BGRT: invalid version %u (expected 1)\n",	51	pr_notice("Ignoring BGRT: invalid version %u (expected 1)\n",
52	bgrt_tab->version);	52	bgrt_tab->version);
53	return;	53	return;
54	}	54	}
55	if (bgrt_tab->status & 0xfe) {	55	if (bgrt_tab->status & 0xfe) {
56	pr_err("Ignoring BGRT: reserved status bits are non-zero %u\n",	56	pr_notice("Ignoring BGRT: reserved status bits are non-zero %u\n",
57	bgrt_tab->status);	57	bgrt_tab->status);
58	return;	58	return;
59	}	59	}
60	if (bgrt_tab->image_type != 0) {	60	if (bgrt_tab->image_type != 0) {
61	pr_err("Ignoring BGRT: invalid image type %u (expected 0)\n",	61	pr_notice("Ignoring BGRT: invalid image type %u (expected 0)\n",
62	bgrt_tab->image_type);	62	bgrt_tab->image_type);
63	return;	63	return;
64	}	64	}
65	if (!bgrt_tab->image_address) {	65	if (!bgrt_tab->image_address) {
66	pr_err("Ignoring BGRT: null image address\n");	66	pr_notice("Ignoring BGRT: null image address\n");
67	return;	67	return;
68	}	68	}
69		69
70	image = memremap(bgrt_tab->image_address, sizeof(bmp_header), MEMREMAP_WB);	70	image = memremap(bgrt_tab->image_address, sizeof(bmp_header), MEMREMAP_WB);
71	if (!image) {	71	if (!image) {
72	pr_err("Ignoring BGRT: failed to map image header memory\n");	72	pr_notice("Ignoring BGRT: failed to map image header memory\n");
73	return;	73	return;
74	}	74	}
75		75
76	memcpy(&bmp_header, image, sizeof(bmp_header));	76	memcpy(&bmp_header, image, sizeof(bmp_header));
77	memunmap(image);	77	memunmap(image);
78	if (bmp_header.id != 0x4d42) {	78	if (bmp_header.id != 0x4d42) {
79	pr_err("Ignoring BGRT: Incorrect BMP magic number 0x%x (expected 0x4d42)\n",	79	pr_notice("Ignoring BGRT: Incorrect BMP magic number 0x%x (expected 0x4d42)\n",
80	bmp_header.id);	80	bmp_header.id);
81	return;	81	return;
82	}	82	}
@@ -84,14 +84,14 @@ void __init efi_bgrt_init(void) · 1 unmodified line
84		84
85	bgrt_image = kmalloc(bgrt_image_size, GFP_KERNEL \| __GFP_NOWARN);	85	bgrt_image = kmalloc(bgrt_image_size, GFP_KERNEL \| __GFP_NOWARN);
86	if (!bgrt_image) {	86	if (!bgrt_image) {
87	pr_err("Ignoring BGRT: failed to allocate memory for image (wanted %zu bytes)\n",	87	pr_notice("Ignoring BGRT: failed to allocate memory for image (wanted %zu bytes)\n",
88	bgrt_image_size);	88	bgrt_image_size);
89	return;	89	return;
90	}	90	}
91		91
92	image = memremap(bgrt_tab->image_address, bmp_header.size, MEMREMAP_WB);	92	image = memremap(bgrt_tab->image_address, bmp_header.size, MEMREMAP_WB);
93	if (!image) {	93	if (!image) {
94	pr_err("Ignoring BGRT: failed to map image memory\n");	94	pr_notice("Ignoring BGRT: failed to map image memory\n");
95	kfree(bgrt_image);	95	kfree(bgrt_image);
96	bgrt_image = NULL;	96	bgrt_image = NULL;
97	return;	97	return;

crypto/Kconfig+1−0

@@ -96,6 +96,7 @@ config CRYPTO_AKCIPHER · 95 unmodified lines
96	config CRYPTO_RSA	96	config CRYPTO_RSA
97	tristate "RSA algorithm"	97	tristate "RSA algorithm"
98	select CRYPTO_AKCIPHER	98	select CRYPTO_AKCIPHER
		99	select CRYPTO_MANAGER
99	select MPILIB	100	select MPILIB
100	select ASN1	101	select ASN1
101	help	102	help

crypto/ahash.c+2−1

 	struct scatterlist *sg;
 	sg = walk->sg;
-	walk->pg = sg_page(sg);
 	walk->offset = sg->offset;
+	walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
+	walk->offset = offset_in_page(walk->offset);
 	walk->entrylen = sg->length;
 	if (walk->entrylen > walk->total)

drivers/acpi/acpica/dsmethod.c+3−0

@@ -428,6 +428,9 @@ acpi_ds_begin_method_execution(struct acpi_namespace_node *method_node, · 427 unmodified lines
428	obj_desc->method.mutex->mutex.	428	obj_desc->method.mutex->mutex.
429	original_sync_level =	429	original_sync_level =
430	obj_desc->method.mutex->mutex.sync_level;	430	obj_desc->method.mutex->mutex.sync_level;
		431
		432	obj_desc->method.mutex->mutex.thread_id =
		433	acpi_os_get_thread_id();
431	}	434	}
432	}	435	}
433		436

drivers/acpi/nfit.c+4−1

 					offset);
 			rc = -ENXIO;
 		}
-	} else
+	} else {
 		rc = 0;
+		if (cmd_rc)
+			*cmd_rc = xlat_status(buf, cmd);
+	}
  out:
 	ACPI_FREE(out_obj);

drivers/ata/Kconfig+8−0

@@ -202,6 +202,14 @@ config SATA_FSL · 201 unmodified lines
202		202
203	If unsure, say N.	203	If unsure, say N.
204		204
		205	config SATA_AHCI_SEATTLE
		206	tristate "AMD Seattle 6.0Gbps AHCI SATA host controller support"
		207	depends on ARCH_SEATTLE
		208	help
		209	This option enables support for AMD Seattle SATA host controller.
		210
		211	If unsure, say N
		212
205	config SATA_INIC162X	213	config SATA_INIC162X
206	tristate "Initio 162x SATA support (Very Experimental)"	214	tristate "Initio 162x SATA support (Very Experimental)"
207	depends on PCI	215	depends on PCI

drivers/ata/Makefile+1−0

@@ -4,6 +4,7 @@ obj-$(CONFIG_ATA) += libata.o · 3 unmodified lines
4	# non-SFF interface	4	# non-SFF interface
5	obj-$(CONFIG_SATA_AHCI) += ahci.o libahci.o	5	obj-$(CONFIG_SATA_AHCI) += ahci.o libahci.o
6	obj-$(CONFIG_SATA_ACARD_AHCI) += acard-ahci.o libahci.o	6	obj-$(CONFIG_SATA_ACARD_AHCI) += acard-ahci.o libahci.o
		7	obj-$(CONFIG_SATA_AHCI_SEATTLE) += ahci_seattle.o libahci.o libahci_platform.o
7	obj-$(CONFIG_SATA_AHCI_PLATFORM) += ahci_platform.o libahci.o libahci_platform.o	8	obj-$(CONFIG_SATA_AHCI_PLATFORM) += ahci_platform.o libahci.o libahci_platform.o
8	obj-$(CONFIG_SATA_FSL) += sata_fsl.o	9	obj-$(CONFIG_SATA_FSL) += sata_fsl.o
9	obj-$(CONFIG_SATA_INIC162X) += sata_inic162x.o	10	obj-$(CONFIG_SATA_INIC162X) += sata_inic162x.o

drivers/ata/ahci_platform.c+3−0

@@ -51,6 +51,9 @@ static int ahci_probe(struct platform_device *pdev) · 50 unmodified lines
51	if (rc)	51	if (rc)
52	return rc;	52	return rc;
53		53
		54	of_property_read_u32(dev->of_node,
		55	"ports-implemented", &hpriv->force_port_map);
		56
54	if (of_device_is_compatible(dev->of_node, "hisilicon,hisi-ahci"))	57	if (of_device_is_compatible(dev->of_node, "hisilicon,hisi-ahci"))
55	hpriv->flags \|= AHCI_HFLAG_NO_FBS \| AHCI_HFLAG_NO_NCQ;	58	hpriv->flags \|= AHCI_HFLAG_NO_FBS \| AHCI_HFLAG_NO_NCQ;
56		59

drivers/ata/ahci_seattle.c+210−0

@@ -0,0 +1,210 @@
	1	/*
	2	* AMD Seattle AHCI SATA driver
	3	*
	4	* Copyright (c) 2015, Advanced Micro Devices
	5	* Author: Brijesh Singh <brijesh.singh@amd.com>
	6	*
	7	* based on the AHCI SATA platform driver by Jeff Garzik and Anton Vorontsov
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/pm.h>
	22	#include <linux/device.h>
	23	#include <linux/of_device.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/libata.h>
	26	#include <linux/ahci_platform.h>
	27	#include <linux/acpi.h>
	28	#include <linux/pci_ids.h>
	29	#include "ahci.h"
	30
	31	/* SGPIO Control Register definition
	32	*
	33	* Bit Type Description
	34	* 31 RW OD7.2 (activity)
	35	* 30 RW OD7.1 (locate)
	36	* 29 RW OD7.0 (fault)
	37	* 28...8 RW OD6.2...OD0.0 (3bits per port, 1 bit per LED)
	38	* 7 RO SGPIO feature flag
	39	* 6:4 RO Reserved
	40	* 3:0 RO Number of ports (0 means no port supported)
	41	*/
	42	#define ACTIVITY_BIT_POS(x) (8 + (3 * x))
	43	#define LOCATE_BIT_POS(x) (ACTIVITY_BIT_POS(x) + 1)
	44	#define FAULT_BIT_POS(x) (LOCATE_BIT_POS(x) + 1)
	45
	46	#define ACTIVITY_MASK 0x00010000
	47	#define LOCATE_MASK 0x00080000
	48	#define FAULT_MASK 0x00400000
	49
	50	#define DRV_NAME "ahci-seattle"
	51
	52	static ssize_t seattle_transmit_led_message(struct ata_port *ap, u32 state,
	53	ssize_t size);
	54
	55	struct seattle_plat_data {
	56	void __iomem *sgpio_ctrl;
	57	};
	58
	59	static struct ata_port_operations ahci_port_ops = {
	60	.inherits = &ahci_ops,
	61	};
	62
	63	static const struct ata_port_info ahci_port_info = {
	64	.flags = AHCI_FLAG_COMMON,
	65	.pio_mask = ATA_PIO4,
	66	.udma_mask = ATA_UDMA6,
	67	.port_ops = &ahci_port_ops,
	68	};
	69
	70	static struct ata_port_operations ahci_seattle_ops = {
	71	.inherits = &ahci_ops,
	72	.transmit_led_message = seattle_transmit_led_message,
	73	};
	74
	75	static const struct ata_port_info ahci_port_seattle_info = {
	76	.flags = AHCI_FLAG_COMMON \| ATA_FLAG_EM \| ATA_FLAG_SW_ACTIVITY,
	77	.link_flags = ATA_LFLAG_SW_ACTIVITY,
	78	.pio_mask = ATA_PIO4,
	79	.udma_mask = ATA_UDMA6,
	80	.port_ops = &ahci_seattle_ops,
	81	};
	82
	83	static struct scsi_host_template ahci_platform_sht = {
	84	AHCI_SHT(DRV_NAME),
	85	};
	86
	87	static ssize_t seattle_transmit_led_message(struct ata_port *ap, u32 state,
	88	ssize_t size)
	89	{
	90	struct ahci_host_priv *hpriv = ap->host->private_data;
	91	struct ahci_port_priv *pp = ap->private_data;
	92	struct seattle_plat_data *plat_data = hpriv->plat_data;
	93	unsigned long flags;
	94	int pmp;
	95	struct ahci_em_priv *emp;
	96	u32 val;
	97
	98	/* get the slot number from the message */
	99	pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
	100	if (pmp >= EM_MAX_SLOTS)
	101	return -EINVAL;
	102	emp = &pp->em_priv[pmp];
	103
	104	val = ioread32(plat_data->sgpio_ctrl);
	105	if (state & ACTIVITY_MASK)
	106	val \|= 1 << ACTIVITY_BIT_POS((ap->port_no));
	107	else
	108	val &= ~(1 << ACTIVITY_BIT_POS((ap->port_no)));
	109
	110	if (state & LOCATE_MASK)
	111	val \|= 1 << LOCATE_BIT_POS((ap->port_no));
	112	else
	113	val &= ~(1 << LOCATE_BIT_POS((ap->port_no)));
	114
	115	if (state & FAULT_MASK)
	116	val \|= 1 << FAULT_BIT_POS((ap->port_no));
	117	else
	118	val &= ~(1 << FAULT_BIT_POS((ap->port_no)));
	119
	120	iowrite32(val, plat_data->sgpio_ctrl);
	121
	122	spin_lock_irqsave(ap->lock, flags);
	123
	124	/* save off new led state for port/slot */
	125	emp->led_state = state;
	126
	127	spin_unlock_irqrestore(ap->lock, flags);
	128
	129	return size;
	130	}
	131
	132	static const struct ata_port_info *ahci_seattle_get_port_info(
	133	struct platform_device pdev, struct ahci_host_priv hpriv)
	134	{
	135	struct device *dev = &pdev->dev;
	136	struct seattle_plat_data *plat_data;
	137	u32 val;
	138
	139	plat_data = devm_kzalloc(dev, sizeof(*plat_data), GFP_KERNEL);
	140	if (IS_ERR(plat_data))
	141	return &ahci_port_info;
	142
	143	plat_data->sgpio_ctrl = devm_ioremap_resource(dev,
	144	platform_get_resource(pdev, IORESOURCE_MEM, 1));
	145	if (IS_ERR(plat_data->sgpio_ctrl))
	146	return &ahci_port_info;
	147
	148	val = ioread32(plat_data->sgpio_ctrl);
	149
	150	if (!(val & 0xf))
	151	return &ahci_port_info;
	152
	153	hpriv->em_loc = 0;
	154	hpriv->em_buf_sz = 4;
	155	hpriv->em_msg_type = EM_MSG_TYPE_LED;
	156	hpriv->plat_data = plat_data;
	157
	158	dev_info(dev, "SGPIO LED control is enabled.\n");
	159	return &ahci_port_seattle_info;
	160	}
	161
	162	static int ahci_seattle_probe(struct platform_device *pdev)
	163	{
	164	int rc;
	165	struct ahci_host_priv *hpriv;
	166
	167	hpriv = ahci_platform_get_resources(pdev);
	168	if (IS_ERR(hpriv))
	169	return PTR_ERR(hpriv);
	170
	171	rc = ahci_platform_enable_resources(hpriv);
	172	if (rc)
	173	return rc;
	174
	175	rc = ahci_platform_init_host(pdev, hpriv,
	176	ahci_seattle_get_port_info(pdev, hpriv),
	177	&ahci_platform_sht);
	178	if (rc)
	179	goto disable_resources;
	180
	181	return 0;
	182	disable_resources:
	183	ahci_platform_disable_resources(hpriv);
	184	return rc;
	185	}
	186
	187	static SIMPLE_DEV_PM_OPS(ahci_pm_ops, ahci_platform_suspend,
	188	ahci_platform_resume);
	189
	190	static const struct acpi_device_id ahci_acpi_match[] = {
	191	{ "AMDI0600", 0 },
	192	{}
	193	};
	194	MODULE_DEVICE_TABLE(acpi, ahci_acpi_match);
	195
	196	static struct platform_driver ahci_seattle_driver = {
	197	.probe = ahci_seattle_probe,
	198	.remove = ata_platform_remove_one,
	199	.driver = {
	200	.name = DRV_NAME,
	201	.acpi_match_table = ahci_acpi_match,
	202	.pm = &ahci_pm_ops,
	203	},
	204	};
	205	module_platform_driver(ahci_seattle_driver);
	206
	207	MODULE_DESCRIPTION("Seattle AHCI SATA platform driver");
	208	MODULE_AUTHOR("Brijesh Singh <brijesh.singh@amd.com>");
	209	MODULE_LICENSE("GPL");
	210	MODULE_ALIAS("platform:" DRV_NAME);

drivers/ata/libahci.c+1−0

@@ -507,6 +507,7 @@ void ahci_save_initial_config(struct device dev, struct ahci_host_priv hpriv) · 506 unmodified lines
507	dev_info(dev, "forcing port_map 0x%x -> 0x%x\n",	507	dev_info(dev, "forcing port_map 0x%x -> 0x%x\n",
508	port_map, hpriv->force_port_map);	508	port_map, hpriv->force_port_map);
509	port_map = hpriv->force_port_map;	509	port_map = hpriv->force_port_map;
		510	hpriv->saved_port_map = port_map;
510	}	511	}
511		512
512	if (hpriv->mask_port_map) {	513	if (hpriv->mask_port_map) {

drivers/base/power/opp/core.c+0−3

 	reg = opp_table->regulator;
 	if (IS_ERR(reg)) {
 		/* Regulator may not be required for device */
-		if (reg)
-			dev_err(dev, "%s: Invalid regulator (%ld)\n", __func__,
-				PTR_ERR(reg));
 		rcu_read_unlock();
 		return 0;
 	}

drivers/base/property.c+1−1

@@ -21,7 +21,7 @@ · 20 unmodified lines
21		21
22	static inline bool is_pset_node(struct fwnode_handle *fwnode)	22	static inline bool is_pset_node(struct fwnode_handle *fwnode)
23	{	23	{
24	return fwnode && fwnode->type == FWNODE_PDATA;	24	return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_PDATA;
25	}	25	}
26		26
27	static inline struct property_set to_pset_node(struct fwnode_handle fwnode)	27	static inline struct property_set to_pset_node(struct fwnode_handle fwnode)

drivers/cpufreq/cpufreq.c+15−11

 	if (!cpufreq_driver)
 		return;
-	if (!has_target())
+	if (!has_target() && !cpufreq_driver->suspend)
 		goto suspend;
 	pr_debug("%s: Suspending Governors\n", __func__);
 	for_each_active_policy(policy) {
-		down_write(&policy->rwsem);
+		if (has_target()) {
-		ret = cpufreq_governor(policy, CPUFREQ_GOV_STOP);
+			down_write(&policy->rwsem);
-		up_write(&policy->rwsem);
+			ret = cpufreq_governor(policy, CPUFREQ_GOV_STOP);
+			up_write(&policy->rwsem);
-		if (ret)
+			if (ret) {
-			pr_err("%s: Failed to stop governor for policy: %p\n",
+				pr_err("%s: Failed to stop governor for policy: %p\n",
-				__func__, policy);
+					__func__, policy);
-		else if (cpufreq_driver->suspend
+				continue;
-		    && cpufreq_driver->suspend(policy))
+			}
+		}
+		if (cpufreq_driver->suspend && cpufreq_driver->suspend(policy))
 			pr_err("%s: Failed to suspend driver: %p\n", __func__,
 				policy);
 	}
 	cpufreq_suspended = false;
-	if (!has_target())
+	if (!has_target() && !cpufreq_driver->resume)
 		return;
 	pr_debug("%s: Resuming Governors\n", __func__);
 		if (cpufreq_driver->resume && cpufreq_driver->resume(policy)) {
 			pr_err("%s: Failed to resume driver: %p\n", __func__,
 				policy);
-		} else {
+		} else if (has_target()) {
 			down_write(&policy->rwsem);
 			ret = cpufreq_start_governor(policy);
 			up_write(&policy->rwsem);

drivers/cpufreq/intel_pstate.c+18−8

 	}
 }
+static int intel_pstate_hwp_set_policy(struct cpufreq_policy *policy)
+{
+	if (hwp_active)
+		intel_pstate_hwp_set(policy->cpus);
+	return 0;
+}
 static void intel_pstate_hwp_set_online_cpus(void)
 {
 	get_online_cpus();
 static inline int32_t get_avg_frequency(struct cpudata *cpu)
 {
-	return div64_u64(cpu->pstate.max_pstate_physical * cpu->sample.aperf *
+	return fp_toint(mul_fp(cpu->sample.core_pct_busy,
-		cpu->pstate.scaling, cpu->sample.mperf);
+			       int_tofp(cpu->pstate.max_pstate_physical *
+						cpu->pstate.scaling / 100)));
 }
 static inline int32_t get_target_pstate_use_cpu_load(struct cpudata *cpu)
 	int32_t core_busy, max_pstate, current_pstate, sample_ratio;
 	u64 duration_ns;
-	intel_pstate_calc_busy(cpu);
 	/*
 	 * core_busy is the ratio of actual performance to max
 	 * max_pstate is the max non turbo pstate available
 	if ((s64)delta_ns >= pid_params.sample_rate_ns) {
 		bool sample_taken = intel_pstate_sample(cpu, time);
-		if (sample_taken && !hwp_active)
+		if (sample_taken) {
-			intel_pstate_adjust_busy_pstate(cpu);
+			intel_pstate_calc_busy(cpu);
+			if (!hwp_active)
+				intel_pstate_adjust_busy_pstate(cpu);
+		}
 	}
 }
  out:
 	intel_pstate_set_update_util_hook(policy->cpu);
-	if (hwp_active)
+	intel_pstate_hwp_set_policy(policy);
-		intel_pstate_hwp_set(policy->cpus);
 	return 0;
 }
 	.flags		= CPUFREQ_CONST_LOOPS,
 	.verify		= intel_pstate_verify_policy,
 	.setpolicy	= intel_pstate_set_policy,
+	.resume		= intel_pstate_hwp_set_policy,
 	.get		= intel_pstate_get,
 	.init		= intel_pstate_cpu_init,
 	.stop_cpu	= intel_pstate_stop_cpu,

drivers/cpufreq/sti-cpufreq.c+4−0

 {
 	int ret;
+	if ((!of_machine_is_compatible("st,stih407")) &&
+		(!of_machine_is_compatible("st,stih410")))
+		return -ENODEV;
 	ddata.cpu = get_cpu_device(0);
 	if (!ddata.cpu) {
 		dev_err(ddata.cpu, "Failed to get device for CPU0\n");

drivers/cpuidle/cpuidle-arm.c+1−1

@@ -50,7 +50,7 @@ static int arm_enter_idle_state(struct cpuidle_device *dev, · 49 unmodified lines
50	* call the CPU ops suspend protocol with idle index as a	50	* call the CPU ops suspend protocol with idle index as a
51	* parameter.	51	* parameter.
52	*/	52	*/
53	arm_cpuidle_suspend(idx);	53	ret = arm_cpuidle_suspend(idx);
54		54
55	cpu_pm_exit();	55	cpu_pm_exit();
56	}	56	}

drivers/crypto/qat/qat_common/adf_common_drv.h+11−0

 				 uint32_t vf_mask);
 void adf_enable_pf2vf_interrupts(struct adf_accel_dev *accel_dev);
 void adf_disable_pf2vf_interrupts(struct adf_accel_dev *accel_dev);
+int adf_init_pf_wq(void);
+void adf_exit_pf_wq(void);
 #else
 static inline int adf_sriov_configure(struct pci_dev *pdev, int numvfs)
 {
 static inline void adf_disable_pf2vf_interrupts(struct adf_accel_dev *accel_dev)
 {
 }
+static inline int adf_init_pf_wq(void)
+{
+	return 0;
+}
+static inline void adf_exit_pf_wq(void)
+{
+}
 #endif
 #endif

drivers/crypto/qat/qat_common/adf_ctl_drv.c+6−0

 	if (adf_init_aer())
 		goto err_aer;
+	if (adf_init_pf_wq())
+		goto err_pf_wq;
 	if (qat_crypto_register())
 		goto err_crypto_register;
 	return 0;
 err_crypto_register:
+	adf_exit_pf_wq();
+err_pf_wq:
 	adf_exit_aer();
 err_aer:
 	adf_chr_drv_destroy();
 {
 	adf_chr_drv_destroy();
 	adf_exit_aer();
+	adf_exit_pf_wq();
 	qat_crypto_unregister();
 	adf_clean_vf_map(false);
 	mutex_destroy(&adf_ctl_lock);

drivers/crypto/qat/qat_common/adf_sriov.c+16−10

 	int i;
 	u32 reg;
-	/* Workqueue for PF2VF responses */
-	pf2vf_resp_wq = create_workqueue("qat_pf2vf_resp_wq");
-	if (!pf2vf_resp_wq)
-		return -ENOMEM;
 	for (i = 0, vf_info = accel_dev->pf.vf_info; i < totalvfs;
 	     i++, vf_info++) {
 		/* This ptr will be populated when VFs will be created */
 	kfree(accel_dev->pf.vf_info);
 	accel_dev->pf.vf_info = NULL;
-	if (pf2vf_resp_wq) {
-		destroy_workqueue(pf2vf_resp_wq);
-		pf2vf_resp_wq = NULL;
-	}
 }
 EXPORT_SYMBOL_GPL(adf_disable_sriov);
 	return numvfs;
 }
 EXPORT_SYMBOL_GPL(adf_sriov_configure);
+int __init adf_init_pf_wq(void)
+{
+	/* Workqueue for PF2VF responses */
+	pf2vf_resp_wq = create_workqueue("qat_pf2vf_resp_wq");
+	return !pf2vf_resp_wq ? -ENOMEM : 0;
+}
+void adf_exit_pf_wq(void)
+{
+	if (pf2vf_resp_wq) {
+		destroy_workqueue(pf2vf_resp_wq);
+		pf2vf_resp_wq = NULL;
+	}
+}

drivers/firmware/qemu_fw_cfg.c+1−1

@@ -77,7 +77,7 @@ static inline u16 fw_cfg_sel_endianness(u16 key) · 76 unmodified lines
77	static inline void fw_cfg_read_blob(u16 key,	77	static inline void fw_cfg_read_blob(u16 key,
78	void *buf, loff_t pos, size_t count)	78	void *buf, loff_t pos, size_t count)
79	{	79	{
80	u32 glk;	80	u32 glk = -1U;
81	acpi_status status;	81	acpi_status status;
82		82
83	/* If we have ACPI, ensure mutual exclusion against any potential	83	/* If we have ACPI, ensure mutual exclusion against any potential

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

@@ -541,6 +541,7 @@ int amdgpu_bo_set_metadata (struct amdgpu_bo bo, void metadata, · 540 unmodified lines
541	if (!metadata_size) {	541	if (!metadata_size) {
542	if (bo->metadata_size) {	542	if (bo->metadata_size) {
543	kfree(bo->metadata);	543	kfree(bo->metadata);
		544	bo->metadata = NULL;
544	bo->metadata_size = 0;	545	bo->metadata_size = 0;
545	}	546	}
546	return 0;	547	return 0;

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

 	    && (mode->crtc_vsync_start < (mode->crtc_vdisplay + 2)))
 		adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + 2;
+	/* vertical FP must be at least 1 */
+	if (mode->crtc_vsync_start == mode->crtc_vdisplay)
+		adjusted_mode->crtc_vsync_start++;
 	/* get the native mode for scaling */
 	if (amdgpu_encoder->active_device & (ATOM_DEVICE_LCD_SUPPORT))
 		amdgpu_panel_mode_fixup(encoder, adjusted_mode);

drivers/gpu/drm/i915/i915_drv.c+31−1

@@ -792,7 +792,7 @@ static int i915_drm_resume(struct drm_device *dev) · 791 unmodified lines
792	static int i915_drm_resume_early(struct drm_device *dev)	792	static int i915_drm_resume_early(struct drm_device *dev)
793	{	793	{
794	struct drm_i915_private *dev_priv = dev->dev_private;	794	struct drm_i915_private *dev_priv = dev->dev_private;
795	int ret = 0;	795	int ret;
796		796
797	/*	797	/*
798	* We have a resume ordering issue with the snd-hda driver also	798	* We have a resume ordering issue with the snd-hda driver also
@@ -803,6 +803,36 @@ static int i915_drm_resume_early(struct drm_device *dev) · 4 unmodified lines
803	* FIXME: This should be solved with a special hdmi sink device or	803	* FIXME: This should be solved with a special hdmi sink device or
804	* similar so that power domains can be employed.	804	* similar so that power domains can be employed.
805	*/	805	*/
		806
		807	/*
		808	* Note that we need to set the power state explicitly, since we
		809	* powered off the device during freeze and the PCI core won't power
		810	* it back up for us during thaw. Powering off the device during
		811	* freeze is not a hard requirement though, and during the
		812	* suspend/resume phases the PCI core makes sure we get here with the
		813	* device powered on. So in case we change our freeze logic and keep
		814	* the device powered we can also remove the following set power state
		815	* call.
		816	*/
		817	ret = pci_set_power_state(dev->pdev, PCI_D0);
		818	if (ret) {
		819	DRM_ERROR("failed to set PCI D0 power state (%d)\n", ret);
		820	goto out;
		821	}
		822
		823	/*
		824	* Note that pci_enable_device() first enables any parent bridge
		825	* device and only then sets the power state for this device. The
		826	* bridge enabling is a nop though, since bridge devices are resumed
		827	* first. The order of enabling power and enabling the device is
		828	* imposed by the PCI core as described above, so here we preserve the
		829	* same order for the freeze/thaw phases.
		830	*
		831	* TODO: eventually we should remove pci_disable_device() /
		832	* pci_enable_enable_device() from suspend/resume. Due to how they
		833	* depend on the device enable refcount we can't anyway depend on them
		834	* disabling/enabling the device.
		835	*/
806	if (pci_enable_device(dev->pdev)) {	836	if (pci_enable_device(dev->pdev)) {
807	ret = -EIO;	837	ret = -EIO;
808	goto out;	838	goto out;

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

 #define GEN6_RP_STATE_CAP	_MMIO(MCHBAR_MIRROR_BASE_SNB + 0x5998)
 #define BXT_RP_STATE_CAP        _MMIO(0x138170)
-#define INTERVAL_1_28_US(us)	(((us) * 100) >> 7)
+/*
+ * Make these a multiple of magic 25 to avoid SNB (eg. Dell XPS
+ * 8300) freezing up around GPU hangs. Looks as if even
+ * scheduling/timer interrupts start misbehaving if the RPS
+ * EI/thresholds are "bad", leading to a very sluggish or even
+ * frozen machine.
+ */
+#define INTERVAL_1_28_US(us)	roundup(((us) * 100) >> 7, 25)
 #define INTERVAL_1_33_US(us)	(((us) * 3)   >> 2)
 #define INTERVAL_0_833_US(us)	(((us) * 6) / 5)
 #define GT_INTERVAL_FROM_US(dev_priv, us) (IS_GEN9(dev_priv) ? \

drivers/gpu/drm/i915/intel_ddi.c+13−9

@@ -443,9 +443,17 @@ void intel_prepare_ddi_buffer(struct intel_encoder *encoder) · 442 unmodified lines
443	} else if (IS_BROADWELL(dev_priv)) {	443	} else if (IS_BROADWELL(dev_priv)) {
444	ddi_translations_fdi = bdw_ddi_translations_fdi;	444	ddi_translations_fdi = bdw_ddi_translations_fdi;
445	ddi_translations_dp = bdw_ddi_translations_dp;	445	ddi_translations_dp = bdw_ddi_translations_dp;
446	ddi_translations_edp = bdw_ddi_translations_edp;	446
		447	if (dev_priv->edp_low_vswing) {
		448	ddi_translations_edp = bdw_ddi_translations_edp;
		449	n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_edp);
		450	} else {
		451	ddi_translations_edp = bdw_ddi_translations_dp;
		452	n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
		453	}
		454
447	ddi_translations_hdmi = bdw_ddi_translations_hdmi;	455	ddi_translations_hdmi = bdw_ddi_translations_hdmi;
448	n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_edp);	456
449	n_dp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);	457	n_dp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
450	n_hdmi_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi);	458	n_hdmi_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi);
451	hdmi_default_entry = 7;	459	hdmi_default_entry = 7;
@@ -3201,12 +3209,6 @@ void intel_ddi_get_config(struct intel_encoder *encoder, · 2749 unmodified lines
3201	intel_ddi_clock_get(encoder, pipe_config);	3209	intel_ddi_clock_get(encoder, pipe_config);
3202	}	3210	}
3203		3211
3204	static void intel_ddi_destroy(struct drm_encoder *encoder)
3205	{
3206	/* HDMI has nothing special to destroy, so we can go with this. */
3207	intel_dp_encoder_destroy(encoder);
3208	}
3209
3210	static bool intel_ddi_compute_config(struct intel_encoder *encoder,	3212	static bool intel_ddi_compute_config(struct intel_encoder *encoder,
3211	struct intel_crtc_state *pipe_config)	3213	struct intel_crtc_state *pipe_config)
3212	{	3214	{
@@ -3225,7 +3227,8 @@ static bool intel_ddi_compute_config(struct intel_encoder *encoder, · 12 unmodified lines
3225	}	3227	}
3226		3228
3227	static const struct drm_encoder_funcs intel_ddi_funcs = {	3229	static const struct drm_encoder_funcs intel_ddi_funcs = {
3228	.destroy = intel_ddi_destroy,	3230	.reset = intel_dp_encoder_reset,
		3231	.destroy = intel_dp_encoder_destroy,
3229	};	3232	};
3230		3233
3231	static struct intel_connector *	3234	static struct intel_connector *
@@ -3324,6 +3327,7 @@ void intel_ddi_init(struct drm_device *dev, enum port port) · 92 unmodified lines
3324	intel_encoder->post_disable = intel_ddi_post_disable;	3327	intel_encoder->post_disable = intel_ddi_post_disable;
3325	intel_encoder->get_hw_state = intel_ddi_get_hw_state;	3328	intel_encoder->get_hw_state = intel_ddi_get_hw_state;
3326	intel_encoder->get_config = intel_ddi_get_config;	3329	intel_encoder->get_config = intel_ddi_get_config;
		3330	intel_encoder->suspend = intel_dp_encoder_suspend;
3327		3331
3328	intel_dig_port->port = port;	3332	intel_dig_port->port = port;
3329	intel_dig_port->saved_port_bits = I915_READ(DDI_BUF_CTL(port)) &	3333	intel_dig_port->saved_port_bits = I915_READ(DDI_BUF_CTL(port)) &

drivers/gpu/drm/i915/intel_display.c+3−0

@@ -13351,6 +13351,9 @@ static int intel_atomic_prepare_commit(struct drm_device *dev, · 13350 unmodified lines
13351	}	13351	}
13352		13352
13353	for_each_crtc_in_state(state, crtc, crtc_state, i) {	13353	for_each_crtc_in_state(state, crtc, crtc_state, i) {
		13354	if (state->legacy_cursor_update)
		13355	continue;
		13356
13354	ret = intel_crtc_wait_for_pending_flips(crtc);	13357	ret = intel_crtc_wait_for_pending_flips(crtc);
13355	if (ret)	13358	if (ret)
13356	return ret;	13359	return ret;

drivers/gpu/drm/i915/intel_dp.c+2−2

@@ -4898,7 +4898,7 @@ void intel_dp_encoder_destroy(struct drm_encoder *encoder) · 4897 unmodified lines
4898	kfree(intel_dig_port);	4898	kfree(intel_dig_port);
4899	}	4899	}
4900		4900
4901	static void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)	4901	void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
4902	{	4902	{
4903	struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);	4903	struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
4904		4904
@@ -4940,7 +4940,7 @@ static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp) · 35 unmodified lines
4940	edp_panel_vdd_schedule_off(intel_dp);	4940	edp_panel_vdd_schedule_off(intel_dp);
4941	}	4941	}
4942		4942
4943	static void intel_dp_encoder_reset(struct drm_encoder *encoder)	4943	void intel_dp_encoder_reset(struct drm_encoder *encoder)
4944	{	4944	{
4945	struct intel_dp *intel_dp;	4945	struct intel_dp *intel_dp;
4946		4946

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

 void intel_dp_start_link_train(struct intel_dp *intel_dp);
 void intel_dp_stop_link_train(struct intel_dp *intel_dp);
 void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode);
+void intel_dp_encoder_reset(struct drm_encoder *encoder);
+void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder);
 void intel_dp_encoder_destroy(struct drm_encoder *encoder);
 int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc);
 bool intel_dp_compute_config(struct intel_encoder *encoder,

drivers/gpu/drm/i915/intel_hdmi.c+10−2

 				hdmi_to_dig_port(intel_hdmi));
 	}
-	if (!live_status)
+	if (!live_status) {
-		DRM_DEBUG_KMS("Live status not up!");
+		DRM_DEBUG_KMS("HDMI live status down\n");
+		/*
+		 * Live status register is not reliable on all intel platforms.
+		 * So consider live_status only for certain platforms, for
+		 * others, read EDID to determine presence of sink.
+		 */
+		if (INTEL_INFO(dev_priv)->gen < 7 || IS_IVYBRIDGE(dev_priv))
+			live_status = true;
+	}
 	intel_hdmi_unset_edid(connector);

drivers/gpu/drm/radeon/atombios_encoders.c+4−0

 	    && (mode->crtc_vsync_start < (mode->crtc_vdisplay + 2)))
 		adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + 2;
+	/* vertical FP must be at least 1 */
+	if (mode->crtc_vsync_start == mode->crtc_vdisplay)
+		adjusted_mode->crtc_vsync_start++;
 	/* get the native mode for scaling */
 	if (radeon_encoder->active_device & (ATOM_DEVICE_LCD_SUPPORT)) {
 		radeon_panel_mode_fixup(encoder, adjusted_mode);

drivers/gpu/ipu-v3/ipu-common.c+6−1

 			goto err_register;
 		}
-		pdev->dev.of_node = of_node;
 		pdev->dev.parent = dev;
 		ret = platform_device_add_data(pdev, &reg->pdata,
 			platform_device_put(pdev);
 			goto err_register;
 		}
+		/*
+		 * Set of_node only after calling platform_device_add. Otherwise
+		 * the platform:imx-ipuv3-crtc modalias won't be used.
+		 */
+		pdev->dev.of_node = of_node;
 	}
 	return 0;

drivers/hv/ring_buffer.c+20−6

  *    there is room for the producer to send the pending packet.
  */
-static bool hv_need_to_signal_on_read(u32 prev_write_sz,
+static bool hv_need_to_signal_on_read(struct hv_ring_buffer_info *rbi)
-				      struct hv_ring_buffer_info *rbi)
 {
 	u32 cur_write_sz;
 	u32 r_size;
-	u32 write_loc = rbi->ring_buffer->write_index;
+	u32 write_loc;
 	u32 read_loc = rbi->ring_buffer->read_index;
-	u32 pending_sz = rbi->ring_buffer->pending_send_sz;
+	u32 pending_sz;
+	/*
+	 * Issue a full memory barrier before making the signaling decision.
+	 * Here is the reason for having this barrier:
+	 * If the reading of the pend_sz (in this function)
+	 * were to be reordered and read before we commit the new read
+	 * index (in the calling function)  we could
+	 * have a problem. If the host were to set the pending_sz after we
+	 * have sampled pending_sz and go to sleep before we commit the
+	 * read index, we could miss sending the interrupt. Issue a full
+	 * memory barrier to address this.
+	 */
+	mb();
+	pending_sz = rbi->ring_buffer->pending_send_sz;
+	write_loc = rbi->ring_buffer->write_index;
 	/* If the other end is not blocked on write don't bother. */
 	if (pending_sz == 0)
 		return false;
 	cur_write_sz = write_loc >= read_loc ? r_size - (write_loc - read_loc) :
 			read_loc - write_loc;
-	if ((prev_write_sz < pending_sz) && (cur_write_sz >= pending_sz))
+	if (cur_write_sz >= pending_sz)
 		return true;
 	return false;
 	/* Update the read index */
 	hv_set_next_read_location(inring_info, next_read_location);
-	*signal = hv_need_to_signal_on_read(bytes_avail_towrite, inring_info);
+	*signal = hv_need_to_signal_on_read(inring_info);
 	return ret;
 }

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

@@ -451,6 +451,8 @@ static int at91_adc_probe(struct platform_device *pdev) · 450 unmodified lines
451	if (ret)	451	if (ret)
452	goto vref_disable;	452	goto vref_disable;
453		453
		454	platform_set_drvdata(pdev, indio_dev);
		455
454	ret = iio_device_register(indio_dev);	456	ret = iio_device_register(indio_dev);
455	if (ret < 0)	457	if (ret < 0)
456	goto per_clk_disable_unprepare;	458	goto per_clk_disable_unprepare;

drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c+27−3

 	return 0;
 }
+static const char *inv_mpu_match_acpi_device(struct device *dev, int *chip_id)
+{
+	const struct acpi_device_id *id;
+	id = acpi_match_device(dev->driver->acpi_match_table, dev);
+	if (!id)
+		return NULL;
+	*chip_id = (int)id->driver_data;
+	return dev_name(dev);
+}
 /**
  *  inv_mpu_probe() - probe function.
  *  @client:          i2c client.
 			 const struct i2c_device_id *id)
 {
 	struct inv_mpu6050_state *st;
-	int result;
+	int result, chip_type;
-	const char *name = id ? id->name : NULL;
 	struct regmap *regmap;
+	const char *name;
 	if (!i2c_check_functionality(client->adapter,
 				     I2C_FUNC_SMBUS_I2C_BLOCK))
 		return -EOPNOTSUPP;
+	if (id) {
+		chip_type = (int)id->driver_data;
+		name = id->name;
+	} else if (ACPI_HANDLE(&client->dev)) {
+		name = inv_mpu_match_acpi_device(&client->dev, &chip_type);
+		if (!name)
+			return -ENODEV;
+	} else {
+		return -ENOSYS;
+	}
 	regmap = devm_regmap_init_i2c(client, &inv_mpu_regmap_config);
 	if (IS_ERR(regmap)) {
 		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
 	}
 	result = inv_mpu_core_probe(regmap, client->irq, name,
-				    NULL, id->driver_data);
+				    NULL, chip_type);
 	if (result < 0)
 		return result;

drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c+2−1

 	struct regmap *regmap;
 	const struct spi_device_id *id = spi_get_device_id(spi);
 	const char *name = id ? id->name : NULL;
+	const int chip_type = id ? id->driver_data : 0;
 	regmap = devm_regmap_init_spi(spi, &inv_mpu_regmap_config);
 	if (IS_ERR(regmap)) {
 	}
 	return inv_mpu_core_probe(regmap, spi->irq, name,
-				  inv_mpu_i2c_disable, id->driver_data);
+				  inv_mpu_i2c_disable, chip_type);
 }
 static int inv_mpu_remove(struct spi_device *spi)

drivers/iio/magnetometer/ak8975.c+3−3

 	int rc;
 	int irq;
+	init_waitqueue_head(&data->data_ready_queue);
+	clear_bit(0, &data->flags);
 	if (client->irq)
 		irq = client->irq;
 	else
 		return rc;
 	}
-	init_waitqueue_head(&data->data_ready_queue);
-	clear_bit(0, &data->flags);
 	data->eoc_irq = irq;
 	return rc;
 	int eoc_gpio;
 	int err;
 	const char *name = NULL;
-	enum asahi_compass_chipset chipset;
+	enum asahi_compass_chipset chipset = AK_MAX_TYPE;
 	/* Grab and set up the supplied GPIO. */
 	if (client->dev.platform_data)

drivers/infiniband/ulp/iser/iscsi_iser.c+10−4

 	struct Scsi_Host *shost;
 	struct iser_conn *iser_conn = NULL;
 	struct ib_conn *ib_conn;
+	u32 max_fr_sectors;
 	u16 max_cmds;
 	shost = iscsi_host_alloc(&iscsi_iser_sht, 0, 0);
 		iser_conn = ep->dd_data;
 		max_cmds = iser_conn->max_cmds;
 		shost->sg_tablesize = iser_conn->scsi_sg_tablesize;
-		shost->max_sectors = iser_conn->scsi_max_sectors;
 		mutex_lock(&iser_conn->state_mutex);
 		if (iser_conn->state != ISER_CONN_UP) {
 		 */
 		shost->sg_tablesize = min_t(unsigned short, shost->sg_tablesize,
 			ib_conn->device->ib_device->attrs.max_fast_reg_page_list_len);
-		shost->max_sectors = min_t(unsigned int,
-			1024, (shost->sg_tablesize * PAGE_SIZE) >> 9);
 		if (iscsi_host_add(shost,
 				   ib_conn->device->ib_device->dma_device)) {
 			goto free_host;
 	}
+	/*
+	 * FRs or FMRs can only map up to a (device) page per entry, but if the
+	 * first entry is misaligned we'll end up using using two entries
+	 * (head and tail) for a single page worth data, so we have to drop
+	 * one segment from the calculation.
+	 */
+	max_fr_sectors = ((shost->sg_tablesize - 1) * PAGE_SIZE) >> 9;
+	shost->max_sectors = min(iser_max_sectors, max_fr_sectors);
 	if (cmds_max > max_cmds) {
 		iser_info("cmds_max changed from %u to %u\n",
 			  cmds_max, max_cmds);
 	.queuecommand           = iscsi_queuecommand,
 	.change_queue_depth	= scsi_change_queue_depth,
 	.sg_tablesize           = ISCSI_ISER_DEF_SG_TABLESIZE,
-	.max_sectors            = ISER_DEF_MAX_SECTORS,
 	.cmd_per_lun            = ISER_DEF_CMD_PER_LUN,
 	.eh_abort_handler       = iscsi_eh_abort,
 	.eh_device_reset_handler= iscsi_eh_device_reset,

drivers/input/misc/twl6040-vibra.c+8−8

 {
 	struct vibra_info *info = container_of(work,
 				struct vibra_info, play_work);
+	int ret;
+	/* Do not allow effect, while the routing is set to use audio */
+	ret = twl6040_get_vibralr_status(info->twl6040);
+	if (ret & TWL6040_VIBSEL) {
+		dev_info(info->dev, "Vibra is configured for audio\n");
+		return;
+	}
 	mutex_lock(&info->mutex);
 		      struct ff_effect *effect)
 {
 	struct vibra_info *info = input_get_drvdata(input);
-	int ret;
-	/* Do not allow effect, while the routing is set to use audio */
-	ret = twl6040_get_vibralr_status(info->twl6040);
-	if (ret & TWL6040_VIBSEL) {
-		dev_info(&input->dev, "Vibra is configured for audio\n");
-		return -EBUSY;
-	}
 	info->weak_speed = effect->u.rumble.weak_magnitude;
 	info->strong_speed = effect->u.rumble.strong_magnitude;

drivers/input/touchscreen/atmel_mxt_ts.c+14−14

 	return 0;
 }
+static int mxt_acquire_irq(struct mxt_data *data)
+{
+	int error;
+	enable_irq(data->irq);
+	error = mxt_process_messages_until_invalid(data);
+	if (error)
+		return error;
+	return 0;
+}
 static int mxt_soft_reset(struct mxt_data *data)
 {
 	struct device *dev = &data->client->dev;
 	/* Ignore CHG line for 100ms after reset */
 	msleep(100);
-	enable_irq(data->irq);
+	mxt_acquire_irq(data);
 	ret = mxt_wait_for_completion(data, &data->reset_completion,
 				      MXT_RESET_TIMEOUT);
 	return ret;
 }
-static int mxt_acquire_irq(struct mxt_data *data)
-{
-	int error;
-	enable_irq(data->irq);
-	error = mxt_process_messages_until_invalid(data);
-	if (error)
-		return error;
-	return 0;
-}
 static int mxt_get_info(struct mxt_data *data)
 {
 	struct i2c_client *client = data->client;

drivers/input/touchscreen/zforce_ts.c+2−2

@@ -370,8 +370,8 @@ static int zforce_touch_event(struct zforce_ts ts, u8 payload) · 369 unmodified lines
370	point.coord_x = point.coord_y = 0;	370	point.coord_x = point.coord_y = 0;
371	}	371	}
372		372
373	point.state = payload[9 * i + 5] & 0x03;	373	point.state = payload[9 * i + 5] & 0x0f;
374	point.id = (payload[9 * i + 5] & 0xfc) >> 2;	374	point.id = (payload[9 * i + 5] & 0xf0) >> 4;
375		375
376	/* determine touch major, minor and orientation */	376	/* determine touch major, minor and orientation */
377	point.area_major = max(payload[9 * i + 6],	377	point.area_major = max(payload[9 * i + 6],

drivers/media/media-device.c+4−4

 }
 EXPORT_SYMBOL_GPL(media_device_find_devres);
+#if IS_ENABLED(CONFIG_PCI)
 void media_device_pci_init(struct media_device *mdev,
 			   struct pci_dev *pci_dev,
 			   const char *name)
 {
-#ifdef CONFIG_PCI
 	mdev->dev = &pci_dev->dev;
 	if (name)
 	mdev->driver_version = LINUX_VERSION_CODE;
 	media_device_init(mdev);
-#endif
 }
 EXPORT_SYMBOL_GPL(media_device_pci_init);
+#endif
+#if IS_ENABLED(CONFIG_USB)
 void __media_device_usb_init(struct media_device *mdev,
 			     struct usb_device *udev,
 			     const char *board_name,
 			     const char *driver_name)
 {
-#ifdef CONFIG_USB
 	mdev->dev = &udev->dev;
 	if (driver_name)
 	mdev->driver_version = LINUX_VERSION_CODE;
 	media_device_init(mdev);
-#endif
 }
 EXPORT_SYMBOL_GPL(__media_device_usb_init);
+#endif
 #endif /* CONFIG_MEDIA_CONTROLLER */

drivers/media/platform/exynos4-is/media-dev.c+2−11

 	platform_set_drvdata(pdev, fmd);
-	/* Protect the media graph while we're registering entities */
-	mutex_lock(&fmd->media_dev.graph_mutex);
 	ret = fimc_md_register_platform_entities(fmd, dev->of_node);
-	if (ret) {
+	if (ret)
-		mutex_unlock(&fmd->media_dev.graph_mutex);
 		goto err_clk;
-	}
 	ret = fimc_md_register_sensor_entities(fmd);
-	if (ret) {
+	if (ret)
-		mutex_unlock(&fmd->media_dev.graph_mutex);
 		goto err_m_ent;
-	}
-	mutex_unlock(&fmd->media_dev.graph_mutex);
 	ret = device_create_file(&pdev->dev, &dev_attr_subdev_conf_mode);
 	if (ret)

drivers/media/platform/s3c-camif/camif-core.c+3−9

 	if (ret < 0)
 		goto err_sens;
-	mutex_lock(&camif->media_dev.graph_mutex);
 	ret = v4l2_device_register_subdev_nodes(&camif->v4l2_dev);
 	if (ret < 0)
-		goto err_unlock;
+		goto err_sens;
 	ret = camif_register_video_nodes(camif);
 	if (ret < 0)
-		goto err_unlock;
+		goto err_sens;
 	ret = camif_create_media_links(camif);
 	if (ret < 0)
-		goto err_unlock;
+		goto err_sens;
-	mutex_unlock(&camif->media_dev.graph_mutex);
 	ret = media_device_register(&camif->media_dev);
 	if (ret < 0)
 	pm_runtime_put(dev);
 	return 0;
-err_unlock:
-	mutex_unlock(&camif->media_dev.graph_mutex);
 err_sens:
 	v4l2_device_unregister(&camif->v4l2_dev);
 	media_device_unregister(&camif->media_dev);

drivers/misc/mic/vop/vop_vringh.c+5−0

 			ret = -EFAULT;
 			goto free_ret;
 		}
+		/* Ensure desc has not changed between the two reads */
+		if (memcmp(&dd, dd_config, sizeof(dd))) {
+			ret = -EINVAL;
+			goto free_ret;
+		}
 		mutex_lock(&vdev->vdev_mutex);
 		mutex_lock(&vi->vop_mutex);
 		ret = vop_virtio_add_device(vdev, dd_config);

drivers/net/ethernet/apm/xgene/xgene_enet_main.c+4−3

 	ret = xgene_enet_init_hw(pdata);
 	if (ret)
-		goto err;
+		goto err_netdev;
 	mac_ops = pdata->mac_ops;
 	if (pdata->phy_mode == PHY_INTERFACE_MODE_RGMII) {
 		ret = xgene_enet_mdio_config(pdata);
 		if (ret)
-			goto err;
+			goto err_netdev;
 	} else {
 		INIT_DELAYED_WORK(&pdata->link_work, mac_ops->link_state);
 	}
 	xgene_enet_napi_add(pdata);
 	return 0;
-err:
+err_netdev:
 	unregister_netdev(ndev);
+err:
 	free_netdev(ndev);
 	return ret;
 }

drivers/net/ethernet/broadcom/bnxt/bnxt.c+19−4

@@ -1439,6 +1439,10 @@ static int bnxt_poll_work(struct bnxt bp, struct bnxt_napi bnapi, int budget) · 1438 unmodified lines
1439	if (!TX_CMP_VALID(txcmp, raw_cons))	1439	if (!TX_CMP_VALID(txcmp, raw_cons))
1440	break;	1440	break;
1441		1441
		1442	/* The valid test of the entry must be done first before
		1443	* reading any further.
		1444	*/
		1445	rmb();
1442	if (TX_CMP_TYPE(txcmp) == CMP_TYPE_TX_L2_CMP) {	1446	if (TX_CMP_TYPE(txcmp) == CMP_TYPE_TX_L2_CMP) {
1443	tx_pkts++;	1447	tx_pkts++;
1444	/* return full budget so NAPI will complete. */	1448	/* return full budget so NAPI will complete. */
@@ -4096,9 +4100,11 @@ static int bnxt_alloc_rfs_vnics(struct bnxt *bp) · 2651 unmodified lines
4096	}	4100	}
4097		4101
4098	static int bnxt_cfg_rx_mode(struct bnxt *);	4102	static int bnxt_cfg_rx_mode(struct bnxt *);
		4103	static bool bnxt_mc_list_updated(struct bnxt , u32 );
4099		4104
4100	static int bnxt_init_chip(struct bnxt *bp, bool irq_re_init)	4105	static int bnxt_init_chip(struct bnxt *bp, bool irq_re_init)
4101	{	4106	{
		4107	struct bnxt_vnic_info *vnic = &bp->vnic_info[0];
4102	int rc = 0;	4108	int rc = 0;
4103		4109
4104	if (irq_re_init) {	4110	if (irq_re_init) {
@@ -4154,13 +4160,22 @@ static int bnxt_init_chip(struct bnxt *bp, bool irq_re_init) · 49 unmodified lines
4154	netdev_err(bp->dev, "HWRM vnic filter failure rc: %x\n", rc);	4160	netdev_err(bp->dev, "HWRM vnic filter failure rc: %x\n", rc);
4155	goto err_out;	4161	goto err_out;
4156	}	4162	}
4157	bp->vnic_info[0].uc_filter_count = 1;	4163	vnic->uc_filter_count = 1;
4158		4164
4159	bp->vnic_info[0].rx_mask = CFA_L2_SET_RX_MASK_REQ_MASK_BCAST;	4165	vnic->rx_mask = CFA_L2_SET_RX_MASK_REQ_MASK_BCAST;
4160		4166
4161	if ((bp->dev->flags & IFF_PROMISC) && BNXT_PF(bp))	4167	if ((bp->dev->flags & IFF_PROMISC) && BNXT_PF(bp))
4162	bp->vnic_info[0].rx_mask \|=	4168	vnic->rx_mask \|= CFA_L2_SET_RX_MASK_REQ_MASK_PROMISCUOUS;
4163	CFA_L2_SET_RX_MASK_REQ_MASK_PROMISCUOUS;	4169
		4170	if (bp->dev->flags & IFF_ALLMULTI) {
		4171	vnic->rx_mask \|= CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST;
		4172	vnic->mc_list_count = 0;
		4173	} else {
		4174	u32 mask = 0;
		4175
		4176	bnxt_mc_list_updated(bp, &mask);
		4177	vnic->rx_mask \|= mask;
		4178	}
4164		4179
4165	rc = bnxt_cfg_rx_mode(bp);	4180	rc = bnxt_cfg_rx_mode(bp);
4166	if (rc)	4181	if (rc)

drivers/net/ethernet/freescale/fec_main.c+8−2

@@ -1521,9 +1521,15 @@ fec_enet_rx(struct net_device *ndev, int budget) · 1520 unmodified lines
1521	struct fec_enet_private *fep = netdev_priv(ndev);	1521	struct fec_enet_private *fep = netdev_priv(ndev);
1522		1522
1523	for_each_set_bit(queue_id, &fep->work_rx, FEC_ENET_MAX_RX_QS) {	1523	for_each_set_bit(queue_id, &fep->work_rx, FEC_ENET_MAX_RX_QS) {
1524	clear_bit(queue_id, &fep->work_rx);	1524	int ret;
1525	pkt_received += fec_enet_rx_queue(ndev,	1525
		1526	ret = fec_enet_rx_queue(ndev,
1526	budget - pkt_received, queue_id);	1527	budget - pkt_received, queue_id);
		1528
		1529	if (ret < budget - pkt_received)
		1530	clear_bit(queue_id, &fep->work_rx);
		1531
		1532	pkt_received += ret;
1527	}	1533	}
1528	return pkt_received;	1534	return pkt_received;
1529	}	1535	}

drivers/net/ethernet/mellanox/mlx4/en_rx.c+1−1

@@ -698,7 +698,7 @@ static int get_fixed_ipv6_csum(__wsum hw_checksum, struct sk_buff *skb, · 697 unmodified lines
698		698
699	if (ipv6h->nexthdr == IPPROTO_FRAGMENT \|\| ipv6h->nexthdr == IPPROTO_HOPOPTS)	699	if (ipv6h->nexthdr == IPPROTO_FRAGMENT \|\| ipv6h->nexthdr == IPPROTO_HOPOPTS)
700	return -1;	700	return -1;
701	hw_checksum = csum_add(hw_checksum, (__force __wsum)(ipv6h->nexthdr << 8));	701	hw_checksum = csum_add(hw_checksum, (__force __wsum)htons(ipv6h->nexthdr));
702		702
703	csum_pseudo_hdr = csum_partial(&ipv6h->saddr,	703	csum_pseudo_hdr = csum_partial(&ipv6h->saddr,
704	sizeof(ipv6h->saddr) + sizeof(ipv6h->daddr), 0);	704	sizeof(ipv6h->saddr) + sizeof(ipv6h->daddr), 0);

drivers/net/ethernet/mellanox/mlx5/core/Kconfig+7−1

 	bool "Mellanox Technologies ConnectX-4 Ethernet support"
 	depends on NETDEVICES && ETHERNET && PCI && MLX5_CORE
 	select PTP_1588_CLOCK
-	select VXLAN if MLX5_CORE=y
 	default n
 	---help---
 	  Ethernet support in Mellanox Technologies ConnectX-4 NIC.
 	  This flag is depended on the kernel's DCB support.
 	  If unsure, set to Y
+config MLX5_CORE_EN_VXLAN
+	bool "VXLAN offloads Support"
+	default y
+	depends on MLX5_CORE_EN && VXLAN && !(MLX5_CORE=y && VXLAN=m)
+	---help---
+	  Say Y here if you want to use VXLAN offloads in the driver.

drivers/net/ethernet/mellanox/mlx5/core/Makefile+2−1

@@ -6,6 +6,7 @@ mlx5_core-y := main.o cmd.o debugfs.o fw.o eq.o uar.o pagealloc.o \ · 5 unmodified lines
6		6
7	mlx5_core-$(CONFIG_MLX5_CORE_EN) += wq.o eswitch.o \	7	mlx5_core-$(CONFIG_MLX5_CORE_EN) += wq.o eswitch.o \
8	en_main.o en_fs.o en_ethtool.o en_tx.o en_rx.o \	8	en_main.o en_fs.o en_ethtool.o en_tx.o en_rx.o \
9	en_txrx.o en_clock.o vxlan.o en_tc.o en_arfs.o	9	en_txrx.o en_clock.o en_tc.o en_arfs.o
10		10
		11	mlx5_core-$(CONFIG_MLX5_CORE_EN_VXLAN) += vxlan.o
11	mlx5_core-$(CONFIG_MLX5_CORE_EN_DCB) += en_dcbnl.o	12	mlx5_core-$(CONFIG_MLX5_CORE_EN_DCB) += en_dcbnl.o

drivers/net/ethernet/mellanox/mlx5/core/en.h+5−0

 	struct mlx5e_direct_tir    direct_tir[MLX5E_MAX_NUM_CHANNELS];
 	struct mlx5e_flow_steering fs;
+	struct mlx5e_flow_tables   fts;
+	struct mlx5e_eth_addr_db   eth_addr;
+	struct mlx5e_vlan_db       vlan;
+#ifdef CONFIG_MLX5_CORE_EN_VXLAN
 	struct mlx5e_vxlan_db      vxlan;
+#endif
 	struct mlx5e_params        params;
 	struct workqueue_struct    *wq;

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+3−0

 					    vf_stats);
 }
+#if IS_ENABLED(CONFIG_MLX5_CORE_EN_VXLAN)
 static void mlx5e_add_vxlan_port(struct net_device *netdev,
 				 sa_family_t sa_family, __be16 port)
 {
 	return features;
 }
+#endif
 static const struct net_device_ops mlx5e_netdev_ops_basic = {
 	.ndo_open                = mlx5e_open,
 	.ndo_set_features        = mlx5e_set_features,
 	.ndo_change_mtu          = mlx5e_change_mtu,
 	.ndo_do_ioctl            = mlx5e_ioctl,
+#ifdef CONFIG_MLX5_CORE_EN_VXLAN
 	.ndo_add_vxlan_port      = mlx5e_add_vxlan_port,
 	.ndo_del_vxlan_port      = mlx5e_del_vxlan_port,
 	.ndo_features_check      = mlx5e_features_check,

drivers/net/ethernet/mellanox/mlx5/core/vxlan.h+9−2

 static inline bool mlx5e_vxlan_allowed(struct mlx5_core_dev *mdev)
 {
-	return (MLX5_CAP_ETH(mdev, tunnel_stateless_vxlan) &&
+	return IS_ENABLED(CONFIG_MLX5_CORE_EN_VXLAN) &&
+		(MLX5_CAP_ETH(mdev, tunnel_stateless_vxlan) &&
 		mlx5_core_is_pf(mdev));
 }
+#ifdef CONFIG_MLX5_CORE_EN_VXLAN
 void mlx5e_vxlan_init(struct mlx5e_priv *priv);
+void mlx5e_vxlan_cleanup(struct mlx5e_priv *priv);
+#else
+static inline void mlx5e_vxlan_init(struct mlx5e_priv *priv) {}
+static inline void mlx5e_vxlan_cleanup(struct mlx5e_priv *priv) {}
+#endif
 void mlx5e_vxlan_queue_work(struct mlx5e_priv *priv, sa_family_t sa_family,
 			    u16 port, int add);
 struct mlx5e_vxlan *mlx5e_vxlan_lookup_port(struct mlx5e_priv *priv, u16 port);
-void mlx5e_vxlan_cleanup(struct mlx5e_priv *priv);
 #endif /* __MLX5_VXLAN_H__ */

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

 	lag->ref_count++;
 	return 0;
+err_col_port_enable:
+	mlxsw_sp_lag_col_port_remove(mlxsw_sp_port, lag_id);
 err_col_port_add:
 	if (!lag->ref_count)
 		mlxsw_sp_lag_destroy(mlxsw_sp, lag_id);
-err_col_port_enable:
-	mlxsw_sp_lag_col_port_remove(mlxsw_sp_port, lag_id);
 	return err;
 }

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c+8−0

@@ -214,7 +214,15 @@ static int __mlxsw_sp_port_flood_set(struct mlxsw_sp_port *mlxsw_sp_port, · 213 unmodified lines
214	mlxsw_reg_sftr_pack(sftr_pl, MLXSW_SP_FLOOD_TABLE_BM, idx_begin,	214	mlxsw_reg_sftr_pack(sftr_pl, MLXSW_SP_FLOOD_TABLE_BM, idx_begin,
215	table_type, range, local_port, set);	215	table_type, range, local_port, set);
216	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sftr), sftr_pl);	216	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sftr), sftr_pl);
		217	if (err)
		218	goto err_flood_bm_set;
		219	else
		220	goto buffer_out;
217		221
		222	err_flood_bm_set:
		223	mlxsw_reg_sftr_pack(sftr_pl, MLXSW_SP_FLOOD_TABLE_UC, idx_begin,
		224	table_type, range, local_port, !set);
		225	mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sftr), sftr_pl);
218	buffer_out:	226	buffer_out:
219	kfree(sftr_pl);	227	kfree(sftr_pl);
220	return err;	228	return err;

drivers/net/ethernet/qlogic/netxen/netxen_nic_hw.c+9−5

 {
 	int i, v, addr;
 	__le32 *ptr32;
+	int ret;
 	addr = base;
 	ptr32 = buf;
 	for (i = 0; i < size / sizeof(u32); i++) {
-		if (netxen_rom_fast_read(adapter, addr, &v) == -1)
+		ret = netxen_rom_fast_read(adapter, addr, &v);
-			return -1;
+		if (ret)
+			return ret;
 		*ptr32 = cpu_to_le32(v);
 		ptr32++;
 		addr += sizeof(u32);
 	}
 	if ((char *)buf + size > (char *)ptr32) {
 		__le32 local;
-		if (netxen_rom_fast_read(adapter, addr, &v) == -1)
+		ret = netxen_rom_fast_read(adapter, addr, &v);
-			return -1;
+		if (ret)
+			return ret;
 		local = cpu_to_le32(v);
 		memcpy(ptr32, &local, (char *)buf + size - (char *)ptr32);
 	}
 				if (adapter->phy_read &&
 				    adapter->phy_read(adapter,
 						      NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
-						      &autoneg) != 0)
+						      &autoneg) == 0)
 					adapter->link_autoneg = autoneg;
 			} else
 				goto link_down;

drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c+2−1

 	ptr32 = (__le32 *)&serial_num;
 	offset = NX_FW_SERIAL_NUM_OFFSET;
 	for (i = 0; i < 8; i++) {
-		if (netxen_rom_fast_read(adapter, offset, &val) == -1) {
+		err = netxen_rom_fast_read(adapter, offset, &val);
+		if (err) {
 			dev_err(&pdev->dev, "error reading board info\n");
 			adapter->driver_mismatch = 1;
 			return;

drivers/net/ethernet/qlogic/qede/qede_main.c+3−5

 	u8 xmit_type;
 	u16 idx;
 	u16 hlen;
-	bool data_split;
+	bool data_split = false;
 	/* Get tx-queue context and netdev index */
 	txq_index = skb_get_queue_mapping(skb);
 	edev->q_num_rx_buffers = NUM_RX_BDS_DEF;
 	edev->q_num_tx_buffers = NUM_TX_BDS_DEF;
-	DP_INFO(edev, "Allocated netdev with 64 tx queues and 64 rx queues\n");
 	SET_NETDEV_DEV(ndev, &pdev->dev);
 	memset(&edev->stats, 0, sizeof(edev->stats));
 {
 	struct qed_pf_params pf_params;
-	/* 16 rx + 16 tx */
+	/* 64 rx + 64 tx */
 	memset(&pf_params, 0, sizeof(struct qed_pf_params));
-	pf_params.eth_pf_params.num_cons = 32;
+	pf_params.eth_pf_params.num_cons = 128;
 	qed_ops->common->update_pf_params(cdev, &pf_params);
 }

drivers/net/geneve.c+3−2

 	int gh_len;
 	int err = -ENOSYS;
-	udp_tunnel_gro_complete(skb, nhoff);
 	gh = (struct genevehdr *)(skb->data + nhoff);
 	gh_len = geneve_hlen(gh);
 	type = gh->proto_type;
 		err = ptype->callbacks.gro_complete(skb, nhoff + gh_len);
 	rcu_read_unlock();
+	skb_set_inner_mac_header(skb, nhoff + gh_len);
 	return err;
 }

drivers/net/macsec.c+13−10

  * @tfm: crypto struct, key storage
  */
 struct macsec_key {
-	u64 id;
+	u8 id[MACSEC_KEYID_LEN];
 	struct crypto_aead *tfm;
 };
 	[MACSEC_SA_ATTR_AN] = { .type = NLA_U8 },
 	[MACSEC_SA_ATTR_ACTIVE] = { .type = NLA_U8 },
 	[MACSEC_SA_ATTR_PN] = { .type = NLA_U32 },
-	[MACSEC_SA_ATTR_KEYID] = { .type = NLA_U64 },
+	[MACSEC_SA_ATTR_KEYID] = { .type = NLA_BINARY,
+				   .len = MACSEC_KEYID_LEN, },
 	[MACSEC_SA_ATTR_KEY] = { .type = NLA_BINARY,
 				 .len = MACSEC_MAX_KEY_LEN, },
 };
 			return false;
 	}
+	if (nla_len(attrs[MACSEC_SA_ATTR_KEYID]) != MACSEC_KEYID_LEN)
+		return false;
 	return true;
 }
 	if (tb_sa[MACSEC_SA_ATTR_ACTIVE])
 		rx_sa->active = !!nla_get_u8(tb_sa[MACSEC_SA_ATTR_ACTIVE]);
-	rx_sa->key.id = nla_get_u64(tb_sa[MACSEC_SA_ATTR_KEYID]);
+	nla_memcpy(rx_sa->key.id, tb_sa[MACSEC_SA_ATTR_KEY], MACSEC_KEYID_LEN);
 	rx_sa->sc = rx_sc;
 	rcu_assign_pointer(rx_sc->sa[assoc_num], rx_sa);
 			return false;
 	}
+	if (nla_len(attrs[MACSEC_SA_ATTR_KEYID]) != MACSEC_KEYID_LEN)
+		return false;
 	return true;
 }
 		return -ENOMEM;
 	}
-	tx_sa->key.id = nla_get_u64(tb_sa[MACSEC_SA_ATTR_KEYID]);
+	nla_memcpy(tx_sa->key.id, tb_sa[MACSEC_SA_ATTR_KEY], MACSEC_KEYID_LEN);
 	spin_lock_bh(&tx_sa->lock);
 	tx_sa->next_pn = nla_get_u32(tb_sa[MACSEC_SA_ATTR_PN]);
 		if (nla_put_u8(skb, MACSEC_SA_ATTR_AN, i) ||
 		    nla_put_u32(skb, MACSEC_SA_ATTR_PN, tx_sa->next_pn) ||
-		    nla_put_u64_64bit(skb, MACSEC_SA_ATTR_KEYID,
+		    nla_put(skb, MACSEC_SA_ATTR_KEYID, MACSEC_KEYID_LEN, tx_sa->key.id) ||
-				      tx_sa->key.id,
-				      MACSEC_SA_ATTR_PAD) ||
 		    nla_put_u8(skb, MACSEC_SA_ATTR_ACTIVE, tx_sa->active)) {
 			nla_nest_cancel(skb, txsa_nest);
 			nla_nest_cancel(skb, txsa_list);
 			if (nla_put_u8(skb, MACSEC_SA_ATTR_AN, i) ||
 			    nla_put_u32(skb, MACSEC_SA_ATTR_PN, rx_sa->next_pn) ||
-			    nla_put_u64_64bit(skb, MACSEC_SA_ATTR_KEYID,
+			    nla_put(skb, MACSEC_SA_ATTR_KEYID, MACSEC_KEYID_LEN, rx_sa->key.id) ||
-					      rx_sa->key.id,
-					      MACSEC_SA_ATTR_PAD) ||
 			    nla_put_u8(skb, MACSEC_SA_ATTR_ACTIVE, rx_sa->active)) {
 				nla_nest_cancel(skb, rxsa_nest);
 				nla_nest_cancel(skb, rxsc_nest);

drivers/net/macvtap.c+1−1

@@ -384,7 +384,7 @@ static rx_handler_result_t macvtap_handle_frame(struct sk_buff **pskb) · 383 unmodified lines
384	goto wake_up;	384	goto wake_up;
385	}	385	}
386		386
387	kfree_skb(skb);	387	consume_skb(skb);
388	while (segs) {	388	while (segs) {
389	struct sk_buff *nskb = segs->next;	389	struct sk_buff *nskb = segs->next;
390		390

drivers/net/vxlan.c+3−2

@@ -613,8 +613,9 @@ out: · 612 unmodified lines
613		613
614	static int vxlan_gro_complete(struct sock sk, struct sk_buff skb, int nhoff)	614	static int vxlan_gro_complete(struct sock sk, struct sk_buff skb, int nhoff)
615	{	615	{
616	udp_tunnel_gro_complete(skb, nhoff);	616	/* Sets 'skb->inner_mac_header' since we are always called with
617		617	* 'skb->encapsulation' set.
		618	*/
618	return eth_gro_complete(skb, nhoff + sizeof(struct vxlanhdr));	619	return eth_gro_complete(skb, nhoff + sizeof(struct vxlanhdr));
619	}	620	}
620		621

drivers/nvdimm/pmem.c+10−3

 	 */
 	start += start_pad;
 	npfns = (pmem->size - start_pad - end_trunc - SZ_8K) / SZ_4K;
-	if (nd_pfn->mode == PFN_MODE_PMEM)
+	if (nd_pfn->mode == PFN_MODE_PMEM) {
-		offset = ALIGN(start + SZ_8K + 64 * npfns, nd_pfn->align)
+		unsigned long memmap_size;
+		/*
+		 * vmemmap_populate_hugepages() allocates the memmap array in
+		 * HPAGE_SIZE chunks.
+		 */
+		memmap_size = ALIGN(64 * npfns, HPAGE_SIZE);
+		offset = ALIGN(start + SZ_8K + memmap_size, nd_pfn->align)
 			- start;
-	else if (nd_pfn->mode == PFN_MODE_RAM)
+	} else if (nd_pfn->mode == PFN_MODE_RAM)
 		offset = ALIGN(start + SZ_8K, nd_pfn->align) - start;
 	else
 		goto err;

drivers/nvmem/mxs-ocotp.c+2−2

@@ -94,7 +94,7 @@ static int mxs_ocotp_read(void context, const void reg, size_t reg_size, · 93 unmodified lines
94	if (ret)	94	if (ret)
95	goto close_banks;	95	goto close_banks;
96		96
97	while (val_size) {	97	while (val_size >= reg_size) {
98	if ((offset < OCOTP_DATA_OFFSET) \|\| (offset % 16)) {	98	if ((offset < OCOTP_DATA_OFFSET) \|\| (offset % 16)) {
99	/* fill up non-data register */	99	/* fill up non-data register */
100	*buf = 0;	100	*buf = 0;
@@ -103,7 +103,7 @@ static int mxs_ocotp_read(void context, const void reg, size_t reg_size, · 2 unmodified lines
103	}	103	}
104		104
105	buf++;	105	buf++;
106	val_size--;	106	val_size -= reg_size;
107	offset += reg_size;	107	offset += reg_size;
108	}	108	}
109		109

drivers/rapidio/devices/rio_mport_cdev.c+64−51

 	struct list_head node;
 	struct mport_dev *md;
 	enum rio_mport_map_dir dir;
-	u32 rioid;
+	u16 rioid;
 	u64 rio_addr;
 	dma_addr_t phys_addr; /* for mmap */
 	void *virt_addr; /* kernel address, for dma_free_coherent */
 struct rio_mport_dma_map {
 	int valid;
-	uint64_t length;
+	u64 length;
 	void *vaddr;
 	dma_addr_t paddr;
 };
 	struct kfifo            event_fifo;
 	wait_queue_head_t       event_rx_wait;
 	spinlock_t              fifo_lock;
-	unsigned int            event_mask; /* RIO_DOORBELL, RIO_PORTWRITE */
+	u32			event_mask; /* RIO_DOORBELL, RIO_PORTWRITE */
 #ifdef CONFIG_RAPIDIO_DMA_ENGINE
 	struct dma_chan		*dmach;
 	struct list_head	async_list;
 		return -EFAULT;
 	if ((maint_io.offset % 4) ||
-	    (maint_io.length == 0) || (maint_io.length % 4))
+	    (maint_io.length == 0) || (maint_io.length % 4) ||
+	    (maint_io.length + maint_io.offset) > RIO_MAINT_SPACE_SZ)
 		return -EINVAL;
 	buffer = vmalloc(maint_io.length);
 		offset += 4;
 	}
-	if (unlikely(copy_to_user(maint_io.buffer, buffer, maint_io.length)))
+	if (unlikely(copy_to_user((void __user *)(uintptr_t)maint_io.buffer,
+				   buffer, maint_io.length)))
 		ret = -EFAULT;
 out:
 	vfree(buffer);
 		return -EFAULT;
 	if ((maint_io.offset % 4) ||
-	    (maint_io.length == 0) || (maint_io.length % 4))
+	    (maint_io.length == 0) || (maint_io.length % 4) ||
+	    (maint_io.length + maint_io.offset) > RIO_MAINT_SPACE_SZ)
 		return -EINVAL;
 	buffer = vmalloc(maint_io.length);
 		return -ENOMEM;
 	length = maint_io.length;
-	if (unlikely(copy_from_user(buffer, maint_io.buffer, length))) {
+	if (unlikely(copy_from_user(buffer,
+			(void __user *)(uintptr_t)maint_io.buffer, length))) {
 		ret = -EFAULT;
 		goto out;
 	}
  */
 static int
 rio_mport_create_outbound_mapping(struct mport_dev *md, struct file *filp,
-				  u32 rioid, u64 raddr, u32 size,
+				  u16 rioid, u64 raddr, u32 size,
 				  dma_addr_t *paddr)
 {
 	struct rio_mport *mport = md->mport;
 	rmcd_debug(OBW, "did=%d ra=0x%llx sz=0x%x", rioid, raddr, size);
-	map = kzalloc(sizeof(struct rio_mport_mapping), GFP_KERNEL);
+	map = kzalloc(sizeof(*map), GFP_KERNEL);
 	if (map == NULL)
 		return -ENOMEM;
 static int
 rio_mport_get_outbound_mapping(struct mport_dev *md, struct file *filp,
-			       u32 rioid, u64 raddr, u32 size,
+			       u16 rioid, u64 raddr, u32 size,
 			       dma_addr_t *paddr)
 {
 	struct rio_mport_mapping *map;
 	dma_addr_t paddr;
 	int ret;
-	if (unlikely(copy_from_user(&map, arg, sizeof(struct rio_mmap))))
+	if (unlikely(copy_from_user(&map, arg, sizeof(map))))
 		return -EFAULT;
 	rmcd_debug(OBW, "did=%d ra=0x%llx sz=0x%llx",
 	map.handle = paddr;
-	if (unlikely(copy_to_user(arg, &map, sizeof(struct rio_mmap))))
+	if (unlikely(copy_to_user(arg, &map, sizeof(map))))
 		return -EFAULT;
 	return 0;
 }
 	if (!md->mport->ops->unmap_outb)
 		return -EPROTONOSUPPORT;
-	if (copy_from_user(&handle, arg, sizeof(u64)))
+	if (copy_from_user(&handle, arg, sizeof(handle)))
 		return -EFAULT;
 	rmcd_debug(OBW, "h=0x%llx", handle);
 static int maint_hdid_set(struct mport_cdev_priv *priv, void __user *arg)
 {
 	struct mport_dev *md = priv->md;
-	uint16_t hdid;
+	u16 hdid;
-	if (copy_from_user(&hdid, arg, sizeof(uint16_t)))
+	if (copy_from_user(&hdid, arg, sizeof(hdid)))
 		return -EFAULT;
 	md->mport->host_deviceid = hdid;
 static int maint_comptag_set(struct mport_cdev_priv *priv, void __user *arg)
 {
 	struct mport_dev *md = priv->md;
-	uint32_t comptag;
+	u32 comptag;
-	if (copy_from_user(&comptag, arg, sizeof(uint32_t)))
+	if (copy_from_user(&comptag, arg, sizeof(comptag)))
 		return -EFAULT;
 	rio_local_write_config_32(md->mport, RIO_COMPONENT_TAG_CSR, comptag);
  * @xfer: data transfer descriptor structure
  */
 static int
-rio_dma_transfer(struct file *filp, uint32_t transfer_mode,
+rio_dma_transfer(struct file *filp, u32 transfer_mode,
 		 enum rio_transfer_sync sync, enum dma_data_direction dir,
 		 struct rio_transfer_io *xfer)
 {
 		unsigned long offset;
 		long pinned;
-		offset = (unsigned long)xfer->loc_addr & ~PAGE_MASK;
+		offset = (unsigned long)(uintptr_t)xfer->loc_addr & ~PAGE_MASK;
 		nr_pages = PAGE_ALIGN(xfer->length + offset) >> PAGE_SHIFT;
 		page_list = kmalloc_array(nr_pages,
 	if (unlikely(copy_from_user(&transaction, arg, sizeof(transaction))))
 		return -EFAULT;
-	if (transaction.count != 1)
+	if (transaction.count != 1) /* only single transfer for now */
 		return -EINVAL;
 	if ((transaction.transfer_mode &
 	     priv->md->properties.transfer_mode) == 0)
 		return -ENODEV;
-	transfer = vmalloc(transaction.count * sizeof(struct rio_transfer_io));
+	transfer = vmalloc(transaction.count * sizeof(*transfer));
 	if (!transfer)
 		return -ENOMEM;
-	if (unlikely(copy_from_user(transfer, transaction.block,
+	if (unlikely(copy_from_user(transfer,
-	      transaction.count * sizeof(struct rio_transfer_io)))) {
+				    (void __user *)(uintptr_t)transaction.block,
+				    transaction.count * sizeof(*transfer)))) {
 		ret = -EFAULT;
 		goto out_free;
 	}
 		ret = rio_dma_transfer(filp, transaction.transfer_mode,
 			transaction.sync, dir, &transfer[i]);
-	if (unlikely(copy_to_user(transaction.block, transfer,
+	if (unlikely(copy_to_user((void __user *)(uintptr_t)transaction.block,
-	      transaction.count * sizeof(struct rio_transfer_io))))
+				  transfer,
+				  transaction.count * sizeof(*transfer))))
 		ret = -EFAULT;
 out_free:
 }
 static int rio_mport_create_dma_mapping(struct mport_dev *md, struct file *filp,
-			uint64_t size, struct rio_mport_mapping **mapping)
+			u64 size, struct rio_mport_mapping **mapping)
 {
 	struct rio_mport_mapping *map;
-	map = kzalloc(sizeof(struct rio_mport_mapping), GFP_KERNEL);
+	map = kzalloc(sizeof(*map), GFP_KERNEL);
 	if (map == NULL)
 		return -ENOMEM;
 	struct rio_mport_mapping *mapping = NULL;
 	int ret;
-	if (unlikely(copy_from_user(&map, arg, sizeof(struct rio_dma_mem))))
+	if (unlikely(copy_from_user(&map, arg, sizeof(map))))
 		return -EFAULT;
 	ret = rio_mport_create_dma_mapping(md, filp, map.length, &mapping);
 	map.dma_handle = mapping->phys_addr;
-	if (unlikely(copy_to_user(arg, &map, sizeof(struct rio_dma_mem)))) {
+	if (unlikely(copy_to_user(arg, &map, sizeof(map)))) {
 		mutex_lock(&md->buf_mutex);
 		kref_put(&mapping->ref, mport_release_mapping);
 		mutex_unlock(&md->buf_mutex);
 	int ret = -EFAULT;
 	struct rio_mport_mapping *map, *_map;
-	if (copy_from_user(&handle, arg, sizeof(u64)))
+	if (copy_from_user(&handle, arg, sizeof(handle)))
 		return -EFAULT;
 	rmcd_debug(EXIT, "filp=%p", filp);
 static int
 rio_mport_create_inbound_mapping(struct mport_dev *md, struct file *filp,
-				u64 raddr, u32 size,
+				u64 raddr, u64 size,
 				struct rio_mport_mapping **mapping)
 {
 	struct rio_mport *mport = md->mport;
 	struct rio_mport_mapping *map;
 	int ret;
-	map = kzalloc(sizeof(struct rio_mport_mapping), GFP_KERNEL);
+	/* rio_map_inb_region() accepts u32 size */
+	if (size > 0xffffffff)
+		return -EINVAL;
+	map = kzalloc(sizeof(*map), GFP_KERNEL);
 	if (map == NULL)
 		return -ENOMEM;
 	if (raddr == RIO_MAP_ANY_ADDR)
 		raddr = map->phys_addr;
-	ret = rio_map_inb_region(mport, map->phys_addr, raddr, size, 0);
+	ret = rio_map_inb_region(mport, map->phys_addr, raddr, (u32)size, 0);
 	if (ret < 0)
 		goto err_map_inb;
 static int
 rio_mport_get_inbound_mapping(struct mport_dev *md, struct file *filp,
-			      u64 raddr, u32 size,
+			      u64 raddr, u64 size,
 			      struct rio_mport_mapping **mapping)
 {
 	struct rio_mport_mapping *map;
 	if (!md->mport->ops->map_inb)
 		return -EPROTONOSUPPORT;
-	if (unlikely(copy_from_user(&map, arg, sizeof(struct rio_mmap))))
+	if (unlikely(copy_from_user(&map, arg, sizeof(map))))
 		return -EFAULT;
 	rmcd_debug(IBW, "%s filp=%p", dev_name(&priv->md->dev), filp);
 	map.handle = mapping->phys_addr;
 	map.rio_addr = mapping->rio_addr;
-	if (unlikely(copy_to_user(arg, &map, sizeof(struct rio_mmap)))) {
+	if (unlikely(copy_to_user(arg, &map, sizeof(map)))) {
 		/* Delete mapping if it was created by this request */
 		if (ret == 0 && mapping->filp == filp) {
 			mutex_lock(&md->buf_mutex);
 	if (!md->mport->ops->unmap_inb)
 		return -EPROTONOSUPPORT;
-	if (copy_from_user(&handle, arg, sizeof(u64)))
+	if (copy_from_user(&handle, arg, sizeof(handle)))
 		return -EFAULT;
 	mutex_lock(&md->buf_mutex);
 static int maint_port_idx_get(struct mport_cdev_priv *priv, void __user *arg)
 {
 	struct mport_dev *md = priv->md;
-	uint32_t port_idx = md->mport->index;
+	u32 port_idx = md->mport->index;
 	rmcd_debug(MPORT, "port_index=%d", port_idx);
 	handled = 0;
 	spin_lock(&data->db_lock);
 	list_for_each_entry(db_filter, &data->doorbells, data_node) {
-		if (((db_filter->filter.rioid == 0xffffffff ||
+		if (((db_filter->filter.rioid == RIO_INVALID_DESTID ||
 		      db_filter->filter.rioid == src)) &&
 		      info >= db_filter->filter.low &&
 		      info <= db_filter->filter.high) {
 	if (copy_from_user(&filter, arg, sizeof(filter)))
 		return -EFAULT;
+	if (filter.low > filter.high)
+		return -EINVAL;
 	spin_lock_irqsave(&priv->md->db_lock, flags);
 	list_for_each_entry(db_filter, &priv->db_filters, priv_node) {
 		if (db_filter->filter.rioid == filter.rioid &&
 		return -EEXIST;
 	}
-	size = sizeof(struct rio_dev);
+	size = sizeof(*rdev);
 	mport = md->mport;
-	destid = (u16)dev_info.destid;
+	destid = dev_info.destid;
-	hopcount = (u8)dev_info.hopcount;
+	hopcount = dev_info.hopcount;
 	if (rio_mport_read_config_32(mport, destid, hopcount,
 				     RIO_PEF_CAR, &rval))
 		do {
 			rdev = rio_get_comptag(dev_info.comptag, rdev);
 			if (rdev && rdev->dev.parent == &mport->net->dev &&
-			    rdev->destid == (u16)dev_info.destid &&
+			    rdev->destid == dev_info.destid &&
-			    rdev->hopcount == (u8)dev_info.hopcount)
+			    rdev->hopcount == dev_info.hopcount)
 				break;
 		} while (rdev);
 	}
 		return maint_port_idx_get(data, (void __user *)arg);
 	case RIO_MPORT_GET_PROPERTIES:
 		md->properties.hdid = md->mport->host_deviceid;
-		if (copy_to_user((void __user *)arg, &(data->md->properties),
+		if (copy_to_user((void __user *)arg, &(md->properties),
-				 sizeof(data->md->properties)))
+				 sizeof(md->properties)))
 			return -EFAULT;
 		return 0;
 	case RIO_ENABLE_DOORBELL_RANGE:
 	case RIO_DISABLE_PORTWRITE_RANGE:
 		return rio_mport_remove_pw_filter(data, (void __user *)arg);
 	case RIO_SET_EVENT_MASK:
-		data->event_mask = arg;
+		data->event_mask = (u32)arg;
 		return 0;
 	case RIO_GET_EVENT_MASK:
 		if (copy_to_user((void __user *)arg, &data->event_mask,
-				    sizeof(data->event_mask)))
+				    sizeof(u32)))
 			return -EFAULT;
 		return 0;
 	case RIO_MAP_OUTBOUND:
 			return -EINVAL;
 		ret = rio_mport_send_doorbell(mport,
-					      (u16)event.u.doorbell.rioid,
+					      event.u.doorbell.rioid,
 					      event.u.doorbell.payload);
 		if (ret < 0)
 			return ret;
 	struct mport_dev *md;
 	struct rio_mport_attr attr;
-	md = kzalloc(sizeof(struct mport_dev), GFP_KERNEL);
+	md = kzalloc(sizeof(*md), GFP_KERNEL);
 	if (!md) {
 		rmcd_error("Unable allocate a device object");
 		return NULL;
 	/* The transfer_mode property will be returned through mport query
 	 * interface
 	 */
-#ifdef CONFIG_PPC /* for now: only on Freescale's SoCs */
+#ifdef CONFIG_FSL_RIO /* for now: only on Freescale's SoCs */
 	md->properties.transfer_mode |= RIO_TRANSFER_MODE_MAPPED;
 #else
 	md->properties.transfer_mode |= RIO_TRANSFER_MODE_TRANSFER;

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

 	return retval;
 }
-static int usb_port_prepare(struct device *dev)
-{
-	return 1;
-}
 #endif
 static const struct dev_pm_ops usb_port_pm_ops = {
 #ifdef CONFIG_PM
 	.runtime_suspend =	usb_port_runtime_suspend,
 	.runtime_resume =	usb_port_runtime_resume,
-	.prepare =		usb_port_prepare,
 #endif
 };

drivers/usb/core/usb.c+1−7

 static int usb_dev_prepare(struct device *dev)
 {
-	struct usb_device *udev = to_usb_device(dev);
+	return 0;		/* Implement eventually? */
-	/* Return 0 if the current wakeup setting is wrong, otherwise 1 */
-	if (udev->do_remote_wakeup != device_may_wakeup(dev))
-		return 0;
-	return 1;
 }
 static void usb_dev_complete(struct device *dev)

drivers/usb/musb/jz4740.c+2−2

@@ -83,9 +83,9 @@ static int jz4740_musb_init(struct musb *musb) · 82 unmodified lines
83	{	83	{
84	usb_phy_generic_register();	84	usb_phy_generic_register();
85	musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);	85	musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
86	if (!musb->xceiv) {	86	if (IS_ERR(musb->xceiv)) {
87	pr_err("HS UDC: no transceiver configured\n");	87	pr_err("HS UDC: no transceiver configured\n");
88	return -ENODEV;	88	return PTR_ERR(musb->xceiv);
89	}	89	}
90		90
91	/* Silicon does not implement ConfigData register.	91	/* Silicon does not implement ConfigData register.

drivers/usb/musb/musb_gadget.c+3−3

 		musb_writew(epio, MUSB_RXMAXP, 0);
 	}
-	musb_ep->desc = NULL;
-	musb_ep->end_point.desc = NULL;
 	/* abort all pending DMA and requests */
 	nuke(musb_ep, -ESHUTDOWN);
+	musb_ep->desc = NULL;
+	musb_ep->end_point.desc = NULL;
 	schedule_work(&musb->irq_work);
 	spin_unlock_irqrestore(&(musb->lock), flags);

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

@@ -2735,7 +2735,7 @@ static const struct hc_driver musb_hc_driver = { · 2734 unmodified lines
2735	.description = "musb-hcd",	2735	.description = "musb-hcd",
2736	.product_desc = "MUSB HDRC host driver",	2736	.product_desc = "MUSB HDRC host driver",
2737	.hcd_priv_size = sizeof(struct musb *),	2737	.hcd_priv_size = sizeof(struct musb *),
2738	.flags = HCD_USB2 \| HCD_MEMORY \| HCD_BH,	2738	.flags = HCD_USB2 \| HCD_MEMORY,
2739		2739
2740	/* not using irq handler or reset hooks from usbcore, since	2740	/* not using irq handler or reset hooks from usbcore, since
2741	* those must be shared with peripheral code for OTG configs	2741	* those must be shared with peripheral code for OTG configs

drivers/usb/serial/cp210x.c+4−0

 	{ USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
 	{ USB_DEVICE(0x10C4, 0x8281) }, /* Nanotec Plug & Drive */
 	{ USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
+	{ USB_DEVICE(0x10C4, 0x82F4) }, /* Starizona MicroTouch */
 	{ USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
 	{ USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
 	{ USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
 	{ USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
 	{ USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
 	{ USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
+	{ USB_DEVICE(0x10C4, 0x84B6) }, /* Starizona Hyperion */
 	{ USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
 	{ USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
 	{ USB_DEVICE(0x10C4, 0x85F8) }, /* Virtenio Preon32 */
 	{ USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
 	{ USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
 	{ USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */
+	{ USB_DEVICE(0x12B8, 0xEC60) }, /* Link G4 ECU */
+	{ USB_DEVICE(0x12B8, 0xEC62) }, /* Link G4+ ECU */
 	{ USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
 	{ USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */
 	{ USB_DEVICE(0x166A, 0x0201) }, /* Clipsal 5500PACA C-Bus Pascal Automation Controller */

drivers/virtio/virtio_ring.c+1−1

@@ -1006,7 +1006,7 @@ struct virtqueue *vring_create_virtqueue( · 1005 unmodified lines
1006	const char *name)	1006	const char *name)
1007	{	1007	{
1008	struct virtqueue *vq;	1008	struct virtqueue *vq;
1009	void *queue;	1009	void *queue = NULL;
1010	dma_addr_t dma_addr;	1010	dma_addr_t dma_addr;
1011	size_t queue_size_in_bytes;	1011	size_t queue_size_in_bytes;
1012	struct vring vring;	1012	struct vring vring;

drivers/xen/balloon.c+16−0

@@ -151,6 +151,8 @@ static DECLARE_WAIT_QUEUE_HEAD(balloon_wq); · 150 unmodified lines
151	static void balloon_process(struct work_struct *work);	151	static void balloon_process(struct work_struct *work);
152	static DECLARE_DELAYED_WORK(balloon_worker, balloon_process);	152	static DECLARE_DELAYED_WORK(balloon_worker, balloon_process);
153		153
		154	static void release_memory_resource(struct resource *resource);
		155
154	/* When ballooning out (allocating memory to return to Xen) we don't really	156	/* When ballooning out (allocating memory to return to Xen) we don't really
155	want the kernel to try too hard since that can trigger the oom killer. */	157	want the kernel to try too hard since that can trigger the oom killer. */
156	#define GFP_BALLOON \	158	#define GFP_BALLOON \
@@ -267,6 +269,20 @@ static struct resource *additional_memory_resource(phys_addr_t size) · 110 unmodified lines
267	return NULL;	269	return NULL;
268	}	270	}
269		271
		272	#ifdef CONFIG_SPARSEMEM
		273	{
		274	unsigned long limit = 1UL << (MAX_PHYSMEM_BITS - PAGE_SHIFT);
		275	unsigned long pfn = res->start >> PAGE_SHIFT;
		276
		277	if (pfn > limit) {
		278	pr_err("New System RAM resource outside addressable RAM (%lu > %lu)\n",
		279	pfn, limit);
		280	release_memory_resource(res);
		281	return NULL;
		282	}
		283	}
		284	#endif
		285
270	return res;	286	return res;
271	}	287	}
272		288

drivers/xen/evtchn.c+8−12

 {
 	unsigned int new_size;
 	evtchn_port_t *new_ring, *old_ring;
-	unsigned int p, c;
 	/*
 	 * Ensure the ring is large enough to capture all possible
 	/*
 	 * Copy the old ring contents to the new ring.
 	 *
-	 * If the ring contents crosses the end of the current ring,
+	 * To take care of wrapping, a full ring, and the new index
-	 * it needs to be copied in two chunks.
+	 * pointing into the second half, simply copy the old contents
+	 * twice.
 	 *
 	 * +---------+    +------------------+
-	 * |34567  12| -> |       1234567    |
+	 * |34567  12| -> |34567  1234567  12|
-	 * +-----p-c-+    +------------------+
+	 * +-----p-c-+    +-------c------p---+
 	 */
-	p = evtchn_ring_offset(u, u->ring_prod);
+	memcpy(new_ring, old_ring, u->ring_size * sizeof(*u->ring));
-	c = evtchn_ring_offset(u, u->ring_cons);
+	memcpy(new_ring + u->ring_size, old_ring,
-	if (p < c) {
+	       u->ring_size * sizeof(*u->ring));
-		memcpy(new_ring + c, u->ring + c, (u->ring_size - c) * sizeof(*u->ring));
-		memcpy(new_ring + u->ring_size, u->ring, p * sizeof(*u->ring));
-	} else
-		memcpy(new_ring + c, u->ring + c, (p - c) * sizeof(*u->ring));
 	u->ring = new_ring;
 	u->ring_size = new_size;

fs/pnode.c+14−11

 /* all accesses are serialized by namespace_sem */
 static struct user_namespace *user_ns;
-static struct mount *last_dest, *last_source, *dest_master;
+static struct mount *last_dest, *first_source, *last_source, *dest_master;
 static struct mountpoint *mp;
 static struct hlist_head *list;
 		type = CL_MAKE_SHARED;
 	} else {
 		struct mount *n, *p;
+		bool done;
 		for (n = m; ; n = p) {
 			p = n->mnt_master;
-			if (p == dest_master || IS_MNT_MARKED(p)) {
+			if (p == dest_master || IS_MNT_MARKED(p))
-				while (last_dest->mnt_master != p) {
-					last_source = last_source->mnt_master;
-					last_dest = last_source->mnt_parent;
-				}
-				if (!peers(n, last_dest)) {
-					last_source = last_source->mnt_master;
-					last_dest = last_source->mnt_parent;
-				}
 				break;
-			}
 		}
+		do {
+			struct mount *parent = last_source->mnt_parent;
+			if (last_source == first_source)
+				break;
+			done = parent->mnt_master == p;
+			if (done && peers(n, parent))
+				break;
+			last_source = last_source->mnt_master;
+		} while (!done);
 		type = CL_SLAVE;
 		/* beginning of peer group among the slaves? */
 		if (IS_MNT_SHARED(m))
 	 */
 	user_ns = current->nsproxy->mnt_ns->user_ns;
 	last_dest = dest_mnt;
+	first_source = source_mnt;
 	last_source = source_mnt;
 	mp = dest_mp;
 	list = tree_list;

fs/proc/base.c+2−1

@@ -955,7 +955,8 @@ static ssize_t environ_read(struct file file, char __user buf, · 954 unmodified lines
955	struct mm_struct *mm = file->private_data;	955	struct mm_struct *mm = file->private_data;
956	unsigned long env_start, env_end;	956	unsigned long env_start, env_end;
957		957
958	if (!mm)	958	/* Ensure the process spawned far enough to have an environment. */
		959	if (!mm \|\| !mm->env_end)
959	return 0;	960	return 0;
960		961
961	page = (char *)__get_free_page(GFP_TEMPORARY);	962	page = (char *)__get_free_page(GFP_TEMPORARY);

include/acpi/acpi_bus.h+2−2

@@ -394,13 +394,13 @@ struct acpi_data_node { · 393 unmodified lines
394		394
395	static inline bool is_acpi_node(struct fwnode_handle *fwnode)	395	static inline bool is_acpi_node(struct fwnode_handle *fwnode)
396	{	396	{
397	return fwnode && (fwnode->type == FWNODE_ACPI	397	return !IS_ERR_OR_NULL(fwnode) && (fwnode->type == FWNODE_ACPI
398	\|\| fwnode->type == FWNODE_ACPI_DATA);	398	\|\| fwnode->type == FWNODE_ACPI_DATA);
399	}	399	}
400		400
401	static inline bool is_acpi_device_node(struct fwnode_handle *fwnode)	401	static inline bool is_acpi_device_node(struct fwnode_handle *fwnode)
402	{	402	{
403	return fwnode && fwnode->type == FWNODE_ACPI;	403	return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_ACPI;
404	}	404	}
405		405
406	static inline struct acpi_device to_acpi_device_node(struct fwnode_handle fwnode)	406	static inline struct acpi_device to_acpi_device_node(struct fwnode_handle fwnode)

include/linux/compiler-gcc.h+1−1

@@ -246,7 +246,7 @@ · 245 unmodified lines
246	#define __HAVE_BUILTIN_BSWAP32__	246	#define __HAVE_BUILTIN_BSWAP32__
247	#define __HAVE_BUILTIN_BSWAP64__	247	#define __HAVE_BUILTIN_BSWAP64__
248	#endif	248	#endif
249	#if GCC_VERSION >= 40800 \|\| (defined(__powerpc__) && GCC_VERSION >= 40600)	249	#if GCC_VERSION >= 40800
250	#define __HAVE_BUILTIN_BSWAP16__	250	#define __HAVE_BUILTIN_BSWAP16__
251	#endif	251	#endif
252	#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */	252	#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */

include/linux/of.h+1−1

@@ -133,7 +133,7 @@ void of_core_init(void); · 132 unmodified lines
133		133
134	static inline bool is_of_node(struct fwnode_handle *fwnode)	134	static inline bool is_of_node(struct fwnode_handle *fwnode)
135	{	135	{
136	return fwnode && fwnode->type == FWNODE_OF;	136	return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_OF;
137	}	137	}
138		138
139	static inline struct device_node to_of_node(struct fwnode_handle fwnode)	139	static inline struct device_node to_of_node(struct fwnode_handle fwnode)

include/linux/page-flags.h+22−0

@@ -516,6 +516,27 @@ static inline int PageTransCompound(struct page *page) · 515 unmodified lines
516	return PageCompound(page);	516	return PageCompound(page);
517	}	517	}
518		518
		519	/*
		520	* PageTransCompoundMap is the same as PageTransCompound, but it also
		521	* guarantees the primary MMU has the entire compound page mapped
		522	* through pmd_trans_huge, which in turn guarantees the secondary MMUs
		523	* can also map the entire compound page. This allows the secondary
		524	* MMUs to call get_user_pages() only once for each compound page and
		525	* to immediately map the entire compound page with a single secondary
		526	* MMU fault. If there will be a pmd split later, the secondary MMUs
		527	* will get an update through the MMU notifier invalidation through
		528	* split_huge_pmd().
		529	*
		530	* Unlike PageTransCompound, this is safe to be called only while
		531	* split_huge_pmd() cannot run from under us, like if protected by the
		532	* MMU notifier, otherwise it may result in page->_mapcount < 0 false
		533	* positives.
		534	*/
		535	static inline int PageTransCompoundMap(struct page *page)
		536	{
		537	return PageTransCompound(page) && atomic_read(&page->_mapcount) < 0;
		538	}
		539
519	/*	540	/*
520	* PageTransTail returns true for both transparent huge pages	541	* PageTransTail returns true for both transparent huge pages
521	* and hugetlbfs pages, so it should only be called when it's known	542	* and hugetlbfs pages, so it should only be called when it's known
@@ -559,6 +580,7 @@ static inline int TestClearPageDoubleMap(struct page *page) · 37 unmodified lines
559	#else	580	#else
560	TESTPAGEFLAG_FALSE(TransHuge)	581	TESTPAGEFLAG_FALSE(TransHuge)
561	TESTPAGEFLAG_FALSE(TransCompound)	582	TESTPAGEFLAG_FALSE(TransCompound)
		583	TESTPAGEFLAG_FALSE(TransCompoundMap)
562	TESTPAGEFLAG_FALSE(TransTail)	584	TESTPAGEFLAG_FALSE(TransTail)
563	TESTPAGEFLAG_FALSE(DoubleMap)	585	TESTPAGEFLAG_FALSE(DoubleMap)
564	TESTSETFLAG_FALSE(DoubleMap)	586	TESTSETFLAG_FALSE(DoubleMap)

include/linux/swap.h+4−0

 #ifdef CONFIG_MEMCG
 static inline int mem_cgroup_swappiness(struct mem_cgroup *memcg)
 {
+	/* Cgroup2 doesn't have per-cgroup swappiness */
+	if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
+		return vm_swappiness;
 	/* root ? */
 	if (mem_cgroup_disabled() || !memcg->css.parent)
 		return vm_swappiness;

include/net/netns/xfrm.h+1−0

@@ -80,6 +80,7 @@ struct netns_xfrm { · 79 unmodified lines
80	struct flow_cache flow_cache_global;	80	struct flow_cache flow_cache_global;
81	atomic_t flow_cache_genid;	81	atomic_t flow_cache_genid;
82	struct list_head flow_cache_gc_list;	82	struct list_head flow_cache_gc_list;
		83	atomic_t flow_cache_gc_count;
83	spinlock_t flow_cache_gc_lock;	84	spinlock_t flow_cache_gc_lock;
84	struct work_struct flow_cache_gc_work;	85	struct work_struct flow_cache_gc_work;
85	struct work_struct flow_cache_flush_work;	86	struct work_struct flow_cache_flush_work;

include/net/udp_tunnel.h+0−9

@@ -112,15 +112,6 @@ static inline int udp_tunnel_handle_offloads(struct sk_buff *skb, bool udp_csum) · 111 unmodified lines
112	return iptunnel_handle_offloads(skb, type);	112	return iptunnel_handle_offloads(skb, type);
113	}	113	}
114		114
115	static inline void udp_tunnel_gro_complete(struct sk_buff *skb, int nhoff)
116	{
117	struct udphdr *uh;
118
119	uh = (struct udphdr *)(skb->data + nhoff - sizeof(struct udphdr));
120	skb_shinfo(skb)->gso_type \|= uh->check ?
121	SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
122	}
123
124	static inline void udp_tunnel_encap_enable(struct socket *sock)	115	static inline void udp_tunnel_encap_enable(struct socket *sock)
125	{	116	{
126	#if IS_ENABLED(CONFIG_IPV6)	117	#if IS_ENABLED(CONFIG_IPV6)

include/uapi/asm-generic/unistd.h+2−2

@@ -718,9 +718,9 @@ __SYSCALL(__NR_mlock2, sys_mlock2) · 717 unmodified lines
718	#define __NR_copy_file_range 285	718	#define __NR_copy_file_range 285
719	__SYSCALL(__NR_copy_file_range, sys_copy_file_range)	719	__SYSCALL(__NR_copy_file_range, sys_copy_file_range)
720	#define __NR_preadv2 286	720	#define __NR_preadv2 286
721	__SYSCALL(__NR_preadv2, sys_preadv2)	721	__SC_COMP(__NR_preadv2, sys_preadv2, compat_sys_preadv2)
722	#define __NR_pwritev2 287	722	#define __NR_pwritev2 287
723	__SYSCALL(__NR_pwritev2, sys_pwritev2)	723	__SC_COMP(__NR_pwritev2, sys_pwritev2, compat_sys_pwritev2)
724		724
725	#undef __NR_syscalls	725	#undef __NR_syscalls
726	#define __NR_syscalls 288	726	#define __NR_syscalls 288

include/uapi/linux/if_macsec.h+3−1

 #define MACSEC_MAX_KEY_LEN 128
+#define MACSEC_KEYID_LEN 16
 #define MACSEC_DEFAULT_CIPHER_ID   0x0080020001000001ULL
 #define MACSEC_DEFAULT_CIPHER_ALT  0x0080C20001000001ULL
 	MACSEC_SA_ATTR_ACTIVE, /* config/dump, u8 0..1 */
 	MACSEC_SA_ATTR_PN,     /* config/dump, u32 */
 	MACSEC_SA_ATTR_KEY,    /* config, data */
-	MACSEC_SA_ATTR_KEYID,  /* config/dump, u64 */
+	MACSEC_SA_ATTR_KEYID,  /* config/dump, 128-bit */
 	MACSEC_SA_ATTR_STATS,  /* dump, nested, macsec_sa_stats_attr */
 	MACSEC_SA_ATTR_PAD,
 	__MACSEC_SA_ATTR_END,

include/uapi/linux/rio_mport_cdev.hrenamed from include/linux/rio_mport_cdev.h+75−69

@@ -39,16 +39,16 @@ · 38 unmodified lines
39	#ifndef _RIO_MPORT_CDEV_H_	39	#ifndef _RIO_MPORT_CDEV_H_
40	#define _RIO_MPORT_CDEV_H_	40	#define _RIO_MPORT_CDEV_H_
41		41
42	#ifndef __user	42	#include <linux/ioctl.h>
43	#define __user	43	#include <linux/types.h>
44	#endif
45		44
46	struct rio_mport_maint_io {	45	struct rio_mport_maint_io {
47	uint32_t rioid; /* destID of remote device */	46	__u16 rioid; /* destID of remote device */
48	uint32_t hopcount; /* hopcount to remote device */	47	__u8 hopcount; /* hopcount to remote device */
49	uint32_t offset; /* offset in register space */	48	__u8 pad0[5];
50	size_t length; /* length in bytes */	49	__u32 offset; /* offset in register space */
51	void __user buffer; / data buffer */	50	__u32 length; /* length in bytes */
		51	__u64 buffer; /* pointer to data buffer */
52	};	52	};
53		53
54	/*	54	/*
@@ -66,22 +66,23 @@ struct rio_mport_maint_io { · 11 unmodified lines
66	#define RIO_CAP_MAP_INB (1 << 7)	66	#define RIO_CAP_MAP_INB (1 << 7)
67		67
68	struct rio_mport_properties {	68	struct rio_mport_properties {
69	uint16_t hdid;	69	__u16 hdid;
70	uint8_t id; /* Physical port ID */	70	__u8 id; /* Physical port ID */
71	uint8_t index;	71	__u8 index;
72	uint32_t flags;	72	__u32 flags;
73	uint32_t sys_size; /* Default addressing size */	73	__u32 sys_size; /* Default addressing size */
74	uint8_t port_ok;	74	__u8 port_ok;
75	uint8_t link_speed;	75	__u8 link_speed;
76	uint8_t link_width;	76	__u8 link_width;
77	uint32_t dma_max_sge;	77	__u8 pad0;
78	uint32_t dma_max_size;	78	__u32 dma_max_sge;
79	uint32_t dma_align;	79	__u32 dma_max_size;
80	uint32_t transfer_mode; /* Default transfer mode */	80	__u32 dma_align;
81	uint32_t cap_sys_size; /* Capable system sizes */	81	__u32 transfer_mode; /* Default transfer mode */
82	uint32_t cap_addr_size; /* Capable addressing sizes */	82	__u32 cap_sys_size; /* Capable system sizes */
83	uint32_t cap_transfer_mode; /* Capable transfer modes */	83	__u32 cap_addr_size; /* Capable addressing sizes */
84	uint32_t cap_mport; /* Mport capabilities */	84	__u32 cap_transfer_mode; /* Capable transfer modes */
		85	__u32 cap_mport; /* Mport capabilities */
85	};	86	};
86		87
87	/*	88	/*
@@ -93,54 +94,57 @@ struct rio_mport_properties { · 5 unmodified lines
93	#define RIO_PORTWRITE (1 << 1)	94	#define RIO_PORTWRITE (1 << 1)
94		95
95	struct rio_doorbell {	96	struct rio_doorbell {
96	uint32_t rioid;	97	__u16 rioid;
97	uint16_t payload;	98	__u16 payload;
98	};	99	};
99		100
100	struct rio_doorbell_filter {	101	struct rio_doorbell_filter {
101	uint32_t rioid; /* 0xffffffff to match all ids */	102	__u16 rioid; /* Use RIO_INVALID_DESTID to match all ids */
102	uint16_t low;	103	__u16 low;
103	uint16_t high;	104	__u16 high;
		105	__u16 pad0;
104	};	106	};
105		107
106		108
107	struct rio_portwrite {	109	struct rio_portwrite {
108	uint32_t payload[16];	110	__u32 payload[16];
109	};	111	};
110		112
111	struct rio_pw_filter {	113	struct rio_pw_filter {
112	uint32_t mask;	114	__u32 mask;
113	uint32_t low;	115	__u32 low;
114	uint32_t high;	116	__u32 high;
		117	__u32 pad0;
115	};	118	};
116		119
117	/* RapidIO base address for inbound requests set to value defined below	120	/* RapidIO base address for inbound requests set to value defined below
118	* indicates that no specific RIO-to-local address translation is requested	121	* indicates that no specific RIO-to-local address translation is requested
119	* and driver should use direct (one-to-one) address mapping.	122	* and driver should use direct (one-to-one) address mapping.
120	*/	123	*/
121	#define RIO_MAP_ANY_ADDR (uint64_t)(~((uint64_t) 0))	124	#define RIO_MAP_ANY_ADDR (__u64)(~((__u64) 0))
122		125
123	struct rio_mmap {	126	struct rio_mmap {
124	uint32_t rioid;	127	__u16 rioid;
125	uint64_t rio_addr;	128	__u16 pad0[3];
126	uint64_t length;	129	__u64 rio_addr;
127	uint64_t handle;	130	__u64 length;
128	void *address;	131	__u64 handle;
		132	__u64 address;
129	};	133	};
130		134
131	struct rio_dma_mem {	135	struct rio_dma_mem {
132	uint64_t length; /* length of DMA memory */	136	__u64 length; /* length of DMA memory */
133	uint64_t dma_handle; /* handle associated with this memory */	137	__u64 dma_handle; /* handle associated with this memory */
134	void buffer; / pointer to this memory */	138	__u64 address;
135	};	139	};
136		140
137
138	struct rio_event {	141	struct rio_event {
139	unsigned int header; /* event type RIO_DOORBELL or RIO_PORTWRITE */	142	__u32 header; /* event type RIO_DOORBELL or RIO_PORTWRITE */
140	union {	143	union {
141	struct rio_doorbell doorbell; /* header for RIO_DOORBELL */	144	struct rio_doorbell doorbell; /* header for RIO_DOORBELL */
142	struct rio_portwrite portwrite; /* header for RIO_PORTWRITE */	145	struct rio_portwrite portwrite; /* header for RIO_PORTWRITE */
143	} u;	146	} u;
		147	__u32 pad0;
144	};	148	};
145		149
146	enum rio_transfer_sync {	150	enum rio_transfer_sync {
@@ -184,35 +188,37 @@ enum rio_exchange { · 37 unmodified lines
184	};	188	};
185		189
186	struct rio_transfer_io {	190	struct rio_transfer_io {
187	uint32_t rioid; /* Target destID */	191	__u64 rio_addr; /* Address in target's RIO mem space */
188	uint64_t rio_addr; /* Address in target's RIO mem space */	192	__u64 loc_addr;
189	enum rio_exchange method; /* Data exchange method */	193	__u64 handle;
190	void __user *loc_addr;	194	__u64 offset; /* Offset in buffer */
191	uint64_t handle;	195	__u64 length; /* Length in bytes */
192	uint64_t offset; /* Offset in buffer */	196	__u16 rioid; /* Target destID */
193	uint64_t length; /* Length in bytes */	197	__u16 method; /* Data exchange method, one of rio_exchange enum */
194	uint32_t completion_code; /* Completion code for this transfer */	198	__u32 completion_code; /* Completion code for this transfer */
195	};	199	};
196		200
197	struct rio_transaction {	201	struct rio_transaction {
198	uint32_t transfer_mode; /* Data transfer mode */	202	__u64 block; /* Pointer to array of <count> transfers */
199	enum rio_transfer_sync sync; /* Synchronization method */	203	__u32 count; /* Number of transfers */
200	enum rio_transfer_dir dir; /* Transfer direction */	204	__u32 transfer_mode; /* Data transfer mode */
201	size_t count; /* Number of transfers */	205	__u16 sync; /* Synch method, one of rio_transfer_sync enum */
202	struct rio_transfer_io __user block; / Array of <count> transfers */	206	__u16 dir; /* Transfer direction, one of rio_transfer_dir enum */
		207	__u32 pad0;
203	};	208	};
204		209
205	struct rio_async_tx_wait {	210	struct rio_async_tx_wait {
206	uint32_t token; /* DMA transaction ID token */	211	__u32 token; /* DMA transaction ID token */
207	uint32_t timeout; /* Wait timeout in msec, if 0 use default TO */	212	__u32 timeout; /* Wait timeout in msec, if 0 use default TO */
208	};	213	};
209		214
210	#define RIO_MAX_DEVNAME_SZ 20	215	#define RIO_MAX_DEVNAME_SZ 20
211		216
212	struct rio_rdev_info {	217	struct rio_rdev_info {
213	uint32_t destid;	218	__u16 destid;
214	uint8_t hopcount;	219	__u8 hopcount;
215	uint32_t comptag;	220	__u8 pad0;
		221	__u32 comptag;
216	char name[RIO_MAX_DEVNAME_SZ + 1];	222	char name[RIO_MAX_DEVNAME_SZ + 1];
217	};	223	};
218		224
@@ -220,11 +226,11 @@ struct rio_rdev_info { · 1 unmodified line
220	#define RIO_MPORT_DRV_MAGIC 'm'	226	#define RIO_MPORT_DRV_MAGIC 'm'
221		227
222	#define RIO_MPORT_MAINT_HDID_SET \	228	#define RIO_MPORT_MAINT_HDID_SET \
223	_IOW(RIO_MPORT_DRV_MAGIC, 1, uint16_t)	229	_IOW(RIO_MPORT_DRV_MAGIC, 1, __u16)
224	#define RIO_MPORT_MAINT_COMPTAG_SET \	230	#define RIO_MPORT_MAINT_COMPTAG_SET \
225	_IOW(RIO_MPORT_DRV_MAGIC, 2, uint32_t)	231	_IOW(RIO_MPORT_DRV_MAGIC, 2, __u32)
226	#define RIO_MPORT_MAINT_PORT_IDX_GET \	232	#define RIO_MPORT_MAINT_PORT_IDX_GET \
227	_IOR(RIO_MPORT_DRV_MAGIC, 3, uint32_t)	233	_IOR(RIO_MPORT_DRV_MAGIC, 3, __u32)
228	#define RIO_MPORT_GET_PROPERTIES \	234	#define RIO_MPORT_GET_PROPERTIES \
229	_IOR(RIO_MPORT_DRV_MAGIC, 4, struct rio_mport_properties)	235	_IOR(RIO_MPORT_DRV_MAGIC, 4, struct rio_mport_properties)
230	#define RIO_MPORT_MAINT_READ_LOCAL \	236	#define RIO_MPORT_MAINT_READ_LOCAL \
@@ -244,9 +250,9 @@ struct rio_rdev_info { · 13 unmodified lines
244	#define RIO_DISABLE_PORTWRITE_RANGE \	250	#define RIO_DISABLE_PORTWRITE_RANGE \
245	_IOW(RIO_MPORT_DRV_MAGIC, 12, struct rio_pw_filter)	251	_IOW(RIO_MPORT_DRV_MAGIC, 12, struct rio_pw_filter)
246	#define RIO_SET_EVENT_MASK \	252	#define RIO_SET_EVENT_MASK \
247	_IOW(RIO_MPORT_DRV_MAGIC, 13, unsigned int)	253	_IOW(RIO_MPORT_DRV_MAGIC, 13, __u32)
248	#define RIO_GET_EVENT_MASK \	254	#define RIO_GET_EVENT_MASK \
249	_IOR(RIO_MPORT_DRV_MAGIC, 14, unsigned int)	255	_IOR(RIO_MPORT_DRV_MAGIC, 14, __u32)
250	#define RIO_MAP_OUTBOUND \	256	#define RIO_MAP_OUTBOUND \
251	_IOWR(RIO_MPORT_DRV_MAGIC, 15, struct rio_mmap)	257	_IOWR(RIO_MPORT_DRV_MAGIC, 15, struct rio_mmap)
252	#define RIO_UNMAP_OUTBOUND \	258	#define RIO_UNMAP_OUTBOUND \
@@ -254,11 +260,11 @@ struct rio_rdev_info { · 1 unmodified line
254	#define RIO_MAP_INBOUND \	260	#define RIO_MAP_INBOUND \
255	_IOWR(RIO_MPORT_DRV_MAGIC, 17, struct rio_mmap)	261	_IOWR(RIO_MPORT_DRV_MAGIC, 17, struct rio_mmap)
256	#define RIO_UNMAP_INBOUND \	262	#define RIO_UNMAP_INBOUND \
257	_IOW(RIO_MPORT_DRV_MAGIC, 18, uint64_t)	263	_IOW(RIO_MPORT_DRV_MAGIC, 18, __u64)
258	#define RIO_ALLOC_DMA \	264	#define RIO_ALLOC_DMA \
259	_IOWR(RIO_MPORT_DRV_MAGIC, 19, struct rio_dma_mem)	265	_IOWR(RIO_MPORT_DRV_MAGIC, 19, struct rio_dma_mem)
260	#define RIO_FREE_DMA \	266	#define RIO_FREE_DMA \
261	_IOW(RIO_MPORT_DRV_MAGIC, 20, uint64_t)	267	_IOW(RIO_MPORT_DRV_MAGIC, 20, __u64)
262	#define RIO_TRANSFER \	268	#define RIO_TRANSFER \
263	_IOWR(RIO_MPORT_DRV_MAGIC, 21, struct rio_transaction)	269	_IOWR(RIO_MPORT_DRV_MAGIC, 21, struct rio_transaction)
264	#define RIO_WAIT_FOR_ASYNC \	270	#define RIO_WAIT_FOR_ASYNC \

include/uapi/linux/swab.h+15−9

 static inline __attribute_const__ __u16 __fswab16(__u16 val)
 {
-#ifdef __HAVE_BUILTIN_BSWAP16__
+#if defined (__arch_swab16)
-	return __builtin_bswap16(val);
-#elif defined (__arch_swab16)
 	return __arch_swab16(val);
 #else
 	return ___constant_swab16(val);
 static inline __attribute_const__ __u32 __fswab32(__u32 val)
 {
-#ifdef __HAVE_BUILTIN_BSWAP32__
+#if defined(__arch_swab32)
-	return __builtin_bswap32(val);
-#elif defined(__arch_swab32)
 	return __arch_swab32(val);
 #else
 	return ___constant_swab32(val);
 static inline __attribute_const__ __u64 __fswab64(__u64 val)
 {
-#ifdef __HAVE_BUILTIN_BSWAP64__
+#if defined (__arch_swab64)
-	return __builtin_bswap64(val);
-#elif defined (__arch_swab64)
 	return __arch_swab64(val);
 #elif defined(__SWAB_64_THRU_32__)
 	__u32 h = val >> 32;
  * __swab16 - return a byteswapped 16-bit value
  * @x: value to byteswap
  */
+#ifdef __HAVE_BUILTIN_BSWAP16__
+#define __swab16(x) (__u16)__builtin_bswap16((__u16)(x))
+#else
 #define __swab16(x)				\
 	(__builtin_constant_p((__u16)(x)) ?	\
 	___constant_swab16(x) :			\
 	__fswab16(x))
+#endif
 /**
  * __swab32 - return a byteswapped 32-bit value
  * @x: value to byteswap
  */
+#ifdef __HAVE_BUILTIN_BSWAP32__
+#define __swab32(x) (__u32)__builtin_bswap32((__u32)(x))
+#else
 #define __swab32(x)				\
 	(__builtin_constant_p((__u32)(x)) ?	\
 	___constant_swab32(x) :			\
 	__fswab32(x))
+#endif
 /**
  * __swab64 - return a byteswapped 64-bit value
  * @x: value to byteswap
  */
+#ifdef __HAVE_BUILTIN_BSWAP64__
+#define __swab64(x) (__u64)__builtin_bswap64((__u64)(x))
+#else
 #define __swab64(x)				\
 	(__builtin_constant_p((__u64)(x)) ?	\
 	___constant_swab64(x) :			\
 	__fswab64(x))
+#endif
 /**
  * __swahw32 - return a word-swapped 32-bit value

include/xen/page.h+2−2

@@ -15,9 +15,9 @@ · 14 unmodified lines
15	*/	15	*/
16		16
17	#define xen_pfn_to_page(xen_pfn) \	17	#define xen_pfn_to_page(xen_pfn) \
18	((pfn_to_page(((unsigned long)(xen_pfn) << XEN_PAGE_SHIFT) >> PAGE_SHIFT)))	18	(pfn_to_page((unsigned long)(xen_pfn) >> (PAGE_SHIFT - XEN_PAGE_SHIFT)))
19	#define page_to_xen_pfn(page) \	19	#define page_to_xen_pfn(page) \
20	(((page_to_pfn(page)) << PAGE_SHIFT) >> XEN_PAGE_SHIFT)	20	((page_to_pfn(page)) << (PAGE_SHIFT - XEN_PAGE_SHIFT))
21		21
22	#define XEN_PFN_PER_PAGE (PAGE_SIZE / XEN_PAGE_SIZE)	22	#define XEN_PFN_PER_PAGE (PAGE_SIZE / XEN_PAGE_SIZE)
23		23

kernel/sched/core.c+16−13

 		return false;
 	/*
-	 * FIFO realtime policy runs the highest priority task (after DEADLINE).
+	 * If there are more than one RR tasks, we need the tick to effect the
-	 * Other runnable tasks are of a lower priority. The scheduler tick
+	 * actual RR behaviour.
-	 * isn't needed.
-	 */
-	fifo_nr_running = rq->rt.rt_nr_running - rq->rt.rr_nr_running;
-	if (fifo_nr_running)
-		return true;
-	/*
-	 * Round-robin realtime tasks time slice with other tasks at the same
-	 * realtime priority.
 	 */
 	if (rq->rt.rr_nr_running) {
 		if (rq->rt.rr_nr_running == 1)
 			return false;
 	}
-	/* Normal multitasking need periodic preemption checks */
+	/*
-	if (rq->cfs.nr_running > 1)
+	 * If there's no RR tasks, but FIFO tasks, we can skip the tick, no
+	 * forced preemption between FIFO tasks.
+	 */
+	fifo_nr_running = rq->rt.rt_nr_running - rq->rt.rr_nr_running;
+	if (fifo_nr_running)
+		return true;
+	/*
+	 * If there are no DL,RR/FIFO tasks, there must only be CFS tasks left;
+	 * if there's more than one we need the tick for involuntary
+	 * preemption.
+	 */
+	if (rq->nr_running > 1)
 		return false;
 	return true;

kernel/trace/trace_events.c+7−2

 	trace_create_file("filter", 0644, file->dir, file,
 			  &ftrace_event_filter_fops);
-	trace_create_file("trigger", 0644, file->dir, file,
+	/*
-			  &event_trigger_fops);
+	 * Only event directories that can be enabled should have
+	 * triggers.
+	 */
+	if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
+		trace_create_file("trigger", 0644, file->dir, file,
+				  &event_trigger_fops);
 	trace_create_file("format", 0444, file->dir, call,
 			  &ftrace_event_format_fops);

lib/stackdepot.c+5−1

 #define DEPOT_STACK_BITS (sizeof(depot_stack_handle_t) * 8)
+#define STACK_ALLOC_NULL_PROTECTION_BITS 1
 #define STACK_ALLOC_ORDER 2 /* 'Slab' size order for stack depot, 4 pages */
 #define STACK_ALLOC_SIZE (1LL << (PAGE_SHIFT + STACK_ALLOC_ORDER))
 #define STACK_ALLOC_ALIGN 4
 #define STACK_ALLOC_OFFSET_BITS (STACK_ALLOC_ORDER + PAGE_SHIFT - \
 					STACK_ALLOC_ALIGN)
-#define STACK_ALLOC_INDEX_BITS (DEPOT_STACK_BITS - STACK_ALLOC_OFFSET_BITS)
+#define STACK_ALLOC_INDEX_BITS (DEPOT_STACK_BITS - \
+		STACK_ALLOC_NULL_PROTECTION_BITS - STACK_ALLOC_OFFSET_BITS)
 #define STACK_ALLOC_SLABS_CAP 1024
 #define STACK_ALLOC_MAX_SLABS \
 	(((1LL << (STACK_ALLOC_INDEX_BITS)) < STACK_ALLOC_SLABS_CAP) ? \
 	struct {
 		u32 slabindex : STACK_ALLOC_INDEX_BITS;
 		u32 offset : STACK_ALLOC_OFFSET_BITS;
+		u32 valid : STACK_ALLOC_NULL_PROTECTION_BITS;
 	};
 };
 	stack->size = size;
 	stack->handle.slabindex = depot_index;
 	stack->handle.offset = depot_offset >> STACK_ALLOC_ALIGN;
+	stack->handle.valid = 1;
 	memcpy(stack->entries, entries, size * sizeof(unsigned long));
 	depot_offset += required_size;

mm/compaction.c+4−10

 		pfn = isolate_migratepages_block(cc, pfn, block_end_pfn,
 							ISOLATE_UNEVICTABLE);
-		/*
+		if (!pfn)
-		 * In case of fatal failure, release everything that might
-		 * have been isolated in the previous iteration, and signal
-		 * the failure back to caller.
-		 */
-		if (!pfn) {
-			putback_movable_pages(&cc->migratepages);
-			cc->nr_migratepages = 0;
 			break;
-		}
 		if (cc->nr_migratepages == COMPACT_CLUSTER_MAX)
 			break;
 static inline bool kcompactd_work_requested(pg_data_t *pgdat)
 {
-	return pgdat->kcompactd_max_order > 0;
+	return pgdat->kcompactd_max_order > 0 || kthread_should_stop();
 }
 static bool kcompactd_node_suitable(pg_data_t *pgdat)
 		INIT_LIST_HEAD(&cc.freepages);
 		INIT_LIST_HEAD(&cc.migratepages);
+		if (kthread_should_stop())
+			return;
 		status = compact_zone(zone, &cc);
 		if (zone_watermark_ok(zone, cc.order, low_wmark_pages(zone),

mm/huge_memory.c+2−2

@@ -3452,7 +3452,7 @@ next: · 3451 unmodified lines
3452	}	3452	}
3453	}	3453	}
3454		3454
3455	pr_info("%lu of %lu THP split", split, total);	3455	pr_info("%lu of %lu THP split\n", split, total);
3456		3456
3457	return 0;	3457	return 0;
3458	}	3458	}
@@ -3463,7 +3463,7 @@ static int __init split_huge_pages_debugfs(void) · 4 unmodified lines
3463	{	3463	{
3464	void *ret;	3464	void *ret;
3465		3465
3466	ret = debugfs_create_file("split_huge_pages", 0644, NULL, NULL,	3466	ret = debugfs_create_file("split_huge_pages", 0200, NULL, NULL,
3467	&split_huge_pages_fops);	3467	&split_huge_pages_fops);
3468	if (!ret)	3468	if (!ret)
3469	pr_warn("Failed to create split_huge_pages in debugfs");	3469	pr_warn("Failed to create split_huge_pages in debugfs");

mm/memory.c+2−9

 		next = pmd_addr_end(addr, end);
 		if (pmd_trans_huge(*pmd) || pmd_devmap(*pmd)) {
 			if (next - addr != HPAGE_PMD_SIZE) {
-#ifdef CONFIG_DEBUG_VM
+				VM_BUG_ON_VMA(vma_is_anonymous(vma) &&
-				if (!rwsem_is_locked(&tlb->mm->mmap_sem)) {
+				    !rwsem_is_locked(&tlb->mm->mmap_sem), vma);
-					pr_err("%s: mmap_sem is unlocked! addr=0x%lx end=0x%lx vma->vm_start=0x%lx vma->vm_end=0x%lx\n",
-						__func__, addr, end,
-						vma->vm_start,
-						vma->vm_end);
-					BUG();
-				}
-#endif
 				split_huge_pmd(vma, pmd, addr);
 			} else if (zap_huge_pmd(tlb, vma, pmd, addr))
 				goto next;

mm/page-writeback.c+4−2

 	if (gdtc->dirty > gdtc->bg_thresh)
 		return true;
-	if (wb_stat(wb, WB_RECLAIMABLE) > __wb_calc_thresh(gdtc))
+	if (wb_stat(wb, WB_RECLAIMABLE) >
+	    wb_calc_thresh(gdtc->wb, gdtc->bg_thresh))
 		return true;
 	if (mdtc) {
 		if (mdtc->dirty > mdtc->bg_thresh)
 			return true;
-		if (wb_stat(wb, WB_RECLAIMABLE) > __wb_calc_thresh(mdtc))
+		if (wb_stat(wb, WB_RECLAIMABLE) >
+		    wb_calc_thresh(mdtc->wb, mdtc->bg_thresh))
 			return true;
 	}

mm/page_alloc.c+1−1

@@ -6485,7 +6485,7 @@ int __meminit init_per_zone_wmark_min(void) · 6484 unmodified lines
6485	setup_per_zone_inactive_ratio();	6485	setup_per_zone_inactive_ratio();
6486	return 0;	6486	return 0;
6487	}	6487	}
6488	module_init(init_per_zone_wmark_min)	6488	core_initcall(init_per_zone_wmark_min)
6489		6489
6490	/*	6490	/*
6491	* min_free_kbytes_sysctl_handler - just a wrapper around proc_dointvec() so	6491	* min_free_kbytes_sysctl_handler - just a wrapper around proc_dointvec() so

mm/zswap.c+7−1

 static LIST_HEAD(zswap_pools);
 /* protects zswap_pools list modification */
 static DEFINE_SPINLOCK(zswap_pools_lock);
+/* pool counter to provide unique names to zpool */
+static atomic_t zswap_pools_count = ATOMIC_INIT(0);
 /* used by param callback function */
 static bool zswap_init_started;
 static struct zswap_pool *zswap_pool_create(char *type, char *compressor)
 {
 	struct zswap_pool *pool;
+	char name[38]; /* 'zswap' + 32 char (max) num + \0 */
 	gfp_t gfp = __GFP_NORETRY | __GFP_NOWARN | __GFP_KSWAPD_RECLAIM;
 	pool = kzalloc(sizeof(*pool), GFP_KERNEL);
 		return NULL;
 	}
-	pool->zpool = zpool_create_pool(type, "zswap", gfp, &zswap_zpool_ops);
+	/* unique name for each pool specifically required by zsmalloc */
+	snprintf(name, 38, "zswap%x", atomic_inc_return(&zswap_pools_count));
+	pool->zpool = zpool_create_pool(type, name, gfp, &zswap_zpool_ops);
 	if (!pool->zpool) {
 		pr_err("%s zpool not available\n", type);
 		goto error;

net/bridge/br_ioctl.c+3−2

 #include <asm/uaccess.h>
 #include "br_private.h"
-/* called with RTNL */
 static int get_bridge_ifindices(struct net *net, int *indices, int num)
 {
 	struct net_device *dev;
 	int i = 0;
-	for_each_netdev(net, dev) {
+	rcu_read_lock();
+	for_each_netdev_rcu(net, dev) {
 		if (i >= num)
 			break;
 		if (dev->priv_flags & IFF_EBRIDGE)
 			indices[i++] = dev->ifindex;
 	}
+	rcu_read_unlock();
 	return i;
 }

net/bridge/br_multicast.c+7−5

 	struct br_ip saddr;
 	unsigned long max_delay;
 	unsigned long now = jiffies;
+	unsigned int offset = skb_transport_offset(skb);
 	__be32 group;
 	int err = 0;
 	group = ih->group;
-	if (skb->len == sizeof(*ih)) {
+	if (skb->len == offset + sizeof(*ih)) {
 		max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
 		if (!max_delay) {
 			max_delay = 10 * HZ;
 			group = 0;
 		}
-	} else if (skb->len >= sizeof(*ih3)) {
+	} else if (skb->len >= offset + sizeof(*ih3)) {
 		ih3 = igmpv3_query_hdr(skb);
 		if (ih3->nsrcs)
 			goto out;
 	struct br_ip saddr;
 	unsigned long max_delay;
 	unsigned long now = jiffies;
+	unsigned int offset = skb_transport_offset(skb);
 	const struct in6_addr *group = NULL;
 	bool is_general_query;
 	int err = 0;
 	    (port && port->state == BR_STATE_DISABLED))
 		goto out;
-	if (skb->len == sizeof(*mld)) {
+	if (skb->len == offset + sizeof(*mld)) {
-		if (!pskb_may_pull(skb, sizeof(*mld))) {
+		if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
 			err = -EINVAL;
 			goto out;
 		}
 		if (max_delay)
 			group = &mld->mld_mca;
 	} else {
-		if (!pskb_may_pull(skb, sizeof(*mld2q))) {
+		if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
 			err = -EINVAL;
 			goto out;
 		}

net/core/flow.c+13−1

 	list_splice_tail_init(&xfrm->flow_cache_gc_list, &gc_list);
 	spin_unlock_bh(&xfrm->flow_cache_gc_lock);
-	list_for_each_entry_safe(fce, n, &gc_list, u.gc_list)
+	list_for_each_entry_safe(fce, n, &gc_list, u.gc_list) {
 		flow_entry_kill(fce, xfrm);
+		atomic_dec(&xfrm->flow_cache_gc_count);
+		WARN_ON(atomic_read(&xfrm->flow_cache_gc_count) < 0);
+	}
 }
 static void flow_cache_queue_garbage(struct flow_cache_percpu *fcp,
 				     struct netns_xfrm *xfrm)
 {
 	if (deleted) {
+		atomic_add(deleted, &xfrm->flow_cache_gc_count);
 		fcp->hash_count -= deleted;
 		spin_lock_bh(&xfrm->flow_cache_gc_lock);
 		list_splice_tail(gc_list, &xfrm->flow_cache_gc_list);
 		if (fcp->hash_count > fc->high_watermark)
 			flow_cache_shrink(fc, fcp);
+		if (fcp->hash_count > 2 * fc->high_watermark ||
+		    atomic_read(&net->xfrm.flow_cache_gc_count) > fc->high_watermark) {
+			atomic_inc(&net->xfrm.flow_cache_genid);
+			flo = ERR_PTR(-ENOBUFS);
+			goto ret_object;
+		}
 		fle = kmem_cache_alloc(flow_cachep, GFP_ATOMIC);
 		if (fle) {
 			fle->net = net;
 	INIT_WORK(&net->xfrm.flow_cache_gc_work, flow_cache_gc_task);
 	INIT_WORK(&net->xfrm.flow_cache_flush_work, flow_cache_flush_task);
 	mutex_init(&net->xfrm.flow_flush_sem);
+	atomic_set(&net->xfrm.flow_cache_gc_count, 0);
 	fc->hash_shift = 10;
 	fc->low_watermark = 2 * flow_cache_hash_size(fc);

net/core/rtnetlink.c+10−8

@@ -1173,14 +1173,16 @@ static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb, · 1172 unmodified lines
1173		1173
1174	static int rtnl_fill_link_ifmap(struct sk_buff skb, struct net_device dev)	1174	static int rtnl_fill_link_ifmap(struct sk_buff skb, struct net_device dev)
1175	{	1175	{
1176	struct rtnl_link_ifmap map = {	1176	struct rtnl_link_ifmap map;
1177	.mem_start = dev->mem_start,	1177
1178	.mem_end = dev->mem_end,	1178	memset(&map, 0, sizeof(map));
1179	.base_addr = dev->base_addr,	1179	map.mem_start = dev->mem_start;
1180	.irq = dev->irq,	1180	map.mem_end = dev->mem_end;
1181	.dma = dev->dma,	1181	map.base_addr = dev->base_addr;
1182	.port = dev->if_port,	1182	map.irq = dev->irq;
1183	};	1183	map.dma = dev->dma;
		1184	map.port = dev->if_port;
		1185
1184	if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))	1186	if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
1185	return -EMSGSIZE;	1187	return -EMSGSIZE;
1186		1188

net/ipv4/fou.c+4−2

 	int err = -ENOSYS;
 	const struct net_offload **offloads;
-	udp_tunnel_gro_complete(skb, nhoff);
 	rcu_read_lock();
 	offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 	ops = rcu_dereference(offloads[proto]);
 	err = ops->callbacks.gro_complete(skb, nhoff);
+	skb_set_inner_mac_header(skb, nhoff);
 out_unlock:
 	rcu_read_unlock();
 	err = ops->callbacks.gro_complete(skb, nhoff + guehlen);
+	skb_set_inner_mac_header(skb, nhoff + guehlen);
 out_unlock:
 	rcu_read_unlock();
 	return err;

net/ipv4/ip_vti.c+18−0

@@ -156,6 +156,7 @@ static netdev_tx_t vti_xmit(struct sk_buff skb, struct net_device dev, · 155 unmodified lines
156	struct dst_entry *dst = skb_dst(skb);	156	struct dst_entry *dst = skb_dst(skb);
157	struct net_device tdev; / Device to other host */	157	struct net_device tdev; / Device to other host */
158	int err;	158	int err;
		159	int mtu;
159		160
160	if (!dst) {	161	if (!dst) {
161	dev->stats.tx_carrier_errors++;	162	dev->stats.tx_carrier_errors++;
@@ -192,6 +193,23 @@ static netdev_tx_t vti_xmit(struct sk_buff skb, struct net_device dev, · 30 unmodified lines
192	tunnel->err_count = 0;	193	tunnel->err_count = 0;
193	}	194	}
194		195
		196	mtu = dst_mtu(dst);
		197	if (skb->len > mtu) {
		198	skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
		199	if (skb->protocol == htons(ETH_P_IP)) {
		200	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
		201	htonl(mtu));
		202	} else {
		203	if (mtu < IPV6_MIN_MTU)
		204	mtu = IPV6_MIN_MTU;
		205
		206	icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
		207	}
		208
		209	dst_release(dst);
		210	goto tx_error;
		211	}
		212
195	skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(dev)));	213	skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(dev)));
196	skb_dst_set(skb, dst);	214	skb_dst_set(skb, dst);
197	skb->dev = skb_dst(skb)->dev;	215	skb->dev = skb_dst(skb)->dev;

net/ipv4/udp_offload.c+5−3

 	uh->len = newlen;
+	/* Set encapsulation before calling into inner gro_complete() functions
+	 * to make them set up the inner offsets.
+	 */
+	skb->encapsulation = 1;
 	rcu_read_lock();
 	sk = (*lookup)(skb, uh->source, uh->dest);
 	if (sk && udp_sk(sk)->gro_complete)
 	if (skb->remcsum_offload)
 		skb_shinfo(skb)->gso_type |= SKB_GSO_TUNNEL_REMCSUM;
-	skb->encapsulation = 1;
-	skb_set_inner_mac_header(skb, nhoff + sizeof(struct udphdr));
 	return err;
 }
 EXPORT_SYMBOL(udp_gro_complete);

net/ipv6/icmp.c+2−3

 	if (__ipv6_addr_needs_scope_id(addr_type))
 		iif = skb->dev->ifindex;
+	else
+		iif = l3mdev_master_ifindex(skb->dev);
 	/*
 	 *	Must not send error if the source does not uniquely
 	else if (!fl6.flowi6_oif)
 		fl6.flowi6_oif = np->ucast_oif;
-	if (!fl6.flowi6_oif)
-		fl6.flowi6_oif = l3mdev_master_ifindex(skb->dev);
 	dst = icmpv6_route_lookup(net, skb, sk, &fl6);
 	if (IS_ERR(dst))
 		goto out;

net/ipv6/tcp_ipv6.c+6−1

 	fl6.flowi6_proto = IPPROTO_TCP;
 	if (rt6_need_strict(&fl6.daddr) && !oif)
 		fl6.flowi6_oif = tcp_v6_iif(skb);
-	else
+	else {
+		if (!oif && netif_index_is_l3_master(net, skb->skb_iif))
+			oif = skb->skb_iif;
 		fl6.flowi6_oif = oif;
+	}
 	fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
 	fl6.fl6_dport = t1->dest;
 	fl6.fl6_sport = t1->source;

net/llc/af_llc.c+1−0

@@ -626,6 +626,7 @@ static void llc_cmsg_rcv(struct msghdr msg, struct sk_buff skb) · 625 unmodified lines
626	if (llc->cmsg_flags & LLC_CMSG_PKTINFO) {	626	if (llc->cmsg_flags & LLC_CMSG_PKTINFO) {
627	struct llc_pktinfo info;	627	struct llc_pktinfo info;
628		628
		629	memset(&info, 0, sizeof(info));
629	info.lpi_ifindex = llc_sk(skb->sk)->dev->ifindex;	630	info.lpi_ifindex = llc_sk(skb->sk)->dev->ifindex;
630	llc_pdu_decode_dsap(skb, &info.lpi_sap);	631	llc_pdu_decode_dsap(skb, &info.lpi_sap);
631	llc_pdu_decode_da(skb, info.lpi_mac);	632	llc_pdu_decode_da(skb, info.lpi_mac);

net/vmw_vsock/af_vsock.c+1−20

@@ -1808,27 +1808,8 @@ vsock_stream_recvmsg(struct socket sock, struct msghdr msg, size_t len, · 1807 unmodified lines
1808	else if (sk->sk_shutdown & RCV_SHUTDOWN)	1808	else if (sk->sk_shutdown & RCV_SHUTDOWN)
1809	err = 0;	1809	err = 0;
1810		1810
1811	if (copied > 0) {	1811	if (copied > 0)
1812	/* We only do these additional bookkeeping/notification steps
1813	* if we actually copied something out of the queue pair
1814	* instead of just peeking ahead.
1815	*/
1816
1817	if (!(flags & MSG_PEEK)) {
1818	/* If the other side has shutdown for sending and there
1819	* is nothing more to read, then modify the socket
1820	* state.
1821	*/
1822	if (vsk->peer_shutdown & SEND_SHUTDOWN) {
1823	if (vsock_stream_has_data(vsk) <= 0) {
1824	sk->sk_state = SS_UNCONNECTED;
1825	sock_set_flag(sk, SOCK_DONE);
1826	sk->sk_state_change(sk);
1827	}
1828	}
1829	}
1830	err = copied;	1812	err = copied;
1831	}
1832		1813
1833	out:	1814	out:
1834	release_sock(sk);	1815	release_sock(sk);

net/xfrm/xfrm_output.c+3−0

@@ -99,6 +99,9 @@ static int xfrm_output_one(struct sk_buff *skb, int err) · 98 unmodified lines
99		99
100	skb_dst_force(skb);	100	skb_dst_force(skb);
101		101
		102	/* Inner headers are invalid now. */
		103	skb->encapsulation = 0;
		104
102	err = x->type->output(x, skb);	105	err = x->type->output(x, skb);
103	if (err == -EINPROGRESS)	106	if (err == -EINPROGRESS)
104	goto out;	107	goto out;

scripts/mod/file2alias.c+45−24

@@ -371,6 +371,49 @@ static void do_usb_table(void *symval, unsigned long size, · 370 unmodified lines
371	do_usb_entry_multi(symval + i, mod);	371	do_usb_entry_multi(symval + i, mod);
372	}	372	}
373		373
		374	static void do_of_entry_multi(void symval, struct module mod)
		375	{
		376	char alias[500];
		377	int len;
		378	char *tmp;
		379
		380	DEF_FIELD_ADDR(symval, of_device_id, name);
		381	DEF_FIELD_ADDR(symval, of_device_id, type);
		382	DEF_FIELD_ADDR(symval, of_device_id, compatible);
		383
		384	len = sprintf(alias, "of:N%sT%s", (name)[0] ? name : "*",
		385	(type)[0] ? type : "*");
		386
		387	if (compatible[0])
		388	sprintf(&alias[len], "%sC%s", (type)[0] ? "" : "",
		389	*compatible);
		390
		391	/* Replace all whitespace with underscores */
		392	for (tmp = alias; tmp && *tmp; tmp++)
		393	if (isspace(*tmp))
		394	*tmp = '_';
		395
		396	buf_printf(&mod->dev_table_buf, "MODULE_ALIAS(\"%s\");\n", alias);
		397	strcat(alias, "C");
		398	add_wildcard(alias);
		399	buf_printf(&mod->dev_table_buf, "MODULE_ALIAS(\"%s\");\n", alias);
		400	}
		401
		402	static void do_of_table(void *symval, unsigned long size,
		403	struct module *mod)
		404	{
		405	unsigned int i;
		406	const unsigned long id_size = SIZE_of_device_id;
		407
		408	device_id_check(mod->name, "of", size, id_size, symval);
		409
		410	/* Leave last one: it's the terminator. */
		411	size -= id_size;
		412
		413	for (i = 0; i < size; i += id_size)
		414	do_of_entry_multi(symval + i, mod);
		415	}
		416
374	/* Looks like: hid:bNvNpN */	417	/* Looks like: hid:bNvNpN */
375	static int do_hid_entry(const char *filename,	418	static int do_hid_entry(const char *filename,
376	void symval, char alias)	419	void symval, char alias)
@@ -684,30 +727,6 @@ static int do_pcmcia_entry(const char *filename, · 307 unmodified lines
684	}	727	}
685	ADD_TO_DEVTABLE("pcmcia", pcmcia_device_id, do_pcmcia_entry);	728	ADD_TO_DEVTABLE("pcmcia", pcmcia_device_id, do_pcmcia_entry);
686		729
687	static int do_of_entry (const char filename, void symval, char *alias)
688	{
689	int len;
690	char *tmp;
691	DEF_FIELD_ADDR(symval, of_device_id, name);
692	DEF_FIELD_ADDR(symval, of_device_id, type);
693	DEF_FIELD_ADDR(symval, of_device_id, compatible);
694
695	len = sprintf(alias, "of:N%sT%s", (name)[0] ? name : "*",
696	(type)[0] ? type : "*");
697
698	if (compatible[0])
699	sprintf(&alias[len], "%sC%s", (type)[0] ? "" : "",
700	*compatible);
701
702	/* Replace all whitespace with underscores */
703	for (tmp = alias; tmp && *tmp; tmp++)
704	if (isspace (*tmp))
705	*tmp = '_';
706
707	return 1;
708	}
709	ADD_TO_DEVTABLE("of", of_device_id, do_of_entry);
710
711	static int do_vio_entry(const char filename, void symval,	730	static int do_vio_entry(const char filename, void symval,
712	char *alias)	731	char *alias)
713	{	732	{
@@ -1348,6 +1367,8 @@ void handle_moddevtable(struct module mod, struct elf_info info, · 634 unmodified lines
1348	/* First handle the "special" cases */	1367	/* First handle the "special" cases */
1349	if (sym_is(name, namelen, "usb"))	1368	if (sym_is(name, namelen, "usb"))
1350	do_usb_table(symval, sym->st_size, mod);	1369	do_usb_table(symval, sym->st_size, mod);
		1370	if (sym_is(name, namelen, "of"))
		1371	do_of_table(symval, sym->st_size, mod);
1351	else if (sym_is(name, namelen, "pnp"))	1372	else if (sym_is(name, namelen, "pnp"))
1352	do_pnp_device_entry(symval, sym->st_size, mod);	1373	do_pnp_device_entry(symval, sym->st_size, mod);
1353	else if (sym_is(name, namelen, "pnp_card"))	1374	else if (sym_is(name, namelen, "pnp_card"))

security/integrity/ima/ima_policy.c+2−2

 	"BPRM_CHECK",
 	"MODULE_CHECK",
 	"FIRMWARE_CHECK",
+	"POST_SETATTR",
 	"KEXEC_KERNEL_CHECK",
 	"KEXEC_INITRAMFS_CHECK",
-	"POLICY_CHECK",
+	"POLICY_CHECK"
-	"POST_SETATTR"
 };
 void *ima_policy_start(struct seq_file *m, loff_t *pos)

tools/net/bpf_jit_disasm.c+3−0

@@ -98,6 +98,9 @@ static char get_klog_buff(unsigned int klen) · 97 unmodified lines
98	char *buff;	98	char *buff;
99		99
100	len = klogctl(CMD_ACTION_SIZE_BUFFER, NULL, 0);	100	len = klogctl(CMD_ACTION_SIZE_BUFFER, NULL, 0);
		101	if (len < 0)
		102	return NULL;
		103
101	buff = malloc(len);	104	buff = malloc(len);
102	if (!buff)	105	if (!buff)
103	return NULL;	106	return NULL;

@@ -69,18 +69,18 @@ LCO: Local Checksum Offload · 68 unmodified lines
69	LCO is a technique for efficiently computing the outer checksum of an	69	LCO is a technique for efficiently computing the outer checksum of an
70	encapsulated datagram when the inner checksum is due to be offloaded.	70	encapsulated datagram when the inner checksum is due to be offloaded.
71	The ones-complement sum of a correctly checksummed TCP or UDP packet is	71	The ones-complement sum of a correctly checksummed TCP or UDP packet is
72	equal to the sum of the pseudo header, because everything else gets	72	equal to the complement of the sum of the pseudo header, because everything
73	'cancelled out' by the checksum field. This is because the sum was	73	else gets 'cancelled out' by the checksum field. This is because the sum was
74	complemented before being written to the checksum field.	74	complemented before being written to the checksum field.
75	More generally, this holds in any case where the 'IP-style' ones complement	75	More generally, this holds in any case where the 'IP-style' ones complement
76	checksum is used, and thus any checksum that TX Checksum Offload supports.	76	checksum is used, and thus any checksum that TX Checksum Offload supports.
77	That is, if we have set up TX Checksum Offload with a start/offset pair, we	77	That is, if we have set up TX Checksum Offload with a start/offset pair, we
78	know that _after the device has filled in that checksum_, the ones	78	know that after the device has filled in that checksum, the ones
79	complement sum from csum_start to the end of the packet will be equal to	79	complement sum from csum_start to the end of the packet will be equal to
80	_whatever value we put in the checksum field beforehand_. This allows us	80	the complement of whatever value we put in the checksum field beforehand.
81	to compute the outer checksum without looking at the payload: we simply	81	This allows us to compute the outer checksum without looking at the payload:
82	stop summing when we get to csum_start, then add the 16-bit word at	82	we simply stop summing when we get to csum_start, then add the complement of
83	(csum_start + csum_offset).	83	the 16-bit word at (csum_start + csum_offset).
84	Then, when the true inner checksum is filled in (either by hardware or by	84	Then, when the true inner checksum is filled in (either by hardware or by
85	skb_checksum_help()), the outer checksum will become correct by virtue of	85	skb_checksum_help()), the outer checksum will become correct by virtue of
86	the arithmetic.	86	the arithmetic.