~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/afs/file.c

Version: ~ [ linux-5.1-rc2 ] ~ [ linux-5.0.4 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.31 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.108 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.165 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.177 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.137 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
662 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp