[gentoo-commits] proj/linux-patches:4.4 commit in: /

[Mike Pagano]

commit:     fffd611ef3a232075303cabed9e60a230583a1a9
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Sun Feb 25 15:46:14 2018 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Sun Feb 25 15:46:14 2018 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=fffd611e

Linux patch 4.4.118

 0000_README              |    4 +
 1117_linux-4.4.118.patch | 9661 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 9665 insertions(+)

diff --git a/0000_README b/0000_README
index 2d08c4f..94125fa 100644
--- a/0000_README
+++ b/0000_README
@@ -511,6 +511,10 @@ Patch:  1116_linux-4.4.117.patch
 From:   http://www.kernel.org
 Desc:   Linux 4.4.117
 
+Patch:  1117_linux-4.4.118.patch
+From:   http://www.kernel.org
+Desc:   Linux 4.4.118
+
 Patch:  1500_XATTR_USER_PREFIX.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=470644
 Desc:   Support for namespace user.pax.* on tmpfs.

diff --git a/1117_linux-4.4.118.patch b/1117_linux-4.4.118.patch
new file mode 100644
index 0000000..6f05ed0
--- /dev/null
+++ b/1117_linux-4.4.118.patch
@@ -0,0 +1,9661 @@
+diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
+index 22a4688dc0c8..f53ef1ac3122 100644
+--- a/Documentation/kernel-parameters.txt
++++ b/Documentation/kernel-parameters.txt
+@@ -2565,8 +2565,6 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
+ 	norandmaps	Don't use address space randomization.  Equivalent to
+ 			echo 0 > /proc/sys/kernel/randomize_va_space
+ 
+-	noreplace-paravirt	[X86,IA-64,PV_OPS] Don't patch paravirt_ops
+-
+ 	noreplace-smp	[X86-32,SMP] Don't replace SMP instructions
+ 			with UP alternatives
+ 
+diff --git a/Documentation/speculation.txt b/Documentation/speculation.txt
+new file mode 100644
+index 000000000000..e9e6cbae2841
+--- /dev/null
++++ b/Documentation/speculation.txt
+@@ -0,0 +1,90 @@
++This document explains potential effects of speculation, and how undesirable
++effects can be mitigated portably using common APIs.
++
++===========
++Speculation
++===========
++
++To improve performance and minimize average latencies, many contemporary CPUs
++employ speculative execution techniques such as branch prediction, performing
++work which may be discarded at a later stage.
++
++Typically speculative execution cannot be observed from architectural state,
++such as the contents of registers. However, in some cases it is possible to
++observe its impact on microarchitectural state, such as the presence or
++absence of data in caches. Such state may form side-channels which can be
++observed to extract secret information.
++
++For example, in the presence of branch prediction, it is possible for bounds
++checks to be ignored by code which is speculatively executed. Consider the
++following code:
++
++	int load_array(int *array, unsigned int index)
++	{
++		if (index >= MAX_ARRAY_ELEMS)
++			return 0;
++		else
++			return array[index];
++	}
++
++Which, on arm64, may be compiled to an assembly sequence such as:
++
++	CMP	<index>, #MAX_ARRAY_ELEMS
++	B.LT	less
++	MOV	<returnval>, #0
++	RET
++  less:
++	LDR	<returnval>, [<array>, <index>]
++	RET
++
++It is possible that a CPU mis-predicts the conditional branch, and
++speculatively loads array[index], even if index >= MAX_ARRAY_ELEMS. This
++value will subsequently be discarded, but the speculated load may affect
++microarchitectural state which can be subsequently measured.
++
++More complex sequences involving multiple dependent memory accesses may
++result in sensitive information being leaked. Consider the following
++code, building on the prior example:
++
++	int load_dependent_arrays(int *arr1, int *arr2, int index)
++	{
++		int val1, val2,
++
++		val1 = load_array(arr1, index);
++		val2 = load_array(arr2, val1);
++
++		return val2;
++	}
++
++Under speculation, the first call to load_array() may return the value
++of an out-of-bounds address, while the second call will influence
++microarchitectural state dependent on this value. This may provide an
++arbitrary read primitive.
++
++====================================
++Mitigating speculation side-channels
++====================================
++
++The kernel provides a generic API to ensure that bounds checks are
++respected even under speculation. Architectures which are affected by
++speculation-based side-channels are expected to implement these
++primitives.
++
++The array_index_nospec() helper in <linux/nospec.h> can be used to
++prevent information from being leaked via side-channels.
++
++A call to array_index_nospec(index, size) returns a sanitized index
++value that is bounded to [0, size) even under cpu speculation
++conditions.
++
++This can be used to protect the earlier load_array() example:
++
++	int load_array(int *array, unsigned int index)
++	{
++		if (index >= MAX_ARRAY_ELEMS)
++			return 0;
++		else {
++			index = array_index_nospec(index, MAX_ARRAY_ELEMS);
++			return array[index];
++		}
++	}
+diff --git a/Makefile b/Makefile
+index 9f53ba1835ad..1e01148744f3 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,6 +1,6 @@
+ VERSION = 4
+ PATCHLEVEL = 4
+-SUBLEVEL = 117
++SUBLEVEL = 118
+ EXTRAVERSION =
+ NAME = Blurry Fish Butt
+ 
+@@ -87,10 +87,12 @@ endif
+ ifneq ($(filter 4.%,$(MAKE_VERSION)),)	# make-4
+ ifneq ($(filter %s ,$(firstword x$(MAKEFLAGS))),)
+   quiet=silent_
++  tools_silent=s
+ endif
+ else					# make-3.8x
+ ifneq ($(filter s% -s%,$(MAKEFLAGS)),)
+   quiet=silent_
++  tools_silent=-s
+ endif
+ endif
+ 
+@@ -1523,11 +1525,11 @@ image_name:
+ # Clear a bunch of variables before executing the submake
+ tools/: FORCE
+ 	$(Q)mkdir -p $(objtree)/tools
+-	$(Q)$(MAKE) LDFLAGS= MAKEFLAGS="$(filter --j% -j,$(MAKEFLAGS))" O=$(shell cd $(objtree) && /bin/pwd) subdir=tools -C $(src)/tools/
++	$(Q)$(MAKE) LDFLAGS= MAKEFLAGS="$(tools_silent) $(filter --j% -j,$(MAKEFLAGS))" O=$(shell cd $(objtree) && /bin/pwd) subdir=tools -C $(src)/tools/
+ 
+ tools/%: FORCE
+ 	$(Q)mkdir -p $(objtree)/tools
+-	$(Q)$(MAKE) LDFLAGS= MAKEFLAGS="$(filter --j% -j,$(MAKEFLAGS))" O=$(shell cd $(objtree) && /bin/pwd) subdir=tools -C $(src)/tools/ $*
++	$(Q)$(MAKE) LDFLAGS= MAKEFLAGS="$(tools_silent) $(filter --j% -j,$(MAKEFLAGS))" O=$(shell cd $(objtree) && /bin/pwd) subdir=tools -C $(src)/tools/ $*
+ 
+ # Single targets
+ # ---------------------------------------------------------------------------
+diff --git a/arch/arm/boot/dts/am4372.dtsi b/arch/arm/boot/dts/am4372.dtsi
+index de8791a4d131..3ef1d5a26389 100644
+--- a/arch/arm/boot/dts/am4372.dtsi
++++ b/arch/arm/boot/dts/am4372.dtsi
+@@ -807,7 +807,8 @@
+ 			reg = <0x48038000 0x2000>,
+ 			      <0x46000000 0x400000>;
+ 			reg-names = "mpu", "dat";
+-			interrupts = <80>, <81>;
++			interrupts = <GIC_SPI 80 IRQ_TYPE_LEVEL_HIGH>,
++				     <GIC_SPI 81 IRQ_TYPE_LEVEL_HIGH>;
+ 			interrupt-names = "tx", "rx";
+ 			status = "disabled";
+ 			dmas = <&edma 8>,
+@@ -821,7 +822,8 @@
+ 			reg = <0x4803C000 0x2000>,
+ 			      <0x46400000 0x400000>;
+ 			reg-names = "mpu", "dat";
+-			interrupts = <82>, <83>;
++			interrupts = <GIC_SPI 82 IRQ_TYPE_LEVEL_HIGH>,
++				     <GIC_SPI 83 IRQ_TYPE_LEVEL_HIGH>;
+ 			interrupt-names = "tx", "rx";
+ 			status = "disabled";
+ 			dmas = <&edma 10>,
+diff --git a/arch/arm/boot/dts/omap4.dtsi b/arch/arm/boot/dts/omap4.dtsi
+index 5a206c100ce2..8a5628c4b135 100644
+--- a/arch/arm/boot/dts/omap4.dtsi
++++ b/arch/arm/boot/dts/omap4.dtsi
+@@ -844,14 +844,12 @@
+ 			usbhsohci: ohci@4a064800 {
+ 				compatible = "ti,ohci-omap3";
+ 				reg = <0x4a064800 0x400>;
+-				interrupt-parent = <&gic>;
+ 				interrupts = <GIC_SPI 76 IRQ_TYPE_LEVEL_HIGH>;
+ 			};
+ 
+ 			usbhsehci: ehci@4a064c00 {
+ 				compatible = "ti,ehci-omap";
+ 				reg = <0x4a064c00 0x400>;
+-				interrupt-parent = <&gic>;
+ 				interrupts = <GIC_SPI 77 IRQ_TYPE_LEVEL_HIGH>;
+ 			};
+ 		};
+diff --git a/arch/arm/mach-omap2/omap-secure.c b/arch/arm/mach-omap2/omap-secure.c
+index 5ac122e88f67..9ff92050053c 100644
+--- a/arch/arm/mach-omap2/omap-secure.c
++++ b/arch/arm/mach-omap2/omap-secure.c
+@@ -73,6 +73,25 @@ phys_addr_t omap_secure_ram_mempool_base(void)
+ 	return omap_secure_memblock_base;
+ }
+ 
++u32 omap3_save_secure_ram(void __iomem *addr, int size)
++{
++	u32 ret;
++	u32 param[5];
++
++	if (size != OMAP3_SAVE_SECURE_RAM_SZ)
++		return OMAP3_SAVE_SECURE_RAM_SZ;
++
++	param[0] = 4;		/* Number of arguments */
++	param[1] = __pa(addr);	/* Physical address for saving */
++	param[2] = 0;
++	param[3] = 1;
++	param[4] = 1;
++
++	ret = save_secure_ram_context(__pa(param));
++
++	return ret;
++}
++
+ /**
+  * rx51_secure_dispatcher: Routine to dispatch secure PPA API calls
+  * @idx: The PPA API index
+diff --git a/arch/arm/mach-omap2/omap-secure.h b/arch/arm/mach-omap2/omap-secure.h
+index af2851fbcdf0..ab6ce2597a88 100644
+--- a/arch/arm/mach-omap2/omap-secure.h
++++ b/arch/arm/mach-omap2/omap-secure.h
+@@ -31,6 +31,8 @@
+ /* Maximum Secure memory storage size */
+ #define OMAP_SECURE_RAM_STORAGE	(88 * SZ_1K)
+ 
++#define OMAP3_SAVE_SECURE_RAM_SZ	0x803F
++
+ /* Secure low power HAL API index */
+ #define OMAP4_HAL_SAVESECURERAM_INDEX	0x1a
+ #define OMAP4_HAL_SAVEHW_INDEX		0x1b
+@@ -64,6 +66,8 @@ extern u32 omap_smc2(u32 id, u32 falg, u32 pargs);
+ extern u32 omap_smc3(u32 id, u32 process, u32 flag, u32 pargs);
+ extern phys_addr_t omap_secure_ram_mempool_base(void);
+ extern int omap_secure_ram_reserve_memblock(void);
++extern u32 save_secure_ram_context(u32 args_pa);
++extern u32 omap3_save_secure_ram(void __iomem *save_regs, int size);
+ 
+ extern u32 rx51_secure_dispatcher(u32 idx, u32 process, u32 flag, u32 nargs,
+ 				  u32 arg1, u32 arg2, u32 arg3, u32 arg4);
+diff --git a/arch/arm/mach-omap2/pm.h b/arch/arm/mach-omap2/pm.h
+index b668719b9b25..8e30772cfe32 100644
+--- a/arch/arm/mach-omap2/pm.h
++++ b/arch/arm/mach-omap2/pm.h
+@@ -81,10 +81,6 @@ extern unsigned int omap3_do_wfi_sz;
+ /* ... and its pointer from SRAM after copy */
+ extern void (*omap3_do_wfi_sram)(void);
+ 
+-/* save_secure_ram_context function pointer and size, for copy to SRAM */
+-extern int save_secure_ram_context(u32 *addr);
+-extern unsigned int save_secure_ram_context_sz;
+-
+ extern void omap3_save_scratchpad_contents(void);
+ 
+ #define PM_RTA_ERRATUM_i608		(1 << 0)
+diff --git a/arch/arm/mach-omap2/pm34xx.c b/arch/arm/mach-omap2/pm34xx.c
+index 2dbd3785ee6f..181da202f981 100644
+--- a/arch/arm/mach-omap2/pm34xx.c
++++ b/arch/arm/mach-omap2/pm34xx.c
+@@ -48,6 +48,7 @@
+ #include "prm3xxx.h"
+ #include "pm.h"
+ #include "sdrc.h"
++#include "omap-secure.h"
+ #include "sram.h"
+ #include "control.h"
+ #include "vc.h"
+@@ -66,7 +67,6 @@ struct power_state {
+ 
+ static LIST_HEAD(pwrst_list);
+ 
+-static int (*_omap_save_secure_sram)(u32 *addr);
+ void (*omap3_do_wfi_sram)(void);
+ 
+ static struct powerdomain *mpu_pwrdm, *neon_pwrdm;
+@@ -121,8 +121,8 @@ static void omap3_save_secure_ram_context(void)
+ 		 * will hang the system.
+ 		 */
+ 		pwrdm_set_next_pwrst(mpu_pwrdm, PWRDM_POWER_ON);
+-		ret = _omap_save_secure_sram((u32 *)(unsigned long)
+-				__pa(omap3_secure_ram_storage));
++		ret = omap3_save_secure_ram(omap3_secure_ram_storage,
++					    OMAP3_SAVE_SECURE_RAM_SZ);
+ 		pwrdm_set_next_pwrst(mpu_pwrdm, mpu_next_state);
+ 		/* Following is for error tracking, it should not happen */
+ 		if (ret) {
+@@ -431,15 +431,10 @@ static int __init pwrdms_setup(struct powerdomain *pwrdm, void *unused)
+  *
+  * The minimum set of functions is pushed to SRAM for execution:
+  * - omap3_do_wfi for erratum i581 WA,
+- * - save_secure_ram_context for security extensions.
+  */
+ void omap_push_sram_idle(void)
+ {
+ 	omap3_do_wfi_sram = omap_sram_push(omap3_do_wfi, omap3_do_wfi_sz);
+-
+-	if (omap_type() != OMAP2_DEVICE_TYPE_GP)
+-		_omap_save_secure_sram = omap_sram_push(save_secure_ram_context,
+-				save_secure_ram_context_sz);
+ }
+ 
+ static void __init pm_errata_configure(void)
+@@ -551,7 +546,7 @@ int __init omap3_pm_init(void)
+ 	clkdm_add_wkdep(neon_clkdm, mpu_clkdm);
+ 	if (omap_type() != OMAP2_DEVICE_TYPE_GP) {
+ 		omap3_secure_ram_storage =
+-			kmalloc(0x803F, GFP_KERNEL);
++			kmalloc(OMAP3_SAVE_SECURE_RAM_SZ, GFP_KERNEL);
+ 		if (!omap3_secure_ram_storage)
+ 			pr_err("Memory allocation failed when allocating for secure sram context\n");
+ 
+diff --git a/arch/arm/mach-omap2/prm33xx.c b/arch/arm/mach-omap2/prm33xx.c
+index dcb5001d77da..973bcd754e1c 100644
+--- a/arch/arm/mach-omap2/prm33xx.c
++++ b/arch/arm/mach-omap2/prm33xx.c
+@@ -176,17 +176,6 @@ static int am33xx_pwrdm_read_pwrst(struct powerdomain *pwrdm)
+ 	return v;
+ }
+ 
+-static int am33xx_pwrdm_read_prev_pwrst(struct powerdomain *pwrdm)
+-{
+-	u32 v;
+-
+-	v = am33xx_prm_read_reg(pwrdm->prcm_offs, pwrdm->pwrstst_offs);
+-	v &= AM33XX_LASTPOWERSTATEENTERED_MASK;
+-	v >>= AM33XX_LASTPOWERSTATEENTERED_SHIFT;
+-
+-	return v;
+-}
+-
+ static int am33xx_pwrdm_set_lowpwrstchange(struct powerdomain *pwrdm)
+ {
+ 	am33xx_prm_rmw_reg_bits(AM33XX_LOWPOWERSTATECHANGE_MASK,
+@@ -357,7 +346,6 @@ struct pwrdm_ops am33xx_pwrdm_operations = {
+ 	.pwrdm_set_next_pwrst		= am33xx_pwrdm_set_next_pwrst,
+ 	.pwrdm_read_next_pwrst		= am33xx_pwrdm_read_next_pwrst,
+ 	.pwrdm_read_pwrst		= am33xx_pwrdm_read_pwrst,
+-	.pwrdm_read_prev_pwrst		= am33xx_pwrdm_read_prev_pwrst,
+ 	.pwrdm_set_logic_retst		= am33xx_pwrdm_set_logic_retst,
+ 	.pwrdm_read_logic_pwrst		= am33xx_pwrdm_read_logic_pwrst,
+ 	.pwrdm_read_logic_retst		= am33xx_pwrdm_read_logic_retst,
+diff --git a/arch/arm/mach-omap2/sleep34xx.S b/arch/arm/mach-omap2/sleep34xx.S
+index 1b9f0520dea9..3e0d802c59da 100644
+--- a/arch/arm/mach-omap2/sleep34xx.S
++++ b/arch/arm/mach-omap2/sleep34xx.S
+@@ -93,20 +93,13 @@ ENTRY(enable_omap3630_toggle_l2_on_restore)
+ ENDPROC(enable_omap3630_toggle_l2_on_restore)
+ 
+ /*
+- * Function to call rom code to save secure ram context. This gets
+- * relocated to SRAM, so it can be all in .data section. Otherwise
+- * we need to initialize api_params separately.
++ * Function to call rom code to save secure ram context.
++ *
++ * r0 = physical address of the parameters
+  */
+-	.data
+-	.align	3
+ ENTRY(save_secure_ram_context)
+ 	stmfd	sp!, {r4 - r11, lr}	@ save registers on stack
+-	adr	r3, api_params		@ r3 points to parameters
+-	str	r0, [r3,#0x4]		@ r0 has sdram address
+-	ldr	r12, high_mask
+-	and	r3, r3, r12
+-	ldr	r12, sram_phy_addr_mask
+-	orr	r3, r3, r12
++	mov	r3, r0			@ physical address of parameters
+ 	mov	r0, #25			@ set service ID for PPA
+ 	mov	r12, r0			@ copy secure service ID in r12
+ 	mov	r1, #0			@ set task id for ROM code in r1
+@@ -120,18 +113,7 @@ ENTRY(save_secure_ram_context)
+ 	nop
+ 	nop
+ 	ldmfd	sp!, {r4 - r11, pc}
+-	.align
+-sram_phy_addr_mask:
+-	.word	SRAM_BASE_P
+-high_mask:
+-	.word	0xffff
+-api_params:
+-	.word	0x4, 0x0, 0x0, 0x1, 0x1
+ ENDPROC(save_secure_ram_context)
+-ENTRY(save_secure_ram_context_sz)
+-	.word	. - save_secure_ram_context
+-
+-	.text
+ 
+ /*
+  * ======================
+diff --git a/arch/arm/mach-tegra/Kconfig b/arch/arm/mach-tegra/Kconfig
+index 0fa4c5f8b1be..2d43357d4a0a 100644
+--- a/arch/arm/mach-tegra/Kconfig
++++ b/arch/arm/mach-tegra/Kconfig
+@@ -12,8 +12,6 @@ menuconfig ARCH_TEGRA
+ 	select ARCH_HAS_RESET_CONTROLLER
+ 	select RESET_CONTROLLER
+ 	select SOC_BUS
+-	select USB_ULPI if USB_PHY
+-	select USB_ULPI_VIEWPORT if USB_PHY
+ 	help
+ 	  This enables support for NVIDIA Tegra based systems.
+ 
+diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig
+index 83af36d9439f..02c08671553e 100644
+--- a/arch/arm64/Kconfig
++++ b/arch/arm64/Kconfig
+@@ -785,7 +785,7 @@ source "fs/Kconfig.binfmt"
+ config COMPAT
+ 	bool "Kernel support for 32-bit EL0"
+ 	depends on ARM64_4K_PAGES || EXPERT
+-	select COMPAT_BINFMT_ELF
++	select COMPAT_BINFMT_ELF if BINFMT_ELF
+ 	select HAVE_UID16
+ 	select OLD_SIGSUSPEND3
+ 	select COMPAT_OLD_SIGACTION
+diff --git a/arch/arm64/Kconfig.platforms b/arch/arm64/Kconfig.platforms
+index 4043c35962cc..5edb50772c11 100644
+--- a/arch/arm64/Kconfig.platforms
++++ b/arch/arm64/Kconfig.platforms
+@@ -90,8 +90,6 @@ config ARCH_TEGRA_132_SOC
+ 	bool "NVIDIA Tegra132 SoC"
+ 	depends on ARCH_TEGRA
+ 	select PINCTRL_TEGRA124
+-	select USB_ULPI if USB_PHY
+-	select USB_ULPI_VIEWPORT if USB_PHY
+ 	help
+ 	  Enable support for NVIDIA Tegra132 SoC, based on the Denver
+ 	  ARMv8 CPU.  The Tegra132 SoC is similar to the Tegra124 SoC,
+diff --git a/arch/arm64/boot/dts/mediatek/mt8173.dtsi b/arch/arm64/boot/dts/mediatek/mt8173.dtsi
+index 4dd5f93d0303..7f42b646d528 100644
+--- a/arch/arm64/boot/dts/mediatek/mt8173.dtsi
++++ b/arch/arm64/boot/dts/mediatek/mt8173.dtsi
+@@ -54,6 +54,7 @@
+ 			reg = <0x000>;
+ 			enable-method = "psci";
+ 			cpu-idle-states = <&CPU_SLEEP_0>;
++			#cooling-cells = <2>;
+ 		};
+ 
+ 		cpu1: cpu@1 {
+@@ -70,6 +71,7 @@
+ 			reg = <0x100>;
+ 			enable-method = "psci";
+ 			cpu-idle-states = <&CPU_SLEEP_0>;
++			#cooling-cells = <2>;
+ 		};
+ 
+ 		cpu3: cpu@101 {
+diff --git a/arch/arm64/include/asm/bug.h b/arch/arm64/include/asm/bug.h
+index 4a748ce9ba1a..ac6382b25add 100644
+--- a/arch/arm64/include/asm/bug.h
++++ b/arch/arm64/include/asm/bug.h
+@@ -20,9 +20,6 @@
+ 
+ #include <asm/debug-monitors.h>
+ 
+-#ifdef CONFIG_GENERIC_BUG
+-#define HAVE_ARCH_BUG
+-
+ #ifdef CONFIG_DEBUG_BUGVERBOSE
+ #define _BUGVERBOSE_LOCATION(file, line) __BUGVERBOSE_LOCATION(file, line)
+ #define __BUGVERBOSE_LOCATION(file, line)				\
+@@ -36,28 +33,36 @@
+ #define _BUGVERBOSE_LOCATION(file, line)
+ #endif
+ 
+-#define _BUG_FLAGS(flags) __BUG_FLAGS(flags)
++#ifdef CONFIG_GENERIC_BUG
+ 
+-#define __BUG_FLAGS(flags) asm volatile (		\
++#define __BUG_ENTRY(flags) 				\
+ 		".pushsection __bug_table,\"a\"\n\t"	\
+ 		".align 2\n\t"				\
+ 	"0:	.long 1f - 0b\n\t"			\
+ _BUGVERBOSE_LOCATION(__FILE__, __LINE__)		\
+ 		".short " #flags "\n\t"			\
+ 		".popsection\n"				\
+-							\
+-	"1:	brk %[imm]"				\
+-		:: [imm] "i" (BUG_BRK_IMM)		\
+-)
++	"1:	"
++#else
++#define __BUG_ENTRY(flags) ""
++#endif
++
++#define __BUG_FLAGS(flags)				\
++	asm volatile (					\
++		__BUG_ENTRY(flags)			\
++		"brk %[imm]" :: [imm] "i" (BUG_BRK_IMM)	\
++	);
+ 
+-#define BUG() do {				\
+-	_BUG_FLAGS(0);				\
+-	unreachable();				\
++
++#define BUG() do {					\
++	__BUG_FLAGS(0);					\
++	unreachable();					\
+ } while (0)
+ 
+-#define __WARN_TAINT(taint) _BUG_FLAGS(BUGFLAG_TAINT(taint))
++#define __WARN_TAINT(taint) 				\
++	__BUG_FLAGS(BUGFLAG_TAINT(taint))
+ 
+-#endif /* ! CONFIG_GENERIC_BUG */
++#define HAVE_ARCH_BUG
+ 
+ #include <asm-generic/bug.h>
+ 
+diff --git a/arch/powerpc/perf/core-book3s.c b/arch/powerpc/perf/core-book3s.c
+index b2ab164a8094..4eba7c00ea1f 100644
+--- a/arch/powerpc/perf/core-book3s.c
++++ b/arch/powerpc/perf/core-book3s.c
+@@ -1381,7 +1381,7 @@ static int collect_events(struct perf_event *group, int max_count,
+ 	int n = 0;
+ 	struct perf_event *event;
+ 
+-	if (!is_software_event(group)) {
++	if (group->pmu->task_ctx_nr == perf_hw_context) {
+ 		if (n >= max_count)
+ 			return -1;
+ 		ctrs[n] = group;
+@@ -1389,7 +1389,7 @@ static int collect_events(struct perf_event *group, int max_count,
+ 		events[n++] = group->hw.config;
+ 	}
+ 	list_for_each_entry(event, &group->sibling_list, group_entry) {
+-		if (!is_software_event(event) &&
++		if (event->pmu->task_ctx_nr == perf_hw_context &&
+ 		    event->state != PERF_EVENT_STATE_OFF) {
+ 			if (n >= max_count)
+ 				return -1;
+diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
+index 2db93042f2f3..bb6aab2fa7f5 100644
+--- a/arch/x86/Kconfig
++++ b/arch/x86/Kconfig
+@@ -1009,7 +1009,7 @@ config X86_MCE_THRESHOLD
+ 	def_bool y
+ 
+ config X86_MCE_INJECT
+-	depends on X86_MCE
++	depends on X86_MCE && X86_LOCAL_APIC
+ 	tristate "Machine check injector support"
+ 	---help---
+ 	  Provide support for injecting machine checks for testing purposes.
+diff --git a/arch/x86/Kconfig.debug b/arch/x86/Kconfig.debug
+index 137dfa96aa14..da00fe1f48f4 100644
+--- a/arch/x86/Kconfig.debug
++++ b/arch/x86/Kconfig.debug
+@@ -391,6 +391,7 @@ config X86_DEBUG_FPU
+ 
+ config PUNIT_ATOM_DEBUG
+ 	tristate "ATOM Punit debug driver"
++	depends on PCI
+ 	select DEBUG_FS
+ 	select IOSF_MBI
+ 	---help---
+diff --git a/arch/x86/boot/Makefile b/arch/x86/boot/Makefile
+index c0cc2a6be0bf..6da2cd0897f3 100644
+--- a/arch/x86/boot/Makefile
++++ b/arch/x86/boot/Makefile
+@@ -64,12 +64,13 @@ GCOV_PROFILE := n
+ $(obj)/bzImage: asflags-y  := $(SVGA_MODE)
+ 
+ quiet_cmd_image = BUILD   $@
++silent_redirect_image = >/dev/null
+ cmd_image = $(obj)/tools/build $(obj)/setup.bin $(obj)/vmlinux.bin \
+-			       $(obj)/zoffset.h $@
++			       $(obj)/zoffset.h $@ $($(quiet)redirect_image)
+ 
+ $(obj)/bzImage: $(obj)/setup.bin $(obj)/vmlinux.bin $(obj)/tools/build FORCE
+ 	$(call if_changed,image)
+-	@echo 'Kernel: $@ is ready' ' (#'`cat .version`')'
++	@$(kecho) 'Kernel: $@ is ready' ' (#'`cat .version`')'
+ 
+ OBJCOPYFLAGS_vmlinux.bin := -O binary -R .note -R .comment -S
+ $(obj)/vmlinux.bin: $(obj)/compressed/vmlinux FORCE
+diff --git a/arch/x86/crypto/twofish-x86_64-asm_64-3way.S b/arch/x86/crypto/twofish-x86_64-asm_64-3way.S
+index 1c3b7ceb36d2..e7273a606a07 100644
+--- a/arch/x86/crypto/twofish-x86_64-asm_64-3way.S
++++ b/arch/x86/crypto/twofish-x86_64-asm_64-3way.S
+@@ -55,29 +55,31 @@
+ #define RAB1bl %bl
+ #define RAB2bl %cl
+ 
++#define CD0 0x0(%rsp)
++#define CD1 0x8(%rsp)
++#define CD2 0x10(%rsp)
++
++# used only before/after all rounds
+ #define RCD0 %r8
+ #define RCD1 %r9
+ #define RCD2 %r10
+ 
+-#define RCD0d %r8d
+-#define RCD1d %r9d
+-#define RCD2d %r10d
+-
+-#define RX0 %rbp
+-#define RX1 %r11
+-#define RX2 %r12
++# used only during rounds
++#define RX0 %r8
++#define RX1 %r9
++#define RX2 %r10
+ 
+-#define RX0d %ebp
+-#define RX1d %r11d
+-#define RX2d %r12d
++#define RX0d %r8d
++#define RX1d %r9d
++#define RX2d %r10d
+ 
+-#define RY0 %r13
+-#define RY1 %r14
+-#define RY2 %r15
++#define RY0 %r11
++#define RY1 %r12
++#define RY2 %r13
+ 
+-#define RY0d %r13d
+-#define RY1d %r14d
+-#define RY2d %r15d
++#define RY0d %r11d
++#define RY1d %r12d
++#define RY2d %r13d
+ 
+ #define RT0 %rdx
+ #define RT1 %rsi
+@@ -85,6 +87,8 @@
+ #define RT0d %edx
+ #define RT1d %esi
+ 
++#define RT1bl %sil
++
+ #define do16bit_ror(rot, op1, op2, T0, T1, tmp1, tmp2, ab, dst) \
+ 	movzbl ab ## bl,		tmp2 ## d; \
+ 	movzbl ab ## bh,		tmp1 ## d; \
+@@ -92,6 +96,11 @@
+ 	op1##l T0(CTX, tmp2, 4),	dst ## d; \
+ 	op2##l T1(CTX, tmp1, 4),	dst ## d;
+ 
++#define swap_ab_with_cd(ab, cd, tmp)	\
++	movq cd, tmp;			\
++	movq ab, cd;			\
++	movq tmp, ab;
++
+ /*
+  * Combined G1 & G2 function. Reordered with help of rotates to have moves
+  * at begining.
+@@ -110,15 +119,15 @@
+ 	/* G1,2 && G2,2 */ \
+ 	do16bit_ror(32, xor, xor, Tx2, Tx3, RT0, RT1, ab ## 0, x ## 0); \
+ 	do16bit_ror(16, xor, xor, Ty3, Ty0, RT0, RT1, ab ## 0, y ## 0); \
+-	xchgq cd ## 0, ab ## 0; \
++	swap_ab_with_cd(ab ## 0, cd ## 0, RT0); \
+ 	\
+ 	do16bit_ror(32, xor, xor, Tx2, Tx3, RT0, RT1, ab ## 1, x ## 1); \
+ 	do16bit_ror(16, xor, xor, Ty3, Ty0, RT0, RT1, ab ## 1, y ## 1); \
+-	xchgq cd ## 1, ab ## 1; \
++	swap_ab_with_cd(ab ## 1, cd ## 1, RT0); \
+ 	\
+ 	do16bit_ror(32, xor, xor, Tx2, Tx3, RT0, RT1, ab ## 2, x ## 2); \
+ 	do16bit_ror(16, xor, xor, Ty3, Ty0, RT0, RT1, ab ## 2, y ## 2); \
+-	xchgq cd ## 2, ab ## 2;
++	swap_ab_with_cd(ab ## 2, cd ## 2, RT0);
+ 
+ #define enc_round_end(ab, x, y, n) \
+ 	addl y ## d,			x ## d; \
+@@ -168,6 +177,16 @@
+ 	decrypt_round3(ba, dc, (n*2)+1); \
+ 	decrypt_round3(ba, dc, (n*2));
+ 
++#define push_cd()	\
++	pushq RCD2;	\
++	pushq RCD1;	\
++	pushq RCD0;
++
++#define pop_cd()	\
++	popq RCD0;	\
++	popq RCD1;	\
++	popq RCD2;
++
+ #define inpack3(in, n, xy, m) \
+ 	movq 4*(n)(in),			xy ## 0; \
+ 	xorq w+4*m(CTX),		xy ## 0; \
+@@ -223,11 +242,8 @@ ENTRY(__twofish_enc_blk_3way)
+ 	 *	%rdx: src, RIO
+ 	 *	%rcx: bool, if true: xor output
+ 	 */
+-	pushq %r15;
+-	pushq %r14;
+ 	pushq %r13;
+ 	pushq %r12;
+-	pushq %rbp;
+ 	pushq %rbx;
+ 
+ 	pushq %rcx; /* bool xor */
+@@ -235,40 +251,36 @@ ENTRY(__twofish_enc_blk_3way)
+ 
+ 	inpack_enc3();
+ 
+-	encrypt_cycle3(RAB, RCD, 0);
+-	encrypt_cycle3(RAB, RCD, 1);
+-	encrypt_cycle3(RAB, RCD, 2);
+-	encrypt_cycle3(RAB, RCD, 3);
+-	encrypt_cycle3(RAB, RCD, 4);
+-	encrypt_cycle3(RAB, RCD, 5);
+-	encrypt_cycle3(RAB, RCD, 6);
+-	encrypt_cycle3(RAB, RCD, 7);
++	push_cd();
++	encrypt_cycle3(RAB, CD, 0);
++	encrypt_cycle3(RAB, CD, 1);
++	encrypt_cycle3(RAB, CD, 2);
++	encrypt_cycle3(RAB, CD, 3);
++	encrypt_cycle3(RAB, CD, 4);
++	encrypt_cycle3(RAB, CD, 5);
++	encrypt_cycle3(RAB, CD, 6);
++	encrypt_cycle3(RAB, CD, 7);
++	pop_cd();
+ 
+ 	popq RIO; /* dst */
+-	popq %rbp; /* bool xor */
++	popq RT1; /* bool xor */
+ 
+-	testb %bpl, %bpl;
++	testb RT1bl, RT1bl;
+ 	jnz .L__enc_xor3;
+ 
+ 	outunpack_enc3(mov);
+ 
+ 	popq %rbx;
+-	popq %rbp;
+ 	popq %r12;
+ 	popq %r13;
+-	popq %r14;
+-	popq %r15;
+ 	ret;
+ 
+ .L__enc_xor3:
+ 	outunpack_enc3(xor);
+ 
+ 	popq %rbx;
+-	popq %rbp;
+ 	popq %r12;
+ 	popq %r13;
+-	popq %r14;
+-	popq %r15;
+ 	ret;
+ ENDPROC(__twofish_enc_blk_3way)
+ 
+@@ -278,35 +290,31 @@ ENTRY(twofish_dec_blk_3way)
+ 	 *	%rsi: dst
+ 	 *	%rdx: src, RIO
+ 	 */
+-	pushq %r15;
+-	pushq %r14;
+ 	pushq %r13;
+ 	pushq %r12;
+-	pushq %rbp;
+ 	pushq %rbx;
+ 
+ 	pushq %rsi; /* dst */
+ 
+ 	inpack_dec3();
+ 
+-	decrypt_cycle3(RAB, RCD, 7);
+-	decrypt_cycle3(RAB, RCD, 6);
+-	decrypt_cycle3(RAB, RCD, 5);
+-	decrypt_cycle3(RAB, RCD, 4);
+-	decrypt_cycle3(RAB, RCD, 3);
+-	decrypt_cycle3(RAB, RCD, 2);
+-	decrypt_cycle3(RAB, RCD, 1);
+-	decrypt_cycle3(RAB, RCD, 0);
++	push_cd();
++	decrypt_cycle3(RAB, CD, 7);
++	decrypt_cycle3(RAB, CD, 6);
++	decrypt_cycle3(RAB, CD, 5);
++	decrypt_cycle3(RAB, CD, 4);
++	decrypt_cycle3(RAB, CD, 3);
++	decrypt_cycle3(RAB, CD, 2);
++	decrypt_cycle3(RAB, CD, 1);
++	decrypt_cycle3(RAB, CD, 0);
++	pop_cd();
+ 
+ 	popq RIO; /* dst */
+ 
+ 	outunpack_dec3();
+ 
+ 	popq %rbx;
+-	popq %rbp;
+ 	popq %r12;
+ 	popq %r13;
+-	popq %r14;
+-	popq %r15;
+ 	ret;
+ ENDPROC(twofish_dec_blk_3way)
+diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c
+index 1a4477cedc49..b5eb1cca70a0 100644
+--- a/arch/x86/entry/common.c
++++ b/arch/x86/entry/common.c
+@@ -20,6 +20,7 @@
+ #include <linux/export.h>
+ #include <linux/context_tracking.h>
+ #include <linux/user-return-notifier.h>
++#include <linux/nospec.h>
+ #include <linux/uprobes.h>
+ 
+ #include <asm/desc.h>
+@@ -381,6 +382,7 @@ __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs)
+ 	}
+ 
+ 	if (likely(nr < IA32_NR_syscalls)) {
++		nr = array_index_nospec(nr, IA32_NR_syscalls);
+ 		/*
+ 		 * It's possible that a 32-bit syscall implementation
+ 		 * takes a 64-bit parameter but nonetheless assumes that
+diff --git a/arch/x86/include/asm/asm-prototypes.h b/arch/x86/include/asm/asm-prototypes.h
+index b15aa4083dfd..5a25ada75aeb 100644
+--- a/arch/x86/include/asm/asm-prototypes.h
++++ b/arch/x86/include/asm/asm-prototypes.h
+@@ -37,5 +37,4 @@ INDIRECT_THUNK(dx)
+ INDIRECT_THUNK(si)
+ INDIRECT_THUNK(di)
+ INDIRECT_THUNK(bp)
+-INDIRECT_THUNK(sp)
+ #endif /* CONFIG_RETPOLINE */
+diff --git a/arch/x86/include/asm/barrier.h b/arch/x86/include/asm/barrier.h
+index 0681d2532527..814ef83c6720 100644
+--- a/arch/x86/include/asm/barrier.h
++++ b/arch/x86/include/asm/barrier.h
+@@ -24,6 +24,34 @@
+ #define wmb()	asm volatile("sfence" ::: "memory")
+ #endif
+ 
++/**
++ * array_index_mask_nospec() - generate a mask that is ~0UL when the
++ * 	bounds check succeeds and 0 otherwise
++ * @index: array element index
++ * @size: number of elements in array
++ *
++ * Returns:
++ *     0 - (index < size)
++ */
++static inline unsigned long array_index_mask_nospec(unsigned long index,
++		unsigned long size)
++{
++	unsigned long mask;
++
++	asm ("cmp %1,%2; sbb %0,%0;"
++			:"=r" (mask)
++			:"r"(size),"r" (index)
++			:"cc");
++	return mask;
++}
++
++/* Override the default implementation from linux/nospec.h. */
++#define array_index_mask_nospec array_index_mask_nospec
++
++/* Prevent speculative execution past this barrier. */
++#define barrier_nospec() alternative_2("", "mfence", X86_FEATURE_MFENCE_RDTSC, \
++					   "lfence", X86_FEATURE_LFENCE_RDTSC)
++
+ #ifdef CONFIG_X86_PPRO_FENCE
+ #define dma_rmb()	rmb()
+ #else
+diff --git a/arch/x86/include/asm/microcode_amd.h b/arch/x86/include/asm/microcode_amd.h
+index adfc847a395e..fb163f02ebb1 100644
+--- a/arch/x86/include/asm/microcode_amd.h
++++ b/arch/x86/include/asm/microcode_amd.h
+@@ -59,7 +59,6 @@ static inline u16 find_equiv_id(struct equiv_cpu_entry *equiv_cpu_table,
+ 
+ extern int __apply_microcode_amd(struct microcode_amd *mc_amd);
+ extern int apply_microcode_amd(int cpu);
+-extern enum ucode_state load_microcode_amd(int cpu, u8 family, const u8 *data, size_t size);
+ 
+ #define PATCH_MAX_SIZE PAGE_SIZE
+ extern u8 amd_ucode_patch[PATCH_MAX_SIZE];
+diff --git a/arch/x86/include/asm/msr.h b/arch/x86/include/asm/msr.h
+index 77d8b284e4a7..5a10ac8c131e 100644
+--- a/arch/x86/include/asm/msr.h
++++ b/arch/x86/include/asm/msr.h
+@@ -147,8 +147,7 @@ static __always_inline unsigned long long rdtsc_ordered(void)
+ 	 * that some other imaginary CPU is updating continuously with a
+ 	 * time stamp.
+ 	 */
+-	alternative_2("", "mfence", X86_FEATURE_MFENCE_RDTSC,
+-			  "lfence", X86_FEATURE_LFENCE_RDTSC);
++	barrier_nospec();
+ 	return rdtsc();
+ }
+ 
+diff --git a/arch/x86/include/asm/nospec-branch.h b/arch/x86/include/asm/nospec-branch.h
+index 492370b9b35b..66094a0473a8 100644
+--- a/arch/x86/include/asm/nospec-branch.h
++++ b/arch/x86/include/asm/nospec-branch.h
+@@ -1,7 +1,7 @@
+ /* SPDX-License-Identifier: GPL-2.0 */
+ 
+-#ifndef __NOSPEC_BRANCH_H__
+-#define __NOSPEC_BRANCH_H__
++#ifndef _ASM_X86_NOSPEC_BRANCH_H_
++#define _ASM_X86_NOSPEC_BRANCH_H_
+ 
+ #include <asm/alternative.h>
+ #include <asm/alternative-asm.h>
+@@ -178,7 +178,7 @@ extern char __indirect_thunk_end[];
+  * On VMEXIT we must ensure that no RSB predictions learned in the guest
+  * can be followed in the host, by overwriting the RSB completely. Both
+  * retpoline and IBRS mitigations for Spectre v2 need this; only on future
+- * CPUs with IBRS_ATT *might* it be avoided.
++ * CPUs with IBRS_ALL *might* it be avoided.
+  */
+ static inline void vmexit_fill_RSB(void)
+ {
+@@ -195,4 +195,4 @@ static inline void vmexit_fill_RSB(void)
+ }
+ 
+ #endif /* __ASSEMBLY__ */
+-#endif /* __NOSPEC_BRANCH_H__ */
++#endif /* _ASM_X86_NOSPEC_BRANCH_H_ */
+diff --git a/arch/x86/include/asm/vmx.h b/arch/x86/include/asm/vmx.h
+index 14c63c7e8337..6b6e16d813b9 100644
+--- a/arch/x86/include/asm/vmx.h
++++ b/arch/x86/include/asm/vmx.h
+@@ -400,10 +400,11 @@ enum vmcs_field {
+ #define IDENTITY_PAGETABLE_PRIVATE_MEMSLOT	(KVM_USER_MEM_SLOTS + 2)
+ 
+ #define VMX_NR_VPIDS				(1 << 16)
++#define VMX_VPID_EXTENT_INDIVIDUAL_ADDR		0
+ #define VMX_VPID_EXTENT_SINGLE_CONTEXT		1
+ #define VMX_VPID_EXTENT_ALL_CONTEXT		2
++#define VMX_VPID_EXTENT_SINGLE_NON_GLOBAL	3
+ 
+-#define VMX_EPT_EXTENT_INDIVIDUAL_ADDR		0
+ #define VMX_EPT_EXTENT_CONTEXT			1
+ #define VMX_EPT_EXTENT_GLOBAL			2
+ #define VMX_EPT_EXTENT_SHIFT			24
+@@ -420,8 +421,10 @@ enum vmcs_field {
+ #define VMX_EPT_EXTENT_GLOBAL_BIT		(1ull << 26)
+ 
+ #define VMX_VPID_INVVPID_BIT                    (1ull << 0) /* (32 - 32) */
++#define VMX_VPID_EXTENT_INDIVIDUAL_ADDR_BIT     (1ull << 8) /* (40 - 32) */
+ #define VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT      (1ull << 9) /* (41 - 32) */
+ #define VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT      (1ull << 10) /* (42 - 32) */
++#define VMX_VPID_EXTENT_SINGLE_NON_GLOBAL_BIT   (1ull << 11) /* (43 - 32) */
+ 
+ #define VMX_EPT_DEFAULT_GAW			3
+ #define VMX_EPT_MAX_GAW				0x4
+diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c
+index d6f375f1b928..89829c3d5a74 100644
+--- a/arch/x86/kernel/alternative.c
++++ b/arch/x86/kernel/alternative.c
+@@ -45,17 +45,6 @@ static int __init setup_noreplace_smp(char *str)
+ }
+ __setup("noreplace-smp", setup_noreplace_smp);
+ 
+-#ifdef CONFIG_PARAVIRT
+-static int __initdata_or_module noreplace_paravirt = 0;
+-
+-static int __init setup_noreplace_paravirt(char *str)
+-{
+-	noreplace_paravirt = 1;
+-	return 1;
+-}
+-__setup("noreplace-paravirt", setup_noreplace_paravirt);
+-#endif
+-
+ #define DPRINTK(fmt, args...)						\
+ do {									\
+ 	if (debug_alternative)						\
+@@ -587,9 +576,6 @@ void __init_or_module apply_paravirt(struct paravirt_patch_site *start,
+ 	struct paravirt_patch_site *p;
+ 	char insnbuf[MAX_PATCH_LEN];
+ 
+-	if (noreplace_paravirt)
+-		return;
+-
+ 	for (p = start; p < end; p++) {
+ 		unsigned int used;
+ 
+diff --git a/arch/x86/kernel/cpu/bugs.c b/arch/x86/kernel/cpu/bugs.c
+index 8cacf62ec458..ecaf7c9baf75 100644
+--- a/arch/x86/kernel/cpu/bugs.c
++++ b/arch/x86/kernel/cpu/bugs.c
+@@ -10,6 +10,7 @@
+ #include <linux/init.h>
+ #include <linux/utsname.h>
+ #include <linux/cpu.h>
++#include <linux/module.h>
+ 
+ #include <asm/nospec-branch.h>
+ #include <asm/cmdline.h>
+@@ -89,20 +90,42 @@ static const char *spectre_v2_strings[] = {
+ };
+ 
+ #undef pr_fmt
+-#define pr_fmt(fmt)     "Spectre V2 mitigation: " fmt
++#define pr_fmt(fmt)     "Spectre V2 : " fmt
+ 
+ static enum spectre_v2_mitigation spectre_v2_enabled = SPECTRE_V2_NONE;
+ 
++
++#ifdef RETPOLINE
++static bool spectre_v2_bad_module;
++
++bool retpoline_module_ok(bool has_retpoline)
++{
++	if (spectre_v2_enabled == SPECTRE_V2_NONE || has_retpoline)
++		return true;
++
++	pr_err("System may be vulnerable to spectre v2\n");
++	spectre_v2_bad_module = true;
++	return false;
++}
++
++static inline const char *spectre_v2_module_string(void)
++{
++	return spectre_v2_bad_module ? " - vulnerable module loaded" : "";
++}
++#else
++static inline const char *spectre_v2_module_string(void) { return ""; }
++#endif
++
+ static void __init spec2_print_if_insecure(const char *reason)
+ {
+ 	if (boot_cpu_has_bug(X86_BUG_SPECTRE_V2))
+-		pr_info("%s\n", reason);
++		pr_info("%s selected on command line.\n", reason);
+ }
+ 
+ static void __init spec2_print_if_secure(const char *reason)
+ {
+ 	if (!boot_cpu_has_bug(X86_BUG_SPECTRE_V2))
+-		pr_info("%s\n", reason);
++		pr_info("%s selected on command line.\n", reason);
+ }
+ 
+ static inline bool retp_compiler(void)
+@@ -117,42 +140,68 @@ static inline bool match_option(const char *arg, int arglen, const char *opt)
+ 	return len == arglen && !strncmp(arg, opt, len);
+ }
+ 
++static const struct {
++	const char *option;
++	enum spectre_v2_mitigation_cmd cmd;
++	bool secure;
++} mitigation_options[] = {
++	{ "off",               SPECTRE_V2_CMD_NONE,              false },
++	{ "on",                SPECTRE_V2_CMD_FORCE,             true },
++	{ "retpoline",         SPECTRE_V2_CMD_RETPOLINE,         false },
++	{ "retpoline,amd",     SPECTRE_V2_CMD_RETPOLINE_AMD,     false },
++	{ "retpoline,generic", SPECTRE_V2_CMD_RETPOLINE_GENERIC, false },
++	{ "auto",              SPECTRE_V2_CMD_AUTO,              false },
++};
++
+ static enum spectre_v2_mitigation_cmd __init spectre_v2_parse_cmdline(void)
+ {
+ 	char arg[20];
+-	int ret;
+-
+-	ret = cmdline_find_option(boot_command_line, "spectre_v2", arg,
+-				  sizeof(arg));
+-	if (ret > 0)  {
+-		if (match_option(arg, ret, "off")) {
+-			goto disable;
+-		} else if (match_option(arg, ret, "on")) {
+-			spec2_print_if_secure("force enabled on command line.");
+-			return SPECTRE_V2_CMD_FORCE;
+-		} else if (match_option(arg, ret, "retpoline")) {
+-			spec2_print_if_insecure("retpoline selected on command line.");
+-			return SPECTRE_V2_CMD_RETPOLINE;
+-		} else if (match_option(arg, ret, "retpoline,amd")) {
+-			if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD) {
+-				pr_err("retpoline,amd selected but CPU is not AMD. Switching to AUTO select\n");
+-				return SPECTRE_V2_CMD_AUTO;
+-			}
+-			spec2_print_if_insecure("AMD retpoline selected on command line.");
+-			return SPECTRE_V2_CMD_RETPOLINE_AMD;
+-		} else if (match_option(arg, ret, "retpoline,generic")) {
+-			spec2_print_if_insecure("generic retpoline selected on command line.");
+-			return SPECTRE_V2_CMD_RETPOLINE_GENERIC;
+-		} else if (match_option(arg, ret, "auto")) {
++	int ret, i;
++	enum spectre_v2_mitigation_cmd cmd = SPECTRE_V2_CMD_AUTO;
++
++	if (cmdline_find_option_bool(boot_command_line, "nospectre_v2"))
++		return SPECTRE_V2_CMD_NONE;
++	else {
++		ret = cmdline_find_option(boot_command_line, "spectre_v2", arg,
++					  sizeof(arg));
++		if (ret < 0)
++			return SPECTRE_V2_CMD_AUTO;
++
++		for (i = 0; i < ARRAY_SIZE(mitigation_options); i++) {
++			if (!match_option(arg, ret, mitigation_options[i].option))
++				continue;
++			cmd = mitigation_options[i].cmd;
++			break;
++		}
++
++		if (i >= ARRAY_SIZE(mitigation_options)) {
++			pr_err("unknown option (%s). Switching to AUTO select\n",
++			       mitigation_options[i].option);
+ 			return SPECTRE_V2_CMD_AUTO;
+ 		}
+ 	}
+ 
+-	if (!cmdline_find_option_bool(boot_command_line, "nospectre_v2"))
++	if ((cmd == SPECTRE_V2_CMD_RETPOLINE ||
++	     cmd == SPECTRE_V2_CMD_RETPOLINE_AMD ||
++	     cmd == SPECTRE_V2_CMD_RETPOLINE_GENERIC) &&
++	    !IS_ENABLED(CONFIG_RETPOLINE)) {
++		pr_err("%s selected but not compiled in. Switching to AUTO select\n",
++		       mitigation_options[i].option);
+ 		return SPECTRE_V2_CMD_AUTO;
+-disable:
+-	spec2_print_if_insecure("disabled on command line.");
+-	return SPECTRE_V2_CMD_NONE;
++	}
++
++	if (cmd == SPECTRE_V2_CMD_RETPOLINE_AMD &&
++	    boot_cpu_data.x86_vendor != X86_VENDOR_AMD) {
++		pr_err("retpoline,amd selected but CPU is not AMD. Switching to AUTO select\n");
++		return SPECTRE_V2_CMD_AUTO;
++	}
++
++	if (mitigation_options[i].secure)
++		spec2_print_if_secure(mitigation_options[i].option);
++	else
++		spec2_print_if_insecure(mitigation_options[i].option);
++
++	return cmd;
+ }
+ 
+ /* Check for Skylake-like CPUs (for RSB handling) */
+@@ -190,10 +239,10 @@ static void __init spectre_v2_select_mitigation(void)
+ 		return;
+ 
+ 	case SPECTRE_V2_CMD_FORCE:
+-		/* FALLTRHU */
+ 	case SPECTRE_V2_CMD_AUTO:
+-		goto retpoline_auto;
+-
++		if (IS_ENABLED(CONFIG_RETPOLINE))
++			goto retpoline_auto;
++		break;
+ 	case SPECTRE_V2_CMD_RETPOLINE_AMD:
+ 		if (IS_ENABLED(CONFIG_RETPOLINE))
+ 			goto retpoline_amd;
+@@ -268,7 +317,7 @@ ssize_t cpu_show_spectre_v1(struct device *dev,
+ {
+ 	if (!boot_cpu_has_bug(X86_BUG_SPECTRE_V1))
+ 		return sprintf(buf, "Not affected\n");
+-	return sprintf(buf, "Vulnerable\n");
++	return sprintf(buf, "Mitigation: __user pointer sanitization\n");
+ }
+ 
+ ssize_t cpu_show_spectre_v2(struct device *dev,
+@@ -277,6 +326,7 @@ ssize_t cpu_show_spectre_v2(struct device *dev,
+ 	if (!boot_cpu_has_bug(X86_BUG_SPECTRE_V2))
+ 		return sprintf(buf, "Not affected\n");
+ 
+-	return sprintf(buf, "%s\n", spectre_v2_strings[spectre_v2_enabled]);
++	return sprintf(buf, "%s%s\n", spectre_v2_strings[spectre_v2_enabled],
++		       spectre_v2_module_string());
+ }
+ #endif
+diff --git a/arch/x86/kernel/cpu/mcheck/mce-inject.c b/arch/x86/kernel/cpu/mcheck/mce-inject.c
+index 4cfba4371a71..101bfae369e1 100644
+--- a/arch/x86/kernel/cpu/mcheck/mce-inject.c
++++ b/arch/x86/kernel/cpu/mcheck/mce-inject.c
+@@ -152,7 +152,6 @@ static void raise_mce(struct mce *m)
+ 	if (context == MCJ_CTX_RANDOM)
+ 		return;
+ 
+-#ifdef CONFIG_X86_LOCAL_APIC
+ 	if (m->inject_flags & (MCJ_IRQ_BROADCAST | MCJ_NMI_BROADCAST)) {
+ 		unsigned long start;
+ 		int cpu;
+@@ -193,9 +192,7 @@ static void raise_mce(struct mce *m)
+ 		raise_local();
+ 		put_cpu();
+ 		put_online_cpus();
+-	} else
+-#endif
+-	{
++	} else {
+ 		preempt_disable();
+ 		raise_local();
+ 		preempt_enable();
+diff --git a/arch/x86/kernel/cpu/microcode/amd.c b/arch/x86/kernel/cpu/microcode/amd.c
+index 2a0f44d225fe..6da6f9cd6d2d 100644
+--- a/arch/x86/kernel/cpu/microcode/amd.c
++++ b/arch/x86/kernel/cpu/microcode/amd.c
+@@ -131,6 +131,9 @@ static size_t compute_container_size(u8 *data, u32 total_size)
+ 	return size;
+ }
+ 
++static enum ucode_state
++load_microcode_amd(bool save, u8 family, const u8 *data, size_t size);
++
+ /*
+  * Early load occurs before we can vmalloc(). So we look for the microcode
+  * patch container file in initrd, traverse equivalent cpu table, look for a
+@@ -438,7 +441,7 @@ int __init save_microcode_in_initrd_amd(void)
+ 	eax   = cpuid_eax(0x00000001);
+ 	eax   = ((eax >> 8) & 0xf) + ((eax >> 20) & 0xff);
+ 
+-	ret = load_microcode_amd(smp_processor_id(), eax, container, container_size);
++	ret = load_microcode_amd(true, eax, container, container_size);
+ 	if (ret != UCODE_OK)
+ 		retval = -EINVAL;
+ 
+@@ -854,7 +857,8 @@ static enum ucode_state __load_microcode_amd(u8 family, const u8 *data,
+ 	return UCODE_OK;
+ }
+ 
+-enum ucode_state load_microcode_amd(int cpu, u8 family, const u8 *data, size_t size)
++static enum ucode_state
++load_microcode_amd(bool save, u8 family, const u8 *data, size_t size)
+ {
+ 	enum ucode_state ret;
+ 
+@@ -868,8 +872,8 @@ enum ucode_state load_microcode_amd(int cpu, u8 family, const u8 *data, size_t s
+ 
+ #ifdef CONFIG_X86_32
+ 	/* save BSP's matching patch for early load */
+-	if (cpu_data(cpu).cpu_index == boot_cpu_data.cpu_index) {
+-		struct ucode_patch *p = find_patch(cpu);
++	if (save) {
++		struct ucode_patch *p = find_patch(0);
+ 		if (p) {
+ 			memset(amd_ucode_patch, 0, PATCH_MAX_SIZE);
+ 			memcpy(amd_ucode_patch, p->data, min_t(u32, ksize(p->data),
+@@ -901,11 +905,12 @@ static enum ucode_state request_microcode_amd(int cpu, struct device *device,
+ {
+ 	char fw_name[36] = "amd-ucode/microcode_amd.bin";
+ 	struct cpuinfo_x86 *c = &cpu_data(cpu);
++	bool bsp = c->cpu_index == boot_cpu_data.cpu_index;
+ 	enum ucode_state ret = UCODE_NFOUND;
+ 	const struct firmware *fw;
+ 
+ 	/* reload ucode container only on the boot cpu */
+-	if (!refresh_fw || c->cpu_index != boot_cpu_data.cpu_index)
++	if (!refresh_fw || !bsp)
+ 		return UCODE_OK;
+ 
+ 	if (c->x86 >= 0x15)
+@@ -922,7 +927,7 @@ static enum ucode_state request_microcode_amd(int cpu, struct device *device,
+ 		goto fw_release;
+ 	}
+ 
+-	ret = load_microcode_amd(cpu, c->x86, fw->data, fw->size);
++	ret = load_microcode_amd(bsp, c->x86, fw->data, fw->size);
+ 
+  fw_release:
+ 	release_firmware(fw);
+diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c
+index 5b2f2306fbcc..b52a8d08ab36 100644
+--- a/arch/x86/kernel/cpu/perf_event.c
++++ b/arch/x86/kernel/cpu/perf_event.c
+@@ -188,8 +188,8 @@ static void release_pmc_hardware(void) {}
+ 
+ static bool check_hw_exists(void)
+ {
+-	u64 val, val_fail, val_new= ~0;
+-	int i, reg, reg_fail, ret = 0;
++	u64 val, val_fail = -1, val_new= ~0;
++	int i, reg, reg_fail = -1, ret = 0;
+ 	int bios_fail = 0;
+ 	int reg_safe = -1;
+ 
+diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S
+index 8f1a3f443f7d..70284d38fdc2 100644
+--- a/arch/x86/kernel/head_32.S
++++ b/arch/x86/kernel/head_32.S
+@@ -669,14 +669,17 @@ __PAGE_ALIGNED_BSS
+ initial_pg_pmd:
+ 	.fill 1024*KPMDS,4,0
+ #else
+-ENTRY(initial_page_table)
++.globl initial_page_table
++initial_page_table:
+ 	.fill 1024,4,0
+ #endif
+ initial_pg_fixmap:
+ 	.fill 1024,4,0
+-ENTRY(empty_zero_page)
++.globl empty_zero_page
++empty_zero_page:
+ 	.fill 4096,1,0
+-ENTRY(swapper_pg_dir)
++.globl swapper_pg_dir
++swapper_pg_dir:
+ 	.fill 1024,4,0
+ 
+ /*
+diff --git a/arch/x86/kvm/Kconfig b/arch/x86/kvm/Kconfig
+index 639a6e34500c..53b7f53f6207 100644
+--- a/arch/x86/kvm/Kconfig
++++ b/arch/x86/kvm/Kconfig
+@@ -22,7 +22,8 @@ config KVM
+ 	depends on HAVE_KVM
+ 	depends on HIGH_RES_TIMERS
+ 	# for TASKSTATS/TASK_DELAY_ACCT:
+-	depends on NET
++	depends on NET && MULTIUSER
++	depends on X86_LOCAL_APIC
+ 	select PREEMPT_NOTIFIERS
+ 	select MMU_NOTIFIER
+ 	select ANON_INODES
+diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
+index e4eb1d2bf849..8864fec63a20 100644
+--- a/arch/x86/kvm/emulate.c
++++ b/arch/x86/kvm/emulate.c
+@@ -26,6 +26,7 @@
+ #include <asm/kvm_emulate.h>
+ #include <linux/stringify.h>
+ #include <asm/debugreg.h>
++#include <asm/nospec-branch.h>
+ 
+ #include "x86.h"
+ #include "tss.h"
+@@ -1000,8 +1001,8 @@ static u8 test_cc(unsigned int condition, unsigned long flags)
+ 	void (*fop)(void) = (void *)em_setcc + 4 * (condition & 0xf);
+ 
+ 	flags = (flags & EFLAGS_MASK) | X86_EFLAGS_IF;
+-	asm("push %[flags]; popf; call *%[fastop]"
+-	    : "=a"(rc) : [fastop]"r"(fop), [flags]"r"(flags));
++	asm("push %[flags]; popf; " CALL_NOSPEC
++	    : "=a"(rc) : [thunk_target]"r"(fop), [flags]"r"(flags));
+ 	return rc;
+ }
+ 
+@@ -5297,9 +5298,9 @@ static int fastop(struct x86_emulate_ctxt *ctxt, void (*fop)(struct fastop *))
+ 	ulong flags = (ctxt->eflags & EFLAGS_MASK) | X86_EFLAGS_IF;
+ 	if (!(ctxt->d & ByteOp))
+ 		fop += __ffs(ctxt->dst.bytes) * FASTOP_SIZE;
+-	asm("push %[flags]; popf; call *%[fastop]; pushf; pop %[flags]\n"
++	asm("push %[flags]; popf; " CALL_NOSPEC "; pushf; pop %[flags]\n"
+ 	    : "+a"(ctxt->dst.val), "+d"(ctxt->src.val), [flags]"+D"(flags),
+-	      [fastop]"+S"(fop)
++	      [thunk_target]"+S"(fop)
+ 	    : "c"(ctxt->src2.val));
+ 	ctxt->eflags = (ctxt->eflags & ~EFLAGS_MASK) | (flags & EFLAGS_MASK);
+ 	if (!fop) /* exception is returned in fop variable */
+diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
+index 2a1a8737015b..849517805eef 100644
+--- a/arch/x86/kvm/vmx.c
++++ b/arch/x86/kvm/vmx.c
+@@ -32,6 +32,7 @@
+ #include <linux/slab.h>
+ #include <linux/tboot.h>
+ #include <linux/hrtimer.h>
++#include <linux/nospec.h>
+ #include "kvm_cache_regs.h"
+ #include "x86.h"
+ 
+@@ -125,6 +126,12 @@ module_param_named(pml, enable_pml, bool, S_IRUGO);
+ 
+ #define VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE 5
+ 
++#define VMX_VPID_EXTENT_SUPPORTED_MASK		\
++	(VMX_VPID_EXTENT_INDIVIDUAL_ADDR_BIT |	\
++	VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT |	\
++	VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT |	\
++	VMX_VPID_EXTENT_SINGLE_NON_GLOBAL_BIT)
++
+ /*
+  * These 2 parameters are used to config the controls for Pause-Loop Exiting:
+  * ple_gap:    upper bound on the amount of time between two successive
+@@ -827,21 +834,18 @@ static const unsigned short vmcs_field_to_offset_table[] = {
+ 
+ static inline short vmcs_field_to_offset(unsigned long field)
+ {
+-	BUILD_BUG_ON(ARRAY_SIZE(vmcs_field_to_offset_table) > SHRT_MAX);
++	const size_t size = ARRAY_SIZE(vmcs_field_to_offset_table);
++	unsigned short offset;
+ 
+-	if (field >= ARRAY_SIZE(vmcs_field_to_offset_table))
++	BUILD_BUG_ON(size > SHRT_MAX);
++	if (field >= size)
+ 		return -ENOENT;
+ 
+-	/*
+-	 * FIXME: Mitigation for CVE-2017-5753.  To be replaced with a
+-	 * generic mechanism.
+-	 */
+-	asm("lfence");
+-
+-	if (vmcs_field_to_offset_table[field] == 0)
++	field = array_index_nospec(field, size);
++	offset = vmcs_field_to_offset_table[field];
++	if (offset == 0)
+ 		return -ENOENT;
+-
+-	return vmcs_field_to_offset_table[field];
++	return offset;
+ }
+ 
+ static inline struct vmcs12 *get_vmcs12(struct kvm_vcpu *vcpu)
+@@ -2659,8 +2663,7 @@ static void nested_vmx_setup_ctls_msrs(struct vcpu_vmx *vmx)
+ 	 */
+ 	if (enable_vpid)
+ 		vmx->nested.nested_vmx_vpid_caps = VMX_VPID_INVVPID_BIT |
+-				VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT |
+-				VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT;
++			VMX_VPID_EXTENT_SUPPORTED_MASK;
+ 	else
+ 		vmx->nested.nested_vmx_vpid_caps = 0;
+ 
+@@ -4514,7 +4517,7 @@ static int vmx_cpu_uses_apicv(struct kvm_vcpu *vcpu)
+ 	return enable_apicv && lapic_in_kernel(vcpu);
+ }
+ 
+-static int vmx_complete_nested_posted_interrupt(struct kvm_vcpu *vcpu)
++static void vmx_complete_nested_posted_interrupt(struct kvm_vcpu *vcpu)
+ {
+ 	struct vcpu_vmx *vmx = to_vmx(vcpu);
+ 	int max_irr;
+@@ -4525,19 +4528,15 @@ static int vmx_complete_nested_posted_interrupt(struct kvm_vcpu *vcpu)
+ 	    vmx->nested.pi_pending) {
+ 		vmx->nested.pi_pending = false;
+ 		if (!pi_test_and_clear_on(vmx->nested.pi_desc))
+-			return 0;
++			return;
+ 
+ 		max_irr = find_last_bit(
+ 			(unsigned long *)vmx->nested.pi_desc->pir, 256);
+ 
+ 		if (max_irr == 256)
+-			return 0;
++			return;
+ 
+ 		vapic_page = kmap(vmx->nested.virtual_apic_page);
+-		if (!vapic_page) {
+-			WARN_ON(1);
+-			return -ENOMEM;
+-		}
+ 		__kvm_apic_update_irr(vmx->nested.pi_desc->pir, vapic_page);
+ 		kunmap(vmx->nested.virtual_apic_page);
+ 
+@@ -4548,7 +4547,6 @@ static int vmx_complete_nested_posted_interrupt(struct kvm_vcpu *vcpu)
+ 			vmcs_write16(GUEST_INTR_STATUS, status);
+ 		}
+ 	}
+-	return 0;
+ }
+ 
+ static inline bool kvm_vcpu_trigger_posted_interrupt(struct kvm_vcpu *vcpu)
+@@ -7368,7 +7366,7 @@ static int handle_invept(struct kvm_vcpu *vcpu)
+ 
+ 	types = (vmx->nested.nested_vmx_ept_caps >> VMX_EPT_EXTENT_SHIFT) & 6;
+ 
+-	if (!(types & (1UL << type))) {
++	if (type >= 32 || !(types & (1 << type))) {
+ 		nested_vmx_failValid(vcpu,
+ 				VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID);
+ 		skip_emulated_instruction(vcpu);
+@@ -7425,9 +7423,10 @@ static int handle_invvpid(struct kvm_vcpu *vcpu)
+ 	vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO);
+ 	type = kvm_register_readl(vcpu, (vmx_instruction_info >> 28) & 0xf);
+ 
+-	types = (vmx->nested.nested_vmx_vpid_caps >> 8) & 0x7;
++	types = (vmx->nested.nested_vmx_vpid_caps &
++			VMX_VPID_EXTENT_SUPPORTED_MASK) >> 8;
+ 
+-	if (!(types & (1UL << type))) {
++	if (type >= 32 || !(types & (1 << type))) {
+ 		nested_vmx_failValid(vcpu,
+ 			VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID);
+ 		skip_emulated_instruction(vcpu);
+@@ -7447,21 +7446,27 @@ static int handle_invvpid(struct kvm_vcpu *vcpu)
+ 	}
+ 
+ 	switch (type) {
++	case VMX_VPID_EXTENT_INDIVIDUAL_ADDR:
+ 	case VMX_VPID_EXTENT_SINGLE_CONTEXT:
+-		/*
+-		 * Old versions of KVM use the single-context version so we
+-		 * have to support it; just treat it the same as all-context.
+-		 */
++	case VMX_VPID_EXTENT_SINGLE_NON_GLOBAL:
++		if (!vpid) {
++			nested_vmx_failValid(vcpu,
++				VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID);
++			skip_emulated_instruction(vcpu);
++			return 1;
++		}
++		break;
+ 	case VMX_VPID_EXTENT_ALL_CONTEXT:
+-		__vmx_flush_tlb(vcpu, to_vmx(vcpu)->nested.vpid02);
+-		nested_vmx_succeed(vcpu);
+ 		break;
+ 	default:
+-		/* Trap individual address invalidation invvpid calls */
+-		BUG_ON(1);
+-		break;
++		WARN_ON_ONCE(1);
++		skip_emulated_instruction(vcpu);
++		return 1;
+ 	}
+ 
++	__vmx_flush_tlb(vcpu, vmx->nested.vpid02);
++	nested_vmx_succeed(vcpu);
++
+ 	skip_emulated_instruction(vcpu);
+ 	return 1;
+ }
+@@ -8377,13 +8382,13 @@ static void vmx_handle_external_intr(struct kvm_vcpu *vcpu)
+ 			"pushf\n\t"
+ 			"orl $0x200, (%%" _ASM_SP ")\n\t"
+ 			__ASM_SIZE(push) " $%c[cs]\n\t"
+-			"call *%[entry]\n\t"
++			CALL_NOSPEC
+ 			:
+ #ifdef CONFIG_X86_64
+ 			[sp]"=&r"(tmp)
+ #endif
+ 			:
+-			[entry]"r"(entry),
++			THUNK_TARGET(entry),
+ 			[ss]"i"(__KERNEL_DS),
+ 			[cs]"i"(__KERNEL_CS)
+ 			);
+@@ -9240,11 +9245,6 @@ static inline bool nested_vmx_merge_msr_bitmap(struct kvm_vcpu *vcpu,
+ 		return false;
+ 	}
+ 	msr_bitmap = (unsigned long *)kmap(page);
+-	if (!msr_bitmap) {
+-		nested_release_page_clean(page);
+-		WARN_ON(1);
+-		return false;
+-	}
+ 
+ 	if (nested_cpu_has_virt_x2apic_mode(vmcs12)) {
+ 		if (nested_cpu_has_apic_reg_virt(vmcs12))
+@@ -10166,7 +10166,8 @@ static int vmx_check_nested_events(struct kvm_vcpu *vcpu, bool external_intr)
+ 		return 0;
+ 	}
+ 
+-	return vmx_complete_nested_posted_interrupt(vcpu);
++	vmx_complete_nested_posted_interrupt(vcpu);
++	return 0;
+ }
+ 
+ static u32 vmx_get_preemption_timer_value(struct kvm_vcpu *vcpu)
+diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
+index 3900d34980de..f37f0c72b22a 100644
+--- a/arch/x86/kvm/x86.c
++++ b/arch/x86/kvm/x86.c
+@@ -2755,6 +2755,12 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
+ 	kvm_x86_ops->vcpu_put(vcpu);
+ 	kvm_put_guest_fpu(vcpu);
+ 	vcpu->arch.last_host_tsc = rdtsc();
++	/*
++	 * If userspace has set any breakpoints or watchpoints, dr6 is restored
++	 * on every vmexit, but if not, we might have a stale dr6 from the
++	 * guest. do_debug expects dr6 to be cleared after it runs, do the same.
++	 */
++	set_debugreg(0, 6);
+ }
+ 
+ static int kvm_vcpu_ioctl_get_lapic(struct kvm_vcpu *vcpu,
+@@ -8204,6 +8210,13 @@ static int apf_put_user(struct kvm_vcpu *vcpu, u32 val)
+ 				      sizeof(val));
+ }
+ 
++static int apf_get_user(struct kvm_vcpu *vcpu, u32 *val)
++{
++
++	return kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.apf.data, val,
++				      sizeof(u32));
++}
++
+ void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
+ 				     struct kvm_async_pf *work)
+ {
+@@ -8230,6 +8243,7 @@ void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
+ 				 struct kvm_async_pf *work)
+ {
+ 	struct x86_exception fault;
++	u32 val;
+ 
+ 	if (work->wakeup_all)
+ 		work->arch.token = ~0; /* broadcast wakeup */
+@@ -8237,14 +8251,24 @@ void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
+ 		kvm_del_async_pf_gfn(vcpu, work->arch.gfn);
+ 	trace_kvm_async_pf_ready(work->arch.token, work->gva);
+ 
+-	if ((vcpu->arch.apf.msr_val & KVM_ASYNC_PF_ENABLED) &&
+-	    !apf_put_user(vcpu, KVM_PV_REASON_PAGE_READY)) {
+-		fault.vector = PF_VECTOR;
+-		fault.error_code_valid = true;
+-		fault.error_code = 0;
+-		fault.nested_page_fault = false;
+-		fault.address = work->arch.token;
+-		kvm_inject_page_fault(vcpu, &fault);
++	if (vcpu->arch.apf.msr_val & KVM_ASYNC_PF_ENABLED &&
++	    !apf_get_user(vcpu, &val)) {
++		if (val == KVM_PV_REASON_PAGE_NOT_PRESENT &&
++		    vcpu->arch.exception.pending &&
++		    vcpu->arch.exception.nr == PF_VECTOR &&
++		    !apf_put_user(vcpu, 0)) {
++			vcpu->arch.exception.pending = false;
++			vcpu->arch.exception.nr = 0;
++			vcpu->arch.exception.has_error_code = false;
++			vcpu->arch.exception.error_code = 0;
++		} else if (!apf_put_user(vcpu, KVM_PV_REASON_PAGE_READY)) {
++			fault.vector = PF_VECTOR;
++			fault.error_code_valid = true;
++			fault.error_code = 0;
++			fault.nested_page_fault = false;
++			fault.address = work->arch.token;
++			kvm_inject_page_fault(vcpu, &fault);
++		}
+ 	}
+ 	vcpu->arch.apf.halted = false;
+ 	vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE;
+diff --git a/arch/x86/lib/getuser.S b/arch/x86/lib/getuser.S
+index 46668cda4ffd..490b2ee4e4bb 100644
+--- a/arch/x86/lib/getuser.S
++++ b/arch/x86/lib/getuser.S
+@@ -38,6 +38,8 @@ ENTRY(__get_user_1)
+ 	GET_THREAD_INFO(%_ASM_DX)
+ 	cmp TI_addr_limit(%_ASM_DX),%_ASM_AX
+ 	jae bad_get_user
++	sbb %_ASM_DX, %_ASM_DX		/* array_index_mask_nospec() */
++	and %_ASM_DX, %_ASM_AX
+ 	ASM_STAC
+ 1:	movzbl (%_ASM_AX),%edx
+ 	xor %eax,%eax
+@@ -51,6 +53,8 @@ ENTRY(__get_user_2)
+ 	GET_THREAD_INFO(%_ASM_DX)
+ 	cmp TI_addr_limit(%_ASM_DX),%_ASM_AX
+ 	jae bad_get_user
++	sbb %_ASM_DX, %_ASM_DX		/* array_index_mask_nospec() */
++	and %_ASM_DX, %_ASM_AX
+ 	ASM_STAC
+ 2:	movzwl -1(%_ASM_AX),%edx
+ 	xor %eax,%eax
+@@ -64,6 +68,8 @@ ENTRY(__get_user_4)
+ 	GET_THREAD_INFO(%_ASM_DX)
+ 	cmp TI_addr_limit(%_ASM_DX),%_ASM_AX
+ 	jae bad_get_user
++	sbb %_ASM_DX, %_ASM_DX		/* array_index_mask_nospec() */
++	and %_ASM_DX, %_ASM_AX
+ 	ASM_STAC
+ 3:	movl -3(%_ASM_AX),%edx
+ 	xor %eax,%eax
+@@ -78,6 +84,8 @@ ENTRY(__get_user_8)
+ 	GET_THREAD_INFO(%_ASM_DX)
+ 	cmp TI_addr_limit(%_ASM_DX),%_ASM_AX
+ 	jae bad_get_user
++	sbb %_ASM_DX, %_ASM_DX		/* array_index_mask_nospec() */
++	and %_ASM_DX, %_ASM_AX
+ 	ASM_STAC
+ 4:	movq -7(%_ASM_AX),%rdx
+ 	xor %eax,%eax
+@@ -89,6 +97,8 @@ ENTRY(__get_user_8)
+ 	GET_THREAD_INFO(%_ASM_DX)
+ 	cmp TI_addr_limit(%_ASM_DX),%_ASM_AX
+ 	jae bad_get_user_8
++	sbb %_ASM_DX, %_ASM_DX		/* array_index_mask_nospec() */
++	and %_ASM_DX, %_ASM_AX
+ 	ASM_STAC
+ 4:	movl -7(%_ASM_AX),%edx
+ 5:	movl -3(%_ASM_AX),%ecx
+diff --git a/arch/x86/lib/retpoline.S b/arch/x86/lib/retpoline.S
+index e611a124c442..3d06b482ebc7 100644
+--- a/arch/x86/lib/retpoline.S
++++ b/arch/x86/lib/retpoline.S
+@@ -36,7 +36,6 @@ GENERATE_THUNK(_ASM_DX)
+ GENERATE_THUNK(_ASM_SI)
+ GENERATE_THUNK(_ASM_DI)
+ GENERATE_THUNK(_ASM_BP)
+-GENERATE_THUNK(_ASM_SP)
+ #ifdef CONFIG_64BIT
+ GENERATE_THUNK(r8)
+ GENERATE_THUNK(r9)
+diff --git a/arch/x86/math-emu/Makefile b/arch/x86/math-emu/Makefile
+index 9b0c63b60302..1b2dac174321 100644
+--- a/arch/x86/math-emu/Makefile
++++ b/arch/x86/math-emu/Makefile
+@@ -5,8 +5,8 @@
+ #DEBUG	= -DDEBUGGING
+ DEBUG	=
+ PARANOID = -DPARANOID
+-EXTRA_CFLAGS	:= $(PARANOID) $(DEBUG) -fno-builtin $(MATH_EMULATION)
+-EXTRA_AFLAGS	:= $(PARANOID)
++ccflags-y += $(PARANOID) $(DEBUG) -fno-builtin $(MATH_EMULATION)
++asflags-y += $(PARANOID)
+ 
+ # From 'C' language sources:
+ C_OBJS =fpu_entry.o errors.o \
+diff --git a/arch/x86/math-emu/reg_compare.c b/arch/x86/math-emu/reg_compare.c
+index b77360fdbf4a..19b33b50adfa 100644
+--- a/arch/x86/math-emu/reg_compare.c
++++ b/arch/x86/math-emu/reg_compare.c
+@@ -168,7 +168,7 @@ static int compare(FPU_REG const *b, int tagb)
+ /* This function requires that st(0) is not empty */
+ int FPU_compare_st_data(FPU_REG const *loaded_data, u_char loaded_tag)
+ {
+-	int f = 0, c;
++	int f, c;
+ 
+ 	c = compare(loaded_data, loaded_tag);
+ 
+@@ -189,12 +189,12 @@ int FPU_compare_st_data(FPU_REG const *loaded_data, u_char loaded_tag)
+ 		case COMP_No_Comp:
+ 			f = SW_C3 | SW_C2 | SW_C0;
+ 			break;
+-#ifdef PARANOID
+ 		default:
++#ifdef PARANOID
+ 			EXCEPTION(EX_INTERNAL | 0x121);
++#endif /* PARANOID */
+ 			f = SW_C3 | SW_C2 | SW_C0;
+ 			break;
+-#endif /* PARANOID */
+ 		}
+ 	setcc(f);
+ 	if (c & COMP_Denormal) {
+@@ -205,7 +205,7 @@ int FPU_compare_st_data(FPU_REG const *loaded_data, u_char loaded_tag)
+ 
+ static int compare_st_st(int nr)
+ {
+-	int f = 0, c;
++	int f, c;
+ 	FPU_REG *st_ptr;
+ 
+ 	if (!NOT_EMPTY(0) || !NOT_EMPTY(nr)) {
+@@ -235,12 +235,12 @@ static int compare_st_st(int nr)
+ 		case COMP_No_Comp:
+ 			f = SW_C3 | SW_C2 | SW_C0;
+ 			break;
+-#ifdef PARANOID
+ 		default:
++#ifdef PARANOID
+ 			EXCEPTION(EX_INTERNAL | 0x122);
++#endif /* PARANOID */
+ 			f = SW_C3 | SW_C2 | SW_C0;
+ 			break;
+-#endif /* PARANOID */
+ 		}
+ 	setcc(f);
+ 	if (c & COMP_Denormal) {
+@@ -283,12 +283,12 @@ static int compare_i_st_st(int nr)
+ 	case COMP_No_Comp:
+ 		f = X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF;
+ 		break;
+-#ifdef PARANOID
+ 	default:
++#ifdef PARANOID
+ 		EXCEPTION(EX_INTERNAL | 0x122);
++#endif /* PARANOID */
+ 		f = 0;
+ 		break;
+-#endif /* PARANOID */
+ 	}
+ 	FPU_EFLAGS = (FPU_EFLAGS & ~(X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF)) | f;
+ 	if (c & COMP_Denormal) {
+diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
+index b9c78f3bcd67..53ab3f367472 100644
+--- a/arch/x86/mm/ioremap.c
++++ b/arch/x86/mm/ioremap.c
+@@ -348,11 +348,11 @@ void iounmap(volatile void __iomem *addr)
+ 	    (void __force *)addr < phys_to_virt(ISA_END_ADDRESS))
+ 		return;
+ 
++	mmiotrace_iounmap(addr);
++
+ 	addr = (volatile void __iomem *)
+ 		(PAGE_MASK & (unsigned long __force)addr);
+ 
+-	mmiotrace_iounmap(addr);
+-
+ 	/* Use the vm area unlocked, assuming the caller
+ 	   ensures there isn't another iounmap for the same address
+ 	   in parallel. Reuse of the virtual address is prevented by
+diff --git a/arch/x86/mm/kmmio.c b/arch/x86/mm/kmmio.c
+index ddb2244b06a1..76604c8a2a48 100644
+--- a/arch/x86/mm/kmmio.c
++++ b/arch/x86/mm/kmmio.c
+@@ -434,17 +434,18 @@ int register_kmmio_probe(struct kmmio_probe *p)
+ 	unsigned long flags;
+ 	int ret = 0;
+ 	unsigned long size = 0;
++	unsigned long addr = p->addr & PAGE_MASK;
+ 	const unsigned long size_lim = p->len + (p->addr & ~PAGE_MASK);
+ 	unsigned int l;
+ 	pte_t *pte;
+ 
+ 	spin_lock_irqsave(&kmmio_lock, flags);
+-	if (get_kmmio_probe(p->addr)) {
++	if (get_kmmio_probe(addr)) {
+ 		ret = -EEXIST;
+ 		goto out;
+ 	}
+ 
+-	pte = lookup_address(p->addr, &l);
++	pte = lookup_address(addr, &l);
+ 	if (!pte) {
+ 		ret = -EINVAL;
+ 		goto out;
+@@ -453,7 +454,7 @@ int register_kmmio_probe(struct kmmio_probe *p)
+ 	kmmio_count++;
+ 	list_add_rcu(&p->list, &kmmio_probes);
+ 	while (size < size_lim) {
+-		if (add_kmmio_fault_page(p->addr + size))
++		if (add_kmmio_fault_page(addr + size))
+ 			pr_err("Unable to set page fault.\n");
+ 		size += page_level_size(l);
+ 	}
+@@ -527,19 +528,20 @@ void unregister_kmmio_probe(struct kmmio_probe *p)
+ {
+ 	unsigned long flags;
+ 	unsigned long size = 0;
++	unsigned long addr = p->addr & PAGE_MASK;
+ 	const unsigned long size_lim = p->len + (p->addr & ~PAGE_MASK);
+ 	struct kmmio_fault_page *release_list = NULL;
+ 	struct kmmio_delayed_release *drelease;
+ 	unsigned int l;
+ 	pte_t *pte;
+ 
+-	pte = lookup_address(p->addr, &l);
++	pte = lookup_address(addr, &l);
+ 	if (!pte)
+ 		return;
+ 
+ 	spin_lock_irqsave(&kmmio_lock, flags);
+ 	while (size < size_lim) {
+-		release_kmmio_fault_page(p->addr + size, &release_list);
++		release_kmmio_fault_page(addr + size, &release_list);
+ 		size += page_level_size(l);
+ 	}
+ 	list_del_rcu(&p->list);
+diff --git a/arch/x86/platform/olpc/olpc-xo15-sci.c b/arch/x86/platform/olpc/olpc-xo15-sci.c
+index 55130846ac87..c0533fbc39e3 100644
+--- a/arch/x86/platform/olpc/olpc-xo15-sci.c
++++ b/arch/x86/platform/olpc/olpc-xo15-sci.c
+@@ -196,6 +196,7 @@ static int xo15_sci_remove(struct acpi_device *device)
+ 	return 0;
+ }
+ 
++#ifdef CONFIG_PM_SLEEP
+ static int xo15_sci_resume(struct device *dev)
+ {
+ 	/* Enable all EC events */
+@@ -207,6 +208,7 @@ static int xo15_sci_resume(struct device *dev)
+ 
+ 	return 0;
+ }
++#endif
+ 
+ static SIMPLE_DEV_PM_OPS(xo15_sci_pm, NULL, xo15_sci_resume);
+ 
+diff --git a/certs/Makefile b/certs/Makefile
+index 28ac694dd11a..2773c4afa24c 100644
+--- a/certs/Makefile
++++ b/certs/Makefile
+@@ -36,29 +36,34 @@ ifndef CONFIG_MODULE_SIG_HASH
+ $(error Could not determine digest type to use from kernel config)
+ endif
+ 
++redirect_openssl	= 2>&1
++quiet_redirect_openssl	= 2>&1
++silent_redirect_openssl = 2>/dev/null
++
+ # We do it this way rather than having a boolean option for enabling an
+ # external private key, because 'make randconfig' might enable such a
+ # boolean option and we unfortunately can't make it depend on !RANDCONFIG.
+ ifeq ($(CONFIG_MODULE_SIG_KEY),"certs/signing_key.pem")
+ $(obj)/signing_key.pem: $(obj)/x509.genkey
+-	@echo "###"
+-	@echo "### Now generating an X.509 key pair to be used for signing modules."
+-	@echo "###"
+-	@echo "### If this takes a long time, you might wish to run rngd in the"
+-	@echo "### background to keep the supply of entropy topped up.  It"
+-	@echo "### needs to be run as root, and uses a hardware random"
+-	@echo "### number generator if one is available."
+-	@echo "###"
+-	openssl req -new -nodes -utf8 -$(CONFIG_MODULE_SIG_HASH) -days 36500 \
++	@$(kecho) "###"
++	@$(kecho) "### Now generating an X.509 key pair to be used for signing modules."
++	@$(kecho) "###"
++	@$(kecho) "### If this takes a long time, you might wish to run rngd in the"
++	@$(kecho) "### background to keep the supply of entropy topped up.  It"
++	@$(kecho) "### needs to be run as root, and uses a hardware random"
++	@$(kecho) "### number generator if one is available."
++	@$(kecho) "###"
++	$(Q)openssl req -new -nodes -utf8 -$(CONFIG_MODULE_SIG_HASH) -days 36500 \
+ 		-batch -x509 -config $(obj)/x509.genkey \
+ 		-outform PEM -out $(obj)/signing_key.pem \
+-		-keyout $(obj)/signing_key.pem 2>&1
+-	@echo "###"
+-	@echo "### Key pair generated."
+-	@echo "###"
++		-keyout $(obj)/signing_key.pem \
++		$($(quiet)redirect_openssl)
++	@$(kecho) "###"
++	@$(kecho) "### Key pair generated."
++	@$(kecho) "###"
+ 
+ $(obj)/x509.genkey:
+-	@echo Generating X.509 key generation config
++	@$(kecho) Generating X.509 key generation config
+ 	@echo  >$@ "[ req ]"
+ 	@echo >>$@ "default_bits = 4096"
+ 	@echo >>$@ "distinguished_name = req_distinguished_name"
+diff --git a/drivers/Makefile b/drivers/Makefile
+index 098997f2cc3a..f42a74ebc1be 100644
+--- a/drivers/Makefile
++++ b/drivers/Makefile
+@@ -96,6 +96,7 @@ obj-$(CONFIG_TC)		+= tc/
+ obj-$(CONFIG_UWB)		+= uwb/
+ obj-$(CONFIG_USB_PHY)		+= usb/
+ obj-$(CONFIG_USB)		+= usb/
++obj-$(CONFIG_USB_SUPPORT)	+= usb/
+ obj-$(CONFIG_PCI)		+= usb/
+ obj-$(CONFIG_USB_GADGET)	+= usb/
+ obj-$(CONFIG_OF)		+= usb/
+diff --git a/drivers/android/binder.c b/drivers/android/binder.c
+index 5531f020e561..55613f6f7c0e 100644
+--- a/drivers/android/binder.c
++++ b/drivers/android/binder.c
+@@ -2622,6 +2622,8 @@ static unsigned int binder_poll(struct file *filp,
+ 	binder_lock(__func__);
+ 
+ 	thread = binder_get_thread(proc);
++	if (!thread)
++		return POLLERR;
+ 
+ 	wait_for_proc_work = thread->transaction_stack == NULL &&
+ 		list_empty(&thread->todo) && thread->return_error == BR_OK;
+diff --git a/drivers/char/hw_random/exynos-rng.c b/drivers/char/hw_random/exynos-rng.c
+index 7845a38b6604..7ba0ae060d61 100644
+--- a/drivers/char/hw_random/exynos-rng.c
++++ b/drivers/char/hw_random/exynos-rng.c
+@@ -155,8 +155,7 @@ static int exynos_rng_probe(struct platform_device *pdev)
+ 	return ret;
+ }
+ 
+-#ifdef CONFIG_PM
+-static int exynos_rng_runtime_suspend(struct device *dev)
++static int __maybe_unused exynos_rng_runtime_suspend(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);
+@@ -166,7 +165,7 @@ static int exynos_rng_runtime_suspend(struct device *dev)
+ 	return 0;
+ }
+ 
+-static int exynos_rng_runtime_resume(struct device *dev)
++static int __maybe_unused exynos_rng_runtime_resume(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);
+@@ -174,12 +173,12 @@ static int exynos_rng_runtime_resume(struct device *dev)
+ 	return clk_prepare_enable(exynos_rng->clk);
+ }
+ 
+-static int exynos_rng_suspend(struct device *dev)
++static int __maybe_unused exynos_rng_suspend(struct device *dev)
+ {
+ 	return pm_runtime_force_suspend(dev);
+ }
+ 
+-static int exynos_rng_resume(struct device *dev)
++static int __maybe_unused exynos_rng_resume(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);
+@@ -191,7 +190,6 @@ static int exynos_rng_resume(struct device *dev)
+ 
+ 	return exynos_rng_configure(exynos_rng);
+ }
+-#endif
+ 
+ static const struct dev_pm_ops exynos_rng_pm_ops = {
+ 	SET_SYSTEM_SLEEP_PM_OPS(exynos_rng_suspend, exynos_rng_resume)
+diff --git a/drivers/crypto/s5p-sss.c b/drivers/crypto/s5p-sss.c
+index fd39893079d5..45ea8957a73a 100644
+--- a/drivers/crypto/s5p-sss.c
++++ b/drivers/crypto/s5p-sss.c
+@@ -401,16 +401,21 @@ static void s5p_aes_crypt_start(struct s5p_aes_dev *dev, unsigned long mode)
+ 	uint32_t                    aes_control;
+ 	int                         err;
+ 	unsigned long               flags;
++	u8 *iv;
+ 
+ 	aes_control = SSS_AES_KEY_CHANGE_MODE;
+ 	if (mode & FLAGS_AES_DECRYPT)
+ 		aes_control |= SSS_AES_MODE_DECRYPT;
+ 
+-	if ((mode & FLAGS_AES_MODE_MASK) == FLAGS_AES_CBC)
++	if ((mode & FLAGS_AES_MODE_MASK) == FLAGS_AES_CBC) {
+ 		aes_control |= SSS_AES_CHAIN_MODE_CBC;
+-	else if ((mode & FLAGS_AES_MODE_MASK) == FLAGS_AES_CTR)
++		iv = req->info;
++	} else if ((mode & FLAGS_AES_MODE_MASK) == FLAGS_AES_CTR) {
+ 		aes_control |= SSS_AES_CHAIN_MODE_CTR;
+-
++		iv = req->info;
++	} else {
++		iv = NULL; /* AES_ECB */
++	}
+ 	if (dev->ctx->keylen == AES_KEYSIZE_192)
+ 		aes_control |= SSS_AES_KEY_SIZE_192;
+ 	else if (dev->ctx->keylen == AES_KEYSIZE_256)
+@@ -440,7 +445,7 @@ static void s5p_aes_crypt_start(struct s5p_aes_dev *dev, unsigned long mode)
+ 		goto outdata_error;
+ 
+ 	SSS_AES_WRITE(dev, AES_CONTROL, aes_control);
+-	s5p_set_aes(dev, dev->ctx->aes_key, req->info, dev->ctx->keylen);
++	s5p_set_aes(dev, dev->ctx->aes_key, iv, dev->ctx->keylen);
+ 
+ 	s5p_set_dma_indata(dev,  req->src);
+ 	s5p_set_dma_outdata(dev, req->dst);
+diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c
+index 53d22eb73b56..be26f625bb3e 100644
+--- a/drivers/dma/at_hdmac.c
++++ b/drivers/dma/at_hdmac.c
+@@ -716,7 +716,7 @@ atc_prep_dma_interleaved(struct dma_chan *chan,
+ 			 unsigned long flags)
+ {
+ 	struct at_dma_chan	*atchan = to_at_dma_chan(chan);
+-	struct data_chunk	*first = xt->sgl;
++	struct data_chunk	*first;
+ 	struct at_desc		*desc = NULL;
+ 	size_t			xfer_count;
+ 	unsigned int		dwidth;
+@@ -728,6 +728,8 @@ atc_prep_dma_interleaved(struct dma_chan *chan,
+ 	if (unlikely(!xt || xt->numf != 1 || !xt->frame_size))
+ 		return NULL;
+ 
++	first = xt->sgl;
++
+ 	dev_info(chan2dev(chan),
+ 		 "%s: src=%pad, dest=%pad, numf=%d, frame_size=%d, flags=0x%lx\n",
+ 		__func__, &xt->src_start, &xt->dst_start, xt->numf,
+diff --git a/drivers/dma/dma-jz4740.c b/drivers/dma/dma-jz4740.c
+index 7638b24ce8d0..35fc58f4bf4b 100644
+--- a/drivers/dma/dma-jz4740.c
++++ b/drivers/dma/dma-jz4740.c
+@@ -557,7 +557,7 @@ static int jz4740_dma_probe(struct platform_device *pdev)
+ 
+ 	ret = dma_async_device_register(dd);
+ 	if (ret)
+-		return ret;
++		goto err_clk;
+ 
+ 	irq = platform_get_irq(pdev, 0);
+ 	ret = request_irq(irq, jz4740_dma_irq, 0, dev_name(&pdev->dev), dmadev);
+@@ -570,6 +570,8 @@ static int jz4740_dma_probe(struct platform_device *pdev)
+ 
+ err_unregister:
+ 	dma_async_device_unregister(dd);
++err_clk:
++	clk_disable_unprepare(dmadev->clk);
+ 	return ret;
+ }
+ 
+diff --git a/drivers/dma/ioat/init.c b/drivers/dma/ioat/init.c
+index abb75ebd65ea..ac8c28968422 100644
+--- a/drivers/dma/ioat/init.c
++++ b/drivers/dma/ioat/init.c
+@@ -395,7 +395,7 @@ static int ioat_dma_self_test(struct ioatdma_device *ioat_dma)
+ 	if (memcmp(src, dest, IOAT_TEST_SIZE)) {
+ 		dev_err(dev, "Self-test copy failed compare, disabling\n");
+ 		err = -ENODEV;
+-		goto free_resources;
++		goto unmap_dma;
+ 	}
+ 
+ unmap_dma:
+diff --git a/drivers/dma/zx296702_dma.c b/drivers/dma/zx296702_dma.c
+index 6059d81e701a..8e55403847b2 100644
+--- a/drivers/dma/zx296702_dma.c
++++ b/drivers/dma/zx296702_dma.c
+@@ -26,7 +26,7 @@
+ 
+ #define DRIVER_NAME		"zx-dma"
+ #define DMA_ALIGN		4
+-#define DMA_MAX_SIZE		(0x10000 - PAGE_SIZE)
++#define DMA_MAX_SIZE		(0x10000 - 512)
+ #define LLI_BLOCK_SIZE		(4 * PAGE_SIZE)
+ 
+ #define REG_ZX_SRC_ADDR			0x00
+diff --git a/drivers/gpio/gpio-intel-mid.c b/drivers/gpio/gpio-intel-mid.c
+index c50e930d97d3..297121acc57d 100644
+--- a/drivers/gpio/gpio-intel-mid.c
++++ b/drivers/gpio/gpio-intel-mid.c
+@@ -326,7 +326,7 @@ static void intel_mid_irq_init_hw(struct intel_mid_gpio *priv)
+ 	}
+ }
+ 
+-static int intel_gpio_runtime_idle(struct device *dev)
++static int __maybe_unused intel_gpio_runtime_idle(struct device *dev)
+ {
+ 	int err = pm_schedule_suspend(dev, 500);
+ 	return err ?: -EBUSY;
+diff --git a/drivers/gpio/gpio-xgene.c b/drivers/gpio/gpio-xgene.c
+index 18a8182d4fec..7f1f32324504 100644
+--- a/drivers/gpio/gpio-xgene.c
++++ b/drivers/gpio/gpio-xgene.c
+@@ -42,9 +42,7 @@ struct xgene_gpio {
+ 	struct gpio_chip	chip;
+ 	void __iomem		*base;
+ 	spinlock_t		lock;
+-#ifdef CONFIG_PM
+ 	u32			set_dr_val[XGENE_MAX_GPIO_BANKS];
+-#endif
+ };
+ 
+ static inline struct xgene_gpio *to_xgene_gpio(struct gpio_chip *chip)
+@@ -132,8 +130,7 @@ static int xgene_gpio_dir_out(struct gpio_chip *gc,
+ 	return 0;
+ }
+ 
+-#ifdef CONFIG_PM
+-static int xgene_gpio_suspend(struct device *dev)
++static __maybe_unused int xgene_gpio_suspend(struct device *dev)
+ {
+ 	struct xgene_gpio *gpio = dev_get_drvdata(dev);
+ 	unsigned long bank_offset;
+@@ -146,7 +143,7 @@ static int xgene_gpio_suspend(struct device *dev)
+ 	return 0;
+ }
+ 
+-static int xgene_gpio_resume(struct device *dev)
++static __maybe_unused int xgene_gpio_resume(struct device *dev)
+ {
+ 	struct xgene_gpio *gpio = dev_get_drvdata(dev);
+ 	unsigned long bank_offset;
+@@ -160,10 +157,6 @@ static int xgene_gpio_resume(struct device *dev)
+ }
+ 
+ static SIMPLE_DEV_PM_OPS(xgene_gpio_pm, xgene_gpio_suspend, xgene_gpio_resume);
+-#define XGENE_GPIO_PM_OPS	(&xgene_gpio_pm)
+-#else
+-#define XGENE_GPIO_PM_OPS	NULL
+-#endif
+ 
+ static int xgene_gpio_probe(struct platform_device *pdev)
+ {
+@@ -230,7 +223,7 @@ static struct platform_driver xgene_gpio_driver = {
+ 	.driver = {
+ 		.name = "xgene-gpio",
+ 		.of_match_table = xgene_gpio_of_match,
+-		.pm     = XGENE_GPIO_PM_OPS,
++		.pm     = &xgene_gpio_pm,
+ 	},
+ 	.probe = xgene_gpio_probe,
+ 	.remove = xgene_gpio_remove,
+diff --git a/drivers/gpu/drm/armada/armada_crtc.c b/drivers/gpu/drm/armada/armada_crtc.c
+index cebcab560626..5d68189176cc 100644
+--- a/drivers/gpu/drm/armada/armada_crtc.c
++++ b/drivers/gpu/drm/armada/armada_crtc.c
+@@ -1182,17 +1182,13 @@ static int armada_drm_crtc_create(struct drm_device *drm, struct device *dev,
+ 
+ 	ret = devm_request_irq(dev, irq, armada_drm_irq, 0, "armada_drm_crtc",
+ 			       dcrtc);
+-	if (ret < 0) {
+-		kfree(dcrtc);
+-		return ret;
+-	}
++	if (ret < 0)
++		goto err_crtc;
+ 
+ 	if (dcrtc->variant->init) {
+ 		ret = dcrtc->variant->init(dcrtc, dev);
+-		if (ret) {
+-			kfree(dcrtc);
+-			return ret;
+-		}
++		if (ret)
++			goto err_crtc;
+ 	}
+ 
+ 	/* Ensure AXI pipeline is enabled */
+@@ -1203,13 +1199,15 @@ static int armada_drm_crtc_create(struct drm_device *drm, struct device *dev,
+ 	dcrtc->crtc.port = port;
+ 
+ 	primary = kzalloc(sizeof(*primary), GFP_KERNEL);
+-	if (!primary)
+-		return -ENOMEM;
++	if (!primary) {
++		ret = -ENOMEM;
++		goto err_crtc;
++	}
+ 
+ 	ret = armada_drm_plane_init(primary);
+ 	if (ret) {
+ 		kfree(primary);
+-		return ret;
++		goto err_crtc;
+ 	}
+ 
+ 	ret = drm_universal_plane_init(drm, &primary->base, 0,
+@@ -1219,7 +1217,7 @@ static int armada_drm_crtc_create(struct drm_device *drm, struct device *dev,
+ 				       DRM_PLANE_TYPE_PRIMARY);
+ 	if (ret) {
+ 		kfree(primary);
+-		return ret;
++		goto err_crtc;
+ 	}
+ 
+ 	ret = drm_crtc_init_with_planes(drm, &dcrtc->crtc, &primary->base, NULL,
+@@ -1238,6 +1236,9 @@ static int armada_drm_crtc_create(struct drm_device *drm, struct device *dev,
+ 
+ err_crtc_init:
+ 	primary->base.funcs->destroy(&primary->base);
++err_crtc:
++	kfree(dcrtc);
++
+ 	return ret;
+ }
+ 
+diff --git a/drivers/gpu/drm/drm_modeset_lock.c b/drivers/gpu/drm/drm_modeset_lock.c
+index 6675b1428410..c257de351cfa 100644
+--- a/drivers/gpu/drm/drm_modeset_lock.c
++++ b/drivers/gpu/drm/drm_modeset_lock.c
+@@ -69,7 +69,7 @@ void drm_modeset_lock_all(struct drm_device *dev)
+ 	struct drm_modeset_acquire_ctx *ctx;
+ 	int ret;
+ 
+-	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
++	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL | __GFP_NOFAIL);
+ 	if (WARN_ON(!ctx))
+ 		return;
+ 
+diff --git a/drivers/gpu/drm/gma500/mdfld_dsi_dpi.c b/drivers/gpu/drm/gma500/mdfld_dsi_dpi.c
+index d4813e03f5ee..00275c3856ce 100644
+--- a/drivers/gpu/drm/gma500/mdfld_dsi_dpi.c
++++ b/drivers/gpu/drm/gma500/mdfld_dsi_dpi.c
+@@ -821,14 +821,18 @@ void mdfld_dsi_dpi_mode_set(struct drm_encoder *encoder,
+ 	struct drm_device *dev = dsi_config->dev;
+ 	struct drm_psb_private *dev_priv = dev->dev_private;
+ 	int pipe = mdfld_dsi_encoder_get_pipe(dsi_encoder);
+-
+ 	u32 pipeconf_reg = PIPEACONF;
+ 	u32 dspcntr_reg = DSPACNTR;
++	u32 pipeconf, dspcntr;
+ 
+-	u32 pipeconf = dev_priv->pipeconf[pipe];
+-	u32 dspcntr = dev_priv->dspcntr[pipe];
+ 	u32 mipi = MIPI_PORT_EN | PASS_FROM_SPHY_TO_AFE | SEL_FLOPPED_HSTX;
+ 
++	if (WARN_ON(pipe < 0))
++		return;
++
++	pipeconf = dev_priv->pipeconf[pipe];
++	dspcntr = dev_priv->dspcntr[pipe];
++
+ 	if (pipe) {
+ 		pipeconf_reg = PIPECCONF;
+ 		dspcntr_reg = DSPCCNTR;
+diff --git a/drivers/gpu/drm/gma500/mdfld_dsi_output.c b/drivers/gpu/drm/gma500/mdfld_dsi_output.c
+index 89f705c3a5eb..910a2f253990 100644
+--- a/drivers/gpu/drm/gma500/mdfld_dsi_output.c
++++ b/drivers/gpu/drm/gma500/mdfld_dsi_output.c
+@@ -382,16 +382,6 @@ static int mdfld_dsi_connector_mode_valid(struct drm_connector *connector,
+ 	return MODE_OK;
+ }
+ 
+-static void mdfld_dsi_connector_dpms(struct drm_connector *connector, int mode)
+-{
+-	if (mode == connector->dpms)
+-		return;
+-
+-	/*first, execute dpms*/
+-
+-	drm_helper_connector_dpms(connector, mode);
+-}
+-
+ static struct drm_encoder *mdfld_dsi_connector_best_encoder(
+ 				struct drm_connector *connector)
+ {
+@@ -404,7 +394,7 @@ static struct drm_encoder *mdfld_dsi_connector_best_encoder(
+ 
+ /*DSI connector funcs*/
+ static const struct drm_connector_funcs mdfld_dsi_connector_funcs = {
+-	.dpms = /*drm_helper_connector_dpms*/mdfld_dsi_connector_dpms,
++	.dpms = drm_helper_connector_dpms,
+ 	.save = mdfld_dsi_connector_save,
+ 	.restore = mdfld_dsi_connector_restore,
+ 	.detect = mdfld_dsi_connector_detect,
+diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.c b/drivers/gpu/drm/nouveau/nouveau_gem.c
+index a0865c49ec83..495c279da200 100644
+--- a/drivers/gpu/drm/nouveau/nouveau_gem.c
++++ b/drivers/gpu/drm/nouveau/nouveau_gem.c
+@@ -370,7 +370,7 @@ validate_init(struct nouveau_channel *chan, struct drm_file *file_priv,
+ 	struct nouveau_cli *cli = nouveau_cli(file_priv);
+ 	struct drm_device *dev = chan->drm->dev;
+ 	int trycnt = 0;
+-	int ret, i;
++	int ret = -EINVAL, i;
+ 	struct nouveau_bo *res_bo = NULL;
+ 	LIST_HEAD(gart_list);
+ 	LIST_HEAD(vram_list);
+diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c
+index 67cebb23c940..aa04fb0159a7 100644
+--- a/drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c
++++ b/drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c
+@@ -293,13 +293,10 @@ static int vmw_cmdbuf_header_submit(struct vmw_cmdbuf_header *header)
+ 	struct vmw_cmdbuf_man *man = header->man;
+ 	u32 val;
+ 
+-	if (sizeof(header->handle) > 4)
+-		val = (header->handle >> 32);
+-	else
+-		val = 0;
++	val = upper_32_bits(header->handle);
+ 	vmw_write(man->dev_priv, SVGA_REG_COMMAND_HIGH, val);
+ 
+-	val = (header->handle & 0xFFFFFFFFULL);
++	val = lower_32_bits(header->handle);
+ 	val |= header->cb_context & SVGA_CB_CONTEXT_MASK;
+ 	vmw_write(man->dev_priv, SVGA_REG_COMMAND_LOW, val);
+ 
+diff --git a/drivers/hv/hv.c b/drivers/hv/hv.c
+index d415a804fd26..9a8976a79b29 100644
+--- a/drivers/hv/hv.c
++++ b/drivers/hv/hv.c
+@@ -195,9 +195,7 @@ int hv_init(void)
+ {
+ 	int max_leaf;
+ 	union hv_x64_msr_hypercall_contents hypercall_msr;
+-	union hv_x64_msr_hypercall_contents tsc_msr;
+ 	void *virtaddr = NULL;
+-	void *va_tsc = NULL;
+ 
+ 	memset(hv_context.synic_event_page, 0, sizeof(void *) * NR_CPUS);
+ 	memset(hv_context.synic_message_page, 0,
+@@ -243,6 +241,9 @@ int hv_init(void)
+ 
+ #ifdef CONFIG_X86_64
+ 	if (ms_hyperv.features & HV_X64_MSR_REFERENCE_TSC_AVAILABLE) {
++		union hv_x64_msr_hypercall_contents tsc_msr;
++		void *va_tsc;
++
+ 		va_tsc = __vmalloc(PAGE_SIZE, GFP_KERNEL, PAGE_KERNEL);
+ 		if (!va_tsc)
+ 			goto cleanup;
+diff --git a/drivers/i2c/i2c-boardinfo.c b/drivers/i2c/i2c-boardinfo.c
+index 90e322959303..42c25aed671d 100644
+--- a/drivers/i2c/i2c-boardinfo.c
++++ b/drivers/i2c/i2c-boardinfo.c
+@@ -56,9 +56,7 @@ EXPORT_SYMBOL_GPL(__i2c_first_dynamic_bus_num);
+  * The board info passed can safely be __initdata, but be careful of embedded
+  * pointers (for platform_data, functions, etc) since that won't be copied.
+  */
+-int __init
+-i2c_register_board_info(int busnum,
+-	struct i2c_board_info const *info, unsigned len)
++int i2c_register_board_info(int busnum, struct i2c_board_info const *info, unsigned len)
+ {
+ 	int status;
+ 
+diff --git a/drivers/idle/Kconfig b/drivers/idle/Kconfig
+index 4732dfc15447..331adc509f3a 100644
+--- a/drivers/idle/Kconfig
++++ b/drivers/idle/Kconfig
+@@ -17,6 +17,7 @@ config I7300_IDLE_IOAT_CHANNEL
+ 
+ config I7300_IDLE
+ 	tristate "Intel chipset idle memory power saving driver"
++	depends on PCI
+ 	select I7300_IDLE_IOAT_CHANNEL
+ 	help
+ 	  Enable memory power savings when idle with certain Intel server
+diff --git a/drivers/iio/adc/axp288_adc.c b/drivers/iio/adc/axp288_adc.c
+index f684fe31f832..64799ad7ebad 100644
+--- a/drivers/iio/adc/axp288_adc.c
++++ b/drivers/iio/adc/axp288_adc.c
+@@ -44,7 +44,7 @@ struct axp288_adc_info {
+ 	struct regmap *regmap;
+ };
+ 
+-static const struct iio_chan_spec const axp288_adc_channels[] = {
++static const struct iio_chan_spec axp288_adc_channels[] = {
+ 	{
+ 		.indexed = 1,
+ 		.type = IIO_TEMP,
+diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
+index e354358db77b..b6c9a370a38b 100644
+--- a/drivers/infiniband/core/cma.c
++++ b/drivers/infiniband/core/cma.c
+@@ -626,6 +626,7 @@ struct rdma_cm_id *rdma_create_id(struct net *net,
+ 	INIT_LIST_HEAD(&id_priv->mc_list);
+ 	get_random_bytes(&id_priv->seq_num, sizeof id_priv->seq_num);
+ 	id_priv->id.route.addr.dev_addr.net = get_net(net);
++	id_priv->seq_num &= 0x00ffffff;
+ 
+ 	return &id_priv->id;
+ }
+diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c
+index 58fce1742b8d..337b1a5eb41c 100644
+--- a/drivers/infiniband/hw/cxgb4/device.c
++++ b/drivers/infiniband/hw/cxgb4/device.c
+@@ -809,10 +809,9 @@ static int c4iw_rdev_open(struct c4iw_rdev *rdev)
+ 	     rdev->lldi.vr->qp.size,
+ 	     rdev->lldi.vr->cq.start,
+ 	     rdev->lldi.vr->cq.size);
+-	PDBG("udb len 0x%x udb base %p db_reg %p gts_reg %p "
++	PDBG("udb %pR db_reg %p gts_reg %p "
+ 	     "qpmask 0x%x cqmask 0x%x\n",
+-	     (unsigned)pci_resource_len(rdev->lldi.pdev, 2),
+-	     (void *)pci_resource_start(rdev->lldi.pdev, 2),
++		&rdev->lldi.pdev->resource[2],
+ 	     rdev->lldi.db_reg, rdev->lldi.gts_reg,
+ 	     rdev->qpmask, rdev->cqmask);
+ 
+diff --git a/drivers/input/keyboard/tca8418_keypad.c b/drivers/input/keyboard/tca8418_keypad.c
+index 9002298698fc..3048ef3e3e16 100644
+--- a/drivers/input/keyboard/tca8418_keypad.c
++++ b/drivers/input/keyboard/tca8418_keypad.c
+@@ -164,11 +164,18 @@ static void tca8418_read_keypad(struct tca8418_keypad *keypad_data)
+ 	int error, col, row;
+ 	u8 reg, state, code;
+ 
+-	/* Initial read of the key event FIFO */
+-	error = tca8418_read_byte(keypad_data, REG_KEY_EVENT_A, &reg);
++	do {
++		error = tca8418_read_byte(keypad_data, REG_KEY_EVENT_A, &reg);
++		if (error < 0) {
++			dev_err(&keypad_data->client->dev,
++				"unable to read REG_KEY_EVENT_A\n");
++			break;
++		}
++
++		/* Assume that key code 0 signifies empty FIFO */
++		if (reg <= 0)
++			break;
+ 
+-	/* Assume that key code 0 signifies empty FIFO */
+-	while (error >= 0 && reg > 0) {
+ 		state = reg & KEY_EVENT_VALUE;
+ 		code  = reg & KEY_EVENT_CODE;
+ 
+@@ -184,11 +191,7 @@ static void tca8418_read_keypad(struct tca8418_keypad *keypad_data)
+ 
+ 		/* Read for next loop */
+ 		error = tca8418_read_byte(keypad_data, REG_KEY_EVENT_A, &reg);
+-	}
+-
+-	if (error < 0)
+-		dev_err(&keypad_data->client->dev,
+-			"unable to read REG_KEY_EVENT_A\n");
++	} while (1);
+ 
+ 	input_sync(input);
+ }
+diff --git a/drivers/isdn/hardware/eicon/message.c b/drivers/isdn/hardware/eicon/message.c
+index 7b4ddf0a39ec..2d28530b7e82 100644
+--- a/drivers/isdn/hardware/eicon/message.c
++++ b/drivers/isdn/hardware/eicon/message.c
+@@ -147,7 +147,7 @@ static word plci_remove_check(PLCI *);
+ static void listen_check(DIVA_CAPI_ADAPTER *);
+ static byte AddInfo(byte **, byte **, byte *, byte *);
+ static byte getChannel(API_PARSE *);
+-static void IndParse(PLCI *, word *, byte **, byte);
++static void IndParse(PLCI *, const word *, byte **, byte);
+ static byte ie_compare(byte *, byte *);
+ static word find_cip(DIVA_CAPI_ADAPTER *, byte *, byte *);
+ static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *, word);
+@@ -4860,7 +4860,7 @@ static void sig_ind(PLCI *plci)
+ 	/* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
+ 	/* SMSG is situated at the end because its 0 (for compatibility reasons */
+ 	/* (see Info_Mask Bit 4, first IE. then the message type)           */
+-	word parms_id[] =
++	static const word parms_id[] =
+ 		{MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
+ 		 UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
+ 		 RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
+@@ -4868,12 +4868,12 @@ static void sig_ind(PLCI *plci)
+ 	/* 14 FTY repl by ESC_CHI */
+ 	/* 18 PI  repl by ESC_LAW */
+ 	/* removed OAD changed to 0xff for future use, OAD is multiIE now */
+-	word multi_fac_id[] = {1, FTY};
+-	word multi_pi_id[]  = {1, PI};
+-	word multi_CiPN_id[]  = {1, OAD};
+-	word multi_ssext_id[]  = {1, ESC_SSEXT};
++	static const word multi_fac_id[] = {1, FTY};
++	static const word multi_pi_id[]  = {1, PI};
++	static const word multi_CiPN_id[]  = {1, OAD};
++	static const word multi_ssext_id[]  = {1, ESC_SSEXT};
+ 
+-	word multi_vswitch_id[]  = {1, ESC_VSWITCH};
++	static const word multi_vswitch_id[]  = {1, ESC_VSWITCH};
+ 
+ 	byte *cau;
+ 	word ncci;
+@@ -8926,7 +8926,7 @@ static void listen_check(DIVA_CAPI_ADAPTER *a)
+ /* functions for all parameters sent in INDs                        */
+ /*------------------------------------------------------------------*/
+ 
+-static void IndParse(PLCI *plci, word *parms_id, byte **parms, byte multiIEsize)
++static void IndParse(PLCI *plci, const word *parms_id, byte **parms, byte multiIEsize)
+ {
+ 	word ploc;            /* points to current location within packet */
+ 	byte w;
+diff --git a/drivers/isdn/icn/icn.c b/drivers/isdn/icn/icn.c
+index 358a574d9e8b..46d957c34be1 100644
+--- a/drivers/isdn/icn/icn.c
++++ b/drivers/isdn/icn/icn.c
+@@ -718,7 +718,7 @@ icn_sendbuf(int channel, int ack, struct sk_buff *skb, icn_card *card)
+ 			return 0;
+ 		if (card->sndcount[channel] > ICN_MAX_SQUEUE)
+ 			return 0;
+-#warning TODO test headroom or use skb->nb to flag ACK
++		/* TODO test headroom or use skb->nb to flag ACK */
+ 		nskb = skb_clone(skb, GFP_ATOMIC);
+ 		if (nskb) {
+ 			/* Push ACK flag as one
+diff --git a/drivers/isdn/sc/init.c b/drivers/isdn/sc/init.c
+index 3597ef47b28a..09fc129ef2fa 100644
+--- a/drivers/isdn/sc/init.c
++++ b/drivers/isdn/sc/init.c
+@@ -441,6 +441,7 @@ static int identify_board(unsigned long rambase, unsigned int iobase)
+ 	RspMessage rcvmsg;
+ 	ReqMessage sndmsg;
+ 	HWConfig_pl hwci;
++	void __iomem *rambase_sig = (void __iomem *)rambase + SIG_OFFSET;
+ 	int x;
+ 
+ 	pr_debug("Attempting to identify adapter @ 0x%lx io 0x%x\n",
+@@ -481,7 +482,7 @@ static int identify_board(unsigned long rambase, unsigned int iobase)
+ 	 */
+ 	outb(PRI_BASEPG_VAL, pgport);
+ 	msleep_interruptible(1000);
+-	sig = readl(rambase + SIG_OFFSET);
++	sig = readl(rambase_sig);
+ 	pr_debug("Looking for a signature, got 0x%lx\n", sig);
+ 	if (sig == SIGNATURE)
+ 		return PRI_BOARD;
+@@ -491,7 +492,7 @@ static int identify_board(unsigned long rambase, unsigned int iobase)
+ 	 */
+ 	outb(BRI_BASEPG_VAL, pgport);
+ 	msleep_interruptible(1000);
+-	sig = readl(rambase + SIG_OFFSET);
++	sig = readl(rambase_sig);
+ 	pr_debug("Looking for a signature, got 0x%lx\n", sig);
+ 	if (sig == SIGNATURE)
+ 		return BRI_BOARD;
+@@ -501,7 +502,7 @@ static int identify_board(unsigned long rambase, unsigned int iobase)
+ 	/*
+ 	 * Try to spot a card
+ 	 */
+-	sig = readl(rambase + SIG_OFFSET);
++	sig = readl(rambase_sig);
+ 	pr_debug("Looking for a signature, got 0x%lx\n", sig);
+ 	if (sig != SIGNATURE)
+ 		return -1;
+diff --git a/drivers/md/md.c b/drivers/md/md.c
+index 0a856cb181e9..62c3328e2a1d 100644
+--- a/drivers/md/md.c
++++ b/drivers/md/md.c
+@@ -1028,8 +1028,9 @@ static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor
+ 	 * (not needed for Linear and RAID0 as metadata doesn't
+ 	 * record this size)
+ 	 */
+-	if (rdev->sectors >= (2ULL << 32) && sb->level >= 1)
+-		rdev->sectors = (2ULL << 32) - 2;
++	if (IS_ENABLED(CONFIG_LBDAF) && (u64)rdev->sectors >= (2ULL << 32) &&
++	    sb->level >= 1)
++		rdev->sectors = (sector_t)(2ULL << 32) - 2;
+ 
+ 	if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
+ 		/* "this cannot possibly happen" ... */
+@@ -1322,8 +1323,9 @@ super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
+ 	/* Limit to 4TB as metadata cannot record more than that.
+ 	 * 4TB == 2^32 KB, or 2*2^32 sectors.
+ 	 */
+-	if (num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
+-		num_sectors = (2ULL << 32) - 2;
++	if (IS_ENABLED(CONFIG_LBDAF) && (u64)num_sectors >= (2ULL << 32) &&
++	    rdev->mddev->level >= 1)
++		num_sectors = (sector_t)(2ULL << 32) - 2;
+ 	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
+ 		       rdev->sb_page);
+ 	md_super_wait(rdev->mddev);
+diff --git a/drivers/media/common/b2c2/flexcop-fe-tuner.c b/drivers/media/common/b2c2/flexcop-fe-tuner.c
+index 9c59f4306883..f5956402fc69 100644
+--- a/drivers/media/common/b2c2/flexcop-fe-tuner.c
++++ b/drivers/media/common/b2c2/flexcop-fe-tuner.c
+@@ -38,7 +38,7 @@ static int flexcop_fe_request_firmware(struct dvb_frontend *fe,
+ #endif
+ 
+ /* lnb control */
+-#if FE_SUPPORTED(MT312) || FE_SUPPORTED(STV0299)
++#if (FE_SUPPORTED(MT312) || FE_SUPPORTED(STV0299)) && FE_SUPPORTED(PLL)
+ static int flexcop_set_voltage(struct dvb_frontend *fe,
+ 			       enum fe_sec_voltage voltage)
+ {
+@@ -68,7 +68,7 @@ static int flexcop_set_voltage(struct dvb_frontend *fe,
+ #endif
+ 
+ #if FE_SUPPORTED(S5H1420) || FE_SUPPORTED(STV0299) || FE_SUPPORTED(MT312)
+-static int flexcop_sleep(struct dvb_frontend* fe)
++static int __maybe_unused flexcop_sleep(struct dvb_frontend* fe)
+ {
+ 	struct flexcop_device *fc = fe->dvb->priv;
+ 	if (fc->fe_sleep)
+diff --git a/drivers/media/i2c/s5k6aa.c b/drivers/media/i2c/s5k6aa.c
+index d0ad6a25bdab..5ac2babe123b 100644
+--- a/drivers/media/i2c/s5k6aa.c
++++ b/drivers/media/i2c/s5k6aa.c
+@@ -421,6 +421,7 @@ static int s5k6aa_set_ahb_address(struct i2c_client *client)
+ 
+ /**
+  * s5k6aa_configure_pixel_clock - apply ISP main clock/PLL configuration
++ * @s5k6aa: pointer to &struct s5k6aa describing the device
+  *
+  * Configure the internal ISP PLL for the required output frequency.
+  * Locking: called with s5k6aa.lock mutex held.
+@@ -669,6 +670,7 @@ static int s5k6aa_set_input_params(struct s5k6aa *s5k6aa)
+ 
+ /**
+  * s5k6aa_configure_video_bus - configure the video output interface
++ * @s5k6aa: pointer to &struct s5k6aa describing the device
+  * @bus_type: video bus type: parallel or MIPI-CSI
+  * @nlanes: number of MIPI lanes to be used (MIPI-CSI only)
+  *
+@@ -724,6 +726,8 @@ static int s5k6aa_new_config_sync(struct i2c_client *client, int timeout,
+ 
+ /**
+  * s5k6aa_set_prev_config - write user preview register set
++ * @s5k6aa: pointer to &struct s5k6aa describing the device
++ * @preset: s5kaa preset to be applied
+  *
+  * Configure output resolution and color fromat, pixel clock
+  * frequency range, device frame rate type and frame period range.
+@@ -777,6 +781,7 @@ static int s5k6aa_set_prev_config(struct s5k6aa *s5k6aa,
+ 
+ /**
+  * s5k6aa_initialize_isp - basic ISP MCU initialization
++ * @sd: pointer to V4L2 sub-device descriptor
+  *
+  * Configure AHB addresses for registers read/write; configure PLLs for
+  * required output pixel clock. The ISP power supply needs to be already
+diff --git a/drivers/media/i2c/tc358743.c b/drivers/media/i2c/tc358743.c
+index 9ef5baaf8646..ea2777e1ee10 100644
+--- a/drivers/media/i2c/tc358743.c
++++ b/drivers/media/i2c/tc358743.c
+@@ -197,57 +197,61 @@ static void i2c_wr(struct v4l2_subdev *sd, u16 reg, u8 *values, u32 n)
+ 	}
+ }
+ 
+-static u8 i2c_rd8(struct v4l2_subdev *sd, u16 reg)
++static noinline u32 i2c_rdreg(struct v4l2_subdev *sd, u16 reg, u32 n)
+ {
+-	u8 val;
++	__le32 val = 0;
+ 
+-	i2c_rd(sd, reg, &val, 1);
++	i2c_rd(sd, reg, (u8 __force *)&val, n);
+ 
+-	return val;
++	return le32_to_cpu(val);
++}
++
++static noinline void i2c_wrreg(struct v4l2_subdev *sd, u16 reg, u32 val, u32 n)
++{
++	__le32 raw = cpu_to_le32(val);
++
++	i2c_wr(sd, reg, (u8 __force *)&raw, n);
++}
++
++static u8 i2c_rd8(struct v4l2_subdev *sd, u16 reg)
++{
++	return i2c_rdreg(sd, reg, 1);
+ }
+ 
+ static void i2c_wr8(struct v4l2_subdev *sd, u16 reg, u8 val)
+ {
+-	i2c_wr(sd, reg, &val, 1);
++	i2c_wrreg(sd, reg, val, 1);
+ }
+ 
+ static void i2c_wr8_and_or(struct v4l2_subdev *sd, u16 reg,
+ 		u8 mask, u8 val)
+ {
+-	i2c_wr8(sd, reg, (i2c_rd8(sd, reg) & mask) | val);
++	i2c_wrreg(sd, reg, (i2c_rdreg(sd, reg, 2) & mask) | val, 2);
+ }
+ 
+ static u16 i2c_rd16(struct v4l2_subdev *sd, u16 reg)
+ {
+-	u16 val;
+-
+-	i2c_rd(sd, reg, (u8 *)&val, 2);
+-
+-	return val;
++	return i2c_rdreg(sd, reg, 2);
+ }
+ 
+ static void i2c_wr16(struct v4l2_subdev *sd, u16 reg, u16 val)
+ {
+-	i2c_wr(sd, reg, (u8 *)&val, 2);
++	i2c_wrreg(sd, reg, val, 2);
+ }
+ 
+ static void i2c_wr16_and_or(struct v4l2_subdev *sd, u16 reg, u16 mask, u16 val)
+ {
+-	i2c_wr16(sd, reg, (i2c_rd16(sd, reg) & mask) | val);
++	i2c_wrreg(sd, reg, (i2c_rdreg(sd, reg, 2) & mask) | val, 2);
+ }
+ 
+ static u32 i2c_rd32(struct v4l2_subdev *sd, u16 reg)
+ {
+-	u32 val;
+-
+-	i2c_rd(sd, reg, (u8 *)&val, 4);
+-
+-	return val;
++	return i2c_rdreg(sd, reg, 4);
+ }
+ 
+ static void i2c_wr32(struct v4l2_subdev *sd, u16 reg, u32 val)
+ {
+-	i2c_wr(sd, reg, (u8 *)&val, 4);
++	i2c_wrreg(sd, reg, val, 4);
+ }
+ 
+ /* --------------- STATUS --------------- */
+@@ -1240,7 +1244,7 @@ static int tc358743_g_register(struct v4l2_subdev *sd,
+ 
+ 	reg->size = tc358743_get_reg_size(reg->reg);
+ 
+-	i2c_rd(sd, reg->reg, (u8 *)&reg->val, reg->size);
++	reg->val = i2c_rdreg(sd, reg->reg, reg->size);
+ 
+ 	return 0;
+ }
+@@ -1266,7 +1270,7 @@ static int tc358743_s_register(struct v4l2_subdev *sd,
+ 	    reg->reg == BCAPS)
+ 		return 0;
+ 
+-	i2c_wr(sd, (u16)reg->reg, (u8 *)&reg->val,
++	i2c_wrreg(sd, (u16)reg->reg, reg->val,
+ 			tc358743_get_reg_size(reg->reg));
+ 
+ 	return 0;
+diff --git a/drivers/media/usb/em28xx/Kconfig b/drivers/media/usb/em28xx/Kconfig
+index e382210c4ada..75323f5efd0f 100644
+--- a/drivers/media/usb/em28xx/Kconfig
++++ b/drivers/media/usb/em28xx/Kconfig
+@@ -11,7 +11,7 @@ config VIDEO_EM28XX_V4L2
+ 	select VIDEO_SAA711X if MEDIA_SUBDRV_AUTOSELECT
+ 	select VIDEO_TVP5150 if MEDIA_SUBDRV_AUTOSELECT
+ 	select VIDEO_MSP3400 if MEDIA_SUBDRV_AUTOSELECT
+-	select VIDEO_MT9V011 if MEDIA_SUBDRV_AUTOSELECT
++	select VIDEO_MT9V011 if MEDIA_SUBDRV_AUTOSELECT && MEDIA_CAMERA_SUPPORT
+ 
+ 	---help---
+ 	  This is a video4linux driver for Empia 28xx based TV cards.
+diff --git a/drivers/media/usb/go7007/Kconfig b/drivers/media/usb/go7007/Kconfig
+index 95a3af644a92..af1d02430931 100644
+--- a/drivers/media/usb/go7007/Kconfig
++++ b/drivers/media/usb/go7007/Kconfig
+@@ -11,7 +11,7 @@ config VIDEO_GO7007
+ 	select VIDEO_TW2804 if MEDIA_SUBDRV_AUTOSELECT
+ 	select VIDEO_TW9903 if MEDIA_SUBDRV_AUTOSELECT
+ 	select VIDEO_TW9906 if MEDIA_SUBDRV_AUTOSELECT
+-	select VIDEO_OV7640 if MEDIA_SUBDRV_AUTOSELECT
++	select VIDEO_OV7640 if MEDIA_SUBDRV_AUTOSELECT && MEDIA_CAMERA_SUPPORT
+ 	select VIDEO_UDA1342 if MEDIA_SUBDRV_AUTOSELECT
+ 	---help---
+ 	  This is a video4linux driver for the WIS GO7007 MPEG
+diff --git a/drivers/media/usb/hdpvr/hdpvr-core.c b/drivers/media/usb/hdpvr/hdpvr-core.c
+index 3fc64197b4e6..08f0ca7aa012 100644
+--- a/drivers/media/usb/hdpvr/hdpvr-core.c
++++ b/drivers/media/usb/hdpvr/hdpvr-core.c
+@@ -273,7 +273,9 @@ static int hdpvr_probe(struct usb_interface *interface,
+ 	struct hdpvr_device *dev;
+ 	struct usb_host_interface *iface_desc;
+ 	struct usb_endpoint_descriptor *endpoint;
++#if IS_ENABLED(CONFIG_I2C)
+ 	struct i2c_client *client;
++#endif
+ 	size_t buffer_size;
+ 	int i;
+ 	int retval = -ENOMEM;
+diff --git a/drivers/media/usb/pwc/pwc-if.c b/drivers/media/usb/pwc/pwc-if.c
+index 58f23bcfe94e..299750e56916 100644
+--- a/drivers/media/usb/pwc/pwc-if.c
++++ b/drivers/media/usb/pwc/pwc-if.c
+@@ -1119,8 +1119,10 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
+ 
+ 	return 0;
+ 
++#ifdef CONFIG_USB_PWC_INPUT_EVDEV
+ err_video_unreg:
+ 	video_unregister_device(&pdev->vdev);
++#endif
+ err_unregister_v4l2_dev:
+ 	v4l2_device_unregister(&pdev->v4l2_dev);
+ err_free_controls:
+diff --git a/drivers/media/v4l2-core/Kconfig b/drivers/media/v4l2-core/Kconfig
+index 9beece00869b..29b3436d0910 100644
+--- a/drivers/media/v4l2-core/Kconfig
++++ b/drivers/media/v4l2-core/Kconfig
+@@ -37,7 +37,6 @@ config VIDEO_PCI_SKELETON
+ # Used by drivers that need tuner.ko
+ config VIDEO_TUNER
+ 	tristate
+-	depends on MEDIA_TUNER
+ 
+ # Used by drivers that need v4l2-mem2mem.ko
+ config V4L2_MEM2MEM_DEV
+diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
+index 5dcc0313c38a..207370d68c17 100644
+--- a/drivers/message/fusion/mptbase.c
++++ b/drivers/message/fusion/mptbase.c
+@@ -6848,6 +6848,7 @@ mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int sh
+ 	*size = y;
+ }
+ 
++#ifdef CONFIG_PROC_FS
+ static void seq_mpt_print_ioc_summary(MPT_ADAPTER *ioc, struct seq_file *m, int showlan)
+ {
+ 	char expVer[32];
+@@ -6879,6 +6880,7 @@ static void seq_mpt_print_ioc_summary(MPT_ADAPTER *ioc, struct seq_file *m, int
+ 
+ 	seq_putc(m, '\n');
+ }
++#endif
+ 
+ /**
+  *	mpt_set_taskmgmt_in_progress_flag - set flags associated with task management
+diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
+index 8a25adced79f..bbfa1f129266 100644
+--- a/drivers/mtd/chips/Kconfig
++++ b/drivers/mtd/chips/Kconfig
+@@ -67,6 +67,10 @@ endchoice
+ config MTD_CFI_GEOMETRY
+ 	bool "Specific CFI Flash geometry selection"
+ 	depends on MTD_CFI_ADV_OPTIONS
++	select MTD_MAP_BANK_WIDTH_1 if  !(MTD_MAP_BANK_WIDTH_2 || \
++		 MTD_MAP_BANK_WIDTH_4  || MTD_MAP_BANK_WIDTH_8 || \
++		 MTD_MAP_BANK_WIDTH_16 || MTD_MAP_BANK_WIDTH_32)
++	select MTD_CFI_I1 if !(MTD_CFI_I2 || MTD_CFI_I4 || MTD_CFI_I8)
+ 	help
+ 	  This option does not affect the code directly, but will enable
+ 	  some other configuration options which would allow you to reduce
+diff --git a/drivers/mtd/maps/ck804xrom.c b/drivers/mtd/maps/ck804xrom.c
+index 0455166f05fa..4f206a99164c 100644
+--- a/drivers/mtd/maps/ck804xrom.c
++++ b/drivers/mtd/maps/ck804xrom.c
+@@ -112,8 +112,8 @@ static void ck804xrom_cleanup(struct ck804xrom_window *window)
+ }
+ 
+ 
+-static int ck804xrom_init_one(struct pci_dev *pdev,
+-			      const struct pci_device_id *ent)
++static int __init ck804xrom_init_one(struct pci_dev *pdev,
++				     const struct pci_device_id *ent)
+ {
+ 	static char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };
+ 	u8 byte;
+diff --git a/drivers/mtd/maps/esb2rom.c b/drivers/mtd/maps/esb2rom.c
+index 76ed651b515b..9646b0766ce0 100644
+--- a/drivers/mtd/maps/esb2rom.c
++++ b/drivers/mtd/maps/esb2rom.c
+@@ -144,8 +144,8 @@ static void esb2rom_cleanup(struct esb2rom_window *window)
+ 	pci_dev_put(window->pdev);
+ }
+ 
+-static int esb2rom_init_one(struct pci_dev *pdev,
+-			    const struct pci_device_id *ent)
++static int __init esb2rom_init_one(struct pci_dev *pdev,
++				   const struct pci_device_id *ent)
+ {
+ 	static char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };
+ 	struct esb2rom_window *window = &esb2rom_window;
+diff --git a/drivers/mtd/maps/ichxrom.c b/drivers/mtd/maps/ichxrom.c
+index 8636bba42200..976d42f63aef 100644
+--- a/drivers/mtd/maps/ichxrom.c
++++ b/drivers/mtd/maps/ichxrom.c
+@@ -57,10 +57,12 @@ static void ichxrom_cleanup(struct ichxrom_window *window)
+ {
+ 	struct ichxrom_map_info *map, *scratch;
+ 	u16 word;
++	int ret;
+ 
+ 	/* Disable writes through the rom window */
+-	pci_read_config_word(window->pdev, BIOS_CNTL, &word);
+-	pci_write_config_word(window->pdev, BIOS_CNTL, word & ~1);
++	ret = pci_read_config_word(window->pdev, BIOS_CNTL, &word);
++	if (!ret)
++		pci_write_config_word(window->pdev, BIOS_CNTL, word & ~1);
+ 	pci_dev_put(window->pdev);
+ 
+ 	/* Free all of the mtd devices */
+@@ -84,8 +86,8 @@ static void ichxrom_cleanup(struct ichxrom_window *window)
+ }
+ 
+ 
+-static int ichxrom_init_one(struct pci_dev *pdev,
+-			    const struct pci_device_id *ent)
++static int __init ichxrom_init_one(struct pci_dev *pdev,
++				   const struct pci_device_id *ent)
+ {
+ 	static char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };
+ 	struct ichxrom_window *window = &ichxrom_window;
+diff --git a/drivers/mtd/nand/sh_flctl.c b/drivers/mtd/nand/sh_flctl.c
+index bcba1a924c75..1f2785ee909f 100644
+--- a/drivers/mtd/nand/sh_flctl.c
++++ b/drivers/mtd/nand/sh_flctl.c
+@@ -160,7 +160,7 @@ static void flctl_setup_dma(struct sh_flctl *flctl)
+ 
+ 	memset(&cfg, 0, sizeof(cfg));
+ 	cfg.direction = DMA_MEM_TO_DEV;
+-	cfg.dst_addr = (dma_addr_t)FLDTFIFO(flctl);
++	cfg.dst_addr = flctl->fifo;
+ 	cfg.src_addr = 0;
+ 	ret = dmaengine_slave_config(flctl->chan_fifo0_tx, &cfg);
+ 	if (ret < 0)
+@@ -176,7 +176,7 @@ static void flctl_setup_dma(struct sh_flctl *flctl)
+ 
+ 	cfg.direction = DMA_DEV_TO_MEM;
+ 	cfg.dst_addr = 0;
+-	cfg.src_addr = (dma_addr_t)FLDTFIFO(flctl);
++	cfg.src_addr = flctl->fifo;
+ 	ret = dmaengine_slave_config(flctl->chan_fifo0_rx, &cfg);
+ 	if (ret < 0)
+ 		goto err;
+@@ -1096,6 +1096,7 @@ static int flctl_probe(struct platform_device *pdev)
+ 	flctl->reg = devm_ioremap_resource(&pdev->dev, res);
+ 	if (IS_ERR(flctl->reg))
+ 		return PTR_ERR(flctl->reg);
++	flctl->fifo = res->start + 0x24; /* FLDTFIFO */
+ 
+ 	irq = platform_get_irq(pdev, 0);
+ 	if (irq < 0) {
+diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
+index f184fb5bd110..5116aec3c174 100644
+--- a/drivers/net/Kconfig
++++ b/drivers/net/Kconfig
+@@ -411,6 +411,9 @@ config XEN_NETDEV_BACKEND
+ config VMXNET3
+ 	tristate "VMware VMXNET3 ethernet driver"
+ 	depends on PCI && INET
++	depends on !(PAGE_SIZE_64KB || ARM64_64K_PAGES || \
++		     IA64_PAGE_SIZE_64KB || MICROBLAZE_64K_PAGES || \
++		     PARISC_PAGE_SIZE_64KB || PPC_64K_PAGES)
+ 	help
+ 	  This driver supports VMware's vmxnet3 virtual ethernet NIC.
+ 	  To compile this driver as a module, choose M here: the
+diff --git a/drivers/net/ethernet/3com/3c509.c b/drivers/net/ethernet/3com/3c509.c
+index 4547a1b8b958..7677c745fb30 100644
+--- a/drivers/net/ethernet/3com/3c509.c
++++ b/drivers/net/ethernet/3com/3c509.c
+@@ -562,7 +562,7 @@ static void el3_common_remove (struct net_device *dev)
+ }
+ 
+ #ifdef CONFIG_EISA
+-static int __init el3_eisa_probe (struct device *device)
++static int el3_eisa_probe(struct device *device)
+ {
+ 	short i;
+ 	int ioaddr, irq, if_port;
+diff --git a/drivers/net/ethernet/3com/3c59x.c b/drivers/net/ethernet/3com/3c59x.c
+index 2839af00f20c..1c5f3b273e6a 100644
+--- a/drivers/net/ethernet/3com/3c59x.c
++++ b/drivers/net/ethernet/3com/3c59x.c
+@@ -907,7 +907,7 @@ static struct eisa_device_id vortex_eisa_ids[] = {
+ };
+ MODULE_DEVICE_TABLE(eisa, vortex_eisa_ids);
+ 
+-static int __init vortex_eisa_probe(struct device *device)
++static int vortex_eisa_probe(struct device *device)
+ {
+ 	void __iomem *ioaddr;
+ 	struct eisa_device *edev;
+diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-main.c b/drivers/net/ethernet/amd/xgbe/xgbe-main.c
+index 618d952c2984..2ef4b4e884ae 100644
+--- a/drivers/net/ethernet/amd/xgbe/xgbe-main.c
++++ b/drivers/net/ethernet/amd/xgbe/xgbe-main.c
+@@ -829,7 +829,7 @@ static int xgbe_remove(struct platform_device *pdev)
+ 	return 0;
+ }
+ 
+-#ifdef CONFIG_PM
++#ifdef CONFIG_PM_SLEEP
+ static int xgbe_suspend(struct device *dev)
+ {
+ 	struct net_device *netdev = dev_get_drvdata(dev);
+@@ -868,7 +868,7 @@ static int xgbe_resume(struct device *dev)
+ 
+ 	return ret;
+ }
+-#endif /* CONFIG_PM */
++#endif /* CONFIG_PM_SLEEP */
+ 
+ #ifdef CONFIG_ACPI
+ static const struct acpi_device_id xgbe_acpi_match[] = {
+diff --git a/drivers/net/ethernet/dec/tulip/de4x5.c b/drivers/net/ethernet/dec/tulip/de4x5.c
+index 8966f3159bb2..3acde3b9b767 100644
+--- a/drivers/net/ethernet/dec/tulip/de4x5.c
++++ b/drivers/net/ethernet/dec/tulip/de4x5.c
+@@ -1990,7 +1990,7 @@ SetMulticastFilter(struct net_device *dev)
+ 
+ static u_char de4x5_irq[] = EISA_ALLOWED_IRQ_LIST;
+ 
+-static int __init de4x5_eisa_probe (struct device *gendev)
++static int de4x5_eisa_probe(struct device *gendev)
+ {
+ 	struct eisa_device *edev;
+ 	u_long iobase;
+diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
+index 7923bfdc9b30..901661149b44 100644
+--- a/drivers/net/ethernet/freescale/gianfar.c
++++ b/drivers/net/ethernet/freescale/gianfar.c
+@@ -1375,9 +1375,11 @@ static int gfar_probe(struct platform_device *ofdev)
+ 
+ 	gfar_init_addr_hash_table(priv);
+ 
+-	/* Insert receive time stamps into padding alignment bytes */
++	/* Insert receive time stamps into padding alignment bytes, and
++	 * plus 2 bytes padding to ensure the cpu alignment.
++	 */
+ 	if (priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER)
+-		priv->padding = 8;
++		priv->padding = 8 + DEFAULT_PADDING;
+ 
+ 	if (dev->features & NETIF_F_IP_CSUM ||
+ 	    priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER)
+diff --git a/drivers/net/ethernet/hp/hp100.c b/drivers/net/ethernet/hp/hp100.c
+index ae6e30d39f0f..3daf2d4a7ca0 100644
+--- a/drivers/net/ethernet/hp/hp100.c
++++ b/drivers/net/ethernet/hp/hp100.c
+@@ -194,7 +194,6 @@ static const char *hp100_isa_tbl[] = {
+ };
+ #endif
+ 
+-#ifdef CONFIG_EISA
+ static struct eisa_device_id hp100_eisa_tbl[] = {
+ 	{ "HWPF180" }, /* HP J2577 rev A */
+ 	{ "HWP1920" }, /* HP 27248B */
+@@ -205,9 +204,7 @@ static struct eisa_device_id hp100_eisa_tbl[] = {
+ 	{ "" }	       /* Mandatory final entry ! */
+ };
+ MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
+-#endif
+ 
+-#ifdef CONFIG_PCI
+ static const struct pci_device_id hp100_pci_tbl[] = {
+ 	{PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,},
+ 	{PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,},
+@@ -219,7 +216,6 @@ static const struct pci_device_id hp100_pci_tbl[] = {
+ 	{}			/* Terminating entry */
+ };
+ MODULE_DEVICE_TABLE(pci, hp100_pci_tbl);
+-#endif
+ 
+ static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
+ static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
+@@ -2842,8 +2838,7 @@ static void cleanup_dev(struct net_device *d)
+ 	free_netdev(d);
+ }
+ 
+-#ifdef CONFIG_EISA
+-static int __init hp100_eisa_probe (struct device *gendev)
++static int hp100_eisa_probe(struct device *gendev)
+ {
+ 	struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
+ 	struct eisa_device *edev = to_eisa_device(gendev);
+@@ -2884,9 +2879,7 @@ static struct eisa_driver hp100_eisa_driver = {
+ 		.remove  = hp100_eisa_remove,
+         }
+ };
+-#endif
+ 
+-#ifdef CONFIG_PCI
+ static int hp100_pci_probe(struct pci_dev *pdev,
+ 			   const struct pci_device_id *ent)
+ {
+@@ -2955,7 +2948,6 @@ static struct pci_driver hp100_pci_driver = {
+ 	.probe		= hp100_pci_probe,
+ 	.remove		= hp100_pci_remove,
+ };
+-#endif
+ 
+ /*
+  *  module section
+@@ -3032,23 +3024,17 @@ static int __init hp100_module_init(void)
+ 	err = hp100_isa_init();
+ 	if (err && err != -ENODEV)
+ 		goto out;
+-#ifdef CONFIG_EISA
+ 	err = eisa_driver_register(&hp100_eisa_driver);
+ 	if (err && err != -ENODEV)
+ 		goto out2;
+-#endif
+-#ifdef CONFIG_PCI
+ 	err = pci_register_driver(&hp100_pci_driver);
+ 	if (err && err != -ENODEV)
+ 		goto out3;
+-#endif
+  out:
+ 	return err;
+  out3:
+-#ifdef CONFIG_EISA
+ 	eisa_driver_unregister (&hp100_eisa_driver);
+  out2:
+-#endif
+ 	hp100_isa_cleanup();
+ 	goto out;
+ }
+@@ -3057,12 +3043,8 @@ static int __init hp100_module_init(void)
+ static void __exit hp100_module_exit(void)
+ {
+ 	hp100_isa_cleanup();
+-#ifdef CONFIG_EISA
+ 	eisa_driver_unregister (&hp100_eisa_driver);
+-#endif
+-#ifdef CONFIG_PCI
+ 	pci_unregister_driver (&hp100_pci_driver);
+-#endif
+ }
+ 
+ module_init(hp100_module_init)
+diff --git a/drivers/net/ethernet/ti/tlan.c b/drivers/net/ethernet/ti/tlan.c
+index a274cd49afe9..399a89f30826 100644
+--- a/drivers/net/ethernet/ti/tlan.c
++++ b/drivers/net/ethernet/ti/tlan.c
+@@ -610,8 +610,8 @@ err_out_regions:
+ #ifdef CONFIG_PCI
+ 	if (pdev)
+ 		pci_release_regions(pdev);
+-#endif
+ err_out:
++#endif
+ 	if (pdev)
+ 		pci_disable_device(pdev);
+ 	return rc;
+diff --git a/drivers/net/hippi/rrunner.c b/drivers/net/hippi/rrunner.c
+index 95c0b45a68fb..313e006f74fe 100644
+--- a/drivers/net/hippi/rrunner.c
++++ b/drivers/net/hippi/rrunner.c
+@@ -1381,8 +1381,8 @@ static int rr_close(struct net_device *dev)
+ 			    rrpriv->info_dma);
+ 	rrpriv->info = NULL;
+ 
+-	free_irq(pdev->irq, dev);
+ 	spin_unlock_irqrestore(&rrpriv->lock, flags);
++	free_irq(pdev->irq, dev);
+ 
+ 	return 0;
+ }
+diff --git a/drivers/net/ipvlan/ipvlan_core.c b/drivers/net/ipvlan/ipvlan_core.c
+index af827faec7fe..8aecea0d5dbf 100644
+--- a/drivers/net/ipvlan/ipvlan_core.c
++++ b/drivers/net/ipvlan/ipvlan_core.c
+@@ -353,6 +353,7 @@ static int ipvlan_process_v4_outbound(struct sk_buff *skb)
+ 		.flowi4_oif = dev->ifindex,
+ 		.flowi4_tos = RT_TOS(ip4h->tos),
+ 		.flowi4_flags = FLOWI_FLAG_ANYSRC,
++		.flowi4_mark = skb->mark,
+ 		.daddr = ip4h->daddr,
+ 		.saddr = ip4h->saddr,
+ 	};
+diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig
+index 1f6893ebce16..3a7286256db0 100644
+--- a/drivers/net/usb/Kconfig
++++ b/drivers/net/usb/Kconfig
+@@ -395,6 +395,10 @@ config USB_NET_RNDIS_HOST
+ 	  The protocol specification is incomplete, and is controlled by
+ 	  (and for) Microsoft; it isn't an "Open" ecosystem or market.
+ 
++config USB_NET_CDC_SUBSET_ENABLE
++	tristate
++	depends on USB_NET_CDC_SUBSET
++
+ config USB_NET_CDC_SUBSET
+ 	tristate "Simple USB Network Links (CDC Ethernet subset)"
+ 	depends on USB_USBNET
+@@ -413,6 +417,7 @@ config USB_NET_CDC_SUBSET
+ config USB_ALI_M5632
+ 	bool "ALi M5632 based 'USB 2.0 Data Link' cables"
+ 	depends on USB_NET_CDC_SUBSET
++	select USB_NET_CDC_SUBSET_ENABLE
+ 	help
+ 	  Choose this option if you're using a host-to-host cable
+ 	  based on this design, which supports USB 2.0 high speed.
+@@ -420,6 +425,7 @@ config USB_ALI_M5632
+ config USB_AN2720
+ 	bool "AnchorChips 2720 based cables (Xircom PGUNET, ...)"
+ 	depends on USB_NET_CDC_SUBSET
++	select USB_NET_CDC_SUBSET_ENABLE
+ 	help
+ 	  Choose this option if you're using a host-to-host cable
+ 	  based on this design.  Note that AnchorChips is now a
+@@ -428,6 +434,7 @@ config USB_AN2720
+ config USB_BELKIN
+ 	bool "eTEK based host-to-host cables (Advance, Belkin, ...)"
+ 	depends on USB_NET_CDC_SUBSET
++	select USB_NET_CDC_SUBSET_ENABLE
+ 	default y
+ 	help
+ 	  Choose this option if you're using a host-to-host cable
+@@ -437,6 +444,7 @@ config USB_BELKIN
+ config USB_ARMLINUX
+ 	bool "Embedded ARM Linux links (iPaq, ...)"
+ 	depends on USB_NET_CDC_SUBSET
++	select USB_NET_CDC_SUBSET_ENABLE
+ 	default y
+ 	help
+ 	  Choose this option to support the "usb-eth" networking driver
+@@ -454,6 +462,7 @@ config USB_ARMLINUX
+ config USB_EPSON2888
+ 	bool "Epson 2888 based firmware (DEVELOPMENT)"
+ 	depends on USB_NET_CDC_SUBSET
++	select USB_NET_CDC_SUBSET_ENABLE
+ 	help
+ 	  Choose this option to support the usb networking links used
+ 	  by some sample firmware from Epson.
+@@ -461,6 +470,7 @@ config USB_EPSON2888
+ config USB_KC2190
+ 	bool "KT Technology KC2190 based cables (InstaNet)"
+ 	depends on USB_NET_CDC_SUBSET
++	select USB_NET_CDC_SUBSET_ENABLE
+ 	help
+ 	  Choose this option if you're using a host-to-host cable
+ 	  with one of these chips.
+diff --git a/drivers/net/usb/Makefile b/drivers/net/usb/Makefile
+index b5f04068dbe4..37fb46aee341 100644
+--- a/drivers/net/usb/Makefile
++++ b/drivers/net/usb/Makefile
+@@ -23,7 +23,7 @@ obj-$(CONFIG_USB_NET_GL620A)	+= gl620a.o
+ obj-$(CONFIG_USB_NET_NET1080)	+= net1080.o
+ obj-$(CONFIG_USB_NET_PLUSB)	+= plusb.o
+ obj-$(CONFIG_USB_NET_RNDIS_HOST)	+= rndis_host.o
+-obj-$(CONFIG_USB_NET_CDC_SUBSET)	+= cdc_subset.o
++obj-$(CONFIG_USB_NET_CDC_SUBSET_ENABLE)	+= cdc_subset.o
+ obj-$(CONFIG_USB_NET_ZAURUS)	+= zaurus.o
+ obj-$(CONFIG_USB_NET_MCS7830)	+= mcs7830.o
+ obj-$(CONFIG_USB_USBNET)	+= usbnet.o
+diff --git a/drivers/net/wireless/cw1200/cw1200_spi.c b/drivers/net/wireless/cw1200/cw1200_spi.c
+index a740083634d8..63f95e9c2992 100644
+--- a/drivers/net/wireless/cw1200/cw1200_spi.c
++++ b/drivers/net/wireless/cw1200/cw1200_spi.c
+@@ -446,8 +446,7 @@ static int cw1200_spi_disconnect(struct spi_device *func)
+ 	return 0;
+ }
+ 
+-#ifdef CONFIG_PM
+-static int cw1200_spi_suspend(struct device *dev)
++static int __maybe_unused cw1200_spi_suspend(struct device *dev)
+ {
+ 	struct hwbus_priv *self = spi_get_drvdata(to_spi_device(dev));
+ 
+@@ -460,16 +459,12 @@ static int cw1200_spi_suspend(struct device *dev)
+ 
+ static SIMPLE_DEV_PM_OPS(cw1200_pm_ops, cw1200_spi_suspend, NULL);
+ 
+-#endif
+-
+ static struct spi_driver spi_driver = {
+ 	.probe		= cw1200_spi_probe,
+ 	.remove		= cw1200_spi_disconnect,
+ 	.driver = {
+ 		.name		= "cw1200_wlan_spi",
+-#ifdef CONFIG_PM
+-		.pm		= &cw1200_pm_ops,
+-#endif
++		.pm		= IS_ENABLED(CONFIG_PM) ? &cw1200_pm_ops : NULL,
+ 	},
+ };
+ 
+diff --git a/drivers/net/wireless/cw1200/pm.h b/drivers/net/wireless/cw1200/pm.h
+index 3ed90ff22bb8..534548470ebc 100644
+--- a/drivers/net/wireless/cw1200/pm.h
++++ b/drivers/net/wireless/cw1200/pm.h
+@@ -31,13 +31,18 @@ int cw1200_pm_init(struct cw1200_pm_state *pm,
+ void cw1200_pm_deinit(struct cw1200_pm_state *pm);
+ int cw1200_wow_suspend(struct ieee80211_hw *hw,
+ 		       struct cfg80211_wowlan *wowlan);
+-int cw1200_wow_resume(struct ieee80211_hw *hw);
+ int cw1200_can_suspend(struct cw1200_common *priv);
++int cw1200_wow_resume(struct ieee80211_hw *hw);
+ void cw1200_pm_stay_awake(struct cw1200_pm_state *pm,
+ 			  unsigned long tmo);
+ #else
+ static inline void cw1200_pm_stay_awake(struct cw1200_pm_state *pm,
+-					unsigned long tmo) {
++					unsigned long tmo)
++{
++}
++static inline int cw1200_can_suspend(struct cw1200_common *priv)
++{
++	return 0;
+ }
+ #endif
+ #endif
+diff --git a/drivers/net/wireless/cw1200/wsm.c b/drivers/net/wireless/cw1200/wsm.c
+index 9e0ca3048657..3dd46c78c1cc 100644
+--- a/drivers/net/wireless/cw1200/wsm.c
++++ b/drivers/net/wireless/cw1200/wsm.c
+@@ -379,7 +379,6 @@ static int wsm_multi_tx_confirm(struct cw1200_common *priv,
+ {
+ 	int ret;
+ 	int count;
+-	int i;
+ 
+ 	count = WSM_GET32(buf);
+ 	if (WARN_ON(count <= 0))
+@@ -395,11 +394,10 @@ static int wsm_multi_tx_confirm(struct cw1200_common *priv,
+ 	}
+ 
+ 	cw1200_debug_txed_multi(priv, count);
+-	for (i = 0; i < count; ++i) {
++	do {
+ 		ret = wsm_tx_confirm(priv, buf, link_id);
+-		if (ret)
+-			return ret;
+-	}
++	} while (!ret && --count);
++
+ 	return ret;
+ 
+ underflow:
+diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
+index b57cfd965196..7b13962ec9da 100644
+--- a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
+@@ -2488,9 +2488,9 @@ void rtl8821ae_dm_txpower_tracking_callback_thermalmeter(
+ 		for (p = RF90_PATH_A; p < MAX_PATH_NUM_8821A; p++)
+ 			rtldm->swing_idx_ofdm_base[p] = rtldm->swing_idx_ofdm[p];
+ 
+-			RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD,
+-				 "pDM_Odm->RFCalibrateInfo.ThermalValue = %d ThermalValue= %d\n",
+-				 rtldm->thermalvalue, thermal_value);
++		RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD,
++			 "pDM_Odm->RFCalibrateInfo.ThermalValue = %d ThermalValue= %d\n",
++			 rtldm->thermalvalue, thermal_value);
+ 		/*Record last Power Tracking Thermal Value*/
+ 		rtldm->thermalvalue = thermal_value;
+ 	}
+diff --git a/drivers/pinctrl/sunxi/pinctrl-sun9i-a80.c b/drivers/pinctrl/sunxi/pinctrl-sun9i-a80.c
+index 1b580ba76453..907d7db3fcee 100644
+--- a/drivers/pinctrl/sunxi/pinctrl-sun9i-a80.c
++++ b/drivers/pinctrl/sunxi/pinctrl-sun9i-a80.c
+@@ -145,19 +145,19 @@ static const struct sunxi_desc_pin sun9i_a80_pins[] = {
+ 		  SUNXI_FUNCTION(0x0, "gpio_in"),
+ 		  SUNXI_FUNCTION(0x1, "gpio_out"),
+ 		  SUNXI_FUNCTION(0x3, "mcsi"),		/* MCLK */
+-		  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 14)),	/* PB_EINT14 */
++		  SUNXI_FUNCTION_IRQ_BANK(0x6, 1, 14)),	/* PB_EINT14 */
+ 	SUNXI_PIN(SUNXI_PINCTRL_PIN(B, 15),
+ 		  SUNXI_FUNCTION(0x0, "gpio_in"),
+ 		  SUNXI_FUNCTION(0x1, "gpio_out"),
+ 		  SUNXI_FUNCTION(0x3, "mcsi"),		/* SCK */
+ 		  SUNXI_FUNCTION(0x4, "i2c4"),		/* SCK */
+-		  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 15)),	/* PB_EINT15 */
++		  SUNXI_FUNCTION_IRQ_BANK(0x6, 1, 15)),	/* PB_EINT15 */
+ 	SUNXI_PIN(SUNXI_PINCTRL_PIN(B, 16),
+ 		  SUNXI_FUNCTION(0x0, "gpio_in"),
+ 		  SUNXI_FUNCTION(0x1, "gpio_out"),
+ 		  SUNXI_FUNCTION(0x3, "mcsi"),		/* SDA */
+ 		  SUNXI_FUNCTION(0x4, "i2c4"),		/* SDA */
+-		  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 16)),	/* PB_EINT16 */
++		  SUNXI_FUNCTION_IRQ_BANK(0x6, 1, 16)),	/* PB_EINT16 */
+ 
+ 	/* Hole */
+ 	SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 0),
+diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
+index 1089eaa02b00..988ebe9a6b90 100644
+--- a/drivers/platform/x86/Kconfig
++++ b/drivers/platform/x86/Kconfig
+@@ -95,6 +95,7 @@ config DELL_LAPTOP
+ 	tristate "Dell Laptop Extras"
+ 	depends on X86
+ 	depends on DCDBAS
++	depends on DMI
+ 	depends on BACKLIGHT_CLASS_DEVICE
+ 	depends on ACPI_VIDEO || ACPI_VIDEO = n
+ 	depends on RFKILL || RFKILL = n
+@@ -110,6 +111,7 @@ config DELL_LAPTOP
+ config DELL_WMI
+ 	tristate "Dell WMI extras"
+ 	depends on ACPI_WMI
++	depends on DMI
+ 	depends on INPUT
+ 	depends on ACPI_VIDEO || ACPI_VIDEO = n
+ 	select INPUT_SPARSEKMAP
+diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
+index 5c768c4627d3..78e1bfee698a 100644
+--- a/drivers/platform/x86/intel_mid_thermal.c
++++ b/drivers/platform/x86/intel_mid_thermal.c
+@@ -415,6 +415,7 @@ static struct thermal_device_info *initialize_sensor(int index)
+ 	return td_info;
+ }
+ 
++#ifdef CONFIG_PM_SLEEP
+ /**
+  * mid_thermal_resume - resume routine
+  * @dev: device structure
+@@ -442,6 +443,7 @@ static int mid_thermal_suspend(struct device *dev)
+ 	 */
+ 	return configure_adc(0);
+ }
++#endif
+ 
+ static SIMPLE_DEV_PM_OPS(mid_thermal_pm,
+ 			 mid_thermal_suspend, mid_thermal_resume);
+diff --git a/drivers/platform/x86/tc1100-wmi.c b/drivers/platform/x86/tc1100-wmi.c
+index 89aa976f0ab2..65b0a4845ddd 100644
+--- a/drivers/platform/x86/tc1100-wmi.c
++++ b/drivers/platform/x86/tc1100-wmi.c
+@@ -52,7 +52,9 @@ struct tc1100_data {
+ 	u32 jogdial;
+ };
+ 
++#ifdef CONFIG_PM
+ static struct tc1100_data suspend_data;
++#endif
+ 
+ /* --------------------------------------------------------------------------
+ 				Device Management
+diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
+index 237d7aa73e8c..9f53fb74ae6f 100644
+--- a/drivers/power/Kconfig
++++ b/drivers/power/Kconfig
+@@ -159,6 +159,7 @@ config BATTERY_SBS
+ 
+ config BATTERY_BQ27XXX
+ 	tristate "BQ27xxx battery driver"
++	depends on I2C || I2C=n
+ 	help
+ 	  Say Y here to enable support for batteries with BQ27xxx (I2C/HDQ) chips.
+ 
+diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
+index 880233ce9343..6c3a447f378b 100644
+--- a/drivers/power/bq27xxx_battery.c
++++ b/drivers/power/bq27xxx_battery.c
+@@ -285,7 +285,7 @@ static u8 bq27421_regs[] = {
+ 	0x18,	/* AP		*/
+ };
+ 
+-static u8 *bq27xxx_regs[] = {
++static u8 *bq27xxx_regs[] __maybe_unused = {
+ 	[BQ27000] = bq27000_regs,
+ 	[BQ27010] = bq27010_regs,
+ 	[BQ27500] = bq27500_regs,
+@@ -991,7 +991,7 @@ static void bq27xxx_external_power_changed(struct power_supply *psy)
+ 	schedule_delayed_work(&di->work, 0);
+ }
+ 
+-static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
++static int __maybe_unused bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
+ 				    const char *name)
+ {
+ 	int ret;
+@@ -1026,7 +1026,7 @@ static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
+ 	return 0;
+ }
+ 
+-static void bq27xxx_powersupply_unregister(struct bq27xxx_device_info *di)
++static void __maybe_unused bq27xxx_powersupply_unregister(struct bq27xxx_device_info *di)
+ {
+ 	/*
+ 	 * power_supply_unregister call bq27xxx_battery_get_property which
+diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
+index 9083247f55a8..21d174e9ebdb 100644
+--- a/drivers/s390/block/dasd_eckd.c
++++ b/drivers/s390/block/dasd_eckd.c
+@@ -518,10 +518,12 @@ static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata,
+ 	pfxdata->validity.define_extent = 1;
+ 
+ 	/* private uid is kept up to date, conf_data may be outdated */
+-	if (startpriv->uid.type != UA_BASE_DEVICE) {
++	if (startpriv->uid.type == UA_BASE_PAV_ALIAS)
+ 		pfxdata->validity.verify_base = 1;
+-		if (startpriv->uid.type == UA_HYPER_PAV_ALIAS)
+-			pfxdata->validity.hyper_pav = 1;
++
++	if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) {
++		pfxdata->validity.verify_base = 1;
++		pfxdata->validity.hyper_pav = 1;
+ 	}
+ 
+ 	/* define extend data (mostly)*/
+@@ -3002,10 +3004,12 @@ static int prepare_itcw(struct itcw *itcw,
+ 	pfxdata.validity.define_extent = 1;
+ 
+ 	/* private uid is kept up to date, conf_data may be outdated */
+-	if (startpriv->uid.type != UA_BASE_DEVICE) {
++	if (startpriv->uid.type == UA_BASE_PAV_ALIAS)
++		pfxdata.validity.verify_base = 1;
++
++	if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) {
+ 		pfxdata.validity.verify_base = 1;
+-		if (startpriv->uid.type == UA_HYPER_PAV_ALIAS)
+-			pfxdata.validity.hyper_pav = 1;
++		pfxdata.validity.hyper_pav = 1;
+ 	}
+ 
+ 	switch (cmd) {
+diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
+index febbd83e2ecd..24e57e770432 100644
+--- a/drivers/scsi/advansys.c
++++ b/drivers/scsi/advansys.c
+@@ -6291,18 +6291,17 @@ static uchar AscGetSynPeriodIndex(ASC_DVC_VAR *asc_dvc, uchar syn_time)
+ static uchar
+ AscMsgOutSDTR(ASC_DVC_VAR *asc_dvc, uchar sdtr_period, uchar sdtr_offset)
+ {
+-	EXT_MSG sdtr_buf;
+-	uchar sdtr_period_index;
+-	PortAddr iop_base;
+-
+-	iop_base = asc_dvc->iop_base;
+-	sdtr_buf.msg_type = EXTENDED_MESSAGE;
+-	sdtr_buf.msg_len = MS_SDTR_LEN;
+-	sdtr_buf.msg_req = EXTENDED_SDTR;
+-	sdtr_buf.xfer_period = sdtr_period;
++	PortAddr iop_base = asc_dvc->iop_base;
++	uchar sdtr_period_index = AscGetSynPeriodIndex(asc_dvc, sdtr_period);
++	EXT_MSG sdtr_buf = {
++		.msg_type = EXTENDED_MESSAGE,
++		.msg_len = MS_SDTR_LEN,
++		.msg_req = EXTENDED_SDTR,
++		.xfer_period = sdtr_period,
++		.req_ack_offset = sdtr_offset,
++	};
+ 	sdtr_offset &= ASC_SYN_MAX_OFFSET;
+-	sdtr_buf.req_ack_offset = sdtr_offset;
+-	sdtr_period_index = AscGetSynPeriodIndex(asc_dvc, sdtr_period);
++
+ 	if (sdtr_period_index <= asc_dvc->max_sdtr_index) {
+ 		AscMemWordCopyPtrToLram(iop_base, ASCV_MSGOUT_BEG,
+ 					(uchar *)&sdtr_buf,
+@@ -11030,6 +11029,9 @@ static int advansys_board_found(struct Scsi_Host *shost, unsigned int iop,
+ 		ASC_DBG(2, "AdvInitGetConfig()\n");
+ 
+ 		ret = AdvInitGetConfig(pdev, shost) ? -ENODEV : 0;
++#else
++		share_irq = 0;
++		ret = -ENODEV;
+ #endif /* CONFIG_PCI */
+ 	}
+ 
+diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
+index d4cda5e9600e..21c8d210c456 100644
+--- a/drivers/scsi/dpt_i2o.c
++++ b/drivers/scsi/dpt_i2o.c
+@@ -180,11 +180,14 @@ static u8 adpt_read_blink_led(adpt_hba* host)
+  *============================================================================
+  */
+ 
++#ifdef MODULE
+ static struct pci_device_id dptids[] = {
+ 	{ PCI_DPT_VENDOR_ID, PCI_DPT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
+ 	{ PCI_DPT_VENDOR_ID, PCI_DPT_RAPTOR_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
+ 	{ 0, }
+ };
++#endif
++
+ MODULE_DEVICE_TABLE(pci,dptids);
+ 
+ static int adpt_detect(struct scsi_host_template* sht)
+diff --git a/drivers/scsi/fdomain.c b/drivers/scsi/fdomain.c
+index eefe14d453db..b87ab38a4530 100644
+--- a/drivers/scsi/fdomain.c
++++ b/drivers/scsi/fdomain.c
+@@ -1768,7 +1768,7 @@ struct scsi_host_template fdomain_driver_template = {
+ };
+ 
+ #ifndef PCMCIA
+-#ifdef CONFIG_PCI
++#if defined(CONFIG_PCI) && defined(MODULE)
+ 
+ static struct pci_device_id fdomain_pci_tbl[] = {
+ 	{ PCI_VENDOR_ID_FD, PCI_DEVICE_ID_FD_36C70,
+diff --git a/drivers/scsi/g_NCR5380.c b/drivers/scsi/g_NCR5380.c
+index f8d2478b11cc..87e081f8a386 100644
+--- a/drivers/scsi/g_NCR5380.c
++++ b/drivers/scsi/g_NCR5380.c
+@@ -538,7 +538,10 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
+ 			printk(KERN_ERR "53C400r: Got 53C80_IRQ start=%d, blocks=%d\n", start, blocks);
+ 			return -1;
+ 		}
+-		while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY);
++		while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
++		{
++			// FIXME - no timeout
++		}
+ 
+ #ifndef SCSI_G_NCR5380_MEM
+ 		{
+diff --git a/drivers/scsi/initio.c b/drivers/scsi/initio.c
+index 6a926bae76b2..7a91cf3ff173 100644
+--- a/drivers/scsi/initio.c
++++ b/drivers/scsi/initio.c
+@@ -110,11 +110,6 @@
+ #define i91u_MAXQUEUE		2
+ #define i91u_REVID "Initio INI-9X00U/UW SCSI device driver; Revision: 1.04a"
+ 
+-#define I950_DEVICE_ID	0x9500	/* Initio's inic-950 product ID   */
+-#define I940_DEVICE_ID	0x9400	/* Initio's inic-940 product ID   */
+-#define I935_DEVICE_ID	0x9401	/* Initio's inic-935 product ID   */
+-#define I920_DEVICE_ID	0x0002	/* Initio's other product ID      */
+-
+ #ifdef DEBUG_i91u
+ static unsigned int i91u_debug = DEBUG_DEFAULT;
+ #endif
+@@ -127,17 +122,6 @@ static int setup_debug = 0;
+ 
+ static void i91uSCBPost(u8 * pHcb, u8 * pScb);
+ 
+-/* PCI Devices supported by this driver */
+-static struct pci_device_id i91u_pci_devices[] = {
+-	{ PCI_VENDOR_ID_INIT,  I950_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+-	{ PCI_VENDOR_ID_INIT,  I940_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+-	{ PCI_VENDOR_ID_INIT,  I935_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+-	{ PCI_VENDOR_ID_INIT,  I920_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+-	{ PCI_VENDOR_ID_DOMEX, I920_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+-	{ }
+-};
+-MODULE_DEVICE_TABLE(pci, i91u_pci_devices);
+-
+ #define DEBUG_INTERRUPT 0
+ #define DEBUG_QUEUE     0
+ #define DEBUG_STATE     0
+diff --git a/drivers/scsi/mvumi.c b/drivers/scsi/mvumi.c
+index 02360de6b7e0..39285070f3b5 100644
+--- a/drivers/scsi/mvumi.c
++++ b/drivers/scsi/mvumi.c
+@@ -2629,7 +2629,7 @@ static void mvumi_shutdown(struct pci_dev *pdev)
+ 	mvumi_flush_cache(mhba);
+ }
+ 
+-static int mvumi_suspend(struct pci_dev *pdev, pm_message_t state)
++static int __maybe_unused mvumi_suspend(struct pci_dev *pdev, pm_message_t state)
+ {
+ 	struct mvumi_hba *mhba = NULL;
+ 
+@@ -2648,7 +2648,7 @@ static int mvumi_suspend(struct pci_dev *pdev, pm_message_t state)
+ 	return 0;
+ }
+ 
+-static int mvumi_resume(struct pci_dev *pdev)
++static int __maybe_unused mvumi_resume(struct pci_dev *pdev)
+ {
+ 	int ret;
+ 	struct mvumi_hba *mhba = NULL;
+diff --git a/drivers/scsi/sim710.c b/drivers/scsi/sim710.c
+index 3b3b56f4a830..82ed99848378 100644
+--- a/drivers/scsi/sim710.c
++++ b/drivers/scsi/sim710.c
+@@ -176,8 +176,7 @@ static struct eisa_device_id sim710_eisa_ids[] = {
+ };
+ MODULE_DEVICE_TABLE(eisa, sim710_eisa_ids);
+ 
+-static __init int
+-sim710_eisa_probe(struct device *dev)
++static int sim710_eisa_probe(struct device *dev)
+ {
+ 	struct eisa_device *edev = to_eisa_device(dev);
+ 	unsigned long io_addr = edev->base_addr;
+diff --git a/drivers/spi/spi-sun4i.c b/drivers/spi/spi-sun4i.c
+index 39d7c7c70112..2eea3de5a668 100644
+--- a/drivers/spi/spi-sun4i.c
++++ b/drivers/spi/spi-sun4i.c
+@@ -458,7 +458,7 @@ err_free_master:
+ 
+ static int sun4i_spi_remove(struct platform_device *pdev)
+ {
+-	pm_runtime_disable(&pdev->dev);
++	pm_runtime_force_suspend(&pdev->dev);
+ 
+ 	return 0;
+ }
+diff --git a/drivers/ssb/main.c b/drivers/ssb/main.c
+index 5d1e9a0fc389..e2ff6b5b2094 100644
+--- a/drivers/ssb/main.c
++++ b/drivers/ssb/main.c
+@@ -613,9 +613,10 @@ out:
+ 	return err;
+ }
+ 
+-static int ssb_bus_register(struct ssb_bus *bus,
+-			    ssb_invariants_func_t get_invariants,
+-			    unsigned long baseaddr)
++static int __maybe_unused
++ssb_bus_register(struct ssb_bus *bus,
++		 ssb_invariants_func_t get_invariants,
++		 unsigned long baseaddr)
+ {
+ 	int err;
+ 
+diff --git a/drivers/staging/android/ashmem.c b/drivers/staging/android/ashmem.c
+index b64327722660..ec31b53ae3a5 100644
+--- a/drivers/staging/android/ashmem.c
++++ b/drivers/staging/android/ashmem.c
+@@ -704,30 +704,32 @@ static int ashmem_pin_unpin(struct ashmem_area *asma, unsigned long cmd,
+ 	size_t pgstart, pgend;
+ 	int ret = -EINVAL;
+ 
++	mutex_lock(&ashmem_mutex);
++
+ 	if (unlikely(!asma->file))
+-		return -EINVAL;
++		goto out_unlock;
+ 
+-	if (unlikely(copy_from_user(&pin, p, sizeof(pin))))
+-		return -EFAULT;
++	if (unlikely(copy_from_user(&pin, p, sizeof(pin)))) {
++		ret = -EFAULT;
++		goto out_unlock;
++	}
+ 
+ 	/* per custom, you can pass zero for len to mean "everything onward" */
+ 	if (!pin.len)
+ 		pin.len = PAGE_ALIGN(asma->size) - pin.offset;
+ 
+ 	if (unlikely((pin.offset | pin.len) & ~PAGE_MASK))
+-		return -EINVAL;
++		goto out_unlock;
+ 
+ 	if (unlikely(((__u32)-1) - pin.offset < pin.len))
+-		return -EINVAL;
++		goto out_unlock;
+ 
+ 	if (unlikely(PAGE_ALIGN(asma->size) < pin.offset + pin.len))
+-		return -EINVAL;
++		goto out_unlock;
+ 
+ 	pgstart = pin.offset / PAGE_SIZE;
+ 	pgend = pgstart + (pin.len / PAGE_SIZE) - 1;
+ 
+-	mutex_lock(&ashmem_mutex);
+-
+ 	switch (cmd) {
+ 	case ASHMEM_PIN:
+ 		ret = ashmem_pin(asma, pgstart, pgend);
+@@ -740,6 +742,7 @@ static int ashmem_pin_unpin(struct ashmem_area *asma, unsigned long cmd,
+ 		break;
+ 	}
+ 
++out_unlock:
+ 	mutex_unlock(&ashmem_mutex);
+ 
+ 	return ret;
+diff --git a/drivers/staging/iio/adc/ad7192.c b/drivers/staging/iio/adc/ad7192.c
+index abc66908681d..6f032009f93f 100644
+--- a/drivers/staging/iio/adc/ad7192.c
++++ b/drivers/staging/iio/adc/ad7192.c
+@@ -124,6 +124,8 @@
+ #define AD7192_GPOCON_P1DAT	BIT(1) /* P1 state */
+ #define AD7192_GPOCON_P0DAT	BIT(0) /* P0 state */
+ 
++#define AD7192_EXT_FREQ_MHZ_MIN	2457600
++#define AD7192_EXT_FREQ_MHZ_MAX	5120000
+ #define AD7192_INT_FREQ_MHZ	4915200
+ 
+ /* NOTE:
+@@ -199,6 +201,12 @@ static int ad7192_calibrate_all(struct ad7192_state *st)
+ 				ARRAY_SIZE(ad7192_calib_arr));
+ }
+ 
++static inline bool ad7192_valid_external_frequency(u32 freq)
++{
++	return (freq >= AD7192_EXT_FREQ_MHZ_MIN &&
++		freq <= AD7192_EXT_FREQ_MHZ_MAX);
++}
++
+ static int ad7192_setup(struct ad7192_state *st,
+ 			const struct ad7192_platform_data *pdata)
+ {
+@@ -224,17 +232,20 @@ static int ad7192_setup(struct ad7192_state *st,
+ 			 id);
+ 
+ 	switch (pdata->clock_source_sel) {
+-	case AD7192_CLK_EXT_MCLK1_2:
+-	case AD7192_CLK_EXT_MCLK2:
+-		st->mclk = AD7192_INT_FREQ_MHZ;
+-		break;
+ 	case AD7192_CLK_INT:
+ 	case AD7192_CLK_INT_CO:
+-		if (pdata->ext_clk_hz)
+-			st->mclk = pdata->ext_clk_hz;
+-		else
+-			st->mclk = AD7192_INT_FREQ_MHZ;
++		st->mclk = AD7192_INT_FREQ_MHZ;
+ 		break;
++	case AD7192_CLK_EXT_MCLK1_2:
++	case AD7192_CLK_EXT_MCLK2:
++		if (ad7192_valid_external_frequency(pdata->ext_clk_hz)) {
++			st->mclk = pdata->ext_clk_hz;
++			break;
++		}
++		dev_err(&st->sd.spi->dev, "Invalid frequency setting %u\n",
++			pdata->ext_clk_hz);
++		ret = -EINVAL;
++		goto out;
+ 	default:
+ 		ret = -EINVAL;
+ 		goto out;
+diff --git a/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c b/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c
+index 824d460911ec..58ccafb97344 100644
+--- a/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c
++++ b/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c
+@@ -1039,7 +1039,6 @@ static int synaptics_rmi4_remove(struct i2c_client *client)
+ 	return 0;
+ }
+ 
+-#ifdef CONFIG_PM
+ /**
+  * synaptics_rmi4_suspend() - suspend the touch screen controller
+  * @dev: pointer to device structure
+@@ -1047,7 +1046,7 @@ static int synaptics_rmi4_remove(struct i2c_client *client)
+  * This function is used to suspend the
+  * touch panel controller and returns integer
+  */
+-static int synaptics_rmi4_suspend(struct device *dev)
++static int __maybe_unused synaptics_rmi4_suspend(struct device *dev)
+ {
+ 	/* Touch sleep mode */
+ 	int retval;
+@@ -1081,7 +1080,7 @@ static int synaptics_rmi4_suspend(struct device *dev)
+  * This function is used to resume the touch panel
+  * controller and returns integer.
+  */
+-static int synaptics_rmi4_resume(struct device *dev)
++static int __maybe_unused synaptics_rmi4_resume(struct device *dev)
+ {
+ 	int retval;
+ 	unsigned char intr_status;
+@@ -1112,8 +1111,6 @@ static int synaptics_rmi4_resume(struct device *dev)
+ 	return 0;
+ }
+ 
+-#endif
+-
+ static SIMPLE_DEV_PM_OPS(synaptics_rmi4_dev_pm_ops, synaptics_rmi4_suspend,
+ 			 synaptics_rmi4_resume);
+ 
+diff --git a/drivers/staging/unisys/visorinput/Kconfig b/drivers/staging/unisys/visorinput/Kconfig
+index d83deb4137e8..6baba2795ce7 100644
+--- a/drivers/staging/unisys/visorinput/Kconfig
++++ b/drivers/staging/unisys/visorinput/Kconfig
+@@ -4,7 +4,7 @@
+ 
+ config UNISYS_VISORINPUT
+ 	tristate "Unisys visorinput driver"
+-	depends on UNISYSSPAR && UNISYS_VISORBUS && FB
++	depends on UNISYSSPAR && UNISYS_VISORBUS && FB && INPUT
+ 	---help---
+ 	If you say Y here, you will enable the Unisys visorinput driver.
+ 
+diff --git a/drivers/staging/wilc1000/wilc_wlan_if.h b/drivers/staging/wilc1000/wilc_wlan_if.h
+index be972afe6e62..bfc3e96d8d25 100644
+--- a/drivers/staging/wilc1000/wilc_wlan_if.h
++++ b/drivers/staging/wilc1000/wilc_wlan_if.h
+@@ -12,6 +12,7 @@
+ 
+ #include <linux/semaphore.h>
+ #include "linux_wlan_common.h"
++#include <linux/netdevice.h>
+ 
+ /********************************************
+  *
+diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c
+index a7d30e894cab..c43c942e1f87 100644
+--- a/drivers/target/target_core_user.c
++++ b/drivers/target/target_core_user.c
+@@ -900,7 +900,7 @@ static int tcmu_configure_device(struct se_device *dev)
+ 	info->version = __stringify(TCMU_MAILBOX_VERSION);
+ 
+ 	info->mem[0].name = "tcm-user command & data buffer";
+-	info->mem[0].addr = (phys_addr_t) udev->mb_addr;
++	info->mem[0].addr = (phys_addr_t)(uintptr_t)udev->mb_addr;
+ 	info->mem[0].size = TCMU_RING_SIZE;
+ 	info->mem[0].memtype = UIO_MEM_VIRTUAL;
+ 
+diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
+index 8cc4ac64a91c..4b660b5beb98 100644
+--- a/drivers/thermal/Kconfig
++++ b/drivers/thermal/Kconfig
+@@ -299,7 +299,7 @@ config X86_PKG_TEMP_THERMAL
+ 
+ config INTEL_SOC_DTS_IOSF_CORE
+ 	tristate
+-	depends on X86
++	depends on X86 && PCI
+ 	select IOSF_MBI
+ 	help
+ 	  This is becoming a common feature for Intel SoCs to expose the additional
+@@ -309,7 +309,7 @@ config INTEL_SOC_DTS_IOSF_CORE
+ 
+ config INTEL_SOC_DTS_THERMAL
+ 	tristate "Intel SoCs DTS thermal driver"
+-	depends on X86
++	depends on X86 && PCI
+ 	select INTEL_SOC_DTS_IOSF_CORE
+ 	select THERMAL_WRITABLE_TRIPS
+ 	help
+diff --git a/drivers/thermal/spear_thermal.c b/drivers/thermal/spear_thermal.c
+index 534dd9136662..81b35aace9de 100644
+--- a/drivers/thermal/spear_thermal.c
++++ b/drivers/thermal/spear_thermal.c
+@@ -54,8 +54,7 @@ static struct thermal_zone_device_ops ops = {
+ 	.get_temp = thermal_get_temp,
+ };
+ 
+-#ifdef CONFIG_PM
+-static int spear_thermal_suspend(struct device *dev)
++static int __maybe_unused spear_thermal_suspend(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct thermal_zone_device *spear_thermal = platform_get_drvdata(pdev);
+@@ -72,7 +71,7 @@ static int spear_thermal_suspend(struct device *dev)
+ 	return 0;
+ }
+ 
+-static int spear_thermal_resume(struct device *dev)
++static int __maybe_unused spear_thermal_resume(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct thermal_zone_device *spear_thermal = platform_get_drvdata(pdev);
+@@ -94,7 +93,6 @@ static int spear_thermal_resume(struct device *dev)
+ 
+ 	return 0;
+ }
+-#endif
+ 
+ static SIMPLE_DEV_PM_OPS(spear_thermal_pm_ops, spear_thermal_suspend,
+ 		spear_thermal_resume);
+diff --git a/drivers/tty/Kconfig b/drivers/tty/Kconfig
+index c01f45095877..82c4d2e45319 100644
+--- a/drivers/tty/Kconfig
++++ b/drivers/tty/Kconfig
+@@ -226,7 +226,7 @@ config CYCLADES
+ 
+ config CYZ_INTR
+ 	bool "Cyclades-Z interrupt mode operation"
+-	depends on CYCLADES
++	depends on CYCLADES && PCI
+ 	help
+ 	  The Cyclades-Z family of multiport cards allows 2 (two) driver op
+ 	  modes: polling and interrupt. In polling mode, the driver will check
+diff --git a/drivers/tty/hvc/hvc_xen.c b/drivers/tty/hvc/hvc_xen.c
+index fa816b7193b6..11725422dacb 100644
+--- a/drivers/tty/hvc/hvc_xen.c
++++ b/drivers/tty/hvc/hvc_xen.c
+@@ -323,6 +323,7 @@ void xen_console_resume(void)
+ 	}
+ }
+ 
++#ifdef CONFIG_HVC_XEN_FRONTEND
+ static void xencons_disconnect_backend(struct xencons_info *info)
+ {
+ 	if (info->irq > 0)
+@@ -363,7 +364,6 @@ static int xen_console_remove(struct xencons_info *info)
+ 	return 0;
+ }
+ 
+-#ifdef CONFIG_HVC_XEN_FRONTEND
+ static int xencons_remove(struct xenbus_device *dev)
+ {
+ 	return xen_console_remove(dev_get_drvdata(&dev->dev));
+diff --git a/drivers/tty/serial/8250/Kconfig b/drivers/tty/serial/8250/Kconfig
+index 6412f1455beb..6f4c180aadc1 100644
+--- a/drivers/tty/serial/8250/Kconfig
++++ b/drivers/tty/serial/8250/Kconfig
+@@ -372,7 +372,7 @@ config SERIAL_8250_MID
+ 	tristate "Support for serial ports on Intel MID platforms"
+ 	depends on SERIAL_8250 && PCI
+ 	select HSU_DMA if SERIAL_8250_DMA
+-	select HSU_DMA_PCI if X86_INTEL_MID
++	select HSU_DMA_PCI if (HSU_DMA && X86_INTEL_MID)
+ 	select RATIONAL
+ 	help
+ 	  Selecting this option will enable handling of the extra features
+diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
+index 3bb08870148f..95e72d75e0a0 100644
+--- a/drivers/usb/host/Kconfig
++++ b/drivers/usb/host/Kconfig
+@@ -220,6 +220,8 @@ config USB_EHCI_TEGRA
+        depends on ARCH_TEGRA
+        select USB_EHCI_ROOT_HUB_TT
+        select USB_PHY
++	select USB_ULPI
++	select USB_ULPI_VIEWPORT
+        help
+          This driver enables support for the internal USB Host Controllers
+          found in NVIDIA Tegra SoCs. The controllers are EHCI compliant.
+diff --git a/drivers/usb/musb/ux500_dma.c b/drivers/usb/musb/ux500_dma.c
+index d0b6a1cd7f62..c92a295049ad 100644
+--- a/drivers/usb/musb/ux500_dma.c
++++ b/drivers/usb/musb/ux500_dma.c
+@@ -207,9 +207,6 @@ static int ux500_dma_channel_program(struct dma_channel *channel,
+ 	BUG_ON(channel->status == MUSB_DMA_STATUS_UNKNOWN ||
+ 		channel->status == MUSB_DMA_STATUS_BUSY);
+ 
+-	if (!ux500_dma_is_compatible(channel, packet_sz, (void *)dma_addr, len))
+-		return false;
+-
+ 	channel->status = MUSB_DMA_STATUS_BUSY;
+ 	channel->actual_len = 0;
+ 	ret = ux500_configure_channel(channel, packet_sz, mode, dma_addr, len);
+diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
+index 22e8ecb6bfbd..7a72bef35acf 100644
+--- a/drivers/usb/phy/Kconfig
++++ b/drivers/usb/phy/Kconfig
+@@ -140,6 +140,7 @@ config USB_MSM_OTG
+ 	tristate "Qualcomm on-chip USB OTG controller support"
+ 	depends on (USB || USB_GADGET) && (ARCH_QCOM || COMPILE_TEST)
+ 	depends on RESET_CONTROLLER
++	depends on REGULATOR
+ 	depends on EXTCON
+ 	select USB_PHY
+ 	help
+diff --git a/drivers/usb/usbip/stub_dev.c b/drivers/usb/usbip/stub_dev.c
+index ec38370ffcab..0931f3271119 100644
+--- a/drivers/usb/usbip/stub_dev.c
++++ b/drivers/usb/usbip/stub_dev.c
+@@ -87,6 +87,7 @@ static ssize_t store_sockfd(struct device *dev, struct device_attribute *attr,
+ 			goto err;
+ 
+ 		sdev->ud.tcp_socket = socket;
++		sdev->ud.sockfd = sockfd;
+ 
+ 		spin_unlock_irq(&sdev->ud.lock);
+ 
+@@ -186,6 +187,7 @@ static void stub_shutdown_connection(struct usbip_device *ud)
+ 	if (ud->tcp_socket) {
+ 		sockfd_put(ud->tcp_socket);
+ 		ud->tcp_socket = NULL;
++		ud->sockfd = -1;
+ 	}
+ 
+ 	/* 3. free used data */
+@@ -280,6 +282,7 @@ static struct stub_device *stub_device_alloc(struct usb_device *udev)
+ 	sdev->ud.status		= SDEV_ST_AVAILABLE;
+ 	spin_lock_init(&sdev->ud.lock);
+ 	sdev->ud.tcp_socket	= NULL;
++	sdev->ud.sockfd		= -1;
+ 
+ 	INIT_LIST_HEAD(&sdev->priv_init);
+ 	INIT_LIST_HEAD(&sdev->priv_tx);
+diff --git a/drivers/usb/usbip/vhci_hcd.c b/drivers/usb/usbip/vhci_hcd.c
+index 2d96bfd34138..4d68a1e9e878 100644
+--- a/drivers/usb/usbip/vhci_hcd.c
++++ b/drivers/usb/usbip/vhci_hcd.c
+@@ -797,6 +797,7 @@ static void vhci_shutdown_connection(struct usbip_device *ud)
+ 	if (vdev->ud.tcp_socket) {
+ 		sockfd_put(vdev->ud.tcp_socket);
+ 		vdev->ud.tcp_socket = NULL;
++		vdev->ud.sockfd = -1;
+ 	}
+ 	pr_info("release socket\n");
+ 
+@@ -844,6 +845,7 @@ static void vhci_device_reset(struct usbip_device *ud)
+ 	if (ud->tcp_socket) {
+ 		sockfd_put(ud->tcp_socket);
+ 		ud->tcp_socket = NULL;
++		ud->sockfd = -1;
+ 	}
+ 	ud->status = VDEV_ST_NULL;
+ 
+diff --git a/drivers/video/fbdev/Kconfig b/drivers/video/fbdev/Kconfig
+index f07a0974fda2..3543e3e4cfb5 100644
+--- a/drivers/video/fbdev/Kconfig
++++ b/drivers/video/fbdev/Kconfig
+@@ -1506,6 +1506,7 @@ config FB_SIS
+ 	select FB_CFB_COPYAREA
+ 	select FB_CFB_IMAGEBLIT
+ 	select FB_BOOT_VESA_SUPPORT if FB_SIS = y
++	select FB_SIS_300 if !FB_SIS_315
+ 	help
+ 	  This is the frame buffer device driver for the SiS 300, 315, 330
+ 	  and 340 series as well as XGI V3XT, V5, V8, Z7 graphics chipsets.
+diff --git a/drivers/video/fbdev/auo_k190x.c b/drivers/video/fbdev/auo_k190x.c
+index 8d2499d1cafb..9580374667ba 100644
+--- a/drivers/video/fbdev/auo_k190x.c
++++ b/drivers/video/fbdev/auo_k190x.c
+@@ -773,9 +773,7 @@ static void auok190x_recover(struct auok190xfb_par *par)
+ /*
+  * Power-management
+  */
+-
+-#ifdef CONFIG_PM
+-static int auok190x_runtime_suspend(struct device *dev)
++static int __maybe_unused auok190x_runtime_suspend(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct fb_info *info = platform_get_drvdata(pdev);
+@@ -822,7 +820,7 @@ finish:
+ 	return 0;
+ }
+ 
+-static int auok190x_runtime_resume(struct device *dev)
++static int __maybe_unused auok190x_runtime_resume(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct fb_info *info = platform_get_drvdata(pdev);
+@@ -856,7 +854,7 @@ static int auok190x_runtime_resume(struct device *dev)
+ 	return 0;
+ }
+ 
+-static int auok190x_suspend(struct device *dev)
++static int __maybe_unused auok190x_suspend(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct fb_info *info = platform_get_drvdata(pdev);
+@@ -896,7 +894,7 @@ static int auok190x_suspend(struct device *dev)
+ 	return 0;
+ }
+ 
+-static int auok190x_resume(struct device *dev)
++static int __maybe_unused auok190x_resume(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct fb_info *info = platform_get_drvdata(pdev);
+@@ -933,7 +931,6 @@ static int auok190x_resume(struct device *dev)
+ 
+ 	return 0;
+ }
+-#endif
+ 
+ const struct dev_pm_ops auok190x_pm = {
+ 	SET_RUNTIME_PM_OPS(auok190x_runtime_suspend, auok190x_runtime_resume,
+diff --git a/drivers/video/fbdev/exynos/s6e8ax0.c b/drivers/video/fbdev/exynos/s6e8ax0.c
+index 95873f26e39c..de2f3e793786 100644
+--- a/drivers/video/fbdev/exynos/s6e8ax0.c
++++ b/drivers/video/fbdev/exynos/s6e8ax0.c
+@@ -829,8 +829,7 @@ static int s6e8ax0_probe(struct mipi_dsim_lcd_device *dsim_dev)
+ 	return 0;
+ }
+ 
+-#ifdef CONFIG_PM
+-static int s6e8ax0_suspend(struct mipi_dsim_lcd_device *dsim_dev)
++static int __maybe_unused s6e8ax0_suspend(struct mipi_dsim_lcd_device *dsim_dev)
+ {
+ 	struct s6e8ax0 *lcd = dev_get_drvdata(&dsim_dev->dev);
+ 
+@@ -843,7 +842,7 @@ static int s6e8ax0_suspend(struct mipi_dsim_lcd_device *dsim_dev)
+ 	return 0;
+ }
+ 
+-static int s6e8ax0_resume(struct mipi_dsim_lcd_device *dsim_dev)
++static int __maybe_unused s6e8ax0_resume(struct mipi_dsim_lcd_device *dsim_dev)
+ {
+ 	struct s6e8ax0 *lcd = dev_get_drvdata(&dsim_dev->dev);
+ 
+@@ -855,10 +854,6 @@ static int s6e8ax0_resume(struct mipi_dsim_lcd_device *dsim_dev)
+ 
+ 	return 0;
+ }
+-#else
+-#define s6e8ax0_suspend		NULL
+-#define s6e8ax0_resume		NULL
+-#endif
+ 
+ static struct mipi_dsim_lcd_driver s6e8ax0_dsim_ddi_driver = {
+ 	.name = "s6e8ax0",
+@@ -867,8 +862,8 @@ static struct mipi_dsim_lcd_driver s6e8ax0_dsim_ddi_driver = {
+ 	.power_on = s6e8ax0_power_on,
+ 	.set_sequence = s6e8ax0_set_sequence,
+ 	.probe = s6e8ax0_probe,
+-	.suspend = s6e8ax0_suspend,
+-	.resume = s6e8ax0_resume,
++	.suspend = IS_ENABLED(CONFIG_PM) ? s6e8ax0_suspend : NULL,
++	.resume = IS_ENABLED(CONFIG_PM) ? s6e8ax0_resume : NULL,
+ };
+ 
+ static int s6e8ax0_init(void)
+diff --git a/drivers/video/fbdev/intelfb/intelfbdrv.c b/drivers/video/fbdev/intelfb/intelfbdrv.c
+index bbec737eef30..bf207444ba0c 100644
+--- a/drivers/video/fbdev/intelfb/intelfbdrv.c
++++ b/drivers/video/fbdev/intelfb/intelfbdrv.c
+@@ -302,7 +302,7 @@ static __inline__ int get_opt_int(const char *this_opt, const char *name,
+ }
+ 
+ static __inline__ int get_opt_bool(const char *this_opt, const char *name,
+-				   int *ret)
++				   bool *ret)
+ {
+ 	if (!ret)
+ 		return 0;
+diff --git a/drivers/video/fbdev/mmp/core.c b/drivers/video/fbdev/mmp/core.c
+index a0f496049db7..3a6bb6561ba0 100644
+--- a/drivers/video/fbdev/mmp/core.c
++++ b/drivers/video/fbdev/mmp/core.c
+@@ -23,6 +23,7 @@
+ #include <linux/slab.h>
+ #include <linux/dma-mapping.h>
+ #include <linux/export.h>
++#include <linux/module.h>
+ #include <video/mmp_disp.h>
+ 
+ static struct mmp_overlay *path_get_overlay(struct mmp_path *path,
+@@ -249,3 +250,7 @@ void mmp_unregister_path(struct mmp_path *path)
+ 	mutex_unlock(&disp_lock);
+ }
+ EXPORT_SYMBOL_GPL(mmp_unregister_path);
++
++MODULE_AUTHOR("Zhou Zhu <zzhu3@×××××××.com>");
++MODULE_DESCRIPTION("Marvell MMP display framework");
++MODULE_LICENSE("GPL");
+diff --git a/drivers/video/fbdev/sis/init301.c b/drivers/video/fbdev/sis/init301.c
+index 295e0dedaf1f..20f7234e809e 100644
+--- a/drivers/video/fbdev/sis/init301.c
++++ b/drivers/video/fbdev/sis/init301.c
+@@ -2151,17 +2151,15 @@ SiS_GetVCLK2Ptr(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned shor
+ 		unsigned short RefreshRateTableIndex)
+ {
+   unsigned short CRT2Index, VCLKIndex = 0, VCLKIndexGEN = 0, VCLKIndexGENCRT = 0;
+-  unsigned short modeflag, resinfo, tempbx;
++  unsigned short resinfo, tempbx;
+   const unsigned char *CHTVVCLKPtr = NULL;
+ 
+   if(ModeNo <= 0x13) {
+-     modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
+      resinfo = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ResInfo;
+      CRT2Index = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_CRT2CRTC;
+      VCLKIndexGEN = (SiS_GetRegByte((SiS_Pr->SiS_P3ca+0x02)) >> 2) & 0x03;
+      VCLKIndexGENCRT = VCLKIndexGEN;
+   } else {
+-     modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
+      resinfo = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_RESINFO;
+      CRT2Index = SiS_Pr->SiS_RefIndex[RefreshRateTableIndex].Ext_CRT2CRTC;
+      VCLKIndexGEN = SiS_Pr->SiS_RefIndex[RefreshRateTableIndex].Ext_CRTVCLK;
+@@ -7270,7 +7268,7 @@ SiS_ShiftXPos(struct SiS_Private *SiS_Pr, int shift)
+ static void
+ SiS_SetGroup4_C_ELV(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short ModeIdIndex)
+ {
+-   unsigned short temp, temp1, resinfo = 0;
++   unsigned short temp, temp1;
+    unsigned char  *ROMAddr = SiS_Pr->VirtualRomBase;
+ 
+    if(!(SiS_Pr->SiS_VBType & VB_SIS30xCLV)) return;
+@@ -7282,10 +7280,6 @@ SiS_SetGroup4_C_ELV(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned
+       if(!(ROMAddr[0x61] & 0x04)) return;
+    }
+ 
+-   if(ModeNo > 0x13) {
+-      resinfo = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_RESINFO;
+-   }
+-
+    SiS_SetRegOR(SiS_Pr->SiS_Part4Port,0x3a,0x08);
+    temp = SiS_GetReg(SiS_Pr->SiS_Part4Port,0x3a);
+    if(!(temp & 0x01)) {
+diff --git a/drivers/video/fbdev/sm712fb.c b/drivers/video/fbdev/sm712fb.c
+index 629bfa2d2f51..86ae1d4556fc 100644
+--- a/drivers/video/fbdev/sm712fb.c
++++ b/drivers/video/fbdev/sm712fb.c
+@@ -28,9 +28,7 @@
+ #include <linux/console.h>
+ #include <linux/screen_info.h>
+ 
+-#ifdef CONFIG_PM
+ #include <linux/pm.h>
+-#endif
+ 
+ #include "sm712.h"
+ 
+@@ -1545,8 +1543,7 @@ static void smtcfb_pci_remove(struct pci_dev *pdev)
+ 	pci_disable_device(pdev);
+ }
+ 
+-#ifdef CONFIG_PM
+-static int smtcfb_pci_suspend(struct device *device)
++static int __maybe_unused smtcfb_pci_suspend(struct device *device)
+ {
+ 	struct pci_dev *pdev = to_pci_dev(device);
+ 	struct smtcfb_info *sfb;
+@@ -1569,7 +1566,7 @@ static int smtcfb_pci_suspend(struct device *device)
+ 	return 0;
+ }
+ 
+-static int smtcfb_pci_resume(struct device *device)
++static int __maybe_unused smtcfb_pci_resume(struct device *device)
+ {
+ 	struct pci_dev *pdev = to_pci_dev(device);
+ 	struct smtcfb_info *sfb;
+@@ -1610,20 +1607,13 @@ static int smtcfb_pci_resume(struct device *device)
+ }
+ 
+ static SIMPLE_DEV_PM_OPS(sm7xx_pm_ops, smtcfb_pci_suspend, smtcfb_pci_resume);
+-#define SM7XX_PM_OPS (&sm7xx_pm_ops)
+-
+-#else  /* !CONFIG_PM */
+-
+-#define SM7XX_PM_OPS NULL
+-
+-#endif /* !CONFIG_PM */
+ 
+ static struct pci_driver smtcfb_driver = {
+ 	.name = "smtcfb",
+ 	.id_table = smtcfb_pci_table,
+ 	.probe = smtcfb_pci_probe,
+ 	.remove = smtcfb_pci_remove,
+-	.driver.pm  = SM7XX_PM_OPS,
++	.driver.pm  = &sm7xx_pm_ops,
+ };
+ 
+ static int __init sm712fb_init(void)
+diff --git a/drivers/video/fbdev/via/viafbdev.c b/drivers/video/fbdev/via/viafbdev.c
+index f9718f012aae..badee04ef496 100644
+--- a/drivers/video/fbdev/via/viafbdev.c
++++ b/drivers/video/fbdev/via/viafbdev.c
+@@ -1630,16 +1630,14 @@ static void viafb_init_proc(struct viafb_shared *shared)
+ }
+ static void viafb_remove_proc(struct viafb_shared *shared)
+ {
+-	struct proc_dir_entry *viafb_entry = shared->proc_entry,
+-		*iga1_entry = shared->iga1_proc_entry,
+-		*iga2_entry = shared->iga2_proc_entry;
++	struct proc_dir_entry *viafb_entry = shared->proc_entry;
+ 
+ 	if (!viafb_entry)
+ 		return;
+ 
+-	remove_proc_entry("output_devices", iga2_entry);
++	remove_proc_entry("output_devices", shared->iga2_proc_entry);
+ 	remove_proc_entry("iga2", viafb_entry);
+-	remove_proc_entry("output_devices", iga1_entry);
++	remove_proc_entry("output_devices", shared->iga1_proc_entry);
+ 	remove_proc_entry("iga1", viafb_entry);
+ 	remove_proc_entry("supported_output_devices", viafb_entry);
+ 
+diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
+index 01d15dca940e..7cf26768ea0b 100644
+--- a/drivers/virtio/virtio_balloon.c
++++ b/drivers/virtio/virtio_balloon.c
+@@ -239,12 +239,14 @@ static void update_balloon_stats(struct virtio_balloon *vb)
+ 	all_vm_events(events);
+ 	si_meminfo(&i);
+ 
++#ifdef CONFIG_VM_EVENT_COUNTERS
+ 	update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
+ 				pages_to_bytes(events[PSWPIN]));
+ 	update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
+ 				pages_to_bytes(events[PSWPOUT]));
+ 	update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
+ 	update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
++#endif
+ 	update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
+ 				pages_to_bytes(i.freeram));
+ 	update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
+diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
+index 73708acce3ca..3a14948269b1 100644
+--- a/drivers/xen/Kconfig
++++ b/drivers/xen/Kconfig
+@@ -239,7 +239,7 @@ config XEN_ACPI_HOTPLUG_CPU
+ 
+ config XEN_ACPI_PROCESSOR
+ 	tristate "Xen ACPI processor"
+-	depends on XEN && X86 && ACPI_PROCESSOR && CPU_FREQ
++	depends on XEN && XEN_DOM0 && X86 && ACPI_PROCESSOR && CPU_FREQ
+ 	default m
+ 	help
+           This ACPI processor uploads Power Management information to the Xen
+diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
+index 9c3b9d07f341..4e3c889c1876 100644
+--- a/fs/btrfs/ioctl.c
++++ b/fs/btrfs/ioctl.c
+@@ -2231,7 +2231,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
+ 	if (!path)
+ 		return -ENOMEM;
+ 
+-	ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX];
++	ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX - 1];
+ 
+ 	key.objectid = tree_id;
+ 	key.type = BTRFS_ROOT_ITEM_KEY;
+diff --git a/fs/compat_binfmt_elf.c b/fs/compat_binfmt_elf.c
+index 4d24d17bcfc1..943be5ecfcd9 100644
+--- a/fs/compat_binfmt_elf.c
++++ b/fs/compat_binfmt_elf.c
+@@ -51,6 +51,7 @@
+ #define elf_prstatus	compat_elf_prstatus
+ #define elf_prpsinfo	compat_elf_prpsinfo
+ 
++#ifdef CONFIG_ELF_CORE
+ /*
+  * Compat version of cputime_to_compat_timeval, perhaps this
+  * should be an inline in <linux/compat.h>.
+@@ -63,6 +64,7 @@ static void cputime_to_compat_timeval(const cputime_t cputime,
+ 	value->tv_sec = tv.tv_sec;
+ 	value->tv_usec = tv.tv_usec;
+ }
++#endif
+ 
+ #undef cputime_to_timeval
+ #define cputime_to_timeval cputime_to_compat_timeval
+diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
+index 03446c5a3ec1..4e1144512522 100644
+--- a/fs/ncpfs/dir.c
++++ b/fs/ncpfs/dir.c
+@@ -133,12 +133,11 @@ ncp_hash_dentry(const struct dentry *dentry, struct qstr *this)
+ 		return 0;
+ 
+ 	if (!ncp_case_sensitive(inode)) {
+-		struct super_block *sb = dentry->d_sb;
+ 		struct nls_table *t;
+ 		unsigned long hash;
+ 		int i;
+ 
+-		t = NCP_IO_TABLE(sb);
++		t = NCP_IO_TABLE(dentry->d_sb);
+ 		hash = init_name_hash();
+ 		for (i=0; i<this->len ; i++)
+ 			hash = partial_name_hash(ncp_tolower(t, this->name[i]),
+diff --git a/fs/reiserfs/lbalance.c b/fs/reiserfs/lbalance.c
+index 249594a821e0..f5cebd70d903 100644
+--- a/fs/reiserfs/lbalance.c
++++ b/fs/reiserfs/lbalance.c
+@@ -475,7 +475,7 @@ static void leaf_item_bottle(struct buffer_info *dest_bi,
+ 			 * 'cpy_bytes'; create new item header;
+ 			 * n_ih = new item_header;
+ 			 */
+-			memcpy(&n_ih, ih, SHORT_KEY_SIZE);
++			memcpy(&n_ih.ih_key, &ih->ih_key, KEY_SIZE);
+ 
+ 			/* Endian safe, both le */
+ 			n_ih.ih_version = ih->ih_version;
+diff --git a/fs/reiserfs/reiserfs.h b/fs/reiserfs/reiserfs.h
+index 2adcde137c3f..5dcf3ab83886 100644
+--- a/fs/reiserfs/reiserfs.h
++++ b/fs/reiserfs/reiserfs.h
+@@ -1326,7 +1326,6 @@ struct cpu_key {
+ #define KEY_NOT_FOUND 0
+ 
+ #define KEY_SIZE (sizeof(struct reiserfs_key))
+-#define SHORT_KEY_SIZE (sizeof (__u32) + sizeof (__u32))
+ 
+ /* return values for search_by_key and clones */
+ #define ITEM_FOUND 1
+diff --git a/include/linux/device.h b/include/linux/device.h
+index 7075a2485ed3..834000903525 100644
+--- a/include/linux/device.h
++++ b/include/linux/device.h
+@@ -1272,8 +1272,11 @@ do {									\
+ 		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
+ } while (0)
+ #else
+-#define dev_dbg_ratelimited(dev, fmt, ...)			\
+-	no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
++#define dev_dbg_ratelimited(dev, fmt, ...)				\
++do {									\
++	if (0)								\
++		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
++} while (0)
+ #endif
+ 
+ #ifdef VERBOSE_DEBUG
+diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
+index 5295535b60c6..a7b7a050bfa8 100644
+--- a/include/linux/fdtable.h
++++ b/include/linux/fdtable.h
+@@ -9,6 +9,7 @@
+ #include <linux/compiler.h>
+ #include <linux/spinlock.h>
+ #include <linux/rcupdate.h>
++#include <linux/nospec.h>
+ #include <linux/types.h>
+ #include <linux/init.h>
+ #include <linux/fs.h>
+@@ -81,8 +82,10 @@ static inline struct file *__fcheck_files(struct files_struct *files, unsigned i
+ {
+ 	struct fdtable *fdt = rcu_dereference_raw(files->fdt);
+ 
+-	if (fd < fdt->max_fds)
++	if (fd < fdt->max_fds) {
++		fd = array_index_nospec(fd, fdt->max_fds);
+ 		return rcu_dereference_raw(fdt->fd[fd]);
++	}
+ 	return NULL;
+ }
+ 
+diff --git a/include/linux/init.h b/include/linux/init.h
+index b449f378f995..5c4a3b7524e0 100644
+--- a/include/linux/init.h
++++ b/include/linux/init.h
+@@ -4,6 +4,13 @@
+ #include <linux/compiler.h>
+ #include <linux/types.h>
+ 
++/* Built-in __init functions needn't be compiled with retpoline */
++#if defined(RETPOLINE) && !defined(MODULE)
++#define __noretpoline __attribute__((indirect_branch("keep")))
++#else
++#define __noretpoline
++#endif
++
+ /* These macros are used to mark some functions or 
+  * initialized data (doesn't apply to uninitialized data)
+  * as `initialization' functions. The kernel can take this
+@@ -39,7 +46,7 @@
+ 
+ /* These are for everybody (although not all archs will actually
+    discard it in modules) */
+-#define __init		__section(.init.text) __cold notrace
++#define __init		__section(.init.text) __cold notrace __noretpoline
+ #define __initdata	__section(.init.data)
+ #define __initconst	__constsection(.init.rodata)
+ #define __exitdata	__section(.exit.data)
+diff --git a/include/linux/module.h b/include/linux/module.h
+index b229a9961d02..c9f2f85017ad 100644
+--- a/include/linux/module.h
++++ b/include/linux/module.h
+@@ -789,6 +789,15 @@ static inline void module_bug_finalize(const Elf_Ehdr *hdr,
+ static inline void module_bug_cleanup(struct module *mod) {}
+ #endif	/* CONFIG_GENERIC_BUG */
+ 
++#ifdef RETPOLINE
++extern bool retpoline_module_ok(bool has_retpoline);
++#else
++static inline bool retpoline_module_ok(bool has_retpoline)
++{
++	return true;
++}
++#endif
++
+ #ifdef CONFIG_MODULE_SIG
+ static inline bool module_sig_ok(struct module *module)
+ {
+diff --git a/include/linux/msi.h b/include/linux/msi.h
+index f0f43ec45ee7..d0d50cf00b4d 100644
+--- a/include/linux/msi.h
++++ b/include/linux/msi.h
+@@ -17,7 +17,13 @@ struct msi_desc;
+ struct pci_dev;
+ struct platform_msi_priv_data;
+ void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
++#ifdef CONFIG_GENERIC_MSI_IRQ
+ void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg);
++#else
++static inline void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg)
++{
++}
++#endif
+ 
+ typedef void (*irq_write_msi_msg_t)(struct msi_desc *desc,
+ 				    struct msi_msg *msg);
+@@ -105,18 +111,21 @@ struct msi_desc {
+ 
+ struct pci_dev *msi_desc_to_pci_dev(struct msi_desc *desc);
+ void *msi_desc_to_pci_sysdata(struct msi_desc *desc);
++void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg);
+ #else /* CONFIG_PCI_MSI */
+ static inline void *msi_desc_to_pci_sysdata(struct msi_desc *desc)
+ {
+ 	return NULL;
+ }
++static inline void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg)
++{
++}
+ #endif /* CONFIG_PCI_MSI */
+ 
+ struct msi_desc *alloc_msi_entry(struct device *dev);
+ void free_msi_entry(struct msi_desc *entry);
+ void __pci_read_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
+ void __pci_write_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
+-void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg);
+ 
+ u32 __pci_msix_desc_mask_irq(struct msi_desc *desc, u32 flag);
+ u32 __pci_msi_desc_mask_irq(struct msi_desc *desc, u32 mask, u32 flag);
+diff --git a/include/linux/mtd/sh_flctl.h b/include/linux/mtd/sh_flctl.h
+index 1c28f8879b1c..067b37aff4a1 100644
+--- a/include/linux/mtd/sh_flctl.h
++++ b/include/linux/mtd/sh_flctl.h
+@@ -148,6 +148,7 @@ struct sh_flctl {
+ 	struct platform_device	*pdev;
+ 	struct dev_pm_qos_request pm_qos;
+ 	void __iomem		*reg;
++	resource_size_t		fifo;
+ 
+ 	uint8_t	done_buff[2048 + 64];	/* max size 2048 + 64 */
+ 	int	read_bytes;
+diff --git a/include/linux/nospec.h b/include/linux/nospec.h
+new file mode 100644
+index 000000000000..b99bced39ac2
+--- /dev/null
++++ b/include/linux/nospec.h
+@@ -0,0 +1,72 @@
++// SPDX-License-Identifier: GPL-2.0
++// Copyright(c) 2018 Linus Torvalds. All rights reserved.
++// Copyright(c) 2018 Alexei Starovoitov. All rights reserved.
++// Copyright(c) 2018 Intel Corporation. All rights reserved.
++
++#ifndef _LINUX_NOSPEC_H
++#define _LINUX_NOSPEC_H
++
++/**
++ * array_index_mask_nospec() - generate a ~0 mask when index < size, 0 otherwise
++ * @index: array element index
++ * @size: number of elements in array
++ *
++ * When @index is out of bounds (@index >= @size), the sign bit will be
++ * set.  Extend the sign bit to all bits and invert, giving a result of
++ * zero for an out of bounds index, or ~0 if within bounds [0, @size).
++ */
++#ifndef array_index_mask_nospec
++static inline unsigned long array_index_mask_nospec(unsigned long index,
++						    unsigned long size)
++{
++	/*
++	 * Warn developers about inappropriate array_index_nospec() usage.
++	 *
++	 * Even if the CPU speculates past the WARN_ONCE branch, the
++	 * sign bit of @index is taken into account when generating the
++	 * mask.
++	 *
++	 * This warning is compiled out when the compiler can infer that
++	 * @index and @size are less than LONG_MAX.
++	 */
++	if (WARN_ONCE(index > LONG_MAX || size > LONG_MAX,
++			"array_index_nospec() limited to range of [0, LONG_MAX]\n"))
++		return 0;
++
++	/*
++	 * Always calculate and emit the mask even if the compiler
++	 * thinks the mask is not needed. The compiler does not take
++	 * into account the value of @index under speculation.
++	 */
++	OPTIMIZER_HIDE_VAR(index);
++	return ~(long)(index | (size - 1UL - index)) >> (BITS_PER_LONG - 1);
++}
++#endif
++
++/*
++ * array_index_nospec - sanitize an array index after a bounds check
++ *
++ * For a code sequence like:
++ *
++ *     if (index < size) {
++ *         index = array_index_nospec(index, size);
++ *         val = array[index];
++ *     }
++ *
++ * ...if the CPU speculates past the bounds check then
++ * array_index_nospec() will clamp the index within the range of [0,
++ * size).
++ */
++#define array_index_nospec(index, size)					\
++({									\
++	typeof(index) _i = (index);					\
++	typeof(size) _s = (size);					\
++	unsigned long _mask = array_index_mask_nospec(_i, _s);		\
++									\
++	BUILD_BUG_ON(sizeof(_i) > sizeof(long));			\
++	BUILD_BUG_ON(sizeof(_s) > sizeof(long));			\
++									\
++	_i &= _mask;							\
++	_i;								\
++})
++#endif /* _LINUX_NOSPEC_H */
+diff --git a/include/linux/string.h b/include/linux/string.h
+index aa30789b0f65..98bb781a2eff 100644
+--- a/include/linux/string.h
++++ b/include/linux/string.h
+@@ -122,6 +122,7 @@ extern char *kstrdup(const char *s, gfp_t gfp);
+ extern const char *kstrdup_const(const char *s, gfp_t gfp);
+ extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
+ extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
++extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp);
+ 
+ extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
+ extern void argv_free(char **argv);
+diff --git a/include/net/dst_cache.h b/include/net/dst_cache.h
+new file mode 100644
+index 000000000000..151accae708b
+--- /dev/null
++++ b/include/net/dst_cache.h
+@@ -0,0 +1,97 @@
++#ifndef _NET_DST_CACHE_H
++#define _NET_DST_CACHE_H
++
++#include <linux/jiffies.h>
++#include <net/dst.h>
++#if IS_ENABLED(CONFIG_IPV6)
++#include <net/ip6_fib.h>
++#endif
++
++struct dst_cache {
++	struct dst_cache_pcpu __percpu *cache;
++	unsigned long reset_ts;
++};
++
++/**
++ *	dst_cache_get - perform cache lookup
++ *	@dst_cache: the cache
++ *
++ *	The caller should use dst_cache_get_ip4() if it need to retrieve the
++ *	source address to be used when xmitting to the cached dst.
++ *	local BH must be disabled.
++ */
++struct dst_entry *dst_cache_get(struct dst_cache *dst_cache);
++
++/**
++ *	dst_cache_get_ip4 - perform cache lookup and fetch ipv4 source address
++ *	@dst_cache: the cache
++ *	@saddr: return value for the retrieved source address
++ *
++ *	local BH must be disabled.
++ */
++struct rtable *dst_cache_get_ip4(struct dst_cache *dst_cache, __be32 *saddr);
++
++/**
++ *	dst_cache_set_ip4 - store the ipv4 dst into the cache
++ *	@dst_cache: the cache
++ *	@dst: the entry to be cached
++ *	@saddr: the source address to be stored inside the cache
++ *
++ *	local BH must be disabled.
++ */
++void dst_cache_set_ip4(struct dst_cache *dst_cache, struct dst_entry *dst,
++		       __be32 saddr);
++
++#if IS_ENABLED(CONFIG_IPV6)
++
++/**
++ *	dst_cache_set_ip6 - store the ipv6 dst into the cache
++ *	@dst_cache: the cache
++ *	@dst: the entry to be cached
++ *	@saddr: the source address to be stored inside the cache
++ *
++ *	local BH must be disabled.
++ */
++void dst_cache_set_ip6(struct dst_cache *dst_cache, struct dst_entry *dst,
++		       const struct in6_addr *addr);
++
++/**
++ *	dst_cache_get_ip6 - perform cache lookup and fetch ipv6 source address
++ *	@dst_cache: the cache
++ *	@saddr: return value for the retrieved source address
++ *
++ *	local BH must be disabled.
++ */
++struct dst_entry *dst_cache_get_ip6(struct dst_cache *dst_cache,
++				    struct in6_addr *saddr);
++#endif
++
++/**
++ *	dst_cache_reset - invalidate the cache contents
++ *	@dst_cache: the cache
++ *
++ *	This do not free the cached dst to avoid races and contentions.
++ *	the dst will be freed on later cache lookup.
++ */
++static inline void dst_cache_reset(struct dst_cache *dst_cache)
++{
++	dst_cache->reset_ts = jiffies;
++}
++
++/**
++ *	dst_cache_init - initialize the cache, allocating the required storage
++ *	@dst_cache: the cache
++ *	@gfp: allocation flags
++ */
++int dst_cache_init(struct dst_cache *dst_cache, gfp_t gfp);
++
++/**
++ *	dst_cache_destroy - empty the cache and free the allocated storage
++ *	@dst_cache: the cache
++ *
++ *	No synchronization is enforced: it must be called only when the cache
++ *	is unsed.
++ */
++void dst_cache_destroy(struct dst_cache *dst_cache);
++
++#endif
+diff --git a/include/net/ip6_tunnel.h b/include/net/ip6_tunnel.h
+index 9c2c044153f6..d143c8480681 100644
+--- a/include/net/ip6_tunnel.h
++++ b/include/net/ip6_tunnel.h
+@@ -5,6 +5,8 @@
+ #include <linux/netdevice.h>
+ #include <linux/if_tunnel.h>
+ #include <linux/ip6_tunnel.h>
++#include <net/ip_tunnels.h>
++#include <net/dst_cache.h>
+ 
+ #define IP6TUNNEL_ERR_TIMEO (30*HZ)
+ 
+@@ -32,12 +34,6 @@ struct __ip6_tnl_parm {
+ 	__be32			o_key;
+ };
+ 
+-struct ip6_tnl_dst {
+-	seqlock_t lock;
+-	struct dst_entry __rcu *dst;
+-	u32 cookie;
+-};
+-
+ /* IPv6 tunnel */
+ struct ip6_tnl {
+ 	struct ip6_tnl __rcu *next;	/* next tunnel in list */
+@@ -45,7 +41,7 @@ struct ip6_tnl {
+ 	struct net *net;	/* netns for packet i/o */
+ 	struct __ip6_tnl_parm parms;	/* tunnel configuration parameters */
+ 	struct flowi fl;	/* flowi template for xmit */
+-	struct ip6_tnl_dst __percpu *dst_cache;	/* cached dst */
++	struct dst_cache dst_cache;	/* cached dst */
+ 
+ 	int err_count;
+ 	unsigned long err_time;
+@@ -65,11 +61,6 @@ struct ipv6_tlv_tnl_enc_lim {
+ 	__u8 encap_limit;	/* tunnel encapsulation limit   */
+ } __packed;
+ 
+-struct dst_entry *ip6_tnl_dst_get(struct ip6_tnl *t);
+-int ip6_tnl_dst_init(struct ip6_tnl *t);
+-void ip6_tnl_dst_destroy(struct ip6_tnl *t);
+-void ip6_tnl_dst_reset(struct ip6_tnl *t);
+-void ip6_tnl_dst_set(struct ip6_tnl *t, struct dst_entry *dst);
+ int ip6_tnl_rcv_ctl(struct ip6_tnl *t, const struct in6_addr *laddr,
+ 		const struct in6_addr *raddr);
+ int ip6_tnl_xmit_ctl(struct ip6_tnl *t, const struct in6_addr *laddr,
+diff --git a/include/net/netlink.h b/include/net/netlink.h
+index 0e3172751755..5ffaea4665f8 100644
+--- a/include/net/netlink.h
++++ b/include/net/netlink.h
+@@ -745,7 +745,10 @@ static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
+  */
+ static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(u8), &value);
++	/* temporary variables to work around GCC PR81715 with asan-stack=1 */
++	u8 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(u8), &tmp);
+ }
+ 
+ /**
+@@ -756,7 +759,9 @@ static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
+  */
+ static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(u16), &value);
++	u16 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(u16), &tmp);
+ }
+ 
+ /**
+@@ -767,7 +772,9 @@ static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
+  */
+ static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(__be16), &value);
++	__be16 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(__be16), &tmp);
+ }
+ 
+ /**
+@@ -778,7 +785,9 @@ static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
+  */
+ static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
+ {
+-	return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, value);
++	__be16 tmp = value;
++
++	return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
+ }
+ 
+ /**
+@@ -789,7 +798,9 @@ static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
+  */
+ static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(__le16), &value);
++	__le16 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(__le16), &tmp);
+ }
+ 
+ /**
+@@ -800,7 +811,9 @@ static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
+  */
+ static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(u32), &value);
++	u32 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(u32), &tmp);
+ }
+ 
+ /**
+@@ -811,7 +824,9 @@ static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
+  */
+ static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(__be32), &value);
++	__be32 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(__be32), &tmp);
+ }
+ 
+ /**
+@@ -822,7 +837,9 @@ static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
+  */
+ static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
+ {
+-	return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, value);
++	__be32 tmp = value;
++
++	return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
+ }
+ 
+ /**
+@@ -833,7 +850,9 @@ static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
+  */
+ static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(__le32), &value);
++	__le32 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(__le32), &tmp);
+ }
+ 
+ /**
+@@ -844,7 +863,9 @@ static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
+  */
+ static inline int nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(u64), &value);
++	u64 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(u64), &tmp);
+ }
+ 
+ /**
+@@ -855,7 +876,9 @@ static inline int nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
+  */
+ static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(__be64), &value);
++	__be64 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(__be64), &tmp);
+ }
+ 
+ /**
+@@ -866,7 +889,9 @@ static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value)
+  */
+ static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value)
+ {
+-	return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, value);
++	__be64 tmp = value;
++
++	return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
+ }
+ 
+ /**
+@@ -877,7 +902,9 @@ static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value)
+  */
+ static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(__le64), &value);
++	__le64 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(__le64), &tmp);
+ }
+ 
+ /**
+@@ -888,7 +915,9 @@ static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value)
+  */
+ static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(s8), &value);
++	s8 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(s8), &tmp);
+ }
+ 
+ /**
+@@ -899,7 +928,9 @@ static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
+  */
+ static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(s16), &value);
++	s16 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(s16), &tmp);
+ }
+ 
+ /**
+@@ -910,7 +941,9 @@ static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
+  */
+ static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(s32), &value);
++	s32 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(s32), &tmp);
+ }
+ 
+ /**
+@@ -921,7 +954,9 @@ static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
+  */
+ static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value)
+ {
+-	return nla_put(skb, attrtype, sizeof(s64), &value);
++	s64 tmp = value;
++
++	return nla_put(skb, attrtype, sizeof(s64), &tmp);
+ }
+ 
+ /**
+@@ -969,7 +1004,9 @@ static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
+ static inline int nla_put_in_addr(struct sk_buff *skb, int attrtype,
+ 				  __be32 addr)
+ {
+-	return nla_put_be32(skb, attrtype, addr);
++	__be32 tmp = addr;
++
++	return nla_put_be32(skb, attrtype, tmp);
+ }
+ 
+ /**
+diff --git a/include/net/red.h b/include/net/red.h
+index 76e0b5f922c6..3618cdfec884 100644
+--- a/include/net/red.h
++++ b/include/net/red.h
+@@ -167,6 +167,17 @@ static inline void red_set_vars(struct red_vars *v)
+ 	v->qcount	= -1;
+ }
+ 
++static inline bool red_check_params(u32 qth_min, u32 qth_max, u8 Wlog)
++{
++	if (fls(qth_min) + Wlog > 32)
++		return false;
++	if (fls(qth_max) + Wlog > 32)
++		return false;
++	if (qth_max < qth_min)
++		return false;
++	return true;
++}
++
+ static inline void red_set_parms(struct red_parms *p,
+ 				 u32 qth_min, u32 qth_max, u8 Wlog, u8 Plog,
+ 				 u8 Scell_log, u8 *stab, u32 max_P)
+@@ -178,7 +189,7 @@ static inline void red_set_parms(struct red_parms *p,
+ 	p->qth_max	= qth_max << Wlog;
+ 	p->Wlog		= Wlog;
+ 	p->Plog		= Plog;
+-	if (delta < 0)
++	if (delta <= 0)
+ 		delta = 1;
+ 	p->qth_delta	= delta;
+ 	if (!max_P) {
+diff --git a/include/trace/events/clk.h b/include/trace/events/clk.h
+index 758607226bfd..2cd449328aee 100644
+--- a/include/trace/events/clk.h
++++ b/include/trace/events/clk.h
+@@ -134,12 +134,12 @@ DECLARE_EVENT_CLASS(clk_parent,
+ 
+ 	TP_STRUCT__entry(
+ 		__string(        name,           core->name                )
+-		__string(        pname,          parent->name              )
++		__string(        pname, parent ? parent->name : "none"     )
+ 	),
+ 
+ 	TP_fast_assign(
+ 		__assign_str(name, core->name);
+-		__assign_str(pname, parent->name);
++		__assign_str(pname, parent ? parent->name : "none");
+ 	),
+ 
+ 	TP_printk("%s %s", __get_str(name), __get_str(pname))
+diff --git a/kernel/module.c b/kernel/module.c
+index 0a56098d3738..aa81f41f2b19 100644
+--- a/kernel/module.c
++++ b/kernel/module.c
+@@ -2869,6 +2869,15 @@ static struct module *setup_load_info(struct load_info *info, int flags)
+ 	return mod;
+ }
+ 
++static void check_modinfo_retpoline(struct module *mod, struct load_info *info)
++{
++	if (retpoline_module_ok(get_modinfo(info, "retpoline")))
++		return;
++
++	pr_warn("%s: loading module not compiled with retpoline compiler.\n",
++		mod->name);
++}
++
+ static int check_modinfo(struct module *mod, struct load_info *info, int flags)
+ {
+ 	const char *modmagic = get_modinfo(info, "vermagic");
+@@ -2895,6 +2904,8 @@ static int check_modinfo(struct module *mod, struct load_info *info, int flags)
+ 		add_taint_module(mod, TAINT_OOT_MODULE, LOCKDEP_STILL_OK);
+ 	}
+ 
++	check_modinfo_retpoline(mod, info);
++
+ 	if (get_modinfo(info, "staging")) {
+ 		add_taint_module(mod, TAINT_CRAP, LOCKDEP_STILL_OK);
+ 		pr_warn("%s: module is from the staging directory, the quality "
+diff --git a/kernel/profile.c b/kernel/profile.c
+index 99513e1160e5..9cd8e18e6f18 100644
+--- a/kernel/profile.c
++++ b/kernel/profile.c
+@@ -44,7 +44,7 @@ int prof_on __read_mostly;
+ EXPORT_SYMBOL_GPL(prof_on);
+ 
+ static cpumask_var_t prof_cpu_mask;
+-#ifdef CONFIG_SMP
++#if defined(CONFIG_SMP) && defined(CONFIG_PROC_FS)
+ static DEFINE_PER_CPU(struct profile_hit *[2], cpu_profile_hits);
+ static DEFINE_PER_CPU(int, cpu_profile_flip);
+ static DEFINE_MUTEX(profile_flip_mutex);
+@@ -201,7 +201,7 @@ int profile_event_unregister(enum profile_type type, struct notifier_block *n)
+ }
+ EXPORT_SYMBOL_GPL(profile_event_unregister);
+ 
+-#ifdef CONFIG_SMP
++#if defined(CONFIG_SMP) && defined(CONFIG_PROC_FS)
+ /*
+  * Each cpu has a pair of open-addressed hashtables for pending
+  * profile hits. read_profile() IPI's all cpus to request them
+diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
+index a990824c8604..7ab5eafea8b2 100644
+--- a/kernel/trace/blktrace.c
++++ b/kernel/trace/blktrace.c
+@@ -57,7 +57,8 @@ static struct tracer_flags blk_tracer_flags = {
+ };
+ 
+ /* Global reference count of probes */
+-static atomic_t blk_probes_ref = ATOMIC_INIT(0);
++static DEFINE_MUTEX(blk_probe_mutex);
++static int blk_probes_ref;
+ 
+ static void blk_register_tracepoints(void);
+ static void blk_unregister_tracepoints(void);
+@@ -300,11 +301,26 @@ static void blk_trace_free(struct blk_trace *bt)
+ 	kfree(bt);
+ }
+ 
++static void get_probe_ref(void)
++{
++	mutex_lock(&blk_probe_mutex);
++	if (++blk_probes_ref == 1)
++		blk_register_tracepoints();
++	mutex_unlock(&blk_probe_mutex);
++}
++
++static void put_probe_ref(void)
++{
++	mutex_lock(&blk_probe_mutex);
++	if (!--blk_probes_ref)
++		blk_unregister_tracepoints();
++	mutex_unlock(&blk_probe_mutex);
++}
++
+ static void blk_trace_cleanup(struct blk_trace *bt)
+ {
+ 	blk_trace_free(bt);
+-	if (atomic_dec_and_test(&blk_probes_ref))
+-		blk_unregister_tracepoints();
++	put_probe_ref();
+ }
+ 
+ int blk_trace_remove(struct request_queue *q)
+@@ -522,8 +538,7 @@ int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
+ 	if (cmpxchg(&q->blk_trace, NULL, bt))
+ 		goto err;
+ 
+-	if (atomic_inc_return(&blk_probes_ref) == 1)
+-		blk_register_tracepoints();
++	get_probe_ref();
+ 
+ 	return 0;
+ err:
+@@ -1466,9 +1481,7 @@ static int blk_trace_remove_queue(struct request_queue *q)
+ 	if (bt == NULL)
+ 		return -EINVAL;
+ 
+-	if (atomic_dec_and_test(&blk_probes_ref))
+-		blk_unregister_tracepoints();
+-
++	put_probe_ref();
+ 	blk_trace_free(bt);
+ 	return 0;
+ }
+@@ -1499,8 +1512,7 @@ static int blk_trace_setup_queue(struct request_queue *q,
+ 	if (cmpxchg(&q->blk_trace, NULL, bt))
+ 		goto free_bt;
+ 
+-	if (atomic_inc_return(&blk_probes_ref) == 1)
+-		blk_register_tracepoints();
++	get_probe_ref();
+ 	return 0;
+ 
+ free_bt:
+diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
+index b53b375e14bd..f0602beeba26 100644
+--- a/lib/Kconfig.debug
++++ b/lib/Kconfig.debug
+@@ -197,7 +197,7 @@ config ENABLE_MUST_CHECK
+ config FRAME_WARN
+ 	int "Warn for stack frames larger than (needs gcc 4.4)"
+ 	range 0 8192
+-	default 0 if KASAN
++	default 2048 if GCC_PLUGIN_LATENT_ENTROPY
+ 	default 1024 if !64BIT
+ 	default 2048 if 64BIT
+ 	help
+diff --git a/lib/oid_registry.c b/lib/oid_registry.c
+index 318f382a010d..150e04d70303 100644
+--- a/lib/oid_registry.c
++++ b/lib/oid_registry.c
+@@ -116,7 +116,7 @@ int sprint_oid(const void *data, size_t datasize, char *buffer, size_t bufsize)
+ 	int count;
+ 
+ 	if (v >= end)
+-		return -EBADMSG;
++		goto bad;
+ 
+ 	n = *v++;
+ 	ret = count = snprintf(buffer, bufsize, "%u.%u", n / 40, n % 40);
+@@ -134,7 +134,7 @@ int sprint_oid(const void *data, size_t datasize, char *buffer, size_t bufsize)
+ 			num = n & 0x7f;
+ 			do {
+ 				if (v >= end)
+-					return -EBADMSG;
++					goto bad;
+ 				n = *v++;
+ 				num <<= 7;
+ 				num |= n & 0x7f;
+@@ -148,6 +148,10 @@ int sprint_oid(const void *data, size_t datasize, char *buffer, size_t bufsize)
+ 	}
+ 
+ 	return ret;
++
++bad:
++	snprintf(buffer, bufsize, "(bad)");
++	return -EBADMSG;
+ }
+ EXPORT_SYMBOL_GPL(sprint_oid);
+ 
+diff --git a/mm/early_ioremap.c b/mm/early_ioremap.c
+index 6d5717bd7197..57540de2b44c 100644
+--- a/mm/early_ioremap.c
++++ b/mm/early_ioremap.c
+@@ -103,7 +103,7 @@ __early_ioremap(resource_size_t phys_addr, unsigned long size, pgprot_t prot)
+ 	enum fixed_addresses idx;
+ 	int i, slot;
+ 
+-	WARN_ON(system_state != SYSTEM_BOOTING);
++	WARN_ON(system_state >= SYSTEM_RUNNING);
+ 
+ 	slot = -1;
+ 	for (i = 0; i < FIX_BTMAPS_SLOTS; i++) {
+diff --git a/mm/util.c b/mm/util.c
+index d5259b62f8d7..818bbae84721 100644
+--- a/mm/util.c
++++ b/mm/util.c
+@@ -80,6 +80,8 @@ EXPORT_SYMBOL(kstrdup_const);
+  * @s: the string to duplicate
+  * @max: read at most @max chars from @s
+  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
++ *
++ * Note: Use kmemdup_nul() instead if the size is known exactly.
+  */
+ char *kstrndup(const char *s, size_t max, gfp_t gfp)
+ {
+@@ -117,6 +119,28 @@ void *kmemdup(const void *src, size_t len, gfp_t gfp)
+ }
+ EXPORT_SYMBOL(kmemdup);
+ 
++/**
++ * kmemdup_nul - Create a NUL-terminated string from unterminated data
++ * @s: The data to stringify
++ * @len: The size of the data
++ * @gfp: the GFP mask used in the kmalloc() call when allocating memory
++ */
++char *kmemdup_nul(const char *s, size_t len, gfp_t gfp)
++{
++	char *buf;
++
++	if (!s)
++		return NULL;
++
++	buf = kmalloc_track_caller(len + 1, gfp);
++	if (buf) {
++		memcpy(buf, s, len);
++		buf[len] = '\0';
++	}
++	return buf;
++}
++EXPORT_SYMBOL(kmemdup_nul);
++
+ /**
+  * memdup_user - duplicate memory region from user space
+  *
+diff --git a/mm/vmscan.c b/mm/vmscan.c
+index 440c2df9be82..930f7c67a9c1 100644
+--- a/mm/vmscan.c
++++ b/mm/vmscan.c
+@@ -254,10 +254,13 @@ EXPORT_SYMBOL(register_shrinker);
+  */
+ void unregister_shrinker(struct shrinker *shrinker)
+ {
++	if (!shrinker->nr_deferred)
++		return;
+ 	down_write(&shrinker_rwsem);
+ 	list_del(&shrinker->list);
+ 	up_write(&shrinker_rwsem);
+ 	kfree(shrinker->nr_deferred);
++	shrinker->nr_deferred = NULL;
+ }
+ EXPORT_SYMBOL(unregister_shrinker);
+ 
+diff --git a/net/Kconfig b/net/Kconfig
+index 6d94140beacc..129b9fcbf1d0 100644
+--- a/net/Kconfig
++++ b/net/Kconfig
+@@ -383,6 +383,10 @@ config LWTUNNEL
+ 	  weight tunnel endpoint. Tunnel encapsulation parameters are stored
+ 	  with light weight tunnel state associated with fib routes.
+ 
++config DST_CACHE
++	bool
++	default n
++
+ endif   # if NET
+ 
+ # Used by archs to tell that they support BPF_JIT
+diff --git a/net/core/Makefile b/net/core/Makefile
+index 086b01fbe1bd..0d8ad4d0261b 100644
+--- a/net/core/Makefile
++++ b/net/core/Makefile
+@@ -24,3 +24,4 @@ obj-$(CONFIG_NET_PTP_CLASSIFY) += ptp_classifier.o
+ obj-$(CONFIG_CGROUP_NET_PRIO) += netprio_cgroup.o
+ obj-$(CONFIG_CGROUP_NET_CLASSID) += netclassid_cgroup.o
+ obj-$(CONFIG_LWTUNNEL) += lwtunnel.o
++obj-$(CONFIG_DST_CACHE) += dst_cache.o
+diff --git a/net/core/dev.c b/net/core/dev.c
+index cb58ba15d51e..389807c1c36f 100644
+--- a/net/core/dev.c
++++ b/net/core/dev.c
+@@ -2598,7 +2598,7 @@ struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
+ 
+ 	segs = skb_mac_gso_segment(skb, features);
+ 
+-	if (unlikely(skb_needs_check(skb, tx_path)))
++	if (unlikely(skb_needs_check(skb, tx_path) && !IS_ERR(segs)))
+ 		skb_warn_bad_offload(skb);
+ 
+ 	return segs;
+diff --git a/net/core/dst_cache.c b/net/core/dst_cache.c
+new file mode 100644
+index 000000000000..554d36449231
+--- /dev/null
++++ b/net/core/dst_cache.c
+@@ -0,0 +1,168 @@
++/*
++ * net/core/dst_cache.c - dst entry cache
++ *
++ * Copyright (c) 2016 Paolo Abeni <pabeni@××××××.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ */
++
++#include <linux/kernel.h>
++#include <linux/percpu.h>
++#include <net/dst_cache.h>
++#include <net/route.h>
++#if IS_ENABLED(CONFIG_IPV6)
++#include <net/ip6_fib.h>
++#endif
++#include <uapi/linux/in.h>
++
++struct dst_cache_pcpu {
++	unsigned long refresh_ts;
++	struct dst_entry *dst;
++	u32 cookie;
++	union {
++		struct in_addr in_saddr;
++		struct in6_addr in6_saddr;
++	};
++};
++
++static void dst_cache_per_cpu_dst_set(struct dst_cache_pcpu *dst_cache,
++				      struct dst_entry *dst, u32 cookie)
++{
++	dst_release(dst_cache->dst);
++	if (dst)
++		dst_hold(dst);
++
++	dst_cache->cookie = cookie;
++	dst_cache->dst = dst;
++}
++
++static struct dst_entry *dst_cache_per_cpu_get(struct dst_cache *dst_cache,
++					       struct dst_cache_pcpu *idst)
++{
++	struct dst_entry *dst;
++
++	dst = idst->dst;
++	if (!dst)
++		goto fail;
++
++	/* the cache already hold a dst reference; it can't go away */
++	dst_hold(dst);
++
++	if (unlikely(!time_after(idst->refresh_ts, dst_cache->reset_ts) ||
++		     (dst->obsolete && !dst->ops->check(dst, idst->cookie)))) {
++		dst_cache_per_cpu_dst_set(idst, NULL, 0);
++		dst_release(dst);
++		goto fail;
++	}
++	return dst;
++
++fail:
++	idst->refresh_ts = jiffies;
++	return NULL;
++}
++
++struct dst_entry *dst_cache_get(struct dst_cache *dst_cache)
++{
++	if (!dst_cache->cache)
++		return NULL;
++
++	return dst_cache_per_cpu_get(dst_cache, this_cpu_ptr(dst_cache->cache));
++}
++EXPORT_SYMBOL_GPL(dst_cache_get);
++
++struct rtable *dst_cache_get_ip4(struct dst_cache *dst_cache, __be32 *saddr)
++{
++	struct dst_cache_pcpu *idst;
++	struct dst_entry *dst;
++
++	if (!dst_cache->cache)
++		return NULL;
++
++	idst = this_cpu_ptr(dst_cache->cache);
++	dst = dst_cache_per_cpu_get(dst_cache, idst);
++	if (!dst)
++		return NULL;
++
++	*saddr = idst->in_saddr.s_addr;
++	return container_of(dst, struct rtable, dst);
++}
++EXPORT_SYMBOL_GPL(dst_cache_get_ip4);
++
++void dst_cache_set_ip4(struct dst_cache *dst_cache, struct dst_entry *dst,
++		       __be32 saddr)
++{
++	struct dst_cache_pcpu *idst;
++
++	if (!dst_cache->cache)
++		return;
++
++	idst = this_cpu_ptr(dst_cache->cache);
++	dst_cache_per_cpu_dst_set(idst, dst, 0);
++	idst->in_saddr.s_addr = saddr;
++}
++EXPORT_SYMBOL_GPL(dst_cache_set_ip4);
++
++#if IS_ENABLED(CONFIG_IPV6)
++void dst_cache_set_ip6(struct dst_cache *dst_cache, struct dst_entry *dst,
++		       const struct in6_addr *addr)
++{
++	struct dst_cache_pcpu *idst;
++
++	if (!dst_cache->cache)
++		return;
++
++	idst = this_cpu_ptr(dst_cache->cache);
++	dst_cache_per_cpu_dst_set(this_cpu_ptr(dst_cache->cache), dst,
++				  rt6_get_cookie((struct rt6_info *)dst));
++	idst->in6_saddr = *addr;
++}
++EXPORT_SYMBOL_GPL(dst_cache_set_ip6);
++
++struct dst_entry *dst_cache_get_ip6(struct dst_cache *dst_cache,
++				    struct in6_addr *saddr)
++{
++	struct dst_cache_pcpu *idst;
++	struct dst_entry *dst;
++
++	if (!dst_cache->cache)
++		return NULL;
++
++	idst = this_cpu_ptr(dst_cache->cache);
++	dst = dst_cache_per_cpu_get(dst_cache, idst);
++	if (!dst)
++		return NULL;
++
++	*saddr = idst->in6_saddr;
++	return dst;
++}
++EXPORT_SYMBOL_GPL(dst_cache_get_ip6);
++#endif
++
++int dst_cache_init(struct dst_cache *dst_cache, gfp_t gfp)
++{
++	dst_cache->cache = alloc_percpu_gfp(struct dst_cache_pcpu,
++					    gfp | __GFP_ZERO);
++	if (!dst_cache->cache)
++		return -ENOMEM;
++
++	dst_cache_reset(dst_cache);
++	return 0;
++}
++EXPORT_SYMBOL_GPL(dst_cache_init);
++
++void dst_cache_destroy(struct dst_cache *dst_cache)
++{
++	int i;
++
++	if (!dst_cache->cache)
++		return;
++
++	for_each_possible_cpu(i)
++		dst_release(per_cpu_ptr(dst_cache->cache, i)->dst);
++
++	free_percpu(dst_cache->cache);
++}
++EXPORT_SYMBOL_GPL(dst_cache_destroy);
+diff --git a/net/decnet/af_decnet.c b/net/decnet/af_decnet.c
+index 13d6b1a6e0fc..9d8fcdefefc0 100644
+--- a/net/decnet/af_decnet.c
++++ b/net/decnet/af_decnet.c
+@@ -1337,6 +1337,12 @@ static int dn_setsockopt(struct socket *sock, int level, int optname, char __use
+ 	lock_sock(sk);
+ 	err = __dn_setsockopt(sock, level, optname, optval, optlen, 0);
+ 	release_sock(sk);
++#ifdef CONFIG_NETFILTER
++	/* we need to exclude all possible ENOPROTOOPTs except default case */
++	if (err == -ENOPROTOOPT && optname != DSO_LINKINFO &&
++	    optname != DSO_STREAM && optname != DSO_SEQPACKET)
++		err = nf_setsockopt(sk, PF_DECnet, optname, optval, optlen);
++#endif
+ 
+ 	return err;
+ }
+@@ -1444,15 +1450,6 @@ static int __dn_setsockopt(struct socket *sock, int level,int optname, char __us
+ 		dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation);
+ 		break;
+ 
+-	default:
+-#ifdef CONFIG_NETFILTER
+-		return nf_setsockopt(sk, PF_DECnet, optname, optval, optlen);
+-#endif
+-	case DSO_LINKINFO:
+-	case DSO_STREAM:
+-	case DSO_SEQPACKET:
+-		return -ENOPROTOOPT;
+-
+ 	case DSO_MAXWINDOW:
+ 		if (optlen != sizeof(unsigned long))
+ 			return -EINVAL;
+@@ -1500,6 +1497,12 @@ static int __dn_setsockopt(struct socket *sock, int level,int optname, char __us
+ 			return -EINVAL;
+ 		scp->info_loc = u.info;
+ 		break;
++
++	case DSO_LINKINFO:
++	case DSO_STREAM:
++	case DSO_SEQPACKET:
++	default:
++		return -ENOPROTOOPT;
+ 	}
+ 
+ 	return 0;
+@@ -1513,6 +1516,20 @@ static int dn_getsockopt(struct socket *sock, int level, int optname, char __use
+ 	lock_sock(sk);
+ 	err = __dn_getsockopt(sock, level, optname, optval, optlen, 0);
+ 	release_sock(sk);
++#ifdef CONFIG_NETFILTER
++	if (err == -ENOPROTOOPT && optname != DSO_STREAM &&
++	    optname != DSO_SEQPACKET && optname != DSO_CONACCEPT &&
++	    optname != DSO_CONREJECT) {
++		int len;
++
++		if (get_user(len, optlen))
++			return -EFAULT;
++
++		err = nf_getsockopt(sk, PF_DECnet, optname, optval, &len);
++		if (err >= 0)
++			err = put_user(len, optlen);
++	}
++#endif
+ 
+ 	return err;
+ }
+@@ -1578,26 +1595,6 @@ static int __dn_getsockopt(struct socket *sock, int level,int optname, char __us
+ 		r_data = &link;
+ 		break;
+ 
+-	default:
+-#ifdef CONFIG_NETFILTER
+-	{
+-		int ret, len;
+-
+-		if (get_user(len, optlen))
+-			return -EFAULT;
+-
+-		ret = nf_getsockopt(sk, PF_DECnet, optname, optval, &len);
+-		if (ret >= 0)
+-			ret = put_user(len, optlen);
+-		return ret;
+-	}
+-#endif
+-	case DSO_STREAM:
+-	case DSO_SEQPACKET:
+-	case DSO_CONACCEPT:
+-	case DSO_CONREJECT:
+-		return -ENOPROTOOPT;
+-
+ 	case DSO_MAXWINDOW:
+ 		if (r_len > sizeof(unsigned long))
+ 			r_len = sizeof(unsigned long);
+@@ -1629,6 +1626,13 @@ static int __dn_getsockopt(struct socket *sock, int level,int optname, char __us
+ 			r_len = sizeof(unsigned char);
+ 		r_data = &scp->info_rem;
+ 		break;
++
++	case DSO_STREAM:
++	case DSO_SEQPACKET:
++	case DSO_CONACCEPT:
++	case DSO_CONREJECT:
++	default:
++		return -ENOPROTOOPT;
+ 	}
+ 
+ 	if (r_data) {
+diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
+index 097a1243c16c..3a819d2cc04b 100644
+--- a/net/ipv4/ip_sockglue.c
++++ b/net/ipv4/ip_sockglue.c
+@@ -1221,11 +1221,8 @@ int ip_setsockopt(struct sock *sk, int level,
+ 	if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
+ 			optname != IP_IPSEC_POLICY &&
+ 			optname != IP_XFRM_POLICY &&
+-			!ip_mroute_opt(optname)) {
+-		lock_sock(sk);
++			!ip_mroute_opt(optname))
+ 		err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
+-		release_sock(sk);
+-	}
+ #endif
+ 	return err;
+ }
+@@ -1250,12 +1247,9 @@ int compat_ip_setsockopt(struct sock *sk, int level, int optname,
+ 	if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
+ 			optname != IP_IPSEC_POLICY &&
+ 			optname != IP_XFRM_POLICY &&
+-			!ip_mroute_opt(optname)) {
+-		lock_sock(sk);
+-		err = compat_nf_setsockopt(sk, PF_INET, optname,
+-					   optval, optlen);
+-		release_sock(sk);
+-	}
++			!ip_mroute_opt(optname))
++		err = compat_nf_setsockopt(sk, PF_INET, optname, optval,
++					   optlen);
+ #endif
+ 	return err;
+ }
+diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
+index 0bc7412d9e14..9d6b9c4c5f82 100644
+--- a/net/ipv4/ipconfig.c
++++ b/net/ipv4/ipconfig.c
+@@ -152,7 +152,11 @@ static char dhcp_client_identifier[253] __initdata;
+ 
+ /* Persistent data: */
+ 
++#ifdef IPCONFIG_DYNAMIC
+ static int ic_proto_used;			/* Protocol used, if any */
++#else
++#define ic_proto_used 0
++#endif
+ static __be32 ic_nameservers[CONF_NAMESERVERS_MAX]; /* DNS Server IP addresses */
+ static u8 ic_domain[64];		/* DNS (not NIS) domain name */
+ 
+diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c b/net/ipv4/netfilter/ipt_CLUSTERIP.c
+index 4a9e6db9df8d..16599bae11dd 100644
+--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
++++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
+@@ -365,7 +365,7 @@ static int clusterip_tg_check(const struct xt_tgchk_param *par)
+ 	struct ipt_clusterip_tgt_info *cipinfo = par->targinfo;
+ 	const struct ipt_entry *e = par->entryinfo;
+ 	struct clusterip_config *config;
+-	int ret;
++	int ret, i;
+ 
+ 	if (par->nft_compat) {
+ 		pr_err("cannot use CLUSTERIP target from nftables compat\n");
+@@ -384,8 +384,18 @@ static int clusterip_tg_check(const struct xt_tgchk_param *par)
+ 		pr_info("Please specify destination IP\n");
+ 		return -EINVAL;
+ 	}
+-
+-	/* FIXME: further sanity checks */
++	if (cipinfo->num_local_nodes > ARRAY_SIZE(cipinfo->local_nodes)) {
++		pr_info("bad num_local_nodes %u\n", cipinfo->num_local_nodes);
++		return -EINVAL;
++	}
++	for (i = 0; i < cipinfo->num_local_nodes; i++) {
++		if (cipinfo->local_nodes[i] - 1 >=
++		    sizeof(config->local_nodes) * 8) {
++			pr_info("bad local_nodes[%d] %u\n",
++				i, cipinfo->local_nodes[i]);
++			return -EINVAL;
++		}
++	}
+ 
+ 	config = clusterip_config_find_get(par->net, e->ip.dst.s_addr, 1);
+ 	if (!config) {
+diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+index 6a20195a3a2a..3fe8c951f427 100644
+--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
++++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+@@ -259,15 +259,19 @@ getorigdst(struct sock *sk, int optval, void __user *user, int *len)
+ 	struct nf_conntrack_tuple tuple;
+ 
+ 	memset(&tuple, 0, sizeof(tuple));
++
++	lock_sock(sk);
+ 	tuple.src.u3.ip = inet->inet_rcv_saddr;
+ 	tuple.src.u.tcp.port = inet->inet_sport;
+ 	tuple.dst.u3.ip = inet->inet_daddr;
+ 	tuple.dst.u.tcp.port = inet->inet_dport;
+ 	tuple.src.l3num = PF_INET;
+ 	tuple.dst.protonum = sk->sk_protocol;
++	release_sock(sk);
+ 
+ 	/* We only do TCP and SCTP at the moment: is there a better way? */
+-	if (sk->sk_protocol != IPPROTO_TCP && sk->sk_protocol != IPPROTO_SCTP) {
++	if (tuple.dst.protonum != IPPROTO_TCP &&
++	    tuple.dst.protonum != IPPROTO_SCTP) {
+ 		pr_debug("SO_ORIGINAL_DST: Not a TCP/SCTP socket\n");
+ 		return -ENOPROTOOPT;
+ 	}
+diff --git a/net/ipv6/Kconfig b/net/ipv6/Kconfig
+index 983bb999738c..851d5c9e3ecc 100644
+--- a/net/ipv6/Kconfig
++++ b/net/ipv6/Kconfig
+@@ -205,6 +205,7 @@ config IPV6_NDISC_NODETYPE
+ config IPV6_TUNNEL
+ 	tristate "IPv6: IP-in-IPv6 tunnel (RFC2473)"
+ 	select INET6_TUNNEL
++	select DST_CACHE
+ 	---help---
+ 	  Support for IPv6-in-IPv6 and IPv4-in-IPv6 tunnels described in
+ 	  RFC 2473.
+diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c
+index c878cbf65485..9ada1095c1cd 100644
+--- a/net/ipv6/ip6_gre.c
++++ b/net/ipv6/ip6_gre.c
+@@ -362,7 +362,7 @@ static void ip6gre_tunnel_uninit(struct net_device *dev)
+ 	struct ip6gre_net *ign = net_generic(t->net, ip6gre_net_id);
+ 
+ 	ip6gre_tunnel_unlink(ign, t);
+-	ip6_tnl_dst_reset(t);
++	dst_cache_reset(&t->dst_cache);
+ 	dev_put(dev);
+ }
+ 
+@@ -640,7 +640,7 @@ static netdev_tx_t ip6gre_xmit2(struct sk_buff *skb,
+ 	}
+ 
+ 	if (!fl6->flowi6_mark)
+-		dst = ip6_tnl_dst_get(tunnel);
++		dst = dst_cache_get(&tunnel->dst_cache);
+ 
+ 	if (!dst) {
+ 		dst = ip6_route_output(net, NULL, fl6);
+@@ -709,7 +709,7 @@ static netdev_tx_t ip6gre_xmit2(struct sk_buff *skb,
+ 	}
+ 
+ 	if (!fl6->flowi6_mark && ndst)
+-		ip6_tnl_dst_set(tunnel, ndst);
++		dst_cache_set_ip6(&tunnel->dst_cache, ndst, &fl6->saddr);
+ 	skb_dst_set(skb, dst);
+ 
+ 	proto = NEXTHDR_GRE;
+@@ -1017,7 +1017,7 @@ static int ip6gre_tnl_change(struct ip6_tnl *t,
+ 	t->parms.o_key = p->o_key;
+ 	t->parms.i_flags = p->i_flags;
+ 	t->parms.o_flags = p->o_flags;
+-	ip6_tnl_dst_reset(t);
++	dst_cache_reset(&t->dst_cache);
+ 	ip6gre_tnl_link_config(t, set_mtu);
+ 	return 0;
+ }
+@@ -1228,7 +1228,7 @@ static void ip6gre_dev_free(struct net_device *dev)
+ {
+ 	struct ip6_tnl *t = netdev_priv(dev);
+ 
+-	ip6_tnl_dst_destroy(t);
++	dst_cache_destroy(&t->dst_cache);
+ 	free_percpu(dev->tstats);
+ 	free_netdev(dev);
+ }
+@@ -1266,7 +1266,7 @@ static int ip6gre_tunnel_init_common(struct net_device *dev)
+ 	if (!dev->tstats)
+ 		return -ENOMEM;
+ 
+-	ret = ip6_tnl_dst_init(tunnel);
++	ret = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
+ 	if (ret) {
+ 		free_percpu(dev->tstats);
+ 		dev->tstats = NULL;
+diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
+index a7170a23ab0b..946c2d015b94 100644
+--- a/net/ipv6/ip6_tunnel.c
++++ b/net/ipv6/ip6_tunnel.c
+@@ -122,97 +122,6 @@ static struct net_device_stats *ip6_get_stats(struct net_device *dev)
+ 	return &dev->stats;
+ }
+ 
+-/*
+- * Locking : hash tables are protected by RCU and RTNL
+- */
+-
+-static void ip6_tnl_per_cpu_dst_set(struct ip6_tnl_dst *idst,
+-				    struct dst_entry *dst)
+-{
+-	write_seqlock_bh(&idst->lock);
+-	dst_release(rcu_dereference_protected(
+-			    idst->dst,
+-			    lockdep_is_held(&idst->lock.lock)));
+-	if (dst) {
+-		dst_hold(dst);
+-		idst->cookie = rt6_get_cookie((struct rt6_info *)dst);
+-	} else {
+-		idst->cookie = 0;
+-	}
+-	rcu_assign_pointer(idst->dst, dst);
+-	write_sequnlock_bh(&idst->lock);
+-}
+-
+-struct dst_entry *ip6_tnl_dst_get(struct ip6_tnl *t)
+-{
+-	struct ip6_tnl_dst *idst;
+-	struct dst_entry *dst;
+-	unsigned int seq;
+-	u32 cookie;
+-
+-	idst = raw_cpu_ptr(t->dst_cache);
+-
+-	rcu_read_lock();
+-	do {
+-		seq = read_seqbegin(&idst->lock);
+-		dst = rcu_dereference(idst->dst);
+-		cookie = idst->cookie;
+-	} while (read_seqretry(&idst->lock, seq));
+-
+-	if (dst && !atomic_inc_not_zero(&dst->__refcnt))
+-		dst = NULL;
+-	rcu_read_unlock();
+-
+-	if (dst && dst->obsolete && !dst->ops->check(dst, cookie)) {
+-		ip6_tnl_per_cpu_dst_set(idst, NULL);
+-		dst_release(dst);
+-		dst = NULL;
+-	}
+-	return dst;
+-}
+-EXPORT_SYMBOL_GPL(ip6_tnl_dst_get);
+-
+-void ip6_tnl_dst_reset(struct ip6_tnl *t)
+-{
+-	int i;
+-
+-	for_each_possible_cpu(i)
+-		ip6_tnl_per_cpu_dst_set(per_cpu_ptr(t->dst_cache, i), NULL);
+-}
+-EXPORT_SYMBOL_GPL(ip6_tnl_dst_reset);
+-
+-void ip6_tnl_dst_set(struct ip6_tnl *t, struct dst_entry *dst)
+-{
+-	ip6_tnl_per_cpu_dst_set(raw_cpu_ptr(t->dst_cache), dst);
+-
+-}
+-EXPORT_SYMBOL_GPL(ip6_tnl_dst_set);
+-
+-void ip6_tnl_dst_destroy(struct ip6_tnl *t)
+-{
+-	if (!t->dst_cache)
+-		return;
+-
+-	ip6_tnl_dst_reset(t);
+-	free_percpu(t->dst_cache);
+-}
+-EXPORT_SYMBOL_GPL(ip6_tnl_dst_destroy);
+-
+-int ip6_tnl_dst_init(struct ip6_tnl *t)
+-{
+-	int i;
+-
+-	t->dst_cache = alloc_percpu(struct ip6_tnl_dst);
+-	if (!t->dst_cache)
+-		return -ENOMEM;
+-
+-	for_each_possible_cpu(i)
+-		seqlock_init(&per_cpu_ptr(t->dst_cache, i)->lock);
+-
+-	return 0;
+-}
+-EXPORT_SYMBOL_GPL(ip6_tnl_dst_init);
+-
+ /**
+  * ip6_tnl_lookup - fetch tunnel matching the end-point addresses
+  *   @remote: the address of the tunnel exit-point
+@@ -331,7 +240,7 @@ static void ip6_dev_free(struct net_device *dev)
+ {
+ 	struct ip6_tnl *t = netdev_priv(dev);
+ 
+-	ip6_tnl_dst_destroy(t);
++	dst_cache_destroy(&t->dst_cache);
+ 	free_percpu(dev->tstats);
+ 	free_netdev(dev);
+ }
+@@ -464,7 +373,7 @@ ip6_tnl_dev_uninit(struct net_device *dev)
+ 		RCU_INIT_POINTER(ip6n->tnls_wc[0], NULL);
+ 	else
+ 		ip6_tnl_unlink(ip6n, t);
+-	ip6_tnl_dst_reset(t);
++	dst_cache_reset(&t->dst_cache);
+ 	dev_put(dev);
+ }
+ 
+@@ -1053,7 +962,6 @@ static int ip6_tnl_xmit2(struct sk_buff *skb,
+ 	struct ipv6_tel_txoption opt;
+ 	struct dst_entry *dst = NULL, *ndst = NULL;
+ 	struct net_device *tdev;
+-	bool use_cache = false;
+ 	int mtu;
+ 	unsigned int max_headroom = sizeof(struct ipv6hdr);
+ 	u8 proto;
+@@ -1061,39 +969,28 @@ static int ip6_tnl_xmit2(struct sk_buff *skb,
+ 
+ 	/* NBMA tunnel */
+ 	if (ipv6_addr_any(&t->parms.raddr)) {
+-		if (skb->protocol == htons(ETH_P_IPV6)) {
+-			struct in6_addr *addr6;
+-			struct neighbour *neigh;
+-			int addr_type;
+-
+-			if (!skb_dst(skb))
+-				goto tx_err_link_failure;
++		struct in6_addr *addr6;
++		struct neighbour *neigh;
++		int addr_type;
+ 
+-			neigh = dst_neigh_lookup(skb_dst(skb),
+-						 &ipv6_hdr(skb)->daddr);
+-			if (!neigh)
+-				goto tx_err_link_failure;
++		if (!skb_dst(skb))
++			goto tx_err_link_failure;
+ 
+-			addr6 = (struct in6_addr *)&neigh->primary_key;
+-			addr_type = ipv6_addr_type(addr6);
++		neigh = dst_neigh_lookup(skb_dst(skb),
++					 &ipv6_hdr(skb)->daddr);
++		if (!neigh)
++			goto tx_err_link_failure;
+ 
+-			if (addr_type == IPV6_ADDR_ANY)
+-				addr6 = &ipv6_hdr(skb)->daddr;
++		addr6 = (struct in6_addr *)&neigh->primary_key;
++		addr_type = ipv6_addr_type(addr6);
+ 
+-			memcpy(&fl6->daddr, addr6, sizeof(fl6->daddr));
+-			neigh_release(neigh);
+-		}
+-	} else if (t->parms.proto != 0 && !(t->parms.flags &
+-					    (IP6_TNL_F_USE_ORIG_TCLASS |
+-					     IP6_TNL_F_USE_ORIG_FWMARK))) {
+-		/* enable the cache only if neither the outer protocol nor the
+-		 * routing decision depends on the current inner header value
+-		 */
+-		use_cache = true;
+-	}
++		if (addr_type == IPV6_ADDR_ANY)
++			addr6 = &ipv6_hdr(skb)->daddr;
+ 
+-	if (use_cache)
+-		dst = ip6_tnl_dst_get(t);
++		memcpy(&fl6->daddr, addr6, sizeof(fl6->daddr));
++		neigh_release(neigh);
++	} else if (!fl6->flowi6_mark)
++		dst = dst_cache_get(&t->dst_cache);
+ 
+ 	if (!ip6_tnl_xmit_ctl(t, &fl6->saddr, &fl6->daddr))
+ 		goto tx_err_link_failure;
+@@ -1156,8 +1053,8 @@ static int ip6_tnl_xmit2(struct sk_buff *skb,
+ 		skb = new_skb;
+ 	}
+ 
+-	if (use_cache && ndst)
+-		ip6_tnl_dst_set(t, ndst);
++	if (!fl6->flowi6_mark && ndst)
++		dst_cache_set_ip6(&t->dst_cache, ndst, &fl6->saddr);
+ 	skb_dst_set(skb, dst);
+ 
+ 	skb->transport_header = skb->network_header;
+@@ -1392,7 +1289,7 @@ ip6_tnl_change(struct ip6_tnl *t, const struct __ip6_tnl_parm *p)
+ 	t->parms.flowinfo = p->flowinfo;
+ 	t->parms.link = p->link;
+ 	t->parms.proto = p->proto;
+-	ip6_tnl_dst_reset(t);
++	dst_cache_reset(&t->dst_cache);
+ 	ip6_tnl_link_config(t);
+ 	return 0;
+ }
+@@ -1663,7 +1560,7 @@ ip6_tnl_dev_init_gen(struct net_device *dev)
+ 	if (!dev->tstats)
+ 		return -ENOMEM;
+ 
+-	ret = ip6_tnl_dst_init(t);
++	ret = dst_cache_init(&t->dst_cache, GFP_KERNEL);
+ 	if (ret) {
+ 		free_percpu(dev->tstats);
+ 		dev->tstats = NULL;
+diff --git a/net/ipv6/ip6_vti.c b/net/ipv6/ip6_vti.c
+index 24dfc2de0165..d7105422bc63 100644
+--- a/net/ipv6/ip6_vti.c
++++ b/net/ipv6/ip6_vti.c
+@@ -645,7 +645,7 @@ vti6_tnl_change(struct ip6_tnl *t, const struct __ip6_tnl_parm *p)
+ 	t->parms.i_key = p->i_key;
+ 	t->parms.o_key = p->o_key;
+ 	t->parms.proto = p->proto;
+-	ip6_tnl_dst_reset(t);
++	dst_cache_reset(&t->dst_cache);
+ 	vti6_link_config(t);
+ 	return 0;
+ }
+diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c
+index 9011176c8387..ede9d0e20538 100644
+--- a/net/ipv6/ipv6_sockglue.c
++++ b/net/ipv6/ipv6_sockglue.c
+@@ -905,12 +905,8 @@ int ipv6_setsockopt(struct sock *sk, int level, int optname,
+ #ifdef CONFIG_NETFILTER
+ 	/* we need to exclude all possible ENOPROTOOPTs except default case */
+ 	if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
+-			optname != IPV6_XFRM_POLICY) {
+-		lock_sock(sk);
+-		err = nf_setsockopt(sk, PF_INET6, optname, optval,
+-				optlen);
+-		release_sock(sk);
+-	}
++			optname != IPV6_XFRM_POLICY)
++		err = nf_setsockopt(sk, PF_INET6, optname, optval, optlen);
+ #endif
+ 	return err;
+ }
+@@ -940,12 +936,9 @@ int compat_ipv6_setsockopt(struct sock *sk, int level, int optname,
+ #ifdef CONFIG_NETFILTER
+ 	/* we need to exclude all possible ENOPROTOOPTs except default case */
+ 	if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
+-	    optname != IPV6_XFRM_POLICY) {
+-		lock_sock(sk);
+-		err = compat_nf_setsockopt(sk, PF_INET6, optname,
+-					   optval, optlen);
+-		release_sock(sk);
+-	}
++	    optname != IPV6_XFRM_POLICY)
++		err = compat_nf_setsockopt(sk, PF_INET6, optname, optval,
++					   optlen);
+ #endif
+ 	return err;
+ }
+diff --git a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
+index 1aa5848764a7..aa051d9d4a96 100644
+--- a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
++++ b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
+@@ -226,20 +226,27 @@ static struct nf_hook_ops ipv6_conntrack_ops[] __read_mostly = {
+ static int
+ ipv6_getorigdst(struct sock *sk, int optval, void __user *user, int *len)
+ {
+-	const struct inet_sock *inet = inet_sk(sk);
++	struct nf_conntrack_tuple tuple = { .src.l3num = NFPROTO_IPV6 };
+ 	const struct ipv6_pinfo *inet6 = inet6_sk(sk);
++	const struct inet_sock *inet = inet_sk(sk);
+ 	const struct nf_conntrack_tuple_hash *h;
+ 	struct sockaddr_in6 sin6;
+-	struct nf_conntrack_tuple tuple = { .src.l3num = NFPROTO_IPV6 };
+ 	struct nf_conn *ct;
++	__be32 flow_label;
++	int bound_dev_if;
+ 
++	lock_sock(sk);
+ 	tuple.src.u3.in6 = sk->sk_v6_rcv_saddr;
+ 	tuple.src.u.tcp.port = inet->inet_sport;
+ 	tuple.dst.u3.in6 = sk->sk_v6_daddr;
+ 	tuple.dst.u.tcp.port = inet->inet_dport;
+ 	tuple.dst.protonum = sk->sk_protocol;
++	bound_dev_if = sk->sk_bound_dev_if;
++	flow_label = inet6->flow_label;
++	release_sock(sk);
+ 
+-	if (sk->sk_protocol != IPPROTO_TCP && sk->sk_protocol != IPPROTO_SCTP)
++	if (tuple.dst.protonum != IPPROTO_TCP &&
++	    tuple.dst.protonum != IPPROTO_SCTP)
+ 		return -ENOPROTOOPT;
+ 
+ 	if (*len < 0 || (unsigned int) *len < sizeof(sin6))
+@@ -257,14 +264,13 @@ ipv6_getorigdst(struct sock *sk, int optval, void __user *user, int *len)
+ 
+ 	sin6.sin6_family = AF_INET6;
+ 	sin6.sin6_port = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u.tcp.port;
+-	sin6.sin6_flowinfo = inet6->flow_label & IPV6_FLOWINFO_MASK;
++	sin6.sin6_flowinfo = flow_label & IPV6_FLOWINFO_MASK;
+ 	memcpy(&sin6.sin6_addr,
+ 		&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3.in6,
+ 					sizeof(sin6.sin6_addr));
+ 
+ 	nf_ct_put(ct);
+-	sin6.sin6_scope_id = ipv6_iface_scope_id(&sin6.sin6_addr,
+-						 sk->sk_bound_dev_if);
++	sin6.sin6_scope_id = ipv6_iface_scope_id(&sin6.sin6_addr, bound_dev_if);
+ 	return copy_to_user(user, &sin6, sizeof(sin6)) ? -EFAULT : 0;
+ }
+ 
+diff --git a/net/netfilter/ipvs/ip_vs_app.c b/net/netfilter/ipvs/ip_vs_app.c
+index 0328f7250693..299edc6add5a 100644
+--- a/net/netfilter/ipvs/ip_vs_app.c
++++ b/net/netfilter/ipvs/ip_vs_app.c
+@@ -605,17 +605,13 @@ static const struct file_operations ip_vs_app_fops = {
+ 
+ int __net_init ip_vs_app_net_init(struct netns_ipvs *ipvs)
+ {
+-	struct net *net = ipvs->net;
+-
+ 	INIT_LIST_HEAD(&ipvs->app_list);
+-	proc_create("ip_vs_app", 0, net->proc_net, &ip_vs_app_fops);
++	proc_create("ip_vs_app", 0, ipvs->net->proc_net, &ip_vs_app_fops);
+ 	return 0;
+ }
+ 
+ void __net_exit ip_vs_app_net_cleanup(struct netns_ipvs *ipvs)
+ {
+-	struct net *net = ipvs->net;
+-
+ 	unregister_ip_vs_app(ipvs, NULL /* all */);
+-	remove_proc_entry("ip_vs_app", net->proc_net);
++	remove_proc_entry("ip_vs_app", ipvs->net->proc_net);
+ }
+diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
+index 2c937c16dc27..2f0e4f61c40f 100644
+--- a/net/netfilter/ipvs/ip_vs_ctl.c
++++ b/net/netfilter/ipvs/ip_vs_ctl.c
+@@ -3951,7 +3951,6 @@ static struct notifier_block ip_vs_dst_notifier = {
+ 
+ int __net_init ip_vs_control_net_init(struct netns_ipvs *ipvs)
+ {
+-	struct net *net = ipvs->net;
+ 	int i, idx;
+ 
+ 	/* Initialize rs_table */
+@@ -3978,9 +3977,9 @@ int __net_init ip_vs_control_net_init(struct netns_ipvs *ipvs)
+ 
+ 	spin_lock_init(&ipvs->tot_stats.lock);
+ 
+-	proc_create("ip_vs", 0, net->proc_net, &ip_vs_info_fops);
+-	proc_create("ip_vs_stats", 0, net->proc_net, &ip_vs_stats_fops);
+-	proc_create("ip_vs_stats_percpu", 0, net->proc_net,
++	proc_create("ip_vs", 0, ipvs->net->proc_net, &ip_vs_info_fops);
++	proc_create("ip_vs_stats", 0, ipvs->net->proc_net, &ip_vs_stats_fops);
++	proc_create("ip_vs_stats_percpu", 0, ipvs->net->proc_net,
+ 		    &ip_vs_stats_percpu_fops);
+ 
+ 	if (ip_vs_control_net_init_sysctl(ipvs))
+@@ -3995,13 +3994,11 @@ err:
+ 
+ void __net_exit ip_vs_control_net_cleanup(struct netns_ipvs *ipvs)
+ {
+-	struct net *net = ipvs->net;
+-
+ 	ip_vs_trash_cleanup(ipvs);
+ 	ip_vs_control_net_cleanup_sysctl(ipvs);
+-	remove_proc_entry("ip_vs_stats_percpu", net->proc_net);
+-	remove_proc_entry("ip_vs_stats", net->proc_net);
+-	remove_proc_entry("ip_vs", net->proc_net);
++	remove_proc_entry("ip_vs_stats_percpu", ipvs->net->proc_net);
++	remove_proc_entry("ip_vs_stats", ipvs->net->proc_net);
++	remove_proc_entry("ip_vs", ipvs->net->proc_net);
+ 	free_percpu(ipvs->tot_stats.cpustats);
+ }
+ 
+diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
+index 7b42b0ad3f9b..5b52dd3feb7d 100644
+--- a/net/netfilter/x_tables.c
++++ b/net/netfilter/x_tables.c
+@@ -38,8 +38,6 @@ MODULE_LICENSE("GPL");
+ MODULE_AUTHOR("Harald Welte <laforge@×××××××××.org>");
+ MODULE_DESCRIPTION("{ip,ip6,arp,eb}_tables backend module");
+ 
+-#define SMP_ALIGN(x) (((x) + SMP_CACHE_BYTES-1) & ~(SMP_CACHE_BYTES-1))
+-
+ struct compat_delta {
+ 	unsigned int offset; /* offset in kernel */
+ 	int delta; /* delta in 32bit user land */
+@@ -208,6 +206,9 @@ xt_request_find_match(uint8_t nfproto, const char *name, uint8_t revision)
+ {
+ 	struct xt_match *match;
+ 
++	if (strnlen(name, XT_EXTENSION_MAXNAMELEN) == XT_EXTENSION_MAXNAMELEN)
++		return ERR_PTR(-EINVAL);
++
+ 	match = xt_find_match(nfproto, name, revision);
+ 	if (IS_ERR(match)) {
+ 		request_module("%st_%s", xt_prefix[nfproto], name);
+@@ -250,6 +251,9 @@ struct xt_target *xt_request_find_target(u8 af, const char *name, u8 revision)
+ {
+ 	struct xt_target *target;
+ 
++	if (strnlen(name, XT_EXTENSION_MAXNAMELEN) == XT_EXTENSION_MAXNAMELEN)
++		return ERR_PTR(-EINVAL);
++
+ 	target = xt_find_target(af, name, revision);
+ 	if (IS_ERR(target)) {
+ 		request_module("%st_%s", xt_prefix[af], name);
+@@ -954,7 +958,7 @@ struct xt_table_info *xt_alloc_table_info(unsigned int size)
+ 		return NULL;
+ 
+ 	/* Pedantry: prevent them from hitting BUG() in vmalloc.c --RR */
+-	if ((SMP_ALIGN(size) >> PAGE_SHIFT) + 2 > totalram_pages)
++	if ((size >> PAGE_SHIFT) + 2 > totalram_pages)
+ 		return NULL;
+ 
+ 	if (sz <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER))
+diff --git a/net/netfilter/xt_RATEEST.c b/net/netfilter/xt_RATEEST.c
+index 604df6fae6fc..0be96f8475f7 100644
+--- a/net/netfilter/xt_RATEEST.c
++++ b/net/netfilter/xt_RATEEST.c
+@@ -40,23 +40,31 @@ static void xt_rateest_hash_insert(struct xt_rateest *est)
+ 	hlist_add_head(&est->list, &rateest_hash[h]);
+ }
+ 
+-struct xt_rateest *xt_rateest_lookup(const char *name)
++static struct xt_rateest *__xt_rateest_lookup(const char *name)
+ {
+ 	struct xt_rateest *est;
+ 	unsigned int h;
+ 
+ 	h = xt_rateest_hash(name);
+-	mutex_lock(&xt_rateest_mutex);
+ 	hlist_for_each_entry(est, &rateest_hash[h], list) {
+ 		if (strcmp(est->name, name) == 0) {
+ 			est->refcnt++;
+-			mutex_unlock(&xt_rateest_mutex);
+ 			return est;
+ 		}
+ 	}
+-	mutex_unlock(&xt_rateest_mutex);
++
+ 	return NULL;
+ }
++
++struct xt_rateest *xt_rateest_lookup(const char *name)
++{
++	struct xt_rateest *est;
++
++	mutex_lock(&xt_rateest_mutex);
++	est = __xt_rateest_lookup(name);
++	mutex_unlock(&xt_rateest_mutex);
++	return est;
++}
+ EXPORT_SYMBOL_GPL(xt_rateest_lookup);
+ 
+ void xt_rateest_put(struct xt_rateest *est)
+@@ -104,8 +112,10 @@ static int xt_rateest_tg_checkentry(const struct xt_tgchk_param *par)
+ 		rnd_inited = true;
+ 	}
+ 
+-	est = xt_rateest_lookup(info->name);
++	mutex_lock(&xt_rateest_mutex);
++	est = __xt_rateest_lookup(info->name);
+ 	if (est) {
++		mutex_unlock(&xt_rateest_mutex);
+ 		/*
+ 		 * If estimator parameters are specified, they must match the
+ 		 * existing estimator.
+@@ -143,11 +153,13 @@ static int xt_rateest_tg_checkentry(const struct xt_tgchk_param *par)
+ 
+ 	info->est = est;
+ 	xt_rateest_hash_insert(est);
++	mutex_unlock(&xt_rateest_mutex);
+ 	return 0;
+ 
+ err2:
+ 	kfree(est);
+ err1:
++	mutex_unlock(&xt_rateest_mutex);
+ 	return ret;
+ }
+ 
+diff --git a/net/sched/sch_choke.c b/net/sched/sch_choke.c
+index 0a08c860eee4..e8dcf94a23c8 100644
+--- a/net/sched/sch_choke.c
++++ b/net/sched/sch_choke.c
+@@ -438,6 +438,9 @@ static int choke_change(struct Qdisc *sch, struct nlattr *opt)
+ 
+ 	ctl = nla_data(tb[TCA_CHOKE_PARMS]);
+ 
++	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
++		return -EINVAL;
++
+ 	if (ctl->limit > CHOKE_MAX_QUEUE)
+ 		return -EINVAL;
+ 
+diff --git a/net/sched/sch_gred.c b/net/sched/sch_gred.c
+index 80105109f756..f9e8deeeac96 100644
+--- a/net/sched/sch_gred.c
++++ b/net/sched/sch_gred.c
+@@ -389,6 +389,9 @@ static inline int gred_change_vq(struct Qdisc *sch, int dp,
+ 	struct gred_sched *table = qdisc_priv(sch);
+ 	struct gred_sched_data *q = table->tab[dp];
+ 
++	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
++		return -EINVAL;
++
+ 	if (!q) {
+ 		table->tab[dp] = q = *prealloc;
+ 		*prealloc = NULL;
+diff --git a/net/sched/sch_red.c b/net/sched/sch_red.c
+index 8c0508c0e287..0505b8408c8b 100644
+--- a/net/sched/sch_red.c
++++ b/net/sched/sch_red.c
+@@ -199,6 +199,8 @@ static int red_change(struct Qdisc *sch, struct nlattr *opt)
+ 	max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
+ 
+ 	ctl = nla_data(tb[TCA_RED_PARMS]);
++	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
++		return -EINVAL;
+ 
+ 	if (ctl->limit > 0) {
+ 		child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit);
+diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
+index 3f2c3eed04da..8b8c084b32cd 100644
+--- a/net/sched/sch_sfq.c
++++ b/net/sched/sch_sfq.c
+@@ -633,6 +633,9 @@ static int sfq_change(struct Qdisc *sch, struct nlattr *opt)
+ 	if (ctl->divisor &&
+ 	    (!is_power_of_2(ctl->divisor) || ctl->divisor > 65536))
+ 		return -EINVAL;
++	if (ctl_v1 && !red_check_params(ctl_v1->qth_min, ctl_v1->qth_max,
++					ctl_v1->Wlog))
++		return -EINVAL;
+ 	if (ctl_v1 && ctl_v1->qth_min) {
+ 		p = kmalloc(sizeof(*p), GFP_KERNEL);
+ 		if (!p)
+diff --git a/net/wireless/core.c b/net/wireless/core.c
+index 8f0bac7e03c4..eeaf83acba1b 100644
+--- a/net/wireless/core.c
++++ b/net/wireless/core.c
+@@ -390,6 +390,8 @@ struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
+ 		if (rv)
+ 			goto use_default_name;
+ 	} else {
++		int rv;
++
+ use_default_name:
+ 		/* NOTE:  This is *probably* safe w/out holding rtnl because of
+ 		 * the restrictions on phy names.  Probably this call could
+@@ -397,7 +399,11 @@ use_default_name:
+ 		 * phyX.  But, might should add some locking and check return
+ 		 * value, and use a different name if this one exists?
+ 		 */
+-		dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
++		rv = dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
++		if (rv < 0) {
++			kfree(rdev);
++			return NULL;
++		}
+ 	}
+ 
+ 	INIT_LIST_HEAD(&rdev->wdev_list);
+diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
+index 7950506395a8..b0b58d1565c2 100644
+--- a/net/wireless/nl80211.c
++++ b/net/wireless/nl80211.c
+@@ -16,6 +16,7 @@
+ #include <linux/nl80211.h>
+ #include <linux/rtnetlink.h>
+ #include <linux/netlink.h>
++#include <linux/nospec.h>
+ #include <linux/etherdevice.h>
+ #include <net/net_namespace.h>
+ #include <net/genetlink.h>
+@@ -1879,20 +1880,22 @@ static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
+ static int parse_txq_params(struct nlattr *tb[],
+ 			    struct ieee80211_txq_params *txq_params)
+ {
++	u8 ac;
++
+ 	if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
+ 	    !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
+ 	    !tb[NL80211_TXQ_ATTR_AIFS])
+ 		return -EINVAL;
+ 
+-	txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
++	ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
+ 	txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
+ 	txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
+ 	txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
+ 	txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
+ 
+-	if (txq_params->ac >= NL80211_NUM_ACS)
++	if (ac >= NL80211_NUM_ACS)
+ 		return -EINVAL;
+-
++	txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
+ 	return 0;
+ }
+ 
+diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
+index 22df3b51e905..4b09a9eaa35f 100644
+--- a/net/xfrm/xfrm_policy.c
++++ b/net/xfrm/xfrm_policy.c
+@@ -1225,9 +1225,15 @@ static struct xfrm_policy *xfrm_sk_policy_lookup(const struct sock *sk, int dir,
+ 	read_lock_bh(&net->xfrm.xfrm_policy_lock);
+ 	pol = rcu_dereference(sk->sk_policy[dir]);
+ 	if (pol != NULL) {
+-		bool match = xfrm_selector_match(&pol->selector, fl, family);
++		bool match;
+ 		int err = 0;
+ 
++		if (pol->family != family) {
++			pol = NULL;
++			goto out;
++		}
++
++		match = xfrm_selector_match(&pol->selector, fl, family);
+ 		if (match) {
+ 			if ((sk->sk_mark & pol->mark.m) != pol->mark.v) {
+ 				pol = NULL;
+diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
+index 76944a4839a5..fa856a07e40b 100644
+--- a/net/xfrm/xfrm_user.c
++++ b/net/xfrm/xfrm_user.c
+@@ -1376,11 +1376,14 @@ static void copy_templates(struct xfrm_policy *xp, struct xfrm_user_tmpl *ut,
+ 
+ static int validate_tmpl(int nr, struct xfrm_user_tmpl *ut, u16 family)
+ {
++	u16 prev_family;
+ 	int i;
+ 
+ 	if (nr > XFRM_MAX_DEPTH)
+ 		return -EINVAL;
+ 
++	prev_family = family;
++
+ 	for (i = 0; i < nr; i++) {
+ 		/* We never validated the ut->family value, so many
+ 		 * applications simply leave it at zero.  The check was
+@@ -1392,6 +1395,12 @@ static int validate_tmpl(int nr, struct xfrm_user_tmpl *ut, u16 family)
+ 		if (!ut[i].family)
+ 			ut[i].family = family;
+ 
++		if ((ut[i].mode == XFRM_MODE_TRANSPORT) &&
++		    (ut[i].family != prev_family))
++			return -EINVAL;
++
++		prev_family = ut[i].family;
++
+ 		switch (ut[i].family) {
+ 		case AF_INET:
+ 			break;
+@@ -1402,6 +1411,21 @@ static int validate_tmpl(int nr, struct xfrm_user_tmpl *ut, u16 family)
+ 		default:
+ 			return -EINVAL;
+ 		}
++
++		switch (ut[i].id.proto) {
++		case IPPROTO_AH:
++		case IPPROTO_ESP:
++		case IPPROTO_COMP:
++#if IS_ENABLED(CONFIG_IPV6)
++		case IPPROTO_ROUTING:
++		case IPPROTO_DSTOPTS:
++#endif
++		case IPSEC_PROTO_ANY:
++			break;
++		default:
++			return -EINVAL;
++		}
++
+ 	}
+ 
+ 	return 0;
+diff --git a/scripts/genksyms/parse.tab.c_shipped b/scripts/genksyms/parse.tab.c_shipped
+index 99950b5afb0d..632f6d66982d 100644
+--- a/scripts/genksyms/parse.tab.c_shipped
++++ b/scripts/genksyms/parse.tab.c_shipped
+@@ -1,19 +1,19 @@
+-/* A Bison parser, made by GNU Bison 2.7.  */
++/* A Bison parser, made by GNU Bison 3.0.4.  */
+ 
+ /* Bison implementation for Yacc-like parsers in C
+-   
+-      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
+-   
++
++   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
++
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+-   
++
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+-   
++
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+ 
+@@ -26,7 +26,7 @@
+    special exception, which will cause the skeleton and the resulting
+    Bison output files to be licensed under the GNU General Public
+    License without this special exception.
+-   
++
+    This special exception was added by the Free Software Foundation in
+    version 2.2 of Bison.  */
+ 
+@@ -44,7 +44,7 @@
+ #define YYBISON 1
+ 
+ /* Bison version.  */
+-#define YYBISON_VERSION "2.7"
++#define YYBISON_VERSION "3.0.4"
+ 
+ /* Skeleton name.  */
+ #define YYSKELETON_NAME "yacc.c"
+@@ -62,7 +62,7 @@
+ 
+ 
+ /* Copy the first part of user declarations.  */
+-
++#line 24 "parse.y" /* yacc.c:339  */
+ 
+ 
+ #include <assert.h>
+@@ -113,13 +113,13 @@ static void record_compound(struct string_list **keyw,
+ }
+ 
+ 
++#line 117 "parse.tab.c" /* yacc.c:339  */
+ 
+-
+-# ifndef YY_NULL
++# ifndef YY_NULLPTR
+ #  if defined __cplusplus && 201103L <= __cplusplus
+-#   define YY_NULL nullptr
++#   define YY_NULLPTR nullptr
+ #  else
+-#   define YY_NULL 0
++#   define YY_NULLPTR 0
+ #  endif
+ # endif
+ 
+@@ -131,8 +131,11 @@ static void record_compound(struct string_list **keyw,
+ # define YYERROR_VERBOSE 0
+ #endif
+ 
+-
+-/* Enabling traces.  */
++/* In a future release of Bison, this section will be replaced
++   by #include "parse.tab.h".  */
++#ifndef YY_YY_PARSE_TAB_H_INCLUDED
++# define YY_YY_PARSE_TAB_H_INCLUDED
++/* Debug traces.  */
+ #ifndef YYDEBUG
+ # define YYDEBUG 1
+ #endif
+@@ -140,86 +143,73 @@ static void record_compound(struct string_list **keyw,
+ extern int yydebug;
+ #endif
+ 
+-/* Tokens.  */
++/* Token type.  */
+ #ifndef YYTOKENTYPE
+ # define YYTOKENTYPE
+-   /* Put the tokens into the symbol table, so that GDB and other debuggers
+-      know about them.  */
+-   enum yytokentype {
+-     ASM_KEYW = 258,
+-     ATTRIBUTE_KEYW = 259,
+-     AUTO_KEYW = 260,
+-     BOOL_KEYW = 261,
+-     CHAR_KEYW = 262,
+-     CONST_KEYW = 263,
+-     DOUBLE_KEYW = 264,
+-     ENUM_KEYW = 265,
+-     EXTERN_KEYW = 266,
+-     EXTENSION_KEYW = 267,
+-     FLOAT_KEYW = 268,
+-     INLINE_KEYW = 269,
+-     INT_KEYW = 270,
+-     LONG_KEYW = 271,
+-     REGISTER_KEYW = 272,
+-     RESTRICT_KEYW = 273,
+-     SHORT_KEYW = 274,
+-     SIGNED_KEYW = 275,
+-     STATIC_KEYW = 276,
+-     STRUCT_KEYW = 277,
+-     TYPEDEF_KEYW = 278,
+-     UNION_KEYW = 279,
+-     UNSIGNED_KEYW = 280,
+-     VOID_KEYW = 281,
+-     VOLATILE_KEYW = 282,
+-     TYPEOF_KEYW = 283,
+-     EXPORT_SYMBOL_KEYW = 284,
+-     ASM_PHRASE = 285,
+-     ATTRIBUTE_PHRASE = 286,
+-     TYPEOF_PHRASE = 287,
+-     BRACE_PHRASE = 288,
+-     BRACKET_PHRASE = 289,
+-     EXPRESSION_PHRASE = 290,
+-     CHAR = 291,
+-     DOTS = 292,
+-     IDENT = 293,
+-     INT = 294,
+-     REAL = 295,
+-     STRING = 296,
+-     TYPE = 297,
+-     OTHER = 298,
+-     FILENAME = 299
+-   };
++  enum yytokentype
++  {
++    ASM_KEYW = 258,
++    ATTRIBUTE_KEYW = 259,
++    AUTO_KEYW = 260,
++    BOOL_KEYW = 261,
++    CHAR_KEYW = 262,
++    CONST_KEYW = 263,
++    DOUBLE_KEYW = 264,
++    ENUM_KEYW = 265,
++    EXTERN_KEYW = 266,
++    EXTENSION_KEYW = 267,
++    FLOAT_KEYW = 268,
++    INLINE_KEYW = 269,
++    INT_KEYW = 270,
++    LONG_KEYW = 271,
++    REGISTER_KEYW = 272,
++    RESTRICT_KEYW = 273,
++    SHORT_KEYW = 274,
++    SIGNED_KEYW = 275,
++    STATIC_KEYW = 276,
++    STRUCT_KEYW = 277,
++    TYPEDEF_KEYW = 278,
++    UNION_KEYW = 279,
++    UNSIGNED_KEYW = 280,
++    VOID_KEYW = 281,
++    VOLATILE_KEYW = 282,
++    TYPEOF_KEYW = 283,
++    EXPORT_SYMBOL_KEYW = 284,
++    ASM_PHRASE = 285,
++    ATTRIBUTE_PHRASE = 286,
++    TYPEOF_PHRASE = 287,
++    BRACE_PHRASE = 288,
++    BRACKET_PHRASE = 289,
++    EXPRESSION_PHRASE = 290,
++    CHAR = 291,
++    DOTS = 292,
++    IDENT = 293,
++    INT = 294,
++    REAL = 295,
++    STRING = 296,
++    TYPE = 297,
++    OTHER = 298,
++    FILENAME = 299
++  };
+ #endif
+ 
+-
++/* Value type.  */
+ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+ typedef int YYSTYPE;
+ # define YYSTYPE_IS_TRIVIAL 1
+-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+ # define YYSTYPE_IS_DECLARED 1
+ #endif
+ 
++
+ extern YYSTYPE yylval;
+ 
+-#ifdef YYPARSE_PARAM
+-#if defined __STDC__ || defined __cplusplus
+-int yyparse (void *YYPARSE_PARAM);
+-#else
+-int yyparse ();
+-#endif
+-#else /* ! YYPARSE_PARAM */
+-#if defined __STDC__ || defined __cplusplus
+ int yyparse (void);
+-#else
+-int yyparse ();
+-#endif
+-#endif /* ! YYPARSE_PARAM */
+-
+ 
++#endif /* !YY_YY_PARSE_TAB_H_INCLUDED  */
+ 
+ /* Copy the second part of user declarations.  */
+ 
+-
++#line 213 "parse.tab.c" /* yacc.c:358  */
+ 
+ #ifdef short
+ # undef short
+@@ -233,11 +223,8 @@ typedef unsigned char yytype_uint8;
+ 
+ #ifdef YYTYPE_INT8
+ typedef YYTYPE_INT8 yytype_int8;
+-#elif (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+-typedef signed char yytype_int8;
+ #else
+-typedef short int yytype_int8;
++typedef signed char yytype_int8;
+ #endif
+ 
+ #ifdef YYTYPE_UINT16
+@@ -257,8 +244,7 @@ typedef short int yytype_int16;
+ #  define YYSIZE_T __SIZE_TYPE__
+ # elif defined size_t
+ #  define YYSIZE_T size_t
+-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++# elif ! defined YYSIZE_T
+ #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+ #  define YYSIZE_T size_t
+ # else
+@@ -280,6 +266,33 @@ typedef short int yytype_int16;
+ # endif
+ #endif
+ 
++#ifndef YY_ATTRIBUTE
++# if (defined __GNUC__                                               \
++      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
++     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
++#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
++# else
++#  define YY_ATTRIBUTE(Spec) /* empty */
++# endif
++#endif
++
++#ifndef YY_ATTRIBUTE_PURE
++# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
++#endif
++
++#ifndef YY_ATTRIBUTE_UNUSED
++# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
++#endif
++
++#if !defined _Noreturn \
++     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
++# if defined _MSC_VER && 1200 <= _MSC_VER
++#  define _Noreturn __declspec (noreturn)
++# else
++#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
++# endif
++#endif
++
+ /* Suppress unused-variable warnings by "using" E.  */
+ #if ! defined lint || defined __GNUC__
+ # define YYUSE(E) ((void) (E))
+@@ -287,24 +300,26 @@ typedef short int yytype_int16;
+ # define YYUSE(E) /* empty */
+ #endif
+ 
+-/* Identity function, used to suppress warnings about constant conditions.  */
+-#ifndef lint
+-# define YYID(N) (N)
+-#else
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+-static int
+-YYID (int yyi)
++#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
++/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
++# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
++    _Pragma ("GCC diagnostic push") \
++    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
++    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
++# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
++    _Pragma ("GCC diagnostic pop")
+ #else
+-static int
+-YYID (yyi)
+-    int yyi;
++# define YY_INITIAL_VALUE(Value) Value
+ #endif
+-{
+-  return yyi;
+-}
++#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++# define YY_IGNORE_MAYBE_UNINITIALIZED_END
++#endif
++#ifndef YY_INITIAL_VALUE
++# define YY_INITIAL_VALUE(Value) /* Nothing. */
+ #endif
+ 
++
+ #if ! defined yyoverflow || YYERROR_VERBOSE
+ 
+ /* The parser invokes alloca or malloc; define the necessary symbols.  */
+@@ -322,8 +337,7 @@ YYID (yyi)
+ #    define alloca _alloca
+ #   else
+ #    define YYSTACK_ALLOC alloca
+-#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+ #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+ #     ifndef EXIT_SUCCESS
+@@ -335,8 +349,8 @@ YYID (yyi)
+ # endif
+ 
+ # ifdef YYSTACK_ALLOC
+-   /* Pacify GCC's `empty if-body' warning.  */
+-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
++   /* Pacify GCC's 'empty if-body' warning.  */
++#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+ #  ifndef YYSTACK_ALLOC_MAXIMUM
+     /* The OS might guarantee only one guard page at the bottom of the stack,
+        and a page size can be as small as 4096 bytes.  So we cannot safely
+@@ -352,7 +366,7 @@ YYID (yyi)
+ #  endif
+ #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+        && ! ((defined YYMALLOC || defined malloc) \
+-	     && (defined YYFREE || defined free)))
++             && (defined YYFREE || defined free)))
+ #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ #   ifndef EXIT_SUCCESS
+ #    define EXIT_SUCCESS 0
+@@ -360,15 +374,13 @@ YYID (yyi)
+ #  endif
+ #  ifndef YYMALLOC
+ #   define YYMALLOC malloc
+-#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++#   if ! defined malloc && ! defined EXIT_SUCCESS
+ void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+ #   endif
+ #  endif
+ #  ifndef YYFREE
+ #   define YYFREE free
+-#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++#   if ! defined free && ! defined EXIT_SUCCESS
+ void free (void *); /* INFRINGES ON USER NAME SPACE */
+ #   endif
+ #  endif
+@@ -378,7 +390,7 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */
+ 
+ #if (! defined yyoverflow \
+      && (! defined __cplusplus \
+-	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
++         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+ 
+ /* A type that is properly aligned for any stack member.  */
+ union yyalloc
+@@ -403,16 +415,16 @@ union yyalloc
+    elements in the stack, and YYPTR gives the new location of the
+    stack.  Advance YYPTR to a properly aligned location for the next
+    stack.  */
+-# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
+-    do									\
+-      {									\
+-	YYSIZE_T yynewbytes;						\
+-	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
+-	Stack = &yyptr->Stack_alloc;					\
+-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+-	yyptr += yynewbytes / sizeof (*yyptr);				\
+-      }									\
+-    while (YYID (0))
++# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
++    do                                                                  \
++      {                                                                 \
++        YYSIZE_T yynewbytes;                                            \
++        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
++        Stack = &yyptr->Stack_alloc;                                    \
++        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
++        yyptr += yynewbytes / sizeof (*yyptr);                          \
++      }                                                                 \
++    while (0)
+ 
+ #endif
+ 
+@@ -431,7 +443,7 @@ union yyalloc
+           for (yyi = 0; yyi < (Count); yyi++)   \
+             (Dst)[yyi] = (Src)[yyi];            \
+         }                                       \
+-      while (YYID (0))
++      while (0)
+ #  endif
+ # endif
+ #endif /* !YYCOPY_NEEDED */
+@@ -439,25 +451,27 @@ union yyalloc
+ /* YYFINAL -- State number of the termination state.  */
+ #define YYFINAL  4
+ /* YYLAST -- Last index in YYTABLE.  */
+-#define YYLAST   515
++#define YYLAST   513
+ 
+ /* YYNTOKENS -- Number of terminals.  */
+ #define YYNTOKENS  54
+ /* YYNNTS -- Number of nonterminals.  */
+ #define YYNNTS  49
+ /* YYNRULES -- Number of rules.  */
+-#define YYNRULES  133
+-/* YYNRULES -- Number of states.  */
+-#define YYNSTATES  188
++#define YYNRULES  132
++/* YYNSTATES -- Number of states.  */
++#define YYNSTATES  186
+ 
+-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
++/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
++   by yylex, with out-of-bounds checking.  */
+ #define YYUNDEFTOK  2
+ #define YYMAXUTOK   299
+ 
+-#define YYTRANSLATE(YYX)						\
++#define YYTRANSLATE(YYX)                                                \
+   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+ 
+-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
++/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
++   as returned by yylex, without out-of-bounds checking.  */
+ static const yytype_uint8 yytranslate[] =
+ {
+        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+@@ -493,69 +507,7 @@ static const yytype_uint8 yytranslate[] =
+ };
+ 
+ #if YYDEBUG
+-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+-   YYRHS.  */
+-static const yytype_uint16 yyprhs[] =
+-{
+-       0,     0,     3,     5,     8,     9,    12,    13,    18,    19,
+-      23,    25,    27,    29,    31,    34,    37,    41,    42,    44,
+-      46,    50,    55,    56,    58,    60,    63,    65,    67,    69,
+-      71,    73,    75,    77,    79,    81,    86,    88,    91,    94,
+-      97,   101,   105,   109,   112,   115,   118,   120,   122,   124,
+-     126,   128,   130,   132,   134,   136,   138,   140,   143,   144,
+-     146,   148,   151,   153,   155,   157,   159,   162,   164,   166,
+-     168,   173,   178,   181,   185,   189,   192,   194,   196,   198,
+-     203,   208,   211,   215,   219,   222,   224,   228,   229,   231,
+-     233,   237,   240,   243,   245,   246,   248,   250,   255,   260,
+-     263,   267,   271,   275,   276,   278,   281,   285,   289,   290,
+-     292,   294,   297,   301,   304,   305,   307,   309,   313,   316,
+-     319,   321,   324,   325,   328,   332,   337,   339,   343,   345,
+-     349,   352,   353,   355
+-};
+-
+-/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+-static const yytype_int8 yyrhs[] =
+-{
+-      55,     0,    -1,    56,    -1,    55,    56,    -1,    -1,    57,
+-      58,    -1,    -1,    12,    23,    59,    61,    -1,    -1,    23,
+-      60,    61,    -1,    61,    -1,    85,    -1,   100,    -1,   102,
+-      -1,     1,    45,    -1,     1,    46,    -1,    65,    62,    45,
+-      -1,    -1,    63,    -1,    64,    -1,    63,    47,    64,    -1,
+-      75,   101,    96,    86,    -1,    -1,    66,    -1,    67,    -1,
+-      66,    67,    -1,    68,    -1,    69,    -1,     5,    -1,    17,
+-      -1,    21,    -1,    11,    -1,    14,    -1,    70,    -1,    74,
+-      -1,    28,    48,    82,    49,    -1,    32,    -1,    22,    38,
+-      -1,    24,    38,    -1,    10,    38,    -1,    22,    38,    88,
+-      -1,    24,    38,    88,    -1,    10,    38,    97,    -1,    10,
+-      97,    -1,    22,    88,    -1,    24,    88,    -1,     7,    -1,
+-      19,    -1,    15,    -1,    16,    -1,    20,    -1,    25,    -1,
+-      13,    -1,     9,    -1,    26,    -1,     6,    -1,    42,    -1,
+-      50,    72,    -1,    -1,    73,    -1,    74,    -1,    73,    74,
+-      -1,     8,    -1,    27,    -1,    31,    -1,    18,    -1,    71,
+-      75,    -1,    76,    -1,    38,    -1,    42,    -1,    76,    48,
+-      79,    49,    -1,    76,    48,     1,    49,    -1,    76,    34,
+-      -1,    48,    75,    49,    -1,    48,     1,    49,    -1,    71,
+-      77,    -1,    78,    -1,    38,    -1,    42,    -1,    78,    48,
+-      79,    49,    -1,    78,    48,     1,    49,    -1,    78,    34,
+-      -1,    48,    77,    49,    -1,    48,     1,    49,    -1,    80,
+-      37,    -1,    80,    -1,    81,    47,    37,    -1,    -1,    81,
+-      -1,    82,    -1,    81,    47,    82,    -1,    66,    83,    -1,
+-      71,    83,    -1,    84,    -1,    -1,    38,    -1,    42,    -1,
+-      84,    48,    79,    49,    -1,    84,    48,     1,    49,    -1,
+-      84,    34,    -1,    48,    83,    49,    -1,    48,     1,    49,
+-      -1,    65,    75,    33,    -1,    -1,    87,    -1,    51,    35,
+-      -1,    52,    89,    46,    -1,    52,     1,    46,    -1,    -1,
+-      90,    -1,    91,    -1,    90,    91,    -1,    65,    92,    45,
+-      -1,     1,    45,    -1,    -1,    93,    -1,    94,    -1,    93,
+-      47,    94,    -1,    77,    96,    -1,    38,    95,    -1,    95,
+-      -1,    53,    35,    -1,    -1,    96,    31,    -1,    52,    98,
+-      46,    -1,    52,    98,    47,    46,    -1,    99,    -1,    98,
+-      47,    99,    -1,    38,    -1,    38,    51,    35,    -1,    30,
+-      45,    -1,    -1,    30,    -1,    29,    48,    38,    49,    45,
+-      -1
+-};
+-
+-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
++  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+ static const yytype_uint16 yyrline[] =
+ {
+        0,   124,   124,   125,   129,   129,   135,   135,   137,   137,
+@@ -565,13 +517,13 @@ static const yytype_uint16 yyrline[] =
+      237,   239,   241,   246,   249,   250,   254,   255,   256,   257,
+      258,   259,   260,   261,   262,   263,   264,   268,   273,   274,
+      278,   279,   283,   283,   283,   284,   292,   293,   297,   306,
+-     315,   317,   319,   321,   323,   330,   331,   335,   336,   337,
+-     339,   341,   343,   345,   350,   351,   352,   356,   357,   361,
+-     362,   367,   372,   374,   378,   379,   387,   391,   393,   395,
+-     397,   399,   404,   413,   414,   419,   424,   425,   429,   430,
+-     434,   435,   439,   441,   446,   447,   451,   452,   456,   457,
+-     458,   462,   466,   467,   471,   472,   476,   477,   480,   485,
+-     493,   497,   498,   502
++     315,   317,   319,   321,   328,   329,   333,   334,   335,   337,
++     339,   341,   343,   348,   349,   350,   354,   355,   359,   360,
++     365,   370,   372,   376,   377,   385,   389,   391,   393,   395,
++     397,   402,   411,   412,   417,   422,   423,   427,   428,   432,
++     433,   437,   439,   444,   445,   449,   450,   454,   455,   456,
++     460,   464,   465,   469,   470,   474,   475,   478,   483,   491,
++     495,   496,   500
+ };
+ #endif
+ 
+@@ -606,13 +558,13 @@ static const char *const yytname[] =
+   "member_declarator_list_opt", "member_declarator_list",
+   "member_declarator", "member_bitfield_declarator", "attribute_opt",
+   "enum_body", "enumerator_list", "enumerator", "asm_definition",
+-  "asm_phrase_opt", "export_definition", YY_NULL
++  "asm_phrase_opt", "export_definition", YY_NULLPTR
+ };
+ #endif
+ 
+ # ifdef YYPRINT
+-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+-   token YYLEX-NUM.  */
++/* YYTOKNUM[NUM] -- (External) token number corresponding to the
++   (internal) symbol number NUM (which must be that of a token).  */
+ static const yytype_uint16 yytoknum[] =
+ {
+        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+@@ -624,47 +576,44 @@ static const yytype_uint16 yytoknum[] =
+ };
+ # endif
+ 
+-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+-static const yytype_uint8 yyr1[] =
+-{
+-       0,    54,    55,    55,    57,    56,    59,    58,    60,    58,
+-      58,    58,    58,    58,    58,    58,    61,    62,    62,    63,
+-      63,    64,    65,    65,    66,    66,    67,    67,    68,    68,
+-      68,    68,    68,    69,    69,    69,    69,    69,    69,    69,
+-      69,    69,    69,    69,    69,    69,    70,    70,    70,    70,
+-      70,    70,    70,    70,    70,    70,    70,    71,    72,    72,
+-      73,    73,    74,    74,    74,    74,    75,    75,    76,    76,
+-      76,    76,    76,    76,    76,    77,    77,    78,    78,    78,
+-      78,    78,    78,    78,    79,    79,    79,    80,    80,    81,
+-      81,    82,    83,    83,    84,    84,    84,    84,    84,    84,
+-      84,    84,    85,    86,    86,    87,    88,    88,    89,    89,
+-      90,    90,    91,    91,    92,    92,    93,    93,    94,    94,
+-      94,    95,    96,    96,    97,    97,    98,    98,    99,    99,
+-     100,   101,   101,   102
+-};
++#define YYPACT_NINF -135
+ 
+-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+-static const yytype_uint8 yyr2[] =
++#define yypact_value_is_default(Yystate) \
++  (!!((Yystate) == (-135)))
++
++#define YYTABLE_NINF -109
++
++#define yytable_value_is_error(Yytable_value) \
++  0
++
++  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
++     STATE-NUM.  */
++static const yytype_int16 yypact[] =
+ {
+-       0,     2,     1,     2,     0,     2,     0,     4,     0,     3,
+-       1,     1,     1,     1,     2,     2,     3,     0,     1,     1,
+-       3,     4,     0,     1,     1,     2,     1,     1,     1,     1,
+-       1,     1,     1,     1,     1,     4,     1,     2,     2,     2,
+-       3,     3,     3,     2,     2,     2,     1,     1,     1,     1,
+-       1,     1,     1,     1,     1,     1,     1,     2,     0,     1,
+-       1,     2,     1,     1,     1,     1,     2,     1,     1,     1,
+-       4,     4,     2,     3,     3,     2,     1,     1,     1,     4,
+-       4,     2,     3,     3,     2,     1,     3,     0,     1,     1,
+-       3,     2,     2,     1,     0,     1,     1,     4,     4,     2,
+-       3,     3,     3,     0,     1,     2,     3,     3,     0,     1,
+-       1,     2,     3,     2,     0,     1,     1,     3,     2,     2,
+-       1,     2,     0,     2,     3,     4,     1,     3,     1,     3,
+-       2,     0,     1,     5
++    -135,    38,  -135,   206,  -135,  -135,    22,  -135,  -135,  -135,
++    -135,  -135,   -24,  -135,    20,  -135,  -135,  -135,  -135,  -135,
++    -135,  -135,  -135,  -135,   -23,  -135,     6,  -135,  -135,  -135,
++      -2,    15,    24,  -135,  -135,  -135,  -135,  -135,    41,   471,
++    -135,  -135,  -135,  -135,  -135,  -135,  -135,  -135,  -135,  -135,
++      13,    36,  -135,  -135,    35,   106,  -135,   471,    35,  -135,
++     471,    44,  -135,  -135,  -135,    41,    39,    45,    48,  -135,
++      41,   -10,    25,  -135,  -135,    47,    34,  -135,   471,  -135,
++      26,   -26,    53,   156,  -135,  -135,    41,  -135,   387,    52,
++      57,    59,  -135,    39,  -135,  -135,    41,  -135,  -135,  -135,
++    -135,  -135,   252,    67,  -135,   -21,  -135,  -135,  -135,    51,
++    -135,    12,    83,    46,  -135,    27,    84,    88,  -135,  -135,
++    -135,    91,  -135,   109,  -135,  -135,     3,    55,  -135,    30,
++    -135,    95,  -135,  -135,  -135,   -20,    92,    93,   108,    96,
++    -135,  -135,  -135,  -135,  -135,    97,  -135,    98,  -135,  -135,
++     118,  -135,   297,  -135,   -26,   101,  -135,   104,  -135,  -135,
++     342,  -135,  -135,   120,  -135,  -135,  -135,  -135,  -135,   433,
++    -135,  -135,   111,   119,  -135,  -135,  -135,   130,   136,  -135,
++    -135,  -135,  -135,  -135,  -135,  -135
+ };
+ 
+-/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
+-   Performed when YYTABLE doesn't specify something else to do.  Zero
+-   means the default is an error.  */
++  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
++     Performed when YYTABLE does not specify something else to do.  Zero
++     means the default is an error.  */
+ static const yytype_uint8 yydefact[] =
+ {
+        4,     4,     2,     0,     1,     3,     0,    28,    55,    46,
+@@ -673,191 +622,158 @@ static const yytype_uint8 yydefact[] =
+        0,     0,     0,    64,    36,    56,     5,    10,    17,    23,
+       24,    26,    27,    33,    34,    11,    12,    13,    14,    15,
+       39,     0,    43,     6,    37,     0,    44,    22,    38,    45,
+-       0,     0,   130,    68,    69,     0,    58,     0,    18,    19,
+-       0,   131,    67,    25,    42,   128,     0,   126,    22,    40,
+-       0,   114,     0,     0,   110,     9,    17,    41,    94,     0,
+-       0,     0,     0,    57,    59,    60,    16,     0,    66,   132,
+-     102,   122,    72,     0,     0,   124,     0,     7,   113,   107,
+-      77,    78,     0,     0,     0,   122,    76,     0,   115,   116,
+-     120,   106,     0,   111,   131,    95,    56,     0,    94,    91,
+-      93,    35,     0,    74,    73,    61,    20,   103,     0,     0,
+-      85,    88,    89,   129,   125,   127,   119,     0,    77,     0,
+-     121,    75,   118,    81,     0,   112,     0,     0,    96,     0,
+-      92,    99,     0,   133,   123,     0,    21,   104,    71,    70,
+-      84,     0,    83,    82,     0,     0,   117,   101,   100,     0,
+-       0,   105,    86,    90,    80,    79,    98,    97
+-};
+-
+-/* YYDEFGOTO[NTERM-NUM].  */
+-static const yytype_int16 yydefgoto[] =
+-{
+-      -1,     1,     2,     3,    36,    78,    57,    37,    67,    68,
+-      69,    81,    39,    40,    41,    42,    43,    70,    93,    94,
+-      44,   124,    72,   115,   116,   139,   140,   141,   142,   129,
+-     130,    45,   166,   167,    56,    82,    83,    84,   117,   118,
+-     119,   120,   137,    52,    76,    77,    46,   101,    47
++       0,     0,   129,    68,    69,     0,    58,     0,    18,    19,
++       0,   130,    67,    25,    42,   127,     0,   125,    22,    40,
++       0,   113,     0,     0,   109,     9,    17,    41,    93,     0,
++       0,     0,    57,    59,    60,    16,     0,    66,   131,   101,
++     121,    72,     0,     0,   123,     0,     7,   112,   106,    76,
++      77,     0,     0,     0,   121,    75,     0,   114,   115,   119,
++     105,     0,   110,   130,    94,    56,     0,    93,    90,    92,
++      35,     0,    73,    61,    20,   102,     0,     0,    84,    87,
++      88,   128,   124,   126,   118,     0,    76,     0,   120,    74,
++     117,    80,     0,   111,     0,     0,    95,     0,    91,    98,
++       0,   132,   122,     0,    21,   103,    71,    70,    83,     0,
++      82,    81,     0,     0,   116,   100,    99,     0,     0,   104,
++      85,    89,    79,    78,    97,    96
+ };
+ 
+-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+-   STATE-NUM.  */
+-#define YYPACT_NINF -92
+-static const yytype_int16 yypact[] =
++  /* YYPGOTO[NTERM-NUM].  */
++static const yytype_int16 yypgoto[] =
+ {
+-     -92,    19,   -92,   208,   -92,   -92,    39,   -92,   -92,   -92,
+-     -92,   -92,   -27,   -92,    23,   -92,   -92,   -92,   -92,   -92,
+-     -92,   -92,   -92,   -92,   -22,   -92,     9,   -92,   -92,   -92,
+-      -6,    16,    25,   -92,   -92,   -92,   -92,   -92,    31,   473,
+-     -92,   -92,   -92,   -92,   -92,   -92,   -92,   -92,   -92,   -92,
+-      49,    37,   -92,   -92,    51,   108,   -92,   473,    51,   -92,
+-     473,    59,   -92,   -92,   -92,    12,    -3,    60,    57,   -92,
+-      31,    -7,    24,   -92,   -92,    55,    42,   -92,   473,   -92,
+-      46,   -21,    61,   158,   -92,   -92,    31,   -92,   389,    71,
+-      82,    88,    89,   -92,    -3,   -92,   -92,    31,   -92,   -92,
+-     -92,   -92,   -92,   254,    73,   -92,   -24,   -92,   -92,   -92,
+-      90,   -92,    17,    75,    45,   -92,    32,    96,    95,   -92,
+-     -92,   -92,    99,   -92,   115,   -92,   -92,     3,    48,   -92,
+-      34,   -92,   102,   -92,   -92,   -92,   -92,   -11,   100,   103,
+-     111,   104,   -92,   -92,   -92,   -92,   -92,   106,   -92,   113,
+-     -92,   -92,   126,   -92,   299,   -92,   -21,   121,   -92,   132,
+-     -92,   -92,   344,   -92,   -92,   125,   -92,   -92,   -92,   -92,
+-     -92,   435,   -92,   -92,   138,   139,   -92,   -92,   -92,   142,
+-     143,   -92,   -92,   -92,   -92,   -92,   -92,   -92
++    -135,  -135,   157,  -135,  -135,  -135,  -135,   -48,  -135,  -135,
++      90,    -1,   -60,   -33,  -135,  -135,  -135,   -78,  -135,  -135,
++     -61,   -31,  -135,   -92,  -135,  -134,  -135,  -135,   -59,   -41,
++    -135,  -135,  -135,  -135,   -18,  -135,  -135,   107,  -135,  -135,
++      37,    80,    78,   143,  -135,    94,  -135,  -135,  -135
+ };
+ 
+-/* YYPGOTO[NTERM-NUM].  */
+-static const yytype_int16 yypgoto[] =
++  /* YYDEFGOTO[NTERM-NUM].  */
++static const yytype_int16 yydefgoto[] =
+ {
+-     -92,   -92,   192,   -92,   -92,   -92,   -92,   -47,   -92,   -92,
+-      97,     0,   -60,   -32,   -92,   -92,   -92,   -79,   -92,   -92,
+-     -58,   -26,   -92,   -38,   -92,   -91,   -92,   -92,   -59,   -28,
+-     -92,   -92,   -92,   -92,   -20,   -92,   -92,   112,   -92,   -92,
+-      41,    91,    83,   149,   -92,   101,   -92,   -92,   -92
++      -1,     1,     2,     3,    36,    78,    57,    37,    67,    68,
++      69,    81,    39,    40,    41,    42,    43,    70,    92,    93,
++      44,   123,    72,   114,   115,   137,   138,   139,   140,   128,
++     129,    45,   164,   165,    56,    82,    83,    84,   116,   117,
++     118,   119,   135,    52,    76,    77,    46,   100,    47
+ };
+ 
+-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+-   positive, shift that token.  If negative, reduce the rule which
+-   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+-#define YYTABLE_NINF -110
++  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
++     positive, shift that token.  If negative, reduce the rule whose
++     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+ static const yytype_int16 yytable[] =
+ {
+-      88,    89,   114,    38,   157,    10,    59,    73,    95,   128,
+-      85,    50,    71,    91,    75,    20,    54,   110,   147,     4,
+-     164,   111,   144,    99,    29,    51,   100,   112,    33,    66,
+-      55,   107,   113,   114,    79,   114,   135,   -94,    87,    92,
+-     165,   125,    60,    88,    98,   158,    53,    58,   128,   128,
+-      63,   127,   -94,    66,    64,   148,    73,    86,   102,   111,
+-      65,    55,    66,   175,    61,   112,   153,    66,   161,    63,
+-      62,   180,   103,    64,   149,    75,   151,   114,    86,    65,
+-     154,    66,   162,   148,    48,    49,   125,   111,   105,   106,
+-     158,   108,   109,   112,    88,    66,   127,    90,    66,   159,
+-     160,    51,    88,    55,    97,    96,   104,   121,   143,    80,
+-     150,    88,   183,     7,     8,     9,    10,    11,    12,    13,
+-     131,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+-      24,   132,    26,    27,    28,    29,    30,   133,   134,    33,
+-      34,   155,   156,   113,   108,    99,   -22,   163,   170,   168,
+-      35,   171,   169,   -22,  -108,   172,   -22,   164,   -22,   122,
+-     181,   -22,   173,     7,     8,     9,    10,    11,    12,    13,
+-     177,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+-      24,   178,    26,    27,    28,    29,    30,   184,   185,    33,
+-      34,   186,   187,     5,   136,   123,   -22,   176,   152,    74,
+-      35,   146,     0,   -22,  -109,     0,   -22,   145,   -22,     6,
+-       0,   -22,     0,     7,     8,     9,    10,    11,    12,    13,
+-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+-      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+-      34,     0,     0,     0,     0,     0,   -22,     0,     0,     0,
+-      35,     0,     0,   -22,     0,   138,   -22,     0,   -22,     7,
+-       8,     9,    10,    11,    12,    13,     0,    15,    16,    17,
+-      18,    19,    20,    21,    22,    23,    24,     0,    26,    27,
+-      28,    29,    30,     0,     0,    33,    34,     0,     0,     0,
+-       0,   -87,     0,     0,     0,     0,    35,     0,     0,     0,
+-     174,     0,     0,   -87,     7,     8,     9,    10,    11,    12,
+-      13,     0,    15,    16,    17,    18,    19,    20,    21,    22,
+-      23,    24,     0,    26,    27,    28,    29,    30,     0,     0,
+-      33,    34,     0,     0,     0,     0,   -87,     0,     0,     0,
+-       0,    35,     0,     0,     0,   179,     0,     0,   -87,     7,
+-       8,     9,    10,    11,    12,    13,     0,    15,    16,    17,
+-      18,    19,    20,    21,    22,    23,    24,     0,    26,    27,
+-      28,    29,    30,     0,     0,    33,    34,     0,     0,     0,
+-       0,   -87,     0,     0,     0,     0,    35,     0,     0,     0,
+-       0,     0,     0,   -87,     7,     8,     9,    10,    11,    12,
+-      13,     0,    15,    16,    17,    18,    19,    20,    21,    22,
+-      23,    24,     0,    26,    27,    28,    29,    30,     0,     0,
+-      33,    34,     0,     0,     0,     0,     0,   125,     0,     0,
+-       0,   126,     0,     0,     0,     0,     0,   127,     0,    66,
+-       7,     8,     9,    10,    11,    12,    13,     0,    15,    16,
+-      17,    18,    19,    20,    21,    22,    23,    24,     0,    26,
+-      27,    28,    29,    30,     0,     0,    33,    34,     0,     0,
+-       0,     0,   182,     0,     0,     0,     0,    35,     7,     8,
++      88,    89,    38,   113,   155,    94,    73,    71,    59,    85,
++     127,   162,   109,   145,    50,    54,   110,    75,   173,   147,
++      98,   149,   111,    99,    66,   142,   178,   112,    51,    55,
++     106,   163,   133,   113,    91,   113,    79,   -93,     4,    97,
++      87,   124,    88,    53,    58,   156,    60,    10,   127,   127,
++     146,   126,   -93,    66,   110,    73,    86,    20,    55,   101,
++     111,   151,    66,    61,   159,    51,    29,    48,    49,    62,
++      33,   107,   108,   102,    75,   152,   113,    86,   160,    63,
++     104,   105,    90,    64,   146,   157,   158,    55,   110,    65,
++      95,    66,    88,   124,   111,    96,    66,   156,   103,   120,
++      88,   130,   141,   126,   112,    66,   131,    80,   132,    88,
++     181,     7,     8,     9,    10,    11,    12,    13,   148,    15,
++      16,    17,    18,    19,    20,    21,    22,    23,    24,   153,
++      26,    27,    28,    29,    30,   154,   107,    33,    34,    98,
++     161,   166,   167,   169,   -22,   168,   170,   171,    35,   162,
++     175,   -22,  -107,   176,   -22,   179,   -22,   121,     5,   -22,
++     182,     7,     8,     9,    10,    11,    12,    13,   183,    15,
++      16,    17,    18,    19,    20,    21,    22,    23,    24,   184,
++      26,    27,    28,    29,    30,   185,   134,    33,    34,   144,
++     122,   174,   150,    74,   -22,     0,     0,     0,    35,   143,
++       0,   -22,  -108,     0,   -22,     0,   -22,     6,     0,   -22,
++       0,     7,     8,     9,    10,    11,    12,    13,    14,    15,
++      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
++      26,    27,    28,    29,    30,    31,    32,    33,    34,     0,
++       0,     0,     0,     0,   -22,     0,     0,     0,    35,     0,
++       0,   -22,     0,   136,   -22,     0,   -22,     7,     8,     9,
++      10,    11,    12,    13,     0,    15,    16,    17,    18,    19,
++      20,    21,    22,    23,    24,     0,    26,    27,    28,    29,
++      30,     0,     0,    33,    34,     0,     0,     0,     0,   -86,
++       0,     0,     0,     0,    35,     0,     0,     0,   172,     0,
++       0,   -86,     7,     8,     9,    10,    11,    12,    13,     0,
++      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
++       0,    26,    27,    28,    29,    30,     0,     0,    33,    34,
++       0,     0,     0,     0,   -86,     0,     0,     0,     0,    35,
++       0,     0,     0,   177,     0,     0,   -86,     7,     8,     9,
++      10,    11,    12,    13,     0,    15,    16,    17,    18,    19,
++      20,    21,    22,    23,    24,     0,    26,    27,    28,    29,
++      30,     0,     0,    33,    34,     0,     0,     0,     0,   -86,
++       0,     0,     0,     0,    35,     0,     0,     0,     0,     0,
++       0,   -86,     7,     8,     9,    10,    11,    12,    13,     0,
++      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
++       0,    26,    27,    28,    29,    30,     0,     0,    33,    34,
++       0,     0,     0,     0,     0,   124,     0,     0,     0,   125,
++       0,     0,     0,     0,     0,   126,     0,    66,     7,     8,
+        9,    10,    11,    12,    13,     0,    15,    16,    17,    18,
+       19,    20,    21,    22,    23,    24,     0,    26,    27,    28,
+       29,    30,     0,     0,    33,    34,     0,     0,     0,     0,
+-       0,     0,     0,     0,     0,    35
++     180,     0,     0,     0,     0,    35,     7,     8,     9,    10,
++      11,    12,    13,     0,    15,    16,    17,    18,    19,    20,
++      21,    22,    23,    24,     0,    26,    27,    28,    29,    30,
++       0,     0,    33,    34,     0,     0,     0,     0,     0,     0,
++       0,     0,     0,    35
+ };
+ 
+-#define yypact_value_is_default(Yystate) \
+-  (!!((Yystate) == (-92)))
+-
+-#define yytable_value_is_error(Yytable_value) \
+-  YYID (0)
+-
+ static const yytype_int16 yycheck[] =
+ {
+-      60,    60,    81,     3,     1,     8,    26,    39,    66,    88,
+-      57,    38,    38,     1,    38,    18,    38,    38,     1,     0,
+-      31,    42,    46,    30,    27,    52,    33,    48,    31,    50,
+-      52,    78,    53,   112,    54,   114,    94,    34,    58,    65,
+-      51,    38,    48,   103,    70,    42,    23,    38,   127,   128,
+-      38,    48,    49,    50,    42,    38,    88,    57,    34,    42,
+-      48,    52,    50,   154,    48,    48,    34,    50,    34,    38,
+-      45,   162,    48,    42,   112,    38,   114,   156,    78,    48,
+-      48,    50,    48,    38,    45,    46,    38,    42,    46,    47,
+-      42,    45,    46,    48,   154,    50,    48,    38,    50,   127,
+-     128,    52,   162,    52,    47,    45,    51,    46,    35,     1,
+-      35,   171,   171,     5,     6,     7,     8,     9,    10,    11,
+-      49,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+-      22,    49,    24,    25,    26,    27,    28,    49,    49,    31,
+-      32,    45,    47,    53,    45,    30,    38,    45,    37,    49,
+-      42,    47,    49,    45,    46,    49,    48,    31,    50,     1,
+-      35,    53,    49,     5,     6,     7,     8,     9,    10,    11,
+-      49,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+-      22,    49,    24,    25,    26,    27,    28,    49,    49,    31,
+-      32,    49,    49,     1,    97,    83,    38,   156,   115,    50,
+-      42,   110,    -1,    45,    46,    -1,    48,   106,    50,     1,
+-      -1,    53,    -1,     5,     6,     7,     8,     9,    10,    11,
+-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+-      32,    -1,    -1,    -1,    -1,    -1,    38,    -1,    -1,    -1,
+-      42,    -1,    -1,    45,    -1,     1,    48,    -1,    50,     5,
+-       6,     7,     8,     9,    10,    11,    -1,    13,    14,    15,
+-      16,    17,    18,    19,    20,    21,    22,    -1,    24,    25,
+-      26,    27,    28,    -1,    -1,    31,    32,    -1,    -1,    -1,
+-      -1,    37,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,
+-       1,    -1,    -1,    49,     5,     6,     7,     8,     9,    10,
+-      11,    -1,    13,    14,    15,    16,    17,    18,    19,    20,
+-      21,    22,    -1,    24,    25,    26,    27,    28,    -1,    -1,
+-      31,    32,    -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,
+-      -1,    42,    -1,    -1,    -1,     1,    -1,    -1,    49,     5,
+-       6,     7,     8,     9,    10,    11,    -1,    13,    14,    15,
+-      16,    17,    18,    19,    20,    21,    22,    -1,    24,    25,
+-      26,    27,    28,    -1,    -1,    31,    32,    -1,    -1,    -1,
+-      -1,    37,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,
+-      -1,    -1,    -1,    49,     5,     6,     7,     8,     9,    10,
+-      11,    -1,    13,    14,    15,    16,    17,    18,    19,    20,
+-      21,    22,    -1,    24,    25,    26,    27,    28,    -1,    -1,
+-      31,    32,    -1,    -1,    -1,    -1,    -1,    38,    -1,    -1,
+-      -1,    42,    -1,    -1,    -1,    -1,    -1,    48,    -1,    50,
+-       5,     6,     7,     8,     9,    10,    11,    -1,    13,    14,
+-      15,    16,    17,    18,    19,    20,    21,    22,    -1,    24,
+-      25,    26,    27,    28,    -1,    -1,    31,    32,    -1,    -1,
+-      -1,    -1,    37,    -1,    -1,    -1,    -1,    42,     5,     6,
++      60,    60,     3,    81,     1,    66,    39,    38,    26,    57,
++      88,    31,    38,     1,    38,    38,    42,    38,   152,   111,
++      30,   113,    48,    33,    50,    46,   160,    53,    52,    52,
++      78,    51,    93,   111,    65,   113,    54,    34,     0,    70,
++      58,    38,   102,    23,    38,    42,    48,     8,   126,   127,
++      38,    48,    49,    50,    42,    88,    57,    18,    52,    34,
++      48,    34,    50,    48,    34,    52,    27,    45,    46,    45,
++      31,    45,    46,    48,    38,    48,   154,    78,    48,    38,
++      46,    47,    38,    42,    38,   126,   127,    52,    42,    48,
++      45,    50,   152,    38,    48,    47,    50,    42,    51,    46,
++     160,    49,    35,    48,    53,    50,    49,     1,    49,   169,
++     169,     5,     6,     7,     8,     9,    10,    11,    35,    13,
++      14,    15,    16,    17,    18,    19,    20,    21,    22,    45,
++      24,    25,    26,    27,    28,    47,    45,    31,    32,    30,
++      45,    49,    49,    47,    38,    37,    49,    49,    42,    31,
++      49,    45,    46,    49,    48,    35,    50,     1,     1,    53,
++      49,     5,     6,     7,     8,     9,    10,    11,    49,    13,
++      14,    15,    16,    17,    18,    19,    20,    21,    22,    49,
++      24,    25,    26,    27,    28,    49,    96,    31,    32,   109,
++      83,   154,   114,    50,    38,    -1,    -1,    -1,    42,   105,
++      -1,    45,    46,    -1,    48,    -1,    50,     1,    -1,    53,
++      -1,     5,     6,     7,     8,     9,    10,    11,    12,    13,
++      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
++      24,    25,    26,    27,    28,    29,    30,    31,    32,    -1,
++      -1,    -1,    -1,    -1,    38,    -1,    -1,    -1,    42,    -1,
++      -1,    45,    -1,     1,    48,    -1,    50,     5,     6,     7,
++       8,     9,    10,    11,    -1,    13,    14,    15,    16,    17,
++      18,    19,    20,    21,    22,    -1,    24,    25,    26,    27,
++      28,    -1,    -1,    31,    32,    -1,    -1,    -1,    -1,    37,
++      -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,     1,    -1,
++      -1,    49,     5,     6,     7,     8,     9,    10,    11,    -1,
++      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
++      -1,    24,    25,    26,    27,    28,    -1,    -1,    31,    32,
++      -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    42,
++      -1,    -1,    -1,     1,    -1,    -1,    49,     5,     6,     7,
++       8,     9,    10,    11,    -1,    13,    14,    15,    16,    17,
++      18,    19,    20,    21,    22,    -1,    24,    25,    26,    27,
++      28,    -1,    -1,    31,    32,    -1,    -1,    -1,    -1,    37,
++      -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    -1,    -1,
++      -1,    49,     5,     6,     7,     8,     9,    10,    11,    -1,
++      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
++      -1,    24,    25,    26,    27,    28,    -1,    -1,    31,    32,
++      -1,    -1,    -1,    -1,    -1,    38,    -1,    -1,    -1,    42,
++      -1,    -1,    -1,    -1,    -1,    48,    -1,    50,     5,     6,
+        7,     8,     9,    10,    11,    -1,    13,    14,    15,    16,
+       17,    18,    19,    20,    21,    22,    -1,    24,    25,    26,
+       27,    28,    -1,    -1,    31,    32,    -1,    -1,    -1,    -1,
+-      -1,    -1,    -1,    -1,    -1,    42
++      37,    -1,    -1,    -1,    -1,    42,     5,     6,     7,     8,
++       9,    10,    11,    -1,    13,    14,    15,    16,    17,    18,
++      19,    20,    21,    22,    -1,    24,    25,    26,    27,    28,
++      -1,    -1,    31,    32,    -1,    -1,    -1,    -1,    -1,    -1,
++      -1,    -1,    -1,    42
+ };
+ 
+-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+-   symbol of state STATE-NUM.  */
++  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
++     symbol of state STATE-NUM.  */
+ static const yytype_uint8 yystos[] =
+ {
+        0,    55,    56,    57,     0,    56,     1,     5,     6,     7,
+@@ -869,42 +785,66 @@ static const yytype_uint8 yystos[] =
+       48,    48,    45,    38,    42,    48,    50,    62,    63,    64,
+       71,    75,    76,    67,    97,    38,    98,    99,    59,    88,
+        1,    65,    89,    90,    91,    61,    65,    88,    66,    82,
+-      38,     1,    75,    72,    73,    74,    45,    47,    75,    30,
+-      33,   101,    34,    48,    51,    46,    47,    61,    45,    46,
+-      38,    42,    48,    53,    71,    77,    78,    92,    93,    94,
+-      95,    46,     1,    91,    75,    38,    42,    48,    71,    83,
+-      84,    49,    49,    49,    49,    74,    64,    96,     1,    79,
+-      80,    81,    82,    35,    46,    99,    95,     1,    38,    77,
+-      35,    77,    96,    34,    48,    45,    47,     1,    42,    83,
+-      83,    34,    48,    45,    31,    51,    86,    87,    49,    49,
+-      37,    47,    49,    49,     1,    79,    94,    49,    49,     1,
+-      79,    35,    37,    82,    49,    49,    49,    49
++      38,    75,    72,    73,    74,    45,    47,    75,    30,    33,
++     101,    34,    48,    51,    46,    47,    61,    45,    46,    38,
++      42,    48,    53,    71,    77,    78,    92,    93,    94,    95,
++      46,     1,    91,    75,    38,    42,    48,    71,    83,    84,
++      49,    49,    49,    74,    64,    96,     1,    79,    80,    81,
++      82,    35,    46,    99,    95,     1,    38,    77,    35,    77,
++      96,    34,    48,    45,    47,     1,    42,    83,    83,    34,
++      48,    45,    31,    51,    86,    87,    49,    49,    37,    47,
++      49,    49,     1,    79,    94,    49,    49,     1,    79,    35,
++      37,    82,    49,    49,    49,    49
+ };
+ 
+-#define yyerrok		(yyerrstatus = 0)
+-#define yyclearin	(yychar = YYEMPTY)
+-#define YYEMPTY		(-2)
+-#define YYEOF		0
+-
+-#define YYACCEPT	goto yyacceptlab
+-#define YYABORT		goto yyabortlab
+-#define YYERROR		goto yyerrorlab
+-
+-
+-/* Like YYERROR except do call yyerror.  This remains here temporarily
+-   to ease the transition to the new meaning of YYERROR, for GCC.
+-   Once GCC version 2 has supplanted version 1, this can go.  However,
+-   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
+-   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+-   discussed.  */
+-
+-#define YYFAIL		goto yyerrlab
+-#if defined YYFAIL
+-  /* This is here to suppress warnings from the GCC cpp's
+-     -Wunused-macros.  Normally we don't worry about that warning, but
+-     some users do, and we want to make it easy for users to remove
+-     YYFAIL uses, which will produce warnings from Bison 2.5.  */
+-#endif
++  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
++static const yytype_uint8 yyr1[] =
++{
++       0,    54,    55,    55,    57,    56,    59,    58,    60,    58,
++      58,    58,    58,    58,    58,    58,    61,    62,    62,    63,
++      63,    64,    65,    65,    66,    66,    67,    67,    68,    68,
++      68,    68,    68,    69,    69,    69,    69,    69,    69,    69,
++      69,    69,    69,    69,    69,    69,    70,    70,    70,    70,
++      70,    70,    70,    70,    70,    70,    70,    71,    72,    72,
++      73,    73,    74,    74,    74,    74,    75,    75,    76,    76,
++      76,    76,    76,    76,    77,    77,    78,    78,    78,    78,
++      78,    78,    78,    79,    79,    79,    80,    80,    81,    81,
++      82,    83,    83,    84,    84,    84,    84,    84,    84,    84,
++      84,    85,    86,    86,    87,    88,    88,    89,    89,    90,
++      90,    91,    91,    92,    92,    93,    93,    94,    94,    94,
++      95,    96,    96,    97,    97,    98,    98,    99,    99,   100,
++     101,   101,   102
++};
++
++  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
++static const yytype_uint8 yyr2[] =
++{
++       0,     2,     1,     2,     0,     2,     0,     4,     0,     3,
++       1,     1,     1,     1,     2,     2,     3,     0,     1,     1,
++       3,     4,     0,     1,     1,     2,     1,     1,     1,     1,
++       1,     1,     1,     1,     1,     4,     1,     2,     2,     2,
++       3,     3,     3,     2,     2,     2,     1,     1,     1,     1,
++       1,     1,     1,     1,     1,     1,     1,     2,     0,     1,
++       1,     2,     1,     1,     1,     1,     2,     1,     1,     1,
++       4,     4,     2,     3,     2,     1,     1,     1,     4,     4,
++       2,     3,     3,     2,     1,     3,     0,     1,     1,     3,
++       2,     2,     1,     0,     1,     1,     4,     4,     2,     3,
++       3,     3,     0,     1,     2,     3,     3,     0,     1,     1,
++       2,     3,     2,     0,     1,     1,     3,     2,     2,     1,
++       2,     0,     2,     3,     4,     1,     3,     1,     3,     2,
++       0,     1,     5
++};
++
++
++#define yyerrok         (yyerrstatus = 0)
++#define yyclearin       (yychar = YYEMPTY)
++#define YYEMPTY         (-2)
++#define YYEOF           0
++
++#define YYACCEPT        goto yyacceptlab
++#define YYABORT         goto yyabortlab
++#define YYERROR         goto yyerrorlab
++
+ 
+ #define YYRECOVERING()  (!!yyerrstatus)
+ 
+@@ -921,27 +861,15 @@ do                                                              \
+   else                                                          \
+     {                                                           \
+       yyerror (YY_("syntax error: cannot back up")); \
+-      YYERROR;							\
+-    }								\
+-while (YYID (0))
++      YYERROR;                                                  \
++    }                                                           \
++while (0)
+ 
+ /* Error token number */
+-#define YYTERROR	1
+-#define YYERRCODE	256
++#define YYTERROR        1
++#define YYERRCODE       256
+ 
+ 
+-/* This macro is provided for backward compatibility. */
+-#ifndef YY_LOCATION_PRINT
+-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+-#endif
+-
+-
+-/* YYLEX -- calling `yylex' with the right arguments.  */
+-#ifdef YYLEX_PARAM
+-# define YYLEX yylex (YYLEX_PARAM)
+-#else
+-# define YYLEX yylex ()
+-#endif
+ 
+ /* Enable debugging if requested.  */
+ #if YYDEBUG
+@@ -951,40 +879,36 @@ while (YYID (0))
+ #  define YYFPRINTF fprintf
+ # endif
+ 
+-# define YYDPRINTF(Args)			\
+-do {						\
+-  if (yydebug)					\
+-    YYFPRINTF Args;				\
+-} while (YYID (0))
++# define YYDPRINTF(Args)                        \
++do {                                            \
++  if (yydebug)                                  \
++    YYFPRINTF Args;                             \
++} while (0)
++
++/* This macro is provided for backward compatibility. */
++#ifndef YY_LOCATION_PRINT
++# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
++#endif
++
+ 
+-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+-do {									  \
+-  if (yydebug)								  \
+-    {									  \
+-      YYFPRINTF (stderr, "%s ", Title);					  \
+-      yy_symbol_print (stderr,						  \
+-		  Type, Value); \
+-      YYFPRINTF (stderr, "\n");						  \
+-    }									  \
+-} while (YYID (0))
++# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
++do {                                                                      \
++  if (yydebug)                                                            \
++    {                                                                     \
++      YYFPRINTF (stderr, "%s ", Title);                                   \
++      yy_symbol_print (stderr,                                            \
++                  Type, Value); \
++      YYFPRINTF (stderr, "\n");                                           \
++    }                                                                     \
++} while (0)
+ 
+ 
+-/*--------------------------------.
+-| Print this symbol on YYOUTPUT.  |
+-`--------------------------------*/
++/*----------------------------------------.
++| Print this symbol's value on YYOUTPUT.  |
++`----------------------------------------*/
+ 
+-/*ARGSUSED*/
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+ yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+-#else
+-static void
+-yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+-    FILE *yyoutput;
+-    int yytype;
+-    YYSTYPE const * const yyvaluep;
+-#endif
+ {
+   FILE *yyo = yyoutput;
+   YYUSE (yyo);
+@@ -993,14 +917,8 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+ # ifdef YYPRINT
+   if (yytype < YYNTOKENS)
+     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+-# else
+-  YYUSE (yyoutput);
+ # endif
+-  switch (yytype)
+-    {
+-      default:
+-        break;
+-    }
++  YYUSE (yytype);
+ }
+ 
+ 
+@@ -1008,22 +926,11 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+ | Print this symbol on YYOUTPUT.  |
+ `--------------------------------*/
+ 
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+ yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+-#else
+-static void
+-yy_symbol_print (yyoutput, yytype, yyvaluep)
+-    FILE *yyoutput;
+-    int yytype;
+-    YYSTYPE const * const yyvaluep;
+-#endif
+ {
+-  if (yytype < YYNTOKENS)
+-    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+-  else
+-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
++  YYFPRINTF (yyoutput, "%s %s (",
++             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+ 
+   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+   YYFPRINTF (yyoutput, ")");
+@@ -1034,16 +941,8 @@ yy_symbol_print (yyoutput, yytype, yyvaluep)
+ | TOP (included).                                                   |
+ `------------------------------------------------------------------*/
+ 
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+ yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+-#else
+-static void
+-yy_stack_print (yybottom, yytop)
+-    yytype_int16 *yybottom;
+-    yytype_int16 *yytop;
+-#endif
+ {
+   YYFPRINTF (stderr, "Stack now");
+   for (; yybottom <= yytop; yybottom++)
+@@ -1054,49 +953,42 @@ yy_stack_print (yybottom, yytop)
+   YYFPRINTF (stderr, "\n");
+ }
+ 
+-# define YY_STACK_PRINT(Bottom, Top)				\
+-do {								\
+-  if (yydebug)							\
+-    yy_stack_print ((Bottom), (Top));				\
+-} while (YYID (0))
++# define YY_STACK_PRINT(Bottom, Top)                            \
++do {                                                            \
++  if (yydebug)                                                  \
++    yy_stack_print ((Bottom), (Top));                           \
++} while (0)
+ 
+ 
+ /*------------------------------------------------.
+ | Report that the YYRULE is going to be reduced.  |
+ `------------------------------------------------*/
+ 
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+-yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
+-#else
+-static void
+-yy_reduce_print (yyvsp, yyrule)
+-    YYSTYPE *yyvsp;
+-    int yyrule;
+-#endif
++yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
+ {
++  unsigned long int yylno = yyrline[yyrule];
+   int yynrhs = yyr2[yyrule];
+   int yyi;
+-  unsigned long int yylno = yyrline[yyrule];
+   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+-	     yyrule - 1, yylno);
++             yyrule - 1, yylno);
+   /* The symbols being reduced.  */
+   for (yyi = 0; yyi < yynrhs; yyi++)
+     {
+       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+-      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+-		       &(yyvsp[(yyi + 1) - (yynrhs)])
+-		       		       );
++      yy_symbol_print (stderr,
++                       yystos[yyssp[yyi + 1 - yynrhs]],
++                       &(yyvsp[(yyi + 1) - (yynrhs)])
++                                              );
+       YYFPRINTF (stderr, "\n");
+     }
+ }
+ 
+-# define YY_REDUCE_PRINT(Rule)		\
+-do {					\
+-  if (yydebug)				\
+-    yy_reduce_print (yyvsp, Rule); \
+-} while (YYID (0))
++# define YY_REDUCE_PRINT(Rule)          \
++do {                                    \
++  if (yydebug)                          \
++    yy_reduce_print (yyssp, yyvsp, Rule); \
++} while (0)
+ 
+ /* Nonzero means print parse trace.  It is left uninitialized so that
+    multiple parsers can coexist.  */
+@@ -1110,7 +1002,7 @@ int yydebug;
+ 
+ 
+ /* YYINITDEPTH -- initial size of the parser's stacks.  */
+-#ifndef	YYINITDEPTH
++#ifndef YYINITDEPTH
+ # define YYINITDEPTH 200
+ #endif
+ 
+@@ -1133,15 +1025,8 @@ int yydebug;
+ #   define yystrlen strlen
+ #  else
+ /* Return the length of YYSTR.  */
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static YYSIZE_T
+ yystrlen (const char *yystr)
+-#else
+-static YYSIZE_T
+-yystrlen (yystr)
+-    const char *yystr;
+-#endif
+ {
+   YYSIZE_T yylen;
+   for (yylen = 0; yystr[yylen]; yylen++)
+@@ -1157,16 +1042,8 @@ yystrlen (yystr)
+ #  else
+ /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+    YYDEST.  */
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static char *
+ yystpcpy (char *yydest, const char *yysrc)
+-#else
+-static char *
+-yystpcpy (yydest, yysrc)
+-    char *yydest;
+-    const char *yysrc;
+-#endif
+ {
+   char *yyd = yydest;
+   const char *yys = yysrc;
+@@ -1196,27 +1073,27 @@ yytnamerr (char *yyres, const char *yystr)
+       char const *yyp = yystr;
+ 
+       for (;;)
+-	switch (*++yyp)
+-	  {
+-	  case '\'':
+-	  case ',':
+-	    goto do_not_strip_quotes;
+-
+-	  case '\\':
+-	    if (*++yyp != '\\')
+-	      goto do_not_strip_quotes;
+-	    /* Fall through.  */
+-	  default:
+-	    if (yyres)
+-	      yyres[yyn] = *yyp;
+-	    yyn++;
+-	    break;
+-
+-	  case '"':
+-	    if (yyres)
+-	      yyres[yyn] = '\0';
+-	    return yyn;
+-	  }
++        switch (*++yyp)
++          {
++          case '\'':
++          case ',':
++            goto do_not_strip_quotes;
++
++          case '\\':
++            if (*++yyp != '\\')
++              goto do_not_strip_quotes;
++            /* Fall through.  */
++          default:
++            if (yyres)
++              yyres[yyn] = *yyp;
++            yyn++;
++            break;
++
++          case '"':
++            if (yyres)
++              yyres[yyn] = '\0';
++            return yyn;
++          }
+     do_not_strip_quotes: ;
+     }
+ 
+@@ -1239,11 +1116,11 @@ static int
+ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                 yytype_int16 *yyssp, int yytoken)
+ {
+-  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
++  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+   YYSIZE_T yysize = yysize0;
+   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+   /* Internationalized format string. */
+-  const char *yyformat = YY_NULL;
++  const char *yyformat = YY_NULLPTR;
+   /* Arguments of yyformat. */
+   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+   /* Number of reported tokens (one for the "unexpected", one per
+@@ -1251,10 +1128,6 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+   int yycount = 0;
+ 
+   /* There are many possibilities here to consider:
+-     - Assume YYFAIL is not used.  It's too flawed to consider.  See
+-       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
+-       for details.  YYERROR is fine as it does not invoke this
+-       function.
+      - If this state is a consistent state with a default action, then
+        the only way this function was invoked is if the default action
+        is an error action.  In that case, don't check for expected
+@@ -1304,7 +1177,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                   }
+                 yyarg[yycount++] = yytname[yyx];
+                 {
+-                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
++                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                   if (! (yysize <= yysize1
+                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                     return 2;
+@@ -1371,31 +1244,17 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+ | Release the memory associated to this symbol.  |
+ `-----------------------------------------------*/
+ 
+-/*ARGSUSED*/
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+-#else
+-static void
+-yydestruct (yymsg, yytype, yyvaluep)
+-    const char *yymsg;
+-    int yytype;
+-    YYSTYPE *yyvaluep;
+-#endif
+ {
+   YYUSE (yyvaluep);
+-
+   if (!yymsg)
+     yymsg = "Deleting";
+   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+ 
+-  switch (yytype)
+-    {
+-
+-      default:
+-        break;
+-    }
++  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++  YYUSE (yytype);
++  YY_IGNORE_MAYBE_UNINITIALIZED_END
+ }
+ 
+ 
+@@ -1404,18 +1263,8 @@ yydestruct (yymsg, yytype, yyvaluep)
+ /* The lookahead symbol.  */
+ int yychar;
+ 
+-
+-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+-#endif
+-#ifndef YY_INITIAL_VALUE
+-# define YY_INITIAL_VALUE(Value) /* Nothing. */
+-#endif
+-
+ /* The semantic value of the lookahead symbol.  */
+-YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
+-
++YYSTYPE yylval;
+ /* Number of syntax errors so far.  */
+ int yynerrs;
+ 
+@@ -1424,35 +1273,16 @@ int yynerrs;
+ | yyparse.  |
+ `----------*/
+ 
+-#ifdef YYPARSE_PARAM
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+-int
+-yyparse (void *YYPARSE_PARAM)
+-#else
+-int
+-yyparse (YYPARSE_PARAM)
+-    void *YYPARSE_PARAM;
+-#endif
+-#else /* ! YYPARSE_PARAM */
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ int
+ yyparse (void)
+-#else
+-int
+-yyparse ()
+-
+-#endif
+-#endif
+ {
+     int yystate;
+     /* Number of tokens to shift before error messages enabled.  */
+     int yyerrstatus;
+ 
+     /* The stacks and their tools:
+-       `yyss': related to states.
+-       `yyvs': related to semantic values.
++       'yyss': related to states.
++       'yyvs': related to semantic values.
+ 
+        Refer to the stacks through separate pointers, to allow yyoverflow
+        to reallocate them elsewhere.  */
+@@ -1520,23 +1350,23 @@ yyparse ()
+ 
+ #ifdef yyoverflow
+       {
+-	/* Give user a chance to reallocate the stack.  Use copies of
+-	   these so that the &'s don't force the real ones into
+-	   memory.  */
+-	YYSTYPE *yyvs1 = yyvs;
+-	yytype_int16 *yyss1 = yyss;
+-
+-	/* Each stack pointer address is followed by the size of the
+-	   data in use in that stack, in bytes.  This used to be a
+-	   conditional around just the two extra args, but that might
+-	   be undefined if yyoverflow is a macro.  */
+-	yyoverflow (YY_("memory exhausted"),
+-		    &yyss1, yysize * sizeof (*yyssp),
+-		    &yyvs1, yysize * sizeof (*yyvsp),
+-		    &yystacksize);
+-
+-	yyss = yyss1;
+-	yyvs = yyvs1;
++        /* Give user a chance to reallocate the stack.  Use copies of
++           these so that the &'s don't force the real ones into
++           memory.  */
++        YYSTYPE *yyvs1 = yyvs;
++        yytype_int16 *yyss1 = yyss;
++
++        /* Each stack pointer address is followed by the size of the
++           data in use in that stack, in bytes.  This used to be a
++           conditional around just the two extra args, but that might
++           be undefined if yyoverflow is a macro.  */
++        yyoverflow (YY_("memory exhausted"),
++                    &yyss1, yysize * sizeof (*yyssp),
++                    &yyvs1, yysize * sizeof (*yyvsp),
++                    &yystacksize);
++
++        yyss = yyss1;
++        yyvs = yyvs1;
+       }
+ #else /* no yyoverflow */
+ # ifndef YYSTACK_RELOCATE
+@@ -1544,22 +1374,22 @@ yyparse ()
+ # else
+       /* Extend the stack our own way.  */
+       if (YYMAXDEPTH <= yystacksize)
+-	goto yyexhaustedlab;
++        goto yyexhaustedlab;
+       yystacksize *= 2;
+       if (YYMAXDEPTH < yystacksize)
+-	yystacksize = YYMAXDEPTH;
++        yystacksize = YYMAXDEPTH;
+ 
+       {
+-	yytype_int16 *yyss1 = yyss;
+-	union yyalloc *yyptr =
+-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+-	if (! yyptr)
+-	  goto yyexhaustedlab;
+-	YYSTACK_RELOCATE (yyss_alloc, yyss);
+-	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
++        yytype_int16 *yyss1 = yyss;
++        union yyalloc *yyptr =
++          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
++        if (! yyptr)
++          goto yyexhaustedlab;
++        YYSTACK_RELOCATE (yyss_alloc, yyss);
++        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+ #  undef YYSTACK_RELOCATE
+-	if (yyss1 != yyssa)
+-	  YYSTACK_FREE (yyss1);
++        if (yyss1 != yyssa)
++          YYSTACK_FREE (yyss1);
+       }
+ # endif
+ #endif /* no yyoverflow */
+@@ -1568,10 +1398,10 @@ yyparse ()
+       yyvsp = yyvs + yysize - 1;
+ 
+       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+-		  (unsigned long int) yystacksize));
++                  (unsigned long int) yystacksize));
+ 
+       if (yyss + yystacksize - 1 <= yyssp)
+-	YYABORT;
++        YYABORT;
+     }
+ 
+   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+@@ -1600,7 +1430,7 @@ yybackup:
+   if (yychar == YYEMPTY)
+     {
+       YYDPRINTF ((stderr, "Reading a token: "));
+-      yychar = YYLEX;
++      yychar = yylex ();
+     }
+ 
+   if (yychar <= YYEOF)
+@@ -1665,7 +1495,7 @@ yyreduce:
+   yylen = yyr2[yyn];
+ 
+   /* If YYLEN is nonzero, implement the default value of the action:
+-     `$$ = $1'.
++     '$$ = $1'.
+ 
+      Otherwise, the following line sets YYVAL to garbage.
+      This behavior is undocumented and Bison
+@@ -1679,483 +1509,560 @@ yyreduce:
+   switch (yyn)
+     {
+         case 4:
+-
++#line 129 "parse.y" /* yacc.c:1646  */
+     { is_typedef = 0; is_extern = 0; current_name = NULL; decl_spec = NULL; }
++#line 1515 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 5:
+-
+-    { free_list(*(yyvsp[(2) - (2)]), NULL); *(yyvsp[(2) - (2)]) = NULL; }
++#line 131 "parse.y" /* yacc.c:1646  */
++    { free_list(*(yyvsp[0]), NULL); *(yyvsp[0]) = NULL; }
++#line 1521 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 6:
+-
++#line 135 "parse.y" /* yacc.c:1646  */
+     { is_typedef = 1; }
++#line 1527 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 7:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++#line 136 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1533 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 8:
+-
++#line 137 "parse.y" /* yacc.c:1646  */
+     { is_typedef = 1; }
++#line 1539 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 9:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 138 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1545 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 14:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 143 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1551 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 15:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 144 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1557 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 16:
+-
++#line 149 "parse.y" /* yacc.c:1646  */
+     { if (current_name) {
+-		    struct string_list *decl = (*(yyvsp[(3) - (3)]))->next;
+-		    (*(yyvsp[(3) - (3)]))->next = NULL;
++		    struct string_list *decl = (*(yyvsp[0]))->next;
++		    (*(yyvsp[0]))->next = NULL;
+ 		    add_symbol(current_name,
+ 			       is_typedef ? SYM_TYPEDEF : SYM_NORMAL,
+ 			       decl, is_extern);
+ 		    current_name = NULL;
+ 		  }
+-		  (yyval) = (yyvsp[(3) - (3)]);
++		  (yyval) = (yyvsp[0]);
+ 		}
++#line 1572 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 17:
+-
++#line 162 "parse.y" /* yacc.c:1646  */
+     { (yyval) = NULL; }
++#line 1578 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 19:
+-
+-    { struct string_list *decl = *(yyvsp[(1) - (1)]);
+-		  *(yyvsp[(1) - (1)]) = NULL;
++#line 168 "parse.y" /* yacc.c:1646  */
++    { struct string_list *decl = *(yyvsp[0]);
++		  *(yyvsp[0]) = NULL;
+ 		  add_symbol(current_name,
+ 			     is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
+ 		  current_name = NULL;
+-		  (yyval) = (yyvsp[(1) - (1)]);
++		  (yyval) = (yyvsp[0]);
+ 		}
++#line 1590 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 20:
+-
+-    { struct string_list *decl = *(yyvsp[(3) - (3)]);
+-		  *(yyvsp[(3) - (3)]) = NULL;
+-		  free_list(*(yyvsp[(2) - (3)]), NULL);
+-		  *(yyvsp[(2) - (3)]) = decl_spec;
++#line 176 "parse.y" /* yacc.c:1646  */
++    { struct string_list *decl = *(yyvsp[0]);
++		  *(yyvsp[0]) = NULL;
++		  free_list(*(yyvsp[-1]), NULL);
++		  *(yyvsp[-1]) = decl_spec;
+ 		  add_symbol(current_name,
+ 			     is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
+ 		  current_name = NULL;
+-		  (yyval) = (yyvsp[(3) - (3)]);
++		  (yyval) = (yyvsp[0]);
+ 		}
++#line 1604 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 21:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]) ? (yyvsp[(4) - (4)]) : (yyvsp[(3) - (4)]) ? (yyvsp[(3) - (4)]) : (yyvsp[(2) - (4)]) ? (yyvsp[(2) - (4)]) : (yyvsp[(1) - (4)]); }
++#line 189 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]) ? (yyvsp[-1]) : (yyvsp[-2]) ? (yyvsp[-2]) : (yyvsp[-3]); }
++#line 1610 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 22:
+-
++#line 194 "parse.y" /* yacc.c:1646  */
+     { decl_spec = NULL; }
++#line 1616 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 24:
+-
+-    { decl_spec = *(yyvsp[(1) - (1)]); }
++#line 199 "parse.y" /* yacc.c:1646  */
++    { decl_spec = *(yyvsp[0]); }
++#line 1622 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 25:
+-
+-    { decl_spec = *(yyvsp[(2) - (2)]); }
++#line 200 "parse.y" /* yacc.c:1646  */
++    { decl_spec = *(yyvsp[0]); }
++#line 1628 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 26:
+-
++#line 205 "parse.y" /* yacc.c:1646  */
+     { /* Version 2 checksumming ignores storage class, as that
+ 		     is really irrelevant to the linkage.  */
+-		  remove_node((yyvsp[(1) - (1)]));
+-		  (yyval) = (yyvsp[(1) - (1)]);
++		  remove_node((yyvsp[0]));
++		  (yyval) = (yyvsp[0]);
+ 		}
++#line 1638 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 31:
+-
+-    { is_extern = 1; (yyval) = (yyvsp[(1) - (1)]); }
++#line 217 "parse.y" /* yacc.c:1646  */
++    { is_extern = 1; (yyval) = (yyvsp[0]); }
++#line 1644 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 32:
+-
+-    { is_extern = 0; (yyval) = (yyvsp[(1) - (1)]); }
++#line 218 "parse.y" /* yacc.c:1646  */
++    { is_extern = 0; (yyval) = (yyvsp[0]); }
++#line 1650 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 37:
+-
+-    { remove_node((yyvsp[(1) - (2)])); (*(yyvsp[(2) - (2)]))->tag = SYM_STRUCT; (yyval) = (yyvsp[(2) - (2)]); }
++#line 230 "parse.y" /* yacc.c:1646  */
++    { remove_node((yyvsp[-1])); (*(yyvsp[0]))->tag = SYM_STRUCT; (yyval) = (yyvsp[0]); }
++#line 1656 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 38:
+-
+-    { remove_node((yyvsp[(1) - (2)])); (*(yyvsp[(2) - (2)]))->tag = SYM_UNION; (yyval) = (yyvsp[(2) - (2)]); }
++#line 232 "parse.y" /* yacc.c:1646  */
++    { remove_node((yyvsp[-1])); (*(yyvsp[0]))->tag = SYM_UNION; (yyval) = (yyvsp[0]); }
++#line 1662 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 39:
+-
+-    { remove_node((yyvsp[(1) - (2)])); (*(yyvsp[(2) - (2)]))->tag = SYM_ENUM; (yyval) = (yyvsp[(2) - (2)]); }
++#line 234 "parse.y" /* yacc.c:1646  */
++    { remove_node((yyvsp[-1])); (*(yyvsp[0]))->tag = SYM_ENUM; (yyval) = (yyvsp[0]); }
++#line 1668 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 40:
+-
+-    { record_compound((yyvsp[(1) - (3)]), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)]), SYM_STRUCT); (yyval) = (yyvsp[(3) - (3)]); }
++#line 238 "parse.y" /* yacc.c:1646  */
++    { record_compound((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]), SYM_STRUCT); (yyval) = (yyvsp[0]); }
++#line 1674 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 41:
+-
+-    { record_compound((yyvsp[(1) - (3)]), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)]), SYM_UNION); (yyval) = (yyvsp[(3) - (3)]); }
++#line 240 "parse.y" /* yacc.c:1646  */
++    { record_compound((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]), SYM_UNION); (yyval) = (yyvsp[0]); }
++#line 1680 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 42:
+-
+-    { record_compound((yyvsp[(1) - (3)]), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)]), SYM_ENUM); (yyval) = (yyvsp[(3) - (3)]); }
++#line 242 "parse.y" /* yacc.c:1646  */
++    { record_compound((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]), SYM_ENUM); (yyval) = (yyvsp[0]); }
++#line 1686 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 43:
+-
+-    { add_symbol(NULL, SYM_ENUM, NULL, 0); (yyval) = (yyvsp[(2) - (2)]); }
++#line 247 "parse.y" /* yacc.c:1646  */
++    { add_symbol(NULL, SYM_ENUM, NULL, 0); (yyval) = (yyvsp[0]); }
++#line 1692 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 44:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 249 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1698 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 45:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 250 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1704 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 56:
+-
+-    { (*(yyvsp[(1) - (1)]))->tag = SYM_TYPEDEF; (yyval) = (yyvsp[(1) - (1)]); }
++#line 264 "parse.y" /* yacc.c:1646  */
++    { (*(yyvsp[0]))->tag = SYM_TYPEDEF; (yyval) = (yyvsp[0]); }
++#line 1710 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 57:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
++#line 269 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); }
++#line 1716 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 58:
+-
++#line 273 "parse.y" /* yacc.c:1646  */
+     { (yyval) = NULL; }
++#line 1722 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 61:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 279 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1728 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 65:
+-
++#line 285 "parse.y" /* yacc.c:1646  */
+     { /* restrict has no effect in prototypes so ignore it */
+-		  remove_node((yyvsp[(1) - (1)]));
+-		  (yyval) = (yyvsp[(1) - (1)]);
++		  remove_node((yyvsp[0]));
++		  (yyval) = (yyvsp[0]);
+ 		}
++#line 1737 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 66:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 292 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1743 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 68:
+-
++#line 298 "parse.y" /* yacc.c:1646  */
+     { if (current_name != NULL) {
+ 		    error_with_pos("unexpected second declaration name");
+ 		    YYERROR;
+ 		  } else {
+-		    current_name = (*(yyvsp[(1) - (1)]))->string;
+-		    (yyval) = (yyvsp[(1) - (1)]);
++		    current_name = (*(yyvsp[0]))->string;
++		    (yyval) = (yyvsp[0]);
+ 		  }
+ 		}
++#line 1756 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 69:
+-
++#line 307 "parse.y" /* yacc.c:1646  */
+     { if (current_name != NULL) {
+ 		    error_with_pos("unexpected second declaration name");
+ 		    YYERROR;
+ 		  } else {
+-		    current_name = (*(yyvsp[(1) - (1)]))->string;
+-		    (yyval) = (yyvsp[(1) - (1)]);
++		    current_name = (*(yyvsp[0]))->string;
++		    (yyval) = (yyvsp[0]);
+ 		  }
+ 		}
++#line 1769 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 70:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++#line 316 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1775 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 71:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++#line 318 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1781 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 72:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 320 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1787 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 73:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 322 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1793 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 74:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 328 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1799 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 75:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++  case 78:
++#line 336 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1805 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 79:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++#line 338 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1811 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 80:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++#line 340 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1817 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 81:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 342 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1823 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 82:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 344 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1829 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 83:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 348 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1835 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 84:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++  case 85:
++#line 350 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1841 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 86:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 354 "parse.y" /* yacc.c:1646  */
++    { (yyval) = NULL; }
++#line 1847 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 87:
+-
+-    { (yyval) = NULL; }
++  case 89:
++#line 361 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1853 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 90:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 366 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); }
++#line 1859 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 91:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
++#line 371 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); }
++#line 1865 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 92:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
++  case 93:
++#line 376 "parse.y" /* yacc.c:1646  */
++    { (yyval) = NULL; }
++#line 1871 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 94:
+-
+-    { (yyval) = NULL; }
++#line 378 "parse.y" /* yacc.c:1646  */
++    { /* For version 2 checksums, we don't want to remember
++		     private parameter names.  */
++		  remove_node((yyvsp[0]));
++		  (yyval) = (yyvsp[0]);
++		}
++#line 1881 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 95:
+-
+-    { /* For version 2 checksums, we don't want to remember
+-		     private parameter names.  */
+-		  remove_node((yyvsp[(1) - (1)]));
+-		  (yyval) = (yyvsp[(1) - (1)]);
++#line 386 "parse.y" /* yacc.c:1646  */
++    { remove_node((yyvsp[0]));
++		  (yyval) = (yyvsp[0]);
+ 		}
++#line 1889 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 96:
+-
+-    { remove_node((yyvsp[(1) - (1)]));
+-		  (yyval) = (yyvsp[(1) - (1)]);
+-		}
++#line 390 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1895 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 97:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++#line 392 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1901 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 98:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++#line 394 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1907 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 99:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 396 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1913 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 100:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 398 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1919 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 101:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
+-    break;
+-
+-  case 102:
+-
+-    { struct string_list *decl = *(yyvsp[(2) - (3)]);
+-		  *(yyvsp[(2) - (3)]) = NULL;
++#line 403 "parse.y" /* yacc.c:1646  */
++    { struct string_list *decl = *(yyvsp[-1]);
++		  *(yyvsp[-1]) = NULL;
+ 		  add_symbol(current_name, SYM_NORMAL, decl, is_extern);
+-		  (yyval) = (yyvsp[(3) - (3)]);
++		  (yyval) = (yyvsp[0]);
+ 		}
++#line 1929 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 103:
+-
++  case 102:
++#line 411 "parse.y" /* yacc.c:1646  */
+     { (yyval) = NULL; }
++#line 1935 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 105:
++  case 104:
++#line 418 "parse.y" /* yacc.c:1646  */
++    { remove_list((yyvsp[0]), &(*(yyvsp[-1]))->next); (yyval) = (yyvsp[0]); }
++#line 1941 "parse.tab.c" /* yacc.c:1646  */
++    break;
+ 
+-    { remove_list((yyvsp[(2) - (2)]), &(*(yyvsp[(1) - (2)]))->next); (yyval) = (yyvsp[(2) - (2)]); }
++  case 105:
++#line 422 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1947 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 106:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 423 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1953 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 107:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 427 "parse.y" /* yacc.c:1646  */
++    { (yyval) = NULL; }
++#line 1959 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 108:
+-
+-    { (yyval) = NULL; }
++  case 110:
++#line 433 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1965 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 111:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 438 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1971 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 112:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 440 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1977 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 113:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++#line 444 "parse.y" /* yacc.c:1646  */
++    { (yyval) = NULL; }
++#line 1983 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 114:
+-
+-    { (yyval) = NULL; }
++  case 116:
++#line 450 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 1989 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 117:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++#line 454 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); }
++#line 1995 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 118:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
++#line 455 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 2001 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 119:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++  case 120:
++#line 460 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 2007 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+   case 121:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
+-    break;
+-
+-  case 122:
+-
++#line 464 "parse.y" /* yacc.c:1646  */
+     { (yyval) = NULL; }
++#line 2013 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 124:
+-
+-    { (yyval) = (yyvsp[(3) - (3)]); }
++  case 123:
++#line 469 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 2019 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 125:
+-
+-    { (yyval) = (yyvsp[(4) - (4)]); }
++  case 124:
++#line 470 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 2025 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 128:
+-
++  case 127:
++#line 479 "parse.y" /* yacc.c:1646  */
+     {
+-			const char *name = strdup((*(yyvsp[(1) - (1)]))->string);
++			const char *name = strdup((*(yyvsp[0]))->string);
+ 			add_symbol(name, SYM_ENUM_CONST, NULL, 0);
+ 		}
++#line 2034 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 129:
+-
++  case 128:
++#line 484 "parse.y" /* yacc.c:1646  */
+     {
+-			const char *name = strdup((*(yyvsp[(1) - (3)]))->string);
+-			struct string_list *expr = copy_list_range(*(yyvsp[(3) - (3)]), *(yyvsp[(2) - (3)]));
++			const char *name = strdup((*(yyvsp[-2]))->string);
++			struct string_list *expr = copy_list_range(*(yyvsp[0]), *(yyvsp[-1]));
+ 			add_symbol(name, SYM_ENUM_CONST, expr, 0);
+ 		}
++#line 2044 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 130:
+-
+-    { (yyval) = (yyvsp[(2) - (2)]); }
++  case 129:
++#line 491 "parse.y" /* yacc.c:1646  */
++    { (yyval) = (yyvsp[0]); }
++#line 2050 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 131:
+-
++  case 130:
++#line 495 "parse.y" /* yacc.c:1646  */
+     { (yyval) = NULL; }
++#line 2056 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 133:
+-
+-    { export_symbol((*(yyvsp[(3) - (5)]))->string); (yyval) = (yyvsp[(5) - (5)]); }
++  case 132:
++#line 501 "parse.y" /* yacc.c:1646  */
++    { export_symbol((*(yyvsp[-2]))->string); (yyval) = (yyvsp[0]); }
++#line 2062 "parse.tab.c" /* yacc.c:1646  */
+     break;
+ 
+ 
+-
++#line 2066 "parse.tab.c" /* yacc.c:1646  */
+       default: break;
+     }
+   /* User semantic actions sometimes alter yychar, and that requires
+@@ -2177,7 +2084,7 @@ yyreduce:
+ 
+   *++yyvsp = yyval;
+ 
+-  /* Now `shift' the result of the reduction.  Determine what state
++  /* Now 'shift' the result of the reduction.  Determine what state
+      that goes to, based on the state we popped back to and the rule
+      number reduced by.  */
+ 
+@@ -2192,9 +2099,9 @@ yyreduce:
+   goto yynewstate;
+ 
+ 
+-/*------------------------------------.
+-| yyerrlab -- here on detecting error |
+-`------------------------------------*/
++/*--------------------------------------.
++| yyerrlab -- here on detecting error.  |
++`--------------------------------------*/
+ yyerrlab:
+   /* Make sure we have latest lookahead translation.  See comments at
+      user semantic actions for why this is necessary.  */
+@@ -2245,20 +2152,20 @@ yyerrlab:
+   if (yyerrstatus == 3)
+     {
+       /* If just tried and failed to reuse lookahead token after an
+-	 error, discard it.  */
++         error, discard it.  */
+ 
+       if (yychar <= YYEOF)
+-	{
+-	  /* Return failure if at end of input.  */
+-	  if (yychar == YYEOF)
+-	    YYABORT;
+-	}
++        {
++          /* Return failure if at end of input.  */
++          if (yychar == YYEOF)
++            YYABORT;
++        }
+       else
+-	{
+-	  yydestruct ("Error: discarding",
+-		      yytoken, &yylval);
+-	  yychar = YYEMPTY;
+-	}
++        {
++          yydestruct ("Error: discarding",
++                      yytoken, &yylval);
++          yychar = YYEMPTY;
++        }
+     }
+ 
+   /* Else will try to reuse lookahead token after shifting the error
+@@ -2277,7 +2184,7 @@ yyerrorlab:
+   if (/*CONSTCOND*/ 0)
+      goto yyerrorlab;
+ 
+-  /* Do not reclaim the symbols of the rule which action triggered
++  /* Do not reclaim the symbols of the rule whose action triggered
+      this YYERROR.  */
+   YYPOPSTACK (yylen);
+   yylen = 0;
+@@ -2290,29 +2197,29 @@ yyerrorlab:
+ | yyerrlab1 -- common code for both syntax error and YYERROR.  |
+ `-------------------------------------------------------------*/
+ yyerrlab1:
+-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
++  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+ 
+   for (;;)
+     {
+       yyn = yypact[yystate];
+       if (!yypact_value_is_default (yyn))
+-	{
+-	  yyn += YYTERROR;
+-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+-	    {
+-	      yyn = yytable[yyn];
+-	      if (0 < yyn)
+-		break;
+-	    }
+-	}
++        {
++          yyn += YYTERROR;
++          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
++            {
++              yyn = yytable[yyn];
++              if (0 < yyn)
++                break;
++            }
++        }
+ 
+       /* Pop the current state because it cannot handle the error token.  */
+       if (yyssp == yyss)
+-	YYABORT;
++        YYABORT;
+ 
+ 
+       yydestruct ("Error: popping",
+-		  yystos[yystate], yyvsp);
++                  yystos[yystate], yyvsp);
+       YYPOPSTACK (1);
+       yystate = *yyssp;
+       YY_STACK_PRINT (yyss, yyssp);
+@@ -2363,14 +2270,14 @@ yyreturn:
+       yydestruct ("Cleanup: discarding lookahead",
+                   yytoken, &yylval);
+     }
+-  /* Do not reclaim the symbols of the rule which action triggered
++  /* Do not reclaim the symbols of the rule whose action triggered
+      this YYABORT or YYACCEPT.  */
+   YYPOPSTACK (yylen);
+   YY_STACK_PRINT (yyss, yyssp);
+   while (yyssp != yyss)
+     {
+       yydestruct ("Cleanup: popping",
+-		  yystos[*yyssp], yyvsp);
++                  yystos[*yyssp], yyvsp);
+       YYPOPSTACK (1);
+     }
+ #ifndef yyoverflow
+@@ -2381,12 +2288,9 @@ yyreturn:
+   if (yymsg != yymsgbuf)
+     YYSTACK_FREE (yymsg);
+ #endif
+-  /* Make sure YYID is used.  */
+-  return YYID (yyresult);
++  return yyresult;
+ }
+-
+-
+-
++#line 505 "parse.y" /* yacc.c:1906  */
+ 
+ 
+ static void
+diff --git a/scripts/genksyms/parse.tab.h_shipped b/scripts/genksyms/parse.tab.h_shipped
+index 4c00cef6d71d..1751bd03ad26 100644
+--- a/scripts/genksyms/parse.tab.h_shipped
++++ b/scripts/genksyms/parse.tab.h_shipped
+@@ -1,19 +1,19 @@
+-/* A Bison parser, made by GNU Bison 2.7.  */
++/* A Bison parser, made by GNU Bison 3.0.4.  */
+ 
+ /* Bison interface for Yacc-like parsers in C
+-   
+-      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
+-   
++
++   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
++
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+-   
++
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+-   
++
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+ 
+@@ -26,93 +26,80 @@
+    special exception, which will cause the skeleton and the resulting
+    Bison output files to be licensed under the GNU General Public
+    License without this special exception.
+-   
++
+    This special exception was added by the Free Software Foundation in
+    version 2.2 of Bison.  */
+ 
+-#ifndef YY_YY_SCRIPTS_GENKSYMS_PARSE_TAB_H_SHIPPED_INCLUDED
+-# define YY_YY_SCRIPTS_GENKSYMS_PARSE_TAB_H_SHIPPED_INCLUDED
+-/* Enabling traces.  */
++#ifndef YY_YY_PARSE_TAB_H_INCLUDED
++# define YY_YY_PARSE_TAB_H_INCLUDED
++/* Debug traces.  */
+ #ifndef YYDEBUG
+-# define YYDEBUG 1
++# define YYDEBUG 0
+ #endif
+ #if YYDEBUG
+ extern int yydebug;
+ #endif
+ 
+-/* Tokens.  */
++/* Token type.  */
+ #ifndef YYTOKENTYPE
+ # define YYTOKENTYPE
+-   /* Put the tokens into the symbol table, so that GDB and other debuggers
+-      know about them.  */
+-   enum yytokentype {
+-     ASM_KEYW = 258,
+-     ATTRIBUTE_KEYW = 259,
+-     AUTO_KEYW = 260,
+-     BOOL_KEYW = 261,
+-     CHAR_KEYW = 262,
+-     CONST_KEYW = 263,
+-     DOUBLE_KEYW = 264,
+-     ENUM_KEYW = 265,
+-     EXTERN_KEYW = 266,
+-     EXTENSION_KEYW = 267,
+-     FLOAT_KEYW = 268,
+-     INLINE_KEYW = 269,
+-     INT_KEYW = 270,
+-     LONG_KEYW = 271,
+-     REGISTER_KEYW = 272,
+-     RESTRICT_KEYW = 273,
+-     SHORT_KEYW = 274,
+-     SIGNED_KEYW = 275,
+-     STATIC_KEYW = 276,
+-     STRUCT_KEYW = 277,
+-     TYPEDEF_KEYW = 278,
+-     UNION_KEYW = 279,
+-     UNSIGNED_KEYW = 280,
+-     VOID_KEYW = 281,
+-     VOLATILE_KEYW = 282,
+-     TYPEOF_KEYW = 283,
+-     EXPORT_SYMBOL_KEYW = 284,
+-     ASM_PHRASE = 285,
+-     ATTRIBUTE_PHRASE = 286,
+-     TYPEOF_PHRASE = 287,
+-     BRACE_PHRASE = 288,
+-     BRACKET_PHRASE = 289,
+-     EXPRESSION_PHRASE = 290,
+-     CHAR = 291,
+-     DOTS = 292,
+-     IDENT = 293,
+-     INT = 294,
+-     REAL = 295,
+-     STRING = 296,
+-     TYPE = 297,
+-     OTHER = 298,
+-     FILENAME = 299
+-   };
++  enum yytokentype
++  {
++    ASM_KEYW = 258,
++    ATTRIBUTE_KEYW = 259,
++    AUTO_KEYW = 260,
++    BOOL_KEYW = 261,
++    CHAR_KEYW = 262,
++    CONST_KEYW = 263,
++    DOUBLE_KEYW = 264,
++    ENUM_KEYW = 265,
++    EXTERN_KEYW = 266,
++    EXTENSION_KEYW = 267,
++    FLOAT_KEYW = 268,
++    INLINE_KEYW = 269,
++    INT_KEYW = 270,
++    LONG_KEYW = 271,
++    REGISTER_KEYW = 272,
++    RESTRICT_KEYW = 273,
++    SHORT_KEYW = 274,
++    SIGNED_KEYW = 275,
++    STATIC_KEYW = 276,
++    STRUCT_KEYW = 277,
++    TYPEDEF_KEYW = 278,
++    UNION_KEYW = 279,
++    UNSIGNED_KEYW = 280,
++    VOID_KEYW = 281,
++    VOLATILE_KEYW = 282,
++    TYPEOF_KEYW = 283,
++    EXPORT_SYMBOL_KEYW = 284,
++    ASM_PHRASE = 285,
++    ATTRIBUTE_PHRASE = 286,
++    TYPEOF_PHRASE = 287,
++    BRACE_PHRASE = 288,
++    BRACKET_PHRASE = 289,
++    EXPRESSION_PHRASE = 290,
++    CHAR = 291,
++    DOTS = 292,
++    IDENT = 293,
++    INT = 294,
++    REAL = 295,
++    STRING = 296,
++    TYPE = 297,
++    OTHER = 298,
++    FILENAME = 299
++  };
+ #endif
+ 
+-
++/* Value type.  */
+ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+ typedef int YYSTYPE;
+ # define YYSTYPE_IS_TRIVIAL 1
+-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+ # define YYSTYPE_IS_DECLARED 1
+ #endif
+ 
++
+ extern YYSTYPE yylval;
+ 
+-#ifdef YYPARSE_PARAM
+-#if defined __STDC__ || defined __cplusplus
+-int yyparse (void *YYPARSE_PARAM);
+-#else
+-int yyparse ();
+-#endif
+-#else /* ! YYPARSE_PARAM */
+-#if defined __STDC__ || defined __cplusplus
+ int yyparse (void);
+-#else
+-int yyparse ();
+-#endif
+-#endif /* ! YYPARSE_PARAM */
+ 
+-#endif /* !YY_YY_SCRIPTS_GENKSYMS_PARSE_TAB_H_SHIPPED_INCLUDED  */
++#endif /* !YY_YY_PARSE_TAB_H_INCLUDED  */
+diff --git a/scripts/genksyms/parse.y b/scripts/genksyms/parse.y
+index 723ab30fe9d4..268efe37688a 100644
+--- a/scripts/genksyms/parse.y
++++ b/scripts/genksyms/parse.y
+@@ -320,8 +320,6 @@ direct_declarator:
+ 		{ $$ = $2; }
+ 	| '(' declarator ')'
+ 		{ $$ = $3; }
+-	| '(' error ')'
+-		{ $$ = $3; }
+ 	;
+ 
+ /* Nested declarators differ from regular declarators in that they do
+diff --git a/scripts/kernel-doc b/scripts/kernel-doc
+index 638a38e1b419..bba8ad9c4f2c 100755
+--- a/scripts/kernel-doc
++++ b/scripts/kernel-doc
+@@ -2742,4 +2742,4 @@ if ($verbose && $warnings) {
+   print STDERR "$warnings warnings\n";
+ }
+ 
+-exit($errors);
++exit($output_mode eq "none" ? 0 : $errors);
+diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c
+index 48958d3cec9e..bd5151915e5a 100644
+--- a/scripts/mod/modpost.c
++++ b/scripts/mod/modpost.c
+@@ -2129,6 +2129,14 @@ static void add_intree_flag(struct buffer *b, int is_intree)
+ 		buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
+ }
+ 
++/* Cannot check for assembler */
++static void add_retpoline(struct buffer *b)
++{
++	buf_printf(b, "\n#ifdef RETPOLINE\n");
++	buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
++	buf_printf(b, "#endif\n");
++}
++
+ static void add_staging_flag(struct buffer *b, const char *name)
+ {
+ 	static const char *staging_dir = "drivers/staging";
+@@ -2473,6 +2481,7 @@ int main(int argc, char **argv)
+ 
+ 		add_header(&buf, mod);
+ 		add_intree_flag(&buf, !external_module);
++		add_retpoline(&buf);
+ 		add_staging_flag(&buf, mod->name);
+ 		err |= add_versions(&buf, mod);
+ 		add_depends(&buf, mod, modules);
+diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
+index ebb5eb3c318c..db7eff3573a9 100644
+--- a/security/selinux/ss/services.c
++++ b/security/selinux/ss/services.c
+@@ -860,6 +860,9 @@ int security_bounded_transition(u32 old_sid, u32 new_sid)
+ 	int index;
+ 	int rc;
+ 
++	if (!ss_initialized)
++		return 0;
++
+ 	read_lock(&policy_rwlock);
+ 
+ 	rc = -EINVAL;
+@@ -1406,27 +1409,25 @@ static int security_context_to_sid_core(const char *scontext, u32 scontext_len,
+ 	if (!scontext_len)
+ 		return -EINVAL;
+ 
++	/* Copy the string to allow changes and ensure a NUL terminator */
++	scontext2 = kmemdup_nul(scontext, scontext_len, gfp_flags);
++	if (!scontext2)
++		return -ENOMEM;
++
+ 	if (!ss_initialized) {
+ 		int i;
+ 
+ 		for (i = 1; i < SECINITSID_NUM; i++) {
+-			if (!strcmp(initial_sid_to_string[i], scontext)) {
++			if (!strcmp(initial_sid_to_string[i], scontext2)) {
+ 				*sid = i;
+-				return 0;
++				goto out;
+ 			}
+ 		}
+ 		*sid = SECINITSID_KERNEL;
+-		return 0;
++		goto out;
+ 	}
+ 	*sid = SECSID_NULL;
+ 
+-	/* Copy the string so that we can modify the copy as we parse it. */
+-	scontext2 = kmalloc(scontext_len + 1, gfp_flags);
+-	if (!scontext2)
+-		return -ENOMEM;
+-	memcpy(scontext2, scontext, scontext_len);
+-	scontext2[scontext_len] = 0;
+-
+ 	if (force) {
+ 		/* Save another copy for storing in uninterpreted form */
+ 		rc = -ENOMEM;
+diff --git a/sound/pci/hda/patch_ca0132.c b/sound/pci/hda/patch_ca0132.c
+index c146d0de53d8..29e1ce2263bc 100644
+--- a/sound/pci/hda/patch_ca0132.c
++++ b/sound/pci/hda/patch_ca0132.c
+@@ -1482,6 +1482,9 @@ static int dspio_scp(struct hda_codec *codec,
+ 		} else if (ret_size != reply_data_size) {
+ 			codec_dbg(codec, "RetLen and HdrLen .NE.\n");
+ 			return -EINVAL;
++		} else if (!reply) {
++			codec_dbg(codec, "NULL reply\n");
++			return -EINVAL;
+ 		} else {
+ 			*reply_len = ret_size*sizeof(unsigned int);
+ 			memcpy(reply, scp_reply.data, *reply_len);
+diff --git a/sound/soc/intel/Kconfig b/sound/soc/intel/Kconfig
+index d430ef5a4f38..79c29330c56a 100644
+--- a/sound/soc/intel/Kconfig
++++ b/sound/soc/intel/Kconfig
+@@ -24,7 +24,6 @@ config SND_SST_IPC_PCI
+ config SND_SST_IPC_ACPI
+ 	tristate
+ 	select SND_SST_IPC
+-	depends on ACPI
+ 
+ config SND_SOC_INTEL_SST
+ 	tristate
+@@ -91,7 +90,7 @@ config SND_SOC_INTEL_BROADWELL_MACH
+ 
+ config SND_SOC_INTEL_BYTCR_RT5640_MACH
+ 	tristate "ASoC Audio DSP Support for MID BYT Platform"
+-	depends on X86 && I2C
++	depends on X86 && I2C && ACPI
+ 	select SND_SOC_RT5640
+ 	select SND_SST_MFLD_PLATFORM
+ 	select SND_SST_IPC_ACPI
+@@ -103,7 +102,7 @@ config SND_SOC_INTEL_BYTCR_RT5640_MACH
+ 
+ config SND_SOC_INTEL_CHT_BSW_RT5672_MACH
+         tristate "ASoC Audio driver for Intel Cherrytrail & Braswell with RT5672 codec"
+-        depends on X86_INTEL_LPSS && I2C
++        depends on X86_INTEL_LPSS && I2C && ACPI
+         select SND_SOC_RT5670
+         select SND_SST_MFLD_PLATFORM
+         select SND_SST_IPC_ACPI
+@@ -115,7 +114,7 @@ config SND_SOC_INTEL_CHT_BSW_RT5672_MACH
+ 
+ config SND_SOC_INTEL_CHT_BSW_RT5645_MACH
+ 	tristate "ASoC Audio driver for Intel Cherrytrail & Braswell with RT5645/5650 codec"
+-	depends on X86_INTEL_LPSS && I2C
++	depends on X86_INTEL_LPSS && I2C && ACPI
+ 	select SND_SOC_RT5645
+ 	select SND_SST_MFLD_PLATFORM
+ 	select SND_SST_IPC_ACPI
+diff --git a/sound/soc/mediatek/Kconfig b/sound/soc/mediatek/Kconfig
+index 15c04e2eae34..976967675387 100644
+--- a/sound/soc/mediatek/Kconfig
++++ b/sound/soc/mediatek/Kconfig
+@@ -9,7 +9,7 @@ config SND_SOC_MEDIATEK
+ 
+ config SND_SOC_MT8173_MAX98090
+ 	tristate "ASoC Audio driver for MT8173 with MAX98090 codec"
+-	depends on SND_SOC_MEDIATEK
++	depends on SND_SOC_MEDIATEK && I2C
+ 	select SND_SOC_MAX98090
+ 	help
+ 	  This adds ASoC driver for Mediatek MT8173 boards
+@@ -19,7 +19,7 @@ config SND_SOC_MT8173_MAX98090
+ 
+ config SND_SOC_MT8173_RT5650_RT5676
+ 	tristate "ASoC Audio driver for MT8173 with RT5650 RT5676 codecs"
+-	depends on SND_SOC_MEDIATEK
++	depends on SND_SOC_MEDIATEK && I2C
+ 	select SND_SOC_RT5645
+ 	select SND_SOC_RT5677
+ 	help
+diff --git a/sound/soc/rockchip/rockchip_spdif.c b/sound/soc/rockchip/rockchip_spdif.c
+index 5a806da89f42..5e2eb4cc5cf1 100644
+--- a/sound/soc/rockchip/rockchip_spdif.c
++++ b/sound/soc/rockchip/rockchip_spdif.c
+@@ -54,7 +54,7 @@ static const struct of_device_id rk_spdif_match[] = {
+ };
+ MODULE_DEVICE_TABLE(of, rk_spdif_match);
+ 
+-static int rk_spdif_runtime_suspend(struct device *dev)
++static int __maybe_unused rk_spdif_runtime_suspend(struct device *dev)
+ {
+ 	struct rk_spdif_dev *spdif = dev_get_drvdata(dev);
+ 
+@@ -64,7 +64,7 @@ static int rk_spdif_runtime_suspend(struct device *dev)
+ 	return 0;
+ }
+ 
+-static int rk_spdif_runtime_resume(struct device *dev)
++static int __maybe_unused rk_spdif_runtime_resume(struct device *dev)
+ {
+ 	struct rk_spdif_dev *spdif = dev_get_drvdata(dev);
+ 	int ret;
+@@ -316,26 +316,30 @@ static int rk_spdif_probe(struct platform_device *pdev)
+ 	spdif->mclk = devm_clk_get(&pdev->dev, "mclk");
+ 	if (IS_ERR(spdif->mclk)) {
+ 		dev_err(&pdev->dev, "Can't retrieve rk_spdif master clock\n");
+-		return PTR_ERR(spdif->mclk);
++		ret = PTR_ERR(spdif->mclk);
++		goto err_disable_hclk;
+ 	}
+ 
+ 	ret = clk_prepare_enable(spdif->mclk);
+ 	if (ret) {
+ 		dev_err(spdif->dev, "clock enable failed %d\n", ret);
+-		return ret;
++		goto err_disable_clocks;
+ 	}
+ 
+ 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ 	regs = devm_ioremap_resource(&pdev->dev, res);
+-	if (IS_ERR(regs))
+-		return PTR_ERR(regs);
++	if (IS_ERR(regs)) {
++		ret = PTR_ERR(regs);
++		goto err_disable_clocks;
++	}
+ 
+ 	spdif->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "hclk", regs,
+ 						  &rk_spdif_regmap_config);
+ 	if (IS_ERR(spdif->regmap)) {
+ 		dev_err(&pdev->dev,
+ 			"Failed to initialise managed register map\n");
+-		return PTR_ERR(spdif->regmap);
++		ret = PTR_ERR(spdif->regmap);
++		goto err_disable_clocks;
+ 	}
+ 
+ 	spdif->playback_dma_data.addr = res->start + SPDIF_SMPDR;
+@@ -367,6 +371,10 @@ static int rk_spdif_probe(struct platform_device *pdev)
+ 
+ err_pm_runtime:
+ 	pm_runtime_disable(&pdev->dev);
++err_disable_clocks:
++	clk_disable_unprepare(spdif->mclk);
++err_disable_hclk:
++	clk_disable_unprepare(spdif->hclk);
+ 
+ 	return ret;
+ }
+diff --git a/sound/soc/ux500/mop500.c b/sound/soc/ux500/mop500.c
+index ba9fc099cf67..503aef8fcde2 100644
+--- a/sound/soc/ux500/mop500.c
++++ b/sound/soc/ux500/mop500.c
+@@ -164,3 +164,7 @@ static struct platform_driver snd_soc_mop500_driver = {
+ };
+ 
+ module_platform_driver(snd_soc_mop500_driver);
++
++MODULE_LICENSE("GPL v2");
++MODULE_DESCRIPTION("ASoC MOP500 board driver");
++MODULE_AUTHOR("Ola Lilja");
+diff --git a/sound/soc/ux500/ux500_pcm.c b/sound/soc/ux500/ux500_pcm.c
+index f12c01dddc8d..d35ba7700f46 100644
+--- a/sound/soc/ux500/ux500_pcm.c
++++ b/sound/soc/ux500/ux500_pcm.c
+@@ -165,3 +165,8 @@ int ux500_pcm_unregister_platform(struct platform_device *pdev)
+ 	return 0;
+ }
+ EXPORT_SYMBOL_GPL(ux500_pcm_unregister_platform);
++
++MODULE_AUTHOR("Ola Lilja");
++MODULE_AUTHOR("Roger Nilsson");
++MODULE_DESCRIPTION("ASoC UX500 driver");
++MODULE_LICENSE("GPL v2");
+diff --git a/tools/build/Makefile.build b/tools/build/Makefile.build
+index 4a96473b180f..4ffc096eaf5d 100644
+--- a/tools/build/Makefile.build
++++ b/tools/build/Makefile.build
+@@ -19,6 +19,16 @@ else
+   Q=@
+ endif
+ 
++ifneq ($(filter 4.%,$(MAKE_VERSION)),)	# make-4
++ifneq ($(filter %s ,$(firstword x$(MAKEFLAGS))),)
++  quiet=silent_
++endif
++else					# make-3.8x
++ifneq ($(filter s% -s%,$(MAKEFLAGS)),)
++  quiet=silent_
++endif
++endif
++
+ build-dir := $(srctree)/tools/build
+ 
+ # Define $(fixdep) for dep-cmd function
+diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
+index b4eb5b679081..73d192f57dc3 100644
+--- a/tools/perf/bench/numa.c
++++ b/tools/perf/bench/numa.c
+@@ -208,6 +208,47 @@ static const char * const numa_usage[] = {
+ 	NULL
+ };
+ 
++/*
++ * To get number of numa nodes present.
++ */
++static int nr_numa_nodes(void)
++{
++	int i, nr_nodes = 0;
++
++	for (i = 0; i < g->p.nr_nodes; i++) {
++		if (numa_bitmask_isbitset(numa_nodes_ptr, i))
++			nr_nodes++;
++	}
++
++	return nr_nodes;
++}
++
++/*
++ * To check if given numa node is present.
++ */
++static int is_node_present(int node)
++{
++	return numa_bitmask_isbitset(numa_nodes_ptr, node);
++}
++
++/*
++ * To check given numa node has cpus.
++ */
++static bool node_has_cpus(int node)
++{
++	struct bitmask *cpu = numa_allocate_cpumask();
++	unsigned int i;
++
++	if (cpu && !numa_node_to_cpus(node, cpu)) {
++		for (i = 0; i < cpu->size; i++) {
++			if (numa_bitmask_isbitset(cpu, i))
++				return true;
++		}
++	}
++
++	return false; /* lets fall back to nocpus safely */
++}
++
+ static cpu_set_t bind_to_cpu(int target_cpu)
+ {
+ 	cpu_set_t orig_mask, mask;
+@@ -236,12 +277,12 @@ static cpu_set_t bind_to_cpu(int target_cpu)
+ 
+ static cpu_set_t bind_to_node(int target_node)
+ {
+-	int cpus_per_node = g->p.nr_cpus/g->p.nr_nodes;
++	int cpus_per_node = g->p.nr_cpus / nr_numa_nodes();
+ 	cpu_set_t orig_mask, mask;
+ 	int cpu;
+ 	int ret;
+ 
+-	BUG_ON(cpus_per_node*g->p.nr_nodes != g->p.nr_cpus);
++	BUG_ON(cpus_per_node * nr_numa_nodes() != g->p.nr_cpus);
+ 	BUG_ON(!cpus_per_node);
+ 
+ 	ret = sched_getaffinity(0, sizeof(orig_mask), &orig_mask);
+@@ -641,7 +682,7 @@ static int parse_setup_node_list(void)
+ 			int i;
+ 
+ 			for (i = 0; i < mul; i++) {
+-				if (t >= g->p.nr_tasks) {
++				if (t >= g->p.nr_tasks || !node_has_cpus(bind_node)) {
+ 					printf("\n# NOTE: ignoring bind NODEs starting at NODE#%d\n", bind_node);
+ 					goto out;
+ 				}
+@@ -956,6 +997,8 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
+ 	sum = 0;
+ 
+ 	for (node = 0; node < g->p.nr_nodes; node++) {
++		if (!is_node_present(node))
++			continue;
+ 		nr = nodes[node];
+ 		nr_min = min(nr, nr_min);
+ 		nr_max = max(nr, nr_max);
+@@ -976,8 +1019,11 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
+ 	process_groups = 0;
+ 
+ 	for (node = 0; node < g->p.nr_nodes; node++) {
+-		int processes = count_node_processes(node);
++		int processes;
+ 
++		if (!is_node_present(node))
++			continue;
++		processes = count_node_processes(node);
+ 		nr = nodes[node];
+ 		tprintf(" %2d/%-2d", nr, processes);
+ 
+@@ -1283,7 +1329,7 @@ static void print_summary(void)
+ 
+ 	printf("\n ###\n");
+ 	printf(" # %d %s will execute (on %d nodes, %d CPUs):\n",
+-		g->p.nr_tasks, g->p.nr_tasks == 1 ? "task" : "tasks", g->p.nr_nodes, g->p.nr_cpus);
++		g->p.nr_tasks, g->p.nr_tasks == 1 ? "task" : "tasks", nr_numa_nodes(), g->p.nr_cpus);
+ 	printf(" #      %5dx %5ldMB global  shared mem operations\n",
+ 			g->p.nr_loops, g->p.bytes_global/1024/1024);
+ 	printf(" #      %5dx %5ldMB process shared mem operations\n",
+diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
+index 4a8a02c302d2..47719bde34c6 100644
+--- a/tools/perf/builtin-top.c
++++ b/tools/perf/builtin-top.c
+@@ -70,6 +70,7 @@
+ #include <linux/types.h>
+ 
+ static volatile int done;
++static volatile int resize;
+ 
+ #define HEADER_LINE_NR  5
+ 
+@@ -79,10 +80,13 @@ static void perf_top__update_print_entries(struct perf_top *top)
+ }
+ 
+ static void perf_top__sig_winch(int sig __maybe_unused,
+-				siginfo_t *info __maybe_unused, void *arg)
++				siginfo_t *info __maybe_unused, void *arg __maybe_unused)
+ {
+-	struct perf_top *top = arg;
++	resize = 1;
++}
+ 
++static void perf_top__resize(struct perf_top *top)
++{
+ 	get_term_dimensions(&top->winsize);
+ 	perf_top__update_print_entries(top);
+ }
+@@ -466,7 +470,7 @@ static bool perf_top__handle_keypress(struct perf_top *top, int c)
+ 					.sa_sigaction = perf_top__sig_winch,
+ 					.sa_flags     = SA_SIGINFO,
+ 				};
+-				perf_top__sig_winch(SIGWINCH, NULL, top);
++				perf_top__resize(top);
+ 				sigaction(SIGWINCH, &act, NULL);
+ 			} else {
+ 				signal(SIGWINCH, SIG_DFL);
+@@ -1023,6 +1027,11 @@ static int __cmd_top(struct perf_top *top)
+ 
+ 		if (hits == top->samples)
+ 			ret = perf_evlist__poll(top->evlist, 100);
++
++		if (resize) {
++			perf_top__resize(top);
++			resize = 0;
++		}
+ 	}
+ 
+ 	ret = 0;
+diff --git a/tools/scripts/Makefile.include b/tools/scripts/Makefile.include
+index 8abbef164b4e..19edc1a7a232 100644
+--- a/tools/scripts/Makefile.include
++++ b/tools/scripts/Makefile.include
+@@ -46,6 +46,16 @@ else
+ NO_SUBDIR = :
+ endif
+ 
++ifneq ($(filter 4.%,$(MAKE_VERSION)),)  # make-4
++ifneq ($(filter %s ,$(firstword x$(MAKEFLAGS))),)
++  silent=1
++endif
++else					# make-3.8x
++ifneq ($(filter s% -s%,$(MAKEFLAGS)),)
++  silent=1
++endif
++endif
++
+ #
+ # Define a callable command for descending to a new directory
+ #
+@@ -58,7 +68,7 @@ descend = \
+ QUIET_SUBDIR0  = +$(MAKE) $(COMMAND_O) -C # space to separate -C and subdir
+ QUIET_SUBDIR1  =
+ 
+-ifneq ($(findstring $(MAKEFLAGS),s),s)
++ifneq ($(silent),1)
+   ifneq ($(V),1)
+ 	QUIET_CC       = @echo '  CC       '$@;
+ 	QUIET_CC_FPIC  = @echo '  CC FPIC  '$@;