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

Commit bbe08c0a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus-4.11' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs 

Pull more btrfs updates from Chris Mason:
 "Btrfs round two.

  These are mostly a continuation of Dave Sterba's collection of
  cleanups, but Filipe also has some bug fixes and performance
  improvements"

* 'for-linus-4.11' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (69 commits)
  btrfs: add dummy callback for readpage_io_failed and drop checks
  btrfs: drop checks for mandatory extent_io_ops callbacks
  btrfs: document existence of extent_io ops callbacks
  btrfs: let writepage_end_io_hook return void
  btrfs: do proper error handling in btrfs_insert_xattr_item
  btrfs: handle allocation error in update_dev_stat_item
  btrfs: remove BUG_ON from __tree_mod_log_insert
  btrfs: derive maximum output size in the compression implementation
  btrfs: use predefined limits for calculating maximum number of pages for compression
  btrfs: export compression buffer limits in a header
  btrfs: merge nr_pages input and output parameter in compress_pages
  btrfs: merge length input and output parameter in compress_pages
  btrfs: constify name of subvolume in creation helpers
  btrfs: constify buffers used by compression helpers
  btrfs: constify input buffer of btrfs_csum_data
  btrfs: constify device path passed to relevant helpers
  btrfs: make btrfs_inode_resume_unlocked_dio take btrfs_inode
  btrfs: make btrfs_inode_block_unlocked_dio take btrfs_inode
  btrfs: Make btrfs_add_nondir take btrfs_inode
  btrfs: Make btrfs_add_link take btrfs_inode
  ...
parents 94e877d0 e9f467d0

fs/btrfs/btrfs_inode.h

+15 −16
Original line number Diff line number Diff line
@@ -237,20 +237,20 @@ static inline u64 btrfs_ino(struct btrfs_inode *inode) 
	return ino;

}



static inline void btrfs_i_size_write(struct inode *inode, u64 size)

static inline void btrfs_i_size_write(struct btrfs_inode *inode, u64 size)

{

	i_size_write(inode, size);

	BTRFS_I(inode)->disk_i_size = size;

	i_size_write(&inode->vfs_inode, size);

	inode->disk_i_size = size;

}



static inline bool btrfs_is_free_space_inode(struct inode *inode)

static inline bool btrfs_is_free_space_inode(struct btrfs_inode *inode)

{

	struct btrfs_root *root = BTRFS_I(inode)->root;

	struct btrfs_root *root = inode->root;



	if (root == root->fs_info->tree_root &&

	    btrfs_ino(BTRFS_I(inode)) != BTRFS_BTREE_INODE_OBJECTID)

	    btrfs_ino(inode) != BTRFS_BTREE_INODE_OBJECTID)

		return true;

	if (BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID)

	if (inode->location.objectid == BTRFS_FREE_INO_OBJECTID)

		return true;

	return false;

}
@@ -311,34 +311,33 @@ struct btrfs_dio_private { 
 * to grab i_mutex. It is used to avoid the endless truncate due to

 * nonlocked dio read.

 */

static inline void btrfs_inode_block_unlocked_dio(struct inode *inode)

static inline void btrfs_inode_block_unlocked_dio(struct btrfs_inode *inode)

{

	set_bit(BTRFS_INODE_READDIO_NEED_LOCK, &BTRFS_I(inode)->runtime_flags);

	set_bit(BTRFS_INODE_READDIO_NEED_LOCK, &inode->runtime_flags);

	smp_mb();

}



static inline void btrfs_inode_resume_unlocked_dio(struct inode *inode)

static inline void btrfs_inode_resume_unlocked_dio(struct btrfs_inode *inode)

{

	smp_mb__before_atomic();

	clear_bit(BTRFS_INODE_READDIO_NEED_LOCK,

		  &BTRFS_I(inode)->runtime_flags);

	clear_bit(BTRFS_INODE_READDIO_NEED_LOCK, &inode->runtime_flags);

}



static inline void btrfs_print_data_csum_error(struct inode *inode,

static inline void btrfs_print_data_csum_error(struct btrfs_inode *inode,

		u64 logical_start, u32 csum, u32 csum_expected, int mirror_num)

{

	struct btrfs_root *root = BTRFS_I(inode)->root;

	struct btrfs_root *root = inode->root;



	/* Output minus objectid, which is more meaningful */

	if (root->objectid >= BTRFS_LAST_FREE_OBJECTID)

		btrfs_warn_rl(root->fs_info,

	"csum failed root %lld ino %lld off %llu csum 0x%08x expected csum 0x%08x mirror %d",

			root->objectid, btrfs_ino(BTRFS_I(inode)),

			root->objectid, btrfs_ino(inode),

			logical_start, csum, csum_expected, mirror_num);

	else

		btrfs_warn_rl(root->fs_info,

	"csum failed root %llu ino %llu off %llu csum 0x%08x expected csum 0x%08x mirror %d",

			root->objectid, btrfs_ino(BTRFS_I(inode)),

			root->objectid, btrfs_ino(inode),

			logical_start, csum, csum_expected, mirror_num);

}

fs/btrfs/compression.c

+19 −24
Original line number Diff line number Diff line
@@ -100,7 +100,7 @@ static struct bio *compressed_bio_alloc(struct block_device *bdev, 
	return btrfs_bio_alloc(bdev, first_byte >> 9, BIO_MAX_PAGES, gfp_flags);

}



static int check_compressed_csum(struct inode *inode,

static int check_compressed_csum(struct btrfs_inode *inode,

				 struct compressed_bio *cb,

				 u64 disk_start)

{
@@ -111,7 +111,7 @@ static int check_compressed_csum(struct inode *inode, 
	u32 csum;

	u32 *cb_sum = &cb->sums;



	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)

	if (inode->flags & BTRFS_INODE_NODATASUM)

		return 0;



	for (i = 0; i < cb->nr_pages; i++) {
@@ -165,7 +165,7 @@ static void end_compressed_bio_read(struct bio *bio) 
		goto out;



	inode = cb->inode;

	ret = check_compressed_csum(inode, cb,

	ret = check_compressed_csum(BTRFS_I(inode), cb,

				    (u64)bio->bi_iter.bi_sector << 9);

	if (ret)

		goto csum_failed;
@@ -911,32 +911,28 @@ static void free_workspaces(void) 
}



/*

 * given an address space and start/len, compress the bytes.

 * Given an address space and start and length, compress the bytes into @pages

 * that are allocated on demand.

 *

 * pages are allocated to hold the compressed result and stored

 * in 'pages'

 * @out_pages is an in/out parameter, holds maximum number of pages to allocate

 * and returns number of actually allocated pages

 *

 * out_pages is used to return the number of pages allocated.  There

 * may be pages allocated even if we return an error

 *

 * total_in is used to return the number of bytes actually read.  It

 * may be smaller then len if we had to exit early because we

 * @total_in is used to return the number of bytes actually read.  It

 * may be smaller than the input length if we had to exit early because we

 * ran out of room in the pages array or because we cross the

 * max_out threshold.

 *

 * total_out is used to return the total number of compressed bytes

 * @total_out is an in/out parameter, must be set to the input length and will

 * be also used to return the total number of compressed bytes

 *

 * max_out tells us the max number of bytes that we're allowed to

 * @max_out tells us the max number of bytes that we're allowed to

 * stuff into pages

 */

int btrfs_compress_pages(int type, struct address_space *mapping,

			 u64 start, unsigned long len,

			 struct page **pages,

			 unsigned long nr_dest_pages,

			 u64 start, struct page **pages,

			 unsigned long *out_pages,

			 unsigned long *total_in,

			 unsigned long *total_out,

			 unsigned long max_out)

			 unsigned long *total_out)

{

	struct list_head *workspace;

	int ret;
@@ -944,10 +940,9 @@ int btrfs_compress_pages(int type, struct address_space *mapping, 
	workspace = find_workspace(type);



	ret = btrfs_compress_op[type-1]->compress_pages(workspace, mapping,

						      start, len, pages,

						      nr_dest_pages, out_pages,

						      total_in, total_out,

						      max_out);

						      start, pages,

						      out_pages,

						      total_in, total_out);

	free_workspace(type, workspace);

	return ret;

}
@@ -1015,7 +1010,7 @@ void btrfs_exit_compress(void) 
 *

 * total_out is the last byte of the buffer

 */

int btrfs_decompress_buf2page(char *buf, unsigned long buf_start,

int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start,

			      unsigned long total_out, u64 disk_start,

			      struct bio *bio)

{

fs/btrfs/compression.h

+20 −10
Original line number Diff line number Diff line
@@ -19,20 +19,32 @@ 
#ifndef __BTRFS_COMPRESSION_

#define __BTRFS_COMPRESSION_



/*

 * We want to make sure that amount of RAM required to uncompress an extent is

 * reasonable, so we limit the total size in ram of a compressed extent to

 * 128k.  This is a crucial number because it also controls how easily we can

 * spread reads across cpus for decompression.

 *

 * We also want to make sure the amount of IO required to do a random read is

 * reasonably small, so we limit the size of a compressed extent to 128k.

 */



/* Maximum length of compressed data stored on disk */

#define BTRFS_MAX_COMPRESSED		(SZ_128K)

/* Maximum size of data before compression */

#define BTRFS_MAX_UNCOMPRESSED		(SZ_128K)



void btrfs_init_compress(void);

void btrfs_exit_compress(void);



int btrfs_compress_pages(int type, struct address_space *mapping,

			 u64 start, unsigned long len,

			 struct page **pages,

			 unsigned long nr_dest_pages,

			 u64 start, struct page **pages,

			 unsigned long *out_pages,

			 unsigned long *total_in,

			 unsigned long *total_out,

			 unsigned long max_out);

			 unsigned long *total_out);

int btrfs_decompress(int type, unsigned char *data_in, struct page *dest_page,

		     unsigned long start_byte, size_t srclen, size_t destlen);

int btrfs_decompress_buf2page(char *buf, unsigned long buf_start,

int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start,

			      unsigned long total_out, u64 disk_start,

			      struct bio *bio);
@@ -59,13 +71,11 @@ struct btrfs_compress_op { 


	int (*compress_pages)(struct list_head *workspace,

			      struct address_space *mapping,

			      u64 start, unsigned long len,

			      u64 start,

			      struct page **pages,

			      unsigned long nr_dest_pages,

			      unsigned long *out_pages,

			      unsigned long *total_in,

			      unsigned long *total_out,

			      unsigned long max_out);

			      unsigned long *total_out);



	int (*decompress_bio)(struct list_head *workspace,

				 struct page **pages_in,

fs/btrfs/ctree.c

+7 −2
Original line number Diff line number Diff line
@@ -453,8 +453,6 @@ __tree_mod_log_insert(struct btrfs_fs_info *fs_info, struct tree_mod_elem *tm) 
	struct rb_node *parent = NULL;

	struct tree_mod_elem *cur;



	BUG_ON(!tm);



	tm->seq = btrfs_inc_tree_mod_seq(fs_info);



	tm_root = &fs_info->tree_mod_log;
@@ -4159,6 +4157,9 @@ static noinline int push_for_double_split(struct btrfs_trans_handle *trans, 


	/* try to push all the items before our slot into the next leaf */

	slot = path->slots[0];

	space_needed = data_size;

	if (slot > 0)

		space_needed -= btrfs_leaf_free_space(fs_info, path->nodes[0]);

	ret = push_leaf_left(trans, root, path, 1, space_needed, 0, slot);

	if (ret < 0)

		return ret;
@@ -4214,6 +4215,10 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans, 
		if (wret < 0)

			return wret;

		if (wret) {

			space_needed = data_size;

			if (slot > 0)

				space_needed -= btrfs_leaf_free_space(fs_info,

								      l);

			wret = push_leaf_left(trans, root, path, space_needed,

					      space_needed, 0, (u32)-1);

			if (wret < 0)

fs/btrfs/ctree.h

+20 −19
Original line number Diff line number Diff line
@@ -2687,7 +2687,7 @@ enum btrfs_flush_state { 
};



int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);

int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes);

int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes);

void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);

void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start,

					    u64 len);
@@ -2695,16 +2695,16 @@ void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans, 
				  struct btrfs_fs_info *fs_info);

void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);

int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,

				  struct inode *inode);

void btrfs_orphan_release_metadata(struct inode *inode);

				  struct btrfs_inode *inode);

void btrfs_orphan_release_metadata(struct btrfs_inode *inode);

int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,

				     struct btrfs_block_rsv *rsv,

				     int nitems,

				     u64 *qgroup_reserved, bool use_global_rsv);

void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,

				      struct btrfs_block_rsv *rsv);

int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);

void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);

int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes);

void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes);

int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len);

void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len);

void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
@@ -2982,7 +2982,7 @@ int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir, 
			  const char *name, int name_len);

int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,

			  struct btrfs_root *root, const char *name,

			  int name_len, struct inode *dir,

			  int name_len, struct btrfs_inode *dir,

			  struct btrfs_key *location, u8 type, u64 index);

struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,

					     struct btrfs_root *root,
@@ -3081,7 +3081,7 @@ int btrfs_csum_one_bio(struct inode *inode, struct bio *bio, 
		       u64 file_start, int contig);

int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,

			     struct list_head *list, int search_commit);

void btrfs_extent_item_to_extent_map(struct inode *inode,

void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,

				     const struct btrfs_path *path,

				     struct btrfs_file_extent_item *fi,

				     const bool new_inline,
@@ -3100,9 +3100,9 @@ struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode, 
						    int delay_iput);

void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);



struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,

					   size_t pg_offset, u64 start, u64 len,

					   int create);

struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,

		struct page *page, size_t pg_offset, u64 start,

		u64 len, int create);

noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,

			      u64 *orig_start, u64 *orig_block_len,

			      u64 *ram_bytes);
@@ -3123,13 +3123,13 @@ static inline void btrfs_force_ra(struct address_space *mapping, 
}



struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);

int btrfs_set_inode_index(struct inode *dir, u64 *index);

int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);

int btrfs_unlink_inode(struct btrfs_trans_handle *trans,

		       struct btrfs_root *root,

		       struct btrfs_inode *dir, struct btrfs_inode *inode,

		       const char *name, int name_len);

int btrfs_add_link(struct btrfs_trans_handle *trans,

		   struct inode *parent_inode, struct inode *inode,

		   struct btrfs_inode *parent_inode, struct btrfs_inode *inode,

		   const char *name, int name_len, int add_backref, u64 index);

int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,

			struct btrfs_root *root,
@@ -3166,15 +3166,16 @@ void btrfs_destroy_cachep(void); 
long btrfs_ioctl_trans_end(struct file *file);

struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,

			 struct btrfs_root *root, int *was_new);

struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,

				    size_t pg_offset, u64 start, u64 end,

				    int create);

struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,

		struct page *page, size_t pg_offset,

		u64 start, u64 end, int create);

int btrfs_update_inode(struct btrfs_trans_handle *trans,

			      struct btrfs_root *root,

			      struct inode *inode);

int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,

				struct btrfs_root *root, struct inode *inode);

int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);

int btrfs_orphan_add(struct btrfs_trans_handle *trans,

		struct btrfs_inode *inode);

int btrfs_orphan_cleanup(struct btrfs_root *root);

void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,

			      struct btrfs_root *root);
@@ -3215,11 +3216,11 @@ ssize_t btrfs_dedupe_file_range(struct file *src_file, u64 loff, u64 olen, 
int btrfs_auto_defrag_init(void);

void btrfs_auto_defrag_exit(void);

int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,

			   struct inode *inode);

			   struct btrfs_inode *inode);

int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);

void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);

int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);

void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,

void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,

			     int skip_pinned);

extern const struct file_operations btrfs_file_operations;

int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
@@ -3233,7 +3234,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, 
		       struct btrfs_root *root, struct inode *inode, u64 start,

		       u64 end, int drop_cache);

int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,

			      struct inode *inode, u64 start, u64 end);

			      struct btrfs_inode *inode, u64 start, u64 end);

int btrfs_release_file(struct inode *inode, struct file *file);

int btrfs_dirty_pages(struct inode *inode, struct page **pages,

		      size_t num_pages, loff_t pos, size_t write_bytes,