Fix races around the access to ->s_options
[linux-2.6.git] / fs / afs / write.c
index aa03d43..c2e7a7f 100644 (file)
@@ -8,7 +8,7 @@
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
-
+#include <linux/backing-dev.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/pagemap.h>
@@ -84,15 +84,23 @@ void afs_put_writeback(struct afs_writeback *wb)
  * partly or wholly fill a page that's under preparation for writing
  */
 static int afs_fill_page(struct afs_vnode *vnode, struct key *key,
-                        unsigned start, unsigned len, struct page *page)
+                        loff_t pos, unsigned len, struct page *page)
 {
+       loff_t i_size;
+       unsigned eof;
        int ret;
 
-       _enter(",,%u,%u", start, len);
+       _enter(",,%llu,%u", (unsigned long long)pos, len);
+
+       ASSERTCMP(len, <=, PAGE_CACHE_SIZE);
 
-       ASSERTCMP(start + len, <=, PAGE_SIZE);
+       i_size = i_size_read(&vnode->vfs_inode);
+       if (pos + len > i_size)
+               eof = i_size;
+       else
+               eof = PAGE_CACHE_SIZE;
 
-       ret = afs_vnode_fetch_data(vnode, key, start, len, page);
+       ret = afs_vnode_fetch_data(vnode, key, 0, eof, page);
        if (ret < 0) {
                if (ret == -ENOENT) {
                        _debug("got NOENT from server"
@@ -107,100 +115,46 @@ static int afs_fill_page(struct afs_vnode *vnode, struct key *key,
 }
 
 /*
- * prepare a page for being written to
- */
-static int afs_prepare_page(struct afs_vnode *vnode, struct page *page,
-                           struct key *key, unsigned offset, unsigned to)
-{
-       unsigned eof, tail, start, stop, len;
-       loff_t i_size, pos;
-       void *p;
-       int ret;
-
-       _enter("");
-
-       if (offset == 0 && to == PAGE_SIZE)
-               return 0;
-
-       p = kmap_atomic(page, KM_USER0);
-
-       i_size = i_size_read(&vnode->vfs_inode);
-       pos = (loff_t) page->index << PAGE_SHIFT;
-       if (pos >= i_size) {
-               /* partial write, page beyond EOF */
-               _debug("beyond");
-               if (offset > 0)
-                       memset(p, 0, offset);
-               if (to < PAGE_SIZE)
-                       memset(p + to, 0, PAGE_SIZE - to);
-               kunmap_atomic(p, KM_USER0);
-               return 0;
-       }
-
-       if (i_size - pos >= PAGE_SIZE) {
-               /* partial write, page entirely before EOF */
-               _debug("before");
-               tail = eof = PAGE_SIZE;
-       } else {
-               /* partial write, page overlaps EOF */
-               eof = i_size - pos;
-               _debug("overlap %u", eof);
-               tail = max(eof, to);
-               if (tail < PAGE_SIZE)
-                       memset(p + tail, 0, PAGE_SIZE - tail);
-               if (offset > eof)
-                       memset(p + eof, 0, PAGE_SIZE - eof);
-       }
-
-       kunmap_atomic(p, KM_USER0);
-
-       ret = 0;
-       if (offset > 0 || eof > to) {
-               /* need to fill one or two bits that aren't going to be written
-                * (cover both fillers in one read if there are two) */
-               start = (offset > 0) ? 0 : to;
-               stop = (eof > to) ? eof : offset;
-               len = stop - start;
-               _debug("wr=%u-%u av=0-%u rd=%u@%u",
-                      offset, to, eof, start, len);
-               ret = afs_fill_page(vnode, key, start, len, page);
-       }
-
-       _leave(" = %d", ret);
-       return ret;
-}
-
-/*
  * prepare to perform part of a write to a page
- * - the caller holds the page locked, preventing it from being written out or
- *   modified by anyone else
  */
-int afs_prepare_write(struct file *file, struct page *page,
-                     unsigned offset, unsigned to)
+int afs_write_begin(struct file *file, struct address_space *mapping,
+                   loff_t pos, unsigned len, unsigned flags,
+                   struct page **pagep, void **fsdata)
 {
        struct afs_writeback *candidate, *wb;
        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
+       struct page *page;
        struct key *key = file->private_data;
-       pgoff_t index;
+       unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+       unsigned to = from + len;
+       pgoff_t index = pos >> PAGE_CACHE_SHIFT;
        int ret;
 
        _enter("{%x:%u},{%lx},%u,%u",
-              vnode->fid.vid, vnode->fid.vnode, page->index, offset, to);
+              vnode->fid.vid, vnode->fid.vnode, index, from, to);
 
        candidate = kzalloc(sizeof(*candidate), GFP_KERNEL);
        if (!candidate)
                return -ENOMEM;
        candidate->vnode = vnode;
-       candidate->first = candidate->last = page->index;
-       candidate->offset_first = offset;
+       candidate->first = candidate->last = index;
+       candidate->offset_first = from;
        candidate->to_last = to;
        candidate->usage = 1;
        candidate->state = AFS_WBACK_PENDING;
        init_waitqueue_head(&candidate->waitq);
 
+       page = grab_cache_page_write_begin(mapping, index, flags);
+       if (!page) {
+               kfree(candidate);
+               return -ENOMEM;
+       }
+       *pagep = page;
+       /* page won't leak in error case: it eventually gets cleaned off LRU */
+
        if (!PageUptodate(page)) {
                _debug("not up to date");
-               ret = afs_prepare_page(vnode, page, key, offset, to);
+               ret = afs_fill_page(vnode, key, pos, len, page);
                if (ret < 0) {
                        kfree(candidate);
                        _leave(" = %d [prep]", ret);
@@ -210,7 +164,6 @@ int afs_prepare_write(struct file *file, struct page *page,
        }
 
 try_again:
-       index = page->index;
        spin_lock(&vnode->writeback_lock);
 
        /* see if this page is already pending a writeback under a suitable key
@@ -243,8 +196,8 @@ try_again:
 subsume_in_current_wb:
        _debug("subsume");
        ASSERTRANGE(wb->first, <=, index, <=, wb->last);
-       if (index == wb->first && offset < wb->offset_first)
-               wb->offset_first = offset;
+       if (index == wb->first && from < wb->offset_first)
+               wb->offset_first = from;
        if (index == wb->last && to > wb->to_last)
                wb->to_last = to;
        spin_unlock(&vnode->writeback_lock);
@@ -290,17 +243,17 @@ flush_conflicting_wb:
 /*
  * finalise part of a write to a page
  */
-int afs_commit_write(struct file *file, struct page *page,
-                    unsigned offset, unsigned to)
+int afs_write_end(struct file *file, struct address_space *mapping,
+                 loff_t pos, unsigned len, unsigned copied,
+                 struct page *page, void *fsdata)
 {
        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
        loff_t i_size, maybe_i_size;
 
-       _enter("{%x:%u},{%lx},%u,%u",
-              vnode->fid.vid, vnode->fid.vnode, page->index, offset, to);
+       _enter("{%x:%u},{%lx}",
+              vnode->fid.vid, vnode->fid.vnode, page->index);
 
-       maybe_i_size = (loff_t) page->index << PAGE_SHIFT;
-       maybe_i_size += to;
+       maybe_i_size = pos + copied;
 
        i_size = i_size_read(&vnode->vfs_inode);
        if (maybe_i_size > i_size) {
@@ -312,11 +265,12 @@ int afs_commit_write(struct file *file, struct page *page,
        }
 
        set_page_dirty(page);
-
        if (PageDirty(page))
                _debug("dirtied");
+       unlock_page(page);
+       page_cache_release(page);
 
-       return 0;
+       return copied;
 }
 
 /*
@@ -395,8 +349,9 @@ static int afs_write_back_from_locked_page(struct afs_writeback *wb,
                if (n == 0)
                        goto no_more;
                if (pages[0]->index != start) {
-                       for (n--; n >= 0; n--)
-                               put_page(pages[n]);
+                       do {
+                               put_page(pages[--n]);
+                       } while (n > 0);
                        goto no_more;
                }
 
@@ -404,7 +359,7 @@ static int afs_write_back_from_locked_page(struct afs_writeback *wb,
                        page = pages[loop];
                        if (page->index > wb->last)
                                break;
-                       if (TestSetPageLocked(page))
+                       if (!trylock_page(page))
                                break;
                        if (!PageDirty(page) ||
                            page_private(page) != (unsigned long) wb) {
@@ -510,9 +465,9 @@ int afs_writepage(struct page *page, struct writeback_control *wbc)
 /*
  * write a region of pages back to the server
  */
-int afs_writepages_region(struct address_space *mapping,
-                         struct writeback_control *wbc,
-                         pgoff_t index, pgoff_t end, pgoff_t *_next)
+static int afs_writepages_region(struct address_space *mapping,
+                                struct writeback_control *wbc,
+                                pgoff_t index, pgoff_t end, pgoff_t *_next)
 {
        struct backing_dev_info *bdi = mapping->backing_dev_info;
        struct afs_writeback *wb;
@@ -669,7 +624,7 @@ void afs_pages_written_back(struct afs_vnode *vnode, struct afs_call *call)
        pagevec_init(&pv, 0);
 
        do {
-               _debug("attach %lx-%lx", first, last);
+               _debug("done %lx-%lx", first, last);
 
                count = last - first + 1;
                if (count > PAGEVEC_SIZE)
@@ -701,7 +656,7 @@ void afs_pages_written_back(struct afs_vnode *vnode, struct afs_call *call)
                }
 
                __pagevec_release(&pv);
-       } while (first < last);
+       } while (first <= last);
 
        _leave("");
 }
@@ -825,3 +780,24 @@ int afs_fsync(struct file *file, struct dentry *dentry, int datasync)
        _leave(" = %d", ret);
        return ret;
 }
+
+/*
+ * notification that a previously read-only page is about to become writable
+ * - if it returns an error, the caller will deliver a bus error signal
+ */
+int afs_page_mkwrite(struct vm_area_struct *vma, struct page *page)
+{
+       struct afs_vnode *vnode = AFS_FS_I(vma->vm_file->f_mapping->host);
+
+       _enter("{{%x:%u}},{%lx}",
+              vnode->fid.vid, vnode->fid.vnode, page->index);
+
+       /* wait for the page to be written to the cache before we allow it to
+        * be modified */
+#ifdef CONFIG_AFS_FSCACHE
+       fscache_wait_on_page_write(vnode->cache, page);
+#endif
+
+       _leave(" = 0");
+       return 0;
+}