Annotation of /trunk/kernel-alx/patches-3.12/0111-3.12.12-all-fixes.patch
Parent Directory | Revision Log
Revision 2423 -
(hide annotations)
(download)
Tue Mar 25 12:29:50 2014 UTC (10 years, 6 months ago) by niro
File size: 36837 byte(s)
Tue Mar 25 12:29:50 2014 UTC (10 years, 6 months ago) by niro
File size: 36837 byte(s)
-added 3.12 branch
1 | niro | 2423 | diff --git a/Makefile b/Makefile |
2 | index b9e092666bf9..563297e159b7 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,6 +1,6 @@ | ||
6 | VERSION = 3 | ||
7 | PATCHLEVEL = 12 | ||
8 | -SUBLEVEL = 11 | ||
9 | +SUBLEVEL = 12 | ||
10 | EXTRAVERSION = | ||
11 | NAME = One Giant Leap for Frogkind | ||
12 | |||
13 | diff --git a/arch/arm64/include/asm/cacheflush.h b/arch/arm64/include/asm/cacheflush.h | ||
14 | index fea9ee327206..889324981aa4 100644 | ||
15 | --- a/arch/arm64/include/asm/cacheflush.h | ||
16 | +++ b/arch/arm64/include/asm/cacheflush.h | ||
17 | @@ -116,6 +116,7 @@ extern void flush_dcache_page(struct page *); | ||
18 | static inline void __flush_icache_all(void) | ||
19 | { | ||
20 | asm("ic ialluis"); | ||
21 | + dsb(); | ||
22 | } | ||
23 | |||
24 | #define flush_dcache_mmap_lock(mapping) \ | ||
25 | diff --git a/arch/arm64/kernel/vdso.c b/arch/arm64/kernel/vdso.c | ||
26 | index 6a389dc1bd49..0ea7a22bcdf2 100644 | ||
27 | --- a/arch/arm64/kernel/vdso.c | ||
28 | +++ b/arch/arm64/kernel/vdso.c | ||
29 | @@ -235,6 +235,8 @@ void update_vsyscall(struct timekeeper *tk) | ||
30 | vdso_data->use_syscall = use_syscall; | ||
31 | vdso_data->xtime_coarse_sec = xtime_coarse.tv_sec; | ||
32 | vdso_data->xtime_coarse_nsec = xtime_coarse.tv_nsec; | ||
33 | + vdso_data->wtm_clock_sec = tk->wall_to_monotonic.tv_sec; | ||
34 | + vdso_data->wtm_clock_nsec = tk->wall_to_monotonic.tv_nsec; | ||
35 | |||
36 | if (!use_syscall) { | ||
37 | vdso_data->cs_cycle_last = tk->clock->cycle_last; | ||
38 | @@ -242,8 +244,6 @@ void update_vsyscall(struct timekeeper *tk) | ||
39 | vdso_data->xtime_clock_nsec = tk->xtime_nsec; | ||
40 | vdso_data->cs_mult = tk->mult; | ||
41 | vdso_data->cs_shift = tk->shift; | ||
42 | - vdso_data->wtm_clock_sec = tk->wall_to_monotonic.tv_sec; | ||
43 | - vdso_data->wtm_clock_nsec = tk->wall_to_monotonic.tv_nsec; | ||
44 | } | ||
45 | |||
46 | smp_wmb(); | ||
47 | diff --git a/arch/arm64/kernel/vdso/Makefile b/arch/arm64/kernel/vdso/Makefile | ||
48 | index d8064af42e62..6d20b7d162d8 100644 | ||
49 | --- a/arch/arm64/kernel/vdso/Makefile | ||
50 | +++ b/arch/arm64/kernel/vdso/Makefile | ||
51 | @@ -48,7 +48,7 @@ $(obj-vdso): %.o: %.S | ||
52 | |||
53 | # Actual build commands | ||
54 | quiet_cmd_vdsold = VDSOL $@ | ||
55 | - cmd_vdsold = $(CC) $(c_flags) -Wl,-T $^ -o $@ | ||
56 | + cmd_vdsold = $(CC) $(c_flags) -Wl,-n -Wl,-T $^ -o $@ | ||
57 | quiet_cmd_vdsoas = VDSOA $@ | ||
58 | cmd_vdsoas = $(CC) $(a_flags) -c -o $@ $< | ||
59 | |||
60 | diff --git a/arch/arm64/kernel/vdso/gettimeofday.S b/arch/arm64/kernel/vdso/gettimeofday.S | ||
61 | index f0a6d10b5211..fe652ffd34c2 100644 | ||
62 | --- a/arch/arm64/kernel/vdso/gettimeofday.S | ||
63 | +++ b/arch/arm64/kernel/vdso/gettimeofday.S | ||
64 | @@ -103,6 +103,8 @@ ENTRY(__kernel_clock_gettime) | ||
65 | bl __do_get_tspec | ||
66 | seqcnt_check w9, 1b | ||
67 | |||
68 | + mov x30, x2 | ||
69 | + | ||
70 | cmp w0, #CLOCK_MONOTONIC | ||
71 | b.ne 6f | ||
72 | |||
73 | @@ -118,6 +120,9 @@ ENTRY(__kernel_clock_gettime) | ||
74 | ccmp w0, #CLOCK_MONOTONIC_COARSE, #0x4, ne | ||
75 | b.ne 8f | ||
76 | |||
77 | + /* xtime_coarse_nsec is already right-shifted */ | ||
78 | + mov x12, #0 | ||
79 | + | ||
80 | /* Get coarse timespec. */ | ||
81 | adr vdso_data, _vdso_data | ||
82 | 3: seqcnt_acquire | ||
83 | @@ -156,7 +161,7 @@ ENTRY(__kernel_clock_gettime) | ||
84 | lsr x11, x11, x12 | ||
85 | stp x10, x11, [x1, #TSPEC_TV_SEC] | ||
86 | mov x0, xzr | ||
87 | - ret x2 | ||
88 | + ret | ||
89 | 7: | ||
90 | mov x30, x2 | ||
91 | 8: /* Syscall fallback. */ | ||
92 | diff --git a/arch/arm64/mm/mmu.c b/arch/arm64/mm/mmu.c | ||
93 | index f557ebbe7013..f8dc7e8fce6f 100644 | ||
94 | --- a/arch/arm64/mm/mmu.c | ||
95 | +++ b/arch/arm64/mm/mmu.c | ||
96 | @@ -203,10 +203,18 @@ static void __init alloc_init_pmd(pud_t *pud, unsigned long addr, | ||
97 | do { | ||
98 | next = pmd_addr_end(addr, end); | ||
99 | /* try section mapping first */ | ||
100 | - if (((addr | next | phys) & ~SECTION_MASK) == 0) | ||
101 | + if (((addr | next | phys) & ~SECTION_MASK) == 0) { | ||
102 | + pmd_t old_pmd =*pmd; | ||
103 | set_pmd(pmd, __pmd(phys | prot_sect_kernel)); | ||
104 | - else | ||
105 | + /* | ||
106 | + * Check for previous table entries created during | ||
107 | + * boot (__create_page_tables) and flush them. | ||
108 | + */ | ||
109 | + if (!pmd_none(old_pmd)) | ||
110 | + flush_tlb_all(); | ||
111 | + } else { | ||
112 | alloc_init_pte(pmd, addr, next, __phys_to_pfn(phys)); | ||
113 | + } | ||
114 | phys += next - addr; | ||
115 | } while (pmd++, addr = next, addr != end); | ||
116 | } | ||
117 | diff --git a/arch/s390/crypto/aes_s390.c b/arch/s390/crypto/aes_s390.c | ||
118 | index 94e20dd2729f..2a245b55bb71 100644 | ||
119 | --- a/arch/s390/crypto/aes_s390.c | ||
120 | +++ b/arch/s390/crypto/aes_s390.c | ||
121 | @@ -25,6 +25,7 @@ | ||
122 | #include <linux/err.h> | ||
123 | #include <linux/module.h> | ||
124 | #include <linux/init.h> | ||
125 | +#include <linux/spinlock.h> | ||
126 | #include "crypt_s390.h" | ||
127 | |||
128 | #define AES_KEYLEN_128 1 | ||
129 | @@ -32,6 +33,7 @@ | ||
130 | #define AES_KEYLEN_256 4 | ||
131 | |||
132 | static u8 *ctrblk; | ||
133 | +static DEFINE_SPINLOCK(ctrblk_lock); | ||
134 | static char keylen_flag; | ||
135 | |||
136 | struct s390_aes_ctx { | ||
137 | @@ -756,43 +758,67 @@ static int ctr_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key, | ||
138 | return aes_set_key(tfm, in_key, key_len); | ||
139 | } | ||
140 | |||
141 | +static unsigned int __ctrblk_init(u8 *ctrptr, unsigned int nbytes) | ||
142 | +{ | ||
143 | + unsigned int i, n; | ||
144 | + | ||
145 | + /* only use complete blocks, max. PAGE_SIZE */ | ||
146 | + n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : nbytes & ~(AES_BLOCK_SIZE - 1); | ||
147 | + for (i = AES_BLOCK_SIZE; i < n; i += AES_BLOCK_SIZE) { | ||
148 | + memcpy(ctrptr + i, ctrptr + i - AES_BLOCK_SIZE, | ||
149 | + AES_BLOCK_SIZE); | ||
150 | + crypto_inc(ctrptr + i, AES_BLOCK_SIZE); | ||
151 | + } | ||
152 | + return n; | ||
153 | +} | ||
154 | + | ||
155 | static int ctr_aes_crypt(struct blkcipher_desc *desc, long func, | ||
156 | struct s390_aes_ctx *sctx, struct blkcipher_walk *walk) | ||
157 | { | ||
158 | int ret = blkcipher_walk_virt_block(desc, walk, AES_BLOCK_SIZE); | ||
159 | - unsigned int i, n, nbytes; | ||
160 | - u8 buf[AES_BLOCK_SIZE]; | ||
161 | - u8 *out, *in; | ||
162 | + unsigned int n, nbytes; | ||
163 | + u8 buf[AES_BLOCK_SIZE], ctrbuf[AES_BLOCK_SIZE]; | ||
164 | + u8 *out, *in, *ctrptr = ctrbuf; | ||
165 | |||
166 | if (!walk->nbytes) | ||
167 | return ret; | ||
168 | |||
169 | - memcpy(ctrblk, walk->iv, AES_BLOCK_SIZE); | ||
170 | + if (spin_trylock(&ctrblk_lock)) | ||
171 | + ctrptr = ctrblk; | ||
172 | + | ||
173 | + memcpy(ctrptr, walk->iv, AES_BLOCK_SIZE); | ||
174 | while ((nbytes = walk->nbytes) >= AES_BLOCK_SIZE) { | ||
175 | out = walk->dst.virt.addr; | ||
176 | in = walk->src.virt.addr; | ||
177 | while (nbytes >= AES_BLOCK_SIZE) { | ||
178 | - /* only use complete blocks, max. PAGE_SIZE */ | ||
179 | - n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : | ||
180 | - nbytes & ~(AES_BLOCK_SIZE - 1); | ||
181 | - for (i = AES_BLOCK_SIZE; i < n; i += AES_BLOCK_SIZE) { | ||
182 | - memcpy(ctrblk + i, ctrblk + i - AES_BLOCK_SIZE, | ||
183 | - AES_BLOCK_SIZE); | ||
184 | - crypto_inc(ctrblk + i, AES_BLOCK_SIZE); | ||
185 | - } | ||
186 | - ret = crypt_s390_kmctr(func, sctx->key, out, in, n, ctrblk); | ||
187 | - if (ret < 0 || ret != n) | ||
188 | + if (ctrptr == ctrblk) | ||
189 | + n = __ctrblk_init(ctrptr, nbytes); | ||
190 | + else | ||
191 | + n = AES_BLOCK_SIZE; | ||
192 | + ret = crypt_s390_kmctr(func, sctx->key, out, in, | ||
193 | + n, ctrptr); | ||
194 | + if (ret < 0 || ret != n) { | ||
195 | + if (ctrptr == ctrblk) | ||
196 | + spin_unlock(&ctrblk_lock); | ||
197 | return -EIO; | ||
198 | + } | ||
199 | if (n > AES_BLOCK_SIZE) | ||
200 | - memcpy(ctrblk, ctrblk + n - AES_BLOCK_SIZE, | ||
201 | + memcpy(ctrptr, ctrptr + n - AES_BLOCK_SIZE, | ||
202 | AES_BLOCK_SIZE); | ||
203 | - crypto_inc(ctrblk, AES_BLOCK_SIZE); | ||
204 | + crypto_inc(ctrptr, AES_BLOCK_SIZE); | ||
205 | out += n; | ||
206 | in += n; | ||
207 | nbytes -= n; | ||
208 | } | ||
209 | ret = blkcipher_walk_done(desc, walk, nbytes); | ||
210 | } | ||
211 | + if (ctrptr == ctrblk) { | ||
212 | + if (nbytes) | ||
213 | + memcpy(ctrbuf, ctrptr, AES_BLOCK_SIZE); | ||
214 | + else | ||
215 | + memcpy(walk->iv, ctrptr, AES_BLOCK_SIZE); | ||
216 | + spin_unlock(&ctrblk_lock); | ||
217 | + } | ||
218 | /* | ||
219 | * final block may be < AES_BLOCK_SIZE, copy only nbytes | ||
220 | */ | ||
221 | @@ -800,14 +826,15 @@ static int ctr_aes_crypt(struct blkcipher_desc *desc, long func, | ||
222 | out = walk->dst.virt.addr; | ||
223 | in = walk->src.virt.addr; | ||
224 | ret = crypt_s390_kmctr(func, sctx->key, buf, in, | ||
225 | - AES_BLOCK_SIZE, ctrblk); | ||
226 | + AES_BLOCK_SIZE, ctrbuf); | ||
227 | if (ret < 0 || ret != AES_BLOCK_SIZE) | ||
228 | return -EIO; | ||
229 | memcpy(out, buf, nbytes); | ||
230 | - crypto_inc(ctrblk, AES_BLOCK_SIZE); | ||
231 | + crypto_inc(ctrbuf, AES_BLOCK_SIZE); | ||
232 | ret = blkcipher_walk_done(desc, walk, 0); | ||
233 | + memcpy(walk->iv, ctrbuf, AES_BLOCK_SIZE); | ||
234 | } | ||
235 | - memcpy(walk->iv, ctrblk, AES_BLOCK_SIZE); | ||
236 | + | ||
237 | return ret; | ||
238 | } | ||
239 | |||
240 | diff --git a/arch/s390/crypto/des_s390.c b/arch/s390/crypto/des_s390.c | ||
241 | index bcca01c9989d..2d96e68febb2 100644 | ||
242 | --- a/arch/s390/crypto/des_s390.c | ||
243 | +++ b/arch/s390/crypto/des_s390.c | ||
244 | @@ -25,6 +25,7 @@ | ||
245 | #define DES3_KEY_SIZE (3 * DES_KEY_SIZE) | ||
246 | |||
247 | static u8 *ctrblk; | ||
248 | +static DEFINE_SPINLOCK(ctrblk_lock); | ||
249 | |||
250 | struct s390_des_ctx { | ||
251 | u8 iv[DES_BLOCK_SIZE]; | ||
252 | @@ -105,29 +106,35 @@ static int ecb_desall_crypt(struct blkcipher_desc *desc, long func, | ||
253 | } | ||
254 | |||
255 | static int cbc_desall_crypt(struct blkcipher_desc *desc, long func, | ||
256 | - u8 *iv, struct blkcipher_walk *walk) | ||
257 | + struct blkcipher_walk *walk) | ||
258 | { | ||
259 | + struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); | ||
260 | int ret = blkcipher_walk_virt(desc, walk); | ||
261 | unsigned int nbytes = walk->nbytes; | ||
262 | + struct { | ||
263 | + u8 iv[DES_BLOCK_SIZE]; | ||
264 | + u8 key[DES3_KEY_SIZE]; | ||
265 | + } param; | ||
266 | |||
267 | if (!nbytes) | ||
268 | goto out; | ||
269 | |||
270 | - memcpy(iv, walk->iv, DES_BLOCK_SIZE); | ||
271 | + memcpy(param.iv, walk->iv, DES_BLOCK_SIZE); | ||
272 | + memcpy(param.key, ctx->key, DES3_KEY_SIZE); | ||
273 | do { | ||
274 | /* only use complete blocks */ | ||
275 | unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1); | ||
276 | u8 *out = walk->dst.virt.addr; | ||
277 | u8 *in = walk->src.virt.addr; | ||
278 | |||
279 | - ret = crypt_s390_kmc(func, iv, out, in, n); | ||
280 | + ret = crypt_s390_kmc(func, ¶m, out, in, n); | ||
281 | if (ret < 0 || ret != n) | ||
282 | return -EIO; | ||
283 | |||
284 | nbytes &= DES_BLOCK_SIZE - 1; | ||
285 | ret = blkcipher_walk_done(desc, walk, nbytes); | ||
286 | } while ((nbytes = walk->nbytes)); | ||
287 | - memcpy(walk->iv, iv, DES_BLOCK_SIZE); | ||
288 | + memcpy(walk->iv, param.iv, DES_BLOCK_SIZE); | ||
289 | |||
290 | out: | ||
291 | return ret; | ||
292 | @@ -179,22 +186,20 @@ static int cbc_des_encrypt(struct blkcipher_desc *desc, | ||
293 | struct scatterlist *dst, struct scatterlist *src, | ||
294 | unsigned int nbytes) | ||
295 | { | ||
296 | - struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); | ||
297 | struct blkcipher_walk walk; | ||
298 | |||
299 | blkcipher_walk_init(&walk, dst, src, nbytes); | ||
300 | - return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, ctx->iv, &walk); | ||
301 | + return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, &walk); | ||
302 | } | ||
303 | |||
304 | static int cbc_des_decrypt(struct blkcipher_desc *desc, | ||
305 | struct scatterlist *dst, struct scatterlist *src, | ||
306 | unsigned int nbytes) | ||
307 | { | ||
308 | - struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); | ||
309 | struct blkcipher_walk walk; | ||
310 | |||
311 | blkcipher_walk_init(&walk, dst, src, nbytes); | ||
312 | - return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, ctx->iv, &walk); | ||
313 | + return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, &walk); | ||
314 | } | ||
315 | |||
316 | static struct crypto_alg cbc_des_alg = { | ||
317 | @@ -327,22 +332,20 @@ static int cbc_des3_encrypt(struct blkcipher_desc *desc, | ||
318 | struct scatterlist *dst, struct scatterlist *src, | ||
319 | unsigned int nbytes) | ||
320 | { | ||
321 | - struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); | ||
322 | struct blkcipher_walk walk; | ||
323 | |||
324 | blkcipher_walk_init(&walk, dst, src, nbytes); | ||
325 | - return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, ctx->iv, &walk); | ||
326 | + return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, &walk); | ||
327 | } | ||
328 | |||
329 | static int cbc_des3_decrypt(struct blkcipher_desc *desc, | ||
330 | struct scatterlist *dst, struct scatterlist *src, | ||
331 | unsigned int nbytes) | ||
332 | { | ||
333 | - struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); | ||
334 | struct blkcipher_walk walk; | ||
335 | |||
336 | blkcipher_walk_init(&walk, dst, src, nbytes); | ||
337 | - return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, ctx->iv, &walk); | ||
338 | + return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, &walk); | ||
339 | } | ||
340 | |||
341 | static struct crypto_alg cbc_des3_alg = { | ||
342 | @@ -366,54 +369,80 @@ static struct crypto_alg cbc_des3_alg = { | ||
343 | } | ||
344 | }; | ||
345 | |||
346 | +static unsigned int __ctrblk_init(u8 *ctrptr, unsigned int nbytes) | ||
347 | +{ | ||
348 | + unsigned int i, n; | ||
349 | + | ||
350 | + /* align to block size, max. PAGE_SIZE */ | ||
351 | + n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : nbytes & ~(DES_BLOCK_SIZE - 1); | ||
352 | + for (i = DES_BLOCK_SIZE; i < n; i += DES_BLOCK_SIZE) { | ||
353 | + memcpy(ctrptr + i, ctrptr + i - DES_BLOCK_SIZE, DES_BLOCK_SIZE); | ||
354 | + crypto_inc(ctrptr + i, DES_BLOCK_SIZE); | ||
355 | + } | ||
356 | + return n; | ||
357 | +} | ||
358 | + | ||
359 | static int ctr_desall_crypt(struct blkcipher_desc *desc, long func, | ||
360 | - struct s390_des_ctx *ctx, struct blkcipher_walk *walk) | ||
361 | + struct s390_des_ctx *ctx, | ||
362 | + struct blkcipher_walk *walk) | ||
363 | { | ||
364 | int ret = blkcipher_walk_virt_block(desc, walk, DES_BLOCK_SIZE); | ||
365 | - unsigned int i, n, nbytes; | ||
366 | - u8 buf[DES_BLOCK_SIZE]; | ||
367 | - u8 *out, *in; | ||
368 | + unsigned int n, nbytes; | ||
369 | + u8 buf[DES_BLOCK_SIZE], ctrbuf[DES_BLOCK_SIZE]; | ||
370 | + u8 *out, *in, *ctrptr = ctrbuf; | ||
371 | + | ||
372 | + if (!walk->nbytes) | ||
373 | + return ret; | ||
374 | |||
375 | - memcpy(ctrblk, walk->iv, DES_BLOCK_SIZE); | ||
376 | + if (spin_trylock(&ctrblk_lock)) | ||
377 | + ctrptr = ctrblk; | ||
378 | + | ||
379 | + memcpy(ctrptr, walk->iv, DES_BLOCK_SIZE); | ||
380 | while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) { | ||
381 | out = walk->dst.virt.addr; | ||
382 | in = walk->src.virt.addr; | ||
383 | while (nbytes >= DES_BLOCK_SIZE) { | ||
384 | - /* align to block size, max. PAGE_SIZE */ | ||
385 | - n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : | ||
386 | - nbytes & ~(DES_BLOCK_SIZE - 1); | ||
387 | - for (i = DES_BLOCK_SIZE; i < n; i += DES_BLOCK_SIZE) { | ||
388 | - memcpy(ctrblk + i, ctrblk + i - DES_BLOCK_SIZE, | ||
389 | - DES_BLOCK_SIZE); | ||
390 | - crypto_inc(ctrblk + i, DES_BLOCK_SIZE); | ||
391 | - } | ||
392 | - ret = crypt_s390_kmctr(func, ctx->key, out, in, n, ctrblk); | ||
393 | - if (ret < 0 || ret != n) | ||
394 | + if (ctrptr == ctrblk) | ||
395 | + n = __ctrblk_init(ctrptr, nbytes); | ||
396 | + else | ||
397 | + n = DES_BLOCK_SIZE; | ||
398 | + ret = crypt_s390_kmctr(func, ctx->key, out, in, | ||
399 | + n, ctrptr); | ||
400 | + if (ret < 0 || ret != n) { | ||
401 | + if (ctrptr == ctrblk) | ||
402 | + spin_unlock(&ctrblk_lock); | ||
403 | return -EIO; | ||
404 | + } | ||
405 | if (n > DES_BLOCK_SIZE) | ||
406 | - memcpy(ctrblk, ctrblk + n - DES_BLOCK_SIZE, | ||
407 | + memcpy(ctrptr, ctrptr + n - DES_BLOCK_SIZE, | ||
408 | DES_BLOCK_SIZE); | ||
409 | - crypto_inc(ctrblk, DES_BLOCK_SIZE); | ||
410 | + crypto_inc(ctrptr, DES_BLOCK_SIZE); | ||
411 | out += n; | ||
412 | in += n; | ||
413 | nbytes -= n; | ||
414 | } | ||
415 | ret = blkcipher_walk_done(desc, walk, nbytes); | ||
416 | } | ||
417 | - | ||
418 | + if (ctrptr == ctrblk) { | ||
419 | + if (nbytes) | ||
420 | + memcpy(ctrbuf, ctrptr, DES_BLOCK_SIZE); | ||
421 | + else | ||
422 | + memcpy(walk->iv, ctrptr, DES_BLOCK_SIZE); | ||
423 | + spin_unlock(&ctrblk_lock); | ||
424 | + } | ||
425 | /* final block may be < DES_BLOCK_SIZE, copy only nbytes */ | ||
426 | if (nbytes) { | ||
427 | out = walk->dst.virt.addr; | ||
428 | in = walk->src.virt.addr; | ||
429 | ret = crypt_s390_kmctr(func, ctx->key, buf, in, | ||
430 | - DES_BLOCK_SIZE, ctrblk); | ||
431 | + DES_BLOCK_SIZE, ctrbuf); | ||
432 | if (ret < 0 || ret != DES_BLOCK_SIZE) | ||
433 | return -EIO; | ||
434 | memcpy(out, buf, nbytes); | ||
435 | - crypto_inc(ctrblk, DES_BLOCK_SIZE); | ||
436 | + crypto_inc(ctrbuf, DES_BLOCK_SIZE); | ||
437 | ret = blkcipher_walk_done(desc, walk, 0); | ||
438 | + memcpy(walk->iv, ctrbuf, DES_BLOCK_SIZE); | ||
439 | } | ||
440 | - memcpy(walk->iv, ctrblk, DES_BLOCK_SIZE); | ||
441 | return ret; | ||
442 | } | ||
443 | |||
444 | diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c | ||
445 | index a51efc90b534..87c0be59970a 100644 | ||
446 | --- a/arch/x86/kernel/cpu/intel.c | ||
447 | +++ b/arch/x86/kernel/cpu/intel.c | ||
448 | @@ -628,7 +628,7 @@ static void intel_tlb_flushall_shift_set(struct cpuinfo_x86 *c) | ||
449 | tlb_flushall_shift = 5; | ||
450 | break; | ||
451 | case 0x63a: /* Ivybridge */ | ||
452 | - tlb_flushall_shift = 1; | ||
453 | + tlb_flushall_shift = 2; | ||
454 | break; | ||
455 | default: | ||
456 | tlb_flushall_shift = 6; | ||
457 | diff --git a/drivers/irqchip/irq-armada-370-xp.c b/drivers/irqchip/irq-armada-370-xp.c | ||
458 | index bb328a366122..a51ee009ed83 100644 | ||
459 | --- a/drivers/irqchip/irq-armada-370-xp.c | ||
460 | +++ b/drivers/irqchip/irq-armada-370-xp.c | ||
461 | @@ -229,7 +229,7 @@ armada_370_xp_handle_irq(struct pt_regs *regs) | ||
462 | ARMADA_370_XP_IN_DRBEL_CAUSE_OFFS) | ||
463 | & IPI_DOORBELL_MASK; | ||
464 | |||
465 | - writel(~IPI_DOORBELL_MASK, per_cpu_int_base + | ||
466 | + writel(~ipimask, per_cpu_int_base + | ||
467 | ARMADA_370_XP_IN_DRBEL_CAUSE_OFFS); | ||
468 | |||
469 | /* Handle all pending doorbells */ | ||
470 | diff --git a/drivers/media/usb/dvb-usb-v2/af9035.c b/drivers/media/usb/dvb-usb-v2/af9035.c | ||
471 | index 8f9b2cea88f0..8ede8ea762e6 100644 | ||
472 | --- a/drivers/media/usb/dvb-usb-v2/af9035.c | ||
473 | +++ b/drivers/media/usb/dvb-usb-v2/af9035.c | ||
474 | @@ -1539,6 +1539,8 @@ static const struct usb_device_id af9035_id_table[] = { | ||
475 | &af9035_props, "TerraTec Cinergy T Stick Dual RC (rev. 2)", NULL) }, | ||
476 | { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6a05, | ||
477 | &af9035_props, "Leadtek WinFast DTV Dongle Dual", NULL) }, | ||
478 | + { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xf900, | ||
479 | + &af9035_props, "Hauppauge WinTV-MiniStick 2", NULL) }, | ||
480 | { } | ||
481 | }; | ||
482 | MODULE_DEVICE_TABLE(usb, af9035_id_table); | ||
483 | diff --git a/drivers/media/usb/dvb-usb-v2/mxl111sf-tuner.h b/drivers/media/usb/dvb-usb-v2/mxl111sf-tuner.h | ||
484 | index 90f583e5d6a6..a8f65d88c9e7 100644 | ||
485 | --- a/drivers/media/usb/dvb-usb-v2/mxl111sf-tuner.h | ||
486 | +++ b/drivers/media/usb/dvb-usb-v2/mxl111sf-tuner.h | ||
487 | @@ -68,7 +68,7 @@ struct dvb_frontend *mxl111sf_tuner_attach(struct dvb_frontend *fe, | ||
488 | #else | ||
489 | static inline | ||
490 | struct dvb_frontend *mxl111sf_tuner_attach(struct dvb_frontend *fe, | ||
491 | - struct mxl111sf_state *mxl_state | ||
492 | + struct mxl111sf_state *mxl_state, | ||
493 | struct mxl111sf_tuner_config *cfg) | ||
494 | { | ||
495 | printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__); | ||
496 | diff --git a/drivers/media/usb/dvb-usb-v2/mxl111sf.c b/drivers/media/usb/dvb-usb-v2/mxl111sf.c | ||
497 | index 2627553f7de1..3b948e3d4583 100644 | ||
498 | --- a/drivers/media/usb/dvb-usb-v2/mxl111sf.c | ||
499 | +++ b/drivers/media/usb/dvb-usb-v2/mxl111sf.c | ||
500 | @@ -105,7 +105,7 @@ int mxl111sf_read_reg(struct mxl111sf_state *state, u8 addr, u8 *data) | ||
501 | ret = -EINVAL; | ||
502 | } | ||
503 | |||
504 | - pr_debug("R: (0x%02x, 0x%02x)\n", addr, *data); | ||
505 | + pr_debug("R: (0x%02x, 0x%02x)\n", addr, buf[1]); | ||
506 | fail: | ||
507 | return ret; | ||
508 | } | ||
509 | diff --git a/drivers/media/v4l2-core/videobuf-dma-contig.c b/drivers/media/v4l2-core/videobuf-dma-contig.c | ||
510 | index 65411adcd0ea..7e6b209b7002 100644 | ||
511 | --- a/drivers/media/v4l2-core/videobuf-dma-contig.c | ||
512 | +++ b/drivers/media/v4l2-core/videobuf-dma-contig.c | ||
513 | @@ -66,14 +66,11 @@ static void __videobuf_dc_free(struct device *dev, | ||
514 | static void videobuf_vm_open(struct vm_area_struct *vma) | ||
515 | { | ||
516 | struct videobuf_mapping *map = vma->vm_private_data; | ||
517 | - struct videobuf_queue *q = map->q; | ||
518 | |||
519 | - dev_dbg(q->dev, "vm_open %p [count=%u,vma=%08lx-%08lx]\n", | ||
520 | + dev_dbg(map->q->dev, "vm_open %p [count=%u,vma=%08lx-%08lx]\n", | ||
521 | map, map->count, vma->vm_start, vma->vm_end); | ||
522 | |||
523 | - videobuf_queue_lock(q); | ||
524 | map->count++; | ||
525 | - videobuf_queue_unlock(q); | ||
526 | } | ||
527 | |||
528 | static void videobuf_vm_close(struct vm_area_struct *vma) | ||
529 | @@ -85,11 +82,12 @@ static void videobuf_vm_close(struct vm_area_struct *vma) | ||
530 | dev_dbg(q->dev, "vm_close %p [count=%u,vma=%08lx-%08lx]\n", | ||
531 | map, map->count, vma->vm_start, vma->vm_end); | ||
532 | |||
533 | - videobuf_queue_lock(q); | ||
534 | - if (!--map->count) { | ||
535 | + map->count--; | ||
536 | + if (0 == map->count) { | ||
537 | struct videobuf_dma_contig_memory *mem; | ||
538 | |||
539 | dev_dbg(q->dev, "munmap %p q=%p\n", map, q); | ||
540 | + videobuf_queue_lock(q); | ||
541 | |||
542 | /* We need first to cancel streams, before unmapping */ | ||
543 | if (q->streaming) | ||
544 | @@ -128,8 +126,8 @@ static void videobuf_vm_close(struct vm_area_struct *vma) | ||
545 | |||
546 | kfree(map); | ||
547 | |||
548 | + videobuf_queue_unlock(q); | ||
549 | } | ||
550 | - videobuf_queue_unlock(q); | ||
551 | } | ||
552 | |||
553 | static const struct vm_operations_struct videobuf_vm_ops = { | ||
554 | diff --git a/drivers/media/v4l2-core/videobuf-dma-sg.c b/drivers/media/v4l2-core/videobuf-dma-sg.c | ||
555 | index 9db674ccdc68..828e7c10bd70 100644 | ||
556 | --- a/drivers/media/v4l2-core/videobuf-dma-sg.c | ||
557 | +++ b/drivers/media/v4l2-core/videobuf-dma-sg.c | ||
558 | @@ -338,14 +338,11 @@ EXPORT_SYMBOL_GPL(videobuf_dma_free); | ||
559 | static void videobuf_vm_open(struct vm_area_struct *vma) | ||
560 | { | ||
561 | struct videobuf_mapping *map = vma->vm_private_data; | ||
562 | - struct videobuf_queue *q = map->q; | ||
563 | |||
564 | dprintk(2, "vm_open %p [count=%d,vma=%08lx-%08lx]\n", map, | ||
565 | map->count, vma->vm_start, vma->vm_end); | ||
566 | |||
567 | - videobuf_queue_lock(q); | ||
568 | map->count++; | ||
569 | - videobuf_queue_unlock(q); | ||
570 | } | ||
571 | |||
572 | static void videobuf_vm_close(struct vm_area_struct *vma) | ||
573 | @@ -358,9 +355,10 @@ static void videobuf_vm_close(struct vm_area_struct *vma) | ||
574 | dprintk(2, "vm_close %p [count=%d,vma=%08lx-%08lx]\n", map, | ||
575 | map->count, vma->vm_start, vma->vm_end); | ||
576 | |||
577 | - videobuf_queue_lock(q); | ||
578 | - if (!--map->count) { | ||
579 | + map->count--; | ||
580 | + if (0 == map->count) { | ||
581 | dprintk(1, "munmap %p q=%p\n", map, q); | ||
582 | + videobuf_queue_lock(q); | ||
583 | for (i = 0; i < VIDEO_MAX_FRAME; i++) { | ||
584 | if (NULL == q->bufs[i]) | ||
585 | continue; | ||
586 | @@ -376,9 +374,9 @@ static void videobuf_vm_close(struct vm_area_struct *vma) | ||
587 | q->bufs[i]->baddr = 0; | ||
588 | q->ops->buf_release(q, q->bufs[i]); | ||
589 | } | ||
590 | + videobuf_queue_unlock(q); | ||
591 | kfree(map); | ||
592 | } | ||
593 | - videobuf_queue_unlock(q); | ||
594 | return; | ||
595 | } | ||
596 | |||
597 | diff --git a/drivers/media/v4l2-core/videobuf-vmalloc.c b/drivers/media/v4l2-core/videobuf-vmalloc.c | ||
598 | index 1365c651c177..2ff7fcc77b11 100644 | ||
599 | --- a/drivers/media/v4l2-core/videobuf-vmalloc.c | ||
600 | +++ b/drivers/media/v4l2-core/videobuf-vmalloc.c | ||
601 | @@ -54,14 +54,11 @@ MODULE_LICENSE("GPL"); | ||
602 | static void videobuf_vm_open(struct vm_area_struct *vma) | ||
603 | { | ||
604 | struct videobuf_mapping *map = vma->vm_private_data; | ||
605 | - struct videobuf_queue *q = map->q; | ||
606 | |||
607 | dprintk(2, "vm_open %p [count=%u,vma=%08lx-%08lx]\n", map, | ||
608 | map->count, vma->vm_start, vma->vm_end); | ||
609 | |||
610 | - videobuf_queue_lock(q); | ||
611 | map->count++; | ||
612 | - videobuf_queue_unlock(q); | ||
613 | } | ||
614 | |||
615 | static void videobuf_vm_close(struct vm_area_struct *vma) | ||
616 | @@ -73,11 +70,12 @@ static void videobuf_vm_close(struct vm_area_struct *vma) | ||
617 | dprintk(2, "vm_close %p [count=%u,vma=%08lx-%08lx]\n", map, | ||
618 | map->count, vma->vm_start, vma->vm_end); | ||
619 | |||
620 | - videobuf_queue_lock(q); | ||
621 | - if (!--map->count) { | ||
622 | + map->count--; | ||
623 | + if (0 == map->count) { | ||
624 | struct videobuf_vmalloc_memory *mem; | ||
625 | |||
626 | dprintk(1, "munmap %p q=%p\n", map, q); | ||
627 | + videobuf_queue_lock(q); | ||
628 | |||
629 | /* We need first to cancel streams, before unmapping */ | ||
630 | if (q->streaming) | ||
631 | @@ -116,8 +114,8 @@ static void videobuf_vm_close(struct vm_area_struct *vma) | ||
632 | |||
633 | kfree(map); | ||
634 | |||
635 | + videobuf_queue_unlock(q); | ||
636 | } | ||
637 | - videobuf_queue_unlock(q); | ||
638 | |||
639 | return; | ||
640 | } | ||
641 | diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c | ||
642 | index 92f86ab30a13..a1ffae4c3770 100644 | ||
643 | --- a/drivers/pinctrl/core.c | ||
644 | +++ b/drivers/pinctrl/core.c | ||
645 | @@ -837,7 +837,9 @@ static struct pinctrl *create_pinctrl(struct device *dev) | ||
646 | kref_init(&p->users); | ||
647 | |||
648 | /* Add the pinctrl handle to the global list */ | ||
649 | + mutex_lock(&pinctrl_list_mutex); | ||
650 | list_add_tail(&p->node, &pinctrl_list); | ||
651 | + mutex_unlock(&pinctrl_list_mutex); | ||
652 | |||
653 | return p; | ||
654 | } | ||
655 | diff --git a/drivers/pinctrl/pinctrl-at91.c b/drivers/pinctrl/pinctrl-at91.c | ||
656 | index f350fd2e170e..f4e99a9491cc 100644 | ||
657 | --- a/drivers/pinctrl/pinctrl-at91.c | ||
658 | +++ b/drivers/pinctrl/pinctrl-at91.c | ||
659 | @@ -1251,22 +1251,22 @@ static int alt_gpio_irq_type(struct irq_data *d, unsigned type) | ||
660 | |||
661 | switch (type) { | ||
662 | case IRQ_TYPE_EDGE_RISING: | ||
663 | - irq_set_handler(d->irq, handle_simple_irq); | ||
664 | + __irq_set_handler_locked(d->irq, handle_simple_irq); | ||
665 | writel_relaxed(mask, pio + PIO_ESR); | ||
666 | writel_relaxed(mask, pio + PIO_REHLSR); | ||
667 | break; | ||
668 | case IRQ_TYPE_EDGE_FALLING: | ||
669 | - irq_set_handler(d->irq, handle_simple_irq); | ||
670 | + __irq_set_handler_locked(d->irq, handle_simple_irq); | ||
671 | writel_relaxed(mask, pio + PIO_ESR); | ||
672 | writel_relaxed(mask, pio + PIO_FELLSR); | ||
673 | break; | ||
674 | case IRQ_TYPE_LEVEL_LOW: | ||
675 | - irq_set_handler(d->irq, handle_level_irq); | ||
676 | + __irq_set_handler_locked(d->irq, handle_level_irq); | ||
677 | writel_relaxed(mask, pio + PIO_LSR); | ||
678 | writel_relaxed(mask, pio + PIO_FELLSR); | ||
679 | break; | ||
680 | case IRQ_TYPE_LEVEL_HIGH: | ||
681 | - irq_set_handler(d->irq, handle_level_irq); | ||
682 | + __irq_set_handler_locked(d->irq, handle_level_irq); | ||
683 | writel_relaxed(mask, pio + PIO_LSR); | ||
684 | writel_relaxed(mask, pio + PIO_REHLSR); | ||
685 | break; | ||
686 | @@ -1275,7 +1275,7 @@ static int alt_gpio_irq_type(struct irq_data *d, unsigned type) | ||
687 | * disable additional interrupt modes: | ||
688 | * fall back to default behavior | ||
689 | */ | ||
690 | - irq_set_handler(d->irq, handle_simple_irq); | ||
691 | + __irq_set_handler_locked(d->irq, handle_simple_irq); | ||
692 | writel_relaxed(mask, pio + PIO_AIMDR); | ||
693 | return 0; | ||
694 | case IRQ_TYPE_NONE: | ||
695 | diff --git a/drivers/pinctrl/vt8500/pinctrl-wmt.c b/drivers/pinctrl/vt8500/pinctrl-wmt.c | ||
696 | index 39aec0850810..25ab2eec92e4 100644 | ||
697 | --- a/drivers/pinctrl/vt8500/pinctrl-wmt.c | ||
698 | +++ b/drivers/pinctrl/vt8500/pinctrl-wmt.c | ||
699 | @@ -276,7 +276,20 @@ static int wmt_pctl_dt_node_to_map_pull(struct wmt_pinctrl_data *data, | ||
700 | if (!configs) | ||
701 | return -ENOMEM; | ||
702 | |||
703 | - configs[0] = pull; | ||
704 | + switch (pull) { | ||
705 | + case 0: | ||
706 | + configs[0] = PIN_CONFIG_BIAS_DISABLE; | ||
707 | + break; | ||
708 | + case 1: | ||
709 | + configs[0] = PIN_CONFIG_BIAS_PULL_DOWN; | ||
710 | + break; | ||
711 | + case 2: | ||
712 | + configs[0] = PIN_CONFIG_BIAS_PULL_UP; | ||
713 | + break; | ||
714 | + default: | ||
715 | + configs[0] = PIN_CONFIG_BIAS_DISABLE; | ||
716 | + dev_err(data->dev, "invalid pull state %d - disabling\n", pull); | ||
717 | + } | ||
718 | |||
719 | map->type = PIN_MAP_TYPE_CONFIGS_PIN; | ||
720 | map->data.configs.group_or_pin = data->groups[group]; | ||
721 | diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c | ||
722 | index 8b8eff051493..1b63d29e44b7 100644 | ||
723 | --- a/fs/btrfs/inode.c | ||
724 | +++ b/fs/btrfs/inode.c | ||
725 | @@ -2613,7 +2613,7 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) | ||
726 | EXTENT_DEFRAG, 1, cached_state); | ||
727 | if (ret) { | ||
728 | u64 last_snapshot = btrfs_root_last_snapshot(&root->root_item); | ||
729 | - if (last_snapshot >= BTRFS_I(inode)->generation) | ||
730 | + if (0 && last_snapshot >= BTRFS_I(inode)->generation) | ||
731 | /* the inode is shared */ | ||
732 | new = record_old_file_extents(inode, ordered_extent); | ||
733 | |||
734 | diff --git a/fs/buffer.c b/fs/buffer.c | ||
735 | index 6024877335ca..aeeea6529bcd 100644 | ||
736 | --- a/fs/buffer.c | ||
737 | +++ b/fs/buffer.c | ||
738 | @@ -654,14 +654,16 @@ EXPORT_SYMBOL(mark_buffer_dirty_inode); | ||
739 | static void __set_page_dirty(struct page *page, | ||
740 | struct address_space *mapping, int warn) | ||
741 | { | ||
742 | - spin_lock_irq(&mapping->tree_lock); | ||
743 | + unsigned long flags; | ||
744 | + | ||
745 | + spin_lock_irqsave(&mapping->tree_lock, flags); | ||
746 | if (page->mapping) { /* Race with truncate? */ | ||
747 | WARN_ON_ONCE(warn && !PageUptodate(page)); | ||
748 | account_page_dirtied(page, mapping); | ||
749 | radix_tree_tag_set(&mapping->page_tree, | ||
750 | page_index(page), PAGECACHE_TAG_DIRTY); | ||
751 | } | ||
752 | - spin_unlock_irq(&mapping->tree_lock); | ||
753 | + spin_unlock_irqrestore(&mapping->tree_lock, flags); | ||
754 | __mark_inode_dirty(mapping->host, I_DIRTY_PAGES); | ||
755 | } | ||
756 | |||
757 | diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c | ||
758 | index 8a572ddde55b..55ebebec4d3b 100644 | ||
759 | --- a/fs/nfs/nfs4client.c | ||
760 | +++ b/fs/nfs/nfs4client.c | ||
761 | @@ -169,7 +169,7 @@ void nfs41_shutdown_client(struct nfs_client *clp) | ||
762 | void nfs40_shutdown_client(struct nfs_client *clp) | ||
763 | { | ||
764 | if (clp->cl_slot_tbl) { | ||
765 | - nfs4_release_slot_table(clp->cl_slot_tbl); | ||
766 | + nfs4_shutdown_slot_table(clp->cl_slot_tbl); | ||
767 | kfree(clp->cl_slot_tbl); | ||
768 | } | ||
769 | } | ||
770 | diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c | ||
771 | index 29c5a2c08f02..d3d7766f55e3 100644 | ||
772 | --- a/fs/nfs/nfs4proc.c | ||
773 | +++ b/fs/nfs/nfs4proc.c | ||
774 | @@ -1611,15 +1611,15 @@ static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata) | ||
775 | { | ||
776 | struct nfs4_opendata *data = calldata; | ||
777 | |||
778 | - nfs40_setup_sequence(data->o_arg.server, &data->o_arg.seq_args, | ||
779 | - &data->o_res.seq_res, task); | ||
780 | + nfs40_setup_sequence(data->o_arg.server, &data->c_arg.seq_args, | ||
781 | + &data->c_res.seq_res, task); | ||
782 | } | ||
783 | |||
784 | static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) | ||
785 | { | ||
786 | struct nfs4_opendata *data = calldata; | ||
787 | |||
788 | - nfs40_sequence_done(task, &data->o_res.seq_res); | ||
789 | + nfs40_sequence_done(task, &data->c_res.seq_res); | ||
790 | |||
791 | data->rpc_status = task->tk_status; | ||
792 | if (data->rpc_status == 0) { | ||
793 | @@ -1677,7 +1677,7 @@ static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) | ||
794 | }; | ||
795 | int status; | ||
796 | |||
797 | - nfs4_init_sequence(&data->o_arg.seq_args, &data->o_res.seq_res, 1); | ||
798 | + nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1); | ||
799 | kref_get(&data->kref); | ||
800 | data->rpc_done = 0; | ||
801 | data->rpc_status = 0; | ||
802 | diff --git a/fs/nfs/nfs4session.c b/fs/nfs/nfs4session.c | ||
803 | index cf883c7ae053..e799dc3c3b1d 100644 | ||
804 | --- a/fs/nfs/nfs4session.c | ||
805 | +++ b/fs/nfs/nfs4session.c | ||
806 | @@ -231,14 +231,23 @@ out: | ||
807 | return ret; | ||
808 | } | ||
809 | |||
810 | +/* | ||
811 | + * nfs4_release_slot_table - release all slot table entries | ||
812 | + */ | ||
813 | +static void nfs4_release_slot_table(struct nfs4_slot_table *tbl) | ||
814 | +{ | ||
815 | + nfs4_shrink_slot_table(tbl, 0); | ||
816 | +} | ||
817 | + | ||
818 | /** | ||
819 | - * nfs4_release_slot_table - release resources attached to a slot table | ||
820 | + * nfs4_shutdown_slot_table - release resources attached to a slot table | ||
821 | * @tbl: slot table to shut down | ||
822 | * | ||
823 | */ | ||
824 | -void nfs4_release_slot_table(struct nfs4_slot_table *tbl) | ||
825 | +void nfs4_shutdown_slot_table(struct nfs4_slot_table *tbl) | ||
826 | { | ||
827 | - nfs4_shrink_slot_table(tbl, 0); | ||
828 | + nfs4_release_slot_table(tbl); | ||
829 | + rpc_destroy_wait_queue(&tbl->slot_tbl_waitq); | ||
830 | } | ||
831 | |||
832 | /** | ||
833 | @@ -422,7 +431,7 @@ void nfs41_update_target_slotid(struct nfs4_slot_table *tbl, | ||
834 | spin_unlock(&tbl->slot_tbl_lock); | ||
835 | } | ||
836 | |||
837 | -static void nfs4_destroy_session_slot_tables(struct nfs4_session *session) | ||
838 | +static void nfs4_release_session_slot_tables(struct nfs4_session *session) | ||
839 | { | ||
840 | nfs4_release_slot_table(&session->fc_slot_table); | ||
841 | nfs4_release_slot_table(&session->bc_slot_table); | ||
842 | @@ -450,7 +459,7 @@ int nfs4_setup_session_slot_tables(struct nfs4_session *ses) | ||
843 | if (status && tbl->slots == NULL) | ||
844 | /* Fore and back channel share a connection so get | ||
845 | * both slot tables or neither */ | ||
846 | - nfs4_destroy_session_slot_tables(ses); | ||
847 | + nfs4_release_session_slot_tables(ses); | ||
848 | return status; | ||
849 | } | ||
850 | |||
851 | @@ -470,6 +479,12 @@ struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp) | ||
852 | return session; | ||
853 | } | ||
854 | |||
855 | +static void nfs4_destroy_session_slot_tables(struct nfs4_session *session) | ||
856 | +{ | ||
857 | + nfs4_shutdown_slot_table(&session->fc_slot_table); | ||
858 | + nfs4_shutdown_slot_table(&session->bc_slot_table); | ||
859 | +} | ||
860 | + | ||
861 | void nfs4_destroy_session(struct nfs4_session *session) | ||
862 | { | ||
863 | struct rpc_xprt *xprt; | ||
864 | diff --git a/fs/nfs/nfs4session.h b/fs/nfs/nfs4session.h | ||
865 | index 232306100651..b34ada9bc6a2 100644 | ||
866 | --- a/fs/nfs/nfs4session.h | ||
867 | +++ b/fs/nfs/nfs4session.h | ||
868 | @@ -74,7 +74,7 @@ enum nfs4_session_state { | ||
869 | |||
870 | extern int nfs4_setup_slot_table(struct nfs4_slot_table *tbl, | ||
871 | unsigned int max_reqs, const char *queue); | ||
872 | -extern void nfs4_release_slot_table(struct nfs4_slot_table *tbl); | ||
873 | +extern void nfs4_shutdown_slot_table(struct nfs4_slot_table *tbl); | ||
874 | extern struct nfs4_slot *nfs4_alloc_slot(struct nfs4_slot_table *tbl); | ||
875 | extern void nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot); | ||
876 | extern void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl); | ||
877 | diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h | ||
878 | index 49f52c8f4422..ea9e076a91bf 100644 | ||
879 | --- a/include/linux/nfs_xdr.h | ||
880 | +++ b/include/linux/nfs_xdr.h | ||
881 | @@ -379,12 +379,14 @@ struct nfs_openres { | ||
882 | * Arguments to the open_confirm call. | ||
883 | */ | ||
884 | struct nfs_open_confirmargs { | ||
885 | + struct nfs4_sequence_args seq_args; | ||
886 | const struct nfs_fh * fh; | ||
887 | nfs4_stateid * stateid; | ||
888 | struct nfs_seqid * seqid; | ||
889 | }; | ||
890 | |||
891 | struct nfs_open_confirmres { | ||
892 | + struct nfs4_sequence_res seq_res; | ||
893 | nfs4_stateid stateid; | ||
894 | struct nfs_seqid * seqid; | ||
895 | }; | ||
896 | diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig | ||
897 | index 4a1fef09f658..07cbdfea9ae2 100644 | ||
898 | --- a/kernel/irq/Kconfig | ||
899 | +++ b/kernel/irq/Kconfig | ||
900 | @@ -40,6 +40,7 @@ config IRQ_EDGE_EOI_HANDLER | ||
901 | # Generic configurable interrupt chip implementation | ||
902 | config GENERIC_IRQ_CHIP | ||
903 | bool | ||
904 | + select IRQ_DOMAIN | ||
905 | |||
906 | # Generic irq_domain hw <--> linux irq number translation | ||
907 | config IRQ_DOMAIN | ||
908 | diff --git a/lib/Makefile b/lib/Makefile | ||
909 | index f3bb2cb98adf..6af6fbb053e3 100644 | ||
910 | --- a/lib/Makefile | ||
911 | +++ b/lib/Makefile | ||
912 | @@ -47,6 +47,7 @@ lib-$(CONFIG_RWSEM_GENERIC_SPINLOCK) += rwsem-spinlock.o | ||
913 | lib-$(CONFIG_RWSEM_XCHGADD_ALGORITHM) += rwsem.o | ||
914 | lib-$(CONFIG_PERCPU_RWSEM) += percpu-rwsem.o | ||
915 | |||
916 | +GCOV_PROFILE_hweight.o := n | ||
917 | CFLAGS_hweight.o = $(subst $(quote),,$(CONFIG_ARCH_HWEIGHT_CFLAGS)) | ||
918 | obj-$(CONFIG_GENERIC_HWEIGHT) += hweight.o | ||
919 | |||
920 | diff --git a/mm/page-writeback.c b/mm/page-writeback.c | ||
921 | index 2d30e2cfe804..7106cb1aca8e 100644 | ||
922 | --- a/mm/page-writeback.c | ||
923 | +++ b/mm/page-writeback.c | ||
924 | @@ -2173,11 +2173,12 @@ int __set_page_dirty_nobuffers(struct page *page) | ||
925 | if (!TestSetPageDirty(page)) { | ||
926 | struct address_space *mapping = page_mapping(page); | ||
927 | struct address_space *mapping2; | ||
928 | + unsigned long flags; | ||
929 | |||
930 | if (!mapping) | ||
931 | return 1; | ||
932 | |||
933 | - spin_lock_irq(&mapping->tree_lock); | ||
934 | + spin_lock_irqsave(&mapping->tree_lock, flags); | ||
935 | mapping2 = page_mapping(page); | ||
936 | if (mapping2) { /* Race with truncate? */ | ||
937 | BUG_ON(mapping2 != mapping); | ||
938 | @@ -2186,7 +2187,7 @@ int __set_page_dirty_nobuffers(struct page *page) | ||
939 | radix_tree_tag_set(&mapping->page_tree, | ||
940 | page_index(page), PAGECACHE_TAG_DIRTY); | ||
941 | } | ||
942 | - spin_unlock_irq(&mapping->tree_lock); | ||
943 | + spin_unlock_irqrestore(&mapping->tree_lock, flags); | ||
944 | if (mapping->host) { | ||
945 | /* !PageAnon && !swapper_space */ | ||
946 | __mark_inode_dirty(mapping->host, I_DIRTY_PAGES); | ||
947 | diff --git a/mm/swapfile.c b/mm/swapfile.c | ||
948 | index de7c904e52e5..0ec2eaf3ccfd 100644 | ||
949 | --- a/mm/swapfile.c | ||
950 | +++ b/mm/swapfile.c | ||
951 | @@ -1922,7 +1922,6 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile) | ||
952 | p->swap_map = NULL; | ||
953 | cluster_info = p->cluster_info; | ||
954 | p->cluster_info = NULL; | ||
955 | - p->flags = 0; | ||
956 | frontswap_map = frontswap_map_get(p); | ||
957 | frontswap_map_set(p, NULL); | ||
958 | spin_unlock(&p->lock); | ||
959 | @@ -1948,6 +1947,16 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile) | ||
960 | mutex_unlock(&inode->i_mutex); | ||
961 | } | ||
962 | filp_close(swap_file, NULL); | ||
963 | + | ||
964 | + /* | ||
965 | + * Clear the SWP_USED flag after all resources are freed so that swapon | ||
966 | + * can reuse this swap_info in alloc_swap_info() safely. It is ok to | ||
967 | + * not hold p->lock after we cleared its SWP_WRITEOK. | ||
968 | + */ | ||
969 | + spin_lock(&swap_lock); | ||
970 | + p->flags = 0; | ||
971 | + spin_unlock(&swap_lock); | ||
972 | + | ||
973 | err = 0; | ||
974 | atomic_inc(&proc_poll_event); | ||
975 | wake_up_interruptible(&proc_poll_wait); | ||
976 | diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c | ||
977 | index b4feecc3fe01..18caa16de27b 100644 | ||
978 | --- a/security/selinux/ss/services.c | ||
979 | +++ b/security/selinux/ss/services.c | ||
980 | @@ -1231,6 +1231,10 @@ static int security_context_to_sid_core(const char *scontext, u32 scontext_len, | ||
981 | struct context context; | ||
982 | int rc = 0; | ||
983 | |||
984 | + /* An empty security context is never valid. */ | ||
985 | + if (!scontext_len) | ||
986 | + return -EINVAL; | ||
987 | + | ||
988 | if (!ss_initialized) { | ||
989 | int i; | ||
990 | |||
991 | diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c | ||
992 | index 31230c68b603..7fc15814c618 100644 | ||
993 | --- a/sound/pci/hda/patch_analog.c | ||
994 | +++ b/sound/pci/hda/patch_analog.c | ||
995 | @@ -227,6 +227,19 @@ static void ad_fixup_inv_jack_detect(struct hda_codec *codec, | ||
996 | } | ||
997 | } | ||
998 | |||
999 | +/* Toshiba Satellite L40 implements EAPD in a standard way unlike others */ | ||
1000 | +static void ad1986a_fixup_eapd(struct hda_codec *codec, | ||
1001 | + const struct hda_fixup *fix, int action) | ||
1002 | +{ | ||
1003 | + struct ad198x_spec *spec = codec->spec; | ||
1004 | + | ||
1005 | + if (action == HDA_FIXUP_ACT_PRE_PROBE) { | ||
1006 | + codec->inv_eapd = 0; | ||
1007 | + spec->gen.keep_eapd_on = 1; | ||
1008 | + spec->eapd_nid = 0x1b; | ||
1009 | + } | ||
1010 | +} | ||
1011 | + | ||
1012 | enum { | ||
1013 | AD1986A_FIXUP_INV_JACK_DETECT, | ||
1014 | AD1986A_FIXUP_ULTRA, | ||
1015 | @@ -234,6 +247,7 @@ enum { | ||
1016 | AD1986A_FIXUP_3STACK, | ||
1017 | AD1986A_FIXUP_LAPTOP, | ||
1018 | AD1986A_FIXUP_LAPTOP_IMIC, | ||
1019 | + AD1986A_FIXUP_EAPD, | ||
1020 | }; | ||
1021 | |||
1022 | static const struct hda_fixup ad1986a_fixups[] = { | ||
1023 | @@ -294,6 +308,10 @@ static const struct hda_fixup ad1986a_fixups[] = { | ||
1024 | .chained_before = 1, | ||
1025 | .chain_id = AD1986A_FIXUP_LAPTOP, | ||
1026 | }, | ||
1027 | + [AD1986A_FIXUP_EAPD] = { | ||
1028 | + .type = HDA_FIXUP_FUNC, | ||
1029 | + .v.func = ad1986a_fixup_eapd, | ||
1030 | + }, | ||
1031 | }; | ||
1032 | |||
1033 | static const struct snd_pci_quirk ad1986a_fixup_tbl[] = { | ||
1034 | @@ -301,6 +319,7 @@ static const struct snd_pci_quirk ad1986a_fixup_tbl[] = { | ||
1035 | SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8100, "ASUS P5", AD1986A_FIXUP_3STACK), | ||
1036 | SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8200, "ASUS M2", AD1986A_FIXUP_3STACK), | ||
1037 | SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_FIXUP_3STACK), | ||
1038 | + SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40", AD1986A_FIXUP_EAPD), | ||
1039 | SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_FIXUP_LAPTOP), | ||
1040 | SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_FIXUP_SAMSUNG), | ||
1041 | SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_FIXUP_ULTRA), | ||
1042 | @@ -455,6 +474,8 @@ static int ad1983_add_spdif_mux_ctl(struct hda_codec *codec) | ||
1043 | static int patch_ad1983(struct hda_codec *codec) | ||
1044 | { | ||
1045 | struct ad198x_spec *spec; | ||
1046 | + static hda_nid_t conn_0c[] = { 0x08 }; | ||
1047 | + static hda_nid_t conn_0d[] = { 0x09 }; | ||
1048 | int err; | ||
1049 | |||
1050 | err = alloc_ad_spec(codec); | ||
1051 | @@ -462,8 +483,14 @@ static int patch_ad1983(struct hda_codec *codec) | ||
1052 | return err; | ||
1053 | spec = codec->spec; | ||
1054 | |||
1055 | + spec->gen.mixer_nid = 0x0e; | ||
1056 | spec->gen.beep_nid = 0x10; | ||
1057 | set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); | ||
1058 | + | ||
1059 | + /* limit the loopback routes not to confuse the parser */ | ||
1060 | + snd_hda_override_conn_list(codec, 0x0c, ARRAY_SIZE(conn_0c), conn_0c); | ||
1061 | + snd_hda_override_conn_list(codec, 0x0d, ARRAY_SIZE(conn_0d), conn_0d); | ||
1062 | + | ||
1063 | err = ad198x_parse_auto_config(codec, false); | ||
1064 | if (err < 0) | ||
1065 | goto error; | ||
1066 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
1067 | index 56b62555eef4..6195a4f8d9b8 100644 | ||
1068 | --- a/sound/pci/hda/patch_realtek.c | ||
1069 | +++ b/sound/pci/hda/patch_realtek.c | ||
1070 | @@ -1771,6 +1771,7 @@ enum { | ||
1071 | ALC889_FIXUP_IMAC91_VREF, | ||
1072 | ALC889_FIXUP_MBA11_VREF, | ||
1073 | ALC889_FIXUP_MBA21_VREF, | ||
1074 | + ALC889_FIXUP_MP11_VREF, | ||
1075 | ALC882_FIXUP_INV_DMIC, | ||
1076 | ALC882_FIXUP_NO_PRIMARY_HP, | ||
1077 | ALC887_FIXUP_ASUS_BASS, | ||
1078 | @@ -2127,6 +2128,12 @@ static const struct hda_fixup alc882_fixups[] = { | ||
1079 | .chained = true, | ||
1080 | .chain_id = ALC889_FIXUP_MBP_VREF, | ||
1081 | }, | ||
1082 | + [ALC889_FIXUP_MP11_VREF] = { | ||
1083 | + .type = HDA_FIXUP_FUNC, | ||
1084 | + .v.func = alc889_fixup_mba11_vref, | ||
1085 | + .chained = true, | ||
1086 | + .chain_id = ALC885_FIXUP_MACPRO_GPIO, | ||
1087 | + }, | ||
1088 | [ALC882_FIXUP_INV_DMIC] = { | ||
1089 | .type = HDA_FIXUP_FUNC, | ||
1090 | .v.func = alc_fixup_inv_dmic_0x12, | ||
1091 | @@ -2184,7 +2191,7 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { | ||
1092 | SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), | ||
1093 | SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF), | ||
1094 | SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), | ||
1095 | - SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO), | ||
1096 | + SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF), | ||
1097 | SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO), | ||
1098 | SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO), | ||
1099 | SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF), | ||
1100 | diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig | ||
1101 | index de9408b83f75..e05a86b7c0da 100644 | ||
1102 | --- a/sound/usb/Kconfig | ||
1103 | +++ b/sound/usb/Kconfig | ||
1104 | @@ -14,6 +14,7 @@ config SND_USB_AUDIO | ||
1105 | select SND_HWDEP | ||
1106 | select SND_RAWMIDI | ||
1107 | select SND_PCM | ||
1108 | + select BITREVERSE | ||
1109 | help | ||
1110 | Say Y here to include support for USB audio and USB MIDI | ||
1111 | devices. |