1 |
commit: dd4931786451e78297909a9b991c25020953d0fd |
2 |
Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> |
3 |
AuthorDate: Sun Jan 16 10:21:45 2022 +0000 |
4 |
Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> |
5 |
CommitDate: Sun Jan 16 10:21:45 2022 +0000 |
6 |
URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=dd493178 |
7 |
|
8 |
Linux patch 5.10.92 |
9 |
|
10 |
Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> |
11 |
|
12 |
0000_README | 4 + |
13 |
1091_linux-5.10.92.patch | 873 +++++++++++++++++++++++++++++++++++++++++++++++ |
14 |
2 files changed, 877 insertions(+) |
15 |
|
16 |
diff --git a/0000_README b/0000_README |
17 |
index 9e878b9b..6d8b55d4 100644 |
18 |
--- a/0000_README |
19 |
+++ b/0000_README |
20 |
@@ -407,6 +407,10 @@ Patch: 1090_linux-5.10.91.patch |
21 |
From: http://www.kernel.org |
22 |
Desc: Linux 5.10.91 |
23 |
|
24 |
+Patch: 1091_linux-5.10.92.patch |
25 |
+From: http://www.kernel.org |
26 |
+Desc: Linux 5.10.92 |
27 |
+ |
28 |
Patch: 1500_XATTR_USER_PREFIX.patch |
29 |
From: https://bugs.gentoo.org/show_bug.cgi?id=470644 |
30 |
Desc: Support for namespace user.pax.* on tmpfs. |
31 |
|
32 |
diff --git a/1091_linux-5.10.92.patch b/1091_linux-5.10.92.patch |
33 |
new file mode 100644 |
34 |
index 00000000..ea857dbe |
35 |
--- /dev/null |
36 |
+++ b/1091_linux-5.10.92.patch |
37 |
@@ -0,0 +1,873 @@ |
38 |
+diff --git a/Makefile b/Makefile |
39 |
+index c8d677c7eaa11..a113a29545bdb 100644 |
40 |
+--- a/Makefile |
41 |
++++ b/Makefile |
42 |
+@@ -1,7 +1,7 @@ |
43 |
+ # SPDX-License-Identifier: GPL-2.0 |
44 |
+ VERSION = 5 |
45 |
+ PATCHLEVEL = 10 |
46 |
+-SUBLEVEL = 91 |
47 |
++SUBLEVEL = 92 |
48 |
+ EXTRAVERSION = |
49 |
+ NAME = Dare mighty things |
50 |
+ |
51 |
+diff --git a/arch/arm/boot/dts/exynos4210-i9100.dts b/arch/arm/boot/dts/exynos4210-i9100.dts |
52 |
+index 7777bf51a6e64..ecc9d4dc707e4 100644 |
53 |
+--- a/arch/arm/boot/dts/exynos4210-i9100.dts |
54 |
++++ b/arch/arm/boot/dts/exynos4210-i9100.dts |
55 |
+@@ -765,7 +765,7 @@ |
56 |
+ compatible = "brcm,bcm4330-bt"; |
57 |
+ |
58 |
+ shutdown-gpios = <&gpl0 4 GPIO_ACTIVE_HIGH>; |
59 |
+- reset-gpios = <&gpl1 0 GPIO_ACTIVE_HIGH>; |
60 |
++ reset-gpios = <&gpl1 0 GPIO_ACTIVE_LOW>; |
61 |
+ device-wakeup-gpios = <&gpx3 1 GPIO_ACTIVE_HIGH>; |
62 |
+ host-wakeup-gpios = <&gpx2 6 GPIO_ACTIVE_HIGH>; |
63 |
+ }; |
64 |
+diff --git a/drivers/bluetooth/bfusb.c b/drivers/bluetooth/bfusb.c |
65 |
+index 5a321b4076aab..cab93935cc7f1 100644 |
66 |
+--- a/drivers/bluetooth/bfusb.c |
67 |
++++ b/drivers/bluetooth/bfusb.c |
68 |
+@@ -628,6 +628,9 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i |
69 |
+ data->bulk_out_ep = bulk_out_ep->desc.bEndpointAddress; |
70 |
+ data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize); |
71 |
+ |
72 |
++ if (!data->bulk_pkt_size) |
73 |
++ goto done; |
74 |
++ |
75 |
+ rwlock_init(&data->lock); |
76 |
+ |
77 |
+ data->reassembly = NULL; |
78 |
+diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c |
79 |
+index e0859f4e28073..538232b4c42ac 100644 |
80 |
+--- a/drivers/bluetooth/btusb.c |
81 |
++++ b/drivers/bluetooth/btusb.c |
82 |
+@@ -379,6 +379,15 @@ static const struct usb_device_id blacklist_table[] = { |
83 |
+ { USB_DEVICE(0x8087, 0x0aaa), .driver_info = BTUSB_INTEL_NEW | |
84 |
+ BTUSB_WIDEBAND_SPEECH | |
85 |
+ BTUSB_VALID_LE_STATES }, |
86 |
++ { USB_DEVICE(0x10ab, 0x9309), .driver_info = BTUSB_QCA_WCN6855 | |
87 |
++ BTUSB_WIDEBAND_SPEECH | |
88 |
++ BTUSB_VALID_LE_STATES }, |
89 |
++ { USB_DEVICE(0x10ab, 0x9409), .driver_info = BTUSB_QCA_WCN6855 | |
90 |
++ BTUSB_WIDEBAND_SPEECH | |
91 |
++ BTUSB_VALID_LE_STATES }, |
92 |
++ { USB_DEVICE(0x0489, 0xe0d0), .driver_info = BTUSB_QCA_WCN6855 | |
93 |
++ BTUSB_WIDEBAND_SPEECH | |
94 |
++ BTUSB_VALID_LE_STATES }, |
95 |
+ |
96 |
+ /* Other Intel Bluetooth devices */ |
97 |
+ { USB_VENDOR_AND_INTERFACE_INFO(0x8087, 0xe0, 0x01, 0x01), |
98 |
+@@ -400,6 +409,14 @@ static const struct usb_device_id blacklist_table[] = { |
99 |
+ BTUSB_WIDEBAND_SPEECH | |
100 |
+ BTUSB_VALID_LE_STATES }, |
101 |
+ |
102 |
++ /* MediaTek MT7922A Bluetooth devices */ |
103 |
++ { USB_DEVICE(0x0489, 0xe0d8), .driver_info = BTUSB_MEDIATEK | |
104 |
++ BTUSB_WIDEBAND_SPEECH | |
105 |
++ BTUSB_VALID_LE_STATES }, |
106 |
++ { USB_DEVICE(0x0489, 0xe0d9), .driver_info = BTUSB_MEDIATEK | |
107 |
++ BTUSB_WIDEBAND_SPEECH | |
108 |
++ BTUSB_VALID_LE_STATES }, |
109 |
++ |
110 |
+ /* Additional Realtek 8723AE Bluetooth devices */ |
111 |
+ { USB_DEVICE(0x0930, 0x021d), .driver_info = BTUSB_REALTEK }, |
112 |
+ { USB_DEVICE(0x13d3, 0x3394), .driver_info = BTUSB_REALTEK }, |
113 |
+@@ -2845,6 +2862,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb) |
114 |
+ skb = bt_skb_alloc(HCI_WMT_MAX_EVENT_SIZE, GFP_ATOMIC); |
115 |
+ if (!skb) { |
116 |
+ hdev->stat.err_rx++; |
117 |
++ kfree(urb->setup_packet); |
118 |
+ return; |
119 |
+ } |
120 |
+ |
121 |
+@@ -2865,6 +2883,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb) |
122 |
+ data->evt_skb = skb_clone(skb, GFP_ATOMIC); |
123 |
+ if (!data->evt_skb) { |
124 |
+ kfree_skb(skb); |
125 |
++ kfree(urb->setup_packet); |
126 |
+ return; |
127 |
+ } |
128 |
+ } |
129 |
+@@ -2873,6 +2892,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb) |
130 |
+ if (err < 0) { |
131 |
+ kfree_skb(data->evt_skb); |
132 |
+ data->evt_skb = NULL; |
133 |
++ kfree(urb->setup_packet); |
134 |
+ return; |
135 |
+ } |
136 |
+ |
137 |
+@@ -2883,6 +2903,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb) |
138 |
+ wake_up_bit(&data->flags, |
139 |
+ BTUSB_TX_WAIT_VND_EVT); |
140 |
+ } |
141 |
++ kfree(urb->setup_packet); |
142 |
+ return; |
143 |
+ } else if (urb->status == -ENOENT) { |
144 |
+ /* Avoid suspend failed when usb_kill_urb */ |
145 |
+@@ -2903,6 +2924,7 @@ static void btusb_mtk_wmt_recv(struct urb *urb) |
146 |
+ usb_anchor_urb(urb, &data->ctrl_anchor); |
147 |
+ err = usb_submit_urb(urb, GFP_ATOMIC); |
148 |
+ if (err < 0) { |
149 |
++ kfree(urb->setup_packet); |
150 |
+ /* -EPERM: urb is being killed; |
151 |
+ * -ENODEV: device got disconnected |
152 |
+ */ |
153 |
+diff --git a/drivers/char/random.c b/drivers/char/random.c |
154 |
+index 340ad21491e28..8c94380e7a463 100644 |
155 |
+--- a/drivers/char/random.c |
156 |
++++ b/drivers/char/random.c |
157 |
+@@ -461,6 +461,7 @@ static struct crng_state primary_crng = { |
158 |
+ * its value (from 0->1->2). |
159 |
+ */ |
160 |
+ static int crng_init = 0; |
161 |
++static bool crng_need_final_init = false; |
162 |
+ #define crng_ready() (likely(crng_init > 1)) |
163 |
+ static int crng_init_cnt = 0; |
164 |
+ static unsigned long crng_global_init_time = 0; |
165 |
+@@ -838,6 +839,36 @@ static void __init crng_initialize_primary(struct crng_state *crng) |
166 |
+ crng->init_time = jiffies - CRNG_RESEED_INTERVAL - 1; |
167 |
+ } |
168 |
+ |
169 |
++static void crng_finalize_init(struct crng_state *crng) |
170 |
++{ |
171 |
++ if (crng != &primary_crng || crng_init >= 2) |
172 |
++ return; |
173 |
++ if (!system_wq) { |
174 |
++ /* We can't call numa_crng_init until we have workqueues, |
175 |
++ * so mark this for processing later. */ |
176 |
++ crng_need_final_init = true; |
177 |
++ return; |
178 |
++ } |
179 |
++ |
180 |
++ invalidate_batched_entropy(); |
181 |
++ numa_crng_init(); |
182 |
++ crng_init = 2; |
183 |
++ process_random_ready_list(); |
184 |
++ wake_up_interruptible(&crng_init_wait); |
185 |
++ kill_fasync(&fasync, SIGIO, POLL_IN); |
186 |
++ pr_notice("crng init done\n"); |
187 |
++ if (unseeded_warning.missed) { |
188 |
++ pr_notice("%d get_random_xx warning(s) missed due to ratelimiting\n", |
189 |
++ unseeded_warning.missed); |
190 |
++ unseeded_warning.missed = 0; |
191 |
++ } |
192 |
++ if (urandom_warning.missed) { |
193 |
++ pr_notice("%d urandom warning(s) missed due to ratelimiting\n", |
194 |
++ urandom_warning.missed); |
195 |
++ urandom_warning.missed = 0; |
196 |
++ } |
197 |
++} |
198 |
++ |
199 |
+ #ifdef CONFIG_NUMA |
200 |
+ static void do_numa_crng_init(struct work_struct *work) |
201 |
+ { |
202 |
+@@ -853,8 +884,8 @@ static void do_numa_crng_init(struct work_struct *work) |
203 |
+ crng_initialize_secondary(crng); |
204 |
+ pool[i] = crng; |
205 |
+ } |
206 |
+- mb(); |
207 |
+- if (cmpxchg(&crng_node_pool, NULL, pool)) { |
208 |
++ /* pairs with READ_ONCE() in select_crng() */ |
209 |
++ if (cmpxchg_release(&crng_node_pool, NULL, pool) != NULL) { |
210 |
+ for_each_node(i) |
211 |
+ kfree(pool[i]); |
212 |
+ kfree(pool); |
213 |
+@@ -867,8 +898,26 @@ static void numa_crng_init(void) |
214 |
+ { |
215 |
+ schedule_work(&numa_crng_init_work); |
216 |
+ } |
217 |
++ |
218 |
++static struct crng_state *select_crng(void) |
219 |
++{ |
220 |
++ struct crng_state **pool; |
221 |
++ int nid = numa_node_id(); |
222 |
++ |
223 |
++ /* pairs with cmpxchg_release() in do_numa_crng_init() */ |
224 |
++ pool = READ_ONCE(crng_node_pool); |
225 |
++ if (pool && pool[nid]) |
226 |
++ return pool[nid]; |
227 |
++ |
228 |
++ return &primary_crng; |
229 |
++} |
230 |
+ #else |
231 |
+ static void numa_crng_init(void) {} |
232 |
++ |
233 |
++static struct crng_state *select_crng(void) |
234 |
++{ |
235 |
++ return &primary_crng; |
236 |
++} |
237 |
+ #endif |
238 |
+ |
239 |
+ /* |
240 |
+@@ -972,38 +1021,23 @@ static void crng_reseed(struct crng_state *crng, struct entropy_store *r) |
241 |
+ crng->state[i+4] ^= buf.key[i] ^ rv; |
242 |
+ } |
243 |
+ memzero_explicit(&buf, sizeof(buf)); |
244 |
+- crng->init_time = jiffies; |
245 |
++ WRITE_ONCE(crng->init_time, jiffies); |
246 |
+ spin_unlock_irqrestore(&crng->lock, flags); |
247 |
+- if (crng == &primary_crng && crng_init < 2) { |
248 |
+- invalidate_batched_entropy(); |
249 |
+- numa_crng_init(); |
250 |
+- crng_init = 2; |
251 |
+- process_random_ready_list(); |
252 |
+- wake_up_interruptible(&crng_init_wait); |
253 |
+- kill_fasync(&fasync, SIGIO, POLL_IN); |
254 |
+- pr_notice("crng init done\n"); |
255 |
+- if (unseeded_warning.missed) { |
256 |
+- pr_notice("%d get_random_xx warning(s) missed due to ratelimiting\n", |
257 |
+- unseeded_warning.missed); |
258 |
+- unseeded_warning.missed = 0; |
259 |
+- } |
260 |
+- if (urandom_warning.missed) { |
261 |
+- pr_notice("%d urandom warning(s) missed due to ratelimiting\n", |
262 |
+- urandom_warning.missed); |
263 |
+- urandom_warning.missed = 0; |
264 |
+- } |
265 |
+- } |
266 |
++ crng_finalize_init(crng); |
267 |
+ } |
268 |
+ |
269 |
+ static void _extract_crng(struct crng_state *crng, |
270 |
+ __u8 out[CHACHA_BLOCK_SIZE]) |
271 |
+ { |
272 |
+- unsigned long v, flags; |
273 |
+- |
274 |
+- if (crng_ready() && |
275 |
+- (time_after(crng_global_init_time, crng->init_time) || |
276 |
+- time_after(jiffies, crng->init_time + CRNG_RESEED_INTERVAL))) |
277 |
+- crng_reseed(crng, crng == &primary_crng ? &input_pool : NULL); |
278 |
++ unsigned long v, flags, init_time; |
279 |
++ |
280 |
++ if (crng_ready()) { |
281 |
++ init_time = READ_ONCE(crng->init_time); |
282 |
++ if (time_after(READ_ONCE(crng_global_init_time), init_time) || |
283 |
++ time_after(jiffies, init_time + CRNG_RESEED_INTERVAL)) |
284 |
++ crng_reseed(crng, crng == &primary_crng ? |
285 |
++ &input_pool : NULL); |
286 |
++ } |
287 |
+ spin_lock_irqsave(&crng->lock, flags); |
288 |
+ if (arch_get_random_long(&v)) |
289 |
+ crng->state[14] ^= v; |
290 |
+@@ -1015,15 +1049,7 @@ static void _extract_crng(struct crng_state *crng, |
291 |
+ |
292 |
+ static void extract_crng(__u8 out[CHACHA_BLOCK_SIZE]) |
293 |
+ { |
294 |
+- struct crng_state *crng = NULL; |
295 |
+- |
296 |
+-#ifdef CONFIG_NUMA |
297 |
+- if (crng_node_pool) |
298 |
+- crng = crng_node_pool[numa_node_id()]; |
299 |
+- if (crng == NULL) |
300 |
+-#endif |
301 |
+- crng = &primary_crng; |
302 |
+- _extract_crng(crng, out); |
303 |
++ _extract_crng(select_crng(), out); |
304 |
+ } |
305 |
+ |
306 |
+ /* |
307 |
+@@ -1052,15 +1078,7 @@ static void _crng_backtrack_protect(struct crng_state *crng, |
308 |
+ |
309 |
+ static void crng_backtrack_protect(__u8 tmp[CHACHA_BLOCK_SIZE], int used) |
310 |
+ { |
311 |
+- struct crng_state *crng = NULL; |
312 |
+- |
313 |
+-#ifdef CONFIG_NUMA |
314 |
+- if (crng_node_pool) |
315 |
+- crng = crng_node_pool[numa_node_id()]; |
316 |
+- if (crng == NULL) |
317 |
+-#endif |
318 |
+- crng = &primary_crng; |
319 |
+- _crng_backtrack_protect(crng, tmp, used); |
320 |
++ _crng_backtrack_protect(select_crng(), tmp, used); |
321 |
+ } |
322 |
+ |
323 |
+ static ssize_t extract_crng_user(void __user *buf, size_t nbytes) |
324 |
+@@ -1799,6 +1817,8 @@ static void __init init_std_data(struct entropy_store *r) |
325 |
+ int __init rand_initialize(void) |
326 |
+ { |
327 |
+ init_std_data(&input_pool); |
328 |
++ if (crng_need_final_init) |
329 |
++ crng_finalize_init(&primary_crng); |
330 |
+ crng_initialize_primary(&primary_crng); |
331 |
+ crng_global_init_time = jiffies; |
332 |
+ if (ratelimit_disable) { |
333 |
+@@ -1973,7 +1993,7 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg) |
334 |
+ if (crng_init < 2) |
335 |
+ return -ENODATA; |
336 |
+ crng_reseed(&primary_crng, &input_pool); |
337 |
+- crng_global_init_time = jiffies - 1; |
338 |
++ WRITE_ONCE(crng_global_init_time, jiffies - 1); |
339 |
+ return 0; |
340 |
+ default: |
341 |
+ return -EINVAL; |
342 |
+@@ -2307,7 +2327,8 @@ void add_hwgenerator_randomness(const char *buffer, size_t count, |
343 |
+ * We'll be woken up again once below random_write_wakeup_thresh, |
344 |
+ * or when the calling thread is about to terminate. |
345 |
+ */ |
346 |
+- wait_event_interruptible(random_write_wait, kthread_should_stop() || |
347 |
++ wait_event_interruptible(random_write_wait, |
348 |
++ !system_wq || kthread_should_stop() || |
349 |
+ ENTROPY_BITS(&input_pool) <= random_write_wakeup_bits); |
350 |
+ mix_pool_bytes(poolp, buffer, count); |
351 |
+ credit_entropy_bits(poolp, entropy); |
352 |
+diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c |
353 |
+index 1f23cb6ece588..e51ca7ca0a2a7 100644 |
354 |
+--- a/drivers/gpu/drm/i915/intel_pm.c |
355 |
++++ b/drivers/gpu/drm/i915/intel_pm.c |
356 |
+@@ -3044,9 +3044,9 @@ static void snb_wm_latency_quirk(struct drm_i915_private *dev_priv) |
357 |
+ * The BIOS provided WM memory latency values are often |
358 |
+ * inadequate for high resolution displays. Adjust them. |
359 |
+ */ |
360 |
+- changed = ilk_increase_wm_latency(dev_priv, dev_priv->wm.pri_latency, 12) | |
361 |
+- ilk_increase_wm_latency(dev_priv, dev_priv->wm.spr_latency, 12) | |
362 |
+- ilk_increase_wm_latency(dev_priv, dev_priv->wm.cur_latency, 12); |
363 |
++ changed = ilk_increase_wm_latency(dev_priv, dev_priv->wm.pri_latency, 12); |
364 |
++ changed |= ilk_increase_wm_latency(dev_priv, dev_priv->wm.spr_latency, 12); |
365 |
++ changed |= ilk_increase_wm_latency(dev_priv, dev_priv->wm.cur_latency, 12); |
366 |
+ |
367 |
+ if (!changed) |
368 |
+ return; |
369 |
+diff --git a/drivers/md/md.c b/drivers/md/md.c |
370 |
+index 2069b16b50eca..cc3876500c4b2 100644 |
371 |
+--- a/drivers/md/md.c |
372 |
++++ b/drivers/md/md.c |
373 |
+@@ -459,34 +459,12 @@ check_suspended: |
374 |
+ } |
375 |
+ EXPORT_SYMBOL(md_handle_request); |
376 |
+ |
377 |
+-struct md_io { |
378 |
+- struct mddev *mddev; |
379 |
+- bio_end_io_t *orig_bi_end_io; |
380 |
+- void *orig_bi_private; |
381 |
+- unsigned long start_time; |
382 |
+- struct hd_struct *part; |
383 |
+-}; |
384 |
+- |
385 |
+-static void md_end_io(struct bio *bio) |
386 |
+-{ |
387 |
+- struct md_io *md_io = bio->bi_private; |
388 |
+- struct mddev *mddev = md_io->mddev; |
389 |
+- |
390 |
+- part_end_io_acct(md_io->part, bio, md_io->start_time); |
391 |
+- |
392 |
+- bio->bi_end_io = md_io->orig_bi_end_io; |
393 |
+- bio->bi_private = md_io->orig_bi_private; |
394 |
+- |
395 |
+- mempool_free(md_io, &mddev->md_io_pool); |
396 |
+- |
397 |
+- if (bio->bi_end_io) |
398 |
+- bio->bi_end_io(bio); |
399 |
+-} |
400 |
+- |
401 |
+ static blk_qc_t md_submit_bio(struct bio *bio) |
402 |
+ { |
403 |
+ const int rw = bio_data_dir(bio); |
404 |
++ const int sgrp = op_stat_group(bio_op(bio)); |
405 |
+ struct mddev *mddev = bio->bi_disk->private_data; |
406 |
++ unsigned int sectors; |
407 |
+ |
408 |
+ if (mddev == NULL || mddev->pers == NULL) { |
409 |
+ bio_io_error(bio); |
410 |
+@@ -507,26 +485,21 @@ static blk_qc_t md_submit_bio(struct bio *bio) |
411 |
+ return BLK_QC_T_NONE; |
412 |
+ } |
413 |
+ |
414 |
+- if (bio->bi_end_io != md_end_io) { |
415 |
+- struct md_io *md_io; |
416 |
+- |
417 |
+- md_io = mempool_alloc(&mddev->md_io_pool, GFP_NOIO); |
418 |
+- md_io->mddev = mddev; |
419 |
+- md_io->orig_bi_end_io = bio->bi_end_io; |
420 |
+- md_io->orig_bi_private = bio->bi_private; |
421 |
+- |
422 |
+- bio->bi_end_io = md_end_io; |
423 |
+- bio->bi_private = md_io; |
424 |
+- |
425 |
+- md_io->start_time = part_start_io_acct(mddev->gendisk, |
426 |
+- &md_io->part, bio); |
427 |
+- } |
428 |
+- |
429 |
++ /* |
430 |
++ * save the sectors now since our bio can |
431 |
++ * go away inside make_request |
432 |
++ */ |
433 |
++ sectors = bio_sectors(bio); |
434 |
+ /* bio could be mergeable after passing to underlayer */ |
435 |
+ bio->bi_opf &= ~REQ_NOMERGE; |
436 |
+ |
437 |
+ md_handle_request(mddev, bio); |
438 |
+ |
439 |
++ part_stat_lock(); |
440 |
++ part_stat_inc(&mddev->gendisk->part0, ios[sgrp]); |
441 |
++ part_stat_add(&mddev->gendisk->part0, sectors[sgrp], sectors); |
442 |
++ part_stat_unlock(); |
443 |
++ |
444 |
+ return BLK_QC_T_NONE; |
445 |
+ } |
446 |
+ |
447 |
+@@ -5636,7 +5609,6 @@ static void md_free(struct kobject *ko) |
448 |
+ |
449 |
+ bioset_exit(&mddev->bio_set); |
450 |
+ bioset_exit(&mddev->sync_set); |
451 |
+- mempool_exit(&mddev->md_io_pool); |
452 |
+ kfree(mddev); |
453 |
+ } |
454 |
+ |
455 |
+@@ -5732,11 +5704,6 @@ static int md_alloc(dev_t dev, char *name) |
456 |
+ */ |
457 |
+ mddev->hold_active = UNTIL_STOP; |
458 |
+ |
459 |
+- error = mempool_init_kmalloc_pool(&mddev->md_io_pool, BIO_POOL_SIZE, |
460 |
+- sizeof(struct md_io)); |
461 |
+- if (error) |
462 |
+- goto abort; |
463 |
+- |
464 |
+ error = -ENOMEM; |
465 |
+ mddev->queue = blk_alloc_queue(NUMA_NO_NODE); |
466 |
+ if (!mddev->queue) |
467 |
+diff --git a/drivers/md/md.h b/drivers/md/md.h |
468 |
+index 2175a5ac4f7c6..c94811cf26004 100644 |
469 |
+--- a/drivers/md/md.h |
470 |
++++ b/drivers/md/md.h |
471 |
+@@ -487,7 +487,6 @@ struct mddev { |
472 |
+ struct bio_set sync_set; /* for sync operations like |
473 |
+ * metadata and bitmap writes |
474 |
+ */ |
475 |
+- mempool_t md_io_pool; |
476 |
+ |
477 |
+ /* Generic flush handling. |
478 |
+ * The last to finish preflush schedules a worker to submit |
479 |
+diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c |
480 |
+index 447b6a198926e..282f3d2388cc2 100644 |
481 |
+--- a/drivers/media/usb/uvc/uvc_driver.c |
482 |
++++ b/drivers/media/usb/uvc/uvc_driver.c |
483 |
+@@ -2065,7 +2065,6 @@ int uvc_register_video_device(struct uvc_device *dev, |
484 |
+ const struct v4l2_file_operations *fops, |
485 |
+ const struct v4l2_ioctl_ops *ioctl_ops) |
486 |
+ { |
487 |
+- const char *name; |
488 |
+ int ret; |
489 |
+ |
490 |
+ /* Initialize the video buffers queue. */ |
491 |
+@@ -2094,20 +2093,16 @@ int uvc_register_video_device(struct uvc_device *dev, |
492 |
+ case V4L2_BUF_TYPE_VIDEO_CAPTURE: |
493 |
+ default: |
494 |
+ vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; |
495 |
+- name = "Video Capture"; |
496 |
+ break; |
497 |
+ case V4L2_BUF_TYPE_VIDEO_OUTPUT: |
498 |
+ vdev->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING; |
499 |
+- name = "Video Output"; |
500 |
+ break; |
501 |
+ case V4L2_BUF_TYPE_META_CAPTURE: |
502 |
+ vdev->device_caps = V4L2_CAP_META_CAPTURE | V4L2_CAP_STREAMING; |
503 |
+- name = "Metadata"; |
504 |
+ break; |
505 |
+ } |
506 |
+ |
507 |
+- snprintf(vdev->name, sizeof(vdev->name), "%s %u", name, |
508 |
+- stream->header.bTerminalLink); |
509 |
++ strscpy(vdev->name, dev->name, sizeof(vdev->name)); |
510 |
+ |
511 |
+ /* |
512 |
+ * Set the driver data before calling video_register_device, otherwise |
513 |
+diff --git a/drivers/mfd/intel-lpss-acpi.c b/drivers/mfd/intel-lpss-acpi.c |
514 |
+index c8fe334b5fe8b..045cbf0cbe53a 100644 |
515 |
+--- a/drivers/mfd/intel-lpss-acpi.c |
516 |
++++ b/drivers/mfd/intel-lpss-acpi.c |
517 |
+@@ -102,6 +102,7 @@ static int intel_lpss_acpi_probe(struct platform_device *pdev) |
518 |
+ { |
519 |
+ struct intel_lpss_platform_info *info; |
520 |
+ const struct acpi_device_id *id; |
521 |
++ int ret; |
522 |
+ |
523 |
+ id = acpi_match_device(intel_lpss_acpi_ids, &pdev->dev); |
524 |
+ if (!id) |
525 |
+@@ -115,10 +116,14 @@ static int intel_lpss_acpi_probe(struct platform_device *pdev) |
526 |
+ info->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
527 |
+ info->irq = platform_get_irq(pdev, 0); |
528 |
+ |
529 |
++ ret = intel_lpss_probe(&pdev->dev, info); |
530 |
++ if (ret) |
531 |
++ return ret; |
532 |
++ |
533 |
+ pm_runtime_set_active(&pdev->dev); |
534 |
+ pm_runtime_enable(&pdev->dev); |
535 |
+ |
536 |
+- return intel_lpss_probe(&pdev->dev, info); |
537 |
++ return 0; |
538 |
+ } |
539 |
+ |
540 |
+ static int intel_lpss_acpi_remove(struct platform_device *pdev) |
541 |
+diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c |
542 |
+index bf04a08eeba13..a78b060ce8471 100644 |
543 |
+--- a/drivers/mmc/host/sdhci-pci-core.c |
544 |
++++ b/drivers/mmc/host/sdhci-pci-core.c |
545 |
+@@ -1932,6 +1932,7 @@ static const struct pci_device_id pci_ids[] = { |
546 |
+ SDHCI_PCI_DEVICE(INTEL, JSL_SD, intel_byt_sd), |
547 |
+ SDHCI_PCI_DEVICE(INTEL, LKF_EMMC, intel_glk_emmc), |
548 |
+ SDHCI_PCI_DEVICE(INTEL, LKF_SD, intel_byt_sd), |
549 |
++ SDHCI_PCI_DEVICE(INTEL, ADL_EMMC, intel_glk_emmc), |
550 |
+ SDHCI_PCI_DEVICE(O2, 8120, o2), |
551 |
+ SDHCI_PCI_DEVICE(O2, 8220, o2), |
552 |
+ SDHCI_PCI_DEVICE(O2, 8221, o2), |
553 |
+diff --git a/drivers/mmc/host/sdhci-pci.h b/drivers/mmc/host/sdhci-pci.h |
554 |
+index 8f90c4163bb5c..dcd99d5057ee1 100644 |
555 |
+--- a/drivers/mmc/host/sdhci-pci.h |
556 |
++++ b/drivers/mmc/host/sdhci-pci.h |
557 |
+@@ -59,6 +59,7 @@ |
558 |
+ #define PCI_DEVICE_ID_INTEL_JSL_SD 0x4df8 |
559 |
+ #define PCI_DEVICE_ID_INTEL_LKF_EMMC 0x98c4 |
560 |
+ #define PCI_DEVICE_ID_INTEL_LKF_SD 0x98f8 |
561 |
++#define PCI_DEVICE_ID_INTEL_ADL_EMMC 0x54c4 |
562 |
+ |
563 |
+ #define PCI_DEVICE_ID_SYSKONNECT_8000 0x8000 |
564 |
+ #define PCI_DEVICE_ID_VIA_95D0 0x95d0 |
565 |
+diff --git a/drivers/net/can/usb/gs_usb.c b/drivers/net/can/usb/gs_usb.c |
566 |
+index 018ca3b057a3b..3f759fae81fe2 100644 |
567 |
+--- a/drivers/net/can/usb/gs_usb.c |
568 |
++++ b/drivers/net/can/usb/gs_usb.c |
569 |
+@@ -320,7 +320,7 @@ static void gs_usb_receive_bulk_callback(struct urb *urb) |
570 |
+ |
571 |
+ /* device reports out of range channel id */ |
572 |
+ if (hf->channel >= GS_MAX_INTF) |
573 |
+- goto resubmit_urb; |
574 |
++ goto device_detach; |
575 |
+ |
576 |
+ dev = usbcan->canch[hf->channel]; |
577 |
+ |
578 |
+@@ -405,6 +405,7 @@ static void gs_usb_receive_bulk_callback(struct urb *urb) |
579 |
+ |
580 |
+ /* USB failure take down all interfaces */ |
581 |
+ if (rc == -ENODEV) { |
582 |
++ device_detach: |
583 |
+ for (rc = 0; rc < GS_MAX_INTF; rc++) { |
584 |
+ if (usbcan->canch[rc]) |
585 |
+ netif_device_detach(usbcan->canch[rc]->netdev); |
586 |
+@@ -506,6 +507,8 @@ static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb, |
587 |
+ |
588 |
+ hf->echo_id = idx; |
589 |
+ hf->channel = dev->channel; |
590 |
++ hf->flags = 0; |
591 |
++ hf->reserved = 0; |
592 |
+ |
593 |
+ cf = (struct can_frame *)skb->data; |
594 |
+ |
595 |
+diff --git a/drivers/net/veth.c b/drivers/net/veth.c |
596 |
+index be18b243642f0..aef66f8eecee1 100644 |
597 |
+--- a/drivers/net/veth.c |
598 |
++++ b/drivers/net/veth.c |
599 |
+@@ -301,7 +301,6 @@ static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev) |
600 |
+ if (rxq < rcv->real_num_rx_queues) { |
601 |
+ rq = &rcv_priv->rq[rxq]; |
602 |
+ rcv_xdp = rcu_access_pointer(rq->xdp_prog); |
603 |
+- skb_record_rx_queue(skb, rxq); |
604 |
+ } |
605 |
+ |
606 |
+ skb_tx_timestamp(skb); |
607 |
+diff --git a/drivers/net/wireless/ath/ath11k/wmi.c b/drivers/net/wireless/ath/ath11k/wmi.c |
608 |
+index 74ebe8e7d1d81..e84127165d858 100644 |
609 |
+--- a/drivers/net/wireless/ath/ath11k/wmi.c |
610 |
++++ b/drivers/net/wireless/ath/ath11k/wmi.c |
611 |
+@@ -2036,7 +2036,7 @@ int ath11k_wmi_send_scan_start_cmd(struct ath11k *ar, |
612 |
+ void *ptr; |
613 |
+ int i, ret, len; |
614 |
+ u32 *tmp_ptr; |
615 |
+- u8 extraie_len_with_pad = 0; |
616 |
++ u16 extraie_len_with_pad = 0; |
617 |
+ struct hint_short_ssid *s_ssid = NULL; |
618 |
+ struct hint_bssid *hint_bssid = NULL; |
619 |
+ |
620 |
+@@ -2055,7 +2055,7 @@ int ath11k_wmi_send_scan_start_cmd(struct ath11k *ar, |
621 |
+ len += sizeof(*bssid) * params->num_bssid; |
622 |
+ |
623 |
+ len += TLV_HDR_SIZE; |
624 |
+- if (params->extraie.len) |
625 |
++ if (params->extraie.len && params->extraie.len <= 0xFFFF) |
626 |
+ extraie_len_with_pad = |
627 |
+ roundup(params->extraie.len, sizeof(u32)); |
628 |
+ len += extraie_len_with_pad; |
629 |
+@@ -2162,7 +2162,7 @@ int ath11k_wmi_send_scan_start_cmd(struct ath11k *ar, |
630 |
+ FIELD_PREP(WMI_TLV_LEN, len); |
631 |
+ ptr += TLV_HDR_SIZE; |
632 |
+ |
633 |
+- if (params->extraie.len) |
634 |
++ if (extraie_len_with_pad) |
635 |
+ memcpy(ptr, params->extraie.ptr, |
636 |
+ params->extraie.len); |
637 |
+ |
638 |
+diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c |
639 |
+index 662e3e8b4b634..2bb8e7b60e8d5 100644 |
640 |
+--- a/drivers/staging/greybus/audio_topology.c |
641 |
++++ b/drivers/staging/greybus/audio_topology.c |
642 |
+@@ -974,6 +974,44 @@ static int gbaudio_widget_event(struct snd_soc_dapm_widget *w, |
643 |
+ return ret; |
644 |
+ } |
645 |
+ |
646 |
++static const struct snd_soc_dapm_widget gbaudio_widgets[] = { |
647 |
++ [snd_soc_dapm_spk] = SND_SOC_DAPM_SPK(NULL, gbcodec_event_spk), |
648 |
++ [snd_soc_dapm_hp] = SND_SOC_DAPM_HP(NULL, gbcodec_event_hp), |
649 |
++ [snd_soc_dapm_mic] = SND_SOC_DAPM_MIC(NULL, gbcodec_event_int_mic), |
650 |
++ [snd_soc_dapm_output] = SND_SOC_DAPM_OUTPUT(NULL), |
651 |
++ [snd_soc_dapm_input] = SND_SOC_DAPM_INPUT(NULL), |
652 |
++ [snd_soc_dapm_switch] = SND_SOC_DAPM_SWITCH_E(NULL, SND_SOC_NOPM, |
653 |
++ 0, 0, NULL, |
654 |
++ gbaudio_widget_event, |
655 |
++ SND_SOC_DAPM_PRE_PMU | |
656 |
++ SND_SOC_DAPM_POST_PMD), |
657 |
++ [snd_soc_dapm_pga] = SND_SOC_DAPM_PGA_E(NULL, SND_SOC_NOPM, |
658 |
++ 0, 0, NULL, 0, |
659 |
++ gbaudio_widget_event, |
660 |
++ SND_SOC_DAPM_PRE_PMU | |
661 |
++ SND_SOC_DAPM_POST_PMD), |
662 |
++ [snd_soc_dapm_mixer] = SND_SOC_DAPM_MIXER_E(NULL, SND_SOC_NOPM, |
663 |
++ 0, 0, NULL, 0, |
664 |
++ gbaudio_widget_event, |
665 |
++ SND_SOC_DAPM_PRE_PMU | |
666 |
++ SND_SOC_DAPM_POST_PMD), |
667 |
++ [snd_soc_dapm_mux] = SND_SOC_DAPM_MUX_E(NULL, SND_SOC_NOPM, |
668 |
++ 0, 0, NULL, |
669 |
++ gbaudio_widget_event, |
670 |
++ SND_SOC_DAPM_PRE_PMU | |
671 |
++ SND_SOC_DAPM_POST_PMD), |
672 |
++ [snd_soc_dapm_aif_in] = SND_SOC_DAPM_AIF_IN_E(NULL, NULL, 0, |
673 |
++ SND_SOC_NOPM, 0, 0, |
674 |
++ gbaudio_widget_event, |
675 |
++ SND_SOC_DAPM_PRE_PMU | |
676 |
++ SND_SOC_DAPM_POST_PMD), |
677 |
++ [snd_soc_dapm_aif_out] = SND_SOC_DAPM_AIF_OUT_E(NULL, NULL, 0, |
678 |
++ SND_SOC_NOPM, 0, 0, |
679 |
++ gbaudio_widget_event, |
680 |
++ SND_SOC_DAPM_PRE_PMU | |
681 |
++ SND_SOC_DAPM_POST_PMD), |
682 |
++}; |
683 |
++ |
684 |
+ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module, |
685 |
+ struct snd_soc_dapm_widget *dw, |
686 |
+ struct gb_audio_widget *w, int *w_size) |
687 |
+@@ -1052,77 +1090,37 @@ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module, |
688 |
+ |
689 |
+ switch (w->type) { |
690 |
+ case snd_soc_dapm_spk: |
691 |
+- *dw = (struct snd_soc_dapm_widget) |
692 |
+- SND_SOC_DAPM_SPK(w->name, gbcodec_event_spk); |
693 |
++ *dw = gbaudio_widgets[w->type]; |
694 |
+ module->op_devices |= GBAUDIO_DEVICE_OUT_SPEAKER; |
695 |
+ break; |
696 |
+ case snd_soc_dapm_hp: |
697 |
+- *dw = (struct snd_soc_dapm_widget) |
698 |
+- SND_SOC_DAPM_HP(w->name, gbcodec_event_hp); |
699 |
++ *dw = gbaudio_widgets[w->type]; |
700 |
+ module->op_devices |= (GBAUDIO_DEVICE_OUT_WIRED_HEADSET |
701 |
+ | GBAUDIO_DEVICE_OUT_WIRED_HEADPHONE); |
702 |
+ module->ip_devices |= GBAUDIO_DEVICE_IN_WIRED_HEADSET; |
703 |
+ break; |
704 |
+ case snd_soc_dapm_mic: |
705 |
+- *dw = (struct snd_soc_dapm_widget) |
706 |
+- SND_SOC_DAPM_MIC(w->name, gbcodec_event_int_mic); |
707 |
++ *dw = gbaudio_widgets[w->type]; |
708 |
+ module->ip_devices |= GBAUDIO_DEVICE_IN_BUILTIN_MIC; |
709 |
+ break; |
710 |
+ case snd_soc_dapm_output: |
711 |
+- *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_OUTPUT(w->name); |
712 |
+- break; |
713 |
+ case snd_soc_dapm_input: |
714 |
+- *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_INPUT(w->name); |
715 |
+- break; |
716 |
+ case snd_soc_dapm_switch: |
717 |
+- *dw = (struct snd_soc_dapm_widget) |
718 |
+- SND_SOC_DAPM_SWITCH_E(w->name, SND_SOC_NOPM, 0, 0, |
719 |
+- widget_kctls, |
720 |
+- gbaudio_widget_event, |
721 |
+- SND_SOC_DAPM_PRE_PMU | |
722 |
+- SND_SOC_DAPM_POST_PMD); |
723 |
+- break; |
724 |
+ case snd_soc_dapm_pga: |
725 |
+- *dw = (struct snd_soc_dapm_widget) |
726 |
+- SND_SOC_DAPM_PGA_E(w->name, SND_SOC_NOPM, 0, 0, NULL, 0, |
727 |
+- gbaudio_widget_event, |
728 |
+- SND_SOC_DAPM_PRE_PMU | |
729 |
+- SND_SOC_DAPM_POST_PMD); |
730 |
+- break; |
731 |
+ case snd_soc_dapm_mixer: |
732 |
+- *dw = (struct snd_soc_dapm_widget) |
733 |
+- SND_SOC_DAPM_MIXER_E(w->name, SND_SOC_NOPM, 0, 0, NULL, |
734 |
+- 0, gbaudio_widget_event, |
735 |
+- SND_SOC_DAPM_PRE_PMU | |
736 |
+- SND_SOC_DAPM_POST_PMD); |
737 |
+- break; |
738 |
+ case snd_soc_dapm_mux: |
739 |
+- *dw = (struct snd_soc_dapm_widget) |
740 |
+- SND_SOC_DAPM_MUX_E(w->name, SND_SOC_NOPM, 0, 0, |
741 |
+- widget_kctls, gbaudio_widget_event, |
742 |
+- SND_SOC_DAPM_PRE_PMU | |
743 |
+- SND_SOC_DAPM_POST_PMD); |
744 |
++ *dw = gbaudio_widgets[w->type]; |
745 |
+ break; |
746 |
+ case snd_soc_dapm_aif_in: |
747 |
+- *dw = (struct snd_soc_dapm_widget) |
748 |
+- SND_SOC_DAPM_AIF_IN_E(w->name, w->sname, 0, |
749 |
+- SND_SOC_NOPM, |
750 |
+- 0, 0, gbaudio_widget_event, |
751 |
+- SND_SOC_DAPM_PRE_PMU | |
752 |
+- SND_SOC_DAPM_POST_PMD); |
753 |
+- break; |
754 |
+ case snd_soc_dapm_aif_out: |
755 |
+- *dw = (struct snd_soc_dapm_widget) |
756 |
+- SND_SOC_DAPM_AIF_OUT_E(w->name, w->sname, 0, |
757 |
+- SND_SOC_NOPM, |
758 |
+- 0, 0, gbaudio_widget_event, |
759 |
+- SND_SOC_DAPM_PRE_PMU | |
760 |
+- SND_SOC_DAPM_POST_PMD); |
761 |
++ *dw = gbaudio_widgets[w->type]; |
762 |
++ dw->sname = w->sname; |
763 |
+ break; |
764 |
+ default: |
765 |
+ ret = -EINVAL; |
766 |
+ goto error; |
767 |
+ } |
768 |
++ dw->name = w->name; |
769 |
+ |
770 |
+ dev_dbg(module->dev, "%s: widget of type %d created\n", dw->name, |
771 |
+ dw->id); |
772 |
+diff --git a/drivers/staging/wlan-ng/hfa384x_usb.c b/drivers/staging/wlan-ng/hfa384x_usb.c |
773 |
+index f2a0e16b0318c..fac3f34d4a1f5 100644 |
774 |
+--- a/drivers/staging/wlan-ng/hfa384x_usb.c |
775 |
++++ b/drivers/staging/wlan-ng/hfa384x_usb.c |
776 |
+@@ -3779,18 +3779,18 @@ static void hfa384x_usb_throttlefn(struct timer_list *t) |
777 |
+ |
778 |
+ spin_lock_irqsave(&hw->ctlxq.lock, flags); |
779 |
+ |
780 |
+- /* |
781 |
+- * We need to check BOTH the RX and the TX throttle controls, |
782 |
+- * so we use the bitwise OR instead of the logical OR. |
783 |
+- */ |
784 |
+ pr_debug("flags=0x%lx\n", hw->usb_flags); |
785 |
+- if (!hw->wlandev->hwremoved && |
786 |
+- ((test_and_clear_bit(THROTTLE_RX, &hw->usb_flags) && |
787 |
+- !test_and_set_bit(WORK_RX_RESUME, &hw->usb_flags)) | |
788 |
+- (test_and_clear_bit(THROTTLE_TX, &hw->usb_flags) && |
789 |
+- !test_and_set_bit(WORK_TX_RESUME, &hw->usb_flags)) |
790 |
+- )) { |
791 |
+- schedule_work(&hw->usb_work); |
792 |
++ if (!hw->wlandev->hwremoved) { |
793 |
++ bool rx_throttle = test_and_clear_bit(THROTTLE_RX, &hw->usb_flags) && |
794 |
++ !test_and_set_bit(WORK_RX_RESUME, &hw->usb_flags); |
795 |
++ bool tx_throttle = test_and_clear_bit(THROTTLE_TX, &hw->usb_flags) && |
796 |
++ !test_and_set_bit(WORK_TX_RESUME, &hw->usb_flags); |
797 |
++ /* |
798 |
++ * We need to check BOTH the RX and the TX throttle controls, |
799 |
++ * so we use the bitwise OR instead of the logical OR. |
800 |
++ */ |
801 |
++ if (rx_throttle | tx_throttle) |
802 |
++ schedule_work(&hw->usb_work); |
803 |
+ } |
804 |
+ |
805 |
+ spin_unlock_irqrestore(&hw->ctlxq.lock, flags); |
806 |
+diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c |
807 |
+index 99908d8d2dd36..b2710015493a5 100644 |
808 |
+--- a/drivers/usb/core/hcd.c |
809 |
++++ b/drivers/usb/core/hcd.c |
810 |
+@@ -754,6 +754,7 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd) |
811 |
+ { |
812 |
+ struct urb *urb; |
813 |
+ int length; |
814 |
++ int status; |
815 |
+ unsigned long flags; |
816 |
+ char buffer[6]; /* Any root hubs with > 31 ports? */ |
817 |
+ |
818 |
+@@ -771,11 +772,17 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd) |
819 |
+ if (urb) { |
820 |
+ clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags); |
821 |
+ hcd->status_urb = NULL; |
822 |
++ if (urb->transfer_buffer_length >= length) { |
823 |
++ status = 0; |
824 |
++ } else { |
825 |
++ status = -EOVERFLOW; |
826 |
++ length = urb->transfer_buffer_length; |
827 |
++ } |
828 |
+ urb->actual_length = length; |
829 |
+ memcpy(urb->transfer_buffer, buffer, length); |
830 |
+ |
831 |
+ usb_hcd_unlink_urb_from_ep(hcd, urb); |
832 |
+- usb_hcd_giveback_urb(hcd, urb, 0); |
833 |
++ usb_hcd_giveback_urb(hcd, urb, status); |
834 |
+ } else { |
835 |
+ length = 0; |
836 |
+ set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags); |
837 |
+diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c |
838 |
+index 3f406519da58d..af15dbe6bb141 100644 |
839 |
+--- a/drivers/usb/core/hub.c |
840 |
++++ b/drivers/usb/core/hub.c |
841 |
+@@ -1224,7 +1224,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type) |
842 |
+ */ |
843 |
+ if (portchange || (hub_is_superspeed(hub->hdev) && |
844 |
+ port_resumed)) |
845 |
+- set_bit(port1, hub->change_bits); |
846 |
++ set_bit(port1, hub->event_bits); |
847 |
+ |
848 |
+ } else if (udev->persist_enabled) { |
849 |
+ #ifdef CONFIG_PM |
850 |
+diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c |
851 |
+index 4e28961cfa53e..b43c9de34a2c2 100644 |
852 |
+--- a/kernel/bpf/verifier.c |
853 |
++++ b/kernel/bpf/verifier.c |
854 |
+@@ -6037,16 +6037,16 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, |
855 |
+ fallthrough; |
856 |
+ case PTR_TO_PACKET_END: |
857 |
+ case PTR_TO_SOCKET: |
858 |
+- case PTR_TO_SOCKET_OR_NULL: |
859 |
+ case PTR_TO_SOCK_COMMON: |
860 |
+- case PTR_TO_SOCK_COMMON_OR_NULL: |
861 |
+ case PTR_TO_TCP_SOCK: |
862 |
+- case PTR_TO_TCP_SOCK_OR_NULL: |
863 |
+ case PTR_TO_XDP_SOCK: |
864 |
++reject: |
865 |
+ verbose(env, "R%d pointer arithmetic on %s prohibited\n", |
866 |
+ dst, reg_type_str[ptr_reg->type]); |
867 |
+ return -EACCES; |
868 |
+ default: |
869 |
++ if (reg_type_may_be_null(ptr_reg->type)) |
870 |
++ goto reject; |
871 |
+ break; |
872 |
+ } |
873 |
+ |
874 |
+diff --git a/kernel/workqueue.c b/kernel/workqueue.c |
875 |
+index d02073b9d56e2..fdf5fa4bf4448 100644 |
876 |
+--- a/kernel/workqueue.c |
877 |
++++ b/kernel/workqueue.c |
878 |
+@@ -850,8 +850,17 @@ void wq_worker_running(struct task_struct *task) |
879 |
+ |
880 |
+ if (!worker->sleeping) |
881 |
+ return; |
882 |
++ |
883 |
++ /* |
884 |
++ * If preempted by unbind_workers() between the WORKER_NOT_RUNNING check |
885 |
++ * and the nr_running increment below, we may ruin the nr_running reset |
886 |
++ * and leave with an unexpected pool->nr_running == 1 on the newly unbound |
887 |
++ * pool. Protect against such race. |
888 |
++ */ |
889 |
++ preempt_disable(); |
890 |
+ if (!(worker->flags & WORKER_NOT_RUNNING)) |
891 |
+ atomic_inc(&worker->pool->nr_running); |
892 |
++ preempt_enable(); |
893 |
+ worker->sleeping = 0; |
894 |
+ } |
895 |
+ |
896 |
+diff --git a/net/can/isotp.c b/net/can/isotp.c |
897 |
+index 8ee580538d876..53ce5b6448a5d 100644 |
898 |
+--- a/net/can/isotp.c |
899 |
++++ b/net/can/isotp.c |
900 |
+@@ -119,8 +119,8 @@ enum { |
901 |
+ }; |
902 |
+ |
903 |
+ struct tpcon { |
904 |
+- int idx; |
905 |
+- int len; |
906 |
++ unsigned int idx; |
907 |
++ unsigned int len; |
908 |
+ u32 state; |
909 |
+ u8 bs; |
910 |
+ u8 sn; |