Btrfs: working file_write, reorganized key flags (a429e513) · Commits · e / devices / android_kernel_oneplus_sm7250

fs/btrfs/ctree.c

+27 −3

Original line number	Diff line number	Diff line
		@@ -893,7 +893,11 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
		}

		left_nritems = btrfs_header_nritems(&left->header);
		for (i = left_nritems - 1; i >= 0; i--) {
		if (left_nritems == 0) {
		btrfs_block_release(root, right_buf);
		return 1;
		}
		for (i = left_nritems - 1; i >= 1; i--) {
		item = left->items + i;
		if (path->slots[0] == i)
		push_space += data_size + sizeof(*item);
		@@ -907,6 +911,8 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
		btrfs_block_release(root, right_buf);
		return 1;
		}
		if (push_items == left_nritems)
		WARN_ON(1);
		right_nritems = btrfs_header_nritems(&right->header);
		/* push left to right */
		push_space = btrfs_item_end(left->items + left_nritems - push_items);
		@@ -943,6 +949,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root

		btrfs_mark_buffer_dirty(left_buf);
		btrfs_mark_buffer_dirty(right_buf);

		btrfs_memcpy(root, upper_node, &upper_node->ptrs[slot + 1].key,
		&right->items[0].key, sizeof(struct btrfs_disk_key));
		btrfs_mark_buffer_dirty(upper);
		@@ -1004,7 +1011,12 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
		return 1;
		}

		for (i = 0; i < btrfs_header_nritems(&right->header); i++) {
		if (btrfs_header_nritems(&right->header) == 0) {
		btrfs_block_release(root, t);
		return 1;
		}

		for (i = 0; i < btrfs_header_nritems(&right->header) - 1; i++) {
		item = right->items + i;
		if (path->slots[0] == i)
		push_space += data_size + sizeof(*item);
		@@ -1018,6 +1030,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
		btrfs_block_release(root, t);
		return 1;
		}
		if (push_items == btrfs_header_nritems(&right->header))
		WARN_ON(1);
		/* push data from right to left */
		btrfs_memcpy(root, left, left->items +
		btrfs_header_nritems(&left->header),
		@@ -1064,7 +1078,6 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root

		btrfs_mark_buffer_dirty(t);
		btrfs_mark_buffer_dirty(right_buf);

		wret = fixup_low_keys(trans, root, path, &right->items[0].key, 1);
		if (wret)
		ret = wret;
		@@ -1181,6 +1194,12 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
		path->nodes[0] = right_buffer;
		path->slots[0] = 0;
		path->slots[1] -= 1;
		if (path->slots[1] == 0) {
		wret = fixup_low_keys(trans, root,
		path, &disk_key, 1);
		if (wret)
		ret = wret;
		}
		return ret;
		}
		mid = slot;
		@@ -1241,6 +1260,11 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
		path->slots[1], 1);
		if (wret)
		ret = wret;
		if (path->slots[1] == 0) {
		wret = fixup_low_keys(trans, root, path, &disk_key, 1);
		if (wret)
		ret = wret;
		}
		btrfs_block_release(root, path->nodes[0]);
		path->nodes[0] = right_buffer;
		path->slots[0] = 0;

fs/btrfs/ctree.h

+26 −26

Original line number	Diff line number	Diff line
		@@ -282,11 +282,12 @@ struct btrfs_root {

		/* the lower bits in the key flags defines the item type */
		#define BTRFS_KEY_TYPE_MAX 256
		#define BTRFS_KEY_TYPE_MASK (BTRFS_KEY_TYPE_MAX - 1)
		#define BTRFS_KEY_TYPE_SHIFT 24
		#define BTRFS_KEY_TYPE_MASK (((u32)BTRFS_KEY_TYPE_MAX - 1) << \
		BTRFS_KEY_TYPE_SHIFT)

		#define BTRFS_KEY_OVERFLOW_MAX 128
		#define BTRFS_KEY_OVERFLOW_SHIFT 8
		#define BTRFS_KEY_OVERFLOW_MASK (0x7FULL << BTRFS_KEY_OVERFLOW_SHIFT)
		#define BTRFS_KEY_OVERFLOW_MASK ((u32)BTRFS_KEY_OVERFLOW_MAX - 1)

		/*
		* inode items have the data typically returned from stat and store other
		@@ -586,56 +587,55 @@ static inline void btrfs_set_disk_key_flags(struct btrfs_disk_key *disk,
		disk->flags = cpu_to_le32(val);
		}

		static inline u32 btrfs_key_overflow(struct btrfs_key *key)
		static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
		{
		u32 over = key->flags & BTRFS_KEY_OVERFLOW_MASK;
		return over >> BTRFS_KEY_OVERFLOW_SHIFT;
		return le32_to_cpu(key->flags) >> BTRFS_KEY_TYPE_SHIFT;
		}

		static inline void btrfs_set_key_overflow(struct btrfs_key *key, u32 over)
		static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key,
		u32 val)
		{
		BUG_ON(over >= BTRFS_KEY_OVERFLOW_MAX);
		over = over << BTRFS_KEY_OVERFLOW_SHIFT;
		key->flags = (key->flags & ~((u64)BTRFS_KEY_OVERFLOW_MASK)) \| over;
		u32 flags = btrfs_disk_key_flags(key);
		BUG_ON(val >= BTRFS_KEY_TYPE_MAX);
		val = val << BTRFS_KEY_TYPE_SHIFT;
		flags = (flags & ~BTRFS_KEY_TYPE_MASK) \| val;
		btrfs_set_disk_key_flags(key, flags);
		}

		static inline u32 btrfs_key_type(struct btrfs_key *key)
		{
		return key->flags & BTRFS_KEY_TYPE_MASK;
		return key->flags >> BTRFS_KEY_TYPE_SHIFT;
		}

		static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
		static inline void btrfs_set_key_type(struct btrfs_key *key, u32 val)
		{
		return le32_to_cpu(key->flags) & BTRFS_KEY_TYPE_MASK;
		BUG_ON(val >= BTRFS_KEY_TYPE_MAX);
		val = val << BTRFS_KEY_TYPE_SHIFT;
		key->flags = (key->flags & ~(BTRFS_KEY_TYPE_MASK)) \| val;
		}

		static inline void btrfs_set_key_type(struct btrfs_key *key, u32 type)
		static inline u32 btrfs_key_overflow(struct btrfs_key *key)
		{
		BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
		key->flags = (key->flags & ~((u64)BTRFS_KEY_TYPE_MASK)) \| type;
		return key->flags & BTRFS_KEY_OVERFLOW_MASK;
		}

		static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key, u32 type)
		static inline void btrfs_set_key_overflow(struct btrfs_key *key, u32 over)
		{
		u32 flags = btrfs_disk_key_flags(key);
		BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
		flags = (flags & ~((u64)BTRFS_KEY_TYPE_MASK)) \| type;
		btrfs_set_disk_key_flags(key, flags);
		BUG_ON(over >= BTRFS_KEY_OVERFLOW_MAX);
		key->flags = (key->flags & ~BTRFS_KEY_OVERFLOW_MASK) \| over;
		}

		static inline u32 btrfs_disk_key_overflow(struct btrfs_disk_key *key)
		{
		u32 over = le32_to_cpu(key->flags) & BTRFS_KEY_OVERFLOW_MASK;
		return over >> BTRFS_KEY_OVERFLOW_SHIFT;
		return le32_to_cpu(key->flags) & BTRFS_KEY_OVERFLOW_MASK;
		}

		static inline void btrfs_set_disK_key_overflow(struct btrfs_disk_key *key,
		static inline void btrfs_set_disk_key_overflow(struct btrfs_disk_key *key,
		u32 over)
		{
		u32 flags = btrfs_disk_key_flags(key);
		BUG_ON(over >= BTRFS_KEY_OVERFLOW_MAX);
		over = over << BTRFS_KEY_OVERFLOW_SHIFT;
		flags = (flags & ~((u64)BTRFS_KEY_OVERFLOW_MASK)) \| over;
		flags = (flags & ~BTRFS_KEY_OVERFLOW_MASK) \| over;
		btrfs_set_disk_key_flags(key, flags);
		}

fs/btrfs/dir-item.c

+0 −70

Original line number	Diff line number	Diff line
		@@ -58,30 +58,6 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root

		btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
		btrfs_mark_buffer_dirty(path->nodes[0]);

		/* FIXME, use some real flag for selecting the extra index */
		if (root == root->fs_info->tree_root)
		goto out;

		btrfs_release_path(root, path);

		btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
		key.offset = location->objectid;
		ret = insert_with_overflow(trans, root, path, &key, data_size);
		// FIXME clear the dirindex bit
		if (ret)
		goto out;

		dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
		path->slots[0],
		struct btrfs_dir_item);
		btrfs_cpu_key_to_disk(&dir_item->location, location);
		btrfs_set_dir_type(dir_item, type);
		btrfs_set_dir_flags(dir_item, 0);
		btrfs_set_dir_name_len(dir_item, name_len);
		name_ptr = (char *)(dir_item + 1);
		btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
		btrfs_mark_buffer_dirty(path->nodes[0]);
		out:
		btrfs_release_path(root, path);
		btrfs_free_path(path);
		@@ -135,52 +111,6 @@ int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
		return 1;
		}

		int btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
		struct btrfs_root *root,
		struct btrfs_path *path, u64 dir,
		u64 objectid, int mod)
		{
		int ret;
		struct btrfs_key key;
		int ins_len = mod < 0 ? -1 : 0;
		int cow = mod != 0;
		struct btrfs_disk_key *found_key;
		struct btrfs_leaf *leaf;
		int overflow = 0;

		key.objectid = dir;
		key.flags = 0;
		btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
		key.offset = objectid;

		while(1) {
		btrfs_set_key_overflow(&key, overflow);
		ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
		if (ret < 0)
		return ret;
		if (ret > 0) {
		if (overflow >= BTRFS_KEY_OVERFLOW_MAX)
		return 1;
		overflow++;
		btrfs_set_key_overflow(&key, overflow);
		btrfs_release_path(root, path);
		continue;
		} else {
		/* found */
		break;
		}
		}
		leaf = btrfs_buffer_leaf(path->nodes[0]);
		found_key = &leaf->items[path->slots[0]].key;

		if (btrfs_disk_key_objectid(found_key) != dir \|\|
		btrfs_disk_key_type(found_key) != BTRFS_DIR_INDEX_KEY)
		return 1;
		if (btrfs_disk_key_offset(found_key) == objectid)
		return 0;
		return 1;
		}

		int btrfs_match_dir_item_name(struct btrfs_root *root,
		struct btrfs_path *path,
		const char *name, int name_len)

fs/btrfs/extent-tree.c

+3 −1

Original line number	Diff line number	Diff line
		@@ -35,8 +35,10 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
		key.offset = num_blocks;
		ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key, path,
		0, 1);
		if (ret != 0)
		if (ret != 0) {
		printk("can't find block %Lu %Lu\n", blocknr, num_blocks);
		BUG();
		}
		BUG_ON(ret != 0);
		l = btrfs_buffer_leaf(path->nodes[0]);
		item = btrfs_item_ptr(l, path->slots[0], struct btrfs_extent_item);

fs/btrfs/file-item.c

+47 −19

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@
		#include "transaction.h"

		#define MAX_CSUM_ITEMS(r) ((((BTRFS_LEAF_DATA_SIZE(r) - \
		sizeof(struct btrfs_item)) / \
		sizeof(struct btrfs_item) * 2) / \
		sizeof(struct btrfs_csum_item)) - 1))
		int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
		struct btrfs_root *root,
		@@ -19,11 +19,6 @@ int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
		path = btrfs_alloc_path();
		BUG_ON(!path);
		btrfs_init_path(path);
		/*
		ret = btrfs_alloc_extent(trans, root, num_blocks, hint_block,
		(u64)-1, &ins);
		*/
		BUG_ON(ret);
		file_key.objectid = objectid;
		file_key.offset = pos;
		file_key.flags = 0;
		@@ -40,6 +35,7 @@ int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
		btrfs_set_file_extent_num_blocks(item, num_blocks);
		btrfs_set_file_extent_generation(item, trans->transid);
		btrfs_mark_buffer_dirty(path->nodes[0]);

		btrfs_release_path(root, path);
		btrfs_free_path(path);
		return 0;
		@@ -57,6 +53,7 @@ struct btrfs_csum_item btrfs_lookup_csum(struct btrfs_trans_handle trans,
		struct btrfs_csum_item *item;
		struct btrfs_leaf *leaf;
		u64 csum_offset = 0;
		int csums_in_item;

		file_key.objectid = objectid;
		file_key.offset = offset;
		@@ -79,9 +76,11 @@ struct btrfs_csum_item btrfs_lookup_csum(struct btrfs_trans_handle trans,
		}
		csum_offset = (offset - found_key.offset) >>
		root->fs_info->sb->s_blocksize_bits;
		if (csum_offset >=
		btrfs_item_size(leaf->items + path->slots[0]) /
		sizeof(struct btrfs_csum_item)) {
		csums_in_item = btrfs_item_size(leaf->items + path->slots[0]);
		csums_in_item /= sizeof(struct btrfs_csum_item);

		if (csum_offset >= csums_in_item) {
		ret = -EFBIG;
		goto fail;
		}
		}
		@@ -128,16 +127,36 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,

		path = btrfs_alloc_path();
		BUG_ON(!path);
		btrfs_init_path(path);

		item = btrfs_lookup_csum(trans, root, path, objectid, offset, 0);
		if (!IS_ERR(item))
		goto found;
		btrfs_release_path(root, path);
		file_key.objectid = objectid;
		file_key.offset = offset;
		file_key.flags = 0;
		btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);

		item = btrfs_lookup_csum(trans, root, path, objectid, offset, 1);
		if (!IS_ERR(item))
		goto found;
		ret = PTR_ERR(item);
		if (ret == -EFBIG) {
		u32 item_size;
		/* we found one, but it isn't big enough yet */
		leaf = btrfs_buffer_leaf(path->nodes[0]);
		item_size = btrfs_item_size(leaf->items + path->slots[0]);
		if ((item_size / sizeof(struct btrfs_csum_item)) >=
		MAX_CSUM_ITEMS(root)) {
		/* already at max size, make a new one */
		goto insert;
		}
		} else {
		/* we didn't find a csum item, insert one */
		goto insert;
		}

		/*
		* at this point, we know the tree has an item, but it isn't big
		* enough yet to put our csum in. Grow it
		*/
		btrfs_release_path(root, path);
		ret = btrfs_search_slot(trans, root, &file_key, path,
		sizeof(struct btrfs_csum_item), 1);
		if (ret < 0)
		@@ -146,7 +165,6 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
		BUG();
		}
		if (path->slots[0] == 0) {
		btrfs_release_path(root, path);
		goto insert;
		}
		path->slots[0]--;
		@@ -157,29 +175,36 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
		if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY \|\|
		found_key.objectid != objectid \|\|
		csum_offset >= MAX_CSUM_ITEMS(root)) {
		btrfs_release_path(root, path);
		WARN_ON(1);
		goto insert;
		}
		if (csum_offset >= btrfs_item_size(leaf->items + path->slots[0]) /
		sizeof(struct btrfs_csum_item)) {
		ret = btrfs_extend_item(trans, root, path,
		sizeof(struct btrfs_csum_item));
		u32 diff = (csum_offset + 1) * sizeof(struct btrfs_csum_item);
		diff = diff - btrfs_item_size(leaf->items + path->slots[0]);
		WARN_ON(diff != sizeof(struct btrfs_csum_item));
		ret = btrfs_extend_item(trans, root, path, diff);
		BUG_ON(ret);
		goto csum;
		}

		insert:
		btrfs_release_path(root, path);
		csum_offset = 0;
		ret = btrfs_insert_empty_item(trans, root, path, &file_key,
		sizeof(struct btrfs_csum_item));
		if (ret != 0 && ret != -EEXIST)
		if (ret != 0) {
		printk("at insert for %Lu %u %Lu ret is %d\n", file_key.objectid, file_key.flags, file_key.offset, ret);
		WARN_ON(1);
		goto fail;
		}
		csum:
		item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
		struct btrfs_csum_item);
		ret = 0;
		item += csum_offset;
		found:
		btrfs_check_bounds(item->csum, BTRFS_CSUM_SIZE, path->nodes[0]->b_data, root->fs_info->sb->s_blocksize);
		ret = btrfs_csum_data(root, data, len, item->csum);
		btrfs_mark_buffer_dirty(path->nodes[0]);
		fail:
		@@ -210,6 +235,9 @@ int btrfs_csum_verify_file_block(struct btrfs_root *root,
		item = btrfs_lookup_csum(NULL, root, path, objectid, offset, 0);
		if (IS_ERR(item)) {
		ret = PTR_ERR(item);
		/* a csum that isn't present is a preallocated region. */
		if (ret == -ENOENT \|\| ret == -EFBIG)
		ret = 1;
		goto fail;
		}