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         int ret;
  54
  55         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
  56
  57         key = afs_request_key(vnode->volume->cell);
  58         if (IS_ERR(key)) {
  59                 _leave(" = %ld [key]", PTR_ERR(key));
  60                 return PTR_ERR(key);
  61         }
  62
  63         ret = afs_validate(vnode, key);
  64         if (ret < 0) {
  65                 _leave(" = %d [val]", ret);
  66                 return ret;
  67         }
  68
  69         file->private_data = key;
  70         _leave(" = 0");
  71         return 0;
  72 }
  73
  74 /*
  75  * release an AFS file or directory and discard its key
  76  */
  77 int afs_release(struct inode *inode, struct file *file)
  78 {
  79         struct afs_vnode *vnode = AFS_FS_I(inode);
  80
  81         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
  82
  83         key_put(file->private_data);
  84         _leave(" = 0");
  85         return 0;
  86 }
  87
  88 /*
  89  * deal with notification that a page was read from the cache
  90  */
  91 #ifdef AFS_CACHING_SUPPORT
  92 static void afs_file_readpage_read_complete(void *cookie_data,
  93                                             struct page *page,
  94                                             void *data,
  95                                             int error)
  96 {
  97         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
  98
  99         if (error)
 100                 SetPageError(page);
 101         else
 102                 SetPageUptodate(page);
 103         unlock_page(page);
 104
 105 }
 106 #endif
 107
 108 /*
 109  * deal with notification that a page was written to the cache
 110  */
 111 #ifdef AFS_CACHING_SUPPORT
 112 static void afs_file_readpage_write_complete(void *cookie_data,
 113                                              struct page *page,
 114                                              void *data,
 115                                              int error)
 116 {
 117         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
 118
 119         unlock_page(page);
 120 }
 121 #endif
 122
 123 /*
 124  * AFS read page from file (or symlink)
 125  */
 126 static int afs_file_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 #ifdef AFS_CACHING_SUPPORT
 152         /* is it cached? */
 153         ret = cachefs_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
 162         switch (ret) {
 163                 /* read BIO submitted and wb-journal entry found */
 164         case 1:
 165                 BUG(); // TODO - handle wb-journal match
 166
 167                 /* read BIO submitted (page in cache) */
 168         case 0:
 169                 break;
 170
 171                 /* no page available in cache */
 172         case -ENOBUFS:
 173         case -ENODATA:
 174         default:
 175                 offset = page->index << PAGE_CACHE_SHIFT;
 176                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
 177
 178                 /* read the contents of the file from the server into the
 179                  * page */
 180                 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
 181                 if (ret < 0) {
 182                         if (ret == -ENOENT) {
 183                                 _debug("got NOENT from server"
 184                                        " - marking file deleted and stale");
 185                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
 186                                 ret = -ESTALE;
 187                         }
 188 #ifdef AFS_CACHING_SUPPORT
 189                         cachefs_uncache_page(vnode->cache, page);
 190 #endif
 191                         goto error;
 192                 }
 193
 194                 SetPageUptodate(page);
 195
 196 #ifdef AFS_CACHING_SUPPORT
 197                 if (cachefs_write_page(vnode->cache,
 198                                        page,
 199                                        afs_file_readpage_write_complete,
 200                                        NULL,
 201                                        GFP_KERNEL) != 0
 202                     ) {
 203                         cachefs_uncache_page(vnode->cache, page);
 204                         unlock_page(page);
 205                 }
 206 #else
 207                 unlock_page(page);
 208 #endif
 209         }
 210
 211         _leave(" = 0");
 212         return 0;
 213
 214 error:
 215         SetPageError(page);
 216         unlock_page(page);
 217         _leave(" = %d", ret);
 218         return ret;
 219 }
 220
 221 /*
 222  * get a page cookie for the specified page
 223  */
 224 #ifdef AFS_CACHING_SUPPORT
 225 int afs_cache_get_page_cookie(struct page *page,
 226                               struct cachefs_page **_page_cookie)
 227 {
 228         int ret;
 229
 230         _enter("");
 231         ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
 232
 233         _leave(" = %d", ret);
 234         return ret;
 235 }
 236 #endif
 237
 238 /*
 239  * invalidate part or all of a page
 240  */
 241 static void afs_file_invalidatepage(struct page *page, unsigned long offset)
 242 {
 243         int ret = 1;
 244
 245         _enter("{%lu},%lu", page->index, offset);
 246
 247         BUG_ON(!PageLocked(page));
 248
 249         if (PagePrivate(page)) {
 250 #ifdef AFS_CACHING_SUPPORT
 251                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 252                 cachefs_uncache_page(vnode->cache,page);
 253 #endif
 254
 255                 /* We release buffers only if the entire page is being
 256                  * invalidated.
 257                  * The get_block cached value has been unconditionally
 258                  * invalidated, so real IO is not possible anymore.
 259                  */
 260                 if (offset == 0) {
 261                         BUG_ON(!PageLocked(page));
 262
 263                         ret = 0;
 264                         if (!PageWriteback(page))
 265                                 ret = page->mapping->a_ops->releasepage(page,
 266                                                                         0);
 267                         /* possibly should BUG_ON(!ret); - neilb */
 268                 }
 269         }
 270
 271         _leave(" = %d", ret);
 272 }
 273
 274 /*
 275  * release a page and cleanup its private data
 276  */
 277 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags)
 278 {
 279         struct cachefs_page *pageio;
 280
 281         _enter("{%lu},%x", page->index, gfp_flags);
 282
 283         if (PagePrivate(page)) {
 284 #ifdef AFS_CACHING_SUPPORT
 285                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
 286                 cachefs_uncache_page(vnode->cache, page);
 287 #endif
 288
 289                 pageio = (struct cachefs_page *) page_private(page);
 290                 set_page_private(page, 0);
 291                 ClearPagePrivate(page);
 292
 293                 kfree(pageio);
 294         }
 295
 296         _leave(" = 0");
 297         return 0;
 298 }