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