Attachment 317393 Details for Bug 455408 – Draft Proposed patch

[patch] Draft Proposed patch

455408.rhel-5.6 (text/plain), 13.00 KB, created by Peter Staubach on 2008-09-22 17:52:47 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Peter Staubach

Created: 2008-09-22 17:52:47 UTC

Size: 13.00 KB

patch

obsolete

>--- linux-2.6.18.i686/fs/nfs/write.c.org
>+++ linux-2.6.18.i686/fs/nfs/write.c
>@@ -642,6 +642,31 @@ nfs_scan_dirty(struct inode *inode, stru
> 	return res;
> }
> 
>+/*
>+ * nfs_scan_dirty_async - Scan an inode for dirty requests
>+ * @inode: NFS inode to scan
>+ * @dst: destination list
>+ * @idx_start: lower bound of page->index to scan.
>+ * @npages: Number of pages to return, if possible
>+ *
>+ * Moves requests from the inode's dirty page list.
>+ * The requests are *not* checked to ensure that they form a contiguous set.
>+ */
>+static int
>+nfs_scan_dirty_async(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
>+{
>+	struct nfs_inode *nfsi = NFS_I(inode);
>+	int res = 0;
>+
>+	if (nfsi->ndirty != 0) {
>+		res = nfs_scan_lock_dirty_async(nfsi, dst, idx_start, npages);
>+		nfsi->ndirty -= res;
>+		if ((nfsi->ndirty == 0) != list_empty(&nfsi->dirty))
>+			printk(KERN_ERR "NFS: desynchronized value of nfs_i.ndirty.\n");
>+	}
>+	return res;
>+}
>+
> #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
> /*
>  * nfs_scan_commit - Scan an inode for commit requests
>@@ -1011,9 +1036,23 @@ static void nfs_execute_write(struct nfs
> {
> 	struct rpc_clnt *clnt = NFS_CLIENT(data->inode);
> 	sigset_t oldset;
>+struct nfs_writeargs *args;
>+struct nfs_inode *nfsi;
> 
> 	rpc_clnt_sigmask(clnt, &oldset);
> 	lock_kernel();
>+args = &data->args;
>+nfsi = NFS_I(data->inode);
>+if (nfs_max_outstanding_writes && (args->offset || args->count)) {
>+	if (args->offset != 0 && args->offset != nfsi->offset) {
>+		printk("nfs_execute_write(%lu): %Lu(%Lu)/%u\n",
>+			data->inode->i_ino, args->offset,
>+			nfsi->offset, args->count);
>+		if (args->count != NFS_SERVER(data->inode)->wsize)
>+			dump_stack();
>+	}
>+	nfsi->offset = args->offset + args->count;
>+}
> 	rpc_execute(&data->task);
> 	unlock_kernel();
> 	rpc_clnt_sigunmask(clnt, &oldset);
>@@ -1068,6 +1107,7 @@ static int nfs_flush_multi(struct inode 
> 					nbytes, offset, how);
> 			nbytes = 0;
> 		}
>+		nfs_inc_writes_outstanding(inode);
> 		nfs_execute_write(data);
> 	} while (nbytes != 0);
> 
>@@ -1119,6 +1159,7 @@ static int nfs_flush_one(struct inode *i
> 	/* Set up the argument struct */
> 	nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
> 
>+	nfs_inc_writes_outstanding(inode);
> 	nfs_execute_write(data);
> 	return 0;
>  out_bad:
>@@ -1143,10 +1184,6 @@ static int nfs_flush_list(struct inode *
> 	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);
>@@ -1348,6 +1385,7 @@ int nfs_writeback_done(struct rpc_task *
> 		/* Can't do anything about it except throw an error. */
> 		task->tk_status = -EIO;
> 	}
>+	nfs_dec_writes_outstanding(data->inode);
> 	return 0;
> }
> 
>@@ -1496,14 +1534,42 @@ static int nfs_flush_inode(struct inode 
> 	LIST_HEAD(head);
> 	int res;
> 
>+	nfs_wait_on_flushing(inode);
>+
> 	spin_lock(&nfsi->req_lock);
> 	res = nfs_scan_dirty(inode, &head, idx_start, npages);
> 	spin_unlock(&nfsi->req_lock);
> 	if (res) {
> 		int error = nfs_flush_list(inode, &head, res, how);
> 		if (error < 0)
>-			return error;
>+			res = error;
> 	}
>+
>+	nfs_wake_up_after_flushing(inode);
>+
>+	return res;
>+}
>+
>+int nfs_flush_inode_async(struct inode *inode, unsigned long idx_start,
>+			   unsigned int npages)
>+{
>+	struct nfs_inode *nfsi = NFS_I(inode);
>+	LIST_HEAD(head);
>+	int res;
>+
>+	nfs_wait_on_flushing(inode);
>+
>+	spin_lock(&nfsi->req_lock);
>+	res = nfs_scan_dirty_async(inode, &head, idx_start, npages);
>+	spin_unlock(&nfsi->req_lock);
>+	if (res) {
>+		int error = nfs_flush_list(inode, &head, res, 0);
>+		if (error < 0)
>+			res = error;
>+	}
>+
>+	nfs_wake_up_after_flushing(inode);
>+
> 	return res;
> }
> 
>@@ -1534,6 +1600,8 @@ int nfs_sync_inode_wait(struct inode *in
> 	int nocommit = how & FLUSH_NOCOMMIT;
> 	int pages, ret;
> 
>+	nfs_wait_on_flushing(inode);
>+
> 	how &= ~FLUSH_NOCOMMIT;
> 	spin_lock(&nfsi->req_lock);
> 	do {
>@@ -1567,6 +1635,9 @@ int nfs_sync_inode_wait(struct inode *in
> 		spin_lock(&nfsi->req_lock);
> 	} while (ret >= 0);
> 	spin_unlock(&nfsi->req_lock);
>+
>+	nfs_wake_up_after_flushing(inode);
>+
> 	return ret;
> }
> 
>--- linux-2.6.18.i686/fs/nfs/inode.c.org
>+++ linux-2.6.18.i686/fs/nfs/inode.c
>@@ -439,6 +439,64 @@ static void nfs_wake_up_inode(struct ino
> 	wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
> }
> 
>+/*
>+ * Wait for the WRITE flushing to complete.
>+ */
>+int nfs_wait_on_flushing(struct inode *inode)
>+{
>+	struct rpc_clnt	*clnt = NFS_CLIENT(inode);
>+	struct nfs_inode *nfsi = NFS_I(inode);
>+	sigset_t oldmask;
>+	int error;
>+
>+	rpc_clnt_sigmask(clnt, &oldmask);
>+	error = wait_on_bit_lock(&nfsi->flags, NFS_INO_FLUSHING,
>+					nfs_wait_schedule, TASK_INTERRUPTIBLE);
>+	rpc_clnt_sigunmask(clnt, &oldmask);
>+
>+	return error;
>+}
>+
>+void nfs_wake_up_after_flushing(struct inode *inode)
>+{
>+	struct nfs_inode *nfsi = NFS_I(inode);
>+
>+	clear_bit(NFS_INO_FLUSHING, &nfsi->flags);
>+	smp_mb__after_clear_bit();
>+	wake_up_bit(&nfsi->flags, NFS_INO_FLUSHING);
>+}
>+
>+int nfs_max_outstanding_writes = 0;
>+int nfs_peak_outstanding_writes = 0;
>+
>+void nfs_inc_writes_outstanding(struct inode *inode)
>+{
>+	struct nfs_inode *nfsi = NFS_I(inode);
>+	int peak;
>+
>+	peak = atomic_inc_return(&nfsi->writes);
>+	if (peak > nfs_peak_outstanding_writes)
>+		nfs_peak_outstanding_writes = peak;
>+}
>+
>+void nfs_dec_writes_outstanding(struct inode *inode)
>+{
>+	struct nfs_inode *nfsi = NFS_I(inode);
>+
>+	if (atomic_dec_return(&nfsi->writes) < nfs_max_outstanding_writes)
>+		wake_up(&nfsi->writes_wq);
>+}
>+
>+void nfs_wait_for_writes_outstanding(struct inode *inode)
>+{
>+	struct nfs_inode *nfsi = NFS_I(inode);
>+
>+	if (nfs_max_outstanding_writes) {
>+		wait_event(nfsi->writes_wq,
>+		    atomic_read(&nfsi->writes) < nfs_max_outstanding_writes);
>+	}
>+}
>+
> int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
> {
> 	struct inode *inode = dentry->d_inode;
>@@ -1082,6 +1140,7 @@ struct inode *nfs_alloc_inode(struct sup
> #ifdef CONFIG_NFS_V4
> 	nfsi->nfs4_acl = NULL;
> #endif /* CONFIG_NFS_V4 */
>+nfsi->offset = 0;
> 	return &nfsi->vfs_inode;
> }
> 
>@@ -1120,6 +1179,8 @@ static void init_once(void * foo, kmem_c
> 		atomic_set(&nfsi->silly_count, 1);
> 		INIT_HLIST_HEAD(&nfsi->silly_list);
> 		init_waitqueue_head(&nfsi->waitqueue);
>+		atomic_set(&nfsi->writes, 0);
>+		init_waitqueue_head(&nfsi->writes_wq);
> 		nfs4_init_once(nfsi);
> 	}
> }
>--- linux-2.6.18.i686/fs/nfs/file.c.org
>+++ linux-2.6.18.i686/fs/nfs/file.c
>@@ -338,7 +338,11 @@ static void nfs_invalidate_page(struct p
> static int nfs_release_page(struct page *page, gfp_t gfp)
> {
> 	if (gfp & __GFP_FS) {
>+#ifdef notdef
> 		int error = nfs_wb_page(page->mapping->host, page);
>+#else
>+		int error = nfs_sync_inode_wait(page->mapping->host, 0, 0, FLUSH_STABLE);
>+#endif
> 
> 		if (error == 0) {
> 			nfs_fscache_release_page(page);
>@@ -395,6 +399,11 @@ static int nfs_need_sync_write(struct fi
> 	return 0;
> }
> 
>+static int nfs_is_serial(struct inode *inode, loff_t pos)
>+{
>+	return NFS_I(inode)->wrpos == pos;
>+}
>+
> static ssize_t
> nfs_file_write(struct kiocb *iocb, const char __user *buf, size_t count, loff_t pos)
> {
>@@ -427,13 +436,25 @@ nfs_file_write(struct kiocb *iocb, const
> 	if (!count)
> 		goto out;
> 
>+	nfs_wait_for_writes_outstanding(inode);
>+
> 	nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, count);
> 	result = generic_file_aio_write(iocb, buf, count, pos);
>-	/* Return error values for O_SYNC and IS_SYNC() */
>-	if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
>-		int err = nfs_do_fsync(iocb->ki_filp->private_data, inode);
>-		if (err < 0)
>-			result = err;
>+	if (result >= 0) {
>+		/* Return error values for O_SYNC and IS_SYNC() */
>+		if (nfs_need_sync_write(iocb->ki_filp, inode)) {
>+			int err;
>+			err = nfs_do_fsync(iocb->ki_filp->private_data, inode);
>+			if (err < 0)
>+				result = err;
>+		} else if (nfs_is_serial(inode, pos) &&
>+			   nfs_max_outstanding_writes) {
>+			if (NFS_I(inode)->ndirty >= NFS_SERVER(inode)->wpages) {
>+				nfs_flush_inode_async(inode, 0,
>+						NFS_SERVER(inode)->wpages);
>+				}
>+		}
>+		NFS_I(inode)->wrpos = pos + result;
> 	}
> out:
> 	return result;
>--- linux-2.6.18.i686/fs/nfs/internal.h.org
>+++ linux-2.6.18.i686/fs/nfs/internal.h
>@@ -153,6 +153,8 @@ extern void nfs_clear_inode(struct inode
> #ifdef CONFIG_NFS_V4
> extern void nfs4_clear_inode(struct inode *);
> #endif
>+extern int nfs_wait_on_flushing(struct inode *);
>+extern void nfs_wake_up_after_flushing(struct inode *);
> 
> /* super.c */
> extern struct file_system_type nfs_xdev_fs_type;
>@@ -168,6 +170,12 @@ extern void __exit unregister_nfs_fs(voi
> extern void nfs_sb_active(struct nfs_server *server);
> extern void nfs_sb_deactive(struct nfs_server *server);
> 
>+extern void nfs_inc_writes_outstanding(struct inode *inode);
>+extern void nfs_dec_writes_outstanding(struct inode *inode);
>+extern void nfs_wait_for_writes_outstanding(struct inode *inode);
>+extern int nfs_max_outstanding_writes;
>+extern int nfs_peak_outstanding_writes;
>+
> /* namespace.c */
> extern char *nfs_path(const char *base,
> 		      const struct dentry *droot,
>--- linux-2.6.18.i686/fs/nfs/sysctl.c.org
>+++ linux-2.6.18.i686/fs/nfs/sysctl.c
>@@ -98,6 +98,22 @@ static ctl_table nfs_cb_sysctls[] = {
> 		.proc_handler = &proc_dointvec,
> 	},
> #endif
>+	{
>+		.ctl_name = CTL_UNNUMBERED,
>+		.procname = "nfs_max_outstanding_writes",
>+		.data = &nfs_max_outstanding_writes,
>+		.maxlen = sizeof(int),
>+		.mode = 0644,
>+		.proc_handler = &proc_dointvec,
>+	},
>+	{
>+		.ctl_name = CTL_UNNUMBERED,
>+		.procname = "nfs_peak_outstanding_writes",
>+		.data = &nfs_peak_outstanding_writes,
>+		.maxlen = sizeof(int),
>+		.mode = 0644,
>+		.proc_handler = &proc_dointvec,
>+	},
> 	{ .ctl_name = 0 }
> };
> 
>--- linux-2.6.18.i686/fs/nfs/pagelist.c.org
>+++ linux-2.6.18.i686/fs/nfs/pagelist.c
>@@ -325,6 +325,55 @@ out:
> }
> 
> /**
>+ * nfs_scan_lock_dirty_async - Scan the radix tree for dirty requests
>+ * @nfsi: NFS inode
>+ * @dst: Destination list
>+ * @idx_start: lower bound of page->index to scan
>+ * @npages: Number of pages to return, if possible
>+ *
>+ * Moves elements from one of the inode request lists.
>+ * The entire address_space starting at index idx_start, is scanned
>+ * until npages requests are found.
>+ * The requests are *not* checked to ensure that they form a contiguous set.
>+ * You must be holding the inode's req_lock when calling this function
>+ */
>+int
>+nfs_scan_lock_dirty_async(struct nfs_inode *nfsi, struct list_head *dst,
>+	      unsigned long idx_start, unsigned int npages)
>+{
>+	struct nfs_page *pgvec[NFS_SCAN_MAXENTRIES];
>+	struct nfs_page *req;
>+	int found, i;
>+	int res;
>+
>+	res = 0;
>+	for (;;) {
>+		found = radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree,
>+			    (void **)&pgvec[0], idx_start, NFS_SCAN_MAXENTRIES,
>+			    NFS_PAGE_TAG_DIRTY);
>+		if (found <= 0)
>+			break;
>+		for (i = 0; i < found; i++) {
>+			req = pgvec[i];
>+			idx_start = req->wb_index + 1;
>+			if (nfs_set_page_writeback_locked(req)) {
>+				radix_tree_tag_clear(&nfsi->nfs_page_tree,
>+					    req->wb_index, NFS_PAGE_TAG_DIRTY);
>+				nfs_list_remove_request(req);
>+				nfs_list_add_request(req, dst);
>+				dec_zone_page_state(req->wb_page,
>+						    NR_FILE_DIRTY);
>+				res++;
>+				if (res == npages)
>+					goto out;
>+			}
>+		}
>+	}
>+out:
>+	return res;
>+}
>+
>+/**
>  * nfs_scan_list - Scan a list for matching requests
>  * @nfsi: NFS inode
>  * @head: One of the NFS inode request lists
>--- linux-2.6.18.i686/include/linux/nfs_fs.h.org
>+++ linux-2.6.18.i686/include/linux/nfs_fs.h
>@@ -203,6 +203,10 @@ struct nfs_inode {
> 	struct fscache_cookie	*fscache;
> #endif
> 	struct inode		vfs_inode;
>+__u64 offset;
>+	atomic_t		writes;	/* number of outstandings WRITES */
>+	wait_queue_head_t	writes_wq;
>+	loff_t			wrpos;	/* position after the last write */
> };
> 
> /*
>@@ -224,6 +228,7 @@ struct nfs_inode {
> #define NFS_INO_ACL_LRU_SET	(3)		/* Inode is on the LRU list */
> #define NFS_INO_FSCACHE	(4)		/* inode can be cached by FS-Cache */
> #define NFS_INO_MOUNTPOINT	(5)		/* inode is remote mountpoint */
>+#define NFS_INO_FLUSHING	(6)		/* flushing WRITE requests */
> 
> static inline struct nfs_inode *NFS_I(struct inode *inode)
> {
>@@ -453,6 +458,7 @@ extern void nfs_writedata_release(void *
>  * return value!)
>  */
> extern int  nfs_sync_inode_wait(struct inode *, unsigned long, unsigned int, int);
>+extern int  nfs_flush_inode_async(struct inode *, unsigned long, unsigned int);
> #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
> extern int  nfs_commit_inode(struct inode *, int);
> extern struct nfs_write_data *nfs_commit_alloc(void);
>--- linux-2.6.18.i686/include/linux/nfs_page.h.org
>+++ linux-2.6.18.i686/include/linux/nfs_page.h
>@@ -62,6 +62,10 @@ extern	void nfs_release_request(struct n
> 
> extern  int nfs_scan_lock_dirty(struct nfs_inode *nfsi, struct list_head *dst,
> 				unsigned long idx_start, unsigned int npages);
>+extern  int nfs_scan_lock_dirty_async(struct nfs_inode *nfsi,
>+				      struct list_head *dst,
>+				      unsigned long idx_start,
>+				      unsigned int npages);
> extern	int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *head, struct list_head *dst,
> 			  unsigned long idx_start, unsigned int npages);
> extern	int nfs_coalesce_requests(struct list_head *, struct list_head *,

Actions: View | Diff

Attachments on bug 455408: 311973 | 312656 | 313588 | 314535 | 316301 | 316870 | 317393