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/slab.h>
  16 #include <linux/fs.h>
  17 #include <linux/pagemap.h>
  18 #include <linux/writeback.h>
  19 #include "internal.h"
  20
  21 static int afs_readpage(struct file *file, struct page *page);
  22 static void afs_invalidatepage(struct page *page, unsigned long offset);
  23 static int afs_releasepage(struct page *page, gfp_t gfp_flags);
  24 static int afs_launder_page(struct page *page);
  25
  26 static int afs_readpages(struct file *filp, struct address_space *mapping,
  27                          struct list_head *pages, unsigned nr_pages);
  28
  29 const struct file_operations afs_file_operations = {
  30         .open           = afs_open,
  31         .release        = afs_release,
  32         .llseek         = generic_file_llseek,
  33         .read           = do_sync_read,
  34         .write          = do_sync_write,
  35         .aio_read       = generic_file_aio_read,
  36         .aio_write      = afs_file_write,
  37         .mmap           = generic_file_readonly_mmap,
  38         .splice_read    = generic_file_splice_read,
  39         .fsync          = afs_fsync,
  40         .lock           = afs_lock,
  41         .flock          = afs_flock,
  42 };
  43
  44 const struct inode_operations afs_file_inode_operations = {
  45         .getattr        = afs_getattr,
  46         .setattr        = afs_setattr,
  47         .permission     = afs_permission,
  48 };
  49
  50 const struct address_space_operations afs_fs_aops = {
  51         .readpage       = afs_readpage,
  52         .readpages      = afs_readpages,
  53         .set_page_dirty = afs_set_page_dirty,
  54         .launder_page   = afs_launder_page,
  55         .releasepage    = afs_releasepage,
  56         .invalidatepage = afs_invalidatepage,
  57         .write_begin    = afs_write_begin,
  58         .write_end      = afs_write_end,
  59         .writepage      = afs_writepage,
  60         .writepages     = afs_writepages,
  61 };
  62
  63 /*
  64  * open an AFS file or directory and attach a key to it
  65  */
  66 int afs_open(struct inode *inode, struct file *file)
  67 {
  68         struct afs_vnode *vnode = AFS_FS_I(inode);
  69         struct key *key;
  70         int ret;
  71
  72         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
  73
  74         key = afs_request_key(vnode->volume->cell);
  75         if (IS_ERR(key)) {
  76                 _leave(" = %ld [key]", PTR_ERR(key));
  77                 return PTR_ERR(key);
  78         }
  79
  80         ret = afs_validate(vnode, key);
  81         if (ret < 0) {
  82                 _leave(" = %d [val]", ret);
  83                 return ret;
  84         }
  85
  86         file->private_data = key;
  87         _leave(" = 0");
  88         return 0;
  89 }
  90
  91 /*
  92  * release an AFS file or directory and discard its key
  93  */
  94 int afs_release(struct inode *inode, struct file *file)
  95 {
  96         struct afs_vnode *vnode = AFS_FS_I(inode);
  97
  98         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
  99
 100         key_put(file->private_data);
 101         _leave(" = 0");
 102         return 0;
 103 }
 104
 105 #ifdef CONFIG_AFS_FSCACHE
 106 /*
 107  * deal with notification that a page was read from the cache
 108  */
 109 static void afs_file_readpage_read_complete(struct page *page,
 110                                             void *data,
 111                                             int error)
 112 {
 113         _enter("%p,%p,%d", page, data, error);
 114
 115         /* if the read completes with an error, we just unlock the page and let
 116          * the VM reissue the readpage */
 117         if (!error)
 118                 SetPageUptodate(page);
 119         unlock_page(page);
 120 }
 121 #endif
 122
 123 /*
 124  * AFS read page from file, directory or symlink
 125  */
 126 static int afs_readpage(struct file *file, struct page *page)
 127 {
 128         struct afs_vnode *vnode;
 129         struct inode *inode;
 130         struct key *key;
 131         size_t len;
 132         off_t offset;
 133         int ret;
 134
 135         inode = page->mapping->host;
 136
 137         ASSERT(file != NULL);
 138         key = file->private_data;
 139         ASSERT(key != NULL);
 140
 141         _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
 142
 143         vnode = AFS_FS_I(inode);
 144
 145         BUG_ON(!PageLocked(page));
 146
 147         ret = -ESTALE;
 148         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
 149                 goto error;
 150
 151         /* is it cached? */
 152 #ifdef CONFIG_AFS_FSCACHE
 153         ret = fscache_read_or_alloc_page(vnode->cache,
 154                                          page,
 155                                          afs_file_readpage_read_complete,
 156                                          NULL,
 157                                          GFP_KERNEL);
 158 #else
 159         ret = -ENOBUFS;
 160 #endif
 161         switch (ret) {
 162                 /* read BIO submitted (page in cache) */
 163         case 0:
 164                 break;
 165
 166                 /* page not yet cached */
 167         case -ENODATA:
 168                 _debug("cache said ENODATA");
 169                 goto go_on;
 170
 171                 /* page will not be cached */
 172         case -ENOBUFS:
 173                 _debug("cache said ENOBUFS");
 174         default:
 175         go_on:
 176                 offset = page->index << PAGE_CACHE_SHIFT;
 177                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
 178
 179                 /* read the contents of the file from the server into the
 180                  * page */
 181                 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
 182                 if (ret < 0) {
 183                         if (ret == -ENOENT) {
 184                                 _debug("got NOENT from server"
 185                                        " - marking file deleted and stale");
 186                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
 187                                 ret = -ESTALE;
 188                         }
 189
 190 #ifdef CONFIG_AFS_FSCACHE
 191                         fscache_uncache_page(vnode->cache, page);
 192 #endif
 193                         BUG_ON(PageFsCache(page));
 194                         goto error;
 195                 }
 196
 197                 SetPageUptodate(page);
 198
 199                 /* send the page to the cache */
 200 #ifdef CONFIG_AFS_FSCACHE
 201                 if (PageFsCache(page) &&
 202                     fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
 203                         fscache_uncache_page(vnode->cache, page);
 204                         BUG_ON(PageFsCache(page));
 205                 }
 206 #endif
 207                 unlock_page(page);
 208         }
 209
 210         _leave(" = 0");
 211         return 0;
 212
 213 error:
 214         SetPageError(page);
 215         unlock_page(page);
 216         _leave(" = %d", ret);
 217         return ret;
 218 }
 219
 220 /*
 221  * read a set of pages
 222  */
 223 static int afs_readpages(struct file *file, struct address_space *mapping,
 224                          struct list_head *pages, unsigned nr_pages)
 225 {
 226         struct afs_vnode *vnode;
 227         int ret = 0;
 228
 229         _enter(",{%lu},,%d", mapping->host->i_ino, nr_pages);
 230
 231         vnode = AFS_FS_I(mapping->host);
 232         if (vnode->flags & AFS_VNODE_DELETED) {
 233                 _leave(" = -ESTALE");
 234                 return -ESTALE;
 235         }
 236
 237         /* attempt to read as many of the pages as possible */
 238 #ifdef CONFIG_AFS_FSCACHE
 239         ret = fscache_read_or_alloc_pages(vnode->cache,
 240                                           mapping,
 241                                           pages,
 242                                           &nr_pages,
 243                                           afs_file_readpage_read_complete,
 244                                           NULL,
 245                                           mapping_gfp_mask(mapping));
 246 #else
 247         ret = -ENOBUFS;
 248 #endif
 249
 250         switch (ret) {
 251                 /* all pages are being read from the cache */
 252         case 0:
 253                 BUG_ON(!list_empty(pages));
 254                 BUG_ON(nr_pages != 0);
 255                 _leave(" = 0 [reading all]");
 256                 return 0;
 257
 258                 /* there were pages that couldn't be read from the cache */
 259         case -ENODATA:
 260         case -ENOBUFS:
 261                 break;
 262
 263                 /* other error */
 264         default:
 265                 _leave(" = %d", ret);
 266                 return ret;
 267         }
 268
 269         /* load the missing pages from the network */
 270         ret = read_cache_pages(mapping, pages, (void *) afs_readpage, file);
 271
 272         _leave(" = %d [netting]", ret);
 273         return ret;
 274 }
 275
 276 /*
 277  * write back a dirty page
 278  */
 279 static int afs_launder_page(struct page *page)
 280 {
 281         _enter("{%lu}", page->index);
 282
 283         return 0;
 284 }
 285
 286 /*
 287  * invalidate part or all of a page
 288  * - release a page and clean up its private data if offset is 0 (indicating
 289  *   the entire page)
 290  */
 291 static void afs_invalidatepage(struct page *page, unsigned long offset)
 292 {
 293         struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
 294
 295         _enter("{%lu},%lu", page->index, offset);
 296
 297         BUG_ON(!PageLocked(page));
 298
 299         /* we clean up only if the entire page is being invalidated */
 300         if (offset == 0) {
 301 #ifdef CONFIG_AFS_FSCACHE
 302                 if (PageFsCache(page)) {
 303                         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 304                         fscache_wait_on_page_write(vnode->cache, page);
 305                         fscache_uncache_page(vnode->cache, page);
 306                         ClearPageFsCache(page);
 307                 }
 308 #endif
 309
 310                 if (PagePrivate(page)) {
 311                         if (wb && !PageWriteback(page)) {
 312                                 set_page_private(page, 0);
 313                                 afs_put_writeback(wb);
 314                         }
 315
 316                         if (!page_private(page))
 317                                 ClearPagePrivate(page);
 318                 }
 319         }
 320
 321         _leave("");
 322 }
 323
 324 /*
 325  * release a page and clean up its private state if it's not busy
 326  * - return true if the page can now be released, false if not
 327  */
 328 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
 329 {
 330         struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
 331         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 332
 333         _enter("{{%x:%u}[%lu],%lx},%x",
 334                vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
 335                gfp_flags);
 336
 337         /* deny if page is being written to the cache and the caller hasn't
 338          * elected to wait */
 339 #ifdef CONFIG_AFS_FSCACHE
 340         if (PageFsCache(page)) {
 341                 if (fscache_check_page_write(vnode->cache, page)) {
 342                         if (!(gfp_flags & __GFP_WAIT)) {
 343                                 _leave(" = F [cache busy]");
 344                                 return 0;
 345                         }
 346                         fscache_wait_on_page_write(vnode->cache, page);
 347                 }
 348
 349                 fscache_uncache_page(vnode->cache, page);
 350                 ClearPageFsCache(page);
 351         }
 352 #endif
 353
 354         if (PagePrivate(page)) {
 355                 if (wb) {
 356                         set_page_private(page, 0);
 357                         afs_put_writeback(wb);
 358                 }
 359                 ClearPagePrivate(page);
 360         }
 361
 362         /* indicate that the page can be released */
 363         _leave(" = T");
 364         return 1;
 365 }