Re: [PATCH 6/9] pnfs/blocklayout: rewrite extent tracking

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On 09/09/2014 12:40 PM, Christoph Hellwig wrote:
> 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.
>
> Signed-off-by: Christoph Hellwig <hch@xxxxxx>
> ---
>  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
>
> diff --git a/fs/nfs/blocklayout/Makefile b/fs/nfs/blocklayout/Makefile
> index d581550..3fa5ec7 100644
> --- a/fs/nfs/blocklayout/Makefile
> +++ b/fs/nfs/blocklayout/Makefile
> @@ -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
> diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
> index 92be984..42b6f9c 100644
> --- a/fs/nfs/blocklayout/blocklayout.c
> +++ b/fs/nfs/blocklayout/blocklayout.c
> @@ -49,26 +49,16 @@ MODULE_LICENSE("GPL");
>  MODULE_AUTHOR("Andy Adamson <andros@xxxxxxxxxxxxxx>");
>  MODULE_DESCRIPTION("The NFSv4.1 pNFS Block layout driver");
>  
> -/* Given the be associated with isect, determine if page data needs to be
> - * initialized.
> - */
> -static int is_hole(struct pnfs_block_extent *be, sector_t isect)
> -{
> -	if (be->be_state == PNFS_BLOCK_NONE_DATA)
> -		return 1;
> -	else if (be->be_state != PNFS_BLOCK_INVALID_DATA)
> -		return 0;
> -	else
> -		return !bl_is_sector_init(be->be_inval, isect);
> -}
> -
> -/* Given the be associated with isect, determine if page data can be
> - * written to disk.
> - */
> -static int is_writable(struct pnfs_block_extent *be, sector_t isect)
> +static bool is_hole(struct pnfs_block_extent *be)
>  {
> -	return (be->be_state == PNFS_BLOCK_READWRITE_DATA ||
> -		be->be_state == PNFS_BLOCK_INVALID_DATA);
> +	switch (be->be_state) {
> +	case PNFS_BLOCK_NONE_DATA:
> +		return true;
> +	case PNFS_BLOCK_INVALID_DATA:
> +		return be->be_tag ? false : true;
> +	default:
> +		return false;
> +	}
>  }
>  
>  /* The data we are handed might be spread across several bios.  We need
> @@ -76,9 +66,8 @@ static int is_writable(struct pnfs_block_extent *be, sector_t isect)
>   */
>  struct parallel_io {
>  	struct kref refcnt;
> -	void (*pnfs_callback) (void *data, int num_se);
> +	void (*pnfs_callback) (void *data);
>  	void *data;
> -	int bse_count;
>  };
>  
>  static inline struct parallel_io *alloc_parallel(void *data)
> @@ -89,7 +78,6 @@ static inline struct parallel_io *alloc_parallel(void *data)
>  	if (rv) {
>  		rv->data = data;
>  		kref_init(&rv->refcnt);
> -		rv->bse_count = 0;
>  	}
>  	return rv;
>  }
> @@ -104,7 +92,7 @@ static void destroy_parallel(struct kref *kref)
>  	struct parallel_io *p = container_of(kref, struct parallel_io, refcnt);
>  
>  	dprintk("%s enter\n", __func__);
> -	p->pnfs_callback(p->data, p->bse_count);
> +	p->pnfs_callback(p->data);
>  	kfree(p);
>  }
>  
> @@ -200,7 +188,7 @@ static void bl_read_cleanup(struct work_struct *work)
>  }
>  
>  static void
> -bl_end_par_io_read(void *data, int unused)
> +bl_end_par_io_read(void *data)
>  {
>  	struct nfs_pgio_header *hdr = data;
>  
> @@ -210,56 +198,46 @@ bl_end_par_io_read(void *data, int unused)
>  }
>  
>  static enum pnfs_try_status
> -bl_read_pagelist(struct nfs_pgio_header *hdr)
> +bl_read_pagelist(struct nfs_pgio_header *header)
>  {
> -	struct nfs_pgio_header *header = hdr;
> -	int i, hole;
> +	struct pnfs_block_layout *bl = BLK_LSEG2EXT(header->lseg);
>  	struct bio *bio = NULL;
> -	struct pnfs_block_extent *be = NULL, *cow_read = NULL;
> +	struct pnfs_block_extent be;
>  	sector_t isect, extent_length = 0;
>  	struct parallel_io *par;
> -	loff_t f_offset = hdr->args.offset;
> -	size_t bytes_left = hdr->args.count;
> +	loff_t f_offset = header->args.offset;
> +	size_t bytes_left = header->args.count;
>  	unsigned int pg_offset, pg_len;
> -	struct page **pages = hdr->args.pages;
> -	int pg_index = hdr->args.pgbase >> PAGE_CACHE_SHIFT;
> +	struct page **pages = header->args.pages;
> +	int pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
>  	const bool is_dio = (header->dreq != NULL);
>  	struct blk_plug plug;
> +	int i;
>  
>  	dprintk("%s enter nr_pages %u offset %lld count %u\n", __func__,
> -		hdr->page_array.npages, f_offset,
> -		(unsigned int)hdr->args.count);
> +		header->page_array.npages, f_offset,
> +		(unsigned int)header->args.count);
>  
> -	par = alloc_parallel(hdr);
> +	par = alloc_parallel(header);
>  	if (!par)
> -		goto use_mds;
> +		return PNFS_NOT_ATTEMPTED;
>  	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++) {
> +	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(READ, bio);
> +
>  			/* Get the next one */
> -			be = bl_find_get_extent(BLK_LSEG2EXT(header->lseg),
> -					     isect, &cow_read);
> -			if (!be) {
> +			if (!ext_tree_lookup(bl, isect, &be, false)) {
>  				header->pnfs_error = -EIO;
>  				goto out;
>  			}
> -			extent_length = be->be_length -
> -				(isect - be->be_f_offset);
> -			if (cow_read) {
> -				sector_t cow_length = cow_read->be_length -
> -					(isect - cow_read->be_f_offset);
> -				extent_length = min(extent_length, cow_length);
> -			}
> +			extent_length = be.be_length - (isect - be.be_f_offset);
>  		}
>  
>  		pg_offset = f_offset & ~PAGE_CACHE_MASK;
> @@ -278,20 +256,16 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
>  			pg_len = PAGE_CACHE_SIZE;
>  		}
>  
> -		hole = is_hole(be, isect);
> -		if (hole && !cow_read) {
> +		if (is_hole(&be)) {
>  			bio = bl_submit_bio(READ, bio);
>  			/* 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);
>  		} else {
> -			struct pnfs_block_extent *be_read;
> -
> -			be_read = (hole && cow_read) ? cow_read : be;
>  			bio = do_add_page_to_bio(bio,
> -						 hdr->page_array.npages - i,
> +						 header->page_array.npages - i,
>  						 READ,
> -						 isect, pages[i], be_read,
> +						 isect, pages[i], &be,
>  						 bl_end_io_read, par,
>  						 pg_offset, pg_len);
>  			if (IS_ERR(bio)) {
> @@ -304,50 +278,16 @@ bl_read_pagelist(struct nfs_pgio_header *hdr)
>  		extent_length -= (pg_len >> SECTOR_SHIFT);
>  	}
>  	if ((isect << SECTOR_SHIFT) >= header->inode->i_size) {
> -		hdr->res.eof = 1;
> -		hdr->res.count = header->inode->i_size - hdr->args.offset;
> +		header->res.eof = 1;
> +		header->res.count = header->inode->i_size - header->args.offset;
>  	} else {
> -		hdr->res.count = (isect << SECTOR_SHIFT) - hdr->args.offset;
> +		header->res.count = (isect << SECTOR_SHIFT) - header->args.offset;
>  	}
>  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;
> -
> - use_mds:
> -	dprintk("Giving up and using normal NFS\n");
> -	return PNFS_NOT_ATTEMPTED;
> -}
> -
> -static void mark_extents_written(struct pnfs_block_layout *bl,
> -				 __u64 offset, __u32 count)
> -{
> -	sector_t isect, end;
> -	struct pnfs_block_extent *be;
> -	struct pnfs_block_short_extent *se;
> -
> -	dprintk("%s(%llu, %u)\n", __func__, offset, count);
> -	if (count == 0)
> -		return;
> -	isect = (offset & (long)(PAGE_CACHE_MASK)) >> SECTOR_SHIFT;
> -	end = (offset + count + PAGE_CACHE_SIZE - 1) & (long)(PAGE_CACHE_MASK);
> -	end >>= SECTOR_SHIFT;
> -	while (isect < end) {
> -		sector_t len;
> -		be = bl_find_get_extent(bl, isect, NULL);
> -		BUG_ON(!be); /* FIXME */
> -		len = min(end, be->be_f_offset + be->be_length) - isect;
> -		if (be->be_state == PNFS_BLOCK_INVALID_DATA) {
> -			se = bl_pop_one_short_extent(be->be_inval);
> -			BUG_ON(!se);
> -			bl_mark_for_commit(be, isect, len, se);
> -		}
> -		isect += len;
> -		bl_put_extent(be);
> -	}
>  }
>  
>  static void bl_end_io_write(struct bio *bio, int err)
> @@ -370,29 +310,30 @@ static void bl_end_io_write(struct bio *bio, int err)
>   */
>  static void bl_write_cleanup(struct work_struct *work)
>  {
> -	struct rpc_task *task;
> -	struct nfs_pgio_header *hdr;
> +	struct rpc_task *task = container_of(work, struct rpc_task, u.tk_work);
> +	struct nfs_pgio_header *hdr =
> +			container_of(task, struct nfs_pgio_header, task);
> +
>  	dprintk("%s enter\n", __func__);
> -	task = container_of(work, struct rpc_task, u.tk_work);
> -	hdr = container_of(task, struct nfs_pgio_header, task);
> +
>  	if (likely(!hdr->pnfs_error)) {
> -		/* Marks for LAYOUTCOMMIT */
> -		mark_extents_written(BLK_LSEG2EXT(hdr->lseg),
> -				     hdr->args.offset, hdr->args.count);
> +		struct pnfs_block_layout *bl = BLK_LSEG2EXT(hdr->lseg);
> +		u64 start = hdr->args.offset & (loff_t)PAGE_CACHE_MASK;
> +		u64 end = (hdr->args.offset + hdr->args.count +
> +			PAGE_CACHE_SIZE - 1) & (loff_t)PAGE_CACHE_MASK;
> +
> +		ext_tree_mark_written(bl, start >> SECTOR_SHIFT,
> +					(end - start) >> SECTOR_SHIFT);
>  	}
> +
>  	pnfs_ld_write_done(hdr);
>  }
>  
>  /* Called when last of bios associated with a bl_write_pagelist call finishes */
> -static void bl_end_par_io_write(void *data, int num_se)
> +static void bl_end_par_io_write(void *data)
>  {
>  	struct nfs_pgio_header *hdr = data;
>  
> -	if (unlikely(hdr->pnfs_error)) {
> -		bl_free_short_extents(&BLK_LSEG2EXT(hdr->lseg)->bl_inval,
> -					num_se);
> -	}
> -
>  	hdr->task.tk_status = hdr->pnfs_error;
>  	hdr->verf.committed = NFS_FILE_SYNC;
>  	INIT_WORK(&hdr->task.u.tk_work, bl_write_cleanup);
> @@ -402,9 +343,9 @@ static void bl_end_par_io_write(void *data, int num_se)
>  static enum pnfs_try_status
>  bl_write_pagelist(struct nfs_pgio_header *header, int sync)
>  {
> -	int i, ret;
> +	struct pnfs_block_layout *bl = BLK_LSEG2EXT(header->lseg);
>  	struct bio *bio = NULL;
> -	struct pnfs_block_extent *be = NULL;
> +	struct pnfs_block_extent be;
>  	sector_t isect, extent_length = 0;
>  	struct parallel_io *par = NULL;
>  	loff_t offset = header->args.offset;
> @@ -412,6 +353,7 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
>  	struct page **pages = header->args.pages;
>  	int pg_index = pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
>  	struct blk_plug plug;
> +	int i;
>  
>  	dprintk("%s enter, %Zu@%lld\n", __func__, count, offset);
>  
> @@ -421,9 +363,8 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
>  	 */
>  	par = alloc_parallel(header);
>  	if (!par)
> -		goto out_mds;
> +		return PNFS_NOT_ATTEMPTED;
>  	par->pnfs_callback = bl_end_par_io_write;
> -	/* At this point, have to be more careful with error handling */
>  
>  	blk_start_plug(&plug);
>  
> @@ -434,44 +375,18 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
>  	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);
>  			bio = bl_submit_bio(WRITE, bio);
>  			/* Get the next one */
> -			be = bl_find_get_extent(BLK_LSEG2EXT(header->lseg),
> -					     isect, NULL);
> -			if (!be || !is_writable(be, isect)) {
> +			if (!ext_tree_lookup(bl, isect, &be, true)) {
>  				header->pnfs_error = -EINVAL;
>  				goto out;
>  			}
> -			if (be->be_state == PNFS_BLOCK_INVALID_DATA) {
> -				if (likely(!bl_push_one_short_extent(
> -								be->be_inval)))
> -					par->bse_count++;
> -				else {
> -					header->pnfs_error = -ENOMEM;
> -					goto out;
> -				}
> -			}
> -			extent_length = be->be_length -
> -			    (isect - be->be_f_offset);
> -		}
>  
> -		BUG_ON(offset & ~PAGE_CACHE_MASK);
> -
> -		if (be->be_state == PNFS_BLOCK_INVALID_DATA &&
> -		    !bl_is_sector_init(be->be_inval, isect)) {
> -			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);
> -				header->pnfs_error = ret;
> -				goto out;
> -			}
> +			extent_length = be.be_length - (isect - be.be_f_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,
>  					 0, PAGE_CACHE_SIZE);
>  		if (IS_ERR(bio)) {
> @@ -487,60 +402,22 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
>  
>  	header->res.count = header->args.count;
>  out:
> -	bl_put_extent(be);
>  	bl_submit_bio(WRITE, bio);
>  	blk_finish_plug(&plug);
>  	put_parallel(par);
>  	return PNFS_ATTEMPTED;
> -out_mds:
> -	return PNFS_NOT_ATTEMPTED;
> -}
> -
> -/* FIXME - range ignored */
> -static void
> -release_extents(struct pnfs_block_layout *bl, struct pnfs_layout_range *range)
> -{
> -	int i;
> -	struct pnfs_block_extent *be;
> -
> -	spin_lock(&bl->bl_ext_lock);
> -	for (i = 0; i < EXTENT_LISTS; i++) {
> -		while (!list_empty(&bl->bl_extents[i])) {
> -			be = list_first_entry(&bl->bl_extents[i],
> -					      struct pnfs_block_extent,
> -					      be_node);
> -			list_del(&be->be_node);
> -			bl_put_extent(be);
> -		}
> -	}
> -	spin_unlock(&bl->bl_ext_lock);
> -}
> -
> -static void
> -release_inval_marks(struct pnfs_inval_markings *marks)
> -{
> -	struct pnfs_inval_tracking *pos, *temp;
> -	struct pnfs_block_short_extent *se, *stemp;
> -
> -	list_for_each_entry_safe(pos, temp, &marks->im_tree.mtt_stub, it_link) {
> -		list_del(&pos->it_link);
> -		kfree(pos);
> -	}
> -
> -	list_for_each_entry_safe(se, stemp, &marks->im_extents, bse_node) {
> -		list_del(&se->bse_node);
> -		kfree(se);
> -	}
> -	return;
>  }
>  
>  static void bl_free_layout_hdr(struct pnfs_layout_hdr *lo)
>  {
>  	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
> +	int err;
>  
>  	dprintk("%s enter\n", __func__);
> -	release_extents(bl, NULL);
> -	release_inval_marks(&bl->bl_inval);
> +
> +	err = ext_tree_remove(bl, true, 0, LLONG_MAX);
> +	WARN_ON(err);
> +
>  	kfree(bl);
>  }
>  
> @@ -553,14 +430,11 @@ static struct pnfs_layout_hdr *bl_alloc_layout_hdr(struct inode *inode,
>  	bl = kzalloc(sizeof(*bl), gfp_flags);
>  	if (!bl)
>  		return NULL;
> +
> +	bl->bl_ext_rw = RB_ROOT;
> +	bl->bl_ext_ro = RB_ROOT;
>  	spin_lock_init(&bl->bl_ext_lock);
> -	INIT_LIST_HEAD(&bl->bl_extents[0]);
> -	INIT_LIST_HEAD(&bl->bl_extents[1]);
> -	INIT_LIST_HEAD(&bl->bl_commit);
> -	INIT_LIST_HEAD(&bl->bl_committing);
> -	bl->bl_count = 0;
> -	bl->bl_blocksize = NFS_SERVER(inode)->pnfs_blksize >> SECTOR_SHIFT;
> -	BL_INIT_INVAL_MARKS(&bl->bl_inval, bl->bl_blocksize);
> +	
>  	return &bl->bl_layout;
>  }
>  
> @@ -600,7 +474,7 @@ bl_encode_layoutcommit(struct pnfs_layout_hdr *lo, struct xdr_stream *xdr,
>  		       const struct nfs4_layoutcommit_args *arg)
>  {
>  	dprintk("%s enter\n", __func__);
> -	encode_pnfs_block_layoutupdate(BLK_LO2EXT(lo), xdr, arg);
> +	ext_tree_encode_commit(BLK_LO2EXT(lo), xdr);
>  }
>  
>  static void
> @@ -609,7 +483,7 @@ bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
>  	struct pnfs_layout_hdr *lo = NFS_I(lcdata->args.inode)->layout;
>  
>  	dprintk("%s enter\n", __func__);
> -	clean_pnfs_block_layoutupdate(BLK_LO2EXT(lo), &lcdata->args, lcdata->res.status);
> +	ext_tree_mark_committed(BLK_LO2EXT(lo), lcdata->res.status);
>  }
>  
>  static void free_blk_mountid(struct block_mount_id *mid)
> diff --git a/fs/nfs/blocklayout/blocklayout.h b/fs/nfs/blocklayout/blocklayout.h
> index 9838fb0..b4f66d8 100644
> --- a/fs/nfs/blocklayout/blocklayout.h
> +++ b/fs/nfs/blocklayout/blocklayout.h
> @@ -63,82 +63,28 @@ enum exstate4 {
>  	PNFS_BLOCK_NONE_DATA		= 3  /* unmapped, it's a hole */
>  };
>  
> -#define MY_MAX_TAGS (15) /* tag bitnums used must be less than this */
> -
> -struct my_tree {
> -	sector_t		mtt_step_size;	/* Internal sector alignment */
> -	struct list_head	mtt_stub; /* Should be a radix tree */
> -};
> -
> -struct pnfs_inval_markings {
> -	spinlock_t	im_lock;
> -	struct my_tree	im_tree;	/* Sectors that need LAYOUTCOMMIT */
> -	sector_t	im_block_size;	/* Server blocksize in sectors */
> -	struct list_head im_extents;	/* Short extents for INVAL->RW conversion */
> -};
> -
> -struct pnfs_inval_tracking {
> -	struct list_head it_link;
> -	int		 it_sector;
> -	int		 it_tags;
> -};
> -
>  /* sector_t fields are all in 512-byte sectors */
>  struct pnfs_block_extent {
> -	struct kref	be_refcnt;
> -	struct list_head be_node;	/* link into lseg list */
> -	struct nfs4_deviceid be_devid;  /* FIXME: could use device cache instead */
> +	union {
> +		struct rb_node	be_node;
> +		struct list_head be_list;
> +	};
> +	struct nfs4_deviceid be_devid;	/* FIXME: could use device cache instead */
>  	struct block_device *be_mdev;
>  	sector_t	be_f_offset;	/* the starting offset in the file */
>  	sector_t	be_length;	/* the size of the extent */
>  	sector_t	be_v_offset;	/* the starting offset in the volume */
>  	enum exstate4	be_state;	/* the state of this extent */
> -	struct pnfs_inval_markings *be_inval; /* tracks INVAL->RW transition */
> -};
> -
> -/* Shortened extent used by LAYOUTCOMMIT */
> -struct pnfs_block_short_extent {
> -	struct list_head bse_node;
> -	struct nfs4_deviceid bse_devid;
> -	struct block_device *bse_mdev;
> -	sector_t	bse_f_offset;	/* the starting offset in the file */
> -	sector_t	bse_length;	/* the size of the extent */
> +#define EXTENT_WRITTEN		1
> +#define EXTENT_COMMITTING	2
> +	unsigned int	be_tag;
>  };
>  
> -static inline void
> -BL_INIT_INVAL_MARKS(struct pnfs_inval_markings *marks, sector_t blocksize)
> -{
> -	spin_lock_init(&marks->im_lock);
> -	INIT_LIST_HEAD(&marks->im_tree.mtt_stub);
> -	INIT_LIST_HEAD(&marks->im_extents);
> -	marks->im_block_size = blocksize;
> -	marks->im_tree.mtt_step_size = min((sector_t)PAGE_CACHE_SECTORS,
> -					   blocksize);
> -}
> -
> -enum extentclass4 {
> -	RW_EXTENT       = 0, /* READWRTE and INVAL */
> -	RO_EXTENT       = 1, /* READ and NONE */
> -	EXTENT_LISTS    = 2,
> -};
> -
> -static inline int bl_choose_list(enum exstate4 state)
> -{
> -	if (state == PNFS_BLOCK_READ_DATA || state == PNFS_BLOCK_NONE_DATA)
> -		return RO_EXTENT;
> -	else
> -		return RW_EXTENT;
> -}
> -
>  struct pnfs_block_layout {
> -	struct pnfs_layout_hdr bl_layout;
> -	struct pnfs_inval_markings bl_inval; /* tracks INVAL->RW transition */
> +	struct pnfs_layout_hdr	bl_layout;
> +	struct rb_root		bl_ext_rw;
> +	struct rb_root		bl_ext_ro;
>  	spinlock_t		bl_ext_lock;   /* Protects list manipulation */
> -	struct list_head	bl_extents[EXTENT_LISTS]; /* R and RW extents */
> -	struct list_head	bl_commit;	/* Needs layout commit */
> -	struct list_head	bl_committing;	/* Layout committing */
> -	unsigned int		bl_count;	/* entries in bl_commit */
> -	sector_t		bl_blocksize;  /* Server blocksize in sectors */
>  };
>  
>  #define BLK_ID(lo) ((struct block_mount_id *)(NFS_SERVER(lo->plh_inode)->pnfs_ld_data))
> @@ -183,29 +129,17 @@ int nfs4_blk_process_layoutget(struct pnfs_layout_hdr *lo,
>  /* blocklayoutdm.c */
>  void bl_free_block_dev(struct pnfs_block_dev *bdev);
>  
> -/* extents.c */
> -struct pnfs_block_extent *
> -bl_find_get_extent(struct pnfs_block_layout *bl, sector_t isect,
> -		struct pnfs_block_extent **cow_read);
> -int bl_mark_sectors_init(struct pnfs_inval_markings *marks,
> -			     sector_t offset, sector_t length);
> -void bl_put_extent(struct pnfs_block_extent *be);
> -struct pnfs_block_extent *bl_alloc_extent(void);
> -int bl_is_sector_init(struct pnfs_inval_markings *marks, sector_t isect);
> -int encode_pnfs_block_layoutupdate(struct pnfs_block_layout *bl,
> -				   struct xdr_stream *xdr,
> -				   const struct nfs4_layoutcommit_args *arg);
> -void clean_pnfs_block_layoutupdate(struct pnfs_block_layout *bl,
> -				   const struct nfs4_layoutcommit_args *arg,
> -				   int status);
> -int bl_add_merge_extent(struct pnfs_block_layout *bl,
> -			 struct pnfs_block_extent *new);
> -int bl_mark_for_commit(struct pnfs_block_extent *be,
> -			sector_t offset, sector_t length,
> -			struct pnfs_block_short_extent *new);
> -int bl_push_one_short_extent(struct pnfs_inval_markings *marks);
> -struct pnfs_block_short_extent *
> -bl_pop_one_short_extent(struct pnfs_inval_markings *marks);
> -void bl_free_short_extents(struct pnfs_inval_markings *marks, int num_to_free);
> +/* extent_tree.c */
> +int ext_tree_insert(struct pnfs_block_layout *bl,
> +		struct pnfs_block_extent *new);
> +int ext_tree_remove(struct pnfs_block_layout *bl, bool rw, sector_t start,
> +		sector_t end);
> +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);
> +void ext_tree_mark_committed(struct pnfs_block_layout *bl, int status);
>  
>  #endif /* FS_NFS_NFS4BLOCKLAYOUT_H */
> diff --git a/fs/nfs/blocklayout/blocklayoutdev.c b/fs/nfs/blocklayout/blocklayoutdev.c
> index 63f77925..cd71b5e 100644
> --- a/fs/nfs/blocklayout/blocklayoutdev.c
> +++ b/fs/nfs/blocklayout/blocklayoutdev.c
> @@ -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;
>  }
> diff --git a/fs/nfs/blocklayout/extent_tree.c b/fs/nfs/blocklayout/extent_tree.c
> new file mode 100644
> index 0000000..c7dacfa
> --- /dev/null
> +++ b/fs/nfs/blocklayout/extent_tree.c
> @@ -0,0 +1,545 @@
> +/*
> + * Copyright (c) 2014 Christoph Hellwig.
> + */
> +
> +#include "blocklayout.h"


fs/nfs/blocklayout/extent_tree.c: In function ‘ext_tree_insert’:
include/linux/nfs_fs.h:601:50: error: ‘NFSDBG_FACILITY’ undeclared (first use in this function)
 #  define ifdebug(fac)  if (unlikely(nfs_debug & NFSDBG_##fac))



I think you need this towards the top of the file:
    #define NFSDBG_FACILITY         NFSDBG_PNFS_LD

Anna
> +
> +static inline struct pnfs_block_extent *
> +ext_node(struct rb_node *node)
> +{
> +	return rb_entry(node, struct pnfs_block_extent, be_node);
> +}
> +
> +static struct pnfs_block_extent *
> +ext_tree_first(struct rb_root *root)
> +{
> +	struct rb_node *node = rb_first(root);
> +	return node ? ext_node(node) : NULL;
> +}
> +
> +static struct pnfs_block_extent *
> +ext_tree_prev(struct pnfs_block_extent *be)
> +{
> +	struct rb_node *node = rb_prev(&be->be_node);
> +	return node ? ext_node(node) : NULL;
> +}
> +
> +static struct pnfs_block_extent *
> +ext_tree_next(struct pnfs_block_extent *be)
> +{
> +	struct rb_node *node = rb_next(&be->be_node);
> +	return node ? ext_node(node) : NULL;
> +}
> +
> +static inline sector_t
> +ext_f_end(struct pnfs_block_extent *be)
> +{
> +	return be->be_f_offset + be->be_length;
> +}
> +
> +static struct pnfs_block_extent *
> +__ext_tree_search(struct rb_root *root, sector_t start)
> +{
> +	struct rb_node *node = root->rb_node;
> +	struct pnfs_block_extent *be = NULL;
> +
> +	while (node) {
> +		be = ext_node(node);
> +		if (start < be->be_f_offset)
> +			node = node->rb_left;
> +		else if (start >= ext_f_end(be))
> +			node = node->rb_right;
> +		else
> +			return be;
> +	}
> +
> +	if (be) {
> +		if (start < be->be_f_offset)
> +			return be;
> +
> +		if (start >= ext_f_end(be))
> +			return ext_tree_next(be);
> +	}
> +
> +	return NULL;
> +}
> +
> +static bool
> +ext_can_merge(struct pnfs_block_extent *be1, struct pnfs_block_extent *be2)
> +{
> +	if (be1->be_state != be2->be_state)
> +		return false;
> +	if (be1->be_mdev != be2->be_mdev)
> +		return false;
> +
> +	if (be1->be_f_offset + be1->be_length != be2->be_f_offset)
> +		return false;
> +
> +	if (be1->be_state != PNFS_BLOCK_NONE_DATA &&
> +	    (be1->be_v_offset + be1->be_length != be2->be_v_offset))
> +		return false;
> +
> +	if (be1->be_state == PNFS_BLOCK_INVALID_DATA &&
> +	    be1->be_tag != be2->be_tag)
> +		return false;
> +
> +	return true;
> +}
> +
> +static struct pnfs_block_extent *
> +ext_try_to_merge_left(struct rb_root *root, struct pnfs_block_extent *be)
> +{
> +	struct pnfs_block_extent *left = ext_tree_prev(be);
> +
> +	if (left && ext_can_merge(left, be)) {
> +		left->be_length += be->be_length;
> +		rb_erase(&be->be_node, root);
> +		kfree(be);
> +		return left;
> +	}
> +
> +	return be;
> +}
> +
> +static struct pnfs_block_extent *
> +ext_try_to_merge_right(struct rb_root *root, struct pnfs_block_extent *be)
> +{
> +	struct pnfs_block_extent *right = ext_tree_next(be);
> +
> +	if (right && ext_can_merge(be, right)) {
> +		be->be_length += right->be_length;
> +		rb_erase(&right->be_node, root);
> +		kfree(right);
> +	}
> +
> +	return be;
> +}
> +
> +static void
> +__ext_tree_insert(struct rb_root *root,
> +		struct pnfs_block_extent *new, bool merge_ok)
> +{
> +	struct rb_node **p = &root->rb_node, *parent = NULL;
> +	struct pnfs_block_extent *be;
> +
> +	while (*p) {
> +		parent = *p;
> +		be = ext_node(parent);
> +
> +		if (new->be_f_offset < be->be_f_offset) {
> +			if (merge_ok && ext_can_merge(new, be)) {
> +				be->be_f_offset = new->be_f_offset;
> +				if (be->be_state != PNFS_BLOCK_NONE_DATA)
> +					be->be_v_offset = new->be_v_offset;
> +				be->be_length += new->be_length;
> +				be = ext_try_to_merge_left(root, be);
> +				kfree(new);
> +				return;
> +			}
> +			p = &(*p)->rb_left;
> +		} else if (new->be_f_offset >= ext_f_end(be)) {
> +			if (merge_ok && ext_can_merge(be, new)) {
> +				be->be_length += new->be_length;
> +				be = ext_try_to_merge_right(root, be);
> +				kfree(new);
> +				return;
> +			}
> +			p = &(*p)->rb_right;
> +		} else {
> +			BUG();
> +		}
> +	}
> +
> +	rb_link_node(&new->be_node, parent, p);
> +	rb_insert_color(&new->be_node, root);
> +}
> +
> +static int
> +__ext_tree_remove(struct rb_root *root, sector_t start, sector_t end)
> +{
> +	struct pnfs_block_extent *be;
> +	sector_t len1 = 0, len2 = 0;
> +	sector_t orig_f_offset;
> +	sector_t orig_v_offset;
> +	sector_t orig_len;
> +
> +	be = __ext_tree_search(root, start);
> +	if (!be)
> +		return 0;
> +	if (be->be_f_offset >= end)
> +		return 0;
> +
> +	orig_f_offset = be->be_f_offset;
> +	orig_v_offset = be->be_v_offset;
> +	orig_len = be->be_length;
> +
> +	if (start > be->be_f_offset)
> +		len1 = start - be->be_f_offset;
> +	if (ext_f_end(be) > end)
> +		len2 = ext_f_end(be) - end;
> +
> +	if (len2 > 0) {
> +		if (len1 > 0) {
> +			struct pnfs_block_extent *new;
> +
> +			new = kzalloc(sizeof(*new), GFP_ATOMIC);
> +			if (!new)
> +				return -ENOMEM;
> +
> +			be->be_length = len1;
> +
> +			new->be_f_offset = end;
> +			if (be->be_state != PNFS_BLOCK_NONE_DATA) {
> +				new->be_v_offset =
> +					orig_v_offset + orig_len - len2;
> +			}
> +			new->be_length = len2;
> +			new->be_state = be->be_state;
> +			new->be_tag = be->be_tag;
> +			new->be_mdev = be->be_mdev;
> +			memcpy(&new->be_devid, &be->be_devid,
> +				sizeof(struct nfs4_deviceid));
> +
> +			__ext_tree_insert(root, new, true);
> +		} else {
> +			be->be_f_offset = end;
> +			if (be->be_state != PNFS_BLOCK_NONE_DATA) {
> +				be->be_v_offset =
> +					orig_v_offset + orig_len - len2;
> +			}
> +			be->be_length = len2;
> +		}
> +	} else {
> +		if (len1 > 0) {
> +			be->be_length = len1;
> +			be = ext_tree_next(be);
> +		}
> +
> +		while (be && ext_f_end(be) <= end) {
> +			struct pnfs_block_extent *next = ext_tree_next(be);
> +
> +			rb_erase(&be->be_node, root);
> +			kfree(be);
> +			be = next;
> +		}
> +
> +		if (be && be->be_f_offset < end) {
> +			len1 = ext_f_end(be) - end;
> +			be->be_f_offset = end;
> +			if (be->be_state != PNFS_BLOCK_NONE_DATA)
> +				be->be_v_offset += be->be_length - len1;
> +			be->be_length = len1;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +int
> +ext_tree_insert(struct pnfs_block_layout *bl, struct pnfs_block_extent *new)
> +{
> +	struct pnfs_block_extent *be;
> +	struct rb_root *root;
> +	int err = 0;
> +
> +	switch (new->be_state) {
> +	case PNFS_BLOCK_READWRITE_DATA:
> +	case PNFS_BLOCK_INVALID_DATA:
> +		root = &bl->bl_ext_rw;
> +		break;
> +	case PNFS_BLOCK_READ_DATA:
> +	case PNFS_BLOCK_NONE_DATA:
> +		root = &bl->bl_ext_ro;
> +		break;
> +	default:
> +		dprintk("invalid extent type\n");
> +		return -EINVAL;
> +	}
> +
> +	spin_lock(&bl->bl_ext_lock);
> +retry:
> +	be = __ext_tree_search(root, new->be_f_offset);
> +	if (!be || be->be_f_offset >= ext_f_end(new)) {
> +		__ext_tree_insert(root, new, true);
> +	} else if (new->be_f_offset >= be->be_f_offset) {
> +		if (ext_f_end(new) <= ext_f_end(be)) {
> +			kfree(new);
> +		} else {
> +			sector_t new_len = ext_f_end(new) - ext_f_end(be);
> +			sector_t diff = new->be_length - new_len;
> +
> +			new->be_f_offset += diff;
> +			new->be_v_offset += diff;
> +			new->be_length = new_len;
> +			goto retry;
> +		}
> +	} else if (ext_f_end(new) <= ext_f_end(be)) {
> +		new->be_length = be->be_f_offset - new->be_f_offset;
> +		__ext_tree_insert(root, new, true);
> +	} else {
> +		struct pnfs_block_extent *split;
> +		sector_t new_len = ext_f_end(new) - ext_f_end(be);
> +		sector_t diff = new->be_length - new_len;
> +
> +		split = kmemdup(new, sizeof(*new), GFP_ATOMIC);
> +		if (!split) {
> +			err = -EINVAL;
> +			goto out;
> +		}
> +
> +		split->be_length = be->be_f_offset - split->be_f_offset;
> +		__ext_tree_insert(root, split, true);
> +
> +		new->be_f_offset += diff;
> +		new->be_v_offset += diff;
> +		new->be_length = new_len;
> +		goto retry;
> +	}
> +out:
> +	spin_unlock(&bl->bl_ext_lock);
> +	return err;
> +}
> +
> +static bool
> +__ext_tree_lookup(struct rb_root *root, sector_t isect,
> +		struct pnfs_block_extent *ret)
> +{
> +	struct rb_node *node;
> +	struct pnfs_block_extent *be;
> +
> +	node = root->rb_node;
> +	while (node) {
> +		be = ext_node(node);
> +		if (isect < be->be_f_offset)
> +			node = node->rb_left;
> +		else if (isect >= ext_f_end(be))
> +			node = node->rb_right;
> +		else {
> +			*ret = *be;
> +			return true;
> +		}
> +	}
> +
> +	return false;
> +}
> +
> +bool
> +ext_tree_lookup(struct pnfs_block_layout *bl, sector_t isect,
> +	    struct pnfs_block_extent *ret, bool rw)
> +{
> +	bool found = false;
> +
> +	spin_lock(&bl->bl_ext_lock);
> +	if (!rw)
> +		found = __ext_tree_lookup(&bl->bl_ext_ro, isect, ret);
> +	if (!found)
> +		found = __ext_tree_lookup(&bl->bl_ext_rw, isect, ret);
> +	spin_unlock(&bl->bl_ext_lock);
> +
> +	return found;
> +}
> +
> +int ext_tree_remove(struct pnfs_block_layout *bl, bool rw,
> +		sector_t start, sector_t end)
> +{
> +	int err, err2;
> +
> +	spin_lock(&bl->bl_ext_lock);
> +	err = __ext_tree_remove(&bl->bl_ext_ro, start, end);
> +	if (rw) {
> +		err2 = __ext_tree_remove(&bl->bl_ext_rw, start, end);
> +		if (!err)
> +			err = err2;
> +	}
> +	spin_unlock(&bl->bl_ext_lock);
> +
> +	return err;
> +}
> +
> +static int
> +ext_tree_split(struct rb_root *root, struct pnfs_block_extent *be,
> +		sector_t split)
> +{
> +	struct pnfs_block_extent *new;
> +	sector_t orig_len = be->be_length;
> +
> +	dprintk("%s: need split for 0x%lx:0x%lx at 0x%lx\n",
> +		__func__, be->be_f_offset, ext_f_end(be), split);
> +
> +	new = kzalloc(sizeof(*new), GFP_ATOMIC);
> +	if (!new)
> +		return -ENOMEM;
> +
> +	be->be_length = split - be->be_f_offset;
> +
> +	new->be_f_offset = split;
> +	if (be->be_state != PNFS_BLOCK_NONE_DATA)
> +		new->be_v_offset = be->be_v_offset + be->be_length;
> +	new->be_length = orig_len - be->be_length;
> +	new->be_state = be->be_state;
> +	new->be_tag = be->be_tag;
> +
> +	new->be_mdev = be->be_mdev;
> +	memcpy(&new->be_devid, &be->be_devid, sizeof(struct nfs4_deviceid));
> +
> +	dprintk("%s: got 0x%lx:0x%lx!\n",
> +		__func__, be->be_f_offset, ext_f_end(be));
> +	dprintk("%s: got 0x%lx:0x%lx!\n",
> +		__func__, new->be_f_offset, ext_f_end(new));
> +
> +	__ext_tree_insert(root, new, false);
> +	return 0;
> +}
> +
> +int
> +ext_tree_mark_written(struct pnfs_block_layout *bl, sector_t start,
> +		sector_t len)
> +{
> +	struct rb_root *root = &bl->bl_ext_rw;
> +	sector_t end = start + len;
> +	struct pnfs_block_extent *be;
> +	int err = 0;
> +
> +	spin_lock(&bl->bl_ext_lock);
> +	/*
> +	 * First remove all COW extents or holes from written to range.
> +	 */
> +	err = __ext_tree_remove(&bl->bl_ext_ro, start, end);
> +	if (err)
> +		goto out;
> +
> +	/*
> +	 * Then mark all invalid extents in the range as written to.
> +	 */
> +	for (be = __ext_tree_search(root, start); be; be = ext_tree_next(be)) {
> +		if (be->be_f_offset >= end)
> +			break;
> +
> +		if (be->be_state != PNFS_BLOCK_INVALID_DATA || be->be_tag)
> +			continue;
> +
> +		if (be->be_f_offset < start) {
> +			struct pnfs_block_extent *left = ext_tree_prev(be);
> +
> +			if (left && ext_can_merge(left, be)) {
> +				sector_t diff = start - be->be_f_offset;
> +
> +				left->be_length += diff;
> +
> +				be->be_f_offset += diff;
> +				be->be_v_offset += diff;
> +				be->be_length -= diff;
> +			} else {
> +				err = ext_tree_split(root, be, start);
> +				if (err)
> +					goto out;
> +			}
> +		}
> +
> +		if (ext_f_end(be) > end) {
> +			struct pnfs_block_extent *right = ext_tree_next(be);
> +
> +			if (right && ext_can_merge(be, right)) {
> +				sector_t diff = end - be->be_f_offset;
> +
> +				be->be_length -= diff;
> +
> +				right->be_f_offset -= diff;
> +				right->be_v_offset -= diff;
> +				right->be_length += diff;
> +			} else {
> +				err = ext_tree_split(root, be, end);
> +				if (err)
> +					goto out;
> +			}
> +		}
> +
> +		if (be->be_f_offset >= start && ext_f_end(be) <= end) {
> +			be->be_tag = EXTENT_WRITTEN;
> +			be = ext_try_to_merge_left(root, be);
> +			be = ext_try_to_merge_right(root, be);
> +		}
> +	}
> +out:
> +	spin_unlock(&bl->bl_ext_lock);
> +	return err;
> +}
> +
> +int
> +ext_tree_encode_commit(struct pnfs_block_layout *bl, struct xdr_stream *xdr)
> +{
> +	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__);
> +			ret = -ENOSPC;
> +			break;
> +		}
> +
> +		p = xdr_encode_opaque_fixed(p, be->be_devid.data,
> +				NFS4_DEVICEID4_SIZE);
> +		p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);
> +		p = xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);
> +		p = xdr_encode_hyper(p, 0LL);
> +		*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);
> +
> +	dprintk("%s found %i ranges\n", __func__, count);
> +	return ret;
> +}
> +
> +void
> +ext_tree_mark_committed(struct pnfs_block_layout *bl, int status)
> +{
> +	struct rb_root *root = &bl->bl_ext_rw;
> +	struct pnfs_block_extent *be;
> +
> +	dprintk("%s status %d\n", __func__, status);
> +
> +	spin_lock(&bl->bl_ext_lock);
> +	for (be = ext_tree_first(root); be; be = ext_tree_next(be)) {
> +		if (be->be_state != PNFS_BLOCK_INVALID_DATA ||
> +		    be->be_tag != EXTENT_COMMITTING)
> +			continue;
> +
> +		if (status) {
> +			/*
> +			 * Mark as written and try again.
> +			 *
> +			 * XXX: some real error handling here wouldn't hurt..
> +			 */
> +			be->be_tag = EXTENT_WRITTEN;
> +		} else {
> +			be->be_state = PNFS_BLOCK_READWRITE_DATA;
> +			be->be_tag = 0;
> +		}
> +
> +		be = ext_try_to_merge_left(root, be);
> +		be = ext_try_to_merge_right(root, be);
> +	}
> +	spin_unlock(&bl->bl_ext_lock);
> +}
> diff --git a/fs/nfs/blocklayout/extents.c b/fs/nfs/blocklayout/extents.c
> deleted file mode 100644
> index 4d01614..0000000
> --- a/fs/nfs/blocklayout/extents.c
> +++ /dev/null
> @@ -1,908 +0,0 @@
> -/*
> - *  linux/fs/nfs/blocklayout/blocklayout.h
> - *
> - *  Module for the NFSv4.1 pNFS block layout driver.
> - *
> - *  Copyright (c) 2006 The Regents of the University of Michigan.
> - *  All rights reserved.
> - *
> - *  Andy Adamson <andros@xxxxxxxxxxxxxx>
> - *  Fred Isaman <iisaman@xxxxxxxxx>
> - *
> - * permission is granted to use, copy, create derivative works and
> - * redistribute this software and such derivative works for any purpose,
> - * so long as the name of the university of michigan is not used in
> - * any advertising or publicity pertaining to the use or distribution
> - * of this software without specific, written prior authorization.  if
> - * the above copyright notice or any other identification of the
> - * university of michigan is included in any copy of any portion of
> - * this software, then the disclaimer below must also be included.
> - *
> - * this software is provided as is, without representation from the
> - * university of michigan as to its fitness for any purpose, and without
> - * warranty by the university of michigan of any kind, either express
> - * or implied, including without limitation the implied warranties of
> - * merchantability and fitness for a particular purpose.  the regents
> - * of the university of michigan shall not be liable for any damages,
> - * including special, indirect, incidental, or consequential damages,
> - * with respect to any claim arising out or in connection with the use
> - * of the software, even if it has been or is hereafter advised of the
> - * possibility of such damages.
> - */
> -
> -#include "blocklayout.h"
> -#define NFSDBG_FACILITY         NFSDBG_PNFS_LD
> -
> -/* Bit numbers */
> -#define EXTENT_INITIALIZED 0
> -#define EXTENT_WRITTEN     1
> -#define EXTENT_IN_COMMIT   2
> -#define INTERNAL_EXISTS    MY_MAX_TAGS
> -#define INTERNAL_MASK      ((1 << INTERNAL_EXISTS) - 1)
> -
> -/* Returns largest t<=s s.t. t%base==0 */
> -static inline sector_t normalize(sector_t s, int base)
> -{
> -	sector_t tmp = s; /* Since do_div modifies its argument */
> -	return s - sector_div(tmp, base);
> -}
> -
> -static inline sector_t normalize_up(sector_t s, int base)
> -{
> -	return normalize(s + base - 1, base);
> -}
> -
> -/* Complete stub using list while determine API wanted */
> -
> -/* Returns tags, or negative */
> -static int32_t _find_entry(struct my_tree *tree, u64 s)
> -{
> -	struct pnfs_inval_tracking *pos;
> -
> -	dprintk("%s(%llu) enter\n", __func__, s);
> -	list_for_each_entry_reverse(pos, &tree->mtt_stub, it_link) {
> -		if (pos->it_sector > s)
> -			continue;
> -		else if (pos->it_sector == s)
> -			return pos->it_tags & INTERNAL_MASK;
> -		else
> -			break;
> -	}
> -	return -ENOENT;
> -}
> -
> -static inline
> -int _has_tag(struct my_tree *tree, u64 s, int32_t tag)
> -{
> -	int32_t tags;
> -
> -	dprintk("%s(%llu, %i) enter\n", __func__, s, tag);
> -	s = normalize(s, tree->mtt_step_size);
> -	tags = _find_entry(tree, s);
> -	if ((tags < 0) || !(tags & (1 << tag)))
> -		return 0;
> -	else
> -		return 1;
> -}
> -
> -/* Creates entry with tag, or if entry already exists, unions tag to it.
> - * If storage is not NULL, newly created entry will use it.
> - * Returns number of entries added, or negative on error.
> - */
> -static int _add_entry(struct my_tree *tree, u64 s, int32_t tag,
> -		      struct pnfs_inval_tracking *storage)
> -{
> -	int found = 0;
> -	struct pnfs_inval_tracking *pos;
> -
> -	dprintk("%s(%llu, %i, %p) enter\n", __func__, s, tag, storage);
> -	list_for_each_entry_reverse(pos, &tree->mtt_stub, it_link) {
> -		if (pos->it_sector > s)
> -			continue;
> -		else if (pos->it_sector == s) {
> -			found = 1;
> -			break;
> -		} else
> -			break;
> -	}
> -	if (found) {
> -		pos->it_tags |= (1 << tag);
> -		return 0;
> -	} else {
> -		struct pnfs_inval_tracking *new;
> -		new = storage;
> -		new->it_sector = s;
> -		new->it_tags = (1 << tag);
> -		list_add(&new->it_link, &pos->it_link);
> -		return 1;
> -	}
> -}
> -
> -/* XXXX Really want option to not create */
> -/* Over range, unions tag with existing entries, else creates entry with tag */
> -static int _set_range(struct my_tree *tree, int32_t tag, u64 s, u64 length)
> -{
> -	u64 i;
> -
> -	dprintk("%s(%i, %llu, %llu) enter\n", __func__, tag, s, length);
> -	for (i = normalize(s, tree->mtt_step_size); i < s + length;
> -	     i += tree->mtt_step_size)
> -		if (_add_entry(tree, i, tag, NULL))
> -			return -ENOMEM;
> -	return 0;
> -}
> -
> -/* Ensure that future operations on given range of tree will not malloc */
> -static int _preload_range(struct pnfs_inval_markings *marks,
> -		u64 offset, u64 length)
> -{
> -	u64 start, end, s;
> -	int count, i, used = 0, status = -ENOMEM;
> -	struct pnfs_inval_tracking **storage;
> -	struct my_tree  *tree = &marks->im_tree;
> -
> -	dprintk("%s(%llu, %llu) enter\n", __func__, offset, length);
> -	start = normalize(offset, tree->mtt_step_size);
> -	end = normalize_up(offset + length, tree->mtt_step_size);
> -	count = (int)(end - start) / (int)tree->mtt_step_size;
> -
> -	/* Pre-malloc what memory we might need */
> -	storage = kcalloc(count, sizeof(*storage), GFP_NOFS);
> -	if (!storage)
> -		return -ENOMEM;
> -	for (i = 0; i < count; i++) {
> -		storage[i] = kmalloc(sizeof(struct pnfs_inval_tracking),
> -				     GFP_NOFS);
> -		if (!storage[i])
> -			goto out_cleanup;
> -	}
> -
> -	spin_lock_bh(&marks->im_lock);
> -	for (s = start; s < end; s += tree->mtt_step_size)
> -		used += _add_entry(tree, s, INTERNAL_EXISTS, storage[used]);
> -	spin_unlock_bh(&marks->im_lock);
> -
> -	status = 0;
> -
> - out_cleanup:
> -	for (i = used; i < count; i++) {
> -		if (!storage[i])
> -			break;
> -		kfree(storage[i]);
> -	}
> -	kfree(storage);
> -	return status;
> -}
> -
> -/* We are relying on page lock to serialize this */
> -int bl_is_sector_init(struct pnfs_inval_markings *marks, sector_t isect)
> -{
> -	int rv;
> -
> -	spin_lock_bh(&marks->im_lock);
> -	rv = _has_tag(&marks->im_tree, isect, EXTENT_INITIALIZED);
> -	spin_unlock_bh(&marks->im_lock);
> -	return rv;
> -}
> -
> -/* Assume start, end already sector aligned */
> -static int
> -_range_has_tag(struct my_tree *tree, u64 start, u64 end, int32_t tag)
> -{
> -	struct pnfs_inval_tracking *pos;
> -	u64 expect = 0;
> -
> -	dprintk("%s(%llu, %llu, %i) enter\n", __func__, start, end, tag);
> -	list_for_each_entry_reverse(pos, &tree->mtt_stub, it_link) {
> -		if (pos->it_sector >= end)
> -			continue;
> -		if (!expect) {
> -			if ((pos->it_sector == end - tree->mtt_step_size) &&
> -			    (pos->it_tags & (1 << tag))) {
> -				expect = pos->it_sector - tree->mtt_step_size;
> -				if (pos->it_sector < tree->mtt_step_size || expect < start)
> -					return 1;
> -				continue;
> -			} else {
> -				return 0;
> -			}
> -		}
> -		if (pos->it_sector != expect || !(pos->it_tags & (1 << tag)))
> -			return 0;
> -		expect -= tree->mtt_step_size;
> -		if (expect < start)
> -			return 1;
> -	}
> -	return 0;
> -}
> -
> -static int is_range_written(struct pnfs_inval_markings *marks,
> -			    sector_t start, sector_t end)
> -{
> -	int rv;
> -
> -	spin_lock_bh(&marks->im_lock);
> -	rv = _range_has_tag(&marks->im_tree, start, end, EXTENT_WRITTEN);
> -	spin_unlock_bh(&marks->im_lock);
> -	return rv;
> -}
> -
> -/* Marks sectors in [offest, offset_length) as having been initialized.
> - * All lengths are step-aligned, where step is min(pagesize, blocksize).
> - * Currently assumes offset is page-aligned
> - */
> -int bl_mark_sectors_init(struct pnfs_inval_markings *marks,
> -			     sector_t offset, sector_t length)
> -{
> -	sector_t start, end;
> -
> -	dprintk("%s(offset=%llu,len=%llu) enter\n",
> -		__func__, (u64)offset, (u64)length);
> -
> -	start = normalize(offset, marks->im_block_size);
> -	end = normalize_up(offset + length, marks->im_block_size);
> -	if (_preload_range(marks, start, end - start))
> -		goto outerr;
> -
> -	spin_lock_bh(&marks->im_lock);
> -	if (_set_range(&marks->im_tree, EXTENT_INITIALIZED, offset, length))
> -		goto out_unlock;
> -	spin_unlock_bh(&marks->im_lock);
> -
> -	return 0;
> -
> -out_unlock:
> -	spin_unlock_bh(&marks->im_lock);
> -outerr:
> -	return -ENOMEM;
> -}
> -
> -/* Marks sectors in [offest, offset+length) as having been written to disk.
> - * All lengths should be block aligned.
> - */
> -static int mark_written_sectors(struct pnfs_inval_markings *marks,
> -				sector_t offset, sector_t length)
> -{
> -	int status;
> -
> -	dprintk("%s(offset=%llu,len=%llu) enter\n", __func__,
> -		(u64)offset, (u64)length);
> -	spin_lock_bh(&marks->im_lock);
> -	status = _set_range(&marks->im_tree, EXTENT_WRITTEN, offset, length);
> -	spin_unlock_bh(&marks->im_lock);
> -	return status;
> -}
> -
> -static void print_short_extent(struct pnfs_block_short_extent *be)
> -{
> -	dprintk("PRINT SHORT EXTENT extent %p\n", be);
> -	if (be) {
> -		dprintk("        be_f_offset %llu\n", (u64)be->bse_f_offset);
> -		dprintk("        be_length   %llu\n", (u64)be->bse_length);
> -	}
> -}
> -
> -static void print_clist(struct list_head *list, unsigned int count)
> -{
> -	struct pnfs_block_short_extent *be;
> -	unsigned int i = 0;
> -
> -	ifdebug(FACILITY) {
> -		printk(KERN_DEBUG "****************\n");
> -		printk(KERN_DEBUG "Extent list looks like:\n");
> -		list_for_each_entry(be, list, bse_node) {
> -			i++;
> -			print_short_extent(be);
> -		}
> -		if (i != count)
> -			printk(KERN_DEBUG "\n\nExpected %u entries\n\n\n", count);
> -		printk(KERN_DEBUG "****************\n");
> -	}
> -}
> -
> -/* Note: In theory, we should do more checking that devid's match between
> - * old and new, but if they don't, the lists are too corrupt to salvage anyway.
> - */
> -/* Note this is very similar to bl_add_merge_extent */
> -static void add_to_commitlist(struct pnfs_block_layout *bl,
> -			      struct pnfs_block_short_extent *new)
> -{
> -	struct list_head *clist = &bl->bl_commit;
> -	struct pnfs_block_short_extent *old, *save;
> -	sector_t end = new->bse_f_offset + new->bse_length;
> -
> -	dprintk("%s enter\n", __func__);
> -	print_short_extent(new);
> -	print_clist(clist, bl->bl_count);
> -	bl->bl_count++;
> -	/* Scan for proper place to insert, extending new to the left
> -	 * as much as possible.
> -	 */
> -	list_for_each_entry_safe(old, save, clist, bse_node) {
> -		if (new->bse_f_offset < old->bse_f_offset)
> -			break;
> -		if (end <= old->bse_f_offset + old->bse_length) {
> -			/* Range is already in list */
> -			bl->bl_count--;
> -			kfree(new);
> -			return;
> -		} else if (new->bse_f_offset <=
> -				old->bse_f_offset + old->bse_length) {
> -			/* new overlaps or abuts existing be */
> -			if (new->bse_mdev == old->bse_mdev) {
> -				/* extend new to fully replace old */
> -				new->bse_length += new->bse_f_offset -
> -						old->bse_f_offset;
> -				new->bse_f_offset = old->bse_f_offset;
> -				list_del(&old->bse_node);
> -				bl->bl_count--;
> -				kfree(old);
> -			}
> -		}
> -	}
> -	/* Note that if we never hit the above break, old will not point to a
> -	 * valid extent.  However, in that case &old->bse_node==list.
> -	 */
> -	list_add_tail(&new->bse_node, &old->bse_node);
> -	/* Scan forward for overlaps.  If we find any, extend new and
> -	 * remove the overlapped extent.
> -	 */
> -	old = list_prepare_entry(new, clist, bse_node);
> -	list_for_each_entry_safe_continue(old, save, clist, bse_node) {
> -		if (end < old->bse_f_offset)
> -			break;
> -		/* new overlaps or abuts old */
> -		if (new->bse_mdev == old->bse_mdev) {
> -			if (end < old->bse_f_offset + old->bse_length) {
> -				/* extend new to fully cover old */
> -				end = old->bse_f_offset + old->bse_length;
> -				new->bse_length = end - new->bse_f_offset;
> -			}
> -			list_del(&old->bse_node);
> -			bl->bl_count--;
> -			kfree(old);
> -		}
> -	}
> -	dprintk("%s: after merging\n", __func__);
> -	print_clist(clist, bl->bl_count);
> -}
> -
> -/* Note the range described by offset, length is guaranteed to be contained
> - * within be.
> - * new will be freed, either by this function or add_to_commitlist if they
> - * decide not to use it, or after LAYOUTCOMMIT uses it in the commitlist.
> - */
> -int bl_mark_for_commit(struct pnfs_block_extent *be,
> -		    sector_t offset, sector_t length,
> -		    struct pnfs_block_short_extent *new)
> -{
> -	sector_t new_end, end = offset + length;
> -	struct pnfs_block_layout *bl = container_of(be->be_inval,
> -						    struct pnfs_block_layout,
> -						    bl_inval);
> -
> -	mark_written_sectors(be->be_inval, offset, length);
> -	/* We want to add the range to commit list, but it must be
> -	 * block-normalized, and verified that the normalized range has
> -	 * been entirely written to disk.
> -	 */
> -	new->bse_f_offset = offset;
> -	offset = normalize(offset, bl->bl_blocksize);
> -	if (offset < new->bse_f_offset) {
> -		if (is_range_written(be->be_inval, offset, new->bse_f_offset))
> -			new->bse_f_offset = offset;
> -		else
> -			new->bse_f_offset = offset + bl->bl_blocksize;
> -	}
> -	new_end = normalize_up(end, bl->bl_blocksize);
> -	if (end < new_end) {
> -		if (is_range_written(be->be_inval, end, new_end))
> -			end = new_end;
> -		else
> -			end = new_end - bl->bl_blocksize;
> -	}
> -	if (end <= new->bse_f_offset) {
> -		kfree(new);
> -		return 0;
> -	}
> -	new->bse_length = end - new->bse_f_offset;
> -	new->bse_devid = be->be_devid;
> -	new->bse_mdev = be->be_mdev;
> -
> -	spin_lock(&bl->bl_ext_lock);
> -	add_to_commitlist(bl, new);
> -	spin_unlock(&bl->bl_ext_lock);
> -	return 0;
> -}
> -
> -static void print_bl_extent(struct pnfs_block_extent *be)
> -{
> -	dprintk("PRINT EXTENT extent %p\n", be);
> -	if (be) {
> -		dprintk("        be_f_offset %llu\n", (u64)be->be_f_offset);
> -		dprintk("        be_length   %llu\n", (u64)be->be_length);
> -		dprintk("        be_v_offset %llu\n", (u64)be->be_v_offset);
> -		dprintk("        be_state    %d\n", be->be_state);
> -	}
> -}
> -
> -static void
> -destroy_extent(struct kref *kref)
> -{
> -	struct pnfs_block_extent *be;
> -
> -	be = container_of(kref, struct pnfs_block_extent, be_refcnt);
> -	dprintk("%s be=%p\n", __func__, be);
> -	kfree(be);
> -}
> -
> -void
> -bl_put_extent(struct pnfs_block_extent *be)
> -{
> -	if (be) {
> -		dprintk("%s enter %p (%i)\n", __func__, be,
> -			atomic_read(&be->be_refcnt.refcount));
> -		kref_put(&be->be_refcnt, destroy_extent);
> -	}
> -}
> -
> -struct pnfs_block_extent *bl_alloc_extent(void)
> -{
> -	struct pnfs_block_extent *be;
> -
> -	be = kmalloc(sizeof(struct pnfs_block_extent), GFP_NOFS);
> -	if (!be)
> -		return NULL;
> -	INIT_LIST_HEAD(&be->be_node);
> -	kref_init(&be->be_refcnt);
> -	be->be_inval = NULL;
> -	return be;
> -}
> -
> -static void print_elist(struct list_head *list)
> -{
> -	struct pnfs_block_extent *be;
> -	dprintk("****************\n");
> -	dprintk("Extent list looks like:\n");
> -	list_for_each_entry(be, list, be_node) {
> -		print_bl_extent(be);
> -	}
> -	dprintk("****************\n");
> -}
> -
> -static inline int
> -extents_consistent(struct pnfs_block_extent *old, struct pnfs_block_extent *new)
> -{
> -	/* Note this assumes new->be_f_offset >= old->be_f_offset */
> -	return (new->be_state == old->be_state) &&
> -		((new->be_state == PNFS_BLOCK_NONE_DATA) ||
> -		 ((new->be_v_offset - old->be_v_offset ==
> -		   new->be_f_offset - old->be_f_offset) &&
> -		  new->be_mdev == old->be_mdev));
> -}
> -
> -/* Adds new to appropriate list in bl, modifying new and removing existing
> - * extents as appropriate to deal with overlaps.
> - *
> - * See bl_find_get_extent for list constraints.
> - *
> - * Refcount on new is already set.  If end up not using it, or error out,
> - * need to put the reference.
> - *
> - * bl->bl_ext_lock is held by caller.
> - */
> -int
> -bl_add_merge_extent(struct pnfs_block_layout *bl,
> -		     struct pnfs_block_extent *new)
> -{
> -	struct pnfs_block_extent *be, *tmp;
> -	sector_t end = new->be_f_offset + new->be_length;
> -	struct list_head *list;
> -
> -	dprintk("%s enter with be=%p\n", __func__, new);
> -	print_bl_extent(new);
> -	list = &bl->bl_extents[bl_choose_list(new->be_state)];
> -	print_elist(list);
> -
> -	/* Scan for proper place to insert, extending new to the left
> -	 * as much as possible.
> -	 */
> -	list_for_each_entry_safe_reverse(be, tmp, list, be_node) {
> -		if (new->be_f_offset >= be->be_f_offset + be->be_length)
> -			break;
> -		if (new->be_f_offset >= be->be_f_offset) {
> -			if (end <= be->be_f_offset + be->be_length) {
> -				/* new is a subset of existing be*/
> -				if (extents_consistent(be, new)) {
> -					dprintk("%s: new is subset, ignoring\n",
> -						__func__);
> -					bl_put_extent(new);
> -					return 0;
> -				} else {
> -					goto out_err;
> -				}
> -			} else {
> -				/* |<--   be   -->|
> -				 *          |<--   new   -->| */
> -				if (extents_consistent(be, new)) {
> -					/* extend new to fully replace be */
> -					new->be_length += new->be_f_offset -
> -						be->be_f_offset;
> -					new->be_f_offset = be->be_f_offset;
> -					new->be_v_offset = be->be_v_offset;
> -					dprintk("%s: removing %p\n", __func__, be);
> -					list_del(&be->be_node);
> -					bl_put_extent(be);
> -				} else {
> -					goto out_err;
> -				}
> -			}
> -		} else if (end >= be->be_f_offset + be->be_length) {
> -			/* new extent overlap existing be */
> -			if (extents_consistent(be, new)) {
> -				/* extend new to fully replace be */
> -				dprintk("%s: removing %p\n", __func__, be);
> -				list_del(&be->be_node);
> -				bl_put_extent(be);
> -			} else {
> -				goto out_err;
> -			}
> -		} else if (end > be->be_f_offset) {
> -			/*           |<--   be   -->|
> -			 *|<--   new   -->| */
> -			if (extents_consistent(new, be)) {
> -				/* extend new to fully replace be */
> -				new->be_length += be->be_f_offset + be->be_length -
> -					new->be_f_offset - new->be_length;
> -				dprintk("%s: removing %p\n", __func__, be);
> -				list_del(&be->be_node);
> -				bl_put_extent(be);
> -			} else {
> -				goto out_err;
> -			}
> -		}
> -	}
> -	/* Note that if we never hit the above break, be will not point to a
> -	 * valid extent.  However, in that case &be->be_node==list.
> -	 */
> -	list_add(&new->be_node, &be->be_node);
> -	dprintk("%s: inserting new\n", __func__);
> -	print_elist(list);
> -	/* FIXME - The per-list consistency checks have all been done,
> -	 * should now check cross-list consistency.
> -	 */
> -	return 0;
> -
> - out_err:
> -	bl_put_extent(new);
> -	return -EIO;
> -}
> -
> -/* Returns extent, or NULL.  If a second READ extent exists, it is returned
> - * in cow_read, if given.
> - *
> - * The extents are kept in two seperate ordered lists, one for READ and NONE,
> - * one for READWRITE and INVALID.  Within each list, we assume:
> - * 1. Extents are ordered by file offset.
> - * 2. For any given isect, there is at most one extents that matches.
> - */
> -struct pnfs_block_extent *
> -bl_find_get_extent(struct pnfs_block_layout *bl, sector_t isect,
> -	    struct pnfs_block_extent **cow_read)
> -{
> -	struct pnfs_block_extent *be, *cow, *ret;
> -	int i;
> -
> -	dprintk("%s enter with isect %llu\n", __func__, (u64)isect);
> -	cow = ret = NULL;
> -	spin_lock(&bl->bl_ext_lock);
> -	for (i = 0; i < EXTENT_LISTS; i++) {
> -		list_for_each_entry_reverse(be, &bl->bl_extents[i], be_node) {
> -			if (isect >= be->be_f_offset + be->be_length)
> -				break;
> -			if (isect >= be->be_f_offset) {
> -				/* We have found an extent */
> -				dprintk("%s Get %p (%i)\n", __func__, be,
> -					atomic_read(&be->be_refcnt.refcount));
> -				kref_get(&be->be_refcnt);
> -				if (!ret)
> -					ret = be;
> -				else if (be->be_state != PNFS_BLOCK_READ_DATA)
> -					bl_put_extent(be);
> -				else
> -					cow = be;
> -				break;
> -			}
> -		}
> -		if (ret &&
> -		    (!cow_read || ret->be_state != PNFS_BLOCK_INVALID_DATA))
> -			break;
> -	}
> -	spin_unlock(&bl->bl_ext_lock);
> -	if (cow_read)
> -		*cow_read = cow;
> -	print_bl_extent(ret);
> -	return ret;
> -}
> -
> -/* Similar to bl_find_get_extent, but called with lock held, and ignores cow */
> -static struct pnfs_block_extent *
> -bl_find_get_extent_locked(struct pnfs_block_layout *bl, sector_t isect)
> -{
> -	struct pnfs_block_extent *be, *ret = NULL;
> -	int i;
> -
> -	dprintk("%s enter with isect %llu\n", __func__, (u64)isect);
> -	for (i = 0; i < EXTENT_LISTS; i++) {
> -		if (ret)
> -			break;
> -		list_for_each_entry_reverse(be, &bl->bl_extents[i], be_node) {
> -			if (isect >= be->be_f_offset + be->be_length)
> -				break;
> -			if (isect >= be->be_f_offset) {
> -				/* We have found an extent */
> -				dprintk("%s Get %p (%i)\n", __func__, be,
> -					atomic_read(&be->be_refcnt.refcount));
> -				kref_get(&be->be_refcnt);
> -				ret = be;
> -				break;
> -			}
> -		}
> -	}
> -	print_bl_extent(ret);
> -	return ret;
> -}
> -
> -int
> -encode_pnfs_block_layoutupdate(struct pnfs_block_layout *bl,
> -			       struct xdr_stream *xdr,
> -			       const struct nfs4_layoutcommit_args *arg)
> -{
> -	struct pnfs_block_short_extent *lce, *save;
> -	unsigned int count = 0;
> -	__be32 *p, *xdr_start;
> -
> -	dprintk("%s enter\n", __func__);
> -	/* BUG - creation of bl_commit is buggy - need to wait for
> -	 * entire block to be marked WRITTEN before it can be added.
> -	 */
> -	spin_lock(&bl->bl_ext_lock);
> -	/* Want to adjust for possible truncate */
> -	/* We now want to adjust argument range */
> -
> -	/* XDR encode the ranges found */
> -	xdr_start = xdr_reserve_space(xdr, 8);
> -	if (!xdr_start)
> -		goto out;
> -	list_for_each_entry_safe(lce, save, &bl->bl_commit, bse_node) {
> -		p = xdr_reserve_space(xdr, 7 * 4 + sizeof(lce->bse_devid.data));
> -		if (!p)
> -			break;
> -		p = xdr_encode_opaque_fixed(p, lce->bse_devid.data, NFS4_DEVICEID4_SIZE);
> -		p = xdr_encode_hyper(p, lce->bse_f_offset << SECTOR_SHIFT);
> -		p = xdr_encode_hyper(p, lce->bse_length << SECTOR_SHIFT);
> -		p = xdr_encode_hyper(p, 0LL);
> -		*p++ = cpu_to_be32(PNFS_BLOCK_READWRITE_DATA);
> -		list_move_tail(&lce->bse_node, &bl->bl_committing);
> -		bl->bl_count--;
> -		count++;
> -	}
> -	xdr_start[0] = cpu_to_be32((xdr->p - xdr_start - 1) * 4);
> -	xdr_start[1] = cpu_to_be32(count);
> -out:
> -	spin_unlock(&bl->bl_ext_lock);
> -	dprintk("%s found %i ranges\n", __func__, count);
> -	return 0;
> -}
> -
> -/* Helper function to set_to_rw that initialize a new extent */
> -static void
> -_prep_new_extent(struct pnfs_block_extent *new,
> -		 struct pnfs_block_extent *orig,
> -		 sector_t offset, sector_t length, int state)
> -{
> -	kref_init(&new->be_refcnt);
> -	/* don't need to INIT_LIST_HEAD(&new->be_node) */
> -	memcpy(&new->be_devid, &orig->be_devid, sizeof(struct nfs4_deviceid));
> -	new->be_mdev = orig->be_mdev;
> -	new->be_f_offset = offset;
> -	new->be_length = length;
> -	new->be_v_offset = orig->be_v_offset - orig->be_f_offset + offset;
> -	new->be_state = state;
> -	new->be_inval = orig->be_inval;
> -}
> -
> -/* Tries to merge be with extent in front of it in list.
> - * Frees storage if not used.
> - */
> -static struct pnfs_block_extent *
> -_front_merge(struct pnfs_block_extent *be, struct list_head *head,
> -	     struct pnfs_block_extent *storage)
> -{
> -	struct pnfs_block_extent *prev;
> -
> -	if (!storage)
> -		goto no_merge;
> -	if (&be->be_node == head || be->be_node.prev == head)
> -		goto no_merge;
> -	prev = list_entry(be->be_node.prev, struct pnfs_block_extent, be_node);
> -	if ((prev->be_f_offset + prev->be_length != be->be_f_offset) ||
> -	    !extents_consistent(prev, be))
> -		goto no_merge;
> -	_prep_new_extent(storage, prev, prev->be_f_offset,
> -			 prev->be_length + be->be_length, prev->be_state);
> -	list_replace(&prev->be_node, &storage->be_node);
> -	bl_put_extent(prev);
> -	list_del(&be->be_node);
> -	bl_put_extent(be);
> -	return storage;
> -
> - no_merge:
> -	kfree(storage);
> -	return be;
> -}
> -
> -static u64
> -set_to_rw(struct pnfs_block_layout *bl, u64 offset, u64 length)
> -{
> -	u64 rv = offset + length;
> -	struct pnfs_block_extent *be, *e1, *e2, *e3, *new, *old;
> -	struct pnfs_block_extent *children[3];
> -	struct pnfs_block_extent *merge1 = NULL, *merge2 = NULL;
> -	int i = 0, j;
> -
> -	dprintk("%s(%llu, %llu)\n", __func__, offset, length);
> -	/* Create storage for up to three new extents e1, e2, e3 */
> -	e1 = kmalloc(sizeof(*e1), GFP_ATOMIC);
> -	e2 = kmalloc(sizeof(*e2), GFP_ATOMIC);
> -	e3 = kmalloc(sizeof(*e3), GFP_ATOMIC);
> -	/* BUG - we are ignoring any failure */
> -	if (!e1 || !e2 || !e3)
> -		goto out_nosplit;
> -
> -	spin_lock(&bl->bl_ext_lock);
> -	be = bl_find_get_extent_locked(bl, offset);
> -	rv = be->be_f_offset + be->be_length;
> -	if (be->be_state != PNFS_BLOCK_INVALID_DATA) {
> -		spin_unlock(&bl->bl_ext_lock);
> -		goto out_nosplit;
> -	}
> -	/* Add e* to children, bumping e*'s krefs */
> -	if (be->be_f_offset != offset) {
> -		_prep_new_extent(e1, be, be->be_f_offset,
> -				 offset - be->be_f_offset,
> -				 PNFS_BLOCK_INVALID_DATA);
> -		children[i++] = e1;
> -		print_bl_extent(e1);
> -	} else
> -		merge1 = e1;
> -	_prep_new_extent(e2, be, offset,
> -			 min(length, be->be_f_offset + be->be_length - offset),
> -			 PNFS_BLOCK_READWRITE_DATA);
> -	children[i++] = e2;
> -	print_bl_extent(e2);
> -	if (offset + length < be->be_f_offset + be->be_length) {
> -		_prep_new_extent(e3, be, e2->be_f_offset + e2->be_length,
> -				 be->be_f_offset + be->be_length -
> -				 offset - length,
> -				 PNFS_BLOCK_INVALID_DATA);
> -		children[i++] = e3;
> -		print_bl_extent(e3);
> -	} else
> -		merge2 = e3;
> -
> -	/* Remove be from list, and insert the e* */
> -	/* We don't get refs on e*, since this list is the base reference
> -	 * set when init'ed.
> -	 */
> -	if (i < 3)
> -		children[i] = NULL;
> -	new = children[0];
> -	list_replace(&be->be_node, &new->be_node);
> -	bl_put_extent(be);
> -	new = _front_merge(new, &bl->bl_extents[RW_EXTENT], merge1);
> -	for (j = 1; j < i; j++) {
> -		old = new;
> -		new = children[j];
> -		list_add(&new->be_node, &old->be_node);
> -	}
> -	if (merge2) {
> -		/* This is a HACK, should just create a _back_merge function */
> -		new = list_entry(new->be_node.next,
> -				 struct pnfs_block_extent, be_node);
> -		new = _front_merge(new, &bl->bl_extents[RW_EXTENT], merge2);
> -	}
> -	spin_unlock(&bl->bl_ext_lock);
> -
> -	/* Since we removed the base reference above, be is now scheduled for
> -	 * destruction.
> -	 */
> -	bl_put_extent(be);
> -	dprintk("%s returns %llu after split\n", __func__, rv);
> -	return rv;
> -
> - out_nosplit:
> -	kfree(e1);
> -	kfree(e2);
> -	kfree(e3);
> -	dprintk("%s returns %llu without splitting\n", __func__, rv);
> -	return rv;
> -}
> -
> -void
> -clean_pnfs_block_layoutupdate(struct pnfs_block_layout *bl,
> -			      const struct nfs4_layoutcommit_args *arg,
> -			      int status)
> -{
> -	struct pnfs_block_short_extent *lce, *save;
> -
> -	dprintk("%s status %d\n", __func__, status);
> -	list_for_each_entry_safe(lce, save, &bl->bl_committing, bse_node) {
> -		if (likely(!status)) {
> -			u64 offset = lce->bse_f_offset;
> -			u64 end = offset + lce->bse_length;
> -
> -			do {
> -				offset = set_to_rw(bl, offset, end - offset);
> -			} while (offset < end);
> -			list_del(&lce->bse_node);
> -
> -			kfree(lce);
> -		} else {
> -			list_del(&lce->bse_node);
> -			spin_lock(&bl->bl_ext_lock);
> -			add_to_commitlist(bl, lce);
> -			spin_unlock(&bl->bl_ext_lock);
> -		}
> -	}
> -}
> -
> -int bl_push_one_short_extent(struct pnfs_inval_markings *marks)
> -{
> -	struct pnfs_block_short_extent *new;
> -
> -	new = kmalloc(sizeof(*new), GFP_NOFS);
> -	if (unlikely(!new))
> -		return -ENOMEM;
> -
> -	spin_lock_bh(&marks->im_lock);
> -	list_add(&new->bse_node, &marks->im_extents);
> -	spin_unlock_bh(&marks->im_lock);
> -
> -	return 0;
> -}
> -
> -struct pnfs_block_short_extent *
> -bl_pop_one_short_extent(struct pnfs_inval_markings *marks)
> -{
> -	struct pnfs_block_short_extent *rv = NULL;
> -
> -	spin_lock_bh(&marks->im_lock);
> -	if (!list_empty(&marks->im_extents)) {
> -		rv = list_entry((&marks->im_extents)->next,
> -				struct pnfs_block_short_extent, bse_node);
> -		list_del_init(&rv->bse_node);
> -	}
> -	spin_unlock_bh(&marks->im_lock);
> -
> -	return rv;
> -}
> -
> -void bl_free_short_extents(struct pnfs_inval_markings *marks, int num_to_free)
> -{
> -	struct pnfs_block_short_extent *se = NULL, *tmp;
> -
> -	if (num_to_free <= 0)
> -		return;
> -
> -	spin_lock(&marks->im_lock);
> -	list_for_each_entry_safe(se, tmp, &marks->im_extents, bse_node) {
> -		list_del(&se->bse_node);
> -		kfree(se);
> -		if (--num_to_free == 0)
> -			break;
> -	}
> -	spin_unlock(&marks->im_lock);
> -
> -	BUG_ON(num_to_free > 0);
> -}

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




[Index of Archives]     [Linux Filesystem Development]     [Linux USB Development]     [Linux Media Development]     [Video for Linux]     [Linux NILFS]     [Linux Audio Users]     [Yosemite Info]     [Linux SCSI]

  Powered by Linux