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 /*
 106  * deal with notification that a page was read from the cache
 107  */
 108 static void afs_file_readpage_read_complete(struct page *page,
 109                                             void *data,
 110                                             int error)
 111 {
 112         _enter("%p,%p,%d", page, data, error);
 113
 114         /* if the read completes with an error, we just unlock the page and let
 115          * the VM reissue the readpage */
 116         if (!error)
 117                 SetPageUptodate(page);
 118         unlock_page(page);
 119 }
 120
 121 /*
 122  * AFS read page from file, directory or symlink
 123  */
 124 static int afs_readpage(struct file *file, struct page *page)
 125 {
 126         struct afs_vnode *vnode;
 127         struct inode *inode;
 128         struct key *key;
 129         size_t len;
 130         off_t offset;
 131         int ret;
 132
 133         inode = page->mapping->host;
 134
 135         ASSERT(file != NULL);
 136         key = file->private_data;
 137         ASSERT(key != NULL);
 138
 139         _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
 140
 141         vnode = AFS_FS_I(inode);
 142
 143         BUG_ON(!PageLocked(page));
 144
 145         ret = -ESTALE;
 146         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
 147                 goto error;
 148
 149         /* is it cached? */
 150 #ifdef CONFIG_AFS_FSCACHE
 151         ret = fscache_read_or_alloc_page(vnode->cache,
 152                                          page,
 153                                          afs_file_readpage_read_complete,
 154                                          NULL,
 155                                          GFP_KERNEL);
 156 #else
 157         ret = -ENOBUFS;
 158 #endif
 159         switch (ret) {
 160                 /* read BIO submitted (page in cache) */
 161         case 0:
 162                 break;
 163
 164                 /* page not yet cached */
 165         case -ENODATA:
 166                 _debug("cache said ENODATA");
 167                 goto go_on;
 168
 169                 /* page will not be cached */
 170         case -ENOBUFS:
 171                 _debug("cache said ENOBUFS");
 172         default:
 173         go_on:
 174                 offset = page->index << PAGE_CACHE_SHIFT;
 175                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
 176
 177                 /* read the contents of the file from the server into the
 178                  * page */
 179                 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
 180                 if (ret < 0) {
 181                         if (ret == -ENOENT) {
 182                                 _debug("got NOENT from server"
 183                                        " - marking file deleted and stale");
 184                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
 185                                 ret = -ESTALE;
 186                         }
 187
 188 #ifdef CONFIG_AFS_FSCACHE
 189                         fscache_uncache_page(vnode->cache, page);
 190 #endif
 191                         BUG_ON(PageFsCache(page));
 192                         goto error;
 193                 }
 194
 195                 SetPageUptodate(page);
 196
 197                 /* send the page to the cache */
 198 #ifdef CONFIG_AFS_FSCACHE
 199                 if (PageFsCache(page) &&
 200                     fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
 201                         fscache_uncache_page(vnode->cache, page);
 202                         BUG_ON(PageFsCache(page));
 203                 }
 204 #endif
 205                 unlock_page(page);
 206         }
 207
 208         _leave(" = 0");
 209         return 0;
 210
 211 error:
 212         SetPageError(page);
 213         unlock_page(page);
 214         _leave(" = %d", ret);
 215         return ret;
 216 }
 217
 218 /*
 219  * read a set of pages
 220  */
 221 static int afs_readpages(struct file *file, struct address_space *mapping,
 222                          struct list_head *pages, unsigned nr_pages)
 223 {
 224         struct afs_vnode *vnode;
 225         int ret = 0;
 226
 227         _enter(",{%lu},,%d", mapping->host->i_ino, nr_pages);
 228
 229         vnode = AFS_FS_I(mapping->host);
 230         if (vnode->flags & AFS_VNODE_DELETED) {
 231                 _leave(" = -ESTALE");
 232                 return -ESTALE;
 233         }
 234
 235         /* attempt to read as many of the pages as possible */
 236 #ifdef CONFIG_AFS_FSCACHE
 237         ret = fscache_read_or_alloc_pages(vnode->cache,
 238                                           mapping,
 239                                           pages,
 240                                           &nr_pages,
 241                                           afs_file_readpage_read_complete,
 242                                           NULL,
 243                                           mapping_gfp_mask(mapping));
 244 #else
 245         ret = -ENOBUFS;
 246 #endif
 247
 248         switch (ret) {
 249                 /* all pages are being read from the cache */
 250         case 0:
 251                 BUG_ON(!list_empty(pages));
 252                 BUG_ON(nr_pages != 0);
 253                 _leave(" = 0 [reading all]");
 254                 return 0;
 255
 256                 /* there were pages that couldn't be read from the cache */
 257         case -ENODATA:
 258         case -ENOBUFS:
 259                 break;
 260
 261                 /* other error */
 262         default:
 263                 _leave(" = %d", ret);
 264                 return ret;
 265         }
 266
 267         /* load the missing pages from the network */
 268         ret = read_cache_pages(mapping, pages, (void *) afs_readpage, file);
 269
 270         _leave(" = %d [netting]", ret);
 271         return ret;
 272 }
 273
 274 /*
 275  * write back a dirty page
 276  */
 277 static int afs_launder_page(struct page *page)
 278 {
 279         _enter("{%lu}", page->index);
 280
 281         return 0;
 282 }
 283
 284 /*
 285  * invalidate part or all of a page
 286  * - release a page and clean up its private data if offset is 0 (indicating
 287  *   the entire page)
 288  */
 289 static void afs_invalidatepage(struct page *page, unsigned long offset)
 290 {
 291         struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
 292
 293         _enter("{%lu},%lu", page->index, offset);
 294
 295         BUG_ON(!PageLocked(page));
 296
 297         /* we clean up only if the entire page is being invalidated */
 298         if (offset == 0) {
 299 #ifdef CONFIG_AFS_FSCACHE
 300                 if (PageFsCache(page)) {
 301                         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 302                         fscache_wait_on_page_write(vnode->cache, page);
 303                         fscache_uncache_page(vnode->cache, page);
 304                         ClearPageFsCache(page);
 305                 }
 306 #endif
 307
 308                 if (PagePrivate(page)) {
 309                         if (wb && !PageWriteback(page)) {
 310                                 set_page_private(page, 0);
 311                                 afs_put_writeback(wb);
 312                         }
 313
 314                         if (!page_private(page))
 315                                 ClearPagePrivate(page);
 316                 }
 317         }
 318
 319         _leave("");
 320 }
 321
 322 /*
 323  * release a page and clean up its private state if it's not busy
 324  * - return true if the page can now be released, false if not
 325  */
 326 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
 327 {
 328         struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
 329         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 330
 331         _enter("{{%x:%u}[%lu],%lx},%x",
 332                vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
 333                gfp_flags);
 334
 335         /* deny if page is being written to the cache and the caller hasn't
 336          * elected to wait */
 337 #ifdef CONFIG_AFS_FSCACHE
 338         if (PageFsCache(page)) {
 339                 if (fscache_check_page_write(vnode->cache, page)) {
 340                         if (!(gfp_flags & __GFP_WAIT)) {
 341                                 _leave(" = F [cache busy]");
 342                                 return 0;
 343                         }
 344                         fscache_wait_on_page_write(vnode->cache, page);
 345                 }
 346
 347                 fscache_uncache_page(vnode->cache, page);
 348                 ClearPageFsCache(page);
 349         }
 350 #endif
 351
 352         if (PagePrivate(page)) {
 353                 if (wb) {
 354                         set_page_private(page, 0);
 355                         afs_put_writeback(wb);
 356                 }
 357                 ClearPagePrivate(page);
 358         }
 359
 360         /* indicate that the page can be released */
 361         _leave(" = T");
 362         return 1;
 363 }