2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* linux/fs/nfs/write.c
|
|
|
|
*
|
2006-12-13 13:23:48 -07:00
|
|
|
* Write file data over NFS.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/writeback.h>
|
2007-03-16 15:38:26 -06:00
|
|
|
#include <linux/swap.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <linux/sunrpc/clnt.h>
|
|
|
|
#include <linux/nfs_fs.h>
|
|
|
|
#include <linux/nfs_mount.h>
|
|
|
|
#include <linux/nfs_page.h>
|
2006-10-20 00:28:16 -06:00
|
|
|
#include <linux/backing-dev.h>
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
#include "delegation.h"
|
2006-12-04 22:35:38 -07:00
|
|
|
#include "internal.h"
|
2006-03-20 11:44:14 -07:00
|
|
|
#include "iostat.h"
|
2009-04-01 07:22:26 -06:00
|
|
|
#include "nfs4_fs.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define NFSDBG_FACILITY NFSDBG_PAGECACHE
|
|
|
|
|
|
|
|
#define MIN_POOL_WRITE (32)
|
|
|
|
#define MIN_POOL_COMMIT (4)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local function declarations
|
|
|
|
*/
|
2007-04-02 17:29:52 -06:00
|
|
|
static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
|
|
|
|
struct inode *inode, int ioflags);
|
nfs: don't ignore return value from nfs_pageio_add_request
Ignoring the return value from nfs_pageio_add_request can cause deadlocks.
In read path:
call nfs_pageio_add_request from readpage_async_filler
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_pageio_add_request to return 0, *WITHOUT* adding the original
request.
BUT, since return code is ignored, readpage_async_filler assumes it has
been added, and does nothing further, leaving page locked.
do_generic_mapping_read will eventually call lock_page, resulting in deadlock
In write path:
page is marked dirty by generic_perform_write
nfs_writepages is called
call nfs_pageio_add_request from nfs_page_async_flush
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_page_async_flush to return 0, *WITHOUT* adding the original
request, yet marking the request as locked (PG_BUSY) and in writeback,
clearing dirty marks.
The next time a write is done to the page, deadlock will result as
nfs_write_end calls nfs_update_request
Signed-off-by: Fred Isaman <iisaman@citi.umich.edu>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-03-19 09:24:39 -06:00
|
|
|
static void nfs_redirty_request(struct nfs_page *req);
|
2006-03-20 11:44:27 -07:00
|
|
|
static const struct rpc_call_ops nfs_write_partial_ops;
|
|
|
|
static const struct rpc_call_ops nfs_write_full_ops;
|
|
|
|
static const struct rpc_call_ops nfs_commit_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-06 21:33:20 -07:00
|
|
|
static struct kmem_cache *nfs_wdata_cachep;
|
2006-03-20 11:44:37 -07:00
|
|
|
static mempool_t *nfs_wdata_mempool;
|
2005-04-16 16:20:36 -06:00
|
|
|
static mempool_t *nfs_commit_mempool;
|
|
|
|
|
2008-04-15 14:56:39 -06:00
|
|
|
struct nfs_write_data *nfs_commitdata_alloc(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-12-06 21:33:14 -07:00
|
|
|
struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS);
|
2005-11-30 16:09:02 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (p) {
|
|
|
|
memset(p, 0, sizeof(*p));
|
|
|
|
INIT_LIST_HEAD(&p->pages);
|
2009-04-01 07:22:05 -06:00
|
|
|
p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2008-02-25 22:53:49 -07:00
|
|
|
void nfs_commit_free(struct nfs_write_data *p)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-30 16:09:02 -07:00
|
|
|
if (p && (p->pagevec != &p->page_array[0]))
|
|
|
|
kfree(p->pagevec);
|
2005-04-16 16:20:36 -06:00
|
|
|
mempool_free(p, nfs_commit_mempool);
|
|
|
|
}
|
|
|
|
|
2007-04-10 07:26:35 -06:00
|
|
|
struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
|
2006-03-20 11:44:37 -07:00
|
|
|
{
|
2006-12-06 21:33:14 -07:00
|
|
|
struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
|
2006-03-20 11:44:37 -07:00
|
|
|
|
|
|
|
if (p) {
|
|
|
|
memset(p, 0, sizeof(*p));
|
|
|
|
INIT_LIST_HEAD(&p->pages);
|
2006-09-08 10:48:54 -06:00
|
|
|
p->npages = pagecount;
|
2009-04-01 07:22:05 -06:00
|
|
|
p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
|
2006-05-24 23:40:53 -06:00
|
|
|
if (pagecount <= ARRAY_SIZE(p->page_array))
|
|
|
|
p->pagevec = p->page_array;
|
2006-03-20 11:44:37 -07:00
|
|
|
else {
|
2006-05-24 23:40:53 -06:00
|
|
|
p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
|
|
|
|
if (!p->pagevec) {
|
2006-03-20 11:44:37 -07:00
|
|
|
mempool_free(p, nfs_wdata_mempool);
|
|
|
|
p = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2008-02-25 22:53:49 -07:00
|
|
|
static void nfs_writedata_free(struct nfs_write_data *p)
|
2006-03-20 11:44:37 -07:00
|
|
|
{
|
|
|
|
if (p && (p->pagevec != &p->page_array[0]))
|
|
|
|
kfree(p->pagevec);
|
|
|
|
mempool_free(p, nfs_wdata_mempool);
|
|
|
|
}
|
|
|
|
|
2008-02-19 18:04:20 -07:00
|
|
|
void nfs_writedata_release(void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-19 18:04:20 -07:00
|
|
|
struct nfs_write_data *wdata = data;
|
|
|
|
|
|
|
|
put_nfs_open_context(wdata->args.context);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_writedata_free(wdata);
|
|
|
|
}
|
|
|
|
|
2007-07-25 12:09:54 -06:00
|
|
|
static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
|
|
|
|
{
|
|
|
|
ctx->error = error;
|
|
|
|
smp_wmb();
|
|
|
|
set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
|
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:35 -07:00
|
|
|
static struct nfs_page *nfs_page_find_request_locked(struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_page *req = NULL;
|
|
|
|
|
|
|
|
if (PagePrivate(page)) {
|
|
|
|
req = (struct nfs_page *)page_private(page);
|
|
|
|
if (req != NULL)
|
2007-06-17 11:26:38 -06:00
|
|
|
kref_get(&req->wb_kref);
|
2006-12-04 22:35:35 -07:00
|
|
|
}
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs_page *nfs_page_find_request(struct page *page)
|
|
|
|
{
|
2007-07-02 07:57:54 -06:00
|
|
|
struct inode *inode = page->mapping->host;
|
2006-12-04 22:35:35 -07:00
|
|
|
struct nfs_page *req = NULL;
|
|
|
|
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2006-12-04 22:35:35 -07:00
|
|
|
req = nfs_page_find_request_locked(page);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-12-04 22:35:35 -07:00
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Adjust the file length if we're writing beyond the end */
|
|
|
|
static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
2008-06-11 10:21:19 -06:00
|
|
|
loff_t end, i_size;
|
|
|
|
pgoff_t end_index;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-11 10:21:19 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
i_size = i_size_read(inode);
|
|
|
|
end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (i_size > 0 && page->index < end_index)
|
2008-06-11 10:21:19 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
|
|
|
|
if (i_size >= end)
|
2008-06-11 10:21:19 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
i_size_write(inode, end);
|
2008-06-11 10:21:19 -06:00
|
|
|
nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
|
|
|
|
out:
|
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-06 12:07:15 -07:00
|
|
|
/* A writeback failed: mark the page as bad, and invalidate the page cache */
|
|
|
|
static void nfs_set_pageerror(struct page *page)
|
|
|
|
{
|
|
|
|
SetPageError(page);
|
|
|
|
nfs_zap_mapping(page->mapping->host, page->mapping);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* We can set the PG_uptodate flag if we see that a write request
|
|
|
|
* covers the full page.
|
|
|
|
*/
|
|
|
|
static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
|
|
|
|
{
|
|
|
|
if (PageUptodate(page))
|
|
|
|
return;
|
|
|
|
if (base != 0)
|
|
|
|
return;
|
2006-12-04 22:35:38 -07:00
|
|
|
if (count != nfs_page_length(page))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
2006-12-04 22:35:38 -07:00
|
|
|
SetPageUptodate(page);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int wb_priority(struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
if (wbc->for_reclaim)
|
2007-04-02 17:29:52 -06:00
|
|
|
return FLUSH_HIGHPRI | FLUSH_STABLE;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (wbc->for_kupdate)
|
|
|
|
return FLUSH_LOWPRI;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-16 15:38:26 -06:00
|
|
|
/*
|
|
|
|
* NFS congestion control
|
|
|
|
*/
|
|
|
|
|
|
|
|
int nfs_congestion_kb;
|
|
|
|
|
|
|
|
#define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10))
|
|
|
|
#define NFS_CONGESTION_OFF_THRESH \
|
|
|
|
(NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
|
|
|
|
|
2007-04-14 17:10:12 -06:00
|
|
|
static int nfs_set_page_writeback(struct page *page)
|
2007-03-16 15:38:26 -06:00
|
|
|
{
|
2007-04-14 17:10:12 -06:00
|
|
|
int ret = test_set_page_writeback(page);
|
|
|
|
|
|
|
|
if (!ret) {
|
2007-03-16 15:38:26 -06:00
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct nfs_server *nfss = NFS_SERVER(inode);
|
|
|
|
|
2007-05-08 01:35:12 -06:00
|
|
|
if (atomic_long_inc_return(&nfss->writeback) >
|
2007-03-16 15:38:26 -06:00
|
|
|
NFS_CONGESTION_ON_THRESH)
|
|
|
|
set_bdi_congested(&nfss->backing_dev_info, WRITE);
|
|
|
|
}
|
2007-04-14 17:10:12 -06:00
|
|
|
return ret;
|
2007-03-16 15:38:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_end_page_writeback(struct page *page)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct nfs_server *nfss = NFS_SERVER(inode);
|
|
|
|
|
|
|
|
end_page_writeback(page);
|
2007-10-17 00:25:41 -06:00
|
|
|
if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
|
2007-03-16 15:38:26 -06:00
|
|
|
clear_bdi_congested(&nfss->backing_dev_info, WRITE);
|
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:41 -07:00
|
|
|
/*
|
|
|
|
* Find an associated nfs write request, and prepare to flush it out
|
2007-07-22 15:09:05 -06:00
|
|
|
* May return an error if the user signalled nfs_wait_on_request().
|
2006-12-04 22:35:41 -07:00
|
|
|
*/
|
2007-04-02 17:29:52 -06:00
|
|
|
static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
|
|
|
|
struct page *page)
|
2006-12-04 22:35:41 -07:00
|
|
|
{
|
2007-07-02 07:57:54 -06:00
|
|
|
struct inode *inode = page->mapping->host;
|
2006-12-04 22:35:41 -07:00
|
|
|
struct nfs_page *req;
|
|
|
|
int ret;
|
|
|
|
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2006-12-04 22:35:41 -07:00
|
|
|
for(;;) {
|
|
|
|
req = nfs_page_find_request_locked(page);
|
|
|
|
if (req == NULL) {
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2007-07-22 15:09:05 -06:00
|
|
|
return 0;
|
2006-12-04 22:35:41 -07:00
|
|
|
}
|
2008-01-22 15:13:07 -07:00
|
|
|
if (nfs_set_page_tag_locked(req))
|
2006-12-04 22:35:41 -07:00
|
|
|
break;
|
|
|
|
/* Note: If we hold the page lock, as is the case in nfs_writepage,
|
2008-01-22 15:13:07 -07:00
|
|
|
* then the call to nfs_set_page_tag_locked() will always
|
2006-12-04 22:35:41 -07:00
|
|
|
* succeed provided that someone hasn't already marked the
|
|
|
|
* request as dirty (in which case we don't care).
|
|
|
|
*/
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-12-04 22:35:41 -07:00
|
|
|
ret = nfs_wait_on_request(req);
|
|
|
|
nfs_release_request(req);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2006-12-04 22:35:41 -07:00
|
|
|
}
|
2008-06-13 11:25:22 -06:00
|
|
|
if (test_bit(PG_CLEAN, &req->wb_flags)) {
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2008-06-13 11:25:22 -06:00
|
|
|
BUG();
|
2007-04-20 14:12:45 -06:00
|
|
|
}
|
2007-04-02 17:29:52 -06:00
|
|
|
if (nfs_set_page_writeback(page) != 0) {
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2007-04-02 17:29:52 -06:00
|
|
|
BUG();
|
|
|
|
}
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
nfs: don't ignore return value from nfs_pageio_add_request
Ignoring the return value from nfs_pageio_add_request can cause deadlocks.
In read path:
call nfs_pageio_add_request from readpage_async_filler
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_pageio_add_request to return 0, *WITHOUT* adding the original
request.
BUT, since return code is ignored, readpage_async_filler assumes it has
been added, and does nothing further, leaving page locked.
do_generic_mapping_read will eventually call lock_page, resulting in deadlock
In write path:
page is marked dirty by generic_perform_write
nfs_writepages is called
call nfs_pageio_add_request from nfs_page_async_flush
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_page_async_flush to return 0, *WITHOUT* adding the original
request, yet marking the request as locked (PG_BUSY) and in writeback,
clearing dirty marks.
The next time a write is done to the page, deadlock will result as
nfs_write_end calls nfs_update_request
Signed-off-by: Fred Isaman <iisaman@citi.umich.edu>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-03-19 09:24:39 -06:00
|
|
|
if (!nfs_pageio_add_request(pgio, req)) {
|
|
|
|
nfs_redirty_request(req);
|
|
|
|
return pgio->pg_error;
|
|
|
|
}
|
2007-07-22 15:09:05 -06:00
|
|
|
return 0;
|
2006-12-04 22:35:41 -07:00
|
|
|
}
|
|
|
|
|
2007-07-22 17:27:32 -06:00
|
|
|
static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
|
|
|
|
nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
|
|
|
|
|
2007-05-20 08:18:27 -06:00
|
|
|
nfs_pageio_cond_complete(pgio, page->index);
|
2007-07-22 17:27:32 -06:00
|
|
|
return nfs_page_async_flush(pgio, page);
|
|
|
|
}
|
2007-05-20 08:18:27 -06:00
|
|
|
|
2007-07-22 17:27:32 -06:00
|
|
|
/*
|
|
|
|
* Write an mmapped page to the server.
|
|
|
|
*/
|
|
|
|
static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
struct nfs_pageio_descriptor pgio;
|
|
|
|
int err;
|
2006-12-04 22:35:38 -07:00
|
|
|
|
2007-07-22 17:27:32 -06:00
|
|
|
nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc));
|
|
|
|
err = nfs_do_writepage(page, wbc, &pgio);
|
|
|
|
nfs_pageio_complete(&pgio);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (pgio.pg_error < 0)
|
|
|
|
return pgio.pg_error;
|
|
|
|
return 0;
|
2006-12-04 22:35:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_writepage(struct page *page, struct writeback_control *wbc)
|
|
|
|
{
|
2007-07-22 17:27:32 -06:00
|
|
|
int ret;
|
2006-12-04 22:35:41 -07:00
|
|
|
|
2007-07-22 17:27:32 -06:00
|
|
|
ret = nfs_writepage_locked(page, wbc);
|
2005-04-16 16:20:36 -06:00
|
|
|
unlock_page(page);
|
2007-07-22 17:27:32 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = nfs_do_writepage(page, wbc, data);
|
|
|
|
unlock_page(page);
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
2009-03-11 12:10:30 -06:00
|
|
|
unsigned long *bitlock = &NFS_I(inode)->flags;
|
2007-04-02 17:29:52 -06:00
|
|
|
struct nfs_pageio_descriptor pgio;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
|
|
|
|
2009-03-11 12:10:30 -06:00
|
|
|
/* Stop dirtying of new pages while we sync */
|
|
|
|
err = wait_on_bit_lock(bitlock, NFS_INO_FLUSHING,
|
|
|
|
nfs_wait_bit_killable, TASK_KILLABLE);
|
|
|
|
if (err)
|
|
|
|
goto out_err;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
|
|
|
|
|
2007-04-02 17:29:52 -06:00
|
|
|
nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
|
2007-07-22 17:27:32 -06:00
|
|
|
err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
|
2007-04-02 17:29:52 -06:00
|
|
|
nfs_pageio_complete(&pgio);
|
2009-03-11 12:10:30 -06:00
|
|
|
|
|
|
|
clear_bit_unlock(NFS_INO_FLUSHING, bitlock);
|
|
|
|
smp_mb__after_clear_bit();
|
|
|
|
wake_up_bit(bitlock, NFS_INO_FLUSHING);
|
|
|
|
|
2007-07-22 17:27:32 -06:00
|
|
|
if (err < 0)
|
2009-03-11 12:10:30 -06:00
|
|
|
goto out_err;
|
|
|
|
err = pgio.pg_error;
|
|
|
|
if (err < 0)
|
|
|
|
goto out_err;
|
2007-04-02 17:29:52 -06:00
|
|
|
return 0;
|
2009-03-11 12:10:30 -06:00
|
|
|
out_err:
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert a write request into an inode
|
|
|
|
*/
|
2008-06-13 10:12:32 -06:00
|
|
|
static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int error;
|
|
|
|
|
2008-06-13 10:12:32 -06:00
|
|
|
error = radix_tree_preload(GFP_NOFS);
|
|
|
|
if (error != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Lock the request! */
|
|
|
|
nfs_lock_request_dontget(req);
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
|
2008-02-05 00:48:37 -07:00
|
|
|
BUG_ON(error);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!nfsi->npages) {
|
|
|
|
igrab(inode);
|
|
|
|
if (nfs_have_delegation(inode, FMODE_WRITE))
|
|
|
|
nfsi->change_attr++;
|
|
|
|
}
|
2006-03-20 11:44:50 -07:00
|
|
|
SetPagePrivate(req->wb_page);
|
2006-12-04 22:35:35 -07:00
|
|
|
set_page_private(req->wb_page, (unsigned long)req);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsi->npages++;
|
2007-06-17 11:26:38 -06:00
|
|
|
kref_get(&req->wb_kref);
|
2008-02-05 00:48:37 -07:00
|
|
|
radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
|
|
|
|
NFS_PAGE_TAG_LOCKED);
|
2008-06-13 10:12:32 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
radix_tree_preload_end();
|
|
|
|
out:
|
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-03-16 15:38:26 -06:00
|
|
|
* Remove a write request from an inode
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static void nfs_inode_remove_request(struct nfs_page *req)
|
|
|
|
{
|
2007-06-05 08:42:27 -06:00
|
|
|
struct inode *inode = req->wb_context->path.dentry->d_inode;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
BUG_ON (!NFS_WBACK_BUSY(req));
|
|
|
|
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2006-12-04 22:35:35 -07:00
|
|
|
set_page_private(req->wb_page, 0);
|
2006-03-20 11:44:50 -07:00
|
|
|
ClearPagePrivate(req->wb_page);
|
2005-04-16 16:20:36 -06:00
|
|
|
radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
|
|
|
|
nfsi->npages--;
|
|
|
|
if (!nfsi->npages) {
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
iput(inode);
|
|
|
|
} else
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_clear_request(req);
|
|
|
|
nfs_release_request(req);
|
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:42 -07:00
|
|
|
static void
|
2008-03-19 09:24:38 -06:00
|
|
|
nfs_mark_request_dirty(struct nfs_page *req)
|
2006-12-04 22:35:42 -07:00
|
|
|
{
|
|
|
|
__set_page_dirty_nobuffers(req->wb_page);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
|
|
|
/*
|
|
|
|
* Add a request to the inode's commit list.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
nfs_mark_request_commit(struct nfs_page *req)
|
|
|
|
{
|
2007-06-05 08:42:27 -06:00
|
|
|
struct inode *inode = req->wb_context->path.dentry->d_inode;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2008-06-13 11:25:22 -06:00
|
|
|
set_bit(PG_CLEAN, &(req)->wb_flags);
|
2007-06-17 13:27:42 -06:00
|
|
|
radix_tree_tag_set(&nfsi->nfs_page_tree,
|
|
|
|
req->wb_index,
|
|
|
|
NFS_PAGE_TAG_COMMIT);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-06-30 02:55:40 -06:00
|
|
|
inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
|
2007-10-17 00:25:47 -06:00
|
|
|
inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE);
|
2006-12-04 22:45:19 -07:00
|
|
|
__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-04-20 14:12:34 -06:00
|
|
|
|
2008-06-13 11:25:22 -06:00
|
|
|
static int
|
|
|
|
nfs_clear_request_commit(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
struct page *page = req->wb_page;
|
|
|
|
|
|
|
|
if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) {
|
|
|
|
dec_zone_page_state(page, NR_UNSTABLE_NFS);
|
|
|
|
dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-20 14:12:34 -06:00
|
|
|
static inline
|
|
|
|
int nfs_write_need_commit(struct nfs_write_data *data)
|
|
|
|
{
|
|
|
|
return data->verf.committed != NFS_FILE_SYNC;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
int nfs_reschedule_unstable_write(struct nfs_page *req)
|
|
|
|
{
|
2008-06-13 11:25:22 -06:00
|
|
|
if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) {
|
2007-04-20 14:12:34 -06:00
|
|
|
nfs_mark_request_commit(req);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) {
|
2008-03-19 09:24:38 -06:00
|
|
|
nfs_mark_request_dirty(req);
|
2007-04-20 14:12:34 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void
|
|
|
|
nfs_mark_request_commit(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-06-13 11:25:22 -06:00
|
|
|
static inline int
|
|
|
|
nfs_clear_request_commit(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-20 14:12:34 -06:00
|
|
|
static inline
|
|
|
|
int nfs_write_need_commit(struct nfs_write_data *data)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
int nfs_reschedule_unstable_write(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for a request to complete.
|
|
|
|
*
|
2007-12-06 14:24:39 -07:00
|
|
|
* Interruptible by fatal signals only.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-04-17 15:22:13 -06:00
|
|
|
static int nfs_wait_on_requests_locked(struct inode *inode, pgoff_t idx_start, unsigned int npages)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
struct nfs_page *req;
|
2007-04-17 15:22:13 -06:00
|
|
|
pgoff_t idx_end, next;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int res = 0;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (npages == 0)
|
|
|
|
idx_end = ~0;
|
|
|
|
else
|
|
|
|
idx_end = idx_start + npages - 1;
|
|
|
|
|
|
|
|
next = idx_start;
|
2007-06-17 13:10:24 -06:00
|
|
|
while (radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree, (void **)&req, next, 1, NFS_PAGE_TAG_LOCKED)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (req->wb_index > idx_end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
next = req->wb_index + 1;
|
2005-06-22 11:16:30 -06:00
|
|
|
BUG_ON(!NFS_WBACK_BUSY(req));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-17 11:26:38 -06:00
|
|
|
kref_get(&req->wb_kref);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
error = nfs_wait_on_request(req);
|
|
|
|
nfs_release_request(req);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error < 0)
|
|
|
|
return error;
|
|
|
|
res++;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-07-05 11:17:12 -06:00
|
|
|
static void nfs_cancel_commit_list(struct list_head *head)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
while(!list_empty(head)) {
|
|
|
|
req = nfs_list_entry(head->next);
|
|
|
|
nfs_list_remove_request(req);
|
2008-06-13 11:25:22 -06:00
|
|
|
nfs_clear_request_commit(req);
|
2006-07-05 11:17:12 -06:00
|
|
|
nfs_inode_remove_request(req);
|
2006-10-20 00:28:38 -06:00
|
|
|
nfs_unlock_request(req);
|
2006-07-05 11:17:12 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-16 06:13:41 -06:00
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
2009-03-11 12:10:29 -06:00
|
|
|
static int
|
|
|
|
nfs_need_commit(struct nfs_inode *nfsi)
|
|
|
|
{
|
|
|
|
return radix_tree_tagged(&nfsi->nfs_page_tree, NFS_PAGE_TAG_COMMIT);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* nfs_scan_commit - Scan an inode for commit requests
|
|
|
|
* @inode: NFS inode to scan
|
|
|
|
* @dst: destination list
|
|
|
|
* @idx_start: lower bound of page->index to scan.
|
|
|
|
* @npages: idx_start + npages sets the upper bound to scan.
|
|
|
|
*
|
|
|
|
* Moves requests from the inode's 'commit' request list.
|
|
|
|
* The requests are *not* checked to ensure that they form a contiguous set.
|
|
|
|
*/
|
|
|
|
static int
|
2007-04-17 15:22:13 -06:00
|
|
|
nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2005-06-22 11:16:31 -06:00
|
|
|
|
2009-03-11 12:10:29 -06:00
|
|
|
if (!nfs_need_commit(nfsi))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return nfs_scan_list(nfsi, dst, idx_start, npages, NFS_PAGE_TAG_COMMIT);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-03-20 11:44:51 -07:00
|
|
|
#else
|
2009-03-11 12:10:29 -06:00
|
|
|
static inline int nfs_need_commit(struct nfs_inode *nfsi)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-17 15:22:13 -06:00
|
|
|
static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
|
2006-03-20 11:44:51 -07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
2008-06-13 10:12:32 -06:00
|
|
|
* Search for an existing write request, and attempt to update
|
|
|
|
* it to reflect a new dirty region on a given page.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-06-13 10:12:32 -06:00
|
|
|
* If the attempt fails, then the existing request is flushed out
|
|
|
|
* to disk.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-06-13 10:12:32 -06:00
|
|
|
static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
|
|
|
|
struct page *page,
|
|
|
|
unsigned int offset,
|
|
|
|
unsigned int bytes)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-06-13 10:12:32 -06:00
|
|
|
struct nfs_page *req;
|
|
|
|
unsigned int rqend;
|
|
|
|
unsigned int end;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!PagePrivate(page))
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
end = offset + bytes;
|
2008-06-13 10:12:32 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (;;) {
|
2006-12-04 22:35:35 -07:00
|
|
|
req = nfs_page_find_request_locked(page);
|
2008-06-13 10:12:32 -06:00
|
|
|
if (req == NULL)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
rqend = req->wb_offset + req->wb_bytes;
|
|
|
|
/*
|
|
|
|
* Tell the caller to flush out the request if
|
|
|
|
* the offsets are non-contiguous.
|
|
|
|
* Note: nfs_flush_incompatible() will already
|
|
|
|
* have flushed out requests having wrong owners.
|
|
|
|
*/
|
2008-06-13 11:25:22 -06:00
|
|
|
if (offset > rqend
|
2008-06-13 10:12:32 -06:00
|
|
|
|| end < req->wb_offset)
|
|
|
|
goto out_flushme;
|
|
|
|
|
|
|
|
if (nfs_set_page_tag_locked(req))
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2008-06-13 10:12:32 -06:00
|
|
|
/* The request is locked, so wait and then retry */
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2008-06-13 10:12:32 -06:00
|
|
|
error = nfs_wait_on_request(req);
|
|
|
|
nfs_release_request(req);
|
|
|
|
if (error != 0)
|
|
|
|
goto out_err;
|
|
|
|
spin_lock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-06-13 11:25:22 -06:00
|
|
|
if (nfs_clear_request_commit(req))
|
|
|
|
radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree,
|
|
|
|
req->wb_index, NFS_PAGE_TAG_COMMIT);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Okay, the request matches. Update the region */
|
|
|
|
if (offset < req->wb_offset) {
|
|
|
|
req->wb_offset = offset;
|
|
|
|
req->wb_pgbase = offset;
|
|
|
|
}
|
|
|
|
if (end > rqend)
|
|
|
|
req->wb_bytes = end - req->wb_offset;
|
2008-06-13 10:12:32 -06:00
|
|
|
else
|
|
|
|
req->wb_bytes = rqend - req->wb_offset;
|
|
|
|
out_unlock:
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
return req;
|
|
|
|
out_flushme:
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
nfs_release_request(req);
|
|
|
|
error = nfs_wb_page(inode, page);
|
|
|
|
out_err:
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to update an existing write request, or create one if there is none.
|
|
|
|
*
|
|
|
|
* Note: Should always be called with the Page Lock held to prevent races
|
|
|
|
* if we have to add a new request. Also assumes that the caller has
|
|
|
|
* already called nfs_flush_incompatible() if necessary.
|
|
|
|
*/
|
|
|
|
static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
|
|
|
|
struct page *page, unsigned int offset, unsigned int bytes)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct nfs_page *req;
|
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-13 10:12:32 -06:00
|
|
|
req = nfs_try_to_update_request(inode, page, offset, bytes);
|
|
|
|
if (req != NULL)
|
|
|
|
goto out;
|
|
|
|
req = nfs_create_request(ctx, inode, page, offset, bytes);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
goto out;
|
|
|
|
error = nfs_inode_add_request(inode, req);
|
|
|
|
if (error != 0) {
|
|
|
|
nfs_release_request(req);
|
|
|
|
req = ERR_PTR(error);
|
|
|
|
}
|
2008-06-10 16:31:00 -06:00
|
|
|
out:
|
2007-10-18 15:08:05 -06:00
|
|
|
return req;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-06-13 10:12:32 -06:00
|
|
|
static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
|
|
|
|
unsigned int offset, unsigned int count)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
req = nfs_setup_write_request(ctx, page, offset, count);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
/* Update file length */
|
|
|
|
nfs_grow_file(page, offset, count);
|
|
|
|
nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
|
|
|
|
nfs_clear_page_tag_locked(req);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int nfs_flush_incompatible(struct file *file, struct page *page)
|
|
|
|
{
|
2007-08-10 15:44:32 -06:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(file);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nfs_page *req;
|
2006-12-04 22:35:40 -07:00
|
|
|
int do_flush, status;
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Look for a request corresponding to this page. If there
|
|
|
|
* is one, and it belongs to another file, we flush it out
|
|
|
|
* before we try to copy anything into the page. Do this
|
|
|
|
* due to the lack of an ACCESS-type call in NFSv2.
|
|
|
|
* Also do the same if we find a request from an existing
|
|
|
|
* dropped page.
|
|
|
|
*/
|
2006-12-04 22:35:40 -07:00
|
|
|
do {
|
|
|
|
req = nfs_page_find_request(page);
|
|
|
|
if (req == NULL)
|
|
|
|
return 0;
|
2008-06-13 11:25:22 -06:00
|
|
|
do_flush = req->wb_page != page || req->wb_context != ctx;
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_release_request(req);
|
2006-12-04 22:35:40 -07:00
|
|
|
if (!do_flush)
|
|
|
|
return 0;
|
|
|
|
status = nfs_wb_page(page->mapping->host, page);
|
|
|
|
} while (status == 0);
|
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
NFS: Fix a potential file corruption issue when writing
If the inode is flagged as having an invalid mapping, then we can't rely on
the PageUptodate() flag. Ensure that we don't use the "anti-fragmentation"
write optimisation in nfs_updatepage(), since that will cause NFS to write
out areas of the page that are no longer guaranteed to be up to date.
A potential corruption could occur in the following scenario:
client 1 client 2
=============== ===============
fd=open("f",O_CREAT|O_WRONLY,0644);
write(fd,"fubar\n",6); // cache last page
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"foo\n",4);
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"bar\n",4);
close(fd);
-----
The bug may lead to the file "f" reading 'fubar\n\0\0\0\nbar\n' because
client 2 does not update the cached page after re-opening the file for
write. Instead it keeps it marked as PageUptodate() until someone calls
invaldate_inode_pages2() (typically by calling read()).
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-02-07 15:24:07 -07:00
|
|
|
/*
|
|
|
|
* If the page cache is marked as unsafe or invalid, then we can't rely on
|
|
|
|
* the PageUptodate() flag. In this case, we will need to turn off
|
|
|
|
* write optimisations that depend on the page contents being correct.
|
|
|
|
*/
|
|
|
|
static int nfs_write_pageuptodate(struct page *page, struct inode *inode)
|
|
|
|
{
|
|
|
|
return PageUptodate(page) &&
|
|
|
|
!(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA));
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Update and possibly write a cached page of an NFS file.
|
|
|
|
*
|
|
|
|
* XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
|
|
|
|
* things with a page scheduled for an RPC call (e.g. invalidate it).
|
|
|
|
*/
|
|
|
|
int nfs_updatepage(struct file *file, struct page *page,
|
|
|
|
unsigned int offset, unsigned int count)
|
|
|
|
{
|
2007-08-10 15:44:32 -06:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(file);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
int status = 0;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
|
|
|
|
|
2008-06-11 15:56:05 -06:00
|
|
|
dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n",
|
2006-12-08 03:36:40 -07:00
|
|
|
file->f_path.dentry->d_parent->d_name.name,
|
|
|
|
file->f_path.dentry->d_name.name, count,
|
2008-06-11 15:56:05 -06:00
|
|
|
(long long)(page_offset(page) + offset));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* If we're not using byte range locks, and we know the page
|
NFS: Fix a potential file corruption issue when writing
If the inode is flagged as having an invalid mapping, then we can't rely on
the PageUptodate() flag. Ensure that we don't use the "anti-fragmentation"
write optimisation in nfs_updatepage(), since that will cause NFS to write
out areas of the page that are no longer guaranteed to be up to date.
A potential corruption could occur in the following scenario:
client 1 client 2
=============== ===============
fd=open("f",O_CREAT|O_WRONLY,0644);
write(fd,"fubar\n",6); // cache last page
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"foo\n",4);
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"bar\n",4);
close(fd);
-----
The bug may lead to the file "f" reading 'fubar\n\0\0\0\nbar\n' because
client 2 does not update the cached page after re-opening the file for
write. Instead it keeps it marked as PageUptodate() until someone calls
invaldate_inode_pages2() (typically by calling read()).
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-02-07 15:24:07 -07:00
|
|
|
* is up to date, it may be more efficient to extend the write
|
|
|
|
* to cover the entire page in order to avoid fragmentation
|
|
|
|
* inefficiencies.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
NFS: Fix a potential file corruption issue when writing
If the inode is flagged as having an invalid mapping, then we can't rely on
the PageUptodate() flag. Ensure that we don't use the "anti-fragmentation"
write optimisation in nfs_updatepage(), since that will cause NFS to write
out areas of the page that are no longer guaranteed to be up to date.
A potential corruption could occur in the following scenario:
client 1 client 2
=============== ===============
fd=open("f",O_CREAT|O_WRONLY,0644);
write(fd,"fubar\n",6); // cache last page
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"foo\n",4);
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"bar\n",4);
close(fd);
-----
The bug may lead to the file "f" reading 'fubar\n\0\0\0\nbar\n' because
client 2 does not update the cached page after re-opening the file for
write. Instead it keeps it marked as PageUptodate() until someone calls
invaldate_inode_pages2() (typically by calling read()).
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-02-07 15:24:07 -07:00
|
|
|
if (nfs_write_pageuptodate(page, inode) &&
|
|
|
|
inode->i_flock == NULL &&
|
2008-02-25 16:56:29 -07:00
|
|
|
!(file->f_flags & O_SYNC)) {
|
2006-12-04 22:35:38 -07:00
|
|
|
count = max(count + offset, nfs_page_length(page));
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = 0;
|
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:39 -07:00
|
|
|
status = nfs_writepage_setup(ctx, page, offset, count);
|
2008-06-05 14:02:35 -06:00
|
|
|
if (status < 0)
|
|
|
|
nfs_set_pageerror(page);
|
|
|
|
else
|
|
|
|
__set_page_dirty_nobuffers(page);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-11 15:56:05 -06:00
|
|
|
dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
status, (long long)i_size_read(inode));
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_writepage_release(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
|
2008-05-25 10:59:19 -06:00
|
|
|
if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req)) {
|
2007-04-20 14:12:34 -06:00
|
|
|
nfs_end_page_writeback(req->wb_page);
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
} else
|
|
|
|
nfs_end_page_writeback(req->wb_page);
|
2007-06-17 13:10:24 -06:00
|
|
|
nfs_clear_page_tag_locked(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-14 13:40:00 -06:00
|
|
|
static int flush_task_priority(int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
|
|
|
|
case FLUSH_HIGHPRI:
|
|
|
|
return RPC_PRIORITY_HIGH;
|
|
|
|
case FLUSH_LOWPRI:
|
|
|
|
return RPC_PRIORITY_LOW;
|
|
|
|
}
|
|
|
|
return RPC_PRIORITY_NORMAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the argument/result storage required for the RPC call.
|
|
|
|
*/
|
2008-04-14 12:54:53 -06:00
|
|
|
static int nfs_write_rpcsetup(struct nfs_page *req,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nfs_write_data *data,
|
2006-03-20 11:44:27 -07:00
|
|
|
const struct rpc_call_ops *call_ops,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int count, unsigned int offset,
|
|
|
|
int how)
|
|
|
|
{
|
2007-07-14 13:39:59 -06:00
|
|
|
struct inode *inode = req->wb_context->path.dentry->d_inode;
|
|
|
|
int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
|
2007-07-14 13:40:00 -06:00
|
|
|
int priority = flush_task_priority(how);
|
2007-10-25 16:42:54 -06:00
|
|
|
struct rpc_task *task;
|
2007-07-14 13:40:00 -06:00
|
|
|
struct rpc_message msg = {
|
|
|
|
.rpc_argp = &data->args,
|
|
|
|
.rpc_resp = &data->res,
|
|
|
|
.rpc_cred = req->wb_context->cred,
|
|
|
|
};
|
2007-07-14 13:39:59 -06:00
|
|
|
struct rpc_task_setup task_setup_data = {
|
|
|
|
.rpc_client = NFS_CLIENT(inode),
|
2007-10-25 16:42:54 -06:00
|
|
|
.task = &data->task,
|
2007-07-14 13:40:00 -06:00
|
|
|
.rpc_message = &msg,
|
2007-07-14 13:39:59 -06:00
|
|
|
.callback_ops = call_ops,
|
|
|
|
.callback_data = data,
|
2008-02-19 18:04:23 -07:00
|
|
|
.workqueue = nfsiod_workqueue,
|
2007-07-14 13:39:59 -06:00
|
|
|
.flags = flags,
|
2007-07-14 13:40:00 -06:00
|
|
|
.priority = priority,
|
2007-07-14 13:39:59 -06:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Set up the RPC argument and reply structs
|
|
|
|
* NB: take care not to mess about with data->commit et al. */
|
|
|
|
|
|
|
|
data->req = req;
|
2007-06-05 08:42:27 -06:00
|
|
|
data->inode = inode = req->wb_context->path.dentry->d_inode;
|
2007-07-14 13:40:00 -06:00
|
|
|
data->cred = msg.rpc_cred;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
data->args.fh = NFS_FH(inode);
|
|
|
|
data->args.offset = req_offset(req) + offset;
|
|
|
|
data->args.pgbase = req->wb_pgbase + offset;
|
|
|
|
data->args.pages = data->pagevec;
|
|
|
|
data->args.count = count;
|
2008-02-19 18:04:20 -07:00
|
|
|
data->args.context = get_nfs_open_context(req->wb_context);
|
2007-07-14 13:40:00 -06:00
|
|
|
data->args.stable = NFS_UNSTABLE;
|
|
|
|
if (how & FLUSH_STABLE) {
|
|
|
|
data->args.stable = NFS_DATA_SYNC;
|
2009-03-11 12:10:29 -06:00
|
|
|
if (!nfs_need_commit(NFS_I(inode)))
|
2007-07-14 13:40:00 -06:00
|
|
|
data->args.stable = NFS_FILE_SYNC;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
data->res.fattr = &data->fattr;
|
|
|
|
data->res.count = count;
|
|
|
|
data->res.verf = &data->verf;
|
2005-10-27 20:12:38 -06:00
|
|
|
nfs_fattr_init(&data->fattr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
/* Set up the initial task struct. */
|
2007-07-14 13:40:00 -06:00
|
|
|
NFS_PROTO(inode)->write_setup(data, &msg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:01 -07:00
|
|
|
dprintk("NFS: %5u initiated write call "
|
2008-06-11 15:56:05 -06:00
|
|
|
"(req %s/%lld, %u bytes @ offset %llu)\n",
|
2005-11-01 14:53:32 -07:00
|
|
|
data->task.tk_pid,
|
2005-04-16 16:20:36 -06:00
|
|
|
inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(inode),
|
|
|
|
count,
|
|
|
|
(unsigned long long)data->args.offset);
|
|
|
|
|
2007-10-25 16:42:54 -06:00
|
|
|
task = rpc_run_task(&task_setup_data);
|
2008-04-14 12:54:53 -06:00
|
|
|
if (IS_ERR(task))
|
|
|
|
return PTR_ERR(task);
|
|
|
|
rpc_put_task(task);
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-03-19 09:24:38 -06:00
|
|
|
/* If a nfs_flush_* function fails, it should remove reqs from @head and
|
|
|
|
* call this on each, which will prepare them to be retried on next
|
|
|
|
* writeback using standard nfs.
|
|
|
|
*/
|
|
|
|
static void nfs_redirty_request(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
nfs_mark_request_dirty(req);
|
|
|
|
nfs_end_page_writeback(req->wb_page);
|
|
|
|
nfs_clear_page_tag_locked(req);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Generate multiple small requests to write out a single
|
|
|
|
* contiguous dirty area on one page.
|
|
|
|
*/
|
2007-04-10 07:26:35 -06:00
|
|
|
static int nfs_flush_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_page *req = nfs_list_entry(head->next);
|
|
|
|
struct page *page = req->wb_page;
|
|
|
|
struct nfs_write_data *data;
|
2006-09-08 10:48:54 -06:00
|
|
|
size_t wsize = NFS_SERVER(inode)->wsize, nbytes;
|
|
|
|
unsigned int offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
int requests = 0;
|
2008-04-14 12:54:53 -06:00
|
|
|
int ret = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
nfs_list_remove_request(req);
|
|
|
|
|
2007-04-02 16:48:28 -06:00
|
|
|
nbytes = count;
|
2006-09-08 10:48:54 -06:00
|
|
|
do {
|
|
|
|
size_t len = min(nbytes, wsize);
|
|
|
|
|
2007-04-10 07:26:35 -06:00
|
|
|
data = nfs_writedata_alloc(1);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!data)
|
|
|
|
goto out_bad;
|
|
|
|
list_add(&data->pages, &list);
|
|
|
|
requests++;
|
2006-09-08 10:48:54 -06:00
|
|
|
nbytes -= len;
|
|
|
|
} while (nbytes != 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
atomic_set(&req->wb_complete, requests);
|
|
|
|
|
|
|
|
ClearPageError(page);
|
|
|
|
offset = 0;
|
2007-04-02 16:48:28 -06:00
|
|
|
nbytes = count;
|
2005-04-16 16:20:36 -06:00
|
|
|
do {
|
2008-04-14 12:54:53 -06:00
|
|
|
int ret2;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
data = list_entry(list.next, struct nfs_write_data, pages);
|
|
|
|
list_del_init(&data->pages);
|
|
|
|
|
|
|
|
data->pagevec[0] = page;
|
|
|
|
|
2007-04-02 16:48:28 -06:00
|
|
|
if (nbytes < wsize)
|
|
|
|
wsize = nbytes;
|
2008-04-14 12:54:53 -06:00
|
|
|
ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
|
2007-04-02 16:48:28 -06:00
|
|
|
wsize, offset, how);
|
2008-04-14 12:54:53 -06:00
|
|
|
if (ret == 0)
|
|
|
|
ret = ret2;
|
2007-04-02 16:48:28 -06:00
|
|
|
offset += wsize;
|
|
|
|
nbytes -= wsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
} while (nbytes != 0);
|
|
|
|
|
2008-04-14 12:54:53 -06:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
out_bad:
|
|
|
|
while (!list_empty(&list)) {
|
|
|
|
data = list_entry(list.next, struct nfs_write_data, pages);
|
|
|
|
list_del(&data->pages);
|
2006-11-13 14:23:44 -07:00
|
|
|
nfs_writedata_release(data);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-12-04 22:35:42 -07:00
|
|
|
nfs_redirty_request(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create an RPC task for the given write request and kick it.
|
|
|
|
* The page must have been locked by the caller.
|
|
|
|
*
|
|
|
|
* It may happen that the page we're passed is not marked dirty.
|
|
|
|
* This is the case if nfs_updatepage detects a conflicting request
|
|
|
|
* that has been written but not committed.
|
|
|
|
*/
|
2007-04-10 07:26:35 -06:00
|
|
|
static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
struct page **pages;
|
|
|
|
struct nfs_write_data *data;
|
|
|
|
|
2007-04-10 07:26:35 -06:00
|
|
|
data = nfs_writedata_alloc(npages);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!data)
|
|
|
|
goto out_bad;
|
|
|
|
|
|
|
|
pages = data->pagevec;
|
|
|
|
while (!list_empty(head)) {
|
|
|
|
req = nfs_list_entry(head->next);
|
|
|
|
nfs_list_remove_request(req);
|
|
|
|
nfs_list_add_request(req, &data->pages);
|
|
|
|
ClearPageError(req->wb_page);
|
|
|
|
*pages++ = req->wb_page;
|
|
|
|
}
|
|
|
|
req = nfs_list_entry(data->pages.next);
|
|
|
|
|
|
|
|
/* Set up the argument struct */
|
2008-04-14 12:54:53 -06:00
|
|
|
return nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
|
2005-04-16 16:20:36 -06:00
|
|
|
out_bad:
|
|
|
|
while (!list_empty(head)) {
|
2007-05-14 15:16:04 -06:00
|
|
|
req = nfs_list_entry(head->next);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_list_remove_request(req);
|
2006-12-04 22:35:42 -07:00
|
|
|
nfs_redirty_request(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2007-04-02 17:29:52 -06:00
|
|
|
static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
|
|
|
|
struct inode *inode, int ioflags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-12-20 12:54:57 -07:00
|
|
|
size_t wsize = NFS_SERVER(inode)->wsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-02 16:48:28 -06:00
|
|
|
if (wsize < PAGE_CACHE_SIZE)
|
2007-04-02 17:29:52 -06:00
|
|
|
nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
|
2007-04-02 16:48:28 -06:00
|
|
|
else
|
2007-04-02 17:29:52 -06:00
|
|
|
nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle a write reply that flushed part of a page.
|
|
|
|
*/
|
2006-03-20 11:44:27 -07:00
|
|
|
static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-03-20 11:44:27 -07:00
|
|
|
struct nfs_write_data *data = calldata;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-11 15:56:05 -06:00
|
|
|
dprintk("NFS: %5u write(%s/%lld %d@%lld)",
|
|
|
|
task->tk_pid,
|
|
|
|
data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
|
|
|
|
(long long)
|
|
|
|
NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
|
|
|
|
data->req->wb_bytes, (long long)req_offset(data->req));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-15 14:56:39 -06:00
|
|
|
nfs_writeback_done(task, data);
|
|
|
|
}
|
2006-03-20 11:44:27 -07:00
|
|
|
|
2008-04-15 14:56:39 -06:00
|
|
|
static void nfs_writeback_release_partial(void *calldata)
|
|
|
|
{
|
|
|
|
struct nfs_write_data *data = calldata;
|
|
|
|
struct nfs_page *req = data->req;
|
|
|
|
struct page *page = req->wb_page;
|
|
|
|
int status = data->task.tk_status;
|
|
|
|
|
|
|
|
if (status < 0) {
|
2007-02-06 12:07:15 -07:00
|
|
|
nfs_set_pageerror(page);
|
2008-04-15 14:56:39 -06:00
|
|
|
nfs_context_set_write_error(req->wb_context, status);
|
|
|
|
dprintk(", error = %d\n", status);
|
2007-04-20 14:12:34 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-04-20 14:12:34 -06:00
|
|
|
if (nfs_write_need_commit(data)) {
|
2007-07-02 07:57:54 -06:00
|
|
|
struct inode *inode = page->mapping->host;
|
2007-04-20 14:12:34 -06:00
|
|
|
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2007-04-20 14:12:34 -06:00
|
|
|
if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
|
|
|
|
/* Do nothing we need to resend the writes */
|
|
|
|
} else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
|
|
|
|
memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
|
|
|
|
dprintk(" defer commit\n");
|
|
|
|
} else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
|
|
|
|
set_bit(PG_NEED_RESCHED, &req->wb_flags);
|
|
|
|
clear_bit(PG_NEED_COMMIT, &req->wb_flags);
|
|
|
|
dprintk(" server reboot detected\n");
|
|
|
|
}
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2007-04-20 14:12:34 -06:00
|
|
|
} else
|
|
|
|
dprintk(" OK\n");
|
|
|
|
|
|
|
|
out:
|
2005-04-16 16:20:36 -06:00
|
|
|
if (atomic_dec_and_test(&req->wb_complete))
|
|
|
|
nfs_writepage_release(req);
|
2008-04-15 14:56:39 -06:00
|
|
|
nfs_writedata_release(calldata);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-04-01 07:22:26 -06:00
|
|
|
#if defined(CONFIG_NFS_V4_1)
|
|
|
|
void nfs_write_prepare(struct rpc_task *task, void *calldata)
|
|
|
|
{
|
|
|
|
struct nfs_write_data *data = calldata;
|
|
|
|
struct nfs_client *clp = (NFS_SERVER(data->inode))->nfs_client;
|
|
|
|
|
|
|
|
if (nfs4_setup_sequence(clp, &data->args.seq_args,
|
|
|
|
&data->res.seq_res, 1, task))
|
|
|
|
return;
|
|
|
|
rpc_call_start(task);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFS_V4_1 */
|
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
static const struct rpc_call_ops nfs_write_partial_ops = {
|
2009-04-01 07:22:26 -06:00
|
|
|
#if defined(CONFIG_NFS_V4_1)
|
|
|
|
.rpc_call_prepare = nfs_write_prepare,
|
|
|
|
#endif /* CONFIG_NFS_V4_1 */
|
2006-03-20 11:44:27 -07:00
|
|
|
.rpc_call_done = nfs_writeback_done_partial,
|
2008-04-15 14:56:39 -06:00
|
|
|
.rpc_release = nfs_writeback_release_partial,
|
2006-03-20 11:44:27 -07:00
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Handle a write reply that flushes a whole page.
|
|
|
|
*
|
|
|
|
* FIXME: There is an inherent race with invalidate_inode_pages and
|
|
|
|
* writebacks since the page->count is kept > 1 for as long
|
|
|
|
* as the page has a write request pending.
|
|
|
|
*/
|
2006-03-20 11:44:27 -07:00
|
|
|
static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-03-20 11:44:27 -07:00
|
|
|
struct nfs_write_data *data = calldata;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-15 14:56:39 -06:00
|
|
|
nfs_writeback_done(task, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_writeback_release_full(void *calldata)
|
|
|
|
{
|
|
|
|
struct nfs_write_data *data = calldata;
|
|
|
|
int status = data->task.tk_status;
|
2006-03-20 11:44:27 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Update attributes as result of writeback. */
|
|
|
|
while (!list_empty(&data->pages)) {
|
2008-04-15 14:56:39 -06:00
|
|
|
struct nfs_page *req = nfs_list_entry(data->pages.next);
|
|
|
|
struct page *page = req->wb_page;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_list_remove_request(req);
|
|
|
|
|
2008-06-11 15:56:05 -06:00
|
|
|
dprintk("NFS: %5u write (%s/%lld %d@%lld)",
|
|
|
|
data->task.tk_pid,
|
2007-06-05 08:42:27 -06:00
|
|
|
req->wb_context->path.dentry->d_inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
|
2005-04-16 16:20:36 -06:00
|
|
|
req->wb_bytes,
|
|
|
|
(long long)req_offset(req));
|
|
|
|
|
2008-04-15 14:56:39 -06:00
|
|
|
if (status < 0) {
|
2007-02-06 12:07:15 -07:00
|
|
|
nfs_set_pageerror(page);
|
2008-04-15 14:56:39 -06:00
|
|
|
nfs_context_set_write_error(req->wb_context, status);
|
|
|
|
dprintk(", error = %d\n", status);
|
2007-04-20 14:12:34 -06:00
|
|
|
goto remove_request;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-04-20 14:12:34 -06:00
|
|
|
if (nfs_write_need_commit(data)) {
|
|
|
|
memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
|
|
|
|
nfs_mark_request_commit(req);
|
|
|
|
nfs_end_page_writeback(page);
|
|
|
|
dprintk(" marked for commit\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
goto next;
|
|
|
|
}
|
2007-04-20 14:12:34 -06:00
|
|
|
dprintk(" OK\n");
|
|
|
|
remove_request:
|
|
|
|
nfs_end_page_writeback(page);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
next:
|
2007-06-17 13:10:24 -06:00
|
|
|
nfs_clear_page_tag_locked(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-04-15 14:56:39 -06:00
|
|
|
nfs_writedata_release(calldata);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
static const struct rpc_call_ops nfs_write_full_ops = {
|
2009-04-01 07:22:26 -06:00
|
|
|
#if defined(CONFIG_NFS_V4_1)
|
|
|
|
.rpc_call_prepare = nfs_write_prepare,
|
|
|
|
#endif /* CONFIG_NFS_V4_1 */
|
2006-03-20 11:44:27 -07:00
|
|
|
.rpc_call_done = nfs_writeback_done_full,
|
2008-04-15 14:56:39 -06:00
|
|
|
.rpc_release = nfs_writeback_release_full,
|
2006-03-20 11:44:27 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This function is called when the WRITE call is complete.
|
|
|
|
*/
|
2006-03-20 11:44:32 -07:00
|
|
|
int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_writeargs *argp = &data->args;
|
|
|
|
struct nfs_writeres *resp = &data->res;
|
2009-04-01 07:22:41 -06:00
|
|
|
struct nfs_server *server = NFS_SERVER(data->inode);
|
2006-03-20 11:44:27 -07:00
|
|
|
int status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:01 -07:00
|
|
|
dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_pid, task->tk_status);
|
|
|
|
|
2006-09-20 12:33:04 -06:00
|
|
|
/*
|
|
|
|
* ->write_done will attempt to use post-op attributes to detect
|
|
|
|
* conflicting writes by other clients. A strict interpretation
|
|
|
|
* of close-to-open would allow us to continue caching even if
|
|
|
|
* another writer had changed the file, but some applications
|
|
|
|
* depend on tighter cache coherency when writing.
|
|
|
|
*/
|
2006-03-20 11:44:27 -07:00
|
|
|
status = NFS_PROTO(data->inode)->write_done(task, data);
|
|
|
|
if (status != 0)
|
|
|
|
return status;
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
|
|
|
if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
|
|
|
|
/* We tried a write call, but the server did not
|
|
|
|
* commit data to stable storage even though we
|
|
|
|
* requested it.
|
|
|
|
* Note: There is a known bug in Tru64 < 5.0 in which
|
|
|
|
* the server reports NFS_DATA_SYNC, but performs
|
|
|
|
* NFS_FILE_SYNC. We therefore implement this checking
|
|
|
|
* as a dprintk() in order to avoid filling syslog.
|
|
|
|
*/
|
|
|
|
static unsigned long complain;
|
|
|
|
|
|
|
|
if (time_before(complain, jiffies)) {
|
2008-06-11 15:56:05 -06:00
|
|
|
dprintk("NFS: faulty NFS server %s:"
|
2005-04-16 16:20:36 -06:00
|
|
|
" (committed = %d) != (stable = %d)\n",
|
2009-04-01 07:22:41 -06:00
|
|
|
server->nfs_client->cl_hostname,
|
2005-04-16 16:20:36 -06:00
|
|
|
resp->verf->committed, argp->stable);
|
|
|
|
complain = jiffies + 300 * HZ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Is this a short write? */
|
|
|
|
if (task->tk_status >= 0 && resp->count < argp->count) {
|
|
|
|
static unsigned long complain;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Has the server at least made some progress? */
|
|
|
|
if (resp->count != 0) {
|
|
|
|
/* Was this an NFSv2 write or an NFSv3 stable write? */
|
|
|
|
if (resp->verf->committed != NFS_UNSTABLE) {
|
|
|
|
/* Resend from where the server left off */
|
|
|
|
argp->offset += resp->count;
|
|
|
|
argp->pgbase += resp->count;
|
|
|
|
argp->count -= resp->count;
|
|
|
|
} else {
|
|
|
|
/* Resend as a stable write in order to avoid
|
|
|
|
* headaches in the case of a server crash.
|
|
|
|
*/
|
|
|
|
argp->stable = NFS_FILE_SYNC;
|
|
|
|
}
|
2009-04-01 07:22:41 -06:00
|
|
|
nfs4_restart_rpc(task, server->nfs_client);
|
2006-03-20 11:44:27 -07:00
|
|
|
return -EAGAIN;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (time_before(complain, jiffies)) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"NFS: Server wrote zero bytes, expected %u.\n",
|
|
|
|
argp->count);
|
|
|
|
complain = jiffies + 300 * HZ;
|
|
|
|
}
|
|
|
|
/* Can't do anything about it except throw an error. */
|
|
|
|
task->tk_status = -EIO;
|
|
|
|
}
|
2009-04-01 07:22:41 -06:00
|
|
|
nfs4_sequence_free_slot(server->nfs_client, &data->res.seq_res);
|
2006-03-20 11:44:27 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
2008-04-15 14:56:39 -06:00
|
|
|
void nfs_commitdata_release(void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-19 18:04:20 -07:00
|
|
|
struct nfs_write_data *wdata = data;
|
|
|
|
|
|
|
|
put_nfs_open_context(wdata->args.context);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_commit_free(wdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the argument/result storage required for the RPC call.
|
|
|
|
*/
|
2008-04-14 12:54:53 -06:00
|
|
|
static int nfs_commit_rpcsetup(struct list_head *head,
|
2006-03-20 11:44:27 -07:00
|
|
|
struct nfs_write_data *data,
|
|
|
|
int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-14 13:39:59 -06:00
|
|
|
struct nfs_page *first = nfs_list_entry(head->next);
|
|
|
|
struct inode *inode = first->wb_context->path.dentry->d_inode;
|
|
|
|
int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
|
2007-07-14 13:40:00 -06:00
|
|
|
int priority = flush_task_priority(how);
|
2007-10-25 16:42:54 -06:00
|
|
|
struct rpc_task *task;
|
2007-07-14 13:40:00 -06:00
|
|
|
struct rpc_message msg = {
|
|
|
|
.rpc_argp = &data->args,
|
|
|
|
.rpc_resp = &data->res,
|
|
|
|
.rpc_cred = first->wb_context->cred,
|
|
|
|
};
|
2007-07-14 13:39:59 -06:00
|
|
|
struct rpc_task_setup task_setup_data = {
|
2007-10-25 16:42:54 -06:00
|
|
|
.task = &data->task,
|
2007-07-14 13:39:59 -06:00
|
|
|
.rpc_client = NFS_CLIENT(inode),
|
2007-07-14 13:40:00 -06:00
|
|
|
.rpc_message = &msg,
|
2007-07-14 13:39:59 -06:00
|
|
|
.callback_ops = &nfs_commit_ops,
|
|
|
|
.callback_data = data,
|
2008-02-19 18:04:23 -07:00
|
|
|
.workqueue = nfsiod_workqueue,
|
2007-07-14 13:39:59 -06:00
|
|
|
.flags = flags,
|
2007-07-14 13:40:00 -06:00
|
|
|
.priority = priority,
|
2007-07-14 13:39:59 -06:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Set up the RPC argument and reply structs
|
|
|
|
* NB: take care not to mess about with data->commit et al. */
|
|
|
|
|
|
|
|
list_splice_init(head, &data->pages);
|
|
|
|
|
|
|
|
data->inode = inode;
|
2007-07-14 13:40:00 -06:00
|
|
|
data->cred = msg.rpc_cred;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
data->args.fh = NFS_FH(data->inode);
|
2005-06-22 11:16:31 -06:00
|
|
|
/* Note: we always request a commit of the entire inode */
|
|
|
|
data->args.offset = 0;
|
|
|
|
data->args.count = 0;
|
2008-02-19 18:04:20 -07:00
|
|
|
data->args.context = get_nfs_open_context(first->wb_context);
|
2005-06-22 11:16:31 -06:00
|
|
|
data->res.count = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
data->res.fattr = &data->fattr;
|
|
|
|
data->res.verf = &data->verf;
|
2005-10-27 20:12:38 -06:00
|
|
|
nfs_fattr_init(&data->fattr);
|
2006-03-20 11:44:27 -07:00
|
|
|
|
|
|
|
/* Set up the initial task struct. */
|
2007-07-14 13:40:00 -06:00
|
|
|
NFS_PROTO(inode)->commit_setup(data, &msg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:01 -07:00
|
|
|
dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
|
2007-07-14 13:40:00 -06:00
|
|
|
|
2007-10-25 16:42:54 -06:00
|
|
|
task = rpc_run_task(&task_setup_data);
|
2008-04-14 12:54:53 -06:00
|
|
|
if (IS_ERR(task))
|
|
|
|
return PTR_ERR(task);
|
|
|
|
rpc_put_task(task);
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit dirty pages
|
|
|
|
*/
|
|
|
|
static int
|
2005-11-30 16:09:02 -07:00
|
|
|
nfs_commit_list(struct inode *inode, struct list_head *head, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_write_data *data;
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
2008-04-15 14:56:39 -06:00
|
|
|
data = nfs_commitdata_alloc();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!data)
|
|
|
|
goto out_bad;
|
|
|
|
|
|
|
|
/* Set up the argument struct */
|
2008-04-14 12:54:53 -06:00
|
|
|
return nfs_commit_rpcsetup(head, data, how);
|
2005-04-16 16:20:36 -06:00
|
|
|
out_bad:
|
|
|
|
while (!list_empty(head)) {
|
|
|
|
req = nfs_list_entry(head->next);
|
|
|
|
nfs_list_remove_request(req);
|
|
|
|
nfs_mark_request_commit(req);
|
2006-07-05 11:17:12 -06:00
|
|
|
dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
|
2007-10-17 00:25:47 -06:00
|
|
|
dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
|
|
|
|
BDI_RECLAIMABLE);
|
2007-06-17 13:10:24 -06:00
|
|
|
nfs_clear_page_tag_locked(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* COMMIT call returned
|
|
|
|
*/
|
2006-03-20 11:44:27 -07:00
|
|
|
static void nfs_commit_done(struct rpc_task *task, void *calldata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-01-03 01:55:04 -07:00
|
|
|
struct nfs_write_data *data = calldata;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:01 -07:00
|
|
|
dprintk("NFS: %5u nfs_commit_done (status %d)\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_pid, task->tk_status);
|
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
/* Call the NFS version-specific code */
|
|
|
|
if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
|
|
|
|
return;
|
2008-04-15 14:56:39 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_commit_release(void *calldata)
|
|
|
|
{
|
|
|
|
struct nfs_write_data *data = calldata;
|
|
|
|
struct nfs_page *req;
|
|
|
|
int status = data->task.tk_status;
|
2006-03-20 11:44:27 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
while (!list_empty(&data->pages)) {
|
|
|
|
req = nfs_list_entry(data->pages.next);
|
|
|
|
nfs_list_remove_request(req);
|
2008-06-13 11:25:22 -06:00
|
|
|
nfs_clear_request_commit(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-11 15:56:05 -06:00
|
|
|
dprintk("NFS: commit (%s/%lld %d@%lld)",
|
2007-06-05 08:42:27 -06:00
|
|
|
req->wb_context->path.dentry->d_inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
|
2005-04-16 16:20:36 -06:00
|
|
|
req->wb_bytes,
|
|
|
|
(long long)req_offset(req));
|
2008-04-15 14:56:39 -06:00
|
|
|
if (status < 0) {
|
|
|
|
nfs_context_set_write_error(req->wb_context, status);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_inode_remove_request(req);
|
2008-04-15 14:56:39 -06:00
|
|
|
dprintk(", error = %d\n", status);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Okay, COMMIT succeeded, apparently. Check the verifier
|
|
|
|
* returned by the server against all stored verfs. */
|
|
|
|
if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
|
|
|
|
/* We have a match */
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
dprintk(" OK\n");
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
/* We have a mismatch. Write the page again */
|
|
|
|
dprintk(" mismatch\n");
|
2008-03-19 09:24:38 -06:00
|
|
|
nfs_mark_request_dirty(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
next:
|
2007-06-17 13:10:24 -06:00
|
|
|
nfs_clear_page_tag_locked(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-04-15 14:56:39 -06:00
|
|
|
nfs_commitdata_release(calldata);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-03-20 11:44:27 -07:00
|
|
|
|
|
|
|
static const struct rpc_call_ops nfs_commit_ops = {
|
2009-04-01 07:22:27 -06:00
|
|
|
#if defined(CONFIG_NFS_V4_1)
|
|
|
|
.rpc_call_prepare = nfs_write_prepare,
|
|
|
|
#endif /* CONFIG_NFS_V4_1 */
|
2006-03-20 11:44:27 -07:00
|
|
|
.rpc_call_done = nfs_commit_done,
|
|
|
|
.rpc_release = nfs_commit_release,
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-06-22 11:16:31 -06:00
|
|
|
int nfs_commit_inode(struct inode *inode, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
LIST_HEAD(head);
|
2006-03-20 11:44:50 -07:00
|
|
|
int res;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-06-22 11:16:31 -06:00
|
|
|
res = nfs_scan_commit(inode, &head, 0, 0);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (res) {
|
2006-03-20 11:44:50 -07:00
|
|
|
int error = nfs_commit_list(inode, &head, how);
|
2005-06-22 11:16:31 -06:00
|
|
|
if (error < 0)
|
|
|
|
return error;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
2007-04-02 17:29:52 -06:00
|
|
|
#else
|
|
|
|
static inline int nfs_commit_list(struct inode *inode, struct list_head *head, int how)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2006-10-09 14:18:38 -06:00
|
|
|
long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_control *wbc, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-10-09 14:18:38 -06:00
|
|
|
struct inode *inode = mapping->host;
|
2007-04-17 15:22:13 -06:00
|
|
|
pgoff_t idx_start, idx_end;
|
2006-10-09 14:18:38 -06:00
|
|
|
unsigned int npages = 0;
|
2006-03-20 11:44:51 -07:00
|
|
|
LIST_HEAD(head);
|
2006-01-03 01:55:34 -07:00
|
|
|
int nocommit = how & FLUSH_NOCOMMIT;
|
2006-09-17 12:46:44 -06:00
|
|
|
long pages, ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-09 14:18:38 -06:00
|
|
|
/* FIXME */
|
|
|
|
if (wbc->range_cyclic)
|
|
|
|
idx_start = 0;
|
|
|
|
else {
|
|
|
|
idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
|
|
|
|
idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
|
|
|
|
if (idx_end > idx_start) {
|
2007-04-17 15:22:13 -06:00
|
|
|
pgoff_t l_npages = 1 + idx_end - idx_start;
|
2006-10-09 14:18:38 -06:00
|
|
|
npages = l_npages;
|
|
|
|
if (sizeof(npages) != sizeof(l_npages) &&
|
2007-04-17 15:22:13 -06:00
|
|
|
(pgoff_t)npages != l_npages)
|
2006-10-09 14:18:38 -06:00
|
|
|
npages = 0;
|
|
|
|
}
|
|
|
|
}
|
2006-03-20 11:44:51 -07:00
|
|
|
how &= ~FLUSH_NOCOMMIT;
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
do {
|
2006-03-20 11:44:51 -07:00
|
|
|
ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
|
|
|
|
if (ret != 0)
|
2006-01-03 01:55:34 -07:00
|
|
|
continue;
|
2006-03-20 11:44:51 -07:00
|
|
|
if (nocommit)
|
|
|
|
break;
|
2006-05-30 23:13:38 -06:00
|
|
|
pages = nfs_scan_commit(inode, &head, idx_start, npages);
|
2007-04-17 15:22:13 -06:00
|
|
|
if (pages == 0)
|
2006-03-20 11:44:51 -07:00
|
|
|
break;
|
2006-05-30 23:13:38 -06:00
|
|
|
if (how & FLUSH_INVALIDATE) {
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-07-05 11:17:12 -06:00
|
|
|
nfs_cancel_commit_list(&head);
|
2006-11-15 15:31:56 -07:00
|
|
|
ret = pages;
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2006-05-30 23:13:38 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
pages += nfs_scan_commit(inode, &head, 0, 0);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-03-20 11:44:51 -07:00
|
|
|
ret = nfs_commit_list(inode, &head, how);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
|
2006-03-20 11:44:51 -07:00
|
|
|
} while (ret >= 0);
|
2007-07-02 07:57:54 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-03-20 11:44:51 -07:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-25 12:09:54 -06:00
|
|
|
static int __nfs_write_mapping(struct address_space *mapping, struct writeback_control *wbc, int how)
|
2006-10-09 14:18:38 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2007-07-25 12:09:54 -06:00
|
|
|
ret = nfs_writepages(mapping, wbc);
|
2006-12-04 22:35:42 -07:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2007-07-25 12:09:54 -06:00
|
|
|
ret = nfs_sync_mapping_wait(mapping, wbc, how);
|
2007-07-20 11:13:28 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
return 0;
|
2006-12-04 22:35:42 -07:00
|
|
|
out:
|
2006-12-04 22:35:42 -07:00
|
|
|
__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
|
2006-10-09 14:18:38 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-07-25 12:09:54 -06:00
|
|
|
/* Two pass sync: first using WB_SYNC_NONE, then WB_SYNC_ALL */
|
|
|
|
static int nfs_write_mapping(struct address_space *mapping, int how)
|
|
|
|
{
|
|
|
|
struct writeback_control wbc = {
|
|
|
|
.bdi = mapping->backing_dev_info,
|
2009-03-11 12:10:30 -06:00
|
|
|
.sync_mode = WB_SYNC_ALL,
|
2007-07-25 12:09:54 -06:00
|
|
|
.nr_to_write = LONG_MAX,
|
2008-10-06 18:08:56 -06:00
|
|
|
.range_start = 0,
|
|
|
|
.range_end = LLONG_MAX,
|
2007-07-25 12:09:54 -06:00
|
|
|
.for_writepages = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
return __nfs_write_mapping(mapping, &wbc, how);
|
|
|
|
}
|
|
|
|
|
2007-07-20 11:13:28 -06:00
|
|
|
/*
|
|
|
|
* flush the inode to disk.
|
|
|
|
*/
|
|
|
|
int nfs_wb_all(struct inode *inode)
|
2006-10-09 14:18:38 -06:00
|
|
|
{
|
2007-07-20 11:13:28 -06:00
|
|
|
return nfs_write_mapping(inode->i_mapping, 0);
|
|
|
|
}
|
2006-10-09 14:18:38 -06:00
|
|
|
|
2007-07-20 11:13:28 -06:00
|
|
|
int nfs_wb_nocommit(struct inode *inode)
|
|
|
|
{
|
|
|
|
return nfs_write_mapping(inode->i_mapping, FLUSH_NOCOMMIT);
|
2006-10-09 14:18:38 -06:00
|
|
|
}
|
|
|
|
|
2007-08-28 08:29:36 -06:00
|
|
|
int nfs_wb_page_cancel(struct inode *inode, struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
loff_t range_start = page_offset(page);
|
|
|
|
loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
|
|
|
|
struct writeback_control wbc = {
|
|
|
|
.bdi = page->mapping->backing_dev_info,
|
|
|
|
.sync_mode = WB_SYNC_ALL,
|
|
|
|
.nr_to_write = LONG_MAX,
|
|
|
|
.range_start = range_start,
|
|
|
|
.range_end = range_end,
|
|
|
|
};
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
BUG_ON(!PageLocked(page));
|
|
|
|
for (;;) {
|
|
|
|
req = nfs_page_find_request(page);
|
|
|
|
if (req == NULL)
|
|
|
|
goto out;
|
2008-06-13 11:25:22 -06:00
|
|
|
if (test_bit(PG_CLEAN, &req->wb_flags)) {
|
2007-08-28 08:29:36 -06:00
|
|
|
nfs_release_request(req);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (nfs_lock_request_dontget(req)) {
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
/*
|
|
|
|
* In case nfs_inode_remove_request has marked the
|
|
|
|
* page as being dirty
|
|
|
|
*/
|
|
|
|
cancel_dirty_page(page, PAGE_CACHE_SIZE);
|
|
|
|
nfs_unlock_request(req);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret = nfs_wait_on_request(req);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!PagePrivate(page))
|
|
|
|
return 0;
|
|
|
|
ret = nfs_sync_mapping_wait(page->mapping, &wbc, FLUSH_INVALIDATE);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-11-21 16:04:31 -07:00
|
|
|
static int nfs_wb_page_priority(struct inode *inode, struct page *page,
|
|
|
|
int how)
|
2006-10-09 14:18:38 -06:00
|
|
|
{
|
|
|
|
loff_t range_start = page_offset(page);
|
|
|
|
loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
|
2006-12-04 22:35:41 -07:00
|
|
|
struct writeback_control wbc = {
|
|
|
|
.bdi = page->mapping->backing_dev_info,
|
|
|
|
.sync_mode = WB_SYNC_ALL,
|
|
|
|
.nr_to_write = LONG_MAX,
|
|
|
|
.range_start = range_start,
|
|
|
|
.range_end = range_end,
|
|
|
|
};
|
|
|
|
int ret;
|
2006-10-09 14:18:38 -06:00
|
|
|
|
2008-04-11 14:03:54 -06:00
|
|
|
do {
|
|
|
|
if (clear_page_dirty_for_io(page)) {
|
|
|
|
ret = nfs_writepage_locked(page, &wbc);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_error;
|
|
|
|
} else if (!PagePrivate(page))
|
|
|
|
break;
|
|
|
|
ret = nfs_sync_mapping_wait(page->mapping, &wbc, how);
|
2006-12-04 22:35:41 -07:00
|
|
|
if (ret < 0)
|
2008-04-11 14:03:54 -06:00
|
|
|
goto out_error;
|
|
|
|
} while (PagePrivate(page));
|
|
|
|
return 0;
|
|
|
|
out_error:
|
2006-12-04 22:35:42 -07:00
|
|
|
__mark_inode_dirty(inode, I_DIRTY_PAGES);
|
2006-12-04 22:35:41 -07:00
|
|
|
return ret;
|
2006-10-09 14:18:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write back all requests on one page - we do this before reading it.
|
|
|
|
*/
|
|
|
|
int nfs_wb_page(struct inode *inode, struct page* page)
|
|
|
|
{
|
2006-12-04 22:35:41 -07:00
|
|
|
return nfs_wb_page_priority(inode, page, FLUSH_STABLE);
|
2006-10-09 14:18:38 -06:00
|
|
|
}
|
|
|
|
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 07:34:33 -06:00
|
|
|
int __init nfs_init_writepagecache(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
|
|
|
|
sizeof(struct nfs_write_data),
|
|
|
|
0, SLAB_HWCACHE_ALIGN,
|
2007-07-19 19:11:58 -06:00
|
|
|
NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (nfs_wdata_cachep == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-03-26 02:37:50 -07:00
|
|
|
nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
|
|
|
|
nfs_wdata_cachep);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (nfs_wdata_mempool == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-03-26 02:37:50 -07:00
|
|
|
nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
|
|
|
|
nfs_wdata_cachep);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (nfs_commit_mempool == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-03-16 15:38:26 -06:00
|
|
|
/*
|
|
|
|
* NFS congestion size, scale with available memory.
|
|
|
|
*
|
|
|
|
* 64MB: 8192k
|
|
|
|
* 128MB: 11585k
|
|
|
|
* 256MB: 16384k
|
|
|
|
* 512MB: 23170k
|
|
|
|
* 1GB: 32768k
|
|
|
|
* 2GB: 46340k
|
|
|
|
* 4GB: 65536k
|
|
|
|
* 8GB: 92681k
|
|
|
|
* 16GB: 131072k
|
|
|
|
*
|
|
|
|
* This allows larger machines to have larger/more transfers.
|
|
|
|
* Limit the default to 256M
|
|
|
|
*/
|
|
|
|
nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
|
|
|
|
if (nfs_congestion_kb > 256*1024)
|
|
|
|
nfs_congestion_kb = 256*1024;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-27 13:59:15 -06:00
|
|
|
void nfs_destroy_writepagecache(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
mempool_destroy(nfs_commit_mempool);
|
|
|
|
mempool_destroy(nfs_wdata_mempool);
|
2006-09-27 02:49:40 -06:00
|
|
|
kmem_cache_destroy(nfs_wdata_cachep);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|