Annotation of /trunk/kernel-alx/patches-5.4/0271-5.4.172-all-fixes.patch
Parent Directory | Revision Log
Revision 3637 -
(hide annotations)
(download)
Mon Oct 24 12:40:44 2022 UTC (18 months, 3 weeks ago) by niro
File size: 44096 byte(s)
Mon Oct 24 12:40:44 2022 UTC (18 months, 3 weeks ago) by niro
File size: 44096 byte(s)
-add missing
1 | niro | 3637 | 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 |