pnfs/blocklayout: rewrite extent tracking (8067253c) · Commits · 戴 / test

fs/nfs/blocklayout/Makefile

+2 −1

Original line number	Diff line number	Diff line
		@@ -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

Original line number	Diff line number	Diff line
		@@ -49,26 +49,16 @@ MODULE_LICENSE("GPL");
		MODULE_AUTHOR("Andy Adamson <andros@citi.umich.edu>");
		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)
		static bool is_hole(struct pnfs_block_extent *be)
		{
		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);
		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;
		}

		/* 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)
		{
		return (be->be_state == PNFS_BLOCK_READWRITE_DATA \|\|
		be->be_state == PNFS_BLOCK_INVALID_DATA);
		}

		/* 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)

fs/nfs/blocklayout/blocklayout.h

+23 −89

Original line number	Diff line number	Diff line
		@@ -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 */
		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 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,
		/* extent_tree.c */
		int ext_tree_insert(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);
		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 */

fs/nfs/blocklayout/blocklayoutdev.c

+13 −22

Original line number	Diff line number	Diff line
		@@ -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

0 → 100644

+547 −0

File added.

Preview size limit exceeded, changes collapsed.

Admin message