Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d0082371 authored by Jeff Mahoney's avatar Jeff Mahoney Committed by David Sterba
Browse files

btrfs: drop gfp_t from lock_extent 



 lock_extent and unlock_extent are always called with GFP_NOFS, drop the
 argument and use GFP_NOFS consistently.

Signed-off-by: default avatarJeff Mahoney <jeffm@suse.com>
parent 143bede5

fs/btrfs/compression.c

+3 −3
Original line number Diff line number Diff line
@@ -496,7 +496,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
		 * sure they map to this compressed extent on disk.

		 */

		set_page_extent_mapped(page);

		lock_extent(tree, last_offset, end, GFP_NOFS);

		lock_extent(tree, last_offset, end);

		read_lock(&em_tree->lock);

		em = lookup_extent_mapping(em_tree, last_offset,

					   PAGE_CACHE_SIZE);
@@ -506,7 +506,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
		    (last_offset + PAGE_CACHE_SIZE > extent_map_end(em)) ||

		    (em->block_start >> 9) != cb->orig_bio->bi_sector) {

			free_extent_map(em);

			unlock_extent(tree, last_offset, end, GFP_NOFS);

			unlock_extent(tree, last_offset, end);

			unlock_page(page);

			page_cache_release(page);

			break;
@@ -534,7 +534,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
			nr_pages++;

			page_cache_release(page);

		} else {

			unlock_extent(tree, last_offset, end, GFP_NOFS);

			unlock_extent(tree, last_offset, end);

			unlock_page(page);

			page_cache_release(page);

			break;

fs/btrfs/disk-io.c

+1 −1
Original line number Diff line number Diff line
@@ -332,7 +332,7 @@ static int verify_parent_transid(struct extent_io_tree *io_tree, 
		return 0;



	lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,

			 0, &cached_state, GFP_NOFS);

			 0, &cached_state);

	if (extent_buffer_uptodate(io_tree, eb, cached_state) &&

	    btrfs_header_generation(eb) == parent_transid) {

		ret = 0;

fs/btrfs/extent_io.c

+19 −22
Original line number Diff line number Diff line
@@ -1171,42 +1171,40 @@ static int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, 
 * us if waiting is desired.

 */

int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,

		     int bits, struct extent_state **cached_state, gfp_t mask)

		     int bits, struct extent_state **cached_state)

{

	int err;

	u64 failed_start;

	while (1) {

		err = set_extent_bit(tree, start, end, EXTENT_LOCKED | bits,

				     EXTENT_LOCKED, &failed_start,

				     cached_state, mask);

		if (err == -EEXIST && (mask & __GFP_WAIT)) {

				     cached_state, GFP_NOFS);

		if (err == -EEXIST) {

			wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED);

			start = failed_start;

		} else {

		} else

			break;

		}

		WARN_ON(start > end);

	}

	return err;

}



int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask)

int lock_extent(struct extent_io_tree *tree, u64 start, u64 end)

{

	return lock_extent_bits(tree, start, end, 0, NULL, mask);

	return lock_extent_bits(tree, start, end, 0, NULL);

}



int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end,

		    gfp_t mask)

int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end)

{

	int err;

	u64 failed_start;



	err = set_extent_bit(tree, start, end, EXTENT_LOCKED, EXTENT_LOCKED,

			     &failed_start, NULL, mask);

			     &failed_start, NULL, GFP_NOFS);

	if (err == -EEXIST) {

		if (failed_start > start)

			clear_extent_bit(tree, start, failed_start - 1,

					 EXTENT_LOCKED, 1, 0, NULL, mask);

					 EXTENT_LOCKED, 1, 0, NULL, GFP_NOFS);

		return 0;

	}

	return 1;
@@ -1219,10 +1217,10 @@ int unlock_extent_cached(struct extent_io_tree *tree, u64 start, u64 end, 
				mask);

}



int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask)

int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end)

{

	return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, NULL,

				mask);

				GFP_NOFS);

}



/*
@@ -1518,8 +1516,7 @@ static noinline u64 find_lock_delalloc_range(struct inode *inode, 
	BUG_ON(ret);



	/* step three, lock the state bits for the whole range */

	lock_extent_bits(tree, delalloc_start, delalloc_end,

			 0, &cached_state, GFP_NOFS);

	lock_extent_bits(tree, delalloc_start, delalloc_end, 0, &cached_state);



	/* then test to make sure it is all still delalloc */

	ret = test_range_bit(tree, delalloc_start, delalloc_end,
@@ -2557,11 +2554,11 @@ static int __extent_read_full_page(struct extent_io_tree *tree, 


	end = page_end;

	while (1) {

		lock_extent(tree, start, end, GFP_NOFS);

		lock_extent(tree, start, end);

		ordered = btrfs_lookup_ordered_extent(inode, start);

		if (!ordered)

			break;

		unlock_extent(tree, start, end, GFP_NOFS);

		unlock_extent(tree, start, end);

		btrfs_start_ordered_extent(inode, ordered, 1);

		btrfs_put_ordered_extent(ordered);

	}
@@ -2598,7 +2595,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree, 
				end - cur + 1, 0);

		if (IS_ERR_OR_NULL(em)) {

			SetPageError(page);

			unlock_extent(tree, cur, end, GFP_NOFS);

			unlock_extent(tree, cur, end);

			break;

		}

		extent_offset = cur - em->start;
@@ -2650,7 +2647,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree, 
		if (test_range_bit(tree, cur, cur_end,

				   EXTENT_UPTODATE, 1, NULL)) {

			check_page_uptodate(tree, page);

			unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS);

			unlock_extent(tree, cur, cur + iosize - 1);

			cur = cur + iosize;

			pg_offset += iosize;

			continue;
@@ -2660,7 +2657,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree, 
		 */

		if (block_start == EXTENT_MAP_INLINE) {

			SetPageError(page);

			unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS);

			unlock_extent(tree, cur, cur + iosize - 1);

			cur = cur + iosize;

			pg_offset += iosize;

			continue;
@@ -3274,7 +3271,7 @@ int extent_invalidatepage(struct extent_io_tree *tree, 
	if (start > end)

		return 0;



	lock_extent_bits(tree, start, end, 0, &cached_state, GFP_NOFS);

	lock_extent_bits(tree, start, end, 0, &cached_state);

	wait_on_page_writeback(page);

	clear_extent_bit(tree, start, end,

			 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
@@ -3488,7 +3485,7 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 
	}



	lock_extent_bits(&BTRFS_I(inode)->io_tree, start, start + len, 0,

			 &cached_state, GFP_NOFS);

			 &cached_state);



	em = get_extent_skip_holes(inode, start, last_for_get_extent,

				   get_extent);

fs/btrfs/extent_io.h

+4 −5
Original line number Diff line number Diff line
@@ -182,14 +182,13 @@ int try_release_extent_buffer(struct extent_io_tree *tree, struct page *page); 
int try_release_extent_state(struct extent_map_tree *map,

			     struct extent_io_tree *tree, struct page *page,

			     gfp_t mask);

int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask);

int lock_extent(struct extent_io_tree *tree, u64 start, u64 end);

int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,

		     int bits, struct extent_state **cached, gfp_t mask);

int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask);

		     int bits, struct extent_state **cached);

int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end);

int unlock_extent_cached(struct extent_io_tree *tree, u64 start, u64 end,

			 struct extent_state **cached, gfp_t mask);

int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end,

		    gfp_t mask);

int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end);

int extent_read_full_page(struct extent_io_tree *tree, struct page *page,

			  get_extent_t *get_extent, int mirror_num);

int __init extent_io_init(void);

fs/btrfs/file.c

+3 −4
Original line number Diff line number Diff line
@@ -1105,8 +1105,7 @@ static noinline int prepare_pages(struct btrfs_root *root, struct file *file, 
	if (start_pos < inode->i_size) {

		struct btrfs_ordered_extent *ordered;

		lock_extent_bits(&BTRFS_I(inode)->io_tree,

				 start_pos, last_pos - 1, 0, &cached_state,

				 GFP_NOFS);

				 start_pos, last_pos - 1, 0, &cached_state);

		ordered = btrfs_lookup_first_ordered_extent(inode,

							    last_pos - 1);

		if (ordered &&
@@ -1638,7 +1637,7 @@ static long btrfs_fallocate(struct file *file, int mode, 
		 * transaction

		 */

		lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,

				 locked_end, 0, &cached_state, GFP_NOFS);

				 locked_end, 0, &cached_state);

		ordered = btrfs_lookup_first_ordered_extent(inode,

							    alloc_end - 1);

		if (ordered &&
@@ -1737,7 +1736,7 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int origin) 
		return -ENXIO;



	lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, 0,

			 &cached_state, GFP_NOFS);

			 &cached_state);



	/*

	 * Delalloc is such a pain.  If we have a hole and we have pending