mm: merge populate and nopage into fault (fixes nonlinear)

[pandora-kernel.git] / fs / afs / file.c

diff --git a/fs/afs/file.c b/fs/afs/file.c
index ae25649..525f7c5 100644 (file)
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -15,32 +15,45 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/pagemap.h>
+#include <linux/writeback.h>
 #include "internal.h"
 
-static int afs_file_readpage(struct file *file, struct page *page);
-static void afs_file_invalidatepage(struct page *page, unsigned long offset);
-static int afs_file_releasepage(struct page *page, gfp_t gfp_flags);
+static int afs_readpage(struct file *file, struct page *page);
+static void afs_invalidatepage(struct page *page, unsigned long offset);
+static int afs_releasepage(struct page *page, gfp_t gfp_flags);
+static int afs_launder_page(struct page *page);
 
 const struct file_operations afs_file_operations = {
        .open           = afs_open,
        .release        = afs_release,
        .llseek         = generic_file_llseek,
        .read           = do_sync_read,
+       .write          = do_sync_write,
        .aio_read       = generic_file_aio_read,
+       .aio_write      = afs_file_write,
        .mmap           = generic_file_readonly_mmap,
-       .sendfile       = generic_file_sendfile,
+       .splice_read    = generic_file_splice_read,
+       .fsync          = afs_fsync,
+       .lock           = afs_lock,
+       .flock          = afs_flock,
 };
 
 const struct inode_operations afs_file_inode_operations = {
-       .getattr        = afs_inode_getattr,
+       .getattr        = afs_getattr,
+       .setattr        = afs_setattr,
        .permission     = afs_permission,
 };
 
 const struct address_space_operations afs_fs_aops = {
-       .readpage       = afs_file_readpage,
-       .set_page_dirty = __set_page_dirty_nobuffers,
-       .releasepage    = afs_file_releasepage,
-       .invalidatepage = afs_file_invalidatepage,
+       .readpage       = afs_readpage,
+       .set_page_dirty = afs_set_page_dirty,
+       .launder_page   = afs_launder_page,
+       .releasepage    = afs_releasepage,
+       .invalidatepage = afs_invalidatepage,
+       .prepare_write  = afs_prepare_write,
+       .commit_write   = afs_commit_write,
+       .writepage      = afs_writepage,
+       .writepages     = afs_writepages,
 };
 
 /*
@@ -52,7 +65,7 @@ int afs_open(struct inode *inode, struct file *file)
        struct key *key;
        int ret;
 
-       _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
+       _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
 
        key = afs_request_key(vnode->volume->cell);
        if (IS_ERR(key)) {
@@ -78,7 +91,7 @@ int afs_release(struct inode *inode, struct file *file)
 {
        struct afs_vnode *vnode = AFS_FS_I(inode);
 
-       _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
+       _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
 
        key_put(file->private_data);
        _leave(" = 0");
@@ -89,10 +102,10 @@ int afs_release(struct inode *inode, struct file *file)
  * deal with notification that a page was read from the cache
  */
 #ifdef AFS_CACHING_SUPPORT
-static void afs_file_readpage_read_complete(void *cookie_data,
-                                           struct page *page,
-                                           void *data,
-                                           int error)
+static void afs_readpage_read_complete(void *cookie_data,
+                                      struct page *page,
+                                      void *data,
+                                      int error)
 {
        _enter("%p,%p,%p,%d", cookie_data, page, data, error);
 
@@ -109,10 +122,10 @@ static void afs_file_readpage_read_complete(void *cookie_data,
  * deal with notification that a page was written to the cache
  */
 #ifdef AFS_CACHING_SUPPORT
-static void afs_file_readpage_write_complete(void *cookie_data,
-                                            struct page *page,
-                                            void *data,
-                                            int error)
+static void afs_readpage_write_complete(void *cookie_data,
+                                       struct page *page,
+                                       void *data,
+                                       int error)
 {
        _enter("%p,%p,%p,%d", cookie_data, page, data, error);
 
@@ -121,9 +134,9 @@ static void afs_file_readpage_write_complete(void *cookie_data,
 #endif
 
 /*
- * AFS read page from file (or symlink)
+ * AFS read page from file, directory or symlink
  */
-static int afs_file_readpage(struct file *file, struct page *page)
+static int afs_readpage(struct file *file, struct page *page)
 {
        struct afs_vnode *vnode;
        struct inode *inode;
@@ -218,27 +231,10 @@ error:
        return ret;
 }
 
-/*
- * get a page cookie for the specified page
- */
-#ifdef AFS_CACHING_SUPPORT
-int afs_cache_get_page_cookie(struct page *page,
-                             struct cachefs_page **_page_cookie)
-{
-       int ret;
-
-       _enter("");
-       ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
-
-       _leave(" = %d", ret);
-       return ret;
-}
-#endif
-
 /*
  * invalidate part or all of a page
  */
-static void afs_file_invalidatepage(struct page *page, unsigned long offset)
+static void afs_invalidatepage(struct page *page, unsigned long offset)
 {
        int ret = 1;
 
@@ -247,11 +243,6 @@ static void afs_file_invalidatepage(struct page *page, unsigned long offset)
        BUG_ON(!PageLocked(page));
 
        if (PagePrivate(page)) {
-#ifdef AFS_CACHING_SUPPORT
-               struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
-               cachefs_uncache_page(vnode->cache,page);
-#endif
-
                /* We release buffers only if the entire page is being
                 * invalidated.
                 * The get_block cached value has been unconditionally
@@ -271,26 +262,34 @@ static void afs_file_invalidatepage(struct page *page, unsigned long offset)
        _leave(" = %d", ret);
 }
 
+/*
+ * write back a dirty page
+ */
+static int afs_launder_page(struct page *page)
+{
+       _enter("{%lu}", page->index);
+
+       return 0;
+}
+
 /*
  * release a page and cleanup its private data
  */
-static int afs_file_releasepage(struct page *page, gfp_t gfp_flags)
+static int afs_releasepage(struct page *page, gfp_t gfp_flags)
 {
-       struct cachefs_page *pageio;
+       struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
+       struct afs_writeback *wb;
 
-       _enter("{%lu},%x", page->index, gfp_flags);
+       _enter("{{%x:%u}[%lu],%lx},%x",
+              vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
+              gfp_flags);
 
        if (PagePrivate(page)) {
-#ifdef AFS_CACHING_SUPPORT
-               struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
-               cachefs_uncache_page(vnode->cache, page);
-#endif
-
-               pageio = (struct cachefs_page *) page_private(page);
+               wb = (struct afs_writeback *) page_private(page);
+               ASSERT(wb != NULL);
                set_page_private(page, 0);
                ClearPagePrivate(page);
-
-               kfree(pageio);
+               afs_put_writeback(wb);
        }
 
        _leave(" = 0");