Annotation of /trunk/kernel-alx/patches-4.4/0126-4.4.27-all-fixes.patch
Parent Directory | Revision Log
Revision 2862 -
(hide annotations)
(download)
Mon Mar 27 13:49:07 2017 UTC (7 years, 6 months ago) by niro
File size: 30650 byte(s)
Mon Mar 27 13:49:07 2017 UTC (7 years, 6 months ago) by niro
File size: 30650 byte(s)
linux-4.4.27
1 | niro | 2862 | diff --git a/Makefile b/Makefile |
2 | index a127b9ef9ebc..b6ee4ce561f8 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,6 +1,6 @@ | ||
6 | VERSION = 4 | ||
7 | PATCHLEVEL = 4 | ||
8 | -SUBLEVEL = 26 | ||
9 | +SUBLEVEL = 27 | ||
10 | EXTRAVERSION = | ||
11 | NAME = Blurry Fish Butt | ||
12 | |||
13 | diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c | ||
14 | index 1f9093e901da..3ad307ee6029 100644 | ||
15 | --- a/block/cfq-iosched.c | ||
16 | +++ b/block/cfq-iosched.c | ||
17 | @@ -3003,7 +3003,6 @@ static struct request *cfq_check_fifo(struct cfq_queue *cfqq) | ||
18 | if (time_before(jiffies, rq->fifo_time)) | ||
19 | rq = NULL; | ||
20 | |||
21 | - cfq_log_cfqq(cfqq->cfqd, cfqq, "fifo=%p", rq); | ||
22 | return rq; | ||
23 | } | ||
24 | |||
25 | @@ -3377,6 +3376,9 @@ static bool cfq_may_dispatch(struct cfq_data *cfqd, struct cfq_queue *cfqq) | ||
26 | { | ||
27 | unsigned int max_dispatch; | ||
28 | |||
29 | + if (cfq_cfqq_must_dispatch(cfqq)) | ||
30 | + return true; | ||
31 | + | ||
32 | /* | ||
33 | * Drain async requests before we start sync IO | ||
34 | */ | ||
35 | @@ -3468,15 +3470,20 @@ static bool cfq_dispatch_request(struct cfq_data *cfqd, struct cfq_queue *cfqq) | ||
36 | |||
37 | BUG_ON(RB_EMPTY_ROOT(&cfqq->sort_list)); | ||
38 | |||
39 | + rq = cfq_check_fifo(cfqq); | ||
40 | + if (rq) | ||
41 | + cfq_mark_cfqq_must_dispatch(cfqq); | ||
42 | + | ||
43 | if (!cfq_may_dispatch(cfqd, cfqq)) | ||
44 | return false; | ||
45 | |||
46 | /* | ||
47 | * follow expired path, else get first next available | ||
48 | */ | ||
49 | - rq = cfq_check_fifo(cfqq); | ||
50 | if (!rq) | ||
51 | rq = cfqq->next_rq; | ||
52 | + else | ||
53 | + cfq_log_cfqq(cfqq->cfqd, cfqq, "fifo=%p", rq); | ||
54 | |||
55 | /* | ||
56 | * insert request into driver dispatch list | ||
57 | @@ -3944,7 +3951,7 @@ cfq_should_preempt(struct cfq_data *cfqd, struct cfq_queue *new_cfqq, | ||
58 | * if the new request is sync, but the currently running queue is | ||
59 | * not, let the sync request have priority. | ||
60 | */ | ||
61 | - if (rq_is_sync(rq) && !cfq_cfqq_sync(cfqq)) | ||
62 | + if (rq_is_sync(rq) && !cfq_cfqq_sync(cfqq) && !cfq_cfqq_must_dispatch(cfqq)) | ||
63 | return true; | ||
64 | |||
65 | if (new_cfqq->cfqg != cfqq->cfqg) | ||
66 | diff --git a/crypto/async_tx/async_pq.c b/crypto/async_tx/async_pq.c | ||
67 | index c0748bbd4c08..84f8d4d8b6bc 100644 | ||
68 | --- a/crypto/async_tx/async_pq.c | ||
69 | +++ b/crypto/async_tx/async_pq.c | ||
70 | @@ -368,8 +368,6 @@ async_syndrome_val(struct page **blocks, unsigned int offset, int disks, | ||
71 | |||
72 | dma_set_unmap(tx, unmap); | ||
73 | async_tx_submit(chan, tx, submit); | ||
74 | - | ||
75 | - return tx; | ||
76 | } else { | ||
77 | struct page *p_src = P(blocks, disks); | ||
78 | struct page *q_src = Q(blocks, disks); | ||
79 | @@ -424,9 +422,11 @@ async_syndrome_val(struct page **blocks, unsigned int offset, int disks, | ||
80 | submit->cb_param = cb_param_orig; | ||
81 | submit->flags = flags_orig; | ||
82 | async_tx_sync_epilog(submit); | ||
83 | - | ||
84 | - return NULL; | ||
85 | + tx = NULL; | ||
86 | } | ||
87 | + dmaengine_unmap_put(unmap); | ||
88 | + | ||
89 | + return tx; | ||
90 | } | ||
91 | EXPORT_SYMBOL_GPL(async_syndrome_val); | ||
92 | |||
93 | diff --git a/crypto/ghash-generic.c b/crypto/ghash-generic.c | ||
94 | index bac70995e064..12ad3e3a84e3 100644 | ||
95 | --- a/crypto/ghash-generic.c | ||
96 | +++ b/crypto/ghash-generic.c | ||
97 | @@ -14,24 +14,13 @@ | ||
98 | |||
99 | #include <crypto/algapi.h> | ||
100 | #include <crypto/gf128mul.h> | ||
101 | +#include <crypto/ghash.h> | ||
102 | #include <crypto/internal/hash.h> | ||
103 | #include <linux/crypto.h> | ||
104 | #include <linux/init.h> | ||
105 | #include <linux/kernel.h> | ||
106 | #include <linux/module.h> | ||
107 | |||
108 | -#define GHASH_BLOCK_SIZE 16 | ||
109 | -#define GHASH_DIGEST_SIZE 16 | ||
110 | - | ||
111 | -struct ghash_ctx { | ||
112 | - struct gf128mul_4k *gf128; | ||
113 | -}; | ||
114 | - | ||
115 | -struct ghash_desc_ctx { | ||
116 | - u8 buffer[GHASH_BLOCK_SIZE]; | ||
117 | - u32 bytes; | ||
118 | -}; | ||
119 | - | ||
120 | static int ghash_init(struct shash_desc *desc) | ||
121 | { | ||
122 | struct ghash_desc_ctx *dctx = shash_desc_ctx(desc); | ||
123 | diff --git a/drivers/base/dma-mapping.c b/drivers/base/dma-mapping.c | ||
124 | index d95c5971c225..a00f7b79202b 100644 | ||
125 | --- a/drivers/base/dma-mapping.c | ||
126 | +++ b/drivers/base/dma-mapping.c | ||
127 | @@ -335,7 +335,7 @@ void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags) | ||
128 | return; | ||
129 | } | ||
130 | |||
131 | - unmap_kernel_range((unsigned long)cpu_addr, size); | ||
132 | + unmap_kernel_range((unsigned long)cpu_addr, PAGE_ALIGN(size)); | ||
133 | vunmap(cpu_addr); | ||
134 | } | ||
135 | #endif | ||
136 | diff --git a/drivers/crypto/vmx/ghash.c b/drivers/crypto/vmx/ghash.c | ||
137 | index 2183a2e77641..9cb3a0b715e2 100644 | ||
138 | --- a/drivers/crypto/vmx/ghash.c | ||
139 | +++ b/drivers/crypto/vmx/ghash.c | ||
140 | @@ -26,16 +26,13 @@ | ||
141 | #include <linux/hardirq.h> | ||
142 | #include <asm/switch_to.h> | ||
143 | #include <crypto/aes.h> | ||
144 | +#include <crypto/ghash.h> | ||
145 | #include <crypto/scatterwalk.h> | ||
146 | #include <crypto/internal/hash.h> | ||
147 | #include <crypto/b128ops.h> | ||
148 | |||
149 | #define IN_INTERRUPT in_interrupt() | ||
150 | |||
151 | -#define GHASH_BLOCK_SIZE (16) | ||
152 | -#define GHASH_DIGEST_SIZE (16) | ||
153 | -#define GHASH_KEY_LEN (16) | ||
154 | - | ||
155 | void gcm_init_p8(u128 htable[16], const u64 Xi[2]); | ||
156 | void gcm_gmult_p8(u64 Xi[2], const u128 htable[16]); | ||
157 | void gcm_ghash_p8(u64 Xi[2], const u128 htable[16], | ||
158 | @@ -55,16 +52,11 @@ struct p8_ghash_desc_ctx { | ||
159 | |||
160 | static int p8_ghash_init_tfm(struct crypto_tfm *tfm) | ||
161 | { | ||
162 | - const char *alg; | ||
163 | + const char *alg = "ghash-generic"; | ||
164 | struct crypto_shash *fallback; | ||
165 | struct crypto_shash *shash_tfm = __crypto_shash_cast(tfm); | ||
166 | struct p8_ghash_ctx *ctx = crypto_tfm_ctx(tfm); | ||
167 | |||
168 | - if (!(alg = crypto_tfm_alg_name(tfm))) { | ||
169 | - printk(KERN_ERR "Failed to get algorithm name.\n"); | ||
170 | - return -ENOENT; | ||
171 | - } | ||
172 | - | ||
173 | fallback = crypto_alloc_shash(alg, 0, CRYPTO_ALG_NEED_FALLBACK); | ||
174 | if (IS_ERR(fallback)) { | ||
175 | printk(KERN_ERR | ||
176 | @@ -78,10 +70,18 @@ static int p8_ghash_init_tfm(struct crypto_tfm *tfm) | ||
177 | crypto_shash_set_flags(fallback, | ||
178 | crypto_shash_get_flags((struct crypto_shash | ||
179 | *) tfm)); | ||
180 | - ctx->fallback = fallback; | ||
181 | |||
182 | - shash_tfm->descsize = sizeof(struct p8_ghash_desc_ctx) | ||
183 | - + crypto_shash_descsize(fallback); | ||
184 | + /* Check if the descsize defined in the algorithm is still enough. */ | ||
185 | + if (shash_tfm->descsize < sizeof(struct p8_ghash_desc_ctx) | ||
186 | + + crypto_shash_descsize(fallback)) { | ||
187 | + printk(KERN_ERR | ||
188 | + "Desc size of the fallback implementation (%s) does not match the expected value: %lu vs %u\n", | ||
189 | + alg, | ||
190 | + shash_tfm->descsize - sizeof(struct p8_ghash_desc_ctx), | ||
191 | + crypto_shash_descsize(fallback)); | ||
192 | + return -EINVAL; | ||
193 | + } | ||
194 | + ctx->fallback = fallback; | ||
195 | |||
196 | return 0; | ||
197 | } | ||
198 | @@ -113,7 +113,7 @@ static int p8_ghash_setkey(struct crypto_shash *tfm, const u8 *key, | ||
199 | { | ||
200 | struct p8_ghash_ctx *ctx = crypto_tfm_ctx(crypto_shash_tfm(tfm)); | ||
201 | |||
202 | - if (keylen != GHASH_KEY_LEN) | ||
203 | + if (keylen != GHASH_BLOCK_SIZE) | ||
204 | return -EINVAL; | ||
205 | |||
206 | preempt_disable(); | ||
207 | @@ -215,7 +215,8 @@ struct shash_alg p8_ghash_alg = { | ||
208 | .update = p8_ghash_update, | ||
209 | .final = p8_ghash_final, | ||
210 | .setkey = p8_ghash_setkey, | ||
211 | - .descsize = sizeof(struct p8_ghash_desc_ctx), | ||
212 | + .descsize = sizeof(struct p8_ghash_desc_ctx) | ||
213 | + + sizeof(struct ghash_desc_ctx), | ||
214 | .base = { | ||
215 | .cra_name = "ghash", | ||
216 | .cra_driver_name = "p8_ghash", | ||
217 | diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c | ||
218 | index 2215bebe208e..979cc024bca7 100644 | ||
219 | --- a/drivers/net/ethernet/intel/i40e/i40e_main.c | ||
220 | +++ b/drivers/net/ethernet/intel/i40e/i40e_main.c | ||
221 | @@ -10853,6 +10853,12 @@ static pci_ers_result_t i40e_pci_error_detected(struct pci_dev *pdev, | ||
222 | |||
223 | dev_info(&pdev->dev, "%s: error %d\n", __func__, error); | ||
224 | |||
225 | + if (!pf) { | ||
226 | + dev_info(&pdev->dev, | ||
227 | + "Cannot recover - error happened during device probe\n"); | ||
228 | + return PCI_ERS_RESULT_DISCONNECT; | ||
229 | + } | ||
230 | + | ||
231 | /* shutdown all operations */ | ||
232 | if (!test_bit(__I40E_SUSPENDED, &pf->state)) { | ||
233 | rtnl_lock(); | ||
234 | diff --git a/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c b/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c | ||
235 | index deb5f78dcacc..71493d2af912 100644 | ||
236 | --- a/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c | ||
237 | +++ b/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c | ||
238 | @@ -2408,7 +2408,7 @@ static void brcmf_fill_bss_param(struct brcmf_if *ifp, struct station_info *si) | ||
239 | WL_BSS_INFO_MAX); | ||
240 | if (err) { | ||
241 | brcmf_err("Failed to get bss info (%d)\n", err); | ||
242 | - return; | ||
243 | + goto out_kfree; | ||
244 | } | ||
245 | si->filled |= BIT(NL80211_STA_INFO_BSS_PARAM); | ||
246 | si->bss_param.beacon_interval = le16_to_cpu(buf->bss_le.beacon_period); | ||
247 | @@ -2420,6 +2420,9 @@ static void brcmf_fill_bss_param(struct brcmf_if *ifp, struct station_info *si) | ||
248 | si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE; | ||
249 | if (capability & WLAN_CAPABILITY_SHORT_SLOT_TIME) | ||
250 | si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME; | ||
251 | + | ||
252 | +out_kfree: | ||
253 | + kfree(buf); | ||
254 | } | ||
255 | |||
256 | static s32 | ||
257 | diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c | ||
258 | index 41f9a00e4f74..8db9f3a5844d 100644 | ||
259 | --- a/drivers/scsi/arcmsr/arcmsr_hba.c | ||
260 | +++ b/drivers/scsi/arcmsr/arcmsr_hba.c | ||
261 | @@ -2297,15 +2297,23 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, | ||
262 | } | ||
263 | case ARCMSR_MESSAGE_WRITE_WQBUFFER: { | ||
264 | unsigned char *ver_addr; | ||
265 | - int32_t user_len, cnt2end; | ||
266 | + uint32_t user_len; | ||
267 | + int32_t cnt2end; | ||
268 | uint8_t *pQbuffer, *ptmpuserbuffer; | ||
269 | + | ||
270 | + user_len = pcmdmessagefld->cmdmessage.Length; | ||
271 | + if (user_len > ARCMSR_API_DATA_BUFLEN) { | ||
272 | + retvalue = ARCMSR_MESSAGE_FAIL; | ||
273 | + goto message_out; | ||
274 | + } | ||
275 | + | ||
276 | ver_addr = kmalloc(ARCMSR_API_DATA_BUFLEN, GFP_ATOMIC); | ||
277 | if (!ver_addr) { | ||
278 | retvalue = ARCMSR_MESSAGE_FAIL; | ||
279 | goto message_out; | ||
280 | } | ||
281 | ptmpuserbuffer = ver_addr; | ||
282 | - user_len = pcmdmessagefld->cmdmessage.Length; | ||
283 | + | ||
284 | memcpy(ptmpuserbuffer, | ||
285 | pcmdmessagefld->messagedatabuffer, user_len); | ||
286 | spin_lock_irqsave(&acb->wqbuffer_lock, flags); | ||
287 | diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c | ||
288 | index 6aa317c303e2..1f9f9e5af207 100644 | ||
289 | --- a/drivers/scsi/ibmvscsi/ibmvfc.c | ||
290 | +++ b/drivers/scsi/ibmvscsi/ibmvfc.c | ||
291 | @@ -717,7 +717,6 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost) | ||
292 | spin_lock_irqsave(vhost->host->host_lock, flags); | ||
293 | vhost->state = IBMVFC_NO_CRQ; | ||
294 | vhost->logged_in = 0; | ||
295 | - ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE); | ||
296 | |||
297 | /* Clean out the queue */ | ||
298 | memset(crq->msgs, 0, PAGE_SIZE); | ||
299 | diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c | ||
300 | index a5d319e4aae6..8435c3f204c1 100644 | ||
301 | --- a/drivers/tty/serial/8250/8250_dw.c | ||
302 | +++ b/drivers/tty/serial/8250/8250_dw.c | ||
303 | @@ -440,7 +440,7 @@ static int dw8250_probe(struct platform_device *pdev) | ||
304 | } | ||
305 | |||
306 | data->pclk = devm_clk_get(&pdev->dev, "apb_pclk"); | ||
307 | - if (IS_ERR(data->clk) && PTR_ERR(data->clk) == -EPROBE_DEFER) { | ||
308 | + if (IS_ERR(data->pclk) && PTR_ERR(data->pclk) == -EPROBE_DEFER) { | ||
309 | err = -EPROBE_DEFER; | ||
310 | goto err_clk; | ||
311 | } | ||
312 | diff --git a/fs/attr.c b/fs/attr.c | ||
313 | index 6530ced19697..d62f674a605f 100644 | ||
314 | --- a/fs/attr.c | ||
315 | +++ b/fs/attr.c | ||
316 | @@ -202,6 +202,21 @@ int notify_change(struct dentry * dentry, struct iattr * attr, struct inode **de | ||
317 | return -EPERM; | ||
318 | } | ||
319 | |||
320 | + /* | ||
321 | + * If utimes(2) and friends are called with times == NULL (or both | ||
322 | + * times are UTIME_NOW), then we need to check for write permission | ||
323 | + */ | ||
324 | + if (ia_valid & ATTR_TOUCH) { | ||
325 | + if (IS_IMMUTABLE(inode)) | ||
326 | + return -EPERM; | ||
327 | + | ||
328 | + if (!inode_owner_or_capable(inode)) { | ||
329 | + error = inode_permission(inode, MAY_WRITE); | ||
330 | + if (error) | ||
331 | + return error; | ||
332 | + } | ||
333 | + } | ||
334 | + | ||
335 | if ((ia_valid & ATTR_MODE)) { | ||
336 | umode_t amode = attr->ia_mode; | ||
337 | /* Flag setting protected by i_mutex */ | ||
338 | diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c | ||
339 | index c473c42d7d6c..bae05c5c75ba 100644 | ||
340 | --- a/fs/btrfs/compression.c | ||
341 | +++ b/fs/btrfs/compression.c | ||
342 | @@ -694,7 +694,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, | ||
343 | ret = btrfs_map_bio(root, READ, comp_bio, | ||
344 | mirror_num, 0); | ||
345 | if (ret) { | ||
346 | - bio->bi_error = ret; | ||
347 | + comp_bio->bi_error = ret; | ||
348 | bio_endio(comp_bio); | ||
349 | } | ||
350 | |||
351 | @@ -723,7 +723,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, | ||
352 | |||
353 | ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0); | ||
354 | if (ret) { | ||
355 | - bio->bi_error = ret; | ||
356 | + comp_bio->bi_error = ret; | ||
357 | bio_endio(comp_bio); | ||
358 | } | ||
359 | |||
360 | diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c | ||
361 | index 3a37bd3f9637..9d7a4a714907 100644 | ||
362 | --- a/fs/dlm/lowcomms.c | ||
363 | +++ b/fs/dlm/lowcomms.c | ||
364 | @@ -1607,16 +1607,12 @@ void dlm_lowcomms_stop(void) | ||
365 | mutex_lock(&connections_lock); | ||
366 | dlm_allow_conn = 0; | ||
367 | foreach_conn(stop_conn); | ||
368 | + clean_writequeues(); | ||
369 | + foreach_conn(free_conn); | ||
370 | mutex_unlock(&connections_lock); | ||
371 | |||
372 | work_stop(); | ||
373 | |||
374 | - mutex_lock(&connections_lock); | ||
375 | - clean_writequeues(); | ||
376 | - | ||
377 | - foreach_conn(free_conn); | ||
378 | - | ||
379 | - mutex_unlock(&connections_lock); | ||
380 | kmem_cache_destroy(con_cache); | ||
381 | } | ||
382 | |||
383 | diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c | ||
384 | index 8eac7d586997..9da42ace762a 100644 | ||
385 | --- a/fs/ext4/extents.c | ||
386 | +++ b/fs/ext4/extents.c | ||
387 | @@ -5738,6 +5738,9 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len) | ||
388 | up_write(&EXT4_I(inode)->i_data_sem); | ||
389 | goto out_stop; | ||
390 | } | ||
391 | + } else { | ||
392 | + ext4_ext_drop_refs(path); | ||
393 | + kfree(path); | ||
394 | } | ||
395 | |||
396 | ret = ext4_es_remove_extent(inode, offset_lblk, | ||
397 | diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c | ||
398 | index 28702932a908..c71d2941a45b 100644 | ||
399 | --- a/fs/ext4/inode.c | ||
400 | +++ b/fs/ext4/inode.c | ||
401 | @@ -3645,7 +3645,7 @@ int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset, | ||
402 | } | ||
403 | |||
404 | /* | ||
405 | - * ext4_punch_hole: punches a hole in a file by releaseing the blocks | ||
406 | + * ext4_punch_hole: punches a hole in a file by releasing the blocks | ||
407 | * associated with the given offset and length | ||
408 | * | ||
409 | * @inode: File inode | ||
410 | @@ -3674,7 +3674,7 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length) | ||
411 | * Write out all dirty pages to avoid race conditions | ||
412 | * Then release them. | ||
413 | */ | ||
414 | - if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) { | ||
415 | + if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) { | ||
416 | ret = filemap_write_and_wait_range(mapping, offset, | ||
417 | offset + length - 1); | ||
418 | if (ret) | ||
419 | @@ -4549,14 +4549,14 @@ static int ext4_do_update_inode(handle_t *handle, | ||
420 | * Fix up interoperability with old kernels. Otherwise, old inodes get | ||
421 | * re-used with the upper 16 bits of the uid/gid intact | ||
422 | */ | ||
423 | - if (!ei->i_dtime) { | ||
424 | + if (ei->i_dtime && list_empty(&ei->i_orphan)) { | ||
425 | + raw_inode->i_uid_high = 0; | ||
426 | + raw_inode->i_gid_high = 0; | ||
427 | + } else { | ||
428 | raw_inode->i_uid_high = | ||
429 | cpu_to_le16(high_16_bits(i_uid)); | ||
430 | raw_inode->i_gid_high = | ||
431 | cpu_to_le16(high_16_bits(i_gid)); | ||
432 | - } else { | ||
433 | - raw_inode->i_uid_high = 0; | ||
434 | - raw_inode->i_gid_high = 0; | ||
435 | } | ||
436 | } else { | ||
437 | raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid)); | ||
438 | diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c | ||
439 | index 796ff0eafd3c..7861d801b048 100644 | ||
440 | --- a/fs/ext4/move_extent.c | ||
441 | +++ b/fs/ext4/move_extent.c | ||
442 | @@ -598,6 +598,13 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, __u64 orig_blk, | ||
443 | return -EOPNOTSUPP; | ||
444 | } | ||
445 | |||
446 | + if (ext4_encrypted_inode(orig_inode) || | ||
447 | + ext4_encrypted_inode(donor_inode)) { | ||
448 | + ext4_msg(orig_inode->i_sb, KERN_ERR, | ||
449 | + "Online defrag not supported for encrypted files"); | ||
450 | + return -EOPNOTSUPP; | ||
451 | + } | ||
452 | + | ||
453 | /* Protect orig and donor inodes against a truncate */ | ||
454 | lock_two_nondirectories(orig_inode, donor_inode); | ||
455 | |||
456 | diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c | ||
457 | index 38eb0c8e43b9..573b4cbb0cb9 100644 | ||
458 | --- a/fs/ext4/namei.c | ||
459 | +++ b/fs/ext4/namei.c | ||
460 | @@ -2017,33 +2017,31 @@ static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname, | ||
461 | frame->entries = entries; | ||
462 | frame->at = entries; | ||
463 | frame->bh = bh; | ||
464 | - bh = bh2; | ||
465 | |||
466 | retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh); | ||
467 | if (retval) | ||
468 | goto out_frames; | ||
469 | - retval = ext4_handle_dirty_dirent_node(handle, dir, bh); | ||
470 | + retval = ext4_handle_dirty_dirent_node(handle, dir, bh2); | ||
471 | if (retval) | ||
472 | goto out_frames; | ||
473 | |||
474 | - de = do_split(handle,dir, &bh, frame, &fname->hinfo); | ||
475 | + de = do_split(handle,dir, &bh2, frame, &fname->hinfo); | ||
476 | if (IS_ERR(de)) { | ||
477 | retval = PTR_ERR(de); | ||
478 | goto out_frames; | ||
479 | } | ||
480 | - dx_release(frames); | ||
481 | |||
482 | - retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh); | ||
483 | - brelse(bh); | ||
484 | - return retval; | ||
485 | + retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2); | ||
486 | out_frames: | ||
487 | /* | ||
488 | * Even if the block split failed, we have to properly write | ||
489 | * out all the changes we did so far. Otherwise we can end up | ||
490 | * with corrupted filesystem. | ||
491 | */ | ||
492 | - ext4_mark_inode_dirty(handle, dir); | ||
493 | + if (retval) | ||
494 | + ext4_mark_inode_dirty(handle, dir); | ||
495 | dx_release(frames); | ||
496 | + brelse(bh2); | ||
497 | return retval; | ||
498 | } | ||
499 | |||
500 | diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c | ||
501 | index 5e2e08712d3b..4b5f2c4e69c8 100644 | ||
502 | --- a/fs/fuse/dir.c | ||
503 | +++ b/fs/fuse/dir.c | ||
504 | @@ -1697,14 +1697,46 @@ error: | ||
505 | static int fuse_setattr(struct dentry *entry, struct iattr *attr) | ||
506 | { | ||
507 | struct inode *inode = d_inode(entry); | ||
508 | + struct file *file = (attr->ia_valid & ATTR_FILE) ? attr->ia_file : NULL; | ||
509 | + int ret; | ||
510 | |||
511 | if (!fuse_allow_current_process(get_fuse_conn(inode))) | ||
512 | return -EACCES; | ||
513 | |||
514 | - if (attr->ia_valid & ATTR_FILE) | ||
515 | - return fuse_do_setattr(inode, attr, attr->ia_file); | ||
516 | - else | ||
517 | - return fuse_do_setattr(inode, attr, NULL); | ||
518 | + if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) { | ||
519 | + int kill; | ||
520 | + | ||
521 | + attr->ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID | | ||
522 | + ATTR_MODE); | ||
523 | + /* | ||
524 | + * ia_mode calculation may have used stale i_mode. Refresh and | ||
525 | + * recalculate. | ||
526 | + */ | ||
527 | + ret = fuse_do_getattr(inode, NULL, file); | ||
528 | + if (ret) | ||
529 | + return ret; | ||
530 | + | ||
531 | + attr->ia_mode = inode->i_mode; | ||
532 | + kill = should_remove_suid(entry); | ||
533 | + if (kill & ATTR_KILL_SUID) { | ||
534 | + attr->ia_valid |= ATTR_MODE; | ||
535 | + attr->ia_mode &= ~S_ISUID; | ||
536 | + } | ||
537 | + if (kill & ATTR_KILL_SGID) { | ||
538 | + attr->ia_valid |= ATTR_MODE; | ||
539 | + attr->ia_mode &= ~S_ISGID; | ||
540 | + } | ||
541 | + } | ||
542 | + if (!attr->ia_valid) | ||
543 | + return 0; | ||
544 | + | ||
545 | + ret = fuse_do_setattr(inode, attr, file); | ||
546 | + if (!ret) { | ||
547 | + /* Directory mode changed, may need to revalidate access */ | ||
548 | + if (d_is_dir(entry) && (attr->ia_valid & ATTR_MODE)) | ||
549 | + fuse_invalidate_entry_cache(entry); | ||
550 | + } | ||
551 | + return ret; | ||
552 | } | ||
553 | |||
554 | static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry, | ||
555 | @@ -1797,6 +1829,23 @@ static ssize_t fuse_getxattr(struct dentry *entry, const char *name, | ||
556 | return ret; | ||
557 | } | ||
558 | |||
559 | +static int fuse_verify_xattr_list(char *list, size_t size) | ||
560 | +{ | ||
561 | + size_t origsize = size; | ||
562 | + | ||
563 | + while (size) { | ||
564 | + size_t thislen = strnlen(list, size); | ||
565 | + | ||
566 | + if (!thislen || thislen == size) | ||
567 | + return -EIO; | ||
568 | + | ||
569 | + size -= thislen + 1; | ||
570 | + list += thislen + 1; | ||
571 | + } | ||
572 | + | ||
573 | + return origsize; | ||
574 | +} | ||
575 | + | ||
576 | static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size) | ||
577 | { | ||
578 | struct inode *inode = d_inode(entry); | ||
579 | @@ -1832,6 +1881,8 @@ static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size) | ||
580 | ret = fuse_simple_request(fc, &args); | ||
581 | if (!ret && !size) | ||
582 | ret = outarg.size; | ||
583 | + if (ret > 0 && size) | ||
584 | + ret = fuse_verify_xattr_list(list, ret); | ||
585 | if (ret == -ENOSYS) { | ||
586 | fc->no_listxattr = 1; | ||
587 | ret = -EOPNOTSUPP; | ||
588 | diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c | ||
589 | index 96a1bcf33db4..8f5ccdf81c25 100644 | ||
590 | --- a/fs/reiserfs/file.c | ||
591 | +++ b/fs/reiserfs/file.c | ||
592 | @@ -260,10 +260,10 @@ const struct file_operations reiserfs_file_operations = { | ||
593 | |||
594 | const struct inode_operations reiserfs_file_inode_operations = { | ||
595 | .setattr = reiserfs_setattr, | ||
596 | - .setxattr = reiserfs_setxattr, | ||
597 | - .getxattr = reiserfs_getxattr, | ||
598 | + .setxattr = generic_setxattr, | ||
599 | + .getxattr = generic_getxattr, | ||
600 | .listxattr = reiserfs_listxattr, | ||
601 | - .removexattr = reiserfs_removexattr, | ||
602 | + .removexattr = generic_removexattr, | ||
603 | .permission = reiserfs_permission, | ||
604 | .get_acl = reiserfs_get_acl, | ||
605 | .set_acl = reiserfs_set_acl, | ||
606 | diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c | ||
607 | index 47f96988fdd4..3ebc70167e41 100644 | ||
608 | --- a/fs/reiserfs/namei.c | ||
609 | +++ b/fs/reiserfs/namei.c | ||
610 | @@ -1649,10 +1649,10 @@ const struct inode_operations reiserfs_dir_inode_operations = { | ||
611 | .mknod = reiserfs_mknod, | ||
612 | .rename = reiserfs_rename, | ||
613 | .setattr = reiserfs_setattr, | ||
614 | - .setxattr = reiserfs_setxattr, | ||
615 | - .getxattr = reiserfs_getxattr, | ||
616 | + .setxattr = generic_setxattr, | ||
617 | + .getxattr = generic_getxattr, | ||
618 | .listxattr = reiserfs_listxattr, | ||
619 | - .removexattr = reiserfs_removexattr, | ||
620 | + .removexattr = generic_removexattr, | ||
621 | .permission = reiserfs_permission, | ||
622 | .get_acl = reiserfs_get_acl, | ||
623 | .set_acl = reiserfs_set_acl, | ||
624 | @@ -1667,10 +1667,10 @@ const struct inode_operations reiserfs_symlink_inode_operations = { | ||
625 | .follow_link = page_follow_link_light, | ||
626 | .put_link = page_put_link, | ||
627 | .setattr = reiserfs_setattr, | ||
628 | - .setxattr = reiserfs_setxattr, | ||
629 | - .getxattr = reiserfs_getxattr, | ||
630 | + .setxattr = generic_setxattr, | ||
631 | + .getxattr = generic_getxattr, | ||
632 | .listxattr = reiserfs_listxattr, | ||
633 | - .removexattr = reiserfs_removexattr, | ||
634 | + .removexattr = generic_removexattr, | ||
635 | .permission = reiserfs_permission, | ||
636 | }; | ||
637 | |||
638 | @@ -1679,10 +1679,10 @@ const struct inode_operations reiserfs_symlink_inode_operations = { | ||
639 | */ | ||
640 | const struct inode_operations reiserfs_special_inode_operations = { | ||
641 | .setattr = reiserfs_setattr, | ||
642 | - .setxattr = reiserfs_setxattr, | ||
643 | - .getxattr = reiserfs_getxattr, | ||
644 | + .setxattr = generic_setxattr, | ||
645 | + .getxattr = generic_getxattr, | ||
646 | .listxattr = reiserfs_listxattr, | ||
647 | - .removexattr = reiserfs_removexattr, | ||
648 | + .removexattr = generic_removexattr, | ||
649 | .permission = reiserfs_permission, | ||
650 | .get_acl = reiserfs_get_acl, | ||
651 | .set_acl = reiserfs_set_acl, | ||
652 | diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c | ||
653 | index 4a62fe8cc3bf..f9f3be50081a 100644 | ||
654 | --- a/fs/reiserfs/super.c | ||
655 | +++ b/fs/reiserfs/super.c | ||
656 | @@ -190,7 +190,15 @@ static int remove_save_link_only(struct super_block *s, | ||
657 | static int reiserfs_quota_on_mount(struct super_block *, int); | ||
658 | #endif | ||
659 | |||
660 | -/* look for uncompleted unlinks and truncates and complete them */ | ||
661 | +/* | ||
662 | + * Look for uncompleted unlinks and truncates and complete them | ||
663 | + * | ||
664 | + * Called with superblock write locked. If quotas are enabled, we have to | ||
665 | + * release/retake lest we call dquot_quota_on_mount(), proceed to | ||
666 | + * schedule_on_each_cpu() in invalidate_bdev() and deadlock waiting for the per | ||
667 | + * cpu worklets to complete flush_async_commits() that in turn wait for the | ||
668 | + * superblock write lock. | ||
669 | + */ | ||
670 | static int finish_unfinished(struct super_block *s) | ||
671 | { | ||
672 | INITIALIZE_PATH(path); | ||
673 | @@ -237,7 +245,9 @@ static int finish_unfinished(struct super_block *s) | ||
674 | quota_enabled[i] = 0; | ||
675 | continue; | ||
676 | } | ||
677 | + reiserfs_write_unlock(s); | ||
678 | ret = reiserfs_quota_on_mount(s, i); | ||
679 | + reiserfs_write_lock(s); | ||
680 | if (ret < 0) | ||
681 | reiserfs_warning(s, "reiserfs-2500", | ||
682 | "cannot turn on journaled " | ||
683 | diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c | ||
684 | index 66b26fdfff8d..a8dbc93e45eb 100644 | ||
685 | --- a/fs/reiserfs/xattr.c | ||
686 | +++ b/fs/reiserfs/xattr.c | ||
687 | @@ -763,60 +763,6 @@ find_xattr_handler_prefix(const struct xattr_handler **handlers, | ||
688 | return xah; | ||
689 | } | ||
690 | |||
691 | - | ||
692 | -/* | ||
693 | - * Inode operation getxattr() | ||
694 | - */ | ||
695 | -ssize_t | ||
696 | -reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer, | ||
697 | - size_t size) | ||
698 | -{ | ||
699 | - const struct xattr_handler *handler; | ||
700 | - | ||
701 | - handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name); | ||
702 | - | ||
703 | - if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) | ||
704 | - return -EOPNOTSUPP; | ||
705 | - | ||
706 | - return handler->get(handler, dentry, name, buffer, size); | ||
707 | -} | ||
708 | - | ||
709 | -/* | ||
710 | - * Inode operation setxattr() | ||
711 | - * | ||
712 | - * d_inode(dentry)->i_mutex down | ||
713 | - */ | ||
714 | -int | ||
715 | -reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value, | ||
716 | - size_t size, int flags) | ||
717 | -{ | ||
718 | - const struct xattr_handler *handler; | ||
719 | - | ||
720 | - handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name); | ||
721 | - | ||
722 | - if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) | ||
723 | - return -EOPNOTSUPP; | ||
724 | - | ||
725 | - return handler->set(handler, dentry, name, value, size, flags); | ||
726 | -} | ||
727 | - | ||
728 | -/* | ||
729 | - * Inode operation removexattr() | ||
730 | - * | ||
731 | - * d_inode(dentry)->i_mutex down | ||
732 | - */ | ||
733 | -int reiserfs_removexattr(struct dentry *dentry, const char *name) | ||
734 | -{ | ||
735 | - const struct xattr_handler *handler; | ||
736 | - | ||
737 | - handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name); | ||
738 | - | ||
739 | - if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) | ||
740 | - return -EOPNOTSUPP; | ||
741 | - | ||
742 | - return handler->set(handler, dentry, name, NULL, 0, XATTR_REPLACE); | ||
743 | -} | ||
744 | - | ||
745 | struct listxattr_buf { | ||
746 | struct dir_context ctx; | ||
747 | size_t size; | ||
748 | diff --git a/fs/reiserfs/xattr.h b/fs/reiserfs/xattr.h | ||
749 | index 15dde6262c00..613ff5aef94e 100644 | ||
750 | --- a/fs/reiserfs/xattr.h | ||
751 | +++ b/fs/reiserfs/xattr.h | ||
752 | @@ -2,6 +2,7 @@ | ||
753 | #include <linux/init.h> | ||
754 | #include <linux/list.h> | ||
755 | #include <linux/rwsem.h> | ||
756 | +#include <linux/xattr.h> | ||
757 | |||
758 | struct inode; | ||
759 | struct dentry; | ||
760 | @@ -18,12 +19,7 @@ int reiserfs_permission(struct inode *inode, int mask); | ||
761 | |||
762 | #ifdef CONFIG_REISERFS_FS_XATTR | ||
763 | #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir) | ||
764 | -ssize_t reiserfs_getxattr(struct dentry *dentry, const char *name, | ||
765 | - void *buffer, size_t size); | ||
766 | -int reiserfs_setxattr(struct dentry *dentry, const char *name, | ||
767 | - const void *value, size_t size, int flags); | ||
768 | ssize_t reiserfs_listxattr(struct dentry *dentry, char *buffer, size_t size); | ||
769 | -int reiserfs_removexattr(struct dentry *dentry, const char *name); | ||
770 | |||
771 | int reiserfs_xattr_get(struct inode *, const char *, void *, size_t); | ||
772 | int reiserfs_xattr_set(struct inode *, const char *, const void *, size_t, int); | ||
773 | @@ -92,10 +88,7 @@ static inline void reiserfs_init_xattr_rwsem(struct inode *inode) | ||
774 | |||
775 | #else | ||
776 | |||
777 | -#define reiserfs_getxattr NULL | ||
778 | -#define reiserfs_setxattr NULL | ||
779 | #define reiserfs_listxattr NULL | ||
780 | -#define reiserfs_removexattr NULL | ||
781 | |||
782 | static inline void reiserfs_init_xattr_rwsem(struct inode *inode) | ||
783 | { | ||
784 | diff --git a/fs/reiserfs/xattr_security.c b/fs/reiserfs/xattr_security.c | ||
785 | index ac659af431ae..60de069225ba 100644 | ||
786 | --- a/fs/reiserfs/xattr_security.c | ||
787 | +++ b/fs/reiserfs/xattr_security.c | ||
788 | @@ -12,26 +12,24 @@ static int | ||
789 | security_get(const struct xattr_handler *handler, struct dentry *dentry, | ||
790 | const char *name, void *buffer, size_t size) | ||
791 | { | ||
792 | - if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) | ||
793 | - return -EINVAL; | ||
794 | - | ||
795 | if (IS_PRIVATE(d_inode(dentry))) | ||
796 | return -EPERM; | ||
797 | |||
798 | - return reiserfs_xattr_get(d_inode(dentry), name, buffer, size); | ||
799 | + return reiserfs_xattr_get(d_inode(dentry), | ||
800 | + xattr_full_name(handler, name), | ||
801 | + buffer, size); | ||
802 | } | ||
803 | |||
804 | static int | ||
805 | security_set(const struct xattr_handler *handler, struct dentry *dentry, | ||
806 | const char *name, const void *buffer, size_t size, int flags) | ||
807 | { | ||
808 | - if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) | ||
809 | - return -EINVAL; | ||
810 | - | ||
811 | if (IS_PRIVATE(d_inode(dentry))) | ||
812 | return -EPERM; | ||
813 | |||
814 | - return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags); | ||
815 | + return reiserfs_xattr_set(d_inode(dentry), | ||
816 | + xattr_full_name(handler, name), | ||
817 | + buffer, size, flags); | ||
818 | } | ||
819 | |||
820 | static size_t security_list(const struct xattr_handler *handler, | ||
821 | diff --git a/fs/reiserfs/xattr_trusted.c b/fs/reiserfs/xattr_trusted.c | ||
822 | index a338adf1b8b4..ebba1ebf28ad 100644 | ||
823 | --- a/fs/reiserfs/xattr_trusted.c | ||
824 | +++ b/fs/reiserfs/xattr_trusted.c | ||
825 | @@ -11,26 +11,24 @@ static int | ||
826 | trusted_get(const struct xattr_handler *handler, struct dentry *dentry, | ||
827 | const char *name, void *buffer, size_t size) | ||
828 | { | ||
829 | - if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) | ||
830 | - return -EINVAL; | ||
831 | - | ||
832 | if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry))) | ||
833 | return -EPERM; | ||
834 | |||
835 | - return reiserfs_xattr_get(d_inode(dentry), name, buffer, size); | ||
836 | + return reiserfs_xattr_get(d_inode(dentry), | ||
837 | + xattr_full_name(handler, name), | ||
838 | + buffer, size); | ||
839 | } | ||
840 | |||
841 | static int | ||
842 | trusted_set(const struct xattr_handler *handler, struct dentry *dentry, | ||
843 | const char *name, const void *buffer, size_t size, int flags) | ||
844 | { | ||
845 | - if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) | ||
846 | - return -EINVAL; | ||
847 | - | ||
848 | if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry))) | ||
849 | return -EPERM; | ||
850 | |||
851 | - return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags); | ||
852 | + return reiserfs_xattr_set(d_inode(dentry), | ||
853 | + xattr_full_name(handler, name), | ||
854 | + buffer, size, flags); | ||
855 | } | ||
856 | |||
857 | static size_t trusted_list(const struct xattr_handler *handler, | ||
858 | diff --git a/fs/reiserfs/xattr_user.c b/fs/reiserfs/xattr_user.c | ||
859 | index 39c9667191c5..6ac8a8c8bd9c 100644 | ||
860 | --- a/fs/reiserfs/xattr_user.c | ||
861 | +++ b/fs/reiserfs/xattr_user.c | ||
862 | @@ -10,24 +10,22 @@ static int | ||
863 | user_get(const struct xattr_handler *handler, struct dentry *dentry, | ||
864 | const char *name, void *buffer, size_t size) | ||
865 | { | ||
866 | - | ||
867 | - if (strlen(name) < sizeof(XATTR_USER_PREFIX)) | ||
868 | - return -EINVAL; | ||
869 | if (!reiserfs_xattrs_user(dentry->d_sb)) | ||
870 | return -EOPNOTSUPP; | ||
871 | - return reiserfs_xattr_get(d_inode(dentry), name, buffer, size); | ||
872 | + return reiserfs_xattr_get(d_inode(dentry), | ||
873 | + xattr_full_name(handler, name), | ||
874 | + buffer, size); | ||
875 | } | ||
876 | |||
877 | static int | ||
878 | user_set(const struct xattr_handler *handler, struct dentry *dentry, | ||
879 | const char *name, const void *buffer, size_t size, int flags) | ||
880 | { | ||
881 | - if (strlen(name) < sizeof(XATTR_USER_PREFIX)) | ||
882 | - return -EINVAL; | ||
883 | - | ||
884 | if (!reiserfs_xattrs_user(dentry->d_sb)) | ||
885 | return -EOPNOTSUPP; | ||
886 | - return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags); | ||
887 | + return reiserfs_xattr_set(d_inode(dentry), | ||
888 | + xattr_full_name(handler, name), | ||
889 | + buffer, size, flags); | ||
890 | } | ||
891 | |||
892 | static size_t user_list(const struct xattr_handler *handler, | ||
893 | diff --git a/fs/utimes.c b/fs/utimes.c | ||
894 | index aa138d64560a..cb771c30d102 100644 | ||
895 | --- a/fs/utimes.c | ||
896 | +++ b/fs/utimes.c | ||
897 | @@ -87,20 +87,7 @@ static int utimes_common(struct path *path, struct timespec *times) | ||
898 | */ | ||
899 | newattrs.ia_valid |= ATTR_TIMES_SET; | ||
900 | } else { | ||
901 | - /* | ||
902 | - * If times is NULL (or both times are UTIME_NOW), | ||
903 | - * then we need to check permissions, because | ||
904 | - * inode_change_ok() won't do it. | ||
905 | - */ | ||
906 | - error = -EACCES; | ||
907 | - if (IS_IMMUTABLE(inode)) | ||
908 | - goto mnt_drop_write_and_out; | ||
909 | - | ||
910 | - if (!inode_owner_or_capable(inode)) { | ||
911 | - error = inode_permission(inode, MAY_WRITE); | ||
912 | - if (error) | ||
913 | - goto mnt_drop_write_and_out; | ||
914 | - } | ||
915 | + newattrs.ia_valid |= ATTR_TOUCH; | ||
916 | } | ||
917 | retry_deleg: | ||
918 | mutex_lock(&inode->i_mutex); | ||
919 | @@ -112,7 +99,6 @@ retry_deleg: | ||
920 | goto retry_deleg; | ||
921 | } | ||
922 | |||
923 | -mnt_drop_write_and_out: | ||
924 | mnt_drop_write(path->mnt); | ||
925 | out: | ||
926 | return error; | ||
927 | diff --git a/include/crypto/ghash.h b/include/crypto/ghash.h | ||
928 | new file mode 100644 | ||
929 | index 000000000000..2a61c9bbab8f | ||
930 | --- /dev/null | ||
931 | +++ b/include/crypto/ghash.h | ||
932 | @@ -0,0 +1,23 @@ | ||
933 | +/* | ||
934 | + * Common values for GHASH algorithms | ||
935 | + */ | ||
936 | + | ||
937 | +#ifndef __CRYPTO_GHASH_H__ | ||
938 | +#define __CRYPTO_GHASH_H__ | ||
939 | + | ||
940 | +#include <linux/types.h> | ||
941 | +#include <crypto/gf128mul.h> | ||
942 | + | ||
943 | +#define GHASH_BLOCK_SIZE 16 | ||
944 | +#define GHASH_DIGEST_SIZE 16 | ||
945 | + | ||
946 | +struct ghash_ctx { | ||
947 | + struct gf128mul_4k *gf128; | ||
948 | +}; | ||
949 | + | ||
950 | +struct ghash_desc_ctx { | ||
951 | + u8 buffer[GHASH_BLOCK_SIZE]; | ||
952 | + u32 bytes; | ||
953 | +}; | ||
954 | + | ||
955 | +#endif | ||
956 | diff --git a/include/linux/fs.h b/include/linux/fs.h | ||
957 | index 0166582c4d78..e1a123760dbf 100644 | ||
958 | --- a/include/linux/fs.h | ||
959 | +++ b/include/linux/fs.h | ||
960 | @@ -226,6 +226,7 @@ typedef void (dax_iodone_t)(struct buffer_head *bh_map, int uptodate); | ||
961 | #define ATTR_KILL_PRIV (1 << 14) | ||
962 | #define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */ | ||
963 | #define ATTR_TIMES_SET (1 << 16) | ||
964 | +#define ATTR_TOUCH (1 << 17) | ||
965 | |||
966 | /* | ||
967 | * Whiteout is represented by a char device. The following constants define the | ||
968 | diff --git a/sound/soc/intel/atom/sst/sst_pvt.c b/sound/soc/intel/atom/sst/sst_pvt.c | ||
969 | index adb32fefd693..b1e6b8f34a6a 100644 | ||
970 | --- a/sound/soc/intel/atom/sst/sst_pvt.c | ||
971 | +++ b/sound/soc/intel/atom/sst/sst_pvt.c | ||
972 | @@ -279,17 +279,15 @@ int sst_prepare_and_post_msg(struct intel_sst_drv *sst, | ||
973 | |||
974 | if (response) { | ||
975 | ret = sst_wait_timeout(sst, block); | ||
976 | - if (ret < 0) { | ||
977 | + if (ret < 0) | ||
978 | goto out; | ||
979 | - } else if(block->data) { | ||
980 | - if (!data) | ||
981 | - goto out; | ||
982 | - *data = kzalloc(block->size, GFP_KERNEL); | ||
983 | - if (!(*data)) { | ||
984 | + | ||
985 | + if (data && block->data) { | ||
986 | + *data = kmemdup(block->data, block->size, GFP_KERNEL); | ||
987 | + if (!*data) { | ||
988 | ret = -ENOMEM; | ||
989 | goto out; | ||
990 | - } else | ||
991 | - memcpy(data, (void *) block->data, block->size); | ||
992 | + } | ||
993 | } | ||
994 | } | ||
995 | out: |