/* * linux/fs/nfs/write.c * * Write file data over NFS. * * 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/swap.h> #include <linux/sunrpc/clnt.h>#include <linux/nfs_fs.h>#include <linux/nfs_mount.h>#include <linux/nfs_page.h>#include <linux/backing-dev.h> #include <asm/uaccess.h>#include <linux/smp_lock.h> #include "delegation.h"#include "internal.h"#include "iostat.h" #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);static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how);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; static struct kmem_cache *nfs_wdata_cachep;static mempool_t *nfs_wdata_mempool;static mempool_t *nfs_commit_mempool; struct nfs_write_data *nfs_commit_alloc(void){ struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS); if (p) { memset(p, 0, sizeof(*p)); INIT_LIST_HEAD(&p->pages); } return p;} void nfs_commit_rcu_free(struct rcu_head *head){ struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu); if (p && (p->pagevec != &p->page_array[0])) kfree(p->pagevec); mempool_free(p, nfs_commit_mempool);} void nfs_commit_free(struct nfs_write_data *wdata){ call_rcu_bh(&wdata->task.u.tk_rcu, nfs_commit_rcu_free);} struct nfs_write_data *nfs_writedata_alloc(size_t len){ unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT; struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS); if (p) { memset(p, 0, sizeof(*p)); INIT_LIST_HEAD(&p->pages); p->npages = pagecount; if (pagecount <= ARRAY_SIZE(p->page_array)) p->pagevec = p->page_array; else { p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS); if (!p->pagevec) { mempool_free(p, nfs_wdata_mempool); p = NULL; } } } return p;} static void nfs_writedata_rcu_free(struct rcu_head *head){ struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu); if (p && (p->pagevec != &p->page_array[0])) kfree(p->pagevec); mempool_free(p, nfs_wdata_mempool);} static void nfs_writedata_free(struct nfs_write_data *wdata){ call_rcu_bh(&wdata->task.u.tk_rcu, nfs_writedata_rcu_free);} void nfs_writedata_release(void *wdata){ nfs_writedata_free(wdata);} 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;} /* 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; nfs_inc_stats(inode, NFSIOS_EXTENDWRITE); i_size_write(inode, end);} /* 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);} /* 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; if (count != nfs_page_length(page)) return; if (count != PAGE_CACHE_SIZE) memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count); SetPageUptodate(page);} static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page, unsigned int offset, unsigned int count){ struct nfs_page *req; int ret; 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; } /* Update file length */ nfs_grow_file(page, offset, count); /* Set the PG_uptodate flag? */ nfs_mark_uptodate(page, offset, count); nfs_unlock_request(req); return 0;} static int wb_priority(struct writeback_control *wbc){ if (wbc->for_reclaim) return FLUSH_HIGHPRI; if (wbc->for_kupdate) return FLUSH_LOWPRI; return 0;} /* * 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)) static int nfs_set_page_writeback(struct page *page){ int ret = test_set_page_writeback(page); if (!ret) { struct inode *inode = page->mapping->host; struct nfs_server *nfss = NFS_SERVER(inode); if (atomic_inc_return(&nfss->writeback) > NFS_CONGESTION_ON_THRESH) set_bdi_congested(&nfss->backing_dev_info, WRITE); } return ret;} 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); if (atomic_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH) { clear_bdi_congested(&nfss->backing_dev_info, WRITE); congestion_end(WRITE); }} /* * 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; struct nfs_inode *nfsi = NFS_I(page->mapping->host); spinlock_t *req_lock = &nfsi->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); } if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) { /* This request is marked for commit */ spin_unlock(req_lock); nfs_unlock_request(req); return 1; } if (nfs_set_page_writeback(page) == 0) { nfs_list_remove_request(req); /* add the request to the inode's dirty list. */ radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_DIRTY); nfs_list_add_request(req, &nfsi->dirty); nfsi->ndirty++; spin_unlock(req_lock); __mark_inode_dirty(page->mapping->host, I_DIRTY_PAGES); } else spin_unlock(req_lock); ret = test_bit(PG_NEED_FLUSH, &req->wb_flags); nfs_unlock_request(req); return ret;} /* * Write an mmapped page to the server. */static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc){ struct nfs_open_context *ctx; struct inode *inode = page->mapping->host; unsigned offset; int err; nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE); nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1); err = nfs_page_mark_flush(page); if (err <= 0) goto out; err = 0; offset = nfs_page_length(page); if (!offset) goto out; ctx = nfs_find_open_context(inode, NULL, FMODE_WRITE); if (ctx == NULL) { err = -EBADF; goto out; } err = nfs_writepage_setup(ctx, page, 0, offset); put_nfs_open_context(ctx); if (err != 0) goto out; err = nfs_page_mark_flush(page); if (err > 0) err = 0;out: if (!wbc->for_writepages) nfs_flush_mapping(page->mapping, wbc, FLUSH_STABLE|wb_priority(wbc)); return err;} int nfs_writepage(struct page *page, struct writeback_control *wbc){ int err; err = nfs_writepage_locked(page, wbc); unlock_page(page); return err; } int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc){ struct inode *inode = mapping->host; int err; nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES); err = generic_writepages(mapping, wbc); if (err) return err; err = nfs_flush_mapping(mapping, wbc, wb_priority(wbc)); if (err < 0) goto out; nfs_add_stats(inode, NFSIOS_WRITEPAGES, err); err = 0;out: 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++; } SetPagePrivate(req->wb_page); set_page_private(req->wb_page, (unsigned long)req); if (PageDirty(req->wb_page)) set_bit(PG_NEED_FLUSH, &req->wb_flags); nfsi->npages++; atomic_inc(&req->wb_count); return 0;} /* * Remove a write request from 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); set_page_private(req->wb_page, 0); ClearPagePrivate(req->wb_page); radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index); if (test_and_clear_bit(PG_NEED_FLUSH, &req->wb_flags)) __set_page_dirty_nobuffers(req->wb_page); nfsi->npages--; if (!nfsi->npages) { spin_unlock(&nfsi->req_lock); nfs_end_data_update(inode); iput(inode); } else spin_unlock(&nfsi->req_lock); nfs_clear_request(req); nfs_release_request(req);} static voidnfs_redirty_request(struct nfs_page *req){ __set_page_dirty_nobuffers(req->wb_page);} /* * Check if a request is dirty */static inline intnfs_dirty_request(struct nfs_page *req){ struct page *page = req->wb_page; if (page == NULL || test_bit(PG_NEED_COMMIT, &req->wb_flags)) return 0; return !PageWriteback(req->wb_page);} #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)/* * Add a request to the inode's commit list. */static voidnfs_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++; set_bit(PG_NEED_COMMIT, &(req)->wb_flags); spin_unlock(&nfsi->req_lock); inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS); __mark_inode_dirty(inode, I_DIRTY_DATASYNC);} static inlineint nfs_write_need_commit(struct nfs_write_data *data){ return data->verf.committed != NFS_FILE_SYNC;} static inlineint nfs_reschedule_unstable_write(struct nfs_page *req){ if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) { nfs_mark_request_commit(req); return 1; } if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) { nfs_redirty_request(req); return 1; } return 0;}#elsestatic inline voidnfs_mark_request_commit(struct nfs_page *req){} static inlineint nfs_write_need_commit(struct nfs_write_data *data){ return 0;} static inlineint nfs_reschedule_unstable_write(struct nfs_page *req){ return 0;}#endif Lines 1–500 of 1601. Load more
/* * linux/fs/nfs/write.c * * Write file data over NFS. * * 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/swap.h> #include <linux/sunrpc/clnt.h> #include <linux/nfs_fs.h> #include <linux/nfs_mount.h> #include <linux/nfs_page.h> #include <linux/backing-dev.h> #include <asm/uaccess.h> #include <linux/smp_lock.h> #include "delegation.h" #include "internal.h" #include "iostat.h" #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); static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how); 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; static struct kmem_cache *nfs_wdata_cachep; static mempool_t *nfs_wdata_mempool; static mempool_t *nfs_commit_mempool; struct nfs_write_data *nfs_commit_alloc(void) { struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS); if (p) { memset(p, 0, sizeof(*p)); INIT_LIST_HEAD(&p->pages); } return p; } void nfs_commit_rcu_free(struct rcu_head *head) { struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu); if (p && (p->pagevec != &p->page_array[0])) kfree(p->pagevec); mempool_free(p, nfs_commit_mempool); } void nfs_commit_free(struct nfs_write_data *wdata) { call_rcu_bh(&wdata->task.u.tk_rcu, nfs_commit_rcu_free); } struct nfs_write_data *nfs_writedata_alloc(size_t len) { unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT; struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS); if (p) { memset(p, 0, sizeof(*p)); INIT_LIST_HEAD(&p->pages); p->npages = pagecount; if (pagecount <= ARRAY_SIZE(p->page_array)) p->pagevec = p->page_array; else { p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS); if (!p->pagevec) { mempool_free(p, nfs_wdata_mempool); p = NULL; } } } return p; } static void nfs_writedata_rcu_free(struct rcu_head *head) { struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu); if (p && (p->pagevec != &p->page_array[0])) kfree(p->pagevec); mempool_free(p, nfs_wdata_mempool); } static void nfs_writedata_free(struct nfs_write_data *wdata) { call_rcu_bh(&wdata->task.u.tk_rcu, nfs_writedata_rcu_free); } void nfs_writedata_release(void *wdata) { nfs_writedata_free(wdata); } 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; } /* 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; nfs_inc_stats(inode, NFSIOS_EXTENDWRITE); i_size_write(inode, end); } /* 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); } /* 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; if (count != nfs_page_length(page)) return; if (count != PAGE_CACHE_SIZE) memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count); SetPageUptodate(page); } static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page, unsigned int offset, unsigned int count) { struct nfs_page *req; int ret; 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; } /* Update file length */ nfs_grow_file(page, offset, count); /* Set the PG_uptodate flag? */ nfs_mark_uptodate(page, offset, count); nfs_unlock_request(req); return 0; } static int wb_priority(struct writeback_control *wbc) { if (wbc->for_reclaim) return FLUSH_HIGHPRI; if (wbc->for_kupdate) return FLUSH_LOWPRI; return 0; } /* * 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)) static int nfs_set_page_writeback(struct page *page) { int ret = test_set_page_writeback(page); if (!ret) { struct inode *inode = page->mapping->host; struct nfs_server *nfss = NFS_SERVER(inode); if (atomic_inc_return(&nfss->writeback) > NFS_CONGESTION_ON_THRESH) set_bdi_congested(&nfss->backing_dev_info, WRITE); } return ret; } 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); if (atomic_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH) { clear_bdi_congested(&nfss->backing_dev_info, WRITE); congestion_end(WRITE); } } /* * 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; struct nfs_inode *nfsi = NFS_I(page->mapping->host); spinlock_t *req_lock = &nfsi->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); } if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) { /* This request is marked for commit */ spin_unlock(req_lock); nfs_unlock_request(req); return 1; } if (nfs_set_page_writeback(page) == 0) { nfs_list_remove_request(req); /* add the request to the inode's dirty list. */ radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_DIRTY); nfs_list_add_request(req, &nfsi->dirty); nfsi->ndirty++; spin_unlock(req_lock); __mark_inode_dirty(page->mapping->host, I_DIRTY_PAGES); } else spin_unlock(req_lock); ret = test_bit(PG_NEED_FLUSH, &req->wb_flags); nfs_unlock_request(req); return ret; } /* * Write an mmapped page to the server. */ static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc) { struct nfs_open_context *ctx; struct inode *inode = page->mapping->host; unsigned offset; int err; nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE); nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1); err = nfs_page_mark_flush(page); if (err <= 0) goto out; err = 0; offset = nfs_page_length(page); if (!offset) goto out; ctx = nfs_find_open_context(inode, NULL, FMODE_WRITE); if (ctx == NULL) { err = -EBADF; goto out; } err = nfs_writepage_setup(ctx, page, 0, offset); put_nfs_open_context(ctx); if (err != 0) goto out; err = nfs_page_mark_flush(page); if (err > 0) err = 0; out: if (!wbc->for_writepages) nfs_flush_mapping(page->mapping, wbc, FLUSH_STABLE|wb_priority(wbc)); return err; } int nfs_writepage(struct page *page, struct writeback_control *wbc) { int err; err = nfs_writepage_locked(page, wbc); unlock_page(page); return err; } int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc) { struct inode *inode = mapping->host; int err; nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES); err = generic_writepages(mapping, wbc); if (err) return err; err = nfs_flush_mapping(mapping, wbc, wb_priority(wbc)); if (err < 0) goto out; nfs_add_stats(inode, NFSIOS_WRITEPAGES, err); err = 0; out: 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++; } SetPagePrivate(req->wb_page); set_page_private(req->wb_page, (unsigned long)req); if (PageDirty(req->wb_page)) set_bit(PG_NEED_FLUSH, &req->wb_flags); nfsi->npages++; atomic_inc(&req->wb_count); return 0; } /* * Remove a write request from 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); set_page_private(req->wb_page, 0); ClearPagePrivate(req->wb_page); radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index); if (test_and_clear_bit(PG_NEED_FLUSH, &req->wb_flags)) __set_page_dirty_nobuffers(req->wb_page); nfsi->npages--; if (!nfsi->npages) { spin_unlock(&nfsi->req_lock); nfs_end_data_update(inode); iput(inode); } else spin_unlock(&nfsi->req_lock); nfs_clear_request(req); nfs_release_request(req); } static void nfs_redirty_request(struct nfs_page *req) { __set_page_dirty_nobuffers(req->wb_page); } /* * Check if a request is dirty */ static inline int nfs_dirty_request(struct nfs_page *req) { struct page *page = req->wb_page; if (page == NULL || test_bit(PG_NEED_COMMIT, &req->wb_flags)) return 0; return !PageWriteback(req->wb_page); } #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++; set_bit(PG_NEED_COMMIT, &(req)->wb_flags); spin_unlock(&nfsi->req_lock); inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS); __mark_inode_dirty(inode, I_DIRTY_DATASYNC); } 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) { if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) { nfs_mark_request_commit(req); return 1; } if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) { nfs_redirty_request(req); return 1; } return 0; } #else static inline void nfs_mark_request_commit(struct nfs_page *req) { } 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; } #endif