[patch] Move nodesize/leafsize/sectorsize to fs_info

[patch] Move nodesize/leafsize/sectorsize to fs_info

[Peeters Simon]

[-- Attachment #1: Type: text/plain, Size: 312 bytes --]

moved nodesize, leafsize and sectorsize from btrfs_root to
btrfs_fs_info as mentioned in [1] and updated everything accordingly.
patch against the "for-linus" tree
builds and loads, no further testing done.


[1] https://btrfs.wiki.kernel.org/index.php/Cleanup_ideas

ps: "Pass fs_info instead of root" is next.

[-- Attachment #2: btrfs-cleanup-leafsize_nodesize_sectorsize2.patch --]
[-- Type: text/x-diff, Size: 34332 bytes --]

diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 8ec5d86..146286c 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -87,7 +87,7 @@ static inline int compressed_bio_size(struct btrfs_root *root,
 {
 	u16 csum_size = btrfs_super_csum_size(&root->fs_info->super_copy);
 	return sizeof(struct compressed_bio) +
-		((disk_size + root->sectorsize - 1) / root->sectorsize) *
+		((disk_size + root->fs_info->sectorsize - 1) / root->fs_info->sectorsize) *
 		csum_size;
 }
 
@@ -674,8 +674,8 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 							comp_bio, sums);
 				BUG_ON(ret);
 			}
-			sums += (comp_bio->bi_size + root->sectorsize - 1) /
-				root->sectorsize;
+			sums += (comp_bio->bi_size + root->fs_info->sectorsize - 1) /
+				root->fs_info->sectorsize;
 
 			ret = btrfs_map_bio(root, READ, comp_bio,
 					    mirror_num, 0);
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 011cab3..b5862a8 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -2070,13 +2070,13 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
 	else
 		btrfs_node_key(lower, &lower_key, 0);
 
-	c = btrfs_alloc_free_block(trans, root, root->nodesize, 0,
+	c = btrfs_alloc_free_block(trans, root, root->fs_info->nodesize, 0,
 				   root->root_key.objectid, &lower_key,
 				   level, root->node->start, 0);
 	if (IS_ERR(c))
 		return PTR_ERR(c);
 
-	root_add_used(root, root->nodesize);
+	root_add_used(root, root->fs_info->nodesize);
 
 	memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
 	btrfs_set_header_nritems(c, 1);
@@ -2197,13 +2197,13 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
 	mid = (c_nritems + 1) / 2;
 	btrfs_node_key(c, &disk_key, mid);
 
-	split = btrfs_alloc_free_block(trans, root, root->nodesize, 0,
+	split = btrfs_alloc_free_block(trans, root, root->fs_info->nodesize, 0,
 					root->root_key.objectid,
 					&disk_key, level, c->start, 0);
 	if (IS_ERR(split))
 		return PTR_ERR(split);
 
-	root_add_used(root, root->nodesize);
+	root_add_used(root, root->fs_info->nodesize);
 
 	memset_extent_buffer(split, 0, 0, sizeof(struct btrfs_header));
 	btrfs_set_header_level(split, btrfs_header_level(c));
@@ -2951,13 +2951,13 @@ again:
 	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->fs_info->leafsize, 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->fs_info->leafsize);
 
 	memset_extent_buffer(right, 0, 0, sizeof(struct btrfs_header));
 	btrfs_set_header_bytenr(right, right->start);
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index a6263bd..ee6c872 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -339,11 +339,11 @@ struct btrfs_header {
 	u8 level;
 } __attribute__ ((__packed__));
 
-#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
+#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->fs_info->nodesize - \
 				      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->fs_info->leafsize))
 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 					sizeof(struct btrfs_item) - \
 					sizeof(struct btrfs_file_extent_item))
@@ -1115,6 +1115,15 @@ struct btrfs_fs_info {
 	int scrub_workers_refcnt;
 	struct btrfs_workers scrub_workers;
 
+	/* node allocations are done in nodesize units */
+	u32 nodesize;
+
+	/* leaf allocations are done in leafsize units */
+	u32 leafsize;
+
+	/* data allocations are done in sectorsize units */
+	u32 sectorsize;
+
 	/* filesystem state */
 	u64 fs_state;
 
@@ -1168,15 +1177,6 @@ struct btrfs_root {
 	u64 objectid;
 	u64 last_trans;
 
-	/* data allocations are done in sectorsize units */
-	u32 sectorsize;
-
-	/* node allocations are done in nodesize units */
-	u32 nodesize;
-
-	/* leaf allocations are done in leafsize units */
-	u32 leafsize;
-
 	u32 stripesize;
 
 	u32 type;
@@ -2107,8 +2107,8 @@ static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
 static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
 {
 	if (level == 0)
-		return root->leafsize;
-	return root->nodesize;
+		return root->fs_info->leafsize;
+	return root->fs_info->nodesize;
 }
 
 /* helper function to cast into the data area of the leaf. */
@@ -2135,7 +2135,7 @@ static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
 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->fs_info->leafsize + root->fs_info->nodesize * (BTRFS_MAX_LEVEL - 1)) *
 		3 * num_items;
 }
 
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 94ecac3..10158cef 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1056,16 +1056,12 @@ int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 	return 0;
 }
 
-static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
-			u32 stripesize, struct btrfs_root *root,
+static int __setup_root(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->ref_cows = 0;
 	root->track_dirty = 0;
@@ -1129,9 +1125,7 @@ static int find_and_setup_root(struct btrfs_root *tree_root,
 	u32 blocksize;
 	u64 generation;
 
-	__setup_root(tree_root->nodesize, tree_root->leafsize,
-		     tree_root->sectorsize, tree_root->stripesize,
-		     root, fs_info, objectid);
+	__setup_root(tree_root->stripesize, root, fs_info, objectid);
 	ret = btrfs_find_last_root(tree_root, objectid,
 				   &root->root_item, &root->root_key);
 	if (ret > 0)
@@ -1161,9 +1155,8 @@ 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->stripesize, root, fs_info,
+		     BTRFS_TREE_LOG_OBJECTID);
 
 	root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
 	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
@@ -1176,7 +1169,7 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
 	 */
 	root->ref_cows = 0;
 
-	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
+	leaf = btrfs_alloc_free_block(trans, root, root->fs_info->leafsize, 0,
 				      BTRFS_TREE_LOG_OBJECTID, NULL, 0, 0, 0);
 	if (IS_ERR(leaf)) {
 		kfree(root);
@@ -1228,7 +1221,7 @@ int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
 	inode_item->generation = cpu_to_le64(1);
 	inode_item->size = cpu_to_le64(3);
 	inode_item->nlink = cpu_to_le32(1);
-	inode_item->nbytes = cpu_to_le64(root->leafsize);
+	inode_item->nbytes = cpu_to_le64(root->fs_info->leafsize);
 	inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
 
 	btrfs_set_root_node(&log_root->root_item, log_root->node);
@@ -1264,9 +1257,7 @@ struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
 		goto out;
 	}
 
-	__setup_root(tree_root->nodesize, tree_root->leafsize,
-		     tree_root->sectorsize, tree_root->stripesize,
-		     root, fs_info, location->objectid);
+	__setup_root(tree_root->stripesize, root, fs_info, location->objectid);
 
 	path = btrfs_alloc_path();
 	if (!path) {
@@ -1762,8 +1753,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 	init_waitqueue_head(&fs_info->transaction_blocked_wait);
 	init_waitqueue_head(&fs_info->async_submit_wait);
 
-	__setup_root(4096, 4096, 4096, 4096, tree_root,
-		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
+	__setup_root(4096, tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
 
 	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
 	if (!bh) {
@@ -1907,9 +1897,10 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 	leafsize = btrfs_super_leafsize(disk_super);
 	sectorsize = btrfs_super_sectorsize(disk_super);
 	stripesize = btrfs_super_stripesize(disk_super);
-	tree_root->nodesize = nodesize;
-	tree_root->leafsize = leafsize;
-	tree_root->sectorsize = sectorsize;
+	
+	fs_info->nodesize = nodesize;
+	fs_info->leafsize = leafsize;
+	fs_info->sectorsize = sectorsize;
 	tree_root->stripesize = stripesize;
 
 	sb->s_blocksize = sectorsize;
@@ -1934,8 +1925,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 				     btrfs_super_chunk_root_level(disk_super));
 	generation = btrfs_super_chunk_root_generation(disk_super);
 
-	__setup_root(nodesize, leafsize, sectorsize, stripesize,
-		     chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
+	__setup_root(stripesize, chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
 
 	chunk_root->node = read_tree_block(chunk_root,
 					   btrfs_super_chunk_root(disk_super),
@@ -2058,8 +2048,8 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 			goto fail_trans_kthread;
 		}
 
-		__setup_root(nodesize, leafsize, sectorsize, stripesize,
-			     log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
+		__setup_root(stripesize, log_tree_root, fs_info,
+			     BTRFS_TREE_LOG_OBJECTID);
 
 		log_tree_root->node = read_tree_block(tree_root, bytenr,
 						      blocksize,
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 66bac22..009c0c3 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -3033,7 +3033,7 @@ int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
 	int ret = 0, committed = 0, alloc_chunk = 1;
 
 	/* make sure bytes are sectorsize aligned */
-	bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
+	bytes = (bytes + root->fs_info->sectorsize - 1) & ~((u64)root->fs_info->sectorsize - 1);
 
 	if (root == root->fs_info->tree_root ||
 	    BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID) {
@@ -3131,7 +3131,7 @@ void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes)
 	struct btrfs_space_info *data_sinfo;
 
 	/* make sure bytes are sectorsize aligned */
-	bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
+	bytes = (bytes + root->fs_info->sectorsize - 1) & ~((u64)root->fs_info->sectorsize - 1);
 
 	data_sinfo = BTRFS_I(inode)->space_info;
 	spin_lock(&data_sinfo->lock);
@@ -3796,7 +3796,7 @@ static u64 calc_global_metadata_size(struct btrfs_fs_info *fs_info)
 	if (num_bytes * 3 > meta_used)
 		num_bytes = div64_u64(meta_used, 3);
 
-	return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10);
+	return ALIGN(num_bytes, fs_info->leafsize << 10);
 }
 
 static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
@@ -3996,7 +3996,7 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
 	if (btrfs_transaction_in_commit(root->fs_info))
 		schedule_timeout(1);
 
-	num_bytes = ALIGN(num_bytes, root->sectorsize);
+	num_bytes = ALIGN(num_bytes, root->fs_info->sectorsize);
 
 	spin_lock(&BTRFS_I(inode)->lock);
 	BTRFS_I(inode)->outstanding_extents++;
@@ -4035,7 +4035,7 @@ void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
 	u64 to_free = 0;
 	unsigned dropped;
 
-	num_bytes = ALIGN(num_bytes, root->sectorsize);
+	num_bytes = ALIGN(num_bytes, root->fs_info->sectorsize);
 	dropped = drop_outstanding_extent(inode);
 
 	to_free = calc_csum_metadata_size(inode, num_bytes);
@@ -4882,7 +4882,7 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
 	u64 ideal_cache_percent = 0;
 	u64 ideal_cache_offset = 0;
 
-	WARN_ON(num_bytes < root->sectorsize);
+	WARN_ON(num_bytes < root->fs_info->sectorsize);
 	btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
 	ins->objectid = 0;
 	ins->offset = 0;
@@ -5375,14 +5375,14 @@ again:
 				     num_bytes + 2 * 1024 * 1024, data,
 				     CHUNK_ALLOC_NO_FORCE);
 
-	WARN_ON(num_bytes < root->sectorsize);
+	WARN_ON(num_bytes < root->fs_info->sectorsize);
 	ret = find_free_extent(trans, root, num_bytes, empty_size,
 			       search_start, search_end, hint_byte,
 			       ins, data);
 
 	if (ret == -ENOSPC && num_bytes > min_alloc_size) {
 		num_bytes = num_bytes >> 1;
-		num_bytes = num_bytes & ~(root->sectorsize - 1);
+		num_bytes = num_bytes & ~(root->fs_info->sectorsize - 1);
 		num_bytes = max(num_bytes, min_alloc_size);
 		do_chunk_alloc(trans, root->fs_info->extent_root,
 			       num_bytes, data, CHUNK_ALLOC_FORCE);
@@ -7008,7 +7008,7 @@ int btrfs_read_block_groups(struct btrfs_root *root)
 		key.objectid = found_key.objectid + found_key.offset;
 		btrfs_release_path(path);
 		cache->flags = btrfs_block_group_flags(&cache->item);
-		cache->sectorsize = root->sectorsize;
+		cache->sectorsize = root->fs_info->sectorsize;
 
 		btrfs_init_free_space_ctl(cache);
 
@@ -7108,7 +7108,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
 	cache->key.objectid = chunk_offset;
 	cache->key.offset = size;
 	cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
-	cache->sectorsize = root->sectorsize;
+	cache->sectorsize = root->fs_info->sectorsize;
 	cache->fs_info = root->fs_info;
 
 	atomic_set(&cache->count, 1);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 8491712..4656757 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2729,7 +2729,7 @@ static struct extent_map *get_extent_skip_holes(struct inode *inode,
 						u64 last,
 						get_extent_t *get_extent)
 {
-	u64 sectorsize = BTRFS_I(inode)->root->sectorsize;
+	u64 sectorsize = BTRFS_I(inode)->root->fs_info->sectorsize;
 	struct extent_map *em;
 	u64 len;
 
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index b910694..b97e657 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -32,7 +32,7 @@
 #define MAX_ORDERED_SUM_BYTES(r) ((PAGE_SIZE - \
 				   sizeof(struct btrfs_ordered_sum)) / \
 				   sizeof(struct btrfs_sector_sum) * \
-				   (r)->sectorsize - (r)->sectorsize)
+				   (r)->fs_info->sectorsize - (r)->fs_info->sectorsize)
 
 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
 			     struct btrfs_root *root,
@@ -234,7 +234,7 @@ static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
 						       path->slots[0]);
 			item_last_offset = item_start_offset +
 				(item_size / csum_size) *
-				root->sectorsize;
+				root->fs_info->sectorsize;
 			item = btrfs_item_ptr(path->nodes[0], path->slots[0],
 					      struct btrfs_csum_item);
 		}
@@ -243,7 +243,7 @@ static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
 		 * a single leaf so it will also fit inside a u32
 		 */
 		diff = disk_bytenr - item_start_offset;
-		diff = diff / root->sectorsize;
+		diff = diff / root->fs_info->sectorsize;
 		diff = diff * csum_size;
 
 		read_extent_buffer(path->nodes[0], &sum,
@@ -344,7 +344,7 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
 			start = key.offset;
 
 		size = btrfs_item_size_nr(leaf, path->slots[0]);
-		csum_end = key.offset + (size / csum_size) * root->sectorsize;
+		csum_end = key.offset + (size / csum_size) * root->fs_info->sectorsize;
 		if (csum_end <= start) {
 			path->slots[0]++;
 			continue;
@@ -375,8 +375,8 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
 						offset, csum_size);
 				sector_sum->bytenr = start;
 
-				size -= root->sectorsize;
-				start += root->sectorsize;
+				size -= root->fs_info->sectorsize;
+				start += root->fs_info->sectorsize;
 				offset += csum_size;
 				sector_sum++;
 			}
@@ -783,14 +783,14 @@ insert:
 	btrfs_release_path(path);
 	csum_offset = 0;
 	if (found_next) {
-		u64 tmp = total_bytes + root->sectorsize;
+		u64 tmp = total_bytes + root->fs_info->sectorsize;
 		u64 next_sector = sector_sum->bytenr;
 		struct btrfs_sector_sum *next = sector_sum + 1;
 
 		while (tmp < sums->len) {
-			if (next_sector + root->sectorsize != next->bytenr)
+			if (next_sector + root->fs_info->sectorsize != next->bytenr)
 				break;
-			tmp += root->sectorsize;
+			tmp += root->fs_info->sectorsize;
 			next_sector = next->bytenr;
 			next++;
 		}
@@ -826,7 +826,7 @@ next_sector:
 
 	write_extent_buffer(leaf, &sector_sum->sum, (unsigned long)item, csum_size);
 
-	total_bytes += root->sectorsize;
+	total_bytes += root->fs_info->sectorsize;
 	sector_sum++;
 	if (total_bytes < sums->len) {
 		item = (struct btrfs_csum_item *)((char *)item +
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 010aec8..96d6ea4 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -396,9 +396,9 @@ int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
 	u64 end_pos = pos + write_bytes;
 	loff_t isize = i_size_read(inode);
 
-	start_pos = pos & ~((u64)root->sectorsize - 1);
+	start_pos = pos & ~((u64)root->fs_info->sectorsize - 1);
 	num_bytes = (write_bytes + pos - start_pos +
-		    root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
+		    root->fs_info->sectorsize - 1) & ~((u64)root->fs_info->sectorsize - 1);
 
 	end_of_last_block = start_pos + num_bytes - 1;
 	err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block,
@@ -745,7 +745,7 @@ next_slot:
 				inode_sub_bytes(inode,
 						extent_end - key.offset);
 				extent_end = ALIGN(extent_end,
-						   root->sectorsize);
+						   root->fs_info->sectorsize);
 			} else if (disk_bytenr > 0) {
 				ret = btrfs_free_extent(trans, root,
 						disk_bytenr, num_bytes, 0,
@@ -1070,7 +1070,7 @@ static noinline int prepare_pages(struct btrfs_root *root, struct file *file,
 	u64 start_pos;
 	u64 last_pos;
 
-	start_pos = pos & ~((u64)root->sectorsize - 1);
+	start_pos = pos & ~((u64)root->fs_info->sectorsize - 1);
 	last_pos = ((u64)index + num_pages) << PAGE_CACHE_SHIFT;
 
 	if (start_pos > inode->i_size) {
@@ -1264,7 +1264,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
 
 		balance_dirty_pages_ratelimited_nr(inode->i_mapping,
 						   dirty_pages);
-		if (dirty_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
+		if (dirty_pages < (root->fs_info->leafsize >> PAGE_CACHE_SHIFT) + 1)
 			btrfs_btree_balance_dirty(root, 1);
 		btrfs_throttle(root);
 
@@ -1563,7 +1563,7 @@ static long btrfs_fallocate(struct file *file, int mode,
 	u64 alloc_end;
 	u64 alloc_hint = 0;
 	u64 locked_end;
-	u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
+	u64 mask = BTRFS_I(inode)->root->fs_info->sectorsize - 1;
 	struct extent_map *em;
 	int ret;
 
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 6377713..c84e752 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -567,7 +567,7 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
 
 	filemap_write_and_wait(inode->i_mapping);
 	btrfs_wait_ordered_range(inode, inode->i_size &
-				 ~(root->sectorsize - 1), (u64)-1);
+				 ~(root->fs_info->sectorsize - 1), (u64)-1);
 
 	pages = kzalloc(sizeof(struct page *) * num_pages, GFP_NOFS);
 	if (!pages)
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 34195f9..bcc138b 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -226,8 +226,8 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
 	u64 isize = i_size_read(inode);
 	u64 actual_end = min(end + 1, isize);
 	u64 inline_len = actual_end - start;
-	u64 aligned_end = (end + root->sectorsize - 1) &
-			~((u64)root->sectorsize - 1);
+	u64 aligned_end = (end + root->fs_info->sectorsize - 1) &
+			~((u64)root->fs_info->sectorsize - 1);
 	u64 hint_byte;
 	u64 data_len = inline_len;
 	int ret;
@@ -239,7 +239,7 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
 	    actual_end >= PAGE_CACHE_SIZE ||
 	    data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
 	    (!compressed_size &&
-	    (actual_end & (root->sectorsize - 1)) == 0) ||
+	    (actual_end & (root->fs_info->sectorsize - 1)) == 0) ||
 	    end + 1 < isize ||
 	    data_len > root->fs_info->max_inline) {
 		return 1;
@@ -326,7 +326,7 @@ static noinline int compress_file_range(struct inode *inode,
 	struct btrfs_root *root = BTRFS_I(inode)->root;
 	struct btrfs_trans_handle *trans;
 	u64 num_bytes;
-	u64 blocksize = root->sectorsize;
+	u64 blocksize = root->fs_info->sectorsize;
 	u64 actual_end;
 	u64 isize = i_size_read(inode);
 	int ret = 0;
@@ -776,7 +776,7 @@ static noinline int cow_file_range(struct inode *inode,
 	unsigned long ram_size;
 	u64 disk_num_bytes;
 	u64 cur_alloc_size;
-	u64 blocksize = root->sectorsize;
+	u64 blocksize = root->fs_info->sectorsize;
 	struct btrfs_key ins;
 	struct extent_map *em;
 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
@@ -830,7 +830,7 @@ static noinline int cow_file_range(struct inode *inode,
 
 		cur_alloc_size = disk_num_bytes;
 		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
-					   root->sectorsize, 0, alloc_hint,
+					   root->fs_info->sectorsize, 0, alloc_hint,
 					   (u64)-1, &ins, 1);
 		BUG_ON(ret);
 
@@ -1158,7 +1158,7 @@ next_slot:
 		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
 			extent_end = found_key.offset +
 				btrfs_file_extent_inline_len(leaf, fi);
-			extent_end = ALIGN(extent_end, root->sectorsize);
+			extent_end = ALIGN(extent_end, root->fs_info->sectorsize);
 		} else {
 			BUG_ON(1);
 		}
@@ -3137,7 +3137,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
 	u64 extent_num_bytes = 0;
 	u64 extent_offset = 0;
 	u64 item_end = 0;
-	u64 mask = root->sectorsize - 1;
+	u64 mask = root->fs_info->sectorsize - 1;
 	u32 found_type = (u8)-1;
 	int found_extent;
 	int del_item;
@@ -3242,9 +3242,9 @@ search_again:
 				u64 orig_num_bytes =
 					btrfs_file_extent_num_bytes(leaf, fi);
 				extent_num_bytes = new_size -
-					found_key.offset + root->sectorsize - 1;
+					found_key.offset + root->fs_info->sectorsize - 1;
 				extent_num_bytes = extent_num_bytes &
-					~((u64)root->sectorsize - 1);
+					~((u64)root->fs_info->sectorsize - 1);
 				btrfs_set_file_extent_num_bytes(leaf, fi,
 							 extent_num_bytes);
 				num_dec = (orig_num_bytes -
@@ -3364,7 +3364,7 @@ static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
 	struct btrfs_ordered_extent *ordered;
 	struct extent_state *cached_state = NULL;
 	char *kaddr;
-	u32 blocksize = root->sectorsize;
+	u32 blocksize = root->fs_info->sectorsize;
 	pgoff_t index = from >> PAGE_CACHE_SHIFT;
 	unsigned offset = from & (PAGE_CACHE_SIZE-1);
 	struct page *page;
@@ -3465,7 +3465,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
 	struct extent_map *em = NULL;
 	struct extent_state *cached_state = NULL;
-	u64 mask = root->sectorsize - 1;
+	u64 mask = root->fs_info->sectorsize - 1;
 	u64 hole_start = (oldsize + mask) & ~mask;
 	u64 block_end = (size + mask) & ~mask;
 	u64 last_byte;
@@ -5014,8 +5014,8 @@ again:
 	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
 		size_t size;
 		size = btrfs_file_extent_inline_len(leaf, item);
-		extent_end = (extent_start + size + root->sectorsize - 1) &
-			~((u64)root->sectorsize - 1);
+		extent_end = (extent_start + size + root->fs_info->sectorsize - 1) &
+			~((u64)root->fs_info->sectorsize - 1);
 	}
 
 	if (start >= extent_end) {
@@ -5085,8 +5085,8 @@ again:
 		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
 				size - extent_offset);
 		em->start = extent_start + extent_offset;
-		em->len = (copy_size + root->sectorsize - 1) &
-			~((u64)root->sectorsize - 1);
+		em->len = (copy_size + root->fs_info->sectorsize - 1) &
+			~((u64)root->fs_info->sectorsize - 1);
 		em->orig_start = EXTENT_MAP_INLINE;
 		if (compress_type) {
 			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
@@ -5181,7 +5181,7 @@ insert:
 			if (existing) {
 				err = merge_extent_mapping(em_tree, existing,
 							   em, start,
-							   root->sectorsize);
+							   root->fs_info->sectorsize);
 				free_extent_map(existing);
 				if (err) {
 					free_extent_map(em);
@@ -5375,7 +5375,7 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
 	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 
 	alloc_hint = get_extent_allocation_hint(inode, start, len);
-	ret = btrfs_reserve_extent(trans, root, len, root->sectorsize, 0,
+	ret = btrfs_reserve_extent(trans, root, len, root->fs_info->sectorsize, 0,
 				   alloc_hint, (u64)-1, &ins, 1);
 	if (ret) {
 		em = ERR_PTR(ret);
@@ -5564,7 +5564,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
 		free_extent_map(em);
 		/* DIO will do one hole at a time, so just unlock a sector */
 		unlock_extent(&BTRFS_I(inode)->io_tree, start,
-			      start + root->sectorsize - 1, GFP_NOFS);
+			      start + root->fs_info->sectorsize - 1, GFP_NOFS);
 		return 0;
 	}
 
@@ -6109,7 +6109,7 @@ static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *io
 	int i;
 	size_t size;
 	unsigned long addr;
-	unsigned blocksize_mask = root->sectorsize - 1;
+	unsigned blocksize_mask = root->fs_info->sectorsize - 1;
 	ssize_t retval = -EINVAL;
 	loff_t end = offset;
 
@@ -6495,7 +6495,7 @@ static int btrfs_truncate(struct inode *inode)
 	int err = 0;
 	struct btrfs_trans_handle *trans;
 	unsigned long nr;
-	u64 mask = root->sectorsize - 1;
+	u64 mask = root->fs_info->sectorsize - 1;
 
 	ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
 	if (ret)
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 2bb0886..dfa3a33 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -351,7 +351,7 @@ static noinline int create_subvol(struct btrfs_root *root,
 		return PTR_ERR(trans);
 	}
 
-	leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
+	leaf = btrfs_alloc_free_block(trans, root, root->fs_info->leafsize,
 				      0, objectid, NULL, 0, 0, 0);
 	if (IS_ERR(leaf)) {
 		ret = PTR_ERR(leaf);
@@ -377,7 +377,7 @@ static noinline int create_subvol(struct btrfs_root *root,
 	inode_item->generation = cpu_to_le64(1);
 	inode_item->size = cpu_to_le64(3);
 	inode_item->nlink = cpu_to_le32(1);
-	inode_item->nbytes = cpu_to_le64(root->leafsize);
+	inode_item->nbytes = cpu_to_le64(root->fs_info->leafsize);
 	inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
 
 	root_item.flags = 0;
@@ -1236,8 +1236,8 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
 		goto out_unlock;
 	}
 
-	do_div(new_size, root->sectorsize);
-	new_size *= root->sectorsize;
+	do_div(new_size, root->fs_info->sectorsize);
+	new_size *= root->fs_info->sectorsize;
 
 	printk(KERN_INFO "new size for %s is %llu\n",
 		device->name, (unsigned long long)new_size);
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index a1c9404..5742481 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -780,7 +780,7 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
 	if (ordered)
 		offset = entry_end(ordered);
 	else
-		offset = ALIGN(offset, BTRFS_I(inode)->root->sectorsize);
+		offset = ALIGN(offset, BTRFS_I(inode)->root->fs_info->sectorsize);
 
 	spin_lock(&tree->lock);
 	disk_i_size = BTRFS_I(inode)->disk_i_size;
@@ -908,7 +908,7 @@ int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,
 	struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
 	unsigned long num_sectors;
 	unsigned long i;
-	u32 sectorsize = BTRFS_I(inode)->root->sectorsize;
+	u32 sectorsize = BTRFS_I(inode)->root->fs_info->sectorsize;
 	int ret = 1;
 
 	ordered = btrfs_lookup_ordered_extent(inode, offset);
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index ff1f69a..3f18fdb 100644
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -123,8 +123,8 @@ struct btrfs_ordered_extent {
 static inline int btrfs_ordered_sum_size(struct btrfs_root *root,
 					 unsigned long bytes)
 {
-	unsigned long num_sectors = (bytes + root->sectorsize - 1) /
-		root->sectorsize;
+	unsigned long num_sectors = (bytes + root->fs_info->sectorsize - 1) /
+		root->fs_info->sectorsize;
 	num_sectors++;
 	return sizeof(struct btrfs_ordered_sum) +
 		num_sectors * sizeof(struct btrfs_sector_sum);
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 59bb176..0d81f08 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1571,8 +1571,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
 				end = key.offset +
 				      btrfs_file_extent_num_bytes(leaf, fi);
 				WARN_ON(!IS_ALIGNED(key.offset,
-						    root->sectorsize));
-				WARN_ON(!IS_ALIGNED(end, root->sectorsize));
+						    root->fs_info->sectorsize));
+				WARN_ON(!IS_ALIGNED(end, root->fs_info->sectorsize));
 				end--;
 				ret = try_lock_extent(&BTRFS_I(inode)->io_tree,
 						      key.offset, end,
@@ -1929,7 +1929,7 @@ static int invalidate_extent_cache(struct btrfs_root *root,
 				start = 0;
 			else {
 				start = min_key->offset;
-				WARN_ON(!IS_ALIGNED(start, root->sectorsize));
+				WARN_ON(!IS_ALIGNED(start, root->fs_info->sectorsize));
 			}
 		} else {
 			start = 0;
@@ -1944,7 +1944,7 @@ static int invalidate_extent_cache(struct btrfs_root *root,
 				if (max_key->offset == 0)
 					continue;
 				end = max_key->offset;
-				WARN_ON(!IS_ALIGNED(end, root->sectorsize));
+				WARN_ON(!IS_ALIGNED(end, root->fs_info->sectorsize));
 				end--;
 			}
 		} else {
@@ -2033,7 +2033,7 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
 		btrfs_unlock_up_safe(path, 0);
 	}
 
-	min_reserved = root->nodesize * (BTRFS_MAX_LEVEL - 1) * 2;
+	min_reserved = root->fs_info->nodesize * (BTRFS_MAX_LEVEL - 1) * 2;
 	memset(&next_key, 0, sizeof(next_key));
 
 	while (1) {
@@ -2145,7 +2145,7 @@ int prepare_to_merge(struct reloc_control *rc, int err)
 	int ret;
 
 	mutex_lock(&root->fs_info->reloc_mutex);
-	rc->merging_rsv_size += root->nodesize * (BTRFS_MAX_LEVEL - 1) * 2;
+	rc->merging_rsv_size += root->fs_info->nodesize * (BTRFS_MAX_LEVEL - 1) * 2;
 	rc->merging_rsv_size += rc->nodes_relocated * 2;
 	mutex_unlock(&root->fs_info->reloc_mutex);
 
@@ -3646,7 +3646,7 @@ int prepare_to_relocate(struct reloc_control *rc)
 	 * is no reservation in transaction handle.
 	 */
 	ret = btrfs_block_rsv_add(NULL, rc->extent_root, rc->block_rsv,
-				  rc->extent_root->nodesize * 256);
+				  rc->extent_root->fs_info->nodesize * 256);
 	if (ret)
 		return ret;
 
@@ -4277,7 +4277,7 @@ int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len)
 		while (offset < sums->len) {
 			sector_sum->bytenr += ordered->start - disk_bytenr;
 			sector_sum++;
-			offset += root->sectorsize;
+			offset += root->fs_info->sectorsize;
 		}
 
 		btrfs_add_ordered_sum(inode, ordered, sums);
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index a8d03d5..23d44a0 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -666,7 +666,7 @@ static int scrub_find_csum(struct scrub_dev *sdev, u64 logical, u64 len,
 	int ret = 0;
 	unsigned long i;
 	unsigned long num_sectors;
-	u32 sectorsize = sdev->dev->dev_root->sectorsize;
+	u32 sectorsize = sdev->dev->dev_root->fs_info->sectorsize;
 
 	while (!list_empty(&sdev->csum_list)) {
 		sum = list_first_entry(&sdev->csum_list,
@@ -1198,9 +1198,9 @@ int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,
 	/*
 	 * check some assumptions
 	 */
-	if (root->sectorsize != PAGE_SIZE ||
-	    root->sectorsize != root->leafsize ||
-	    root->sectorsize != root->nodesize) {
+	if (root->fs_info->sectorsize != PAGE_SIZE ||
+	    root->fs_info->sectorsize != root->fs_info->leafsize ||
+	    root->fs_info->sectorsize != root->fs_info->nodesize) {
 		printk(KERN_ERR "btrfs_scrub: size assumptions fail\n");
 		return -EINVAL;
 	}
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 15634d4..4a07966 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -320,7 +320,7 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
 				if (info->max_inline) {
 					info->max_inline = max_t(u64,
 						info->max_inline,
-						root->sectorsize);
+						root->fs_info->sectorsize);
 				}
 				printk(KERN_INFO "btrfs: max_inline at %llu\n",
 					(unsigned long long)info->max_inline);
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index babee65..d69bae4 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -483,7 +483,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
 				      struct btrfs_key *key)
 {
 	int found_type;
-	u64 mask = root->sectorsize - 1;
+	u64 mask = root->fs_info->sectorsize - 1;
 	u64 extent_end;
 	u64 alloc_hint;
 	u64 start = key->offset;
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 3c5f2fc..03ef6d0 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1634,9 +1634,9 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
 	generate_random_uuid(device->uuid);
 	spin_lock_init(&device->io_lock);
 	device->generation = trans->transid;
-	device->io_width = root->sectorsize;
-	device->io_align = root->sectorsize;
-	device->sector_size = root->sectorsize;
+	device->io_width = root->fs_info->sectorsize;
+	device->io_align = root->fs_info->sectorsize;
+	device->sector_size = root->fs_info->sectorsize;
 	device->total_bytes = i_size_read(bdev->bd_inode);
 	device->disk_total_bytes = device->total_bytes;
 	device->dev_root = root->fs_info->dev_root;
@@ -2500,7 +2500,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 						   j * stripe_size;
 		}
 	}
-	map->sector_size = extent_root->sectorsize;
+	map->sector_size = extent_root->fs_info->sectorsize;
 	map->stripe_len = BTRFS_STRIPE_LEN;
 	map->io_align = BTRFS_STRIPE_LEN;
 	map->io_width = BTRFS_STRIPE_LEN;
@@ -2609,7 +2609,7 @@ static int __finish_chunk_alloc(struct btrfs_trans_handle *trans,
 	btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);
 	btrfs_set_stack_chunk_io_align(chunk, map->stripe_len);
 	btrfs_set_stack_chunk_io_width(chunk, map->stripe_len);
-	btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize);
+	btrfs_set_stack_chunk_sector_size(chunk, extent_root->fs_info->sectorsize);
 	btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
 
 	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;

Re: [patch] Move nodesize/leafsize/sectorsize to fs_info

[David Sterba]

Hi,

sorry for late reply. This patch tries to unify node-/leaf-/... sizes
nad put it just into fs_info, but this assumes all trees share the same
sizes. Unfortunatelly this is not true (once we allow big blocks; soon?).

The root tree has a hardcoded size of 4k, see the __setup_root called
with 4k in open_ctree:

1760         __setup_root(4096, 4096, 4096, 4096, tree_root,
1761                      fs_info, BTRFS_ROOT_TREE_OBJECTID);

the other trees have size defined during mkfs. And only these trees
share the size. You'd have to add exception to use 4k or ->leafsize
depending on the tree being used. It's less error prone to always just
the structure item as it will hold always the correct value, although
there is some memory wasted.

>From the peformace POV, the ->leafsize etc items can cause cacheline
bouncing when any of the code wants to access the item (and it's not
that rare) for a different tree / cpu. But anyway with current
performance status, this effect will be hardly measurable.

On Sun, Aug 07, 2011 at 11:54:31PM +0200, Peeters Simon wrote:
> [1] https://btrfs.wiki.kernel.org/index.php/Cleanup_ideas

I'd like to see how this idea was expected to be implemented, but
there's no wiki to check.


david

Re: [patch] Move nodesize/leafsize/sectorsize to fs_info

[Arne Jansen]

On 10/26/2011 03:34 PM, David Sterba wrote:
> Hi,
>
> sorry for late reply. This patch tries to unify node-/leaf-/... sizes
> nad put it just into fs_info, but this assumes all trees share the same
> sizes. Unfortunatelly this is not true (once we allow big blocks; soon?).
>
> The root tree has a hardcoded size of 4k, see the __setup_root called
> with 4k in open_ctree:
>
> 1760         __setup_root(4096, 4096, 4096, 4096, tree_root,
> 1761                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
>
> the other trees have size defined during mkfs. And only these trees
> share the size. You'd have to add exception to use 4k or ->leafsize
> depending on the tree being used. It's less error prone to always just
> the structure item as it will hold always the correct value, although
> there is some memory wasted.

The sizes get initialized to 4096, but after the super block is read,
these are replaced by those from the SB.

>
>  From the peformace POV, the ->leafsize etc items can cause cacheline
> bouncing when any of the code wants to access the item (and it's not
> that rare) for a different tree / cpu. But anyway with current
> performance status, this effect will be hardly measurable.
>
> On Sun, Aug 07, 2011 at 11:54:31PM +0200, Peeters Simon wrote:
>> [1] https://btrfs.wiki.kernel.org/index.php/Cleanup_ideas
>
> I'd like to see how this idea was expected to be implemented, but
> there's no wiki to check.

It was indeed meant to get rid of the possibility to have different
sizes for different trees, as it just adds complexity. Chris mentioned
once that he does not intend to allow different sizes between trees,
thus the idea for this cleanup.

-Arne

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

Re: [patch] Move nodesize/leafsize/sectorsize to fs_info

[David Sterba]

On Wed, Oct 26, 2011 at 04:47:15PM +0200, Arne Jansen wrote:
> The sizes get initialized to 4096, but after the super block is read,
> these are replaced by those from the SB.

[reads sources again] right, and the initial values are not used up to
that point, so 4096 could be any number.

> It was indeed meant to get rid of the possibility to have different
> sizes for different trees, as it just adds complexity. Chris mentioned
> once that he does not intend to allow different sizes between trees,
> thus the idea for this cleanup.

Ok then. I'll gather it to cleanup patch queue.


david

Re: [patch] Move nodesize/leafsize/sectorsize to fs_info

[Chris Mason]

On Wed, Oct 26, 2011 at 06:23:38PM +0200, David Sterba wrote:
> On Wed, Oct 26, 2011 at 04:47:15PM +0200, Arne Jansen wrote:
> > The sizes get initialized to 4096, but after the super block is read,
> > these are replaced by those from the SB.
> 
> [reads sources again] right, and the initial values are not used up to
> that point, so 4096 could be any number.
> 
> > It was indeed meant to get rid of the possibility to have different
> > sizes for different trees, as it just adds complexity. Chris mentioned
> > once that he does not intend to allow different sizes between trees,
> > thus the idea for this cleanup.
> 
> Ok then. I'll gather it to cleanup patch queue.

Thanks, I actually don't intend to allow different leaf and node sizes
anymore either, but we might as well keep both numbers.

-chris

Re: [patch] Move nodesize/leafsize/sectorsize to fs_info

[Arne Jansen]

On 10/26/2011 06:27 PM, Chris Mason wrote:
> On Wed, Oct 26, 2011 at 06:23:38PM +0200, David Sterba wrote:
>> On Wed, Oct 26, 2011 at 04:47:15PM +0200, Arne Jansen wrote:
>>> The sizes get initialized to 4096, but after the super block is read,
>>> these are replaced by those from the SB.
>>
>> [reads sources again] right, and the initial values are not used up to
>> that point, so 4096 could be any number.
>>
>>> It was indeed meant to get rid of the possibility to have different
>>> sizes for different trees, as it just adds complexity. Chris mentioned
>>> once that he does not intend to allow different sizes between trees,
>>> thus the idea for this cleanup.
>>
>> Ok then. I'll gather it to cleanup patch queue.
>
> Thanks, I actually don't intend to allow different leaf and node sizes
> anymore either, but we might as well keep both numbers.

So that would be another good cleanup, as it is not always easy to tell
if a block is a node or a leaf. It would actually simplify things.

-Arne

>
> -chris
>

Re: [patch] Move nodesize/leafsize/sectorsize to fs_info

[David Sterba]

Hi Simon,

On Sun, Aug 07, 2011 at 11:54:31PM +0200, Peeters Simon wrote:
> moved nodesize, leafsize and sectorsize from btrfs_root to
> btrfs_fs_info as mentioned in [1] and updated everything accordingly.
> patch against the "for-linus" tree
> builds and loads, no further testing done.

Please add a "btrfs:" prefix to the subject line of the patch and add
your "Signed-off-by:" line, and also revise the changelog, so it
describes what the patch does and why, no need to reference the wiki
there (you can add such information after a '---' marker following the
changelog).

Please rebase your patch on top of Josef's for-chris branch, the sources
have evolved since your first posting (though the fixup is trivial, but
the process still needs your S-O-B line).


thanks,
david