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

[Mike Pagano]

commit:     5eb02d5ddb6475c1c30455c59af7fbeb47158762
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Sun Jan 16 10:22:22 2022 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Sun Jan 16 10:22:22 2022 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=5eb02d5d

Linuxpatch 5.4.172

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

 0000_README              |    4 +
 1171_linux-5.4.172.patch | 1290 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1294 insertions(+)

diff --git a/0000_README b/0000_README
index 5d64761b..85a7c8aa 100644
--- a/0000_README
+++ b/0000_README
@@ -727,6 +727,10 @@ Patch:  1170_linux-5.4.171.patch
 From:   http://www.kernel.org
 Desc:   Linux 5.4.171
 
+Patch:  1171_linux-5.4.172.patch
+From:   http://www.kernel.org
+Desc:   Linux 5.4.172
+
 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/1171_linux-5.4.172.patch b/1171_linux-5.4.172.patch
new file mode 100644
index 00000000..e28d266b
--- /dev/null
+++ b/1171_linux-5.4.172.patch
@@ -0,0 +1,1290 @@
+diff --git a/Makefile b/Makefile
+index 062052f71a976..2f914dd223c81 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 5
+ PATCHLEVEL = 4
+-SUBLEVEL = 171
++SUBLEVEL = 172
+ EXTRAVERSION =
+ NAME = Kleptomaniac Octopus
+ 
+diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
+index 83e26fd188cc9..d5f64018044b0 100644
+--- a/drivers/base/arch_topology.c
++++ b/drivers/base/arch_topology.c
+@@ -48,7 +48,7 @@ static ssize_t cpu_capacity_show(struct device *dev,
+ {
+ 	struct cpu *cpu = container_of(dev, struct cpu, dev);
+ 
+-	return sprintf(buf, "%lu\n", topology_get_cpu_scale(cpu->dev.id));
++	return sysfs_emit(buf, "%lu\n", topology_get_cpu_scale(cpu->dev.id));
+ }
+ 
+ static void update_topology_flags_workfn(struct work_struct *work);
+diff --git a/drivers/base/cacheinfo.c b/drivers/base/cacheinfo.c
+index 8d553c92cd322..6a8c2b5881be3 100644
+--- a/drivers/base/cacheinfo.c
++++ b/drivers/base/cacheinfo.c
+@@ -377,7 +377,7 @@ static ssize_t size_show(struct device *dev,
+ {
+ 	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
+ 
+-	return sprintf(buf, "%uK\n", this_leaf->size >> 10);
++	return sysfs_emit(buf, "%uK\n", this_leaf->size >> 10);
+ }
+ 
+ static ssize_t shared_cpumap_show_func(struct device *dev, bool list, char *buf)
+@@ -407,11 +407,11 @@ static ssize_t type_show(struct device *dev,
+ 
+ 	switch (this_leaf->type) {
+ 	case CACHE_TYPE_DATA:
+-		return sprintf(buf, "Data\n");
++		return sysfs_emit(buf, "Data\n");
+ 	case CACHE_TYPE_INST:
+-		return sprintf(buf, "Instruction\n");
++		return sysfs_emit(buf, "Instruction\n");
+ 	case CACHE_TYPE_UNIFIED:
+-		return sprintf(buf, "Unified\n");
++		return sysfs_emit(buf, "Unified\n");
+ 	default:
+ 		return -EINVAL;
+ 	}
+@@ -425,11 +425,11 @@ static ssize_t allocation_policy_show(struct device *dev,
+ 	int n = 0;
+ 
+ 	if ((ci_attr & CACHE_READ_ALLOCATE) && (ci_attr & CACHE_WRITE_ALLOCATE))
+-		n = sprintf(buf, "ReadWriteAllocate\n");
++		n = sysfs_emit(buf, "ReadWriteAllocate\n");
+ 	else if (ci_attr & CACHE_READ_ALLOCATE)
+-		n = sprintf(buf, "ReadAllocate\n");
++		n = sysfs_emit(buf, "ReadAllocate\n");
+ 	else if (ci_attr & CACHE_WRITE_ALLOCATE)
+-		n = sprintf(buf, "WriteAllocate\n");
++		n = sysfs_emit(buf, "WriteAllocate\n");
+ 	return n;
+ }
+ 
+@@ -441,9 +441,9 @@ static ssize_t write_policy_show(struct device *dev,
+ 	int n = 0;
+ 
+ 	if (ci_attr & CACHE_WRITE_THROUGH)
+-		n = sprintf(buf, "WriteThrough\n");
++		n = sysfs_emit(buf, "WriteThrough\n");
+ 	else if (ci_attr & CACHE_WRITE_BACK)
+-		n = sprintf(buf, "WriteBack\n");
++		n = sysfs_emit(buf, "WriteBack\n");
+ 	return n;
+ }
+ 
+diff --git a/drivers/base/core.c b/drivers/base/core.c
+index 8b651bfc1d88e..1b016fdd1a750 100644
+--- a/drivers/base/core.c
++++ b/drivers/base/core.c
+@@ -1027,7 +1027,7 @@ ssize_t device_show_ulong(struct device *dev,
+ 			  char *buf)
+ {
+ 	struct dev_ext_attribute *ea = to_ext_attr(attr);
+-	return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
++	return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var));
+ }
+ EXPORT_SYMBOL_GPL(device_show_ulong);
+ 
+@@ -1057,7 +1057,7 @@ ssize_t device_show_int(struct device *dev,
+ {
+ 	struct dev_ext_attribute *ea = to_ext_attr(attr);
+ 
+-	return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
++	return sysfs_emit(buf, "%d\n", *(int *)(ea->var));
+ }
+ EXPORT_SYMBOL_GPL(device_show_int);
+ 
+@@ -1078,7 +1078,7 @@ ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
+ {
+ 	struct dev_ext_attribute *ea = to_ext_attr(attr);
+ 
+-	return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var));
++	return sysfs_emit(buf, "%d\n", *(bool *)(ea->var));
+ }
+ EXPORT_SYMBOL_GPL(device_show_bool);
+ 
+@@ -1310,7 +1310,7 @@ static ssize_t online_show(struct device *dev, struct device_attribute *attr,
+ 	device_lock(dev);
+ 	val = !dev->offline;
+ 	device_unlock(dev);
+-	return sprintf(buf, "%u\n", val);
++	return sysfs_emit(buf, "%u\n", val);
+ }
+ 
+ static ssize_t online_store(struct device *dev, struct device_attribute *attr,
+diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
+index f00da44ae6fe0..81ec0a1020d60 100644
+--- a/drivers/base/cpu.c
++++ b/drivers/base/cpu.c
+@@ -156,7 +156,7 @@ static ssize_t show_crash_notes(struct device *dev, struct device_attribute *att
+ 	 * operation should be safe. No locking required.
+ 	 */
+ 	addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
+-	rc = sprintf(buf, "%Lx\n", addr);
++	rc = sysfs_emit(buf, "%Lx\n", addr);
+ 	return rc;
+ }
+ static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
+@@ -167,7 +167,7 @@ static ssize_t show_crash_notes_size(struct device *dev,
+ {
+ 	ssize_t rc;
+ 
+-	rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
++	rc = sysfs_emit(buf, "%zu\n", sizeof(note_buf_t));
+ 	return rc;
+ }
+ static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
+@@ -231,8 +231,7 @@ static struct cpu_attr cpu_attrs[] = {
+ static ssize_t print_cpus_kernel_max(struct device *dev,
+ 				     struct device_attribute *attr, char *buf)
+ {
+-	int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
+-	return n;
++	return sprintf(buf, "%d\n", NR_CPUS - 1);
+ }
+ static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
+ 
+@@ -272,7 +271,7 @@ static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
+ static ssize_t print_cpus_isolated(struct device *dev,
+ 				  struct device_attribute *attr, char *buf)
+ {
+-	int n = 0, len = PAGE_SIZE-2;
++	int n;
+ 	cpumask_var_t isolated;
+ 
+ 	if (!alloc_cpumask_var(&isolated, GFP_KERNEL))
+@@ -280,7 +279,7 @@ static ssize_t print_cpus_isolated(struct device *dev,
+ 
+ 	cpumask_andnot(isolated, cpu_possible_mask,
+ 		       housekeeping_cpumask(HK_FLAG_DOMAIN));
+-	n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(isolated));
++	n = sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(isolated));
+ 
+ 	free_cpumask_var(isolated);
+ 
+@@ -292,11 +291,7 @@ static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL);
+ static ssize_t print_cpus_nohz_full(struct device *dev,
+ 				  struct device_attribute *attr, char *buf)
+ {
+-	int n = 0, len = PAGE_SIZE-2;
+-
+-	n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask));
+-
+-	return n;
++	return sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask));
+ }
+ static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL);
+ #endif
+@@ -328,8 +323,8 @@ static ssize_t print_cpu_modalias(struct device *dev,
+ 	ssize_t n;
+ 	u32 i;
+ 
+-	n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
+-		    CPU_FEATURE_TYPEVAL);
++	n = sysfs_emit(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
++		       CPU_FEATURE_TYPEVAL);
+ 
+ 	for (i = 0; i < MAX_CPU_FEATURES; i++)
+ 		if (cpu_have_feature(i)) {
+@@ -521,56 +516,56 @@ static void __init cpu_dev_register_generic(void)
+ ssize_t __weak cpu_show_meltdown(struct device *dev,
+ 				 struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_spectre_v1(struct device *dev,
+ 				   struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_spectre_v2(struct device *dev,
+ 				   struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_spec_store_bypass(struct device *dev,
+ 					  struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_l1tf(struct device *dev,
+ 			     struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_mds(struct device *dev,
+ 			    struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_tsx_async_abort(struct device *dev,
+ 					struct device_attribute *attr,
+ 					char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_itlb_multihit(struct device *dev,
+ 			    struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ ssize_t __weak cpu_show_srbds(struct device *dev,
+ 			      struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "Not affected\n");
++	return sysfs_emit(buf, "Not affected\n");
+ }
+ 
+ static DEVICE_ATTR(meltdown, 0444, cpu_show_meltdown, NULL);
+diff --git a/drivers/base/firmware_loader/fallback.c b/drivers/base/firmware_loader/fallback.c
+index 5f3e5d8372590..19d18afb30864 100644
+--- a/drivers/base/firmware_loader/fallback.c
++++ b/drivers/base/firmware_loader/fallback.c
+@@ -215,7 +215,7 @@ static ssize_t firmware_loading_show(struct device *dev,
+ 		loading = fw_sysfs_loading(fw_sysfs->fw_priv);
+ 	mutex_unlock(&fw_lock);
+ 
+-	return sprintf(buf, "%d\n", loading);
++	return sysfs_emit(buf, "%d\n", loading);
+ }
+ 
+ /**
+diff --git a/drivers/base/memory.c b/drivers/base/memory.c
+index 5a8c430fb8ffa..729e93e0c1c13 100644
+--- a/drivers/base/memory.c
++++ b/drivers/base/memory.c
+@@ -110,7 +110,7 @@ static ssize_t phys_index_show(struct device *dev,
+ 	unsigned long phys_index;
+ 
+ 	phys_index = mem->start_section_nr / sections_per_block;
+-	return sprintf(buf, "%08lx\n", phys_index);
++	return sysfs_emit(buf, "%08lx\n", phys_index);
+ }
+ 
+ /*
+@@ -120,7 +120,7 @@ static ssize_t phys_index_show(struct device *dev,
+ static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
+ 			      char *buf)
+ {
+-	return sprintf(buf, "%d\n", (int)IS_ENABLED(CONFIG_MEMORY_HOTREMOVE));
++	return sysfs_emit(buf, "%d\n", (int)IS_ENABLED(CONFIG_MEMORY_HOTREMOVE));
+ }
+ 
+ /*
+@@ -138,17 +138,17 @@ static ssize_t state_show(struct device *dev, struct device_attribute *attr,
+ 	 */
+ 	switch (mem->state) {
+ 	case MEM_ONLINE:
+-		len = sprintf(buf, "online\n");
++		len = sysfs_emit(buf, "online\n");
+ 		break;
+ 	case MEM_OFFLINE:
+-		len = sprintf(buf, "offline\n");
++		len = sysfs_emit(buf, "offline\n");
+ 		break;
+ 	case MEM_GOING_OFFLINE:
+-		len = sprintf(buf, "going-offline\n");
++		len = sysfs_emit(buf, "going-offline\n");
+ 		break;
+ 	default:
+-		len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
+-				mem->state);
++		len = sysfs_emit(buf, "ERROR-UNKNOWN-%ld\n",
++				 mem->state);
+ 		WARN_ON(1);
+ 		break;
+ 	}
+@@ -358,7 +358,7 @@ static ssize_t phys_device_show(struct device *dev,
+ 				struct device_attribute *attr, char *buf)
+ {
+ 	struct memory_block *mem = to_memory_block(dev);
+-	return sprintf(buf, "%d\n", mem->phys_device);
++	return sysfs_emit(buf, "%d\n", mem->phys_device);
+ }
+ 
+ #ifdef CONFIG_MEMORY_HOTREMOVE
+@@ -396,7 +396,7 @@ static ssize_t valid_zones_show(struct device *dev,
+ 		 */
+ 		if (!test_pages_in_a_zone(start_pfn, start_pfn + nr_pages,
+ 					  &valid_start_pfn, &valid_end_pfn))
+-			return sprintf(buf, "none\n");
++			return sysfs_emit(buf, "none\n");
+ 		start_pfn = valid_start_pfn;
+ 		strcat(buf, page_zone(pfn_to_page(start_pfn))->name);
+ 		goto out;
+@@ -429,7 +429,7 @@ static DEVICE_ATTR_RO(removable);
+ static ssize_t block_size_bytes_show(struct device *dev,
+ 				     struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "%lx\n", memory_block_size_bytes());
++	return sysfs_emit(buf, "%lx\n", memory_block_size_bytes());
+ }
+ 
+ static DEVICE_ATTR_RO(block_size_bytes);
+@@ -442,9 +442,9 @@ static ssize_t auto_online_blocks_show(struct device *dev,
+ 				       struct device_attribute *attr, char *buf)
+ {
+ 	if (memhp_auto_online)
+-		return sprintf(buf, "online\n");
++		return sysfs_emit(buf, "online\n");
+ 	else
+-		return sprintf(buf, "offline\n");
++		return sysfs_emit(buf, "offline\n");
+ }
+ 
+ static ssize_t auto_online_blocks_store(struct device *dev,
+diff --git a/drivers/base/node.c b/drivers/base/node.c
+index c9976dc4aa65f..62a052990bb9b 100644
+--- a/drivers/base/node.c
++++ b/drivers/base/node.c
+@@ -368,7 +368,7 @@ static ssize_t node_read_meminfo(struct device *dev,
+ 	si_meminfo_node(&i, nid);
+ 	sreclaimable = node_page_state(pgdat, NR_SLAB_RECLAIMABLE);
+ 	sunreclaimable = node_page_state(pgdat, NR_SLAB_UNRECLAIMABLE);
+-	n = sprintf(buf,
++	n = sysfs_emit(buf,
+ 		       "Node %d MemTotal:       %8lu kB\n"
+ 		       "Node %d MemFree:        %8lu kB\n"
+ 		       "Node %d MemUsed:        %8lu kB\n"
+@@ -469,19 +469,19 @@ static DEVICE_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL);
+ static ssize_t node_read_numastat(struct device *dev,
+ 				struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf,
+-		       "numa_hit %lu\n"
+-		       "numa_miss %lu\n"
+-		       "numa_foreign %lu\n"
+-		       "interleave_hit %lu\n"
+-		       "local_node %lu\n"
+-		       "other_node %lu\n",
+-		       sum_zone_numa_state(dev->id, NUMA_HIT),
+-		       sum_zone_numa_state(dev->id, NUMA_MISS),
+-		       sum_zone_numa_state(dev->id, NUMA_FOREIGN),
+-		       sum_zone_numa_state(dev->id, NUMA_INTERLEAVE_HIT),
+-		       sum_zone_numa_state(dev->id, NUMA_LOCAL),
+-		       sum_zone_numa_state(dev->id, NUMA_OTHER));
++	return sysfs_emit(buf,
++			  "numa_hit %lu\n"
++			  "numa_miss %lu\n"
++			  "numa_foreign %lu\n"
++			  "interleave_hit %lu\n"
++			  "local_node %lu\n"
++			  "other_node %lu\n",
++			  sum_zone_numa_state(dev->id, NUMA_HIT),
++			  sum_zone_numa_state(dev->id, NUMA_MISS),
++			  sum_zone_numa_state(dev->id, NUMA_FOREIGN),
++			  sum_zone_numa_state(dev->id, NUMA_INTERLEAVE_HIT),
++			  sum_zone_numa_state(dev->id, NUMA_LOCAL),
++			  sum_zone_numa_state(dev->id, NUMA_OTHER));
+ }
+ static DEVICE_ATTR(numastat, S_IRUGO, node_read_numastat, NULL);
+ 
+diff --git a/drivers/base/platform.c b/drivers/base/platform.c
+index 0b67d41bab8ff..75623b914b8c2 100644
+--- a/drivers/base/platform.c
++++ b/drivers/base/platform.c
+@@ -1009,7 +1009,7 @@ static ssize_t driver_override_show(struct device *dev,
+ 	ssize_t len;
+ 
+ 	device_lock(dev);
+-	len = sprintf(buf, "%s\n", pdev->driver_override);
++	len = sysfs_emit(buf, "%s\n", pdev->driver_override);
+ 	device_unlock(dev);
+ 	return len;
+ }
+diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
+index d7d82db2e4bc4..2786962e08107 100644
+--- a/drivers/base/power/sysfs.c
++++ b/drivers/base/power/sysfs.c
+@@ -100,7 +100,7 @@ static const char ctrl_on[] = "on";
+ static ssize_t control_show(struct device *dev, struct device_attribute *attr,
+ 			    char *buf)
+ {
+-	return sprintf(buf, "%s\n",
++	return sysfs_emit(buf, "%s\n",
+ 				dev->power.runtime_auto ? ctrl_auto : ctrl_on);
+ }
+ 
+@@ -126,7 +126,7 @@ static ssize_t runtime_active_time_show(struct device *dev,
+ 	int ret;
+ 	u64 tmp = pm_runtime_active_time(dev);
+ 	do_div(tmp, NSEC_PER_MSEC);
+-	ret = sprintf(buf, "%llu\n", tmp);
++	ret = sysfs_emit(buf, "%llu\n", tmp);
+ 	return ret;
+ }
+ 
+@@ -138,7 +138,7 @@ static ssize_t runtime_suspended_time_show(struct device *dev,
+ 	int ret;
+ 	u64 tmp = pm_runtime_suspended_time(dev);
+ 	do_div(tmp, NSEC_PER_MSEC);
+-	ret = sprintf(buf, "%llu\n", tmp);
++	ret = sysfs_emit(buf, "%llu\n", tmp);
+ 	return ret;
+ }
+ 
+@@ -171,7 +171,7 @@ static ssize_t runtime_status_show(struct device *dev,
+ 			return -EIO;
+ 		}
+ 	}
+-	return sprintf(buf, p);
++	return sysfs_emit(buf, p);
+ }
+ 
+ static DEVICE_ATTR_RO(runtime_status);
+@@ -181,7 +181,7 @@ static ssize_t autosuspend_delay_ms_show(struct device *dev,
+ {
+ 	if (!dev->power.use_autosuspend)
+ 		return -EIO;
+-	return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
++	return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay);
+ }
+ 
+ static ssize_t autosuspend_delay_ms_store(struct device *dev,
+@@ -210,11 +210,11 @@ static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
+ 	s32 value = dev_pm_qos_requested_resume_latency(dev);
+ 
+ 	if (value == 0)
+-		return sprintf(buf, "n/a\n");
++		return sysfs_emit(buf, "n/a\n");
+ 	if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
+ 		value = 0;
+ 
+-	return sprintf(buf, "%d\n", value);
++	return sysfs_emit(buf, "%d\n", value);
+ }
+ 
+ static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
+@@ -254,11 +254,11 @@ static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
+ 	s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
+ 
+ 	if (value < 0)
+-		return sprintf(buf, "auto\n");
++		return sysfs_emit(buf, "auto\n");
+ 	if (value == PM_QOS_LATENCY_ANY)
+-		return sprintf(buf, "any\n");
++		return sysfs_emit(buf, "any\n");
+ 
+-	return sprintf(buf, "%d\n", value);
++	return sysfs_emit(buf, "%d\n", value);
+ }
+ 
+ static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
+@@ -290,8 +290,8 @@ static ssize_t pm_qos_no_power_off_show(struct device *dev,
+ 					struct device_attribute *attr,
+ 					char *buf)
+ {
+-	return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
+-					& PM_QOS_FLAG_NO_POWER_OFF));
++	return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
++					  & PM_QOS_FLAG_NO_POWER_OFF));
+ }
+ 
+ static ssize_t pm_qos_no_power_off_store(struct device *dev,
+@@ -319,9 +319,9 @@ static const char _disabled[] = "disabled";
+ static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
+ 			   char *buf)
+ {
+-	return sprintf(buf, "%s\n", device_can_wakeup(dev)
+-		? (device_may_wakeup(dev) ? _enabled : _disabled)
+-		: "");
++	return sysfs_emit(buf, "%s\n", device_can_wakeup(dev)
++			  ? (device_may_wakeup(dev) ? _enabled : _disabled)
++			  : "");
+ }
+ 
+ static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
+@@ -507,7 +507,7 @@ static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
+ static ssize_t runtime_usage_show(struct device *dev,
+ 				  struct device_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
++	return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
+ }
+ static DEVICE_ATTR_RO(runtime_usage);
+ 
+@@ -515,8 +515,8 @@ static ssize_t runtime_active_kids_show(struct device *dev,
+ 					struct device_attribute *attr,
+ 					char *buf)
+ {
+-	return sprintf(buf, "%d\n", dev->power.ignore_children ?
+-		0 : atomic_read(&dev->power.child_count));
++	return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
++			  0 : atomic_read(&dev->power.child_count));
+ }
+ static DEVICE_ATTR_RO(runtime_active_kids);
+ 
+@@ -524,12 +524,12 @@ static ssize_t runtime_enabled_show(struct device *dev,
+ 				    struct device_attribute *attr, char *buf)
+ {
+ 	if (dev->power.disable_depth && (dev->power.runtime_auto == false))
+-		return sprintf(buf, "disabled & forbidden\n");
++		return sysfs_emit(buf, "disabled & forbidden\n");
+ 	if (dev->power.disable_depth)
+-		return sprintf(buf, "disabled\n");
++		return sysfs_emit(buf, "disabled\n");
+ 	if (dev->power.runtime_auto == false)
+-		return sprintf(buf, "forbidden\n");
+-	return sprintf(buf, "enabled\n");
++		return sysfs_emit(buf, "forbidden\n");
++	return sysfs_emit(buf, "enabled\n");
+ }
+ static DEVICE_ATTR_RO(runtime_enabled);
+ 
+@@ -537,9 +537,9 @@ static DEVICE_ATTR_RO(runtime_enabled);
+ static ssize_t async_show(struct device *dev, struct device_attribute *attr,
+ 			  char *buf)
+ {
+-	return sprintf(buf, "%s\n",
+-			device_async_suspend_enabled(dev) ?
+-				_enabled : _disabled);
++	return sysfs_emit(buf, "%s\n",
++			  device_async_suspend_enabled(dev) ?
++			  _enabled : _disabled);
+ }
+ 
+ static ssize_t async_store(struct device *dev, struct device_attribute *attr,
+diff --git a/drivers/base/power/wakeup_stats.c b/drivers/base/power/wakeup_stats.c
+index c7734914d9144..5568e25d7c9c2 100644
+--- a/drivers/base/power/wakeup_stats.c
++++ b/drivers/base/power/wakeup_stats.c
+@@ -42,7 +42,7 @@ static ssize_t active_time_ms_show(struct device *dev,
+ 	ktime_t active_time =
+ 		ws->active ? ktime_sub(ktime_get(), ws->last_time) : 0;
+ 
+-	return sprintf(buf, "%lld\n", ktime_to_ms(active_time));
++	return sysfs_emit(buf, "%lld\n", ktime_to_ms(active_time));
+ }
+ static DEVICE_ATTR_RO(active_time_ms);
+ 
+@@ -57,7 +57,7 @@ static ssize_t total_time_ms_show(struct device *dev,
+ 		active_time = ktime_sub(ktime_get(), ws->last_time);
+ 		total_time = ktime_add(total_time, active_time);
+ 	}
+-	return sprintf(buf, "%lld\n", ktime_to_ms(total_time));
++	return sysfs_emit(buf, "%lld\n", ktime_to_ms(total_time));
+ }
+ static DEVICE_ATTR_RO(total_time_ms);
+ 
+@@ -73,7 +73,7 @@ static ssize_t max_time_ms_show(struct device *dev,
+ 		if (active_time > max_time)
+ 			max_time = active_time;
+ 	}
+-	return sprintf(buf, "%lld\n", ktime_to_ms(max_time));
++	return sysfs_emit(buf, "%lld\n", ktime_to_ms(max_time));
+ }
+ static DEVICE_ATTR_RO(max_time_ms);
+ 
+@@ -82,7 +82,7 @@ static ssize_t last_change_ms_show(struct device *dev,
+ {
+ 	struct wakeup_source *ws = dev_get_drvdata(dev);
+ 
+-	return sprintf(buf, "%lld\n", ktime_to_ms(ws->last_time));
++	return sysfs_emit(buf, "%lld\n", ktime_to_ms(ws->last_time));
+ }
+ static DEVICE_ATTR_RO(last_change_ms);
+ 
+@@ -91,7 +91,7 @@ static ssize_t name_show(struct device *dev, struct device_attribute *attr,
+ {
+ 	struct wakeup_source *ws = dev_get_drvdata(dev);
+ 
+-	return sprintf(buf, "%s\n", ws->name);
++	return sysfs_emit(buf, "%s\n", ws->name);
+ }
+ static DEVICE_ATTR_RO(name);
+ 
+@@ -106,7 +106,7 @@ static ssize_t prevent_suspend_time_ms_show(struct device *dev,
+ 		prevent_sleep_time = ktime_add(prevent_sleep_time,
+ 			ktime_sub(ktime_get(), ws->start_prevent_time));
+ 	}
+-	return sprintf(buf, "%lld\n", ktime_to_ms(prevent_sleep_time));
++	return sysfs_emit(buf, "%lld\n", ktime_to_ms(prevent_sleep_time));
+ }
+ static DEVICE_ATTR_RO(prevent_suspend_time_ms);
+ 
+diff --git a/drivers/base/soc.c b/drivers/base/soc.c
+index 7c0c5ca5953d2..735f122c2ba31 100644
+--- a/drivers/base/soc.c
++++ b/drivers/base/soc.c
+@@ -76,15 +76,15 @@ static ssize_t soc_info_get(struct device *dev,
+ 	struct soc_device *soc_dev = container_of(dev, struct soc_device, dev);
+ 
+ 	if (attr == &dev_attr_machine)
+-		return sprintf(buf, "%s\n", soc_dev->attr->machine);
++		return sysfs_emit(buf, "%s\n", soc_dev->attr->machine);
+ 	if (attr == &dev_attr_family)
+-		return sprintf(buf, "%s\n", soc_dev->attr->family);
++		return sysfs_emit(buf, "%s\n", soc_dev->attr->family);
+ 	if (attr == &dev_attr_revision)
+-		return sprintf(buf, "%s\n", soc_dev->attr->revision);
++		return sysfs_emit(buf, "%s\n", soc_dev->attr->revision);
+ 	if (attr == &dev_attr_serial_number)
+-		return sprintf(buf, "%s\n", soc_dev->attr->serial_number);
++		return sysfs_emit(buf, "%s\n", soc_dev->attr->serial_number);
+ 	if (attr == &dev_attr_soc_id)
+-		return sprintf(buf, "%s\n", soc_dev->attr->soc_id);
++		return sysfs_emit(buf, "%s\n", soc_dev->attr->soc_id);
+ 
+ 	return -EINVAL;
+ 
+diff --git a/drivers/bluetooth/bfusb.c b/drivers/bluetooth/bfusb.c
+index 0e5954cac98e0..00d72f6d8e8e2 100644
+--- a/drivers/bluetooth/bfusb.c
++++ b/drivers/bluetooth/bfusb.c
+@@ -629,6 +629,9 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
+ 	data->bulk_out_ep   = bulk_out_ep->desc.bEndpointAddress;
+ 	data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);
+ 
++	if (!data->bulk_pkt_size)
++		goto done;
++
+ 	rwlock_init(&data->lock);
+ 
+ 	data->reassembly = NULL;
+diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
+index 6d643651d69f7..c8f2b991e9cf7 100644
+--- a/drivers/bluetooth/btusb.c
++++ b/drivers/bluetooth/btusb.c
+@@ -2568,6 +2568,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
+ 		skb = bt_skb_alloc(HCI_WMT_MAX_EVENT_SIZE, GFP_ATOMIC);
+ 		if (!skb) {
+ 			hdev->stat.err_rx++;
++			kfree(urb->setup_packet);
+ 			return;
+ 		}
+ 
+@@ -2588,6 +2589,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
+ 			data->evt_skb = skb_clone(skb, GFP_ATOMIC);
+ 			if (!data->evt_skb) {
+ 				kfree_skb(skb);
++				kfree(urb->setup_packet);
+ 				return;
+ 			}
+ 		}
+@@ -2596,6 +2598,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
+ 		if (err < 0) {
+ 			kfree_skb(data->evt_skb);
+ 			data->evt_skb = NULL;
++			kfree(urb->setup_packet);
+ 			return;
+ 		}
+ 
+@@ -2606,6 +2609,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
+ 			wake_up_bit(&data->flags,
+ 				    BTUSB_TX_WAIT_VND_EVT);
+ 		}
++		kfree(urb->setup_packet);
+ 		return;
+ 	} else if (urb->status == -ENOENT) {
+ 		/* Avoid suspend failed when usb_kill_urb */
+@@ -2626,6 +2630,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
+ 	usb_anchor_urb(urb, &data->ctrl_anchor);
+ 	err = usb_submit_urb(urb, GFP_ATOMIC);
+ 	if (err < 0) {
++		kfree(urb->setup_packet);
+ 		/* -EPERM: urb is being killed;
+ 		 * -ENODEV: device got disconnected
+ 		 */
+diff --git a/drivers/char/random.c b/drivers/char/random.c
+index ffd61aadb7614..60b39af1279a4 100644
+--- a/drivers/char/random.c
++++ b/drivers/char/random.c
+@@ -497,6 +497,7 @@ static struct crng_state primary_crng = {
+  * its value (from 0->1->2).
+  */
+ static int crng_init = 0;
++static bool crng_need_final_init = false;
+ #define crng_ready() (likely(crng_init > 1))
+ static int crng_init_cnt = 0;
+ static unsigned long crng_global_init_time = 0;
+@@ -889,6 +890,38 @@ static void crng_initialize(struct crng_state *crng)
+ 	crng->init_time = jiffies - CRNG_RESEED_INTERVAL - 1;
+ }
+ 
++static void crng_finalize_init(struct crng_state *crng)
++{
++	if (crng != &primary_crng || crng_init >= 2)
++		return;
++	if (!system_wq) {
++		/* We can't call numa_crng_init until we have workqueues,
++		 * so mark this for processing later. */
++		crng_need_final_init = true;
++		return;
++	}
++
++	invalidate_batched_entropy();
++	numa_crng_init();
++	crng_init = 2;
++	process_random_ready_list();
++	wake_up_interruptible(&crng_init_wait);
++	kill_fasync(&fasync, SIGIO, POLL_IN);
++	pr_notice("crng init done\n");
++	if (unseeded_warning.missed) {
++		pr_notice("random: %d get_random_xx warning(s) missed "
++			  "due to ratelimiting\n",
++			  unseeded_warning.missed);
++		unseeded_warning.missed = 0;
++	}
++	if (urandom_warning.missed) {
++		pr_notice("random: %d urandom warning(s) missed "
++			  "due to ratelimiting\n",
++			  urandom_warning.missed);
++		urandom_warning.missed = 0;
++	}
++}
++
+ #ifdef CONFIG_NUMA
+ static void do_numa_crng_init(struct work_struct *work)
+ {
+@@ -904,8 +937,8 @@ static void do_numa_crng_init(struct work_struct *work)
+ 		crng_initialize(crng);
+ 		pool[i] = crng;
+ 	}
+-	mb();
+-	if (cmpxchg(&crng_node_pool, NULL, pool)) {
++	/* pairs with READ_ONCE() in select_crng() */
++	if (cmpxchg_release(&crng_node_pool, NULL, pool) != NULL) {
+ 		for_each_node(i)
+ 			kfree(pool[i]);
+ 		kfree(pool);
+@@ -918,8 +951,26 @@ static void numa_crng_init(void)
+ {
+ 	schedule_work(&numa_crng_init_work);
+ }
++
++static struct crng_state *select_crng(void)
++{
++	struct crng_state **pool;
++	int nid = numa_node_id();
++
++	/* pairs with cmpxchg_release() in do_numa_crng_init() */
++	pool = READ_ONCE(crng_node_pool);
++	if (pool && pool[nid])
++		return pool[nid];
++
++	return &primary_crng;
++}
+ #else
+ static void numa_crng_init(void) {}
++
++static struct crng_state *select_crng(void)
++{
++	return &primary_crng;
++}
+ #endif
+ 
+ /*
+@@ -1024,39 +1075,23 @@ static void crng_reseed(struct crng_state *crng, struct entropy_store *r)
+ 		crng->state[i+4] ^= buf.key[i] ^ rv;
+ 	}
+ 	memzero_explicit(&buf, sizeof(buf));
+-	crng->init_time = jiffies;
++	WRITE_ONCE(crng->init_time, jiffies);
+ 	spin_unlock_irqrestore(&crng->lock, flags);
+-	if (crng == &primary_crng && crng_init < 2) {
+-		invalidate_batched_entropy();
+-		numa_crng_init();
+-		crng_init = 2;
+-		process_random_ready_list();
+-		wake_up_interruptible(&crng_init_wait);
+-		pr_notice("random: crng init done\n");
+-		if (unseeded_warning.missed) {
+-			pr_notice("random: %d get_random_xx warning(s) missed "
+-				  "due to ratelimiting\n",
+-				  unseeded_warning.missed);
+-			unseeded_warning.missed = 0;
+-		}
+-		if (urandom_warning.missed) {
+-			pr_notice("random: %d urandom warning(s) missed "
+-				  "due to ratelimiting\n",
+-				  urandom_warning.missed);
+-			urandom_warning.missed = 0;
+-		}
+-	}
++	crng_finalize_init(crng);
+ }
+ 
+ static void _extract_crng(struct crng_state *crng,
+ 			  __u8 out[CHACHA_BLOCK_SIZE])
+ {
+-	unsigned long v, flags;
++	unsigned long v, flags, init_time;
+ 
+-	if (crng_ready() &&
+-	    (time_after(crng_global_init_time, crng->init_time) ||
+-	     time_after(jiffies, crng->init_time + CRNG_RESEED_INTERVAL)))
+-		crng_reseed(crng, crng == &primary_crng ? &input_pool : NULL);
++	if (crng_ready()) {
++		init_time = READ_ONCE(crng->init_time);
++		if (time_after(READ_ONCE(crng_global_init_time), init_time) ||
++		    time_after(jiffies, init_time + CRNG_RESEED_INTERVAL))
++			crng_reseed(crng, crng == &primary_crng ?
++				    &input_pool : NULL);
++	}
+ 	spin_lock_irqsave(&crng->lock, flags);
+ 	if (arch_get_random_long(&v))
+ 		crng->state[14] ^= v;
+@@ -1068,15 +1103,7 @@ static void _extract_crng(struct crng_state *crng,
+ 
+ static void extract_crng(__u8 out[CHACHA_BLOCK_SIZE])
+ {
+-	struct crng_state *crng = NULL;
+-
+-#ifdef CONFIG_NUMA
+-	if (crng_node_pool)
+-		crng = crng_node_pool[numa_node_id()];
+-	if (crng == NULL)
+-#endif
+-		crng = &primary_crng;
+-	_extract_crng(crng, out);
++	_extract_crng(select_crng(), out);
+ }
+ 
+ /*
+@@ -1105,15 +1132,7 @@ static void _crng_backtrack_protect(struct crng_state *crng,
+ 
+ static void crng_backtrack_protect(__u8 tmp[CHACHA_BLOCK_SIZE], int used)
+ {
+-	struct crng_state *crng = NULL;
+-
+-#ifdef CONFIG_NUMA
+-	if (crng_node_pool)
+-		crng = crng_node_pool[numa_node_id()];
+-	if (crng == NULL)
+-#endif
+-		crng = &primary_crng;
+-	_crng_backtrack_protect(crng, tmp, used);
++	_crng_backtrack_protect(select_crng(), tmp, used);
+ }
+ 
+ static ssize_t extract_crng_user(void __user *buf, size_t nbytes)
+@@ -1957,6 +1976,8 @@ int __init rand_initialize(void)
+ {
+ 	init_std_data(&input_pool);
+ 	init_std_data(&blocking_pool);
++	if (crng_need_final_init)
++		crng_finalize_init(&primary_crng);
+ 	crng_initialize(&primary_crng);
+ 	crng_global_init_time = jiffies;
+ 	if (ratelimit_disable) {
+@@ -2150,7 +2171,7 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
+ 		if (crng_init < 2)
+ 			return -ENODATA;
+ 		crng_reseed(&primary_crng, &input_pool);
+-		crng_global_init_time = jiffies - 1;
++		WRITE_ONCE(crng_global_init_time, jiffies - 1);
+ 		return 0;
+ 	default:
+ 		return -EINVAL;
+@@ -2488,7 +2509,8 @@ void add_hwgenerator_randomness(const char *buffer, size_t count,
+ 	 * We'll be woken up again once below random_write_wakeup_thresh,
+ 	 * or when the calling thread is about to terminate.
+ 	 */
+-	wait_event_interruptible(random_write_wait, kthread_should_stop() ||
++	wait_event_interruptible(random_write_wait,
++			!system_wq || kthread_should_stop() ||
+ 			ENTROPY_BITS(&input_pool) <= random_write_wakeup_bits);
+ 	mix_pool_bytes(poolp, buffer, count);
+ 	credit_entropy_bits(poolp, entropy);
+diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
+index 91afeca0c6f82..e43a76b027a2a 100644
+--- a/drivers/gpu/drm/i915/intel_pm.c
++++ b/drivers/gpu/drm/i915/intel_pm.c
+@@ -3017,9 +3017,9 @@ static void snb_wm_latency_quirk(struct drm_i915_private *dev_priv)
+ 	 * The BIOS provided WM memory latency values are often
+ 	 * inadequate for high resolution displays. Adjust them.
+ 	 */
+-	changed = ilk_increase_wm_latency(dev_priv, dev_priv->wm.pri_latency, 12) |
+-		ilk_increase_wm_latency(dev_priv, dev_priv->wm.spr_latency, 12) |
+-		ilk_increase_wm_latency(dev_priv, dev_priv->wm.cur_latency, 12);
++	changed = ilk_increase_wm_latency(dev_priv, dev_priv->wm.pri_latency, 12);
++	changed |= ilk_increase_wm_latency(dev_priv, dev_priv->wm.spr_latency, 12);
++	changed |= ilk_increase_wm_latency(dev_priv, dev_priv->wm.cur_latency, 12);
+ 
+ 	if (!changed)
+ 		return;
+diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
+index 378cfc46fc195..40ca1d4e03483 100644
+--- a/drivers/media/usb/uvc/uvc_driver.c
++++ b/drivers/media/usb/uvc/uvc_driver.c
+@@ -1972,7 +1972,6 @@ int uvc_register_video_device(struct uvc_device *dev,
+ 			      const struct v4l2_file_operations *fops,
+ 			      const struct v4l2_ioctl_ops *ioctl_ops)
+ {
+-	const char *name;
+ 	int ret;
+ 
+ 	/* Initialize the video buffers queue. */
+@@ -2001,20 +2000,16 @@ int uvc_register_video_device(struct uvc_device *dev,
+ 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+ 	default:
+ 		vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+-		name = "Video Capture";
+ 		break;
+ 	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+ 		vdev->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
+-		name = "Video Output";
+ 		break;
+ 	case V4L2_BUF_TYPE_META_CAPTURE:
+ 		vdev->device_caps = V4L2_CAP_META_CAPTURE | V4L2_CAP_STREAMING;
+-		name = "Metadata";
+ 		break;
+ 	}
+ 
+-	snprintf(vdev->name, sizeof(vdev->name), "%s %u", name,
+-		 stream->header.bTerminalLink);
++	strscpy(vdev->name, dev->name, sizeof(vdev->name));
+ 
+ 	/*
+ 	 * Set the driver data before calling video_register_device, otherwise
+diff --git a/drivers/mfd/intel-lpss-acpi.c b/drivers/mfd/intel-lpss-acpi.c
+index c8fe334b5fe8b..045cbf0cbe53a 100644
+--- a/drivers/mfd/intel-lpss-acpi.c
++++ b/drivers/mfd/intel-lpss-acpi.c
+@@ -102,6 +102,7 @@ static int intel_lpss_acpi_probe(struct platform_device *pdev)
+ {
+ 	struct intel_lpss_platform_info *info;
+ 	const struct acpi_device_id *id;
++	int ret;
+ 
+ 	id = acpi_match_device(intel_lpss_acpi_ids, &pdev->dev);
+ 	if (!id)
+@@ -115,10 +116,14 @@ static int intel_lpss_acpi_probe(struct platform_device *pdev)
+ 	info->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ 	info->irq = platform_get_irq(pdev, 0);
+ 
++	ret = intel_lpss_probe(&pdev->dev, info);
++	if (ret)
++		return ret;
++
+ 	pm_runtime_set_active(&pdev->dev);
+ 	pm_runtime_enable(&pdev->dev);
+ 
+-	return intel_lpss_probe(&pdev->dev, info);
++	return 0;
+ }
+ 
+ static int intel_lpss_acpi_remove(struct platform_device *pdev)
+diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c
+index a9151bd27211a..1e19c0d0bca80 100644
+--- a/drivers/mmc/host/sdhci-pci-core.c
++++ b/drivers/mmc/host/sdhci-pci-core.c
+@@ -1936,6 +1936,7 @@ static const struct pci_device_id pci_ids[] = {
+ 	SDHCI_PCI_DEVICE(INTEL, JSL_SD,    intel_byt_sd),
+ 	SDHCI_PCI_DEVICE(INTEL, LKF_EMMC,  intel_glk_emmc),
+ 	SDHCI_PCI_DEVICE(INTEL, LKF_SD,    intel_byt_sd),
++	SDHCI_PCI_DEVICE(INTEL, ADL_EMMC,  intel_glk_emmc),
+ 	SDHCI_PCI_DEVICE(O2, 8120,     o2),
+ 	SDHCI_PCI_DEVICE(O2, 8220,     o2),
+ 	SDHCI_PCI_DEVICE(O2, 8221,     o2),
+diff --git a/drivers/mmc/host/sdhci-pci.h b/drivers/mmc/host/sdhci-pci.h
+index 779156ce1ee17..b4ac314790b2c 100644
+--- a/drivers/mmc/host/sdhci-pci.h
++++ b/drivers/mmc/host/sdhci-pci.h
+@@ -59,6 +59,7 @@
+ #define PCI_DEVICE_ID_INTEL_JSL_SD	0x4df8
+ #define PCI_DEVICE_ID_INTEL_LKF_EMMC	0x98c4
+ #define PCI_DEVICE_ID_INTEL_LKF_SD	0x98f8
++#define PCI_DEVICE_ID_INTEL_ADL_EMMC	0x54c4
+ 
+ #define PCI_DEVICE_ID_SYSKONNECT_8000	0x8000
+ #define PCI_DEVICE_ID_VIA_95D0		0x95d0
+diff --git a/drivers/net/can/usb/gs_usb.c b/drivers/net/can/usb/gs_usb.c
+index 0ad13d78815c5..8b4c1bb77c334 100644
+--- a/drivers/net/can/usb/gs_usb.c
++++ b/drivers/net/can/usb/gs_usb.c
+@@ -320,7 +320,7 @@ static void gs_usb_receive_bulk_callback(struct urb *urb)
+ 
+ 	/* device reports out of range channel id */
+ 	if (hf->channel >= GS_MAX_INTF)
+-		goto resubmit_urb;
++		goto device_detach;
+ 
+ 	dev = usbcan->canch[hf->channel];
+ 
+@@ -405,6 +405,7 @@ static void gs_usb_receive_bulk_callback(struct urb *urb)
+ 
+ 	/* USB failure take down all interfaces */
+ 	if (rc == -ENODEV) {
++ device_detach:
+ 		for (rc = 0; rc < GS_MAX_INTF; rc++) {
+ 			if (usbcan->canch[rc])
+ 				netif_device_detach(usbcan->canch[rc]->netdev);
+@@ -506,6 +507,8 @@ static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb,
+ 
+ 	hf->echo_id = idx;
+ 	hf->channel = dev->channel;
++	hf->flags = 0;
++	hf->reserved = 0;
+ 
+ 	cf = (struct can_frame *)skb->data;
+ 
+diff --git a/drivers/net/veth.c b/drivers/net/veth.c
+index 44ad412f9a06f..81a79e7132483 100644
+--- a/drivers/net/veth.c
++++ b/drivers/net/veth.c
+@@ -254,7 +254,6 @@ static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
+ 	if (rxq < rcv->real_num_rx_queues) {
+ 		rq = &rcv_priv->rq[rxq];
+ 		rcv_xdp = rcu_access_pointer(rq->xdp_prog);
+-		skb_record_rx_queue(skb, rxq);
+ 	}
+ 
+ 	skb_tx_timestamp(skb);
+diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c
+index cc329b990e165..a8cfea957868a 100644
+--- a/drivers/staging/greybus/audio_topology.c
++++ b/drivers/staging/greybus/audio_topology.c
+@@ -983,6 +983,44 @@ static int gbaudio_widget_event(struct snd_soc_dapm_widget *w,
+ 	return ret;
+ }
+ 
++static const struct snd_soc_dapm_widget gbaudio_widgets[] = {
++	[snd_soc_dapm_spk]	= SND_SOC_DAPM_SPK(NULL, gbcodec_event_spk),
++	[snd_soc_dapm_hp]	= SND_SOC_DAPM_HP(NULL, gbcodec_event_hp),
++	[snd_soc_dapm_mic]	= SND_SOC_DAPM_MIC(NULL, gbcodec_event_int_mic),
++	[snd_soc_dapm_output]	= SND_SOC_DAPM_OUTPUT(NULL),
++	[snd_soc_dapm_input]	= SND_SOC_DAPM_INPUT(NULL),
++	[snd_soc_dapm_switch]	= SND_SOC_DAPM_SWITCH_E(NULL, SND_SOC_NOPM,
++					0, 0, NULL,
++					gbaudio_widget_event,
++					SND_SOC_DAPM_PRE_PMU |
++					SND_SOC_DAPM_POST_PMD),
++	[snd_soc_dapm_pga]	= SND_SOC_DAPM_PGA_E(NULL, SND_SOC_NOPM,
++					0, 0, NULL, 0,
++					gbaudio_widget_event,
++					SND_SOC_DAPM_PRE_PMU |
++					SND_SOC_DAPM_POST_PMD),
++	[snd_soc_dapm_mixer]	= SND_SOC_DAPM_MIXER_E(NULL, SND_SOC_NOPM,
++					0, 0, NULL, 0,
++					gbaudio_widget_event,
++					SND_SOC_DAPM_PRE_PMU |
++					SND_SOC_DAPM_POST_PMD),
++	[snd_soc_dapm_mux]	= SND_SOC_DAPM_MUX_E(NULL, SND_SOC_NOPM,
++					0, 0, NULL,
++					gbaudio_widget_event,
++					SND_SOC_DAPM_PRE_PMU |
++					SND_SOC_DAPM_POST_PMD),
++	[snd_soc_dapm_aif_in]	= SND_SOC_DAPM_AIF_IN_E(NULL, NULL, 0,
++					SND_SOC_NOPM, 0, 0,
++					gbaudio_widget_event,
++					SND_SOC_DAPM_PRE_PMU |
++					SND_SOC_DAPM_POST_PMD),
++	[snd_soc_dapm_aif_out]	= SND_SOC_DAPM_AIF_OUT_E(NULL, NULL, 0,
++					SND_SOC_NOPM, 0, 0,
++					gbaudio_widget_event,
++					SND_SOC_DAPM_PRE_PMU |
++					SND_SOC_DAPM_POST_PMD),
++};
++
+ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module,
+ 				      struct snd_soc_dapm_widget *dw,
+ 				      struct gb_audio_widget *w, int *w_size)
+@@ -1061,77 +1099,37 @@ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module,
+ 
+ 	switch (w->type) {
+ 	case snd_soc_dapm_spk:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_SPK(w->name, gbcodec_event_spk);
++		*dw = gbaudio_widgets[w->type];
+ 		module->op_devices |= GBAUDIO_DEVICE_OUT_SPEAKER;
+ 		break;
+ 	case snd_soc_dapm_hp:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_HP(w->name, gbcodec_event_hp);
++		*dw = gbaudio_widgets[w->type];
+ 		module->op_devices |= (GBAUDIO_DEVICE_OUT_WIRED_HEADSET
+ 					| GBAUDIO_DEVICE_OUT_WIRED_HEADPHONE);
+ 		module->ip_devices |= GBAUDIO_DEVICE_IN_WIRED_HEADSET;
+ 		break;
+ 	case snd_soc_dapm_mic:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_MIC(w->name, gbcodec_event_int_mic);
++		*dw = gbaudio_widgets[w->type];
+ 		module->ip_devices |= GBAUDIO_DEVICE_IN_BUILTIN_MIC;
+ 		break;
+ 	case snd_soc_dapm_output:
+-		*dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_OUTPUT(w->name);
+-		break;
+ 	case snd_soc_dapm_input:
+-		*dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_INPUT(w->name);
+-		break;
+ 	case snd_soc_dapm_switch:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_SWITCH_E(w->name, SND_SOC_NOPM, 0, 0,
+-					      widget_kctls,
+-					      gbaudio_widget_event,
+-					      SND_SOC_DAPM_PRE_PMU |
+-					      SND_SOC_DAPM_POST_PMD);
+-		break;
+ 	case snd_soc_dapm_pga:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_PGA_E(w->name, SND_SOC_NOPM, 0, 0, NULL, 0,
+-					   gbaudio_widget_event,
+-					   SND_SOC_DAPM_PRE_PMU |
+-					   SND_SOC_DAPM_POST_PMD);
+-		break;
+ 	case snd_soc_dapm_mixer:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_MIXER_E(w->name, SND_SOC_NOPM, 0, 0, NULL,
+-					     0, gbaudio_widget_event,
+-					     SND_SOC_DAPM_PRE_PMU |
+-					     SND_SOC_DAPM_POST_PMD);
+-		break;
+ 	case snd_soc_dapm_mux:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_MUX_E(w->name, SND_SOC_NOPM, 0, 0,
+-					   widget_kctls, gbaudio_widget_event,
+-					   SND_SOC_DAPM_PRE_PMU |
+-					   SND_SOC_DAPM_POST_PMD);
++		*dw = gbaudio_widgets[w->type];
+ 		break;
+ 	case snd_soc_dapm_aif_in:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_AIF_IN_E(w->name, w->sname, 0,
+-					      SND_SOC_NOPM,
+-					      0, 0, gbaudio_widget_event,
+-					      SND_SOC_DAPM_PRE_PMU |
+-					      SND_SOC_DAPM_POST_PMD);
+-		break;
+ 	case snd_soc_dapm_aif_out:
+-		*dw = (struct snd_soc_dapm_widget)
+-			SND_SOC_DAPM_AIF_OUT_E(w->name, w->sname, 0,
+-					       SND_SOC_NOPM,
+-					       0, 0, gbaudio_widget_event,
+-					       SND_SOC_DAPM_PRE_PMU |
+-					       SND_SOC_DAPM_POST_PMD);
++		*dw = gbaudio_widgets[w->type];
++		dw->sname = w->sname;
+ 		break;
+ 	default:
+ 		ret = -EINVAL;
+ 		goto error;
+ 	}
++	dw->name = w->name;
+ 
+ 	dev_dbg(module->dev, "%s: widget of type %d created\n", dw->name,
+ 		dw->id);
+diff --git a/drivers/staging/wlan-ng/hfa384x_usb.c b/drivers/staging/wlan-ng/hfa384x_usb.c
+index ed4ff78dd02aa..71cca6e1dea46 100644
+--- a/drivers/staging/wlan-ng/hfa384x_usb.c
++++ b/drivers/staging/wlan-ng/hfa384x_usb.c
+@@ -3779,18 +3779,18 @@ static void hfa384x_usb_throttlefn(struct timer_list *t)
+ 
+ 	spin_lock_irqsave(&hw->ctlxq.lock, flags);
+ 
+-	/*
+-	 * We need to check BOTH the RX and the TX throttle controls,
+-	 * so we use the bitwise OR instead of the logical OR.
+-	 */
+ 	pr_debug("flags=0x%lx\n", hw->usb_flags);
+-	if (!hw->wlandev->hwremoved &&
+-	    ((test_and_clear_bit(THROTTLE_RX, &hw->usb_flags) &&
+-	      !test_and_set_bit(WORK_RX_RESUME, &hw->usb_flags)) |
+-	     (test_and_clear_bit(THROTTLE_TX, &hw->usb_flags) &&
+-	      !test_and_set_bit(WORK_TX_RESUME, &hw->usb_flags))
+-	    )) {
+-		schedule_work(&hw->usb_work);
++	if (!hw->wlandev->hwremoved) {
++		bool rx_throttle = test_and_clear_bit(THROTTLE_RX, &hw->usb_flags) &&
++				   !test_and_set_bit(WORK_RX_RESUME, &hw->usb_flags);
++		bool tx_throttle = test_and_clear_bit(THROTTLE_TX, &hw->usb_flags) &&
++				   !test_and_set_bit(WORK_TX_RESUME, &hw->usb_flags);
++		/*
++		 * We need to check BOTH the RX and the TX throttle controls,
++		 * so we use the bitwise OR instead of the logical OR.
++		 */
++		if (rx_throttle | tx_throttle)
++			schedule_work(&hw->usb_work);
+ 	}
+ 
+ 	spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
+diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
+index d0f45600b6698..fe9b392bffee3 100644
+--- a/drivers/usb/core/hcd.c
++++ b/drivers/usb/core/hcd.c
+@@ -753,6 +753,7 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
+ {
+ 	struct urb	*urb;
+ 	int		length;
++	int		status;
+ 	unsigned long	flags;
+ 	char		buffer[6];	/* Any root hubs with > 31 ports? */
+ 
+@@ -770,11 +771,17 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
+ 		if (urb) {
+ 			clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
+ 			hcd->status_urb = NULL;
++			if (urb->transfer_buffer_length >= length) {
++				status = 0;
++			} else {
++				status = -EOVERFLOW;
++				length = urb->transfer_buffer_length;
++			}
+ 			urb->actual_length = length;
+ 			memcpy(urb->transfer_buffer, buffer, length);
+ 
+ 			usb_hcd_unlink_urb_from_ep(hcd, urb);
+-			usb_hcd_giveback_urb(hcd, urb, 0);
++			usb_hcd_giveback_urb(hcd, urb, status);
+ 		} else {
+ 			length = 0;
+ 			set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
+diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
+index d7ab2e88631a0..69dd48f9507e5 100644
+--- a/drivers/usb/core/hub.c
++++ b/drivers/usb/core/hub.c
+@@ -1223,7 +1223,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
+ 			 */
+ 			if (portchange || (hub_is_superspeed(hub->hdev) &&
+ 						port_resumed))
+-				set_bit(port1, hub->change_bits);
++				set_bit(port1, hub->event_bits);
+ 
+ 		} else if (udev->persist_enabled) {
+ #ifdef CONFIG_PM
+diff --git a/kernel/workqueue.c b/kernel/workqueue.c
+index 77e6964ae1a99..e90f37e22202a 100644
+--- a/kernel/workqueue.c
++++ b/kernel/workqueue.c
+@@ -855,8 +855,17 @@ void wq_worker_running(struct task_struct *task)
+ 
+ 	if (!worker->sleeping)
+ 		return;
++
++	/*
++	 * If preempted by unbind_workers() between the WORKER_NOT_RUNNING check
++	 * and the nr_running increment below, we may ruin the nr_running reset
++	 * and leave with an unexpected pool->nr_running == 1 on the newly unbound
++	 * pool. Protect against such race.
++	 */
++	preempt_disable();
+ 	if (!(worker->flags & WORKER_NOT_RUNNING))
+ 		atomic_inc(&worker->pool->nr_running);
++	preempt_enable();
+ 	worker->sleeping = 0;
+ }
+