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 const struct file_operations afs_file_operations = {
  27         .open           = afs_open,
  28         .release        = afs_release,
  29         .llseek         = generic_file_llseek,
  30         .read           = do_sync_read,
  31         .write          = do_sync_write,
  32         .aio_read       = generic_file_aio_read,
  33         .aio_write      = afs_file_write,
  34         .mmap           = generic_file_readonly_mmap,
  35         .splice_read    = generic_file_splice_read,
  36         .fsync          = afs_fsync,
  37         .lock           = afs_lock,
  38         .flock          = afs_flock,
  39 };
  40
  41 const struct inode_operations afs_file_inode_operations = {
  42         .getattr        = afs_getattr,
  43         .setattr        = afs_setattr,
  44         .permission     = afs_permission,
  45 };
  46
  47 const struct address_space_operations afs_fs_aops = {
  48         .readpage       = afs_readpage,
  49         .set_page_dirty = afs_set_page_dirty,
  50         .launder_page   = afs_launder_page,
  51         .releasepage    = afs_releasepage,
  52         .invalidatepage = afs_invalidatepage,
  53         .prepare_write  = afs_prepare_write,
  54         .commit_write   = afs_commit_write,
  55         .writepage      = afs_writepage,
  56         .writepages     = afs_writepages,
  57 };
  58
  59 /*
  60  * open an AFS file or directory and attach a key to it
  61  */
  62 int afs_open(struct inode *inode, struct file *file)
  63 {
  64         struct afs_vnode *vnode = AFS_FS_I(inode);
  65         struct key *key;
  66         int ret;
  67
  68         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
  69
  70         key = afs_request_key(vnode->volume->cell);
  71         if (IS_ERR(key)) {
  72                 _leave(" = %ld [key]", PTR_ERR(key));
  73                 return PTR_ERR(key);
  74         }
  75
  76         ret = afs_validate(vnode, key);
  77         if (ret < 0) {
  78                 _leave(" = %d [val]", ret);
  79                 return ret;
  80         }
  81
  82         file->private_data = key;
  83         _leave(" = 0");
  84         return 0;
  85 }
  86
  87 /*
  88  * release an AFS file or directory and discard its key
  89  */
  90 int afs_release(struct inode *inode, struct file *file)
  91 {
  92         struct afs_vnode *vnode = AFS_FS_I(inode);
  93
  94         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
  95
  96         key_put(file->private_data);
  97         _leave(" = 0");
  98         return 0;
  99 }
 100
 101 /*
 102  * deal with notification that a page was read from the cache
 103  */
 104 #ifdef AFS_CACHING_SUPPORT
 105 static void afs_readpage_read_complete(void *cookie_data,
 106                                        struct page *page,
 107                                        void *data,
 108                                        int error)
 109 {
 110         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
 111
 112         if (error)
 113                 SetPageError(page);
 114         else
 115                 SetPageUptodate(page);
 116         unlock_page(page);
 117
 118 }
 119 #endif
 120
 121 /*
 122  * deal with notification that a page was written to the cache
 123  */
 124 #ifdef AFS_CACHING_SUPPORT
 125 static void afs_readpage_write_complete(void *cookie_data,
 126                                         struct page *page,
 127                                         void *data,
 128                                         int error)
 129 {
 130         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
 131
 132         unlock_page(page);
 133 }
 134 #endif
 135
 136 /*
 137  * AFS read page from file, directory or symlink
 138  */
 139 static int afs_readpage(struct file *file, struct page *page)
 140 {
 141         struct afs_vnode *vnode;
 142         struct inode *inode;
 143         struct key *key;
 144         size_t len;
 145         off_t offset;
 146         int ret;
 147
 148         inode = page->mapping->host;
 149
 150         ASSERT(file != NULL);
 151         key = file->private_data;
 152         ASSERT(key != NULL);
 153
 154         _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
 155
 156         vnode = AFS_FS_I(inode);
 157
 158         BUG_ON(!PageLocked(page));
 159
 160         ret = -ESTALE;
 161         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
 162                 goto error;
 163
 164 #ifdef AFS_CACHING_SUPPORT
 165         /* is it cached? */
 166         ret = cachefs_read_or_alloc_page(vnode->cache,
 167                                          page,
 168                                          afs_file_readpage_read_complete,
 169                                          NULL,
 170                                          GFP_KERNEL);
 171 #else
 172         ret = -ENOBUFS;
 173 #endif
 174
 175         switch (ret) {
 176                 /* read BIO submitted and wb-journal entry found */
 177         case 1:
 178                 BUG(); // TODO - handle wb-journal match
 179
 180                 /* read BIO submitted (page in cache) */
 181         case 0:
 182                 break;
 183
 184                 /* no page available in cache */
 185         case -ENOBUFS:
 186         case -ENODATA:
 187         default:
 188                 offset = page->index << PAGE_CACHE_SHIFT;
 189                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
 190
 191                 /* read the contents of the file from the server into the
 192                  * page */
 193                 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
 194                 if (ret < 0) {
 195                         if (ret == -ENOENT) {
 196                                 _debug("got NOENT from server"
 197                                        " - marking file deleted and stale");
 198                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
 199                                 ret = -ESTALE;
 200                         }
 201 #ifdef AFS_CACHING_SUPPORT
 202                         cachefs_uncache_page(vnode->cache, page);
 203 #endif
 204                         goto error;
 205                 }
 206
 207                 SetPageUptodate(page);
 208
 209 #ifdef AFS_CACHING_SUPPORT
 210                 if (cachefs_write_page(vnode->cache,
 211                                        page,
 212                                        afs_file_readpage_write_complete,
 213                                        NULL,
 214                                        GFP_KERNEL) != 0
 215                     ) {
 216                         cachefs_uncache_page(vnode->cache, page);
 217                         unlock_page(page);
 218                 }
 219 #else
 220                 unlock_page(page);
 221 #endif
 222         }
 223
 224         _leave(" = 0");
 225         return 0;
 226
 227 error:
 228         SetPageError(page);
 229         unlock_page(page);
 230         _leave(" = %d", ret);
 231         return ret;
 232 }
 233
 234 /*
 235  * invalidate part or all of a page
 236  */
 237 static void afs_invalidatepage(struct page *page, unsigned long offset)
 238 {
 239         int ret = 1;
 240
 241         _enter("{%lu},%lu", page->index, offset);
 242
 243         BUG_ON(!PageLocked(page));
 244
 245         if (PagePrivate(page)) {
 246                 /* We release buffers only if the entire page is being
 247                  * invalidated.
 248                  * The get_block cached value has been unconditionally
 249                  * invalidated, so real IO is not possible anymore.
 250                  */
 251                 if (offset == 0) {
 252                         BUG_ON(!PageLocked(page));
 253
 254                         ret = 0;
 255                         if (!PageWriteback(page))
 256                                 ret = page->mapping->a_ops->releasepage(page,
 257                                                                         0);
 258                         /* possibly should BUG_ON(!ret); - neilb */
 259                 }
 260         }
 261
 262         _leave(" = %d", ret);
 263 }
 264
 265 /*
 266  * write back a dirty page
 267  */
 268 static int afs_launder_page(struct page *page)
 269 {
 270         _enter("{%lu}", page->index);
 271
 272         return 0;
 273 }
 274
 275 /*
 276  * release a page and cleanup its private data
 277  */
 278 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
 279 {
 280         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 281         struct afs_writeback *wb;
 282
 283         _enter("{{%x:%u}[%lu],%lx},%x",
 284                vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
 285                gfp_flags);
 286
 287         if (PagePrivate(page)) {
 288                 wb = (struct afs_writeback *) page_private(page);
 289                 ASSERT(wb != NULL);
 290                 set_page_private(page, 0);
 291                 ClearPagePrivate(page);
 292                 afs_put_writeback(wb);
 293         }
 294
 295         _leave(" = 0");
 296         return 0;
 297 }