[linux-2.6-block.git] / fs / afs / write.c

/* handling of writes to regular files and writing back to the server
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * 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>
#include <linux/writeback.h>
#include <linux/pagevec.h>
#include <linux/aio.h>
#include "internal.h"

static int afs_write_back_from_locked_page(struct afs_writeback *wb,
					   struct page *page);

/*
 * mark a page as having been made dirty and thus needing writeback
 */
int afs_set_page_dirty(struct page *page)
{
	_enter("");
	return __set_page_dirty_nobuffers(page);
}

/*
 * unlink a writeback record because its usage has reached zero
 * - must be called with the wb->vnode->writeback_lock held
 */
static void afs_unlink_writeback(struct afs_writeback *wb)
{
	struct afs_writeback *front;
	struct afs_vnode *vnode = wb->vnode;

	list_del_init(&wb->link);
	if (!list_empty(&vnode->writebacks)) {
		/* if an fsync rises to the front of the queue then wake it
		 * up */
		front = list_entry(vnode->writebacks.next,
				   struct afs_writeback, link);
		if (front->state == AFS_WBACK_SYNCING) {
			_debug("wake up sync");
			front->state = AFS_WBACK_COMPLETE;
			wake_up(&front->waitq);
		}
	}
}

/*
 * free a writeback record
 */
static void afs_free_writeback(struct afs_writeback *wb)
{
	_enter("");
	key_put(wb->key);
	kfree(wb);
}

/*
 * dispose of a reference to a writeback record
 */
void afs_put_writeback(struct afs_writeback *wb)
{
	struct afs_vnode *vnode = wb->vnode;

	_enter("{%d}", wb->usage);

	spin_lock(&vnode->writeback_lock);
	if (--wb->usage == 0)
		afs_unlink_writeback(wb);
	else
		wb = NULL;
	spin_unlock(&vnode->writeback_lock);
	if (wb)
		afs_free_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,
			 loff_t pos, struct page *page)
{
	loff_t i_size;
	int ret;
	int len;

	_enter(",,%llu", (unsigned long long)pos);

	i_size = i_size_read(&vnode->vfs_inode);
	if (pos + PAGE_CACHE_SIZE > i_size)
		len = i_size - pos;
	else
		len = PAGE_CACHE_SIZE;

	ret = afs_vnode_fetch_data(vnode, key, pos, len, page);
	if (ret < 0) {
		if (ret == -ENOENT) {
			_debug("got NOENT from server"
			       " - marking file deleted and stale");
			set_bit(AFS_VNODE_DELETED, &vnode->flags);
			ret = -ESTALE;
		}
	}

	_leave(" = %d", ret);
	return ret;
}

/*
 * prepare to perform part of a write to a page
 */
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_inode(file));
	struct page *page;
	struct key *key = file->private_data;
	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, index, from, to);

	candidate = kzalloc(sizeof(*candidate), GFP_KERNEL);
	if (!candidate)
		return -ENOMEM;
	candidate->vnode = vnode;
	candidate->first = candidate->last = index;
	candidate->offset_first = from;
	candidate->to_last = to;
	INIT_LIST_HEAD(&candidate->link);
	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) && len != PAGE_CACHE_SIZE) {
		ret = afs_fill_page(vnode, key, index << PAGE_CACHE_SHIFT, page);
		if (ret < 0) {
			kfree(candidate);
			_leave(" = %d [prep]", ret);
			return ret;
		}
		SetPageUptodate(page);
	}

try_again:
	spin_lock(&vnode->writeback_lock);

	/* see if this page is already pending a writeback under a suitable key
	 * - if so we can just join onto that one */
	wb = (struct afs_writeback *) page_private(page);
	if (wb) {
		if (wb->key == key && wb->state == AFS_WBACK_PENDING)
			goto subsume_in_current_wb;
		goto flush_conflicting_wb;
	}

	if (index > 0) {
		/* see if we can find an already pending writeback that we can
		 * append this page to */
		list_for_each_entry(wb, &vnode->writebacks, link) {
			if (wb->last == index - 1 && wb->key == key &&
			    wb->state == AFS_WBACK_PENDING)
				goto append_to_previous_wb;
		}
	}

	list_add_tail(&candidate->link, &vnode->writebacks);
	candidate->key = key_get(key);
	spin_unlock(&vnode->writeback_lock);
	SetPagePrivate(page);
	set_page_private(page, (unsigned long) candidate);
	_leave(" = 0 [new]");
	return 0;

subsume_in_current_wb:
	_debug("subsume");
	ASSERTRANGE(wb->first, <=, index, <=, wb->last);
	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);
	kfree(candidate);
	_leave(" = 0 [sub]");
	return 0;

append_to_previous_wb:
	_debug("append into %lx-%lx", wb->first, wb->last);
	wb->usage++;
	wb->last++;
	wb->to_last = to;
	spin_unlock(&vnode->writeback_lock);
	SetPagePrivate(page);
	set_page_private(page, (unsigned long) wb);
	kfree(candidate);
	_leave(" = 0 [app]");
	return 0;

	/* the page is currently bound to another context, so if it's dirty we
	 * need to flush it before we can use the new context */
flush_conflicting_wb:
	_debug("flush conflict");
	if (wb->state == AFS_WBACK_PENDING)
		wb->state = AFS_WBACK_CONFLICTING;
	spin_unlock(&vnode->writeback_lock);
	if (PageDirty(page)) {
		ret = afs_write_back_from_locked_page(wb, page);
		if (ret < 0) {
			afs_put_writeback(candidate);
			_leave(" = %d", ret);
			return ret;
		}
	}

	/* the page holds a ref on the writeback record */
	afs_put_writeback(wb);
	set_page_private(page, 0);
	ClearPagePrivate(page);
	goto try_again;
}

/*
 * finalise part of a write to a page
 */
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_inode(file));
	loff_t i_size, maybe_i_size;

	_enter("{%x:%u},{%lx}",
	       vnode->fid.vid, vnode->fid.vnode, page->index);

	maybe_i_size = pos + copied;

	i_size = i_size_read(&vnode->vfs_inode);
	if (maybe_i_size > i_size) {
		spin_lock(&vnode->writeback_lock);
		i_size = i_size_read(&vnode->vfs_inode);
		if (maybe_i_size > i_size)
			i_size_write(&vnode->vfs_inode, maybe_i_size);
		spin_unlock(&vnode->writeback_lock);
	}

	set_page_dirty(page);
	if (PageDirty(page))
		_debug("dirtied");
	unlock_page(page);
	page_cache_release(page);

	return copied;
}

/*
 * kill all the pages in the given range
 */
static void afs_kill_pages(struct afs_vnode *vnode, bool error,
			   pgoff_t first, pgoff_t last)
{
	struct pagevec pv;
	unsigned count, loop;

	_enter("{%x:%u},%lx-%lx",
	       vnode->fid.vid, vnode->fid.vnode, first, last);

	pagevec_init(&pv, 0);

	do {
		_debug("kill %lx-%lx", first, last);

		count = last - first + 1;
		if (count > PAGEVEC_SIZE)
			count = PAGEVEC_SIZE;
		pv.nr = find_get_pages_contig(vnode->vfs_inode.i_mapping,
					      first, count, pv.pages);
		ASSERTCMP(pv.nr, ==, count);

		for (loop = 0; loop < count; loop++) {
			ClearPageUptodate(pv.pages[loop]);
			if (error)
				SetPageError(pv.pages[loop]);
			end_page_writeback(pv.pages[loop]);
		}

		__pagevec_release(&pv);
	} while (first < last);

	_leave("");
}

/*
 * synchronously write back the locked page and any subsequent non-locked dirty
 * pages also covered by the same writeback record
 */
static int afs_write_back_from_locked_page(struct afs_writeback *wb,
					   struct page *primary_page)
{
	struct page *pages[8], *page;
	unsigned long count;
	unsigned n, offset, to;
	pgoff_t start, first, last;
	int loop, ret;

	_enter(",%lx", primary_page->index);

	count = 1;
	if (!clear_page_dirty_for_io(primary_page))
		BUG();
	if (test_set_page_writeback(primary_page))
		BUG();

	/* find all consecutive lockable dirty pages, stopping when we find a
	 * page that is not immediately lockable, is not dirty or is missing,
	 * or we reach the end of the range */
	start = primary_page->index;
	if (start >= wb->last)
		goto no_more;
	start++;
	do {
		_debug("more %lx [%lx]", start, count);
		n = wb->last - start + 1;
		if (n > ARRAY_SIZE(pages))
			n = ARRAY_SIZE(pages);
		n = find_get_pages_contig(wb->vnode->vfs_inode.i_mapping,
					  start, n, pages);
		_debug("fgpc %u", n);
		if (n == 0)
			goto no_more;
		if (pages[0]->index != start) {
			do {
				put_page(pages[--n]);
			} while (n > 0);
			goto no_more;
		}

		for (loop = 0; loop < n; loop++) {
			page = pages[loop];
			if (page->index > wb->last)
				break;
			if (!trylock_page(page))
				break;
			if (!PageDirty(page) ||
			    page_private(page) != (unsigned long) wb) {
				unlock_page(page);
				break;
			}
			if (!clear_page_dirty_for_io(page))
				BUG();
			if (test_set_page_writeback(page))
				BUG();
			unlock_page(page);
			put_page(page);
		}
		count += loop;
		if (loop < n) {
			for (; loop < n; loop++)
				put_page(pages[loop]);
			goto no_more;
		}

		start += loop;
	} while (start <= wb->last && count < 65536);

no_more:
	/* we now have a contiguous set of dirty pages, each with writeback set
	 * and the dirty mark cleared; the first page is locked and must remain
	 * so, all the rest are unlocked */
	first = primary_page->index;
	last = first + count - 1;

	offset = (first == wb->first) ? wb->offset_first : 0;
	to = (last == wb->last) ? wb->to_last : PAGE_SIZE;

	_debug("write back %lx[%u..] to %lx[..%u]", first, offset, last, to);

	ret = afs_vnode_store_data(wb, first, last, offset, to);
	if (ret < 0) {
		switch (ret) {
		case -EDQUOT:
		case -ENOSPC:
			set_bit(AS_ENOSPC,
				&wb->vnode->vfs_inode.i_mapping->flags);
			break;
		case -EROFS:
		case -EIO:
		case -EREMOTEIO:
		case -EFBIG:
		case -ENOENT:
		case -ENOMEDIUM:
		case -ENXIO:
			afs_kill_pages(wb->vnode, true, first, last);
			set_bit(AS_EIO, &wb->vnode->vfs_inode.i_mapping->flags);
			break;
		case -EACCES:
		case -EPERM:
		case -ENOKEY:
		case -EKEYEXPIRED:
		case -EKEYREJECTED:
		case -EKEYREVOKED:
			afs_kill_pages(wb->vnode, false, first, last);
			break;
		default:
			break;
		}
	} else {
		ret = count;
	}

	_leave(" = %d", ret);
	return ret;
}

/*
 * write a page back to the server
 * - the caller locked the page for us
 */
int afs_writepage(struct page *page, struct writeback_control *wbc)
{
	struct afs_writeback *wb;
	int ret;

	_enter("{%lx},", page->index);

	wb = (struct afs_writeback *) page_private(page);
	ASSERT(wb != NULL);

	ret = afs_write_back_from_locked_page(wb, page);
	unlock_page(page);
	if (ret < 0) {
		_leave(" = %d", ret);
		return 0;
	}

	wbc->nr_to_write -= ret;

	_leave(" = 0");
	return 0;
}

/*
 * write a region of pages back to the server
 */
static int afs_writepages_region(struct address_space *mapping,
				 struct writeback_control *wbc,
				 pgoff_t index, pgoff_t end, pgoff_t *_next)
{
	struct afs_writeback *wb;
	struct page *page;
	int ret, n;

	_enter(",,%lx,%lx,", index, end);

	do {
		n = find_get_pages_tag(mapping, &index, PAGECACHE_TAG_DIRTY,
				       1, &page);
		if (!n)
			break;

		_debug("wback %lx", page->index);

		if (page->index > end) {
			*_next = index;
			page_cache_release(page);
			_leave(" = 0 [%lx]", *_next);
			return 0;
		}

		/* at this point we hold neither mapping->tree_lock nor lock on
		 * the page itself: the page may be truncated or invalidated
		 * (changing page->mapping to NULL), or even swizzled back from
		 * swapper_space to tmpfs file mapping
		 */
		lock_page(page);

		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			continue;
		}

		if (wbc->sync_mode != WB_SYNC_NONE)
			wait_on_page_writeback(page);

		if (PageWriteback(page) || !PageDirty(page)) {
			unlock_page(page);
			continue;
		}

		wb = (struct afs_writeback *) page_private(page);
		ASSERT(wb != NULL);

		spin_lock(&wb->vnode->writeback_lock);
		wb->state = AFS_WBACK_WRITING;
		spin_unlock(&wb->vnode->writeback_lock);

		ret = afs_write_back_from_locked_page(wb, page);
		unlock_page(page);
		page_cache_release(page);
		if (ret < 0) {
			_leave(" = %d", ret);
			return ret;
		}

		wbc->nr_to_write -= ret;

		cond_resched();
	} while (index < end && wbc->nr_to_write > 0);

	*_next = index;
	_leave(" = 0 [%lx]", *_next);
	return 0;
}

/*
 * write some of the pending data back to the server
 */
int afs_writepages(struct address_space *mapping,
		   struct writeback_control *wbc)
{
	pgoff_t start, end, next;
	int ret;

	_enter("");

	if (wbc->range_cyclic) {
		start = mapping->writeback_index;
		end = -1;
		ret = afs_writepages_region(mapping, wbc, start, end, &next);
		if (start > 0 && wbc->nr_to_write > 0 && ret == 0)
			ret = afs_writepages_region(mapping, wbc, 0, start,
						    &next);
		mapping->writeback_index = next;
	} else if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) {
		end = (pgoff_t)(LLONG_MAX >> PAGE_CACHE_SHIFT);
		ret = afs_writepages_region(mapping, wbc, 0, end, &next);
		if (wbc->nr_to_write > 0)
			mapping->writeback_index = next;
	} else {
		start = wbc->range_start >> PAGE_CACHE_SHIFT;
		end = wbc->range_end >> PAGE_CACHE_SHIFT;
		ret = afs_writepages_region(mapping, wbc, start, end, &next);
	}

	_leave(" = %d", ret);
	return ret;
}

/*
 * completion of write to server
 */
void afs_pages_written_back(struct afs_vnode *vnode, struct afs_call *call)
{
	struct afs_writeback *wb = call->wb;
	struct pagevec pv;
	unsigned count, loop;
	pgoff_t first = call->first, last = call->last;
	bool free_wb;

	_enter("{%x:%u},{%lx-%lx}",
	       vnode->fid.vid, vnode->fid.vnode, first, last);

	ASSERT(wb != NULL);

	pagevec_init(&pv, 0);

	do {
		_debug("done %lx-%lx", first, last);

		count = last - first + 1;
		if (count > PAGEVEC_SIZE)
			count = PAGEVEC_SIZE;
		pv.nr = find_get_pages_contig(call->mapping, first, count,
					      pv.pages);
		ASSERTCMP(pv.nr, ==, count);

		spin_lock(&vnode->writeback_lock);
		for (loop = 0; loop < count; loop++) {
			struct page *page = pv.pages[loop];
			end_page_writeback(page);
			if (page_private(page) == (unsigned long) wb) {
				set_page_private(page, 0);
				ClearPagePrivate(page);
				wb->usage--;
			}
		}
		free_wb = false;
		if (wb->usage == 0) {
			afs_unlink_writeback(wb);
			free_wb = true;
		}
		spin_unlock(&vnode->writeback_lock);
		first += count;
		if (free_wb) {
			afs_free_writeback(wb);
			wb = NULL;
		}

		__pagevec_release(&pv);
	} while (first <= last);

	_leave("");
}

/*
 * write to an AFS file
 */
ssize_t afs_file_write(struct kiocb *iocb, struct iov_iter *from)
{
	struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp));
	ssize_t result;
	size_t count = iov_iter_count(from);

	_enter("{%x.%u},{%zu},",
	       vnode->fid.vid, vnode->fid.vnode, count);

	if (IS_SWAPFILE(&vnode->vfs_inode)) {
		printk(KERN_INFO
		       "AFS: Attempt to write to active swap file!\n");
		return -EBUSY;
	}

	if (!count)
		return 0;

	result = generic_file_write_iter(iocb, from);
	if (IS_ERR_VALUE(result)) {
		_leave(" = %zd", result);
		return result;
	}

	_leave(" = %zd", result);
	return result;
}

/*
 * flush the vnode to the fileserver
 */
int afs_writeback_all(struct afs_vnode *vnode)
{
	struct address_space *mapping = vnode->vfs_inode.i_mapping;
	struct writeback_control wbc = {
		.sync_mode	= WB_SYNC_ALL,
		.nr_to_write	= LONG_MAX,
		.range_cyclic	= 1,
	};
	int ret;

	_enter("");

	ret = mapping->a_ops->writepages(mapping, &wbc);
	__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);

	_leave(" = %d", ret);
	return ret;
}

/*
 * flush any dirty pages for this process, and check for write errors.
 * - the return status from this call provides a reliable indication of
 *   whether any write errors occurred for this process.
 */
int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
{
	struct inode *inode = file_inode(file);
	struct afs_writeback *wb, *xwb;
	struct afs_vnode *vnode = AFS_FS_I(inode);
	int ret;

	_enter("{%x:%u},{n=%pD},%d",
	       vnode->fid.vid, vnode->fid.vnode, file,
	       datasync);

	ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
	if (ret)
		return ret;
	mutex_lock(&inode->i_mutex);

	/* use a writeback record as a marker in the queue - when this reaches
	 * the front of the queue, all the outstanding writes are either
	 * completed or rejected */
	wb = kzalloc(sizeof(*wb), GFP_KERNEL);
	if (!wb) {
		ret = -ENOMEM;
		goto out;
	}
	wb->vnode = vnode;
	wb->first = 0;
	wb->last = -1;
	wb->offset_first = 0;
	wb->to_last = PAGE_SIZE;
	wb->usage = 1;
	wb->state = AFS_WBACK_SYNCING;
	init_waitqueue_head(&wb->waitq);

	spin_lock(&vnode->writeback_lock);
	list_for_each_entry(xwb, &vnode->writebacks, link) {
		if (xwb->state == AFS_WBACK_PENDING)
			xwb->state = AFS_WBACK_CONFLICTING;
	}
	list_add_tail(&wb->link, &vnode->writebacks);
	spin_unlock(&vnode->writeback_lock);

	/* push all the outstanding writebacks to the server */
	ret = afs_writeback_all(vnode);
	if (ret < 0) {
		afs_put_writeback(wb);
		_leave(" = %d [wb]", ret);
		goto out;
	}

	/* wait for the preceding writes to actually complete */
	ret = wait_event_interruptible(wb->waitq,
				       wb->state == AFS_WBACK_COMPLETE ||
				       vnode->writebacks.next == &wb->link);
	afs_put_writeback(wb);
	_leave(" = %d", ret);
out:
	mutex_unlock(&inode->i_mutex);
	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;
}
Commit	Line	Data
31143d5d DH	1	/* handling of writes to regular files and writing back to the server
	2	*
	3	* Copyright (C) 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	*/
4af3c9cc	11	#include <linux/backing-dev.h>
31143d5d DH	12	#include <linux/slab.h>
	13	#include <linux/fs.h>
	14	#include <linux/pagemap.h>
	15	#include <linux/writeback.h>
	16	#include <linux/pagevec.h>
a27bb332	17	#include <linux/aio.h>
31143d5d DH	18	#include "internal.h"
	19
	20	static int afs_write_back_from_locked_page(struct afs_writeback *wb,
	21	struct page *page);
	22
	23	/*
	24	* mark a page as having been made dirty and thus needing writeback
	25	*/
	26	int afs_set_page_dirty(struct page *page)
	27	{
	28	_enter("");
	29	return __set_page_dirty_nobuffers(page);
	30	}
	31
	32	/*
	33	* unlink a writeback record because its usage has reached zero
	34	* - must be called with the wb->vnode->writeback_lock held
	35	*/
	36	static void afs_unlink_writeback(struct afs_writeback *wb)
	37	{
	38	struct afs_writeback *front;
	39	struct afs_vnode *vnode = wb->vnode;
	40
	41	list_del_init(&wb->link);
	42	if (!list_empty(&vnode->writebacks)) {
	43	/* if an fsync rises to the front of the queue then wake it
	44	* up */
	45	front = list_entry(vnode->writebacks.next,
	46	struct afs_writeback, link);
	47	if (front->state == AFS_WBACK_SYNCING) {
	48	_debug("wake up sync");
	49	front->state = AFS_WBACK_COMPLETE;
	50	wake_up(&front->waitq);
	51	}
	52	}
	53	}
	54
	55	/*
	56	* free a writeback record
	57	*/
	58	static void afs_free_writeback(struct afs_writeback *wb)
	59	{
	60	_enter("");
	61	key_put(wb->key);
	62	kfree(wb);
	63	}
	64
	65	/*
	66	* dispose of a reference to a writeback record
	67	*/
	68	void afs_put_writeback(struct afs_writeback *wb)
	69	{
	70	struct afs_vnode *vnode = wb->vnode;
	71
	72	_enter("{%d}", wb->usage);
	73
	74	spin_lock(&vnode->writeback_lock);
	75	if (--wb->usage == 0)
	76	afs_unlink_writeback(wb);
	77	else
	78	wb = NULL;
	79	spin_unlock(&vnode->writeback_lock);
	80	if (wb)
	81	afs_free_writeback(wb);
82	}
83
84	/*
85	* partly or wholly fill a page that's under preparation for writing
86	*/
87	static int afs_fill_page(struct afs_vnode vnode, struct key key,
5e7f2337	88	loff_t pos, struct page *page)
31143d5d	89	{
15b4650e	90	loff_t i_size;
31143d5d	91	int ret;
5e7f2337	92	int len;
31143d5d	93
5e7f2337	94	_enter(",,%llu", (unsigned long long)pos);
31143d5d	95
15b4650e	96	i_size = i_size_read(&vnode->vfs_inode);
5e7f2337 AB	97	if (pos + PAGE_CACHE_SIZE > i_size)
5e7f2337 AB	98	len = i_size - pos;
15b4650e	99	else
5e7f2337	100	len = PAGE_CACHE_SIZE;
15b4650e	101
5e7f2337	102	ret = afs_vnode_fetch_data(vnode, key, pos, len, page);
31143d5d DH	103	if (ret < 0) {
	104	if (ret == -ENOENT) {
	105	_debug("got NOENT from server"
	106	" - marking file deleted and stale");
	107	set_bit(AFS_VNODE_DELETED, &vnode->flags);
	108	ret = -ESTALE;
	109	}
	110	}
	111
	112	_leave(" = %d", ret);
	113	return ret;
	114	}
	115
31143d5d DH	116	/*
31143d5d DH	117	* prepare to perform part of a write to a page
31143d5d	118	*/
15b4650e NP	119	int afs_write_begin(struct file file, struct address_space mapping,
	120	loff_t pos, unsigned len, unsigned flags,
	121	struct page pagep, void fsdata)
31143d5d DH	122	{
31143d5d DH	123	struct afs_writeback candidate, wb;
496ad9aa	124	struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
15b4650e	125	struct page *page;
31143d5d	126	struct key *key = file->private_data;
15b4650e NP	127	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
	128	unsigned to = from + len;
	129	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
31143d5d DH	130	int ret;
	131
	132	_enter("{%x:%u},{%lx},%u,%u",
15b4650e	133	vnode->fid.vid, vnode->fid.vnode, index, from, to);
31143d5d DH	134
	135	candidate = kzalloc(sizeof(*candidate), GFP_KERNEL);
	136	if (!candidate)
	137	return -ENOMEM;
	138	candidate->vnode = vnode;
15b4650e NP	139	candidate->first = candidate->last = index;
15b4650e NP	140	candidate->offset_first = from;
31143d5d	141	candidate->to_last = to;
f129ccc9	142	INIT_LIST_HEAD(&candidate->link);
31143d5d DH	143	candidate->usage = 1;
	144	candidate->state = AFS_WBACK_PENDING;
	145	init_waitqueue_head(&candidate->waitq);
	146
54566b2c	147	page = grab_cache_page_write_begin(mapping, index, flags);
15b4650e NP	148	if (!page) {
	149	kfree(candidate);
	150	return -ENOMEM;
	151	}
	152	*pagep = page;
	153	/* page won't leak in error case: it eventually gets cleaned off LRU */
	154
5e7f2337 AB	155	if (!PageUptodate(page) && len != PAGE_CACHE_SIZE) {
5e7f2337 AB	156	ret = afs_fill_page(vnode, key, index << PAGE_CACHE_SHIFT, page);
31143d5d DH	157	if (ret < 0) {
	158	kfree(candidate);
	159	_leave(" = %d [prep]", ret);
	160	return ret;
	161	}
15b4650e	162	SetPageUptodate(page);
31143d5d DH	163	}
	164
	165	try_again:
31143d5d DH	166	spin_lock(&vnode->writeback_lock);
	167
	168	/* see if this page is already pending a writeback under a suitable key
	169	* - if so we can just join onto that one */
	170	wb = (struct afs_writeback *) page_private(page);
	171	if (wb) {
	172	if (wb->key == key && wb->state == AFS_WBACK_PENDING)
	173	goto subsume_in_current_wb;
	174	goto flush_conflicting_wb;
	175	}
	176
	177	if (index > 0) {
	178	/* see if we can find an already pending writeback that we can
	179	* append this page to */
	180	list_for_each_entry(wb, &vnode->writebacks, link) {
	181	if (wb->last == index - 1 && wb->key == key &&
	182	wb->state == AFS_WBACK_PENDING)
	183	goto append_to_previous_wb;
	184	}
	185	}
	186
	187	list_add_tail(&candidate->link, &vnode->writebacks);
	188	candidate->key = key_get(key);
	189	spin_unlock(&vnode->writeback_lock);
	190	SetPagePrivate(page);
	191	set_page_private(page, (unsigned long) candidate);
	192	_leave(" = 0 [new]");
	193	return 0;
	194
	195	subsume_in_current_wb:
	196	_debug("subsume");
	197	ASSERTRANGE(wb->first, <=, index, <=, wb->last);
15b4650e NP	198	if (index == wb->first && from < wb->offset_first)
15b4650e NP	199	wb->offset_first = from;
31143d5d DH	200	if (index == wb->last && to > wb->to_last)
	201	wb->to_last = to;
	202	spin_unlock(&vnode->writeback_lock);
	203	kfree(candidate);
	204	_leave(" = 0 [sub]");
	205	return 0;
	206
	207	append_to_previous_wb:
	208	_debug("append into %lx-%lx", wb->first, wb->last);
	209	wb->usage++;
	210	wb->last++;
	211	wb->to_last = to;
	212	spin_unlock(&vnode->writeback_lock);
	213	SetPagePrivate(page);
	214	set_page_private(page, (unsigned long) wb);
	215	kfree(candidate);
	216	_leave(" = 0 [app]");
	217	return 0;
	218
	219	/* the page is currently bound to another context, so if it's dirty we
	220	* need to flush it before we can use the new context */
	221	flush_conflicting_wb:
	222	_debug("flush conflict");
	223	if (wb->state == AFS_WBACK_PENDING)
	224	wb->state = AFS_WBACK_CONFLICTING;
	225	spin_unlock(&vnode->writeback_lock);
	226	if (PageDirty(page)) {
	227	ret = afs_write_back_from_locked_page(wb, page);
	228	if (ret < 0) {
	229	afs_put_writeback(candidate);
	230	_leave(" = %d", ret);
	231	return ret;
	232	}
	233	}
	234
	235	/* the page holds a ref on the writeback record */
	236	afs_put_writeback(wb);
	237	set_page_private(page, 0);
	238	ClearPagePrivate(page);
	239	goto try_again;
	240	}
	241
	242	/*
	243	* finalise part of a write to a page
	244	*/
15b4650e NP	245	int afs_write_end(struct file file, struct address_space mapping,
	246	loff_t pos, unsigned len, unsigned copied,
	247	struct page page, void fsdata)
31143d5d	248	{
496ad9aa	249	struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
31143d5d DH	250	loff_t i_size, maybe_i_size;
31143d5d DH	251
15b4650e NP	252	_enter("{%x:%u},{%lx}",
15b4650e NP	253	vnode->fid.vid, vnode->fid.vnode, page->index);
31143d5d	254
15b4650e	255	maybe_i_size = pos + copied;
31143d5d DH	256
	257	i_size = i_size_read(&vnode->vfs_inode);
	258	if (maybe_i_size > i_size) {
	259	spin_lock(&vnode->writeback_lock);
	260	i_size = i_size_read(&vnode->vfs_inode);
	261	if (maybe_i_size > i_size)
	262	i_size_write(&vnode->vfs_inode, maybe_i_size);
	263	spin_unlock(&vnode->writeback_lock);
	264	}
	265
	266	set_page_dirty(page);
31143d5d DH	267	if (PageDirty(page))
31143d5d DH	268	_debug("dirtied");
15b4650e NP	269	unlock_page(page);
15b4650e NP	270	page_cache_release(page);
31143d5d	271
15b4650e	272	return copied;
31143d5d DH	273	}
	274
	275	/*
	276	* kill all the pages in the given range
	277	*/
	278	static void afs_kill_pages(struct afs_vnode *vnode, bool error,
	279	pgoff_t first, pgoff_t last)
	280	{
	281	struct pagevec pv;
	282	unsigned count, loop;
	283
	284	_enter("{%x:%u},%lx-%lx",
	285	vnode->fid.vid, vnode->fid.vnode, first, last);
	286
	287	pagevec_init(&pv, 0);
	288
	289	do {
	290	_debug("kill %lx-%lx", first, last);
	291
	292	count = last - first + 1;
	293	if (count > PAGEVEC_SIZE)
	294	count = PAGEVEC_SIZE;
	295	pv.nr = find_get_pages_contig(vnode->vfs_inode.i_mapping,
	296	first, count, pv.pages);
	297	ASSERTCMP(pv.nr, ==, count);
	298
	299	for (loop = 0; loop < count; loop++) {
	300	ClearPageUptodate(pv.pages[loop]);
	301	if (error)
	302	SetPageError(pv.pages[loop]);
	303	end_page_writeback(pv.pages[loop]);
	304	}
	305
	306	__pagevec_release(&pv);
	307	} while (first < last);
	308
	309	_leave("");
	310	}
	311
	312	/*
	313	* synchronously write back the locked page and any subsequent non-locked dirty
	314	* pages also covered by the same writeback record
	315	*/
	316	static int afs_write_back_from_locked_page(struct afs_writeback *wb,
	317	struct page *primary_page)
	318	{
	319	struct page pages[8], page;
	320	unsigned long count;
	321	unsigned n, offset, to;
	322	pgoff_t start, first, last;
	323	int loop, ret;
	324
	325	_enter(",%lx", primary_page->index);
	326
	327	count = 1;
	328	if (!clear_page_dirty_for_io(primary_page))
	329	BUG();
	330	if (test_set_page_writeback(primary_page))
	331	BUG();
	332
	333	/* find all consecutive lockable dirty pages, stopping when we find a
	334	* page that is not immediately lockable, is not dirty or is missing,
	335	* or we reach the end of the range */
	336	start = primary_page->index;
337	if (start >= wb->last)
338	goto no_more;
339	start++;
340	do {
341	_debug("more %lx [%lx]", start, count);
342	n = wb->last - start + 1;
343	if (n > ARRAY_SIZE(pages))
344	n = ARRAY_SIZE(pages);
345	n = find_get_pages_contig(wb->vnode->vfs_inode.i_mapping,
346	start, n, pages);
347	_debug("fgpc %u", n);
348	if (n == 0)
349	goto no_more;
350	if (pages[0]->index != start) {
9d577b6a DH	351	do {
	352	put_page(pages[--n]);
	353	} while (n > 0);
31143d5d DH	354	goto no_more;
	355	}
	356
	357	for (loop = 0; loop < n; loop++) {
	358	page = pages[loop];
	359	if (page->index > wb->last)
	360	break;
529ae9aa	361	if (!trylock_page(page))
31143d5d DH	362	break;
	363	if (!PageDirty(page) \|\|
	364	page_private(page) != (unsigned long) wb) {
	365	unlock_page(page);
	366	break;
	367	}
	368	if (!clear_page_dirty_for_io(page))
	369	BUG();
	370	if (test_set_page_writeback(page))
	371	BUG();
	372	unlock_page(page);
	373	put_page(page);
	374	}
	375	count += loop;
	376	if (loop < n) {
	377	for (; loop < n; loop++)
	378	put_page(pages[loop]);
	379	goto no_more;
	380	}
	381
	382	start += loop;
	383	} while (start <= wb->last && count < 65536);
	384
	385	no_more:
	386	/* we now have a contiguous set of dirty pages, each with writeback set
	387	* and the dirty mark cleared; the first page is locked and must remain
	388	* so, all the rest are unlocked */
	389	first = primary_page->index;
	390	last = first + count - 1;
	391
	392	offset = (first == wb->first) ? wb->offset_first : 0;
	393	to = (last == wb->last) ? wb->to_last : PAGE_SIZE;
	394
	395	_debug("write back %lx[%u..] to %lx[..%u]", first, offset, last, to);
	396
	397	ret = afs_vnode_store_data(wb, first, last, offset, to);
	398	if (ret < 0) {
	399	switch (ret) {
	400	case -EDQUOT:
	401	case -ENOSPC:
	402	set_bit(AS_ENOSPC,
	403	&wb->vnode->vfs_inode.i_mapping->flags);
	404	break;
	405	case -EROFS:
	406	case -EIO:
	407	case -EREMOTEIO:
	408	case -EFBIG:
	409	case -ENOENT:
	410	case -ENOMEDIUM:
	411	case -ENXIO:
	412	afs_kill_pages(wb->vnode, true, first, last);
	413	set_bit(AS_EIO, &wb->vnode->vfs_inode.i_mapping->flags);
	414	break;
	415	case -EACCES:
	416	case -EPERM:
	417	case -ENOKEY:
	418	case -EKEYEXPIRED:
	419	case -EKEYREJECTED:
	420	case -EKEYREVOKED:
	421	afs_kill_pages(wb->vnode, false, first, last);
	422	break;
	423	default:
	424	break;
	425	}
426	} else {
427	ret = count;
428	}
429
430	_leave(" = %d", ret);
431	return ret;
432	}
433
434	/*
435	* write a page back to the server
436	* - the caller locked the page for us
437	*/
438	int afs_writepage(struct page page, struct writeback_control wbc)
439	{
31143d5d DH	440	struct afs_writeback *wb;
	441	int ret;
	442
	443	_enter("{%lx},", page->index);
	444
31143d5d DH	445	wb = (struct afs_writeback *) page_private(page);
	446	ASSERT(wb != NULL);
	447
	448	ret = afs_write_back_from_locked_page(wb, page);
	449	unlock_page(page);
	450	if (ret < 0) {
	451	_leave(" = %d", ret);
	452	return 0;
	453	}
	454
	455	wbc->nr_to_write -= ret;
31143d5d DH	456
	457	_leave(" = 0");
	458	return 0;
	459	}
	460
	461	/*
	462	* write a region of pages back to the server
	463	*/
c1206a2c AB	464	static int afs_writepages_region(struct address_space *mapping,
	465	struct writeback_control *wbc,
	466	pgoff_t index, pgoff_t end, pgoff_t *_next)
31143d5d	467	{
31143d5d DH	468	struct afs_writeback *wb;
	469	struct page *page;
	470	int ret, n;
	471
	472	_enter(",,%lx,%lx,", index, end);
	473
	474	do {
	475	n = find_get_pages_tag(mapping, &index, PAGECACHE_TAG_DIRTY,
	476	1, &page);
	477	if (!n)
	478	break;
	479
	480	_debug("wback %lx", page->index);
	481
	482	if (page->index > end) {
	483	*_next = index;
	484	page_cache_release(page);
	485	_leave(" = 0 [%lx]", *_next);
	486	return 0;
	487	}
	488
	489	/* at this point we hold neither mapping->tree_lock nor lock on
	490	* the page itself: the page may be truncated or invalidated
	491	* (changing page->mapping to NULL), or even swizzled back from
	492	* swapper_space to tmpfs file mapping
	493	*/
	494	lock_page(page);
	495
	496	if (page->mapping != mapping) {
	497	unlock_page(page);
	498	page_cache_release(page);
	499	continue;
	500	}
	501
	502	if (wbc->sync_mode != WB_SYNC_NONE)
	503	wait_on_page_writeback(page);
	504
	505	if (PageWriteback(page) \|\| !PageDirty(page)) {
	506	unlock_page(page);
	507	continue;
	508	}
	509
	510	wb = (struct afs_writeback *) page_private(page);
	511	ASSERT(wb != NULL);
	512
	513	spin_lock(&wb->vnode->writeback_lock);
	514	wb->state = AFS_WBACK_WRITING;
	515	spin_unlock(&wb->vnode->writeback_lock);
	516
	517	ret = afs_write_back_from_locked_page(wb, page);
	518	unlock_page(page);
	519	page_cache_release(page);
	520	if (ret < 0) {
	521	_leave(" = %d", ret);
	522	return ret;
	523	}
	524
	525	wbc->nr_to_write -= ret;
	526
31143d5d DH	527	cond_resched();
	528	} while (index < end && wbc->nr_to_write > 0);
	529
	530	*_next = index;
	531	_leave(" = 0 [%lx]", *_next);
	532	return 0;
	533	}
	534
	535	/*
	536	* write some of the pending data back to the server
	537	*/
	538	int afs_writepages(struct address_space *mapping,
	539	struct writeback_control *wbc)
	540	{
31143d5d DH	541	pgoff_t start, end, next;
	542	int ret;
	543
	544	_enter("");
	545
31143d5d DH	546	if (wbc->range_cyclic) {
	547	start = mapping->writeback_index;
	548	end = -1;
	549	ret = afs_writepages_region(mapping, wbc, start, end, &next);
1b430bee	550	if (start > 0 && wbc->nr_to_write > 0 && ret == 0)
31143d5d DH	551	ret = afs_writepages_region(mapping, wbc, 0, start,
	552	&next);
	553	mapping->writeback_index = next;
	554	} else if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) {
	555	end = (pgoff_t)(LLONG_MAX >> PAGE_CACHE_SHIFT);
	556	ret = afs_writepages_region(mapping, wbc, 0, end, &next);
	557	if (wbc->nr_to_write > 0)
	558	mapping->writeback_index = next;
	559	} else {
	560	start = wbc->range_start >> PAGE_CACHE_SHIFT;
	561	end = wbc->range_end >> PAGE_CACHE_SHIFT;
	562	ret = afs_writepages_region(mapping, wbc, start, end, &next);
	563	}
	564
	565	_leave(" = %d", ret);
	566	return ret;
	567	}
	568
31143d5d DH	569	/*
	570	* completion of write to server
	571	*/
	572	void afs_pages_written_back(struct afs_vnode vnode, struct afs_call call)
	573	{
	574	struct afs_writeback *wb = call->wb;
	575	struct pagevec pv;
	576	unsigned count, loop;
	577	pgoff_t first = call->first, last = call->last;
	578	bool free_wb;
	579
	580	_enter("{%x:%u},{%lx-%lx}",
	581	vnode->fid.vid, vnode->fid.vnode, first, last);
	582
	583	ASSERT(wb != NULL);
	584
	585	pagevec_init(&pv, 0);
	586
	587	do {
5bbf5d39	588	_debug("done %lx-%lx", first, last);
31143d5d DH	589
	590	count = last - first + 1;
	591	if (count > PAGEVEC_SIZE)
	592	count = PAGEVEC_SIZE;
	593	pv.nr = find_get_pages_contig(call->mapping, first, count,
	594	pv.pages);
	595	ASSERTCMP(pv.nr, ==, count);
	596
	597	spin_lock(&vnode->writeback_lock);
	598	for (loop = 0; loop < count; loop++) {
	599	struct page *page = pv.pages[loop];
	600	end_page_writeback(page);
	601	if (page_private(page) == (unsigned long) wb) {
	602	set_page_private(page, 0);
	603	ClearPagePrivate(page);
	604	wb->usage--;
	605	}
	606	}
	607	free_wb = false;
	608	if (wb->usage == 0) {
	609	afs_unlink_writeback(wb);
	610	free_wb = true;
	611	}
	612	spin_unlock(&vnode->writeback_lock);
	613	first += count;
	614	if (free_wb) {
	615	afs_free_writeback(wb);
	616	wb = NULL;
	617	}
	618
	619	__pagevec_release(&pv);
5bbf5d39	620	} while (first <= last);
31143d5d DH	621
	622	_leave("");
	623	}
	624
	625	/*
	626	* write to an AFS file
	627	*/
50b5551d	628	ssize_t afs_file_write(struct kiocb iocb, struct iov_iter from)
31143d5d	629	{
496ad9aa	630	struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp));
31143d5d	631	ssize_t result;
50b5551d	632	size_t count = iov_iter_count(from);
31143d5d	633
50b5551d AV	634	_enter("{%x.%u},{%zu},",
50b5551d AV	635	vnode->fid.vid, vnode->fid.vnode, count);
31143d5d DH	636
	637	if (IS_SWAPFILE(&vnode->vfs_inode)) {
	638	printk(KERN_INFO
	639	"AFS: Attempt to write to active swap file!\n");
	640	return -EBUSY;
	641	}
	642
	643	if (!count)
	644	return 0;
	645
50b5551d	646	result = generic_file_write_iter(iocb, from);
31143d5d DH	647	if (IS_ERR_VALUE(result)) {
	648	_leave(" = %zd", result);
	649	return result;
	650	}
	651
31143d5d DH	652	_leave(" = %zd", result);
	653	return result;
	654	}
	655
	656	/*
	657	* flush the vnode to the fileserver
	658	*/
	659	int afs_writeback_all(struct afs_vnode *vnode)
	660	{
	661	struct address_space *mapping = vnode->vfs_inode.i_mapping;
	662	struct writeback_control wbc = {
31143d5d DH	663	.sync_mode = WB_SYNC_ALL,
31143d5d DH	664	.nr_to_write = LONG_MAX,
31143d5d DH	665	.range_cyclic = 1,
	666	};
	667	int ret;
	668
	669	_enter("");
	670
	671	ret = mapping->a_ops->writepages(mapping, &wbc);
	672	__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
	673
	674	_leave(" = %d", ret);
	675	return ret;
	676	}
	677
	678	/*
	679	* flush any dirty pages for this process, and check for write errors.
	680	* - the return status from this call provides a reliable indication of
	681	* whether any write errors occurred for this process.
	682	*/
02c24a82	683	int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
31143d5d	684	{
3c981bfc	685	struct inode *inode = file_inode(file);
31143d5d	686	struct afs_writeback wb, xwb;
3c981bfc	687	struct afs_vnode *vnode = AFS_FS_I(inode);
31143d5d DH	688	int ret;
31143d5d DH	689
3c981bfc AV	690	_enter("{%x:%u},{n=%pD},%d",
3c981bfc AV	691	vnode->fid.vid, vnode->fid.vnode, file,
31143d5d DH	692	datasync);
31143d5d DH	693
02c24a82 JB	694	ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
	695	if (ret)
	696	return ret;
	697	mutex_lock(&inode->i_mutex);
	698
31143d5d DH	699	/* use a writeback record as a marker in the queue - when this reaches
	700	* the front of the queue, all the outstanding writes are either
	701	* completed or rejected */
	702	wb = kzalloc(sizeof(*wb), GFP_KERNEL);
02c24a82 JB	703	if (!wb) {
	704	ret = -ENOMEM;
	705	goto out;
	706	}
31143d5d DH	707	wb->vnode = vnode;
	708	wb->first = 0;
	709	wb->last = -1;
	710	wb->offset_first = 0;
	711	wb->to_last = PAGE_SIZE;
	712	wb->usage = 1;
	713	wb->state = AFS_WBACK_SYNCING;
	714	init_waitqueue_head(&wb->waitq);
	715
	716	spin_lock(&vnode->writeback_lock);
	717	list_for_each_entry(xwb, &vnode->writebacks, link) {
	718	if (xwb->state == AFS_WBACK_PENDING)
	719	xwb->state = AFS_WBACK_CONFLICTING;
	720	}
	721	list_add_tail(&wb->link, &vnode->writebacks);
	722	spin_unlock(&vnode->writeback_lock);
	723
	724	/* push all the outstanding writebacks to the server */
	725	ret = afs_writeback_all(vnode);
	726	if (ret < 0) {
	727	afs_put_writeback(wb);
	728	_leave(" = %d [wb]", ret);
02c24a82	729	goto out;
31143d5d DH	730	}
	731
	732	/* wait for the preceding writes to actually complete */
	733	ret = wait_event_interruptible(wb->waitq,
	734	wb->state == AFS_WBACK_COMPLETE \|\|
	735	vnode->writebacks.next == &wb->link);
	736	afs_put_writeback(wb);
	737	_leave(" = %d", ret);
02c24a82 JB	738	out:
02c24a82 JB	739	mutex_unlock(&inode->i_mutex);
31143d5d DH	740	return ret;
31143d5d DH	741	}
9b3f26c9 DH	742
	743	/*
	744	* notification that a previously read-only page is about to become writable
	745	* - if it returns an error, the caller will deliver a bus error signal
	746	*/
	747	int afs_page_mkwrite(struct vm_area_struct vma, struct page page)
	748	{
	749	struct afs_vnode *vnode = AFS_FS_I(vma->vm_file->f_mapping->host);
	750
	751	_enter("{{%x:%u}},{%lx}",
	752	vnode->fid.vid, vnode->fid.vnode, page->index);
	753
	754	/* wait for the page to be written to the cache before we allow it to
	755	* be modified */
	756	#ifdef CONFIG_AFS_FSCACHE
	757	fscache_wait_on_page_write(vnode->cache, page);
	758	#endif
	759
	760	_leave(" = 0");
	761	return 0;
	762	}