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

Commit 707e8a07 authored by David Sterba's avatar David Sterba Committed by Chris Mason
Browse files

btrfs: use nodesize everywhere, kill leafsize 



The nodesize and leafsize were never of different values. Unify the
usage and make nodesize the one. Cleanup the redundant checks and
helpers.

Shaves a few bytes from .text:

  text    data     bss     dec     hex filename
852418   24560   23112  900090   dbbfa btrfs.ko.before
851074   24584   23112  898770   db6d2 btrfs.ko.after

Signed-off-by: default avatarDavid Sterba <dsterba@suse.cz>
Signed-off-by: default avatarChris Mason <clm@fb.com>
parent 962a298f

fs/btrfs/backref.c

+4 −4
Original line number Diff line number Diff line
@@ -482,7 +482,7 @@ static int __add_missing_keys(struct btrfs_fs_info *fs_info, 
			continue;

		BUG_ON(!ref->wanted_disk_byte);

		eb = read_tree_block(fs_info->tree_root, ref->wanted_disk_byte,

				     fs_info->tree_root->leafsize, 0);

				     fs_info->tree_root->nodesize, 0);

		if (!eb || !extent_buffer_uptodate(eb)) {

			free_extent_buffer(eb);

			return -EIO;
@@ -991,8 +991,8 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans, 
			    ref->level == 0) {

				u32 bsz;

				struct extent_buffer *eb;

				bsz = btrfs_level_size(fs_info->extent_root,

							ref->level);



				bsz = fs_info->extent_root->nodesize;

				eb = read_tree_block(fs_info->extent_root,

							   ref->parent, bsz, 0);

				if (!eb || !extent_buffer_uptodate(eb)) {
@@ -1366,7 +1366,7 @@ int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical, 
	}

	btrfs_item_key_to_cpu(path->nodes[0], found_key, path->slots[0]);

	if (found_key->type == BTRFS_METADATA_ITEM_KEY)

		size = fs_info->extent_root->leafsize;

		size = fs_info->extent_root->nodesize;

	else if (found_key->type == BTRFS_EXTENT_ITEM_KEY)

		size = found_key->offset;

fs/btrfs/check-integrity.c

+0 −13
Original line number Diff line number Diff line
@@ -820,7 +820,6 @@ static int btrfsic_process_superblock_dev_mirror( 
	    btrfs_super_magic(super_tmp) != BTRFS_MAGIC ||

	    memcmp(device->uuid, super_tmp->dev_item.uuid, BTRFS_UUID_SIZE) ||

	    btrfs_super_nodesize(super_tmp) != state->metablock_size ||

	    btrfs_super_leafsize(super_tmp) != state->metablock_size ||

	    btrfs_super_sectorsize(super_tmp) != state->datablock_size) {

		brelse(bh);

		return 0;
@@ -3120,24 +3119,12 @@ int btrfsic_mount(struct btrfs_root *root, 
	struct list_head *dev_head = &fs_devices->devices;

	struct btrfs_device *device;



	if (root->nodesize != root->leafsize) {

		printk(KERN_INFO

		       "btrfsic: cannot handle nodesize %d != leafsize %d!\n",

		       root->nodesize, root->leafsize);

		return -1;

	}

	if (root->nodesize & ((u64)PAGE_CACHE_SIZE - 1)) {

		printk(KERN_INFO

		       "btrfsic: cannot handle nodesize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",

		       root->nodesize, PAGE_CACHE_SIZE);

		return -1;

	}

	if (root->leafsize & ((u64)PAGE_CACHE_SIZE - 1)) {

		printk(KERN_INFO

		       "btrfsic: cannot handle leafsize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",

		       root->leafsize, PAGE_CACHE_SIZE);

		return -1;

	}

	if (root->sectorsize & ((u64)PAGE_CACHE_SIZE - 1)) {

		printk(KERN_INFO

		       "btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",

fs/btrfs/ctree.c

+9 −9
Original line number Diff line number Diff line
@@ -1444,7 +1444,7 @@ get_old_root(struct btrfs_root *root, u64 time_seq) 
	if (old_root && tm && tm->op != MOD_LOG_KEY_REMOVE_WHILE_FREEING) {

		btrfs_tree_read_unlock(eb_root);

		free_extent_buffer(eb_root);

		blocksize = btrfs_level_size(root, old_root->level);

		blocksize = root->nodesize;

		old = read_tree_block(root, logical, blocksize, 0);

		if (WARN_ON(!old || !extent_buffer_uptodate(old))) {

			free_extent_buffer(old);
@@ -1651,7 +1651,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, 
	WARN_ON(trans->transid != root->fs_info->generation);



	parent_nritems = btrfs_header_nritems(parent);

	blocksize = btrfs_level_size(root, parent_level - 1);

	blocksize = root->nodesize;

	end_slot = parent_nritems;



	if (parent_nritems == 1)
@@ -1872,7 +1872,7 @@ static noinline struct extent_buffer *read_node_slot(struct btrfs_root *root, 
	BUG_ON(level == 0);



	eb = read_tree_block(root, btrfs_node_blockptr(parent, slot),

			     btrfs_level_size(root, level - 1),

			     root->nodesize,

			     btrfs_node_ptr_generation(parent, slot));

	if (eb && !extent_buffer_uptodate(eb)) {

		free_extent_buffer(eb);
@@ -2267,7 +2267,7 @@ static void reada_for_search(struct btrfs_root *root, 
	node = path->nodes[level];



	search = btrfs_node_blockptr(node, slot);

	blocksize = btrfs_level_size(root, level - 1);

	blocksize = root->nodesize;

	eb = btrfs_find_tree_block(root, search, blocksize);

	if (eb) {

		free_extent_buffer(eb);
@@ -2325,7 +2325,7 @@ static noinline void reada_for_balance(struct btrfs_root *root, 


	nritems = btrfs_header_nritems(parent);

	slot = path->slots[level + 1];

	blocksize = btrfs_level_size(root, level);

	blocksize = root->nodesize;



	if (slot > 0) {

		block1 = btrfs_node_blockptr(parent, slot - 1);
@@ -2461,7 +2461,7 @@ read_block_for_search(struct btrfs_trans_handle *trans, 


	blocknr = btrfs_node_blockptr(b, slot);

	gen = btrfs_node_ptr_generation(b, slot);

	blocksize = btrfs_level_size(root, level - 1);

	blocksize = root->nodesize;



	tmp = btrfs_find_tree_block(root, blocknr, blocksize);

	if (tmp) {
@@ -4282,13 +4282,13 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans, 
	else

		btrfs_item_key(l, &disk_key, mid);



	right = btrfs_alloc_free_block(trans, root, root->leafsize, 0,

	right = btrfs_alloc_free_block(trans, root, root->nodesize, 0,

					root->root_key.objectid,

					&disk_key, 0, l->start, 0);

	if (IS_ERR(right))

		return PTR_ERR(right);



	root_add_used(root, root->leafsize);

	root_add_used(root, root->nodesize);



	memset_extent_buffer(right, 0, 0, sizeof(struct btrfs_header));

	btrfs_set_header_bytenr(right, right->start);
@@ -5375,7 +5375,7 @@ int btrfs_compare_trees(struct btrfs_root *left_root, 
		goto out;

	}



	tmp_buf = kmalloc(left_root->leafsize, GFP_NOFS);

	tmp_buf = kmalloc(left_root->nodesize, GFP_NOFS);

	if (!tmp_buf) {

		ret = -ENOMEM;

		goto out;

fs/btrfs/ctree.h

+4 −17
Original line number Diff line number Diff line
@@ -391,7 +391,7 @@ struct btrfs_header { 
				      sizeof(struct btrfs_header)) / \

				     sizeof(struct btrfs_key_ptr))

#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))

#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))

#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->nodesize))

#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \

					sizeof(struct btrfs_item) - \

					sizeof(struct btrfs_file_extent_item))
@@ -474,7 +474,7 @@ struct btrfs_super_block { 
	__le64 num_devices;

	__le32 sectorsize;

	__le32 nodesize;

	__le32 leafsize;

	__le32 __unused_leafsize;

	__le32 stripesize;

	__le32 sys_chunk_array_size;

	__le64 chunk_root_generation;
@@ -1806,9 +1806,6 @@ struct btrfs_root { 
	/* node allocations are done in nodesize units */

	u32 nodesize;



	/* leaf allocations are done in leafsize units */

	u32 leafsize;



	u32 stripesize;



	u32 type;
@@ -2995,8 +2992,6 @@ BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block, 
			 sectorsize, 32);

BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,

			 nodesize, 32);

BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,

			 leafsize, 32);

BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,

			 stripesize, 32);

BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
@@ -3232,13 +3227,6 @@ static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb) 
	return sb->s_fs_info;

}



static inline u32 btrfs_level_size(struct btrfs_root *root, int level)

{

	if (level == 0)

		return root->leafsize;

	return root->nodesize;

}



/* helper function to cast into the data area of the leaf. */

#define btrfs_item_ptr(leaf, slot, type) \

	((type *)(btrfs_leaf_data(leaf) + \
@@ -3263,7 +3251,7 @@ static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping) 
static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,

						 unsigned num_items)

{

	return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *

	return (root->nodesize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *

		2 * num_items;

}
@@ -3274,8 +3262,7 @@ static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root, 
static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,

						 unsigned num_items)

{

	return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *

		num_items;

	return root->nodesize * BTRFS_MAX_LEVEL * num_items;

}



int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,

fs/btrfs/disk-io.c

+33 −41
Original line number Diff line number Diff line
@@ -1200,16 +1200,14 @@ btrfs_free_subvolume_writers(struct btrfs_subvolume_writers *writers) 
	kfree(writers);

}



static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,

			 u32 stripesize, struct btrfs_root *root,

			 struct btrfs_fs_info *fs_info,

static void __setup_root(u32 nodesize, u32 sectorsize, u32 stripesize,

			 struct btrfs_root *root, struct btrfs_fs_info *fs_info,

			 u64 objectid)

{

	root->node = NULL;

	root->commit_root = NULL;

	root->sectorsize = sectorsize;

	root->nodesize = nodesize;

	root->leafsize = leafsize;

	root->stripesize = stripesize;

	root->state = 0;

	root->orphan_cleanup_state = 0;
@@ -1295,7 +1293,7 @@ struct btrfs_root *btrfs_alloc_dummy_root(void) 
	root = btrfs_alloc_root(NULL);

	if (!root)

		return ERR_PTR(-ENOMEM);

	__setup_root(4096, 4096, 4096, 4096, root, NULL, 1);

	__setup_root(4096, 4096, 4096, root, NULL, 1);

	set_bit(BTRFS_ROOT_DUMMY_ROOT, &root->state);

	root->alloc_bytenr = 0;
@@ -1318,14 +1316,13 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans, 
	if (!root)

		return ERR_PTR(-ENOMEM);



	__setup_root(tree_root->nodesize, tree_root->leafsize,

		     tree_root->sectorsize, tree_root->stripesize,

		     root, fs_info, objectid);

	__setup_root(tree_root->nodesize, tree_root->sectorsize,

		tree_root->stripesize, root, fs_info, objectid);

	root->root_key.objectid = objectid;

	root->root_key.type = BTRFS_ROOT_ITEM_KEY;

	root->root_key.offset = 0;



	leaf = btrfs_alloc_free_block(trans, root, root->leafsize,

	leaf = btrfs_alloc_free_block(trans, root, root->nodesize,

				      0, objectid, NULL, 0, 0, 0);

	if (IS_ERR(leaf)) {

		ret = PTR_ERR(leaf);
@@ -1396,9 +1393,9 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans, 
	if (!root)

		return ERR_PTR(-ENOMEM);



	__setup_root(tree_root->nodesize, tree_root->leafsize,

		     tree_root->sectorsize, tree_root->stripesize,

		     root, fs_info, BTRFS_TREE_LOG_OBJECTID);

	__setup_root(tree_root->nodesize, tree_root->sectorsize,

		     tree_root->stripesize, root, fs_info,

		     BTRFS_TREE_LOG_OBJECTID);



	root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;

	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
@@ -1413,7 +1410,7 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans, 
	 * updated (along with back refs to the log tree).

	 */



	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,

	leaf = btrfs_alloc_free_block(trans, root, root->nodesize, 0,

				      BTRFS_TREE_LOG_OBJECTID, NULL,

				      0, 0, 0);

	if (IS_ERR(leaf)) {
@@ -1465,7 +1462,7 @@ int btrfs_add_log_tree(struct btrfs_trans_handle *trans, 
	btrfs_set_stack_inode_generation(inode_item, 1);

	btrfs_set_stack_inode_size(inode_item, 3);

	btrfs_set_stack_inode_nlink(inode_item, 1);

	btrfs_set_stack_inode_nbytes(inode_item, root->leafsize);

	btrfs_set_stack_inode_nbytes(inode_item, root->nodesize);

	btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);



	btrfs_set_root_node(&log_root->root_item, log_root->node);
@@ -1498,9 +1495,8 @@ static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root, 
		goto alloc_fail;

	}



	__setup_root(tree_root->nodesize, tree_root->leafsize,

		     tree_root->sectorsize, tree_root->stripesize,

		     root, fs_info, key->objectid);

	__setup_root(tree_root->nodesize, tree_root->sectorsize,

		tree_root->stripesize, root, fs_info, key->objectid);



	ret = btrfs_find_root(tree_root, key, path,

			      &root->root_item, &root->root_key);
@@ -1511,7 +1507,7 @@ static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root, 
	}



	generation = btrfs_root_generation(&root->root_item);

	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));

	blocksize = root->nodesize;

	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),

				     blocksize, generation);

	if (!root->node) {
@@ -2143,7 +2139,6 @@ int open_ctree(struct super_block *sb, 
{

	u32 sectorsize;

	u32 nodesize;

	u32 leafsize;

	u32 blocksize;

	u32 stripesize;

	u64 generation;
@@ -2389,7 +2384,7 @@ int open_ctree(struct super_block *sb, 
		goto fail_alloc;

	}



	__setup_root(4096, 4096, 4096, 4096, tree_root,

	__setup_root(4096, 4096, 4096, tree_root,

		     fs_info, BTRFS_ROOT_TREE_OBJECTID);



	invalidate_bdev(fs_devices->latest_bdev);
@@ -2469,19 +2464,22 @@ int open_ctree(struct super_block *sb, 
		goto fail_alloc;

	}



	if (btrfs_super_leafsize(disk_super) !=

	/*

	 * Leafsize and nodesize were always equal, this is only a sanity check.

	 */

	if (le32_to_cpu(disk_super->__unused_leafsize) !=

	    btrfs_super_nodesize(disk_super)) {

		printk(KERN_ERR "BTRFS: couldn't mount because metadata "

		       "blocksizes don't match.  node %d leaf %d\n",

		       btrfs_super_nodesize(disk_super),

		       btrfs_super_leafsize(disk_super));

		       le32_to_cpu(disk_super->__unused_leafsize));

		err = -EINVAL;

		goto fail_alloc;

	}

	if (btrfs_super_leafsize(disk_super) > BTRFS_MAX_METADATA_BLOCKSIZE) {

	if (btrfs_super_nodesize(disk_super) > BTRFS_MAX_METADATA_BLOCKSIZE) {

		printk(KERN_ERR "BTRFS: couldn't mount because metadata "

		       "blocksize (%d) was too large\n",

		       btrfs_super_leafsize(disk_super));

		       btrfs_super_nodesize(disk_super));

		err = -EINVAL;

		goto fail_alloc;

	}
@@ -2498,17 +2496,16 @@ int open_ctree(struct super_block *sb, 
	 * flag our filesystem as having big metadata blocks if

	 * they are bigger than the page size

	 */

	if (btrfs_super_leafsize(disk_super) > PAGE_CACHE_SIZE) {

	if (btrfs_super_nodesize(disk_super) > PAGE_CACHE_SIZE) {

		if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))

			printk(KERN_INFO "BTRFS: flagging fs with big metadata feature\n");

		features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;

	}



	nodesize = btrfs_super_nodesize(disk_super);

	leafsize = btrfs_super_leafsize(disk_super);

	sectorsize = btrfs_super_sectorsize(disk_super);

	stripesize = btrfs_super_stripesize(disk_super);

	fs_info->dirty_metadata_batch = leafsize * (1 + ilog2(nr_cpu_ids));

	fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));

	fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));



	/*
@@ -2516,7 +2513,7 @@ int open_ctree(struct super_block *sb, 
	 * extent buffers for the same range.  It leads to corruptions

	 */

	if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&

	    (sectorsize != leafsize)) {

	    (sectorsize != nodesize)) {

		printk(KERN_WARNING "BTRFS: unequal leaf/node/sector sizes "

				"are not allowed for mixed block groups on %s\n",

				sb->s_id);
@@ -2615,7 +2612,6 @@ int open_ctree(struct super_block *sb, 
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);



	tree_root->nodesize = nodesize;

	tree_root->leafsize = leafsize;

	tree_root->sectorsize = sectorsize;

	tree_root->stripesize = stripesize;
@@ -2642,12 +2638,11 @@ int open_ctree(struct super_block *sb, 
		goto fail_sb_buffer;

	}



	blocksize = btrfs_level_size(tree_root,

				     btrfs_super_chunk_root_level(disk_super));

	blocksize = tree_root->nodesize;

	generation = btrfs_super_chunk_root_generation(disk_super);



	__setup_root(nodesize, leafsize, sectorsize, stripesize,

		     chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);

	__setup_root(nodesize, sectorsize, stripesize, chunk_root,

		     fs_info, BTRFS_CHUNK_TREE_OBJECTID);



	chunk_root->node = read_tree_block(chunk_root,

					   btrfs_super_chunk_root(disk_super),
@@ -2684,8 +2679,7 @@ int open_ctree(struct super_block *sb, 
	}



retry_root_backup:

	blocksize = btrfs_level_size(tree_root,

				     btrfs_super_root_level(disk_super));

	blocksize = tree_root->nodesize;

	generation = btrfs_super_generation(disk_super);



	tree_root->node = read_tree_block(tree_root,
@@ -2859,9 +2853,7 @@ int open_ctree(struct super_block *sb, 
			err = -EIO;

			goto fail_qgroup;

		}

		blocksize =

		     btrfs_level_size(tree_root,

				      btrfs_super_log_root_level(disk_super));

		blocksize = tree_root->nodesize;



		log_tree_root = btrfs_alloc_root(fs_info);

		if (!log_tree_root) {
@@ -2869,7 +2861,7 @@ int open_ctree(struct super_block *sb, 
			goto fail_qgroup;

		}



		__setup_root(nodesize, leafsize, sectorsize, stripesize,

		__setup_root(nodesize, sectorsize, stripesize,

			     log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);



		log_tree_root->node = read_tree_block(tree_root, bytenr,
@@ -4008,8 +4000,8 @@ static int btrfs_destroy_marked_extents(struct btrfs_root *root, 
		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);

		while (start <= end) {

			eb = btrfs_find_tree_block(root, start,

						   root->leafsize);

			start += root->leafsize;

						   root->nodesize);

			start += root->nodesize;

			if (!eb)

				continue;

			wait_on_extent_buffer_writeback(eb);