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; + } +
