Merge tag 'afs-next-20171113' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowel...
[sfrench/cifs-2.6.git] / fs / afs / file.c
1 /* AFS filesystem file handling
2  *
3  * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/fs.h>
16 #include <linux/pagemap.h>
17 #include <linux/writeback.h>
18 #include <linux/gfp.h>
19 #include <linux/task_io_accounting_ops.h>
20 #include "internal.h"
21
22 static int afs_file_mmap(struct file *file, struct vm_area_struct *vma);
23 static int afs_readpage(struct file *file, struct page *page);
24 static void afs_invalidatepage(struct page *page, unsigned int offset,
25                                unsigned int length);
26 static int afs_releasepage(struct page *page, gfp_t gfp_flags);
27
28 static int afs_readpages(struct file *filp, struct address_space *mapping,
29                          struct list_head *pages, unsigned nr_pages);
30
31 const struct file_operations afs_file_operations = {
32         .open           = afs_open,
33         .flush          = afs_flush,
34         .release        = afs_release,
35         .llseek         = generic_file_llseek,
36         .read_iter      = generic_file_read_iter,
37         .write_iter     = afs_file_write,
38         .mmap           = afs_file_mmap,
39         .splice_read    = generic_file_splice_read,
40         .fsync          = afs_fsync,
41         .lock           = afs_lock,
42         .flock          = afs_flock,
43 };
44
45 const struct inode_operations afs_file_inode_operations = {
46         .getattr        = afs_getattr,
47         .setattr        = afs_setattr,
48         .permission     = afs_permission,
49         .listxattr      = afs_listxattr,
50 };
51
52 const struct address_space_operations afs_fs_aops = {
53         .readpage       = afs_readpage,
54         .readpages      = afs_readpages,
55         .set_page_dirty = afs_set_page_dirty,
56         .launder_page   = afs_launder_page,
57         .releasepage    = afs_releasepage,
58         .invalidatepage = afs_invalidatepage,
59         .write_begin    = afs_write_begin,
60         .write_end      = afs_write_end,
61         .writepage      = afs_writepage,
62         .writepages     = afs_writepages,
63 };
64
65 static const struct vm_operations_struct afs_vm_ops = {
66         .fault          = filemap_fault,
67         .map_pages      = filemap_map_pages,
68         .page_mkwrite   = afs_page_mkwrite,
69 };
70
71 /*
72  * Discard a pin on a writeback key.
73  */
74 void afs_put_wb_key(struct afs_wb_key *wbk)
75 {
76         if (refcount_dec_and_test(&wbk->usage)) {
77                 key_put(wbk->key);
78                 kfree(wbk);
79         }
80 }
81
82 /*
83  * Cache key for writeback.
84  */
85 int afs_cache_wb_key(struct afs_vnode *vnode, struct afs_file *af)
86 {
87         struct afs_wb_key *wbk, *p;
88
89         wbk = kzalloc(sizeof(struct afs_wb_key), GFP_KERNEL);
90         if (!wbk)
91                 return -ENOMEM;
92         refcount_set(&wbk->usage, 2);
93         wbk->key = af->key;
94
95         spin_lock(&vnode->wb_lock);
96         list_for_each_entry(p, &vnode->wb_keys, vnode_link) {
97                 if (p->key == wbk->key)
98                         goto found;
99         }
100
101         key_get(wbk->key);
102         list_add_tail(&wbk->vnode_link, &vnode->wb_keys);
103         spin_unlock(&vnode->wb_lock);
104         af->wb = wbk;
105         return 0;
106
107 found:
108         refcount_inc(&p->usage);
109         spin_unlock(&vnode->wb_lock);
110         af->wb = p;
111         kfree(wbk);
112         return 0;
113 }
114
115 /*
116  * open an AFS file or directory and attach a key to it
117  */
118 int afs_open(struct inode *inode, struct file *file)
119 {
120         struct afs_vnode *vnode = AFS_FS_I(inode);
121         struct afs_file *af;
122         struct key *key;
123         int ret;
124
125         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
126
127         key = afs_request_key(vnode->volume->cell);
128         if (IS_ERR(key)) {
129                 ret = PTR_ERR(key);
130                 goto error;
131         }
132
133         af = kzalloc(sizeof(*af), GFP_KERNEL);
134         if (!af) {
135                 ret = -ENOMEM;
136                 goto error_key;
137         }
138         af->key = key;
139
140         ret = afs_validate(vnode, key);
141         if (ret < 0)
142                 goto error_af;
143
144         if (file->f_mode & FMODE_WRITE) {
145                 ret = afs_cache_wb_key(vnode, af);
146                 if (ret < 0)
147                         goto error_af;
148         }
149         
150         file->private_data = af;
151         _leave(" = 0");
152         return 0;
153
154 error_af:
155         kfree(af);
156 error_key:
157         key_put(key);
158 error:
159         _leave(" = %d", ret);
160         return ret;
161 }
162
163 /*
164  * release an AFS file or directory and discard its key
165  */
166 int afs_release(struct inode *inode, struct file *file)
167 {
168         struct afs_vnode *vnode = AFS_FS_I(inode);
169         struct afs_file *af = file->private_data;
170
171         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
172
173         file->private_data = NULL;
174         if (af->wb)
175                 afs_put_wb_key(af->wb);
176         key_put(af->key);
177         kfree(af);
178         afs_prune_wb_keys(vnode);
179         _leave(" = 0");
180         return 0;
181 }
182
183 /*
184  * Dispose of a ref to a read record.
185  */
186 void afs_put_read(struct afs_read *req)
187 {
188         int i;
189
190         if (atomic_dec_and_test(&req->usage)) {
191                 for (i = 0; i < req->nr_pages; i++)
192                         if (req->pages[i])
193                                 put_page(req->pages[i]);
194                 kfree(req);
195         }
196 }
197
198 #ifdef CONFIG_AFS_FSCACHE
199 /*
200  * deal with notification that a page was read from the cache
201  */
202 static void afs_file_readpage_read_complete(struct page *page,
203                                             void *data,
204                                             int error)
205 {
206         _enter("%p,%p,%d", page, data, error);
207
208         /* if the read completes with an error, we just unlock the page and let
209          * the VM reissue the readpage */
210         if (!error)
211                 SetPageUptodate(page);
212         unlock_page(page);
213 }
214 #endif
215
216 /*
217  * Fetch file data from the volume.
218  */
219 int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *desc)
220 {
221         struct afs_fs_cursor fc;
222         int ret;
223
224         _enter("%s{%x:%u.%u},%x,,,",
225                vnode->volume->name,
226                vnode->fid.vid,
227                vnode->fid.vnode,
228                vnode->fid.unique,
229                key_serial(key));
230
231         ret = -ERESTARTSYS;
232         if (afs_begin_vnode_operation(&fc, vnode, key)) {
233                 while (afs_select_fileserver(&fc)) {
234                         fc.cb_break = vnode->cb_break + vnode->cb_s_break;
235                         afs_fs_fetch_data(&fc, desc);
236                 }
237
238                 afs_check_for_remote_deletion(&fc, fc.vnode);
239                 afs_vnode_commit_status(&fc, vnode, fc.cb_break);
240                 ret = afs_end_vnode_operation(&fc);
241         }
242
243         _leave(" = %d", ret);
244         return ret;
245 }
246
247 /*
248  * read page from file, directory or symlink, given a key to use
249  */
250 int afs_page_filler(void *data, struct page *page)
251 {
252         struct inode *inode = page->mapping->host;
253         struct afs_vnode *vnode = AFS_FS_I(inode);
254         struct afs_read *req;
255         struct key *key = data;
256         int ret;
257
258         _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
259
260         BUG_ON(!PageLocked(page));
261
262         ret = -ESTALE;
263         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
264                 goto error;
265
266         /* is it cached? */
267 #ifdef CONFIG_AFS_FSCACHE
268         ret = fscache_read_or_alloc_page(vnode->cache,
269                                          page,
270                                          afs_file_readpage_read_complete,
271                                          NULL,
272                                          GFP_KERNEL);
273 #else
274         ret = -ENOBUFS;
275 #endif
276         switch (ret) {
277                 /* read BIO submitted (page in cache) */
278         case 0:
279                 break;
280
281                 /* page not yet cached */
282         case -ENODATA:
283                 _debug("cache said ENODATA");
284                 goto go_on;
285
286                 /* page will not be cached */
287         case -ENOBUFS:
288                 _debug("cache said ENOBUFS");
289         default:
290         go_on:
291                 req = kzalloc(sizeof(struct afs_read) + sizeof(struct page *),
292                               GFP_KERNEL);
293                 if (!req)
294                         goto enomem;
295
296                 /* We request a full page.  If the page is a partial one at the
297                  * end of the file, the server will return a short read and the
298                  * unmarshalling code will clear the unfilled space.
299                  */
300                 atomic_set(&req->usage, 1);
301                 req->pos = (loff_t)page->index << PAGE_SHIFT;
302                 req->len = PAGE_SIZE;
303                 req->nr_pages = 1;
304                 req->pages[0] = page;
305                 get_page(page);
306
307                 /* read the contents of the file from the server into the
308                  * page */
309                 ret = afs_fetch_data(vnode, key, req);
310                 afs_put_read(req);
311
312                 if (ret >= 0 && S_ISDIR(inode->i_mode) &&
313                     !afs_dir_check_page(inode, page))
314                         ret = -EIO;
315
316                 if (ret < 0) {
317                         if (ret == -ENOENT) {
318                                 _debug("got NOENT from server"
319                                        " - marking file deleted and stale");
320                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
321                                 ret = -ESTALE;
322                         }
323
324 #ifdef CONFIG_AFS_FSCACHE
325                         fscache_uncache_page(vnode->cache, page);
326 #endif
327                         BUG_ON(PageFsCache(page));
328
329                         if (ret == -EINTR ||
330                             ret == -ENOMEM ||
331                             ret == -ERESTARTSYS ||
332                             ret == -EAGAIN)
333                                 goto error;
334                         goto io_error;
335                 }
336
337                 SetPageUptodate(page);
338
339                 /* send the page to the cache */
340 #ifdef CONFIG_AFS_FSCACHE
341                 if (PageFsCache(page) &&
342                     fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
343                         fscache_uncache_page(vnode->cache, page);
344                         BUG_ON(PageFsCache(page));
345                 }
346 #endif
347                 unlock_page(page);
348         }
349
350         _leave(" = 0");
351         return 0;
352
353 io_error:
354         SetPageError(page);
355         goto error;
356 enomem:
357         ret = -ENOMEM;
358 error:
359         unlock_page(page);
360         _leave(" = %d", ret);
361         return ret;
362 }
363
364 /*
365  * read page from file, directory or symlink, given a file to nominate the key
366  * to be used
367  */
368 static int afs_readpage(struct file *file, struct page *page)
369 {
370         struct key *key;
371         int ret;
372
373         if (file) {
374                 key = afs_file_key(file);
375                 ASSERT(key != NULL);
376                 ret = afs_page_filler(key, page);
377         } else {
378                 struct inode *inode = page->mapping->host;
379                 key = afs_request_key(AFS_FS_S(inode->i_sb)->cell);
380                 if (IS_ERR(key)) {
381                         ret = PTR_ERR(key);
382                 } else {
383                         ret = afs_page_filler(key, page);
384                         key_put(key);
385                 }
386         }
387         return ret;
388 }
389
390 /*
391  * Make pages available as they're filled.
392  */
393 static void afs_readpages_page_done(struct afs_call *call, struct afs_read *req)
394 {
395 #ifdef CONFIG_AFS_FSCACHE
396         struct afs_vnode *vnode = call->reply[0];
397 #endif
398         struct page *page = req->pages[req->index];
399
400         req->pages[req->index] = NULL;
401         SetPageUptodate(page);
402
403         /* send the page to the cache */
404 #ifdef CONFIG_AFS_FSCACHE
405         if (PageFsCache(page) &&
406             fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
407                 fscache_uncache_page(vnode->cache, page);
408                 BUG_ON(PageFsCache(page));
409         }
410 #endif
411         unlock_page(page);
412         put_page(page);
413 }
414
415 /*
416  * Read a contiguous set of pages.
417  */
418 static int afs_readpages_one(struct file *file, struct address_space *mapping,
419                              struct list_head *pages)
420 {
421         struct afs_vnode *vnode = AFS_FS_I(mapping->host);
422         struct afs_read *req;
423         struct list_head *p;
424         struct page *first, *page;
425         struct key *key = afs_file_key(file);
426         pgoff_t index;
427         int ret, n, i;
428
429         /* Count the number of contiguous pages at the front of the list.  Note
430          * that the list goes prev-wards rather than next-wards.
431          */
432         first = list_entry(pages->prev, struct page, lru);
433         index = first->index + 1;
434         n = 1;
435         for (p = first->lru.prev; p != pages; p = p->prev) {
436                 page = list_entry(p, struct page, lru);
437                 if (page->index != index)
438                         break;
439                 index++;
440                 n++;
441         }
442
443         req = kzalloc(sizeof(struct afs_read) + sizeof(struct page *) * n,
444                       GFP_NOFS);
445         if (!req)
446                 return -ENOMEM;
447
448         atomic_set(&req->usage, 1);
449         req->page_done = afs_readpages_page_done;
450         req->pos = first->index;
451         req->pos <<= PAGE_SHIFT;
452
453         /* Transfer the pages to the request.  We add them in until one fails
454          * to add to the LRU and then we stop (as that'll make a hole in the
455          * contiguous run.
456          *
457          * Note that it's possible for the file size to change whilst we're
458          * doing this, but we rely on the server returning less than we asked
459          * for if the file shrank.  We also rely on this to deal with a partial
460          * page at the end of the file.
461          */
462         do {
463                 page = list_entry(pages->prev, struct page, lru);
464                 list_del(&page->lru);
465                 index = page->index;
466                 if (add_to_page_cache_lru(page, mapping, index,
467                                           readahead_gfp_mask(mapping))) {
468 #ifdef CONFIG_AFS_FSCACHE
469                         fscache_uncache_page(vnode->cache, page);
470 #endif
471                         put_page(page);
472                         break;
473                 }
474
475                 req->pages[req->nr_pages++] = page;
476                 req->len += PAGE_SIZE;
477         } while (req->nr_pages < n);
478
479         if (req->nr_pages == 0) {
480                 kfree(req);
481                 return 0;
482         }
483
484         ret = afs_fetch_data(vnode, key, req);
485         if (ret < 0)
486                 goto error;
487
488         task_io_account_read(PAGE_SIZE * req->nr_pages);
489         afs_put_read(req);
490         return 0;
491
492 error:
493         if (ret == -ENOENT) {
494                 _debug("got NOENT from server"
495                        " - marking file deleted and stale");
496                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
497                 ret = -ESTALE;
498         }
499
500         for (i = 0; i < req->nr_pages; i++) {
501                 page = req->pages[i];
502                 if (page) {
503 #ifdef CONFIG_AFS_FSCACHE
504                         fscache_uncache_page(vnode->cache, page);
505 #endif
506                         SetPageError(page);
507                         unlock_page(page);
508                 }
509         }
510
511         afs_put_read(req);
512         return ret;
513 }
514
515 /*
516  * read a set of pages
517  */
518 static int afs_readpages(struct file *file, struct address_space *mapping,
519                          struct list_head *pages, unsigned nr_pages)
520 {
521         struct key *key = afs_file_key(file);
522         struct afs_vnode *vnode;
523         int ret = 0;
524
525         _enter("{%d},{%lu},,%d",
526                key_serial(key), mapping->host->i_ino, nr_pages);
527
528         ASSERT(key != NULL);
529
530         vnode = AFS_FS_I(mapping->host);
531         if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
532                 _leave(" = -ESTALE");
533                 return -ESTALE;
534         }
535
536         /* attempt to read as many of the pages as possible */
537 #ifdef CONFIG_AFS_FSCACHE
538         ret = fscache_read_or_alloc_pages(vnode->cache,
539                                           mapping,
540                                           pages,
541                                           &nr_pages,
542                                           afs_file_readpage_read_complete,
543                                           NULL,
544                                           mapping_gfp_mask(mapping));
545 #else
546         ret = -ENOBUFS;
547 #endif
548
549         switch (ret) {
550                 /* all pages are being read from the cache */
551         case 0:
552                 BUG_ON(!list_empty(pages));
553                 BUG_ON(nr_pages != 0);
554                 _leave(" = 0 [reading all]");
555                 return 0;
556
557                 /* there were pages that couldn't be read from the cache */
558         case -ENODATA:
559         case -ENOBUFS:
560                 break;
561
562                 /* other error */
563         default:
564                 _leave(" = %d", ret);
565                 return ret;
566         }
567
568         while (!list_empty(pages)) {
569                 ret = afs_readpages_one(file, mapping, pages);
570                 if (ret < 0)
571                         break;
572         }
573
574         _leave(" = %d [netting]", ret);
575         return ret;
576 }
577
578 /*
579  * invalidate part or all of a page
580  * - release a page and clean up its private data if offset is 0 (indicating
581  *   the entire page)
582  */
583 static void afs_invalidatepage(struct page *page, unsigned int offset,
584                                unsigned int length)
585 {
586         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
587         unsigned long priv;
588
589         _enter("{%lu},%u,%u", page->index, offset, length);
590
591         BUG_ON(!PageLocked(page));
592
593         /* we clean up only if the entire page is being invalidated */
594         if (offset == 0 && length == PAGE_SIZE) {
595 #ifdef CONFIG_AFS_FSCACHE
596                 if (PageFsCache(page)) {
597                         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
598                         fscache_wait_on_page_write(vnode->cache, page);
599                         fscache_uncache_page(vnode->cache, page);
600                 }
601 #endif
602
603                 if (PagePrivate(page)) {
604                         priv = page_private(page);
605                         trace_afs_page_dirty(vnode, tracepoint_string("inval"),
606                                              page->index, priv);
607                         set_page_private(page, 0);
608                         ClearPagePrivate(page);
609                 }
610         }
611
612         _leave("");
613 }
614
615 /*
616  * release a page and clean up its private state if it's not busy
617  * - return true if the page can now be released, false if not
618  */
619 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
620 {
621         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
622         unsigned long priv;
623
624         _enter("{{%x:%u}[%lu],%lx},%x",
625                vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
626                gfp_flags);
627
628         /* deny if page is being written to the cache and the caller hasn't
629          * elected to wait */
630 #ifdef CONFIG_AFS_FSCACHE
631         if (!fscache_maybe_release_page(vnode->cache, page, gfp_flags)) {
632                 _leave(" = F [cache busy]");
633                 return 0;
634         }
635 #endif
636
637         if (PagePrivate(page)) {
638                 priv = page_private(page);
639                 trace_afs_page_dirty(vnode, tracepoint_string("rel"),
640                                      page->index, priv);
641                 set_page_private(page, 0);
642                 ClearPagePrivate(page);
643         }
644
645         /* indicate that the page can be released */
646         _leave(" = T");
647         return 1;
648 }
649
650 /*
651  * Handle setting up a memory mapping on an AFS file.
652  */
653 static int afs_file_mmap(struct file *file, struct vm_area_struct *vma)
654 {
655         int ret;
656
657         ret = generic_file_mmap(file, vma);
658         if (ret == 0)
659                 vma->vm_ops = &afs_vm_ops;
660         return ret;
661 }