Annotation of /trunk/kernel-alx/patches-4.14/0133-4.14.34-all-fixes.patch
Parent Directory | Revision Log
Revision 3238 -
(hide annotations)
(download)
Fri Nov 9 12:14:58 2018 UTC (5 years, 10 months ago) by niro
File size: 171983 byte(s)
Fri Nov 9 12:14:58 2018 UTC (5 years, 10 months ago) by niro
File size: 171983 byte(s)
-added up to patches-4.14.79
1 | niro | 3238 | diff --git a/Makefile b/Makefile |
2 | index 00dd6af8eab4..a6906dfb112e 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,7 +1,7 @@ | ||
6 | # SPDX-License-Identifier: GPL-2.0 | ||
7 | VERSION = 4 | ||
8 | PATCHLEVEL = 14 | ||
9 | -SUBLEVEL = 33 | ||
10 | +SUBLEVEL = 34 | ||
11 | EXTRAVERSION = | ||
12 | NAME = Petit Gorille | ||
13 | |||
14 | diff --git a/arch/arm/boot/dts/ls1021a.dtsi b/arch/arm/boot/dts/ls1021a.dtsi | ||
15 | index 9319e1f0f1d8..379b4a03cfe2 100644 | ||
16 | --- a/arch/arm/boot/dts/ls1021a.dtsi | ||
17 | +++ b/arch/arm/boot/dts/ls1021a.dtsi | ||
18 | @@ -155,7 +155,7 @@ | ||
19 | }; | ||
20 | |||
21 | esdhc: esdhc@1560000 { | ||
22 | - compatible = "fsl,esdhc"; | ||
23 | + compatible = "fsl,ls1021a-esdhc", "fsl,esdhc"; | ||
24 | reg = <0x0 0x1560000 0x0 0x10000>; | ||
25 | interrupts = <GIC_SPI 94 IRQ_TYPE_LEVEL_HIGH>; | ||
26 | clock-frequency = <0>; | ||
27 | diff --git a/arch/arm64/crypto/Makefile b/arch/arm64/crypto/Makefile | ||
28 | index 12fd81af1d1c..93dbf4889eb6 100644 | ||
29 | --- a/arch/arm64/crypto/Makefile | ||
30 | +++ b/arch/arm64/crypto/Makefile | ||
31 | @@ -24,7 +24,7 @@ obj-$(CONFIG_CRYPTO_CRC32_ARM64_CE) += crc32-ce.o | ||
32 | crc32-ce-y:= crc32-ce-core.o crc32-ce-glue.o | ||
33 | |||
34 | obj-$(CONFIG_CRYPTO_AES_ARM64_CE) += aes-ce-cipher.o | ||
35 | -CFLAGS_aes-ce-cipher.o += -march=armv8-a+crypto | ||
36 | +aes-ce-cipher-y := aes-ce-core.o aes-ce-glue.o | ||
37 | |||
38 | obj-$(CONFIG_CRYPTO_AES_ARM64_CE_CCM) += aes-ce-ccm.o | ||
39 | aes-ce-ccm-y := aes-ce-ccm-glue.o aes-ce-ccm-core.o | ||
40 | diff --git a/arch/arm64/crypto/aes-ce-cipher.c b/arch/arm64/crypto/aes-ce-cipher.c | ||
41 | deleted file mode 100644 | ||
42 | index 6a75cd75ed11..000000000000 | ||
43 | --- a/arch/arm64/crypto/aes-ce-cipher.c | ||
44 | +++ /dev/null | ||
45 | @@ -1,281 +0,0 @@ | ||
46 | -/* | ||
47 | - * aes-ce-cipher.c - core AES cipher using ARMv8 Crypto Extensions | ||
48 | - * | ||
49 | - * Copyright (C) 2013 - 2017 Linaro Ltd <ard.biesheuvel@linaro.org> | ||
50 | - * | ||
51 | - * This program is free software; you can redistribute it and/or modify | ||
52 | - * it under the terms of the GNU General Public License version 2 as | ||
53 | - * published by the Free Software Foundation. | ||
54 | - */ | ||
55 | - | ||
56 | -#include <asm/neon.h> | ||
57 | -#include <asm/simd.h> | ||
58 | -#include <asm/unaligned.h> | ||
59 | -#include <crypto/aes.h> | ||
60 | -#include <linux/cpufeature.h> | ||
61 | -#include <linux/crypto.h> | ||
62 | -#include <linux/module.h> | ||
63 | - | ||
64 | -#include "aes-ce-setkey.h" | ||
65 | - | ||
66 | -MODULE_DESCRIPTION("Synchronous AES cipher using ARMv8 Crypto Extensions"); | ||
67 | -MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>"); | ||
68 | -MODULE_LICENSE("GPL v2"); | ||
69 | - | ||
70 | -asmlinkage void __aes_arm64_encrypt(u32 *rk, u8 *out, const u8 *in, int rounds); | ||
71 | -asmlinkage void __aes_arm64_decrypt(u32 *rk, u8 *out, const u8 *in, int rounds); | ||
72 | - | ||
73 | -struct aes_block { | ||
74 | - u8 b[AES_BLOCK_SIZE]; | ||
75 | -}; | ||
76 | - | ||
77 | -static int num_rounds(struct crypto_aes_ctx *ctx) | ||
78 | -{ | ||
79 | - /* | ||
80 | - * # of rounds specified by AES: | ||
81 | - * 128 bit key 10 rounds | ||
82 | - * 192 bit key 12 rounds | ||
83 | - * 256 bit key 14 rounds | ||
84 | - * => n byte key => 6 + (n/4) rounds | ||
85 | - */ | ||
86 | - return 6 + ctx->key_length / 4; | ||
87 | -} | ||
88 | - | ||
89 | -static void aes_cipher_encrypt(struct crypto_tfm *tfm, u8 dst[], u8 const src[]) | ||
90 | -{ | ||
91 | - struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); | ||
92 | - struct aes_block *out = (struct aes_block *)dst; | ||
93 | - struct aes_block const *in = (struct aes_block *)src; | ||
94 | - void *dummy0; | ||
95 | - int dummy1; | ||
96 | - | ||
97 | - if (!may_use_simd()) { | ||
98 | - __aes_arm64_encrypt(ctx->key_enc, dst, src, num_rounds(ctx)); | ||
99 | - return; | ||
100 | - } | ||
101 | - | ||
102 | - kernel_neon_begin(); | ||
103 | - | ||
104 | - __asm__(" ld1 {v0.16b}, %[in] ;" | ||
105 | - " ld1 {v1.4s}, [%[key]], #16 ;" | ||
106 | - " cmp %w[rounds], #10 ;" | ||
107 | - " bmi 0f ;" | ||
108 | - " bne 3f ;" | ||
109 | - " mov v3.16b, v1.16b ;" | ||
110 | - " b 2f ;" | ||
111 | - "0: mov v2.16b, v1.16b ;" | ||
112 | - " ld1 {v3.4s}, [%[key]], #16 ;" | ||
113 | - "1: aese v0.16b, v2.16b ;" | ||
114 | - " aesmc v0.16b, v0.16b ;" | ||
115 | - "2: ld1 {v1.4s}, [%[key]], #16 ;" | ||
116 | - " aese v0.16b, v3.16b ;" | ||
117 | - " aesmc v0.16b, v0.16b ;" | ||
118 | - "3: ld1 {v2.4s}, [%[key]], #16 ;" | ||
119 | - " subs %w[rounds], %w[rounds], #3 ;" | ||
120 | - " aese v0.16b, v1.16b ;" | ||
121 | - " aesmc v0.16b, v0.16b ;" | ||
122 | - " ld1 {v3.4s}, [%[key]], #16 ;" | ||
123 | - " bpl 1b ;" | ||
124 | - " aese v0.16b, v2.16b ;" | ||
125 | - " eor v0.16b, v0.16b, v3.16b ;" | ||
126 | - " st1 {v0.16b}, %[out] ;" | ||
127 | - | ||
128 | - : [out] "=Q"(*out), | ||
129 | - [key] "=r"(dummy0), | ||
130 | - [rounds] "=r"(dummy1) | ||
131 | - : [in] "Q"(*in), | ||
132 | - "1"(ctx->key_enc), | ||
133 | - "2"(num_rounds(ctx) - 2) | ||
134 | - : "cc"); | ||
135 | - | ||
136 | - kernel_neon_end(); | ||
137 | -} | ||
138 | - | ||
139 | -static void aes_cipher_decrypt(struct crypto_tfm *tfm, u8 dst[], u8 const src[]) | ||
140 | -{ | ||
141 | - struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); | ||
142 | - struct aes_block *out = (struct aes_block *)dst; | ||
143 | - struct aes_block const *in = (struct aes_block *)src; | ||
144 | - void *dummy0; | ||
145 | - int dummy1; | ||
146 | - | ||
147 | - if (!may_use_simd()) { | ||
148 | - __aes_arm64_decrypt(ctx->key_dec, dst, src, num_rounds(ctx)); | ||
149 | - return; | ||
150 | - } | ||
151 | - | ||
152 | - kernel_neon_begin(); | ||
153 | - | ||
154 | - __asm__(" ld1 {v0.16b}, %[in] ;" | ||
155 | - " ld1 {v1.4s}, [%[key]], #16 ;" | ||
156 | - " cmp %w[rounds], #10 ;" | ||
157 | - " bmi 0f ;" | ||
158 | - " bne 3f ;" | ||
159 | - " mov v3.16b, v1.16b ;" | ||
160 | - " b 2f ;" | ||
161 | - "0: mov v2.16b, v1.16b ;" | ||
162 | - " ld1 {v3.4s}, [%[key]], #16 ;" | ||
163 | - "1: aesd v0.16b, v2.16b ;" | ||
164 | - " aesimc v0.16b, v0.16b ;" | ||
165 | - "2: ld1 {v1.4s}, [%[key]], #16 ;" | ||
166 | - " aesd v0.16b, v3.16b ;" | ||
167 | - " aesimc v0.16b, v0.16b ;" | ||
168 | - "3: ld1 {v2.4s}, [%[key]], #16 ;" | ||
169 | - " subs %w[rounds], %w[rounds], #3 ;" | ||
170 | - " aesd v0.16b, v1.16b ;" | ||
171 | - " aesimc v0.16b, v0.16b ;" | ||
172 | - " ld1 {v3.4s}, [%[key]], #16 ;" | ||
173 | - " bpl 1b ;" | ||
174 | - " aesd v0.16b, v2.16b ;" | ||
175 | - " eor v0.16b, v0.16b, v3.16b ;" | ||
176 | - " st1 {v0.16b}, %[out] ;" | ||
177 | - | ||
178 | - : [out] "=Q"(*out), | ||
179 | - [key] "=r"(dummy0), | ||
180 | - [rounds] "=r"(dummy1) | ||
181 | - : [in] "Q"(*in), | ||
182 | - "1"(ctx->key_dec), | ||
183 | - "2"(num_rounds(ctx) - 2) | ||
184 | - : "cc"); | ||
185 | - | ||
186 | - kernel_neon_end(); | ||
187 | -} | ||
188 | - | ||
189 | -/* | ||
190 | - * aes_sub() - use the aese instruction to perform the AES sbox substitution | ||
191 | - * on each byte in 'input' | ||
192 | - */ | ||
193 | -static u32 aes_sub(u32 input) | ||
194 | -{ | ||
195 | - u32 ret; | ||
196 | - | ||
197 | - __asm__("dup v1.4s, %w[in] ;" | ||
198 | - "movi v0.16b, #0 ;" | ||
199 | - "aese v0.16b, v1.16b ;" | ||
200 | - "umov %w[out], v0.4s[0] ;" | ||
201 | - | ||
202 | - : [out] "=r"(ret) | ||
203 | - : [in] "r"(input) | ||
204 | - : "v0","v1"); | ||
205 | - | ||
206 | - return ret; | ||
207 | -} | ||
208 | - | ||
209 | -int ce_aes_expandkey(struct crypto_aes_ctx *ctx, const u8 *in_key, | ||
210 | - unsigned int key_len) | ||
211 | -{ | ||
212 | - /* | ||
213 | - * The AES key schedule round constants | ||
214 | - */ | ||
215 | - static u8 const rcon[] = { | ||
216 | - 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, | ||
217 | - }; | ||
218 | - | ||
219 | - u32 kwords = key_len / sizeof(u32); | ||
220 | - struct aes_block *key_enc, *key_dec; | ||
221 | - int i, j; | ||
222 | - | ||
223 | - if (key_len != AES_KEYSIZE_128 && | ||
224 | - key_len != AES_KEYSIZE_192 && | ||
225 | - key_len != AES_KEYSIZE_256) | ||
226 | - return -EINVAL; | ||
227 | - | ||
228 | - ctx->key_length = key_len; | ||
229 | - for (i = 0; i < kwords; i++) | ||
230 | - ctx->key_enc[i] = get_unaligned_le32(in_key + i * sizeof(u32)); | ||
231 | - | ||
232 | - kernel_neon_begin(); | ||
233 | - for (i = 0; i < sizeof(rcon); i++) { | ||
234 | - u32 *rki = ctx->key_enc + (i * kwords); | ||
235 | - u32 *rko = rki + kwords; | ||
236 | - | ||
237 | - rko[0] = ror32(aes_sub(rki[kwords - 1]), 8) ^ rcon[i] ^ rki[0]; | ||
238 | - rko[1] = rko[0] ^ rki[1]; | ||
239 | - rko[2] = rko[1] ^ rki[2]; | ||
240 | - rko[3] = rko[2] ^ rki[3]; | ||
241 | - | ||
242 | - if (key_len == AES_KEYSIZE_192) { | ||
243 | - if (i >= 7) | ||
244 | - break; | ||
245 | - rko[4] = rko[3] ^ rki[4]; | ||
246 | - rko[5] = rko[4] ^ rki[5]; | ||
247 | - } else if (key_len == AES_KEYSIZE_256) { | ||
248 | - if (i >= 6) | ||
249 | - break; | ||
250 | - rko[4] = aes_sub(rko[3]) ^ rki[4]; | ||
251 | - rko[5] = rko[4] ^ rki[5]; | ||
252 | - rko[6] = rko[5] ^ rki[6]; | ||
253 | - rko[7] = rko[6] ^ rki[7]; | ||
254 | - } | ||
255 | - } | ||
256 | - | ||
257 | - /* | ||
258 | - * Generate the decryption keys for the Equivalent Inverse Cipher. | ||
259 | - * This involves reversing the order of the round keys, and applying | ||
260 | - * the Inverse Mix Columns transformation on all but the first and | ||
261 | - * the last one. | ||
262 | - */ | ||
263 | - key_enc = (struct aes_block *)ctx->key_enc; | ||
264 | - key_dec = (struct aes_block *)ctx->key_dec; | ||
265 | - j = num_rounds(ctx); | ||
266 | - | ||
267 | - key_dec[0] = key_enc[j]; | ||
268 | - for (i = 1, j--; j > 0; i++, j--) | ||
269 | - __asm__("ld1 {v0.4s}, %[in] ;" | ||
270 | - "aesimc v1.16b, v0.16b ;" | ||
271 | - "st1 {v1.4s}, %[out] ;" | ||
272 | - | ||
273 | - : [out] "=Q"(key_dec[i]) | ||
274 | - : [in] "Q"(key_enc[j]) | ||
275 | - : "v0","v1"); | ||
276 | - key_dec[i] = key_enc[0]; | ||
277 | - | ||
278 | - kernel_neon_end(); | ||
279 | - return 0; | ||
280 | -} | ||
281 | -EXPORT_SYMBOL(ce_aes_expandkey); | ||
282 | - | ||
283 | -int ce_aes_setkey(struct crypto_tfm *tfm, const u8 *in_key, | ||
284 | - unsigned int key_len) | ||
285 | -{ | ||
286 | - struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); | ||
287 | - int ret; | ||
288 | - | ||
289 | - ret = ce_aes_expandkey(ctx, in_key, key_len); | ||
290 | - if (!ret) | ||
291 | - return 0; | ||
292 | - | ||
293 | - tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; | ||
294 | - return -EINVAL; | ||
295 | -} | ||
296 | -EXPORT_SYMBOL(ce_aes_setkey); | ||
297 | - | ||
298 | -static struct crypto_alg aes_alg = { | ||
299 | - .cra_name = "aes", | ||
300 | - .cra_driver_name = "aes-ce", | ||
301 | - .cra_priority = 250, | ||
302 | - .cra_flags = CRYPTO_ALG_TYPE_CIPHER, | ||
303 | - .cra_blocksize = AES_BLOCK_SIZE, | ||
304 | - .cra_ctxsize = sizeof(struct crypto_aes_ctx), | ||
305 | - .cra_module = THIS_MODULE, | ||
306 | - .cra_cipher = { | ||
307 | - .cia_min_keysize = AES_MIN_KEY_SIZE, | ||
308 | - .cia_max_keysize = AES_MAX_KEY_SIZE, | ||
309 | - .cia_setkey = ce_aes_setkey, | ||
310 | - .cia_encrypt = aes_cipher_encrypt, | ||
311 | - .cia_decrypt = aes_cipher_decrypt | ||
312 | - } | ||
313 | -}; | ||
314 | - | ||
315 | -static int __init aes_mod_init(void) | ||
316 | -{ | ||
317 | - return crypto_register_alg(&aes_alg); | ||
318 | -} | ||
319 | - | ||
320 | -static void __exit aes_mod_exit(void) | ||
321 | -{ | ||
322 | - crypto_unregister_alg(&aes_alg); | ||
323 | -} | ||
324 | - | ||
325 | -module_cpu_feature_match(AES, aes_mod_init); | ||
326 | -module_exit(aes_mod_exit); | ||
327 | diff --git a/arch/arm64/crypto/aes-ce-core.S b/arch/arm64/crypto/aes-ce-core.S | ||
328 | new file mode 100644 | ||
329 | index 000000000000..8efdfdade393 | ||
330 | --- /dev/null | ||
331 | +++ b/arch/arm64/crypto/aes-ce-core.S | ||
332 | @@ -0,0 +1,87 @@ | ||
333 | +/* | ||
334 | + * Copyright (C) 2013 - 2017 Linaro Ltd <ard.biesheuvel@linaro.org> | ||
335 | + * | ||
336 | + * This program is free software; you can redistribute it and/or modify | ||
337 | + * it under the terms of the GNU General Public License version 2 as | ||
338 | + * published by the Free Software Foundation. | ||
339 | + */ | ||
340 | + | ||
341 | +#include <linux/linkage.h> | ||
342 | +#include <asm/assembler.h> | ||
343 | + | ||
344 | + .arch armv8-a+crypto | ||
345 | + | ||
346 | +ENTRY(__aes_ce_encrypt) | ||
347 | + sub w3, w3, #2 | ||
348 | + ld1 {v0.16b}, [x2] | ||
349 | + ld1 {v1.4s}, [x0], #16 | ||
350 | + cmp w3, #10 | ||
351 | + bmi 0f | ||
352 | + bne 3f | ||
353 | + mov v3.16b, v1.16b | ||
354 | + b 2f | ||
355 | +0: mov v2.16b, v1.16b | ||
356 | + ld1 {v3.4s}, [x0], #16 | ||
357 | +1: aese v0.16b, v2.16b | ||
358 | + aesmc v0.16b, v0.16b | ||
359 | +2: ld1 {v1.4s}, [x0], #16 | ||
360 | + aese v0.16b, v3.16b | ||
361 | + aesmc v0.16b, v0.16b | ||
362 | +3: ld1 {v2.4s}, [x0], #16 | ||
363 | + subs w3, w3, #3 | ||
364 | + aese v0.16b, v1.16b | ||
365 | + aesmc v0.16b, v0.16b | ||
366 | + ld1 {v3.4s}, [x0], #16 | ||
367 | + bpl 1b | ||
368 | + aese v0.16b, v2.16b | ||
369 | + eor v0.16b, v0.16b, v3.16b | ||
370 | + st1 {v0.16b}, [x1] | ||
371 | + ret | ||
372 | +ENDPROC(__aes_ce_encrypt) | ||
373 | + | ||
374 | +ENTRY(__aes_ce_decrypt) | ||
375 | + sub w3, w3, #2 | ||
376 | + ld1 {v0.16b}, [x2] | ||
377 | + ld1 {v1.4s}, [x0], #16 | ||
378 | + cmp w3, #10 | ||
379 | + bmi 0f | ||
380 | + bne 3f | ||
381 | + mov v3.16b, v1.16b | ||
382 | + b 2f | ||
383 | +0: mov v2.16b, v1.16b | ||
384 | + ld1 {v3.4s}, [x0], #16 | ||
385 | +1: aesd v0.16b, v2.16b | ||
386 | + aesimc v0.16b, v0.16b | ||
387 | +2: ld1 {v1.4s}, [x0], #16 | ||
388 | + aesd v0.16b, v3.16b | ||
389 | + aesimc v0.16b, v0.16b | ||
390 | +3: ld1 {v2.4s}, [x0], #16 | ||
391 | + subs w3, w3, #3 | ||
392 | + aesd v0.16b, v1.16b | ||
393 | + aesimc v0.16b, v0.16b | ||
394 | + ld1 {v3.4s}, [x0], #16 | ||
395 | + bpl 1b | ||
396 | + aesd v0.16b, v2.16b | ||
397 | + eor v0.16b, v0.16b, v3.16b | ||
398 | + st1 {v0.16b}, [x1] | ||
399 | + ret | ||
400 | +ENDPROC(__aes_ce_decrypt) | ||
401 | + | ||
402 | +/* | ||
403 | + * __aes_ce_sub() - use the aese instruction to perform the AES sbox | ||
404 | + * substitution on each byte in 'input' | ||
405 | + */ | ||
406 | +ENTRY(__aes_ce_sub) | ||
407 | + dup v1.4s, w0 | ||
408 | + movi v0.16b, #0 | ||
409 | + aese v0.16b, v1.16b | ||
410 | + umov w0, v0.s[0] | ||
411 | + ret | ||
412 | +ENDPROC(__aes_ce_sub) | ||
413 | + | ||
414 | +ENTRY(__aes_ce_invert) | ||
415 | + ld1 {v0.4s}, [x1] | ||
416 | + aesimc v1.16b, v0.16b | ||
417 | + st1 {v1.4s}, [x0] | ||
418 | + ret | ||
419 | +ENDPROC(__aes_ce_invert) | ||
420 | diff --git a/arch/arm64/crypto/aes-ce-glue.c b/arch/arm64/crypto/aes-ce-glue.c | ||
421 | new file mode 100644 | ||
422 | index 000000000000..e6b3227bbf57 | ||
423 | --- /dev/null | ||
424 | +++ b/arch/arm64/crypto/aes-ce-glue.c | ||
425 | @@ -0,0 +1,190 @@ | ||
426 | +/* | ||
427 | + * aes-ce-cipher.c - core AES cipher using ARMv8 Crypto Extensions | ||
428 | + * | ||
429 | + * Copyright (C) 2013 - 2017 Linaro Ltd <ard.biesheuvel@linaro.org> | ||
430 | + * | ||
431 | + * This program is free software; you can redistribute it and/or modify | ||
432 | + * it under the terms of the GNU General Public License version 2 as | ||
433 | + * published by the Free Software Foundation. | ||
434 | + */ | ||
435 | + | ||
436 | +#include <asm/neon.h> | ||
437 | +#include <asm/simd.h> | ||
438 | +#include <asm/unaligned.h> | ||
439 | +#include <crypto/aes.h> | ||
440 | +#include <linux/cpufeature.h> | ||
441 | +#include <linux/crypto.h> | ||
442 | +#include <linux/module.h> | ||
443 | + | ||
444 | +#include "aes-ce-setkey.h" | ||
445 | + | ||
446 | +MODULE_DESCRIPTION("Synchronous AES cipher using ARMv8 Crypto Extensions"); | ||
447 | +MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>"); | ||
448 | +MODULE_LICENSE("GPL v2"); | ||
449 | + | ||
450 | +asmlinkage void __aes_arm64_encrypt(u32 *rk, u8 *out, const u8 *in, int rounds); | ||
451 | +asmlinkage void __aes_arm64_decrypt(u32 *rk, u8 *out, const u8 *in, int rounds); | ||
452 | + | ||
453 | +struct aes_block { | ||
454 | + u8 b[AES_BLOCK_SIZE]; | ||
455 | +}; | ||
456 | + | ||
457 | +asmlinkage void __aes_ce_encrypt(u32 *rk, u8 *out, const u8 *in, int rounds); | ||
458 | +asmlinkage void __aes_ce_decrypt(u32 *rk, u8 *out, const u8 *in, int rounds); | ||
459 | + | ||
460 | +asmlinkage u32 __aes_ce_sub(u32 l); | ||
461 | +asmlinkage void __aes_ce_invert(struct aes_block *out, | ||
462 | + const struct aes_block *in); | ||
463 | + | ||
464 | +static int num_rounds(struct crypto_aes_ctx *ctx) | ||
465 | +{ | ||
466 | + /* | ||
467 | + * # of rounds specified by AES: | ||
468 | + * 128 bit key 10 rounds | ||
469 | + * 192 bit key 12 rounds | ||
470 | + * 256 bit key 14 rounds | ||
471 | + * => n byte key => 6 + (n/4) rounds | ||
472 | + */ | ||
473 | + return 6 + ctx->key_length / 4; | ||
474 | +} | ||
475 | + | ||
476 | +static void aes_cipher_encrypt(struct crypto_tfm *tfm, u8 dst[], u8 const src[]) | ||
477 | +{ | ||
478 | + struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); | ||
479 | + | ||
480 | + if (!may_use_simd()) { | ||
481 | + __aes_arm64_encrypt(ctx->key_enc, dst, src, num_rounds(ctx)); | ||
482 | + return; | ||
483 | + } | ||
484 | + | ||
485 | + kernel_neon_begin(); | ||
486 | + __aes_ce_encrypt(ctx->key_enc, dst, src, num_rounds(ctx)); | ||
487 | + kernel_neon_end(); | ||
488 | +} | ||
489 | + | ||
490 | +static void aes_cipher_decrypt(struct crypto_tfm *tfm, u8 dst[], u8 const src[]) | ||
491 | +{ | ||
492 | + struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); | ||
493 | + | ||
494 | + if (!may_use_simd()) { | ||
495 | + __aes_arm64_decrypt(ctx->key_dec, dst, src, num_rounds(ctx)); | ||
496 | + return; | ||
497 | + } | ||
498 | + | ||
499 | + kernel_neon_begin(); | ||
500 | + __aes_ce_decrypt(ctx->key_dec, dst, src, num_rounds(ctx)); | ||
501 | + kernel_neon_end(); | ||
502 | +} | ||
503 | + | ||
504 | +int ce_aes_expandkey(struct crypto_aes_ctx *ctx, const u8 *in_key, | ||
505 | + unsigned int key_len) | ||
506 | +{ | ||
507 | + /* | ||
508 | + * The AES key schedule round constants | ||
509 | + */ | ||
510 | + static u8 const rcon[] = { | ||
511 | + 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, | ||
512 | + }; | ||
513 | + | ||
514 | + u32 kwords = key_len / sizeof(u32); | ||
515 | + struct aes_block *key_enc, *key_dec; | ||
516 | + int i, j; | ||
517 | + | ||
518 | + if (key_len != AES_KEYSIZE_128 && | ||
519 | + key_len != AES_KEYSIZE_192 && | ||
520 | + key_len != AES_KEYSIZE_256) | ||
521 | + return -EINVAL; | ||
522 | + | ||
523 | + ctx->key_length = key_len; | ||
524 | + for (i = 0; i < kwords; i++) | ||
525 | + ctx->key_enc[i] = get_unaligned_le32(in_key + i * sizeof(u32)); | ||
526 | + | ||
527 | + kernel_neon_begin(); | ||
528 | + for (i = 0; i < sizeof(rcon); i++) { | ||
529 | + u32 *rki = ctx->key_enc + (i * kwords); | ||
530 | + u32 *rko = rki + kwords; | ||
531 | + | ||
532 | + rko[0] = ror32(__aes_ce_sub(rki[kwords - 1]), 8) ^ rcon[i] ^ rki[0]; | ||
533 | + rko[1] = rko[0] ^ rki[1]; | ||
534 | + rko[2] = rko[1] ^ rki[2]; | ||
535 | + rko[3] = rko[2] ^ rki[3]; | ||
536 | + | ||
537 | + if (key_len == AES_KEYSIZE_192) { | ||
538 | + if (i >= 7) | ||
539 | + break; | ||
540 | + rko[4] = rko[3] ^ rki[4]; | ||
541 | + rko[5] = rko[4] ^ rki[5]; | ||
542 | + } else if (key_len == AES_KEYSIZE_256) { | ||
543 | + if (i >= 6) | ||
544 | + break; | ||
545 | + rko[4] = __aes_ce_sub(rko[3]) ^ rki[4]; | ||
546 | + rko[5] = rko[4] ^ rki[5]; | ||
547 | + rko[6] = rko[5] ^ rki[6]; | ||
548 | + rko[7] = rko[6] ^ rki[7]; | ||
549 | + } | ||
550 | + } | ||
551 | + | ||
552 | + /* | ||
553 | + * Generate the decryption keys for the Equivalent Inverse Cipher. | ||
554 | + * This involves reversing the order of the round keys, and applying | ||
555 | + * the Inverse Mix Columns transformation on all but the first and | ||
556 | + * the last one. | ||
557 | + */ | ||
558 | + key_enc = (struct aes_block *)ctx->key_enc; | ||
559 | + key_dec = (struct aes_block *)ctx->key_dec; | ||
560 | + j = num_rounds(ctx); | ||
561 | + | ||
562 | + key_dec[0] = key_enc[j]; | ||
563 | + for (i = 1, j--; j > 0; i++, j--) | ||
564 | + __aes_ce_invert(key_dec + i, key_enc + j); | ||
565 | + key_dec[i] = key_enc[0]; | ||
566 | + | ||
567 | + kernel_neon_end(); | ||
568 | + return 0; | ||
569 | +} | ||
570 | +EXPORT_SYMBOL(ce_aes_expandkey); | ||
571 | + | ||
572 | +int ce_aes_setkey(struct crypto_tfm *tfm, const u8 *in_key, | ||
573 | + unsigned int key_len) | ||
574 | +{ | ||
575 | + struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); | ||
576 | + int ret; | ||
577 | + | ||
578 | + ret = ce_aes_expandkey(ctx, in_key, key_len); | ||
579 | + if (!ret) | ||
580 | + return 0; | ||
581 | + | ||
582 | + tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; | ||
583 | + return -EINVAL; | ||
584 | +} | ||
585 | +EXPORT_SYMBOL(ce_aes_setkey); | ||
586 | + | ||
587 | +static struct crypto_alg aes_alg = { | ||
588 | + .cra_name = "aes", | ||
589 | + .cra_driver_name = "aes-ce", | ||
590 | + .cra_priority = 250, | ||
591 | + .cra_flags = CRYPTO_ALG_TYPE_CIPHER, | ||
592 | + .cra_blocksize = AES_BLOCK_SIZE, | ||
593 | + .cra_ctxsize = sizeof(struct crypto_aes_ctx), | ||
594 | + .cra_module = THIS_MODULE, | ||
595 | + .cra_cipher = { | ||
596 | + .cia_min_keysize = AES_MIN_KEY_SIZE, | ||
597 | + .cia_max_keysize = AES_MAX_KEY_SIZE, | ||
598 | + .cia_setkey = ce_aes_setkey, | ||
599 | + .cia_encrypt = aes_cipher_encrypt, | ||
600 | + .cia_decrypt = aes_cipher_decrypt | ||
601 | + } | ||
602 | +}; | ||
603 | + | ||
604 | +static int __init aes_mod_init(void) | ||
605 | +{ | ||
606 | + return crypto_register_alg(&aes_alg); | ||
607 | +} | ||
608 | + | ||
609 | +static void __exit aes_mod_exit(void) | ||
610 | +{ | ||
611 | + crypto_unregister_alg(&aes_alg); | ||
612 | +} | ||
613 | + | ||
614 | +module_cpu_feature_match(AES, aes_mod_init); | ||
615 | +module_exit(aes_mod_exit); | ||
616 | diff --git a/arch/x86/include/asm/microcode.h b/arch/x86/include/asm/microcode.h | ||
617 | index 55520cec8b27..6cf0e4cb7b97 100644 | ||
618 | --- a/arch/x86/include/asm/microcode.h | ||
619 | +++ b/arch/x86/include/asm/microcode.h | ||
620 | @@ -37,7 +37,13 @@ struct cpu_signature { | ||
621 | |||
622 | struct device; | ||
623 | |||
624 | -enum ucode_state { UCODE_ERROR, UCODE_OK, UCODE_NFOUND }; | ||
625 | +enum ucode_state { | ||
626 | + UCODE_OK = 0, | ||
627 | + UCODE_NEW, | ||
628 | + UCODE_UPDATED, | ||
629 | + UCODE_NFOUND, | ||
630 | + UCODE_ERROR, | ||
631 | +}; | ||
632 | |||
633 | struct microcode_ops { | ||
634 | enum ucode_state (*request_microcode_user) (int cpu, | ||
635 | @@ -54,7 +60,7 @@ struct microcode_ops { | ||
636 | * are being called. | ||
637 | * See also the "Synchronization" section in microcode_core.c. | ||
638 | */ | ||
639 | - int (*apply_microcode) (int cpu); | ||
640 | + enum ucode_state (*apply_microcode) (int cpu); | ||
641 | int (*collect_cpu_info) (int cpu, struct cpu_signature *csig); | ||
642 | }; | ||
643 | |||
644 | diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h | ||
645 | index 15fc074bd628..3222c7746cb1 100644 | ||
646 | --- a/arch/x86/include/asm/processor.h | ||
647 | +++ b/arch/x86/include/asm/processor.h | ||
648 | @@ -968,4 +968,5 @@ bool xen_set_default_idle(void); | ||
649 | |||
650 | void stop_this_cpu(void *dummy); | ||
651 | void df_debug(struct pt_regs *regs, long error_code); | ||
652 | +void microcode_check(void); | ||
653 | #endif /* _ASM_X86_PROCESSOR_H */ | ||
654 | diff --git a/arch/x86/kernel/aperture_64.c b/arch/x86/kernel/aperture_64.c | ||
655 | index f5d92bc3b884..2c4d5ece7456 100644 | ||
656 | --- a/arch/x86/kernel/aperture_64.c | ||
657 | +++ b/arch/x86/kernel/aperture_64.c | ||
658 | @@ -30,6 +30,7 @@ | ||
659 | #include <asm/dma.h> | ||
660 | #include <asm/amd_nb.h> | ||
661 | #include <asm/x86_init.h> | ||
662 | +#include <linux/crash_dump.h> | ||
663 | |||
664 | /* | ||
665 | * Using 512M as goal, in case kexec will load kernel_big | ||
666 | @@ -56,6 +57,33 @@ int fallback_aper_force __initdata; | ||
667 | |||
668 | int fix_aperture __initdata = 1; | ||
669 | |||
670 | +#ifdef CONFIG_PROC_VMCORE | ||
671 | +/* | ||
672 | + * If the first kernel maps the aperture over e820 RAM, the kdump kernel will | ||
673 | + * use the same range because it will remain configured in the northbridge. | ||
674 | + * Trying to dump this area via /proc/vmcore may crash the machine, so exclude | ||
675 | + * it from vmcore. | ||
676 | + */ | ||
677 | +static unsigned long aperture_pfn_start, aperture_page_count; | ||
678 | + | ||
679 | +static int gart_oldmem_pfn_is_ram(unsigned long pfn) | ||
680 | +{ | ||
681 | + return likely((pfn < aperture_pfn_start) || | ||
682 | + (pfn >= aperture_pfn_start + aperture_page_count)); | ||
683 | +} | ||
684 | + | ||
685 | +static void exclude_from_vmcore(u64 aper_base, u32 aper_order) | ||
686 | +{ | ||
687 | + aperture_pfn_start = aper_base >> PAGE_SHIFT; | ||
688 | + aperture_page_count = (32 * 1024 * 1024) << aper_order >> PAGE_SHIFT; | ||
689 | + WARN_ON(register_oldmem_pfn_is_ram(&gart_oldmem_pfn_is_ram)); | ||
690 | +} | ||
691 | +#else | ||
692 | +static void exclude_from_vmcore(u64 aper_base, u32 aper_order) | ||
693 | +{ | ||
694 | +} | ||
695 | +#endif | ||
696 | + | ||
697 | /* This code runs before the PCI subsystem is initialized, so just | ||
698 | access the northbridge directly. */ | ||
699 | |||
700 | @@ -435,8 +463,16 @@ int __init gart_iommu_hole_init(void) | ||
701 | |||
702 | out: | ||
703 | if (!fix && !fallback_aper_force) { | ||
704 | - if (last_aper_base) | ||
705 | + if (last_aper_base) { | ||
706 | + /* | ||
707 | + * If this is the kdump kernel, the first kernel | ||
708 | + * may have allocated the range over its e820 RAM | ||
709 | + * and fixed up the northbridge | ||
710 | + */ | ||
711 | + exclude_from_vmcore(last_aper_base, last_aper_order); | ||
712 | + | ||
713 | return 1; | ||
714 | + } | ||
715 | return 0; | ||
716 | } | ||
717 | |||
718 | @@ -473,6 +509,14 @@ int __init gart_iommu_hole_init(void) | ||
719 | return 0; | ||
720 | } | ||
721 | |||
722 | + /* | ||
723 | + * If this is the kdump kernel _and_ the first kernel did not | ||
724 | + * configure the aperture in the northbridge, this range may | ||
725 | + * overlap with the first kernel's memory. We can't access the | ||
726 | + * range through vmcore even though it should be part of the dump. | ||
727 | + */ | ||
728 | + exclude_from_vmcore(aper_alloc, aper_order); | ||
729 | + | ||
730 | /* Fix up the north bridges */ | ||
731 | for (i = 0; i < amd_nb_bus_dev_ranges[i].dev_limit; i++) { | ||
732 | int bus, dev_base, dev_limit; | ||
733 | diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c | ||
734 | index 651b7afed4da..cf6380200dc2 100644 | ||
735 | --- a/arch/x86/kernel/cpu/common.c | ||
736 | +++ b/arch/x86/kernel/cpu/common.c | ||
737 | @@ -1724,3 +1724,33 @@ static int __init init_cpu_syscore(void) | ||
738 | return 0; | ||
739 | } | ||
740 | core_initcall(init_cpu_syscore); | ||
741 | + | ||
742 | +/* | ||
743 | + * The microcode loader calls this upon late microcode load to recheck features, | ||
744 | + * only when microcode has been updated. Caller holds microcode_mutex and CPU | ||
745 | + * hotplug lock. | ||
746 | + */ | ||
747 | +void microcode_check(void) | ||
748 | +{ | ||
749 | + struct cpuinfo_x86 info; | ||
750 | + | ||
751 | + perf_check_microcode(); | ||
752 | + | ||
753 | + /* Reload CPUID max function as it might've changed. */ | ||
754 | + info.cpuid_level = cpuid_eax(0); | ||
755 | + | ||
756 | + /* | ||
757 | + * Copy all capability leafs to pick up the synthetic ones so that | ||
758 | + * memcmp() below doesn't fail on that. The ones coming from CPUID will | ||
759 | + * get overwritten in get_cpu_cap(). | ||
760 | + */ | ||
761 | + memcpy(&info.x86_capability, &boot_cpu_data.x86_capability, sizeof(info.x86_capability)); | ||
762 | + | ||
763 | + get_cpu_cap(&info); | ||
764 | + | ||
765 | + if (!memcmp(&info.x86_capability, &boot_cpu_data.x86_capability, sizeof(info.x86_capability))) | ||
766 | + return; | ||
767 | + | ||
768 | + pr_warn("x86/CPU: CPU features have changed after loading microcode, but might not take effect.\n"); | ||
769 | + pr_warn("x86/CPU: Please consider either early loading through initrd/built-in or a potential BIOS update.\n"); | ||
770 | +} | ||
771 | diff --git a/arch/x86/kernel/cpu/microcode/amd.c b/arch/x86/kernel/cpu/microcode/amd.c | ||
772 | index 330b8462d426..48179928ff38 100644 | ||
773 | --- a/arch/x86/kernel/cpu/microcode/amd.c | ||
774 | +++ b/arch/x86/kernel/cpu/microcode/amd.c | ||
775 | @@ -339,7 +339,7 @@ int __init save_microcode_in_initrd_amd(unsigned int cpuid_1_eax) | ||
776 | return -EINVAL; | ||
777 | |||
778 | ret = load_microcode_amd(true, x86_family(cpuid_1_eax), desc.data, desc.size); | ||
779 | - if (ret != UCODE_OK) | ||
780 | + if (ret > UCODE_UPDATED) | ||
781 | return -EINVAL; | ||
782 | |||
783 | return 0; | ||
784 | @@ -498,7 +498,7 @@ static unsigned int verify_patch_size(u8 family, u32 patch_size, | ||
785 | return patch_size; | ||
786 | } | ||
787 | |||
788 | -static int apply_microcode_amd(int cpu) | ||
789 | +static enum ucode_state apply_microcode_amd(int cpu) | ||
790 | { | ||
791 | struct cpuinfo_x86 *c = &cpu_data(cpu); | ||
792 | struct microcode_amd *mc_amd; | ||
793 | @@ -512,7 +512,7 @@ static int apply_microcode_amd(int cpu) | ||
794 | |||
795 | p = find_patch(cpu); | ||
796 | if (!p) | ||
797 | - return 0; | ||
798 | + return UCODE_NFOUND; | ||
799 | |||
800 | mc_amd = p->data; | ||
801 | uci->mc = p->data; | ||
802 | @@ -523,13 +523,13 @@ static int apply_microcode_amd(int cpu) | ||
803 | if (rev >= mc_amd->hdr.patch_id) { | ||
804 | c->microcode = rev; | ||
805 | uci->cpu_sig.rev = rev; | ||
806 | - return 0; | ||
807 | + return UCODE_OK; | ||
808 | } | ||
809 | |||
810 | if (__apply_microcode_amd(mc_amd)) { | ||
811 | pr_err("CPU%d: update failed for patch_level=0x%08x\n", | ||
812 | cpu, mc_amd->hdr.patch_id); | ||
813 | - return -1; | ||
814 | + return UCODE_ERROR; | ||
815 | } | ||
816 | pr_info("CPU%d: new patch_level=0x%08x\n", cpu, | ||
817 | mc_amd->hdr.patch_id); | ||
818 | @@ -537,7 +537,7 @@ static int apply_microcode_amd(int cpu) | ||
819 | uci->cpu_sig.rev = mc_amd->hdr.patch_id; | ||
820 | c->microcode = mc_amd->hdr.patch_id; | ||
821 | |||
822 | - return 0; | ||
823 | + return UCODE_UPDATED; | ||
824 | } | ||
825 | |||
826 | static int install_equiv_cpu_table(const u8 *buf) | ||
827 | @@ -683,27 +683,35 @@ static enum ucode_state __load_microcode_amd(u8 family, const u8 *data, | ||
828 | static enum ucode_state | ||
829 | load_microcode_amd(bool save, u8 family, const u8 *data, size_t size) | ||
830 | { | ||
831 | + struct ucode_patch *p; | ||
832 | enum ucode_state ret; | ||
833 | |||
834 | /* free old equiv table */ | ||
835 | free_equiv_cpu_table(); | ||
836 | |||
837 | ret = __load_microcode_amd(family, data, size); | ||
838 | - | ||
839 | - if (ret != UCODE_OK) | ||
840 | + if (ret != UCODE_OK) { | ||
841 | cleanup(); | ||
842 | + return ret; | ||
843 | + } | ||
844 | |||
845 | -#ifdef CONFIG_X86_32 | ||
846 | - /* save BSP's matching patch for early load */ | ||
847 | - if (save) { | ||
848 | - struct ucode_patch *p = find_patch(0); | ||
849 | - if (p) { | ||
850 | - memset(amd_ucode_patch, 0, PATCH_MAX_SIZE); | ||
851 | - memcpy(amd_ucode_patch, p->data, min_t(u32, ksize(p->data), | ||
852 | - PATCH_MAX_SIZE)); | ||
853 | - } | ||
854 | + p = find_patch(0); | ||
855 | + if (!p) { | ||
856 | + return ret; | ||
857 | + } else { | ||
858 | + if (boot_cpu_data.microcode == p->patch_id) | ||
859 | + return ret; | ||
860 | + | ||
861 | + ret = UCODE_NEW; | ||
862 | } | ||
863 | -#endif | ||
864 | + | ||
865 | + /* save BSP's matching patch for early load */ | ||
866 | + if (!save) | ||
867 | + return ret; | ||
868 | + | ||
869 | + memset(amd_ucode_patch, 0, PATCH_MAX_SIZE); | ||
870 | + memcpy(amd_ucode_patch, p->data, min_t(u32, ksize(p->data), PATCH_MAX_SIZE)); | ||
871 | + | ||
872 | return ret; | ||
873 | } | ||
874 | |||
875 | diff --git a/arch/x86/kernel/cpu/microcode/core.c b/arch/x86/kernel/cpu/microcode/core.c | ||
876 | index e4fc595cd6ea..021c90464cc2 100644 | ||
877 | --- a/arch/x86/kernel/cpu/microcode/core.c | ||
878 | +++ b/arch/x86/kernel/cpu/microcode/core.c | ||
879 | @@ -22,13 +22,16 @@ | ||
880 | #define pr_fmt(fmt) "microcode: " fmt | ||
881 | |||
882 | #include <linux/platform_device.h> | ||
883 | +#include <linux/stop_machine.h> | ||
884 | #include <linux/syscore_ops.h> | ||
885 | #include <linux/miscdevice.h> | ||
886 | #include <linux/capability.h> | ||
887 | #include <linux/firmware.h> | ||
888 | #include <linux/kernel.h> | ||
889 | +#include <linux/delay.h> | ||
890 | #include <linux/mutex.h> | ||
891 | #include <linux/cpu.h> | ||
892 | +#include <linux/nmi.h> | ||
893 | #include <linux/fs.h> | ||
894 | #include <linux/mm.h> | ||
895 | |||
896 | @@ -64,6 +67,11 @@ LIST_HEAD(microcode_cache); | ||
897 | */ | ||
898 | static DEFINE_MUTEX(microcode_mutex); | ||
899 | |||
900 | +/* | ||
901 | + * Serialize late loading so that CPUs get updated one-by-one. | ||
902 | + */ | ||
903 | +static DEFINE_SPINLOCK(update_lock); | ||
904 | + | ||
905 | struct ucode_cpu_info ucode_cpu_info[NR_CPUS]; | ||
906 | |||
907 | struct cpu_info_ctx { | ||
908 | @@ -373,26 +381,23 @@ static int collect_cpu_info(int cpu) | ||
909 | return ret; | ||
910 | } | ||
911 | |||
912 | -struct apply_microcode_ctx { | ||
913 | - int err; | ||
914 | -}; | ||
915 | - | ||
916 | static void apply_microcode_local(void *arg) | ||
917 | { | ||
918 | - struct apply_microcode_ctx *ctx = arg; | ||
919 | + enum ucode_state *err = arg; | ||
920 | |||
921 | - ctx->err = microcode_ops->apply_microcode(smp_processor_id()); | ||
922 | + *err = microcode_ops->apply_microcode(smp_processor_id()); | ||
923 | } | ||
924 | |||
925 | static int apply_microcode_on_target(int cpu) | ||
926 | { | ||
927 | - struct apply_microcode_ctx ctx = { .err = 0 }; | ||
928 | + enum ucode_state err; | ||
929 | int ret; | ||
930 | |||
931 | - ret = smp_call_function_single(cpu, apply_microcode_local, &ctx, 1); | ||
932 | - if (!ret) | ||
933 | - ret = ctx.err; | ||
934 | - | ||
935 | + ret = smp_call_function_single(cpu, apply_microcode_local, &err, 1); | ||
936 | + if (!ret) { | ||
937 | + if (err == UCODE_ERROR) | ||
938 | + ret = 1; | ||
939 | + } | ||
940 | return ret; | ||
941 | } | ||
942 | |||
943 | @@ -489,31 +494,124 @@ static void __exit microcode_dev_exit(void) | ||
944 | /* fake device for request_firmware */ | ||
945 | static struct platform_device *microcode_pdev; | ||
946 | |||
947 | -static int reload_for_cpu(int cpu) | ||
948 | +/* | ||
949 | + * Late loading dance. Why the heavy-handed stomp_machine effort? | ||
950 | + * | ||
951 | + * - HT siblings must be idle and not execute other code while the other sibling | ||
952 | + * is loading microcode in order to avoid any negative interactions caused by | ||
953 | + * the loading. | ||
954 | + * | ||
955 | + * - In addition, microcode update on the cores must be serialized until this | ||
956 | + * requirement can be relaxed in the future. Right now, this is conservative | ||
957 | + * and good. | ||
958 | + */ | ||
959 | +#define SPINUNIT 100 /* 100 nsec */ | ||
960 | + | ||
961 | +static int check_online_cpus(void) | ||
962 | { | ||
963 | - struct ucode_cpu_info *uci = ucode_cpu_info + cpu; | ||
964 | - enum ucode_state ustate; | ||
965 | - int err = 0; | ||
966 | + if (num_online_cpus() == num_present_cpus()) | ||
967 | + return 0; | ||
968 | |||
969 | - if (!uci->valid) | ||
970 | - return err; | ||
971 | + pr_err("Not all CPUs online, aborting microcode update.\n"); | ||
972 | |||
973 | - ustate = microcode_ops->request_microcode_fw(cpu, µcode_pdev->dev, true); | ||
974 | - if (ustate == UCODE_OK) | ||
975 | - apply_microcode_on_target(cpu); | ||
976 | - else | ||
977 | - if (ustate == UCODE_ERROR) | ||
978 | - err = -EINVAL; | ||
979 | - return err; | ||
980 | + return -EINVAL; | ||
981 | +} | ||
982 | + | ||
983 | +static atomic_t late_cpus_in; | ||
984 | +static atomic_t late_cpus_out; | ||
985 | + | ||
986 | +static int __wait_for_cpus(atomic_t *t, long long timeout) | ||
987 | +{ | ||
988 | + int all_cpus = num_online_cpus(); | ||
989 | + | ||
990 | + atomic_inc(t); | ||
991 | + | ||
992 | + while (atomic_read(t) < all_cpus) { | ||
993 | + if (timeout < SPINUNIT) { | ||
994 | + pr_err("Timeout while waiting for CPUs rendezvous, remaining: %d\n", | ||
995 | + all_cpus - atomic_read(t)); | ||
996 | + return 1; | ||
997 | + } | ||
998 | + | ||
999 | + ndelay(SPINUNIT); | ||
1000 | + timeout -= SPINUNIT; | ||
1001 | + | ||
1002 | + touch_nmi_watchdog(); | ||
1003 | + } | ||
1004 | + return 0; | ||
1005 | +} | ||
1006 | + | ||
1007 | +/* | ||
1008 | + * Returns: | ||
1009 | + * < 0 - on error | ||
1010 | + * 0 - no update done | ||
1011 | + * 1 - microcode was updated | ||
1012 | + */ | ||
1013 | +static int __reload_late(void *info) | ||
1014 | +{ | ||
1015 | + int cpu = smp_processor_id(); | ||
1016 | + enum ucode_state err; | ||
1017 | + int ret = 0; | ||
1018 | + | ||
1019 | + /* | ||
1020 | + * Wait for all CPUs to arrive. A load will not be attempted unless all | ||
1021 | + * CPUs show up. | ||
1022 | + * */ | ||
1023 | + if (__wait_for_cpus(&late_cpus_in, NSEC_PER_SEC)) | ||
1024 | + return -1; | ||
1025 | + | ||
1026 | + spin_lock(&update_lock); | ||
1027 | + apply_microcode_local(&err); | ||
1028 | + spin_unlock(&update_lock); | ||
1029 | + | ||
1030 | + if (err > UCODE_NFOUND) { | ||
1031 | + pr_warn("Error reloading microcode on CPU %d\n", cpu); | ||
1032 | + return -1; | ||
1033 | + /* siblings return UCODE_OK because their engine got updated already */ | ||
1034 | + } else if (err == UCODE_UPDATED || err == UCODE_OK) { | ||
1035 | + ret = 1; | ||
1036 | + } else { | ||
1037 | + return ret; | ||
1038 | + } | ||
1039 | + | ||
1040 | + /* | ||
1041 | + * Increase the wait timeout to a safe value here since we're | ||
1042 | + * serializing the microcode update and that could take a while on a | ||
1043 | + * large number of CPUs. And that is fine as the *actual* timeout will | ||
1044 | + * be determined by the last CPU finished updating and thus cut short. | ||
1045 | + */ | ||
1046 | + if (__wait_for_cpus(&late_cpus_out, NSEC_PER_SEC * num_online_cpus())) | ||
1047 | + panic("Timeout during microcode update!\n"); | ||
1048 | + | ||
1049 | + return ret; | ||
1050 | +} | ||
1051 | + | ||
1052 | +/* | ||
1053 | + * Reload microcode late on all CPUs. Wait for a sec until they | ||
1054 | + * all gather together. | ||
1055 | + */ | ||
1056 | +static int microcode_reload_late(void) | ||
1057 | +{ | ||
1058 | + int ret; | ||
1059 | + | ||
1060 | + atomic_set(&late_cpus_in, 0); | ||
1061 | + atomic_set(&late_cpus_out, 0); | ||
1062 | + | ||
1063 | + ret = stop_machine_cpuslocked(__reload_late, NULL, cpu_online_mask); | ||
1064 | + if (ret > 0) | ||
1065 | + microcode_check(); | ||
1066 | + | ||
1067 | + return ret; | ||
1068 | } | ||
1069 | |||
1070 | static ssize_t reload_store(struct device *dev, | ||
1071 | struct device_attribute *attr, | ||
1072 | const char *buf, size_t size) | ||
1073 | { | ||
1074 | + enum ucode_state tmp_ret = UCODE_OK; | ||
1075 | + int bsp = boot_cpu_data.cpu_index; | ||
1076 | unsigned long val; | ||
1077 | - int cpu; | ||
1078 | - ssize_t ret = 0, tmp_ret; | ||
1079 | + ssize_t ret = 0; | ||
1080 | |||
1081 | ret = kstrtoul(buf, 0, &val); | ||
1082 | if (ret) | ||
1083 | @@ -522,23 +620,24 @@ static ssize_t reload_store(struct device *dev, | ||
1084 | if (val != 1) | ||
1085 | return size; | ||
1086 | |||
1087 | + tmp_ret = microcode_ops->request_microcode_fw(bsp, µcode_pdev->dev, true); | ||
1088 | + if (tmp_ret != UCODE_NEW) | ||
1089 | + return size; | ||
1090 | + | ||
1091 | get_online_cpus(); | ||
1092 | - mutex_lock(µcode_mutex); | ||
1093 | - for_each_online_cpu(cpu) { | ||
1094 | - tmp_ret = reload_for_cpu(cpu); | ||
1095 | - if (tmp_ret != 0) | ||
1096 | - pr_warn("Error reloading microcode on CPU %d\n", cpu); | ||
1097 | |||
1098 | - /* save retval of the first encountered reload error */ | ||
1099 | - if (!ret) | ||
1100 | - ret = tmp_ret; | ||
1101 | - } | ||
1102 | - if (!ret) | ||
1103 | - perf_check_microcode(); | ||
1104 | + ret = check_online_cpus(); | ||
1105 | + if (ret) | ||
1106 | + goto put; | ||
1107 | + | ||
1108 | + mutex_lock(µcode_mutex); | ||
1109 | + ret = microcode_reload_late(); | ||
1110 | mutex_unlock(µcode_mutex); | ||
1111 | + | ||
1112 | +put: | ||
1113 | put_online_cpus(); | ||
1114 | |||
1115 | - if (!ret) | ||
1116 | + if (ret >= 0) | ||
1117 | ret = size; | ||
1118 | |||
1119 | return ret; | ||
1120 | @@ -606,10 +705,8 @@ static enum ucode_state microcode_init_cpu(int cpu, bool refresh_fw) | ||
1121 | if (system_state != SYSTEM_RUNNING) | ||
1122 | return UCODE_NFOUND; | ||
1123 | |||
1124 | - ustate = microcode_ops->request_microcode_fw(cpu, µcode_pdev->dev, | ||
1125 | - refresh_fw); | ||
1126 | - | ||
1127 | - if (ustate == UCODE_OK) { | ||
1128 | + ustate = microcode_ops->request_microcode_fw(cpu, µcode_pdev->dev, refresh_fw); | ||
1129 | + if (ustate == UCODE_NEW) { | ||
1130 | pr_debug("CPU%d updated upon init\n", cpu); | ||
1131 | apply_microcode_on_target(cpu); | ||
1132 | } | ||
1133 | diff --git a/arch/x86/kernel/cpu/microcode/intel.c b/arch/x86/kernel/cpu/microcode/intel.c | ||
1134 | index a15db2b4e0d6..32b8e5724f96 100644 | ||
1135 | --- a/arch/x86/kernel/cpu/microcode/intel.c | ||
1136 | +++ b/arch/x86/kernel/cpu/microcode/intel.c | ||
1137 | @@ -589,6 +589,23 @@ static int apply_microcode_early(struct ucode_cpu_info *uci, bool early) | ||
1138 | if (!mc) | ||
1139 | return 0; | ||
1140 | |||
1141 | + /* | ||
1142 | + * Save us the MSR write below - which is a particular expensive | ||
1143 | + * operation - when the other hyperthread has updated the microcode | ||
1144 | + * already. | ||
1145 | + */ | ||
1146 | + rev = intel_get_microcode_revision(); | ||
1147 | + if (rev >= mc->hdr.rev) { | ||
1148 | + uci->cpu_sig.rev = rev; | ||
1149 | + return UCODE_OK; | ||
1150 | + } | ||
1151 | + | ||
1152 | + /* | ||
1153 | + * Writeback and invalidate caches before updating microcode to avoid | ||
1154 | + * internal issues depending on what the microcode is updating. | ||
1155 | + */ | ||
1156 | + native_wbinvd(); | ||
1157 | + | ||
1158 | /* write microcode via MSR 0x79 */ | ||
1159 | native_wrmsrl(MSR_IA32_UCODE_WRITE, (unsigned long)mc->bits); | ||
1160 | |||
1161 | @@ -772,27 +789,44 @@ static int collect_cpu_info(int cpu_num, struct cpu_signature *csig) | ||
1162 | return 0; | ||
1163 | } | ||
1164 | |||
1165 | -static int apply_microcode_intel(int cpu) | ||
1166 | +static enum ucode_state apply_microcode_intel(int cpu) | ||
1167 | { | ||
1168 | + struct ucode_cpu_info *uci = ucode_cpu_info + cpu; | ||
1169 | + struct cpuinfo_x86 *c = &cpu_data(cpu); | ||
1170 | struct microcode_intel *mc; | ||
1171 | - struct ucode_cpu_info *uci; | ||
1172 | - struct cpuinfo_x86 *c; | ||
1173 | static int prev_rev; | ||
1174 | u32 rev; | ||
1175 | |||
1176 | /* We should bind the task to the CPU */ | ||
1177 | if (WARN_ON(raw_smp_processor_id() != cpu)) | ||
1178 | - return -1; | ||
1179 | + return UCODE_ERROR; | ||
1180 | |||
1181 | - uci = ucode_cpu_info + cpu; | ||
1182 | - mc = uci->mc; | ||
1183 | + /* Look for a newer patch in our cache: */ | ||
1184 | + mc = find_patch(uci); | ||
1185 | if (!mc) { | ||
1186 | - /* Look for a newer patch in our cache: */ | ||
1187 | - mc = find_patch(uci); | ||
1188 | + mc = uci->mc; | ||
1189 | if (!mc) | ||
1190 | - return 0; | ||
1191 | + return UCODE_NFOUND; | ||
1192 | } | ||
1193 | |||
1194 | + /* | ||
1195 | + * Save us the MSR write below - which is a particular expensive | ||
1196 | + * operation - when the other hyperthread has updated the microcode | ||
1197 | + * already. | ||
1198 | + */ | ||
1199 | + rev = intel_get_microcode_revision(); | ||
1200 | + if (rev >= mc->hdr.rev) { | ||
1201 | + uci->cpu_sig.rev = rev; | ||
1202 | + c->microcode = rev; | ||
1203 | + return UCODE_OK; | ||
1204 | + } | ||
1205 | + | ||
1206 | + /* | ||
1207 | + * Writeback and invalidate caches before updating microcode to avoid | ||
1208 | + * internal issues depending on what the microcode is updating. | ||
1209 | + */ | ||
1210 | + native_wbinvd(); | ||
1211 | + | ||
1212 | /* write microcode via MSR 0x79 */ | ||
1213 | wrmsrl(MSR_IA32_UCODE_WRITE, (unsigned long)mc->bits); | ||
1214 | |||
1215 | @@ -801,7 +835,7 @@ static int apply_microcode_intel(int cpu) | ||
1216 | if (rev != mc->hdr.rev) { | ||
1217 | pr_err("CPU%d update to revision 0x%x failed\n", | ||
1218 | cpu, mc->hdr.rev); | ||
1219 | - return -1; | ||
1220 | + return UCODE_ERROR; | ||
1221 | } | ||
1222 | |||
1223 | if (rev != prev_rev) { | ||
1224 | @@ -813,12 +847,10 @@ static int apply_microcode_intel(int cpu) | ||
1225 | prev_rev = rev; | ||
1226 | } | ||
1227 | |||
1228 | - c = &cpu_data(cpu); | ||
1229 | - | ||
1230 | uci->cpu_sig.rev = rev; | ||
1231 | c->microcode = rev; | ||
1232 | |||
1233 | - return 0; | ||
1234 | + return UCODE_UPDATED; | ||
1235 | } | ||
1236 | |||
1237 | static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size, | ||
1238 | @@ -830,6 +862,7 @@ static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size, | ||
1239 | unsigned int leftover = size; | ||
1240 | unsigned int curr_mc_size = 0, new_mc_size = 0; | ||
1241 | unsigned int csig, cpf; | ||
1242 | + enum ucode_state ret = UCODE_OK; | ||
1243 | |||
1244 | while (leftover) { | ||
1245 | struct microcode_header_intel mc_header; | ||
1246 | @@ -871,6 +904,7 @@ static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size, | ||
1247 | new_mc = mc; | ||
1248 | new_mc_size = mc_size; | ||
1249 | mc = NULL; /* trigger new vmalloc */ | ||
1250 | + ret = UCODE_NEW; | ||
1251 | } | ||
1252 | |||
1253 | ucode_ptr += mc_size; | ||
1254 | @@ -900,7 +934,7 @@ static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size, | ||
1255 | pr_debug("CPU%d found a matching microcode update with version 0x%x (current=0x%x)\n", | ||
1256 | cpu, new_rev, uci->cpu_sig.rev); | ||
1257 | |||
1258 | - return UCODE_OK; | ||
1259 | + return ret; | ||
1260 | } | ||
1261 | |||
1262 | static int get_ucode_fw(void *to, const void *from, size_t n) | ||
1263 | diff --git a/arch/x86/xen/mmu_hvm.c b/arch/x86/xen/mmu_hvm.c | ||
1264 | index 2cfcfe4f6b2a..dd2ad82eee80 100644 | ||
1265 | --- a/arch/x86/xen/mmu_hvm.c | ||
1266 | +++ b/arch/x86/xen/mmu_hvm.c | ||
1267 | @@ -75,6 +75,6 @@ void __init xen_hvm_init_mmu_ops(void) | ||
1268 | if (is_pagetable_dying_supported()) | ||
1269 | pv_mmu_ops.exit_mmap = xen_hvm_exit_mmap; | ||
1270 | #ifdef CONFIG_PROC_VMCORE | ||
1271 | - register_oldmem_pfn_is_ram(&xen_oldmem_pfn_is_ram); | ||
1272 | + WARN_ON(register_oldmem_pfn_is_ram(&xen_oldmem_pfn_is_ram)); | ||
1273 | #endif | ||
1274 | } | ||
1275 | diff --git a/block/bfq-cgroup.c b/block/bfq-cgroup.c | ||
1276 | index ceefb9a706d6..5d53e504acae 100644 | ||
1277 | --- a/block/bfq-cgroup.c | ||
1278 | +++ b/block/bfq-cgroup.c | ||
1279 | @@ -749,10 +749,11 @@ static void bfq_pd_offline(struct blkg_policy_data *pd) | ||
1280 | unsigned long flags; | ||
1281 | int i; | ||
1282 | |||
1283 | + spin_lock_irqsave(&bfqd->lock, flags); | ||
1284 | + | ||
1285 | if (!entity) /* root group */ | ||
1286 | - return; | ||
1287 | + goto put_async_queues; | ||
1288 | |||
1289 | - spin_lock_irqsave(&bfqd->lock, flags); | ||
1290 | /* | ||
1291 | * Empty all service_trees belonging to this group before | ||
1292 | * deactivating the group itself. | ||
1293 | @@ -783,6 +784,8 @@ static void bfq_pd_offline(struct blkg_policy_data *pd) | ||
1294 | } | ||
1295 | |||
1296 | __bfq_deactivate_entity(entity, false); | ||
1297 | + | ||
1298 | +put_async_queues: | ||
1299 | bfq_put_async_queues(bfqd, bfqg); | ||
1300 | |||
1301 | spin_unlock_irqrestore(&bfqd->lock, flags); | ||
1302 | diff --git a/block/blk-mq.c b/block/blk-mq.c | ||
1303 | index f1fb126a3be5..6f899669cbdd 100644 | ||
1304 | --- a/block/blk-mq.c | ||
1305 | +++ b/block/blk-mq.c | ||
1306 | @@ -1928,7 +1928,8 @@ static void blk_mq_exit_hctx(struct request_queue *q, | ||
1307 | { | ||
1308 | blk_mq_debugfs_unregister_hctx(hctx); | ||
1309 | |||
1310 | - blk_mq_tag_idle(hctx); | ||
1311 | + if (blk_mq_hw_queue_mapped(hctx)) | ||
1312 | + blk_mq_tag_idle(hctx); | ||
1313 | |||
1314 | if (set->ops->exit_request) | ||
1315 | set->ops->exit_request(set, hctx->fq->flush_rq, hctx_idx); | ||
1316 | @@ -2314,6 +2315,9 @@ static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set, | ||
1317 | struct blk_mq_hw_ctx **hctxs = q->queue_hw_ctx; | ||
1318 | |||
1319 | blk_mq_sysfs_unregister(q); | ||
1320 | + | ||
1321 | + /* protect against switching io scheduler */ | ||
1322 | + mutex_lock(&q->sysfs_lock); | ||
1323 | for (i = 0; i < set->nr_hw_queues; i++) { | ||
1324 | int node; | ||
1325 | |||
1326 | @@ -2358,6 +2362,7 @@ static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set, | ||
1327 | } | ||
1328 | } | ||
1329 | q->nr_hw_queues = i; | ||
1330 | + mutex_unlock(&q->sysfs_lock); | ||
1331 | blk_mq_sysfs_register(q); | ||
1332 | } | ||
1333 | |||
1334 | @@ -2528,9 +2533,27 @@ static int blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set) | ||
1335 | |||
1336 | static int blk_mq_update_queue_map(struct blk_mq_tag_set *set) | ||
1337 | { | ||
1338 | - if (set->ops->map_queues) | ||
1339 | + if (set->ops->map_queues) { | ||
1340 | + int cpu; | ||
1341 | + /* | ||
1342 | + * transport .map_queues is usually done in the following | ||
1343 | + * way: | ||
1344 | + * | ||
1345 | + * for (queue = 0; queue < set->nr_hw_queues; queue++) { | ||
1346 | + * mask = get_cpu_mask(queue) | ||
1347 | + * for_each_cpu(cpu, mask) | ||
1348 | + * set->mq_map[cpu] = queue; | ||
1349 | + * } | ||
1350 | + * | ||
1351 | + * When we need to remap, the table has to be cleared for | ||
1352 | + * killing stale mapping since one CPU may not be mapped | ||
1353 | + * to any hw queue. | ||
1354 | + */ | ||
1355 | + for_each_possible_cpu(cpu) | ||
1356 | + set->mq_map[cpu] = 0; | ||
1357 | + | ||
1358 | return set->ops->map_queues(set); | ||
1359 | - else | ||
1360 | + } else | ||
1361 | return blk_mq_map_queues(set); | ||
1362 | } | ||
1363 | |||
1364 | diff --git a/crypto/Makefile b/crypto/Makefile | ||
1365 | index da190be60ce2..adaf2c63baeb 100644 | ||
1366 | --- a/crypto/Makefile | ||
1367 | +++ b/crypto/Makefile | ||
1368 | @@ -98,6 +98,7 @@ obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o | ||
1369 | obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o | ||
1370 | CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 | ||
1371 | obj-$(CONFIG_CRYPTO_AES) += aes_generic.o | ||
1372 | +CFLAGS_aes_generic.o := $(call cc-ifversion, -ge, 0701, -Os) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83356 | ||
1373 | obj-$(CONFIG_CRYPTO_AES_TI) += aes_ti.o | ||
1374 | obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o | ||
1375 | obj-$(CONFIG_CRYPTO_CAST_COMMON) += cast_common.o | ||
1376 | diff --git a/drivers/acpi/acpi_video.c b/drivers/acpi/acpi_video.c | ||
1377 | index 0972ec0e2eb8..f53ccc680238 100644 | ||
1378 | --- a/drivers/acpi/acpi_video.c | ||
1379 | +++ b/drivers/acpi/acpi_video.c | ||
1380 | @@ -80,8 +80,8 @@ MODULE_PARM_DESC(report_key_events, | ||
1381 | static bool device_id_scheme = false; | ||
1382 | module_param(device_id_scheme, bool, 0444); | ||
1383 | |||
1384 | -static bool only_lcd = false; | ||
1385 | -module_param(only_lcd, bool, 0444); | ||
1386 | +static int only_lcd = -1; | ||
1387 | +module_param(only_lcd, int, 0444); | ||
1388 | |||
1389 | static int register_count; | ||
1390 | static DEFINE_MUTEX(register_count_mutex); | ||
1391 | @@ -2136,6 +2136,16 @@ int acpi_video_register(void) | ||
1392 | goto leave; | ||
1393 | } | ||
1394 | |||
1395 | + /* | ||
1396 | + * We're seeing a lot of bogus backlight interfaces on newer machines | ||
1397 | + * without a LCD such as desktops, servers and HDMI sticks. Checking | ||
1398 | + * the lcd flag fixes this, so enable this on any machines which are | ||
1399 | + * win8 ready (where we also prefer the native backlight driver, so | ||
1400 | + * normally the acpi_video code should not register there anyways). | ||
1401 | + */ | ||
1402 | + if (only_lcd == -1) | ||
1403 | + only_lcd = acpi_osi_is_win8(); | ||
1404 | + | ||
1405 | dmi_check_system(video_dmi_table); | ||
1406 | |||
1407 | ret = acpi_bus_register_driver(&acpi_video_bus); | ||
1408 | diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c | ||
1409 | index df842465634a..6adcda057b36 100644 | ||
1410 | --- a/drivers/acpi/ec.c | ||
1411 | +++ b/drivers/acpi/ec.c | ||
1412 | @@ -1516,7 +1516,7 @@ static int acpi_ec_setup(struct acpi_ec *ec, bool handle_events) | ||
1413 | } | ||
1414 | |||
1415 | acpi_handle_info(ec->handle, | ||
1416 | - "GPE=0x%lx, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", | ||
1417 | + "GPE=0x%x, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", | ||
1418 | ec->gpe, ec->command_addr, ec->data_addr); | ||
1419 | return ret; | ||
1420 | } | ||
1421 | diff --git a/drivers/acpi/ec_sys.c b/drivers/acpi/ec_sys.c | ||
1422 | index 6c7dd7af789e..dd70d6c2bca0 100644 | ||
1423 | --- a/drivers/acpi/ec_sys.c | ||
1424 | +++ b/drivers/acpi/ec_sys.c | ||
1425 | @@ -128,7 +128,7 @@ static int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count) | ||
1426 | return -ENOMEM; | ||
1427 | } | ||
1428 | |||
1429 | - if (!debugfs_create_x32("gpe", 0444, dev_dir, (u32 *)&first_ec->gpe)) | ||
1430 | + if (!debugfs_create_x32("gpe", 0444, dev_dir, &first_ec->gpe)) | ||
1431 | goto error; | ||
1432 | if (!debugfs_create_bool("use_global_lock", 0444, dev_dir, | ||
1433 | &first_ec->global_lock)) | ||
1434 | diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h | ||
1435 | index ede83d38beed..2cd2ae152ab7 100644 | ||
1436 | --- a/drivers/acpi/internal.h | ||
1437 | +++ b/drivers/acpi/internal.h | ||
1438 | @@ -159,7 +159,7 @@ static inline void acpi_early_processor_osc(void) {} | ||
1439 | -------------------------------------------------------------------------- */ | ||
1440 | struct acpi_ec { | ||
1441 | acpi_handle handle; | ||
1442 | - unsigned long gpe; | ||
1443 | + u32 gpe; | ||
1444 | unsigned long command_addr; | ||
1445 | unsigned long data_addr; | ||
1446 | bool global_lock; | ||
1447 | diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c | ||
1448 | index b2c0306f97ed..e9dff868c028 100644 | ||
1449 | --- a/drivers/bluetooth/btusb.c | ||
1450 | +++ b/drivers/bluetooth/btusb.c | ||
1451 | @@ -277,6 +277,7 @@ static const struct usb_device_id blacklist_table[] = { | ||
1452 | { USB_DEVICE(0x0489, 0xe09f), .driver_info = BTUSB_QCA_ROME }, | ||
1453 | { USB_DEVICE(0x0489, 0xe0a2), .driver_info = BTUSB_QCA_ROME }, | ||
1454 | { USB_DEVICE(0x04ca, 0x3011), .driver_info = BTUSB_QCA_ROME }, | ||
1455 | + { USB_DEVICE(0x04ca, 0x3015), .driver_info = BTUSB_QCA_ROME }, | ||
1456 | { USB_DEVICE(0x04ca, 0x3016), .driver_info = BTUSB_QCA_ROME }, | ||
1457 | |||
1458 | /* Broadcom BCM2035 */ | ||
1459 | diff --git a/drivers/char/tpm/tpm-interface.c b/drivers/char/tpm/tpm-interface.c | ||
1460 | index 5294442505cb..0f1dc35e7078 100644 | ||
1461 | --- a/drivers/char/tpm/tpm-interface.c | ||
1462 | +++ b/drivers/char/tpm/tpm-interface.c | ||
1463 | @@ -328,7 +328,7 @@ unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, | ||
1464 | } | ||
1465 | EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration); | ||
1466 | |||
1467 | -static bool tpm_validate_command(struct tpm_chip *chip, | ||
1468 | +static int tpm_validate_command(struct tpm_chip *chip, | ||
1469 | struct tpm_space *space, | ||
1470 | const u8 *cmd, | ||
1471 | size_t len) | ||
1472 | @@ -340,10 +340,10 @@ static bool tpm_validate_command(struct tpm_chip *chip, | ||
1473 | unsigned int nr_handles; | ||
1474 | |||
1475 | if (len < TPM_HEADER_SIZE) | ||
1476 | - return false; | ||
1477 | + return -EINVAL; | ||
1478 | |||
1479 | if (!space) | ||
1480 | - return true; | ||
1481 | + return 0; | ||
1482 | |||
1483 | if (chip->flags & TPM_CHIP_FLAG_TPM2 && chip->nr_commands) { | ||
1484 | cc = be32_to_cpu(header->ordinal); | ||
1485 | @@ -352,7 +352,7 @@ static bool tpm_validate_command(struct tpm_chip *chip, | ||
1486 | if (i < 0) { | ||
1487 | dev_dbg(&chip->dev, "0x%04X is an invalid command\n", | ||
1488 | cc); | ||
1489 | - return false; | ||
1490 | + return -EOPNOTSUPP; | ||
1491 | } | ||
1492 | |||
1493 | attrs = chip->cc_attrs_tbl[i]; | ||
1494 | @@ -362,11 +362,11 @@ static bool tpm_validate_command(struct tpm_chip *chip, | ||
1495 | goto err_len; | ||
1496 | } | ||
1497 | |||
1498 | - return true; | ||
1499 | + return 0; | ||
1500 | err_len: | ||
1501 | dev_dbg(&chip->dev, | ||
1502 | "%s: insufficient command length %zu", __func__, len); | ||
1503 | - return false; | ||
1504 | + return -EINVAL; | ||
1505 | } | ||
1506 | |||
1507 | /** | ||
1508 | @@ -391,8 +391,20 @@ ssize_t tpm_transmit(struct tpm_chip *chip, struct tpm_space *space, | ||
1509 | unsigned long stop; | ||
1510 | bool need_locality; | ||
1511 | |||
1512 | - if (!tpm_validate_command(chip, space, buf, bufsiz)) | ||
1513 | - return -EINVAL; | ||
1514 | + rc = tpm_validate_command(chip, space, buf, bufsiz); | ||
1515 | + if (rc == -EINVAL) | ||
1516 | + return rc; | ||
1517 | + /* | ||
1518 | + * If the command is not implemented by the TPM, synthesize a | ||
1519 | + * response with a TPM2_RC_COMMAND_CODE return for user-space. | ||
1520 | + */ | ||
1521 | + if (rc == -EOPNOTSUPP) { | ||
1522 | + header->length = cpu_to_be32(sizeof(*header)); | ||
1523 | + header->tag = cpu_to_be16(TPM2_ST_NO_SESSIONS); | ||
1524 | + header->return_code = cpu_to_be32(TPM2_RC_COMMAND_CODE | | ||
1525 | + TSS2_RESMGR_TPM_RC_LAYER); | ||
1526 | + return bufsiz; | ||
1527 | + } | ||
1528 | |||
1529 | if (bufsiz > TPM_BUFSIZE) | ||
1530 | bufsiz = TPM_BUFSIZE; | ||
1531 | diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h | ||
1532 | index 2d5466a72e40..0b5b499f726a 100644 | ||
1533 | --- a/drivers/char/tpm/tpm.h | ||
1534 | +++ b/drivers/char/tpm/tpm.h | ||
1535 | @@ -93,12 +93,17 @@ enum tpm2_structures { | ||
1536 | TPM2_ST_SESSIONS = 0x8002, | ||
1537 | }; | ||
1538 | |||
1539 | +/* Indicates from what layer of the software stack the error comes from */ | ||
1540 | +#define TSS2_RC_LAYER_SHIFT 16 | ||
1541 | +#define TSS2_RESMGR_TPM_RC_LAYER (11 << TSS2_RC_LAYER_SHIFT) | ||
1542 | + | ||
1543 | enum tpm2_return_codes { | ||
1544 | TPM2_RC_SUCCESS = 0x0000, | ||
1545 | TPM2_RC_HASH = 0x0083, /* RC_FMT1 */ | ||
1546 | TPM2_RC_HANDLE = 0x008B, | ||
1547 | TPM2_RC_INITIALIZE = 0x0100, /* RC_VER1 */ | ||
1548 | TPM2_RC_DISABLED = 0x0120, | ||
1549 | + TPM2_RC_COMMAND_CODE = 0x0143, | ||
1550 | TPM2_RC_TESTING = 0x090A, /* RC_WARN */ | ||
1551 | TPM2_RC_REFERENCE_H0 = 0x0910, | ||
1552 | }; | ||
1553 | diff --git a/drivers/clk/clk-divider.c b/drivers/clk/clk-divider.c | ||
1554 | index 4ed516cb7276..b49942b9fe50 100644 | ||
1555 | --- a/drivers/clk/clk-divider.c | ||
1556 | +++ b/drivers/clk/clk-divider.c | ||
1557 | @@ -118,12 +118,11 @@ static unsigned int _get_val(const struct clk_div_table *table, | ||
1558 | unsigned long divider_recalc_rate(struct clk_hw *hw, unsigned long parent_rate, | ||
1559 | unsigned int val, | ||
1560 | const struct clk_div_table *table, | ||
1561 | - unsigned long flags) | ||
1562 | + unsigned long flags, unsigned long width) | ||
1563 | { | ||
1564 | - struct clk_divider *divider = to_clk_divider(hw); | ||
1565 | unsigned int div; | ||
1566 | |||
1567 | - div = _get_div(table, val, flags, divider->width); | ||
1568 | + div = _get_div(table, val, flags, width); | ||
1569 | if (!div) { | ||
1570 | WARN(!(flags & CLK_DIVIDER_ALLOW_ZERO), | ||
1571 | "%s: Zero divisor and CLK_DIVIDER_ALLOW_ZERO not set\n", | ||
1572 | @@ -145,7 +144,7 @@ static unsigned long clk_divider_recalc_rate(struct clk_hw *hw, | ||
1573 | val &= div_mask(divider->width); | ||
1574 | |||
1575 | return divider_recalc_rate(hw, parent_rate, val, divider->table, | ||
1576 | - divider->flags); | ||
1577 | + divider->flags, divider->width); | ||
1578 | } | ||
1579 | |||
1580 | static bool _is_valid_table_div(const struct clk_div_table *table, | ||
1581 | diff --git a/drivers/clk/hisilicon/clkdivider-hi6220.c b/drivers/clk/hisilicon/clkdivider-hi6220.c | ||
1582 | index a1c1f684ad58..9f46cf9dcc65 100644 | ||
1583 | --- a/drivers/clk/hisilicon/clkdivider-hi6220.c | ||
1584 | +++ b/drivers/clk/hisilicon/clkdivider-hi6220.c | ||
1585 | @@ -56,7 +56,7 @@ static unsigned long hi6220_clkdiv_recalc_rate(struct clk_hw *hw, | ||
1586 | val &= div_mask(dclk->width); | ||
1587 | |||
1588 | return divider_recalc_rate(hw, parent_rate, val, dclk->table, | ||
1589 | - CLK_DIVIDER_ROUND_CLOSEST); | ||
1590 | + CLK_DIVIDER_ROUND_CLOSEST, dclk->width); | ||
1591 | } | ||
1592 | |||
1593 | static long hi6220_clkdiv_round_rate(struct clk_hw *hw, unsigned long rate, | ||
1594 | diff --git a/drivers/clk/meson/clk-mpll.c b/drivers/clk/meson/clk-mpll.c | ||
1595 | index 44a5a535ca63..5144360e2c80 100644 | ||
1596 | --- a/drivers/clk/meson/clk-mpll.c | ||
1597 | +++ b/drivers/clk/meson/clk-mpll.c | ||
1598 | @@ -98,7 +98,7 @@ static void params_from_rate(unsigned long requested_rate, | ||
1599 | *sdm = SDM_DEN - 1; | ||
1600 | } else { | ||
1601 | *n2 = div; | ||
1602 | - *sdm = DIV_ROUND_UP(rem * SDM_DEN, requested_rate); | ||
1603 | + *sdm = DIV_ROUND_UP_ULL((u64)rem * SDM_DEN, requested_rate); | ||
1604 | } | ||
1605 | } | ||
1606 | |||
1607 | diff --git a/drivers/clk/nxp/clk-lpc32xx.c b/drivers/clk/nxp/clk-lpc32xx.c | ||
1608 | index 7b359afd620e..a6438f50e6db 100644 | ||
1609 | --- a/drivers/clk/nxp/clk-lpc32xx.c | ||
1610 | +++ b/drivers/clk/nxp/clk-lpc32xx.c | ||
1611 | @@ -956,7 +956,7 @@ static unsigned long clk_divider_recalc_rate(struct clk_hw *hw, | ||
1612 | val &= div_mask(divider->width); | ||
1613 | |||
1614 | return divider_recalc_rate(hw, parent_rate, val, divider->table, | ||
1615 | - divider->flags); | ||
1616 | + divider->flags, divider->width); | ||
1617 | } | ||
1618 | |||
1619 | static long clk_divider_round_rate(struct clk_hw *hw, unsigned long rate, | ||
1620 | diff --git a/drivers/clk/qcom/clk-regmap-divider.c b/drivers/clk/qcom/clk-regmap-divider.c | ||
1621 | index 53484912301e..928fcc16ee27 100644 | ||
1622 | --- a/drivers/clk/qcom/clk-regmap-divider.c | ||
1623 | +++ b/drivers/clk/qcom/clk-regmap-divider.c | ||
1624 | @@ -59,7 +59,7 @@ static unsigned long div_recalc_rate(struct clk_hw *hw, | ||
1625 | div &= BIT(divider->width) - 1; | ||
1626 | |||
1627 | return divider_recalc_rate(hw, parent_rate, div, NULL, | ||
1628 | - CLK_DIVIDER_ROUND_CLOSEST); | ||
1629 | + CLK_DIVIDER_ROUND_CLOSEST, divider->width); | ||
1630 | } | ||
1631 | |||
1632 | const struct clk_ops clk_regmap_div_ops = { | ||
1633 | diff --git a/drivers/clk/sunxi-ng/ccu-sun8i-a83t.c b/drivers/clk/sunxi-ng/ccu-sun8i-a83t.c | ||
1634 | index f8203115a6bc..c10160d7a556 100644 | ||
1635 | --- a/drivers/clk/sunxi-ng/ccu-sun8i-a83t.c | ||
1636 | +++ b/drivers/clk/sunxi-ng/ccu-sun8i-a83t.c | ||
1637 | @@ -493,8 +493,8 @@ static SUNXI_CCU_MUX_WITH_GATE(tcon0_clk, "tcon0", tcon0_parents, | ||
1638 | 0x118, 24, 3, BIT(31), CLK_SET_RATE_PARENT); | ||
1639 | |||
1640 | static const char * const tcon1_parents[] = { "pll-video1" }; | ||
1641 | -static SUNXI_CCU_MUX_WITH_GATE(tcon1_clk, "tcon1", tcon1_parents, | ||
1642 | - 0x11c, 24, 3, BIT(31), CLK_SET_RATE_PARENT); | ||
1643 | +static SUNXI_CCU_M_WITH_MUX_GATE(tcon1_clk, "tcon1", tcon1_parents, | ||
1644 | + 0x11c, 0, 4, 24, 2, BIT(31), CLK_SET_RATE_PARENT); | ||
1645 | |||
1646 | static SUNXI_CCU_GATE(csi_misc_clk, "csi-misc", "osc24M", 0x130, BIT(16), 0); | ||
1647 | |||
1648 | diff --git a/drivers/clk/sunxi-ng/ccu_div.c b/drivers/clk/sunxi-ng/ccu_div.c | ||
1649 | index baa3cf96507b..302a18efd39f 100644 | ||
1650 | --- a/drivers/clk/sunxi-ng/ccu_div.c | ||
1651 | +++ b/drivers/clk/sunxi-ng/ccu_div.c | ||
1652 | @@ -71,7 +71,7 @@ static unsigned long ccu_div_recalc_rate(struct clk_hw *hw, | ||
1653 | parent_rate); | ||
1654 | |||
1655 | val = divider_recalc_rate(hw, parent_rate, val, cd->div.table, | ||
1656 | - cd->div.flags); | ||
1657 | + cd->div.flags, cd->div.width); | ||
1658 | |||
1659 | if (cd->common.features & CCU_FEATURE_FIXED_POSTDIV) | ||
1660 | val /= cd->fixed_post_div; | ||
1661 | diff --git a/drivers/cpufreq/powernv-cpufreq.c b/drivers/cpufreq/powernv-cpufreq.c | ||
1662 | index 7e1e5bbcf430..6b3a63545619 100644 | ||
1663 | --- a/drivers/cpufreq/powernv-cpufreq.c | ||
1664 | +++ b/drivers/cpufreq/powernv-cpufreq.c | ||
1665 | @@ -41,11 +41,9 @@ | ||
1666 | #define POWERNV_MAX_PSTATES 256 | ||
1667 | #define PMSR_PSAFE_ENABLE (1UL << 30) | ||
1668 | #define PMSR_SPR_EM_DISABLE (1UL << 31) | ||
1669 | -#define PMSR_MAX(x) ((x >> 32) & 0xFF) | ||
1670 | +#define MAX_PSTATE_SHIFT 32 | ||
1671 | #define LPSTATE_SHIFT 48 | ||
1672 | #define GPSTATE_SHIFT 56 | ||
1673 | -#define GET_LPSTATE(x) (((x) >> LPSTATE_SHIFT) & 0xFF) | ||
1674 | -#define GET_GPSTATE(x) (((x) >> GPSTATE_SHIFT) & 0xFF) | ||
1675 | |||
1676 | #define MAX_RAMP_DOWN_TIME 5120 | ||
1677 | /* | ||
1678 | @@ -93,6 +91,7 @@ struct global_pstate_info { | ||
1679 | }; | ||
1680 | |||
1681 | static struct cpufreq_frequency_table powernv_freqs[POWERNV_MAX_PSTATES+1]; | ||
1682 | +u32 pstate_sign_prefix; | ||
1683 | static bool rebooting, throttled, occ_reset; | ||
1684 | |||
1685 | static const char * const throttle_reason[] = { | ||
1686 | @@ -147,6 +146,20 @@ static struct powernv_pstate_info { | ||
1687 | bool wof_enabled; | ||
1688 | } powernv_pstate_info; | ||
1689 | |||
1690 | +static inline int extract_pstate(u64 pmsr_val, unsigned int shift) | ||
1691 | +{ | ||
1692 | + int ret = ((pmsr_val >> shift) & 0xFF); | ||
1693 | + | ||
1694 | + if (!ret) | ||
1695 | + return ret; | ||
1696 | + | ||
1697 | + return (pstate_sign_prefix | ret); | ||
1698 | +} | ||
1699 | + | ||
1700 | +#define extract_local_pstate(x) extract_pstate(x, LPSTATE_SHIFT) | ||
1701 | +#define extract_global_pstate(x) extract_pstate(x, GPSTATE_SHIFT) | ||
1702 | +#define extract_max_pstate(x) extract_pstate(x, MAX_PSTATE_SHIFT) | ||
1703 | + | ||
1704 | /* Use following macros for conversions between pstate_id and index */ | ||
1705 | static inline int idx_to_pstate(unsigned int i) | ||
1706 | { | ||
1707 | @@ -277,6 +290,9 @@ static int init_powernv_pstates(void) | ||
1708 | |||
1709 | powernv_pstate_info.nr_pstates = nr_pstates; | ||
1710 | pr_debug("NR PStates %d\n", nr_pstates); | ||
1711 | + | ||
1712 | + pstate_sign_prefix = pstate_min & ~0xFF; | ||
1713 | + | ||
1714 | for (i = 0; i < nr_pstates; i++) { | ||
1715 | u32 id = be32_to_cpu(pstate_ids[i]); | ||
1716 | u32 freq = be32_to_cpu(pstate_freqs[i]); | ||
1717 | @@ -437,17 +453,10 @@ struct powernv_smp_call_data { | ||
1718 | static void powernv_read_cpu_freq(void *arg) | ||
1719 | { | ||
1720 | unsigned long pmspr_val; | ||
1721 | - s8 local_pstate_id; | ||
1722 | struct powernv_smp_call_data *freq_data = arg; | ||
1723 | |||
1724 | pmspr_val = get_pmspr(SPRN_PMSR); | ||
1725 | - | ||
1726 | - /* | ||
1727 | - * The local pstate id corresponds bits 48..55 in the PMSR. | ||
1728 | - * Note: Watch out for the sign! | ||
1729 | - */ | ||
1730 | - local_pstate_id = (pmspr_val >> 48) & 0xFF; | ||
1731 | - freq_data->pstate_id = local_pstate_id; | ||
1732 | + freq_data->pstate_id = extract_local_pstate(pmspr_val); | ||
1733 | freq_data->freq = pstate_id_to_freq(freq_data->pstate_id); | ||
1734 | |||
1735 | pr_debug("cpu %d pmsr %016lX pstate_id %d frequency %d kHz\n", | ||
1736 | @@ -521,7 +530,7 @@ static void powernv_cpufreq_throttle_check(void *data) | ||
1737 | chip = this_cpu_read(chip_info); | ||
1738 | |||
1739 | /* Check for Pmax Capping */ | ||
1740 | - pmsr_pmax = (s8)PMSR_MAX(pmsr); | ||
1741 | + pmsr_pmax = extract_max_pstate(pmsr); | ||
1742 | pmsr_pmax_idx = pstate_to_idx(pmsr_pmax); | ||
1743 | if (pmsr_pmax_idx != powernv_pstate_info.max) { | ||
1744 | if (chip->throttled) | ||
1745 | @@ -644,8 +653,8 @@ void gpstate_timer_handler(unsigned long data) | ||
1746 | * value. Hence, read from PMCR to get correct data. | ||
1747 | */ | ||
1748 | val = get_pmspr(SPRN_PMCR); | ||
1749 | - freq_data.gpstate_id = (s8)GET_GPSTATE(val); | ||
1750 | - freq_data.pstate_id = (s8)GET_LPSTATE(val); | ||
1751 | + freq_data.gpstate_id = extract_global_pstate(val); | ||
1752 | + freq_data.pstate_id = extract_local_pstate(val); | ||
1753 | if (freq_data.gpstate_id == freq_data.pstate_id) { | ||
1754 | reset_gpstates(policy); | ||
1755 | spin_unlock(&gpstates->gpstate_lock); | ||
1756 | diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c | ||
1757 | index 202476fbbc4c..8a411514a7c5 100644 | ||
1758 | --- a/drivers/devfreq/devfreq.c | ||
1759 | +++ b/drivers/devfreq/devfreq.c | ||
1760 | @@ -935,7 +935,8 @@ static ssize_t governor_store(struct device *dev, struct device_attribute *attr, | ||
1761 | if (df->governor == governor) { | ||
1762 | ret = 0; | ||
1763 | goto out; | ||
1764 | - } else if (df->governor->immutable || governor->immutable) { | ||
1765 | + } else if ((df->governor && df->governor->immutable) || | ||
1766 | + governor->immutable) { | ||
1767 | ret = -EINVAL; | ||
1768 | goto out; | ||
1769 | } | ||
1770 | diff --git a/drivers/edac/mv64x60_edac.c b/drivers/edac/mv64x60_edac.c | ||
1771 | index ec5d695bbb72..3c68bb525d5d 100644 | ||
1772 | --- a/drivers/edac/mv64x60_edac.c | ||
1773 | +++ b/drivers/edac/mv64x60_edac.c | ||
1774 | @@ -758,7 +758,7 @@ static int mv64x60_mc_err_probe(struct platform_device *pdev) | ||
1775 | /* Non-ECC RAM? */ | ||
1776 | printk(KERN_WARNING "%s: No ECC DIMMs discovered\n", __func__); | ||
1777 | res = -ENODEV; | ||
1778 | - goto err2; | ||
1779 | + goto err; | ||
1780 | } | ||
1781 | |||
1782 | edac_dbg(3, "init mci\n"); | ||
1783 | diff --git a/drivers/gpio/gpio-thunderx.c b/drivers/gpio/gpio-thunderx.c | ||
1784 | index 57efb251f9c4..10523ce00c38 100644 | ||
1785 | --- a/drivers/gpio/gpio-thunderx.c | ||
1786 | +++ b/drivers/gpio/gpio-thunderx.c | ||
1787 | @@ -566,8 +566,10 @@ static int thunderx_gpio_probe(struct pci_dev *pdev, | ||
1788 | txgpio->irqd = irq_domain_create_hierarchy(irq_get_irq_data(txgpio->msix_entries[0].vector)->domain, | ||
1789 | 0, 0, of_node_to_fwnode(dev->of_node), | ||
1790 | &thunderx_gpio_irqd_ops, txgpio); | ||
1791 | - if (!txgpio->irqd) | ||
1792 | + if (!txgpio->irqd) { | ||
1793 | + err = -ENOMEM; | ||
1794 | goto out; | ||
1795 | + } | ||
1796 | |||
1797 | /* Push on irq_data and the domain for each line. */ | ||
1798 | for (i = 0; i < ngpio; i++) { | ||
1799 | diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c | ||
1800 | index bdd68ff197dc..b4c8b25453a6 100644 | ||
1801 | --- a/drivers/gpio/gpiolib.c | ||
1802 | +++ b/drivers/gpio/gpiolib.c | ||
1803 | @@ -3340,7 +3340,8 @@ struct gpio_desc *__must_check gpiod_get_index(struct device *dev, | ||
1804 | return desc; | ||
1805 | } | ||
1806 | |||
1807 | - status = gpiod_request(desc, con_id); | ||
1808 | + /* If a connection label was passed use that, else use the device name as label */ | ||
1809 | + status = gpiod_request(desc, con_id ? con_id : dev_name(dev)); | ||
1810 | if (status < 0) | ||
1811 | return ERR_PTR(status); | ||
1812 | |||
1813 | diff --git a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c | ||
1814 | index fe15aa64086f..71fe60e5f01f 100644 | ||
1815 | --- a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c | ||
1816 | +++ b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c | ||
1817 | @@ -698,7 +698,7 @@ static unsigned long dsi_pll_14nm_postdiv_recalc_rate(struct clk_hw *hw, | ||
1818 | val &= div_mask(width); | ||
1819 | |||
1820 | return divider_recalc_rate(hw, parent_rate, val, NULL, | ||
1821 | - postdiv->flags); | ||
1822 | + postdiv->flags, width); | ||
1823 | } | ||
1824 | |||
1825 | static long dsi_pll_14nm_postdiv_round_rate(struct clk_hw *hw, | ||
1826 | diff --git a/drivers/hwmon/ina2xx.c b/drivers/hwmon/ina2xx.c | ||
1827 | index 62e38fa8cda2..e362a932fe8c 100644 | ||
1828 | --- a/drivers/hwmon/ina2xx.c | ||
1829 | +++ b/drivers/hwmon/ina2xx.c | ||
1830 | @@ -95,18 +95,20 @@ enum ina2xx_ids { ina219, ina226 }; | ||
1831 | |||
1832 | struct ina2xx_config { | ||
1833 | u16 config_default; | ||
1834 | - int calibration_factor; | ||
1835 | + int calibration_value; | ||
1836 | int registers; | ||
1837 | int shunt_div; | ||
1838 | int bus_voltage_shift; | ||
1839 | int bus_voltage_lsb; /* uV */ | ||
1840 | - int power_lsb; /* uW */ | ||
1841 | + int power_lsb_factor; | ||
1842 | }; | ||
1843 | |||
1844 | struct ina2xx_data { | ||
1845 | const struct ina2xx_config *config; | ||
1846 | |||
1847 | long rshunt; | ||
1848 | + long current_lsb_uA; | ||
1849 | + long power_lsb_uW; | ||
1850 | struct mutex config_lock; | ||
1851 | struct regmap *regmap; | ||
1852 | |||
1853 | @@ -116,21 +118,21 @@ struct ina2xx_data { | ||
1854 | static const struct ina2xx_config ina2xx_config[] = { | ||
1855 | [ina219] = { | ||
1856 | .config_default = INA219_CONFIG_DEFAULT, | ||
1857 | - .calibration_factor = 40960000, | ||
1858 | + .calibration_value = 4096, | ||
1859 | .registers = INA219_REGISTERS, | ||
1860 | .shunt_div = 100, | ||
1861 | .bus_voltage_shift = 3, | ||
1862 | .bus_voltage_lsb = 4000, | ||
1863 | - .power_lsb = 20000, | ||
1864 | + .power_lsb_factor = 20, | ||
1865 | }, | ||
1866 | [ina226] = { | ||
1867 | .config_default = INA226_CONFIG_DEFAULT, | ||
1868 | - .calibration_factor = 5120000, | ||
1869 | + .calibration_value = 2048, | ||
1870 | .registers = INA226_REGISTERS, | ||
1871 | .shunt_div = 400, | ||
1872 | .bus_voltage_shift = 0, | ||
1873 | .bus_voltage_lsb = 1250, | ||
1874 | - .power_lsb = 25000, | ||
1875 | + .power_lsb_factor = 25, | ||
1876 | }, | ||
1877 | }; | ||
1878 | |||
1879 | @@ -169,12 +171,16 @@ static u16 ina226_interval_to_reg(int interval) | ||
1880 | return INA226_SHIFT_AVG(avg_bits); | ||
1881 | } | ||
1882 | |||
1883 | +/* | ||
1884 | + * Calibration register is set to the best value, which eliminates | ||
1885 | + * truncation errors on calculating current register in hardware. | ||
1886 | + * According to datasheet (eq. 3) the best values are 2048 for | ||
1887 | + * ina226 and 4096 for ina219. They are hardcoded as calibration_value. | ||
1888 | + */ | ||
1889 | static int ina2xx_calibrate(struct ina2xx_data *data) | ||
1890 | { | ||
1891 | - u16 val = DIV_ROUND_CLOSEST(data->config->calibration_factor, | ||
1892 | - data->rshunt); | ||
1893 | - | ||
1894 | - return regmap_write(data->regmap, INA2XX_CALIBRATION, val); | ||
1895 | + return regmap_write(data->regmap, INA2XX_CALIBRATION, | ||
1896 | + data->config->calibration_value); | ||
1897 | } | ||
1898 | |||
1899 | /* | ||
1900 | @@ -187,10 +193,6 @@ static int ina2xx_init(struct ina2xx_data *data) | ||
1901 | if (ret < 0) | ||
1902 | return ret; | ||
1903 | |||
1904 | - /* | ||
1905 | - * Set current LSB to 1mA, shunt is in uOhms | ||
1906 | - * (equation 13 in datasheet). | ||
1907 | - */ | ||
1908 | return ina2xx_calibrate(data); | ||
1909 | } | ||
1910 | |||
1911 | @@ -268,15 +270,15 @@ static int ina2xx_get_value(struct ina2xx_data *data, u8 reg, | ||
1912 | val = DIV_ROUND_CLOSEST(val, 1000); | ||
1913 | break; | ||
1914 | case INA2XX_POWER: | ||
1915 | - val = regval * data->config->power_lsb; | ||
1916 | + val = regval * data->power_lsb_uW; | ||
1917 | break; | ||
1918 | case INA2XX_CURRENT: | ||
1919 | - /* signed register, LSB=1mA (selected), in mA */ | ||
1920 | - val = (s16)regval; | ||
1921 | + /* signed register, result in mA */ | ||
1922 | + val = regval * data->current_lsb_uA; | ||
1923 | + val = DIV_ROUND_CLOSEST(val, 1000); | ||
1924 | break; | ||
1925 | case INA2XX_CALIBRATION: | ||
1926 | - val = DIV_ROUND_CLOSEST(data->config->calibration_factor, | ||
1927 | - regval); | ||
1928 | + val = regval; | ||
1929 | break; | ||
1930 | default: | ||
1931 | /* programmer goofed */ | ||
1932 | @@ -304,9 +306,32 @@ static ssize_t ina2xx_show_value(struct device *dev, | ||
1933 | ina2xx_get_value(data, attr->index, regval)); | ||
1934 | } | ||
1935 | |||
1936 | -static ssize_t ina2xx_set_shunt(struct device *dev, | ||
1937 | - struct device_attribute *da, | ||
1938 | - const char *buf, size_t count) | ||
1939 | +/* | ||
1940 | + * In order to keep calibration register value fixed, the product | ||
1941 | + * of current_lsb and shunt_resistor should also be fixed and equal | ||
1942 | + * to shunt_voltage_lsb = 1 / shunt_div multiplied by 10^9 in order | ||
1943 | + * to keep the scale. | ||
1944 | + */ | ||
1945 | +static int ina2xx_set_shunt(struct ina2xx_data *data, long val) | ||
1946 | +{ | ||
1947 | + unsigned int dividend = DIV_ROUND_CLOSEST(1000000000, | ||
1948 | + data->config->shunt_div); | ||
1949 | + if (val <= 0 || val > dividend) | ||
1950 | + return -EINVAL; | ||
1951 | + | ||
1952 | + mutex_lock(&data->config_lock); | ||
1953 | + data->rshunt = val; | ||
1954 | + data->current_lsb_uA = DIV_ROUND_CLOSEST(dividend, val); | ||
1955 | + data->power_lsb_uW = data->config->power_lsb_factor * | ||
1956 | + data->current_lsb_uA; | ||
1957 | + mutex_unlock(&data->config_lock); | ||
1958 | + | ||
1959 | + return 0; | ||
1960 | +} | ||
1961 | + | ||
1962 | +static ssize_t ina2xx_store_shunt(struct device *dev, | ||
1963 | + struct device_attribute *da, | ||
1964 | + const char *buf, size_t count) | ||
1965 | { | ||
1966 | unsigned long val; | ||
1967 | int status; | ||
1968 | @@ -316,18 +341,9 @@ static ssize_t ina2xx_set_shunt(struct device *dev, | ||
1969 | if (status < 0) | ||
1970 | return status; | ||
1971 | |||
1972 | - if (val == 0 || | ||
1973 | - /* Values greater than the calibration factor make no sense. */ | ||
1974 | - val > data->config->calibration_factor) | ||
1975 | - return -EINVAL; | ||
1976 | - | ||
1977 | - mutex_lock(&data->config_lock); | ||
1978 | - data->rshunt = val; | ||
1979 | - status = ina2xx_calibrate(data); | ||
1980 | - mutex_unlock(&data->config_lock); | ||
1981 | + status = ina2xx_set_shunt(data, val); | ||
1982 | if (status < 0) | ||
1983 | return status; | ||
1984 | - | ||
1985 | return count; | ||
1986 | } | ||
1987 | |||
1988 | @@ -387,7 +403,7 @@ static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina2xx_show_value, NULL, | ||
1989 | |||
1990 | /* shunt resistance */ | ||
1991 | static SENSOR_DEVICE_ATTR(shunt_resistor, S_IRUGO | S_IWUSR, | ||
1992 | - ina2xx_show_value, ina2xx_set_shunt, | ||
1993 | + ina2xx_show_value, ina2xx_store_shunt, | ||
1994 | INA2XX_CALIBRATION); | ||
1995 | |||
1996 | /* update interval (ina226 only) */ | ||
1997 | @@ -448,10 +464,7 @@ static int ina2xx_probe(struct i2c_client *client, | ||
1998 | val = INA2XX_RSHUNT_DEFAULT; | ||
1999 | } | ||
2000 | |||
2001 | - if (val <= 0 || val > data->config->calibration_factor) | ||
2002 | - return -ENODEV; | ||
2003 | - | ||
2004 | - data->rshunt = val; | ||
2005 | + ina2xx_set_shunt(data, val); | ||
2006 | |||
2007 | ina2xx_regmap_config.max_register = data->config->registers; | ||
2008 | |||
2009 | diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c | ||
2010 | index 6cae00ecc905..25de7cc9f49f 100644 | ||
2011 | --- a/drivers/infiniband/core/cma.c | ||
2012 | +++ b/drivers/infiniband/core/cma.c | ||
2013 | @@ -4453,6 +4453,7 @@ static int cma_get_id_stats(struct sk_buff *skb, struct netlink_callback *cb) | ||
2014 | id_stats->qp_type = id->qp_type; | ||
2015 | |||
2016 | i_id++; | ||
2017 | + nlmsg_end(skb, nlh); | ||
2018 | } | ||
2019 | |||
2020 | cb->args[1] = 0; | ||
2021 | diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c | ||
2022 | index 722235bed075..d6fa38f8604f 100644 | ||
2023 | --- a/drivers/infiniband/core/ucma.c | ||
2024 | +++ b/drivers/infiniband/core/ucma.c | ||
2025 | @@ -914,13 +914,14 @@ static ssize_t ucma_query_path(struct ucma_context *ctx, | ||
2026 | |||
2027 | resp->path_data[i].flags = IB_PATH_GMP | IB_PATH_PRIMARY | | ||
2028 | IB_PATH_BIDIRECTIONAL; | ||
2029 | - if (rec->rec_type == SA_PATH_REC_TYPE_IB) { | ||
2030 | - ib_sa_pack_path(rec, &resp->path_data[i].path_rec); | ||
2031 | - } else { | ||
2032 | + if (rec->rec_type == SA_PATH_REC_TYPE_OPA) { | ||
2033 | struct sa_path_rec ib; | ||
2034 | |||
2035 | sa_convert_path_opa_to_ib(&ib, rec); | ||
2036 | ib_sa_pack_path(&ib, &resp->path_data[i].path_rec); | ||
2037 | + | ||
2038 | + } else { | ||
2039 | + ib_sa_pack_path(rec, &resp->path_data[i].path_rec); | ||
2040 | } | ||
2041 | } | ||
2042 | |||
2043 | diff --git a/drivers/infiniband/hw/i40iw/i40iw_cm.c b/drivers/infiniband/hw/i40iw/i40iw_cm.c | ||
2044 | index d6a1a308c6a0..b7f1ce5333cb 100644 | ||
2045 | --- a/drivers/infiniband/hw/i40iw/i40iw_cm.c | ||
2046 | +++ b/drivers/infiniband/hw/i40iw/i40iw_cm.c | ||
2047 | @@ -125,7 +125,8 @@ static u8 i40iw_derive_hw_ird_setting(u16 cm_ird) | ||
2048 | * @conn_ird: connection IRD | ||
2049 | * @conn_ord: connection ORD | ||
2050 | */ | ||
2051 | -static void i40iw_record_ird_ord(struct i40iw_cm_node *cm_node, u16 conn_ird, u16 conn_ord) | ||
2052 | +static void i40iw_record_ird_ord(struct i40iw_cm_node *cm_node, u32 conn_ird, | ||
2053 | + u32 conn_ord) | ||
2054 | { | ||
2055 | if (conn_ird > I40IW_MAX_IRD_SIZE) | ||
2056 | conn_ird = I40IW_MAX_IRD_SIZE; | ||
2057 | @@ -3841,7 +3842,7 @@ int i40iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param) | ||
2058 | } | ||
2059 | |||
2060 | cm_node->apbvt_set = true; | ||
2061 | - i40iw_record_ird_ord(cm_node, (u16)conn_param->ird, (u16)conn_param->ord); | ||
2062 | + i40iw_record_ird_ord(cm_node, conn_param->ird, conn_param->ord); | ||
2063 | if (cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO && | ||
2064 | !cm_node->ord_size) | ||
2065 | cm_node->ord_size = 1; | ||
2066 | diff --git a/drivers/infiniband/hw/i40iw/i40iw_ctrl.c b/drivers/infiniband/hw/i40iw/i40iw_ctrl.c | ||
2067 | index d86f3e670804..472ef4d6e858 100644 | ||
2068 | --- a/drivers/infiniband/hw/i40iw/i40iw_ctrl.c | ||
2069 | +++ b/drivers/infiniband/hw/i40iw/i40iw_ctrl.c | ||
2070 | @@ -3875,8 +3875,10 @@ enum i40iw_status_code i40iw_config_fpm_values(struct i40iw_sc_dev *dev, u32 qp_ | ||
2071 | hmc_info->hmc_obj[I40IW_HMC_IW_APBVT_ENTRY].cnt = 1; | ||
2072 | hmc_info->hmc_obj[I40IW_HMC_IW_MR].cnt = mrwanted; | ||
2073 | |||
2074 | - hmc_info->hmc_obj[I40IW_HMC_IW_XF].cnt = I40IW_MAX_WQ_ENTRIES * qpwanted; | ||
2075 | - hmc_info->hmc_obj[I40IW_HMC_IW_Q1].cnt = 4 * I40IW_MAX_IRD_SIZE * qpwanted; | ||
2076 | + hmc_info->hmc_obj[I40IW_HMC_IW_XF].cnt = | ||
2077 | + roundup_pow_of_two(I40IW_MAX_WQ_ENTRIES * qpwanted); | ||
2078 | + hmc_info->hmc_obj[I40IW_HMC_IW_Q1].cnt = | ||
2079 | + roundup_pow_of_two(2 * I40IW_MAX_IRD_SIZE * qpwanted); | ||
2080 | hmc_info->hmc_obj[I40IW_HMC_IW_XFFL].cnt = | ||
2081 | hmc_info->hmc_obj[I40IW_HMC_IW_XF].cnt / hmc_fpm_misc->xf_block_size; | ||
2082 | hmc_info->hmc_obj[I40IW_HMC_IW_Q1FL].cnt = | ||
2083 | diff --git a/drivers/infiniband/hw/i40iw/i40iw_d.h b/drivers/infiniband/hw/i40iw/i40iw_d.h | ||
2084 | index 24eabcad5e40..019ad3b939f9 100644 | ||
2085 | --- a/drivers/infiniband/hw/i40iw/i40iw_d.h | ||
2086 | +++ b/drivers/infiniband/hw/i40iw/i40iw_d.h | ||
2087 | @@ -93,6 +93,7 @@ | ||
2088 | #define RDMA_OPCODE_MASK 0x0f | ||
2089 | #define RDMA_READ_REQ_OPCODE 1 | ||
2090 | #define Q2_BAD_FRAME_OFFSET 72 | ||
2091 | +#define Q2_FPSN_OFFSET 64 | ||
2092 | #define CQE_MAJOR_DRV 0x8000 | ||
2093 | |||
2094 | #define I40IW_TERM_SENT 0x01 | ||
2095 | diff --git a/drivers/infiniband/hw/i40iw/i40iw_puda.c b/drivers/infiniband/hw/i40iw/i40iw_puda.c | ||
2096 | index 59f70676f0e0..14d38d733cb4 100644 | ||
2097 | --- a/drivers/infiniband/hw/i40iw/i40iw_puda.c | ||
2098 | +++ b/drivers/infiniband/hw/i40iw/i40iw_puda.c | ||
2099 | @@ -1376,7 +1376,7 @@ static void i40iw_ieq_handle_exception(struct i40iw_puda_rsrc *ieq, | ||
2100 | u32 *hw_host_ctx = (u32 *)qp->hw_host_ctx; | ||
2101 | u32 rcv_wnd = hw_host_ctx[23]; | ||
2102 | /* first partial seq # in q2 */ | ||
2103 | - u32 fps = qp->q2_buf[16]; | ||
2104 | + u32 fps = *(u32 *)(qp->q2_buf + Q2_FPSN_OFFSET); | ||
2105 | struct list_head *rxlist = &pfpdu->rxlist; | ||
2106 | struct list_head *plist; | ||
2107 | |||
2108 | diff --git a/drivers/infiniband/sw/rdmavt/cq.c b/drivers/infiniband/sw/rdmavt/cq.c | ||
2109 | index 97d71e49c092..88fa4d44ab5f 100644 | ||
2110 | --- a/drivers/infiniband/sw/rdmavt/cq.c | ||
2111 | +++ b/drivers/infiniband/sw/rdmavt/cq.c | ||
2112 | @@ -198,7 +198,7 @@ struct ib_cq *rvt_create_cq(struct ib_device *ibdev, | ||
2113 | return ERR_PTR(-EINVAL); | ||
2114 | |||
2115 | /* Allocate the completion queue structure. */ | ||
2116 | - cq = kzalloc(sizeof(*cq), GFP_KERNEL); | ||
2117 | + cq = kzalloc_node(sizeof(*cq), GFP_KERNEL, rdi->dparms.node); | ||
2118 | if (!cq) | ||
2119 | return ERR_PTR(-ENOMEM); | ||
2120 | |||
2121 | @@ -214,7 +214,9 @@ struct ib_cq *rvt_create_cq(struct ib_device *ibdev, | ||
2122 | sz += sizeof(struct ib_uverbs_wc) * (entries + 1); | ||
2123 | else | ||
2124 | sz += sizeof(struct ib_wc) * (entries + 1); | ||
2125 | - wc = vmalloc_user(sz); | ||
2126 | + wc = udata ? | ||
2127 | + vmalloc_user(sz) : | ||
2128 | + vzalloc_node(sz, rdi->dparms.node); | ||
2129 | if (!wc) { | ||
2130 | ret = ERR_PTR(-ENOMEM); | ||
2131 | goto bail_cq; | ||
2132 | @@ -369,7 +371,9 @@ int rvt_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata) | ||
2133 | sz += sizeof(struct ib_uverbs_wc) * (cqe + 1); | ||
2134 | else | ||
2135 | sz += sizeof(struct ib_wc) * (cqe + 1); | ||
2136 | - wc = vmalloc_user(sz); | ||
2137 | + wc = udata ? | ||
2138 | + vmalloc_user(sz) : | ||
2139 | + vzalloc_node(sz, rdi->dparms.node); | ||
2140 | if (!wc) | ||
2141 | return -ENOMEM; | ||
2142 | |||
2143 | diff --git a/drivers/input/touchscreen/goodix.c b/drivers/input/touchscreen/goodix.c | ||
2144 | index b3bbad7d2282..5dafafad6351 100644 | ||
2145 | --- a/drivers/input/touchscreen/goodix.c | ||
2146 | +++ b/drivers/input/touchscreen/goodix.c | ||
2147 | @@ -808,8 +808,10 @@ static int __maybe_unused goodix_suspend(struct device *dev) | ||
2148 | int error; | ||
2149 | |||
2150 | /* We need gpio pins to suspend/resume */ | ||
2151 | - if (!ts->gpiod_int || !ts->gpiod_rst) | ||
2152 | + if (!ts->gpiod_int || !ts->gpiod_rst) { | ||
2153 | + disable_irq(client->irq); | ||
2154 | return 0; | ||
2155 | + } | ||
2156 | |||
2157 | wait_for_completion(&ts->firmware_loading_complete); | ||
2158 | |||
2159 | @@ -849,8 +851,10 @@ static int __maybe_unused goodix_resume(struct device *dev) | ||
2160 | struct goodix_ts_data *ts = i2c_get_clientdata(client); | ||
2161 | int error; | ||
2162 | |||
2163 | - if (!ts->gpiod_int || !ts->gpiod_rst) | ||
2164 | + if (!ts->gpiod_int || !ts->gpiod_rst) { | ||
2165 | + enable_irq(client->irq); | ||
2166 | return 0; | ||
2167 | + } | ||
2168 | |||
2169 | /* | ||
2170 | * Exit sleep mode by outputting HIGH level to INT pin | ||
2171 | diff --git a/drivers/irqchip/irq-gic-v3.c b/drivers/irqchip/irq-gic-v3.c | ||
2172 | index ae9ff72e83ee..848fcdf6a112 100644 | ||
2173 | --- a/drivers/irqchip/irq-gic-v3.c | ||
2174 | +++ b/drivers/irqchip/irq-gic-v3.c | ||
2175 | @@ -1297,6 +1297,10 @@ gic_acpi_parse_madt_gicc(struct acpi_subtable_header *header, | ||
2176 | u32 size = reg == GIC_PIDR2_ARCH_GICv4 ? SZ_64K * 4 : SZ_64K * 2; | ||
2177 | void __iomem *redist_base; | ||
2178 | |||
2179 | + /* GICC entry which has !ACPI_MADT_ENABLED is not unusable so skip */ | ||
2180 | + if (!(gicc->flags & ACPI_MADT_ENABLED)) | ||
2181 | + return 0; | ||
2182 | + | ||
2183 | redist_base = ioremap(gicc->gicr_base_address, size); | ||
2184 | if (!redist_base) | ||
2185 | return -ENOMEM; | ||
2186 | @@ -1346,6 +1350,13 @@ static int __init gic_acpi_match_gicc(struct acpi_subtable_header *header, | ||
2187 | if ((gicc->flags & ACPI_MADT_ENABLED) && gicc->gicr_base_address) | ||
2188 | return 0; | ||
2189 | |||
2190 | + /* | ||
2191 | + * It's perfectly valid firmware can pass disabled GICC entry, driver | ||
2192 | + * should not treat as errors, skip the entry instead of probe fail. | ||
2193 | + */ | ||
2194 | + if (!(gicc->flags & ACPI_MADT_ENABLED)) | ||
2195 | + return 0; | ||
2196 | + | ||
2197 | return -ENODEV; | ||
2198 | } | ||
2199 | |||
2200 | diff --git a/drivers/md/bcache/alloc.c b/drivers/md/bcache/alloc.c | ||
2201 | index 934b1fce4ce1..f0dc8e2aee65 100644 | ||
2202 | --- a/drivers/md/bcache/alloc.c | ||
2203 | +++ b/drivers/md/bcache/alloc.c | ||
2204 | @@ -515,15 +515,21 @@ struct open_bucket { | ||
2205 | |||
2206 | /* | ||
2207 | * We keep multiple buckets open for writes, and try to segregate different | ||
2208 | - * write streams for better cache utilization: first we look for a bucket where | ||
2209 | - * the last write to it was sequential with the current write, and failing that | ||
2210 | - * we look for a bucket that was last used by the same task. | ||
2211 | + * write streams for better cache utilization: first we try to segregate flash | ||
2212 | + * only volume write streams from cached devices, secondly we look for a bucket | ||
2213 | + * where the last write to it was sequential with the current write, and | ||
2214 | + * failing that we look for a bucket that was last used by the same task. | ||
2215 | * | ||
2216 | * The ideas is if you've got multiple tasks pulling data into the cache at the | ||
2217 | * same time, you'll get better cache utilization if you try to segregate their | ||
2218 | * data and preserve locality. | ||
2219 | * | ||
2220 | - * For example, say you've starting Firefox at the same time you're copying a | ||
2221 | + * For example, dirty sectors of flash only volume is not reclaimable, if their | ||
2222 | + * dirty sectors mixed with dirty sectors of cached device, such buckets will | ||
2223 | + * be marked as dirty and won't be reclaimed, though the dirty data of cached | ||
2224 | + * device have been written back to backend device. | ||
2225 | + * | ||
2226 | + * And say you've starting Firefox at the same time you're copying a | ||
2227 | * bunch of files. Firefox will likely end up being fairly hot and stay in the | ||
2228 | * cache awhile, but the data you copied might not be; if you wrote all that | ||
2229 | * data to the same buckets it'd get invalidated at the same time. | ||
2230 | @@ -540,7 +546,10 @@ static struct open_bucket *pick_data_bucket(struct cache_set *c, | ||
2231 | struct open_bucket *ret, *ret_task = NULL; | ||
2232 | |||
2233 | list_for_each_entry_reverse(ret, &c->data_buckets, list) | ||
2234 | - if (!bkey_cmp(&ret->key, search)) | ||
2235 | + if (UUID_FLASH_ONLY(&c->uuids[KEY_INODE(&ret->key)]) != | ||
2236 | + UUID_FLASH_ONLY(&c->uuids[KEY_INODE(search)])) | ||
2237 | + continue; | ||
2238 | + else if (!bkey_cmp(&ret->key, search)) | ||
2239 | goto found; | ||
2240 | else if (ret->last_write_point == write_point) | ||
2241 | ret_task = ret; | ||
2242 | diff --git a/drivers/md/bcache/request.c b/drivers/md/bcache/request.c | ||
2243 | index e9fbf2bcd122..f34ad8720756 100644 | ||
2244 | --- a/drivers/md/bcache/request.c | ||
2245 | +++ b/drivers/md/bcache/request.c | ||
2246 | @@ -568,6 +568,7 @@ static void cache_lookup(struct closure *cl) | ||
2247 | { | ||
2248 | struct search *s = container_of(cl, struct search, iop.cl); | ||
2249 | struct bio *bio = &s->bio.bio; | ||
2250 | + struct cached_dev *dc; | ||
2251 | int ret; | ||
2252 | |||
2253 | bch_btree_op_init(&s->op, -1); | ||
2254 | @@ -580,6 +581,27 @@ static void cache_lookup(struct closure *cl) | ||
2255 | return; | ||
2256 | } | ||
2257 | |||
2258 | + /* | ||
2259 | + * We might meet err when searching the btree, If that happens, we will | ||
2260 | + * get negative ret, in this scenario we should not recover data from | ||
2261 | + * backing device (when cache device is dirty) because we don't know | ||
2262 | + * whether bkeys the read request covered are all clean. | ||
2263 | + * | ||
2264 | + * And after that happened, s->iop.status is still its initial value | ||
2265 | + * before we submit s->bio.bio | ||
2266 | + */ | ||
2267 | + if (ret < 0) { | ||
2268 | + BUG_ON(ret == -EINTR); | ||
2269 | + if (s->d && s->d->c && | ||
2270 | + !UUID_FLASH_ONLY(&s->d->c->uuids[s->d->id])) { | ||
2271 | + dc = container_of(s->d, struct cached_dev, disk); | ||
2272 | + if (dc && atomic_read(&dc->has_dirty)) | ||
2273 | + s->recoverable = false; | ||
2274 | + } | ||
2275 | + if (!s->iop.status) | ||
2276 | + s->iop.status = BLK_STS_IOERR; | ||
2277 | + } | ||
2278 | + | ||
2279 | closure_return(cl); | ||
2280 | } | ||
2281 | |||
2282 | diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c | ||
2283 | index 9417170f180a..5d0430777dda 100644 | ||
2284 | --- a/drivers/md/bcache/super.c | ||
2285 | +++ b/drivers/md/bcache/super.c | ||
2286 | @@ -893,6 +893,12 @@ static void cached_dev_detach_finish(struct work_struct *w) | ||
2287 | |||
2288 | mutex_lock(&bch_register_lock); | ||
2289 | |||
2290 | + cancel_delayed_work_sync(&dc->writeback_rate_update); | ||
2291 | + if (!IS_ERR_OR_NULL(dc->writeback_thread)) { | ||
2292 | + kthread_stop(dc->writeback_thread); | ||
2293 | + dc->writeback_thread = NULL; | ||
2294 | + } | ||
2295 | + | ||
2296 | memset(&dc->sb.set_uuid, 0, 16); | ||
2297 | SET_BDEV_STATE(&dc->sb, BDEV_STATE_NONE); | ||
2298 | |||
2299 | diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c | ||
2300 | index cb115ba6a1d2..6d9adcaa26ba 100644 | ||
2301 | --- a/drivers/media/v4l2-core/videobuf2-core.c | ||
2302 | +++ b/drivers/media/v4l2-core/videobuf2-core.c | ||
2303 | @@ -332,6 +332,10 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory, | ||
2304 | struct vb2_buffer *vb; | ||
2305 | int ret; | ||
2306 | |||
2307 | + /* Ensure that q->num_buffers+num_buffers is below VB2_MAX_FRAME */ | ||
2308 | + num_buffers = min_t(unsigned int, num_buffers, | ||
2309 | + VB2_MAX_FRAME - q->num_buffers); | ||
2310 | + | ||
2311 | for (buffer = 0; buffer < num_buffers; ++buffer) { | ||
2312 | /* Allocate videobuf buffer structures */ | ||
2313 | vb = kzalloc(q->buf_struct_size, GFP_KERNEL); | ||
2314 | diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c | ||
2315 | index 070f5da06fd2..5bedf4b7f0f7 100644 | ||
2316 | --- a/drivers/mmc/host/sdhci-pci-core.c | ||
2317 | +++ b/drivers/mmc/host/sdhci-pci-core.c | ||
2318 | @@ -806,6 +806,8 @@ static int intel_mrfld_mmc_probe_slot(struct sdhci_pci_slot *slot) | ||
2319 | slot->host->quirks2 |= SDHCI_QUIRK2_NO_1_8_V; | ||
2320 | break; | ||
2321 | case INTEL_MRFLD_SDIO: | ||
2322 | + /* Advertise 2.0v for compatibility with the SDIO card's OCR */ | ||
2323 | + slot->host->ocr_mask = MMC_VDD_20_21 | MMC_VDD_165_195; | ||
2324 | slot->host->mmc->caps |= MMC_CAP_NONREMOVABLE | | ||
2325 | MMC_CAP_POWER_OFF_CARD; | ||
2326 | break; | ||
2327 | diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c | ||
2328 | index 90cc1977b792..d35deb79965d 100644 | ||
2329 | --- a/drivers/mmc/host/sdhci.c | ||
2330 | +++ b/drivers/mmc/host/sdhci.c | ||
2331 | @@ -1470,6 +1470,13 @@ void sdhci_set_power_noreg(struct sdhci_host *host, unsigned char mode, | ||
2332 | if (mode != MMC_POWER_OFF) { | ||
2333 | switch (1 << vdd) { | ||
2334 | case MMC_VDD_165_195: | ||
2335 | + /* | ||
2336 | + * Without a regulator, SDHCI does not support 2.0v | ||
2337 | + * so we only get here if the driver deliberately | ||
2338 | + * added the 2.0v range to ocr_avail. Map it to 1.8v | ||
2339 | + * for the purpose of turning on the power. | ||
2340 | + */ | ||
2341 | + case MMC_VDD_20_21: | ||
2342 | pwr = SDHCI_POWER_180; | ||
2343 | break; | ||
2344 | case MMC_VDD_29_30: | ||
2345 | diff --git a/drivers/mtd/tests/oobtest.c b/drivers/mtd/tests/oobtest.c | ||
2346 | index 1cb3f7758fb6..766b2c385682 100644 | ||
2347 | --- a/drivers/mtd/tests/oobtest.c | ||
2348 | +++ b/drivers/mtd/tests/oobtest.c | ||
2349 | @@ -193,6 +193,9 @@ static int verify_eraseblock(int ebnum) | ||
2350 | ops.datbuf = NULL; | ||
2351 | ops.oobbuf = readbuf; | ||
2352 | err = mtd_read_oob(mtd, addr, &ops); | ||
2353 | + if (mtd_is_bitflip(err)) | ||
2354 | + err = 0; | ||
2355 | + | ||
2356 | if (err || ops.oobretlen != use_len) { | ||
2357 | pr_err("error: readoob failed at %#llx\n", | ||
2358 | (long long)addr); | ||
2359 | @@ -227,6 +230,9 @@ static int verify_eraseblock(int ebnum) | ||
2360 | ops.datbuf = NULL; | ||
2361 | ops.oobbuf = readbuf; | ||
2362 | err = mtd_read_oob(mtd, addr, &ops); | ||
2363 | + if (mtd_is_bitflip(err)) | ||
2364 | + err = 0; | ||
2365 | + | ||
2366 | if (err || ops.oobretlen != mtd->oobavail) { | ||
2367 | pr_err("error: readoob failed at %#llx\n", | ||
2368 | (long long)addr); | ||
2369 | @@ -286,6 +292,9 @@ static int verify_eraseblock_in_one_go(int ebnum) | ||
2370 | |||
2371 | /* read entire block's OOB at one go */ | ||
2372 | err = mtd_read_oob(mtd, addr, &ops); | ||
2373 | + if (mtd_is_bitflip(err)) | ||
2374 | + err = 0; | ||
2375 | + | ||
2376 | if (err || ops.oobretlen != len) { | ||
2377 | pr_err("error: readoob failed at %#llx\n", | ||
2378 | (long long)addr); | ||
2379 | @@ -527,6 +536,9 @@ static int __init mtd_oobtest_init(void) | ||
2380 | pr_info("attempting to start read past end of OOB\n"); | ||
2381 | pr_info("an error is expected...\n"); | ||
2382 | err = mtd_read_oob(mtd, addr0, &ops); | ||
2383 | + if (mtd_is_bitflip(err)) | ||
2384 | + err = 0; | ||
2385 | + | ||
2386 | if (err) { | ||
2387 | pr_info("error occurred as expected\n"); | ||
2388 | err = 0; | ||
2389 | @@ -571,6 +583,9 @@ static int __init mtd_oobtest_init(void) | ||
2390 | pr_info("attempting to read past end of device\n"); | ||
2391 | pr_info("an error is expected...\n"); | ||
2392 | err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops); | ||
2393 | + if (mtd_is_bitflip(err)) | ||
2394 | + err = 0; | ||
2395 | + | ||
2396 | if (err) { | ||
2397 | pr_info("error occurred as expected\n"); | ||
2398 | err = 0; | ||
2399 | @@ -615,6 +630,9 @@ static int __init mtd_oobtest_init(void) | ||
2400 | pr_info("attempting to read past end of device\n"); | ||
2401 | pr_info("an error is expected...\n"); | ||
2402 | err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops); | ||
2403 | + if (mtd_is_bitflip(err)) | ||
2404 | + err = 0; | ||
2405 | + | ||
2406 | if (err) { | ||
2407 | pr_info("error occurred as expected\n"); | ||
2408 | err = 0; | ||
2409 | @@ -684,6 +702,9 @@ static int __init mtd_oobtest_init(void) | ||
2410 | ops.datbuf = NULL; | ||
2411 | ops.oobbuf = readbuf; | ||
2412 | err = mtd_read_oob(mtd, addr, &ops); | ||
2413 | + if (mtd_is_bitflip(err)) | ||
2414 | + err = 0; | ||
2415 | + | ||
2416 | if (err) | ||
2417 | goto out; | ||
2418 | if (memcmpshow(addr, readbuf, writebuf, | ||
2419 | diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c | ||
2420 | index b2db581131b2..82f28ffccddf 100644 | ||
2421 | --- a/drivers/net/bonding/bond_main.c | ||
2422 | +++ b/drivers/net/bonding/bond_main.c | ||
2423 | @@ -1524,39 +1524,6 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) | ||
2424 | goto err_close; | ||
2425 | } | ||
2426 | |||
2427 | - /* If the mode uses primary, then the following is handled by | ||
2428 | - * bond_change_active_slave(). | ||
2429 | - */ | ||
2430 | - if (!bond_uses_primary(bond)) { | ||
2431 | - /* set promiscuity level to new slave */ | ||
2432 | - if (bond_dev->flags & IFF_PROMISC) { | ||
2433 | - res = dev_set_promiscuity(slave_dev, 1); | ||
2434 | - if (res) | ||
2435 | - goto err_close; | ||
2436 | - } | ||
2437 | - | ||
2438 | - /* set allmulti level to new slave */ | ||
2439 | - if (bond_dev->flags & IFF_ALLMULTI) { | ||
2440 | - res = dev_set_allmulti(slave_dev, 1); | ||
2441 | - if (res) | ||
2442 | - goto err_close; | ||
2443 | - } | ||
2444 | - | ||
2445 | - netif_addr_lock_bh(bond_dev); | ||
2446 | - | ||
2447 | - dev_mc_sync_multiple(slave_dev, bond_dev); | ||
2448 | - dev_uc_sync_multiple(slave_dev, bond_dev); | ||
2449 | - | ||
2450 | - netif_addr_unlock_bh(bond_dev); | ||
2451 | - } | ||
2452 | - | ||
2453 | - if (BOND_MODE(bond) == BOND_MODE_8023AD) { | ||
2454 | - /* add lacpdu mc addr to mc list */ | ||
2455 | - u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR; | ||
2456 | - | ||
2457 | - dev_mc_add(slave_dev, lacpdu_multicast); | ||
2458 | - } | ||
2459 | - | ||
2460 | res = vlan_vids_add_by_dev(slave_dev, bond_dev); | ||
2461 | if (res) { | ||
2462 | netdev_err(bond_dev, "Couldn't add bond vlan ids to %s\n", | ||
2463 | @@ -1721,6 +1688,40 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) | ||
2464 | goto err_upper_unlink; | ||
2465 | } | ||
2466 | |||
2467 | + /* If the mode uses primary, then the following is handled by | ||
2468 | + * bond_change_active_slave(). | ||
2469 | + */ | ||
2470 | + if (!bond_uses_primary(bond)) { | ||
2471 | + /* set promiscuity level to new slave */ | ||
2472 | + if (bond_dev->flags & IFF_PROMISC) { | ||
2473 | + res = dev_set_promiscuity(slave_dev, 1); | ||
2474 | + if (res) | ||
2475 | + goto err_sysfs_del; | ||
2476 | + } | ||
2477 | + | ||
2478 | + /* set allmulti level to new slave */ | ||
2479 | + if (bond_dev->flags & IFF_ALLMULTI) { | ||
2480 | + res = dev_set_allmulti(slave_dev, 1); | ||
2481 | + if (res) { | ||
2482 | + if (bond_dev->flags & IFF_PROMISC) | ||
2483 | + dev_set_promiscuity(slave_dev, -1); | ||
2484 | + goto err_sysfs_del; | ||
2485 | + } | ||
2486 | + } | ||
2487 | + | ||
2488 | + netif_addr_lock_bh(bond_dev); | ||
2489 | + dev_mc_sync_multiple(slave_dev, bond_dev); | ||
2490 | + dev_uc_sync_multiple(slave_dev, bond_dev); | ||
2491 | + netif_addr_unlock_bh(bond_dev); | ||
2492 | + | ||
2493 | + if (BOND_MODE(bond) == BOND_MODE_8023AD) { | ||
2494 | + /* add lacpdu mc addr to mc list */ | ||
2495 | + u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR; | ||
2496 | + | ||
2497 | + dev_mc_add(slave_dev, lacpdu_multicast); | ||
2498 | + } | ||
2499 | + } | ||
2500 | + | ||
2501 | bond->slave_cnt++; | ||
2502 | bond_compute_features(bond); | ||
2503 | bond_set_carrier(bond); | ||
2504 | @@ -1744,6 +1745,9 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) | ||
2505 | return 0; | ||
2506 | |||
2507 | /* Undo stages on error */ | ||
2508 | +err_sysfs_del: | ||
2509 | + bond_sysfs_slave_del(new_slave); | ||
2510 | + | ||
2511 | err_upper_unlink: | ||
2512 | bond_upper_dev_unlink(bond, new_slave); | ||
2513 | |||
2514 | @@ -1751,9 +1755,6 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) | ||
2515 | netdev_rx_handler_unregister(slave_dev); | ||
2516 | |||
2517 | err_detach: | ||
2518 | - if (!bond_uses_primary(bond)) | ||
2519 | - bond_hw_addr_flush(bond_dev, slave_dev); | ||
2520 | - | ||
2521 | vlan_vids_del_by_dev(slave_dev, bond_dev); | ||
2522 | if (rcu_access_pointer(bond->primary_slave) == new_slave) | ||
2523 | RCU_INIT_POINTER(bond->primary_slave, NULL); | ||
2524 | diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c | ||
2525 | index 05498e7f2840..6246003f9922 100644 | ||
2526 | --- a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c | ||
2527 | +++ b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c | ||
2528 | @@ -2619,8 +2619,8 @@ void t4vf_sge_stop(struct adapter *adapter) | ||
2529 | int t4vf_sge_init(struct adapter *adapter) | ||
2530 | { | ||
2531 | struct sge_params *sge_params = &adapter->params.sge; | ||
2532 | - u32 fl0 = sge_params->sge_fl_buffer_size[0]; | ||
2533 | - u32 fl1 = sge_params->sge_fl_buffer_size[1]; | ||
2534 | + u32 fl_small_pg = sge_params->sge_fl_buffer_size[0]; | ||
2535 | + u32 fl_large_pg = sge_params->sge_fl_buffer_size[1]; | ||
2536 | struct sge *s = &adapter->sge; | ||
2537 | |||
2538 | /* | ||
2539 | @@ -2628,9 +2628,20 @@ int t4vf_sge_init(struct adapter *adapter) | ||
2540 | * the Physical Function Driver. Ideally we should be able to deal | ||
2541 | * with _any_ configuration. Practice is different ... | ||
2542 | */ | ||
2543 | - if (fl0 != PAGE_SIZE || (fl1 != 0 && fl1 <= fl0)) { | ||
2544 | + | ||
2545 | + /* We only bother using the Large Page logic if the Large Page Buffer | ||
2546 | + * is larger than our Page Size Buffer. | ||
2547 | + */ | ||
2548 | + if (fl_large_pg <= fl_small_pg) | ||
2549 | + fl_large_pg = 0; | ||
2550 | + | ||
2551 | + /* The Page Size Buffer must be exactly equal to our Page Size and the | ||
2552 | + * Large Page Size Buffer should be 0 (per above) or a power of 2. | ||
2553 | + */ | ||
2554 | + if (fl_small_pg != PAGE_SIZE || | ||
2555 | + (fl_large_pg & (fl_large_pg - 1)) != 0) { | ||
2556 | dev_err(adapter->pdev_dev, "bad SGE FL buffer sizes [%d, %d]\n", | ||
2557 | - fl0, fl1); | ||
2558 | + fl_small_pg, fl_large_pg); | ||
2559 | return -EINVAL; | ||
2560 | } | ||
2561 | if ((sge_params->sge_control & RXPKTCPLMODE_F) != | ||
2562 | @@ -2642,8 +2653,8 @@ int t4vf_sge_init(struct adapter *adapter) | ||
2563 | /* | ||
2564 | * Now translate the adapter parameters into our internal forms. | ||
2565 | */ | ||
2566 | - if (fl1) | ||
2567 | - s->fl_pg_order = ilog2(fl1) - PAGE_SHIFT; | ||
2568 | + if (fl_large_pg) | ||
2569 | + s->fl_pg_order = ilog2(fl_large_pg) - PAGE_SHIFT; | ||
2570 | s->stat_len = ((sge_params->sge_control & EGRSTATUSPAGESIZE_F) | ||
2571 | ? 128 : 64); | ||
2572 | s->pktshift = PKTSHIFT_G(sge_params->sge_control); | ||
2573 | diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c | ||
2574 | index a0ef97e7f3c9..ff7a70ffafc6 100644 | ||
2575 | --- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c | ||
2576 | +++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c | ||
2577 | @@ -2092,6 +2092,10 @@ static int hclge_get_autoneg(struct hnae3_handle *handle) | ||
2578 | { | ||
2579 | struct hclge_vport *vport = hclge_get_vport(handle); | ||
2580 | struct hclge_dev *hdev = vport->back; | ||
2581 | + struct phy_device *phydev = hdev->hw.mac.phydev; | ||
2582 | + | ||
2583 | + if (phydev) | ||
2584 | + return phydev->autoneg; | ||
2585 | |||
2586 | hclge_query_autoneg_result(hdev); | ||
2587 | |||
2588 | diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_enet.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_enet.c | ||
2589 | index 186772493711..d1e4dcec5db2 100644 | ||
2590 | --- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_enet.c | ||
2591 | +++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_enet.c | ||
2592 | @@ -1060,6 +1060,8 @@ hns3_nic_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) | ||
2593 | u64 rx_bytes = 0; | ||
2594 | u64 tx_pkts = 0; | ||
2595 | u64 rx_pkts = 0; | ||
2596 | + u64 tx_drop = 0; | ||
2597 | + u64 rx_drop = 0; | ||
2598 | |||
2599 | for (idx = 0; idx < queue_num; idx++) { | ||
2600 | /* fetch the tx stats */ | ||
2601 | @@ -1068,6 +1070,8 @@ hns3_nic_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) | ||
2602 | start = u64_stats_fetch_begin_irq(&ring->syncp); | ||
2603 | tx_bytes += ring->stats.tx_bytes; | ||
2604 | tx_pkts += ring->stats.tx_pkts; | ||
2605 | + tx_drop += ring->stats.tx_busy; | ||
2606 | + tx_drop += ring->stats.sw_err_cnt; | ||
2607 | } while (u64_stats_fetch_retry_irq(&ring->syncp, start)); | ||
2608 | |||
2609 | /* fetch the rx stats */ | ||
2610 | @@ -1076,6 +1080,9 @@ hns3_nic_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) | ||
2611 | start = u64_stats_fetch_begin_irq(&ring->syncp); | ||
2612 | rx_bytes += ring->stats.rx_bytes; | ||
2613 | rx_pkts += ring->stats.rx_pkts; | ||
2614 | + rx_drop += ring->stats.non_vld_descs; | ||
2615 | + rx_drop += ring->stats.err_pkt_len; | ||
2616 | + rx_drop += ring->stats.l2_err; | ||
2617 | } while (u64_stats_fetch_retry_irq(&ring->syncp, start)); | ||
2618 | } | ||
2619 | |||
2620 | @@ -1091,8 +1098,8 @@ hns3_nic_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) | ||
2621 | stats->rx_missed_errors = netdev->stats.rx_missed_errors; | ||
2622 | |||
2623 | stats->tx_errors = netdev->stats.tx_errors; | ||
2624 | - stats->rx_dropped = netdev->stats.rx_dropped; | ||
2625 | - stats->tx_dropped = netdev->stats.tx_dropped; | ||
2626 | + stats->rx_dropped = rx_drop + netdev->stats.rx_dropped; | ||
2627 | + stats->tx_dropped = tx_drop + netdev->stats.tx_dropped; | ||
2628 | stats->collisions = netdev->stats.collisions; | ||
2629 | stats->rx_over_errors = netdev->stats.rx_over_errors; | ||
2630 | stats->rx_frame_errors = netdev->stats.rx_frame_errors; | ||
2631 | @@ -1306,6 +1313,8 @@ static int hns3_nic_change_mtu(struct net_device *netdev, int new_mtu) | ||
2632 | return ret; | ||
2633 | } | ||
2634 | |||
2635 | + netdev->mtu = new_mtu; | ||
2636 | + | ||
2637 | /* if the netdev was running earlier, bring it up again */ | ||
2638 | if (if_running && hns3_nic_net_open(netdev)) | ||
2639 | ret = -EINVAL; | ||
2640 | @@ -2687,8 +2696,12 @@ static int hns3_uninit_all_ring(struct hns3_nic_priv *priv) | ||
2641 | h->ae_algo->ops->reset_queue(h, i); | ||
2642 | |||
2643 | hns3_fini_ring(priv->ring_data[i].ring); | ||
2644 | + devm_kfree(priv->dev, priv->ring_data[i].ring); | ||
2645 | hns3_fini_ring(priv->ring_data[i + h->kinfo.num_tqps].ring); | ||
2646 | + devm_kfree(priv->dev, | ||
2647 | + priv->ring_data[i + h->kinfo.num_tqps].ring); | ||
2648 | } | ||
2649 | + devm_kfree(priv->dev, priv->ring_data); | ||
2650 | |||
2651 | return 0; | ||
2652 | } | ||
2653 | diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_ethtool.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_ethtool.c | ||
2654 | index e590d96e434a..a64a5a413d4d 100644 | ||
2655 | --- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_ethtool.c | ||
2656 | +++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_ethtool.c | ||
2657 | @@ -22,7 +22,8 @@ struct hns3_stats { | ||
2658 | #define HNS3_TQP_STAT(_string, _member) { \ | ||
2659 | .stats_string = _string, \ | ||
2660 | .stats_size = FIELD_SIZEOF(struct ring_stats, _member), \ | ||
2661 | - .stats_offset = offsetof(struct hns3_enet_ring, stats), \ | ||
2662 | + .stats_offset = offsetof(struct hns3_enet_ring, stats) +\ | ||
2663 | + offsetof(struct ring_stats, _member), \ | ||
2664 | } \ | ||
2665 | |||
2666 | static const struct hns3_stats hns3_txq_stats[] = { | ||
2667 | @@ -189,13 +190,13 @@ static u64 *hns3_get_stats_tqps(struct hnae3_handle *handle, u64 *data) | ||
2668 | struct hnae3_knic_private_info *kinfo = &handle->kinfo; | ||
2669 | struct hns3_enet_ring *ring; | ||
2670 | u8 *stat; | ||
2671 | - u32 i; | ||
2672 | + int i, j; | ||
2673 | |||
2674 | /* get stats for Tx */ | ||
2675 | for (i = 0; i < kinfo->num_tqps; i++) { | ||
2676 | ring = nic_priv->ring_data[i].ring; | ||
2677 | - for (i = 0; i < HNS3_TXQ_STATS_COUNT; i++) { | ||
2678 | - stat = (u8 *)ring + hns3_txq_stats[i].stats_offset; | ||
2679 | + for (j = 0; j < HNS3_TXQ_STATS_COUNT; j++) { | ||
2680 | + stat = (u8 *)ring + hns3_txq_stats[j].stats_offset; | ||
2681 | *data++ = *(u64 *)stat; | ||
2682 | } | ||
2683 | } | ||
2684 | @@ -203,8 +204,8 @@ static u64 *hns3_get_stats_tqps(struct hnae3_handle *handle, u64 *data) | ||
2685 | /* get stats for Rx */ | ||
2686 | for (i = 0; i < kinfo->num_tqps; i++) { | ||
2687 | ring = nic_priv->ring_data[i + kinfo->num_tqps].ring; | ||
2688 | - for (i = 0; i < HNS3_RXQ_STATS_COUNT; i++) { | ||
2689 | - stat = (u8 *)ring + hns3_rxq_stats[i].stats_offset; | ||
2690 | + for (j = 0; j < HNS3_RXQ_STATS_COUNT; j++) { | ||
2691 | + stat = (u8 *)ring + hns3_rxq_stats[j].stats_offset; | ||
2692 | *data++ = *(u64 *)stat; | ||
2693 | } | ||
2694 | } | ||
2695 | diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c | ||
2696 | index 3b0db01ead1f..3ae02b0620bc 100644 | ||
2697 | --- a/drivers/net/ethernet/ibm/ibmvnic.c | ||
2698 | +++ b/drivers/net/ethernet/ibm/ibmvnic.c | ||
2699 | @@ -2209,6 +2209,12 @@ static irqreturn_t ibmvnic_interrupt_rx(int irq, void *instance) | ||
2700 | struct ibmvnic_sub_crq_queue *scrq = instance; | ||
2701 | struct ibmvnic_adapter *adapter = scrq->adapter; | ||
2702 | |||
2703 | + /* When booting a kdump kernel we can hit pending interrupts | ||
2704 | + * prior to completing driver initialization. | ||
2705 | + */ | ||
2706 | + if (unlikely(adapter->state != VNIC_OPEN)) | ||
2707 | + return IRQ_NONE; | ||
2708 | + | ||
2709 | adapter->rx_stats_buffers[scrq->scrq_num].interrupts++; | ||
2710 | |||
2711 | if (napi_schedule_prep(&adapter->napi[scrq->scrq_num])) { | ||
2712 | diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_main.c b/drivers/net/ethernet/intel/i40evf/i40evf_main.c | ||
2713 | index 1ccad6f30ebf..4eb6ff60e8fc 100644 | ||
2714 | --- a/drivers/net/ethernet/intel/i40evf/i40evf_main.c | ||
2715 | +++ b/drivers/net/ethernet/intel/i40evf/i40evf_main.c | ||
2716 | @@ -1775,7 +1775,11 @@ static void i40evf_disable_vf(struct i40evf_adapter *adapter) | ||
2717 | |||
2718 | adapter->flags |= I40EVF_FLAG_PF_COMMS_FAILED; | ||
2719 | |||
2720 | - if (netif_running(adapter->netdev)) { | ||
2721 | + /* We don't use netif_running() because it may be true prior to | ||
2722 | + * ndo_open() returning, so we can't assume it means all our open | ||
2723 | + * tasks have finished, since we're not holding the rtnl_lock here. | ||
2724 | + */ | ||
2725 | + if (adapter->state == __I40EVF_RUNNING) { | ||
2726 | set_bit(__I40E_VSI_DOWN, adapter->vsi.state); | ||
2727 | netif_carrier_off(adapter->netdev); | ||
2728 | netif_tx_disable(adapter->netdev); | ||
2729 | @@ -1833,6 +1837,7 @@ static void i40evf_reset_task(struct work_struct *work) | ||
2730 | struct i40evf_mac_filter *f; | ||
2731 | u32 reg_val; | ||
2732 | int i = 0, err; | ||
2733 | + bool running; | ||
2734 | |||
2735 | while (test_and_set_bit(__I40EVF_IN_CLIENT_TASK, | ||
2736 | &adapter->crit_section)) | ||
2737 | @@ -1892,7 +1897,13 @@ static void i40evf_reset_task(struct work_struct *work) | ||
2738 | } | ||
2739 | |||
2740 | continue_reset: | ||
2741 | - if (netif_running(netdev)) { | ||
2742 | + /* We don't use netif_running() because it may be true prior to | ||
2743 | + * ndo_open() returning, so we can't assume it means all our open | ||
2744 | + * tasks have finished, since we're not holding the rtnl_lock here. | ||
2745 | + */ | ||
2746 | + running = (adapter->state == __I40EVF_RUNNING); | ||
2747 | + | ||
2748 | + if (running) { | ||
2749 | netif_carrier_off(netdev); | ||
2750 | netif_tx_stop_all_queues(netdev); | ||
2751 | adapter->link_up = false; | ||
2752 | @@ -1936,7 +1947,10 @@ static void i40evf_reset_task(struct work_struct *work) | ||
2753 | |||
2754 | mod_timer(&adapter->watchdog_timer, jiffies + 2); | ||
2755 | |||
2756 | - if (netif_running(adapter->netdev)) { | ||
2757 | + /* We were running when the reset started, so we need to restore some | ||
2758 | + * state here. | ||
2759 | + */ | ||
2760 | + if (running) { | ||
2761 | /* allocate transmit descriptors */ | ||
2762 | err = i40evf_setup_all_tx_resources(adapter); | ||
2763 | if (err) | ||
2764 | diff --git a/drivers/net/ethernet/marvell/sky2.c b/drivers/net/ethernet/marvell/sky2.c | ||
2765 | index 1145cde2274a..b12e3a4f9439 100644 | ||
2766 | --- a/drivers/net/ethernet/marvell/sky2.c | ||
2767 | +++ b/drivers/net/ethernet/marvell/sky2.c | ||
2768 | @@ -5087,7 +5087,7 @@ static int sky2_probe(struct pci_dev *pdev, const struct pci_device_id *ent) | ||
2769 | INIT_WORK(&hw->restart_work, sky2_restart); | ||
2770 | |||
2771 | pci_set_drvdata(pdev, hw); | ||
2772 | - pdev->d3_delay = 150; | ||
2773 | + pdev->d3_delay = 200; | ||
2774 | |||
2775 | return 0; | ||
2776 | |||
2777 | diff --git a/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c b/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c | ||
2778 | index 5f41dc92aa68..752a72499b4f 100644 | ||
2779 | --- a/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c | ||
2780 | +++ b/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c | ||
2781 | @@ -156,57 +156,63 @@ static int mlx4_en_dcbnl_getnumtcs(struct net_device *netdev, int tcid, u8 *num) | ||
2782 | static u8 mlx4_en_dcbnl_set_all(struct net_device *netdev) | ||
2783 | { | ||
2784 | struct mlx4_en_priv *priv = netdev_priv(netdev); | ||
2785 | + struct mlx4_en_port_profile *prof = priv->prof; | ||
2786 | struct mlx4_en_dev *mdev = priv->mdev; | ||
2787 | + u8 tx_pause, tx_ppp, rx_pause, rx_ppp; | ||
2788 | |||
2789 | if (!(priv->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) | ||
2790 | return 1; | ||
2791 | |||
2792 | if (priv->cee_config.pfc_state) { | ||
2793 | int tc; | ||
2794 | + rx_ppp = prof->rx_ppp; | ||
2795 | + tx_ppp = prof->tx_ppp; | ||
2796 | |||
2797 | - priv->prof->rx_pause = 0; | ||
2798 | - priv->prof->tx_pause = 0; | ||
2799 | for (tc = 0; tc < CEE_DCBX_MAX_PRIO; tc++) { | ||
2800 | u8 tc_mask = 1 << tc; | ||
2801 | |||
2802 | switch (priv->cee_config.dcb_pfc[tc]) { | ||
2803 | case pfc_disabled: | ||
2804 | - priv->prof->tx_ppp &= ~tc_mask; | ||
2805 | - priv->prof->rx_ppp &= ~tc_mask; | ||
2806 | + tx_ppp &= ~tc_mask; | ||
2807 | + rx_ppp &= ~tc_mask; | ||
2808 | break; | ||
2809 | case pfc_enabled_full: | ||
2810 | - priv->prof->tx_ppp |= tc_mask; | ||
2811 | - priv->prof->rx_ppp |= tc_mask; | ||
2812 | + tx_ppp |= tc_mask; | ||
2813 | + rx_ppp |= tc_mask; | ||
2814 | break; | ||
2815 | case pfc_enabled_tx: | ||
2816 | - priv->prof->tx_ppp |= tc_mask; | ||
2817 | - priv->prof->rx_ppp &= ~tc_mask; | ||
2818 | + tx_ppp |= tc_mask; | ||
2819 | + rx_ppp &= ~tc_mask; | ||
2820 | break; | ||
2821 | case pfc_enabled_rx: | ||
2822 | - priv->prof->tx_ppp &= ~tc_mask; | ||
2823 | - priv->prof->rx_ppp |= tc_mask; | ||
2824 | + tx_ppp &= ~tc_mask; | ||
2825 | + rx_ppp |= tc_mask; | ||
2826 | break; | ||
2827 | default: | ||
2828 | break; | ||
2829 | } | ||
2830 | } | ||
2831 | - en_dbg(DRV, priv, "Set pfc on\n"); | ||
2832 | + rx_pause = !!(rx_ppp || tx_ppp) ? 0 : prof->rx_pause; | ||
2833 | + tx_pause = !!(rx_ppp || tx_ppp) ? 0 : prof->tx_pause; | ||
2834 | } else { | ||
2835 | - priv->prof->rx_pause = 1; | ||
2836 | - priv->prof->tx_pause = 1; | ||
2837 | - en_dbg(DRV, priv, "Set pfc off\n"); | ||
2838 | + rx_ppp = 0; | ||
2839 | + tx_ppp = 0; | ||
2840 | + rx_pause = prof->rx_pause; | ||
2841 | + tx_pause = prof->tx_pause; | ||
2842 | } | ||
2843 | |||
2844 | if (mlx4_SET_PORT_general(mdev->dev, priv->port, | ||
2845 | priv->rx_skb_size + ETH_FCS_LEN, | ||
2846 | - priv->prof->tx_pause, | ||
2847 | - priv->prof->tx_ppp, | ||
2848 | - priv->prof->rx_pause, | ||
2849 | - priv->prof->rx_ppp)) { | ||
2850 | + tx_pause, tx_ppp, rx_pause, rx_ppp)) { | ||
2851 | en_err(priv, "Failed setting pause params\n"); | ||
2852 | return 1; | ||
2853 | } | ||
2854 | |||
2855 | + prof->tx_ppp = tx_ppp; | ||
2856 | + prof->rx_ppp = rx_ppp; | ||
2857 | + prof->tx_pause = tx_pause; | ||
2858 | + prof->rx_pause = rx_pause; | ||
2859 | + | ||
2860 | return 0; | ||
2861 | } | ||
2862 | |||
2863 | @@ -310,6 +316,7 @@ static int mlx4_en_ets_validate(struct mlx4_en_priv *priv, struct ieee_ets *ets) | ||
2864 | } | ||
2865 | |||
2866 | switch (ets->tc_tsa[i]) { | ||
2867 | + case IEEE_8021QAZ_TSA_VENDOR: | ||
2868 | case IEEE_8021QAZ_TSA_STRICT: | ||
2869 | break; | ||
2870 | case IEEE_8021QAZ_TSA_ETS: | ||
2871 | @@ -347,6 +354,10 @@ static int mlx4_en_config_port_scheduler(struct mlx4_en_priv *priv, | ||
2872 | /* higher TC means higher priority => lower pg */ | ||
2873 | for (i = IEEE_8021QAZ_MAX_TCS - 1; i >= 0; i--) { | ||
2874 | switch (ets->tc_tsa[i]) { | ||
2875 | + case IEEE_8021QAZ_TSA_VENDOR: | ||
2876 | + pg[i] = MLX4_EN_TC_VENDOR; | ||
2877 | + tc_tx_bw[i] = MLX4_EN_BW_MAX; | ||
2878 | + break; | ||
2879 | case IEEE_8021QAZ_TSA_STRICT: | ||
2880 | pg[i] = num_strict++; | ||
2881 | tc_tx_bw[i] = MLX4_EN_BW_MAX; | ||
2882 | @@ -403,6 +414,7 @@ static int mlx4_en_dcbnl_ieee_setpfc(struct net_device *dev, | ||
2883 | struct mlx4_en_priv *priv = netdev_priv(dev); | ||
2884 | struct mlx4_en_port_profile *prof = priv->prof; | ||
2885 | struct mlx4_en_dev *mdev = priv->mdev; | ||
2886 | + u32 tx_pause, tx_ppp, rx_pause, rx_ppp; | ||
2887 | int err; | ||
2888 | |||
2889 | en_dbg(DRV, priv, "cap: 0x%x en: 0x%x mbc: 0x%x delay: %d\n", | ||
2890 | @@ -411,23 +423,26 @@ static int mlx4_en_dcbnl_ieee_setpfc(struct net_device *dev, | ||
2891 | pfc->mbc, | ||
2892 | pfc->delay); | ||
2893 | |||
2894 | - prof->rx_pause = !pfc->pfc_en; | ||
2895 | - prof->tx_pause = !pfc->pfc_en; | ||
2896 | - prof->rx_ppp = pfc->pfc_en; | ||
2897 | - prof->tx_ppp = pfc->pfc_en; | ||
2898 | + rx_pause = prof->rx_pause && !pfc->pfc_en; | ||
2899 | + tx_pause = prof->tx_pause && !pfc->pfc_en; | ||
2900 | + rx_ppp = pfc->pfc_en; | ||
2901 | + tx_ppp = pfc->pfc_en; | ||
2902 | |||
2903 | err = mlx4_SET_PORT_general(mdev->dev, priv->port, | ||
2904 | priv->rx_skb_size + ETH_FCS_LEN, | ||
2905 | - prof->tx_pause, | ||
2906 | - prof->tx_ppp, | ||
2907 | - prof->rx_pause, | ||
2908 | - prof->rx_ppp); | ||
2909 | - if (err) | ||
2910 | + tx_pause, tx_ppp, rx_pause, rx_ppp); | ||
2911 | + if (err) { | ||
2912 | en_err(priv, "Failed setting pause params\n"); | ||
2913 | - else | ||
2914 | - mlx4_en_update_pfc_stats_bitmap(mdev->dev, &priv->stats_bitmap, | ||
2915 | - prof->rx_ppp, prof->rx_pause, | ||
2916 | - prof->tx_ppp, prof->tx_pause); | ||
2917 | + return err; | ||
2918 | + } | ||
2919 | + | ||
2920 | + mlx4_en_update_pfc_stats_bitmap(mdev->dev, &priv->stats_bitmap, | ||
2921 | + rx_ppp, rx_pause, tx_ppp, tx_pause); | ||
2922 | + | ||
2923 | + prof->tx_ppp = tx_ppp; | ||
2924 | + prof->rx_ppp = rx_ppp; | ||
2925 | + prof->rx_pause = rx_pause; | ||
2926 | + prof->tx_pause = tx_pause; | ||
2927 | |||
2928 | return err; | ||
2929 | } | ||
2930 | diff --git a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c | ||
2931 | index 3d4e4a5d00d1..67f74fcb265e 100644 | ||
2932 | --- a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c | ||
2933 | +++ b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c | ||
2934 | @@ -1046,27 +1046,32 @@ static int mlx4_en_set_pauseparam(struct net_device *dev, | ||
2935 | { | ||
2936 | struct mlx4_en_priv *priv = netdev_priv(dev); | ||
2937 | struct mlx4_en_dev *mdev = priv->mdev; | ||
2938 | + u8 tx_pause, tx_ppp, rx_pause, rx_ppp; | ||
2939 | int err; | ||
2940 | |||
2941 | if (pause->autoneg) | ||
2942 | return -EINVAL; | ||
2943 | |||
2944 | - priv->prof->tx_pause = pause->tx_pause != 0; | ||
2945 | - priv->prof->rx_pause = pause->rx_pause != 0; | ||
2946 | + tx_pause = !!(pause->tx_pause); | ||
2947 | + rx_pause = !!(pause->rx_pause); | ||
2948 | + rx_ppp = priv->prof->rx_ppp && !(tx_pause || rx_pause); | ||
2949 | + tx_ppp = priv->prof->tx_ppp && !(tx_pause || rx_pause); | ||
2950 | + | ||
2951 | err = mlx4_SET_PORT_general(mdev->dev, priv->port, | ||
2952 | priv->rx_skb_size + ETH_FCS_LEN, | ||
2953 | - priv->prof->tx_pause, | ||
2954 | - priv->prof->tx_ppp, | ||
2955 | - priv->prof->rx_pause, | ||
2956 | - priv->prof->rx_ppp); | ||
2957 | - if (err) | ||
2958 | - en_err(priv, "Failed setting pause params\n"); | ||
2959 | - else | ||
2960 | - mlx4_en_update_pfc_stats_bitmap(mdev->dev, &priv->stats_bitmap, | ||
2961 | - priv->prof->rx_ppp, | ||
2962 | - priv->prof->rx_pause, | ||
2963 | - priv->prof->tx_ppp, | ||
2964 | - priv->prof->tx_pause); | ||
2965 | + tx_pause, tx_ppp, rx_pause, rx_ppp); | ||
2966 | + if (err) { | ||
2967 | + en_err(priv, "Failed setting pause params, err = %d\n", err); | ||
2968 | + return err; | ||
2969 | + } | ||
2970 | + | ||
2971 | + mlx4_en_update_pfc_stats_bitmap(mdev->dev, &priv->stats_bitmap, | ||
2972 | + rx_ppp, rx_pause, tx_ppp, tx_pause); | ||
2973 | + | ||
2974 | + priv->prof->tx_pause = tx_pause; | ||
2975 | + priv->prof->rx_pause = rx_pause; | ||
2976 | + priv->prof->tx_ppp = tx_ppp; | ||
2977 | + priv->prof->rx_ppp = rx_ppp; | ||
2978 | |||
2979 | return err; | ||
2980 | } | ||
2981 | diff --git a/drivers/net/ethernet/mellanox/mlx4/en_main.c b/drivers/net/ethernet/mellanox/mlx4/en_main.c | ||
2982 | index 686e18de9a97..6b2f7122b3ab 100644 | ||
2983 | --- a/drivers/net/ethernet/mellanox/mlx4/en_main.c | ||
2984 | +++ b/drivers/net/ethernet/mellanox/mlx4/en_main.c | ||
2985 | @@ -163,9 +163,9 @@ static void mlx4_en_get_profile(struct mlx4_en_dev *mdev) | ||
2986 | params->udp_rss = 0; | ||
2987 | } | ||
2988 | for (i = 1; i <= MLX4_MAX_PORTS; i++) { | ||
2989 | - params->prof[i].rx_pause = 1; | ||
2990 | + params->prof[i].rx_pause = !(pfcrx || pfctx); | ||
2991 | params->prof[i].rx_ppp = pfcrx; | ||
2992 | - params->prof[i].tx_pause = 1; | ||
2993 | + params->prof[i].tx_pause = !(pfcrx || pfctx); | ||
2994 | params->prof[i].tx_ppp = pfctx; | ||
2995 | params->prof[i].tx_ring_size = MLX4_EN_DEF_TX_RING_SIZE; | ||
2996 | params->prof[i].rx_ring_size = MLX4_EN_DEF_RX_RING_SIZE; | ||
2997 | diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c | ||
2998 | index 9c218f1cfc6c..c097eef41a9c 100644 | ||
2999 | --- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c | ||
3000 | +++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c | ||
3001 | @@ -3335,6 +3335,13 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, | ||
3002 | priv->msg_enable = MLX4_EN_MSG_LEVEL; | ||
3003 | #ifdef CONFIG_MLX4_EN_DCB | ||
3004 | if (!mlx4_is_slave(priv->mdev->dev)) { | ||
3005 | + u8 prio; | ||
3006 | + | ||
3007 | + for (prio = 0; prio < IEEE_8021QAZ_MAX_TCS; ++prio) { | ||
3008 | + priv->ets.prio_tc[prio] = prio; | ||
3009 | + priv->ets.tc_tsa[prio] = IEEE_8021QAZ_TSA_VENDOR; | ||
3010 | + } | ||
3011 | + | ||
3012 | priv->dcbx_cap = DCB_CAP_DCBX_VER_CEE | DCB_CAP_DCBX_HOST | | ||
3013 | DCB_CAP_DCBX_VER_IEEE; | ||
3014 | priv->flags |= MLX4_EN_DCB_ENABLED; | ||
3015 | diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h | ||
3016 | index fdb3ad0cbe54..2c1a5ff6acfa 100644 | ||
3017 | --- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h | ||
3018 | +++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h | ||
3019 | @@ -476,6 +476,7 @@ struct mlx4_en_frag_info { | ||
3020 | #define MLX4_EN_BW_MIN 1 | ||
3021 | #define MLX4_EN_BW_MAX 100 /* Utilize 100% of the line */ | ||
3022 | |||
3023 | +#define MLX4_EN_TC_VENDOR 0 | ||
3024 | #define MLX4_EN_TC_ETS 7 | ||
3025 | |||
3026 | enum dcb_pfc_type { | ||
3027 | diff --git a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c | ||
3028 | index fabb53379727..a069fcc823c3 100644 | ||
3029 | --- a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c | ||
3030 | +++ b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c | ||
3031 | @@ -5089,6 +5089,7 @@ static void rem_slave_fs_rule(struct mlx4_dev *dev, int slave) | ||
3032 | &tracker->res_tree[RES_FS_RULE]); | ||
3033 | list_del(&fs_rule->com.list); | ||
3034 | spin_unlock_irq(mlx4_tlock(dev)); | ||
3035 | + kfree(fs_rule->mirr_mbox); | ||
3036 | kfree(fs_rule); | ||
3037 | state = 0; | ||
3038 | break; | ||
3039 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c | ||
3040 | index a863572882b2..225b2ad3e15f 100644 | ||
3041 | --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c | ||
3042 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c | ||
3043 | @@ -2718,6 +2718,9 @@ int mlx5e_open(struct net_device *netdev) | ||
3044 | mlx5_set_port_admin_status(priv->mdev, MLX5_PORT_UP); | ||
3045 | mutex_unlock(&priv->state_lock); | ||
3046 | |||
3047 | + if (mlx5e_vxlan_allowed(priv->mdev)) | ||
3048 | + udp_tunnel_get_rx_info(netdev); | ||
3049 | + | ||
3050 | return err; | ||
3051 | } | ||
3052 | |||
3053 | @@ -4276,13 +4279,6 @@ static void mlx5e_nic_enable(struct mlx5e_priv *priv) | ||
3054 | if (netdev->reg_state != NETREG_REGISTERED) | ||
3055 | return; | ||
3056 | |||
3057 | - /* Device already registered: sync netdev system state */ | ||
3058 | - if (mlx5e_vxlan_allowed(mdev)) { | ||
3059 | - rtnl_lock(); | ||
3060 | - udp_tunnel_get_rx_info(netdev); | ||
3061 | - rtnl_unlock(); | ||
3062 | - } | ||
3063 | - | ||
3064 | queue_work(priv->wq, &priv->set_rx_mode_work); | ||
3065 | |||
3066 | rtnl_lock(); | ||
3067 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c | ||
3068 | index 45e03c427faf..5ffd1db4e797 100644 | ||
3069 | --- a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c | ||
3070 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c | ||
3071 | @@ -43,6 +43,11 @@ | ||
3072 | #include "en_tc.h" | ||
3073 | #include "fs_core.h" | ||
3074 | |||
3075 | +#define MLX5E_REP_PARAMS_LOG_SQ_SIZE \ | ||
3076 | + max(0x6, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE) | ||
3077 | +#define MLX5E_REP_PARAMS_LOG_RQ_SIZE \ | ||
3078 | + max(0x6, MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE) | ||
3079 | + | ||
3080 | static const char mlx5e_rep_driver_name[] = "mlx5e_rep"; | ||
3081 | |||
3082 | static void mlx5e_rep_get_drvinfo(struct net_device *dev, | ||
3083 | @@ -230,7 +235,7 @@ void mlx5e_remove_sqs_fwd_rules(struct mlx5e_priv *priv) | ||
3084 | static void mlx5e_rep_neigh_update_init_interval(struct mlx5e_rep_priv *rpriv) | ||
3085 | { | ||
3086 | #if IS_ENABLED(CONFIG_IPV6) | ||
3087 | - unsigned long ipv6_interval = NEIGH_VAR(&ipv6_stub->nd_tbl->parms, | ||
3088 | + unsigned long ipv6_interval = NEIGH_VAR(&nd_tbl.parms, | ||
3089 | DELAY_PROBE_TIME); | ||
3090 | #else | ||
3091 | unsigned long ipv6_interval = ~0UL; | ||
3092 | @@ -366,7 +371,7 @@ static int mlx5e_rep_netevent_event(struct notifier_block *nb, | ||
3093 | case NETEVENT_NEIGH_UPDATE: | ||
3094 | n = ptr; | ||
3095 | #if IS_ENABLED(CONFIG_IPV6) | ||
3096 | - if (n->tbl != ipv6_stub->nd_tbl && n->tbl != &arp_tbl) | ||
3097 | + if (n->tbl != &nd_tbl && n->tbl != &arp_tbl) | ||
3098 | #else | ||
3099 | if (n->tbl != &arp_tbl) | ||
3100 | #endif | ||
3101 | @@ -414,7 +419,7 @@ static int mlx5e_rep_netevent_event(struct notifier_block *nb, | ||
3102 | * done per device delay prob time parameter. | ||
3103 | */ | ||
3104 | #if IS_ENABLED(CONFIG_IPV6) | ||
3105 | - if (!p->dev || (p->tbl != ipv6_stub->nd_tbl && p->tbl != &arp_tbl)) | ||
3106 | + if (!p->dev || (p->tbl != &nd_tbl && p->tbl != &arp_tbl)) | ||
3107 | #else | ||
3108 | if (!p->dev || p->tbl != &arp_tbl) | ||
3109 | #endif | ||
3110 | @@ -610,7 +615,6 @@ static int mlx5e_rep_open(struct net_device *dev) | ||
3111 | struct mlx5e_priv *priv = netdev_priv(dev); | ||
3112 | struct mlx5e_rep_priv *rpriv = priv->ppriv; | ||
3113 | struct mlx5_eswitch_rep *rep = rpriv->rep; | ||
3114 | - struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; | ||
3115 | int err; | ||
3116 | |||
3117 | mutex_lock(&priv->state_lock); | ||
3118 | @@ -618,8 +622,9 @@ static int mlx5e_rep_open(struct net_device *dev) | ||
3119 | if (err) | ||
3120 | goto unlock; | ||
3121 | |||
3122 | - if (!mlx5_eswitch_set_vport_state(esw, rep->vport, | ||
3123 | - MLX5_ESW_VPORT_ADMIN_STATE_UP)) | ||
3124 | + if (!mlx5_modify_vport_admin_state(priv->mdev, | ||
3125 | + MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT, | ||
3126 | + rep->vport, MLX5_ESW_VPORT_ADMIN_STATE_UP)) | ||
3127 | netif_carrier_on(dev); | ||
3128 | |||
3129 | unlock: | ||
3130 | @@ -632,11 +637,12 @@ static int mlx5e_rep_close(struct net_device *dev) | ||
3131 | struct mlx5e_priv *priv = netdev_priv(dev); | ||
3132 | struct mlx5e_rep_priv *rpriv = priv->ppriv; | ||
3133 | struct mlx5_eswitch_rep *rep = rpriv->rep; | ||
3134 | - struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; | ||
3135 | int ret; | ||
3136 | |||
3137 | mutex_lock(&priv->state_lock); | ||
3138 | - (void)mlx5_eswitch_set_vport_state(esw, rep->vport, MLX5_ESW_VPORT_ADMIN_STATE_DOWN); | ||
3139 | + mlx5_modify_vport_admin_state(priv->mdev, | ||
3140 | + MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT, | ||
3141 | + rep->vport, MLX5_ESW_VPORT_ADMIN_STATE_DOWN); | ||
3142 | ret = mlx5e_close_locked(dev); | ||
3143 | mutex_unlock(&priv->state_lock); | ||
3144 | return ret; | ||
3145 | @@ -797,9 +803,9 @@ static void mlx5e_build_rep_params(struct mlx5_core_dev *mdev, | ||
3146 | MLX5_CQ_PERIOD_MODE_START_FROM_CQE : | ||
3147 | MLX5_CQ_PERIOD_MODE_START_FROM_EQE; | ||
3148 | |||
3149 | - params->log_sq_size = MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE; | ||
3150 | + params->log_sq_size = MLX5E_REP_PARAMS_LOG_SQ_SIZE; | ||
3151 | params->rq_wq_type = MLX5_WQ_TYPE_LINKED_LIST; | ||
3152 | - params->log_rq_size = MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE; | ||
3153 | + params->log_rq_size = MLX5E_REP_PARAMS_LOG_RQ_SIZE; | ||
3154 | |||
3155 | params->rx_am_enabled = MLX5_CAP_GEN(mdev, cq_moderation); | ||
3156 | mlx5e_set_rx_cq_mode_params(params, cq_period_mode); | ||
3157 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | ||
3158 | index 9ba1f72060aa..42bab73a9f40 100644 | ||
3159 | --- a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | ||
3160 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | ||
3161 | @@ -484,7 +484,7 @@ void mlx5e_tc_update_neigh_used_value(struct mlx5e_neigh_hash_entry *nhe) | ||
3162 | tbl = &arp_tbl; | ||
3163 | #if IS_ENABLED(CONFIG_IPV6) | ||
3164 | else if (m_neigh->family == AF_INET6) | ||
3165 | - tbl = ipv6_stub->nd_tbl; | ||
3166 | + tbl = &nd_tbl; | ||
3167 | #endif | ||
3168 | else | ||
3169 | return; | ||
3170 | @@ -2091,19 +2091,19 @@ int mlx5e_configure_flower(struct mlx5e_priv *priv, | ||
3171 | if (err != -EAGAIN) | ||
3172 | flow->flags |= MLX5E_TC_FLOW_OFFLOADED; | ||
3173 | |||
3174 | + if (!(flow->flags & MLX5E_TC_FLOW_ESWITCH) || | ||
3175 | + !(flow->esw_attr->action & MLX5_FLOW_CONTEXT_ACTION_ENCAP)) | ||
3176 | + kvfree(parse_attr); | ||
3177 | + | ||
3178 | err = rhashtable_insert_fast(&tc->ht, &flow->node, | ||
3179 | tc->ht_params); | ||
3180 | - if (err) | ||
3181 | - goto err_del_rule; | ||
3182 | + if (err) { | ||
3183 | + mlx5e_tc_del_flow(priv, flow); | ||
3184 | + kfree(flow); | ||
3185 | + } | ||
3186 | |||
3187 | - if (flow->flags & MLX5E_TC_FLOW_ESWITCH && | ||
3188 | - !(flow->esw_attr->action & MLX5_FLOW_CONTEXT_ACTION_ENCAP)) | ||
3189 | - kvfree(parse_attr); | ||
3190 | return err; | ||
3191 | |||
3192 | -err_del_rule: | ||
3193 | - mlx5e_tc_del_flow(priv, flow); | ||
3194 | - | ||
3195 | err_free: | ||
3196 | kvfree(parse_attr); | ||
3197 | kfree(flow); | ||
3198 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/vport.c b/drivers/net/ethernet/mellanox/mlx5/core/vport.c | ||
3199 | index a1296a62497d..71153c0f1605 100644 | ||
3200 | --- a/drivers/net/ethernet/mellanox/mlx5/core/vport.c | ||
3201 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/vport.c | ||
3202 | @@ -36,6 +36,9 @@ | ||
3203 | #include <linux/mlx5/vport.h> | ||
3204 | #include "mlx5_core.h" | ||
3205 | |||
3206 | +/* Mutex to hold while enabling or disabling RoCE */ | ||
3207 | +static DEFINE_MUTEX(mlx5_roce_en_lock); | ||
3208 | + | ||
3209 | static int _mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod, | ||
3210 | u16 vport, u32 *out, int outlen) | ||
3211 | { | ||
3212 | @@ -998,17 +1001,35 @@ static int mlx5_nic_vport_update_roce_state(struct mlx5_core_dev *mdev, | ||
3213 | |||
3214 | int mlx5_nic_vport_enable_roce(struct mlx5_core_dev *mdev) | ||
3215 | { | ||
3216 | - if (atomic_inc_return(&mdev->roce.roce_en) != 1) | ||
3217 | - return 0; | ||
3218 | - return mlx5_nic_vport_update_roce_state(mdev, MLX5_VPORT_ROCE_ENABLED); | ||
3219 | + int err = 0; | ||
3220 | + | ||
3221 | + mutex_lock(&mlx5_roce_en_lock); | ||
3222 | + if (!mdev->roce.roce_en) | ||
3223 | + err = mlx5_nic_vport_update_roce_state(mdev, MLX5_VPORT_ROCE_ENABLED); | ||
3224 | + | ||
3225 | + if (!err) | ||
3226 | + mdev->roce.roce_en++; | ||
3227 | + mutex_unlock(&mlx5_roce_en_lock); | ||
3228 | + | ||
3229 | + return err; | ||
3230 | } | ||
3231 | EXPORT_SYMBOL_GPL(mlx5_nic_vport_enable_roce); | ||
3232 | |||
3233 | int mlx5_nic_vport_disable_roce(struct mlx5_core_dev *mdev) | ||
3234 | { | ||
3235 | - if (atomic_dec_return(&mdev->roce.roce_en) != 0) | ||
3236 | - return 0; | ||
3237 | - return mlx5_nic_vport_update_roce_state(mdev, MLX5_VPORT_ROCE_DISABLED); | ||
3238 | + int err = 0; | ||
3239 | + | ||
3240 | + mutex_lock(&mlx5_roce_en_lock); | ||
3241 | + if (mdev->roce.roce_en) { | ||
3242 | + mdev->roce.roce_en--; | ||
3243 | + if (mdev->roce.roce_en == 0) | ||
3244 | + err = mlx5_nic_vport_update_roce_state(mdev, MLX5_VPORT_ROCE_DISABLED); | ||
3245 | + | ||
3246 | + if (err) | ||
3247 | + mdev->roce.roce_en++; | ||
3248 | + } | ||
3249 | + mutex_unlock(&mlx5_roce_en_lock); | ||
3250 | + return err; | ||
3251 | } | ||
3252 | EXPORT_SYMBOL_GPL(mlx5_nic_vport_disable_roce); | ||
3253 | |||
3254 | diff --git a/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c b/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c | ||
3255 | index 37364555c42b..f88ff3f4b661 100644 | ||
3256 | --- a/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c | ||
3257 | +++ b/drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c | ||
3258 | @@ -68,10 +68,11 @@ | ||
3259 | /* CPP address to retrieve the data from */ | ||
3260 | #define NSP_BUFFER 0x10 | ||
3261 | #define NSP_BUFFER_CPP GENMASK_ULL(63, 40) | ||
3262 | -#define NSP_BUFFER_PCIE GENMASK_ULL(39, 38) | ||
3263 | -#define NSP_BUFFER_ADDRESS GENMASK_ULL(37, 0) | ||
3264 | +#define NSP_BUFFER_ADDRESS GENMASK_ULL(39, 0) | ||
3265 | |||
3266 | #define NSP_DFLT_BUFFER 0x18 | ||
3267 | +#define NSP_DFLT_BUFFER_CPP GENMASK_ULL(63, 40) | ||
3268 | +#define NSP_DFLT_BUFFER_ADDRESS GENMASK_ULL(39, 0) | ||
3269 | |||
3270 | #define NSP_DFLT_BUFFER_CONFIG 0x20 | ||
3271 | #define NSP_DFLT_BUFFER_SIZE_MB GENMASK_ULL(7, 0) | ||
3272 | @@ -412,8 +413,8 @@ static int nfp_nsp_command_buf(struct nfp_nsp *nsp, u16 code, u32 option, | ||
3273 | if (err < 0) | ||
3274 | return err; | ||
3275 | |||
3276 | - cpp_id = FIELD_GET(NSP_BUFFER_CPP, reg) << 8; | ||
3277 | - cpp_buf = FIELD_GET(NSP_BUFFER_ADDRESS, reg); | ||
3278 | + cpp_id = FIELD_GET(NSP_DFLT_BUFFER_CPP, reg) << 8; | ||
3279 | + cpp_buf = FIELD_GET(NSP_DFLT_BUFFER_ADDRESS, reg); | ||
3280 | |||
3281 | if (in_buf && in_size) { | ||
3282 | err = nfp_cpp_write(cpp, cpp_id, cpp_buf, in_buf, in_size); | ||
3283 | diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c | ||
3284 | index 619a1b7281a0..db553d4e8d22 100644 | ||
3285 | --- a/drivers/net/ethernet/realtek/r8169.c | ||
3286 | +++ b/drivers/net/ethernet/realtek/r8169.c | ||
3287 | @@ -8466,12 +8466,12 @@ static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) | ||
3288 | goto err_out_msi_5; | ||
3289 | } | ||
3290 | |||
3291 | + pci_set_drvdata(pdev, dev); | ||
3292 | + | ||
3293 | rc = register_netdev(dev); | ||
3294 | if (rc < 0) | ||
3295 | goto err_out_cnt_6; | ||
3296 | |||
3297 | - pci_set_drvdata(pdev, dev); | ||
3298 | - | ||
3299 | netif_info(tp, probe, dev, "%s at 0x%p, %pM, XID %08x IRQ %d\n", | ||
3300 | rtl_chip_infos[chipset].name, ioaddr, dev->dev_addr, | ||
3301 | (u32)(RTL_R32(TxConfig) & 0x9cf0f8ff), pdev->irq); | ||
3302 | diff --git a/drivers/net/ppp/pptp.c b/drivers/net/ppp/pptp.c | ||
3303 | index 6dde9a0cfe76..9b70a3af678e 100644 | ||
3304 | --- a/drivers/net/ppp/pptp.c | ||
3305 | +++ b/drivers/net/ppp/pptp.c | ||
3306 | @@ -464,7 +464,6 @@ static int pptp_connect(struct socket *sock, struct sockaddr *uservaddr, | ||
3307 | po->chan.mtu = dst_mtu(&rt->dst); | ||
3308 | if (!po->chan.mtu) | ||
3309 | po->chan.mtu = PPP_MRU; | ||
3310 | - ip_rt_put(rt); | ||
3311 | po->chan.mtu -= PPTP_HEADER_OVERHEAD; | ||
3312 | |||
3313 | po->chan.hdrlen = 2 + sizeof(struct pptp_gre_header); | ||
3314 | diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c | ||
3315 | index 23cd41c82210..2a366554c503 100644 | ||
3316 | --- a/drivers/net/team/team.c | ||
3317 | +++ b/drivers/net/team/team.c | ||
3318 | @@ -1197,11 +1197,6 @@ static int team_port_add(struct team *team, struct net_device *port_dev) | ||
3319 | goto err_dev_open; | ||
3320 | } | ||
3321 | |||
3322 | - netif_addr_lock_bh(dev); | ||
3323 | - dev_uc_sync_multiple(port_dev, dev); | ||
3324 | - dev_mc_sync_multiple(port_dev, dev); | ||
3325 | - netif_addr_unlock_bh(dev); | ||
3326 | - | ||
3327 | err = vlan_vids_add_by_dev(port_dev, dev); | ||
3328 | if (err) { | ||
3329 | netdev_err(dev, "Failed to add vlan ids to device %s\n", | ||
3330 | @@ -1241,6 +1236,11 @@ static int team_port_add(struct team *team, struct net_device *port_dev) | ||
3331 | goto err_option_port_add; | ||
3332 | } | ||
3333 | |||
3334 | + netif_addr_lock_bh(dev); | ||
3335 | + dev_uc_sync_multiple(port_dev, dev); | ||
3336 | + dev_mc_sync_multiple(port_dev, dev); | ||
3337 | + netif_addr_unlock_bh(dev); | ||
3338 | + | ||
3339 | port->index = -1; | ||
3340 | list_add_tail_rcu(&port->list, &team->port_list); | ||
3341 | team_port_enable(team, port); | ||
3342 | @@ -1265,8 +1265,6 @@ static int team_port_add(struct team *team, struct net_device *port_dev) | ||
3343 | vlan_vids_del_by_dev(port_dev, dev); | ||
3344 | |||
3345 | err_vids_add: | ||
3346 | - dev_uc_unsync(port_dev, dev); | ||
3347 | - dev_mc_unsync(port_dev, dev); | ||
3348 | dev_close(port_dev); | ||
3349 | |||
3350 | err_dev_open: | ||
3351 | diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c | ||
3352 | index a8dd1c7a08cb..89d82c4ee8df 100644 | ||
3353 | --- a/drivers/net/usb/lan78xx.c | ||
3354 | +++ b/drivers/net/usb/lan78xx.c | ||
3355 | @@ -2863,8 +2863,7 @@ static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf) | ||
3356 | if (ret < 0) { | ||
3357 | netdev_warn(dev->net, | ||
3358 | "lan78xx_setup_irq_domain() failed : %d", ret); | ||
3359 | - kfree(pdata); | ||
3360 | - return ret; | ||
3361 | + goto out1; | ||
3362 | } | ||
3363 | |||
3364 | dev->net->hard_header_len += TX_OVERHEAD; | ||
3365 | @@ -2872,14 +2871,32 @@ static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf) | ||
3366 | |||
3367 | /* Init all registers */ | ||
3368 | ret = lan78xx_reset(dev); | ||
3369 | + if (ret) { | ||
3370 | + netdev_warn(dev->net, "Registers INIT FAILED...."); | ||
3371 | + goto out2; | ||
3372 | + } | ||
3373 | |||
3374 | ret = lan78xx_mdio_init(dev); | ||
3375 | + if (ret) { | ||
3376 | + netdev_warn(dev->net, "MDIO INIT FAILED....."); | ||
3377 | + goto out2; | ||
3378 | + } | ||
3379 | |||
3380 | dev->net->flags |= IFF_MULTICAST; | ||
3381 | |||
3382 | pdata->wol = WAKE_MAGIC; | ||
3383 | |||
3384 | return ret; | ||
3385 | + | ||
3386 | +out2: | ||
3387 | + lan78xx_remove_irq_domain(dev); | ||
3388 | + | ||
3389 | +out1: | ||
3390 | + netdev_warn(dev->net, "Bind routine FAILED"); | ||
3391 | + cancel_work_sync(&pdata->set_multicast); | ||
3392 | + cancel_work_sync(&pdata->set_vlan); | ||
3393 | + kfree(pdata); | ||
3394 | + return ret; | ||
3395 | } | ||
3396 | |||
3397 | static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf) | ||
3398 | @@ -2891,6 +2908,8 @@ static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf) | ||
3399 | lan78xx_remove_mdio(dev); | ||
3400 | |||
3401 | if (pdata) { | ||
3402 | + cancel_work_sync(&pdata->set_multicast); | ||
3403 | + cancel_work_sync(&pdata->set_vlan); | ||
3404 | netif_dbg(dev, ifdown, dev->net, "free pdata"); | ||
3405 | kfree(pdata); | ||
3406 | pdata = NULL; | ||
3407 | diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c | ||
3408 | index 67ecf2425b88..5c6a8ef54aec 100644 | ||
3409 | --- a/drivers/net/vrf.c | ||
3410 | +++ b/drivers/net/vrf.c | ||
3411 | @@ -579,12 +579,13 @@ static int vrf_finish_output(struct net *net, struct sock *sk, struct sk_buff *s | ||
3412 | if (!IS_ERR(neigh)) { | ||
3413 | sock_confirm_neigh(skb, neigh); | ||
3414 | ret = neigh_output(neigh, skb); | ||
3415 | + rcu_read_unlock_bh(); | ||
3416 | + return ret; | ||
3417 | } | ||
3418 | |||
3419 | rcu_read_unlock_bh(); | ||
3420 | err: | ||
3421 | - if (unlikely(ret < 0)) | ||
3422 | - vrf_tx_error(skb->dev, skb); | ||
3423 | + vrf_tx_error(skb->dev, skb); | ||
3424 | return ret; | ||
3425 | } | ||
3426 | |||
3427 | diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00mac.c b/drivers/net/wireless/ralink/rt2x00/rt2x00mac.c | ||
3428 | index ecc96312a370..6fe0c6abe0d6 100644 | ||
3429 | --- a/drivers/net/wireless/ralink/rt2x00/rt2x00mac.c | ||
3430 | +++ b/drivers/net/wireless/ralink/rt2x00/rt2x00mac.c | ||
3431 | @@ -142,15 +142,25 @@ void rt2x00mac_tx(struct ieee80211_hw *hw, | ||
3432 | if (!rt2x00dev->ops->hw->set_rts_threshold && | ||
3433 | (tx_info->control.rates[0].flags & (IEEE80211_TX_RC_USE_RTS_CTS | | ||
3434 | IEEE80211_TX_RC_USE_CTS_PROTECT))) { | ||
3435 | - if (rt2x00queue_available(queue) <= 1) | ||
3436 | - goto exit_fail; | ||
3437 | + if (rt2x00queue_available(queue) <= 1) { | ||
3438 | + /* | ||
3439 | + * Recheck for full queue under lock to avoid race | ||
3440 | + * conditions with rt2x00lib_txdone(). | ||
3441 | + */ | ||
3442 | + spin_lock(&queue->tx_lock); | ||
3443 | + if (rt2x00queue_threshold(queue)) | ||
3444 | + rt2x00queue_pause_queue(queue); | ||
3445 | + spin_unlock(&queue->tx_lock); | ||
3446 | + | ||
3447 | + goto exit_free_skb; | ||
3448 | + } | ||
3449 | |||
3450 | if (rt2x00mac_tx_rts_cts(rt2x00dev, queue, skb)) | ||
3451 | - goto exit_fail; | ||
3452 | + goto exit_free_skb; | ||
3453 | } | ||
3454 | |||
3455 | if (unlikely(rt2x00queue_write_tx_frame(queue, skb, control->sta, false))) | ||
3456 | - goto exit_fail; | ||
3457 | + goto exit_free_skb; | ||
3458 | |||
3459 | /* | ||
3460 | * Pausing queue has to be serialized with rt2x00lib_txdone(). Note | ||
3461 | @@ -164,10 +174,6 @@ void rt2x00mac_tx(struct ieee80211_hw *hw, | ||
3462 | |||
3463 | return; | ||
3464 | |||
3465 | - exit_fail: | ||
3466 | - spin_lock(&queue->tx_lock); | ||
3467 | - rt2x00queue_pause_queue(queue); | ||
3468 | - spin_unlock(&queue->tx_lock); | ||
3469 | exit_free_skb: | ||
3470 | ieee80211_free_txskb(hw, skb); | ||
3471 | } | ||
3472 | diff --git a/drivers/net/wireless/ti/wl1251/main.c b/drivers/net/wireless/ti/wl1251/main.c | ||
3473 | index 6d02c660b4ab..037defd10b91 100644 | ||
3474 | --- a/drivers/net/wireless/ti/wl1251/main.c | ||
3475 | +++ b/drivers/net/wireless/ti/wl1251/main.c | ||
3476 | @@ -1200,8 +1200,7 @@ static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw, | ||
3477 | WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS); | ||
3478 | |||
3479 | enable = bss_conf->arp_addr_cnt == 1 && bss_conf->assoc; | ||
3480 | - wl1251_acx_arp_ip_filter(wl, enable, addr); | ||
3481 | - | ||
3482 | + ret = wl1251_acx_arp_ip_filter(wl, enable, addr); | ||
3483 | if (ret < 0) | ||
3484 | goto out_sleep; | ||
3485 | } | ||
3486 | diff --git a/drivers/nvme/target/fcloop.c b/drivers/nvme/target/fcloop.c | ||
3487 | index 7b75d9de55ab..c0080f6ab2f5 100644 | ||
3488 | --- a/drivers/nvme/target/fcloop.c | ||
3489 | +++ b/drivers/nvme/target/fcloop.c | ||
3490 | @@ -204,6 +204,10 @@ struct fcloop_lport { | ||
3491 | struct completion unreg_done; | ||
3492 | }; | ||
3493 | |||
3494 | +struct fcloop_lport_priv { | ||
3495 | + struct fcloop_lport *lport; | ||
3496 | +}; | ||
3497 | + | ||
3498 | struct fcloop_rport { | ||
3499 | struct nvme_fc_remote_port *remoteport; | ||
3500 | struct nvmet_fc_target_port *targetport; | ||
3501 | @@ -370,6 +374,7 @@ fcloop_tgt_fcprqst_done_work(struct work_struct *work) | ||
3502 | |||
3503 | spin_lock(&tfcp_req->reqlock); | ||
3504 | fcpreq = tfcp_req->fcpreq; | ||
3505 | + tfcp_req->fcpreq = NULL; | ||
3506 | spin_unlock(&tfcp_req->reqlock); | ||
3507 | |||
3508 | if (tport->remoteport && fcpreq) { | ||
3509 | @@ -611,11 +616,7 @@ fcloop_fcp_abort(struct nvme_fc_local_port *localport, | ||
3510 | |||
3511 | if (!tfcp_req) | ||
3512 | /* abort has already been called */ | ||
3513 | - return; | ||
3514 | - | ||
3515 | - if (rport->targetport) | ||
3516 | - nvmet_fc_rcv_fcp_abort(rport->targetport, | ||
3517 | - &tfcp_req->tgt_fcp_req); | ||
3518 | + goto finish; | ||
3519 | |||
3520 | /* break initiator/target relationship for io */ | ||
3521 | spin_lock(&tfcp_req->reqlock); | ||
3522 | @@ -623,6 +624,11 @@ fcloop_fcp_abort(struct nvme_fc_local_port *localport, | ||
3523 | tfcp_req->fcpreq = NULL; | ||
3524 | spin_unlock(&tfcp_req->reqlock); | ||
3525 | |||
3526 | + if (rport->targetport) | ||
3527 | + nvmet_fc_rcv_fcp_abort(rport->targetport, | ||
3528 | + &tfcp_req->tgt_fcp_req); | ||
3529 | + | ||
3530 | +finish: | ||
3531 | /* post the aborted io completion */ | ||
3532 | fcpreq->status = -ECANCELED; | ||
3533 | schedule_work(&inireq->iniwork); | ||
3534 | @@ -657,7 +663,8 @@ fcloop_nport_get(struct fcloop_nport *nport) | ||
3535 | static void | ||
3536 | fcloop_localport_delete(struct nvme_fc_local_port *localport) | ||
3537 | { | ||
3538 | - struct fcloop_lport *lport = localport->private; | ||
3539 | + struct fcloop_lport_priv *lport_priv = localport->private; | ||
3540 | + struct fcloop_lport *lport = lport_priv->lport; | ||
3541 | |||
3542 | /* release any threads waiting for the unreg to complete */ | ||
3543 | complete(&lport->unreg_done); | ||
3544 | @@ -697,7 +704,7 @@ static struct nvme_fc_port_template fctemplate = { | ||
3545 | .max_dif_sgl_segments = FCLOOP_SGL_SEGS, | ||
3546 | .dma_boundary = FCLOOP_DMABOUND_4G, | ||
3547 | /* sizes of additional private data for data structures */ | ||
3548 | - .local_priv_sz = sizeof(struct fcloop_lport), | ||
3549 | + .local_priv_sz = sizeof(struct fcloop_lport_priv), | ||
3550 | .remote_priv_sz = sizeof(struct fcloop_rport), | ||
3551 | .lsrqst_priv_sz = sizeof(struct fcloop_lsreq), | ||
3552 | .fcprqst_priv_sz = sizeof(struct fcloop_ini_fcpreq), | ||
3553 | @@ -728,11 +735,17 @@ fcloop_create_local_port(struct device *dev, struct device_attribute *attr, | ||
3554 | struct fcloop_ctrl_options *opts; | ||
3555 | struct nvme_fc_local_port *localport; | ||
3556 | struct fcloop_lport *lport; | ||
3557 | - int ret; | ||
3558 | + struct fcloop_lport_priv *lport_priv; | ||
3559 | + unsigned long flags; | ||
3560 | + int ret = -ENOMEM; | ||
3561 | + | ||
3562 | + lport = kzalloc(sizeof(*lport), GFP_KERNEL); | ||
3563 | + if (!lport) | ||
3564 | + return -ENOMEM; | ||
3565 | |||
3566 | opts = kzalloc(sizeof(*opts), GFP_KERNEL); | ||
3567 | if (!opts) | ||
3568 | - return -ENOMEM; | ||
3569 | + goto out_free_lport; | ||
3570 | |||
3571 | ret = fcloop_parse_options(opts, buf); | ||
3572 | if (ret) | ||
3573 | @@ -752,23 +765,25 @@ fcloop_create_local_port(struct device *dev, struct device_attribute *attr, | ||
3574 | |||
3575 | ret = nvme_fc_register_localport(&pinfo, &fctemplate, NULL, &localport); | ||
3576 | if (!ret) { | ||
3577 | - unsigned long flags; | ||
3578 | - | ||
3579 | /* success */ | ||
3580 | - lport = localport->private; | ||
3581 | + lport_priv = localport->private; | ||
3582 | + lport_priv->lport = lport; | ||
3583 | + | ||
3584 | lport->localport = localport; | ||
3585 | INIT_LIST_HEAD(&lport->lport_list); | ||
3586 | |||
3587 | spin_lock_irqsave(&fcloop_lock, flags); | ||
3588 | list_add_tail(&lport->lport_list, &fcloop_lports); | ||
3589 | spin_unlock_irqrestore(&fcloop_lock, flags); | ||
3590 | - | ||
3591 | - /* mark all of the input buffer consumed */ | ||
3592 | - ret = count; | ||
3593 | } | ||
3594 | |||
3595 | out_free_opts: | ||
3596 | kfree(opts); | ||
3597 | +out_free_lport: | ||
3598 | + /* free only if we're going to fail */ | ||
3599 | + if (ret) | ||
3600 | + kfree(lport); | ||
3601 | + | ||
3602 | return ret ? ret : count; | ||
3603 | } | ||
3604 | |||
3605 | @@ -790,6 +805,8 @@ __wait_localport_unreg(struct fcloop_lport *lport) | ||
3606 | |||
3607 | wait_for_completion(&lport->unreg_done); | ||
3608 | |||
3609 | + kfree(lport); | ||
3610 | + | ||
3611 | return ret; | ||
3612 | } | ||
3613 | |||
3614 | diff --git a/drivers/pinctrl/intel/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c | ||
3615 | index 0f3a02495aeb..beeb7cbb5015 100644 | ||
3616 | --- a/drivers/pinctrl/intel/pinctrl-baytrail.c | ||
3617 | +++ b/drivers/pinctrl/intel/pinctrl-baytrail.c | ||
3618 | @@ -46,6 +46,9 @@ | ||
3619 | #define BYT_TRIG_POS BIT(25) | ||
3620 | #define BYT_TRIG_LVL BIT(24) | ||
3621 | #define BYT_DEBOUNCE_EN BIT(20) | ||
3622 | +#define BYT_GLITCH_FILTER_EN BIT(19) | ||
3623 | +#define BYT_GLITCH_F_SLOW_CLK BIT(17) | ||
3624 | +#define BYT_GLITCH_F_FAST_CLK BIT(16) | ||
3625 | #define BYT_PULL_STR_SHIFT 9 | ||
3626 | #define BYT_PULL_STR_MASK (3 << BYT_PULL_STR_SHIFT) | ||
3627 | #define BYT_PULL_STR_2K (0 << BYT_PULL_STR_SHIFT) | ||
3628 | @@ -1579,6 +1582,9 @@ static int byt_irq_type(struct irq_data *d, unsigned int type) | ||
3629 | */ | ||
3630 | value &= ~(BYT_DIRECT_IRQ_EN | BYT_TRIG_POS | BYT_TRIG_NEG | | ||
3631 | BYT_TRIG_LVL); | ||
3632 | + /* Enable glitch filtering */ | ||
3633 | + value |= BYT_GLITCH_FILTER_EN | BYT_GLITCH_F_SLOW_CLK | | ||
3634 | + BYT_GLITCH_F_FAST_CLK; | ||
3635 | |||
3636 | writel(value, reg); | ||
3637 | |||
3638 | diff --git a/drivers/power/supply/axp288_charger.c b/drivers/power/supply/axp288_charger.c | ||
3639 | index d51ebd1da65e..9dc7590e07cb 100644 | ||
3640 | --- a/drivers/power/supply/axp288_charger.c | ||
3641 | +++ b/drivers/power/supply/axp288_charger.c | ||
3642 | @@ -785,6 +785,14 @@ static int charger_init_hw_regs(struct axp288_chrg_info *info) | ||
3643 | return 0; | ||
3644 | } | ||
3645 | |||
3646 | +static void axp288_charger_cancel_work(void *data) | ||
3647 | +{ | ||
3648 | + struct axp288_chrg_info *info = data; | ||
3649 | + | ||
3650 | + cancel_work_sync(&info->otg.work); | ||
3651 | + cancel_work_sync(&info->cable.work); | ||
3652 | +} | ||
3653 | + | ||
3654 | static int axp288_charger_probe(struct platform_device *pdev) | ||
3655 | { | ||
3656 | int ret, i, pirq; | ||
3657 | @@ -836,6 +844,11 @@ static int axp288_charger_probe(struct platform_device *pdev) | ||
3658 | return ret; | ||
3659 | } | ||
3660 | |||
3661 | + /* Cancel our work on cleanup, register this before the notifiers */ | ||
3662 | + ret = devm_add_action(dev, axp288_charger_cancel_work, info); | ||
3663 | + if (ret) | ||
3664 | + return ret; | ||
3665 | + | ||
3666 | /* Register for extcon notification */ | ||
3667 | INIT_WORK(&info->cable.work, axp288_charger_extcon_evt_worker); | ||
3668 | info->cable.nb[0].notifier_call = axp288_charger_handle_cable0_evt; | ||
3669 | diff --git a/drivers/rtc/rtc-ac100.c b/drivers/rtc/rtc-ac100.c | ||
3670 | index 0e358d4b6738..8ff9dc3fe5bf 100644 | ||
3671 | --- a/drivers/rtc/rtc-ac100.c | ||
3672 | +++ b/drivers/rtc/rtc-ac100.c | ||
3673 | @@ -137,13 +137,15 @@ static unsigned long ac100_clkout_recalc_rate(struct clk_hw *hw, | ||
3674 | div = (reg >> AC100_CLKOUT_PRE_DIV_SHIFT) & | ||
3675 | ((1 << AC100_CLKOUT_PRE_DIV_WIDTH) - 1); | ||
3676 | prate = divider_recalc_rate(hw, prate, div, | ||
3677 | - ac100_clkout_prediv, 0); | ||
3678 | + ac100_clkout_prediv, 0, | ||
3679 | + AC100_CLKOUT_PRE_DIV_WIDTH); | ||
3680 | } | ||
3681 | |||
3682 | div = (reg >> AC100_CLKOUT_DIV_SHIFT) & | ||
3683 | (BIT(AC100_CLKOUT_DIV_WIDTH) - 1); | ||
3684 | return divider_recalc_rate(hw, prate, div, NULL, | ||
3685 | - CLK_DIVIDER_POWER_OF_TWO); | ||
3686 | + CLK_DIVIDER_POWER_OF_TWO, | ||
3687 | + AC100_CLKOUT_DIV_WIDTH); | ||
3688 | } | ||
3689 | |||
3690 | static long ac100_clkout_round_rate(struct clk_hw *hw, unsigned long rate, | ||
3691 | diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c | ||
3692 | index f8dc1601efd5..bddbe2da5283 100644 | ||
3693 | --- a/drivers/scsi/libiscsi.c | ||
3694 | +++ b/drivers/scsi/libiscsi.c | ||
3695 | @@ -1696,6 +1696,15 @@ int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) | ||
3696 | */ | ||
3697 | switch (session->state) { | ||
3698 | case ISCSI_STATE_FAILED: | ||
3699 | + /* | ||
3700 | + * cmds should fail during shutdown, if the session | ||
3701 | + * state is bad, allowing completion to happen | ||
3702 | + */ | ||
3703 | + if (unlikely(system_state != SYSTEM_RUNNING)) { | ||
3704 | + reason = FAILURE_SESSION_FAILED; | ||
3705 | + sc->result = DID_NO_CONNECT << 16; | ||
3706 | + break; | ||
3707 | + } | ||
3708 | case ISCSI_STATE_IN_RECOVERY: | ||
3709 | reason = FAILURE_SESSION_IN_RECOVERY; | ||
3710 | sc->result = DID_IMM_RETRY << 16; | ||
3711 | @@ -1980,6 +1989,19 @@ enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) | ||
3712 | } | ||
3713 | |||
3714 | if (session->state != ISCSI_STATE_LOGGED_IN) { | ||
3715 | + /* | ||
3716 | + * During shutdown, if session is prematurely disconnected, | ||
3717 | + * recovery won't happen and there will be hung cmds. Not | ||
3718 | + * handling cmds would trigger EH, also bad in this case. | ||
3719 | + * Instead, handle cmd, allow completion to happen and let | ||
3720 | + * upper layer to deal with the result. | ||
3721 | + */ | ||
3722 | + if (unlikely(system_state != SYSTEM_RUNNING)) { | ||
3723 | + sc->result = DID_NO_CONNECT << 16; | ||
3724 | + ISCSI_DBG_EH(session, "sc on shutdown, handled\n"); | ||
3725 | + rc = BLK_EH_HANDLED; | ||
3726 | + goto done; | ||
3727 | + } | ||
3728 | /* | ||
3729 | * We are probably in the middle of iscsi recovery so let | ||
3730 | * that complete and handle the error. | ||
3731 | @@ -2084,7 +2106,7 @@ enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) | ||
3732 | task->last_timeout = jiffies; | ||
3733 | spin_unlock(&session->frwd_lock); | ||
3734 | ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? | ||
3735 | - "timer reset" : "nh"); | ||
3736 | + "timer reset" : "shutdown or nh"); | ||
3737 | return rc; | ||
3738 | } | ||
3739 | EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out); | ||
3740 | diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c | ||
3741 | index 324d8d8c62de..e2ea389fbec3 100644 | ||
3742 | --- a/drivers/scsi/libsas/sas_expander.c | ||
3743 | +++ b/drivers/scsi/libsas/sas_expander.c | ||
3744 | @@ -293,6 +293,7 @@ static void sas_set_ex_phy(struct domain_device *dev, int phy_id, void *rsp) | ||
3745 | phy->phy->minimum_linkrate = dr->pmin_linkrate; | ||
3746 | phy->phy->maximum_linkrate = dr->pmax_linkrate; | ||
3747 | phy->phy->negotiated_linkrate = phy->linkrate; | ||
3748 | + phy->phy->enabled = (phy->linkrate != SAS_PHY_DISABLED); | ||
3749 | |||
3750 | skip: | ||
3751 | if (new_phy) | ||
3752 | @@ -686,7 +687,7 @@ int sas_smp_get_phy_events(struct sas_phy *phy) | ||
3753 | res = smp_execute_task(dev, req, RPEL_REQ_SIZE, | ||
3754 | resp, RPEL_RESP_SIZE); | ||
3755 | |||
3756 | - if (!res) | ||
3757 | + if (res) | ||
3758 | goto out; | ||
3759 | |||
3760 | phy->invalid_dword_count = scsi_to_u32(&resp[12]); | ||
3761 | @@ -695,6 +696,7 @@ int sas_smp_get_phy_events(struct sas_phy *phy) | ||
3762 | phy->phy_reset_problem_count = scsi_to_u32(&resp[24]); | ||
3763 | |||
3764 | out: | ||
3765 | + kfree(req); | ||
3766 | kfree(resp); | ||
3767 | return res; | ||
3768 | |||
3769 | diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c | ||
3770 | index e518dadc8161..4beb4dd2bee8 100644 | ||
3771 | --- a/drivers/scsi/megaraid/megaraid_sas_base.c | ||
3772 | +++ b/drivers/scsi/megaraid/megaraid_sas_base.c | ||
3773 | @@ -6605,7 +6605,6 @@ static void megasas_detach_one(struct pci_dev *pdev) | ||
3774 | u32 pd_seq_map_sz; | ||
3775 | |||
3776 | instance = pci_get_drvdata(pdev); | ||
3777 | - instance->unload = 1; | ||
3778 | host = instance->host; | ||
3779 | fusion = instance->ctrl_context; | ||
3780 | |||
3781 | @@ -6616,6 +6615,7 @@ static void megasas_detach_one(struct pci_dev *pdev) | ||
3782 | if (instance->fw_crash_state != UNAVAILABLE) | ||
3783 | megasas_free_host_crash_buffer(instance); | ||
3784 | scsi_remove_host(instance->host); | ||
3785 | + instance->unload = 1; | ||
3786 | |||
3787 | if (megasas_wait_for_adapter_operational(instance)) | ||
3788 | goto skip_firing_dcmds; | ||
3789 | diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c | ||
3790 | index ecc699a65bac..08945142b9f8 100644 | ||
3791 | --- a/drivers/scsi/megaraid/megaraid_sas_fp.c | ||
3792 | +++ b/drivers/scsi/megaraid/megaraid_sas_fp.c | ||
3793 | @@ -168,7 +168,7 @@ static struct MR_LD_SPAN *MR_LdSpanPtrGet(u32 ld, u32 span, | ||
3794 | /* | ||
3795 | * This function will Populate Driver Map using firmware raid map | ||
3796 | */ | ||
3797 | -void MR_PopulateDrvRaidMap(struct megasas_instance *instance) | ||
3798 | +static int MR_PopulateDrvRaidMap(struct megasas_instance *instance) | ||
3799 | { | ||
3800 | struct fusion_context *fusion = instance->ctrl_context; | ||
3801 | struct MR_FW_RAID_MAP_ALL *fw_map_old = NULL; | ||
3802 | @@ -259,7 +259,7 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance) | ||
3803 | ld_count = (u16)le16_to_cpu(fw_map_ext->ldCount); | ||
3804 | if (ld_count > MAX_LOGICAL_DRIVES_EXT) { | ||
3805 | dev_dbg(&instance->pdev->dev, "megaraid_sas: LD count exposed in RAID map in not valid\n"); | ||
3806 | - return; | ||
3807 | + return 1; | ||
3808 | } | ||
3809 | |||
3810 | pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count); | ||
3811 | @@ -285,6 +285,12 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance) | ||
3812 | fusion->ld_map[(instance->map_id & 1)]; | ||
3813 | pFwRaidMap = &fw_map_old->raidMap; | ||
3814 | ld_count = (u16)le32_to_cpu(pFwRaidMap->ldCount); | ||
3815 | + if (ld_count > MAX_LOGICAL_DRIVES) { | ||
3816 | + dev_dbg(&instance->pdev->dev, | ||
3817 | + "LD count exposed in RAID map in not valid\n"); | ||
3818 | + return 1; | ||
3819 | + } | ||
3820 | + | ||
3821 | pDrvRaidMap->totalSize = pFwRaidMap->totalSize; | ||
3822 | pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count); | ||
3823 | pDrvRaidMap->fpPdIoTimeoutSec = pFwRaidMap->fpPdIoTimeoutSec; | ||
3824 | @@ -300,6 +306,8 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance) | ||
3825 | sizeof(struct MR_DEV_HANDLE_INFO) * | ||
3826 | MAX_RAIDMAP_PHYSICAL_DEVICES); | ||
3827 | } | ||
3828 | + | ||
3829 | + return 0; | ||
3830 | } | ||
3831 | |||
3832 | /* | ||
3833 | @@ -317,8 +325,8 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance) | ||
3834 | u16 ld; | ||
3835 | u32 expected_size; | ||
3836 | |||
3837 | - | ||
3838 | - MR_PopulateDrvRaidMap(instance); | ||
3839 | + if (MR_PopulateDrvRaidMap(instance)) | ||
3840 | + return 0; | ||
3841 | |||
3842 | fusion = instance->ctrl_context; | ||
3843 | drv_map = fusion->ld_drv_map[(instance->map_id & 1)]; | ||
3844 | diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c | ||
3845 | index beb4bf8fe9b0..139219c994e9 100644 | ||
3846 | --- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c | ||
3847 | +++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c | ||
3848 | @@ -4106,19 +4106,6 @@ scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd) | ||
3849 | return 0; | ||
3850 | } | ||
3851 | |||
3852 | - /* | ||
3853 | - * Bug work around for firmware SATL handling. The loop | ||
3854 | - * is based on atomic operations and ensures consistency | ||
3855 | - * since we're lockless at this point | ||
3856 | - */ | ||
3857 | - do { | ||
3858 | - if (test_bit(0, &sas_device_priv_data->ata_command_pending)) { | ||
3859 | - scmd->result = SAM_STAT_BUSY; | ||
3860 | - scmd->scsi_done(scmd); | ||
3861 | - return 0; | ||
3862 | - } | ||
3863 | - } while (_scsih_set_satl_pending(scmd, true)); | ||
3864 | - | ||
3865 | sas_target_priv_data = sas_device_priv_data->sas_target; | ||
3866 | |||
3867 | /* invalid device handle */ | ||
3868 | @@ -4144,6 +4131,19 @@ scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd) | ||
3869 | sas_device_priv_data->block) | ||
3870 | return SCSI_MLQUEUE_DEVICE_BUSY; | ||
3871 | |||
3872 | + /* | ||
3873 | + * Bug work around for firmware SATL handling. The loop | ||
3874 | + * is based on atomic operations and ensures consistency | ||
3875 | + * since we're lockless at this point | ||
3876 | + */ | ||
3877 | + do { | ||
3878 | + if (test_bit(0, &sas_device_priv_data->ata_command_pending)) { | ||
3879 | + scmd->result = SAM_STAT_BUSY; | ||
3880 | + scmd->scsi_done(scmd); | ||
3881 | + return 0; | ||
3882 | + } | ||
3883 | + } while (_scsih_set_satl_pending(scmd, true)); | ||
3884 | + | ||
3885 | if (scmd->sc_data_direction == DMA_FROM_DEVICE) | ||
3886 | mpi_control = MPI2_SCSIIO_CONTROL_READ; | ||
3887 | else if (scmd->sc_data_direction == DMA_TO_DEVICE) | ||
3888 | @@ -4170,6 +4170,7 @@ scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd) | ||
3889 | if (!smid) { | ||
3890 | pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", | ||
3891 | ioc->name, __func__); | ||
3892 | + _scsih_set_satl_pending(scmd, false); | ||
3893 | goto out; | ||
3894 | } | ||
3895 | mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); | ||
3896 | @@ -4200,6 +4201,7 @@ scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd) | ||
3897 | if (mpi_request->DataLength) { | ||
3898 | if (ioc->build_sg_scmd(ioc, scmd, smid)) { | ||
3899 | mpt3sas_base_free_smid(ioc, smid); | ||
3900 | + _scsih_set_satl_pending(scmd, false); | ||
3901 | goto out; | ||
3902 | } | ||
3903 | } else | ||
3904 | diff --git a/drivers/spi/spi-sh-msiof.c b/drivers/spi/spi-sh-msiof.c | ||
3905 | index 092a5fc85b9a..2770fbd4ce49 100644 | ||
3906 | --- a/drivers/spi/spi-sh-msiof.c | ||
3907 | +++ b/drivers/spi/spi-sh-msiof.c | ||
3908 | @@ -797,11 +797,21 @@ static int sh_msiof_dma_once(struct sh_msiof_spi_priv *p, const void *tx, | ||
3909 | goto stop_dma; | ||
3910 | } | ||
3911 | |||
3912 | - /* wait for tx fifo to be emptied / rx fifo to be filled */ | ||
3913 | + /* wait for tx/rx DMA completion */ | ||
3914 | ret = sh_msiof_wait_for_completion(p); | ||
3915 | if (ret) | ||
3916 | goto stop_reset; | ||
3917 | |||
3918 | + if (!rx) { | ||
3919 | + reinit_completion(&p->done); | ||
3920 | + sh_msiof_write(p, IER, IER_TEOFE); | ||
3921 | + | ||
3922 | + /* wait for tx fifo to be emptied */ | ||
3923 | + ret = sh_msiof_wait_for_completion(p); | ||
3924 | + if (ret) | ||
3925 | + goto stop_reset; | ||
3926 | + } | ||
3927 | + | ||
3928 | /* clear status bits */ | ||
3929 | sh_msiof_reset_str(p); | ||
3930 | |||
3931 | diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-cpu.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-cpu.c | ||
3932 | index 2da051c0d251..a4bb93b440a5 100644 | ||
3933 | --- a/drivers/staging/lustre/lnet/libcfs/linux/linux-cpu.c | ||
3934 | +++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-cpu.c | ||
3935 | @@ -528,19 +528,20 @@ EXPORT_SYMBOL(cfs_cpt_spread_node); | ||
3936 | int | ||
3937 | cfs_cpt_current(struct cfs_cpt_table *cptab, int remap) | ||
3938 | { | ||
3939 | - int cpu = smp_processor_id(); | ||
3940 | - int cpt = cptab->ctb_cpu2cpt[cpu]; | ||
3941 | + int cpu; | ||
3942 | + int cpt; | ||
3943 | |||
3944 | - if (cpt < 0) { | ||
3945 | - if (!remap) | ||
3946 | - return cpt; | ||
3947 | + preempt_disable(); | ||
3948 | + cpu = smp_processor_id(); | ||
3949 | + cpt = cptab->ctb_cpu2cpt[cpu]; | ||
3950 | |||
3951 | + if (cpt < 0 && remap) { | ||
3952 | /* don't return negative value for safety of upper layer, | ||
3953 | * instead we shadow the unknown cpu to a valid partition ID | ||
3954 | */ | ||
3955 | cpt = cpu % cptab->ctb_nparts; | ||
3956 | } | ||
3957 | - | ||
3958 | + preempt_enable(); | ||
3959 | return cpt; | ||
3960 | } | ||
3961 | EXPORT_SYMBOL(cfs_cpt_current); | ||
3962 | diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c | ||
3963 | index 942d094269fb..c4a5fb6f038f 100644 | ||
3964 | --- a/drivers/target/target_core_user.c | ||
3965 | +++ b/drivers/target/target_core_user.c | ||
3966 | @@ -796,6 +796,13 @@ tcmu_queue_cmd_ring(struct tcmu_cmd *tcmu_cmd) | ||
3967 | int ret; | ||
3968 | DEFINE_WAIT(__wait); | ||
3969 | |||
3970 | + /* | ||
3971 | + * Don't leave commands partially setup because the unmap | ||
3972 | + * thread might need the blocks to make forward progress. | ||
3973 | + */ | ||
3974 | + tcmu_cmd_free_data(tcmu_cmd, tcmu_cmd->dbi_cur); | ||
3975 | + tcmu_cmd_reset_dbi_cur(tcmu_cmd); | ||
3976 | + | ||
3977 | prepare_to_wait(&udev->wait_cmdr, &__wait, TASK_INTERRUPTIBLE); | ||
3978 | |||
3979 | pr_debug("sleeping for ring space\n"); | ||
3980 | diff --git a/drivers/thermal/int340x_thermal/int3400_thermal.c b/drivers/thermal/int340x_thermal/int3400_thermal.c | ||
3981 | index 8ee38f55c7f3..43b90fd577e4 100644 | ||
3982 | --- a/drivers/thermal/int340x_thermal/int3400_thermal.c | ||
3983 | +++ b/drivers/thermal/int340x_thermal/int3400_thermal.c | ||
3984 | @@ -319,17 +319,21 @@ static int int3400_thermal_probe(struct platform_device *pdev) | ||
3985 | |||
3986 | result = sysfs_create_group(&pdev->dev.kobj, &uuid_attribute_group); | ||
3987 | if (result) | ||
3988 | - goto free_zone; | ||
3989 | + goto free_rel_misc; | ||
3990 | |||
3991 | result = acpi_install_notify_handler( | ||
3992 | priv->adev->handle, ACPI_DEVICE_NOTIFY, int3400_notify, | ||
3993 | (void *)priv); | ||
3994 | if (result) | ||
3995 | - goto free_zone; | ||
3996 | + goto free_sysfs; | ||
3997 | |||
3998 | return 0; | ||
3999 | |||
4000 | -free_zone: | ||
4001 | +free_sysfs: | ||
4002 | + sysfs_remove_group(&pdev->dev.kobj, &uuid_attribute_group); | ||
4003 | +free_rel_misc: | ||
4004 | + if (!priv->rel_misc_dev_res) | ||
4005 | + acpi_thermal_rel_misc_device_remove(priv->adev->handle); | ||
4006 | thermal_zone_device_unregister(priv->thermal); | ||
4007 | free_art_trt: | ||
4008 | kfree(priv->trts); | ||
4009 | diff --git a/drivers/thermal/power_allocator.c b/drivers/thermal/power_allocator.c | ||
4010 | index b4d3116cfdaf..3055f9a12a17 100644 | ||
4011 | --- a/drivers/thermal/power_allocator.c | ||
4012 | +++ b/drivers/thermal/power_allocator.c | ||
4013 | @@ -523,6 +523,7 @@ static void allow_maximum_power(struct thermal_zone_device *tz) | ||
4014 | struct thermal_instance *instance; | ||
4015 | struct power_allocator_params *params = tz->governor_data; | ||
4016 | |||
4017 | + mutex_lock(&tz->lock); | ||
4018 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | ||
4019 | if ((instance->trip != params->trip_max_desired_temperature) || | ||
4020 | (!cdev_is_power_actor(instance->cdev))) | ||
4021 | @@ -534,6 +535,7 @@ static void allow_maximum_power(struct thermal_zone_device *tz) | ||
4022 | mutex_unlock(&instance->cdev->lock); | ||
4023 | thermal_cdev_update(instance->cdev); | ||
4024 | } | ||
4025 | + mutex_unlock(&tz->lock); | ||
4026 | } | ||
4027 | |||
4028 | /** | ||
4029 | diff --git a/drivers/tty/n_gsm.c b/drivers/tty/n_gsm.c | ||
4030 | index 0a3c9665e015..7253e8d2c6d9 100644 | ||
4031 | --- a/drivers/tty/n_gsm.c | ||
4032 | +++ b/drivers/tty/n_gsm.c | ||
4033 | @@ -1463,6 +1463,10 @@ static void gsm_dlci_open(struct gsm_dlci *dlci) | ||
4034 | * in which case an opening port goes back to closed and a closing port | ||
4035 | * is simply put into closed state (any further frames from the other | ||
4036 | * end will get a DM response) | ||
4037 | + * | ||
4038 | + * Some control dlci can stay in ADM mode with other dlci working just | ||
4039 | + * fine. In that case we can just keep the control dlci open after the | ||
4040 | + * DLCI_OPENING retries time out. | ||
4041 | */ | ||
4042 | |||
4043 | static void gsm_dlci_t1(unsigned long data) | ||
4044 | @@ -1476,8 +1480,15 @@ static void gsm_dlci_t1(unsigned long data) | ||
4045 | if (dlci->retries) { | ||
4046 | gsm_command(dlci->gsm, dlci->addr, SABM|PF); | ||
4047 | mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100); | ||
4048 | - } else | ||
4049 | + } else if (!dlci->addr && gsm->control == (DM | PF)) { | ||
4050 | + if (debug & 8) | ||
4051 | + pr_info("DLCI %d opening in ADM mode.\n", | ||
4052 | + dlci->addr); | ||
4053 | + gsm_dlci_open(dlci); | ||
4054 | + } else { | ||
4055 | gsm_dlci_close(dlci); | ||
4056 | + } | ||
4057 | + | ||
4058 | break; | ||
4059 | case DLCI_CLOSING: | ||
4060 | dlci->retries--; | ||
4061 | @@ -1495,8 +1506,8 @@ static void gsm_dlci_t1(unsigned long data) | ||
4062 | * @dlci: DLCI to open | ||
4063 | * | ||
4064 | * Commence opening a DLCI from the Linux side. We issue SABM messages | ||
4065 | - * to the modem which should then reply with a UA, at which point we | ||
4066 | - * will move into open state. Opening is done asynchronously with retry | ||
4067 | + * to the modem which should then reply with a UA or ADM, at which point | ||
4068 | + * we will move into open state. Opening is done asynchronously with retry | ||
4069 | * running off timers and the responses. | ||
4070 | */ | ||
4071 | |||
4072 | diff --git a/drivers/uio/uio_hv_generic.c b/drivers/uio/uio_hv_generic.c | ||
4073 | index 48d5327d38d4..fe5cdda80b2c 100644 | ||
4074 | --- a/drivers/uio/uio_hv_generic.c | ||
4075 | +++ b/drivers/uio/uio_hv_generic.c | ||
4076 | @@ -124,6 +124,13 @@ hv_uio_probe(struct hv_device *dev, | ||
4077 | if (ret) | ||
4078 | goto fail; | ||
4079 | |||
4080 | + /* Communicating with host has to be via shared memory not hypercall */ | ||
4081 | + if (!dev->channel->offermsg.monitor_allocated) { | ||
4082 | + dev_err(&dev->device, "vmbus channel requires hypercall\n"); | ||
4083 | + ret = -ENOTSUPP; | ||
4084 | + goto fail_close; | ||
4085 | + } | ||
4086 | + | ||
4087 | dev->channel->inbound.ring_buffer->interrupt_mask = 1; | ||
4088 | set_channel_read_mode(dev->channel, HV_CALL_DIRECT); | ||
4089 | |||
4090 | diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c | ||
4091 | index 082891dffd9d..b0d606b2d06c 100644 | ||
4092 | --- a/drivers/vhost/net.c | ||
4093 | +++ b/drivers/vhost/net.c | ||
4094 | @@ -622,7 +622,7 @@ static int vhost_net_rx_peek_head_len(struct vhost_net *net, struct sock *sk) | ||
4095 | |||
4096 | if (!len && vq->busyloop_timeout) { | ||
4097 | /* Both tx vq and rx socket were polled here */ | ||
4098 | - mutex_lock(&vq->mutex); | ||
4099 | + mutex_lock_nested(&vq->mutex, 1); | ||
4100 | vhost_disable_notify(&net->dev, vq); | ||
4101 | |||
4102 | preempt_disable(); | ||
4103 | @@ -755,7 +755,7 @@ static void handle_rx(struct vhost_net *net) | ||
4104 | struct iov_iter fixup; | ||
4105 | __virtio16 num_buffers; | ||
4106 | |||
4107 | - mutex_lock(&vq->mutex); | ||
4108 | + mutex_lock_nested(&vq->mutex, 0); | ||
4109 | sock = vq->private_data; | ||
4110 | if (!sock) | ||
4111 | goto out; | ||
4112 | diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c | ||
4113 | index a827c1a684a9..c692e0b13242 100644 | ||
4114 | --- a/drivers/vhost/vhost.c | ||
4115 | +++ b/drivers/vhost/vhost.c | ||
4116 | @@ -213,8 +213,7 @@ int vhost_poll_start(struct vhost_poll *poll, struct file *file) | ||
4117 | if (mask) | ||
4118 | vhost_poll_wakeup(&poll->wait, 0, 0, (void *)mask); | ||
4119 | if (mask & POLLERR) { | ||
4120 | - if (poll->wqh) | ||
4121 | - remove_wait_queue(poll->wqh, &poll->wait); | ||
4122 | + vhost_poll_stop(poll); | ||
4123 | ret = -EINVAL; | ||
4124 | } | ||
4125 | |||
4126 | @@ -1253,14 +1252,12 @@ static int vq_log_access_ok(struct vhost_virtqueue *vq, | ||
4127 | /* Caller should have vq mutex and device mutex */ | ||
4128 | int vhost_vq_access_ok(struct vhost_virtqueue *vq) | ||
4129 | { | ||
4130 | - if (vq->iotlb) { | ||
4131 | - /* When device IOTLB was used, the access validation | ||
4132 | - * will be validated during prefetching. | ||
4133 | - */ | ||
4134 | - return 1; | ||
4135 | - } | ||
4136 | - return vq_access_ok(vq, vq->num, vq->desc, vq->avail, vq->used) && | ||
4137 | - vq_log_access_ok(vq, vq->log_base); | ||
4138 | + int ret = vq_log_access_ok(vq, vq->log_base); | ||
4139 | + | ||
4140 | + if (ret || vq->iotlb) | ||
4141 | + return ret; | ||
4142 | + | ||
4143 | + return vq_access_ok(vq, vq->num, vq->desc, vq->avail, vq->used); | ||
4144 | } | ||
4145 | EXPORT_SYMBOL_GPL(vhost_vq_access_ok); | ||
4146 | |||
4147 | diff --git a/drivers/video/backlight/corgi_lcd.c b/drivers/video/backlight/corgi_lcd.c | ||
4148 | index d7c239ea3d09..f5574060f9c8 100644 | ||
4149 | --- a/drivers/video/backlight/corgi_lcd.c | ||
4150 | +++ b/drivers/video/backlight/corgi_lcd.c | ||
4151 | @@ -177,7 +177,7 @@ static int corgi_ssp_lcdtg_send(struct corgi_lcd *lcd, int adrs, uint8_t data) | ||
4152 | struct spi_message msg; | ||
4153 | struct spi_transfer xfer = { | ||
4154 | .len = 1, | ||
4155 | - .cs_change = 1, | ||
4156 | + .cs_change = 0, | ||
4157 | .tx_buf = lcd->buf, | ||
4158 | }; | ||
4159 | |||
4160 | diff --git a/drivers/video/backlight/tdo24m.c b/drivers/video/backlight/tdo24m.c | ||
4161 | index eab1f842f9c0..e4bd63e9db6b 100644 | ||
4162 | --- a/drivers/video/backlight/tdo24m.c | ||
4163 | +++ b/drivers/video/backlight/tdo24m.c | ||
4164 | @@ -369,7 +369,7 @@ static int tdo24m_probe(struct spi_device *spi) | ||
4165 | |||
4166 | spi_message_init(m); | ||
4167 | |||
4168 | - x->cs_change = 1; | ||
4169 | + x->cs_change = 0; | ||
4170 | x->tx_buf = &lcd->buf[0]; | ||
4171 | spi_message_add_tail(x, m); | ||
4172 | |||
4173 | diff --git a/drivers/video/backlight/tosa_lcd.c b/drivers/video/backlight/tosa_lcd.c | ||
4174 | index 6a41ea92737a..4dc5ee8debeb 100644 | ||
4175 | --- a/drivers/video/backlight/tosa_lcd.c | ||
4176 | +++ b/drivers/video/backlight/tosa_lcd.c | ||
4177 | @@ -49,7 +49,7 @@ static int tosa_tg_send(struct spi_device *spi, int adrs, uint8_t data) | ||
4178 | struct spi_message msg; | ||
4179 | struct spi_transfer xfer = { | ||
4180 | .len = 1, | ||
4181 | - .cs_change = 1, | ||
4182 | + .cs_change = 0, | ||
4183 | .tx_buf = buf, | ||
4184 | }; | ||
4185 | |||
4186 | diff --git a/drivers/video/fbdev/vfb.c b/drivers/video/fbdev/vfb.c | ||
4187 | index da653a080394..54127905bfe7 100644 | ||
4188 | --- a/drivers/video/fbdev/vfb.c | ||
4189 | +++ b/drivers/video/fbdev/vfb.c | ||
4190 | @@ -239,8 +239,23 @@ static int vfb_check_var(struct fb_var_screeninfo *var, | ||
4191 | */ | ||
4192 | static int vfb_set_par(struct fb_info *info) | ||
4193 | { | ||
4194 | + switch (info->var.bits_per_pixel) { | ||
4195 | + case 1: | ||
4196 | + info->fix.visual = FB_VISUAL_MONO01; | ||
4197 | + break; | ||
4198 | + case 8: | ||
4199 | + info->fix.visual = FB_VISUAL_PSEUDOCOLOR; | ||
4200 | + break; | ||
4201 | + case 16: | ||
4202 | + case 24: | ||
4203 | + case 32: | ||
4204 | + info->fix.visual = FB_VISUAL_TRUECOLOR; | ||
4205 | + break; | ||
4206 | + } | ||
4207 | + | ||
4208 | info->fix.line_length = get_line_length(info->var.xres_virtual, | ||
4209 | info->var.bits_per_pixel); | ||
4210 | + | ||
4211 | return 0; | ||
4212 | } | ||
4213 | |||
4214 | @@ -450,6 +465,8 @@ static int vfb_probe(struct platform_device *dev) | ||
4215 | goto err2; | ||
4216 | platform_set_drvdata(dev, info); | ||
4217 | |||
4218 | + vfb_set_par(info); | ||
4219 | + | ||
4220 | fb_info(info, "Virtual frame buffer device, using %ldK of video memory\n", | ||
4221 | videomemorysize >> 10); | ||
4222 | return 0; | ||
4223 | diff --git a/drivers/watchdog/dw_wdt.c b/drivers/watchdog/dw_wdt.c | ||
4224 | index 36be987ff9ef..c2f4ff516230 100644 | ||
4225 | --- a/drivers/watchdog/dw_wdt.c | ||
4226 | +++ b/drivers/watchdog/dw_wdt.c | ||
4227 | @@ -127,14 +127,27 @@ static int dw_wdt_start(struct watchdog_device *wdd) | ||
4228 | |||
4229 | dw_wdt_set_timeout(wdd, wdd->timeout); | ||
4230 | |||
4231 | - set_bit(WDOG_HW_RUNNING, &wdd->status); | ||
4232 | - | ||
4233 | writel(WDOG_CONTROL_REG_WDT_EN_MASK, | ||
4234 | dw_wdt->regs + WDOG_CONTROL_REG_OFFSET); | ||
4235 | |||
4236 | return 0; | ||
4237 | } | ||
4238 | |||
4239 | +static int dw_wdt_stop(struct watchdog_device *wdd) | ||
4240 | +{ | ||
4241 | + struct dw_wdt *dw_wdt = to_dw_wdt(wdd); | ||
4242 | + | ||
4243 | + if (!dw_wdt->rst) { | ||
4244 | + set_bit(WDOG_HW_RUNNING, &wdd->status); | ||
4245 | + return 0; | ||
4246 | + } | ||
4247 | + | ||
4248 | + reset_control_assert(dw_wdt->rst); | ||
4249 | + reset_control_deassert(dw_wdt->rst); | ||
4250 | + | ||
4251 | + return 0; | ||
4252 | +} | ||
4253 | + | ||
4254 | static int dw_wdt_restart(struct watchdog_device *wdd, | ||
4255 | unsigned long action, void *data) | ||
4256 | { | ||
4257 | @@ -173,6 +186,7 @@ static const struct watchdog_info dw_wdt_ident = { | ||
4258 | static const struct watchdog_ops dw_wdt_ops = { | ||
4259 | .owner = THIS_MODULE, | ||
4260 | .start = dw_wdt_start, | ||
4261 | + .stop = dw_wdt_stop, | ||
4262 | .ping = dw_wdt_ping, | ||
4263 | .set_timeout = dw_wdt_set_timeout, | ||
4264 | .get_timeleft = dw_wdt_get_timeleft, | ||
4265 | diff --git a/fs/dcache.c b/fs/dcache.c | ||
4266 | index a1417787e269..c28b9c91b5cb 100644 | ||
4267 | --- a/fs/dcache.c | ||
4268 | +++ b/fs/dcache.c | ||
4269 | @@ -468,9 +468,11 @@ static void dentry_lru_add(struct dentry *dentry) | ||
4270 | * d_drop() is used mainly for stuff that wants to invalidate a dentry for some | ||
4271 | * reason (NFS timeouts or autofs deletes). | ||
4272 | * | ||
4273 | - * __d_drop requires dentry->d_lock. | ||
4274 | + * __d_drop requires dentry->d_lock | ||
4275 | + * ___d_drop doesn't mark dentry as "unhashed" | ||
4276 | + * (dentry->d_hash.pprev will be LIST_POISON2, not NULL). | ||
4277 | */ | ||
4278 | -void __d_drop(struct dentry *dentry) | ||
4279 | +static void ___d_drop(struct dentry *dentry) | ||
4280 | { | ||
4281 | if (!d_unhashed(dentry)) { | ||
4282 | struct hlist_bl_head *b; | ||
4283 | @@ -486,12 +488,17 @@ void __d_drop(struct dentry *dentry) | ||
4284 | |||
4285 | hlist_bl_lock(b); | ||
4286 | __hlist_bl_del(&dentry->d_hash); | ||
4287 | - dentry->d_hash.pprev = NULL; | ||
4288 | hlist_bl_unlock(b); | ||
4289 | /* After this call, in-progress rcu-walk path lookup will fail. */ | ||
4290 | write_seqcount_invalidate(&dentry->d_seq); | ||
4291 | } | ||
4292 | } | ||
4293 | + | ||
4294 | +void __d_drop(struct dentry *dentry) | ||
4295 | +{ | ||
4296 | + ___d_drop(dentry); | ||
4297 | + dentry->d_hash.pprev = NULL; | ||
4298 | +} | ||
4299 | EXPORT_SYMBOL(__d_drop); | ||
4300 | |||
4301 | void d_drop(struct dentry *dentry) | ||
4302 | @@ -2386,7 +2393,7 @@ EXPORT_SYMBOL(d_delete); | ||
4303 | static void __d_rehash(struct dentry *entry) | ||
4304 | { | ||
4305 | struct hlist_bl_head *b = d_hash(entry->d_name.hash); | ||
4306 | - BUG_ON(!d_unhashed(entry)); | ||
4307 | + | ||
4308 | hlist_bl_lock(b); | ||
4309 | hlist_bl_add_head_rcu(&entry->d_hash, b); | ||
4310 | hlist_bl_unlock(b); | ||
4311 | @@ -2821,9 +2828,9 @@ static void __d_move(struct dentry *dentry, struct dentry *target, | ||
4312 | write_seqcount_begin_nested(&target->d_seq, DENTRY_D_LOCK_NESTED); | ||
4313 | |||
4314 | /* unhash both */ | ||
4315 | - /* __d_drop does write_seqcount_barrier, but they're OK to nest. */ | ||
4316 | - __d_drop(dentry); | ||
4317 | - __d_drop(target); | ||
4318 | + /* ___d_drop does write_seqcount_barrier, but they're OK to nest. */ | ||
4319 | + ___d_drop(dentry); | ||
4320 | + ___d_drop(target); | ||
4321 | |||
4322 | /* Switch the names.. */ | ||
4323 | if (exchange) | ||
4324 | @@ -2835,6 +2842,8 @@ static void __d_move(struct dentry *dentry, struct dentry *target, | ||
4325 | __d_rehash(dentry); | ||
4326 | if (exchange) | ||
4327 | __d_rehash(target); | ||
4328 | + else | ||
4329 | + target->d_hash.pprev = NULL; | ||
4330 | |||
4331 | /* ... and switch them in the tree */ | ||
4332 | if (IS_ROOT(dentry)) { | ||
4333 | diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h | ||
4334 | index 5100ec1b5d55..86eb33f67618 100644 | ||
4335 | --- a/include/linux/clk-provider.h | ||
4336 | +++ b/include/linux/clk-provider.h | ||
4337 | @@ -412,7 +412,7 @@ extern const struct clk_ops clk_divider_ro_ops; | ||
4338 | |||
4339 | unsigned long divider_recalc_rate(struct clk_hw *hw, unsigned long parent_rate, | ||
4340 | unsigned int val, const struct clk_div_table *table, | ||
4341 | - unsigned long flags); | ||
4342 | + unsigned long flags, unsigned long width); | ||
4343 | long divider_round_rate_parent(struct clk_hw *hw, struct clk_hw *parent, | ||
4344 | unsigned long rate, unsigned long *prate, | ||
4345 | const struct clk_div_table *table, | ||
4346 | diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h | ||
4347 | index bfb4a9d962a5..f2f9e957bf1b 100644 | ||
4348 | --- a/include/linux/mlx5/driver.h | ||
4349 | +++ b/include/linux/mlx5/driver.h | ||
4350 | @@ -794,7 +794,7 @@ struct mlx5_core_dev { | ||
4351 | struct mlx5e_resources mlx5e_res; | ||
4352 | struct { | ||
4353 | struct mlx5_rsvd_gids reserved_gids; | ||
4354 | - atomic_t roce_en; | ||
4355 | + u32 roce_en; | ||
4356 | } roce; | ||
4357 | #ifdef CONFIG_MLX5_FPGA | ||
4358 | struct mlx5_fpga_device *fpga; | ||
4359 | diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c | ||
4360 | index f7e83f6d2e64..236452ebbd9e 100644 | ||
4361 | --- a/net/8021q/vlan_dev.c | ||
4362 | +++ b/net/8021q/vlan_dev.c | ||
4363 | @@ -29,6 +29,7 @@ | ||
4364 | #include <linux/net_tstamp.h> | ||
4365 | #include <linux/etherdevice.h> | ||
4366 | #include <linux/ethtool.h> | ||
4367 | +#include <linux/phy.h> | ||
4368 | #include <net/arp.h> | ||
4369 | #include <net/switchdev.h> | ||
4370 | |||
4371 | @@ -665,8 +666,11 @@ static int vlan_ethtool_get_ts_info(struct net_device *dev, | ||
4372 | { | ||
4373 | const struct vlan_dev_priv *vlan = vlan_dev_priv(dev); | ||
4374 | const struct ethtool_ops *ops = vlan->real_dev->ethtool_ops; | ||
4375 | + struct phy_device *phydev = vlan->real_dev->phydev; | ||
4376 | |||
4377 | - if (ops->get_ts_info) { | ||
4378 | + if (phydev && phydev->drv && phydev->drv->ts_info) { | ||
4379 | + return phydev->drv->ts_info(phydev, info); | ||
4380 | + } else if (ops->get_ts_info) { | ||
4381 | return ops->get_ts_info(vlan->real_dev, info); | ||
4382 | } else { | ||
4383 | info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE | | ||
4384 | diff --git a/net/core/dev.c b/net/core/dev.c | ||
4385 | index 387af3415385..4be2a4047640 100644 | ||
4386 | --- a/net/core/dev.c | ||
4387 | +++ b/net/core/dev.c | ||
4388 | @@ -1025,7 +1025,7 @@ bool dev_valid_name(const char *name) | ||
4389 | { | ||
4390 | if (*name == '\0') | ||
4391 | return false; | ||
4392 | - if (strlen(name) >= IFNAMSIZ) | ||
4393 | + if (strnlen(name, IFNAMSIZ) == IFNAMSIZ) | ||
4394 | return false; | ||
4395 | if (!strcmp(name, ".") || !strcmp(name, "..")) | ||
4396 | return false; | ||
4397 | @@ -2696,7 +2696,7 @@ __be16 skb_network_protocol(struct sk_buff *skb, int *depth) | ||
4398 | if (unlikely(!pskb_may_pull(skb, sizeof(struct ethhdr)))) | ||
4399 | return 0; | ||
4400 | |||
4401 | - eth = (struct ethhdr *)skb_mac_header(skb); | ||
4402 | + eth = (struct ethhdr *)skb->data; | ||
4403 | type = eth->h_proto; | ||
4404 | } | ||
4405 | |||
4406 | diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c | ||
4407 | index a1d1f50e0e19..7d9cf26f4bb1 100644 | ||
4408 | --- a/net/ipv4/arp.c | ||
4409 | +++ b/net/ipv4/arp.c | ||
4410 | @@ -437,7 +437,7 @@ static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev) | ||
4411 | /*unsigned long now; */ | ||
4412 | struct net *net = dev_net(dev); | ||
4413 | |||
4414 | - rt = ip_route_output(net, sip, tip, 0, 0); | ||
4415 | + rt = ip_route_output(net, sip, tip, 0, l3mdev_master_ifindex_rcu(dev)); | ||
4416 | if (IS_ERR(rt)) | ||
4417 | return 1; | ||
4418 | if (rt->dst.dev != dev) { | ||
4419 | diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c | ||
4420 | index 1ee6c0d8dde4..f39955913d3f 100644 | ||
4421 | --- a/net/ipv4/fib_semantics.c | ||
4422 | +++ b/net/ipv4/fib_semantics.c | ||
4423 | @@ -1755,18 +1755,20 @@ void fib_select_multipath(struct fib_result *res, int hash) | ||
4424 | bool first = false; | ||
4425 | |||
4426 | for_nexthops(fi) { | ||
4427 | + if (net->ipv4.sysctl_fib_multipath_use_neigh) { | ||
4428 | + if (!fib_good_nh(nh)) | ||
4429 | + continue; | ||
4430 | + if (!first) { | ||
4431 | + res->nh_sel = nhsel; | ||
4432 | + first = true; | ||
4433 | + } | ||
4434 | + } | ||
4435 | + | ||
4436 | if (hash > atomic_read(&nh->nh_upper_bound)) | ||
4437 | continue; | ||
4438 | |||
4439 | - if (!net->ipv4.sysctl_fib_multipath_use_neigh || | ||
4440 | - fib_good_nh(nh)) { | ||
4441 | - res->nh_sel = nhsel; | ||
4442 | - return; | ||
4443 | - } | ||
4444 | - if (!first) { | ||
4445 | - res->nh_sel = nhsel; | ||
4446 | - first = true; | ||
4447 | - } | ||
4448 | + res->nh_sel = nhsel; | ||
4449 | + return; | ||
4450 | } endfor_nexthops(fi); | ||
4451 | } | ||
4452 | #endif | ||
4453 | diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c | ||
4454 | index 4e90082b23a6..13f7bbc0168d 100644 | ||
4455 | --- a/net/ipv4/ip_tunnel.c | ||
4456 | +++ b/net/ipv4/ip_tunnel.c | ||
4457 | @@ -253,13 +253,14 @@ static struct net_device *__ip_tunnel_create(struct net *net, | ||
4458 | struct net_device *dev; | ||
4459 | char name[IFNAMSIZ]; | ||
4460 | |||
4461 | - if (parms->name[0]) | ||
4462 | + err = -E2BIG; | ||
4463 | + if (parms->name[0]) { | ||
4464 | + if (!dev_valid_name(parms->name)) | ||
4465 | + goto failed; | ||
4466 | strlcpy(name, parms->name, IFNAMSIZ); | ||
4467 | - else { | ||
4468 | - if (strlen(ops->kind) > (IFNAMSIZ - 3)) { | ||
4469 | - err = -E2BIG; | ||
4470 | + } else { | ||
4471 | + if (strlen(ops->kind) > (IFNAMSIZ - 3)) | ||
4472 | goto failed; | ||
4473 | - } | ||
4474 | strlcpy(name, ops->kind, IFNAMSIZ); | ||
4475 | strncat(name, "%d", 2); | ||
4476 | } | ||
4477 | diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c | ||
4478 | index e8ab306794d8..4228f3b2f347 100644 | ||
4479 | --- a/net/ipv6/ip6_gre.c | ||
4480 | +++ b/net/ipv6/ip6_gre.c | ||
4481 | @@ -319,11 +319,13 @@ static struct ip6_tnl *ip6gre_tunnel_locate(struct net *net, | ||
4482 | if (t || !create) | ||
4483 | return t; | ||
4484 | |||
4485 | - if (parms->name[0]) | ||
4486 | + if (parms->name[0]) { | ||
4487 | + if (!dev_valid_name(parms->name)) | ||
4488 | + return NULL; | ||
4489 | strlcpy(name, parms->name, IFNAMSIZ); | ||
4490 | - else | ||
4491 | + } else { | ||
4492 | strcpy(name, "ip6gre%d"); | ||
4493 | - | ||
4494 | + } | ||
4495 | dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN, | ||
4496 | ip6gre_tunnel_setup); | ||
4497 | if (!dev) | ||
4498 | diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c | ||
4499 | index 3763dc01e374..ffbb81609016 100644 | ||
4500 | --- a/net/ipv6/ip6_output.c | ||
4501 | +++ b/net/ipv6/ip6_output.c | ||
4502 | @@ -138,6 +138,14 @@ static int ip6_finish_output(struct net *net, struct sock *sk, struct sk_buff *s | ||
4503 | return ret; | ||
4504 | } | ||
4505 | |||
4506 | +#if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM) | ||
4507 | + /* Policy lookup after SNAT yielded a new policy */ | ||
4508 | + if (skb_dst(skb)->xfrm) { | ||
4509 | + IPCB(skb)->flags |= IPSKB_REROUTED; | ||
4510 | + return dst_output(net, sk, skb); | ||
4511 | + } | ||
4512 | +#endif | ||
4513 | + | ||
4514 | if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) || | ||
4515 | dst_allfrag(skb_dst(skb)) || | ||
4516 | (IP6CB(skb)->frag_max_size && skb->len > IP6CB(skb)->frag_max_size)) | ||
4517 | @@ -367,6 +375,11 @@ static int ip6_forward_proxy_check(struct sk_buff *skb) | ||
4518 | static inline int ip6_forward_finish(struct net *net, struct sock *sk, | ||
4519 | struct sk_buff *skb) | ||
4520 | { | ||
4521 | + struct dst_entry *dst = skb_dst(skb); | ||
4522 | + | ||
4523 | + __IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS); | ||
4524 | + __IP6_ADD_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len); | ||
4525 | + | ||
4526 | return dst_output(net, sk, skb); | ||
4527 | } | ||
4528 | |||
4529 | @@ -560,8 +573,6 @@ int ip6_forward(struct sk_buff *skb) | ||
4530 | |||
4531 | hdr->hop_limit--; | ||
4532 | |||
4533 | - __IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS); | ||
4534 | - __IP6_ADD_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len); | ||
4535 | return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, | ||
4536 | net, NULL, skb, skb->dev, dst->dev, | ||
4537 | ip6_forward_finish); | ||
4538 | @@ -1237,7 +1248,7 @@ static int __ip6_append_data(struct sock *sk, | ||
4539 | const struct sockcm_cookie *sockc) | ||
4540 | { | ||
4541 | struct sk_buff *skb, *skb_prev = NULL; | ||
4542 | - unsigned int maxfraglen, fragheaderlen, mtu, orig_mtu; | ||
4543 | + unsigned int maxfraglen, fragheaderlen, mtu, orig_mtu, pmtu; | ||
4544 | int exthdrlen = 0; | ||
4545 | int dst_exthdrlen = 0; | ||
4546 | int hh_len; | ||
4547 | @@ -1273,6 +1284,12 @@ static int __ip6_append_data(struct sock *sk, | ||
4548 | sizeof(struct frag_hdr) : 0) + | ||
4549 | rt->rt6i_nfheader_len; | ||
4550 | |||
4551 | + /* as per RFC 7112 section 5, the entire IPv6 Header Chain must fit | ||
4552 | + * the first fragment | ||
4553 | + */ | ||
4554 | + if (headersize + transhdrlen > mtu) | ||
4555 | + goto emsgsize; | ||
4556 | + | ||
4557 | if (cork->length + length > mtu - headersize && ipc6->dontfrag && | ||
4558 | (sk->sk_protocol == IPPROTO_UDP || | ||
4559 | sk->sk_protocol == IPPROTO_RAW)) { | ||
4560 | @@ -1288,9 +1305,8 @@ static int __ip6_append_data(struct sock *sk, | ||
4561 | |||
4562 | if (cork->length + length > maxnonfragsize - headersize) { | ||
4563 | emsgsize: | ||
4564 | - ipv6_local_error(sk, EMSGSIZE, fl6, | ||
4565 | - mtu - headersize + | ||
4566 | - sizeof(struct ipv6hdr)); | ||
4567 | + pmtu = max_t(int, mtu - headersize + sizeof(struct ipv6hdr), 0); | ||
4568 | + ipv6_local_error(sk, EMSGSIZE, fl6, pmtu); | ||
4569 | return -EMSGSIZE; | ||
4570 | } | ||
4571 | |||
4572 | diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c | ||
4573 | index 1161fd5630c1..7e11f6a811f5 100644 | ||
4574 | --- a/net/ipv6/ip6_tunnel.c | ||
4575 | +++ b/net/ipv6/ip6_tunnel.c | ||
4576 | @@ -297,13 +297,16 @@ static struct ip6_tnl *ip6_tnl_create(struct net *net, struct __ip6_tnl_parm *p) | ||
4577 | struct net_device *dev; | ||
4578 | struct ip6_tnl *t; | ||
4579 | char name[IFNAMSIZ]; | ||
4580 | - int err = -ENOMEM; | ||
4581 | + int err = -E2BIG; | ||
4582 | |||
4583 | - if (p->name[0]) | ||
4584 | + if (p->name[0]) { | ||
4585 | + if (!dev_valid_name(p->name)) | ||
4586 | + goto failed; | ||
4587 | strlcpy(name, p->name, IFNAMSIZ); | ||
4588 | - else | ||
4589 | + } else { | ||
4590 | sprintf(name, "ip6tnl%%d"); | ||
4591 | - | ||
4592 | + } | ||
4593 | + err = -ENOMEM; | ||
4594 | dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN, | ||
4595 | ip6_tnl_dev_setup); | ||
4596 | if (!dev) | ||
4597 | diff --git a/net/ipv6/ip6_vti.c b/net/ipv6/ip6_vti.c | ||
4598 | index bcdc2d557de1..7c0f647b5195 100644 | ||
4599 | --- a/net/ipv6/ip6_vti.c | ||
4600 | +++ b/net/ipv6/ip6_vti.c | ||
4601 | @@ -212,10 +212,13 @@ static struct ip6_tnl *vti6_tnl_create(struct net *net, struct __ip6_tnl_parm *p | ||
4602 | char name[IFNAMSIZ]; | ||
4603 | int err; | ||
4604 | |||
4605 | - if (p->name[0]) | ||
4606 | + if (p->name[0]) { | ||
4607 | + if (!dev_valid_name(p->name)) | ||
4608 | + goto failed; | ||
4609 | strlcpy(name, p->name, IFNAMSIZ); | ||
4610 | - else | ||
4611 | + } else { | ||
4612 | sprintf(name, "ip6_vti%%d"); | ||
4613 | + } | ||
4614 | |||
4615 | dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN, vti6_dev_setup); | ||
4616 | if (!dev) | ||
4617 | diff --git a/net/ipv6/route.c b/net/ipv6/route.c | ||
4618 | index a4a865c8a23c..0126d9bfa670 100644 | ||
4619 | --- a/net/ipv6/route.c | ||
4620 | +++ b/net/ipv6/route.c | ||
4621 | @@ -871,6 +871,9 @@ static struct rt6_info *ip6_pol_route_lookup(struct net *net, | ||
4622 | struct fib6_node *fn; | ||
4623 | struct rt6_info *rt; | ||
4624 | |||
4625 | + if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF) | ||
4626 | + flags &= ~RT6_LOOKUP_F_IFACE; | ||
4627 | + | ||
4628 | read_lock_bh(&table->tb6_lock); | ||
4629 | fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); | ||
4630 | restart: | ||
4631 | diff --git a/net/ipv6/seg6_iptunnel.c b/net/ipv6/seg6_iptunnel.c | ||
4632 | index 7a78dcfda68a..f343e6f0fc95 100644 | ||
4633 | --- a/net/ipv6/seg6_iptunnel.c | ||
4634 | +++ b/net/ipv6/seg6_iptunnel.c | ||
4635 | @@ -16,6 +16,7 @@ | ||
4636 | #include <linux/net.h> | ||
4637 | #include <linux/module.h> | ||
4638 | #include <net/ip.h> | ||
4639 | +#include <net/ip_tunnels.h> | ||
4640 | #include <net/lwtunnel.h> | ||
4641 | #include <net/netevent.h> | ||
4642 | #include <net/netns/generic.h> | ||
4643 | @@ -211,11 +212,6 @@ static int seg6_do_srh(struct sk_buff *skb) | ||
4644 | |||
4645 | tinfo = seg6_encap_lwtunnel(dst->lwtstate); | ||
4646 | |||
4647 | - if (likely(!skb->encapsulation)) { | ||
4648 | - skb_reset_inner_headers(skb); | ||
4649 | - skb->encapsulation = 1; | ||
4650 | - } | ||
4651 | - | ||
4652 | switch (tinfo->mode) { | ||
4653 | case SEG6_IPTUN_MODE_INLINE: | ||
4654 | if (skb->protocol != htons(ETH_P_IPV6)) | ||
4655 | @@ -224,10 +220,12 @@ static int seg6_do_srh(struct sk_buff *skb) | ||
4656 | err = seg6_do_srh_inline(skb, tinfo->srh); | ||
4657 | if (err) | ||
4658 | return err; | ||
4659 | - | ||
4660 | - skb_reset_inner_headers(skb); | ||
4661 | break; | ||
4662 | case SEG6_IPTUN_MODE_ENCAP: | ||
4663 | + err = iptunnel_handle_offloads(skb, SKB_GSO_IPXIP6); | ||
4664 | + if (err) | ||
4665 | + return err; | ||
4666 | + | ||
4667 | if (skb->protocol == htons(ETH_P_IPV6)) | ||
4668 | proto = IPPROTO_IPV6; | ||
4669 | else if (skb->protocol == htons(ETH_P_IP)) | ||
4670 | @@ -239,6 +237,8 @@ static int seg6_do_srh(struct sk_buff *skb) | ||
4671 | if (err) | ||
4672 | return err; | ||
4673 | |||
4674 | + skb_set_inner_transport_header(skb, skb_transport_offset(skb)); | ||
4675 | + skb_set_inner_protocol(skb, skb->protocol); | ||
4676 | skb->protocol = htons(ETH_P_IPV6); | ||
4677 | break; | ||
4678 | case SEG6_IPTUN_MODE_L2ENCAP: | ||
4679 | @@ -262,8 +262,6 @@ static int seg6_do_srh(struct sk_buff *skb) | ||
4680 | ipv6_hdr(skb)->payload_len = htons(skb->len - sizeof(struct ipv6hdr)); | ||
4681 | skb_set_transport_header(skb, sizeof(struct ipv6hdr)); | ||
4682 | |||
4683 | - skb_set_inner_protocol(skb, skb->protocol); | ||
4684 | - | ||
4685 | return 0; | ||
4686 | } | ||
4687 | |||
4688 | diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c | ||
4689 | index cac815cc8600..f03c1a562135 100644 | ||
4690 | --- a/net/ipv6/sit.c | ||
4691 | +++ b/net/ipv6/sit.c | ||
4692 | @@ -244,11 +244,13 @@ static struct ip_tunnel *ipip6_tunnel_locate(struct net *net, | ||
4693 | if (!create) | ||
4694 | goto failed; | ||
4695 | |||
4696 | - if (parms->name[0]) | ||
4697 | + if (parms->name[0]) { | ||
4698 | + if (!dev_valid_name(parms->name)) | ||
4699 | + goto failed; | ||
4700 | strlcpy(name, parms->name, IFNAMSIZ); | ||
4701 | - else | ||
4702 | + } else { | ||
4703 | strcpy(name, "sit%d"); | ||
4704 | - | ||
4705 | + } | ||
4706 | dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN, | ||
4707 | ipip6_tunnel_setup); | ||
4708 | if (!dev) | ||
4709 | diff --git a/net/l2tp/l2tp_netlink.c b/net/l2tp/l2tp_netlink.c | ||
4710 | index c28223d8092b..fca69c3771f5 100644 | ||
4711 | --- a/net/l2tp/l2tp_netlink.c | ||
4712 | +++ b/net/l2tp/l2tp_netlink.c | ||
4713 | @@ -765,6 +765,8 @@ static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, int fl | ||
4714 | |||
4715 | if ((session->ifname[0] && | ||
4716 | nla_put_string(skb, L2TP_ATTR_IFNAME, session->ifname)) || | ||
4717 | + (session->offset && | ||
4718 | + nla_put_u16(skb, L2TP_ATTR_OFFSET, session->offset)) || | ||
4719 | (session->cookie_len && | ||
4720 | nla_put(skb, L2TP_ATTR_COOKIE, session->cookie_len, | ||
4721 | &session->cookie[0])) || | ||
4722 | diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c | ||
4723 | index 84f757c5d91a..288640471c2f 100644 | ||
4724 | --- a/net/mac80211/cfg.c | ||
4725 | +++ b/net/mac80211/cfg.c | ||
4726 | @@ -2373,10 +2373,17 @@ static int ieee80211_set_tx_power(struct wiphy *wiphy, | ||
4727 | struct ieee80211_sub_if_data *sdata; | ||
4728 | enum nl80211_tx_power_setting txp_type = type; | ||
4729 | bool update_txp_type = false; | ||
4730 | + bool has_monitor = false; | ||
4731 | |||
4732 | if (wdev) { | ||
4733 | sdata = IEEE80211_WDEV_TO_SUB_IF(wdev); | ||
4734 | |||
4735 | + if (sdata->vif.type == NL80211_IFTYPE_MONITOR) { | ||
4736 | + sdata = rtnl_dereference(local->monitor_sdata); | ||
4737 | + if (!sdata) | ||
4738 | + return -EOPNOTSUPP; | ||
4739 | + } | ||
4740 | + | ||
4741 | switch (type) { | ||
4742 | case NL80211_TX_POWER_AUTOMATIC: | ||
4743 | sdata->user_power_level = IEEE80211_UNSET_POWER_LEVEL; | ||
4744 | @@ -2415,15 +2422,34 @@ static int ieee80211_set_tx_power(struct wiphy *wiphy, | ||
4745 | |||
4746 | mutex_lock(&local->iflist_mtx); | ||
4747 | list_for_each_entry(sdata, &local->interfaces, list) { | ||
4748 | + if (sdata->vif.type == NL80211_IFTYPE_MONITOR) { | ||
4749 | + has_monitor = true; | ||
4750 | + continue; | ||
4751 | + } | ||
4752 | sdata->user_power_level = local->user_power_level; | ||
4753 | if (txp_type != sdata->vif.bss_conf.txpower_type) | ||
4754 | update_txp_type = true; | ||
4755 | sdata->vif.bss_conf.txpower_type = txp_type; | ||
4756 | } | ||
4757 | - list_for_each_entry(sdata, &local->interfaces, list) | ||
4758 | + list_for_each_entry(sdata, &local->interfaces, list) { | ||
4759 | + if (sdata->vif.type == NL80211_IFTYPE_MONITOR) | ||
4760 | + continue; | ||
4761 | ieee80211_recalc_txpower(sdata, update_txp_type); | ||
4762 | + } | ||
4763 | mutex_unlock(&local->iflist_mtx); | ||
4764 | |||
4765 | + if (has_monitor) { | ||
4766 | + sdata = rtnl_dereference(local->monitor_sdata); | ||
4767 | + if (sdata) { | ||
4768 | + sdata->user_power_level = local->user_power_level; | ||
4769 | + if (txp_type != sdata->vif.bss_conf.txpower_type) | ||
4770 | + update_txp_type = true; | ||
4771 | + sdata->vif.bss_conf.txpower_type = txp_type; | ||
4772 | + | ||
4773 | + ieee80211_recalc_txpower(sdata, update_txp_type); | ||
4774 | + } | ||
4775 | + } | ||
4776 | + | ||
4777 | return 0; | ||
4778 | } | ||
4779 | |||
4780 | diff --git a/net/mac80211/driver-ops.h b/net/mac80211/driver-ops.h | ||
4781 | index c7f93fd9ca7a..4d82fe7d627c 100644 | ||
4782 | --- a/net/mac80211/driver-ops.h | ||
4783 | +++ b/net/mac80211/driver-ops.h | ||
4784 | @@ -165,7 +165,8 @@ static inline void drv_bss_info_changed(struct ieee80211_local *local, | ||
4785 | if (WARN_ON_ONCE(sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE || | ||
4786 | sdata->vif.type == NL80211_IFTYPE_NAN || | ||
4787 | (sdata->vif.type == NL80211_IFTYPE_MONITOR && | ||
4788 | - !sdata->vif.mu_mimo_owner))) | ||
4789 | + !sdata->vif.mu_mimo_owner && | ||
4790 | + !(changed & BSS_CHANGED_TXPOWER)))) | ||
4791 | return; | ||
4792 | |||
4793 | if (!check_sdata_in_driver(sdata)) | ||
4794 | diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c | ||
4795 | index 9219bc134109..1b86eccf94b6 100644 | ||
4796 | --- a/net/netlink/af_netlink.c | ||
4797 | +++ b/net/netlink/af_netlink.c | ||
4798 | @@ -1053,6 +1053,9 @@ static int netlink_connect(struct socket *sock, struct sockaddr *addr, | ||
4799 | if (addr->sa_family != AF_NETLINK) | ||
4800 | return -EINVAL; | ||
4801 | |||
4802 | + if (alen < sizeof(struct sockaddr_nl)) | ||
4803 | + return -EINVAL; | ||
4804 | + | ||
4805 | if ((nladdr->nl_groups || nladdr->nl_pid) && | ||
4806 | !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND)) | ||
4807 | return -EPERM; | ||
4808 | diff --git a/net/rds/bind.c b/net/rds/bind.c | ||
4809 | index 75d43dc8e96b..5aa3a64aa4f0 100644 | ||
4810 | --- a/net/rds/bind.c | ||
4811 | +++ b/net/rds/bind.c | ||
4812 | @@ -114,6 +114,7 @@ static int rds_add_bound(struct rds_sock *rs, __be32 addr, __be16 *port) | ||
4813 | rs, &addr, (int)ntohs(*port)); | ||
4814 | break; | ||
4815 | } else { | ||
4816 | + rs->rs_bound_addr = 0; | ||
4817 | rds_sock_put(rs); | ||
4818 | ret = -ENOMEM; | ||
4819 | break; | ||
4820 | diff --git a/net/sched/act_api.c b/net/sched/act_api.c | ||
4821 | index 8f2c63514956..4444d7e755e6 100644 | ||
4822 | --- a/net/sched/act_api.c | ||
4823 | +++ b/net/sched/act_api.c | ||
4824 | @@ -133,8 +133,10 @@ static int tcf_dump_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb, | ||
4825 | continue; | ||
4826 | |||
4827 | nest = nla_nest_start(skb, n_i); | ||
4828 | - if (!nest) | ||
4829 | + if (!nest) { | ||
4830 | + index--; | ||
4831 | goto nla_put_failure; | ||
4832 | + } | ||
4833 | err = tcf_action_dump_1(skb, p, 0, 0); | ||
4834 | if (err < 0) { | ||
4835 | index--; | ||
4836 | diff --git a/net/sched/act_bpf.c b/net/sched/act_bpf.c | ||
4837 | index c0c707eb2c96..2b087623fb1d 100644 | ||
4838 | --- a/net/sched/act_bpf.c | ||
4839 | +++ b/net/sched/act_bpf.c | ||
4840 | @@ -248,10 +248,14 @@ static int tcf_bpf_init_from_efd(struct nlattr **tb, struct tcf_bpf_cfg *cfg) | ||
4841 | |||
4842 | static void tcf_bpf_cfg_cleanup(const struct tcf_bpf_cfg *cfg) | ||
4843 | { | ||
4844 | - if (cfg->is_ebpf) | ||
4845 | - bpf_prog_put(cfg->filter); | ||
4846 | - else | ||
4847 | - bpf_prog_destroy(cfg->filter); | ||
4848 | + struct bpf_prog *filter = cfg->filter; | ||
4849 | + | ||
4850 | + if (filter) { | ||
4851 | + if (cfg->is_ebpf) | ||
4852 | + bpf_prog_put(filter); | ||
4853 | + else | ||
4854 | + bpf_prog_destroy(filter); | ||
4855 | + } | ||
4856 | |||
4857 | kfree(cfg->bpf_ops); | ||
4858 | kfree(cfg->bpf_name); | ||
4859 | diff --git a/net/sched/act_skbmod.c b/net/sched/act_skbmod.c | ||
4860 | index b642ad3d39dd..6d10b3af479b 100644 | ||
4861 | --- a/net/sched/act_skbmod.c | ||
4862 | +++ b/net/sched/act_skbmod.c | ||
4863 | @@ -190,7 +190,8 @@ static void tcf_skbmod_cleanup(struct tc_action *a, int bind) | ||
4864 | struct tcf_skbmod_params *p; | ||
4865 | |||
4866 | p = rcu_dereference_protected(d->skbmod_p, 1); | ||
4867 | - kfree_rcu(p, rcu); | ||
4868 | + if (p) | ||
4869 | + kfree_rcu(p, rcu); | ||
4870 | } | ||
4871 | |||
4872 | static int tcf_skbmod_dump(struct sk_buff *skb, struct tc_action *a, | ||
4873 | diff --git a/net/sched/act_tunnel_key.c b/net/sched/act_tunnel_key.c | ||
4874 | index 22bf1a376b91..7cb63616805d 100644 | ||
4875 | --- a/net/sched/act_tunnel_key.c | ||
4876 | +++ b/net/sched/act_tunnel_key.c | ||
4877 | @@ -208,11 +208,12 @@ static void tunnel_key_release(struct tc_action *a, int bind) | ||
4878 | struct tcf_tunnel_key_params *params; | ||
4879 | |||
4880 | params = rcu_dereference_protected(t->params, 1); | ||
4881 | + if (params) { | ||
4882 | + if (params->tcft_action == TCA_TUNNEL_KEY_ACT_SET) | ||
4883 | + dst_release(¶ms->tcft_enc_metadata->dst); | ||
4884 | |||
4885 | - if (params->tcft_action == TCA_TUNNEL_KEY_ACT_SET) | ||
4886 | - dst_release(¶ms->tcft_enc_metadata->dst); | ||
4887 | - | ||
4888 | - kfree_rcu(params, rcu); | ||
4889 | + kfree_rcu(params, rcu); | ||
4890 | + } | ||
4891 | } | ||
4892 | |||
4893 | static int tunnel_key_dump_addresses(struct sk_buff *skb, | ||
4894 | diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c | ||
4895 | index f27a9718554c..08b5705e7381 100644 | ||
4896 | --- a/net/sctp/ipv6.c | ||
4897 | +++ b/net/sctp/ipv6.c | ||
4898 | @@ -728,8 +728,10 @@ static int sctp_v6_addr_to_user(struct sctp_sock *sp, union sctp_addr *addr) | ||
4899 | sctp_v6_map_v4(addr); | ||
4900 | } | ||
4901 | |||
4902 | - if (addr->sa.sa_family == AF_INET) | ||
4903 | + if (addr->sa.sa_family == AF_INET) { | ||
4904 | + memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero)); | ||
4905 | return sizeof(struct sockaddr_in); | ||
4906 | + } | ||
4907 | return sizeof(struct sockaddr_in6); | ||
4908 | } | ||
4909 | |||
4910 | diff --git a/net/sctp/socket.c b/net/sctp/socket.c | ||
4911 | index 6b3a862706de..2d6f612f32c3 100644 | ||
4912 | --- a/net/sctp/socket.c | ||
4913 | +++ b/net/sctp/socket.c | ||
4914 | @@ -337,11 +337,14 @@ static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt, | ||
4915 | if (!opt->pf->af_supported(addr->sa.sa_family, opt)) | ||
4916 | return NULL; | ||
4917 | |||
4918 | - /* V4 mapped address are really of AF_INET family */ | ||
4919 | - if (addr->sa.sa_family == AF_INET6 && | ||
4920 | - ipv6_addr_v4mapped(&addr->v6.sin6_addr) && | ||
4921 | - !opt->pf->af_supported(AF_INET, opt)) | ||
4922 | - return NULL; | ||
4923 | + if (addr->sa.sa_family == AF_INET6) { | ||
4924 | + if (len < SIN6_LEN_RFC2133) | ||
4925 | + return NULL; | ||
4926 | + /* V4 mapped address are really of AF_INET family */ | ||
4927 | + if (ipv6_addr_v4mapped(&addr->v6.sin6_addr) && | ||
4928 | + !opt->pf->af_supported(AF_INET, opt)) | ||
4929 | + return NULL; | ||
4930 | + } | ||
4931 | |||
4932 | /* If we get this far, af is valid. */ | ||
4933 | af = sctp_get_af_specific(addr->sa.sa_family); | ||
4934 | diff --git a/net/strparser/strparser.c b/net/strparser/strparser.c | ||
4935 | index c5fda15ba319..4a3a3f1331ee 100644 | ||
4936 | --- a/net/strparser/strparser.c | ||
4937 | +++ b/net/strparser/strparser.c | ||
4938 | @@ -60,7 +60,7 @@ static void strp_abort_strp(struct strparser *strp, int err) | ||
4939 | struct sock *sk = strp->sk; | ||
4940 | |||
4941 | /* Report an error on the lower socket */ | ||
4942 | - sk->sk_err = err; | ||
4943 | + sk->sk_err = -err; | ||
4944 | sk->sk_error_report(sk); | ||
4945 | } | ||
4946 | } | ||
4947 | @@ -458,7 +458,7 @@ static void strp_msg_timeout(struct work_struct *w) | ||
4948 | /* Message assembly timed out */ | ||
4949 | STRP_STATS_INCR(strp->stats.msg_timeouts); | ||
4950 | strp->cb.lock(strp); | ||
4951 | - strp->cb.abort_parser(strp, ETIMEDOUT); | ||
4952 | + strp->cb.abort_parser(strp, -ETIMEDOUT); | ||
4953 | strp->cb.unlock(strp); | ||
4954 | } | ||
4955 | |||
4956 | diff --git a/sound/soc/intel/atom/sst/sst_stream.c b/sound/soc/intel/atom/sst/sst_stream.c | ||
4957 | index 83d8dda15233..4eeb9afdc89f 100644 | ||
4958 | --- a/sound/soc/intel/atom/sst/sst_stream.c | ||
4959 | +++ b/sound/soc/intel/atom/sst/sst_stream.c | ||
4960 | @@ -221,7 +221,7 @@ int sst_send_byte_stream_mrfld(struct intel_sst_drv *sst_drv_ctx, | ||
4961 | sst_free_block(sst_drv_ctx, block); | ||
4962 | out: | ||
4963 | test_and_clear_bit(pvt_id, &sst_drv_ctx->pvt_id); | ||
4964 | - return 0; | ||
4965 | + return ret; | ||
4966 | } | ||
4967 | |||
4968 | /* | ||
4969 | diff --git a/sound/soc/intel/boards/cht_bsw_rt5645.c b/sound/soc/intel/boards/cht_bsw_rt5645.c | ||
4970 | index 5bcde01d15e6..fbfb76ee2346 100644 | ||
4971 | --- a/sound/soc/intel/boards/cht_bsw_rt5645.c | ||
4972 | +++ b/sound/soc/intel/boards/cht_bsw_rt5645.c | ||
4973 | @@ -133,6 +133,7 @@ static const struct snd_soc_dapm_widget cht_dapm_widgets[] = { | ||
4974 | SND_SOC_DAPM_HP("Headphone", NULL), | ||
4975 | SND_SOC_DAPM_MIC("Headset Mic", NULL), | ||
4976 | SND_SOC_DAPM_MIC("Int Mic", NULL), | ||
4977 | + SND_SOC_DAPM_MIC("Int Analog Mic", NULL), | ||
4978 | SND_SOC_DAPM_SPK("Ext Spk", NULL), | ||
4979 | SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0, | ||
4980 | platform_clock_control, SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD), | ||
4981 | @@ -143,6 +144,8 @@ static const struct snd_soc_dapm_route cht_rt5645_audio_map[] = { | ||
4982 | {"IN1N", NULL, "Headset Mic"}, | ||
4983 | {"DMIC L1", NULL, "Int Mic"}, | ||
4984 | {"DMIC R1", NULL, "Int Mic"}, | ||
4985 | + {"IN2P", NULL, "Int Analog Mic"}, | ||
4986 | + {"IN2N", NULL, "Int Analog Mic"}, | ||
4987 | {"Headphone", NULL, "HPOL"}, | ||
4988 | {"Headphone", NULL, "HPOR"}, | ||
4989 | {"Ext Spk", NULL, "SPOL"}, | ||
4990 | @@ -150,6 +153,9 @@ static const struct snd_soc_dapm_route cht_rt5645_audio_map[] = { | ||
4991 | {"Headphone", NULL, "Platform Clock"}, | ||
4992 | {"Headset Mic", NULL, "Platform Clock"}, | ||
4993 | {"Int Mic", NULL, "Platform Clock"}, | ||
4994 | + {"Int Analog Mic", NULL, "Platform Clock"}, | ||
4995 | + {"Int Analog Mic", NULL, "micbias1"}, | ||
4996 | + {"Int Analog Mic", NULL, "micbias2"}, | ||
4997 | {"Ext Spk", NULL, "Platform Clock"}, | ||
4998 | }; | ||
4999 | |||
5000 | @@ -204,6 +210,7 @@ static const struct snd_kcontrol_new cht_mc_controls[] = { | ||
5001 | SOC_DAPM_PIN_SWITCH("Headphone"), | ||
5002 | SOC_DAPM_PIN_SWITCH("Headset Mic"), | ||
5003 | SOC_DAPM_PIN_SWITCH("Int Mic"), | ||
5004 | + SOC_DAPM_PIN_SWITCH("Int Analog Mic"), | ||
5005 | SOC_DAPM_PIN_SWITCH("Ext Spk"), | ||
5006 | }; | ||
5007 | |||
5008 | diff --git a/sound/soc/intel/skylake/skl-messages.c b/sound/soc/intel/skylake/skl-messages.c | ||
5009 | index 89f70133c8e4..b74a6040cd96 100644 | ||
5010 | --- a/sound/soc/intel/skylake/skl-messages.c | ||
5011 | +++ b/sound/soc/intel/skylake/skl-messages.c | ||
5012 | @@ -404,7 +404,11 @@ int skl_resume_dsp(struct skl *skl) | ||
5013 | if (skl->skl_sst->is_first_boot == true) | ||
5014 | return 0; | ||
5015 | |||
5016 | + /* disable dynamic clock gating during fw and lib download */ | ||
5017 | + ctx->enable_miscbdcge(ctx->dev, false); | ||
5018 | + | ||
5019 | ret = skl_dsp_wake(ctx->dsp); | ||
5020 | + ctx->enable_miscbdcge(ctx->dev, true); | ||
5021 | if (ret < 0) | ||
5022 | return ret; | ||
5023 | |||
5024 | diff --git a/sound/soc/intel/skylake/skl-pcm.c b/sound/soc/intel/skylake/skl-pcm.c | ||
5025 | index 2b1e513b1680..7fe1e8f273a0 100644 | ||
5026 | --- a/sound/soc/intel/skylake/skl-pcm.c | ||
5027 | +++ b/sound/soc/intel/skylake/skl-pcm.c | ||
5028 | @@ -1332,7 +1332,11 @@ static int skl_platform_soc_probe(struct snd_soc_platform *platform) | ||
5029 | return -EIO; | ||
5030 | } | ||
5031 | |||
5032 | + /* disable dynamic clock gating during fw and lib download */ | ||
5033 | + skl->skl_sst->enable_miscbdcge(platform->dev, false); | ||
5034 | + | ||
5035 | ret = ops->init_fw(platform->dev, skl->skl_sst); | ||
5036 | + skl->skl_sst->enable_miscbdcge(platform->dev, true); | ||
5037 | if (ret < 0) { | ||
5038 | dev_err(platform->dev, "Failed to boot first fw: %d\n", ret); | ||
5039 | return ret; | ||
5040 | diff --git a/tools/objtool/check.c b/tools/objtool/check.c | ||
5041 | index 9d01d0b1084e..c8b8b7101c6f 100644 | ||
5042 | --- a/tools/objtool/check.c | ||
5043 | +++ b/tools/objtool/check.c | ||
5044 | @@ -1385,6 +1385,17 @@ static int update_insn_state(struct instruction *insn, struct insn_state *state) | ||
5045 | state->vals[op->dest.reg].offset = -state->stack_size; | ||
5046 | } | ||
5047 | |||
5048 | + else if (op->src.reg == CFI_BP && op->dest.reg == CFI_SP && | ||
5049 | + cfa->base == CFI_BP) { | ||
5050 | + | ||
5051 | + /* | ||
5052 | + * mov %rbp, %rsp | ||
5053 | + * | ||
5054 | + * Restore the original stack pointer (Clang). | ||
5055 | + */ | ||
5056 | + state->stack_size = -state->regs[CFI_BP].offset; | ||
5057 | + } | ||
5058 | + | ||
5059 | else if (op->dest.reg == cfa->base) { | ||
5060 | |||
5061 | /* mov %reg, %rsp */ | ||
5062 | diff --git a/tools/perf/arch/powerpc/util/sym-handling.c b/tools/perf/arch/powerpc/util/sym-handling.c | ||
5063 | index 9c4e23d8c8ce..53d83d7e6a09 100644 | ||
5064 | --- a/tools/perf/arch/powerpc/util/sym-handling.c | ||
5065 | +++ b/tools/perf/arch/powerpc/util/sym-handling.c | ||
5066 | @@ -64,6 +64,14 @@ int arch__compare_symbol_names_n(const char *namea, const char *nameb, | ||
5067 | |||
5068 | return strncmp(namea, nameb, n); | ||
5069 | } | ||
5070 | + | ||
5071 | +const char *arch__normalize_symbol_name(const char *name) | ||
5072 | +{ | ||
5073 | + /* Skip over initial dot */ | ||
5074 | + if (name && *name == '.') | ||
5075 | + name++; | ||
5076 | + return name; | ||
5077 | +} | ||
5078 | #endif | ||
5079 | |||
5080 | #if defined(_CALL_ELF) && _CALL_ELF == 2 | ||
5081 | diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c | ||
5082 | index 0c95ffefb6cc..1957abc1c8cf 100644 | ||
5083 | --- a/tools/perf/builtin-record.c | ||
5084 | +++ b/tools/perf/builtin-record.c | ||
5085 | @@ -1856,8 +1856,8 @@ int cmd_record(int argc, const char **argv) | ||
5086 | goto out; | ||
5087 | } | ||
5088 | |||
5089 | - /* Enable ignoring missing threads when -u option is defined. */ | ||
5090 | - rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX; | ||
5091 | + /* Enable ignoring missing threads when -u/-p option is defined. */ | ||
5092 | + rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX || rec->opts.target.pid; | ||
5093 | |||
5094 | err = -ENOMEM; | ||
5095 | if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0) | ||
5096 | diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c | ||
5097 | index fae4b0340750..183c3ed56e08 100644 | ||
5098 | --- a/tools/perf/builtin-report.c | ||
5099 | +++ b/tools/perf/builtin-report.c | ||
5100 | @@ -162,12 +162,28 @@ static int hist_iter__branch_callback(struct hist_entry_iter *iter, | ||
5101 | struct hist_entry *he = iter->he; | ||
5102 | struct report *rep = arg; | ||
5103 | struct branch_info *bi; | ||
5104 | + struct perf_sample *sample = iter->sample; | ||
5105 | + struct perf_evsel *evsel = iter->evsel; | ||
5106 | + int err; | ||
5107 | + | ||
5108 | + if (!ui__has_annotation()) | ||
5109 | + return 0; | ||
5110 | + | ||
5111 | + hist__account_cycles(sample->branch_stack, al, sample, | ||
5112 | + rep->nonany_branch_mode); | ||
5113 | |||
5114 | bi = he->branch_info; | ||
5115 | + err = addr_map_symbol__inc_samples(&bi->from, sample, evsel->idx); | ||
5116 | + if (err) | ||
5117 | + goto out; | ||
5118 | + | ||
5119 | + err = addr_map_symbol__inc_samples(&bi->to, sample, evsel->idx); | ||
5120 | + | ||
5121 | branch_type_count(&rep->brtype_stat, &bi->flags, | ||
5122 | bi->from.addr, bi->to.addr); | ||
5123 | |||
5124 | - return 0; | ||
5125 | +out: | ||
5126 | + return err; | ||
5127 | } | ||
5128 | |||
5129 | static int process_sample_event(struct perf_tool *tool, | ||
5130 | diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c | ||
5131 | index 1f6beb3d0c68..ac19130c14d8 100644 | ||
5132 | --- a/tools/perf/util/evsel.c | ||
5133 | +++ b/tools/perf/util/evsel.c | ||
5134 | @@ -1591,10 +1591,46 @@ static int __open_attr__fprintf(FILE *fp, const char *name, const char *val, | ||
5135 | return fprintf(fp, " %-32s %s\n", name, val); | ||
5136 | } | ||
5137 | |||
5138 | +static void perf_evsel__remove_fd(struct perf_evsel *pos, | ||
5139 | + int nr_cpus, int nr_threads, | ||
5140 | + int thread_idx) | ||
5141 | +{ | ||
5142 | + for (int cpu = 0; cpu < nr_cpus; cpu++) | ||
5143 | + for (int thread = thread_idx; thread < nr_threads - 1; thread++) | ||
5144 | + FD(pos, cpu, thread) = FD(pos, cpu, thread + 1); | ||
5145 | +} | ||
5146 | + | ||
5147 | +static int update_fds(struct perf_evsel *evsel, | ||
5148 | + int nr_cpus, int cpu_idx, | ||
5149 | + int nr_threads, int thread_idx) | ||
5150 | +{ | ||
5151 | + struct perf_evsel *pos; | ||
5152 | + | ||
5153 | + if (cpu_idx >= nr_cpus || thread_idx >= nr_threads) | ||
5154 | + return -EINVAL; | ||
5155 | + | ||
5156 | + evlist__for_each_entry(evsel->evlist, pos) { | ||
5157 | + nr_cpus = pos != evsel ? nr_cpus : cpu_idx; | ||
5158 | + | ||
5159 | + perf_evsel__remove_fd(pos, nr_cpus, nr_threads, thread_idx); | ||
5160 | + | ||
5161 | + /* | ||
5162 | + * Since fds for next evsel has not been created, | ||
5163 | + * there is no need to iterate whole event list. | ||
5164 | + */ | ||
5165 | + if (pos == evsel) | ||
5166 | + break; | ||
5167 | + } | ||
5168 | + return 0; | ||
5169 | +} | ||
5170 | + | ||
5171 | static bool ignore_missing_thread(struct perf_evsel *evsel, | ||
5172 | + int nr_cpus, int cpu, | ||
5173 | struct thread_map *threads, | ||
5174 | int thread, int err) | ||
5175 | { | ||
5176 | + pid_t ignore_pid = thread_map__pid(threads, thread); | ||
5177 | + | ||
5178 | if (!evsel->ignore_missing_thread) | ||
5179 | return false; | ||
5180 | |||
5181 | @@ -1610,11 +1646,18 @@ static bool ignore_missing_thread(struct perf_evsel *evsel, | ||
5182 | if (threads->nr == 1) | ||
5183 | return false; | ||
5184 | |||
5185 | + /* | ||
5186 | + * We should remove fd for missing_thread first | ||
5187 | + * because thread_map__remove() will decrease threads->nr. | ||
5188 | + */ | ||
5189 | + if (update_fds(evsel, nr_cpus, cpu, threads->nr, thread)) | ||
5190 | + return false; | ||
5191 | + | ||
5192 | if (thread_map__remove(threads, thread)) | ||
5193 | return false; | ||
5194 | |||
5195 | pr_warning("WARNING: Ignored open failure for pid %d\n", | ||
5196 | - thread_map__pid(threads, thread)); | ||
5197 | + ignore_pid); | ||
5198 | return true; | ||
5199 | } | ||
5200 | |||
5201 | @@ -1719,7 +1762,7 @@ int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus, | ||
5202 | if (fd < 0) { | ||
5203 | err = -errno; | ||
5204 | |||
5205 | - if (ignore_missing_thread(evsel, threads, thread, err)) { | ||
5206 | + if (ignore_missing_thread(evsel, cpus->nr, cpu, threads, thread, err)) { | ||
5207 | /* | ||
5208 | * We just removed 1 thread, so take a step | ||
5209 | * back on thread index and lower the upper | ||
5210 | diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c | ||
5211 | index b7aaf9b2294d..68786bb7790e 100644 | ||
5212 | --- a/tools/perf/util/probe-event.c | ||
5213 | +++ b/tools/perf/util/probe-event.c | ||
5214 | @@ -2625,6 +2625,14 @@ static int get_new_event_name(char *buf, size_t len, const char *base, | ||
5215 | |||
5216 | out: | ||
5217 | free(nbase); | ||
5218 | + | ||
5219 | + /* Final validation */ | ||
5220 | + if (ret >= 0 && !is_c_func_name(buf)) { | ||
5221 | + pr_warning("Internal error: \"%s\" is an invalid event name.\n", | ||
5222 | + buf); | ||
5223 | + ret = -EINVAL; | ||
5224 | + } | ||
5225 | + | ||
5226 | return ret; | ||
5227 | } | ||
5228 | |||
5229 | @@ -2792,16 +2800,32 @@ static int find_probe_functions(struct map *map, char *name, | ||
5230 | int found = 0; | ||
5231 | struct symbol *sym; | ||
5232 | struct rb_node *tmp; | ||
5233 | + const char *norm, *ver; | ||
5234 | + char *buf = NULL; | ||
5235 | |||
5236 | if (map__load(map) < 0) | ||
5237 | return 0; | ||
5238 | |||
5239 | map__for_each_symbol(map, sym, tmp) { | ||
5240 | - if (strglobmatch(sym->name, name)) { | ||
5241 | + norm = arch__normalize_symbol_name(sym->name); | ||
5242 | + if (!norm) | ||
5243 | + continue; | ||
5244 | + | ||
5245 | + /* We don't care about default symbol or not */ | ||
5246 | + ver = strchr(norm, '@'); | ||
5247 | + if (ver) { | ||
5248 | + buf = strndup(norm, ver - norm); | ||
5249 | + if (!buf) | ||
5250 | + return -ENOMEM; | ||
5251 | + norm = buf; | ||
5252 | + } | ||
5253 | + if (strglobmatch(norm, name)) { | ||
5254 | found++; | ||
5255 | if (syms && found < probe_conf.max_probes) | ||
5256 | syms[found - 1] = sym; | ||
5257 | } | ||
5258 | + if (buf) | ||
5259 | + zfree(&buf); | ||
5260 | } | ||
5261 | |||
5262 | return found; | ||
5263 | @@ -2847,7 +2871,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev, | ||
5264 | * same name but different addresses, this lists all the symbols. | ||
5265 | */ | ||
5266 | num_matched_functions = find_probe_functions(map, pp->function, syms); | ||
5267 | - if (num_matched_functions == 0) { | ||
5268 | + if (num_matched_functions <= 0) { | ||
5269 | pr_err("Failed to find symbol %s in %s\n", pp->function, | ||
5270 | pev->target ? : "kernel"); | ||
5271 | ret = -ENOENT; | ||
5272 | diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c | ||
5273 | index 6492ef38b090..4e8dd5fd45fd 100644 | ||
5274 | --- a/tools/perf/util/symbol.c | ||
5275 | +++ b/tools/perf/util/symbol.c | ||
5276 | @@ -93,6 +93,11 @@ static int prefix_underscores_count(const char *str) | ||
5277 | return tail - str; | ||
5278 | } | ||
5279 | |||
5280 | +const char * __weak arch__normalize_symbol_name(const char *name) | ||
5281 | +{ | ||
5282 | + return name; | ||
5283 | +} | ||
5284 | + | ||
5285 | int __weak arch__compare_symbol_names(const char *namea, const char *nameb) | ||
5286 | { | ||
5287 | return strcmp(namea, nameb); | ||
5288 | diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h | ||
5289 | index 6352022593c6..698c65e603a8 100644 | ||
5290 | --- a/tools/perf/util/symbol.h | ||
5291 | +++ b/tools/perf/util/symbol.h | ||
5292 | @@ -347,6 +347,7 @@ bool elf__needs_adjust_symbols(GElf_Ehdr ehdr); | ||
5293 | void arch__sym_update(struct symbol *s, GElf_Sym *sym); | ||
5294 | #endif | ||
5295 | |||
5296 | +const char *arch__normalize_symbol_name(const char *name); | ||
5297 | #define SYMBOL_A 0 | ||
5298 | #define SYMBOL_B 1 | ||
5299 | |||
5300 | diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c | ||
5301 | index 3687b720327a..cc57c246eade 100644 | ||
5302 | --- a/tools/perf/util/util.c | ||
5303 | +++ b/tools/perf/util/util.c | ||
5304 | @@ -196,7 +196,7 @@ int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size) | ||
5305 | |||
5306 | size -= ret; | ||
5307 | off_in += ret; | ||
5308 | - off_out -= ret; | ||
5309 | + off_out += ret; | ||
5310 | } | ||
5311 | munmap(ptr, off_in + size); | ||
5312 | |||
5313 | diff --git a/tools/testing/selftests/net/msg_zerocopy.c b/tools/testing/selftests/net/msg_zerocopy.c | ||
5314 | index 3ab6ec403905..e11fe84de0fd 100644 | ||
5315 | --- a/tools/testing/selftests/net/msg_zerocopy.c | ||
5316 | +++ b/tools/testing/selftests/net/msg_zerocopy.c | ||
5317 | @@ -259,22 +259,28 @@ static int setup_ip6h(struct ipv6hdr *ip6h, uint16_t payload_len) | ||
5318 | return sizeof(*ip6h); | ||
5319 | } | ||
5320 | |||
5321 | -static void setup_sockaddr(int domain, const char *str_addr, void *sockaddr) | ||
5322 | + | ||
5323 | +static void setup_sockaddr(int domain, const char *str_addr, | ||
5324 | + struct sockaddr_storage *sockaddr) | ||
5325 | { | ||
5326 | struct sockaddr_in6 *addr6 = (void *) sockaddr; | ||
5327 | struct sockaddr_in *addr4 = (void *) sockaddr; | ||
5328 | |||
5329 | switch (domain) { | ||
5330 | case PF_INET: | ||
5331 | + memset(addr4, 0, sizeof(*addr4)); | ||
5332 | addr4->sin_family = AF_INET; | ||
5333 | addr4->sin_port = htons(cfg_port); | ||
5334 | - if (inet_pton(AF_INET, str_addr, &(addr4->sin_addr)) != 1) | ||
5335 | + if (str_addr && | ||
5336 | + inet_pton(AF_INET, str_addr, &(addr4->sin_addr)) != 1) | ||
5337 | error(1, 0, "ipv4 parse error: %s", str_addr); | ||
5338 | break; | ||
5339 | case PF_INET6: | ||
5340 | + memset(addr6, 0, sizeof(*addr6)); | ||
5341 | addr6->sin6_family = AF_INET6; | ||
5342 | addr6->sin6_port = htons(cfg_port); | ||
5343 | - if (inet_pton(AF_INET6, str_addr, &(addr6->sin6_addr)) != 1) | ||
5344 | + if (str_addr && | ||
5345 | + inet_pton(AF_INET6, str_addr, &(addr6->sin6_addr)) != 1) | ||
5346 | error(1, 0, "ipv6 parse error: %s", str_addr); | ||
5347 | break; | ||
5348 | default: | ||
5349 | @@ -603,6 +609,7 @@ static void parse_opts(int argc, char **argv) | ||
5350 | sizeof(struct tcphdr) - | ||
5351 | 40 /* max tcp options */; | ||
5352 | int c; | ||
5353 | + char *daddr = NULL, *saddr = NULL; | ||
5354 | |||
5355 | cfg_payload_len = max_payload_len; | ||
5356 | |||
5357 | @@ -627,7 +634,7 @@ static void parse_opts(int argc, char **argv) | ||
5358 | cfg_cpu = strtol(optarg, NULL, 0); | ||
5359 | break; | ||
5360 | case 'D': | ||
5361 | - setup_sockaddr(cfg_family, optarg, &cfg_dst_addr); | ||
5362 | + daddr = optarg; | ||
5363 | break; | ||
5364 | case 'i': | ||
5365 | cfg_ifindex = if_nametoindex(optarg); | ||
5366 | @@ -638,7 +645,7 @@ static void parse_opts(int argc, char **argv) | ||
5367 | cfg_cork_mixed = true; | ||
5368 | break; | ||
5369 | case 'p': | ||
5370 | - cfg_port = htons(strtoul(optarg, NULL, 0)); | ||
5371 | + cfg_port = strtoul(optarg, NULL, 0); | ||
5372 | break; | ||
5373 | case 'r': | ||
5374 | cfg_rx = true; | ||
5375 | @@ -647,7 +654,7 @@ static void parse_opts(int argc, char **argv) | ||
5376 | cfg_payload_len = strtoul(optarg, NULL, 0); | ||
5377 | break; | ||
5378 | case 'S': | ||
5379 | - setup_sockaddr(cfg_family, optarg, &cfg_src_addr); | ||
5380 | + saddr = optarg; | ||
5381 | break; | ||
5382 | case 't': | ||
5383 | cfg_runtime_ms = 200 + strtoul(optarg, NULL, 10) * 1000; | ||
5384 | @@ -660,6 +667,8 @@ static void parse_opts(int argc, char **argv) | ||
5385 | break; | ||
5386 | } | ||
5387 | } | ||
5388 | + setup_sockaddr(cfg_family, daddr, &cfg_dst_addr); | ||
5389 | + setup_sockaddr(cfg_family, saddr, &cfg_src_addr); | ||
5390 | |||
5391 | if (cfg_payload_len > max_payload_len) | ||
5392 | error(1, 0, "-s: payload exceeds max (%d)", max_payload_len); |