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

Commit e17cade2 authored by Chris Mason's avatar Chris Mason
Browse files

Btrfs: Add chunk uuids and update multi-device back references 



Block headers now store the chunk tree uuid

Chunk items records the device uuid for each stripes

Device extent items record better back refs to the chunk tree

Block groups record better back refs to the chunk tree

The chunk tree format has also changed.  The objectid of BTRFS_CHUNK_ITEM_KEY
used to be the logical offset of the chunk.  Now it is a chunk tree id,
with the logical offset being stored in the offset field of the key.

This allows a single chunk tree to record multiple logical address spaces,
upping the number of bytes indexed by a chunk tree from 2^64 to
2^128.

Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parent b248a415

fs/btrfs/ctree.c

+12 −0
Original line number Diff line number Diff line
@@ -1382,6 +1382,11 @@ static int noinline insert_new_root(struct btrfs_trans_handle *trans, 
	write_extent_buffer(c, root->fs_info->fsid,

			    (unsigned long)btrfs_header_fsid(c),

			    BTRFS_FSID_SIZE);



	write_extent_buffer(c, root->fs_info->chunk_tree_uuid,

			    (unsigned long)btrfs_header_chunk_tree_uuid(c),

			    BTRFS_UUID_SIZE);



	btrfs_set_node_key(c, &lower_key, 0);

	btrfs_set_node_blockptr(c, 0, lower->start);

	lower_gen = btrfs_header_generation(lower);
@@ -1513,6 +1518,9 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root 
	write_extent_buffer(split, root->fs_info->fsid,

			    (unsigned long)btrfs_header_fsid(split),

			    BTRFS_FSID_SIZE);

	write_extent_buffer(split, root->fs_info->chunk_tree_uuid,

			    (unsigned long)btrfs_header_chunk_tree_uuid(split),

			    BTRFS_UUID_SIZE);



	mid = (c_nritems + 1) / 2;
@@ -2043,6 +2051,10 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root 
	write_extent_buffer(right, root->fs_info->fsid,

			    (unsigned long)btrfs_header_fsid(right),

			    BTRFS_FSID_SIZE);



	write_extent_buffer(right, root->fs_info->chunk_tree_uuid,

			    (unsigned long)btrfs_header_chunk_tree_uuid(right),

			    BTRFS_UUID_SIZE);

	if (mid <= slot) {

		if (nritems == 1 ||

		    leaf_space_used(l, mid, nritems - mid) + space_needed >

fs/btrfs/ctree.h

+67 −13
Original line number Diff line number Diff line
@@ -70,6 +70,7 @@ extern struct kmem_cache *btrfs_path_cachep; 
 * All files have objectids higher than this.

 */

#define BTRFS_FIRST_FREE_OBJECTID 256ULL

#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL





/*
@@ -131,7 +132,7 @@ struct btrfs_mapping_tree { 
	struct extent_map_tree map_tree;

};



#define BTRFS_DEV_UUID_SIZE 16

#define BTRFS_UUID_SIZE 16

struct btrfs_dev_item {

	/* the internal btrfs device id */

	__le64 devid;
@@ -154,17 +155,32 @@ struct btrfs_dev_item { 
	/* type and info about this device */

	__le64 type;



	/* grouping information for allocation decisions */

	__le32 dev_group;



	/* seek speed 0-100 where 100 is fastest */

	u8 seek_speed;



	/* bandwidth 0-100 where 100 is fastest */

	u8 bandwidth;



	/* btrfs generated uuid for this device */

	u8 uuid[BTRFS_DEV_UUID_SIZE];

	u8 uuid[BTRFS_UUID_SIZE];

} __attribute__ ((__packed__));



struct btrfs_stripe {

	__le64 devid;

	__le64 offset;

	u8 dev_uuid[BTRFS_UUID_SIZE];

} __attribute__ ((__packed__));



struct btrfs_chunk {

	/* size of this chunk in bytes */

	__le64 length;



	/* objectid of the root referencing this chunk */

	__le64 owner;



	__le64 stripe_len;

	__le64 type;
@@ -199,10 +215,14 @@ static inline unsigned long btrfs_chunk_item_size(int num_stripes) 
 * every tree block (leaf or node) starts with this header.

 */

struct btrfs_header {

	/* these first four must match the super block */

	u8 csum[BTRFS_CSUM_SIZE];

	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */

	__le64 bytenr; /* which block this node is supposed to live in */

	__le64 flags;



	/* allowed to be different from the super from here on down */

	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];

	__le64 generation;

	__le64 owner;

	__le32 nritems;
@@ -235,6 +255,8 @@ struct btrfs_super_block { 
	u8 fsid[16];    /* FS specific uuid */

	__le64 bytenr; /* this block number */

	__le64 flags;



	/* allowed to be different from the btrfs_header from here own down */

	__le64 magic;

	__le64 generation;

	__le64 root;
@@ -323,14 +345,16 @@ struct btrfs_extent_ref { 


/* dev extents record free space on individual devices.  The owner

 * field points back to the chunk allocation mapping tree that allocated

 * the extent

 * the extent.  The chunk tree uuid field is a way to double check the owner

 */

struct btrfs_dev_extent {

	__le64 owner;

	__le64 chunk_tree;

	__le64 chunk_objectid;

	__le64 chunk_offset;

	__le64 length;

	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];

} __attribute__ ((__packed__));





struct btrfs_inode_ref {

	__le16 name_len;

	/* name goes here */
@@ -424,7 +448,6 @@ struct btrfs_csum_item { 


struct btrfs_block_group_item {

	__le64 used;

	__le64 chunk_tree;

	__le64 chunk_objectid;

	__le64 flags;

} __attribute__ ((__packed__));
@@ -451,6 +474,7 @@ struct btrfs_device; 
struct btrfs_fs_devices;

struct btrfs_fs_info {

	u8 fsid[BTRFS_FSID_SIZE];

	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];

	struct btrfs_root *extent_root;

	struct btrfs_root *tree_root;

	struct btrfs_root *chunk_root;
@@ -697,6 +721,9 @@ BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32); 
BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);

BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);

BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);

BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);

BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);

BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);



BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);

BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
@@ -710,12 +737,19 @@ BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item, 
BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,

			 sector_size, 32);

BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);

BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,

			 dev_group, 32);

BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,

			 seek_speed, 8);

BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,

			 bandwidth, 8);



static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)

{

	return (char *)d + offsetof(struct btrfs_dev_item, uuid);

}



BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);

BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);

BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);

BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
@@ -726,6 +760,12 @@ BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16); 
BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);

BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);



static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)

{

	return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);

}



BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);

BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);

BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,

			 stripe_len, 64);
@@ -781,13 +821,10 @@ BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item, 
			 used, 64);

BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,

			 used, 64);

BTRFS_SETGET_STACK_FUNCS(block_group_chunk_tree, struct btrfs_block_group_item,

			 chunk_tree, 64);

BTRFS_SETGET_FUNCS(disk_block_group_chunk_tree, struct btrfs_block_group_item,

			 chunk_tree, 64);

BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,

			struct btrfs_block_group_item, chunk_objectid, 64);

BTRFS_SETGET_FUNCS(disk_block_group_chunk_objecitd,



BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,

		   struct btrfs_block_group_item, chunk_objectid, 64);

BTRFS_SETGET_FUNCS(disk_block_group_flags,

		   struct btrfs_block_group_item, flags, 64);
@@ -850,9 +887,20 @@ BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32); 
BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 32);



/* struct btrfs_dev_extent */

BTRFS_SETGET_FUNCS(dev_extent_owner, struct btrfs_dev_extent, owner, 64);

BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,

		   chunk_tree, 64);

BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,

		   chunk_objectid, 64);

BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,

		   chunk_offset, 64);

BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);



static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)

{

	unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);

	return (u8 *)((unsigned long)dev + ptr);

}



/* struct btrfs_extent_ref */

BTRFS_SETGET_FUNCS(ref_root, struct btrfs_extent_ref, root, 64);

BTRFS_SETGET_FUNCS(ref_generation, struct btrfs_extent_ref, generation, 64);
@@ -1087,6 +1135,12 @@ static inline u8 *btrfs_header_fsid(struct extent_buffer *eb) 
	return (u8 *)ptr;

}



static inline u8 *btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)

{

	unsigned long ptr = offsetof(struct btrfs_header, chunk_tree_uuid);

	return (u8 *)ptr;

}



static inline u8 *btrfs_super_fsid(struct extent_buffer *eb)

{

	unsigned long ptr = offsetof(struct btrfs_super_block, fsid);
@@ -1311,7 +1365,7 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info); 
int btrfs_read_block_groups(struct btrfs_root *root);

int btrfs_make_block_group(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, u64 bytes_used,

			   u64 type, u64 chunk_tree, u64 chunk_objectid,

			   u64 type, u64 chunk_objectid, u64 chunk_offset,

			   u64 size);

/* ctree.c */

int btrfs_previous_item(struct btrfs_root *root,

fs/btrfs/disk-io.c

+5 −1
Original line number Diff line number Diff line
@@ -1125,6 +1125,10 @@ struct btrfs_root *open_ctree(struct super_block *sb, 
					   blocksize);

	BUG_ON(!chunk_root->node);



	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,

	         (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),

		 BTRFS_UUID_SIZE);



	ret = btrfs_read_chunk_tree(chunk_root);

	BUG_ON(ret);
@@ -1229,7 +1233,7 @@ int write_all_supers(struct btrfs_root *root) 
		btrfs_set_device_sector_size(sb, dev_item, dev->sector_size);

		write_extent_buffer(sb, dev->uuid,

				    (unsigned long)btrfs_device_uuid(dev_item),

				    BTRFS_DEV_UUID_SIZE);

				    BTRFS_UUID_SIZE);



		btrfs_set_header_flag(sb, BTRFS_HEADER_FLAG_WRITTEN);

		csum_tree_block(root, sb, 0);

fs/btrfs/extent-tree.c

+8 −14
Original line number Diff line number Diff line
@@ -35,10 +35,6 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, struct 
				 btrfs_root *extent_root);

static int del_pending_extents(struct btrfs_trans_handle *trans, struct

			       btrfs_root *extent_root);

int btrfs_make_block_group(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, u64 bytes_used,

			   u64 type, u64 chunk_tree, u64 chunk_objectid,

			   u64 size);





static int cache_block_group(struct btrfs_root *root,
@@ -980,7 +976,6 @@ int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 
		ret = get_state_private(block_group_cache, start, &ptr);

		if (ret)

			break;



		cache = (struct btrfs_block_group_cache *)(unsigned long)ptr;

		err = write_one_cache_group(trans, root,

					    path, cache);
@@ -1094,8 +1089,7 @@ printk("space info full %Lu\n", flags); 
	BUG_ON(ret);



	ret = btrfs_make_block_group(trans, extent_root, 0, flags,

		     extent_root->fs_info->chunk_root->root_key.objectid,

		     start, num_bytes);

		     BTRFS_FIRST_CHUNK_TREE_OBJECTID, start, num_bytes);

	BUG_ON(ret);



	return 0;
@@ -2782,7 +2776,7 @@ int btrfs_read_block_groups(struct btrfs_root *root) 


int btrfs_make_block_group(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, u64 bytes_used,

			   u64 type, u64 chunk_tree, u64 chunk_objectid,

			   u64 type, u64 chunk_objectid, u64 chunk_offset,

			   u64 size)

{

	int ret;
@@ -2796,14 +2790,14 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, 


	cache = kmalloc(sizeof(*cache), GFP_NOFS);

	BUG_ON(!cache);

	cache->key.objectid = chunk_objectid;

	cache->key.objectid = chunk_offset;

	cache->key.offset = size;

	cache->cached = 0;

	cache->pinned = 0;



	btrfs_set_key_type(&cache->key, BTRFS_BLOCK_GROUP_ITEM_KEY);

	memset(&cache->item, 0, sizeof(cache->item));

	btrfs_set_block_group_used(&cache->item, bytes_used);

	btrfs_set_block_group_chunk_tree(&cache->item, chunk_tree);

	btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);

	cache->flags = type;

	btrfs_set_block_group_flags(&cache->item, type);
@@ -2813,12 +2807,12 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, 
	BUG_ON(ret);



	bit = block_group_state_bits(type);

	set_extent_bits(block_group_cache, chunk_objectid,

			chunk_objectid + size - 1,

	set_extent_bits(block_group_cache, chunk_offset,

			chunk_offset + size - 1,

			bit | EXTENT_LOCKED, GFP_NOFS);

	set_state_private(block_group_cache, chunk_objectid,

			  (unsigned long)cache);



	set_state_private(block_group_cache, chunk_offset,

			  (unsigned long)cache);

	ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,

				sizeof(cache->item));

	BUG_ON(ret);

fs/btrfs/print-tree.c

+14 −6
Original line number Diff line number Diff line
@@ -24,7 +24,8 @@ static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk) 
{

	int num_stripes = btrfs_chunk_num_stripes(eb, chunk);

	int i;

	printk("\t\tchunk owner %llu type %llu num_stripes %d\n",

	printk("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n",

	       (unsigned long long)btrfs_chunk_length(eb, chunk),

	       (unsigned long long)btrfs_chunk_owner(eb, chunk),

	       (unsigned long long)btrfs_chunk_type(eb, chunk),

	       num_stripes);
@@ -140,17 +141,24 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l) 
		case BTRFS_DEV_EXTENT_KEY:

			dev_extent = btrfs_item_ptr(l, i,

						    struct btrfs_dev_extent);

			printk("\t\tdev extent owner %llu length %llu\n",

			       (unsigned long long)btrfs_dev_extent_owner(l, dev_extent),

			       (unsigned long long)btrfs_dev_extent_length(l, dev_extent));

			printk("\t\tdev extent chunk_tree %llu\n"

			       "\t\tchunk objectid %llu chunk offset %llu "

			       "length %llu\n",

			       (unsigned long long)

			       btrfs_dev_extent_chunk_tree(l, dev_extent),

			       (unsigned long long)

			       btrfs_dev_extent_chunk_objectid(l, dev_extent),

			       (unsigned long long)

			       btrfs_dev_extent_chunk_offset(l, dev_extent),

			       (unsigned long long)

			       btrfs_dev_extent_length(l, dev_extent));

		};

	}

}



void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *c)

{

	int i;

	u32 nr;

	int i; u32 nr;

	struct btrfs_key key;

	int level;