2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* linux/fs/nfs/write.c
|
|
|
|
*
|
|
|
|
* Writing file data over NFS.
|
|
|
|
*
|
|
|
|
* We do it like this: When a (user) process wishes to write data to an
|
|
|
|
* NFS file, a write request is allocated that contains the RPC task data
|
|
|
|
* plus some info on the page to be written, and added to the inode's
|
|
|
|
* write chain. If the process writes past the end of the page, an async
|
|
|
|
* RPC call to write the page is scheduled immediately; otherwise, the call
|
|
|
|
* is delayed for a few seconds.
|
|
|
|
*
|
|
|
|
* Just like readahead, no async I/O is performed if wsize < PAGE_SIZE.
|
|
|
|
*
|
|
|
|
* Write requests are kept on the inode's writeback list. Each entry in
|
|
|
|
* that list references the page (portion) to be written. When the
|
|
|
|
* cache timeout has expired, the RPC task is woken up, and tries to
|
|
|
|
* lock the page. As soon as it manages to do so, the request is moved
|
|
|
|
* from the writeback list to the writelock list.
|
|
|
|
*
|
|
|
|
* Note: we must make sure never to confuse the inode passed in the
|
|
|
|
* write_page request with the one in page->inode. As far as I understand
|
|
|
|
* it, these are different when doing a swap-out.
|
|
|
|
*
|
|
|
|
* To understand everything that goes on here and in the NFS read code,
|
|
|
|
* one should be aware that a page is locked in exactly one of the following
|
|
|
|
* cases:
|
|
|
|
*
|
|
|
|
* - A write request is in progress.
|
|
|
|
* - A user process is in generic_file_write/nfs_update_page
|
|
|
|
* - A user process is in generic_file_read
|
|
|
|
*
|
|
|
|
* Also note that because of the way pages are invalidated in
|
|
|
|
* nfs_revalidate_inode, the following assertions hold:
|
|
|
|
*
|
|
|
|
* - If a page is dirty, there will be no read requests (a page will
|
|
|
|
* not be re-read unless invalidated by nfs_revalidate_inode).
|
|
|
|
* - If the page is not uptodate, there will be no pending write
|
|
|
|
* requests, and no process will be in nfs_update_page.
|
|
|
|
*
|
|
|
|
* FIXME: Interaction with the vmscan routines is not optimal yet.
|
|
|
|
* Either vmscan must be made nfs-savvy, or we need a different page
|
|
|
|
* reclaim concept that supports something like FS-independent
|
|
|
|
* buffer_heads with a b_ops-> field.
|
|
|
|
*
|
|
|
|
* 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>
|
|
|
|
|
|
|
|
#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 <linux/smp_lock.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"
|
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
|
|
|
|
*/
|
|
|
|
static struct nfs_page * nfs_update_request(struct nfs_open_context*,
|
|
|
|
struct page *,
|
|
|
|
unsigned int, unsigned int);
|
2006-12-04 22:35:41 -07:00
|
|
|
static void nfs_mark_request_dirty(struct nfs_page *req);
|
2005-04-16 16:20:36 -06:00
|
|
|
static int nfs_wait_on_write_congestion(struct address_space *, int);
|
|
|
|
static int nfs_wait_on_requests(struct inode *, unsigned long, unsigned int);
|
2006-09-17 12:46:44 -06:00
|
|
|
static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how);
|
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;
|
|
|
|
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(nfs_write_congestion);
|
|
|
|
|
2006-09-08 10:48:54 -06:00
|
|
|
struct nfs_write_data *nfs_commit_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);
|
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2006-11-13 14:23:44 -07:00
|
|
|
void nfs_commit_rcu_free(struct rcu_head *head)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-11-13 14:23:44 -07:00
|
|
|
struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
|
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);
|
|
|
|
}
|
|
|
|
|
2006-11-13 14:23:44 -07:00
|
|
|
void nfs_commit_free(struct nfs_write_data *wdata)
|
|
|
|
{
|
|
|
|
call_rcu_bh(&wdata->task.u.tk_rcu, nfs_commit_rcu_free);
|
|
|
|
}
|
|
|
|
|
2006-09-08 10:48:54 -06:00
|
|
|
struct nfs_write_data *nfs_writedata_alloc(size_t len)
|
2006-03-20 11:44:37 -07:00
|
|
|
{
|
2006-09-08 10:48:54 -06:00
|
|
|
unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
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;
|
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;
|
|
|
|
}
|
|
|
|
|
2006-11-13 14:23:44 -07:00
|
|
|
static void nfs_writedata_rcu_free(struct rcu_head *head)
|
2006-03-20 11:44:37 -07:00
|
|
|
{
|
2006-11-13 14:23:44 -07:00
|
|
|
struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
|
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);
|
|
|
|
}
|
|
|
|
|
2006-11-13 14:23:44 -07:00
|
|
|
static void nfs_writedata_free(struct nfs_write_data *wdata)
|
|
|
|
{
|
|
|
|
call_rcu_bh(&wdata->task.u.tk_rcu, nfs_writedata_rcu_free);
|
|
|
|
}
|
|
|
|
|
2006-01-03 01:55:04 -07:00
|
|
|
void nfs_writedata_release(void *wdata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
nfs_writedata_free(wdata);
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
atomic_inc(&req->wb_count);
|
|
|
|
}
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs_page *nfs_page_find_request(struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_page *req = NULL;
|
|
|
|
spinlock_t *req_lock = &NFS_I(page->mapping->host)->req_lock;
|
|
|
|
|
|
|
|
spin_lock(req_lock);
|
|
|
|
req = nfs_page_find_request_locked(page);
|
|
|
|
spin_unlock(req_lock);
|
|
|
|
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;
|
|
|
|
loff_t end, i_size = i_size_read(inode);
|
|
|
|
unsigned long end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
if (i_size > 0 && page->index < end_index)
|
|
|
|
return;
|
|
|
|
end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
|
|
|
|
if (i_size >= end)
|
|
|
|
return;
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
|
2005-04-16 16:20:36 -06:00
|
|
|
i_size_write(inode, end);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
|
|
if (count != PAGE_CACHE_SIZE)
|
2005-04-16 16:20:36 -06:00
|
|
|
memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count);
|
2006-12-04 22:35:38 -07:00
|
|
|
SetPageUptodate(page);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:39 -07:00
|
|
|
static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int offset, unsigned int count)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
2006-12-04 22:35:39 -07:00
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-04 22:35:39 -07:00
|
|
|
for (;;) {
|
|
|
|
req = nfs_update_request(ctx, page, offset, count);
|
|
|
|
if (!IS_ERR(req))
|
|
|
|
break;
|
|
|
|
ret = PTR_ERR(req);
|
|
|
|
if (ret != -EBUSY)
|
|
|
|
return ret;
|
|
|
|
ret = nfs_wb_page(page->mapping->host, page);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Update file length */
|
|
|
|
nfs_grow_file(page, offset, count);
|
|
|
|
/* Set the PG_uptodate flag? */
|
|
|
|
nfs_mark_uptodate(page, offset, count);
|
|
|
|
nfs_unlock_request(req);
|
2006-01-03 01:55:02 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int wb_priority(struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
if (wbc->for_reclaim)
|
|
|
|
return FLUSH_HIGHPRI;
|
|
|
|
if (wbc->for_kupdate)
|
|
|
|
return FLUSH_LOWPRI;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:41 -07:00
|
|
|
/*
|
|
|
|
* Find an associated nfs write request, and prepare to flush it out
|
|
|
|
* Returns 1 if there was no write request, or if the request was
|
|
|
|
* already tagged by nfs_set_page_dirty.Returns 0 if the request
|
|
|
|
* was not tagged.
|
|
|
|
* May also return an error if the user signalled nfs_wait_on_request().
|
|
|
|
*/
|
|
|
|
static int nfs_page_mark_flush(struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
spinlock_t *req_lock = &NFS_I(page->mapping->host)->req_lock;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock(req_lock);
|
|
|
|
for(;;) {
|
|
|
|
req = nfs_page_find_request_locked(page);
|
|
|
|
if (req == NULL) {
|
|
|
|
spin_unlock(req_lock);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (nfs_lock_request_dontget(req))
|
|
|
|
break;
|
|
|
|
/* Note: If we hold the page lock, as is the case in nfs_writepage,
|
|
|
|
* then the call to nfs_lock_request_dontget() will always
|
|
|
|
* succeed provided that someone hasn't already marked the
|
|
|
|
* request as dirty (in which case we don't care).
|
|
|
|
*/
|
|
|
|
spin_unlock(req_lock);
|
|
|
|
ret = nfs_wait_on_request(req);
|
|
|
|
nfs_release_request(req);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
spin_lock(req_lock);
|
|
|
|
}
|
|
|
|
spin_unlock(req_lock);
|
2006-12-04 22:35:42 -07:00
|
|
|
if (test_and_set_bit(PG_FLUSHING, &req->wb_flags) == 0) {
|
2006-12-04 22:35:41 -07:00
|
|
|
nfs_mark_request_dirty(req);
|
2006-12-04 22:35:42 -07:00
|
|
|
set_page_writeback(page);
|
|
|
|
}
|
2006-12-04 22:35:41 -07:00
|
|
|
ret = test_bit(PG_NEED_FLUSH, &req->wb_flags);
|
|
|
|
nfs_unlock_request(req);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Write an mmapped page to the server.
|
|
|
|
*/
|
2006-12-04 22:35:41 -07:00
|
|
|
static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx;
|
|
|
|
struct inode *inode = page->mapping->host;
|
2006-12-04 22:35:38 -07:00
|
|
|
unsigned offset;
|
2006-12-04 22:35:41 -07:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
|
|
|
|
nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
|
|
|
|
|
2006-12-04 22:35:41 -07:00
|
|
|
err = nfs_page_mark_flush(page);
|
|
|
|
if (err <= 0)
|
|
|
|
goto out;
|
|
|
|
err = 0;
|
2006-12-04 22:35:38 -07:00
|
|
|
offset = nfs_page_length(page);
|
|
|
|
if (!offset)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
2006-12-04 22:35:38 -07:00
|
|
|
|
2005-11-04 13:33:38 -07:00
|
|
|
ctx = nfs_find_open_context(inode, NULL, FMODE_WRITE);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ctx == NULL) {
|
|
|
|
err = -EBADF;
|
|
|
|
goto out;
|
|
|
|
}
|
2006-12-04 22:35:40 -07:00
|
|
|
err = nfs_writepage_setup(ctx, page, 0, offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
put_nfs_open_context(ctx);
|
2006-12-04 22:35:41 -07:00
|
|
|
if (err != 0)
|
|
|
|
goto out;
|
|
|
|
err = nfs_page_mark_flush(page);
|
|
|
|
if (err > 0)
|
|
|
|
err = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2006-12-04 22:35:40 -07:00
|
|
|
if (!wbc->for_writepages)
|
|
|
|
nfs_flush_mapping(page->mapping, wbc, wb_priority(wbc));
|
2006-12-04 22:35:41 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_writepage(struct page *page, struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = nfs_writepage_locked(page, wbc);
|
2005-04-16 16:20:36 -06:00
|
|
|
unlock_page(page);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: causes nfs_update_request() to block on the assumption
|
|
|
|
* that the writeback is generated due to memory pressure.
|
|
|
|
*/
|
|
|
|
int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
struct backing_dev_info *bdi = mapping->backing_dev_info;
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
int err;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
err = generic_writepages(mapping, wbc);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
while (test_and_set_bit(BDI_write_congested, &bdi->state) != 0) {
|
|
|
|
if (wbc->nonblocking)
|
|
|
|
return 0;
|
|
|
|
nfs_wait_on_write_congestion(mapping, 0);
|
|
|
|
}
|
2006-09-16 11:04:50 -06:00
|
|
|
err = nfs_flush_mapping(mapping, wbc, wb_priority(wbc));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (err < 0)
|
|
|
|
goto out;
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_add_stats(inode, NFSIOS_WRITEPAGES, err);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!wbc->nonblocking && wbc->sync_mode == WB_SYNC_ALL) {
|
|
|
|
err = nfs_wait_on_requests(inode, 0, 0);
|
|
|
|
if (err < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
2005-06-22 11:16:31 -06:00
|
|
|
err = nfs_commit_inode(inode, wb_priority(wbc));
|
2006-09-17 12:46:44 -06:00
|
|
|
if (err > 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
err = 0;
|
|
|
|
out:
|
|
|
|
clear_bit(BDI_write_congested, &bdi->state);
|
|
|
|
wake_up_all(&nfs_write_congestion);
|
2006-10-20 00:28:16 -06:00
|
|
|
congestion_end(WRITE);
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert a write request into an inode
|
|
|
|
*/
|
|
|
|
static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
|
|
|
|
BUG_ON(error == -EEXIST);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
if (!nfsi->npages) {
|
|
|
|
igrab(inode);
|
|
|
|
nfs_begin_data_update(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++;
|
|
|
|
atomic_inc(&req->wb_count);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert a write request into an inode
|
|
|
|
*/
|
|
|
|
static void nfs_inode_remove_request(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
struct inode *inode = req->wb_context->dentry->d_inode;
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
BUG_ON (!NFS_WBACK_BUSY(req));
|
|
|
|
|
|
|
|
spin_lock(&nfsi->req_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) {
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
2005-06-22 11:16:30 -06:00
|
|
|
nfs_end_data_update(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
iput(inode);
|
|
|
|
} else
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
nfs_clear_request(req);
|
|
|
|
nfs_release_request(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a request to the inode's dirty list.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
nfs_mark_request_dirty(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
struct inode *inode = req->wb_context->dentry->d_inode;
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
spin_lock(&nfsi->req_lock);
|
2005-06-22 11:16:31 -06:00
|
|
|
radix_tree_tag_set(&nfsi->nfs_page_tree,
|
|
|
|
req->wb_index, NFS_PAGE_TAG_DIRTY);
|
2005-04-16 16:20:36 -06:00
|
|
|
nfs_list_add_request(req, &nfsi->dirty);
|
|
|
|
nfsi->ndirty++;
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
2006-12-04 22:45:19 -07:00
|
|
|
__mark_inode_dirty(inode, I_DIRTY_PAGES);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:42 -07:00
|
|
|
static void
|
|
|
|
nfs_redirty_request(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
clear_bit(PG_FLUSHING, &req->wb_flags);
|
|
|
|
__set_page_dirty_nobuffers(req->wb_page);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Check if a request is dirty
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
nfs_dirty_request(struct nfs_page *req)
|
|
|
|
{
|
2006-12-04 22:35:41 -07:00
|
|
|
return test_bit(PG_FLUSHING, &req->wb_flags) == 0;
|
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)
|
|
|
|
{
|
|
|
|
struct inode *inode = req->wb_context->dentry->d_inode;
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
spin_lock(&nfsi->req_lock);
|
|
|
|
nfs_list_add_request(req, &nfsi->commit);
|
|
|
|
nfsi->ncommit++;
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
2006-06-30 02:55:40 -06:00
|
|
|
inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
|
2006-12-04 22:45:19 -07:00
|
|
|
__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for a request to complete.
|
|
|
|
*
|
|
|
|
* Interruptible by signals only if mounted with intr flag.
|
|
|
|
*/
|
2006-03-20 11:44:51 -07:00
|
|
|
static int nfs_wait_on_requests_locked(struct inode *inode, unsigned long idx_start, unsigned int npages)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
struct nfs_page *req;
|
|
|
|
unsigned long idx_end, next;
|
|
|
|
unsigned int res = 0;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (npages == 0)
|
|
|
|
idx_end = ~0;
|
|
|
|
else
|
|
|
|
idx_end = idx_start + npages - 1;
|
|
|
|
|
|
|
|
next = idx_start;
|
2005-06-22 11:16:30 -06:00
|
|
|
while (radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree, (void **)&req, next, 1, NFS_PAGE_TAG_WRITEBACK)) {
|
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
|
|
|
|
|
|
|
atomic_inc(&req->wb_count);
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
error = nfs_wait_on_request(req);
|
|
|
|
nfs_release_request(req);
|
2006-03-20 11:44:51 -07:00
|
|
|
spin_lock(&nfsi->req_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error < 0)
|
|
|
|
return error;
|
|
|
|
res++;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-03-20 11:44:51 -07:00
|
|
|
static int nfs_wait_on_requests(struct inode *inode, unsigned long idx_start, unsigned int npages)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock(&nfsi->req_lock);
|
|
|
|
ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-05 11:17:12 -06:00
|
|
|
static void nfs_cancel_dirty_list(struct list_head *head)
|
2006-05-30 23:13:38 -06:00
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
while(!list_empty(head)) {
|
|
|
|
req = nfs_list_entry(head->next);
|
|
|
|
nfs_list_remove_request(req);
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
nfs_clear_page_writeback(req);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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);
|
2006-10-20 00:28:38 -06:00
|
|
|
dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
|
2006-07-05 11:17:12 -06:00
|
|
|
nfs_list_remove_request(req);
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
nfs_scan_commit(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2005-06-22 11:16:31 -06:00
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
if (nfsi->ncommit != 0) {
|
2006-05-30 23:13:38 -06:00
|
|
|
res = nfs_scan_list(nfsi, &nfsi->commit, dst, idx_start, npages);
|
2005-06-22 11:16:31 -06:00
|
|
|
nfsi->ncommit -= res;
|
|
|
|
if ((nfsi->ncommit == 0) != list_empty(&nfsi->commit))
|
|
|
|
printk(KERN_ERR "NFS: desynchronized value of nfs_i.ncommit.\n");
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
2006-03-20 11:44:51 -07:00
|
|
|
#else
|
|
|
|
static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
static int nfs_wait_on_write_congestion(struct address_space *mapping, int intr)
|
|
|
|
{
|
|
|
|
struct backing_dev_info *bdi = mapping->backing_dev_info;
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
might_sleep();
|
|
|
|
|
|
|
|
if (!bdi_write_congested(bdi))
|
|
|
|
return 0;
|
2006-03-20 11:44:14 -07:00
|
|
|
|
|
|
|
nfs_inc_stats(mapping->host, NFSIOS_CONGESTIONWAIT);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (intr) {
|
|
|
|
struct rpc_clnt *clnt = NFS_CLIENT(mapping->host);
|
|
|
|
sigset_t oldset;
|
|
|
|
|
|
|
|
rpc_clnt_sigmask(clnt, &oldset);
|
|
|
|
prepare_to_wait(&nfs_write_congestion, &wait, TASK_INTERRUPTIBLE);
|
|
|
|
if (bdi_write_congested(bdi)) {
|
|
|
|
if (signalled())
|
|
|
|
ret = -ERESTARTSYS;
|
|
|
|
else
|
|
|
|
schedule();
|
|
|
|
}
|
|
|
|
rpc_clnt_sigunmask(clnt, &oldset);
|
|
|
|
} else {
|
|
|
|
prepare_to_wait(&nfs_write_congestion, &wait, TASK_UNINTERRUPTIBLE);
|
|
|
|
if (bdi_write_congested(bdi))
|
|
|
|
schedule();
|
|
|
|
}
|
|
|
|
finish_wait(&nfs_write_congestion, &wait);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to update any existing write request, or create one if there is none.
|
|
|
|
* In order to match, the request's credentials must match those of
|
|
|
|
* the calling process.
|
|
|
|
*
|
|
|
|
* Note: Should always be called with the Page Lock held!
|
|
|
|
*/
|
|
|
|
static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
|
2006-12-04 22:35:39 -07:00
|
|
|
struct page *page, unsigned int offset, unsigned int bytes)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-12-04 22:35:39 -07:00
|
|
|
struct inode *inode = page->mapping->host;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
struct nfs_page *req, *new = NULL;
|
|
|
|
unsigned long rqend, end;
|
|
|
|
|
|
|
|
end = offset + bytes;
|
|
|
|
|
2006-12-04 22:35:39 -07:00
|
|
|
if (nfs_wait_on_write_congestion(page->mapping, NFS_SERVER(inode)->flags & NFS_MOUNT_INTR))
|
2005-04-16 16:20:36 -06:00
|
|
|
return ERR_PTR(-ERESTARTSYS);
|
|
|
|
for (;;) {
|
|
|
|
/* Loop over all inode entries and see if we find
|
|
|
|
* A request for the page we wish to update
|
|
|
|
*/
|
|
|
|
spin_lock(&nfsi->req_lock);
|
2006-12-04 22:35:35 -07:00
|
|
|
req = nfs_page_find_request_locked(page);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (req) {
|
|
|
|
if (!nfs_lock_request_dontget(req)) {
|
|
|
|
int error;
|
2006-12-04 22:35:35 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
error = nfs_wait_on_request(req);
|
|
|
|
nfs_release_request(req);
|
2006-03-20 11:44:04 -07:00
|
|
|
if (error < 0) {
|
|
|
|
if (new)
|
|
|
|
nfs_release_request(new);
|
2005-04-16 16:20:36 -06:00
|
|
|
return ERR_PTR(error);
|
2006-03-20 11:44:04 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
if (new)
|
|
|
|
nfs_release_request(new);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new) {
|
|
|
|
int error;
|
|
|
|
nfs_lock_request_dontget(new);
|
|
|
|
error = nfs_inode_add_request(inode, new);
|
|
|
|
if (error) {
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
nfs_unlock_request(new);
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
|
|
|
|
new = nfs_create_request(ctx, inode, page, offset, bytes);
|
|
|
|
if (IS_ERR(new))
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We have a request for our page.
|
|
|
|
* If the creds don't match, or the
|
|
|
|
* page addresses don't match,
|
|
|
|
* tell the caller to wait on the conflicting
|
|
|
|
* request.
|
|
|
|
*/
|
|
|
|
rqend = req->wb_offset + req->wb_bytes;
|
|
|
|
if (req->wb_context != ctx
|
|
|
|
|| req->wb_page != page
|
|
|
|
|| !nfs_dirty_request(req)
|
|
|
|
|| offset > rqend || end < req->wb_offset) {
|
|
|
|
nfs_unlock_request(req);
|
|
|
|
return ERR_PTR(-EBUSY);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Okay, the request matches. Update the region */
|
|
|
|
if (offset < req->wb_offset) {
|
|
|
|
req->wb_offset = offset;
|
|
|
|
req->wb_pgbase = offset;
|
|
|
|
req->wb_bytes = rqend - req->wb_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end > rqend)
|
|
|
|
req->wb_bytes = end - req->wb_offset;
|
|
|
|
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_flush_incompatible(struct file *file, struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
|
|
|
|
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;
|
|
|
|
do_flush = req->wb_page != page || req->wb_context != ctx
|
2006-12-04 22:35:41 -07:00
|
|
|
|| !nfs_dirty_request(req);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
int status = 0;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dprintk("NFS: nfs_updatepage(%s/%s %d@%Ld)\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,
|
2005-11-01 14:53:32 -07: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
|
|
|
|
* is entirely in cache, it may be more efficient to avoid
|
|
|
|
* fragmenting write requests.
|
|
|
|
*/
|
2005-06-22 11:16:30 -06:00
|
|
|
if (PageUptodate(page) && inode->i_flock == NULL && !(file->f_mode & 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);
|
2006-12-04 22:35:41 -07:00
|
|
|
__set_page_dirty_nobuffers(page);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("NFS: nfs_updatepage returns %d (isize %Ld)\n",
|
|
|
|
status, (long long)i_size_read(inode));
|
|
|
|
if (status < 0)
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_writepage_release(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
end_page_writeback(req->wb_page);
|
|
|
|
|
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
|
|
|
if (!PageError(req->wb_page)) {
|
|
|
|
if (NFS_NEED_RESCHED(req)) {
|
2006-12-04 22:35:42 -07:00
|
|
|
nfs_redirty_request(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
} else if (NFS_NEED_COMMIT(req)) {
|
|
|
|
nfs_mark_request_commit(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
|
|
|
|
out:
|
|
|
|
nfs_clear_commit(req);
|
|
|
|
nfs_clear_reschedule(req);
|
|
|
|
#else
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
#endif
|
2005-06-22 11:16:30 -06:00
|
|
|
nfs_clear_page_writeback(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int flush_task_priority(int how)
|
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static void nfs_write_rpcsetup(struct nfs_page *req,
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
2006-03-20 11:44:27 -07:00
|
|
|
int flags;
|
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;
|
|
|
|
data->inode = inode = req->wb_context->dentry->d_inode;
|
|
|
|
data->cred = req->wb_context->cred;
|
|
|
|
|
|
|
|
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;
|
|
|
|
data->args.context = req->wb_context;
|
|
|
|
|
|
|
|
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. */
|
|
|
|
flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
|
|
|
|
rpc_init_task(&data->task, NFS_CLIENT(inode), flags, call_ops, data);
|
2005-04-16 16:20:36 -06:00
|
|
|
NFS_PROTO(inode)->write_setup(data, how);
|
|
|
|
|
|
|
|
data->task.tk_priority = flush_task_priority(how);
|
|
|
|
data->task.tk_cookie = (unsigned long)inode;
|
|
|
|
|
|
|
|
dprintk("NFS: %4d initiated write call (req %s/%Ld, %u bytes @ offset %Lu)\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);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_execute_write(struct nfs_write_data *data)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = NFS_CLIENT(data->inode);
|
|
|
|
sigset_t oldset;
|
|
|
|
|
|
|
|
rpc_clnt_sigmask(clnt, &oldset);
|
|
|
|
rpc_execute(&data->task);
|
|
|
|
rpc_clnt_sigunmask(clnt, &oldset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Generate multiple small requests to write out a single
|
|
|
|
* contiguous dirty area on one page.
|
|
|
|
*/
|
2006-03-20 11:44:50 -07:00
|
|
|
static int nfs_flush_multi(struct inode *inode, struct list_head *head, 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;
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
nfs_list_remove_request(req);
|
|
|
|
|
|
|
|
nbytes = req->wb_bytes;
|
2006-09-08 10:48:54 -06:00
|
|
|
do {
|
|
|
|
size_t len = min(nbytes, wsize);
|
|
|
|
|
|
|
|
data = nfs_writedata_alloc(len);
|
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;
|
|
|
|
nbytes = req->wb_bytes;
|
|
|
|
do {
|
|
|
|
data = list_entry(list.next, struct nfs_write_data, pages);
|
|
|
|
list_del_init(&data->pages);
|
|
|
|
|
|
|
|
data->pagevec[0] = page;
|
|
|
|
|
|
|
|
if (nbytes > wsize) {
|
2006-03-20 11:44:27 -07:00
|
|
|
nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
|
|
|
|
wsize, offset, how);
|
2005-04-16 16:20:36 -06:00
|
|
|
offset += wsize;
|
|
|
|
nbytes -= wsize;
|
|
|
|
} else {
|
2006-03-20 11:44:27 -07:00
|
|
|
nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
|
|
|
|
nbytes, offset, how);
|
2005-04-16 16:20:36 -06:00
|
|
|
nbytes = 0;
|
|
|
|
}
|
|
|
|
nfs_execute_write(data);
|
|
|
|
} while (nbytes != 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
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-06-22 11:16:30 -06:00
|
|
|
nfs_clear_page_writeback(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.
|
|
|
|
*/
|
2006-03-20 11:44:50 -07:00
|
|
|
static int nfs_flush_one(struct inode *inode, struct list_head *head, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
struct page **pages;
|
|
|
|
struct nfs_write_data *data;
|
|
|
|
unsigned int count;
|
|
|
|
|
2006-09-08 10:48:54 -06:00
|
|
|
data = nfs_writedata_alloc(NFS_SERVER(inode)->wsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!data)
|
|
|
|
goto out_bad;
|
|
|
|
|
|
|
|
pages = data->pagevec;
|
|
|
|
count = 0;
|
|
|
|
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;
|
|
|
|
count += req->wb_bytes;
|
|
|
|
}
|
|
|
|
req = nfs_list_entry(data->pages.next);
|
|
|
|
|
|
|
|
/* Set up the argument struct */
|
2006-03-20 11:44:27 -07:00
|
|
|
nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
nfs_execute_write(data);
|
|
|
|
return 0;
|
|
|
|
out_bad:
|
|
|
|
while (!list_empty(head)) {
|
|
|
|
struct nfs_page *req = nfs_list_entry(head->next);
|
|
|
|
nfs_list_remove_request(req);
|
2006-12-04 22:35:42 -07:00
|
|
|
nfs_redirty_request(req);
|
2005-06-22 11:16:30 -06:00
|
|
|
nfs_clear_page_writeback(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2006-03-20 11:44:50 -07:00
|
|
|
static int nfs_flush_list(struct inode *inode, struct list_head *head, int npages, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
LIST_HEAD(one_request);
|
2006-03-20 11:44:50 -07:00
|
|
|
int (*flush_one)(struct inode *, struct list_head *, int);
|
|
|
|
struct nfs_page *req;
|
|
|
|
int wpages = NFS_SERVER(inode)->wpages;
|
|
|
|
int wsize = NFS_SERVER(inode)->wsize;
|
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-20 11:44:50 -07:00
|
|
|
flush_one = nfs_flush_one;
|
|
|
|
if (wsize < PAGE_CACHE_SIZE)
|
|
|
|
flush_one = nfs_flush_multi;
|
|
|
|
/* For single writes, FLUSH_STABLE is more efficient */
|
|
|
|
if (npages <= wpages && npages == NFS_I(inode)->npages
|
|
|
|
&& nfs_list_entry(head->next)->wb_bytes <= wsize)
|
|
|
|
how |= FLUSH_STABLE;
|
|
|
|
|
|
|
|
do {
|
|
|
|
nfs_coalesce_requests(head, &one_request, wpages);
|
2005-04-16 16:20:36 -06:00
|
|
|
req = nfs_list_entry(one_request.next);
|
2006-03-20 11:44:50 -07:00
|
|
|
error = flush_one(inode, &one_request, how);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error < 0)
|
2006-03-20 11:44:50 -07:00
|
|
|
goto out_err;
|
|
|
|
} while (!list_empty(head));
|
|
|
|
return 0;
|
|
|
|
out_err:
|
2005-04-16 16:20:36 -06:00
|
|
|
while (!list_empty(head)) {
|
|
|
|
req = nfs_list_entry(head->next);
|
|
|
|
nfs_list_remove_request(req);
|
2006-12-04 22:35:42 -07:00
|
|
|
nfs_redirty_request(req);
|
2005-06-22 11:16:30 -06:00
|
|
|
nfs_clear_page_writeback(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
struct nfs_page *req = data->req;
|
|
|
|
struct page *page = req->wb_page;
|
|
|
|
|
|
|
|
dprintk("NFS: write (%s/%Ld %d@%Ld)",
|
|
|
|
req->wb_context->dentry->d_inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(req->wb_context->dentry->d_inode),
|
|
|
|
req->wb_bytes,
|
|
|
|
(long long)req_offset(req));
|
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
if (nfs_writeback_done(task, data) != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (task->tk_status < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
2006-03-20 11:44:27 -07:00
|
|
|
req->wb_context->error = task->tk_status;
|
|
|
|
dprintk(", error = %d\n", task->tk_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
|
|
|
if (data->verf.committed < NFS_FILE_SYNC) {
|
|
|
|
if (!NFS_NEED_COMMIT(req)) {
|
|
|
|
nfs_defer_commit(req);
|
|
|
|
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))) {
|
|
|
|
nfs_defer_reschedule(req);
|
|
|
|
dprintk(" server reboot detected\n");
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
dprintk(" OK\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atomic_dec_and_test(&req->wb_complete))
|
|
|
|
nfs_writepage_release(req);
|
|
|
|
}
|
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
static const struct rpc_call_ops nfs_write_partial_ops = {
|
|
|
|
.rpc_call_done = nfs_writeback_done_partial,
|
|
|
|
.rpc_release = nfs_writedata_release,
|
|
|
|
};
|
|
|
|
|
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
|
|
|
struct nfs_page *req;
|
|
|
|
struct page *page;
|
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
if (nfs_writeback_done(task, data) != 0)
|
|
|
|
return;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Update attributes as result of writeback. */
|
|
|
|
while (!list_empty(&data->pages)) {
|
|
|
|
req = nfs_list_entry(data->pages.next);
|
|
|
|
nfs_list_remove_request(req);
|
|
|
|
page = req->wb_page;
|
|
|
|
|
|
|
|
dprintk("NFS: write (%s/%Ld %d@%Ld)",
|
|
|
|
req->wb_context->dentry->d_inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(req->wb_context->dentry->d_inode),
|
|
|
|
req->wb_bytes,
|
|
|
|
(long long)req_offset(req));
|
|
|
|
|
2006-03-20 11:44:27 -07:00
|
|
|
if (task->tk_status < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
2006-03-20 11:44:27 -07:00
|
|
|
req->wb_context->error = task->tk_status;
|
2005-04-16 16:20:36 -06:00
|
|
|
end_page_writeback(page);
|
|
|
|
nfs_inode_remove_request(req);
|
2006-03-20 11:44:27 -07:00
|
|
|
dprintk(", error = %d\n", task->tk_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
end_page_writeback(page);
|
|
|
|
|
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
|
|
|
if (data->args.stable != NFS_UNSTABLE || data->verf.committed == NFS_FILE_SYNC) {
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
dprintk(" OK\n");
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
|
|
|
|
nfs_mark_request_commit(req);
|
|
|
|
dprintk(" marked for commit\n");
|
|
|
|
#else
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
#endif
|
|
|
|
next:
|
2005-06-22 11:16:30 -06:00
|
|
|
nfs_clear_page_writeback(req);
|
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 = {
|
|
|
|
.rpc_call_done = nfs_writeback_done_full,
|
|
|
|
.rpc_release = nfs_writedata_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
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;
|
2006-03-20 11:44:27 -07:00
|
|
|
int status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("NFS: %4d nfs_writeback_done (status %d)\n",
|
|
|
|
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)) {
|
|
|
|
dprintk("NFS: faulty NFS server %s:"
|
|
|
|
" (committed = %d) != (stable = %d)\n",
|
NFS: Share NFS superblocks per-protocol per-server per-FSID
The attached patch makes NFS share superblocks between mounts from the same
server and FSID over the same protocol.
It does this by creating each superblock with a false root and returning the
real root dentry in the vfsmount presented by get_sb(). The root dentry set
starts off as an anonymous dentry if we don't already have the dentry for its
inode, otherwise it simply returns the dentry we already have.
We may thus end up with several trees of dentries in the superblock, and if at
some later point one of anonymous tree roots is discovered by normal filesystem
activity to be located in another tree within the superblock, the anonymous
root is named and materialises attached to the second tree at the appropriate
point.
Why do it this way? Why not pass an extra argument to the mount() syscall to
indicate the subpath and then pathwalk from the server root to the desired
directory? You can't guarantee this will work for two reasons:
(1) The root and intervening nodes may not be accessible to the client.
With NFS2 and NFS3, for instance, mountd is called on the server to get
the filehandle for the tip of a path. mountd won't give us handles for
anything we don't have permission to access, and so we can't set up NFS
inodes for such nodes, and so can't easily set up dentries (we'd have to
have ghost inodes or something).
With this patch we don't actually create dentries until we get handles
from the server that we can use to set up their inodes, and we don't
actually bind them into the tree until we know for sure where they go.
(2) Inaccessible symbolic links.
If we're asked to mount two exports from the server, eg:
mount warthog:/warthog/aaa/xxx /mmm
mount warthog:/warthog/bbb/yyy /nnn
We may not be able to access anything nearer the root than xxx and yyy,
but we may find out later that /mmm/www/yyy, say, is actually the same
directory as the one mounted on /nnn. What we might then find out, for
example, is that /warthog/bbb was actually a symbolic link to
/warthog/aaa/xxx/www, but we can't actually determine that by talking to
the server until /warthog is made available by NFS.
This would lead to having constructed an errneous dentry tree which we
can't easily fix. We can end up with a dentry marked as a directory when
it should actually be a symlink, or we could end up with an apparently
hardlinked directory.
With this patch we need not make assumptions about the type of a dentry
for which we can't retrieve information, nor need we assume we know its
place in the grand scheme of things until we actually see that place.
This patch reduces the possibility of aliasing in the inode and page caches for
inodes that may be accessed by more than one NFS export. It also reduces the
number of superblocks required for NFS where there are many NFS exports being
used from a server (home directory server + autofs for example).
This in turn makes it simpler to do local caching of network filesystems, as it
can then be guaranteed that there won't be links from multiple inodes in
separate superblocks to the same cache file.
Obviously, cache aliasing between different levels of NFS protocol could still
be a problem, but at least that gives us another key to use when indexing the
cache.
This patch makes the following changes:
(1) The server record construction/destruction has been abstracted out into
its own set of functions to make things easier to get right. These have
been moved into fs/nfs/client.c.
All the code in fs/nfs/client.c has to do with the management of
connections to servers, and doesn't touch superblocks in any way; the
remaining code in fs/nfs/super.c has to do with VFS superblock management.
(2) The sequence of events undertaken by NFS mount is now reordered:
(a) A volume representation (struct nfs_server) is allocated.
(b) A server representation (struct nfs_client) is acquired. This may be
allocated or shared, and is keyed on server address, port and NFS
version.
(c) If allocated, the client representation is initialised. The state
member variable of nfs_client is used to prevent a race during
initialisation from two mounts.
(d) For NFS4 a simple pathwalk is performed, walking from FH to FH to find
the root filehandle for the mount (fs/nfs/getroot.c). For NFS2/3 we
are given the root FH in advance.
(e) The volume FSID is probed for on the root FH.
(f) The volume representation is initialised from the FSINFO record
retrieved on the root FH.
(g) sget() is called to acquire a superblock. This may be allocated or
shared, keyed on client pointer and FSID.
(h) If allocated, the superblock is initialised.
(i) If the superblock is shared, then the new nfs_server record is
discarded.
(j) The root dentry for this mount is looked up from the root FH.
(k) The root dentry for this mount is assigned to the vfsmount.
(3) nfs_readdir_lookup() creates dentries for each of the entries readdir()
returns; this function now attaches disconnected trees from alternate
roots that happen to be discovered attached to a directory being read (in
the same way nfs_lookup() is made to do for lookup ops).
The new d_materialise_unique() function is now used to do this, thus
permitting the whole thing to be done under one set of locks, and thus
avoiding any race between mount and lookup operations on the same
directory.
(4) The client management code uses a new debug facility: NFSDBG_CLIENT which
is set by echoing 1024 to /proc/net/sunrpc/nfs_debug.
(5) Clone mounts are now called xdev mounts.
(6) Use the dentry passed to the statfs() op as the handle for retrieving fs
statistics rather than the root dentry of the superblock (which is now a
dummy).
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2006-08-22 18:06:13 -06:00
|
|
|
NFS_SERVER(data->inode)->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;
|
|
|
|
}
|
|
|
|
rpc_restart_call(task);
|
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;
|
|
|
|
}
|
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)
|
2006-01-03 01:55:04 -07:00
|
|
|
void nfs_commit_release(void *wdata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
nfs_commit_free(wdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the argument/result storage required for the RPC call.
|
|
|
|
*/
|
|
|
|
static void 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
|
|
|
{
|
2005-06-22 11:16:31 -06:00
|
|
|
struct nfs_page *first;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct inode *inode;
|
2006-03-20 11:44:27 -07:00
|
|
|
int flags;
|
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);
|
|
|
|
first = nfs_list_entry(data->pages.next);
|
|
|
|
inode = first->wb_context->dentry->d_inode;
|
|
|
|
|
|
|
|
data->inode = inode;
|
|
|
|
data->cred = first->wb_context->cred;
|
|
|
|
|
|
|
|
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;
|
|
|
|
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. */
|
|
|
|
flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
|
|
|
|
rpc_init_task(&data->task, NFS_CLIENT(inode), flags, &nfs_commit_ops, data);
|
2005-04-16 16:20:36 -06:00
|
|
|
NFS_PROTO(inode)->commit_setup(data, how);
|
|
|
|
|
|
|
|
data->task.tk_priority = flush_task_priority(how);
|
|
|
|
data->task.tk_cookie = (unsigned long)inode;
|
|
|
|
|
2005-11-01 14:53:32 -07:00
|
|
|
dprintk("NFS: %4d initiated commit call\n", data->task.tk_pid);
|
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;
|
|
|
|
|
2006-09-08 10:48:54 -06:00
|
|
|
data = nfs_commit_alloc();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!data)
|
|
|
|
goto out_bad;
|
|
|
|
|
|
|
|
/* Set up the argument struct */
|
|
|
|
nfs_commit_rpcsetup(head, data, how);
|
|
|
|
|
|
|
|
nfs_execute_write(data);
|
|
|
|
return 0;
|
|
|
|
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);
|
2006-09-18 21:20:35 -06:00
|
|
|
nfs_clear_page_writeback(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
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
dprintk("NFS: %4d nfs_commit_done (status %d)\n",
|
|
|
|
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;
|
|
|
|
|
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);
|
2006-06-30 02:55:40 -06:00
|
|
|
dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("NFS: commit (%s/%Ld %d@%Ld)",
|
|
|
|
req->wb_context->dentry->d_inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(req->wb_context->dentry->d_inode),
|
|
|
|
req->wb_bytes,
|
|
|
|
(long long)req_offset(req));
|
|
|
|
if (task->tk_status < 0) {
|
|
|
|
req->wb_context->error = task->tk_status;
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
dprintk(", error = %d\n", task->tk_status);
|
|
|
|
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");
|
2006-12-04 22:35:42 -07:00
|
|
|
nfs_redirty_request(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
next:
|
2005-06-22 11:16:30 -06:00
|
|
|
nfs_clear_page_writeback(req);
|
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 = {
|
|
|
|
.rpc_call_done = nfs_commit_done,
|
|
|
|
.rpc_release = nfs_commit_release,
|
|
|
|
};
|
2006-03-20 11:44:51 -07: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-09-17 12:46:44 -06:00
|
|
|
static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-16 11:04:50 -06:00
|
|
|
struct nfs_inode *nfsi = NFS_I(mapping->host);
|
2005-04-16 16:20:36 -06:00
|
|
|
LIST_HEAD(head);
|
2006-09-17 12:46:44 -06:00
|
|
|
long res;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock(&nfsi->req_lock);
|
2006-09-17 12:46:44 -06:00
|
|
|
res = nfs_scan_dirty(mapping, wbc, &head);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock(&nfsi->req_lock);
|
2005-06-22 11:16:30 -06:00
|
|
|
if (res) {
|
2006-09-16 11:04:50 -06:00
|
|
|
int error = nfs_flush_list(mapping->host, &head, res, how);
|
2006-03-20 11:44:50 -07:00
|
|
|
if (error < 0)
|
|
|
|
return error;
|
2005-06-22 11:16:30 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
|
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
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
LIST_HEAD(head);
|
2006-03-20 11:44:50 -07:00
|
|
|
int res;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock(&nfsi->req_lock);
|
2005-06-22 11:16:31 -06:00
|
|
|
res = nfs_scan_commit(inode, &head, 0, 0);
|
|
|
|
spin_unlock(&nfsi->req_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;
|
|
|
|
}
|
|
|
|
#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;
|
2006-03-20 11:44:51 -07:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2006-10-09 14:18:38 -06:00
|
|
|
unsigned long idx_start, idx_end;
|
|
|
|
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) {
|
|
|
|
unsigned long l_npages = 1 + idx_end - idx_start;
|
|
|
|
npages = l_npages;
|
|
|
|
if (sizeof(npages) != sizeof(l_npages) &&
|
|
|
|
(unsigned long)npages != l_npages)
|
|
|
|
npages = 0;
|
|
|
|
}
|
|
|
|
}
|
2006-03-20 11:44:51 -07:00
|
|
|
how &= ~FLUSH_NOCOMMIT;
|
|
|
|
spin_lock(&nfsi->req_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
do {
|
2006-10-09 14:18:38 -06:00
|
|
|
wbc->pages_skipped = 0;
|
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-10-09 14:18:38 -06:00
|
|
|
pages = nfs_scan_dirty(mapping, wbc, &head);
|
2006-03-20 11:44:51 -07:00
|
|
|
if (pages != 0) {
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
2006-11-15 15:31:56 -07:00
|
|
|
if (how & FLUSH_INVALIDATE) {
|
2006-07-05 11:17:12 -06:00
|
|
|
nfs_cancel_dirty_list(&head);
|
2006-11-15 15:31:56 -07:00
|
|
|
ret = pages;
|
|
|
|
} else
|
2006-05-30 23:13:38 -06:00
|
|
|
ret = nfs_flush_list(inode, &head, pages, how);
|
2006-03-20 11:44:51 -07:00
|
|
|
spin_lock(&nfsi->req_lock);
|
|
|
|
continue;
|
|
|
|
}
|
2006-10-09 14:18:38 -06:00
|
|
|
if (wbc->pages_skipped != 0)
|
|
|
|
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);
|
2006-10-09 14:18:38 -06:00
|
|
|
if (pages == 0) {
|
|
|
|
if (wbc->pages_skipped != 0)
|
|
|
|
continue;
|
2006-03-20 11:44:51 -07:00
|
|
|
break;
|
2006-10-09 14:18:38 -06:00
|
|
|
}
|
2006-05-30 23:13:38 -06:00
|
|
|
if (how & FLUSH_INVALIDATE) {
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
2006-07-05 11:17:12 -06:00
|
|
|
nfs_cancel_commit_list(&head);
|
2006-11-15 15:31:56 -07:00
|
|
|
ret = pages;
|
2006-05-30 23:13:38 -06:00
|
|
|
spin_lock(&nfsi->req_lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
pages += nfs_scan_commit(inode, &head, 0, 0);
|
2006-03-20 11:44:51 -07:00
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
ret = nfs_commit_list(inode, &head, how);
|
|
|
|
spin_lock(&nfsi->req_lock);
|
|
|
|
} while (ret >= 0);
|
|
|
|
spin_unlock(&nfsi->req_lock);
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-10-09 14:18:38 -06:00
|
|
|
/*
|
|
|
|
* flush the inode to disk.
|
|
|
|
*/
|
|
|
|
int nfs_wb_all(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct writeback_control wbc = {
|
|
|
|
.bdi = mapping->backing_dev_info,
|
|
|
|
.sync_mode = WB_SYNC_ALL,
|
|
|
|
.nr_to_write = LONG_MAX,
|
2006-12-04 22:35:42 -07:00
|
|
|
.for_writepages = 1,
|
2006-10-09 14:18:38 -06:00
|
|
|
.range_cyclic = 1,
|
|
|
|
};
|
|
|
|
int ret;
|
|
|
|
|
2006-12-04 22:35:42 -07:00
|
|
|
ret = generic_writepages(mapping, &wbc);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2006-10-09 14:18:38 -06:00
|
|
|
ret = nfs_sync_mapping_wait(mapping, &wbc, 0);
|
|
|
|
if (ret >= 0)
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_sync_mapping_range(struct address_space *mapping, loff_t range_start, loff_t range_end, int how)
|
|
|
|
{
|
|
|
|
struct writeback_control wbc = {
|
|
|
|
.bdi = mapping->backing_dev_info,
|
|
|
|
.sync_mode = WB_SYNC_ALL,
|
|
|
|
.nr_to_write = LONG_MAX,
|
|
|
|
.range_start = range_start,
|
|
|
|
.range_end = range_end,
|
2006-12-04 22:35:42 -07:00
|
|
|
.for_writepages = 1,
|
2006-10-09 14:18:38 -06:00
|
|
|
};
|
|
|
|
int ret;
|
|
|
|
|
2006-12-04 22:35:42 -07:00
|
|
|
if (!(how & FLUSH_NOWRITEPAGE)) {
|
|
|
|
ret = generic_writepages(mapping, &wbc);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
2006-10-09 14:18:38 -06:00
|
|
|
ret = nfs_sync_mapping_wait(mapping, &wbc, how);
|
|
|
|
if (ret >= 0)
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:42 -07:00
|
|
|
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
|
|
|
|
2006-12-04 22:35:41 -07:00
|
|
|
BUG_ON(!PageLocked(page));
|
|
|
|
if (!(how & FLUSH_NOWRITEPAGE) && clear_page_dirty_for_io(page)) {
|
|
|
|
ret = nfs_writepage_locked(page, &wbc);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = nfs_sync_mapping_wait(page->mapping, &wbc, how);
|
|
|
|
if (ret >= 0)
|
|
|
|
return 0;
|
|
|
|
out:
|
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
|
|
|
}
|
|
|
|
|
2006-12-04 22:35:40 -07:00
|
|
|
int nfs_set_page_dirty(struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
req = nfs_page_find_request(page);
|
|
|
|
if (req != NULL) {
|
|
|
|
/* Mark any existing write requests for flushing */
|
|
|
|
set_bit(PG_NEED_FLUSH, &req->wb_flags);
|
|
|
|
nfs_release_request(req);
|
|
|
|
}
|
|
|
|
return __set_page_dirty_nobuffers(page);
|
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
NULL, NULL);
|
|
|
|
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;
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|