diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/arm64/boot/dts/amlogic/meson-gxbb-odroidc2.dts linux-libre-4.14.163-gnu/arch/arm64/boot/dts/amlogic/meson-gxbb-odroidc2.dts
--- linux-libre-4.14.162-gnu/arch/arm64/boot/dts/amlogic/meson-gxbb-odroidc2.dts	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/arm64/boot/dts/amlogic/meson-gxbb-odroidc2.dts	2020-01-09 04:18:00.000000000 -0500
@@ -295,7 +295,7 @@
 };
 
 &usb0_phy {
-	status = "okay";
+	status = "disabled";
 	phy-supply = <&usb_otg_pwr>;
 };
 
@@ -305,7 +305,7 @@
 };
 
 &usb0 {
-	status = "okay";
+	status = "disabled";
 };
 
 &usb1 {
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/arm64/include/asm/pgtable.h linux-libre-4.14.163-gnu/arch/arm64/include/asm/pgtable.h
--- linux-libre-4.14.162-gnu/arch/arm64/include/asm/pgtable.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/arm64/include/asm/pgtable.h	2020-01-09 04:18:00.000000000 -0500
@@ -90,12 +90,8 @@ extern unsigned long empty_zero_page[PAG
 #define pte_dirty(pte)		(pte_sw_dirty(pte) || pte_hw_dirty(pte))
 
 #define pte_valid(pte)		(!!(pte_val(pte) & PTE_VALID))
-/*
- * Execute-only user mappings do not have the PTE_USER bit set. All valid
- * kernel mappings have the PTE_UXN bit set.
- */
 #define pte_valid_not_user(pte) \
-	((pte_val(pte) & (PTE_VALID | PTE_USER | PTE_UXN)) == (PTE_VALID | PTE_UXN))
+	((pte_val(pte) & (PTE_VALID | PTE_USER)) == PTE_VALID)
 #define pte_valid_young(pte) \
 	((pte_val(pte) & (PTE_VALID | PTE_AF)) == (PTE_VALID | PTE_AF))
 #define pte_valid_user(pte) \
@@ -111,8 +107,8 @@ extern unsigned long empty_zero_page[PAG
 
 /*
  * p??_access_permitted() is true for valid user mappings (subject to the
- * write permission check) other than user execute-only which do not have the
- * PTE_USER bit set. PROT_NONE mappings do not have the PTE_VALID bit set.
+ * write permission check). PROT_NONE mappings do not have the PTE_VALID bit
+ * set.
  */
 #define pte_access_permitted(pte, write) \
 	(pte_valid_user(pte) && (!(write) || pte_write(pte)))
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/arm64/include/asm/pgtable-prot.h linux-libre-4.14.163-gnu/arch/arm64/include/asm/pgtable-prot.h
--- linux-libre-4.14.162-gnu/arch/arm64/include/asm/pgtable-prot.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/arm64/include/asm/pgtable-prot.h	2020-01-09 04:18:00.000000000 -0500
@@ -76,13 +76,12 @@
 #define PAGE_SHARED_EXEC	__pgprot(_PAGE_DEFAULT | PTE_USER | PTE_RDONLY | PTE_NG | PTE_PXN | PTE_WRITE)
 #define PAGE_READONLY		__pgprot(_PAGE_DEFAULT | PTE_USER | PTE_RDONLY | PTE_NG | PTE_PXN | PTE_UXN)
 #define PAGE_READONLY_EXEC	__pgprot(_PAGE_DEFAULT | PTE_USER | PTE_RDONLY | PTE_NG | PTE_PXN)
-#define PAGE_EXECONLY		__pgprot(_PAGE_DEFAULT | PTE_RDONLY | PTE_NG | PTE_PXN)
 
 #define __P000  PAGE_NONE
 #define __P001  PAGE_READONLY
 #define __P010  PAGE_READONLY
 #define __P011  PAGE_READONLY
-#define __P100  PAGE_EXECONLY
+#define __P100  PAGE_READONLY_EXEC
 #define __P101  PAGE_READONLY_EXEC
 #define __P110  PAGE_READONLY_EXEC
 #define __P111  PAGE_READONLY_EXEC
@@ -91,7 +90,7 @@
 #define __S001  PAGE_READONLY
 #define __S010  PAGE_SHARED
 #define __S011  PAGE_SHARED
-#define __S100  PAGE_EXECONLY
+#define __S100  PAGE_READONLY_EXEC
 #define __S101  PAGE_READONLY_EXEC
 #define __S110  PAGE_SHARED_EXEC
 #define __S111  PAGE_SHARED_EXEC
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/arm64/mm/fault.c linux-libre-4.14.163-gnu/arch/arm64/mm/fault.c
--- linux-libre-4.14.162-gnu/arch/arm64/mm/fault.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/arm64/mm/fault.c	2020-01-09 04:18:00.000000000 -0500
@@ -400,7 +400,7 @@ static int __kprobes do_page_fault(unsig
 	struct task_struct *tsk;
 	struct mm_struct *mm;
 	int fault, sig, code, major = 0;
-	unsigned long vm_flags = VM_READ | VM_WRITE;
+	unsigned long vm_flags = VM_READ | VM_WRITE | VM_EXEC;
 	unsigned int mm_flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
 
 	if (notify_page_fault(regs, esr))
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/mips/include/asm/thread_info.h linux-libre-4.14.163-gnu/arch/mips/include/asm/thread_info.h
--- linux-libre-4.14.162-gnu/arch/mips/include/asm/thread_info.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/mips/include/asm/thread_info.h	2020-01-09 04:18:00.000000000 -0500
@@ -52,8 +52,26 @@ struct thread_info {
 #define init_thread_info	(init_thread_union.thread_info)
 #define init_stack		(init_thread_union.stack)
 
-/* How to get the thread information struct from C.  */
+/*
+ * A pointer to the struct thread_info for the currently executing thread is
+ * held in register $28/$gp.
+ *
+ * We declare __current_thread_info as a global register variable rather than a
+ * local register variable within current_thread_info() because clang doesn't
+ * support explicit local register variables.
+ *
+ * When building the VDSO we take care not to declare the global register
+ * variable because this causes GCC to not preserve the value of $28/$gp in
+ * functions that change its value (which is common in the PIC VDSO when
+ * accessing the GOT). Since the VDSO shouldn't be accessing
+ * __current_thread_info anyway we declare it extern in order to cause a link
+ * failure if it's referenced.
+ */
+#ifdef __VDSO__
+extern struct thread_info *__current_thread_info;
+#else
 register struct thread_info *__current_thread_info __asm__("$28");
+#endif
 
 static inline struct thread_info *current_thread_info(void)
 {
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/powerpc/platforms/pseries/hvconsole.c linux-libre-4.14.163-gnu/arch/powerpc/platforms/pseries/hvconsole.c
--- linux-libre-4.14.162-gnu/arch/powerpc/platforms/pseries/hvconsole.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/powerpc/platforms/pseries/hvconsole.c	2020-01-09 04:18:00.000000000 -0500
@@ -62,7 +62,7 @@ EXPORT_SYMBOL(hvc_get_chars);
  * @vtermno: The vtermno or unit_address of the adapter from which the data
  *	originated.
  * @buf: The character buffer that contains the character data to send to
- *	firmware.
+ *	firmware. Must be at least 16 bytes, even if count is less than 16.
  * @count: Send this number of characters.
  */
 int hvc_put_chars(uint32_t vtermno, const char *buf, int count)
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/s390/kernel/perf_cpum_sf.c linux-libre-4.14.163-gnu/arch/s390/kernel/perf_cpum_sf.c
--- linux-libre-4.14.162-gnu/arch/s390/kernel/perf_cpum_sf.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/s390/kernel/perf_cpum_sf.c	2020-01-09 04:18:00.000000000 -0500
@@ -1294,18 +1294,28 @@ static void hw_perf_event_update(struct
 		 */
 		if (flush_all && done)
 			break;
-
-		/* If an event overflow happened, discard samples by
-		 * processing any remaining sample-data-blocks.
-		 */
-		if (event_overflow)
-			flush_all = 1;
 	}
 
 	/* Account sample overflows in the event hardware structure */
 	if (sampl_overflow)
 		OVERFLOW_REG(hwc) = DIV_ROUND_UP(OVERFLOW_REG(hwc) +
 						 sampl_overflow, 1 + num_sdb);
+
+	/* Perf_event_overflow() and perf_event_account_interrupt() limit
+	 * the interrupt rate to an upper limit. Roughly 1000 samples per
+	 * task tick.
+	 * Hitting this limit results in a large number
+	 * of throttled REF_REPORT_THROTTLE entries and the samples
+	 * are dropped.
+	 * Slightly increase the interval to avoid hitting this limit.
+	 */
+	if (event_overflow) {
+		SAMPL_RATE(hwc) += DIV_ROUND_UP(SAMPL_RATE(hwc), 10);
+		debug_sprintf_event(sfdbg, 1, "%s: rate adjustment %ld\n",
+				    __func__,
+				    DIV_ROUND_UP(SAMPL_RATE(hwc), 10));
+	}
+
 	if (sampl_overflow || event_overflow)
 		debug_sprintf_event(sfdbg, 4, "hw_perf_event_update: "
 				    "overflow stats: sample=%llu event=%llu\n",
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/s390/kernel/smp.c linux-libre-4.14.163-gnu/arch/s390/kernel/smp.c
--- linux-libre-4.14.162-gnu/arch/s390/kernel/smp.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/s390/kernel/smp.c	2020-01-09 04:18:00.000000000 -0500
@@ -725,39 +725,67 @@ static void __ref smp_get_core_info(stru
 
 static int smp_add_present_cpu(int cpu);
 
-static int __smp_rescan_cpus(struct sclp_core_info *info, int sysfs_add)
+static int smp_add_core(struct sclp_core_entry *core, cpumask_t *avail,
+			bool configured, bool early)
 {
 	struct pcpu *pcpu;
-	cpumask_t avail;
-	int cpu, nr, i, j;
+	int cpu, nr, i;
 	u16 address;
 
 	nr = 0;
-	cpumask_xor(&avail, cpu_possible_mask, cpu_present_mask);
-	cpu = cpumask_first(&avail);
-	for (i = 0; (i < info->combined) && (cpu < nr_cpu_ids); i++) {
-		if (sclp.has_core_type && info->core[i].type != boot_core_type)
+	if (sclp.has_core_type && core->type != boot_core_type)
+		return nr;
+	cpu = cpumask_first(avail);
+	address = core->core_id << smp_cpu_mt_shift;
+	for (i = 0; (i <= smp_cpu_mtid) && (cpu < nr_cpu_ids); i++) {
+		if (pcpu_find_address(cpu_present_mask, address + i))
 			continue;
-		address = info->core[i].core_id << smp_cpu_mt_shift;
-		for (j = 0; j <= smp_cpu_mtid; j++) {
-			if (pcpu_find_address(cpu_present_mask, address + j))
-				continue;
-			pcpu = pcpu_devices + cpu;
-			pcpu->address = address + j;
-			pcpu->state =
-				(cpu >= info->configured*(smp_cpu_mtid + 1)) ?
-				CPU_STATE_STANDBY : CPU_STATE_CONFIGURED;
-			smp_cpu_set_polarization(cpu, POLARIZATION_UNKNOWN);
-			set_cpu_present(cpu, true);
-			if (sysfs_add && smp_add_present_cpu(cpu) != 0)
-				set_cpu_present(cpu, false);
-			else
-				nr++;
-			cpu = cpumask_next(cpu, &avail);
-			if (cpu >= nr_cpu_ids)
+		pcpu = pcpu_devices + cpu;
+		pcpu->address = address + i;
+		if (configured)
+			pcpu->state = CPU_STATE_CONFIGURED;
+		else
+			pcpu->state = CPU_STATE_STANDBY;
+		smp_cpu_set_polarization(cpu, POLARIZATION_UNKNOWN);
+		set_cpu_present(cpu, true);
+		if (!early && smp_add_present_cpu(cpu) != 0)
+			set_cpu_present(cpu, false);
+		else
+			nr++;
+		cpumask_clear_cpu(cpu, avail);
+		cpu = cpumask_next(cpu, avail);
+	}
+	return nr;
+}
+
+static int __smp_rescan_cpus(struct sclp_core_info *info, bool early)
+{
+	struct sclp_core_entry *core;
+	cpumask_t avail;
+	bool configured;
+	u16 core_id;
+	int nr, i;
+
+	nr = 0;
+	cpumask_xor(&avail, cpu_possible_mask, cpu_present_mask);
+	/*
+	 * Add IPL core first (which got logical CPU number 0) to make sure
+	 * that all SMT threads get subsequent logical CPU numbers.
+	 */
+	if (early) {
+		core_id = pcpu_devices[0].address >> smp_cpu_mt_shift;
+		for (i = 0; i < info->configured; i++) {
+			core = &info->core[i];
+			if (core->core_id == core_id) {
+				nr += smp_add_core(core, &avail, true, early);
 				break;
+			}
 		}
 	}
+	for (i = 0; i < info->combined; i++) {
+		configured = i < info->configured;
+		nr += smp_add_core(&info->core[i], &avail, configured, early);
+	}
 	return nr;
 }
 
@@ -803,7 +831,7 @@ void __init smp_detect_cpus(void)
 
 	/* Add CPUs present at boot */
 	get_online_cpus();
-	__smp_rescan_cpus(info, 0);
+	__smp_rescan_cpus(info, true);
 	put_online_cpus();
 	memblock_free_early((unsigned long)info, sizeof(*info));
 }
@@ -1156,7 +1184,7 @@ int __ref smp_rescan_cpus(void)
 	smp_get_core_info(info, 0);
 	get_online_cpus();
 	mutex_lock(&smp_cpu_state_mutex);
-	nr = __smp_rescan_cpus(info, 1);
+	nr = __smp_rescan_cpus(info, false);
 	mutex_unlock(&smp_cpu_state_mutex);
 	put_online_cpus();
 	kfree(info);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/arch/x86/events/intel/bts.c linux-libre-4.14.163-gnu/arch/x86/events/intel/bts.c
--- linux-libre-4.14.162-gnu/arch/x86/events/intel/bts.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/arch/x86/events/intel/bts.c	2020-01-09 04:18:00.000000000 -0500
@@ -71,9 +71,17 @@ struct bts_buffer {
 
 static struct pmu bts_pmu;
 
+static int buf_nr_pages(struct page *page)
+{
+	if (!PagePrivate(page))
+		return 1;
+
+	return 1 << page_private(page);
+}
+
 static size_t buf_size(struct page *page)
 {
-	return 1 << (PAGE_SHIFT + page_private(page));
+	return buf_nr_pages(page) * PAGE_SIZE;
 }
 
 static void *
@@ -89,9 +97,7 @@ bts_buffer_setup_aux(int cpu, void **pag
 	/* count all the high order buffers */
 	for (pg = 0, nbuf = 0; pg < nr_pages;) {
 		page = virt_to_page(pages[pg]);
-		if (WARN_ON_ONCE(!PagePrivate(page) && nr_pages > 1))
-			return NULL;
-		pg += 1 << page_private(page);
+		pg += buf_nr_pages(page);
 		nbuf++;
 	}
 
@@ -115,7 +121,7 @@ bts_buffer_setup_aux(int cpu, void **pag
 		unsigned int __nr_pages;
 
 		page = virt_to_page(pages[pg]);
-		__nr_pages = PagePrivate(page) ? 1 << page_private(page) : 1;
+		__nr_pages = buf_nr_pages(page);
 		buf->buf[nbuf].page = page;
 		buf->buf[nbuf].offset = offset;
 		buf->buf[nbuf].displacement = (pad ? BTS_RECORD_SIZE - pad : 0);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/block/compat_ioctl.c linux-libre-4.14.163-gnu/block/compat_ioctl.c
--- linux-libre-4.14.162-gnu/block/compat_ioctl.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/block/compat_ioctl.c	2020-01-09 04:18:00.000000000 -0500
@@ -6,6 +6,7 @@
 #include <linux/compat.h>
 #include <linux/elevator.h>
 #include <linux/hdreg.h>
+#include <linux/pr.h>
 #include <linux/slab.h>
 #include <linux/syscalls.h>
 #include <linux/types.h>
@@ -354,6 +355,8 @@ long compat_blkdev_ioctl(struct file *fi
 	 * but we call blkdev_ioctl, which gets the lock for us
 	 */
 	case BLKRRPART:
+	case BLKREPORTZONE:
+	case BLKRESETZONE:
 		return blkdev_ioctl(bdev, mode, cmd,
 				(unsigned long)compat_ptr(arg));
 	case BLKBSZSET_32:
@@ -401,6 +404,14 @@ long compat_blkdev_ioctl(struct file *fi
 	case BLKTRACETEARDOWN: /* compatible */
 		ret = blk_trace_ioctl(bdev, cmd, compat_ptr(arg));
 		return ret;
+	case IOC_PR_REGISTER:
+	case IOC_PR_RESERVE:
+	case IOC_PR_RELEASE:
+	case IOC_PR_PREEMPT:
+	case IOC_PR_PREEMPT_ABORT:
+	case IOC_PR_CLEAR:
+		return blkdev_ioctl(bdev, mode, cmd,
+				(unsigned long)compat_ptr(arg));
 	default:
 		if (disk->fops->compat_ioctl)
 			ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/Documentation/devicetree/bindings/clock/renesas,rcar-usb2-clock-sel.txt linux-libre-4.14.163-gnu/Documentation/devicetree/bindings/clock/renesas,rcar-usb2-clock-sel.txt
--- linux-libre-4.14.162-gnu/Documentation/devicetree/bindings/clock/renesas,rcar-usb2-clock-sel.txt	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/Documentation/devicetree/bindings/clock/renesas,rcar-usb2-clock-sel.txt	2020-01-09 04:18:00.000000000 -0500
@@ -46,7 +46,7 @@ Required properties:
 Example (R-Car H3):
 
 	usb2_clksel: clock-controller@e6590630 {
-		compatible = "renesas,r8a77950-rcar-usb2-clock-sel",
+		compatible = "renesas,r8a7795-rcar-usb2-clock-sel",
 			     "renesas,rcar-gen3-usb2-clock-sel";
 		reg = <0 0xe6590630 0 0x02>;
 		clocks = <&cpg CPG_MOD 703>, <&usb_extal>, <&usb_xtal>;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/ata/ahci_brcm.c linux-libre-4.14.163-gnu/drivers/ata/ahci_brcm.c
--- linux-libre-4.14.162-gnu/drivers/ata/ahci_brcm.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/ata/ahci_brcm.c	2020-01-09 04:18:00.000000000 -0500
@@ -25,6 +25,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/reset.h>
 #include <linux/string.h>
 
 #include "ahci.h"
@@ -87,6 +88,7 @@ struct brcm_ahci_priv {
 	u32 port_mask;
 	u32 quirks;
 	enum brcm_ahci_version version;
+	struct reset_control *rcdev;
 };
 
 static const struct ata_port_info ahci_brcm_port_info = {
@@ -221,19 +223,12 @@ static void brcm_sata_phys_disable(struc
 			brcm_sata_phy_disable(priv, i);
 }
 
-static u32 brcm_ahci_get_portmask(struct platform_device *pdev,
+static u32 brcm_ahci_get_portmask(struct ahci_host_priv *hpriv,
 				  struct brcm_ahci_priv *priv)
 {
-	void __iomem *ahci;
-	struct resource *res;
 	u32 impl;
 
-	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ahci");
-	ahci = devm_ioremap_resource(&pdev->dev, res);
-	if (IS_ERR(ahci))
-		return 0;
-
-	impl = readl(ahci + HOST_PORTS_IMPL);
+	impl = readl(hpriv->mmio + HOST_PORTS_IMPL);
 
 	if (fls(impl) > SATA_TOP_MAX_PHYS)
 		dev_warn(priv->dev, "warning: more ports than PHYs (%#x)\n",
@@ -241,9 +236,6 @@ static u32 brcm_ahci_get_portmask(struct
 	else if (!impl)
 		dev_info(priv->dev, "no ports found\n");
 
-	devm_iounmap(&pdev->dev, ahci);
-	devm_release_mem_region(&pdev->dev, res->start, resource_size(res));
-
 	return impl;
 }
 
@@ -270,11 +262,10 @@ static int brcm_ahci_suspend(struct devi
 	struct ata_host *host = dev_get_drvdata(dev);
 	struct ahci_host_priv *hpriv = host->private_data;
 	struct brcm_ahci_priv *priv = hpriv->plat_data;
-	int ret;
 
-	ret = ahci_platform_suspend(dev);
 	brcm_sata_phys_disable(priv);
-	return ret;
+
+	return ahci_platform_suspend(dev);
 }
 
 static int brcm_ahci_resume(struct device *dev)
@@ -282,11 +273,44 @@ static int brcm_ahci_resume(struct devic
 	struct ata_host *host = dev_get_drvdata(dev);
 	struct ahci_host_priv *hpriv = host->private_data;
 	struct brcm_ahci_priv *priv = hpriv->plat_data;
+	int ret;
+
+	/* Make sure clocks are turned on before re-configuration */
+	ret = ahci_platform_enable_clks(hpriv);
+	if (ret)
+		return ret;
 
 	brcm_sata_init(priv);
 	brcm_sata_phys_enable(priv);
 	brcm_sata_alpm_init(hpriv);
-	return ahci_platform_resume(dev);
+
+	/* Since we had to enable clocks earlier on, we cannot use
+	 * ahci_platform_resume() as-is since a second call to
+	 * ahci_platform_enable_resources() would bump up the resources
+	 * (regulators, clocks, PHYs) count artificially so we copy the part
+	 * after ahci_platform_enable_resources().
+	 */
+	ret = ahci_platform_enable_phys(hpriv);
+	if (ret)
+		goto out_disable_phys;
+
+	ret = ahci_platform_resume_host(dev);
+	if (ret)
+		goto out_disable_platform_phys;
+
+	/* We resumed so update PM runtime state */
+	pm_runtime_disable(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
+	return 0;
+
+out_disable_platform_phys:
+	ahci_platform_disable_phys(hpriv);
+out_disable_phys:
+	brcm_sata_phys_disable(priv);
+	ahci_platform_disable_clks(hpriv);
+	return ret;
 }
 #endif
 
@@ -327,44 +351,74 @@ static int brcm_ahci_probe(struct platfo
 	if (IS_ERR(priv->top_ctrl))
 		return PTR_ERR(priv->top_ctrl);
 
+	/* Reset is optional depending on platform */
+	priv->rcdev = devm_reset_control_get(&pdev->dev, "ahci");
+	if (!IS_ERR_OR_NULL(priv->rcdev))
+		reset_control_deassert(priv->rcdev);
+
 	if ((priv->version == BRCM_SATA_BCM7425) ||
 		(priv->version == BRCM_SATA_NSP)) {
 		priv->quirks |= BRCM_AHCI_QUIRK_NO_NCQ;
 		priv->quirks |= BRCM_AHCI_QUIRK_SKIP_PHY_ENABLE;
 	}
 
+	hpriv = ahci_platform_get_resources(pdev);
+	if (IS_ERR(hpriv)) {
+		ret = PTR_ERR(hpriv);
+		goto out_reset;
+	}
+
+	ret = ahci_platform_enable_clks(hpriv);
+	if (ret)
+		goto out_reset;
+
+	/* Must be first so as to configure endianness including that
+	 * of the standard AHCI register space.
+	 */
 	brcm_sata_init(priv);
 
-	priv->port_mask = brcm_ahci_get_portmask(pdev, priv);
-	if (!priv->port_mask)
-		return -ENODEV;
+	/* Initializes priv->port_mask which is used below */
+	priv->port_mask = brcm_ahci_get_portmask(hpriv, priv);
+	if (!priv->port_mask) {
+		ret = -ENODEV;
+		goto out_disable_clks;
+	}
 
+	/* Must be done before ahci_platform_enable_phys() */
 	brcm_sata_phys_enable(priv);
 
-	hpriv = ahci_platform_get_resources(pdev);
-	if (IS_ERR(hpriv))
-		return PTR_ERR(hpriv);
 	hpriv->plat_data = priv;
 	hpriv->flags = AHCI_HFLAG_WAKE_BEFORE_STOP;
 
 	brcm_sata_alpm_init(hpriv);
 
-	ret = ahci_platform_enable_resources(hpriv);
-	if (ret)
-		return ret;
-
 	if (priv->quirks & BRCM_AHCI_QUIRK_NO_NCQ)
 		hpriv->flags |= AHCI_HFLAG_NO_NCQ;
 	hpriv->flags |= AHCI_HFLAG_NO_WRITE_TO_RO;
 
+	ret = ahci_platform_enable_phys(hpriv);
+	if (ret)
+		goto out_disable_phys;
+
 	ret = ahci_platform_init_host(pdev, hpriv, &ahci_brcm_port_info,
 				      &ahci_platform_sht);
 	if (ret)
-		return ret;
+		goto out_disable_platform_phys;
 
 	dev_info(dev, "Broadcom AHCI SATA3 registered\n");
 
 	return 0;
+
+out_disable_platform_phys:
+	ahci_platform_disable_phys(hpriv);
+out_disable_phys:
+	brcm_sata_phys_disable(priv);
+out_disable_clks:
+	ahci_platform_disable_clks(hpriv);
+out_reset:
+	if (!IS_ERR_OR_NULL(priv->rcdev))
+		reset_control_assert(priv->rcdev);
+	return ret;
 }
 
 static int brcm_ahci_remove(struct platform_device *pdev)
@@ -374,12 +428,12 @@ static int brcm_ahci_remove(struct platf
 	struct brcm_ahci_priv *priv = hpriv->plat_data;
 	int ret;
 
+	brcm_sata_phys_disable(priv);
+
 	ret = ata_platform_remove_one(pdev);
 	if (ret)
 		return ret;
 
-	brcm_sata_phys_disable(priv);
-
 	return 0;
 }
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/ata/libahci_platform.c linux-libre-4.14.163-gnu/drivers/ata/libahci_platform.c
--- linux-libre-4.14.162-gnu/drivers/ata/libahci_platform.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/ata/libahci_platform.c	2020-01-09 04:18:00.000000000 -0500
@@ -46,7 +46,7 @@ EXPORT_SYMBOL_GPL(ahci_platform_ops);
  * RETURNS:
  * 0 on success otherwise a negative error code
  */
-static int ahci_platform_enable_phys(struct ahci_host_priv *hpriv)
+int ahci_platform_enable_phys(struct ahci_host_priv *hpriv)
 {
 	int rc, i;
 
@@ -71,6 +71,7 @@ disable_phys:
 	}
 	return rc;
 }
+EXPORT_SYMBOL_GPL(ahci_platform_enable_phys);
 
 /**
  * ahci_platform_disable_phys - Disable PHYs
@@ -78,7 +79,7 @@ disable_phys:
  *
  * This function disables all PHYs found in hpriv->phys.
  */
-static void ahci_platform_disable_phys(struct ahci_host_priv *hpriv)
+void ahci_platform_disable_phys(struct ahci_host_priv *hpriv)
 {
 	int i;
 
@@ -87,6 +88,7 @@ static void ahci_platform_disable_phys(s
 		phy_exit(hpriv->phys[i]);
 	}
 }
+EXPORT_SYMBOL_GPL(ahci_platform_disable_phys);
 
 /**
  * ahci_platform_enable_clks - Enable platform clocks
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/block/xen-blkback/blkback.c linux-libre-4.14.163-gnu/drivers/block/xen-blkback/blkback.c
--- linux-libre-4.14.162-gnu/drivers/block/xen-blkback/blkback.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/block/xen-blkback/blkback.c	2020-01-09 04:18:00.000000000 -0500
@@ -929,6 +929,8 @@ next:
 out_of_memory:
 	pr_alert("%s: out of memory\n", __func__);
 	put_free_pages(ring, pages_to_gnt, segs_to_map);
+	for (i = last_map; i < num; i++)
+		pages[i]->handle = BLKBACK_INVALID_HANDLE;
 	return -ENOMEM;
 }
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/block/xen-blkback/xenbus.c linux-libre-4.14.163-gnu/drivers/block/xen-blkback/xenbus.c
--- linux-libre-4.14.162-gnu/drivers/block/xen-blkback/xenbus.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/block/xen-blkback/xenbus.c	2020-01-09 04:18:00.000000000 -0500
@@ -178,6 +178,15 @@ static struct xen_blkif *xen_blkif_alloc
 	blkif->domid = domid;
 	atomic_set(&blkif->refcnt, 1);
 	init_completion(&blkif->drain_complete);
+
+	/*
+	 * Because freeing back to the cache may be deferred, it is not
+	 * safe to unload the module (and hence destroy the cache) until
+	 * this has completed. To prevent premature unloading, take an
+	 * extra module reference here and release only when the object
+	 * has been freed back to the cache.
+	 */
+	__module_get(THIS_MODULE);
 	INIT_WORK(&blkif->free_work, xen_blkif_deferred_free);
 
 	return blkif;
@@ -327,6 +336,7 @@ static void xen_blkif_free(struct xen_bl
 
 	/* Make sure everything is drained before shutting down */
 	kmem_cache_free(xen_blkif_cachep, blkif);
+	module_put(THIS_MODULE);
 }
 
 int __init xen_blkif_interface_init(void)
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/bluetooth/btusb.c linux-libre-4.14.163-gnu/drivers/bluetooth/btusb.c
--- linux-libre-4.14.162-gnu/drivers/bluetooth/btusb.c	2020-01-04 11:01:45.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/bluetooth/btusb.c	2020-01-09 09:20:22.000000000 -0500
@@ -1123,7 +1123,7 @@ static int btusb_open(struct hci_dev *hd
 	if (data->setup_on_usb) {
 		err = data->setup_on_usb(hdev);
 		if (err < 0)
-			return err;
+			goto setup_fail;
 	}
 
 	data->intf->needs_remote_wakeup = 1;
@@ -1155,6 +1155,7 @@ done:
 
 failed:
 	clear_bit(BTUSB_INTR_RUNNING, &data->flags);
+setup_fail:
 	usb_autopm_put_interface(data->intf);
 	return err;
 }
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/devfreq/devfreq.c linux-libre-4.14.163-gnu/drivers/devfreq/devfreq.c
--- linux-libre-4.14.162-gnu/drivers/devfreq/devfreq.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/devfreq/devfreq.c	2020-01-09 04:18:00.000000000 -0500
@@ -484,11 +484,6 @@ static void devfreq_dev_release(struct d
 	struct devfreq *devfreq = to_devfreq(dev);
 
 	mutex_lock(&devfreq_list_lock);
-	if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) {
-		mutex_unlock(&devfreq_list_lock);
-		dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n");
-		return;
-	}
 	list_del(&devfreq->node);
 	mutex_unlock(&devfreq_list_lock);
 
@@ -547,6 +542,7 @@ struct devfreq *devfreq_add_device(struc
 	devfreq->dev.parent = dev;
 	devfreq->dev.class = devfreq_class;
 	devfreq->dev.release = devfreq_dev_release;
+	INIT_LIST_HEAD(&devfreq->node);
 	devfreq->profile = profile;
 	strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
 	devfreq->previous_freq = profile->initial_freq;
@@ -978,7 +974,7 @@ static ssize_t available_governors_show(
 	 * The devfreq with immutable governor (e.g., passive) shows
 	 * only own governor.
 	 */
-	if (df->governor->immutable) {
+	if (df->governor && df->governor->immutable) {
 		count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
 				   "%s ", df->governor_name);
 	/*
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/firewire/net.c linux-libre-4.14.163-gnu/drivers/firewire/net.c
--- linux-libre-4.14.162-gnu/drivers/firewire/net.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/firewire/net.c	2020-01-09 04:18:00.000000000 -0500
@@ -249,7 +249,11 @@ static int fwnet_header_cache(const stru
 	h = (struct fwnet_header *)((u8 *)hh->hh_data + HH_DATA_OFF(sizeof(*h)));
 	h->h_proto = type;
 	memcpy(h->h_dest, neigh->ha, net->addr_len);
-	hh->hh_len = FWNET_HLEN;
+
+	/* Pairs with the READ_ONCE() in neigh_resolve_output(),
+	 * neigh_hh_output() and neigh_update_hhs().
+	 */
+	smp_store_release(&hh->hh_len, FWNET_HLEN);
 
 	return 0;
 }
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/gpio/gpiolib.c linux-libre-4.14.163-gnu/drivers/gpio/gpiolib.c
--- linux-libre-4.14.162-gnu/drivers/gpio/gpiolib.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/gpio/gpiolib.c	2020-01-09 04:18:00.000000000 -0500
@@ -206,6 +206,14 @@ int gpiod_get_direction(struct gpio_desc
 	chip = gpiod_to_chip(desc);
 	offset = gpio_chip_hwgpio(desc);
 
+	/*
+	 * Open drain emulation using input mode may incorrectly report
+	 * input here, fix that up.
+	 */
+	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) &&
+	    test_bit(FLAG_IS_OUT, &desc->flags))
+		return 0;
+
 	if (!chip->get_direction)
 		return status;
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/gpu/drm/drm_dp_mst_topology.c linux-libre-4.14.163-gnu/drivers/gpu/drm/drm_dp_mst_topology.c
--- linux-libre-4.14.162-gnu/drivers/gpu/drm/drm_dp_mst_topology.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/gpu/drm/drm_dp_mst_topology.c	2020-01-09 04:18:00.000000000 -0500
@@ -1540,7 +1540,11 @@ static void process_single_up_tx_qlock(s
 	if (ret != 1)
 		DRM_DEBUG_KMS("failed to send msg in q %d\n", ret);
 
-	txmsg->dst->tx_slots[txmsg->seqno] = NULL;
+	if (txmsg->seqno != -1) {
+		WARN_ON((unsigned int)txmsg->seqno >
+			ARRAY_SIZE(txmsg->dst->tx_slots));
+		txmsg->dst->tx_slots[txmsg->seqno] = NULL;
+	}
 }
 
 static void drm_dp_queue_down_tx(struct drm_dp_mst_topology_mgr *mgr,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/gpu/drm/drm_property.c linux-libre-4.14.163-gnu/drivers/gpu/drm/drm_property.c
--- linux-libre-4.14.162-gnu/drivers/gpu/drm/drm_property.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/gpu/drm/drm_property.c	2020-01-09 04:18:00.000000000 -0500
@@ -540,7 +540,7 @@ drm_property_create_blob(struct drm_devi
 	struct drm_property_blob *blob;
 	int ret;
 
-	if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob))
+	if (!length || length > INT_MAX - sizeof(struct drm_property_blob))
 		return ERR_PTR(-EINVAL);
 
 	blob = kvzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/gpu/drm/nouveau/nouveau_connector.h linux-libre-4.14.163-gnu/drivers/gpu/drm/nouveau/nouveau_connector.h
--- linux-libre-4.14.162-gnu/drivers/gpu/drm/nouveau/nouveau_connector.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/gpu/drm/nouveau/nouveau_connector.h	2020-01-09 04:18:00.000000000 -0500
@@ -29,6 +29,7 @@
 
 #include <nvif/notify.h>
 
+#include <drm/drm_crtc.h>
 #include <drm/drm_edid.h>
 #include <drm/drm_encoder.h>
 #include <drm/drm_dp_helper.h>
@@ -37,6 +38,60 @@
 
 struct nvkm_i2c_port;
 
+#define nouveau_conn_atom(p)                                                   \
+	container_of((p), struct nouveau_conn_atom, state)
+
+struct nouveau_conn_atom {
+	struct drm_connector_state state;
+
+	struct {
+		/* The enum values specifically defined here match nv50/gf119
+		 * hw values, and the code relies on this.
+		 */
+		enum {
+			DITHERING_MODE_OFF = 0x00,
+			DITHERING_MODE_ON = 0x01,
+			DITHERING_MODE_DYNAMIC2X2 = 0x10 | DITHERING_MODE_ON,
+			DITHERING_MODE_STATIC2X2 = 0x18 | DITHERING_MODE_ON,
+			DITHERING_MODE_TEMPORAL = 0x20 | DITHERING_MODE_ON,
+			DITHERING_MODE_AUTO
+		} mode;
+		enum {
+			DITHERING_DEPTH_6BPC = 0x00,
+			DITHERING_DEPTH_8BPC = 0x02,
+			DITHERING_DEPTH_AUTO
+		} depth;
+	} dither;
+
+	struct {
+		int mode;	/* DRM_MODE_SCALE_* */
+		struct {
+			enum {
+				UNDERSCAN_OFF,
+				UNDERSCAN_ON,
+				UNDERSCAN_AUTO,
+			} mode;
+			u32 hborder;
+			u32 vborder;
+		} underscan;
+		bool full;
+	} scaler;
+
+	struct {
+		int color_vibrance;
+		int vibrant_hue;
+	} procamp;
+
+	union {
+		struct {
+			bool dither:1;
+			bool scaler:1;
+			bool procamp:1;
+		};
+		u8 mask;
+	} set;
+};
+
 struct nouveau_connector {
 	struct drm_connector base;
 	enum dcb_connector_type type;
@@ -111,61 +166,6 @@ extern int nouveau_ignorelid;
 extern int nouveau_duallink;
 extern int nouveau_hdmimhz;
 
-#include <drm/drm_crtc.h>
-#define nouveau_conn_atom(p)                                                   \
-	container_of((p), struct nouveau_conn_atom, state)
-
-struct nouveau_conn_atom {
-	struct drm_connector_state state;
-
-	struct {
-		/* The enum values specifically defined here match nv50/gf119
-		 * hw values, and the code relies on this.
-		 */
-		enum {
-			DITHERING_MODE_OFF = 0x00,
-			DITHERING_MODE_ON = 0x01,
-			DITHERING_MODE_DYNAMIC2X2 = 0x10 | DITHERING_MODE_ON,
-			DITHERING_MODE_STATIC2X2 = 0x18 | DITHERING_MODE_ON,
-			DITHERING_MODE_TEMPORAL = 0x20 | DITHERING_MODE_ON,
-			DITHERING_MODE_AUTO
-		} mode;
-		enum {
-			DITHERING_DEPTH_6BPC = 0x00,
-			DITHERING_DEPTH_8BPC = 0x02,
-			DITHERING_DEPTH_AUTO
-		} depth;
-	} dither;
-
-	struct {
-		int mode;	/* DRM_MODE_SCALE_* */
-		struct {
-			enum {
-				UNDERSCAN_OFF,
-				UNDERSCAN_ON,
-				UNDERSCAN_AUTO,
-			} mode;
-			u32 hborder;
-			u32 vborder;
-		} underscan;
-		bool full;
-	} scaler;
-
-	struct {
-		int color_vibrance;
-		int vibrant_hue;
-	} procamp;
-
-	union {
-		struct {
-			bool dither:1;
-			bool scaler:1;
-			bool procamp:1;
-		};
-		u8 mask;
-	} set;
-};
-
 void nouveau_conn_attach_properties(struct drm_connector *);
 void nouveau_conn_reset(struct drm_connector *);
 struct drm_connector_state *
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c linux-libre-4.14.163-gnu/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c
--- linux-libre-4.14.162-gnu/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c	2020-01-09 04:18:00.000000000 -0500
@@ -438,8 +438,6 @@ static void sun4i_hdmi_unbind(struct dev
 	struct sun4i_hdmi *hdmi = dev_get_drvdata(dev);
 
 	cec_unregister_adapter(hdmi->cec_adap);
-	drm_connector_cleanup(&hdmi->connector);
-	drm_encoder_cleanup(&hdmi->encoder);
 	i2c_del_adapter(hdmi->i2c);
 	clk_disable_unprepare(hdmi->mod_clk);
 	clk_disable_unprepare(hdmi->bus_clk);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/iio/adc/max9611.c linux-libre-4.14.163-gnu/drivers/iio/adc/max9611.c
--- linux-libre-4.14.162-gnu/drivers/iio/adc/max9611.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/iio/adc/max9611.c	2020-01-09 04:18:00.000000000 -0500
@@ -92,6 +92,12 @@
 #define MAX9611_TEMP_SCALE_NUM		1000000
 #define MAX9611_TEMP_SCALE_DIV		2083
 
+/*
+ * Conversion time is 2 ms (typically) at Ta=25 degreeC
+ * No maximum value is known, so play it safe.
+ */
+#define MAX9611_CONV_TIME_US_RANGE	3000, 3300
+
 struct max9611_dev {
 	struct device *dev;
 	struct i2c_client *i2c_client;
@@ -239,11 +245,9 @@ static int max9611_read_single(struct ma
 		return ret;
 	}
 
-	/*
-	 * need a delay here to make register configuration
-	 * stabilize. 1 msec at least, from empirical testing.
-	 */
-	usleep_range(1000, 2000);
+	/* need a delay here to make register configuration stabilize. */
+
+	usleep_range(MAX9611_CONV_TIME_US_RANGE);
 
 	ret = i2c_smbus_read_word_swapped(max9611->i2c_client, reg_addr);
 	if (ret < 0) {
@@ -511,7 +515,7 @@ static int max9611_init(struct max9611_d
 			MAX9611_REG_CTRL2, 0);
 		return ret;
 	}
-	usleep_range(1000, 2000);
+	usleep_range(MAX9611_CONV_TIME_US_RANGE);
 
 	return 0;
 }
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/infiniband/core/cma.c linux-libre-4.14.163-gnu/drivers/infiniband/core/cma.c
--- linux-libre-4.14.162-gnu/drivers/infiniband/core/cma.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/infiniband/core/cma.c	2020-01-09 04:18:00.000000000 -0500
@@ -4568,6 +4568,7 @@ err:
 	unregister_netdevice_notifier(&cma_nb);
 	rdma_addr_unregister_client(&addr_client);
 	ib_sa_unregister_client(&sa_client);
+	unregister_pernet_subsys(&cma_pernet_operations);
 err_wq:
 	destroy_workqueue(cma_wq);
 	return ret;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/infiniband/hw/mlx4/main.c linux-libre-4.14.163-gnu/drivers/infiniband/hw/mlx4/main.c
--- linux-libre-4.14.162-gnu/drivers/infiniband/hw/mlx4/main.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/infiniband/hw/mlx4/main.c	2020-01-09 04:18:00.000000000 -0500
@@ -3073,16 +3073,17 @@ static void mlx4_ib_remove(struct mlx4_d
 	ibdev->ib_active = false;
 	flush_workqueue(wq);
 
-	mlx4_ib_close_sriov(ibdev);
-	mlx4_ib_mad_cleanup(ibdev);
-	ib_unregister_device(&ibdev->ib_dev);
-	mlx4_ib_diag_cleanup(ibdev);
 	if (ibdev->iboe.nb.notifier_call) {
 		if (unregister_netdevice_notifier(&ibdev->iboe.nb))
 			pr_warn("failure unregistering notifier\n");
 		ibdev->iboe.nb.notifier_call = NULL;
 	}
 
+	mlx4_ib_close_sriov(ibdev);
+	mlx4_ib_mad_cleanup(ibdev);
+	ib_unregister_device(&ibdev->ib_dev);
+	mlx4_ib_diag_cleanup(ibdev);
+
 	mlx4_qp_release_range(dev, ibdev->steer_qpn_base,
 			      ibdev->steer_qpn_count);
 	kfree(ibdev->ib_uc_qpns_bitmap);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/infiniband/sw/rxe/rxe_recv.c linux-libre-4.14.163-gnu/drivers/infiniband/sw/rxe/rxe_recv.c
--- linux-libre-4.14.162-gnu/drivers/infiniband/sw/rxe/rxe_recv.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/infiniband/sw/rxe/rxe_recv.c	2020-01-09 04:18:00.000000000 -0500
@@ -393,7 +393,7 @@ int rxe_rcv(struct sk_buff *skb)
 
 	calc_icrc = rxe_icrc_hdr(pkt, skb);
 	calc_icrc = rxe_crc32(rxe, calc_icrc, (u8 *)payload_addr(pkt),
-			      payload_size(pkt));
+			      payload_size(pkt) + bth_pad(pkt));
 	calc_icrc = (__force u32)cpu_to_be32(~calc_icrc);
 	if (unlikely(calc_icrc != pack_icrc)) {
 		if (skb->protocol == htons(ETH_P_IPV6))
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/infiniband/sw/rxe/rxe_req.c linux-libre-4.14.163-gnu/drivers/infiniband/sw/rxe/rxe_req.c
--- linux-libre-4.14.162-gnu/drivers/infiniband/sw/rxe/rxe_req.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/infiniband/sw/rxe/rxe_req.c	2020-01-09 04:18:00.000000000 -0500
@@ -500,6 +500,12 @@ static int fill_packet(struct rxe_qp *qp
 			if (err)
 				return err;
 		}
+		if (bth_pad(pkt)) {
+			u8 *pad = payload_addr(pkt) + paylen;
+
+			memset(pad, 0, bth_pad(pkt));
+			crc = rxe_crc32(rxe, crc, pad, bth_pad(pkt));
+		}
 	}
 	p = payload_addr(pkt) + paylen + bth_pad(pkt);
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/infiniband/sw/rxe/rxe_resp.c linux-libre-4.14.163-gnu/drivers/infiniband/sw/rxe/rxe_resp.c
--- linux-libre-4.14.162-gnu/drivers/infiniband/sw/rxe/rxe_resp.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/infiniband/sw/rxe/rxe_resp.c	2020-01-09 04:18:00.000000000 -0500
@@ -738,6 +738,13 @@ static enum resp_states read_reply(struc
 	if (err)
 		pr_err("Failed copying memory\n");
 
+	if (bth_pad(&ack_pkt)) {
+		struct rxe_dev *rxe = to_rdev(qp->ibqp.device);
+		u8 *pad = payload_addr(&ack_pkt) + payload;
+
+		memset(pad, 0, bth_pad(&ack_pkt));
+		icrc = rxe_crc32(rxe, icrc, pad, bth_pad(&ack_pkt));
+	}
 	p = payload_addr(&ack_pkt) + payload + bth_pad(&ack_pkt);
 	*p = ~icrc;
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/md/raid1.c linux-libre-4.14.163-gnu/drivers/md/raid1.c
--- linux-libre-4.14.162-gnu/drivers/md/raid1.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/md/raid1.c	2020-01-09 04:18:00.000000000 -0500
@@ -2749,7 +2749,7 @@ static sector_t raid1_sync_request(struc
 				write_targets++;
 			}
 		}
-		if (bio->bi_end_io) {
+		if (rdev && bio->bi_end_io) {
 			atomic_inc(&rdev->nr_pending);
 			bio->bi_iter.bi_sector = sector_nr + rdev->data_offset;
 			bio_set_dev(bio, rdev->bdev);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/media/cec/cec-adap.c linux-libre-4.14.163-gnu/drivers/media/cec/cec-adap.c
--- linux-libre-4.14.162-gnu/drivers/media/cec/cec-adap.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/media/cec/cec-adap.c	2020-01-09 04:18:00.000000000 -0500
@@ -330,7 +330,8 @@ static void cec_data_cancel(struct cec_d
 	} else {
 		list_del_init(&data->list);
 		if (!(data->msg.tx_status & CEC_TX_STATUS_OK))
-			data->adap->transmit_queue_sz--;
+			if (!WARN_ON(!data->adap->transmit_queue_sz))
+				data->adap->transmit_queue_sz--;
 	}
 
 	/* Mark it as an error */
@@ -377,6 +378,14 @@ static void cec_flush(struct cec_adapter
 		 * need to do anything special in that case.
 		 */
 	}
+	/*
+	 * If something went wrong and this counter isn't what it should
+	 * be, then this will reset it back to 0. Warn if it is not 0,
+	 * since it indicates a bug, either in this framework or in a
+	 * CEC driver.
+	 */
+	if (WARN_ON(adap->transmit_queue_sz))
+		adap->transmit_queue_sz = 0;
 }
 
 /*
@@ -465,7 +474,8 @@ int cec_thread_func(void *_adap)
 		data = list_first_entry(&adap->transmit_queue,
 					struct cec_data, list);
 		list_del_init(&data->list);
-		adap->transmit_queue_sz--;
+		if (!WARN_ON(!data->adap->transmit_queue_sz))
+			adap->transmit_queue_sz--;
 
 		/* Make this the current transmitting message */
 		adap->transmitting = data;
@@ -1031,11 +1041,11 @@ void cec_received_msg_ts(struct cec_adap
 			valid_la = false;
 		else if (!cec_msg_is_broadcast(msg) && !(dir_fl & DIRECTED))
 			valid_la = false;
-		else if (cec_msg_is_broadcast(msg) && !(dir_fl & BCAST1_4))
+		else if (cec_msg_is_broadcast(msg) && !(dir_fl & BCAST))
 			valid_la = false;
 		else if (cec_msg_is_broadcast(msg) &&
-			 adap->log_addrs.cec_version >= CEC_OP_CEC_VERSION_2_0 &&
-			 !(dir_fl & BCAST2_0))
+			 adap->log_addrs.cec_version < CEC_OP_CEC_VERSION_2_0 &&
+			 !(dir_fl & BCAST1_4))
 			valid_la = false;
 	}
 	if (valid_la && min_len) {
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/media/usb/b2c2/flexcop-usb.c linux-libre-4.14.163-gnu/drivers/media/usb/b2c2/flexcop-usb.c
--- linux-libre-4.14.162-gnu/drivers/media/usb/b2c2/flexcop-usb.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/media/usb/b2c2/flexcop-usb.c	2020-01-09 04:18:00.000000000 -0500
@@ -294,7 +294,7 @@ static int flexcop_usb_i2c_req(struct fl
 
 	mutex_unlock(&fc_usb->data_mutex);
 
-	return 0;
+	return ret;
 }
 
 /* actual bus specific access functions,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/media/usb/dvb-usb/af9005.c linux-libre-4.14.163-gnu/drivers/media/usb/dvb-usb/af9005.c
--- linux-libre-4.14.162-gnu/drivers/media/usb/dvb-usb/af9005.c	2020-01-04 10:47:37.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/media/usb/dvb-usb/af9005.c	2020-01-09 09:04:51.000000000 -0500
@@ -985,8 +985,9 @@ static int af9005_identify_state(struct
 	else if (reply == 0x02)
 		*cold = 0;
 	else
-		return -EIO;
-	deb_info("Identify state cold = %d\n", *cold);
+		ret = -EIO;
+	if (!ret)
+		deb_info("Identify state cold = %d\n", *cold);
 
 err:
 	kfree(buf);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/media/usb/pulse8-cec/pulse8-cec.c linux-libre-4.14.163-gnu/drivers/media/usb/pulse8-cec/pulse8-cec.c
--- linux-libre-4.14.162-gnu/drivers/media/usb/pulse8-cec/pulse8-cec.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/media/usb/pulse8-cec/pulse8-cec.c	2020-01-09 04:18:00.000000000 -0500
@@ -121,6 +121,7 @@ struct pulse8 {
 	unsigned int vers;
 	struct completion cmd_done;
 	struct work_struct work;
+	u8 work_result;
 	struct delayed_work ping_eeprom_work;
 	struct cec_msg rx_msg;
 	u8 data[DATA_SIZE];
@@ -142,8 +143,10 @@ static void pulse8_irq_work_handler(stru
 {
 	struct pulse8 *pulse8 =
 		container_of(work, struct pulse8, work);
+	u8 result = pulse8->work_result;
 
-	switch (pulse8->data[0] & 0x3f) {
+	pulse8->work_result = 0;
+	switch (result & 0x3f) {
 	case MSGCODE_FRAME_DATA:
 		cec_received_msg(pulse8->adap, &pulse8->rx_msg);
 		break;
@@ -177,12 +180,12 @@ static irqreturn_t pulse8_interrupt(stru
 		pulse8->escape = false;
 	} else if (data == MSGEND) {
 		struct cec_msg *msg = &pulse8->rx_msg;
+		u8 msgcode = pulse8->buf[0];
 
 		if (debug)
 			dev_info(pulse8->dev, "received: %*ph\n",
 				 pulse8->idx, pulse8->buf);
-		pulse8->data[0] = pulse8->buf[0];
-		switch (pulse8->buf[0] & 0x3f) {
+		switch (msgcode & 0x3f) {
 		case MSGCODE_FRAME_START:
 			msg->len = 1;
 			msg->msg[0] = pulse8->buf[1];
@@ -191,14 +194,20 @@ static irqreturn_t pulse8_interrupt(stru
 			if (msg->len == CEC_MAX_MSG_SIZE)
 				break;
 			msg->msg[msg->len++] = pulse8->buf[1];
-			if (pulse8->buf[0] & MSGCODE_FRAME_EOM)
+			if (msgcode & MSGCODE_FRAME_EOM) {
+				WARN_ON(pulse8->work_result);
+				pulse8->work_result = msgcode;
 				schedule_work(&pulse8->work);
+				break;
+			}
 			break;
 		case MSGCODE_TRANSMIT_SUCCEEDED:
 		case MSGCODE_TRANSMIT_FAILED_LINE:
 		case MSGCODE_TRANSMIT_FAILED_ACK:
 		case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
 		case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
+			WARN_ON(pulse8->work_result);
+			pulse8->work_result = msgcode;
 			schedule_work(&pulse8->work);
 			break;
 		case MSGCODE_HIGH_ERROR:
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c linux-libre-4.14.163-gnu/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
--- linux-libre-4.14.162-gnu/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c	2020-01-09 04:18:00.000000000 -0500
@@ -973,6 +973,8 @@ static bool ath9k_rx_prepare(struct ath9
 	struct ath_htc_rx_status *rxstatus;
 	struct ath_rx_status rx_stats;
 	bool decrypt_error = false;
+	__be16 rs_datalen;
+	bool is_phyerr;
 
 	if (skb->len < HTC_RX_FRAME_HEADER_SIZE) {
 		ath_err(common, "Corrupted RX frame, dropping (len: %d)\n",
@@ -982,11 +984,24 @@ static bool ath9k_rx_prepare(struct ath9
 
 	rxstatus = (struct ath_htc_rx_status *)skb->data;
 
-	if (be16_to_cpu(rxstatus->rs_datalen) -
-	    (skb->len - HTC_RX_FRAME_HEADER_SIZE) != 0) {
+	rs_datalen = be16_to_cpu(rxstatus->rs_datalen);
+	if (unlikely(rs_datalen -
+	    (skb->len - HTC_RX_FRAME_HEADER_SIZE) != 0)) {
 		ath_err(common,
 			"Corrupted RX data len, dropping (dlen: %d, skblen: %d)\n",
-			rxstatus->rs_datalen, skb->len);
+			rs_datalen, skb->len);
+		goto rx_next;
+	}
+
+	is_phyerr = rxstatus->rs_status & ATH9K_RXERR_PHY;
+	/*
+	 * Discard zero-length packets and packets smaller than an ACK
+	 * which are not PHY_ERROR (short radar pulses have a length of 3)
+	 */
+	if (unlikely(!rs_datalen || (rs_datalen < 10 && !is_phyerr))) {
+		ath_warn(common,
+			 "Short RX data len, dropping (dlen: %d)\n",
+			 rs_datalen);
 		goto rx_next;
 	}
 
@@ -1011,7 +1026,7 @@ static bool ath9k_rx_prepare(struct ath9
 	 * Process PHY errors and return so that the packet
 	 * can be dropped.
 	 */
-	if (rx_stats.rs_status & ATH9K_RXERR_PHY) {
+	if (unlikely(is_phyerr)) {
 		/* TODO: Not using DFS processing now. */
 		if (ath_cmn_process_fft(&priv->spec_priv, hdr,
 				    &rx_stats, rx_status->mactime)) {
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/nvme/host/fc.c linux-libre-4.14.163-gnu/drivers/nvme/host/fc.c
--- linux-libre-4.14.162-gnu/drivers/nvme/host/fc.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/nvme/host/fc.c	2020-01-09 04:18:00.000000000 -0500
@@ -337,7 +337,8 @@ nvme_fc_register_localport(struct nvme_f
 	    !template->ls_req || !template->fcp_io ||
 	    !template->ls_abort || !template->fcp_abort ||
 	    !template->max_hw_queues || !template->max_sgl_segments ||
-	    !template->max_dif_sgl_segments || !template->dma_boundary) {
+	    !template->max_dif_sgl_segments || !template->dma_boundary ||
+	    !template->module) {
 		ret = -EINVAL;
 		goto out_reghost_failed;
 	}
@@ -1762,6 +1763,7 @@ nvme_fc_ctrl_free(struct kref *ref)
 {
 	struct nvme_fc_ctrl *ctrl =
 		container_of(ref, struct nvme_fc_ctrl, ref);
+	struct nvme_fc_lport *lport = ctrl->lport;
 	unsigned long flags;
 
 	if (ctrl->ctrl.tagset) {
@@ -1787,6 +1789,7 @@ nvme_fc_ctrl_free(struct kref *ref)
 	if (ctrl->ctrl.opts)
 		nvmf_free_options(ctrl->ctrl.opts);
 	kfree(ctrl);
+	module_put(lport->ops->module);
 }
 
 static void
@@ -2765,10 +2768,15 @@ nvme_fc_init_ctrl(struct device *dev, st
 		goto out_fail;
 	}
 
+	if (!try_module_get(lport->ops->module)) {
+		ret = -EUNATCH;
+		goto out_free_ctrl;
+	}
+
 	idx = ida_simple_get(&nvme_fc_ctrl_cnt, 0, 0, GFP_KERNEL);
 	if (idx < 0) {
 		ret = -ENOSPC;
-		goto out_free_ctrl;
+		goto out_mod_put;
 	}
 
 	ctrl->ctrl.opts = opts;
@@ -2915,6 +2923,8 @@ out_free_queues:
 out_free_ida:
 	put_device(ctrl->dev);
 	ida_simple_remove(&nvme_fc_ctrl_cnt, ctrl->cnum);
+out_mod_put:
+	module_put(lport->ops->module);
 out_free_ctrl:
 	kfree(ctrl);
 out_fail:
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/nvme/target/fcloop.c linux-libre-4.14.163-gnu/drivers/nvme/target/fcloop.c
--- linux-libre-4.14.162-gnu/drivers/nvme/target/fcloop.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/nvme/target/fcloop.c	2020-01-09 04:18:00.000000000 -0500
@@ -693,6 +693,7 @@ fcloop_targetport_delete(struct nvmet_fc
 #define FCLOOP_DMABOUND_4G		0xFFFFFFFF
 
 static struct nvme_fc_port_template fctemplate = {
+	.module			= THIS_MODULE,
 	.localport_delete	= fcloop_localport_delete,
 	.remoteport_delete	= fcloop_remoteport_delete,
 	.create_queue		= fcloop_create_queue,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/platform/x86/pmc_atom.c linux-libre-4.14.163-gnu/drivers/platform/x86/pmc_atom.c
--- linux-libre-4.14.162-gnu/drivers/platform/x86/pmc_atom.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/platform/x86/pmc_atom.c	2020-01-09 04:18:00.000000000 -0500
@@ -482,6 +482,14 @@ static const struct dmi_system_id critcl
 			DMI_MATCH(DMI_PRODUCT_VERSION, "6ES7647-8B"),
 		},
 	},
+	{
+		.ident = "CONNECT X300",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "SIEMENS AG"),
+			DMI_MATCH(DMI_PRODUCT_VERSION, "A5E45074588"),
+		},
+	},
+
 	{ /*sentinel*/ }
 };
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/regulator/ab8500.c linux-libre-4.14.163-gnu/drivers/regulator/ab8500.c
--- linux-libre-4.14.162-gnu/drivers/regulator/ab8500.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/regulator/ab8500.c	2020-01-09 04:18:00.000000000 -0500
@@ -1099,23 +1099,6 @@ static struct ab8500_regulator_info
 		.update_val_idle	= 0x82,
 		.update_val_normal	= 0x02,
 	},
-	[AB8505_LDO_USB] = {
-		.desc = {
-			.name           = "LDO-USB",
-			.ops            = &ab8500_regulator_mode_ops,
-			.type           = REGULATOR_VOLTAGE,
-			.id             = AB8505_LDO_USB,
-			.owner          = THIS_MODULE,
-			.n_voltages     = 1,
-			.volt_table	= fixed_3300000_voltage,
-		},
-		.update_bank            = 0x03,
-		.update_reg             = 0x82,
-		.update_mask            = 0x03,
-		.update_val		= 0x01,
-		.update_val_idle	= 0x03,
-		.update_val_normal	= 0x01,
-	},
 	[AB8505_LDO_AUDIO] = {
 		.desc = {
 			.name		= "LDO-AUDIO",
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/libsas/sas_discover.c linux-libre-4.14.163-gnu/drivers/scsi/libsas/sas_discover.c
--- linux-libre-4.14.162-gnu/drivers/scsi/libsas/sas_discover.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/libsas/sas_discover.c	2020-01-09 04:18:00.000000000 -0500
@@ -97,12 +97,21 @@ static int sas_get_port_device(struct as
 		else
 			dev->dev_type = SAS_SATA_DEV;
 		dev->tproto = SAS_PROTOCOL_SATA;
-	} else {
+	} else if (port->oob_mode == SAS_OOB_MODE) {
 		struct sas_identify_frame *id =
 			(struct sas_identify_frame *) dev->frame_rcvd;
 		dev->dev_type = id->dev_type;
 		dev->iproto = id->initiator_bits;
 		dev->tproto = id->target_bits;
+	} else {
+		/* If the oob mode is OOB_NOT_CONNECTED, the port is
+		 * disconnected due to race with PHY down. We cannot
+		 * continue to discover this port
+		 */
+		sas_put_device(dev);
+		pr_warn("Port %016llx is disconnected when discovering\n",
+			SAS_ADDR(port->attached_sas_addr));
+		return -ENODEV;
 	}
 
 	sas_init_dev(dev);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/lpfc/lpfc_bsg.c linux-libre-4.14.163-gnu/drivers/scsi/lpfc/lpfc_bsg.c
--- linux-libre-4.14.162-gnu/drivers/scsi/lpfc/lpfc_bsg.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/lpfc/lpfc_bsg.c	2020-01-09 04:18:00.000000000 -0500
@@ -4419,12 +4419,6 @@ lpfc_bsg_write_ebuf_set(struct lpfc_hba
 	phba->mbox_ext_buf_ctx.seqNum++;
 	nemb_tp = phba->mbox_ext_buf_ctx.nembType;
 
-	dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
-	if (!dd_data) {
-		rc = -ENOMEM;
-		goto job_error;
-	}
-
 	pbuf = (uint8_t *)dmabuf->virt;
 	size = job->request_payload.payload_len;
 	sg_copy_to_buffer(job->request_payload.sg_list,
@@ -4461,6 +4455,13 @@ lpfc_bsg_write_ebuf_set(struct lpfc_hba
 				"2968 SLI_CONFIG ext-buffer wr all %d "
 				"ebuffers received\n",
 				phba->mbox_ext_buf_ctx.numBuf);
+
+		dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+		if (!dd_data) {
+			rc = -ENOMEM;
+			goto job_error;
+		}
+
 		/* mailbox command structure for base driver */
 		pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 		if (!pmboxq) {
@@ -4509,6 +4510,8 @@ lpfc_bsg_write_ebuf_set(struct lpfc_hba
 	return SLI_CONFIG_HANDLED;
 
 job_error:
+	if (pmboxq)
+		mempool_free(pmboxq, phba->mbox_mem_pool);
 	lpfc_bsg_dma_page_free(phba, dmabuf);
 	kfree(dd_data);
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/lpfc/lpfc_nvme.c linux-libre-4.14.163-gnu/drivers/scsi/lpfc/lpfc_nvme.c
--- linux-libre-4.14.162-gnu/drivers/scsi/lpfc/lpfc_nvme.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/lpfc/lpfc_nvme.c	2020-01-09 04:18:00.000000000 -0500
@@ -1591,6 +1591,8 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local
 
 /* Declare and initialization an instance of the FC NVME template. */
 static struct nvme_fc_port_template lpfc_nvme_template = {
+	.module	= THIS_MODULE,
+
 	/* initiator-based functions */
 	.localport_delete  = lpfc_nvme_localport_delete,
 	.remoteport_delete = lpfc_nvme_remoteport_delete,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/qedf/qedf_els.c linux-libre-4.14.163-gnu/drivers/scsi/qedf/qedf_els.c
--- linux-libre-4.14.162-gnu/drivers/scsi/qedf/qedf_els.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/qedf/qedf_els.c	2020-01-09 04:18:00.000000000 -0500
@@ -23,8 +23,6 @@ static int qedf_initiate_els(struct qedf
 	int rc = 0;
 	uint32_t did, sid;
 	uint16_t xid;
-	uint32_t start_time = jiffies / HZ;
-	uint32_t current_time;
 	struct fcoe_wqe *sqe;
 	unsigned long flags;
 	u16 sqe_idx;
@@ -50,18 +48,12 @@ static int qedf_initiate_els(struct qedf
 		goto els_err;
 	}
 
-retry_els:
 	els_req = qedf_alloc_cmd(fcport, QEDF_ELS);
 	if (!els_req) {
-		current_time = jiffies / HZ;
-		if ((current_time - start_time) > 10) {
-			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
-				   "els: Failed els 0x%x\n", op);
-			rc = -ENOMEM;
-			goto els_err;
-		}
-		mdelay(20 * USEC_PER_MSEC);
-		goto retry_els;
+		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_ELS,
+			  "Failed to alloc ELS request 0x%x\n", op);
+		rc = -ENOMEM;
+		goto els_err;
 	}
 
 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "initiate_els els_req = "
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/qla2xxx/qla_isr.c linux-libre-4.14.163-gnu/drivers/scsi/qla2xxx/qla_isr.c
--- linux-libre-4.14.162-gnu/drivers/scsi/qla2xxx/qla_isr.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/qla2xxx/qla_isr.c	2020-01-09 04:18:00.000000000 -0500
@@ -1046,8 +1046,6 @@ global_port_update:
 			ql_dbg(ql_dbg_async, vha, 0x5011,
 			    "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
 			    mb[1], mb[2], mb[3]);
-
-			qlt_async_event(mb[0], vha, mb);
 			break;
 		}
 
@@ -1065,8 +1063,6 @@ global_port_update:
 		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
 		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
 		set_bit(VP_CONFIG_OK, &vha->vp_flags);
-
-		qlt_async_event(mb[0], vha, mb);
 		break;
 
 	case MBA_RSCN_UPDATE:		/* State Change Registration */
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/qla2xxx/qla_nvme.c linux-libre-4.14.163-gnu/drivers/scsi/qla2xxx/qla_nvme.c
--- linux-libre-4.14.162-gnu/drivers/scsi/qla2xxx/qla_nvme.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/qla2xxx/qla_nvme.c	2020-01-09 04:18:00.000000000 -0500
@@ -578,6 +578,7 @@ static void qla_nvme_remoteport_delete(s
 }
 
 static struct nvme_fc_port_template qla_nvme_fc_transport = {
+	.module	= THIS_MODULE,
 	.localport_delete = qla_nvme_localport_delete,
 	.remoteport_delete = qla_nvme_remoteport_delete,
 	.create_queue   = qla_nvme_alloc_queue,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/qla2xxx/qla_target.c linux-libre-4.14.163-gnu/drivers/scsi/qla2xxx/qla_target.c
--- linux-libre-4.14.162-gnu/drivers/scsi/qla2xxx/qla_target.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/qla2xxx/qla_target.c	2020-01-09 04:18:00.000000000 -0500
@@ -1210,7 +1210,6 @@ void qlt_schedule_sess_for_deletion(stru
 	    "Scheduling sess %p for deletion %8phC\n",
 	    sess, sess->port_name);
 
-	INIT_WORK(&sess->del_work, qla24xx_delete_sess_fn);
 	queue_work(sess->vha->hw->wq, &sess->del_work);
 }
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/scsi/qla4xxx/ql4_os.c linux-libre-4.14.163-gnu/drivers/scsi/qla4xxx/ql4_os.c
--- linux-libre-4.14.162-gnu/drivers/scsi/qla4xxx/ql4_os.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/scsi/qla4xxx/ql4_os.c	2020-01-09 04:18:00.000000000 -0500
@@ -4285,7 +4285,6 @@ static int qla4xxx_mem_alloc(struct scsi
 	return QLA_SUCCESS;
 
 mem_alloc_error_exit:
-	qla4xxx_mem_free(ha);
 	return QLA_ERROR;
 }
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/tty/hvc/hvc_vio.c linux-libre-4.14.163-gnu/drivers/tty/hvc/hvc_vio.c
--- linux-libre-4.14.162-gnu/drivers/tty/hvc/hvc_vio.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/tty/hvc/hvc_vio.c	2020-01-09 04:18:00.000000000 -0500
@@ -120,6 +120,14 @@ static int hvterm_raw_get_chars(uint32_t
 	return got;
 }
 
+/**
+ * hvterm_raw_put_chars: send characters to firmware for given vterm adapter
+ * @vtermno: The virtual terminal number.
+ * @buf: The characters to send. Because of the underlying hypercall in
+ *       hvc_put_chars(), this buffer must be at least 16 bytes long, even if
+ *       you are sending fewer chars.
+ * @count: number of chars to send.
+ */
 static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
 {
 	struct hvterm_priv *pv = hvterm_privs[vtermno];
@@ -232,6 +240,7 @@ static const struct hv_ops hvterm_hvsi_o
 static void udbg_hvc_putc(char c)
 {
 	int count = -1;
+	unsigned char bounce_buffer[16];
 
 	if (!hvterm_privs[0])
 		return;
@@ -242,7 +251,12 @@ static void udbg_hvc_putc(char c)
 	do {
 		switch(hvterm_privs[0]->proto) {
 		case HV_PROTOCOL_RAW:
-			count = hvterm_raw_put_chars(0, &c, 1);
+			/*
+			 * hvterm_raw_put_chars requires at least a 16-byte
+			 * buffer, so go via the bounce buffer
+			 */
+			bounce_buffer[0] = c;
+			count = hvterm_raw_put_chars(0, bounce_buffer, 1);
 			break;
 		case HV_PROTOCOL_HVSI:
 			count = hvterm_hvsi_put_chars(0, &c, 1);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/tty/serial/msm_serial.c linux-libre-4.14.163-gnu/drivers/tty/serial/msm_serial.c
--- linux-libre-4.14.162-gnu/drivers/tty/serial/msm_serial.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/tty/serial/msm_serial.c	2020-01-09 04:18:00.000000000 -0500
@@ -1588,6 +1588,7 @@ static void __msm_console_write(struct u
 	int num_newlines = 0;
 	bool replaced = false;
 	void __iomem *tf;
+	int locked = 1;
 
 	if (is_uartdm)
 		tf = port->membase + UARTDM_TF;
@@ -1600,7 +1601,13 @@ static void __msm_console_write(struct u
 			num_newlines++;
 	count += num_newlines;
 
-	spin_lock(&port->lock);
+	if (port->sysrq)
+		locked = 0;
+	else if (oops_in_progress)
+		locked = spin_trylock(&port->lock);
+	else
+		spin_lock(&port->lock);
+
 	if (is_uartdm)
 		msm_reset_dm_count(port, count);
 
@@ -1636,7 +1643,9 @@ static void __msm_console_write(struct u
 		iowrite32_rep(tf, buf, 1);
 		i += num_chars;
 	}
-	spin_unlock(&port->lock);
+
+	if (locked)
+		spin_unlock(&port->lock);
 }
 
 static void msm_console_write(struct console *co, const char *s,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/usb/gadget/function/f_ecm.c linux-libre-4.14.163-gnu/drivers/usb/gadget/function/f_ecm.c
--- linux-libre-4.14.162-gnu/drivers/usb/gadget/function/f_ecm.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/usb/gadget/function/f_ecm.c	2020-01-09 04:18:00.000000000 -0500
@@ -625,8 +625,12 @@ static void ecm_disable(struct usb_funct
 
 	DBG(cdev, "ecm deactivated\n");
 
-	if (ecm->port.in_ep->enabled)
+	if (ecm->port.in_ep->enabled) {
 		gether_disconnect(&ecm->port);
+	} else {
+		ecm->port.in_ep->desc = NULL;
+		ecm->port.out_ep->desc = NULL;
+	}
 
 	usb_ep_disable(ecm->notify);
 	ecm->notify->desc = NULL;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/usb/gadget/function/f_rndis.c linux-libre-4.14.163-gnu/drivers/usb/gadget/function/f_rndis.c
--- linux-libre-4.14.162-gnu/drivers/usb/gadget/function/f_rndis.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/usb/gadget/function/f_rndis.c	2020-01-09 04:18:00.000000000 -0500
@@ -622,6 +622,7 @@ static void rndis_disable(struct usb_fun
 	gether_disconnect(&rndis->port);
 
 	usb_ep_disable(rndis->notify);
+	rndis->notify->desc = NULL;
 }
 
 /*-------------------------------------------------------------------------*/
diff -druNp --no-dereference linux-libre-4.14.162-gnu/drivers/xen/balloon.c linux-libre-4.14.163-gnu/drivers/xen/balloon.c
--- linux-libre-4.14.162-gnu/drivers/xen/balloon.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/drivers/xen/balloon.c	2020-01-09 04:18:00.000000000 -0500
@@ -401,7 +401,8 @@ static struct notifier_block xen_memory_
 #else
 static enum bp_state reserve_additional_memory(void)
 {
-	balloon_stats.target_pages = balloon_stats.current_pages;
+	balloon_stats.target_pages = balloon_stats.current_pages +
+				     balloon_stats.target_unpopulated;
 	return BP_ECANCELED;
 }
 #endif /* CONFIG_XEN_BALLOON_MEMORY_HOTPLUG */
diff -druNp --no-dereference linux-libre-4.14.162-gnu/fs/compat_ioctl.c linux-libre-4.14.163-gnu/fs/compat_ioctl.c
--- linux-libre-4.14.162-gnu/fs/compat_ioctl.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/fs/compat_ioctl.c	2020-01-09 04:18:00.000000000 -0500
@@ -1577,9 +1577,10 @@ COMPAT_SYSCALL_DEFINE3(ioctl, unsigned i
 #endif
 
 	case FICLONE:
+		goto do_ioctl;
 	case FICLONERANGE:
 	case FIDEDUPERANGE:
-		goto do_ioctl;
+		goto found_handler;
 
 	case FIBMAP:
 	case FIGETBSZ:
diff -druNp --no-dereference linux-libre-4.14.162-gnu/fs/locks.c linux-libre-4.14.163-gnu/fs/locks.c
--- linux-libre-4.14.162-gnu/fs/locks.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/fs/locks.c	2020-01-09 04:18:00.000000000 -0500
@@ -2691,7 +2691,7 @@ static void lock_get_status(struct seq_f
 	}
 	if (inode) {
 		/* userspace relies on this representation of dev_t */
-		seq_printf(f, "%d %02x:%02x:%ld ", fl_pid,
+		seq_printf(f, "%d %02x:%02x:%lu ", fl_pid,
 				MAJOR(inode->i_sb->s_dev),
 				MINOR(inode->i_sb->s_dev), inode->i_ino);
 	} else {
diff -druNp --no-dereference linux-libre-4.14.162-gnu/fs/nfsd/nfs4state.c linux-libre-4.14.163-gnu/fs/nfsd/nfs4state.c
--- linux-libre-4.14.162-gnu/fs/nfsd/nfs4state.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/fs/nfsd/nfs4state.c	2020-01-09 04:18:00.000000000 -0500
@@ -3058,12 +3058,17 @@ static bool replay_matches_cache(struct
 	    (bool)seq->cachethis)
 		return false;
 	/*
-	 * If there's an error than the reply can have fewer ops than
-	 * the call.  But if we cached a reply with *more* ops than the
-	 * call you're sending us now, then this new call is clearly not
-	 * really a replay of the old one:
+	 * If there's an error then the reply can have fewer ops than
+	 * the call.
 	 */
-	if (slot->sl_opcnt < argp->opcnt)
+	if (slot->sl_opcnt < argp->opcnt && !slot->sl_status)
+		return false;
+	/*
+	 * But if we cached a reply with *more* ops than the call you're
+	 * sending us now, then this new call is clearly not really a
+	 * replay of the old one:
+	 */
+	if (slot->sl_opcnt > argp->opcnt)
 		return false;
 	/* This is the only check explicitly called by spec: */
 	if (!same_creds(&rqstp->rq_cred, &slot->sl_cred))
diff -druNp --no-dereference linux-libre-4.14.162-gnu/fs/pstore/ram.c linux-libre-4.14.163-gnu/fs/pstore/ram.c
--- linux-libre-4.14.162-gnu/fs/pstore/ram.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/fs/pstore/ram.c	2020-01-09 04:18:00.000000000 -0500
@@ -433,6 +433,17 @@ static int notrace ramoops_pstore_write(
 
 	prz = cxt->dprzs[cxt->dump_write_cnt];
 
+	/*
+	 * Since this is a new crash dump, we need to reset the buffer in
+	 * case it still has an old dump present. Without this, the new dump
+	 * will get appended, which would seriously confuse anything trying
+	 * to check dump file contents. Specifically, ramoops_read_kmsg_hdr()
+	 * expects to find a dump header in the beginning of buffer data, so
+	 * we must to reset the buffer values, in order to ensure that the
+	 * header will be written to the beginning of the buffer.
+	 */
+	persistent_ram_zap(prz);
+
 	/* Build header and append record contents. */
 	hlen = ramoops_write_kmsg_hdr(prz, record);
 	size = record->size;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/fs/xfs/libxfs/xfs_bmap.c linux-libre-4.14.163-gnu/fs/xfs/libxfs/xfs_bmap.c
--- linux-libre-4.14.162-gnu/fs/xfs/libxfs/xfs_bmap.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/fs/xfs/libxfs/xfs_bmap.c	2020-01-09 04:18:00.000000000 -0500
@@ -5556,7 +5556,7 @@ __xfs_bunmapi(
 		 * Make sure we don't touch multiple AGF headers out of order
 		 * in a single transaction, as that could cause AB-BA deadlocks.
 		 */
-		if (!wasdel) {
+		if (!wasdel && !isrt) {
 			agno = XFS_FSB_TO_AGNO(mp, del.br_startblock);
 			if (prev_agno != NULLAGNUMBER && prev_agno > agno)
 				break;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/fs/xfs/xfs_log.c linux-libre-4.14.163-gnu/fs/xfs/xfs_log.c
--- linux-libre-4.14.162-gnu/fs/xfs/xfs_log.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/fs/xfs/xfs_log.c	2020-01-09 04:18:00.000000000 -0500
@@ -1539,6 +1539,8 @@ out_free_iclog:
 		if (iclog->ic_bp)
 			xfs_buf_free(iclog->ic_bp);
 		kmem_free(iclog);
+		if (prev_iclog == log->l_iclog)
+			break;
 	}
 	spinlock_destroy(&log->l_icloglock);
 	xfs_buf_free(log->l_xbuf);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/include/linux/ahci_platform.h linux-libre-4.14.163-gnu/include/linux/ahci_platform.h
--- linux-libre-4.14.162-gnu/include/linux/ahci_platform.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/include/linux/ahci_platform.h	2020-01-09 04:18:00.000000000 -0500
@@ -23,6 +23,8 @@ struct ahci_host_priv;
 struct platform_device;
 struct scsi_host_template;
 
+int ahci_platform_enable_phys(struct ahci_host_priv *hpriv);
+void ahci_platform_disable_phys(struct ahci_host_priv *hpriv);
 int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);
 void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);
 int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/include/linux/dmaengine.h linux-libre-4.14.163-gnu/include/linux/dmaengine.h
--- linux-libre-4.14.162-gnu/include/linux/dmaengine.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/include/linux/dmaengine.h	2020-01-09 04:18:00.000000000 -0500
@@ -1362,8 +1362,11 @@ static inline int dma_get_slave_caps(str
 static inline int dmaengine_desc_set_reuse(struct dma_async_tx_descriptor *tx)
 {
 	struct dma_slave_caps caps;
+	int ret;
 
-	dma_get_slave_caps(tx->chan, &caps);
+	ret = dma_get_slave_caps(tx->chan, &caps);
+	if (ret)
+		return ret;
 
 	if (caps.descriptor_reuse) {
 		tx->flags |= DMA_CTRL_REUSE;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/include/linux/nvme-fc-driver.h linux-libre-4.14.163-gnu/include/linux/nvme-fc-driver.h
--- linux-libre-4.14.162-gnu/include/linux/nvme-fc-driver.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/include/linux/nvme-fc-driver.h	2020-01-09 04:18:00.000000000 -0500
@@ -279,6 +279,8 @@ struct nvme_fc_remote_port {
  *
  * Host/Initiator Transport Entrypoints/Parameters:
  *
+ * @module:  The LLDD module using the interface
+ *
  * @localport_delete:  The LLDD initiates deletion of a localport via
  *       nvme_fc_deregister_localport(). However, the teardown is
  *       asynchronous. This routine is called upon the completion of the
@@ -392,6 +394,8 @@ struct nvme_fc_remote_port {
  *       Value is Mandatory. Allowed to be zero.
  */
 struct nvme_fc_port_template {
+	struct module	*module;
+
 	/* initiator-based functions */
 	void	(*localport_delete)(struct nvme_fc_local_port *);
 	void	(*remoteport_delete)(struct nvme_fc_remote_port *);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/include/linux/regulator/ab8500.h linux-libre-4.14.163-gnu/include/linux/regulator/ab8500.h
--- linux-libre-4.14.162-gnu/include/linux/regulator/ab8500.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/include/linux/regulator/ab8500.h	2020-01-09 04:18:00.000000000 -0500
@@ -38,7 +38,6 @@ enum ab8505_regulator_id {
 	AB8505_LDO_AUX6,
 	AB8505_LDO_INTCORE,
 	AB8505_LDO_ADC,
-	AB8505_LDO_USB,
 	AB8505_LDO_AUDIO,
 	AB8505_LDO_ANAMIC1,
 	AB8505_LDO_ANAMIC2,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/include/net/neighbour.h linux-libre-4.14.163-gnu/include/net/neighbour.h
--- linux-libre-4.14.162-gnu/include/net/neighbour.h	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/include/net/neighbour.h	2020-01-09 04:18:00.000000000 -0500
@@ -458,7 +458,7 @@ static inline int neigh_hh_output(const
 
 	do {
 		seq = read_seqbegin(&hh->hh_lock);
-		hh_len = hh->hh_len;
+		hh_len = READ_ONCE(hh->hh_len);
 		if (likely(hh_len <= HH_DATA_MOD)) {
 			hh_alen = HH_DATA_MOD;
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/cred.c linux-libre-4.14.163-gnu/kernel/cred.c
--- linux-libre-4.14.162-gnu/kernel/cred.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/cred.c	2020-01-09 04:18:00.000000000 -0500
@@ -220,7 +220,7 @@ struct cred *cred_alloc_blank(void)
 	new->magic = CRED_MAGIC;
 #endif
 
-	if (security_cred_alloc_blank(new, GFP_KERNEL) < 0)
+	if (security_cred_alloc_blank(new, GFP_KERNEL_ACCOUNT) < 0)
 		goto error;
 
 	return new;
@@ -279,7 +279,7 @@ struct cred *prepare_creds(void)
 	new->security = NULL;
 #endif
 
-	if (security_prepare_creds(new, old, GFP_KERNEL) < 0)
+	if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)
 		goto error;
 	validate_creds(new);
 	return new;
@@ -654,7 +654,7 @@ struct cred *prepare_kernel_cred(struct
 #ifdef CONFIG_SECURITY
 	new->security = NULL;
 #endif
-	if (security_prepare_creds(new, old, GFP_KERNEL) < 0)
+	if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)
 		goto error;
 
 	put_cred(old);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/exit.c linux-libre-4.14.163-gnu/kernel/exit.c
--- linux-libre-4.14.162-gnu/kernel/exit.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/exit.c	2020-01-09 04:18:00.000000000 -0500
@@ -577,10 +577,6 @@ static struct task_struct *find_child_re
 	}
 
 	write_unlock_irq(&tasklist_lock);
-	if (unlikely(pid_ns == &init_pid_ns)) {
-		panic("Attempted to kill init! exitcode=0x%08x\n",
-			father->signal->group_exit_code ?: father->exit_code);
-	}
 
 	list_for_each_entry_safe(p, n, dead, ptrace_entry) {
 		list_del_init(&p->ptrace_entry);
@@ -823,6 +819,14 @@ void __noreturn do_exit(long code)
 	acct_update_integrals(tsk);
 	group_dead = atomic_dec_and_test(&tsk->signal->live);
 	if (group_dead) {
+		/*
+		 * If the last thread of global init has exited, panic
+		 * immediately to get a useable coredump.
+		 */
+		if (unlikely(is_global_init(tsk)))
+			panic("Attempted to kill init! exitcode=0x%08x\n",
+				tsk->signal->group_exit_code ?: (int)code);
+
 #ifdef CONFIG_POSIX_TIMERS
 		hrtimer_cancel(&tsk->signal->real_timer);
 		exit_itimers(tsk->signal);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/power/snapshot.c linux-libre-4.14.163-gnu/kernel/power/snapshot.c
--- linux-libre-4.14.162-gnu/kernel/power/snapshot.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/power/snapshot.c	2020-01-09 04:18:00.000000000 -0500
@@ -734,8 +734,15 @@ zone_found:
 	 * We have found the zone. Now walk the radix tree to find the leaf node
 	 * for our PFN.
 	 */
+
+	/*
+	 * If the zone we wish to scan is the the current zone and the
+	 * pfn falls into the current node then we do not need to walk
+	 * the tree.
+	 */
 	node = bm->cur.node;
-	if (((pfn - zone->start_pfn) & ~BM_BLOCK_MASK) == bm->cur.node_pfn)
+	if (zone == bm->cur.zone &&
+	    ((pfn - zone->start_pfn) & ~BM_BLOCK_MASK) == bm->cur.node_pfn)
 		goto node_found;
 
 	node      = zone->rtree;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/taskstats.c linux-libre-4.14.163-gnu/kernel/taskstats.c
--- linux-libre-4.14.162-gnu/kernel/taskstats.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/taskstats.c	2020-01-09 04:18:00.000000000 -0500
@@ -568,25 +568,33 @@ static int taskstats_user_cmd(struct sk_
 static struct taskstats *taskstats_tgid_alloc(struct task_struct *tsk)
 {
 	struct signal_struct *sig = tsk->signal;
-	struct taskstats *stats;
+	struct taskstats *stats_new, *stats;
 
-	if (sig->stats || thread_group_empty(tsk))
-		goto ret;
+	/* Pairs with smp_store_release() below. */
+	stats = smp_load_acquire(&sig->stats);
+	if (stats || thread_group_empty(tsk))
+		return stats;
 
 	/* No problem if kmem_cache_zalloc() fails */
-	stats = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
+	stats_new = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
 
 	spin_lock_irq(&tsk->sighand->siglock);
-	if (!sig->stats) {
-		sig->stats = stats;
-		stats = NULL;
+	stats = sig->stats;
+	if (!stats) {
+		/*
+		 * Pairs with smp_store_release() above and order the
+		 * kmem_cache_zalloc().
+		 */
+		smp_store_release(&sig->stats, stats_new);
+		stats = stats_new;
+		stats_new = NULL;
 	}
 	spin_unlock_irq(&tsk->sighand->siglock);
 
-	if (stats)
-		kmem_cache_free(taskstats_cache, stats);
-ret:
-	return sig->stats;
+	if (stats_new)
+		kmem_cache_free(taskstats_cache, stats_new);
+
+	return stats;
 }
 
 /* Send pid data out on exit */
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/trace/ftrace.c linux-libre-4.14.163-gnu/kernel/trace/ftrace.c
--- linux-libre-4.14.162-gnu/kernel/trace/ftrace.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/trace/ftrace.c	2020-01-09 04:18:00.000000000 -0500
@@ -622,8 +622,7 @@ static int function_stat_show(struct seq
 	}
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
-	avg = rec->time;
-	do_div(avg, rec->counter);
+	avg = div64_ul(rec->time, rec->counter);
 	if (tracing_thresh && (avg < tracing_thresh))
 		goto out;
 #endif
@@ -649,7 +648,8 @@ static int function_stat_show(struct seq
 		 * Divide only 1000 for ns^2 -> us^2 conversion.
 		 * trace_print_graph_duration will divide 1000 again.
 		 */
-		do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
+		stddev = div64_ul(stddev,
+				  rec->counter * (rec->counter - 1) * 1000);
 	}
 
 	trace_seq_init(&s);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/trace/trace.c linux-libre-4.14.163-gnu/kernel/trace/trace.c
--- linux-libre-4.14.162-gnu/kernel/trace/trace.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/trace/trace.c	2020-01-09 04:18:00.000000000 -0500
@@ -4368,6 +4368,10 @@ int trace_keep_overwrite(struct tracer *
 
 int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)
 {
+	if ((mask == TRACE_ITER_RECORD_TGID) ||
+	    (mask == TRACE_ITER_RECORD_CMD))
+		lockdep_assert_held(&event_mutex);
+
 	/* do nothing if flag is already set */
 	if (!!(tr->trace_flags & mask) == !!enabled)
 		return 0;
@@ -4433,6 +4437,7 @@ static int trace_set_options(struct trac
 		cmp += 2;
 	}
 
+	mutex_lock(&event_mutex);
 	mutex_lock(&trace_types_lock);
 
 	for (i = 0; trace_options[i]; i++) {
@@ -4447,6 +4452,7 @@ static int trace_set_options(struct trac
 		ret = set_tracer_option(tr, cmp, neg);
 
 	mutex_unlock(&trace_types_lock);
+	mutex_unlock(&event_mutex);
 
 	/*
 	 * If the first trailing whitespace is replaced with '\0' by strstrip,
@@ -7373,9 +7379,11 @@ trace_options_core_write(struct file *fi
 	if (val != 0 && val != 1)
 		return -EINVAL;
 
+	mutex_lock(&event_mutex);
 	mutex_lock(&trace_types_lock);
 	ret = set_tracer_flag(tr, 1 << index, val);
 	mutex_unlock(&trace_types_lock);
+	mutex_unlock(&event_mutex);
 
 	if (ret < 0)
 		return ret;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/trace/trace_events.c linux-libre-4.14.163-gnu/kernel/trace/trace_events.c
--- linux-libre-4.14.162-gnu/kernel/trace/trace_events.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/trace/trace_events.c	2020-01-09 04:18:00.000000000 -0500
@@ -326,7 +326,8 @@ void trace_event_enable_cmd_record(bool
 	struct trace_event_file *file;
 	struct trace_array *tr;
 
-	mutex_lock(&event_mutex);
+	lockdep_assert_held(&event_mutex);
+
 	do_for_each_event_file(tr, file) {
 
 		if (!(file->flags & EVENT_FILE_FL_ENABLED))
@@ -340,7 +341,6 @@ void trace_event_enable_cmd_record(bool
 			clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
 		}
 	} while_for_each_event_file();
-	mutex_unlock(&event_mutex);
 }
 
 void trace_event_enable_tgid_record(bool enable)
@@ -348,7 +348,8 @@ void trace_event_enable_tgid_record(bool
 	struct trace_event_file *file;
 	struct trace_array *tr;
 
-	mutex_lock(&event_mutex);
+	lockdep_assert_held(&event_mutex);
+
 	do_for_each_event_file(tr, file) {
 		if (!(file->flags & EVENT_FILE_FL_ENABLED))
 			continue;
@@ -362,7 +363,6 @@ void trace_event_enable_tgid_record(bool
 				  &file->flags);
 		}
 	} while_for_each_event_file();
-	mutex_unlock(&event_mutex);
 }
 
 static int __ftrace_event_enable_disable(struct trace_event_file *file,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/kernel/trace/tracing_map.c linux-libre-4.14.163-gnu/kernel/trace/tracing_map.c
--- linux-libre-4.14.162-gnu/kernel/trace/tracing_map.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/kernel/trace/tracing_map.c	2020-01-09 04:18:00.000000000 -0500
@@ -90,8 +90,8 @@ static int tracing_map_cmp_atomic64(void
 #define DEFINE_TRACING_MAP_CMP_FN(type)					\
 static int tracing_map_cmp_##type(void *val_a, void *val_b)		\
 {									\
-	type a = *(type *)val_a;					\
-	type b = *(type *)val_b;					\
+	type a = (type)(*(u64 *)val_a);					\
+	type b = (type)(*(u64 *)val_b);					\
 									\
 	return (a > b) ? 1 : ((a < b) ? -1 : 0);			\
 }
diff -druNp --no-dereference linux-libre-4.14.162-gnu/Makefile linux-libre-4.14.163-gnu/Makefile
--- linux-libre-4.14.162-gnu/Makefile	2020-01-04 10:42:03.000000000 -0500
+++ linux-libre-4.14.163-gnu/Makefile	2020-01-09 08:56:25.000000000 -0500
@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0
 VERSION = 4
 PATCHLEVEL = 14
-SUBLEVEL = 162
+SUBLEVEL = 163
 EXTRAVERSION = -gnu
 NAME = Petit Gorille
 
diff -druNp --no-dereference linux-libre-4.14.162-gnu/mm/mmap.c linux-libre-4.14.163-gnu/mm/mmap.c
--- linux-libre-4.14.162-gnu/mm/mmap.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/mm/mmap.c	2020-01-09 04:18:00.000000000 -0500
@@ -89,12 +89,6 @@ static void unmap_region(struct mm_struc
  * MAP_PRIVATE	r: (no) no	r: (yes) yes	r: (no) yes	r: (no) yes
  *		w: (no) no	w: (no) no	w: (copy) copy	w: (no) no
  *		x: (no) no	x: (no) yes	x: (no) yes	x: (yes) yes
- *
- * On arm64, PROT_EXEC has the following behaviour for both MAP_SHARED and
- * MAP_PRIVATE:
- *								r: (no) no
- *								w: (no) no
- *								x: (yes) yes
  */
 pgprot_t protection_map[16] __ro_after_init = {
 	__P000, __P001, __P010, __P011, __P100, __P101, __P110, __P111,
diff -druNp --no-dereference linux-libre-4.14.162-gnu/mm/zsmalloc.c linux-libre-4.14.163-gnu/mm/zsmalloc.c
--- linux-libre-4.14.162-gnu/mm/zsmalloc.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/mm/zsmalloc.c	2020-01-09 04:18:00.000000000 -0500
@@ -2088,6 +2088,11 @@ int zs_page_migrate(struct address_space
 		zs_pool_dec_isolated(pool);
 	}
 
+	if (page_zone(newpage) != page_zone(page)) {
+		dec_zone_page_state(page, NR_ZSPAGES);
+		inc_zone_page_state(newpage, NR_ZSPAGES);
+	}
+
 	reset_page(page);
 	put_page(page);
 	page = newpage;
diff -druNp --no-dereference linux-libre-4.14.162-gnu/net/bluetooth/hci_conn.c linux-libre-4.14.163-gnu/net/bluetooth/hci_conn.c
--- linux-libre-4.14.162-gnu/net/bluetooth/hci_conn.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/net/bluetooth/hci_conn.c	2020-01-09 04:18:00.000000000 -0500
@@ -1054,8 +1054,10 @@ struct hci_conn *hci_connect_le_scan(str
 	if (!conn)
 		return ERR_PTR(-ENOMEM);
 
-	if (hci_explicit_conn_params_set(hdev, dst, dst_type) < 0)
+	if (hci_explicit_conn_params_set(hdev, dst, dst_type) < 0) {
+		hci_conn_del(conn);
 		return ERR_PTR(-EBUSY);
+	}
 
 	conn->state = BT_CONNECT;
 	set_bit(HCI_CONN_SCANNING, &conn->flags);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/net/bluetooth/l2cap_core.c linux-libre-4.14.163-gnu/net/bluetooth/l2cap_core.c
--- linux-libre-4.14.162-gnu/net/bluetooth/l2cap_core.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/net/bluetooth/l2cap_core.c	2020-01-09 04:18:00.000000000 -0500
@@ -4918,10 +4918,8 @@ void __l2cap_physical_cfm(struct l2cap_c
 	BT_DBG("chan %p, result %d, local_amp_id %d, remote_amp_id %d",
 	       chan, result, local_amp_id, remote_amp_id);
 
-	if (chan->state == BT_DISCONN || chan->state == BT_CLOSED) {
-		l2cap_chan_unlock(chan);
+	if (chan->state == BT_DISCONN || chan->state == BT_CLOSED)
 		return;
-	}
 
 	if (chan->state != BT_CONNECTED) {
 		l2cap_do_create(chan, result, local_amp_id, remote_amp_id);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/net/core/neighbour.c linux-libre-4.14.163-gnu/net/core/neighbour.c
--- linux-libre-4.14.162-gnu/net/core/neighbour.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/net/core/neighbour.c	2020-01-09 04:18:00.000000000 -0500
@@ -1094,7 +1094,7 @@ static void neigh_update_hhs(struct neig
 
 	if (update) {
 		hh = &neigh->hh;
-		if (hh->hh_len) {
+		if (READ_ONCE(hh->hh_len)) {
 			write_seqlock_bh(&hh->hh_lock);
 			update(hh, neigh->dev, neigh->ha);
 			write_sequnlock_bh(&hh->hh_lock);
@@ -1355,7 +1355,7 @@ int neigh_resolve_output(struct neighbou
 		struct net_device *dev = neigh->dev;
 		unsigned int seq;
 
-		if (dev->header_ops->cache && !neigh->hh.hh_len)
+		if (dev->header_ops->cache && !READ_ONCE(neigh->hh.hh_len))
 			neigh_hh_init(neigh);
 
 		do {
diff -druNp --no-dereference linux-libre-4.14.162-gnu/net/ethernet/eth.c linux-libre-4.14.163-gnu/net/ethernet/eth.c
--- linux-libre-4.14.162-gnu/net/ethernet/eth.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/net/ethernet/eth.c	2020-01-09 04:18:00.000000000 -0500
@@ -239,7 +239,12 @@ int eth_header_cache(const struct neighb
 	eth->h_proto = type;
 	memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
 	memcpy(eth->h_dest, neigh->ha, ETH_ALEN);
-	hh->hh_len = ETH_HLEN;
+
+	/* Pairs with READ_ONCE() in neigh_resolve_output(),
+	 * neigh_hh_output() and neigh_update_hhs().
+	 */
+	smp_store_release(&hh->hh_len, ETH_HLEN);
+
 	return 0;
 }
 EXPORT_SYMBOL(eth_header_cache);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/net/rxrpc/peer_event.c linux-libre-4.14.163-gnu/net/rxrpc/peer_event.c
--- linux-libre-4.14.162-gnu/net/rxrpc/peer_event.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/net/rxrpc/peer_event.c	2020-01-09 04:18:00.000000000 -0500
@@ -150,6 +150,9 @@ void rxrpc_error_report(struct sock *sk)
 	struct rxrpc_peer *peer;
 	struct sk_buff *skb;
 
+	if (unlikely(!local))
+		return;
+
 	_enter("%p{%d}", sk, local->debug_id);
 
 	skb = sock_dequeue_err_skb(sk);
diff -druNp --no-dereference linux-libre-4.14.162-gnu/net/socket.c linux-libre-4.14.163-gnu/net/socket.c
--- linux-libre-4.14.162-gnu/net/socket.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/net/socket.c	2020-01-09 04:18:00.000000000 -0500
@@ -891,7 +891,7 @@ static ssize_t sock_read_iter(struct kio
 			     .msg_iocb = iocb};
 	ssize_t res;
 
-	if (file->f_flags & O_NONBLOCK)
+	if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
 		msg.msg_flags = MSG_DONTWAIT;
 
 	if (iocb->ki_pos != 0)
@@ -916,7 +916,7 @@ static ssize_t sock_write_iter(struct ki
 	if (iocb->ki_pos != 0)
 		return -ESPIPE;
 
-	if (file->f_flags & O_NONBLOCK)
+	if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
 		msg.msg_flags = MSG_DONTWAIT;
 
 	if (sock->type == SOCK_SEQPACKET)
diff -druNp --no-dereference linux-libre-4.14.162-gnu/sound/firewire/motu/motu-proc.c linux-libre-4.14.163-gnu/sound/firewire/motu/motu-proc.c
--- linux-libre-4.14.162-gnu/sound/firewire/motu/motu-proc.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/sound/firewire/motu/motu-proc.c	2020-01-09 04:18:00.000000000 -0500
@@ -17,7 +17,7 @@ static const char *const clock_names[] =
 	[SND_MOTU_CLOCK_SOURCE_SPDIF_ON_OPT] = "S/PDIF on optical interface",
 	[SND_MOTU_CLOCK_SOURCE_SPDIF_ON_OPT_A] = "S/PDIF on optical interface A",
 	[SND_MOTU_CLOCK_SOURCE_SPDIF_ON_OPT_B] = "S/PDIF on optical interface B",
-	[SND_MOTU_CLOCK_SOURCE_SPDIF_ON_COAX] = "S/PCIF on coaxial interface",
+	[SND_MOTU_CLOCK_SOURCE_SPDIF_ON_COAX] = "S/PDIF on coaxial interface",
 	[SND_MOTU_CLOCK_SOURCE_AESEBU_ON_XLR] = "AESEBU on XLR interface",
 	[SND_MOTU_CLOCK_SOURCE_WORD_ON_BNC] = "Word clock on BNC interface",
 };
diff -druNp --no-dereference linux-libre-4.14.162-gnu/sound/isa/cs423x/cs4236.c linux-libre-4.14.163-gnu/sound/isa/cs423x/cs4236.c
--- linux-libre-4.14.162-gnu/sound/isa/cs423x/cs4236.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/sound/isa/cs423x/cs4236.c	2020-01-09 04:18:00.000000000 -0500
@@ -293,7 +293,8 @@ static int snd_cs423x_pnp_init_mpu(int d
 	} else {
 		mpu_port[dev] = pnp_port_start(pdev, 0);
 		if (mpu_irq[dev] >= 0 &&
-		    pnp_irq_valid(pdev, 0) && pnp_irq(pdev, 0) >= 0) {
+		    pnp_irq_valid(pdev, 0) &&
+		    pnp_irq(pdev, 0) != (resource_size_t)-1) {
 			mpu_irq[dev] = pnp_irq(pdev, 0);
 		} else {
 			mpu_irq[dev] = -1;	/* disable interrupt */
diff -druNp --no-dereference linux-libre-4.14.162-gnu/sound/pci/ice1712/ice1724.c linux-libre-4.14.163-gnu/sound/pci/ice1712/ice1724.c
--- linux-libre-4.14.162-gnu/sound/pci/ice1712/ice1724.c	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/sound/pci/ice1712/ice1724.c	2020-01-09 04:18:00.000000000 -0500
@@ -661,6 +661,7 @@ static int snd_vt1724_set_pro_rate(struc
 	unsigned long flags;
 	unsigned char mclk_change;
 	unsigned int i, old_rate;
+	bool call_set_rate = false;
 
 	if (rate > ice->hw_rates->list[ice->hw_rates->count - 1])
 		return -EINVAL;
@@ -684,7 +685,7 @@ static int snd_vt1724_set_pro_rate(struc
 		 * setting clock rate for internal clock mode */
 		old_rate = ice->get_rate(ice);
 		if (force || (old_rate != rate))
-			ice->set_rate(ice, rate);
+			call_set_rate = true;
 		else if (rate == ice->cur_rate) {
 			spin_unlock_irqrestore(&ice->reg_lock, flags);
 			return 0;
@@ -692,12 +693,14 @@ static int snd_vt1724_set_pro_rate(struc
 	}
 
 	ice->cur_rate = rate;
+	spin_unlock_irqrestore(&ice->reg_lock, flags);
+
+	if (call_set_rate)
+		ice->set_rate(ice, rate);
 
 	/* setting master clock */
 	mclk_change = ice->set_mclk(ice, rate);
 
-	spin_unlock_irqrestore(&ice->reg_lock, flags);
-
 	if (mclk_change && ice->gpio.i2s_mclk_changed)
 		ice->gpio.i2s_mclk_changed(ice);
 	if (ice->gpio.set_pro_rate)
diff -druNp --no-dereference linux-libre-4.14.162-gnu/tools/testing/selftests/net/rtnetlink.sh linux-libre-4.14.163-gnu/tools/testing/selftests/net/rtnetlink.sh
--- linux-libre-4.14.162-gnu/tools/testing/selftests/net/rtnetlink.sh	2020-01-04 08:00:23.000000000 -0500
+++ linux-libre-4.14.163-gnu/tools/testing/selftests/net/rtnetlink.sh	2020-01-09 04:18:00.000000000 -0500
@@ -195,6 +195,26 @@ kci_test_route_get()
 	echo "PASS: route get"
 }
 
+kci_test_addrlft()
+{
+	for i in $(seq 10 100) ;do
+		lft=$(((RANDOM%3) + 1))
+		ip addr add 10.23.11.$i/32 dev "$devdummy" preferred_lft $lft valid_lft $((lft+1))
+		check_err $?
+	done
+
+	sleep 5
+
+	ip addr show dev "$devdummy" | grep "10.23.11."
+	if [ $? -eq 0 ]; then
+		echo "FAIL: preferred_lft addresses remaining"
+		check_err 1
+		return
+	fi
+
+	echo "PASS: preferred_lft addresses have expired"
+}
+
 kci_test_addrlabel()
 {
 	ret=0
@@ -245,6 +265,7 @@ kci_test_rtnl()
 
 	kci_test_polrouting
 	kci_test_route_get
+	kci_test_addrlft
 	kci_test_tc
 	kci_test_gre
 	kci_test_bridge
