Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-5.4/0271-5.4.172-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-5.4/0271-5.4.172-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3637 - (show annotations) (download)
    Mon Oct 24 12:40:44 2022 UTC (18 months ago) by niro
    File size: 44096 byte(s) 
    -add missing
    1 diff --git a/Makefile b/Makefile
    2 index 062052f71a976..2f914dd223c81 100644
    3 --- a/Makefile
    4 +++ b/Makefile
    5 @@ -1,7 +1,7 @@
    6 # SPDX-License-Identifier: GPL-2.0
    7 VERSION = 5
    8 PATCHLEVEL = 4
    9 -SUBLEVEL = 171
    10 +SUBLEVEL = 172
    11 EXTRAVERSION =
    12 NAME = Kleptomaniac Octopus
    13
    14 diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
    15 index 83e26fd188cc9..d5f64018044b0 100644
    16 --- a/drivers/base/arch_topology.c
    17 +++ b/drivers/base/arch_topology.c
    18 @@ -48,7 +48,7 @@ static ssize_t cpu_capacity_show(struct device *dev,
    19 {
    20 struct cpu *cpu = container_of(dev, struct cpu, dev);
    21
    22 - return sprintf(buf, "%lu\n", topology_get_cpu_scale(cpu->dev.id));
    23 + return sysfs_emit(buf, "%lu\n", topology_get_cpu_scale(cpu->dev.id));
    24 }
    25
    26 static void update_topology_flags_workfn(struct work_struct *work);
    27 diff --git a/drivers/base/cacheinfo.c b/drivers/base/cacheinfo.c
    28 index 8d553c92cd322..6a8c2b5881be3 100644
    29 --- a/drivers/base/cacheinfo.c
    30 +++ b/drivers/base/cacheinfo.c
    31 @@ -377,7 +377,7 @@ static ssize_t size_show(struct device *dev,
    32 {
    33 struct cacheinfo *this_leaf = dev_get_drvdata(dev);
    34
    35 - return sprintf(buf, "%uK\n", this_leaf->size >> 10);
    36 + return sysfs_emit(buf, "%uK\n", this_leaf->size >> 10);
    37 }
    38
    39 static ssize_t shared_cpumap_show_func(struct device *dev, bool list, char *buf)
    40 @@ -407,11 +407,11 @@ static ssize_t type_show(struct device *dev,
    41
    42 switch (this_leaf->type) {
    43 case CACHE_TYPE_DATA:
    44 - return sprintf(buf, "Data\n");
    45 + return sysfs_emit(buf, "Data\n");
    46 case CACHE_TYPE_INST:
    47 - return sprintf(buf, "Instruction\n");
    48 + return sysfs_emit(buf, "Instruction\n");
    49 case CACHE_TYPE_UNIFIED:
    50 - return sprintf(buf, "Unified\n");
    51 + return sysfs_emit(buf, "Unified\n");
    52 default:
    53 return -EINVAL;
    54 }
    55 @@ -425,11 +425,11 @@ static ssize_t allocation_policy_show(struct device *dev,
    56 int n = 0;
    57
    58 if ((ci_attr & CACHE_READ_ALLOCATE) && (ci_attr & CACHE_WRITE_ALLOCATE))
    59 - n = sprintf(buf, "ReadWriteAllocate\n");
    60 + n = sysfs_emit(buf, "ReadWriteAllocate\n");
    61 else if (ci_attr & CACHE_READ_ALLOCATE)
    62 - n = sprintf(buf, "ReadAllocate\n");
    63 + n = sysfs_emit(buf, "ReadAllocate\n");
    64 else if (ci_attr & CACHE_WRITE_ALLOCATE)
    65 - n = sprintf(buf, "WriteAllocate\n");
    66 + n = sysfs_emit(buf, "WriteAllocate\n");
    67 return n;
    68 }
    69
    70 @@ -441,9 +441,9 @@ static ssize_t write_policy_show(struct device *dev,
    71 int n = 0;
    72
    73 if (ci_attr & CACHE_WRITE_THROUGH)
    74 - n = sprintf(buf, "WriteThrough\n");
    75 + n = sysfs_emit(buf, "WriteThrough\n");
    76 else if (ci_attr & CACHE_WRITE_BACK)
    77 - n = sprintf(buf, "WriteBack\n");
    78 + n = sysfs_emit(buf, "WriteBack\n");
    79 return n;
    80 }
    81
    82 diff --git a/drivers/base/core.c b/drivers/base/core.c
    83 index 8b651bfc1d88e..1b016fdd1a750 100644
    84 --- a/drivers/base/core.c
    85 +++ b/drivers/base/core.c
    86 @@ -1027,7 +1027,7 @@ ssize_t device_show_ulong(struct device *dev,
    87 char *buf)
    88 {
    89 struct dev_ext_attribute *ea = to_ext_attr(attr);
    90 - return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
    91 + return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var));
    92 }
    93 EXPORT_SYMBOL_GPL(device_show_ulong);
    94
    95 @@ -1057,7 +1057,7 @@ ssize_t device_show_int(struct device *dev,
    96 {
    97 struct dev_ext_attribute *ea = to_ext_attr(attr);
    98
    99 - return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
    100 + return sysfs_emit(buf, "%d\n", *(int *)(ea->var));
    101 }
    102 EXPORT_SYMBOL_GPL(device_show_int);
    103
    104 @@ -1078,7 +1078,7 @@ ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
    105 {
    106 struct dev_ext_attribute *ea = to_ext_attr(attr);
    107
    108 - return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var));
    109 + return sysfs_emit(buf, "%d\n", *(bool *)(ea->var));
    110 }
    111 EXPORT_SYMBOL_GPL(device_show_bool);
    112
    113 @@ -1310,7 +1310,7 @@ static ssize_t online_show(struct device *dev, struct device_attribute *attr,
    114 device_lock(dev);
    115 val = !dev->offline;
    116 device_unlock(dev);
    117 - return sprintf(buf, "%u\n", val);
    118 + return sysfs_emit(buf, "%u\n", val);
    119 }
    120
    121 static ssize_t online_store(struct device *dev, struct device_attribute *attr,
    122 diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
    123 index f00da44ae6fe0..81ec0a1020d60 100644
    124 --- a/drivers/base/cpu.c
    125 +++ b/drivers/base/cpu.c
    126 @@ -156,7 +156,7 @@ static ssize_t show_crash_notes(struct device *dev, struct device_attribute *att
    127 * operation should be safe. No locking required.
    128 */
    129 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
    130 - rc = sprintf(buf, "%Lx\n", addr);
    131 + rc = sysfs_emit(buf, "%Lx\n", addr);
    132 return rc;
    133 }
    134 static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
    135 @@ -167,7 +167,7 @@ static ssize_t show_crash_notes_size(struct device *dev,
    136 {
    137 ssize_t rc;
    138
    139 - rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
    140 + rc = sysfs_emit(buf, "%zu\n", sizeof(note_buf_t));
    141 return rc;
    142 }
    143 static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
    144 @@ -231,8 +231,7 @@ static struct cpu_attr cpu_attrs[] = {
    145 static ssize_t print_cpus_kernel_max(struct device *dev,
    146 struct device_attribute *attr, char *buf)
    147 {
    148 - int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
    149 - return n;
    150 + return sprintf(buf, "%d\n", NR_CPUS - 1);
    151 }
    152 static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
    153
    154 @@ -272,7 +271,7 @@ static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
    155 static ssize_t print_cpus_isolated(struct device *dev,
    156 struct device_attribute *attr, char *buf)
    157 {
    158 - int n = 0, len = PAGE_SIZE-2;
    159 + int n;
    160 cpumask_var_t isolated;
    161
    162 if (!alloc_cpumask_var(&isolated, GFP_KERNEL))
    163 @@ -280,7 +279,7 @@ static ssize_t print_cpus_isolated(struct device *dev,
    164
    165 cpumask_andnot(isolated, cpu_possible_mask,
    166 housekeeping_cpumask(HK_FLAG_DOMAIN));
    167 - n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(isolated));
    168 + n = sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(isolated));
    169
    170 free_cpumask_var(isolated);
    171
    172 @@ -292,11 +291,7 @@ static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL);
    173 static ssize_t print_cpus_nohz_full(struct device *dev,
    174 struct device_attribute *attr, char *buf)
    175 {
    176 - int n = 0, len = PAGE_SIZE-2;
    177 -
    178 - n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask));
    179 -
    180 - return n;
    181 + return sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask));
    182 }
    183 static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL);
    184 #endif
    185 @@ -328,8 +323,8 @@ static ssize_t print_cpu_modalias(struct device *dev,
    186 ssize_t n;
    187 u32 i;
    188
    189 - n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
    190 - CPU_FEATURE_TYPEVAL);
    191 + n = sysfs_emit(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
    192 + CPU_FEATURE_TYPEVAL);
    193
    194 for (i = 0; i < MAX_CPU_FEATURES; i++)
    195 if (cpu_have_feature(i)) {
    196 @@ -521,56 +516,56 @@ static void __init cpu_dev_register_generic(void)
    197 ssize_t __weak cpu_show_meltdown(struct device *dev,
    198 struct device_attribute *attr, char *buf)
    199 {
    200 - return sprintf(buf, "Not affected\n");
    201 + return sysfs_emit(buf, "Not affected\n");
    202 }
    203
    204 ssize_t __weak cpu_show_spectre_v1(struct device *dev,
    205 struct device_attribute *attr, char *buf)
    206 {
    207 - return sprintf(buf, "Not affected\n");
    208 + return sysfs_emit(buf, "Not affected\n");
    209 }
    210
    211 ssize_t __weak cpu_show_spectre_v2(struct device *dev,
    212 struct device_attribute *attr, char *buf)
    213 {
    214 - return sprintf(buf, "Not affected\n");
    215 + return sysfs_emit(buf, "Not affected\n");
    216 }
    217
    218 ssize_t __weak cpu_show_spec_store_bypass(struct device *dev,
    219 struct device_attribute *attr, char *buf)
    220 {
    221 - return sprintf(buf, "Not affected\n");
    222 + return sysfs_emit(buf, "Not affected\n");
    223 }
    224
    225 ssize_t __weak cpu_show_l1tf(struct device *dev,
    226 struct device_attribute *attr, char *buf)
    227 {
    228 - return sprintf(buf, "Not affected\n");
    229 + return sysfs_emit(buf, "Not affected\n");
    230 }
    231
    232 ssize_t __weak cpu_show_mds(struct device *dev,
    233 struct device_attribute *attr, char *buf)
    234 {
    235 - return sprintf(buf, "Not affected\n");
    236 + return sysfs_emit(buf, "Not affected\n");
    237 }
    238
    239 ssize_t __weak cpu_show_tsx_async_abort(struct device *dev,
    240 struct device_attribute *attr,
    241 char *buf)
    242 {
    243 - return sprintf(buf, "Not affected\n");
    244 + return sysfs_emit(buf, "Not affected\n");
    245 }
    246
    247 ssize_t __weak cpu_show_itlb_multihit(struct device *dev,
    248 struct device_attribute *attr, char *buf)
    249 {
    250 - return sprintf(buf, "Not affected\n");
    251 + return sysfs_emit(buf, "Not affected\n");
    252 }
    253
    254 ssize_t __weak cpu_show_srbds(struct device *dev,
    255 struct device_attribute *attr, char *buf)
    256 {
    257 - return sprintf(buf, "Not affected\n");
    258 + return sysfs_emit(buf, "Not affected\n");
    259 }
    260
    261 static DEVICE_ATTR(meltdown, 0444, cpu_show_meltdown, NULL);
    262 diff --git a/drivers/base/firmware_loader/fallback.c b/drivers/base/firmware_loader/fallback.c
    263 index 5f3e5d8372590..19d18afb30864 100644
    264 --- a/drivers/base/firmware_loader/fallback.c
    265 +++ b/drivers/base/firmware_loader/fallback.c
    266 @@ -215,7 +215,7 @@ static ssize_t firmware_loading_show(struct device *dev,
    267 loading = fw_sysfs_loading(fw_sysfs->fw_priv);
    268 mutex_unlock(&fw_lock);
    269
    270 - return sprintf(buf, "%d\n", loading);
    271 + return sysfs_emit(buf, "%d\n", loading);
    272 }
    273
    274 /**
    275 diff --git a/drivers/base/memory.c b/drivers/base/memory.c
    276 index 5a8c430fb8ffa..729e93e0c1c13 100644
    277 --- a/drivers/base/memory.c
    278 +++ b/drivers/base/memory.c
    279 @@ -110,7 +110,7 @@ static ssize_t phys_index_show(struct device *dev,
    280 unsigned long phys_index;
    281
    282 phys_index = mem->start_section_nr / sections_per_block;
    283 - return sprintf(buf, "%08lx\n", phys_index);
    284 + return sysfs_emit(buf, "%08lx\n", phys_index);
    285 }
    286
    287 /*
    288 @@ -120,7 +120,7 @@ static ssize_t phys_index_show(struct device *dev,
    289 static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
    290 char *buf)
    291 {
    292 - return sprintf(buf, "%d\n", (int)IS_ENABLED(CONFIG_MEMORY_HOTREMOVE));
    293 + return sysfs_emit(buf, "%d\n", (int)IS_ENABLED(CONFIG_MEMORY_HOTREMOVE));
    294 }
    295
    296 /*
    297 @@ -138,17 +138,17 @@ static ssize_t state_show(struct device *dev, struct device_attribute *attr,
    298 */
    299 switch (mem->state) {
    300 case MEM_ONLINE:
    301 - len = sprintf(buf, "online\n");
    302 + len = sysfs_emit(buf, "online\n");
    303 break;
    304 case MEM_OFFLINE:
    305 - len = sprintf(buf, "offline\n");
    306 + len = sysfs_emit(buf, "offline\n");
    307 break;
    308 case MEM_GOING_OFFLINE:
    309 - len = sprintf(buf, "going-offline\n");
    310 + len = sysfs_emit(buf, "going-offline\n");
    311 break;
    312 default:
    313 - len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
    314 - mem->state);
    315 + len = sysfs_emit(buf, "ERROR-UNKNOWN-%ld\n",
    316 + mem->state);
    317 WARN_ON(1);
    318 break;
    319 }
    320 @@ -358,7 +358,7 @@ static ssize_t phys_device_show(struct device *dev,
    321 struct device_attribute *attr, char *buf)
    322 {
    323 struct memory_block *mem = to_memory_block(dev);
    324 - return sprintf(buf, "%d\n", mem->phys_device);
    325 + return sysfs_emit(buf, "%d\n", mem->phys_device);
    326 }
    327
    328 #ifdef CONFIG_MEMORY_HOTREMOVE
    329 @@ -396,7 +396,7 @@ static ssize_t valid_zones_show(struct device *dev,
    330 */
    331 if (!test_pages_in_a_zone(start_pfn, start_pfn + nr_pages,
    332 &valid_start_pfn, &valid_end_pfn))
    333 - return sprintf(buf, "none\n");
    334 + return sysfs_emit(buf, "none\n");
    335 start_pfn = valid_start_pfn;
    336 strcat(buf, page_zone(pfn_to_page(start_pfn))->name);
    337 goto out;
    338 @@ -429,7 +429,7 @@ static DEVICE_ATTR_RO(removable);
    339 static ssize_t block_size_bytes_show(struct device *dev,
    340 struct device_attribute *attr, char *buf)
    341 {
    342 - return sprintf(buf, "%lx\n", memory_block_size_bytes());
    343 + return sysfs_emit(buf, "%lx\n", memory_block_size_bytes());
    344 }
    345
    346 static DEVICE_ATTR_RO(block_size_bytes);
    347 @@ -442,9 +442,9 @@ static ssize_t auto_online_blocks_show(struct device *dev,
    348 struct device_attribute *attr, char *buf)
    349 {
    350 if (memhp_auto_online)
    351 - return sprintf(buf, "online\n");
    352 + return sysfs_emit(buf, "online\n");
    353 else
    354 - return sprintf(buf, "offline\n");
    355 + return sysfs_emit(buf, "offline\n");
    356 }
    357
    358 static ssize_t auto_online_blocks_store(struct device *dev,
    359 diff --git a/drivers/base/node.c b/drivers/base/node.c
    360 index c9976dc4aa65f..62a052990bb9b 100644
    361 --- a/drivers/base/node.c
    362 +++ b/drivers/base/node.c
    363 @@ -368,7 +368,7 @@ static ssize_t node_read_meminfo(struct device *dev,
    364 si_meminfo_node(&i, nid);
    365 sreclaimable = node_page_state(pgdat, NR_SLAB_RECLAIMABLE);
    366 sunreclaimable = node_page_state(pgdat, NR_SLAB_UNRECLAIMABLE);
    367 - n = sprintf(buf,
    368 + n = sysfs_emit(buf,
    369 "Node %d MemTotal: %8lu kB\n"
    370 "Node %d MemFree: %8lu kB\n"
    371 "Node %d MemUsed: %8lu kB\n"
    372 @@ -469,19 +469,19 @@ static DEVICE_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL);
    373 static ssize_t node_read_numastat(struct device *dev,
    374 struct device_attribute *attr, char *buf)
    375 {
    376 - return sprintf(buf,
    377 - "numa_hit %lu\n"
    378 - "numa_miss %lu\n"
    379 - "numa_foreign %lu\n"
    380 - "interleave_hit %lu\n"
    381 - "local_node %lu\n"
    382 - "other_node %lu\n",
    383 - sum_zone_numa_state(dev->id, NUMA_HIT),
    384 - sum_zone_numa_state(dev->id, NUMA_MISS),
    385 - sum_zone_numa_state(dev->id, NUMA_FOREIGN),
    386 - sum_zone_numa_state(dev->id, NUMA_INTERLEAVE_HIT),
    387 - sum_zone_numa_state(dev->id, NUMA_LOCAL),
    388 - sum_zone_numa_state(dev->id, NUMA_OTHER));
    389 + return sysfs_emit(buf,
    390 + "numa_hit %lu\n"
    391 + "numa_miss %lu\n"
    392 + "numa_foreign %lu\n"
    393 + "interleave_hit %lu\n"
    394 + "local_node %lu\n"
    395 + "other_node %lu\n",
    396 + sum_zone_numa_state(dev->id, NUMA_HIT),
    397 + sum_zone_numa_state(dev->id, NUMA_MISS),
    398 + sum_zone_numa_state(dev->id, NUMA_FOREIGN),
    399 + sum_zone_numa_state(dev->id, NUMA_INTERLEAVE_HIT),
    400 + sum_zone_numa_state(dev->id, NUMA_LOCAL),
    401 + sum_zone_numa_state(dev->id, NUMA_OTHER));
    402 }
    403 static DEVICE_ATTR(numastat, S_IRUGO, node_read_numastat, NULL);
    404
    405 diff --git a/drivers/base/platform.c b/drivers/base/platform.c
    406 index 0b67d41bab8ff..75623b914b8c2 100644
    407 --- a/drivers/base/platform.c
    408 +++ b/drivers/base/platform.c
    409 @@ -1009,7 +1009,7 @@ static ssize_t driver_override_show(struct device *dev,
    410 ssize_t len;
    411
    412 device_lock(dev);
    413 - len = sprintf(buf, "%s\n", pdev->driver_override);
    414 + len = sysfs_emit(buf, "%s\n", pdev->driver_override);
    415 device_unlock(dev);
    416 return len;
    417 }
    418 diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
    419 index d7d82db2e4bc4..2786962e08107 100644
    420 --- a/drivers/base/power/sysfs.c
    421 +++ b/drivers/base/power/sysfs.c
    422 @@ -100,7 +100,7 @@ static const char ctrl_on[] = "on";
    423 static ssize_t control_show(struct device *dev, struct device_attribute *attr,
    424 char *buf)
    425 {
    426 - return sprintf(buf, "%s\n",
    427 + return sysfs_emit(buf, "%s\n",
    428 dev->power.runtime_auto ? ctrl_auto : ctrl_on);
    429 }
    430
    431 @@ -126,7 +126,7 @@ static ssize_t runtime_active_time_show(struct device *dev,
    432 int ret;
    433 u64 tmp = pm_runtime_active_time(dev);
    434 do_div(tmp, NSEC_PER_MSEC);
    435 - ret = sprintf(buf, "%llu\n", tmp);
    436 + ret = sysfs_emit(buf, "%llu\n", tmp);
    437 return ret;
    438 }
    439
    440 @@ -138,7 +138,7 @@ static ssize_t runtime_suspended_time_show(struct device *dev,
    441 int ret;
    442 u64 tmp = pm_runtime_suspended_time(dev);
    443 do_div(tmp, NSEC_PER_MSEC);
    444 - ret = sprintf(buf, "%llu\n", tmp);
    445 + ret = sysfs_emit(buf, "%llu\n", tmp);
    446 return ret;
    447 }
    448
    449 @@ -171,7 +171,7 @@ static ssize_t runtime_status_show(struct device *dev,
    450 return -EIO;
    451 }
    452 }
    453 - return sprintf(buf, p);
    454 + return sysfs_emit(buf, p);
    455 }
    456
    457 static DEVICE_ATTR_RO(runtime_status);
    458 @@ -181,7 +181,7 @@ static ssize_t autosuspend_delay_ms_show(struct device *dev,
    459 {
    460 if (!dev->power.use_autosuspend)
    461 return -EIO;
    462 - return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
    463 + return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay);
    464 }
    465
    466 static ssize_t autosuspend_delay_ms_store(struct device *dev,
    467 @@ -210,11 +210,11 @@ static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
    468 s32 value = dev_pm_qos_requested_resume_latency(dev);
    469
    470 if (value == 0)
    471 - return sprintf(buf, "n/a\n");
    472 + return sysfs_emit(buf, "n/a\n");
    473 if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
    474 value = 0;
    475
    476 - return sprintf(buf, "%d\n", value);
    477 + return sysfs_emit(buf, "%d\n", value);
    478 }
    479
    480 static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
    481 @@ -254,11 +254,11 @@ static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
    482 s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
    483
    484 if (value < 0)
    485 - return sprintf(buf, "auto\n");
    486 + return sysfs_emit(buf, "auto\n");
    487 if (value == PM_QOS_LATENCY_ANY)
    488 - return sprintf(buf, "any\n");
    489 + return sysfs_emit(buf, "any\n");
    490
    491 - return sprintf(buf, "%d\n", value);
    492 + return sysfs_emit(buf, "%d\n", value);
    493 }
    494
    495 static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
    496 @@ -290,8 +290,8 @@ static ssize_t pm_qos_no_power_off_show(struct device *dev,
    497 struct device_attribute *attr,
    498 char *buf)
    499 {
    500 - return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
    501 - & PM_QOS_FLAG_NO_POWER_OFF));
    502 + return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
    503 + & PM_QOS_FLAG_NO_POWER_OFF));
    504 }
    505
    506 static ssize_t pm_qos_no_power_off_store(struct device *dev,
    507 @@ -319,9 +319,9 @@ static const char _disabled[] = "disabled";
    508 static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
    509 char *buf)
    510 {
    511 - return sprintf(buf, "%s\n", device_can_wakeup(dev)
    512 - ? (device_may_wakeup(dev) ? _enabled : _disabled)
    513 - : "");
    514 + return sysfs_emit(buf, "%s\n", device_can_wakeup(dev)
    515 + ? (device_may_wakeup(dev) ? _enabled : _disabled)
    516 + : "");
    517 }
    518
    519 static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
    520 @@ -507,7 +507,7 @@ static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
    521 static ssize_t runtime_usage_show(struct device *dev,
    522 struct device_attribute *attr, char *buf)
    523 {
    524 - return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
    525 + return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
    526 }
    527 static DEVICE_ATTR_RO(runtime_usage);
    528
    529 @@ -515,8 +515,8 @@ static ssize_t runtime_active_kids_show(struct device *dev,
    530 struct device_attribute *attr,
    531 char *buf)
    532 {
    533 - return sprintf(buf, "%d\n", dev->power.ignore_children ?
    534 - 0 : atomic_read(&dev->power.child_count));
    535 + return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
    536 + 0 : atomic_read(&dev->power.child_count));
    537 }
    538 static DEVICE_ATTR_RO(runtime_active_kids);
    539
    540 @@ -524,12 +524,12 @@ static ssize_t runtime_enabled_show(struct device *dev,
    541 struct device_attribute *attr, char *buf)
    542 {
    543 if (dev->power.disable_depth && (dev->power.runtime_auto == false))
    544 - return sprintf(buf, "disabled & forbidden\n");
    545 + return sysfs_emit(buf, "disabled & forbidden\n");
    546 if (dev->power.disable_depth)
    547 - return sprintf(buf, "disabled\n");
    548 + return sysfs_emit(buf, "disabled\n");
    549 if (dev->power.runtime_auto == false)
    550 - return sprintf(buf, "forbidden\n");
    551 - return sprintf(buf, "enabled\n");
    552 + return sysfs_emit(buf, "forbidden\n");
    553 + return sysfs_emit(buf, "enabled\n");
    554 }
    555 static DEVICE_ATTR_RO(runtime_enabled);
    556
    557 @@ -537,9 +537,9 @@ static DEVICE_ATTR_RO(runtime_enabled);
    558 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
    559 char *buf)
    560 {
    561 - return sprintf(buf, "%s\n",
    562 - device_async_suspend_enabled(dev) ?
    563 - _enabled : _disabled);
    564 + return sysfs_emit(buf, "%s\n",
    565 + device_async_suspend_enabled(dev) ?
    566 + _enabled : _disabled);
    567 }
    568
    569 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
    570 diff --git a/drivers/base/power/wakeup_stats.c b/drivers/base/power/wakeup_stats.c
    571 index c7734914d9144..5568e25d7c9c2 100644
    572 --- a/drivers/base/power/wakeup_stats.c
    573 +++ b/drivers/base/power/wakeup_stats.c
    574 @@ -42,7 +42,7 @@ static ssize_t active_time_ms_show(struct device *dev,
    575 ktime_t active_time =
    576 ws->active ? ktime_sub(ktime_get(), ws->last_time) : 0;
    577
    578 - return sprintf(buf, "%lld\n", ktime_to_ms(active_time));
    579 + return sysfs_emit(buf, "%lld\n", ktime_to_ms(active_time));
    580 }
    581 static DEVICE_ATTR_RO(active_time_ms);
    582
    583 @@ -57,7 +57,7 @@ static ssize_t total_time_ms_show(struct device *dev,
    584 active_time = ktime_sub(ktime_get(), ws->last_time);
    585 total_time = ktime_add(total_time, active_time);
    586 }
    587 - return sprintf(buf, "%lld\n", ktime_to_ms(total_time));
    588 + return sysfs_emit(buf, "%lld\n", ktime_to_ms(total_time));
    589 }
    590 static DEVICE_ATTR_RO(total_time_ms);
    591
    592 @@ -73,7 +73,7 @@ static ssize_t max_time_ms_show(struct device *dev,
    593 if (active_time > max_time)
    594 max_time = active_time;
    595 }
    596 - return sprintf(buf, "%lld\n", ktime_to_ms(max_time));
    597 + return sysfs_emit(buf, "%lld\n", ktime_to_ms(max_time));
    598 }
    599 static DEVICE_ATTR_RO(max_time_ms);
    600
    601 @@ -82,7 +82,7 @@ static ssize_t last_change_ms_show(struct device *dev,
    602 {
    603 struct wakeup_source *ws = dev_get_drvdata(dev);
    604
    605 - return sprintf(buf, "%lld\n", ktime_to_ms(ws->last_time));
    606 + return sysfs_emit(buf, "%lld\n", ktime_to_ms(ws->last_time));
    607 }
    608 static DEVICE_ATTR_RO(last_change_ms);
    609
    610 @@ -91,7 +91,7 @@ static ssize_t name_show(struct device *dev, struct device_attribute *attr,
    611 {
    612 struct wakeup_source *ws = dev_get_drvdata(dev);
    613
    614 - return sprintf(buf, "%s\n", ws->name);
    615 + return sysfs_emit(buf, "%s\n", ws->name);
    616 }
    617 static DEVICE_ATTR_RO(name);
    618
    619 @@ -106,7 +106,7 @@ static ssize_t prevent_suspend_time_ms_show(struct device *dev,
    620 prevent_sleep_time = ktime_add(prevent_sleep_time,
    621 ktime_sub(ktime_get(), ws->start_prevent_time));
    622 }
    623 - return sprintf(buf, "%lld\n", ktime_to_ms(prevent_sleep_time));
    624 + return sysfs_emit(buf, "%lld\n", ktime_to_ms(prevent_sleep_time));
    625 }
    626 static DEVICE_ATTR_RO(prevent_suspend_time_ms);
    627
    628 diff --git a/drivers/base/soc.c b/drivers/base/soc.c
    629 index 7c0c5ca5953d2..735f122c2ba31 100644
    630 --- a/drivers/base/soc.c
    631 +++ b/drivers/base/soc.c
    632 @@ -76,15 +76,15 @@ static ssize_t soc_info_get(struct device *dev,
    633 struct soc_device *soc_dev = container_of(dev, struct soc_device, dev);
    634
    635 if (attr == &dev_attr_machine)
    636 - return sprintf(buf, "%s\n", soc_dev->attr->machine);
    637 + return sysfs_emit(buf, "%s\n", soc_dev->attr->machine);
    638 if (attr == &dev_attr_family)
    639 - return sprintf(buf, "%s\n", soc_dev->attr->family);
    640 + return sysfs_emit(buf, "%s\n", soc_dev->attr->family);
    641 if (attr == &dev_attr_revision)
    642 - return sprintf(buf, "%s\n", soc_dev->attr->revision);
    643 + return sysfs_emit(buf, "%s\n", soc_dev->attr->revision);
    644 if (attr == &dev_attr_serial_number)
    645 - return sprintf(buf, "%s\n", soc_dev->attr->serial_number);
    646 + return sysfs_emit(buf, "%s\n", soc_dev->attr->serial_number);
    647 if (attr == &dev_attr_soc_id)
    648 - return sprintf(buf, "%s\n", soc_dev->attr->soc_id);
    649 + return sysfs_emit(buf, "%s\n", soc_dev->attr->soc_id);
    650
    651 return -EINVAL;
    652
    653 diff --git a/drivers/bluetooth/bfusb.c b/drivers/bluetooth/bfusb.c
    654 index 0e5954cac98e0..00d72f6d8e8e2 100644
    655 --- a/drivers/bluetooth/bfusb.c
    656 +++ b/drivers/bluetooth/bfusb.c
    657 @@ -629,6 +629,9 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
    658 data->bulk_out_ep = bulk_out_ep->desc.bEndpointAddress;
    659 data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);
    660
    661 + if (!data->bulk_pkt_size)
    662 + goto done;
    663 +
    664 rwlock_init(&data->lock);
    665
    666 data->reassembly = NULL;
    667 diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
    668 index 6d643651d69f7..c8f2b991e9cf7 100644
    669 --- a/drivers/bluetooth/btusb.c
    670 +++ b/drivers/bluetooth/btusb.c
    671 @@ -2568,6 +2568,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
    672 skb = bt_skb_alloc(HCI_WMT_MAX_EVENT_SIZE, GFP_ATOMIC);
    673 if (!skb) {
    674 hdev->stat.err_rx++;
    675 + kfree(urb->setup_packet);
    676 return;
    677 }
    678
    679 @@ -2588,6 +2589,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
    680 data->evt_skb = skb_clone(skb, GFP_ATOMIC);
    681 if (!data->evt_skb) {
    682 kfree_skb(skb);
    683 + kfree(urb->setup_packet);
    684 return;
    685 }
    686 }
    687 @@ -2596,6 +2598,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
    688 if (err < 0) {
    689 kfree_skb(data->evt_skb);
    690 data->evt_skb = NULL;
    691 + kfree(urb->setup_packet);
    692 return;
    693 }
    694
    695 @@ -2606,6 +2609,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
    696 wake_up_bit(&data->flags,
    697 BTUSB_TX_WAIT_VND_EVT);
    698 }
    699 + kfree(urb->setup_packet);
    700 return;
    701 } else if (urb->status == -ENOENT) {
    702 /* Avoid suspend failed when usb_kill_urb */
    703 @@ -2626,6 +2630,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb)
    704 usb_anchor_urb(urb, &data->ctrl_anchor);
    705 err = usb_submit_urb(urb, GFP_ATOMIC);
    706 if (err < 0) {
    707 + kfree(urb->setup_packet);
    708 /* -EPERM: urb is being killed;
    709 * -ENODEV: device got disconnected
    710 */
    711 diff --git a/drivers/char/random.c b/drivers/char/random.c
    712 index ffd61aadb7614..60b39af1279a4 100644
    713 --- a/drivers/char/random.c
    714 +++ b/drivers/char/random.c
    715 @@ -497,6 +497,7 @@ static struct crng_state primary_crng = {
    716 * its value (from 0->1->2).
    717 */
    718 static int crng_init = 0;
    719 +static bool crng_need_final_init = false;
    720 #define crng_ready() (likely(crng_init > 1))
    721 static int crng_init_cnt = 0;
    722 static unsigned long crng_global_init_time = 0;
    723 @@ -889,6 +890,38 @@ static void crng_initialize(struct crng_state *crng)
    724 crng->init_time = jiffies - CRNG_RESEED_INTERVAL - 1;
    725 }
    726
    727 +static void crng_finalize_init(struct crng_state *crng)
    728 +{
    729 + if (crng != &primary_crng || crng_init >= 2)
    730 + return;
    731 + if (!system_wq) {
    732 + /* We can't call numa_crng_init until we have workqueues,
    733 + * so mark this for processing later. */
    734 + crng_need_final_init = true;
    735 + return;
    736 + }
    737 +
    738 + invalidate_batched_entropy();
    739 + numa_crng_init();
    740 + crng_init = 2;
    741 + process_random_ready_list();
    742 + wake_up_interruptible(&crng_init_wait);
    743 + kill_fasync(&fasync, SIGIO, POLL_IN);
    744 + pr_notice("crng init done\n");
    745 + if (unseeded_warning.missed) {
    746 + pr_notice("random: %d get_random_xx warning(s) missed "
    747 + "due to ratelimiting\n",
    748 + unseeded_warning.missed);
    749 + unseeded_warning.missed = 0;
    750 + }
    751 + if (urandom_warning.missed) {
    752 + pr_notice("random: %d urandom warning(s) missed "
    753 + "due to ratelimiting\n",
    754 + urandom_warning.missed);
    755 + urandom_warning.missed = 0;
    756 + }
    757 +}
    758 +
    759 #ifdef CONFIG_NUMA
    760 static void do_numa_crng_init(struct work_struct *work)
    761 {
    762 @@ -904,8 +937,8 @@ static void do_numa_crng_init(struct work_struct *work)
    763 crng_initialize(crng);
    764 pool[i] = crng;
    765 }
    766 - mb();
    767 - if (cmpxchg(&crng_node_pool, NULL, pool)) {
    768 + /* pairs with READ_ONCE() in select_crng() */
    769 + if (cmpxchg_release(&crng_node_pool, NULL, pool) != NULL) {
    770 for_each_node(i)
    771 kfree(pool[i]);
    772 kfree(pool);
    773 @@ -918,8 +951,26 @@ static void numa_crng_init(void)
    774 {
    775 schedule_work(&numa_crng_init_work);
    776 }
    777 +
    778 +static struct crng_state *select_crng(void)
    779 +{
    780 + struct crng_state **pool;
    781 + int nid = numa_node_id();
    782 +
    783 + /* pairs with cmpxchg_release() in do_numa_crng_init() */
    784 + pool = READ_ONCE(crng_node_pool);
    785 + if (pool && pool[nid])
    786 + return pool[nid];
    787 +
    788 + return &primary_crng;
    789 +}
    790 #else
    791 static void numa_crng_init(void) {}
    792 +
    793 +static struct crng_state *select_crng(void)
    794 +{
    795 + return &primary_crng;
    796 +}
    797 #endif
    798
    799 /*
    800 @@ -1024,39 +1075,23 @@ static void crng_reseed(struct crng_state *crng, struct entropy_store *r)
    801 crng->state[i+4] ^= buf.key[i] ^ rv;
    802 }
    803 memzero_explicit(&buf, sizeof(buf));
    804 - crng->init_time = jiffies;
    805 + WRITE_ONCE(crng->init_time, jiffies);
    806 spin_unlock_irqrestore(&crng->lock, flags);
    807 - if (crng == &primary_crng && crng_init < 2) {
    808 - invalidate_batched_entropy();
    809 - numa_crng_init();
    810 - crng_init = 2;
    811 - process_random_ready_list();
    812 - wake_up_interruptible(&crng_init_wait);
    813 - pr_notice("random: crng init done\n");
    814 - if (unseeded_warning.missed) {
    815 - pr_notice("random: %d get_random_xx warning(s) missed "
    816 - "due to ratelimiting\n",
    817 - unseeded_warning.missed);
    818 - unseeded_warning.missed = 0;
    819 - }
    820 - if (urandom_warning.missed) {
    821 - pr_notice("random: %d urandom warning(s) missed "
    822 - "due to ratelimiting\n",
    823 - urandom_warning.missed);
    824 - urandom_warning.missed = 0;
    825 - }
    826 - }
    827 + crng_finalize_init(crng);
    828 }
    829
    830 static void _extract_crng(struct crng_state *crng,
    831 __u8 out[CHACHA_BLOCK_SIZE])
    832 {
    833 - unsigned long v, flags;
    834 + unsigned long v, flags, init_time;
    835
    836 - if (crng_ready() &&
    837 - (time_after(crng_global_init_time, crng->init_time) ||
    838 - time_after(jiffies, crng->init_time + CRNG_RESEED_INTERVAL)))
    839 - crng_reseed(crng, crng == &primary_crng ? &input_pool : NULL);
    840 + if (crng_ready()) {
    841 + init_time = READ_ONCE(crng->init_time);
    842 + if (time_after(READ_ONCE(crng_global_init_time), init_time) ||
    843 + time_after(jiffies, init_time + CRNG_RESEED_INTERVAL))
    844 + crng_reseed(crng, crng == &primary_crng ?
    845 + &input_pool : NULL);
    846 + }
    847 spin_lock_irqsave(&crng->lock, flags);
    848 if (arch_get_random_long(&v))
    849 crng->state[14] ^= v;
    850 @@ -1068,15 +1103,7 @@ static void _extract_crng(struct crng_state *crng,
    851
    852 static void extract_crng(__u8 out[CHACHA_BLOCK_SIZE])
    853 {
    854 - struct crng_state *crng = NULL;
    855 -
    856 -#ifdef CONFIG_NUMA
    857 - if (crng_node_pool)
    858 - crng = crng_node_pool[numa_node_id()];
    859 - if (crng == NULL)
    860 -#endif
    861 - crng = &primary_crng;
    862 - _extract_crng(crng, out);
    863 + _extract_crng(select_crng(), out);
    864 }
    865
    866 /*
    867 @@ -1105,15 +1132,7 @@ static void _crng_backtrack_protect(struct crng_state *crng,
    868
    869 static void crng_backtrack_protect(__u8 tmp[CHACHA_BLOCK_SIZE], int used)
    870 {
    871 - struct crng_state *crng = NULL;
    872 -
    873 -#ifdef CONFIG_NUMA
    874 - if (crng_node_pool)
    875 - crng = crng_node_pool[numa_node_id()];
    876 - if (crng == NULL)
    877 -#endif
    878 - crng = &primary_crng;
    879 - _crng_backtrack_protect(crng, tmp, used);
    880 + _crng_backtrack_protect(select_crng(), tmp, used);
    881 }
    882
    883 static ssize_t extract_crng_user(void __user *buf, size_t nbytes)
    884 @@ -1957,6 +1976,8 @@ int __init rand_initialize(void)
    885 {
    886 init_std_data(&input_pool);
    887 init_std_data(&blocking_pool);
    888 + if (crng_need_final_init)
    889 + crng_finalize_init(&primary_crng);
    890 crng_initialize(&primary_crng);
    891 crng_global_init_time = jiffies;
    892 if (ratelimit_disable) {
    893 @@ -2150,7 +2171,7 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
    894 if (crng_init < 2)
    895 return -ENODATA;
    896 crng_reseed(&primary_crng, &input_pool);
    897 - crng_global_init_time = jiffies - 1;
    898 + WRITE_ONCE(crng_global_init_time, jiffies - 1);
    899 return 0;
    900 default:
    901 return -EINVAL;
    902 @@ -2488,7 +2509,8 @@ void add_hwgenerator_randomness(const char *buffer, size_t count,
    903 * We'll be woken up again once below random_write_wakeup_thresh,
    904 * or when the calling thread is about to terminate.
    905 */
    906 - wait_event_interruptible(random_write_wait, kthread_should_stop() ||
    907 + wait_event_interruptible(random_write_wait,
    908 + !system_wq || kthread_should_stop() ||
    909 ENTROPY_BITS(&input_pool) <= random_write_wakeup_bits);
    910 mix_pool_bytes(poolp, buffer, count);
    911 credit_entropy_bits(poolp, entropy);
    912 diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
    913 index 91afeca0c6f82..e43a76b027a2a 100644
    914 --- a/drivers/gpu/drm/i915/intel_pm.c
    915 +++ b/drivers/gpu/drm/i915/intel_pm.c
    916 @@ -3017,9 +3017,9 @@ static void snb_wm_latency_quirk(struct drm_i915_private *dev_priv)
    917 * The BIOS provided WM memory latency values are often
    918 * inadequate for high resolution displays. Adjust them.
    919 */
    920 - changed = ilk_increase_wm_latency(dev_priv, dev_priv->wm.pri_latency, 12) |
    921 - ilk_increase_wm_latency(dev_priv, dev_priv->wm.spr_latency, 12) |
    922 - ilk_increase_wm_latency(dev_priv, dev_priv->wm.cur_latency, 12);
    923 + changed = ilk_increase_wm_latency(dev_priv, dev_priv->wm.pri_latency, 12);
    924 + changed |= ilk_increase_wm_latency(dev_priv, dev_priv->wm.spr_latency, 12);
    925 + changed |= ilk_increase_wm_latency(dev_priv, dev_priv->wm.cur_latency, 12);
    926
    927 if (!changed)
    928 return;
    929 diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
    930 index 378cfc46fc195..40ca1d4e03483 100644
    931 --- a/drivers/media/usb/uvc/uvc_driver.c
    932 +++ b/drivers/media/usb/uvc/uvc_driver.c
    933 @@ -1972,7 +1972,6 @@ int uvc_register_video_device(struct uvc_device *dev,
    934 const struct v4l2_file_operations *fops,
    935 const struct v4l2_ioctl_ops *ioctl_ops)
    936 {
    937 - const char *name;
    938 int ret;
    939
    940 /* Initialize the video buffers queue. */
    941 @@ -2001,20 +2000,16 @@ int uvc_register_video_device(struct uvc_device *dev,
    942 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
    943 default:
    944 vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
    945 - name = "Video Capture";
    946 break;
    947 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
    948 vdev->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
    949 - name = "Video Output";
    950 break;
    951 case V4L2_BUF_TYPE_META_CAPTURE:
    952 vdev->device_caps = V4L2_CAP_META_CAPTURE | V4L2_CAP_STREAMING;
    953 - name = "Metadata";
    954 break;
    955 }
    956
    957 - snprintf(vdev->name, sizeof(vdev->name), "%s %u", name,
    958 - stream->header.bTerminalLink);
    959 + strscpy(vdev->name, dev->name, sizeof(vdev->name));
    960
    961 /*
    962 * Set the driver data before calling video_register_device, otherwise
    963 diff --git a/drivers/mfd/intel-lpss-acpi.c b/drivers/mfd/intel-lpss-acpi.c
    964 index c8fe334b5fe8b..045cbf0cbe53a 100644
    965 --- a/drivers/mfd/intel-lpss-acpi.c
    966 +++ b/drivers/mfd/intel-lpss-acpi.c
    967 @@ -102,6 +102,7 @@ static int intel_lpss_acpi_probe(struct platform_device *pdev)
    968 {
    969 struct intel_lpss_platform_info *info;
    970 const struct acpi_device_id *id;
    971 + int ret;
    972
    973 id = acpi_match_device(intel_lpss_acpi_ids, &pdev->dev);
    974 if (!id)
    975 @@ -115,10 +116,14 @@ static int intel_lpss_acpi_probe(struct platform_device *pdev)
    976 info->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    977 info->irq = platform_get_irq(pdev, 0);
    978
    979 + ret = intel_lpss_probe(&pdev->dev, info);
    980 + if (ret)
    981 + return ret;
    982 +
    983 pm_runtime_set_active(&pdev->dev);
    984 pm_runtime_enable(&pdev->dev);
    985
    986 - return intel_lpss_probe(&pdev->dev, info);
    987 + return 0;
    988 }
    989
    990 static int intel_lpss_acpi_remove(struct platform_device *pdev)
    991 diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c
    992 index a9151bd27211a..1e19c0d0bca80 100644
    993 --- a/drivers/mmc/host/sdhci-pci-core.c
    994 +++ b/drivers/mmc/host/sdhci-pci-core.c
    995 @@ -1936,6 +1936,7 @@ static const struct pci_device_id pci_ids[] = {
    996 SDHCI_PCI_DEVICE(INTEL, JSL_SD, intel_byt_sd),
    997 SDHCI_PCI_DEVICE(INTEL, LKF_EMMC, intel_glk_emmc),
    998 SDHCI_PCI_DEVICE(INTEL, LKF_SD, intel_byt_sd),
    999 + SDHCI_PCI_DEVICE(INTEL, ADL_EMMC, intel_glk_emmc),
    1000 SDHCI_PCI_DEVICE(O2, 8120, o2),
    1001 SDHCI_PCI_DEVICE(O2, 8220, o2),
    1002 SDHCI_PCI_DEVICE(O2, 8221, o2),
    1003 diff --git a/drivers/mmc/host/sdhci-pci.h b/drivers/mmc/host/sdhci-pci.h
    1004 index 779156ce1ee17..b4ac314790b2c 100644
    1005 --- a/drivers/mmc/host/sdhci-pci.h
    1006 +++ b/drivers/mmc/host/sdhci-pci.h
    1007 @@ -59,6 +59,7 @@
    1008 #define PCI_DEVICE_ID_INTEL_JSL_SD 0x4df8
    1009 #define PCI_DEVICE_ID_INTEL_LKF_EMMC 0x98c4
    1010 #define PCI_DEVICE_ID_INTEL_LKF_SD 0x98f8
    1011 +#define PCI_DEVICE_ID_INTEL_ADL_EMMC 0x54c4
    1012
    1013 #define PCI_DEVICE_ID_SYSKONNECT_8000 0x8000
    1014 #define PCI_DEVICE_ID_VIA_95D0 0x95d0
    1015 diff --git a/drivers/net/can/usb/gs_usb.c b/drivers/net/can/usb/gs_usb.c
    1016 index 0ad13d78815c5..8b4c1bb77c334 100644
    1017 --- a/drivers/net/can/usb/gs_usb.c
    1018 +++ b/drivers/net/can/usb/gs_usb.c
    1019 @@ -320,7 +320,7 @@ static void gs_usb_receive_bulk_callback(struct urb *urb)
    1020
    1021 /* device reports out of range channel id */
    1022 if (hf->channel >= GS_MAX_INTF)
    1023 - goto resubmit_urb;
    1024 + goto device_detach;
    1025
    1026 dev = usbcan->canch[hf->channel];
    1027
    1028 @@ -405,6 +405,7 @@ static void gs_usb_receive_bulk_callback(struct urb *urb)
    1029
    1030 /* USB failure take down all interfaces */
    1031 if (rc == -ENODEV) {
    1032 + device_detach:
    1033 for (rc = 0; rc < GS_MAX_INTF; rc++) {
    1034 if (usbcan->canch[rc])
    1035 netif_device_detach(usbcan->canch[rc]->netdev);
    1036 @@ -506,6 +507,8 @@ static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb,
    1037
    1038 hf->echo_id = idx;
    1039 hf->channel = dev->channel;
    1040 + hf->flags = 0;
    1041 + hf->reserved = 0;
    1042
    1043 cf = (struct can_frame *)skb->data;
    1044
    1045 diff --git a/drivers/net/veth.c b/drivers/net/veth.c
    1046 index 44ad412f9a06f..81a79e7132483 100644
    1047 --- a/drivers/net/veth.c
    1048 +++ b/drivers/net/veth.c
    1049 @@ -254,7 +254,6 @@ static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
    1050 if (rxq < rcv->real_num_rx_queues) {
    1051 rq = &rcv_priv->rq[rxq];
    1052 rcv_xdp = rcu_access_pointer(rq->xdp_prog);
    1053 - skb_record_rx_queue(skb, rxq);
    1054 }
    1055
    1056 skb_tx_timestamp(skb);
    1057 diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c
    1058 index cc329b990e165..a8cfea957868a 100644
    1059 --- a/drivers/staging/greybus/audio_topology.c
    1060 +++ b/drivers/staging/greybus/audio_topology.c
    1061 @@ -983,6 +983,44 @@ static int gbaudio_widget_event(struct snd_soc_dapm_widget *w,
    1062 return ret;
    1063 }
    1064
    1065 +static const struct snd_soc_dapm_widget gbaudio_widgets[] = {
    1066 + [snd_soc_dapm_spk] = SND_SOC_DAPM_SPK(NULL, gbcodec_event_spk),
    1067 + [snd_soc_dapm_hp] = SND_SOC_DAPM_HP(NULL, gbcodec_event_hp),
    1068 + [snd_soc_dapm_mic] = SND_SOC_DAPM_MIC(NULL, gbcodec_event_int_mic),
    1069 + [snd_soc_dapm_output] = SND_SOC_DAPM_OUTPUT(NULL),
    1070 + [snd_soc_dapm_input] = SND_SOC_DAPM_INPUT(NULL),
    1071 + [snd_soc_dapm_switch] = SND_SOC_DAPM_SWITCH_E(NULL, SND_SOC_NOPM,
    1072 + 0, 0, NULL,
    1073 + gbaudio_widget_event,
    1074 + SND_SOC_DAPM_PRE_PMU |
    1075 + SND_SOC_DAPM_POST_PMD),
    1076 + [snd_soc_dapm_pga] = SND_SOC_DAPM_PGA_E(NULL, SND_SOC_NOPM,
    1077 + 0, 0, NULL, 0,
    1078 + gbaudio_widget_event,
    1079 + SND_SOC_DAPM_PRE_PMU |
    1080 + SND_SOC_DAPM_POST_PMD),
    1081 + [snd_soc_dapm_mixer] = SND_SOC_DAPM_MIXER_E(NULL, SND_SOC_NOPM,
    1082 + 0, 0, NULL, 0,
    1083 + gbaudio_widget_event,
    1084 + SND_SOC_DAPM_PRE_PMU |
    1085 + SND_SOC_DAPM_POST_PMD),
    1086 + [snd_soc_dapm_mux] = SND_SOC_DAPM_MUX_E(NULL, SND_SOC_NOPM,
    1087 + 0, 0, NULL,
    1088 + gbaudio_widget_event,
    1089 + SND_SOC_DAPM_PRE_PMU |
    1090 + SND_SOC_DAPM_POST_PMD),
    1091 + [snd_soc_dapm_aif_in] = SND_SOC_DAPM_AIF_IN_E(NULL, NULL, 0,
    1092 + SND_SOC_NOPM, 0, 0,
    1093 + gbaudio_widget_event,
    1094 + SND_SOC_DAPM_PRE_PMU |
    1095 + SND_SOC_DAPM_POST_PMD),
    1096 + [snd_soc_dapm_aif_out] = SND_SOC_DAPM_AIF_OUT_E(NULL, NULL, 0,
    1097 + SND_SOC_NOPM, 0, 0,
    1098 + gbaudio_widget_event,
    1099 + SND_SOC_DAPM_PRE_PMU |
    1100 + SND_SOC_DAPM_POST_PMD),
    1101 +};
    1102 +
    1103 static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module,
    1104 struct snd_soc_dapm_widget *dw,
    1105 struct gb_audio_widget *w, int *w_size)
    1106 @@ -1061,77 +1099,37 @@ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module,
    1107
    1108 switch (w->type) {
    1109 case snd_soc_dapm_spk:
    1110 - *dw = (struct snd_soc_dapm_widget)
    1111 - SND_SOC_DAPM_SPK(w->name, gbcodec_event_spk);
    1112 + *dw = gbaudio_widgets[w->type];
    1113 module->op_devices |= GBAUDIO_DEVICE_OUT_SPEAKER;
    1114 break;
    1115 case snd_soc_dapm_hp:
    1116 - *dw = (struct snd_soc_dapm_widget)
    1117 - SND_SOC_DAPM_HP(w->name, gbcodec_event_hp);
    1118 + *dw = gbaudio_widgets[w->type];
    1119 module->op_devices |= (GBAUDIO_DEVICE_OUT_WIRED_HEADSET
    1120 | GBAUDIO_DEVICE_OUT_WIRED_HEADPHONE);
    1121 module->ip_devices |= GBAUDIO_DEVICE_IN_WIRED_HEADSET;
    1122 break;
    1123 case snd_soc_dapm_mic:
    1124 - *dw = (struct snd_soc_dapm_widget)
    1125 - SND_SOC_DAPM_MIC(w->name, gbcodec_event_int_mic);
    1126 + *dw = gbaudio_widgets[w->type];
    1127 module->ip_devices |= GBAUDIO_DEVICE_IN_BUILTIN_MIC;
    1128 break;
    1129 case snd_soc_dapm_output:
    1130 - *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_OUTPUT(w->name);
    1131 - break;
    1132 case snd_soc_dapm_input:
    1133 - *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_INPUT(w->name);
    1134 - break;
    1135 case snd_soc_dapm_switch:
    1136 - *dw = (struct snd_soc_dapm_widget)
    1137 - SND_SOC_DAPM_SWITCH_E(w->name, SND_SOC_NOPM, 0, 0,
    1138 - widget_kctls,
    1139 - gbaudio_widget_event,
    1140 - SND_SOC_DAPM_PRE_PMU |
    1141 - SND_SOC_DAPM_POST_PMD);
    1142 - break;
    1143 case snd_soc_dapm_pga:
    1144 - *dw = (struct snd_soc_dapm_widget)
    1145 - SND_SOC_DAPM_PGA_E(w->name, SND_SOC_NOPM, 0, 0, NULL, 0,
    1146 - gbaudio_widget_event,
    1147 - SND_SOC_DAPM_PRE_PMU |
    1148 - SND_SOC_DAPM_POST_PMD);
    1149 - break;
    1150 case snd_soc_dapm_mixer:
    1151 - *dw = (struct snd_soc_dapm_widget)
    1152 - SND_SOC_DAPM_MIXER_E(w->name, SND_SOC_NOPM, 0, 0, NULL,
    1153 - 0, gbaudio_widget_event,
    1154 - SND_SOC_DAPM_PRE_PMU |
    1155 - SND_SOC_DAPM_POST_PMD);
    1156 - break;
    1157 case snd_soc_dapm_mux:
    1158 - *dw = (struct snd_soc_dapm_widget)
    1159 - SND_SOC_DAPM_MUX_E(w->name, SND_SOC_NOPM, 0, 0,
    1160 - widget_kctls, gbaudio_widget_event,
    1161 - SND_SOC_DAPM_PRE_PMU |
    1162 - SND_SOC_DAPM_POST_PMD);
    1163 + *dw = gbaudio_widgets[w->type];
    1164 break;
    1165 case snd_soc_dapm_aif_in:
    1166 - *dw = (struct snd_soc_dapm_widget)
    1167 - SND_SOC_DAPM_AIF_IN_E(w->name, w->sname, 0,
    1168 - SND_SOC_NOPM,
    1169 - 0, 0, gbaudio_widget_event,
    1170 - SND_SOC_DAPM_PRE_PMU |
    1171 - SND_SOC_DAPM_POST_PMD);
    1172 - break;
    1173 case snd_soc_dapm_aif_out:
    1174 - *dw = (struct snd_soc_dapm_widget)
    1175 - SND_SOC_DAPM_AIF_OUT_E(w->name, w->sname, 0,
    1176 - SND_SOC_NOPM,
    1177 - 0, 0, gbaudio_widget_event,
    1178 - SND_SOC_DAPM_PRE_PMU |
    1179 - SND_SOC_DAPM_POST_PMD);
    1180 + *dw = gbaudio_widgets[w->type];
    1181 + dw->sname = w->sname;
    1182 break;
    1183 default:
    1184 ret = -EINVAL;
    1185 goto error;
    1186 }
    1187 + dw->name = w->name;
    1188
    1189 dev_dbg(module->dev, "%s: widget of type %d created\n", dw->name,
    1190 dw->id);
    1191 diff --git a/drivers/staging/wlan-ng/hfa384x_usb.c b/drivers/staging/wlan-ng/hfa384x_usb.c
    1192 index ed4ff78dd02aa..71cca6e1dea46 100644
    1193 --- a/drivers/staging/wlan-ng/hfa384x_usb.c
    1194 +++ b/drivers/staging/wlan-ng/hfa384x_usb.c
    1195 @@ -3779,18 +3779,18 @@ static void hfa384x_usb_throttlefn(struct timer_list *t)
    1196
    1197 spin_lock_irqsave(&hw->ctlxq.lock, flags);
    1198
    1199 - /*
    1200 - * We need to check BOTH the RX and the TX throttle controls,
    1201 - * so we use the bitwise OR instead of the logical OR.
    1202 - */
    1203 pr_debug("flags=0x%lx\n", hw->usb_flags);
    1204 - if (!hw->wlandev->hwremoved &&
    1205 - ((test_and_clear_bit(THROTTLE_RX, &hw->usb_flags) &&
    1206 - !test_and_set_bit(WORK_RX_RESUME, &hw->usb_flags)) |
    1207 - (test_and_clear_bit(THROTTLE_TX, &hw->usb_flags) &&
    1208 - !test_and_set_bit(WORK_TX_RESUME, &hw->usb_flags))
    1209 - )) {
    1210 - schedule_work(&hw->usb_work);
    1211 + if (!hw->wlandev->hwremoved) {
    1212 + bool rx_throttle = test_and_clear_bit(THROTTLE_RX, &hw->usb_flags) &&
    1213 + !test_and_set_bit(WORK_RX_RESUME, &hw->usb_flags);
    1214 + bool tx_throttle = test_and_clear_bit(THROTTLE_TX, &hw->usb_flags) &&
    1215 + !test_and_set_bit(WORK_TX_RESUME, &hw->usb_flags);
    1216 + /*
    1217 + * We need to check BOTH the RX and the TX throttle controls,
    1218 + * so we use the bitwise OR instead of the logical OR.
    1219 + */
    1220 + if (rx_throttle | tx_throttle)
    1221 + schedule_work(&hw->usb_work);
    1222 }
    1223
    1224 spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
    1225 diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
    1226 index d0f45600b6698..fe9b392bffee3 100644
    1227 --- a/drivers/usb/core/hcd.c
    1228 +++ b/drivers/usb/core/hcd.c
    1229 @@ -753,6 +753,7 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
    1230 {
    1231 struct urb *urb;
    1232 int length;
    1233 + int status;
    1234 unsigned long flags;
    1235 char buffer[6]; /* Any root hubs with > 31 ports? */
    1236
    1237 @@ -770,11 +771,17 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
    1238 if (urb) {
    1239 clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
    1240 hcd->status_urb = NULL;
    1241 + if (urb->transfer_buffer_length >= length) {
    1242 + status = 0;
    1243 + } else {
    1244 + status = -EOVERFLOW;
    1245 + length = urb->transfer_buffer_length;
    1246 + }
    1247 urb->actual_length = length;
    1248 memcpy(urb->transfer_buffer, buffer, length);
    1249
    1250 usb_hcd_unlink_urb_from_ep(hcd, urb);
    1251 - usb_hcd_giveback_urb(hcd, urb, 0);
    1252 + usb_hcd_giveback_urb(hcd, urb, status);
    1253 } else {
    1254 length = 0;
    1255 set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
    1256 diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
    1257 index d7ab2e88631a0..69dd48f9507e5 100644
    1258 --- a/drivers/usb/core/hub.c
    1259 +++ b/drivers/usb/core/hub.c
    1260 @@ -1223,7 +1223,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
    1261 */
    1262 if (portchange || (hub_is_superspeed(hub->hdev) &&
    1263 port_resumed))
    1264 - set_bit(port1, hub->change_bits);
    1265 + set_bit(port1, hub->event_bits);
    1266
    1267 } else if (udev->persist_enabled) {
    1268 #ifdef CONFIG_PM
    1269 diff --git a/kernel/workqueue.c b/kernel/workqueue.c
    1270 index 77e6964ae1a99..e90f37e22202a 100644
    1271 --- a/kernel/workqueue.c
    1272 +++ b/kernel/workqueue.c
    1273 @@ -855,8 +855,17 @@ void wq_worker_running(struct task_struct *task)
    1274
    1275 if (!worker->sleeping)
    1276 return;
    1277 +
    1278 + /*
    1279 + * If preempted by unbind_workers() between the WORKER_NOT_RUNNING check
    1280 + * and the nr_running increment below, we may ruin the nr_running reset
    1281 + * and leave with an unexpected pool->nr_running == 1 on the newly unbound
    1282 + * pool. Protect against such race.
    1283 + */
    1284 + preempt_disable();
    1285 if (!(worker->flags & WORKER_NOT_RUNNING))
    1286 atomic_inc(&worker->pool->nr_running);
    1287 + preempt_enable();
    1288 worker->sleeping = 0;
    1289 }
    1290