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 "internal.h"
  19
  20 static int afs_file_readpage(struct file *file, struct page *page);
  21 static void afs_file_invalidatepage(struct page *page, unsigned long offset);
  22 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags);
  23
  24 const struct file_operations afs_file_operations = {
  25         .open           = afs_open,
  26         .release        = afs_release,
  27         .llseek         = generic_file_llseek,
  28         .read           = do_sync_read,
  29         .aio_read       = generic_file_aio_read,
  30         .mmap           = generic_file_readonly_mmap,
  31         .sendfile       = generic_file_sendfile,
  32 };
  33
  34 const struct inode_operations afs_file_inode_operations = {
  35         .getattr        = afs_inode_getattr,
  36         .permission     = afs_permission,
  37 };
  38
  39 const struct address_space_operations afs_fs_aops = {
  40         .readpage       = afs_file_readpage,
  41         .set_page_dirty = __set_page_dirty_nobuffers,
  42         .releasepage    = afs_file_releasepage,
  43         .invalidatepage = afs_file_invalidatepage,
  44 };
  45
  46 /*
  47  * open an AFS file or directory and attach a key to it
  48  */
  49 int afs_open(struct inode *inode, struct file *file)
  50 {
  51         struct afs_vnode *vnode = AFS_FS_I(inode);
  52         struct key *key;
  53
  54         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
  55
  56         key = afs_request_key(vnode->volume->cell);
  57         if (IS_ERR(key)) {
  58                 _leave(" = %ld [key]", PTR_ERR(key));
  59                 return PTR_ERR(key);
  60         }
  61
  62         file->private_data = key;
  63         _leave(" = 0");
  64         return 0;
  65 }
  66
  67 /*
  68  * release an AFS file or directory and discard its key
  69  */
  70 int afs_release(struct inode *inode, struct file *file)
  71 {
  72         struct afs_vnode *vnode = AFS_FS_I(inode);
  73
  74         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
  75
  76         key_put(file->private_data);
  77         _leave(" = 0");
  78         return 0;
  79 }
  80
  81 /*
  82  * deal with notification that a page was read from the cache
  83  */
  84 #ifdef AFS_CACHING_SUPPORT
  85 static void afs_file_readpage_read_complete(void *cookie_data,
  86                                             struct page *page,
  87                                             void *data,
  88                                             int error)
  89 {
  90         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
  91
  92         if (error)
  93                 SetPageError(page);
  94         else
  95                 SetPageUptodate(page);
  96         unlock_page(page);
  97
  98 }
  99 #endif
 100
 101 /*
 102  * deal with notification that a page was written to the cache
 103  */
 104 #ifdef AFS_CACHING_SUPPORT
 105 static void afs_file_readpage_write_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         unlock_page(page);
 113 }
 114 #endif
 115
 116 /*
 117  * AFS read page from file (or symlink)
 118  */
 119 static int afs_file_readpage(struct file *file, struct page *page)
 120 {
 121         struct afs_vnode *vnode;
 122         struct inode *inode;
 123         struct key *key;
 124         size_t len;
 125         off_t offset;
 126         int ret;
 127
 128         inode = page->mapping->host;
 129
 130         ASSERT(file != NULL);
 131         key = file->private_data;
 132         ASSERT(key != NULL);
 133
 134         _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
 135
 136         vnode = AFS_FS_I(inode);
 137
 138         BUG_ON(!PageLocked(page));
 139
 140         ret = -ESTALE;
 141         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
 142                 goto error;
 143
 144 #ifdef AFS_CACHING_SUPPORT
 145         /* is it cached? */
 146         ret = cachefs_read_or_alloc_page(vnode->cache,
 147                                          page,
 148                                          afs_file_readpage_read_complete,
 149                                          NULL,
 150                                          GFP_KERNEL);
 151 #else
 152         ret = -ENOBUFS;
 153 #endif
 154
 155         switch (ret) {
 156                 /* read BIO submitted and wb-journal entry found */
 157         case 1:
 158                 BUG(); // TODO - handle wb-journal match
 159
 160                 /* read BIO submitted (page in cache) */
 161         case 0:
 162                 break;
 163
 164                 /* no page available in cache */
 165         case -ENOBUFS:
 166         case -ENODATA:
 167         default:
 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 #ifdef AFS_CACHING_SUPPORT
 182                         cachefs_uncache_page(vnode->cache, page);
 183 #endif
 184                         goto error;
 185                 }
 186
 187                 SetPageUptodate(page);
 188
 189 #ifdef AFS_CACHING_SUPPORT
 190                 if (cachefs_write_page(vnode->cache,
 191                                        page,
 192                                        afs_file_readpage_write_complete,
 193                                        NULL,
 194                                        GFP_KERNEL) != 0
 195                     ) {
 196                         cachefs_uncache_page(vnode->cache, page);
 197                         unlock_page(page);
 198                 }
 199 #else
 200                 unlock_page(page);
 201 #endif
 202         }
 203
 204         _leave(" = 0");
 205         return 0;
 206
 207 error:
 208         SetPageError(page);
 209         unlock_page(page);
 210         _leave(" = %d", ret);
 211         return ret;
 212 }
 213
 214 /*
 215  * get a page cookie for the specified page
 216  */
 217 #ifdef AFS_CACHING_SUPPORT
 218 int afs_cache_get_page_cookie(struct page *page,
 219                               struct cachefs_page **_page_cookie)
 220 {
 221         int ret;
 222
 223         _enter("");
 224         ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
 225
 226         _leave(" = %d", ret);
 227         return ret;
 228 }
 229 #endif
 230
 231 /*
 232  * invalidate part or all of a page
 233  */
 234 static void afs_file_invalidatepage(struct page *page, unsigned long offset)
 235 {
 236         int ret = 1;
 237
 238         _enter("{%lu},%lu", page->index, offset);
 239
 240         BUG_ON(!PageLocked(page));
 241
 242         if (PagePrivate(page)) {
 243 #ifdef AFS_CACHING_SUPPORT
 244                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 245                 cachefs_uncache_page(vnode->cache,page);
 246 #endif
 247
 248                 /* We release buffers only if the entire page is being
 249                  * invalidated.
 250                  * The get_block cached value has been unconditionally
 251                  * invalidated, so real IO is not possible anymore.
 252                  */
 253                 if (offset == 0) {
 254                         BUG_ON(!PageLocked(page));
 255
 256                         ret = 0;
 257                         if (!PageWriteback(page))
 258                                 ret = page->mapping->a_ops->releasepage(page,
 259                                                                         0);
 260                         /* possibly should BUG_ON(!ret); - neilb */
 261                 }
 262         }
 263
 264         _leave(" = %d", ret);
 265 }
 266
 267 /*
 268  * release a page and cleanup its private data
 269  */
 270 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags)
 271 {
 272         struct cachefs_page *pageio;
 273
 274         _enter("{%lu},%x", page->index, gfp_flags);
 275
 276         if (PagePrivate(page)) {
 277 #ifdef AFS_CACHING_SUPPORT
 278                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 279                 cachefs_uncache_page(vnode->cache, page);
 280 #endif
 281
 282                 pageio = (struct cachefs_page *) page_private(page);
 283                 set_page_private(page, 0);
 284                 ClearPagePrivate(page);
 285
 286                 kfree(pageio);
 287         }
 288
 289         _leave(" = 0");
 290         return 0;
 291 }