Skip to contentSkip to conversation

pnfs block layout driver fixes

PATCH In review Christoph Hellwig 7 participants 38 messages Aug 7, 2014 – Sep 7, 2014

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

This series fixes a wide range of issues with the pnfs block layout driver.

Before this we were seeing frequent silent data corruption, softlockups and kernel crashes when running both user applications and test cases like xfstests.

After this rewrite of the I/O path we've sorted out all issues under normal operations, although error handling in the block layout driver and its interaction with the core nfs and pnfs code still needs further work.

This work was sponsored by NetApp, Inc.

#1 lore raw

PATCH 1/17 nfs: cap request size to fit a kmalloced page array

pNFS servers may return arbitrarily large layouts. Trim back the I/O size to one that we can at least allocate the page array for.

---
 fs/nfs/pagelist.c | 8 ++++++++
 1 file changed, 8 insertions(+)
fs/nfs/pagelist.c +8 -0
index 9425118..23471b1 100644
@@ -466,6 +466,14 @@ size_t nfs_generic_pg_test(struct nfs_pageio_descriptor *desc,
 		return 0;
 	}
 
+	/*
+	 * Limit the request size so that we can still allocate a page array
+	 * for it without upsetting the slab allocator.
+	 */
+	if (((desc->pg_count + req->wb_bytes) >> PAGE_SHIFT) *
+			sizeof(struct page) > PAGE_SIZE)
+		return 0;
+
 	return min(desc->pg_bsize - desc->pg_count, (size_t)req->wb_bytes);
 }
 EXPORT_SYMBOL_GPL(nfs_generic_pg_test);
Signature · 1 line
1.9.1
#2 lore raw

PATCH 2/17 pnfs: do not pass uninitialized lsegs to ->free_lseg

In reply to Christoph Hellwig

Ensure the lsegs are initialized early so that we don't pass an unitialized one back to ->free_lseg during error processing.

---
 fs/nfs/pnfs.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/nfs/pnfs.c +3 -2
index 4e85315..6d01740 100644
@@ -1358,6 +1358,9 @@ pnfs_layout_process(struct nfs4_layoutget *lgp)
 		goto out;
 	}
 
+	init_lseg(lo, lseg);
+	lseg->pls_range = res->range;
+
 	spin_lock(&ino->i_lock);
 	if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) {
 		dprintk("%s forget reply due to recall\n", __func__);
@@ -1375,8 +1378,6 @@ pnfs_layout_process(struct nfs4_layoutget *lgp)
 	/* Done processing layoutget. Set the layout stateid */
 	pnfs_set_layout_stateid(lo, &res->stateid, false);
 
-	init_lseg(lo, lseg);
-	lseg->pls_range = res->range;
 	pnfs_get_lseg(lseg);
 	pnfs_layout_insert_lseg(lo, lseg);
 
Signature · 1 line
1.9.1
#3 lore raw

PATCH 3/17 pnfs: force a layout commit when encountering busy segments during recall

In reply to Christoph Hellwig

Expedite layout recall processing by forcing a layout commit when we see busy segments. Without it the layout recall might have to wait until the VM decided to start writeback for the file, which can introduce long delays.

---
 fs/nfs/callback_proc.c | 16 +++++++++++-----
 fs/nfs/pnfs.c          |  3 +++
 2 files changed, 14 insertions(+), 5 deletions(-)
fs/nfs/callback_proc.c +11 -5
index 41db525..bf017b0 100644
@@ -164,6 +164,7 @@ static u32 initiate_file_draining(struct nfs_client *clp,
 	struct inode *ino;
 	struct pnfs_layout_hdr *lo;
 	u32 rv = NFS4ERR_NOMATCHING_LAYOUT;
+	bool need_commit = false;
 	LIST_HEAD(free_me_list);
 
 	lo = get_layout_by_fh(clp, &args->cbl_fh, &args->cbl_stateid);
@@ -172,16 +173,21 @@ static u32 initiate_file_draining(struct nfs_client *clp,
 
 	ino = lo->plh_inode;
 	spin_lock(&ino->i_lock);
-	if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags) ||
-	    pnfs_mark_matching_lsegs_invalid(lo, &free_me_list,
-					&args->cbl_range))
+	if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) {
 		rv = NFS4ERR_DELAY;
-	else
-		rv = NFS4ERR_NOMATCHING_LAYOUT;
+	} else if (pnfs_mark_matching_lsegs_invalid(lo, &free_me_list,
+			&args->cbl_range)) {
+		need_commit = true;
+		rv = NFS4ERR_DELAY;
+	}
+
 	pnfs_set_layout_stateid(lo, &args->cbl_stateid, true);
 	spin_unlock(&ino->i_lock);
 	pnfs_free_lseg_list(&free_me_list);
 	pnfs_put_layout_hdr(lo);
+
+	if (need_commit)
+		pnfs_layoutcommit_inode(ino, false);
 	iput(ino);
 out:
 	return rv;
fs/nfs/pnfs.c +3 -0
index 6d01740..c72376c 100644
@@ -604,6 +604,9 @@ pnfs_layout_free_bulk_destroy_list(struct list_head *layout_list,
 		spin_unlock(&inode->i_lock);
 		pnfs_free_lseg_list(&lseg_list);
 		pnfs_put_layout_hdr(lo);
+
+		if (ret)
+			pnfs_layoutcommit_inode(inode, false);
 		iput(inode);
 	}
 	return ret;
Signature · 1 line
1.9.1
#4 lore raw

PATCH 4/17 pnfs: don't check sequence on new stateids in layoutget

In reply to Christoph Hellwig

When layoutget returns an entirely new layout stateid it should not check the generation counter as the new stateid will start with a new counter entirely unrelated to old one.

The current behavior causes constant layoutget failures against a block server which allocates a new stateid after an recall that removed all outstanding layouts.

---
 fs/nfs/pnfs.c | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)
fs/nfs/pnfs.c +19 -17
index c72376c..22183fc 100644
@@ -685,17 +685,6 @@ static bool pnfs_seqid_is_newer(u32 s1, u32 s2)
 	return (s32)(s1 - s2) > 0;
 }
 
-static void
-pnfs_verify_layout_stateid(struct pnfs_layout_hdr *lo,
-		const nfs4_stateid *new,
-		struct list_head *free_me_list)
-{
-	if (nfs4_stateid_match_other(&lo->plh_stateid, new))
-		return;
-	/* Layout is new! Kill existing layout segments */
-	pnfs_mark_matching_lsegs_invalid(lo, free_me_list, NULL);
-}
-
 /* update lo->plh_stateid with new if is more recent */
 void
 pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo, const nfs4_stateid *new,
@@ -1370,16 +1359,29 @@ pnfs_layout_process(struct nfs4_layoutget *lgp)
 		goto out_forget_reply;
 	}
 
-	if (pnfs_layoutgets_blocked(lo, 1) ||
-	    pnfs_layout_stateid_blocked(lo, &res->stateid)) {
+	if (pnfs_layoutgets_blocked(lo, 1)) {
 		dprintk("%s forget reply due to state\n", __func__);
 		goto out_forget_reply;
 	}
 
-	/* Check that the new stateid matches the old stateid */
-	pnfs_verify_layout_stateid(lo, &res->stateid, &free_me);
-	/* Done processing layoutget. Set the layout stateid */
-	pnfs_set_layout_stateid(lo, &res->stateid, false);
+	if (nfs4_stateid_match_other(&lo->plh_stateid, &res->stateid)) {
+		/* existing state ID, make sure the sequence number matches. */
+		if (pnfs_layout_stateid_blocked(lo, &res->stateid)) {
+			dprintk("%s forget reply due to sequence\n", __func__);
+			goto out_forget_reply;
+		}
+		pnfs_set_layout_stateid(lo, &res->stateid, false);
+	} else {
+		/*
+		 * We got an entirely new state ID.  Mark all segments for the
+		 * inode invalid, and don't bother validating the stateid
+		 * sequence number.
+		 */
+		pnfs_mark_matching_lsegs_invalid(lo, &free_me, NULL);
+
+		nfs4_stateid_copy(&lo->plh_stateid, &res->stateid);
+		lo->plh_barrier = be32_to_cpu(res->stateid.seqid);
+	}
 
 	pnfs_get_lseg(lseg);
 	pnfs_layout_insert_lseg(lo, lseg);
Signature · 1 line
1.9.1
#5 lore raw

PATCH 5/17 pnfs: add flag to force read-modify-write in ->write_begin

In reply to Christoph Hellwig

Like all block based filesystems, the pNFS block layout driver can't read or write at a byte granularity and thus has to perform read-modify-write cycles on writes smaller than this granularity.

Add a flag so that the core NFS code always reads a whole page when starting a smaller write, so that we can do it in the place where the VFS expects it instead of doing in very deadlock prone way in the writeback handler.

Note that in theory we could do less than page size reads here for disks that have a smaller sector size which are server by a server with a smaller pnfs block size. But so far that doesn't seem like a worthwhile optimization.

---
 fs/nfs/file.c | 9 +++++++++
 fs/nfs/pnfs.h | 1 +
 2 files changed, 10 insertions(+)
fs/nfs/file.c +9 -0
index 4042ff5..718cdd6 100644
@@ -36,6 +36,7 @@
 #include "internal.h"
 #include "iostat.h"
 #include "fscache.h"
+#include "pnfs.h"
 
 #include "nfstrace.h"
 
@@ -323,10 +324,18 @@ nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 static int nfs_want_read_modify_write(struct file *file, struct page *page,
 			loff_t pos, unsigned len)
 {
+	struct nfs_server *server = NFS_SERVER(file->f_mapping->host);
 	unsigned int pglen = nfs_page_length(page);
 	unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
 	unsigned int end = offset + len;
 
+	if (server->pnfs_curr_ld &&
+	    (server->pnfs_curr_ld->flags & PNFS_READ_WHOLE_PAGE)) {
+		if (!PageUptodate(page))
+			return 1;
+		return 0;
+	}
+
 	if ((file->f_mode & FMODE_READ) &&	/* open for read? */
 	    !PageUptodate(page) &&		/* Uptodate? */
 	    !PagePrivate(page) &&		/* i/o request already? */
fs/nfs/pnfs.h +1 -0
index aca3dff..882387c 100644
@@ -71,6 +71,7 @@ enum layoutdriver_policy_flags {
 	/* Should the pNFS client commit and return the layout upon a setattr */
 	PNFS_LAYOUTRET_ON_SETATTR	= 1 << 0,
 	PNFS_LAYOUTRET_ON_ERROR		= 1 << 1,
+	PNFS_READ_WHOLE_PAGE		= 1 << 2,
 };
 
 struct nfs4_deviceid_node;
Signature · 1 line
1.9.1
#6 lore raw

PATCH 6/17 pnfs: add return_range method

In reply to Christoph Hellwig

If a layout driver keeps per-inode state outside of the layout segments it needs to be notified of any layout returns or recalls on an inode, and not just about the freeing of layout segments. Add a method to acomplish this, which will allow the block layout driver to handle the case of truncated and re-expanded files properly.

---
 fs/nfs/callback_proc.c |  6 +++++-
 fs/nfs/pnfs.c          | 10 ++++++++++
 fs/nfs/pnfs.h          |  3 +++
 3 files changed, 18 insertions(+), 1 deletion(-)
fs/nfs/callback_proc.c +5 -1
index bf017b0..86541e0 100644
@@ -179,8 +179,12 @@ static u32 initiate_file_draining(struct nfs_client *clp,
 			&args->cbl_range)) {
 		need_commit = true;
 		rv = NFS4ERR_DELAY;
+	} else {
+		if (NFS_SERVER(ino)->pnfs_curr_ld->return_range) {
+			NFS_SERVER(ino)->pnfs_curr_ld->return_range(lo,
+				&args->cbl_range);
+		}
 	}
-
 	pnfs_set_layout_stateid(lo, &args->cbl_stateid, true);
 	spin_unlock(&ino->i_lock);
 	pnfs_free_lseg_list(&free_me_list);
fs/nfs/pnfs.c +10 -0
index 22183fc..13b1406 100644
@@ -856,6 +856,16 @@ _pnfs_return_layout(struct inode *ino)
 	empty = list_empty(&lo->plh_segs);
 	pnfs_clear_layoutcommit(ino, &tmp_list);
 	pnfs_mark_matching_lsegs_invalid(lo, &tmp_list, NULL);
+
+	if (NFS_SERVER(ino)->pnfs_curr_ld->return_range) {
+		struct pnfs_layout_range range = {
+			.iomode		= IOMODE_ANY,
+			.offset		= 0,
+			.length		= NFS4_MAX_UINT64,
+		};
+		NFS_SERVER(ino)->pnfs_curr_ld->return_range(lo, &range);
+	}
+
 	/* Don't send a LAYOUTRETURN if list was initially empty */
 	if (empty) {
 		spin_unlock(&ino->i_lock);
fs/nfs/pnfs.h +3 -0
index 882387c..cab5259 100644
@@ -93,6 +93,9 @@ struct pnfs_layoutdriver_type {
 	struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr, gfp_t gfp_flags);
 	void (*free_lseg) (struct pnfs_layout_segment *lseg);
 
+	void (*return_range) (struct pnfs_layout_hdr *lo,
+			      struct pnfs_layout_range *range);
+
 	/* test for nfs page cache coalescing */
 	const struct nfs_pageio_ops *pg_read_ops;
 	const struct nfs_pageio_ops *pg_write_ops;
Signature · 1 line
1.9.1
#7 lore raw

PATCH 7/17 pnfs: allow splicing pre-encoded pages into the layoutcommit args

In reply to Christoph Hellwig

Currently there is no XDR buffer space allocated for the per-layout driver layoutcommit payload, which leads to server buffer overflows in the blocklayout driver even under simple workloads. As we can't do per-layout sizes for XDR operations we'll have to splice a previously encoded list of pages into the XDR stream, similar to how we handle ACL buffers.

---
 fs/nfs/nfs4proc.c       | 14 ++++++++++++++
 fs/nfs/nfs4xdr.c        | 18 +++++++++++++-----
 fs/nfs/pnfs.c           | 15 +++++++++++++++
 fs/nfs/pnfs.h           |  4 ++--
 include/linux/nfs_xdr.h |  3 +++
 5 files changed, 47 insertions(+), 7 deletions(-)
fs/nfs/nfs4proc.c +14 -0
index 66fd901..732fe09 100644
@@ -7920,6 +7920,18 @@ nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
 	}
 }
 
+static void nfs4_layoutcommit_release_pages(
+		struct nfs4_layoutcommit_data *data)
+{
+	int nr_pages = DIV_ROUND_UP(data->args.layoutupdate_len, PAGE_SIZE), i;
+
+	for (i = 0; i < nr_pages; i++)
+		put_page(data->args.layoutupdate_pages[i]);
+
+	if (data->args.layoutupdate_pages != &data->args.layoutupdate_page)
+		kfree(data->args.layoutupdate_pages);
+}
+
 static void nfs4_layoutcommit_release(void *calldata)
 {
 	struct nfs4_layoutcommit_data *data = calldata;
@@ -7927,6 +7939,8 @@ static void nfs4_layoutcommit_release(void *calldata)
 	pnfs_cleanup_layoutcommit(data);
 	nfs_post_op_update_inode_force_wcc(data->args.inode,
 					   data->res.fattr);
+	if (data->args.layoutupdate_pages)
+		nfs4_layoutcommit_release_pages(data);
 	put_rpccred(data->cred);
 	kfree(data);
 }
fs/nfs/nfs4xdr.c +13 -5
index e13b59d..f2cd957 100644
@@ -395,7 +395,10 @@ static int nfs4_stat_to_errno(int);
 				2 /* last byte written */ + \
 				1 /* nt_timechanged (false) */ + \
 				1 /* layoutupdate4 layout type */ + \
-				1 /* NULL filelayout layoutupdate4 payload */)
+				1 /* layoutupdate4 opaqueue len */)
+				  /* the actual content of layoutupdate4 should
+				     be allocated by drivers and spliced in
+				     using xdr_write_pages */
 #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)
 #define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
 				encode_stateid_maxsz + \
@@ -1990,7 +1993,7 @@ encode_layoutget(struct xdr_stream *xdr,
 static int
 encode_layoutcommit(struct xdr_stream *xdr,
 		    struct inode *inode,
-		    const struct nfs4_layoutcommit_args *args,
+		    struct nfs4_layoutcommit_args *args,
 		    struct compound_hdr *hdr)
 {
 	__be32 *p;
@@ -2011,11 +2014,16 @@ encode_layoutcommit(struct xdr_stream *xdr,
 	*p++ = cpu_to_be32(0); /* Never send time_modify_changed */
 	*p++ = cpu_to_be32(NFS_SERVER(args->inode)->pnfs_curr_ld->id);/* type */
 
-	if (NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit)
+	if (NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit) {
 		NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit(
 			NFS_I(inode)->layout, xdr, args);
-	else
-		encode_uint32(xdr, 0); /* no layout-type payload */
+	} else {
+		encode_uint32(xdr, args->layoutupdate_len);
+		if (args->layoutupdate_pages) {
+			xdr_write_pages(xdr, args->layoutupdate_pages, 0,
+					args->layoutupdate_len);
+		}
+	}
 
 	return 0;
 }
fs/nfs/pnfs.c +15 -0
index 13b1406..8c8955e 100644
@@ -1833,6 +1833,7 @@ void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data)
 int
 pnfs_layoutcommit_inode(struct inode *inode, bool sync)
 {
+	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 	struct nfs4_layoutcommit_data *data;
 	struct nfs_inode *nfsi = NFS_I(inode);
 	loff_t end_pos;
@@ -1883,6 +1884,20 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
 	data->args.lastbytewritten = end_pos - 1;
 	data->res.server = NFS_SERVER(inode);
 
+	if (ld->prepare_layoutcommit) {
+		status = ld->prepare_layoutcommit(&data->args);
+		if (status) {
+			spin_lock(&inode->i_lock);
+			if (end_pos < nfsi->layout->plh_lwb)
+				nfsi->layout->plh_lwb = end_pos;
+			spin_unlock(&inode->i_lock);
+			put_rpccred(data->cred);
+			set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags);
+			goto clear_layoutcommitting;
+		}
+	}
+
+
 	status = nfs4_proc_layoutcommit(data, sync);
 out:
 	if (status)
fs/nfs/pnfs.h +2 -2
index cab5259..603f460 100644
@@ -131,8 +131,8 @@ struct pnfs_layoutdriver_type {
 				     const struct nfs4_layoutreturn_args *args);
 
 	void (*cleanup_layoutcommit) (struct nfs4_layoutcommit_data *data);
-
-	void (*encode_layoutcommit) (struct pnfs_layout_hdr *layoutid,
+	int (*prepare_layoutcommit) (struct nfs4_layoutcommit_args *args);
+	void (*encode_layoutcommit) (struct pnfs_layout_hdr *lo,
 				     struct xdr_stream *xdr,
 				     const struct nfs4_layoutcommit_args *args);
 };
include/linux/nfs_xdr.h +3 -0
index 8a57de3..7d8c3d4 100644
@@ -279,6 +279,9 @@ struct nfs4_layoutcommit_args {
 	__u64 lastbytewritten;
 	struct inode *inode;
 	const u32 *bitmask;
+	size_t layoutupdate_len;
+	struct page *layoutupdate_page;
+	struct page **layoutupdate_pages;
 };
 
 struct nfs4_layoutcommit_res {
Signature · 1 line
1.9.1
#8 lore raw

PATCH 8/17 pnfs/blocklayout: reject pnfs blocksize larger than page size

In reply to Christoph Hellwig

The Linux VM subsystem can't support block sizes larger than page size for block based filesystems very well. While this can be hacked around to some extent for simple filesystems the read-modify-write cycles required for pnfs block invalid extents are extremly deadlock prone when operating on multiple pages. Reject this case early on instead of pretending to support it (badly).

---
 fs/nfs/blocklayout/blocklayout.c | 6 ++++++
 1 file changed, 6 insertions(+)
fs/nfs/blocklayout/blocklayout.c +6 -0
index cbb1797..6c1a421 100644
@@ -1115,6 +1115,12 @@ bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)
 		dprintk("%s Server did not return blksize\n", __func__);
 		return -EINVAL;
 	}
+	if (server->pnfs_blksize > PAGE_SIZE) {
+		printk(KERN_ERR "%s: pNFS blksize %d not supported.\n",
+			__func__, server->pnfs_blksize);
+		return -EINVAL;
+	}
+
 	b_mt_id = kzalloc(sizeof(struct block_mount_id), GFP_NOFS);
 	if (!b_mt_id) {
 		status = -ENOMEM;
Signature · 1 line
1.9.1
#9 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 7 lines · Christoph Hellwig

The Linux VM subsystem can't support block sizes larger than page size for block based filesystems very well. While this can be hacked around to some extent for simple filesystems the read-modify-write cycles required for pnfs block invalid extents are extremly deadlock prone when operating on multiple pages. Reject this case early on instead of pretending to support it (badly).

So this kills EMC server support. Can you please share what kind of badly deadlock you saw with large block size support?

Thanks,
Tao

Quoted 29 lines
---
 fs/nfs/blocklayout/blocklayout.c | 6 ++++++
 1 file changed, 6 insertions(+)
fs/nfs/blocklayout/blocklayout.c +6 -1
index cbb1797..6c1a421 100644
@@ -1115,6 +1115,12 @@ bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)
                dprintk("%s Server did not return blksize\n", __func__);
                return -EINVAL;
        }
+       if (server->pnfs_blksize > PAGE_SIZE) {
+               printk(KERN_ERR "%s: pNFS blksize %d not supported.\n",
+                       __func__, server->pnfs_blksize);
+               return -EINVAL;
+       }
+
        b_mt_id = kzalloc(sizeof(struct block_mount_id), GFP_NOFS);
        if (!b_mt_id) {
                status = -ENOMEM;
--

1.9.1

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#10 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 1 line · Peng Tao

So this kills EMC server support.

Given the state the code claiming support for any server is a large exaggeration..

Quoted 2 lines

Can you please share what kind of
badly deadlock you saw with large block size support?

The read-modify write code (which I'll remove later) can lock arbitary numbers of additional pages from the writeback back code without doing a trylock, which is required for doing this in page writeback. Note that it's not a deadlock, but I can also trivіally corrupt data in those pages as it doesn't lock against them, you just need a race window where it's modified after writeback has been started for a large extents, which isn't too hard to hit with tools like fsstress.

#11 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 9 lines · Christoph Hellwig
Quoted 1 line · Peng Tao

So this kills EMC server support.

Given the state the code claiming support for any server is a large exaggeration..

Quoted 2 lines

Can you please share what kind of
badly deadlock you saw with large block size support?

Quoted 8 lines

The read-modify write code (which I'll remove later) can lock arbitary numbers of additional pages from the writeback back code without doing a trylock, which is required for doing this in page writeback. Note that it's not a deadlock, but I can also trivіally corrupt data in those pages as it doesn't lock against them, you just need a race window where it's modified after writeback has been started for a large extents, which isn't too hard to hit with tools like fsstress.

Is it bl_find_get_zeroing_page() you are concerning about? I was hoping page flags can tell if some other threads are flushing the same page. And the extra page is always locked before readin or zeroed, after which the page is marked uptodate before unlocking. So the problem is that a page that is being written back gets modified by a new writer, is it correct? How about marking it writeback before unlocking in bl_find_get_zeroing_page()? That should keep new writers from modifying it concurrently.

#12 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 1 line · Peng Tao

Is it bl_find_get_zeroing_page() you are concerning about?

That's the primary culprit.

If you want to do the read-modify write cycle properly you'll have to do it at the time the invalid extent is read, not written. Take a look at my patch to add a flag to do that in page 5, although it would be a lot more involved to do it for large pnfs block sizes. Given that the code never really fully worked beforehand I'm not tempted to come up with that myself, though.

#13 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 12 lines · Christoph Hellwig
Quoted 1 line · Peng Tao

Is it bl_find_get_zeroing_page() you are concerning about?

That's the primary culprit.

If you want to do the read-modify write cycle properly you'll have to do it at the time the invalid extent is read, not written. Take a look at my patch to add a flag to do that in page 5, although it would be a lot more involved to do it for large pnfs block sizes. Given that the code never really fully worked beforehand I'm not tempted to come up with that myself, though.

we can't assume all pages written back have their pari pages (for 8K block size e.g.) read in read_pagelists(). A page can also be read in via MDS read. So what we need is a hook into nfs_readpage to read or zero additional pages. But we might not even have a layout there.

#14 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 4 lines · Peng Tao

we can't assume all pages written back have their pari pages (for 8K block size e.g.) read in read_pagelists(). A page can also be read in via MDS read. So what we need is a hook into nfs_readpage to read or zero additional pages. But we might not even have a layout there.

We can't assume the page is there for writeback either, what all this mess exists for. That's why we really shouldn't even attempt to support a a block size large than the page size, and that's also why the local Linux filesystems strictly refuse to support it. If you want to hack around it you will run into problems in either case.

I also don't really see why a server would insist on this large block size, there really isn't any major benefit in doing that today (aka the last 20 years) now that we have extent based filesystems.

#15 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 8 lines · Christoph Hellwig
Quoted 4 lines · Peng Tao

we can't assume all pages written back have their pari pages (for 8K block size e.g.) read in read_pagelists(). A page can also be read in via MDS read. So what we need is a hook into nfs_readpage to read or zero additional pages. But we might not even have a layout there.

We can't assume the page is there for writeback either, what all this mess exists for.

In write_pagelist, we can find or create the pair page. It is indeed cow extent that makes things complicated by requiring to read from disk. If we drop cow support (which is required by rfc but I don't know of any server that supports it), we can just zero the extra pages and mark them uptodate. No extra read in or writeback required. That is doable IMHO.

Quoted 8 lines

That's why we really shouldn't even attempt to support
a a block size large than the page size, and that's also why the local Linux filesystems strictly refuse to support it. If you want to hack around it you will run into problems in either case.

I also don't really see why a server would insist on this large block size, there really isn't any major benefit in doing that today (aka the last 20 years) now that we have extent based filesystems.

#16 lore raw

RE: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

In reply to Peng Tao

V2h5IGRvbid0IHlvdSBzZW5kIGEgcGF0Y2g/DQoNCi0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0t DQpGcm9tOiBQZW5nIFRhbyBbbWFpbHRvOmJlcmd3b2xmQGdtYWlsLmNvbV0gDQpTZW50OiBUaHVy c2RheSwgQXVndXN0IDA3LCAyMDE0IDc6NTIgQU0NClRvOiBDaHJpc3RvcGggSGVsbHdpZw0KQ2M6 IFRyb25kIE15a2xlYnVzdDsgbGludXhuZnM7IGZhaWJpc2gsIHNvcmluDQpTdWJqZWN0OiBSZTog W1BBVENIIDA4LzE3XSBwbmZzL2Jsb2NrbGF5b3V0OiByZWplY3QgcG5mcyBibG9ja3NpemUgbGFy Z2VyIHRoYW4gcGFnZSBzaXplDQoNCk9uIFRodSwgQXVnIDcsIDIwMTQgYXQgNzoyNSBQTSwgQ2hy aXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+IHdyb3RlOg0KPiBPbiBUaHUsIEF1ZyAwNywgMjAx NCBhdCAwNjo0MzoxNFBNICswODAwLCBQZW5nIFRhbyB3cm90ZToNCj4+IFNvIHRoaXMga2lsbHMg RU1DIHNlcnZlciBzdXBwb3J0Lg0KPg0KPiBHaXZlbiB0aGUgc3RhdGUgdGhlIGNvZGUgIGNsYWlt aW5nIHN1cHBvcnQgZm9yIGFueSBzZXJ2ZXIgaXMgYSBsYXJnZSANCj4gZXhhZ2dlcmF0aW9uLi4N Cj4NCj4+IENhbiB5b3UgcGxlYXNlIHNoYXJlIHdoYXQga2luZCBvZg0KPj4gYmFkbHkgZGVhZGxv Y2sgeW91IHNhdyB3aXRoIGxhcmdlIGJsb2NrIHNpemUgc3VwcG9ydD8NCj4NCj4gVGhlIHJlYWQt bW9kaWZ5IHdyaXRlIGNvZGUgKHdoaWNoIEknbGwgcmVtb3ZlIGxhdGVyKSBjYW4gbG9jayBhcmJp dGFyeSANCj4gbnVtYmVycyBvZiBhZGRpdGlvbmFsIHBhZ2VzIGZyb20gdGhlIHdyaXRlYmFjayBi YWNrIGNvZGUgd2l0aG91dCBkb2luZyANCj4gYSB0cnlsb2NrLCB3aGljaCBpcyByZXF1aXJlZCBm b3IgZG9pbmcgdGhpcyBpbiBwYWdlIHdyaXRlYmFjay4gIE5vdGUgDQo+IHRoYXQgaXQncyBub3Qg YSBkZWFkbG9jaywgYnV0IEkgY2FuIGFsc28gdHJpdtGWYWxseSBjb3JydXB0IGRhdGEgaW4gDQo+ IHRob3NlIHBhZ2VzIGFzIGl0IGRvZXNuJ3QgbG9jayBhZ2FpbnN0IHRoZW0sIHlvdSBqdXN0IG5l ZWQgYSByYWNlIA0KPiB3aW5kb3cgd2hlcmUgaXQncyBtb2RpZmllZCBhZnRlciB3cml0ZWJhY2sg aGFzIGJlZW4gc3RhcnRlZCBmb3IgYSANCj4gbGFyZ2UgZXh0ZW50cywgd2hpY2ggaXNuJ3QgdG9v IGhhcmQgdG8gaGl0IHdpdGggdG9vbHMgbGlrZSBmc3N0cmVzcy4NCj4NCklzIGl0IGJsX2ZpbmRf Z2V0X3plcm9pbmdfcGFnZSgpIHlvdSBhcmUgY29uY2VybmluZyBhYm91dD8gSSB3YXMgaG9waW5n IHBhZ2UgZmxhZ3MgY2FuIHRlbGwgaWYgc29tZSBvdGhlciB0aHJlYWRzIGFyZSBmbHVzaGluZyB0 aGUgc2FtZSBwYWdlLiBBbmQgdGhlIGV4dHJhIHBhZ2UgaXMgYWx3YXlzIGxvY2tlZCBiZWZvcmUg cmVhZGluIG9yIHplcm9lZCwgYWZ0ZXIgd2hpY2ggdGhlIHBhZ2UgaXMgbWFya2VkIHVwdG9kYXRl IGJlZm9yZSB1bmxvY2tpbmcuIFNvIHRoZSBwcm9ibGVtIGlzIHRoYXQgYSBwYWdlIHRoYXQgaXMg YmVpbmcgd3JpdHRlbiBiYWNrIGdldHMgbW9kaWZpZWQgYnkgYSBuZXcgd3JpdGVyLCBpcyBpdCBj b3JyZWN0PyBIb3cgYWJvdXQgbWFya2luZyBpdCB3cml0ZWJhY2sgYmVmb3JlIHVubG9ja2luZyBp biBibF9maW5kX2dldF96ZXJvaW5nX3BhZ2UoKT8gVGhhdCBzaG91bGQga2VlcCBuZXcgd3JpdGVy cyBmcm9tIG1vZGlmeWluZyBpdCBjb25jdXJyZW50bHkuDQo=

#17 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 2 lines · sorin

Why don't you send a patch?

I can't be sure what I proposed is correct and I don't have any server to test against.

Quoted 26 lines

-----Original Message-----
From: Peng Tao [mailto:[email protected]]
Sent: Thursday, August 07, 2014 7:52 AM
To: Christoph Hellwig
Cc: Trond Myklebust; linuxnfs; faibish, sorin
Subject: Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 9 lines · Christoph Hellwig
Quoted 1 line · Peng Tao

So this kills EMC server support.

Given the state the code claiming support for any server is a large exaggeration..

Quoted 2 lines

Can you please share what kind of
badly deadlock you saw with large block size support?

Quoted 8 lines

The read-modify write code (which I'll remove later) can lock arbitary numbers of additional pages from the writeback back code without doing a trylock, which is required for doing this in page writeback. Note that it's not a deadlock, but I can also trivіally corrupt data in those pages as it doesn't lock against them, you just need a race window where it's modified after writeback has been started for a large extents, which isn't too hard to hit with tools like fsstress.

Is it bl_find_get_zeroing_page() you are concerning about? I was hoping page flags can tell if some other threads are flushing the same page. And the extra page is always locked before readin or zeroed, after which the page is marked uptodate before unlocking. So the problem is that a page that is being written back gets modified by a new writer, is it correct? How about marking it writeback before unlocking in bl_find_get_zeroing_page()? That should keep new writers from modifying it concurrently.

#18 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

In reply to faibish, sorin
Quoted 1 line · sorin

Why don't you send a patch?

What patch? Rewriting the broken code that was put in to support a server I don't have access to and that apparently no one cared enough before to fix even the most trivial bugs for?

I can leave the code for it in, but I can neither test nor really support it, and from the state of the code it doesn't seem like anyone else really cares for it.

How will sign up for supporting and testing > PAGE_SIZE servers if we leave that support in? And with support I mean regular runs of basic QA like xfstests or just doing a simple dd if=/dev/zero of=/mnt/nfs/bigfile, which already causes softlocks with the current code.

#19 lore raw

RE: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

What Peng suggested to solve: "marking it writeback before unlocking in bl_find_get_zeroing_page()?"

-----Original Message-----
From: Christoph Hellwig [mailto:[email protected]]
Sent: Thursday, August 07, 2014 12:11 PM
To: faibish, sorin
Cc: Peng Tao; Trond Myklebust; linuxnfs
Subject: Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 1 line · sorin

Why don't you send a patch?

What patch? Rewriting the broken code that was put in to support a server I don't have access to and that apparently no one cared enough before to fix even the most trivial bugs for?

I can leave the code for it in, but I can neither test nor really support it, and from the state of the code it doesn't seem like anyone else really cares for it.

How will sign up for supporting and testing > PAGE_SIZE servers if we leave that support in? And with support I mean regular runs of basic QA like xfstests or just doing a simple dd if=/dev/zero of=/mnt/nfs/bigfile, which already causes softlocks with the current code.

#20 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

In reply to Christoph Hellwig
Quoted 5 lines · Christoph Hellwig
Quoted 1 line · Peng Tao
Quoted 1 line

So this kills EMC server support.

Given the state the code claiming support for any server is a large exaggeration..

But eliminating the potential of supporting block layouts does not sound like a very good idea to me....

There are rumors of other block layouts implementations coming down the pike.... So hopefully we don't eliminating any and all possible support of block layouts in the future...

steved.

#21 lore raw

Re: [PATCH 08/17] pnfs/blocklayout: reject pnfs blocksize larger than page size

Quoted 8 lines · Steve Dickson
Quoted 5 lines · Christoph Hellwig
Quoted 1 line · Peng Tao
Quoted 1 line

So this kills EMC server support.

Given the state the code claiming support for any server is a large exaggeration..

Quoted 7 lines

But eliminating the potential of supporting block layouts does not sound like a very good idea to me....

There are rumors of other block layouts implementations coming down the pike.... So hopefully we don't eliminating any and all possible support of block layouts in the future...

My bad... I see this not the case... I jumped in with out reading the entire thread....

But EMC server support is still not a good idea IMHO...

steved.

#22 lore raw

PATCH 9/17 pnfs/blocklayout: improve GETDEVICEINFO error reporting

In reply to Christoph Hellwig

Tell userspace what stage of GETDEVICEINFO failed so that there is a chance to debug it, especially with the userspace daemon clusterf***k in the block layout driver.

---
 fs/nfs/blocklayout/blocklayoutdev.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/nfs/blocklayout/blocklayoutdev.c +3 -2
index 04303b5..63f77925 100644
@@ -150,7 +150,7 @@ nfs4_blk_decode_device(struct nfs_server *server,
 	remove_wait_queue(&nn->bl_wq, &wq);
 
 	if (reply->status != BL_DEVICE_REQUEST_PROC) {
-		dprintk("%s failed to open device: %d\n",
+		printk(KERN_WARNING "%s failed to decode device: %d\n",
 			__func__, reply->status);
 		rv = ERR_PTR(-EINVAL);
 		goto out;
@@ -159,7 +159,8 @@ nfs4_blk_decode_device(struct nfs_server *server,
 	bd = blkdev_get_by_dev(MKDEV(reply->major, reply->minor),
 			       FMODE_READ, NULL);
 	if (IS_ERR(bd)) {
-		dprintk("%s failed to open device : %ld\n", __func__,
+		printk(KERN_WARNING "%s failed to open device %d:%d (%ld)\n",
+			__func__, reply->major, reply->minor,
 			PTR_ERR(bd));
 		rv = ERR_CAST(bd);
 		goto out;
Signature · 1 line
1.9.1
#23 lore raw

PATCH 10/17 pnfs/blocklayout: plug block queues

In reply to Christoph Hellwig

Make sure the block queue is plugged when performing pNFS blocklayout I/O.

---
 fs/nfs/blocklayout/blocklayout.c | 9 +++++++++
 1 file changed, 9 insertions(+)
fs/nfs/blocklayout/blocklayout.c +9 -0
index 6c1a421..5427ae7 100644
@@ -255,6 +255,7 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 	struct page **pages = hdr->args.pages;
 	int pg_index = hdr->args.pgbase >> PAGE_CACHE_SHIFT;
 	const bool is_dio = (header->dreq != NULL);
+	struct blk_plug plug;
 
 	dprintk("%s enter nr_pages %u offset %lld count %u\n", __func__,
 		hdr->page_array.npages, f_offset,
@@ -266,6 +267,8 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 	par->pnfs_callback = bl_end_par_io_read;
 	/* At this point, we can no longer jump to use_mds */
 
+	blk_start_plug(&plug);
+
 	isect = (sector_t) (f_offset >> SECTOR_SHIFT);
 	/* Code assumes extents are page-aligned */
 	for (i = pg_index; i < hdr->page_array.npages; i++) {
@@ -342,6 +345,7 @@ out:
 	bl_put_extent(be);
 	bl_put_extent(cow_read);
 	bl_submit_bio(READ, bio);
+	blk_finish_plug(&plug);
 	put_parallel(par);
 	return PNFS_ATTEMPTED;
 
@@ -688,9 +692,12 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
 	u64 temp;
 	int npg_per_block =
 	    NFS_SERVER(header->inode)->pnfs_blksize >> PAGE_CACHE_SHIFT;
+	struct blk_plug plug;
 
 	dprintk("%s enter, %Zu@%lld\n", __func__, count, offset);
 
+	blk_start_plug(&plug);
+
 	if (header->dreq != NULL &&
 	    (!IS_ALIGNED(offset, NFS_SERVER(header->inode)->pnfs_blksize) ||
 	     !IS_ALIGNED(count, NFS_SERVER(header->inode)->pnfs_blksize))) {
@@ -894,9 +901,11 @@ out:
 	bl_put_extent(be);
 	bl_put_extent(cow_read);
 	bl_submit_bio(WRITE, bio);
+	blk_finish_plug(&plug);
 	put_parallel(par);
 	return PNFS_ATTEMPTED;
 out_mds:
+	blk_finish_plug(&plug);
 	bl_put_extent(be);
 	bl_put_extent(cow_read);
 	kfree(par);
Signature · 1 line
1.9.1
#24 lore raw

PATCH 11/17 pnfs/blocklayout: correctly decrement extent length

In reply to Christoph Hellwig

When we do non-page sized reads we can underflow the extent_length variable and read incorrect data. Fix the extent_length calculation and change to defensive <= checks for the extent length in the read and write path.

---
 fs/nfs/blocklayout/blocklayout.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)
fs/nfs/blocklayout/blocklayout.c +4 -3
index 5427ae7..87a633d 100644
@@ -272,7 +272,7 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 	isect = (sector_t) (f_offset >> SECTOR_SHIFT);
 	/* Code assumes extents are page-aligned */
 	for (i = pg_index; i < hdr->page_array.npages; i++) {
-		if (!extent_length) {
+		if (extent_length <= 0) {
 			/* We've used up the previous extent */
 			bl_put_extent(be);
 			bl_put_extent(cow_read);
@@ -303,6 +303,7 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 			f_offset += pg_len;
 			bytes_left -= pg_len;
 			isect += (pg_offset >> SECTOR_SHIFT);
+			extent_length -= (pg_offset >> SECTOR_SHIFT);
 		} else {
 			pg_offset = 0;
 			pg_len = PAGE_CACHE_SIZE;
@@ -333,7 +334,7 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 			}
 		}
 		isect += (pg_len >> SECTOR_SHIFT);
-		extent_length -= PAGE_CACHE_SECTORS;
+		extent_length -= (pg_len >> SECTOR_SHIFT);
 	}
 	if ((isect << SECTOR_SHIFT) >= header->inode->i_size) {
 		hdr->res.eof = 1;
@@ -797,7 +798,7 @@ next_page:
 	/* Middle pages */
 	pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
 	for (i = pg_index; i < header->page_array.npages; i++) {
-		if (!extent_length) {
+		if (extent_length <= 0) {
 			/* We've used up the previous extent */
 			bl_put_extent(be);
 			bl_put_extent(cow_read);
Signature · 1 line
1.9.1
#25 lore raw

PATCH 12/17 pnfs/blocklayout: remove read-modify-write handling in bl_write_pagelist

In reply to Christoph Hellwig

Use the new PNFS_READ_WHOLE_PAGE flag to offload read-modify-write handling to core nfs code, and remove a huge chunk of deadlock prone mess from the block layout writeback path.

---
 fs/nfs/blocklayout/blocklayout.c | 500 +++++----------------------------------
 1 file changed, 64 insertions(+), 436 deletions(-)
fs/nfs/blocklayout/blocklayout.c +64 -436
index 87a633d..6484b9f 100644
@@ -35,7 +35,6 @@
 #include <linux/mount.h>
 #include <linux/namei.h>
 #include <linux/bio.h>		/* struct bio */
-#include <linux/buffer_head.h>	/* various write calls */
 #include <linux/prefetch.h>
 #include <linux/pagevec.h>
 
@@ -188,16 +187,6 @@ retry:
 	return bio;
 }
 
-static struct bio *bl_add_page_to_bio(struct bio *bio, int npg, int rw,
-				      sector_t isect, struct page *page,
-				      struct pnfs_block_extent *be,
-				      void (*end_io)(struct bio *, int err),
-				      struct parallel_io *par)
-{
-	return do_add_page_to_bio(bio, npg, rw, isect, page, be,
-				  end_io, par, 0, PAGE_CACHE_SIZE);
-}
-
 /* This is basically copied from mpage_end_io_read */
 static void bl_end_io_read(struct bio *bio, int err)
 {
@@ -293,8 +282,8 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 			}
 		}
 
+		pg_offset = f_offset & ~PAGE_CACHE_MASK;
 		if (is_dio) {
-			pg_offset = f_offset & ~PAGE_CACHE_MASK;
 			if (pg_offset + bytes_left > PAGE_CACHE_SIZE)
 				pg_len = PAGE_CACHE_SIZE - pg_offset;
 			else
@@ -305,7 +294,7 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 			isect += (pg_offset >> SECTOR_SHIFT);
 			extent_length -= (pg_offset >> SECTOR_SHIFT);
 		} else {
-			pg_offset = 0;
+			BUG_ON(pg_offset != 0);
 			pg_len = PAGE_CACHE_SIZE;
 		}
 
@@ -383,29 +372,6 @@ static void mark_extents_written(struct pnfs_block_layout *bl,
 	}
 }
 
-static void bl_end_io_write_zero(struct bio *bio, int err)
-{
-	struct parallel_io *par = bio->bi_private;
-	struct bio_vec *bvec;
-	int i;
-
-	bio_for_each_segment_all(bvec, bio, i) {
-		/* This is the zeroing page we added */
-		end_page_writeback(bvec->bv_page);
-		page_cache_release(bvec->bv_page);
-	}
-
-	if (unlikely(err)) {
-		struct nfs_pgio_header *header = par->data;
-
-		if (!header->pnfs_error)
-			header->pnfs_error = -EIO;
-		pnfs_set_lo_fail(header->lseg);
-	}
-	bio_put(bio);
-	put_parallel(par);
-}
-
 static void bl_end_io_write(struct bio *bio, int err)
 {
 	struct parallel_io *par = bio->bi_private;
@@ -455,256 +421,22 @@ static void bl_end_par_io_write(void *data, int num_se)
 	schedule_work(&hdr->task.u.tk_work);
 }
 
-/* FIXME STUB - mark intersection of layout and page as bad, so is not
- * used again.
- */
-static void mark_bad_read(void)
-{
-	return;
-}
-
-/*
- * map_block:  map a requested I/0 block (isect) into an offset in the LVM
- * block_device
- */
-static void
-map_block(struct buffer_head *bh, sector_t isect, struct pnfs_block_extent *be)
-{
-	dprintk("%s enter be=%p\n", __func__, be);
-
-	set_buffer_mapped(bh);
-	bh->b_bdev = be->be_mdev;
-	bh->b_blocknr = (isect - be->be_f_offset + be->be_v_offset) >>
-	    (be->be_mdev->bd_inode->i_blkbits - SECTOR_SHIFT);
-
-	dprintk("%s isect %llu, bh->b_blocknr %ld, using bsize %Zd\n",
-		__func__, (unsigned long long)isect, (long)bh->b_blocknr,
-		bh->b_size);
-	return;
-}
-
-static void
-bl_read_single_end_io(struct bio *bio, int error)
-{
-	struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
-	struct page *page = bvec->bv_page;
-
-	/* Only one page in bvec */
-	unlock_page(page);
-}
-
-static int
-bl_do_readpage_sync(struct page *page, struct pnfs_block_extent *be,
-		    unsigned int offset, unsigned int len)
-{
-	struct bio *bio;
-	struct page *shadow_page;
-	sector_t isect;
-	char *kaddr, *kshadow_addr;
-	int ret = 0;
-
-	dprintk("%s: offset %u len %u\n", __func__, offset, len);
-
-	shadow_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
-	if (shadow_page == NULL)
-		return -ENOMEM;
-
-	bio = bio_alloc(GFP_NOIO, 1);
-	if (bio == NULL)
-		return -ENOMEM;
-
-	isect = (page->index << PAGE_CACHE_SECTOR_SHIFT) +
-		(offset / SECTOR_SIZE);
-
-	bio->bi_iter.bi_sector = isect - be->be_f_offset + be->be_v_offset;
-	bio->bi_bdev = be->be_mdev;
-	bio->bi_end_io = bl_read_single_end_io;
-
-	lock_page(shadow_page);
-	if (bio_add_page(bio, shadow_page,
-			 SECTOR_SIZE, round_down(offset, SECTOR_SIZE)) == 0) {
-		unlock_page(shadow_page);
-		bio_put(bio);
-		return -EIO;
-	}
-
-	submit_bio(READ, bio);
-	wait_on_page_locked(shadow_page);
-	if (unlikely(!test_bit(BIO_UPTODATE, &bio->bi_flags))) {
-		ret = -EIO;
-	} else {
-		kaddr = kmap_atomic(page);
-		kshadow_addr = kmap_atomic(shadow_page);
-		memcpy(kaddr + offset, kshadow_addr + offset, len);
-		kunmap_atomic(kshadow_addr);
-		kunmap_atomic(kaddr);
-	}
-	__free_page(shadow_page);
-	bio_put(bio);
-
-	return ret;
-}
-
-static int
-bl_read_partial_page_sync(struct page *page, struct pnfs_block_extent *be,
-			  unsigned int dirty_offset, unsigned int dirty_len,
-			  bool full_page)
-{
-	int ret = 0;
-	unsigned int start, end;
-
-	if (full_page) {
-		start = 0;
-		end = PAGE_CACHE_SIZE;
-	} else {
-		start = round_down(dirty_offset, SECTOR_SIZE);
-		end = round_up(dirty_offset + dirty_len, SECTOR_SIZE);
-	}
-
-	dprintk("%s: offset %u len %d\n", __func__, dirty_offset, dirty_len);
-	if (!be) {
-		zero_user_segments(page, start, dirty_offset,
-				   dirty_offset + dirty_len, end);
-		if (start == 0 && end == PAGE_CACHE_SIZE &&
-		    trylock_page(page)) {
-			SetPageUptodate(page);
-			unlock_page(page);
-		}
-		return ret;
-	}
-
-	if (start != dirty_offset)
-		ret = bl_do_readpage_sync(page, be, start, dirty_offset - start);
-
-	if (!ret && (dirty_offset + dirty_len < end))
-		ret = bl_do_readpage_sync(page, be, dirty_offset + dirty_len,
-					  end - dirty_offset - dirty_len);
-
-	return ret;
-}
-
-/* Given an unmapped page, zero it or read in page for COW, page is locked
- * by caller.
- */
-static int
-init_page_for_write(struct page *page, struct pnfs_block_extent *cow_read)
-{
-	struct buffer_head *bh = NULL;
-	int ret = 0;
-	sector_t isect;
-
-	dprintk("%s enter, %p\n", __func__, page);
-	BUG_ON(PageUptodate(page));
-	if (!cow_read) {
-		zero_user_segment(page, 0, PAGE_SIZE);
-		SetPageUptodate(page);
-		goto cleanup;
-	}
-
-	bh = alloc_page_buffers(page, PAGE_CACHE_SIZE, 0);
-	if (!bh) {
-		ret = -ENOMEM;
-		goto cleanup;
-	}
-
-	isect = (sector_t) page->index << PAGE_CACHE_SECTOR_SHIFT;
-	map_block(bh, isect, cow_read);
-	if (!bh_uptodate_or_lock(bh))
-		ret = bh_submit_read(bh);
-	if (ret)
-		goto cleanup;
-	SetPageUptodate(page);
-
-cleanup:
-	if (bh)
-		free_buffer_head(bh);
-	if (ret) {
-		/* Need to mark layout with bad read...should now
-		 * just use nfs4 for reads and writes.
-		 */
-		mark_bad_read();
-	}
-	return ret;
-}
-
-/* Find or create a zeroing page marked being writeback.
- * Return ERR_PTR on error, NULL to indicate skip this page and page itself
- * to indicate write out.
- */
-static struct page *
-bl_find_get_zeroing_page(struct inode *inode, pgoff_t index,
-			struct pnfs_block_extent *cow_read)
-{
-	struct page *page;
-	int locked = 0;
-	page = find_get_page(inode->i_mapping, index);
-	if (page)
-		goto check_page;
-
-	page = find_or_create_page(inode->i_mapping, index, GFP_NOFS);
-	if (unlikely(!page)) {
-		dprintk("%s oom\n", __func__);
-		return ERR_PTR(-ENOMEM);
-	}
-	locked = 1;
-
-check_page:
-	/* PageDirty: Other will write this out
-	 * PageWriteback: Other is writing this out
-	 * PageUptodate: It was read before
-	 */
-	if (PageDirty(page) || PageWriteback(page)) {
-		print_page(page);
-		if (locked)
-			unlock_page(page);
-		page_cache_release(page);
-		return NULL;
-	}
-
-	if (!locked) {
-		lock_page(page);
-		locked = 1;
-		goto check_page;
-	}
-	if (!PageUptodate(page)) {
-		/* New page, readin or zero it */
-		init_page_for_write(page, cow_read);
-	}
-	set_page_writeback(page);
-	unlock_page(page);
-
-	return page;
-}
-
 static enum pnfs_try_status
 bl_write_pagelist(struct nfs_pgio_header *header, int sync)
 {
-	int i, ret, npg_zero, pg_index, last = 0;
+	int i, ret;
 	struct bio *bio = NULL;
-	struct pnfs_block_extent *be = NULL, *cow_read = NULL;
-	sector_t isect, last_isect = 0, extent_length = 0;
+	struct pnfs_block_extent *be = NULL;
+	sector_t isect, extent_length = 0;
 	struct parallel_io *par = NULL;
 	loff_t offset = header->args.offset;
 	size_t count = header->args.count;
-	unsigned int pg_offset, pg_len, saved_len;
 	struct page **pages = header->args.pages;
-	struct page *page;
-	pgoff_t index;
-	u64 temp;
-	int npg_per_block =
-	    NFS_SERVER(header->inode)->pnfs_blksize >> PAGE_CACHE_SHIFT;
+	int pg_index = pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
 	struct blk_plug plug;
 
 	dprintk("%s enter, %Zu@%lld\n", __func__, count, offset);
 
-	blk_start_plug(&plug);
-
-	if (header->dreq != NULL &&
-	    (!IS_ALIGNED(offset, NFS_SERVER(header->inode)->pnfs_blksize) ||
-	     !IS_ALIGNED(count, NFS_SERVER(header->inode)->pnfs_blksize))) {
-		dprintk("pnfsblock nonblock aligned DIO writes. Resend MDS\n");
-		goto out_mds;
-	}
 	/* At this point, header->page_aray is a (sequential) list of nfs_pages.
 	 * We want to write each, and if there is an error set pnfs_error
 	 * to have it redone using nfs.
@@ -715,97 +447,20 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
 	par->pnfs_callback = bl_end_par_io_write;
 	/* At this point, have to be more careful with error handling */
 
-	isect = (sector_t) ((offset & (long)PAGE_CACHE_MASK) >> SECTOR_SHIFT);
-	be = bl_find_get_extent(BLK_LSEG2EXT(header->lseg), isect, &cow_read);
-	if (!be || !is_writable(be, isect)) {
-		dprintk("%s no matching extents!\n", __func__);
-		goto out_mds;
-	}
-
-	/* First page inside INVALID extent */
-	if (be->be_state == PNFS_BLOCK_INVALID_DATA) {
-		if (likely(!bl_push_one_short_extent(be->be_inval)))
-			par->bse_count++;
-		else
-			goto out_mds;
-		temp = offset >> PAGE_CACHE_SHIFT;
-		npg_zero = do_div(temp, npg_per_block);
-		isect = (sector_t) (((offset - npg_zero * PAGE_CACHE_SIZE) &
-				     (long)PAGE_CACHE_MASK) >> SECTOR_SHIFT);
-		extent_length = be->be_length - (isect - be->be_f_offset);
-
-fill_invalid_ext:
-		dprintk("%s need to zero %d pages\n", __func__, npg_zero);
-		for (;npg_zero > 0; npg_zero--) {
-			if (bl_is_sector_init(be->be_inval, isect)) {
-				dprintk("isect %llu already init\n",
-					(unsigned long long)isect);
-				goto next_page;
-			}
-			/* page ref released in bl_end_io_write_zero */
-			index = isect >> PAGE_CACHE_SECTOR_SHIFT;
-			dprintk("%s zero %dth page: index %lu isect %llu\n",
-				__func__, npg_zero, index,
-				(unsigned long long)isect);
-			page = bl_find_get_zeroing_page(header->inode, index,
-							cow_read);
-			if (unlikely(IS_ERR(page))) {
-				header->pnfs_error = PTR_ERR(page);
-				goto out;
-			} else if (page == NULL)
-				goto next_page;
-
-			ret = bl_mark_sectors_init(be->be_inval, isect,
-						       PAGE_CACHE_SECTORS);
-			if (unlikely(ret)) {
-				dprintk("%s bl_mark_sectors_init fail %d\n",
-					__func__, ret);
-				end_page_writeback(page);
-				page_cache_release(page);
-				header->pnfs_error = ret;
-				goto out;
-			}
-			if (likely(!bl_push_one_short_extent(be->be_inval)))
-				par->bse_count++;
-			else {
-				end_page_writeback(page);
-				page_cache_release(page);
-				header->pnfs_error = -ENOMEM;
-				goto out;
-			}
-			/* FIXME: This should be done in bi_end_io */
-			mark_extents_written(BLK_LSEG2EXT(header->lseg),
-					     page->index << PAGE_CACHE_SHIFT,
-					     PAGE_CACHE_SIZE);
-
-			bio = bl_add_page_to_bio(bio, npg_zero, WRITE,
-						 isect, page, be,
-						 bl_end_io_write_zero, par);
-			if (IS_ERR(bio)) {
-				header->pnfs_error = PTR_ERR(bio);
-				bio = NULL;
-				goto out;
-			}
-next_page:
-			isect += PAGE_CACHE_SECTORS;
-			extent_length -= PAGE_CACHE_SECTORS;
-		}
-		if (last)
-			goto write_done;
-	}
-	bio = bl_submit_bio(WRITE, bio);
+	blk_start_plug(&plug);
 
-	/* Middle pages */
-	pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
+	/* we always write out the whole page */
+	offset = offset & (loff_t)PAGE_CACHE_MASK;
+	isect = offset >> SECTOR_SHIFT;
+	
 	for (i = pg_index; i < header->page_array.npages; i++) {
 		if (extent_length <= 0) {
 			/* We've used up the previous extent */
 			bl_put_extent(be);
-			bl_put_extent(cow_read);
 			bio = bl_submit_bio(WRITE, bio);
 			/* Get the next one */
 			be = bl_find_get_extent(BLK_LSEG2EXT(header->lseg),
-					     isect, &cow_read);
+					     isect, NULL);
 			if (!be || !is_writable(be, isect)) {
 				header->pnfs_error = -EINVAL;
 				goto out;
@@ -823,25 +478,10 @@ next_page:
 			    (isect - be->be_f_offset);
 		}
 
-		dprintk("%s offset %lld count %Zu\n", __func__, offset, count);
-		pg_offset = offset & ~PAGE_CACHE_MASK;
-		if (pg_offset + count > PAGE_CACHE_SIZE)
-			pg_len = PAGE_CACHE_SIZE - pg_offset;
-		else
-			pg_len = count;
+		BUG_ON(offset & ~PAGE_CACHE_MASK);
 
-		saved_len = pg_len;
 		if (be->be_state == PNFS_BLOCK_INVALID_DATA &&
 		    !bl_is_sector_init(be->be_inval, isect)) {
-			ret = bl_read_partial_page_sync(pages[i], cow_read,
-							pg_offset, pg_len, true);
-			if (ret) {
-				dprintk("%s bl_read_partial_page_sync fail %d\n",
-					__func__, ret);
-				header->pnfs_error = ret;
-				goto out;
-			}
-
 			ret = bl_mark_sectors_init(be->be_inval, isect,
 						       PAGE_CACHE_SECTORS);
 			if (unlikely(ret)) {
@@ -850,66 +490,31 @@ next_page:
 				header->pnfs_error = ret;
 				goto out;
 			}
-
-			/* Expand to full page write */
-			pg_offset = 0;
-			pg_len = PAGE_CACHE_SIZE;
-		} else if  ((pg_offset & (SECTOR_SIZE - 1)) ||
-			    (pg_len & (SECTOR_SIZE - 1))){
-			/* ahh, nasty case. We have to do sync full sector
-			 * read-modify-write cycles.
-			 */
-			unsigned int saved_offset = pg_offset;
-			ret = bl_read_partial_page_sync(pages[i], be, pg_offset,
-							pg_len, false);
-			pg_offset = round_down(pg_offset, SECTOR_SIZE);
-			pg_len = round_up(saved_offset + pg_len, SECTOR_SIZE)
-				 - pg_offset;
 		}
 
-
 		bio = do_add_page_to_bio(bio, header->page_array.npages - i,
-					 WRITE,
-					 isect, pages[i], be,
+					 WRITE, isect, pages[i], be,
 					 bl_end_io_write, par,
-					 pg_offset, pg_len);
+					 0, PAGE_CACHE_SIZE);
 		if (IS_ERR(bio)) {
 			header->pnfs_error = PTR_ERR(bio);
 			bio = NULL;
 			goto out;
 		}
-		offset += saved_len;
-		count -= saved_len;
+		offset += PAGE_CACHE_SIZE;
+		count -= PAGE_CACHE_SIZE;
 		isect += PAGE_CACHE_SECTORS;
-		last_isect = isect;
 		extent_length -= PAGE_CACHE_SECTORS;
 	}
 
-	/* Last page inside INVALID extent */
-	if (be->be_state == PNFS_BLOCK_INVALID_DATA) {
-		bio = bl_submit_bio(WRITE, bio);
-		temp = last_isect >> PAGE_CACHE_SECTOR_SHIFT;
-		npg_zero = npg_per_block - do_div(temp, npg_per_block);
-		if (npg_zero < npg_per_block) {
-			last = 1;
-			goto fill_invalid_ext;
-		}
-	}
-
-write_done:
 	header->res.count = header->args.count;
 out:
 	bl_put_extent(be);
-	bl_put_extent(cow_read);
 	bl_submit_bio(WRITE, bio);
 	blk_finish_plug(&plug);
 	put_parallel(par);
 	return PNFS_ATTEMPTED;
 out_mds:
-	blk_finish_plug(&plug);
-	bl_put_extent(be);
-	bl_put_extent(cow_read);
-	kfree(par);
 	return PNFS_NOT_ATTEMPTED;
 }
 
@@ -1188,20 +793,45 @@ bl_clear_layoutdriver(struct nfs_server *server)
 }
 
 static bool
-is_aligned_req(struct nfs_page *req, unsigned int alignment)
+is_aligned_req(struct nfs_pageio_descriptor *pgio,
+		struct nfs_page *req, unsigned int alignment)
 {
-	return IS_ALIGNED(req->wb_offset, alignment) &&
-	       IS_ALIGNED(req->wb_bytes, alignment);
+	/*
+	 * Always accept buffered writes, higher layers take care of the
+	 * right alignment.
+	 */
+	if (pgio->pg_dreq == NULL)
+		return true;
+
+	if (!IS_ALIGNED(req->wb_offset, alignment))
+		return false;
+
+	if (IS_ALIGNED(req->wb_bytes, alignment))
+		return true;
+
+	if (req_offset(req) + req->wb_bytes == i_size_read(pgio->pg_inode)) {
+		/*
+		 * If the write goes up to the inode size, just write
+		 * the full page.  Data past the inode size is
+		 * guaranteed to be zeroed by the higher level client
+		 * code, and this behaviour is mandated by RFC 5663
+		 * section 2.3.2.
+		 */
+		return true;
+	}
+
+	return false;
 }
 
 static void
 bl_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
 {
-	if (pgio->pg_dreq != NULL &&
-	    !is_aligned_req(req, SECTOR_SIZE))
+	if (!is_aligned_req(pgio, req, SECTOR_SIZE)) {
 		nfs_pageio_reset_read_mds(pgio);
-	else
-		pnfs_generic_pg_init_read(pgio, req);
+		return;
+	}
+
+	pnfs_generic_pg_init_read(pgio, req);
 }
 
 /*
@@ -1212,10 +842,8 @@ static size_t
 bl_pg_test_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
 		struct nfs_page *req)
 {
-	if (pgio->pg_dreq != NULL &&
-	    !is_aligned_req(req, SECTOR_SIZE))
+	if (!is_aligned_req(pgio, req, SECTOR_SIZE))
 		return 0;
-
 	return pnfs_generic_pg_test(pgio, prev, req);
 }
 
@@ -1245,19 +873,20 @@ static u64 pnfs_num_cont_bytes(struct inode *inode, pgoff_t idx)
 static void
 bl_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
 {
-	if (pgio->pg_dreq != NULL &&
-	    !is_aligned_req(req, PAGE_CACHE_SIZE)) {
+	u64 wb_size;
+
+	if (!is_aligned_req(pgio, req, PAGE_SIZE)) {
 		nfs_pageio_reset_write_mds(pgio);
-	} else {
-		u64 wb_size;
-		if (pgio->pg_dreq == NULL)
-			wb_size = pnfs_num_cont_bytes(pgio->pg_inode,
-						      req->wb_index);
-		else
-			wb_size = nfs_dreq_bytes_left(pgio->pg_dreq);
-
-		pnfs_generic_pg_init_write(pgio, req, wb_size);
+		return;
 	}
+
+	if (pgio->pg_dreq == NULL)
+		wb_size = pnfs_num_cont_bytes(pgio->pg_inode,
+					      req->wb_index);
+	else
+		wb_size = nfs_dreq_bytes_left(pgio->pg_dreq);
+
+	pnfs_generic_pg_init_write(pgio, req, wb_size);
 }
 
 /*
@@ -1268,10 +897,8 @@ static size_t
 bl_pg_test_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
 		 struct nfs_page *req)
 {
-	if (pgio->pg_dreq != NULL &&
-	    !is_aligned_req(req, PAGE_CACHE_SIZE))
+	if (!is_aligned_req(pgio, req, PAGE_SIZE))
 		return 0;
-
 	return pnfs_generic_pg_test(pgio, prev, req);
 }
 
@@ -1291,6 +918,7 @@ static struct pnfs_layoutdriver_type blocklayout_type = {
 	.id				= LAYOUT_BLOCK_VOLUME,
 	.name				= "LAYOUT_BLOCK_VOLUME",
 	.owner				= THIS_MODULE,
+	.flags				= PNFS_READ_WHOLE_PAGE,
 	.read_pagelist			= bl_read_pagelist,
 	.write_pagelist			= bl_write_pagelist,
 	.alloc_layout_hdr		= bl_alloc_layout_hdr,
Signature · 1 line
1.9.1
#26 lore raw

PATCH 13/17 pnfs/blocklayout: don't set pages uptodate

In reply to Christoph Hellwig

The core nfs code handles setting pages uptodate on reads, no need to mess with the pageflags outselves. Also remove a debug function to dump page flags.

---
 fs/nfs/blocklayout/blocklayout.c | 24 +-----------------------
 1 file changed, 1 insertion(+), 23 deletions(-)
fs/nfs/blocklayout/blocklayout.c +1 -23
index 6484b9f..92be984 100644
@@ -49,20 +49,6 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Andy Adamson <[email protected]>");
 MODULE_DESCRIPTION("The NFSv4.1 pNFS Block layout driver");
 
-static void print_page(struct page *page)
-{
-	dprintk("PRINTPAGE page %p\n", page);
-	dprintk("	PagePrivate %d\n", PagePrivate(page));
-	dprintk("	PageUptodate %d\n", PageUptodate(page));
-	dprintk("	PageError %d\n", PageError(page));
-	dprintk("	PageDirty %d\n", PageDirty(page));
-	dprintk("	PageReferenced %d\n", PageReferenced(page));
-	dprintk("	PageLocked %d\n", PageLocked(page));
-	dprintk("	PageWriteback %d\n", PageWriteback(page));
-	dprintk("	PageMappedToDisk %d\n", PageMappedToDisk(page));
-	dprintk("\n");
-}
-
 /* Given the be associated with isect, determine if page data needs to be
  * initialized.
  */
@@ -187,16 +173,9 @@ retry:
 	return bio;
 }
 
-/* This is basically copied from mpage_end_io_read */
 static void bl_end_io_read(struct bio *bio, int err)
 {
 	struct parallel_io *par = bio->bi_private;
-	struct bio_vec *bvec;
-	int i;
-
-	if (!err)
-		bio_for_each_segment_all(bvec, bio, i)
-			SetPageUptodate(bvec->bv_page);
 
 	if (err) {
 		struct nfs_pgio_header *header = par->data;
@@ -205,6 +184,7 @@ static void bl_end_io_read(struct bio *bio, int err)
 			header->pnfs_error = -EIO;
 		pnfs_set_lo_fail(header->lseg);
 	}
+
 	bio_put(bio);
 	put_parallel(par);
 }
@@ -304,8 +284,6 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
 			/* Fill hole w/ zeroes w/o accessing device */
 			dprintk("%s Zeroing page for hole\n", __func__);
 			zero_user_segment(pages[i], pg_offset, pg_len);
-			print_page(pages[i]);
-			SetPageUptodate(pages[i]);
 		} else {
 			struct pnfs_block_extent *be_read;
 
Signature · 1 line
1.9.1
#27 lore raw

PATCH 14/17 pnfs/blocklayout: rewrite extent tracking

In reply to Christoph Hellwig

Currently the block layout driver tracks extents in three separate data structures:

- the two list of pnfs_block_extent structures returned by the server
- the list of sectors that were in invalid state but have been written to
- a list of pnfs_block_short_extent structures for LAYOUTCOMMIT

All of these share the property that they are not only highly inefficient data structures, but also that operations on them are even more inefficient than nessecary.

In addition there are various implementation defects like:

- using an int to track sectors, causing corruption for large offsets
- incorrect normalization of page or block granularity ranges
- insufficient error handling
- incorrect synchronization as extents can be modified while they are in use

This patch replace all three data with a single unified rbtree structure tracking all extents, as well as their in-memory state, although we still need to instance for read-only and read-write extent due to the arcane client side COW feature in the block layouts spec.

To fix the problem of extent possibly being modified while in use we make sure to return a copy of the extent for use in the write path - the extent can only be invalidated by a layout recall or return which has to wait until the I/O operations finished due to refcounts on the layout segment.

The new extent tree work similar to the schemes used by block based filesystems like XFS or ext4.

---
 fs/nfs/blocklayout/Makefile         |   3 +-
 fs/nfs/blocklayout/blocklayout.c    | 258 +++-------
 fs/nfs/blocklayout/blocklayout.h    | 112 +----
 fs/nfs/blocklayout/blocklayoutdev.c |  35 +-
 fs/nfs/blocklayout/extent_tree.c    | 545 ++++++++++++++++++++++
 fs/nfs/blocklayout/extents.c        | 908 ------------------------------------
 6 files changed, 649 insertions(+), 1212 deletions(-)
 create mode 100644 fs/nfs/blocklayout/extent_tree.c
 delete mode 100644 fs/nfs/blocklayout/extents.c
fs/nfs/blocklayout/Makefile +2 -1
index d581550..3fa5ec7 100644
@@ -2,4 +2,5 @@
 # Makefile for the pNFS block layout driver kernel module
 #
 obj-$(CONFIG_PNFS_BLOCK) += blocklayoutdriver.o
-blocklayoutdriver-objs := blocklayout.o extents.o blocklayoutdev.o blocklayoutdm.o
+blocklayoutdriver-objs := blocklayout.o blocklayoutdev.o blocklayoutdm.o \
+	extent_tree.o
fs/nfs/blocklayout/blocklayout.c +66 -192

433 lines not on this page · raw message

fs/nfs/blocklayout/blocklayout.h +23 -89

134 lines not on this page · raw message

fs/nfs/blocklayout/blocklayoutdev.c +13 -22
index 63f77925..cd71b5e 100644
@@ -309,7 +309,7 @@ nfs4_blk_process_layoutget(struct pnfs_layout_hdr *lo,
 	 * recovery easier.
 	 */
 	for (i = 0; i < count; i++) {
-		be = bl_alloc_extent();
+		be = kzalloc(sizeof(struct pnfs_block_extent), GFP_NOFS);
 		if (!be) {
 			status = -ENOMEM;
 			goto out_err;
@@ -330,13 +330,11 @@ nfs4_blk_process_layoutget(struct pnfs_layout_hdr *lo,
 		if (decode_sector_number(&p, &be->be_v_offset) < 0)
 			goto out_err;
 		be->be_state = be32_to_cpup(p++);
-		if (be->be_state == PNFS_BLOCK_INVALID_DATA)
-			be->be_inval = &bl->bl_inval;
 		if (verify_extent(be, &lv)) {
 			dprintk("%s verify failed\n", __func__);
 			goto out_err;
 		}
-		list_add_tail(&be->be_node, &extents);
+		list_add_tail(&be->be_list, &extents);
 	}
 	if (lgr->range.offset + lgr->range.length !=
 			lv.start << SECTOR_SHIFT) {
@@ -352,21 +350,13 @@ nfs4_blk_process_layoutget(struct pnfs_layout_hdr *lo,
 	/* Extents decoded properly, now try to merge them in to
 	 * existing layout extents.
 	 */
-	spin_lock(&bl->bl_ext_lock);
-	list_for_each_entry_safe(be, save, &extents, be_node) {
-		list_del(&be->be_node);
-		status = bl_add_merge_extent(bl, be);
-		if (status) {
-			spin_unlock(&bl->bl_ext_lock);
-			/* This is a fairly catastrophic error, as the
-			 * entire layout extent lists are now corrupted.
-			 * We should have some way to distinguish this.
-			 */
-			be = NULL;
-			goto out_err;
-		}
+	list_for_each_entry_safe(be, save, &extents, be_list) {
+		list_del(&be->be_list);
+
+		status = ext_tree_insert(bl, be);
+		if (status)
+			goto out_free_list;
 	}
-	spin_unlock(&bl->bl_ext_lock);
 	status = 0;
  out:
 	__free_page(scratch);
@@ -374,12 +364,13 @@ nfs4_blk_process_layoutget(struct pnfs_layout_hdr *lo,
 	return status;
 
  out_err:
-	bl_put_extent(be);
+	kfree(be);
+ out_free_list:
 	while (!list_empty(&extents)) {
 		be = list_first_entry(&extents, struct pnfs_block_extent,
-				      be_node);
-		list_del(&be->be_node);
-		bl_put_extent(be);
+				      be_list);
+		list_del(&be->be_list);
+		kfree(be);
 	}
 	goto out;
 }
fs/nfs/blocklayout/extent_tree.c new file +545 -0

545 lines not on this page · raw message

fs/nfs/blocklayout/extents.c deleted +0 -908

908 lines not on this page · raw message

Signature · 1 line
1.9.1
#28 lore raw

PATCH 15/17 pnfs/blocklayout: implement the return_range method

In reply to Christoph Hellwig

This allows removing extents from the extent tree especially on truncate operations, and thus fixing reads from truncated and re-extended that previously returned stale data.

---
 fs/nfs/blocklayout/blocklayout.c | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
fs/nfs/blocklayout/blocklayout.c +30 -0
index 42b6f9c..a7524c4 100644
@@ -470,6 +470,35 @@ static struct pnfs_layout_segment *bl_alloc_lseg(struct pnfs_layout_hdr *lo,
 }
 
 static void
+bl_return_range(struct pnfs_layout_hdr *lo,
+		struct pnfs_layout_range *range)
+{
+	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
+	sector_t offset = range->offset >> SECTOR_SHIFT, end;
+	int err;
+
+	if (range->offset % 8) {
+		dprintk("%s: offset %lld not block size aligned\n",
+			__func__, range->offset);
+		return;
+	}
+
+	if (range->length != NFS4_MAX_UINT64) {
+		if (range->length % 8) {
+			dprintk("%s: length %lld not block size aligned\n",
+				__func__, range->length);
+			return;
+		}
+
+		end = offset + (range->length >> SECTOR_SHIFT);
+	} else {
+		end = round_down(NFS4_MAX_UINT64, PAGE_SIZE);
+	}
+
+	err = ext_tree_remove(bl, range->iomode & IOMODE_RW, offset, end);
+}
+
+static void
 bl_encode_layoutcommit(struct pnfs_layout_hdr *lo, struct xdr_stream *xdr,
 		       const struct nfs4_layoutcommit_args *arg)
 {
@@ -777,6 +806,7 @@ static struct pnfs_layoutdriver_type blocklayout_type = {
 	.free_layout_hdr		= bl_free_layout_hdr,
 	.alloc_lseg			= bl_alloc_lseg,
 	.free_lseg			= bl_free_lseg,
+	.return_range			= bl_return_range,
 	.encode_layoutcommit		= bl_encode_layoutcommit,
 	.cleanup_layoutcommit		= bl_cleanup_layoutcommit,
 	.set_layoutdriver		= bl_set_layoutdriver,
Signature · 1 line
1.9.1
#29 lore raw

PATCH 16/17 pnfs/blocklayout: return layouts on setattr

In reply to Christoph Hellwig

This speads up truncate-heavy workloads like fsx by multiple orders of magnitude.

---
 fs/nfs/blocklayout/blocklayout.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
fs/nfs/blocklayout/blocklayout.c +2 -1
index a7524c4..d5a2b87 100644
@@ -799,7 +799,8 @@ static struct pnfs_layoutdriver_type blocklayout_type = {
 	.id				= LAYOUT_BLOCK_VOLUME,
 	.name				= "LAYOUT_BLOCK_VOLUME",
 	.owner				= THIS_MODULE,
-	.flags				= PNFS_READ_WHOLE_PAGE,
+	.flags				= PNFS_LAYOUTRET_ON_SETATTR |
+					  PNFS_READ_WHOLE_PAGE,
 	.read_pagelist			= bl_read_pagelist,
 	.write_pagelist			= bl_write_pagelist,
 	.alloc_layout_hdr		= bl_alloc_layout_hdr,
Signature · 1 line
1.9.1
#30 lore raw

PATCH 17/17 pnfs/blocklayout: allocate separate pages for the layoutcommit payload

In reply to Christoph Hellwig

Instead of overflowing the XDR send buffer with our extent list allocate pages and pre-encode the layoutupdate payload into them. We optimistically allocate a single page use alloc_page and only switch to vmalloc when we have more extents outstanding. Currently there is only a single testcase (xfstests generic/113) which can reproduce large enough extent lists for this to occur.

---
 fs/nfs/blocklayout/blocklayout.c |  9 ++--
 fs/nfs/blocklayout/blocklayout.h |  6 ++-
 fs/nfs/blocklayout/extent_tree.c | 89 +++++++++++++++++++++++++++++++---------
 3 files changed, 78 insertions(+), 26 deletions(-)
fs/nfs/blocklayout/blocklayout.c +4 -5
index d5a2b87..fae8144 100644
@@ -498,12 +498,11 @@ bl_return_range(struct pnfs_layout_hdr *lo,
 	err = ext_tree_remove(bl, range->iomode & IOMODE_RW, offset, end);
 }
 
-static void
-bl_encode_layoutcommit(struct pnfs_layout_hdr *lo, struct xdr_stream *xdr,
-		       const struct nfs4_layoutcommit_args *arg)
+static int
+bl_prepare_layoutcommit(struct nfs4_layoutcommit_args *arg)
 {
 	dprintk("%s enter\n", __func__);
-	ext_tree_encode_commit(BLK_LO2EXT(lo), xdr);
+	return ext_tree_prepare_commit(arg);
 }
 
 static void
@@ -808,7 +807,7 @@ static struct pnfs_layoutdriver_type blocklayout_type = {
 	.alloc_lseg			= bl_alloc_lseg,
 	.free_lseg			= bl_free_lseg,
 	.return_range			= bl_return_range,
-	.encode_layoutcommit		= bl_encode_layoutcommit,
+	.prepare_layoutcommit		= bl_prepare_layoutcommit,
 	.cleanup_layoutcommit		= bl_cleanup_layoutcommit,
 	.set_layoutdriver		= bl_set_layoutdriver,
 	.clear_layoutdriver		= bl_clear_layoutdriver,
fs/nfs/blocklayout/blocklayout.h +4 -2
index b4f66d8..caae202 100644
@@ -80,6 +80,9 @@ struct pnfs_block_extent {
 	unsigned int	be_tag;
 };
 
+/* on the wire size of the extent */
+#define BL_EXTENT_SIZE	(7 * sizeof(__be32) + NFS4_DEVICEID4_SIZE)
+
 struct pnfs_block_layout {
 	struct pnfs_layout_hdr	bl_layout;
 	struct rb_root		bl_ext_rw;
@@ -138,8 +141,7 @@ int ext_tree_mark_written(struct pnfs_block_layout *bl, sector_t start,
 		sector_t len);
 bool ext_tree_lookup(struct pnfs_block_layout *bl, sector_t isect,
 		struct pnfs_block_extent *ret, bool rw);
-int ext_tree_encode_commit(struct pnfs_block_layout *bl,
-		struct xdr_stream *xdr);
+int ext_tree_prepare_commit(struct nfs4_layoutcommit_args *arg);
 void ext_tree_mark_committed(struct pnfs_block_layout *bl, int status);
 
 #endif /* FS_NFS_NFS4BLOCKLAYOUT_H */
fs/nfs/blocklayout/extent_tree.c +70 -19

117 lines not on this page · raw message

Signature · 1 line
1.9.1
#31 lore raw

Re: [PATCH 17/17] pnfs/blocklayout: allocate separate pages for the layoutcommit payload

Quoted 7 lines · Christoph Hellwig

Instead of overflowing the XDR send buffer with our extent list allocate pages and pre-encode the layoutupdate payload into them. We optimistically allocate a single page use alloc_page and only switch to vmalloc when we have more extents outstanding. Currently there is only a single testcase (xfstests generic/113) which can reproduce large enough extent lists for this to occur.

depending on how badly the extents are fragmented, it might worth starting an async layoutcommit within blocklayout client when bl_count reaches certain limit, so that we don't send an unlimited amount of extents in one layoutcommit.

Cheers,
Tao

Quoted 190 lines
---
 fs/nfs/blocklayout/blocklayout.c |  9 ++--
 fs/nfs/blocklayout/blocklayout.h |  6 ++-
 fs/nfs/blocklayout/extent_tree.c | 89 +++++++++++++++++++++++++++++++---------
 3 files changed, 78 insertions(+), 26 deletions(-)
fs/nfs/blocklayout/blocklayout.c +4 -5
index d5a2b87..fae8144 100644
@@ -498,12 +498,11 @@ bl_return_range(struct pnfs_layout_hdr *lo,
        err = ext_tree_remove(bl, range->iomode & IOMODE_RW, offset, end);
 }
 
-static void
-bl_encode_layoutcommit(struct pnfs_layout_hdr *lo, struct xdr_stream *xdr,
-                      const struct nfs4_layoutcommit_args *arg)
+static int
+bl_prepare_layoutcommit(struct nfs4_layoutcommit_args *arg)
 {
        dprintk("%s enter\n", __func__);
-       ext_tree_encode_commit(BLK_LO2EXT(lo), xdr);
+       return ext_tree_prepare_commit(arg);
 }
 
 static void
@@ -808,7 +807,7 @@ static struct pnfs_layoutdriver_type blocklayout_type = {
        .alloc_lseg                     = bl_alloc_lseg,
        .free_lseg                      = bl_free_lseg,
        .return_range                   = bl_return_range,
-       .encode_layoutcommit            = bl_encode_layoutcommit,
+       .prepare_layoutcommit           = bl_prepare_layoutcommit,
        .cleanup_layoutcommit           = bl_cleanup_layoutcommit,
        .set_layoutdriver               = bl_set_layoutdriver,
        .clear_layoutdriver             = bl_clear_layoutdriver,
fs/nfs/blocklayout/blocklayout.h +4 -2
index b4f66d8..caae202 100644
@@ -80,6 +80,9 @@ struct pnfs_block_extent {
        unsigned int    be_tag;
 };
 
+/* on the wire size of the extent */
+#define BL_EXTENT_SIZE (7 * sizeof(__be32) + NFS4_DEVICEID4_SIZE)
+
 struct pnfs_block_layout {
        struct pnfs_layout_hdr  bl_layout;
        struct rb_root          bl_ext_rw;
@@ -138,8 +141,7 @@ int ext_tree_mark_written(struct pnfs_block_layout *bl, sector_t start,
                sector_t len);
 bool ext_tree_lookup(struct pnfs_block_layout *bl, sector_t isect,
                struct pnfs_block_extent *ret, bool rw);
-int ext_tree_encode_commit(struct pnfs_block_layout *bl,
-               struct xdr_stream *xdr);
+int ext_tree_prepare_commit(struct nfs4_layoutcommit_args *arg);
 void ext_tree_mark_committed(struct pnfs_block_layout *bl, int status);
 
 #endif /* FS_NFS_NFS4BLOCKLAYOUT_H */
fs/nfs/blocklayout/extent_tree.c +70 -20
index c7dacfa..3945221 100644
@@ -465,32 +465,23 @@ out:
        return err;
 }
 
-int
-ext_tree_encode_commit(struct pnfs_block_layout *bl, struct xdr_stream *xdr)
+static int ext_tree_encode_commit(struct pnfs_block_layout *bl, __be32 *p,
+               size_t buffer_size, size_t *count)
 {
        struct pnfs_block_extent *be;
-       unsigned int count = 0;
-       __be32 *p, *xdr_start;
        int ret = 0;
 
-       dprintk("%s enter\n", __func__);
-
-       xdr_start = xdr_reserve_space(xdr, 8);
-       if (!xdr_start)
-               return -ENOSPC;
-
        spin_lock(&bl->bl_ext_lock);
        for (be = ext_tree_first(&bl->bl_ext_rw); be; be = ext_tree_next(be)) {
                if (be->be_state != PNFS_BLOCK_INVALID_DATA ||
                    be->be_tag != EXTENT_WRITTEN)
                        continue;
 
-               p = xdr_reserve_space(xdr, 7 * sizeof(__be32) +
-                                       NFS4_DEVICEID4_SIZE);
-               if (!p) {
-                       printk("%s: out of space for extent list\n", __func__);
+               (*count)++;
+               if (*count * BL_EXTENT_SIZE > buffer_size) {
+                       /* keep counting.. */
                        ret = -ENOSPC;
-                       break;
+                       continue;
                }
 
                p = xdr_encode_opaque_fixed(p, be->be_devid.data,
@@ -501,15 +492,75 @@ ext_tree_encode_commit(struct pnfs_block_layout *bl, struct xdr_stream *xdr)
                *p++ = cpu_to_be32(PNFS_BLOCK_READWRITE_DATA);
 
                be->be_tag = EXTENT_COMMITTING;
-               count++;
        }
        spin_unlock(&bl->bl_ext_lock);
 
-       xdr_start[0] = cpu_to_be32((xdr->p - xdr_start - 1) * 4);
-       xdr_start[1] = cpu_to_be32(count);
+       return ret;
+}
+
+int
+ext_tree_prepare_commit(struct nfs4_layoutcommit_args *arg)
+{
+       struct pnfs_block_layout *bl = BLK_LO2EXT(NFS_I(arg->inode)->layout);
+       size_t count = 0, buffer_size = PAGE_SIZE;
+       __be32 *start_p;
+       int ret;
+
+       dprintk("%s enter\n", __func__);
+
+       arg->layoutupdate_page = alloc_page(GFP_NOFS);
+       if (!arg->layoutupdate_page)
+               return -ENOMEM;
+       start_p = page_address(arg->layoutupdate_page);
+       arg->layoutupdate_pages = &arg->layoutupdate_page;
+
+retry:
+       ret = ext_tree_encode_commit(bl, start_p + 1, buffer_size, &count);
+       if (unlikely(ret)) {
+               if (arg->layoutupdate_pages != &arg->layoutupdate_page) {
+                       int nr_pages = DIV_ROUND_UP(buffer_size, PAGE_SIZE), i;
+
+                       for (i = 0; i < nr_pages; i++)
+                               put_page(arg->layoutupdate_pages[i]);
+                       kfree(arg->layoutupdate_pages);
+               } else {
+                       put_page(arg->layoutupdate_page);
+               }
+
+               buffer_size = sizeof(__be32) + BL_EXTENT_SIZE * count;
+               count = 0;
+
+               arg->layoutupdate_pages =
+                       kcalloc(DIV_ROUND_UP(buffer_size, PAGE_SIZE),
+                               sizeof(struct page *), GFP_NOFS);
+               if (!arg->layoutupdate_pages)
+                       return -ENOMEM;
+
+               start_p = __vmalloc(buffer_size, GFP_NOFS, PAGE_KERNEL);
+               if (!start_p) {
+                       kfree(arg->layoutupdate_pages);
+                       return -ENOMEM;
+               }
+
+               goto retry;
+       }
+
+       *start_p = cpu_to_be32(count);
+       arg->layoutupdate_len = sizeof(__be32) + BL_EXTENT_SIZE * count;
+
+       if (unlikely(arg->layoutupdate_pages != &arg->layoutupdate_page)) {
+               __be32 *p = start_p;
+               int i = 0;
+
+               for (p = start_p;
+                    p < start_p + arg->layoutupdate_len;
+                    p += PAGE_SIZE) {
+                       arg->layoutupdate_pages[i++] = vmalloc_to_page(p);
+               }
+       }
 
        dprintk("%s found %i ranges\n", __func__, count);
-       return ret;
+       return 0;
 }
 
 void
--

1.9.1

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#32 lore raw

Re: [PATCH 17/17] pnfs/blocklayout: allocate separate pages for the layoutcommit payload

Quoted 8 lines · Peng Tao
Quoted 7 lines · Christoph Hellwig

Instead of overflowing the XDR send buffer with our extent list allocate pages and pre-encode the layoutupdate payload into them. We optimistically allocate a single page use alloc_page and only switch to vmalloc when we have more extents outstanding. Currently there is only a single testcase (xfstests generic/113) which can reproduce large enough extent lists for this to occur.

Quoted 4 lines

depending on how badly the extents are fragmented, it might worth starting an async layoutcommit within blocklayout client when bl_count reaches certain limit, so that we don't send an unlimited amount of extents in one layoutcommit.

I though about this, but this only reduces the problem and we'd still need to be able to commit all extents for a data integrity operation, so we'd still need someting like the above.

The other option I considered and prototyped was to send multiple on the wire layoutcommit calls from pnfs_layoutcommit_inode, but that did prove to be even more cumbersome.

#33 lore raw

Re: [PATCH 17/17] pnfs/blocklayout: allocate separate pages for the layoutcommit payload

Quoted 9 lines · Christoph Hellwig
Quoted 8 lines · Peng Tao
Quoted 7 lines · Christoph Hellwig

Instead of overflowing the XDR send buffer with our extent list allocate pages and pre-encode the layoutupdate payload into them. We optimistically allocate a single page use alloc_page and only switch to vmalloc when we have more extents outstanding. Currently there is only a single testcase (xfstests generic/113) which can reproduce large enough extent lists for this to occur.

Quoted 9 lines
Quoted 4 lines

depending on how badly the extents are fragmented, it might worth starting an async layoutcommit within blocklayout client when bl_count reaches certain limit, so that we don't send an unlimited amount of extents in one layoutcommit.

I though about this, but this only reduces the problem and we'd still need to be able to commit all extents for a data integrity operation, so we'd still need someting like the above.

yeah, I wasn't against your patch. What I suggested is a way to limit the amount of commit extents such that we don't end up sending more that one RPC, whose size is still limited even if we allocate large enough XDR buffer.

Quoted 3 lines

The other option I considered and prototyped was to send multiple on the wire layoutcommit calls from pnfs_layoutcommit_inode, but that did prove to be even more cumbersome.

#34 lore raw
In reply to Christoph Hellwig
Quoted 11 lines · On Thu, 7 Aug 2014 09:23:32 +0200 Christoph Hellwig <[email protected]> wrote:

This series fixes a wide range of issues with the pnfs block layout driver.

Before this we were seeing frequent silent data corruption, softlockups and kernel crashes when running both user applications and test cases like xfstests.

After this rewrite of the I/O path we've sorted out all issues under normal operations, although error handling in the block layout driver and its interaction with the core nfs and pnfs code still needs further work.

This work was sponsored by NetApp, Inc.

What sort of server are you testing this against?

Signature · 1 line
Jeff Layton <[email protected]>
#35 lore raw
Quoted 1 line · Jeff Layton

What sort of server are you testing this against?

I've written a new Linux knfsd based one that will be posted here in the not too distant future.

#36 lore raw
In reply to Christoph Hellwig

This series has been out for a Month now with a repost with 2 additional patches. Any chance to get reviewing it (or at least the core patches as there seems little interest in the block layout) and merging it expedited?

#37 lore raw
Quoted 5 lines · Christoph Hellwig

This series has been out for a Month now with a repost with 2 additional patches. Any chance to get reviewing it (or at least the core patches as there seems little interest in the block layout) and merging it expedited?

Yes. I've been planning on merging it, but I've been a little out of sorts due to illness and travel. Will get to it in the next few days.

Signature · 5 lines
Trond Myklebust

Linux NFS client maintainer, PrimaryData

[email protected]