1601 lines · 40.1 KB · C
RawDownload
/* * 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.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t