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

[Mike Pagano]

commit:     322846fef88cdebfc404e238754403f460b16adb
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Fri Feb 15 12:50:48 2019 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Fri Feb 15 12:50:48 2019 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=322846fe

proj/linux-patches: Linux patches 4.14.100 and 4.14.101

Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org>

 0000_README               |    8 +
 1099_linux-4.14.100.patch | 1775 +++++++++++++++++++++++++++++++++++++++++++++
 1100_linux-4.14.101.patch |   35 +
 3 files changed, 1818 insertions(+)

diff --git a/0000_README b/0000_README
index 6e5e8ac..b57a8e5 100644
--- a/0000_README
+++ b/0000_README
@@ -439,6 +439,14 @@ Patch:  1098_4.14.99.patch
 From:   http://www.kernel.org
 Desc:   Linux 4.14.99
 
+Patch:  1099_4.14.100.patch
+From:   http://www.kernel.org
+Desc:   Linux 4.14.100
+
+Patch:  1100_4.14.101.patch
+From:   http://www.kernel.org
+Desc:   Linux 4.14.101
+
 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/1099_linux-4.14.100.patch b/1099_linux-4.14.100.patch
new file mode 100644
index 0000000..d6607d1
--- /dev/null
+++ b/1099_linux-4.14.100.patch
@@ -0,0 +1,1775 @@
+diff --git a/Makefile b/Makefile
+index 3b10c8b542e2..86fa9a371383 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 4
+ PATCHLEVEL = 14
+-SUBLEVEL = 99
++SUBLEVEL = 100
+ EXTRAVERSION =
+ NAME = Petit Gorille
+ 
+diff --git a/arch/arm/mach-iop32x/n2100.c b/arch/arm/mach-iop32x/n2100.c
+index c1cd80ecc219..a904244264ce 100644
+--- a/arch/arm/mach-iop32x/n2100.c
++++ b/arch/arm/mach-iop32x/n2100.c
+@@ -75,8 +75,7 @@ void __init n2100_map_io(void)
+ /*
+  * N2100 PCI.
+  */
+-static int __init
+-n2100_pci_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
++static int n2100_pci_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
+ {
+ 	int irq;
+ 
+diff --git a/arch/arm/mach-tango/pm.c b/arch/arm/mach-tango/pm.c
+index 028e50c6383f..a32c3b631484 100644
+--- a/arch/arm/mach-tango/pm.c
++++ b/arch/arm/mach-tango/pm.c
+@@ -3,6 +3,7 @@
+ #include <linux/suspend.h>
+ #include <asm/suspend.h>
+ #include "smc.h"
++#include "pm.h"
+ 
+ static int tango_pm_powerdown(unsigned long arg)
+ {
+@@ -24,10 +25,7 @@ static const struct platform_suspend_ops tango_pm_ops = {
+ 	.valid = suspend_valid_only_mem,
+ };
+ 
+-static int __init tango_pm_init(void)
++void __init tango_pm_init(void)
+ {
+ 	suspend_set_ops(&tango_pm_ops);
+-	return 0;
+ }
+-
+-late_initcall(tango_pm_init);
+diff --git a/arch/arm/mach-tango/pm.h b/arch/arm/mach-tango/pm.h
+new file mode 100644
+index 000000000000..35ea705a0ee2
+--- /dev/null
++++ b/arch/arm/mach-tango/pm.h
+@@ -0,0 +1,7 @@
++/* SPDX-License-Identifier: GPL-2.0 */
++
++#ifdef CONFIG_SUSPEND
++void __init tango_pm_init(void);
++#else
++#define tango_pm_init NULL
++#endif
+diff --git a/arch/arm/mach-tango/setup.c b/arch/arm/mach-tango/setup.c
+index 677dd7b5efd9..824f90737b04 100644
+--- a/arch/arm/mach-tango/setup.c
++++ b/arch/arm/mach-tango/setup.c
+@@ -2,6 +2,7 @@
+ #include <asm/mach/arch.h>
+ #include <asm/hardware/cache-l2x0.h>
+ #include "smc.h"
++#include "pm.h"
+ 
+ static void tango_l2c_write(unsigned long val, unsigned int reg)
+ {
+@@ -15,4 +16,5 @@ DT_MACHINE_START(TANGO_DT, "Sigma Tango DT")
+ 	.dt_compat	= tango_dt_compat,
+ 	.l2c_aux_mask	= ~0,
+ 	.l2c_write_sec	= tango_l2c_write,
++	.init_late	= tango_pm_init,
+ MACHINE_END
+diff --git a/arch/mips/kernel/mips-cm.c b/arch/mips/kernel/mips-cm.c
+index 8f5bd04f320a..7f3f136572de 100644
+--- a/arch/mips/kernel/mips-cm.c
++++ b/arch/mips/kernel/mips-cm.c
+@@ -457,5 +457,5 @@ void mips_cm_error_report(void)
+ 	}
+ 
+ 	/* reprime cause register */
+-	write_gcr_error_cause(0);
++	write_gcr_error_cause(cm_error);
+ }
+diff --git a/arch/mips/pci/pci-octeon.c b/arch/mips/pci/pci-octeon.c
+index 3e92a06fa772..4adb8f1fcbc7 100644
+--- a/arch/mips/pci/pci-octeon.c
++++ b/arch/mips/pci/pci-octeon.c
+@@ -572,6 +572,11 @@ static int __init octeon_pci_setup(void)
+ 	if (octeon_has_feature(OCTEON_FEATURE_PCIE))
+ 		return 0;
+ 
++	if (!octeon_is_pci_host()) {
++		pr_notice("Not in host mode, PCI Controller not initialized\n");
++		return 0;
++	}
++
+ 	/* Point pcibios_map_irq() to the PCI version of it */
+ 	octeon_pcibios_map_irq = octeon_pci_pcibios_map_irq;
+ 
+@@ -583,11 +588,6 @@ static int __init octeon_pci_setup(void)
+ 	else
+ 		octeon_dma_bar_type = OCTEON_DMA_BAR_TYPE_BIG;
+ 
+-	if (!octeon_is_pci_host()) {
+-		pr_notice("Not in host mode, PCI Controller not initialized\n");
+-		return 0;
+-	}
+-
+ 	/* PCI I/O and PCI MEM values */
+ 	set_io_port_base(OCTEON_PCI_IOSPACE_BASE);
+ 	ioport_resource.start = 0;
+diff --git a/arch/mips/vdso/Makefile b/arch/mips/vdso/Makefile
+index ce196046ac3e..d1a60690e690 100644
+--- a/arch/mips/vdso/Makefile
++++ b/arch/mips/vdso/Makefile
+@@ -121,7 +121,7 @@ $(obj)/%-o32.o: $(src)/%.c FORCE
+ 	$(call cmd,force_checksrc)
+ 	$(call if_changed_rule,cc_o_c)
+ 
+-$(obj)/vdso-o32.lds: KBUILD_CPPFLAGS := -mabi=32
++$(obj)/vdso-o32.lds: KBUILD_CPPFLAGS := $(ccflags-vdso) -mabi=32
+ $(obj)/vdso-o32.lds: $(src)/vdso.lds.S FORCE
+ 	$(call if_changed_dep,cpp_lds_S)
+ 
+@@ -161,7 +161,7 @@ $(obj)/%-n32.o: $(src)/%.c FORCE
+ 	$(call cmd,force_checksrc)
+ 	$(call if_changed_rule,cc_o_c)
+ 
+-$(obj)/vdso-n32.lds: KBUILD_CPPFLAGS := -mabi=n32
++$(obj)/vdso-n32.lds: KBUILD_CPPFLAGS := $(ccflags-vdso) -mabi=n32
+ $(obj)/vdso-n32.lds: $(src)/vdso.lds.S FORCE
+ 	$(call if_changed_dep,cpp_lds_S)
+ 
+diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c
+index 4a3f68a33844..3e3035c9e96b 100644
+--- a/drivers/gpu/drm/drm_modes.c
++++ b/drivers/gpu/drm/drm_modes.c
+@@ -751,7 +751,7 @@ int drm_mode_hsync(const struct drm_display_mode *mode)
+ 	if (mode->hsync)
+ 		return mode->hsync;
+ 
+-	if (mode->htotal < 0)
++	if (mode->htotal <= 0)
+ 		return 0;
+ 
+ 	calc_val = (mode->clock * 1000) / mode->htotal; /* hsync in Hz */
+diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+index 86d25f18aa99..3bc7915097ad 100644
+--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
++++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+@@ -604,13 +604,16 @@ out_fixup:
+ static int vmw_dma_masks(struct vmw_private *dev_priv)
+ {
+ 	struct drm_device *dev = dev_priv->dev;
++	int ret = 0;
+ 
+-	if (intel_iommu_enabled &&
++	ret = dma_set_mask_and_coherent(dev->dev, DMA_BIT_MASK(64));
++	if (dev_priv->map_mode != vmw_dma_phys &&
+ 	    (sizeof(unsigned long) == 4 || vmw_restrict_dma_mask)) {
+ 		DRM_INFO("Restricting DMA addresses to 44 bits.\n");
+-		return dma_set_mask(dev->dev, DMA_BIT_MASK(44));
++		return dma_set_mask_and_coherent(dev->dev, DMA_BIT_MASK(44));
+ 	}
+-	return 0;
++
++	return ret;
+ }
+ #else
+ static int vmw_dma_masks(struct vmw_private *dev_priv)
+diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+index 87e8af5776a3..49c28a48c5ab 100644
+--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
++++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+@@ -3818,7 +3818,7 @@ int vmw_execbuf_fence_commands(struct drm_file *file_priv,
+ 		*p_fence = NULL;
+ 	}
+ 
+-	return 0;
++	return ret;
+ }
+ 
+ /**
+diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
+index ae8c8e66a6c4..a90967cd4987 100644
+--- a/drivers/hid/hid-debug.c
++++ b/drivers/hid/hid-debug.c
+@@ -30,6 +30,7 @@
+ 
+ #include <linux/debugfs.h>
+ #include <linux/seq_file.h>
++#include <linux/kfifo.h>
+ #include <linux/sched/signal.h>
+ #include <linux/export.h>
+ #include <linux/slab.h>
+@@ -457,7 +458,7 @@ static char *resolv_usage_page(unsigned page, struct seq_file *f) {
+ 	char *buf = NULL;
+ 
+ 	if (!f) {
+-		buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
++		buf = kzalloc(HID_DEBUG_BUFSIZE, GFP_ATOMIC);
+ 		if (!buf)
+ 			return ERR_PTR(-ENOMEM);
+ 	}
+@@ -661,17 +662,12 @@ EXPORT_SYMBOL_GPL(hid_dump_device);
+ /* enqueue string to 'events' ring buffer */
+ void hid_debug_event(struct hid_device *hdev, char *buf)
+ {
+-	unsigned i;
+ 	struct hid_debug_list *list;
+ 	unsigned long flags;
+ 
+ 	spin_lock_irqsave(&hdev->debug_list_lock, flags);
+-	list_for_each_entry(list, &hdev->debug_list, node) {
+-		for (i = 0; buf[i]; i++)
+-			list->hid_debug_buf[(list->tail + i) % HID_DEBUG_BUFSIZE] =
+-				buf[i];
+-		list->tail = (list->tail + i) % HID_DEBUG_BUFSIZE;
+-        }
++	list_for_each_entry(list, &hdev->debug_list, node)
++		kfifo_in(&list->hid_debug_fifo, buf, strlen(buf));
+ 	spin_unlock_irqrestore(&hdev->debug_list_lock, flags);
+ 
+ 	wake_up_interruptible(&hdev->debug_wait);
+@@ -722,8 +718,7 @@ void hid_dump_input(struct hid_device *hdev, struct hid_usage *usage, __s32 valu
+ 	hid_debug_event(hdev, buf);
+ 
+ 	kfree(buf);
+-        wake_up_interruptible(&hdev->debug_wait);
+-
++	wake_up_interruptible(&hdev->debug_wait);
+ }
+ EXPORT_SYMBOL_GPL(hid_dump_input);
+ 
+@@ -1088,8 +1083,8 @@ static int hid_debug_events_open(struct inode *inode, struct file *file)
+ 		goto out;
+ 	}
+ 
+-	if (!(list->hid_debug_buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_KERNEL))) {
+-		err = -ENOMEM;
++	err = kfifo_alloc(&list->hid_debug_fifo, HID_DEBUG_FIFOSIZE, GFP_KERNEL);
++	if (err) {
+ 		kfree(list);
+ 		goto out;
+ 	}
+@@ -1109,77 +1104,57 @@ static ssize_t hid_debug_events_read(struct file *file, char __user *buffer,
+ 		size_t count, loff_t *ppos)
+ {
+ 	struct hid_debug_list *list = file->private_data;
+-	int ret = 0, len;
++	int ret = 0, copied;
+ 	DECLARE_WAITQUEUE(wait, current);
+ 
+ 	mutex_lock(&list->read_mutex);
+-	while (ret == 0) {
+-		if (list->head == list->tail) {
+-			add_wait_queue(&list->hdev->debug_wait, &wait);
+-			set_current_state(TASK_INTERRUPTIBLE);
+-
+-			while (list->head == list->tail) {
+-				if (file->f_flags & O_NONBLOCK) {
+-					ret = -EAGAIN;
+-					break;
+-				}
+-				if (signal_pending(current)) {
+-					ret = -ERESTARTSYS;
+-					break;
+-				}
++	if (kfifo_is_empty(&list->hid_debug_fifo)) {
++		add_wait_queue(&list->hdev->debug_wait, &wait);
++		set_current_state(TASK_INTERRUPTIBLE);
++
++		while (kfifo_is_empty(&list->hid_debug_fifo)) {
++			if (file->f_flags & O_NONBLOCK) {
++				ret = -EAGAIN;
++				break;
++			}
+ 
+-				if (!list->hdev || !list->hdev->debug) {
+-					ret = -EIO;
+-					set_current_state(TASK_RUNNING);
+-					goto out;
+-				}
++			if (signal_pending(current)) {
++				ret = -ERESTARTSYS;
++				break;
++			}
+ 
+-				/* allow O_NONBLOCK from other threads */
+-				mutex_unlock(&list->read_mutex);
+-				schedule();
+-				mutex_lock(&list->read_mutex);
+-				set_current_state(TASK_INTERRUPTIBLE);
++			/* if list->hdev is NULL we cannot remove_wait_queue().
++			 * if list->hdev->debug is 0 then hid_debug_unregister()
++			 * was already called and list->hdev is being destroyed.
++			 * if we add remove_wait_queue() here we can hit a race.
++			 */
++			if (!list->hdev || !list->hdev->debug) {
++				ret = -EIO;
++				set_current_state(TASK_RUNNING);
++				goto out;
+ 			}
+ 
+-			set_current_state(TASK_RUNNING);
+-			remove_wait_queue(&list->hdev->debug_wait, &wait);
++			/* allow O_NONBLOCK from other threads */
++			mutex_unlock(&list->read_mutex);
++			schedule();
++			mutex_lock(&list->read_mutex);
++			set_current_state(TASK_INTERRUPTIBLE);
+ 		}
+ 
+-		if (ret)
+-			goto out;
++		__set_current_state(TASK_RUNNING);
++		remove_wait_queue(&list->hdev->debug_wait, &wait);
+ 
+-		/* pass the ringbuffer contents to userspace */
+-copy_rest:
+-		if (list->tail == list->head)
++		if (ret)
+ 			goto out;
+-		if (list->tail > list->head) {
+-			len = list->tail - list->head;
+-			if (len > count)
+-				len = count;
+-
+-			if (copy_to_user(buffer + ret, &list->hid_debug_buf[list->head], len)) {
+-				ret = -EFAULT;
+-				goto out;
+-			}
+-			ret += len;
+-			list->head += len;
+-		} else {
+-			len = HID_DEBUG_BUFSIZE - list->head;
+-			if (len > count)
+-				len = count;
+-
+-			if (copy_to_user(buffer, &list->hid_debug_buf[list->head], len)) {
+-				ret = -EFAULT;
+-				goto out;
+-			}
+-			list->head = 0;
+-			ret += len;
+-			count -= len;
+-			if (count > 0)
+-				goto copy_rest;
+-		}
+-
+ 	}
++
++	/* pass the fifo content to userspace, locking is not needed with only
++	 * one concurrent reader and one concurrent writer
++	 */
++	ret = kfifo_to_user(&list->hid_debug_fifo, buffer, count, &copied);
++	if (ret)
++		goto out;
++	ret = copied;
+ out:
+ 	mutex_unlock(&list->read_mutex);
+ 	return ret;
+@@ -1190,7 +1165,7 @@ static unsigned int hid_debug_events_poll(struct file *file, poll_table *wait)
+ 	struct hid_debug_list *list = file->private_data;
+ 
+ 	poll_wait(file, &list->hdev->debug_wait, wait);
+-	if (list->head != list->tail)
++	if (!kfifo_is_empty(&list->hid_debug_fifo))
+ 		return POLLIN | POLLRDNORM;
+ 	if (!list->hdev->debug)
+ 		return POLLERR | POLLHUP;
+@@ -1205,7 +1180,7 @@ static int hid_debug_events_release(struct inode *inode, struct file *file)
+ 	spin_lock_irqsave(&list->hdev->debug_list_lock, flags);
+ 	list_del(&list->node);
+ 	spin_unlock_irqrestore(&list->hdev->debug_list_lock, flags);
+-	kfree(list->hid_debug_buf);
++	kfifo_free(&list->hid_debug_fifo);
+ 	kfree(list);
+ 
+ 	return 0;
+@@ -1256,4 +1231,3 @@ void hid_debug_exit(void)
+ {
+ 	debugfs_remove_recursive(hid_debug_root);
+ }
+-
+diff --git a/drivers/iio/adc/axp288_adc.c b/drivers/iio/adc/axp288_adc.c
+index 462a99c13e7a..0153df01e7b6 100644
+--- a/drivers/iio/adc/axp288_adc.c
++++ b/drivers/iio/adc/axp288_adc.c
+@@ -27,9 +27,18 @@
+ #include <linux/iio/machine.h>
+ #include <linux/iio/driver.h>
+ 
+-#define AXP288_ADC_EN_MASK		0xF1
+-#define AXP288_ADC_TS_PIN_GPADC		0xF2
+-#define AXP288_ADC_TS_PIN_ON		0xF3
++/*
++ * This mask enables all ADCs except for the battery temp-sensor (TS), that is
++ * left as-is to avoid breaking charging on devices without a temp-sensor.
++ */
++#define AXP288_ADC_EN_MASK				0xF0
++#define AXP288_ADC_TS_ENABLE				0x01
++
++#define AXP288_ADC_TS_CURRENT_ON_OFF_MASK		GENMASK(1, 0)
++#define AXP288_ADC_TS_CURRENT_OFF			(0 << 0)
++#define AXP288_ADC_TS_CURRENT_ON_WHEN_CHARGING		(1 << 0)
++#define AXP288_ADC_TS_CURRENT_ON_ONDEMAND		(2 << 0)
++#define AXP288_ADC_TS_CURRENT_ON			(3 << 0)
+ 
+ enum axp288_adc_id {
+ 	AXP288_ADC_TS,
+@@ -44,6 +53,7 @@ enum axp288_adc_id {
+ struct axp288_adc_info {
+ 	int irq;
+ 	struct regmap *regmap;
++	bool ts_enabled;
+ };
+ 
+ static const struct iio_chan_spec axp288_adc_channels[] = {
+@@ -123,21 +133,33 @@ static int axp288_adc_read_channel(int *val, unsigned long address,
+ 	return IIO_VAL_INT;
+ }
+ 
+-static int axp288_adc_set_ts(struct regmap *regmap, unsigned int mode,
+-				unsigned long address)
++/*
++ * The current-source used for the battery temp-sensor (TS) is shared
++ * with the GPADC. For proper fuel-gauge and charger operation the TS
++ * current-source needs to be permanently on. But to read the GPADC we
++ * need to temporary switch the TS current-source to ondemand, so that
++ * the GPADC can use it, otherwise we will always read an all 0 value.
++ */
++static int axp288_adc_set_ts(struct axp288_adc_info *info,
++			     unsigned int mode, unsigned long address)
+ {
+ 	int ret;
+ 
+-	/* channels other than GPADC do not need to switch TS pin */
++	/* No need to switch the current-source if the TS pin is disabled */
++	if (!info->ts_enabled)
++		return 0;
++
++	/* Channels other than GPADC do not need the current source */
+ 	if (address != AXP288_GP_ADC_H)
+ 		return 0;
+ 
+-	ret = regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, mode);
++	ret = regmap_update_bits(info->regmap, AXP288_ADC_TS_PIN_CTRL,
++				 AXP288_ADC_TS_CURRENT_ON_OFF_MASK, mode);
+ 	if (ret)
+ 		return ret;
+ 
+ 	/* When switching to the GPADC pin give things some time to settle */
+-	if (mode == AXP288_ADC_TS_PIN_GPADC)
++	if (mode == AXP288_ADC_TS_CURRENT_ON_ONDEMAND)
+ 		usleep_range(6000, 10000);
+ 
+ 	return 0;
+@@ -153,14 +175,14 @@ static int axp288_adc_read_raw(struct iio_dev *indio_dev,
+ 	mutex_lock(&indio_dev->mlock);
+ 	switch (mask) {
+ 	case IIO_CHAN_INFO_RAW:
+-		if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_GPADC,
++		if (axp288_adc_set_ts(info, AXP288_ADC_TS_CURRENT_ON_ONDEMAND,
+ 					chan->address)) {
+ 			dev_err(&indio_dev->dev, "GPADC mode\n");
+ 			ret = -EINVAL;
+ 			break;
+ 		}
+ 		ret = axp288_adc_read_channel(val, chan->address, info->regmap);
+-		if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_ON,
++		if (axp288_adc_set_ts(info, AXP288_ADC_TS_CURRENT_ON,
+ 						chan->address))
+ 			dev_err(&indio_dev->dev, "TS pin restore\n");
+ 		break;
+@@ -172,13 +194,35 @@ static int axp288_adc_read_raw(struct iio_dev *indio_dev,
+ 	return ret;
+ }
+ 
+-static int axp288_adc_set_state(struct regmap *regmap)
++static int axp288_adc_initialize(struct axp288_adc_info *info)
+ {
+-	/* ADC should be always enabled for internal FG to function */
+-	if (regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, AXP288_ADC_TS_PIN_ON))
+-		return -EIO;
++	int ret, adc_enable_val;
++
++	/*
++	 * Determine if the TS pin is enabled and set the TS current-source
++	 * accordingly.
++	 */
++	ret = regmap_read(info->regmap, AXP20X_ADC_EN1, &adc_enable_val);
++	if (ret)
++		return ret;
++
++	if (adc_enable_val & AXP288_ADC_TS_ENABLE) {
++		info->ts_enabled = true;
++		ret = regmap_update_bits(info->regmap, AXP288_ADC_TS_PIN_CTRL,
++					 AXP288_ADC_TS_CURRENT_ON_OFF_MASK,
++					 AXP288_ADC_TS_CURRENT_ON);
++	} else {
++		info->ts_enabled = false;
++		ret = regmap_update_bits(info->regmap, AXP288_ADC_TS_PIN_CTRL,
++					 AXP288_ADC_TS_CURRENT_ON_OFF_MASK,
++					 AXP288_ADC_TS_CURRENT_OFF);
++	}
++	if (ret)
++		return ret;
+ 
+-	return regmap_write(regmap, AXP20X_ADC_EN1, AXP288_ADC_EN_MASK);
++	/* Turn on the ADC for all channels except TS, leave TS as is */
++	return regmap_update_bits(info->regmap, AXP20X_ADC_EN1,
++				  AXP288_ADC_EN_MASK, AXP288_ADC_EN_MASK);
+ }
+ 
+ static const struct iio_info axp288_adc_iio_info = {
+@@ -209,7 +253,7 @@ static int axp288_adc_probe(struct platform_device *pdev)
+ 	 * Set ADC to enabled state at all time, including system suspend.
+ 	 * otherwise internal fuel gauge functionality may be affected.
+ 	 */
+-	ret = axp288_adc_set_state(axp20x->regmap);
++	ret = axp288_adc_initialize(info);
+ 	if (ret) {
+ 		dev_err(&pdev->dev, "unable to enable ADC device\n");
+ 		return ret;
+diff --git a/drivers/iio/chemical/atlas-ph-sensor.c b/drivers/iio/chemical/atlas-ph-sensor.c
+index ef761a508630..dad2a8be6830 100644
+--- a/drivers/iio/chemical/atlas-ph-sensor.c
++++ b/drivers/iio/chemical/atlas-ph-sensor.c
+@@ -453,9 +453,8 @@ static int atlas_read_raw(struct iio_dev *indio_dev,
+ 	case IIO_CHAN_INFO_SCALE:
+ 		switch (chan->type) {
+ 		case IIO_TEMP:
+-			*val = 1; /* 0.01 */
+-			*val2 = 100;
+-			break;
++			*val = 10;
++			return IIO_VAL_INT;
+ 		case IIO_PH:
+ 			*val = 1; /* 0.001 */
+ 			*val2 = 1000;
+@@ -486,7 +485,7 @@ static int atlas_write_raw(struct iio_dev *indio_dev,
+ 			   int val, int val2, long mask)
+ {
+ 	struct atlas_data *data = iio_priv(indio_dev);
+-	__be32 reg = cpu_to_be32(val);
++	__be32 reg = cpu_to_be32(val / 10);
+ 
+ 	if (val2 != 0 || val < 0 || val > 20000)
+ 		return -EINVAL;
+diff --git a/drivers/misc/vexpress-syscfg.c b/drivers/misc/vexpress-syscfg.c
+index 2cde80c7bb93..9b4eba41ee5d 100644
+--- a/drivers/misc/vexpress-syscfg.c
++++ b/drivers/misc/vexpress-syscfg.c
+@@ -61,7 +61,7 @@ static int vexpress_syscfg_exec(struct vexpress_syscfg_func *func,
+ 	int tries;
+ 	long timeout;
+ 
+-	if (WARN_ON(index > func->num_templates))
++	if (WARN_ON(index >= func->num_templates))
+ 		return -EINVAL;
+ 
+ 	command = readl(syscfg->base + SYS_CFGCTRL);
+diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-lib.c b/drivers/mtd/nand/gpmi-nand/gpmi-lib.c
+index 97787246af41..55e369b6b862 100644
+--- a/drivers/mtd/nand/gpmi-nand/gpmi-lib.c
++++ b/drivers/mtd/nand/gpmi-nand/gpmi-lib.c
+@@ -168,9 +168,10 @@ int gpmi_init(struct gpmi_nand_data *this)
+ 
+ 	/*
+ 	 * Reset BCH here, too. We got failures otherwise :(
+-	 * See later BCH reset for explanation of MX23 handling
++	 * See later BCH reset for explanation of MX23 and MX28 handling
+ 	 */
+-	ret = gpmi_reset_block(r->bch_regs, GPMI_IS_MX23(this));
++	ret = gpmi_reset_block(r->bch_regs,
++			       GPMI_IS_MX23(this) || GPMI_IS_MX28(this));
+ 	if (ret)
+ 		goto err_out;
+ 
+@@ -275,13 +276,11 @@ int bch_set_geometry(struct gpmi_nand_data *this)
+ 
+ 	/*
+ 	* Due to erratum #2847 of the MX23, the BCH cannot be soft reset on this
+-	* chip, otherwise it will lock up. So we skip resetting BCH on the MX23.
+-	* On the other hand, the MX28 needs the reset, because one case has been
+-	* seen where the BCH produced ECC errors constantly after 10000
+-	* consecutive reboots. The latter case has not been seen on the MX23
+-	* yet, still we don't know if it could happen there as well.
++	* chip, otherwise it will lock up. So we skip resetting BCH on the MX23
++	* and MX28.
+ 	*/
+-	ret = gpmi_reset_block(r->bch_regs, GPMI_IS_MX23(this));
++	ret = gpmi_reset_block(r->bch_regs,
++			       GPMI_IS_MX23(this) || GPMI_IS_MX28(this));
+ 	if (ret)
+ 		goto err_out;
+ 
+diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
+index 654579bc1e54..fb5c9701b1fb 100644
+--- a/drivers/uio/uio.c
++++ b/drivers/uio/uio.c
+@@ -215,7 +215,20 @@ static ssize_t name_show(struct device *dev,
+ 			 struct device_attribute *attr, char *buf)
+ {
+ 	struct uio_device *idev = dev_get_drvdata(dev);
+-	return sprintf(buf, "%s\n", idev->info->name);
++	int ret;
++
++	mutex_lock(&idev->info_lock);
++	if (!idev->info) {
++		ret = -EINVAL;
++		dev_err(dev, "the device has been unregistered\n");
++		goto out;
++	}
++
++	ret = sprintf(buf, "%s\n", idev->info->name);
++
++out:
++	mutex_unlock(&idev->info_lock);
++	return ret;
+ }
+ static DEVICE_ATTR_RO(name);
+ 
+@@ -223,7 +236,20 @@ static ssize_t version_show(struct device *dev,
+ 			    struct device_attribute *attr, char *buf)
+ {
+ 	struct uio_device *idev = dev_get_drvdata(dev);
+-	return sprintf(buf, "%s\n", idev->info->version);
++	int ret;
++
++	mutex_lock(&idev->info_lock);
++	if (!idev->info) {
++		ret = -EINVAL;
++		dev_err(dev, "the device has been unregistered\n");
++		goto out;
++	}
++
++	ret = sprintf(buf, "%s\n", idev->info->version);
++
++out:
++	mutex_unlock(&idev->info_lock);
++	return ret;
+ }
+ static DEVICE_ATTR_RO(version);
+ 
+@@ -272,7 +298,7 @@ static int uio_dev_add_attributes(struct uio_device *idev)
+ 		if (!map_found) {
+ 			map_found = 1;
+ 			idev->map_dir = kobject_create_and_add("maps",
+-							&idev->dev->kobj);
++							&idev->dev.kobj);
+ 			if (!idev->map_dir) {
+ 				ret = -ENOMEM;
+ 				goto err_map;
+@@ -301,7 +327,7 @@ static int uio_dev_add_attributes(struct uio_device *idev)
+ 		if (!portio_found) {
+ 			portio_found = 1;
+ 			idev->portio_dir = kobject_create_and_add("portio",
+-							&idev->dev->kobj);
++							&idev->dev.kobj);
+ 			if (!idev->portio_dir) {
+ 				ret = -ENOMEM;
+ 				goto err_portio;
+@@ -344,7 +370,7 @@ err_map_kobj:
+ 		kobject_put(&map->kobj);
+ 	}
+ 	kobject_put(idev->map_dir);
+-	dev_err(idev->dev, "error creating sysfs files (%d)\n", ret);
++	dev_err(&idev->dev, "error creating sysfs files (%d)\n", ret);
+ 	return ret;
+ }
+ 
+@@ -381,7 +407,7 @@ static int uio_get_minor(struct uio_device *idev)
+ 		idev->minor = retval;
+ 		retval = 0;
+ 	} else if (retval == -ENOSPC) {
+-		dev_err(idev->dev, "too many uio devices\n");
++		dev_err(&idev->dev, "too many uio devices\n");
+ 		retval = -EINVAL;
+ 	}
+ 	mutex_unlock(&minor_lock);
+@@ -417,8 +443,9 @@ EXPORT_SYMBOL_GPL(uio_event_notify);
+ static irqreturn_t uio_interrupt(int irq, void *dev_id)
+ {
+ 	struct uio_device *idev = (struct uio_device *)dev_id;
+-	irqreturn_t ret = idev->info->handler(irq, idev->info);
++	irqreturn_t ret;
+ 
++	ret = idev->info->handler(irq, idev->info);
+ 	if (ret == IRQ_HANDLED)
+ 		uio_event_notify(idev->info);
+ 
+@@ -444,9 +471,11 @@ static int uio_open(struct inode *inode, struct file *filep)
+ 		goto out;
+ 	}
+ 
++	get_device(&idev->dev);
++
+ 	if (!try_module_get(idev->owner)) {
+ 		ret = -ENODEV;
+-		goto out;
++		goto err_module_get;
+ 	}
+ 
+ 	listener = kmalloc(sizeof(*listener), GFP_KERNEL);
+@@ -459,11 +488,19 @@ static int uio_open(struct inode *inode, struct file *filep)
+ 	listener->event_count = atomic_read(&idev->event);
+ 	filep->private_data = listener;
+ 
+-	if (idev->info->open) {
+-		ret = idev->info->open(idev->info, inode);
+-		if (ret)
+-			goto err_infoopen;
++	mutex_lock(&idev->info_lock);
++	if (!idev->info) {
++		mutex_unlock(&idev->info_lock);
++		ret = -EINVAL;
++		goto err_alloc_listener;
+ 	}
++
++	if (idev->info && idev->info->open)
++		ret = idev->info->open(idev->info, inode);
++	mutex_unlock(&idev->info_lock);
++	if (ret)
++		goto err_infoopen;
++
+ 	return 0;
+ 
+ err_infoopen:
+@@ -472,6 +509,9 @@ err_infoopen:
+ err_alloc_listener:
+ 	module_put(idev->owner);
+ 
++err_module_get:
++	put_device(&idev->dev);
++
+ out:
+ 	return ret;
+ }
+@@ -490,11 +530,14 @@ static int uio_release(struct inode *inode, struct file *filep)
+ 	struct uio_listener *listener = filep->private_data;
+ 	struct uio_device *idev = listener->dev;
+ 
+-	if (idev->info->release)
++	mutex_lock(&idev->info_lock);
++	if (idev->info && idev->info->release)
+ 		ret = idev->info->release(idev->info, inode);
++	mutex_unlock(&idev->info_lock);
+ 
+ 	module_put(idev->owner);
+ 	kfree(listener);
++	put_device(&idev->dev);
+ 	return ret;
+ }
+ 
+@@ -502,9 +545,15 @@ static unsigned int uio_poll(struct file *filep, poll_table *wait)
+ {
+ 	struct uio_listener *listener = filep->private_data;
+ 	struct uio_device *idev = listener->dev;
++	unsigned int ret = 0;
+ 
+-	if (!idev->info->irq)
+-		return -EIO;
++	mutex_lock(&idev->info_lock);
++	if (!idev->info || !idev->info->irq)
++		ret = -EIO;
++	mutex_unlock(&idev->info_lock);
++
++	if (ret)
++		return ret;
+ 
+ 	poll_wait(filep, &idev->wait, wait);
+ 	if (listener->event_count != atomic_read(&idev->event))
+@@ -518,11 +567,16 @@ static ssize_t uio_read(struct file *filep, char __user *buf,
+ 	struct uio_listener *listener = filep->private_data;
+ 	struct uio_device *idev = listener->dev;
+ 	DECLARE_WAITQUEUE(wait, current);
+-	ssize_t retval;
++	ssize_t retval = 0;
+ 	s32 event_count;
+ 
+-	if (!idev->info->irq)
+-		return -EIO;
++	mutex_lock(&idev->info_lock);
++	if (!idev->info || !idev->info->irq)
++		retval = -EIO;
++	mutex_unlock(&idev->info_lock);
++
++	if (retval)
++		return retval;
+ 
+ 	if (count != sizeof(s32))
+ 		return -EINVAL;
+@@ -570,20 +624,32 @@ static ssize_t uio_write(struct file *filep, const char __user *buf,
+ 	ssize_t retval;
+ 	s32 irq_on;
+ 
+-	if (!idev->info->irq)
+-		return -EIO;
+-
+ 	if (count != sizeof(s32))
+ 		return -EINVAL;
+ 
+-	if (!idev->info->irqcontrol)
+-		return -ENOSYS;
+-
+ 	if (copy_from_user(&irq_on, buf, count))
+ 		return -EFAULT;
+ 
++	mutex_lock(&idev->info_lock);
++	if (!idev->info) {
++		retval = -EINVAL;
++		goto out;
++	}
++
++	if (!idev->info || !idev->info->irq) {
++		retval = -EIO;
++		goto out;
++	}
++
++	if (!idev->info->irqcontrol) {
++		retval = -ENOSYS;
++		goto out;
++	}
++
+ 	retval = idev->info->irqcontrol(idev->info, irq_on);
+ 
++out:
++	mutex_unlock(&idev->info_lock);
+ 	return retval ? retval : sizeof(s32);
+ }
+ 
+@@ -605,10 +671,20 @@ static int uio_vma_fault(struct vm_fault *vmf)
+ 	struct page *page;
+ 	unsigned long offset;
+ 	void *addr;
++	int ret = 0;
++	int mi;
+ 
+-	int mi = uio_find_mem_index(vmf->vma);
+-	if (mi < 0)
+-		return VM_FAULT_SIGBUS;
++	mutex_lock(&idev->info_lock);
++	if (!idev->info) {
++		ret = VM_FAULT_SIGBUS;
++		goto out;
++	}
++
++	mi = uio_find_mem_index(vmf->vma);
++	if (mi < 0) {
++		ret = VM_FAULT_SIGBUS;
++		goto out;
++	}
+ 
+ 	/*
+ 	 * We need to subtract mi because userspace uses offset = N*PAGE_SIZE
+@@ -623,7 +699,11 @@ static int uio_vma_fault(struct vm_fault *vmf)
+ 		page = vmalloc_to_page(addr);
+ 	get_page(page);
+ 	vmf->page = page;
+-	return 0;
++
++out:
++	mutex_unlock(&idev->info_lock);
++
++	return ret;
+ }
+ 
+ static const struct vm_operations_struct uio_logical_vm_ops = {
+@@ -648,6 +728,7 @@ static int uio_mmap_physical(struct vm_area_struct *vma)
+ 	struct uio_device *idev = vma->vm_private_data;
+ 	int mi = uio_find_mem_index(vma);
+ 	struct uio_mem *mem;
++
+ 	if (mi < 0)
+ 		return -EINVAL;
+ 	mem = idev->info->mem + mi;
+@@ -689,30 +770,46 @@ static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
+ 
+ 	vma->vm_private_data = idev;
+ 
++	mutex_lock(&idev->info_lock);
++	if (!idev->info) {
++		ret = -EINVAL;
++		goto out;
++	}
++
+ 	mi = uio_find_mem_index(vma);
+-	if (mi < 0)
+-		return -EINVAL;
++	if (mi < 0) {
++		ret = -EINVAL;
++		goto out;
++	}
+ 
+ 	requested_pages = vma_pages(vma);
+ 	actual_pages = ((idev->info->mem[mi].addr & ~PAGE_MASK)
+ 			+ idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT;
+-	if (requested_pages > actual_pages)
+-		return -EINVAL;
++	if (requested_pages > actual_pages) {
++		ret = -EINVAL;
++		goto out;
++	}
+ 
+ 	if (idev->info->mmap) {
+ 		ret = idev->info->mmap(idev->info, vma);
+-		return ret;
++		goto out;
+ 	}
+ 
+ 	switch (idev->info->mem[mi].memtype) {
+ 		case UIO_MEM_PHYS:
+-			return uio_mmap_physical(vma);
++			ret = uio_mmap_physical(vma);
++			break;
+ 		case UIO_MEM_LOGICAL:
+ 		case UIO_MEM_VIRTUAL:
+-			return uio_mmap_logical(vma);
++			ret = uio_mmap_logical(vma);
++			break;
+ 		default:
+-			return -EINVAL;
++			ret = -EINVAL;
+ 	}
++
++out:
++	mutex_unlock(&idev->info_lock);
++	return ret;
+ }
+ 
+ static const struct file_operations uio_fops = {
+@@ -800,6 +897,13 @@ static void release_uio_class(void)
+ 	uio_major_cleanup();
+ }
+ 
++static void uio_device_release(struct device *dev)
++{
++	struct uio_device *idev = dev_get_drvdata(dev);
++
++	kfree(idev);
++}
++
+ /**
+  * uio_register_device - register a new userspace IO device
+  * @owner:	module that creates the new device
+@@ -823,13 +927,14 @@ int __uio_register_device(struct module *owner,
+ 
+ 	info->uio_dev = NULL;
+ 
+-	idev = devm_kzalloc(parent, sizeof(*idev), GFP_KERNEL);
++	idev = kzalloc(sizeof(*idev), GFP_KERNEL);
+ 	if (!idev) {
+ 		return -ENOMEM;
+ 	}
+ 
+ 	idev->owner = owner;
+ 	idev->info = info;
++	mutex_init(&idev->info_lock);
+ 	init_waitqueue_head(&idev->wait);
+ 	atomic_set(&idev->event, 0);
+ 
+@@ -837,14 +942,19 @@ int __uio_register_device(struct module *owner,
+ 	if (ret)
+ 		return ret;
+ 
+-	idev->dev = device_create(&uio_class, parent,
+-				  MKDEV(uio_major, idev->minor), idev,
+-				  "uio%d", idev->minor);
+-	if (IS_ERR(idev->dev)) {
+-		printk(KERN_ERR "UIO: device register failed\n");
+-		ret = PTR_ERR(idev->dev);
++	idev->dev.devt = MKDEV(uio_major, idev->minor);
++	idev->dev.class = &uio_class;
++	idev->dev.parent = parent;
++	idev->dev.release = uio_device_release;
++	dev_set_drvdata(&idev->dev, idev);
++
++	ret = dev_set_name(&idev->dev, "uio%d", idev->minor);
++	if (ret)
++		goto err_device_create;
++
++	ret = device_register(&idev->dev);
++	if (ret)
+ 		goto err_device_create;
+-	}
+ 
+ 	ret = uio_dev_add_attributes(idev);
+ 	if (ret)
+@@ -874,7 +984,7 @@ int __uio_register_device(struct module *owner,
+ err_request_irq:
+ 	uio_dev_del_attributes(idev);
+ err_uio_dev_add_attributes:
+-	device_destroy(&uio_class, MKDEV(uio_major, idev->minor));
++	device_unregister(&idev->dev);
+ err_device_create:
+ 	uio_free_minor(idev);
+ 	return ret;
+@@ -897,12 +1007,16 @@ void uio_unregister_device(struct uio_info *info)
+ 
+ 	uio_free_minor(idev);
+ 
++	mutex_lock(&idev->info_lock);
+ 	uio_dev_del_attributes(idev);
+ 
+ 	if (info->irq && info->irq != UIO_IRQ_CUSTOM)
+ 		free_irq(info->irq, idev);
+ 
+-	device_destroy(&uio_class, MKDEV(uio_major, idev->minor));
++	idev->info = NULL;
++	mutex_unlock(&idev->info_lock);
++
++	device_unregister(&idev->dev);
+ 
+ 	return;
+ }
+diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
+index c59f015f386e..ccfe1e1cb6bc 100644
+--- a/fs/debugfs/inode.c
++++ b/fs/debugfs/inode.c
+@@ -766,6 +766,13 @@ struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
+ 	struct dentry *dentry = NULL, *trap;
+ 	struct name_snapshot old_name;
+ 
++	if (IS_ERR(old_dir))
++		return old_dir;
++	if (IS_ERR(new_dir))
++		return new_dir;
++	if (IS_ERR_OR_NULL(old_dentry))
++		return old_dentry;
++
+ 	trap = lock_rename(new_dir, old_dir);
+ 	/* Source or destination directories don't exist? */
+ 	if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
+diff --git a/fs/ext4/fsync.c b/fs/ext4/fsync.c
+index 712f00995390..5508baa11bb6 100644
+--- a/fs/ext4/fsync.c
++++ b/fs/ext4/fsync.c
+@@ -116,16 +116,8 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
+ 		goto out;
+ 	}
+ 
+-	ret = file_write_and_wait_range(file, start, end);
+-	if (ret)
+-		return ret;
+-
+ 	if (!journal) {
+-		struct writeback_control wbc = {
+-			.sync_mode = WB_SYNC_ALL
+-		};
+-
+-		ret = ext4_write_inode(inode, &wbc);
++		ret = __generic_file_fsync(file, start, end, datasync);
+ 		if (!ret)
+ 			ret = ext4_sync_parent(inode);
+ 		if (test_opt(inode->i_sb, BARRIER))
+@@ -133,6 +125,9 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
+ 		goto out;
+ 	}
+ 
++	ret = file_write_and_wait_range(file, start, end);
++	if (ret)
++		return ret;
+ 	/*
+ 	 * data=writeback,ordered:
+ 	 *  The caller's filemap_fdatawrite()/wait will sync the data.
+diff --git a/include/linux/hid-debug.h b/include/linux/hid-debug.h
+index 8663f216c563..2d6100edf204 100644
+--- a/include/linux/hid-debug.h
++++ b/include/linux/hid-debug.h
+@@ -24,7 +24,10 @@
+ 
+ #ifdef CONFIG_DEBUG_FS
+ 
++#include <linux/kfifo.h>
++
+ #define HID_DEBUG_BUFSIZE 512
++#define HID_DEBUG_FIFOSIZE 512
+ 
+ void hid_dump_input(struct hid_device *, struct hid_usage *, __s32);
+ void hid_dump_report(struct hid_device *, int , u8 *, int);
+@@ -37,11 +40,8 @@ void hid_debug_init(void);
+ void hid_debug_exit(void);
+ void hid_debug_event(struct hid_device *, char *);
+ 
+-
+ struct hid_debug_list {
+-	char *hid_debug_buf;
+-	int head;
+-	int tail;
++	DECLARE_KFIFO_PTR(hid_debug_fifo, char);
+ 	struct fasync_struct *fasync;
+ 	struct hid_device *hdev;
+ 	struct list_head node;
+@@ -64,4 +64,3 @@ struct hid_debug_list {
+ #endif
+ 
+ #endif
+-
+diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
+index 3c85c81b0027..6f8b68cd460f 100644
+--- a/include/linux/uio_driver.h
++++ b/include/linux/uio_driver.h
+@@ -14,6 +14,7 @@
+ #ifndef _UIO_DRIVER_H_
+ #define _UIO_DRIVER_H_
+ 
++#include <linux/device.h>
+ #include <linux/fs.h>
+ #include <linux/interrupt.h>
+ 
+@@ -68,12 +69,13 @@ struct uio_port {
+ 
+ struct uio_device {
+         struct module           *owner;
+-        struct device           *dev;
++	struct device		dev;
+         int                     minor;
+         atomic_t                event;
+         struct fasync_struct    *async_queue;
+         wait_queue_head_t       wait;
+         struct uio_info         *info;
++	struct mutex		info_lock;
+         struct kobject          *map_dir;
+         struct kobject          *portio_dir;
+ };
+diff --git a/kernel/signal.c b/kernel/signal.c
+index 164c36ef0825..04b3a621b3cc 100644
+--- a/kernel/signal.c
++++ b/kernel/signal.c
+@@ -672,6 +672,48 @@ void signal_wake_up_state(struct task_struct *t, unsigned int state)
+ 		kick_process(t);
+ }
+ 
++static int dequeue_synchronous_signal(siginfo_t *info)
++{
++	struct task_struct *tsk = current;
++	struct sigpending *pending = &tsk->pending;
++	struct sigqueue *q, *sync = NULL;
++
++	/*
++	 * Might a synchronous signal be in the queue?
++	 */
++	if (!((pending->signal.sig[0] & ~tsk->blocked.sig[0]) & SYNCHRONOUS_MASK))
++		return 0;
++
++	/*
++	 * Return the first synchronous signal in the queue.
++	 */
++	list_for_each_entry(q, &pending->list, list) {
++		/* Synchronous signals have a postive si_code */
++		if ((q->info.si_code > SI_USER) &&
++		    (sigmask(q->info.si_signo) & SYNCHRONOUS_MASK)) {
++			sync = q;
++			goto next;
++		}
++	}
++	return 0;
++next:
++	/*
++	 * Check if there is another siginfo for the same signal.
++	 */
++	list_for_each_entry_continue(q, &pending->list, list) {
++		if (q->info.si_signo == sync->info.si_signo)
++			goto still_pending;
++	}
++
++	sigdelset(&pending->signal, sync->info.si_signo);
++	recalc_sigpending();
++still_pending:
++	list_del_init(&sync->list);
++	copy_siginfo(info, &sync->info);
++	__sigqueue_free(sync);
++	return info->si_signo;
++}
++
+ /*
+  * Remove signals in mask from the pending set and queue.
+  * Returns 1 if any signals were found.
+@@ -2225,6 +2267,11 @@ relock:
+ 		goto relock;
+ 	}
+ 
++	/* Has this task already been marked for death? */
++	ksig->info.si_signo = signr = SIGKILL;
++	if (signal_group_exit(signal))
++		goto fatal;
++
+ 	for (;;) {
+ 		struct k_sigaction *ka;
+ 
+@@ -2238,7 +2285,15 @@ relock:
+ 			goto relock;
+ 		}
+ 
+-		signr = dequeue_signal(current, &current->blocked, &ksig->info);
++		/*
++		 * Signals generated by the execution of an instruction
++		 * need to be delivered before any other pending signals
++		 * so that the instruction pointer in the signal stack
++		 * frame points to the faulting instruction.
++		 */
++		signr = dequeue_synchronous_signal(&ksig->info);
++		if (!signr)
++			signr = dequeue_signal(current, &current->blocked, &ksig->info);
+ 
+ 		if (!signr)
+ 			break; /* will return 0 */
+@@ -2320,6 +2375,7 @@ relock:
+ 			continue;
+ 		}
+ 
++	fatal:
+ 		spin_unlock_irq(&sighand->siglock);
+ 
+ 		/*
+diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
+index ea0d90a31fc9..86718c85d8d3 100644
+--- a/kernel/trace/trace_uprobe.c
++++ b/kernel/trace/trace_uprobe.c
+@@ -17,7 +17,7 @@
+  * Copyright (C) IBM Corporation, 2010-2012
+  * Author:	Srikar Dronamraju <srikar@××××××××××××××.com>
+  */
+-#define pr_fmt(fmt)	"trace_kprobe: " fmt
++#define pr_fmt(fmt)	"trace_uprobe: " fmt
+ 
+ #include <linux/module.h>
+ #include <linux/uaccess.h>
+diff --git a/net/batman-adv/hard-interface.c b/net/batman-adv/hard-interface.c
+index e348f76ea8c1..2e1a084b0bd2 100644
+--- a/net/batman-adv/hard-interface.c
++++ b/net/batman-adv/hard-interface.c
+@@ -19,7 +19,6 @@
+ #include "main.h"
+ 
+ #include <linux/atomic.h>
+-#include <linux/bug.h>
+ #include <linux/byteorder/generic.h>
+ #include <linux/errno.h>
+ #include <linux/fs.h>
+@@ -172,8 +171,10 @@ static bool batadv_is_on_batman_iface(const struct net_device *net_dev)
+ 	parent_dev = __dev_get_by_index((struct net *)parent_net,
+ 					dev_get_iflink(net_dev));
+ 	/* if we got a NULL parent_dev there is something broken.. */
+-	if (WARN(!parent_dev, "Cannot find parent device"))
++	if (!parent_dev) {
++		pr_err("Cannot find parent device\n");
+ 		return false;
++	}
+ 
+ 	if (batadv_mutual_parents(net_dev, net, parent_dev, parent_net))
+ 		return false;
+diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c
+index 8cedb5db1ab3..3a80beef247c 100644
+--- a/net/batman-adv/soft-interface.c
++++ b/net/batman-adv/soft-interface.c
+@@ -213,6 +213,8 @@ static int batadv_interface_tx(struct sk_buff *skb,
+ 
+ 	netif_trans_update(soft_iface);
+ 	vid = batadv_get_vid(skb, 0);
++
++	skb_reset_mac_header(skb);
+ 	ethhdr = eth_hdr(skb);
+ 
+ 	switch (ntohs(ethhdr->h_proto)) {
+diff --git a/net/ceph/messenger.c b/net/ceph/messenger.c
+index f864807284d4..5fd222dc64b3 100644
+--- a/net/ceph/messenger.c
++++ b/net/ceph/messenger.c
+@@ -3210,9 +3210,10 @@ void ceph_con_keepalive(struct ceph_connection *con)
+ 	dout("con_keepalive %p\n", con);
+ 	mutex_lock(&con->mutex);
+ 	clear_standby(con);
++	con_flag_set(con, CON_FLAG_KEEPALIVE_PENDING);
+ 	mutex_unlock(&con->mutex);
+-	if (con_flag_test_and_set(con, CON_FLAG_KEEPALIVE_PENDING) == 0 &&
+-	    con_flag_test_and_set(con, CON_FLAG_WRITE_PENDING) == 0)
++
++	if (con_flag_test_and_set(con, CON_FLAG_WRITE_PENDING) == 0)
+ 		queue_con(con);
+ }
+ EXPORT_SYMBOL(ceph_con_keepalive);
+diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
+index 6b9bf9c027a2..305a4655f23e 100644
+--- a/net/mac80211/tx.c
++++ b/net/mac80211/tx.c
+@@ -1856,9 +1856,16 @@ static int ieee80211_skb_resize(struct ieee80211_sub_if_data *sdata,
+ 				int head_need, bool may_encrypt)
+ {
+ 	struct ieee80211_local *local = sdata->local;
++	struct ieee80211_hdr *hdr;
++	bool enc_tailroom;
+ 	int tail_need = 0;
+ 
+-	if (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt) {
++	hdr = (struct ieee80211_hdr *) skb->data;
++	enc_tailroom = may_encrypt &&
++		       (sdata->crypto_tx_tailroom_needed_cnt ||
++			ieee80211_is_mgmt(hdr->frame_control));
++
++	if (enc_tailroom) {
+ 		tail_need = IEEE80211_ENCRYPT_TAILROOM;
+ 		tail_need -= skb_tailroom(skb);
+ 		tail_need = max_t(int, tail_need, 0);
+@@ -1866,8 +1873,7 @@ static int ieee80211_skb_resize(struct ieee80211_sub_if_data *sdata,
+ 
+ 	if (skb_cloned(skb) &&
+ 	    (!ieee80211_hw_check(&local->hw, SUPPORTS_CLONED_SKBS) ||
+-	     !skb_clone_writable(skb, ETH_HLEN) ||
+-	     (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt)))
++	     !skb_clone_writable(skb, ETH_HLEN) || enc_tailroom))
+ 		I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
+ 	else if (head_need || tail_need)
+ 		I802_DEBUG_INC(local->tx_expand_skb_head);
+diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
+index 4e8319766f2b..9ff9255d2191 100644
+--- a/net/xfrm/xfrm_user.c
++++ b/net/xfrm/xfrm_user.c
+@@ -1445,10 +1445,15 @@ 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;
+-
++		switch (ut[i].mode) {
++		case XFRM_MODE_TUNNEL:
++		case XFRM_MODE_BEET:
++			break;
++		default:
++			if (ut[i].family != prev_family)
++				return -EINVAL;
++			break;
++		}
+ 		if (ut[i].mode >= XFRM_MODE_MAX)
+ 			return -EINVAL;
+ 
+diff --git a/samples/mei/mei-amt-version.c b/samples/mei/mei-amt-version.c
+index 57d0d871dcf7..bb9988914a56 100644
+--- a/samples/mei/mei-amt-version.c
++++ b/samples/mei/mei-amt-version.c
+@@ -117,7 +117,7 @@ static bool mei_init(struct mei *me, const uuid_le *guid,
+ 
+ 	me->verbose = verbose;
+ 
+-	me->fd = open("/dev/mei", O_RDWR);
++	me->fd = open("/dev/mei0", O_RDWR);
+ 	if (me->fd == -1) {
+ 		mei_err(me, "Cannot establish a handle to the Intel MEI driver\n");
+ 		goto err;
+diff --git a/tools/perf/tests/attr/base-record b/tools/perf/tests/attr/base-record
+index 31e0b1da830b..37940665f736 100644
+--- a/tools/perf/tests/attr/base-record
++++ b/tools/perf/tests/attr/base-record
+@@ -23,7 +23,7 @@ comm=1
+ freq=1
+ inherit_stat=0
+ enable_on_exec=1
+-task=0
++task=1
+ watermark=0
+ precise_ip=0|1|2|3
+ mmap_data=0
+diff --git a/tools/perf/tests/attr/test-record-group b/tools/perf/tests/attr/test-record-group
+index 6e7961f6f7a5..618ba1c17474 100644
+--- a/tools/perf/tests/attr/test-record-group
++++ b/tools/perf/tests/attr/test-record-group
+@@ -17,5 +17,6 @@ sample_type=327
+ read_format=4
+ mmap=0
+ comm=0
++task=0
+ enable_on_exec=0
+ disabled=0
+diff --git a/tools/perf/tests/attr/test-record-group-sampling b/tools/perf/tests/attr/test-record-group-sampling
+index ef59afd6d635..f906b793196f 100644
+--- a/tools/perf/tests/attr/test-record-group-sampling
++++ b/tools/perf/tests/attr/test-record-group-sampling
+@@ -23,7 +23,7 @@ sample_type=343
+ 
+ # PERF_FORMAT_ID | PERF_FORMAT_GROUP
+ read_format=12
+-
++task=0
+ mmap=0
+ comm=0
+ enable_on_exec=0
+diff --git a/tools/perf/tests/attr/test-record-group1 b/tools/perf/tests/attr/test-record-group1
+index 87a222d014d8..48e8bd12fe46 100644
+--- a/tools/perf/tests/attr/test-record-group1
++++ b/tools/perf/tests/attr/test-record-group1
+@@ -18,5 +18,6 @@ sample_type=327
+ read_format=4
+ mmap=0
+ comm=0
++task=0
+ enable_on_exec=0
+ disabled=0
+diff --git a/tools/perf/tests/attr/test-stat-C0 b/tools/perf/tests/attr/test-stat-C0
+index 67717fe6a65d..a2c76d10b2bb 100644
+--- a/tools/perf/tests/attr/test-stat-C0
++++ b/tools/perf/tests/attr/test-stat-C0
+@@ -7,3 +7,4 @@ ret     = 1
+ # events are disabled by default when attached to cpu
+ disabled=1
+ enable_on_exec=0
++optional=1
+diff --git a/tools/perf/tests/attr/test-stat-basic b/tools/perf/tests/attr/test-stat-basic
+index 74e17881f2ba..69867d049fda 100644
+--- a/tools/perf/tests/attr/test-stat-basic
++++ b/tools/perf/tests/attr/test-stat-basic
+@@ -4,3 +4,4 @@ args    = -e cycles kill >/dev/null 2>&1
+ ret     = 1
+ 
+ [event:base-stat]
++optional=1
+diff --git a/tools/perf/tests/attr/test-stat-default b/tools/perf/tests/attr/test-stat-default
+index e911dbd4eb47..d9e99b3f77e6 100644
+--- a/tools/perf/tests/attr/test-stat-default
++++ b/tools/perf/tests/attr/test-stat-default
+@@ -32,6 +32,7 @@ config=2
+ fd=5
+ type=0
+ config=0
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_STALLED_CYCLES_FRONTEND
+ [event6:base-stat]
+@@ -52,15 +53,18 @@ optional=1
+ fd=8
+ type=0
+ config=1
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_INSTRUCTIONS
+ [event9:base-stat]
+ fd=9
+ type=0
+ config=4
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_MISSES
+ [event10:base-stat]
+ fd=10
+ type=0
+ config=5
++optional=1
+diff --git a/tools/perf/tests/attr/test-stat-detailed-1 b/tools/perf/tests/attr/test-stat-detailed-1
+index b39270a08e74..8b04a055d154 100644
+--- a/tools/perf/tests/attr/test-stat-detailed-1
++++ b/tools/perf/tests/attr/test-stat-detailed-1
+@@ -33,6 +33,7 @@ config=2
+ fd=5
+ type=0
+ config=0
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_STALLED_CYCLES_FRONTEND
+ [event6:base-stat]
+@@ -53,18 +54,21 @@ optional=1
+ fd=8
+ type=0
+ config=1
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_INSTRUCTIONS
+ [event9:base-stat]
+ fd=9
+ type=0
+ config=4
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_MISSES
+ [event10:base-stat]
+ fd=10
+ type=0
+ config=5
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_L1D                <<  0  |
+@@ -74,6 +78,7 @@ config=5
+ fd=11
+ type=3
+ config=0
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_L1D                <<  0  |
+@@ -83,6 +88,7 @@ config=0
+ fd=12
+ type=3
+ config=65536
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_LL                 <<  0  |
+@@ -92,6 +98,7 @@ config=65536
+ fd=13
+ type=3
+ config=2
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_LL                 <<  0  |
+@@ -101,3 +108,4 @@ config=2
+ fd=14
+ type=3
+ config=65538
++optional=1
+diff --git a/tools/perf/tests/attr/test-stat-detailed-2 b/tools/perf/tests/attr/test-stat-detailed-2
+index 45f8e6ea34f8..4fca9f1bfbf8 100644
+--- a/tools/perf/tests/attr/test-stat-detailed-2
++++ b/tools/perf/tests/attr/test-stat-detailed-2
+@@ -33,6 +33,7 @@ config=2
+ fd=5
+ type=0
+ config=0
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_STALLED_CYCLES_FRONTEND
+ [event6:base-stat]
+@@ -53,18 +54,21 @@ optional=1
+ fd=8
+ type=0
+ config=1
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_INSTRUCTIONS
+ [event9:base-stat]
+ fd=9
+ type=0
+ config=4
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_MISSES
+ [event10:base-stat]
+ fd=10
+ type=0
+ config=5
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_L1D                <<  0  |
+@@ -74,6 +78,7 @@ config=5
+ fd=11
+ type=3
+ config=0
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_L1D                <<  0  |
+@@ -83,6 +88,7 @@ config=0
+ fd=12
+ type=3
+ config=65536
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_LL                 <<  0  |
+@@ -92,6 +98,7 @@ config=65536
+ fd=13
+ type=3
+ config=2
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_LL                 <<  0  |
+@@ -101,6 +108,7 @@ config=2
+ fd=14
+ type=3
+ config=65538
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_L1I                <<  0  |
+@@ -120,6 +128,7 @@ optional=1
+ fd=16
+ type=3
+ config=65537
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_DTLB               <<  0  |
+@@ -129,6 +138,7 @@ config=65537
+ fd=17
+ type=3
+ config=3
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_DTLB               <<  0  |
+@@ -138,6 +148,7 @@ config=3
+ fd=18
+ type=3
+ config=65539
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_ITLB               <<  0  |
+@@ -147,6 +158,7 @@ config=65539
+ fd=19
+ type=3
+ config=4
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_ITLB               <<  0  |
+@@ -156,3 +168,4 @@ config=4
+ fd=20
+ type=3
+ config=65540
++optional=1
+diff --git a/tools/perf/tests/attr/test-stat-detailed-3 b/tools/perf/tests/attr/test-stat-detailed-3
+index 30ae0fb7a3fd..4bb58e1c82a6 100644
+--- a/tools/perf/tests/attr/test-stat-detailed-3
++++ b/tools/perf/tests/attr/test-stat-detailed-3
+@@ -33,6 +33,7 @@ config=2
+ fd=5
+ type=0
+ config=0
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_STALLED_CYCLES_FRONTEND
+ [event6:base-stat]
+@@ -53,18 +54,21 @@ optional=1
+ fd=8
+ type=0
+ config=1
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_INSTRUCTIONS
+ [event9:base-stat]
+ fd=9
+ type=0
+ config=4
++optional=1
+ 
+ # PERF_TYPE_HARDWARE / PERF_COUNT_HW_BRANCH_MISSES
+ [event10:base-stat]
+ fd=10
+ type=0
+ config=5
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_L1D                <<  0  |
+@@ -74,6 +78,7 @@ config=5
+ fd=11
+ type=3
+ config=0
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_L1D                <<  0  |
+@@ -83,6 +88,7 @@ config=0
+ fd=12
+ type=3
+ config=65536
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE /
+ #  PERF_COUNT_HW_CACHE_LL                 <<  0  |
+@@ -92,6 +98,7 @@ config=65536
+ fd=13
+ type=3
+ config=2
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_LL                 <<  0  |
+@@ -101,6 +108,7 @@ config=2
+ fd=14
+ type=3
+ config=65538
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_L1I                <<  0  |
+@@ -120,6 +128,7 @@ optional=1
+ fd=16
+ type=3
+ config=65537
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_DTLB               <<  0  |
+@@ -129,6 +138,7 @@ config=65537
+ fd=17
+ type=3
+ config=3
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_DTLB               <<  0  |
+@@ -138,6 +148,7 @@ config=3
+ fd=18
+ type=3
+ config=65539
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_ITLB               <<  0  |
+@@ -147,6 +158,7 @@ config=65539
+ fd=19
+ type=3
+ config=4
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_ITLB               <<  0  |
+@@ -156,6 +168,7 @@ config=4
+ fd=20
+ type=3
+ config=65540
++optional=1
+ 
+ # PERF_TYPE_HW_CACHE,
+ #  PERF_COUNT_HW_CACHE_L1D                <<  0  |
+diff --git a/tools/perf/tests/attr/test-stat-group b/tools/perf/tests/attr/test-stat-group
+index fdc1596a8862..e15d6946e9b3 100644
+--- a/tools/perf/tests/attr/test-stat-group
++++ b/tools/perf/tests/attr/test-stat-group
+@@ -6,6 +6,7 @@ ret     = 1
+ [event-1:base-stat]
+ fd=1
+ group_fd=-1
++read_format=3|15
+ 
+ [event-2:base-stat]
+ fd=2
+@@ -13,3 +14,4 @@ group_fd=1
+ config=1
+ disabled=0
+ enable_on_exec=0
++read_format=3|15
+diff --git a/tools/perf/tests/attr/test-stat-group1 b/tools/perf/tests/attr/test-stat-group1
+index 2a1f86e4a904..1746751123dc 100644
+--- a/tools/perf/tests/attr/test-stat-group1
++++ b/tools/perf/tests/attr/test-stat-group1
+@@ -6,6 +6,7 @@ ret     = 1
+ [event-1:base-stat]
+ fd=1
+ group_fd=-1
++read_format=3|15
+ 
+ [event-2:base-stat]
+ fd=2
+@@ -13,3 +14,4 @@ group_fd=1
+ config=1
+ disabled=0
+ enable_on_exec=0
++read_format=3|15
+diff --git a/tools/perf/tests/attr/test-stat-no-inherit b/tools/perf/tests/attr/test-stat-no-inherit
+index d54b2a1e3e28..924fbb9300d1 100644
+--- a/tools/perf/tests/attr/test-stat-no-inherit
++++ b/tools/perf/tests/attr/test-stat-no-inherit
+@@ -5,3 +5,4 @@ ret     = 1
+ 
+ [event:base-stat]
+ inherit=0
++optional=1

diff --git a/1100_linux-4.14.101.patch b/1100_linux-4.14.101.patch
new file mode 100644
index 0000000..9b535b6
--- /dev/null
+++ b/1100_linux-4.14.101.patch
@@ -0,0 +1,35 @@
+diff --git a/Makefile b/Makefile
+index 86fa9a371383..d5b20b618517 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 4
+ PATCHLEVEL = 14
+-SUBLEVEL = 100
++SUBLEVEL = 101
+ EXTRAVERSION =
+ NAME = Petit Gorille
+ 
+diff --git a/fs/binfmt_script.c b/fs/binfmt_script.c
+index d0078cbb718b..7cde3f46ad26 100644
+--- a/fs/binfmt_script.c
++++ b/fs/binfmt_script.c
+@@ -42,14 +42,10 @@ static int load_script(struct linux_binprm *bprm)
+ 	fput(bprm->file);
+ 	bprm->file = NULL;
+ 
+-	for (cp = bprm->buf+2;; cp++) {
+-		if (cp >= bprm->buf + BINPRM_BUF_SIZE)
+-			return -ENOEXEC;
+-		if (!*cp || (*cp == '\n'))
+-			break;
+-	}
++	bprm->buf[BINPRM_BUF_SIZE - 1] = '\0';
++	if ((cp = strchr(bprm->buf, '\n')) == NULL)
++		cp = bprm->buf+BINPRM_BUF_SIZE-1;
+ 	*cp = '\0';
+-
+ 	while (cp > bprm->buf) {
+ 		cp--;
+ 		if ((*cp == ' ') || (*cp == '\t'))