btrfs-progs: more prep work for syncing ctree.c
Subsystems (2)
cover btrfs-progs: more prep work for syncing ctree.c
Hello,
These are a bunch of changes that sync various api and structure differences that exist between btrfs-progs and the kernel. Most of these are small, but the last patch is sync'ing tree-checker.[ch]. This was mostly left intact, however there's a slight change to disable some of the checking for tools like fsck or btrfs-image.
This series depends on
btrfs-progs: prep work for syncing files into kernel-shared
btrfs-progs: sync basic code from the kernel
btrfs-progs: prep work for syncing ctree.c
Thanks,
Josef
Josef Bacik (18):
btrfs-progs: sync and stub-out tree-mod-log.h
btrfs-progs: add btrfs_root_id helper
btrfs-progs: remove root argument from free_extent and inc_extent_ref
btrfs-progs: pass root_id for btrfs_free_tree_block
btrfs-progs: add a free_extent_buffer_stale helper
btrfs-progs: add btrfs_is_testing helper
btrfs-progs: add accounting_lock to btrfs_root
btrfs-progs: update read_tree_block to match the kernel definition
btrfs-progs: make reada_for_search static
btrfs-progs: sync btrfs_path fields with the kernel
btrfs-progs: update arguments of find_extent_buffer
btrfs-progs: add btrfs_readahead_node_child helper
btrfs-progs: add an atomic arg to btrfs_buffer_uptodate
btrfs-progs: add a btrfs_read_extent_buffer helper
btrfs-progs: add BTRFS_STRIPE_LEN_SHIFT definition
btrfs-progs: rename btrfs_check_* to __btrfs_check_*
btrfs-progs: change btrfs_check_chunk_valid to match the kernel
version
btrfs-progs: sync tree-checker.[ch]
Makefile | 1 + btrfs-corrupt-block.c | 8 +- btrfs-find-root.c | 2 +- check/clear-cache.c | 5 +- check/main.c | 28 +- check/mode-common.c | 4 +- check/mode-lowmem.c | 31 +- check/qgroup-verify.c | 3 +- check/repair.c | 13 +- cmds/inspect-dump-tree.c | 12 +- cmds/inspect-tree-stats.c | 4 +- cmds/rescue.c | 3 +- cmds/restore.c | 11 +- image/main.c | 25 +- include/kerncompat.h | 10 + kernel-shared/backref.c | 6 +- kernel-shared/ctree.c | 222 +--- kernel-shared/ctree.h | 77 +- kernel-shared/disk-io.c | 92 +- kernel-shared/disk-io.h | 16 +- kernel-shared/extent-tree.c | 33 +- kernel-shared/extent_io.c | 26 +- kernel-shared/extent_io.h | 4 +- kernel-shared/free-space-cache.c | 5 +- kernel-shared/print-tree.c | 4 +- kernel-shared/tree-checker.c | 2064 ++++++++++++++++++++++++++++++ kernel-shared/tree-checker.h | 72 ++ kernel-shared/tree-mod-log.h | 96 ++ kernel-shared/volumes.c | 136 +- kernel-shared/volumes.h | 5 +- tune/change-uuid.c | 2 +- 31 files changed, 2521 insertions(+), 499 deletions(-) create mode 100644 kernel-shared/tree-checker.c create mode 100644 kernel-shared/tree-checker.h create mode 100644 kernel-shared/tree-mod-log.h
Signature · 1 line
2.40.0
PATCH 1/18 btrfs-progs: sync and stub-out tree-mod-log.h
In order to sync ctree.c we're going to have to have definitions for the tree-mod-log stuff. However we don't need any of the code, we don't do live backref lookups in btrfs-progs, so simply sync the header file and stub all the helpers out.
--- kernel-shared/tree-mod-log.h | 96 ++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 kernel-shared/tree-mod-log.h
kernel-shared/tree-mod-log.h new file +96 -0
@@ -0,0 +1,96 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef BTRFS_TREE_MOD_LOG_H +#define BTRFS_TREE_MOD_LOG_H + +#include "ctree.h" + +/* Represents a tree mod log user. */ +struct btrfs_seq_list { +struct list_head list; +u64 seq; +}; + +#define BTRFS_SEQ_LIST_INIT (name) { .list = LIST_HEAD_INIT((name).list), .seq = 0 } +#define BTRFS_SEQ_LAST ((u64)-1) + +enum btrfs_mod_log_op { +BTRFS_MOD_LOG_KEY_REPLACE , +BTRFS_MOD_LOG_KEY_ADD , +BTRFS_MOD_LOG_KEY_REMOVE , +BTRFS_MOD_LOG_KEY_REMOVE_WHILE_FREEING , +BTRFS_MOD_LOG_KEY_REMOVE_WHILE_MOVING , +BTRFS_MOD_LOG_MOVE_KEYS , +BTRFS_MOD_LOG_ROOT_REPLACE , +}; + +static inline u64 btrfs_get_tree_mod_seq (struct btrfs_fs_info *fs_info, +struct btrfs_seq_list *elem) +{ +return 0 ; +} + +static inline void btrfs_put_tree_mod_seq (struct btrfs_fs_info *fs_info, +struct btrfs_seq_list *elem) +{ +} + +static inline int btrfs_tree_mod_log_insert_root (struct extent_buffer *old_root, +struct extent_buffer *new_root, +bool log_removal) +{ +return 0 ; +} + +static inline int btrfs_tree_mod_log_insert_key (struct extent_buffer *eb,int slot, +enum btrfs_mod_log_op op) +{ +return 0 ; +} + +static inline int btrfs_tree_mod_log_free_eb (struct extent_buffer *eb) +{ +return 0 ; +} + +static inline struct extent_buffer *btrfs_tree_mod_log_rewind (struct btrfs_fs_info *fs_info, +struct btrfs_path *path, +struct extent_buffer *eb, +u64 time_seq) +{ +return NULL ; +} + +static inline struct extent_buffer *btrfs_get_old_root (struct btrfs_root *root, +u64 time_seq) +{ +return NULL ; +} + +static inline int btrfs_old_root_level (struct btrfs_root *root,u64 time_seq) +{ +return btrfs_header_level (root->node); +} + +static inline int btrfs_tree_mod_log_eb_copy (struct extent_buffer *dst, +struct extent_buffer *src, +unsigned long dst_offset, +unsigned long src_offset, +int nr_items) +{ +return 0 ; +} + +static inline int btrfs_tree_mod_log_insert_move (struct extent_buffer *eb, +int dst_slot,int src_slot, +int nr_items) +{ +return 0 ; +} + +static inline u64 btrfs_tree_mod_log_lowest_seq (struct btrfs_fs_info *fs_info) +{ +return 0 ; +} + +#endif
Signature · 1 line
2.40.0
PATCH 2/18 btrfs-progs: add btrfs_root_id helper
In reply to Josef BacikThis exists in the kernel and is used throughout ctree.c, sync this helper to make sync'ing ctree.c easier.
--- kernel-shared/ctree.h | 5 +++++ 1 file changed, 5 insertions(+)
kernel-shared/ctree.h +5 -0
@@ -476,6 +476,11 @@ struct btrfs_root {struct rb_node rb_node; }; +static inline u64 btrfs_root_id (const struct btrfs_root *root) +{ +return root->root_key.objectid; +} +static inline u32 BTRFS_MAX_ITEM_SIZE (const struct btrfs_fs_info *info) {return BTRFS_LEAF_DATA_SIZE (info) -sizeof (struct btrfs_item );
Signature · 1 line
2.40.0
PATCH 3/18 btrfs-progs: remove root argument from free_extent and inc_extent_ref
In reply to Josef BacikNeither of these actually need the root argument, we provide all the information for the ref through the arguments we pass through. Remove the root argument from both of them. These needed to be done in the same patch because of the __btrfs_mod_ref helper which will pick one or the other function for processing reference updates.
--- check/clear-cache.c | 5 +++-- check/main.c | 10 ++++------ check/mode-lowmem.c | 10 +++++----- kernel-shared/ctree.c | 29 +++++++++++++---------------- kernel-shared/ctree.h | 2 -- kernel-shared/extent-tree.c | 24 ++++++++++-------------- kernel-shared/free-space-cache.c | 5 ++--- 7 files changed, 37 insertions(+), 48 deletions(-)
check/clear-cache.c +3 -2
@@ -513,8 +513,9 @@ int truncate_free_ino_items(struct btrfs_root *root) extent_offset = found_key.offset -btrfs_file_extent_offset (leaf, fi);UASSERT (extent_offset ==0 ); - ret =btrfs_free_extent (trans, root, extent_disk_bytenr, - extent_num_bytes,0 , root->objectid, + ret =btrfs_free_extent (trans, extent_disk_bytenr, + extent_num_bytes,0 , + root->objectid,BTRFS_FREE_INO_OBJECTID ,0 );if (ret <0 ) {btrfs_abort_transaction (trans, ret);
check/main.c +4 -6
@@ -3586,7 +3586,7 @@ static int repair_btree(struct btrfs_root *root,* return value is not concerned. */ btrfs_release_path (&path); - ret =btrfs_free_extent (trans, root, offset, + ret =btrfs_free_extent (trans, offset, gfs_info->nodesize,0 , root->root_key.objectid, level -1 ,0 ); cache =next_cache_extent (cache);
@@ -6861,9 +6861,8 @@ static int record_extent(struct btrfs_trans_handle *trans,* just makes the backref allocator create a data * backref */ - ret = btrfs_inc_extent_ref(trans, extent_root, - rec->start, rec->max_size, - parent, + ret = btrfs_inc_extent_ref(trans, rec->start, + rec->max_size, parent, dback->root, parent ? BTRFS_FIRST_FREE_OBJECTID :
@@ -6890,8 +6889,7 @@ static int record_extent(struct btrfs_trans_handle *trans,else parent =0 ; - ret =btrfs_inc_extent_ref (trans, extent_root, - rec->start, rec->max_size, + ret =btrfs_inc_extent_ref (trans, rec->start, rec->max_size, parent, tback->root,0 ,0 ); fprintf(stderr, "adding new tree backref on start %llu len %llu parent %llu root %llu\n",
check/mode-lowmem.c +5 -5
@@ -755,8 +755,8 @@ static int repair_tree_block_ref(struct btrfs_root *root, parent = nrefs->bytenr[level +1 ];/* increase the ref */ - ret =btrfs_inc_extent_ref (trans, extent_root, bytenr, node_size, - parent, root->objectid, level,0 ); + ret =btrfs_inc_extent_ref (trans, bytenr, node_size, parent, + root->objectid, level,0 ); nrefs->refs[level]++; out:
@@ -3335,7 +3335,7 @@ static int repair_extent_data_item(struct btrfs_root *root,btrfs_release_path (&path); } - ret =btrfs_inc_extent_ref (trans, root, disk_bytenr, num_bytes, parent, + ret =btrfs_inc_extent_ref (trans, disk_bytenr, num_bytes, parent, root->objectid, parent ?BTRFS_FIRST_FREE_OBJECTID : fi_key.objectid, offset);
@@ -4132,8 +4132,8 @@ static int repair_extent_item(struct btrfs_path *path, u64 bytenr, u64 goto out; }/* delete the backref */ - ret =btrfs_free_extent (trans, gfs_info->fs_root, bytenr, - num_bytes, parent, root_objectid, owner, offset); + ret =btrfs_free_extent (trans, bytenr, num_bytes, parent, root_objectid, + owner, offset);if (!ret)printf ("Delete backref in extent [%llu %llu]\n" , bytenr, num_bytes);
kernel-shared/ctree.c +13 -16
@@ -491,8 +491,8 @@ static int __btrfs_cow_block(struct btrfs_trans_handle *trans, root->node = cow;extent_buffer_get (cow); -btrfs_free_extent (trans, root, buf->start, buf->len, -0 , root->root_key.objectid, level,0 ); +btrfs_free_extent (trans, buf->start, buf->len,0 , + root->root_key.objectid, level,0 );free_extent_buffer (buf);add_root_to_dirty_list (root); }else {
@@ -504,8 +504,8 @@ static int __btrfs_cow_block(struct btrfs_trans_handle *trans,btrfs_mark_buffer_dirty (parent);WARN_ON (btrfs_header_generation (parent) != trans->transid); -btrfs_free_extent (trans, root, buf->start, buf->len, -0 , root->root_key.objectid, level,0 ); +btrfs_free_extent (trans, buf->start, buf->len,0 , + root->root_key.objectid, level,0 ); }if (!list_empty (&buf->recow)) {list_del_init (&buf->recow);
@@ -942,9 +942,8 @@ static int balance_level(struct btrfs_trans_handle *trans,root_sub_used (root, mid->len); - ret =btrfs_free_extent (trans, root, mid->start, mid->len, -0 , root->root_key.objectid, - level,0 ); + ret =btrfs_free_extent (trans, mid->start, mid->len,0 , + root->root_key.objectid, level,0 );/* once for the root ptr */ free_extent_buffer (mid);return ret;
@@ -999,10 +998,9 @@ static int balance_level(struct btrfs_trans_handle *trans, ret = wret;root_sub_used (root, blocksize); - wret =btrfs_free_extent (trans, root, bytenr, - blocksize,0 , - root->root_key.objectid, - level,0 ); + wret =btrfs_free_extent (trans, bytenr, blocksize,0 , + root->root_key.objectid, level, +0 );if (wret) ret = wret; }else {
@@ -1047,9 +1045,8 @@ static int balance_level(struct btrfs_trans_handle *trans, ret = wret;root_sub_used (root, blocksize); - wret =btrfs_free_extent (trans, root, bytenr, blocksize, -0 , root->root_key.objectid, - level,0 ); + wret =btrfs_free_extent (trans, bytenr, blocksize,0 , + root->root_key.objectid, level,0 );if (wret) ret = wret; }else {
@@ -2956,8 +2953,8 @@ static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans,root_sub_used (root, leaf->len); - ret =btrfs_free_extent (trans, root, leaf->start, leaf->len, -0 , root->root_key.objectid,0 ,0 ); + ret =btrfs_free_extent (trans, leaf->start, leaf->len,0 , + root->root_key.objectid,0 ,0 );return ret; }
kernel-shared/ctree.h +0 -2
@@ -875,12 +875,10 @@ int btrfs_free_tree_block(struct btrfs_trans_handle *trans,struct extent_buffer *buf, u64 parent, int last_ref);int btrfs_free_extent (struct btrfs_trans_handle *trans, -struct btrfs_root *root,u64 bytenr,u64 num_bytes,u64 parent,u64 root_objectid,u64 owner,u64 offset);void btrfs_finish_extent_commit (struct btrfs_trans_handle *trans);int btrfs_inc_extent_ref (struct btrfs_trans_handle *trans, -struct btrfs_root *root,u64 bytenr,u64 num_bytes,u64 parent,u64 root_objectid,u64 owner,u64 offset); int btrfs_update_extent_ref(struct btrfs_trans_handle *trans,
kernel-shared/extent-tree.c +10 -14
@@ -1242,11 +1242,10 @@ static int remove_extent_backref(struct btrfs_trans_handle *trans, }int btrfs_inc_extent_ref (struct btrfs_trans_handle *trans, -struct btrfs_root *root,u64 bytenr,u64 num_bytes,u64 parent,u64 root_objectid,u64 owner,u64 offset) { -struct btrfs_root *extent_root =btrfs_extent_root (root->fs_info, +struct btrfs_root *extent_root =btrfs_extent_root (trans->fs_info, bytenr);struct btrfs_path *path;struct extent_buffer *leaf;
@@ -1467,7 +1466,6 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,int level;int ret =0 ;int (*process_func)(struct btrfs_trans_handle *trans, -struct btrfs_root *root,u64 ,u64 ,u64 ,u64 ,u64 ,u64 ); ref_root =btrfs_header_owner (buf);
@@ -1504,9 +1502,8 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, num_bytes =btrfs_file_extent_disk_num_bytes (buf, fi); key.offset -=btrfs_file_extent_offset (buf, fi); - ret =process_func (trans, root, bytenr, num_bytes, - parent, ref_root, key.objectid, - key.offset); + ret =process_func (trans, bytenr, num_bytes, parent, + ref_root, key.objectid, key.offset);if (ret) {WARN_ON (1 ); goto fail;
@@ -1514,8 +1511,8 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, }else { bytenr =btrfs_node_blockptr (buf, i); num_bytes = root->fs_info->nodesize; - ret =process_func (trans, root, bytenr, num_bytes, - parent, ref_root, level -1 ,0 ); + ret =process_func (trans, bytenr, num_bytes, parent, + ref_root, level -1 ,0 );if (ret) {WARN_ON (1 ); goto fail;
@@ -2148,7 +2145,7 @@ int btrfs_free_tree_block(struct btrfs_trans_handle *trans,struct extent_buffer *buf, u64 parent, int last_ref) { - return btrfs_free_extent(trans, root, buf->start, buf->len, parent, + return btrfs_free_extent(trans, buf->start, buf->len, parent, root->root_key.objectid, btrfs_header_level(buf), 0); }
@@ -2158,13 +2155,12 @@ int btrfs_free_tree_block(struct btrfs_trans_handle *trans,*/ int btrfs_free_extent (struct btrfs_trans_handle *trans, -struct btrfs_root *root,u64 bytenr,u64 num_bytes,u64 parent,u64 root_objectid,u64 owner,u64 offset) {int ret; -WARN_ON (num_bytes < root->fs_info->sectorsize); +WARN_ON (num_bytes < trans->fs_info->sectorsize);/* * tree log blocks never actually go into the extent allocation * tree, just update pinning info and exit early.
@@ -2579,8 +2575,8 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, buf =btrfs_find_create_tree_block (root->fs_info, ins.objectid);if (!buf) { -btrfs_free_extent (trans, root, ins.objectid, ins.offset, -0 , root->root_key.objectid, level,0 ); +btrfs_free_extent (trans, ins.objectid, ins.offset,0 , + root->root_key.objectid, level,0 );BUG_ON (1 );return ERR_PTR (-ENOMEM ); }
@@ -3723,7 +3719,7 @@ static int __btrfs_record_file_extent(struct btrfs_trans_handle *trans,btrfs_set_stack_inode_nbytes (inode, nbytes);btrfs_release_path (path); - ret =btrfs_inc_extent_ref (trans, root, extent_bytenr, extent_num_bytes, + ret =btrfs_inc_extent_ref (trans, extent_bytenr, extent_num_bytes,0 , root->root_key.objectid, objectid, file_pos - extent_offset);if (ret)
kernel-shared/free-space-cache.c +2 -3
@@ -982,9 +982,8 @@ int btrfs_clear_free_space_cache(struct btrfs_trans_handle *trans, disk_bytenr =btrfs_file_extent_disk_bytenr (node, fi); disk_num_bytes =btrfs_file_extent_disk_num_bytes (node, fi); - ret =btrfs_free_extent (trans, tree_root, disk_bytenr, - disk_num_bytes,0 , tree_root->objectid, - ino, key.offset); + ret =btrfs_free_extent (trans, disk_bytenr, disk_num_bytes,0 , + tree_root->objectid, ino, key.offset);if (ret <0 ) {error ("failed to remove backref for disk bytenr %llu: %d" , disk_bytenr, ret);
Signature · 1 line
2.40.0
PATCH 4/18 btrfs-progs: pass root_id for btrfs_free_tree_block
In reply to Josef BacikIn the kernel we pass in the root_id for btrfs_free_tree_block instead of the root itself. Update the btrfs-progs version of the helper to match what we do in the kernel.
--- cmds/rescue.c | 3 ++- kernel-shared/ctree.h | 6 ++---- kernel-shared/disk-io.c | 2 +- kernel-shared/extent-tree.c | 9 +++------ 4 files changed, 8 insertions(+), 12 deletions(-)
cmds/rescue.c +2 -1
@@ -343,7 +343,8 @@ static int clear_uuid_tree(struct btrfs_fs_info *fs_info) ret =btrfs_clear_buffer_dirty (uuid_root->node);if (ret <0 ) goto out; - ret =btrfs_free_tree_block (trans, uuid_root, uuid_root->node,0 ,1 ); + ret =btrfs_free_tree_block (trans,btrfs_root_id (uuid_root), + uuid_root->node,0 ,1 );if (ret <0 ) goto out;free_extent_buffer (uuid_root->node);
kernel-shared/ctree.h +2 -4
@@ -870,10 +870,8 @@ int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct extent_buffer *buf, int record_parent);int btrfs_dec_ref (struct btrfs_trans_handle *trans,struct btrfs_root *root,struct extent_buffer *buf,int record_parent); -int btrfs_free_tree_block (struct btrfs_trans_handle *trans, -struct btrfs_root *root, -struct extent_buffer *buf, -u64 parent,int last_ref); +int btrfs_free_tree_block (struct btrfs_trans_handle *trans,u64 root_id, +struct extent_buffer *buf,u64 parent,int last_ref);int btrfs_free_extent (struct btrfs_trans_handle *trans,u64 bytenr,u64 num_bytes,u64 parent,u64 root_objectid,u64 owner,u64 offset);
kernel-shared/disk-io.c +1 -1
@@ -2301,7 +2301,7 @@ int btrfs_delete_and_free_root(struct btrfs_trans_handle *trans, ret =btrfs_clear_buffer_dirty (root->node);if (ret)return ret; - ret =btrfs_free_tree_block (trans, root, root->node,0 ,1 ); + ret =btrfs_free_tree_block (trans,btrfs_root_id (root), root->node,0 ,1 );if (ret)return ret;if (is_global_root (root))
kernel-shared/extent-tree.c +3 -6
@@ -2140,13 +2140,10 @@ fail:return ret; } -int btrfs_free_tree_block (struct btrfs_trans_handle *trans, -struct btrfs_root *root, -struct extent_buffer *buf, -u64 parent,int last_ref) +int btrfs_free_tree_block (struct btrfs_trans_handle *trans,u64 root_id, +struct extent_buffer *buf,u64 parent,int last_ref) { -return btrfs_free_extent (trans, buf->start, buf->len, parent, - root->root_key.objectid, +return btrfs_free_extent (trans, buf->start, buf->len, parent, root_id,btrfs_header_level (buf),0 ); }
Signature · 1 line
2.40.0
PATCH 5/18 btrfs-progs: add a free_extent_buffer_stale helper
In reply to Josef BacikThis does exactly what free_extent_buffer_nocache does, but we call btrfs_free_extent_buffer_stale in the kernel code, so add this extra helper. Once the kernel code is sync'ed we can get rid of the old helper.
--- kernel-shared/extent_io.c | 5 +++++ kernel-shared/extent_io.h | 1 + 2 files changed, 6 insertions(+)
kernel-shared/extent_io.c +5 -0
@@ -204,6 +204,11 @@ void free_extent_buffer_nocache(struct extent_buffer *eb)free_extent_buffer_internal (eb,1 ); } +void free_extent_buffer_stale (struct extent_buffer *eb) +{ +free_extent_buffer_internal (eb,1 ); +} +struct extent_buffer *find_extent_buffer (struct btrfs_fs_info *fs_info,u64 bytenr,u32 blocksize) {
kernel-shared/extent_io.h +1 -0
@@ -104,6 +104,7 @@ struct extent_buffer *alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize);void free_extent_buffer (struct extent_buffer *eb);void free_extent_buffer_nocache (struct extent_buffer *eb); +void free_extent_buffer_stale (struct extent_buffer *eb);int memcmp_extent_buffer (const struct extent_buffer *eb,const void *ptrv,unsigned long start,unsigned long len); void read_extent_buffer(const struct extent_buffer *eb, void *dst,
Signature · 1 line
2.40.0
PATCH 6/18 btrfs-progs: add btrfs_is_testing helper
In reply to Josef BacikThis is sprinkled throughout the kernel code for the in-kernel self tests. Add the helper to btrfs-progs to make it easier to sync the kernel code.
--- kernel-shared/ctree.h | 5 +++++ 1 file changed, 5 insertions(+)
kernel-shared/ctree.h +5 -0
@@ -389,6 +389,11 @@ static inline bool btrfs_is_zoned(const struct btrfs_fs_info *fs_info)return fs_info->zoned !=0 ; } +static inline bool btrfs_is_testing (const struct btrfs_fs_info *fs_info) +{ +return false; +} +/* * The state of btrfs root */
Signature · 1 line
2.40.0
PATCH 7/18 btrfs-progs: add accounting_lock to btrfs_root
In reply to Josef BacikThis is used to protect the used count for btrfs_root in the kernel, sync it to btrfs-progs to allow us to sync ctree.c into btrfs-progs.
--- kernel-shared/ctree.h | 2 ++ 1 file changed, 2 insertions(+)
kernel-shared/ctree.h +2 -0
@@ -479,6 +479,8 @@ struct btrfs_root {/* the dirty list is only used by non-reference counted roots */ struct list_head dirty_list;struct rb_node rb_node; + +spinlock_t accounting_lock; };static inline u64 btrfs_root_id (const struct btrfs_root *root)
Signature · 1 line
2.40.0
PATCH 8/18 btrfs-progs: update read_tree_block to match the kernel definition
In reply to Josef BacikThe in-kernel version of read_tree_block adds some extra sanity checks to make sure we don't return blocks that don't match what we expect. This includes the owning root, the level, and the expected first key. We don't actually do these checks in btrfs-progs, however kernel code we're going to sync will expect this calling convention, so update it to match the in-kernel code and then update all the callers.
--- btrfs-corrupt-block.c | 8 +++++--- btrfs-find-root.c | 2 +- check/main.c | 9 ++++++--- check/mode-common.c | 4 ++-- check/mode-lowmem.c | 12 +++++++----- check/qgroup-verify.c | 3 ++- check/repair.c | 8 ++++++-- cmds/inspect-dump-tree.c | 12 +++++++----- cmds/inspect-tree-stats.c | 4 +++- cmds/restore.c | 6 ++++-- image/main.c | 11 ++++++----- kernel-shared/backref.c | 6 ++++-- kernel-shared/ctree.c | 4 +++- kernel-shared/disk-io.c | 8 +++++--- kernel-shared/disk-io.h | 5 +++-- kernel-shared/print-tree.c | 4 +++- tune/change-uuid.c | 2 +- 17 files changed, 68 insertions(+), 40 deletions(-)
btrfs-corrupt-block.c +5 -3
@@ -166,7 +166,7 @@ static int corrupt_keys_in_block(struct btrfs_fs_info *fs_info, u64 bytenr) {struct extent_buffer *eb; - eb =read_tree_block (fs_info, bytenr,0 ); + eb =read_tree_block (fs_info, bytenr,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (eb))return -EIO ;;
@@ -296,7 +296,9 @@ static void btrfs_corrupt_extent_tree(struct btrfs_trans_handle *trans,struct extent_buffer *next; next =read_tree_block (fs_info,btrfs_node_blockptr (eb, i), -btrfs_node_ptr_generation (eb, i)); +btrfs_header_owner (eb), +btrfs_node_ptr_generation (eb, i), +btrfs_header_level (eb) -1 ,NULL );if (!extent_buffer_uptodate (next))continue ;btrfs_corrupt_extent_tree (trans, root, next);
@@ -860,7 +862,7 @@ static int corrupt_metadata_block(struct btrfs_fs_info *fs_info, u64 block,return -EINVAL ; } - eb =read_tree_block (fs_info, block,0 ); + eb =read_tree_block (fs_info, block,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (eb)) {error ("couldn't read in tree block %s" , field);return -EINVAL ;
btrfs-find-root.c +1 -1
@@ -199,7 +199,7 @@ int btrfs_find_root_search(struct btrfs_fs_info *fs_info,for (offset = chunk_offset; offset < chunk_offset + chunk_size; offset += nodesize) { - eb =read_tree_block (fs_info, offset,0 ); + eb =read_tree_block (fs_info, offset,0 ,0 ,0 ,NULL );if (!eb ||IS_ERR (eb))continue ; ret = add_eb_to_result(eb, result, nodesize, filter,
check/main.c +6 -3
@@ -1898,7 +1898,9 @@ static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,if (!next || !btrfs_buffer_uptodate (next, ptr_gen)) {free_extent_buffer (next);reada_walk_down (root, cur, path->slots[*level]); - next =read_tree_block (gfs_info, bytenr, ptr_gen); + next =read_tree_block (gfs_info, bytenr, +btrfs_header_owner (cur), ptr_gen, + *level -1 ,NULL );if (!extent_buffer_uptodate (next)) {struct btrfs_key node_key;
@@ -6269,7 +6271,7 @@ static int run_next_block(struct btrfs_root *root, }/* fixme, get the real parent transid */ - buf =read_tree_block (gfs_info, bytenr, gen); + buf =read_tree_block (gfs_info, bytenr,0 , gen,0 ,NULL );if (!extent_buffer_uptodate (buf)) {record_bad_block_io (extent_cache, bytenr, size); goto out;
@@ -8615,7 +8617,8 @@ static int deal_root_from_list(struct list_head *list, rec =list_entry (list->next, struct root_item_record, list); last =0 ; - buf =read_tree_block (gfs_info, rec->bytenr,0 ); + buf =read_tree_block (gfs_info, rec->bytenr, rec->objectid,0 , + rec->level,NULL );if (!extent_buffer_uptodate (buf)) {free_extent_buffer (buf); ret = -EIO ;
check/mode-common.c +2 -2
@@ -132,7 +132,7 @@ static int check_prealloc_shared_data_ref(u64 parent, u64 disk_bytenr)int i;int ret =0 ; - eb =read_tree_block (gfs_info, parent,0 ); + eb =read_tree_block (gfs_info, parent,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (eb)) { ret = -EIO ; goto out;
@@ -1127,7 +1127,7 @@ int get_extent_item_generation(u64 bytenr, u64 *gen_ret) BTRFS_EXTENT_FLAG_TREE_BLOCK) {struct extent_buffer *eb; - eb =read_tree_block (gfs_info, bytenr,0 ); + eb =read_tree_block (gfs_info, bytenr,0 ,0 ,0 ,NULL );if (extent_buffer_uptodate (eb)) { *gen_ret =btrfs_header_generation (eb); ret =0 ;
check/mode-lowmem.c +7 -5
@@ -3748,7 +3748,7 @@ static int query_tree_block_level(u64 bytenr)btrfs_release_path (&path);/* Get level from tree block as an alternative source */ - eb =read_tree_block (gfs_info, bytenr, transid); + eb =read_tree_block (gfs_info, bytenr,0 , transid,0 ,NULL );if (!extent_buffer_uptodate (eb)) {free_extent_buffer (eb);return -EIO ;
@@ -3800,7 +3800,7 @@ static int check_tree_block_backref(u64 root_id, u64 bytenr, int level) }/* Read out the tree block to get item/node key */ - eb =read_tree_block (gfs_info, bytenr,0 ); + eb =read_tree_block (gfs_info, bytenr, root_id,0 ,0 ,NULL );if (!extent_buffer_uptodate (eb)) { err |=REFERENCER_MISSING ;free_extent_buffer (eb);
@@ -3899,7 +3899,7 @@ static int check_shared_block_backref(u64 parent, u64 bytenr, int level)int found_parent =0 ;int i; - eb =read_tree_block (gfs_info, parent,0 ); + eb =read_tree_block (gfs_info, parent,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (eb)) goto out;
@@ -4072,7 +4072,7 @@ static int check_shared_data_backref(u64 parent, u64 bytenr)int found_parent =0 ;int i; - eb =read_tree_block (gfs_info, parent,0 ); + eb =read_tree_block (gfs_info, parent,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (eb)) goto out;
@@ -5046,7 +5046,9 @@ static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,if (!next || !btrfs_buffer_uptodate (next, ptr_gen)) {free_extent_buffer (next);reada_walk_down (root, cur, path->slots[*level]); - next =read_tree_block (gfs_info, bytenr, ptr_gen); + next =read_tree_block (gfs_info, bytenr, +btrfs_header_owner (cur), + ptr_gen, *level -1 ,NULL );if (!extent_buffer_uptodate (next)) {struct btrfs_key node_key;
check/qgroup-verify.c +2 -1
@@ -720,7 +720,8 @@ static int travel_tree(struct btrfs_fs_info *info, struct btrfs_root *root,// printf("travel_tree: bytenr: %llu\tnum_bytes: %llu\tref_parent: %llu\n", // bytenr, num_bytes, ref_parent); - eb =read_tree_block (info, bytenr,0 ); + eb =read_tree_block (info, bytenr,btrfs_root_id (root),0 , +0 ,NULL );if (!extent_buffer_uptodate (eb))return -EIO ;
check/repair.c +6 -2
@@ -108,7 +108,9 @@ static int traverse_tree_blocks(struct extent_io_tree *tree,* in, but for now this doesn't actually use the root so * just pass in extent_root. */ - tmp =read_tree_block (fs_info, bytenr,0 ); + tmp =read_tree_block (fs_info, bytenr, key.objectid,0 , +btrfs_disk_root_level (eb, ri), +NULL );if (!extent_buffer_uptodate (tmp)) {fprintf (stderr,"Error reading root block\n" );return -EIO ;
@@ -133,7 +135,9 @@ static int traverse_tree_blocks(struct extent_io_tree *tree,continue ; } - tmp =read_tree_block (fs_info, bytenr,0 ); + tmp =read_tree_block (fs_info, bytenr, +btrfs_header_owner (eb),0 , + level -1 ,NULL );if (!extent_buffer_uptodate (tmp)) {fprintf (stderr,"Error reading tree block\n" );return -EIO ;
cmds/inspect-dump-tree.c +7 -5
@@ -58,9 +58,10 @@ static void print_extents(struct extent_buffer *eb) nr =btrfs_header_nritems (eb);for (i =0 ; i < nr; i++) { - next =read_tree_block (fs_info, -btrfs_node_blockptr (eb, i), -btrfs_node_ptr_generation (eb, i)); + next =read_tree_block (fs_info,btrfs_node_blockptr (eb, i), +btrfs_header_owner (eb), +btrfs_node_ptr_generation (eb, i), +btrfs_header_level (eb) -1 ,NULL );if (!extent_buffer_uptodate (next))continue ;if (btrfs_is_leaf (next) &&btrfs_header_level (eb) !=1 ) {
@@ -288,7 +289,7 @@ static int dump_print_tree_blocks(struct btrfs_fs_info *fs_info, goto next; } - eb =read_tree_block (fs_info, bytenr,0 ); + eb =read_tree_block (fs_info, bytenr,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (eb)) {error ("failed to read tree block %llu" , bytenr); ret = -EIO ;
@@ -625,7 +626,8 @@ again: offset =btrfs_item_ptr_offset (leaf, slot);read_extent_buffer (leaf, &ri, offset,sizeof (ri)); - buf =read_tree_block (info,btrfs_root_bytenr (&ri),0 ); + buf =read_tree_block (info,btrfs_root_bytenr (&ri), + key.objectid,0 ,0 ,NULL );if (!extent_buffer_uptodate (buf)) goto next;if (tree_id && found_key.objectid != tree_id) {
cmds/inspect-tree-stats.c +3 -1
@@ -153,7 +153,9 @@ static int walk_nodes(struct btrfs_root *root, struct btrfs_path *path, path->slots[level] = i;if ((level -1 ) >0 || find_inline) { tmp =read_tree_block (root->fs_info, cur_blocknr, -btrfs_node_ptr_generation (b, i)); +btrfs_header_owner (b), +btrfs_node_ptr_generation (b, i), + level -1 ,NULL );if (!extent_buffer_uptodate (tmp)) {error ("failed to read blocknr %llu" ,btrfs_node_blockptr (b, i));
cmds/restore.c +4 -2
@@ -1260,7 +1260,8 @@ static struct btrfs_root *open_fs(const char *dev, u64 root_location, root_location =btrfs_super_root (fs_info->super_copy); generation =btrfs_super_generation (fs_info->super_copy); root->node =read_tree_block (fs_info, root_location, - generation); +btrfs_root_id (root), generation, +0 ,NULL );if (!extent_buffer_uptodate (root->node)) {error ("opening tree root failed" );close_ctree (root);
@@ -1527,7 +1528,8 @@ static int cmd_restore(const struct cmd_struct *cmd, int argc, char **argv)if (fs_location !=0 ) {free_extent_buffer (root->node); - root->node =read_tree_block (root->fs_info, fs_location,0 ); + root->node =read_tree_block (root->fs_info, fs_location,0 ,0 , +0 ,NULL );if (!extent_buffer_uptodate (root->node)) {error ("failed to read fs location" ); ret =1 ;
image/main.c +6 -5
@@ -707,7 +707,8 @@ static int flush_pending(struct metadump_struct *md, int done)u64 this_read =min ((u64 )md->root->fs_info->nodesize, size); - eb =read_tree_block (md->root->fs_info, start,0 ); + eb =read_tree_block (md->root->fs_info, start,0 ,0 ,0 , +NULL );if (!extent_buffer_uptodate (eb)) {free (async->buffer);free (async);
@@ -811,7 +812,7 @@ static int copy_tree_blocks(struct btrfs_root *root, struct extent_buffer *eb,continue ; ri = btrfs_item_ptr(eb, i, struct btrfs_root_item); bytenr =btrfs_disk_root_bytenr (eb, ri); - tmp =read_tree_block (fs_info, bytenr,0 ); + tmp =read_tree_block (fs_info, bytenr,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (tmp)) {error ("unable to read log root block" );return -EIO ;
@@ -822,7 +823,7 @@ static int copy_tree_blocks(struct btrfs_root *root, struct extent_buffer *eb,return ret; }else { bytenr =btrfs_node_blockptr (eb, i); - tmp =read_tree_block (fs_info, bytenr,0 ); + tmp =read_tree_block (fs_info, bytenr,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (tmp)) {error ("unable to read log root block" );return -EIO ;
@@ -2697,7 +2698,7 @@ static int iter_tree_blocks(struct btrfs_fs_info *fs_info,continue ; ri = btrfs_item_ptr(eb, i, struct btrfs_root_item); bytenr =btrfs_disk_root_bytenr (eb, ri); - tmp =read_tree_block (fs_info, bytenr,0 ); + tmp =read_tree_block (fs_info, bytenr,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (tmp)) {error ("unable to read log root block" );return -EIO ;
@@ -2708,7 +2709,7 @@ static int iter_tree_blocks(struct btrfs_fs_info *fs_info,return ret; }else { bytenr =btrfs_node_blockptr (eb, i); - tmp =read_tree_block (fs_info, bytenr,0 ); + tmp =read_tree_block (fs_info, bytenr,0 ,0 ,0 ,NULL );if (!extent_buffer_uptodate (tmp)) {error ("unable to read log root block" );return -EIO ;
kernel-shared/backref.c +4 -2
@@ -461,7 +461,8 @@ static int __add_missing_keys(struct btrfs_fs_info *fs_info,ASSERT (!ref->parent);ASSERT (!ref->key_for_search.type);BUG_ON (!ref->wanted_disk_byte); - eb =read_tree_block (fs_info, ref->wanted_disk_byte,0 ); + eb =read_tree_block (fs_info, ref->wanted_disk_byte, + ref->root_id,0 , ref->level -1 ,NULL );if (!extent_buffer_uptodate (eb)) {free_extent_buffer (eb);return -EIO ;
@@ -823,7 +824,8 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans, ref->level == 0) {struct extent_buffer *eb; - eb =read_tree_block (fs_info, ref->parent,0 ); + eb =read_tree_block (fs_info, ref->parent,0 , +0 , ref->level,NULL );if (!extent_buffer_uptodate (eb)) {free_extent_buffer (eb); ret = -EIO ;
kernel-shared/ctree.c +3 -1
@@ -874,7 +874,9 @@ struct extent_buffer *read_node_slot(struct btrfs_fs_info *fs_info,return NULL ; ret =read_tree_block (fs_info,btrfs_node_blockptr (parent, slot), -btrfs_node_ptr_generation (parent, slot)); +btrfs_header_owner (parent), +btrfs_node_ptr_generation (parent, slot), + level -1 ,NULL );if (!extent_buffer_uptodate (ret))return ERR_PTR (-EIO );
kernel-shared/disk-io.c +5 -3
@@ -337,8 +337,9 @@ int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirrreturn 0 ; } -struct extent_buffer *read_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr, -u64 parent_transid) +struct extent_buffer *read_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr, +u64 owner_root,u64 parent_transid, +int level,struct btrfs_key *first_key) {int ret;struct extent_buffer *eb;
@@ -510,7 +511,8 @@ static int read_root_node(struct btrfs_fs_info *fs_info, struct btrfs_root *root, u64 bytenr, u64 gen, int level) { - root->node = read_tree_block(fs_info, bytenr, gen); + root->node = read_tree_block(fs_info, bytenr, btrfs_root_id(root), + gen, level,NULL );if (!extent_buffer_uptodate (root->node)) goto err;if (btrfs_header_level (root->node) != level) {
kernel-shared/disk-io.h +3 -2
@@ -138,8 +138,9 @@ static inline u64 btrfs_sb_offset(int mirror)struct btrfs_device ;int read_whole_eb (struct btrfs_fs_info *info,struct extent_buffer *eb,int mirror); -struct extent_buffer *read_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr, -u64 parent_transid); +struct extent_buffer *read_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr, +u64 owner_root,u64 parent_transid, +int level,struct btrfs_key *first_key);void readahead_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr,u64 parent_transid);
kernel-shared/print-tree.c +3 -1
@@ -1557,7 +1557,9 @@ static void dfs_print_children(struct extent_buffer *root_eb, unsigned int mode)for (i =0 ; i < nr; i++) { next =read_tree_block (fs_info,btrfs_node_blockptr (root_eb, i), -btrfs_node_ptr_generation (root_eb, i)); +btrfs_header_owner (root_eb), +btrfs_node_ptr_generation (root_eb, i), + root_eb_level,NULL );if (!extent_buffer_uptodate (next)) { fprintf(stderr, "failed to read %llu in tree %llu\n", btrfs_node_blockptr(root_eb, i),
tune/change-uuid.c +1 -1
@@ -111,7 +111,7 @@ static int change_extent_tree_uuid(struct btrfs_fs_info *fs_info, uuid_t new_fsi goto next; bytenr = key.objectid; - eb =read_tree_block (fs_info, bytenr,0 ); + eb =read_tree_block (fs_info, bytenr,0 ,0 ,0 ,NULL );if (IS_ERR (eb)) {error ("failed to read tree block: %llu" , bytenr); ret =PTR_ERR (eb);
Signature · 1 line
2.40.0
PATCH 9/18 btrfs-progs: make reada_for_search static
In reply to Josef BacikWe were using this in cmds/restore.c, however it only does anything if path->reada is set, and we don't set that in cmds/restore.c. Remove this usage of reada_for_search and make the function static.
--- cmds/restore.c | 5 ----- kernel-shared/ctree.c | 5 +++-- kernel-shared/ctree.h | 2 -- 3 files changed, 3 insertions(+), 9 deletions(-)
cmds/restore.c +0 -5
@@ -267,9 +267,6 @@ again:continue ; } -if (path->reada) -reada_for_search (fs_info, path, level, slot,0 ); - next =read_node_slot (fs_info, c, slot);if (extent_buffer_uptodate (next))break ;
@@ -284,8 +281,6 @@ again: path->slots[level] =0 ;if (!level)break ; -if (path->reada) -reada_for_search (fs_info, path, level,0 ,0 ); next =read_node_slot (fs_info, next,0 );if (!extent_buffer_uptodate (next)) goto again;
kernel-shared/ctree.c +3 -2
@@ -1205,8 +1205,9 @@ static int noinline push_nodes_for_insert(struct btrfs_trans_handle *trans,/* * readahead one full node of leaves */ -void reada_for_search (struct btrfs_fs_info *fs_info,struct btrfs_path *path, -int level,int slot,u64 objectid) +static void reada_for_search (struct btrfs_fs_info *fs_info, +struct btrfs_path *path,int level,int slot, +u64 objectid) {struct extent_buffer *node;struct btrfs_disk_key disk_key;
kernel-shared/ctree.h +0 -2
@@ -929,8 +929,6 @@ int btrfs_del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level, int slot);enum btrfs_tree_block_status btrfs_check_node (struct extent_buffer *buf);enum btrfs_tree_block_status btrfs_check_leaf (struct extent_buffer *buf); -void reada_for_search (struct btrfs_fs_info *fs_info,struct btrfs_path *path, -int level,int slot,u64 objectid);struct extent_buffer *read_node_slot (struct btrfs_fs_info *fs_info,struct extent_buffer *parent,int slot); int btrfs_previous_item(struct btrfs_root *root,
Signature · 1 line
2.40.0
PATCH 10/18 btrfs-progs: sync btrfs_path fields with the kernel
In reply to Josef BacikWhen we sync ctree.c into btrfs-progs we're going to need to have a bunch of flags and definitions that exist in btrfs_path in the kernel that do not exist in btrfs_progs. Sync these changes into btrfs-progs to enable us to sync ctree.c into btrfs-progs.
--- kernel-shared/ctree.h | 41 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 5 deletions(-)
kernel-shared/ctree.h +36 -5
@@ -129,14 +129,32 @@ static inline u32 __BTRFS_LEAF_DATA_SIZE(u32 nodesize)* The slots array records the index of the item or block pointer * used while walking the tree. */ -enum {READA_NONE =0 ,READA_BACK ,READA_FORWARD }; +enum { +READA_NONE , +READA_BACK , +READA_FORWARD , +/* +* Similar to READA_FORWARD but unlike it: +* +* 1) It will trigger readahead even for leaves that are not close to +* each other on disk; +* 2) It also triggers readahead for nodes; +* 3) During a search, even when a node or leaf is already in memory, it +* will still trigger readahead for other nodes and leaves that follow +* it. +* +* This is meant to be used only when we know we are iterating over the +* entire tree or a very large part of it. +*/ +READA_FORWARD_ALWAYS , +}; +struct btrfs_path {struct extent_buffer *nodes[BTRFS_MAX_LEVEL ];int slots[BTRFS_MAX_LEVEL ]; -#if 0 /* The kernel locking scheme is not done in userspace. */ int locks[BTRFS_MAX_LEVEL ]; -#endif +signed char reada;/* keep some upper locks as we walk down */ u8 lowest_level;
@@ -145,8 +163,21 @@ struct btrfs_path {* set by btrfs_split_item, tells search_slot to keep all locks * and to force calls to keep space in the nodes */ -u8 search_for_split; -u8 skip_check_block; + unsigned int search_for_split:1; + unsigned int keep_locks:1; + unsigned int skip_locking:1; + unsigned int search_commit_root:1; + unsigned int need_commit_sem:1; + unsigned int skip_release_on_error:1; +/* +* Indicate that new item (btrfs_search_slot) is extending already +* existing item and ins_len contains only the data size and not item +* header (ie. sizeof(struct btrfs_item) is not included). +*/ + unsigned int search_for_extension:1; +/* Stop search if any locks need to be taken (for read) */ + unsigned int nowait:1; + unsigned int skip_check_block:1; };#define BTRFS_MAX_EXTENT_ITEM_SIZE (r) \
Signature · 1 line
2.40.0
PATCH 11/18 btrfs-progs: update arguments of find_extent_buffer
In reply to Josef BacikIn the kernel we only take a bytenr for this as the extent buffer cache is indexed on bytenr. Since we're passing in the btrfs_fs_info we can simply use the ->nodesize for the blocksize, and drop the blocksize argument completely. This brings us into parity with the kernel, which will allow the syncing of ctree.c.
--- kernel-shared/disk-io.c | 2 +- kernel-shared/extent_io.c | 7 ++++--- kernel-shared/extent_io.h | 2 +- 3 files changed, 6 insertions(+), 5 deletions(-)
kernel-shared/disk-io.c +1 -1
@@ -228,7 +228,7 @@ static int csum_tree_block(struct btrfs_fs_info *fs_info,struct extent_buffer *btrfs_find_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr,u32 blocksize) { -return find_extent_buffer (fs_info, bytenr, blocksize); +return find_extent_buffer (fs_info, bytenr); } struct extent_buffer* btrfs_find_create_tree_block(
kernel-shared/extent_io.c +4 -3
@@ -210,14 +210,15 @@ void free_extent_buffer_stale(struct extent_buffer *eb) }struct extent_buffer *find_extent_buffer (struct btrfs_fs_info *fs_info, -u64 bytenr,u32 blocksize) +u64 bytenr) {struct extent_buffer *eb =NULL ;struct cache_extent *cache; - cache =lookup_cache_extent (&fs_info->extent_cache, bytenr, blocksize); + cache =lookup_cache_extent (&fs_info->extent_cache, bytenr, + fs_info->nodesize);if (cache && cache->start == bytenr && - cache->size == blocksize) { + cache->size == fs_info->nodesize) { eb = container_of(cache, struct extent_buffer, cache_node);list_move_tail (&eb->lru, &fs_info->lru); eb->refs++;
kernel-shared/extent_io.h +1 -1
@@ -94,7 +94,7 @@ static inline int extent_buffer_uptodate(struct extent_buffer *eb) }struct extent_buffer *find_extent_buffer (struct btrfs_fs_info *fs_info, -u64 bytenr,u32 blocksize); +u64 bytenr);struct extent_buffer *find_first_extent_buffer (struct btrfs_fs_info *fs_info,u64 start); struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
Signature · 1 line
2.40.0
PATCH 12/18 btrfs-progs: add btrfs_readahead_node_child helper
In reply to Josef BacikThis exists in the kernel as a wrapper for readahead_tree_block, and is used extensively in ctree.c in the kernel. Sync this helper so that we can easily sync ctree.c
--- kernel-shared/extent_io.c | 14 ++++++++++++++ kernel-shared/extent_io.h | 1 + 2 files changed, 15 insertions(+)
kernel-shared/extent_io.c +14 -0
@@ -651,3 +651,17 @@ void write_extent_buffer_fsid(const struct extent_buffer *eb, const void *srcv) {write_extent_buffer (eb, srcv,btrfs_header_fsid (),BTRFS_FSID_SIZE ); } + +/* +* btrfs_readahead_node_child - readahead a node's child block +* @node: parent node we're reading from +* @slot: slot in the parent node for the child we want to read +* +* A helper for readahead_tree_block, we simply read the bytenr pointed at the +* slot in the node provided. +*/ +void btrfs_readahead_node_child (struct extent_buffer *node,int slot) +{ +readahead_tree_block (node->fs_info,btrfs_node_blockptr (node, slot), +btrfs_node_ptr_generation (node, slot)); +}
kernel-shared/extent_io.h +1 -0
@@ -137,5 +137,6 @@ void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start,void extent_buffer_init_cache (struct btrfs_fs_info *fs_info);void extent_buffer_free_cache (struct btrfs_fs_info *fs_info);void write_extent_buffer_fsid (const struct extent_buffer *eb,const void *srcv); +void btrfs_readahead_node_child (struct extent_buffer *node,int slot);#endif
Signature · 1 line
2.40.0
PATCH 13/18 btrfs-progs: add an atomic arg to btrfs_buffer_uptodate
In reply to Josef BacikWe have this extra argument in the kernel to indicate if we are atomic and thus can't lock the io_tree when checking the transid for an extent buffer. This isn't necessary in btrfs-progs, but to allow for easier sync'ing of ctree.c add this argument to our copy of btrfs_buffer_uptodate.
--- check/main.c | 2 +- check/mode-lowmem.c | 2 +- kernel-shared/disk-io.c | 9 +++++---- kernel-shared/disk-io.h | 3 ++- kernel-shared/extent-tree.c | 2 +- 5 files changed, 10 insertions(+), 8 deletions(-)
check/main.c +1 -1
@@ -1895,7 +1895,7 @@ static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path, } next =btrfs_find_tree_block (gfs_info, bytenr, gfs_info->nodesize); -if (!next || !btrfs_buffer_uptodate (next, ptr_gen)) { +if (!next || !btrfs_buffer_uptodate (next, ptr_gen,0 )) {free_extent_buffer (next);reada_walk_down (root, cur, path->slots[*level]); next = read_tree_block(gfs_info, bytenr,
check/mode-lowmem.c +1 -1
@@ -5043,7 +5043,7 @@ static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path, } next =btrfs_find_tree_block (gfs_info, bytenr, gfs_info->nodesize); -if (!next || !btrfs_buffer_uptodate (next, ptr_gen)) { +if (!next || !btrfs_buffer_uptodate (next, ptr_gen,0 )) {free_extent_buffer (next);reada_walk_down (root, cur, path->slots[*level]); next = read_tree_block(gfs_info, bytenr,
kernel-shared/disk-io.c +5 -4
@@ -246,7 +246,7 @@ void readahead_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,struct btrfs_device *device; eb =btrfs_find_tree_block (fs_info, bytenr, fs_info->nodesize); -if (!(eb &&btrfs_buffer_uptodate (eb, parent_transid)) && +if (!(eb &&btrfs_buffer_uptodate (eb, parent_transid,0 )) && !btrfs_map_block (fs_info,READ , bytenr, &length, &multi,0 ,NULL )) { device = multi->stripes[0 ].dev;
@@ -367,7 +367,7 @@ struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,if (!eb)return ERR_PTR (-ENOMEM ); -if (btrfs_buffer_uptodate (eb, parent_transid)) +if (btrfs_buffer_uptodate (eb, parent_transid,0 ))return eb; num_copies =btrfs_num_copies (fs_info, eb->start, eb->len);
@@ -478,7 +478,7 @@ int write_tree_block(struct btrfs_trans_handle *trans,BUG (); } -if (trans && !btrfs_buffer_uptodate (eb, trans->transid)) +if (trans && !btrfs_buffer_uptodate (eb, trans->transid,0 ))BUG ();btrfs_clear_header_flag (eb,BTRFS_HEADER_FLAG_CSUM_NEW );
@@ -2262,7 +2262,8 @@ void btrfs_mark_buffer_dirty(struct extent_buffer *eb)set_extent_buffer_dirty (eb); } -int btrfs_buffer_uptodate (struct extent_buffer *buf,u64 parent_transid) +int btrfs_buffer_uptodate (struct extent_buffer *buf,u64 parent_transid, +int atomic) {int ret;
kernel-shared/disk-io.h +2 -1
@@ -201,7 +201,8 @@ struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info, struct btrfs_key *location);int btrfs_free_fs_root (struct btrfs_root *root);void btrfs_mark_buffer_dirty (struct extent_buffer *buf); -int btrfs_buffer_uptodate (struct extent_buffer *buf,u64 parent_transid); +int btrfs_buffer_uptodate (struct extent_buffer *buf,u64 parent_transid, +int atomic);int btrfs_set_buffer_uptodate (struct extent_buffer *buf);int btrfs_csum_data (struct btrfs_fs_info *fs_info,u16 csum_type,const u8 *data,u8 *out,size_t len);
kernel-shared/extent-tree.c +1 -1
@@ -1893,7 +1893,7 @@ static int pin_down_bytes(struct btrfs_trans_handle *trans, u64 bytenr,* reuse anything from the tree log root because * it has tiny sub-transactions. */ -if (btrfs_buffer_uptodate (buf,0 )) { +if (btrfs_buffer_uptodate (buf,0 ,0 )) {u64 header_owner =btrfs_header_owner (buf);u64 header_transid =btrfs_header_generation (buf); if (header_owner != BTRFS_TREE_LOG_OBJECTID &&
Signature · 1 line
2.40.0
PATCH 14/18 btrfs-progs: add a btrfs_read_extent_buffer helper
In reply to Josef BacikThis exists in the kernel to do the read on an extent buffer we may have already looked up and initialized. Simply create this helper by extracting out the existing code from read_tree_block and make read_tree_block call this helper. This gives us the helper we need to sync ctree.c into btrfs-progs, and keeps the code the same in btrfs-progs.
--- kernel-shared/disk-io.c | 72 ++++++++++++++++++++++++----------------- kernel-shared/disk-io.h | 2 ++ 2 files changed, 45 insertions(+), 29 deletions(-)
kernel-shared/disk-io.c +43 -29
@@ -337,39 +337,18 @@ int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirrreturn 0 ; } -struct extent_buffer *read_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr, -u64 owner_root,u64 parent_transid, -int level,struct btrfs_key *first_key) +int btrfs_read_extent_buffer (struct extent_buffer *eb,u64 parent_transid, +int level,struct btrfs_key *first_key) { +struct btrfs_fs_info *fs_info = eb->fs_info;int ret; -struct extent_buffer *eb;u64 best_transid =0 ; -u32 sectorsize = fs_info->sectorsize;int mirror_num =1 ;int good_mirror =0 ;int candidate_mirror =0 ;int num_copies;int ignore =0 ; -/* -* Don't even try to create tree block for unaligned tree block -* bytenr. -* Such unaligned tree block will free overlapping extent buffer, -* causing use-after-free bugs for fuzzed images. -*/ -if (bytenr < sectorsize || !IS_ALIGNED (bytenr, sectorsize)) { -error ("tree block bytenr %llu is not aligned to sectorsize %u" , - bytenr, sectorsize); -return ERR_PTR (-EIO ); - } - - eb =btrfs_find_create_tree_block (fs_info, bytenr); -if (!eb) -return ERR_PTR (-ENOMEM ); - -if (btrfs_buffer_uptodate (eb, parent_transid,0 )) -return eb; - num_copies =btrfs_num_copies (fs_info, eb->start, eb->len);while (1 ) { ret =read_whole_eb (fs_info, eb, mirror_num);
@@ -396,7 +375,7 @@ struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr, ret =btrfs_check_leaf (eb);if (!ret || candidate_mirror == mirror_num) {btrfs_set_buffer_uptodate (eb); -return eb; +return 0 ; }if (candidate_mirror <=0 ) candidate_mirror = mirror_num;
@@ -439,12 +418,47 @@ struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,continue ; } } +return ret; +} + +struct extent_buffer *read_tree_block (struct btrfs_fs_info *fs_info,u64 bytenr, +u64 owner_root,u64 parent_transid, +int level,struct btrfs_key *first_key) +{ +int ret; +struct extent_buffer *eb; +u32 sectorsize = fs_info->sectorsize; +/* -* We failed to read this tree block, it be should deleted right now -* to avoid stale cache populate the cache. +* Don't even try to create tree block for unaligned tree block +* bytenr. +* Such unaligned tree block will free overlapping extent buffer, +* causing use-after-free bugs for fuzzed images. */ -free_extent_buffer_nocache (eb); -return ERR_PTR (ret); +if (bytenr < sectorsize || !IS_ALIGNED (bytenr, sectorsize)) { +error ("tree block bytenr %llu is not aligned to sectorsize %u" , + bytenr, sectorsize); +return ERR_PTR (-EIO ); + } + + eb =btrfs_find_create_tree_block (fs_info, bytenr); +if (!eb) +return ERR_PTR (-ENOMEM ); + +if (btrfs_buffer_uptodate (eb, parent_transid,0 )) +return eb; + + ret =btrfs_read_extent_buffer (eb, parent_transid, level, first_key); +if (ret) { +/* +* We failed to read this tree block, it be should deleted right +* now to avoid stale cache populate the cache. +*/ +free_extent_buffer_nocache (eb); +return ERR_PTR (ret); + } + +return eb; }int write_and_map_eb (struct btrfs_fs_info *fs_info,struct extent_buffer *eb)
kernel-shared/disk-io.h +2 -0
@@ -233,6 +233,8 @@ int btrfs_global_root_insert(struct btrfs_fs_info *fs_info,int btrfs_find_and_setup_root (struct btrfs_root *tree_root,struct btrfs_fs_info *fs_info,u64 objectid,struct btrfs_root *root); +int btrfs_read_extent_buffer (struct extent_buffer *eb,u64 parent_transid, +int level,struct btrfs_key *first_key);static inline struct btrfs_root *btrfs_block_group_root (struct btrfs_fs_info *fs_info)
Signature · 1 line
2.40.0
PATCH 15/18 btrfs-progs: add BTRFS_STRIPE_LEN_SHIFT definition
In reply to Josef BacikThis is used by tree-checker.c, so sync this into volumes.h to make it easier to sync tree-checker.c.
--- kernel-shared/volumes.h | 1 + 1 file changed, 1 insertion(+)
kernel-shared/volumes.h +1 -0
@@ -24,6 +24,7 @@#include "kernel-lib/sizes.h" #define BTRFS_STRIPE_LEN SZ_64K +#define BTRFS_STRIPE_LEN_SHIFT (16)struct btrfs_device {struct list_head dev_list;
Signature · 1 line
2.40.0
PATCH 16/18 btrfs-progs: rename btrfs_check_* to __btrfs_check_*
In reply to Josef BacikThese helpers are called __btrfs_check_* in the kernel as they return the special enum to indicate what part of the leaf/node failed. Rename the uses in btrfs-progs to match the kernel naming convention to make it easier to sync that code.
--- check/repair.c | 4 ++-- kernel-shared/ctree.c | 8 ++++---- kernel-shared/ctree.h | 4 ++-- kernel-shared/disk-io.c | 4 ++-- 4 files changed, 10 insertions(+), 10 deletions(-)
check/repair.c +2 -2
@@ -311,9 +311,9 @@ enum btrfs_tree_block_status btrfs_check_block_for_repair(struct extent_buffer *enum btrfs_tree_block_status status;if (btrfs_is_leaf (eb)) - status =btrfs_check_leaf (eb); + status =__btrfs_check_leaf (eb);else - status =btrfs_check_node (eb); + status =__btrfs_check_node (eb);if (status ==BTRFS_TREE_BLOCK_CLEAN )return status;
kernel-shared/ctree.c +4 -4
@@ -616,7 +616,7 @@ static void generic_err(const struct extent_buffer *buf, int slot,fprintf (stderr,"\n" ); } -enum btrfs_tree_block_status btrfs_check_node (struct extent_buffer *node) +enum btrfs_tree_block_status __btrfs_check_node (struct extent_buffer *node) {struct btrfs_fs_info *fs_info = node->fs_info;unsigned long nr =btrfs_header_nritems (node);
@@ -677,7 +677,7 @@ fail:return ret; } -enum btrfs_tree_block_status btrfs_check_leaf (struct extent_buffer *leaf) +enum btrfs_tree_block_status __btrfs_check_leaf (struct extent_buffer *leaf) {struct btrfs_fs_info *fs_info = leaf->fs_info;/* No valid key type is 0, so all key should be larger than this key */
@@ -789,9 +789,9 @@ static int noinline check_block(struct btrfs_fs_info *fs_info,if (path->skip_check_block)return 0 ;if (level ==0 ) - ret =btrfs_check_leaf (path->nodes[0 ]); + ret =__btrfs_check_leaf (path->nodes[0 ]);else - ret =btrfs_check_node (path->nodes[level]); + ret =__btrfs_check_node (path->nodes[level]);if (ret ==BTRFS_TREE_BLOCK_CLEAN )return 0 ;return -EIO ;
kernel-shared/ctree.h +2 -2
@@ -958,8 +958,8 @@ int btrfs_convert_one_bg(struct btrfs_trans_handle *trans, u64 bytenr);int btrfs_comp_cpu_keys (const struct btrfs_key *k1,const struct btrfs_key *k2);int btrfs_del_ptr (struct btrfs_root *root,struct btrfs_path *path,int level,int slot); -enum btrfs_tree_block_status btrfs_check_node (struct extent_buffer *buf); -enum btrfs_tree_block_status btrfs_check_leaf (struct extent_buffer *buf); +enum btrfs_tree_block_status __btrfs_check_node (struct extent_buffer *buf); +enum btrfs_tree_block_status __btrfs_check_leaf (struct extent_buffer *buf);struct extent_buffer *read_node_slot (struct btrfs_fs_info *fs_info,struct extent_buffer *parent,int slot); int btrfs_previous_item(struct btrfs_root *root,
kernel-shared/disk-io.c +2 -2
@@ -370,9 +370,9 @@ int btrfs_read_extent_buffer(struct extent_buffer *eb, u64 parent_transid,* btrfs ins dump-tree. */ if (btrfs_header_level (eb)) - ret =btrfs_check_node (eb); + ret =__btrfs_check_node (eb);else - ret =btrfs_check_leaf (eb); + ret =__btrfs_check_leaf (eb);if (!ret || candidate_mirror == mirror_num) {btrfs_set_buffer_uptodate (eb);return 0 ;
Signature · 1 line
2.40.0
PATCH 17/18 btrfs-progs: change btrfs_check_chunk_valid to match the kernel version
In reply to Josef BacikIn btrfs-progs we check the actual leaf pointers as well as the chunk itself in btrfs_check_chunk_valid. However in the kernel the leaf stuff is handled separately as part of the read, and then we have the chunk checker itself. Change the btrfs-progs version to match the in-kernel version temporarily so it makes syncing the in-kernel code easier.
--- check/main.c | 3 +-- check/mode-lowmem.c | 6 ++---- kernel-shared/volumes.c | 46 ++++------------------------------------- kernel-shared/volumes.h | 6 ++---- 4 files changed, 9 insertions(+), 52 deletions(-)
check/main.c +1 -2
@@ -5329,8 +5329,7 @@ static int process_chunk_item(struct cache_tree *chunk_cache,* wrong onwer(3) out of chunk tree, to pass both chunk tree check * and owner<->key_type check. */ - ret =btrfs_check_chunk_valid (gfs_info, eb, chunk, slot, - key->offset); + ret =btrfs_check_chunk_valid (eb, chunk, key->offset);if (ret <0 ) {error ("chunk(%llu, %llu) is not valid, ignore it" , key->offset,btrfs_chunk_length (eb, chunk));
check/mode-lowmem.c +2 -4
@@ -4470,8 +4470,7 @@ static int check_dev_extent_item(struct extent_buffer *eb, int slot) l = path.nodes[0 ]; chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk); - ret =btrfs_check_chunk_valid (gfs_info, l, chunk, path.slots[0 ], - chunk_key.offset); + ret =btrfs_check_chunk_valid (l, chunk, chunk_key.offset);if (ret <0 ) goto out;
@@ -4702,8 +4701,7 @@ static int check_chunk_item(struct extent_buffer *eb, int slot) chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk); length =btrfs_chunk_length (eb, chunk); chunk_end = chunk_key.offset + length; - ret =btrfs_check_chunk_valid (gfs_info, eb, chunk, slot, - chunk_key.offset); + ret =btrfs_check_chunk_valid (eb, chunk, chunk_key.offset);if (ret <0 ) {error ("chunk[%llu %llu) is invalid" , chunk_key.offset, chunk_end);
kernel-shared/volumes.c +4 -42
86 lines not on this page · raw message
kernel-shared/volumes.h +2 -4
@@ -294,10 +294,8 @@ int write_raid56_with_parity(struct btrfs_fs_info *info,struct extent_buffer *eb, struct btrfs_multi_bio *multi, u64 stripe_len, u64 *raid_map); -int btrfs_check_chunk_valid (struct btrfs_fs_info *fs_info, -struct extent_buffer *leaf, -struct btrfs_chunk *chunk, -int slot,u64 logical); +int btrfs_check_chunk_valid (struct extent_buffer *leaf, +struct btrfs_chunk *chunk,u64 logical);u64 btrfs_stripe_length (struct btrfs_fs_info *fs_info,struct extent_buffer *leaf,struct btrfs_chunk *chunk);
Signature · 1 line
2.40.0
PATCH 18/18 btrfs-progs: sync tree-checker.[ch]
In reply to Josef BacikThis syncs tree-checker.c from the kernel. The main modification was to add a open ctree flag to skip the deeper leaf checks, and plumbing this through tree-checker.c. We need this for things like fsck or btrfs-image that need to work with slightly corrupted file systems, and these checks simply make us unable to look at the corrupted blocks.
--- Makefile | 1 + check/main.c | 4 +- check/mode-lowmem.c | 1 + check/repair.c | 1 + image/main.c | 14 +- include/kerncompat.h | 10 + kernel-shared/ctree.c | 180 +-- kernel-shared/ctree.h | 14 +- kernel-shared/disk-io.c | 3 + kernel-shared/disk-io.h | 6 + kernel-shared/tree-checker.c | 2064 ++++++++++++++++++++++++++++++++++ kernel-shared/tree-checker.h | 72 ++ kernel-shared/volumes.c | 96 +- kernel-shared/volumes.h | 2 - 14 files changed, 2173 insertions(+), 295 deletions(-) create mode 100644 kernel-shared/tree-checker.c create mode 100644 kernel-shared/tree-checker.h
Makefile +1 -0
@@ -187,6 +187,7 @@ objects = \ kernel-shared/print-tree.o \ kernel-shared/root-tree.o \ kernel-shared/transaction.o \ + kernel-shared/tree-checker.o \ kernel-shared/ulist.o \ kernel-shared/uuid-tree.o \ kernel-shared/volumes.o \
check/main.c +3 -1
@@ -64,6 +64,7 @@#include "check/clear-cache.h" #include "kernel-shared/uapi/btrfs.h" #include "kernel-lib/bitops.h" +#include "kernel-shared/tree-checker.h" /* Global context variables */ struct btrfs_fs_info *gfs_info;
@@ -9996,7 +9997,8 @@ static int cmd_check(const struct cmd_struct *cmd, int argc, char **argv)int qgroups_repaired =0 ;int qgroup_verify_ret;unsigned ctree_flags =OPEN_CTREE_EXCLUSIVE | -OPEN_CTREE_ALLOW_TRANSID_MISMATCH ; +OPEN_CTREE_ALLOW_TRANSID_MISMATCH | +OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS ;int force =0 ;while (1 ) {
check/mode-lowmem.c +1 -0
@@ -38,6 +38,7 @@#include "check/repair.h" #include "check/mode-common.h" #include "check/mode-lowmem.h" +#include "kernel-shared/tree-checker.h" static u64 last_allocated_chunk;static u64 total_used =0 ;
check/repair.c +1 -0
@@ -29,6 +29,7 @@#include "kernel-shared/disk-io.h" #include "common/extent-cache.h" #include "check/repair.h" +#include "kernel-shared/tree-checker.h" int opt_check_repair =0 ;
image/main.c +9 -5
@@ -1025,7 +1025,8 @@ static int create_metadump(const char *input, FILE *out, int num_threads,int ret;int err =0 ; - root =open_ctree (input,0 ,OPEN_CTREE_ALLOW_TRANSID_MISMATCH ); + root =open_ctree (input,0 ,OPEN_CTREE_ALLOW_TRANSID_MISMATCH | +OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS );if (!root) {error ("open ctree failed" );return -EIO ;
@@ -2798,7 +2799,7 @@ static int restore_metadump(const char *input, FILE *out, int old_restore, ocf.filename = target; ocf.flags =OPEN_CTREE_WRITES |OPEN_CTREE_RESTORE | -OPEN_CTREE_PARTIAL ; +OPEN_CTREE_PARTIAL |OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS ; info =open_ctree_fs_info (&ocf);if (!info) {error ("open ctree failed" );
@@ -2864,7 +2865,8 @@ static int restore_metadump(const char *input, FILE *out, int old_restore,OPEN_CTREE_PARTIAL |OPEN_CTREE_WRITES |OPEN_CTREE_NO_DEVICES | - OPEN_CTREE_ALLOW_TRANSID_MISMATCH); +OPEN_CTREE_ALLOW_TRANSID_MISMATCH | + OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS);if (!root) {error ("open ctree failed in %s" , target); ret = -EIO ;
@@ -2883,7 +2885,8 @@ static int restore_metadump(const char *input, FILE *out, int old_restore,if (!info) { root =open_ctree_fd (fileno (out), target,0 , -OPEN_CTREE_ALLOW_TRANSID_MISMATCH ); +OPEN_CTREE_ALLOW_TRANSID_MISMATCH | +OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS );if (!root) {error ("open ctree failed in %s" , target); ret = -EIO ;
@@ -3226,7 +3229,8 @@ int BOX_MAIN(image)(int argc, char *argv[])int i; ocf.filename = target; - ocf.flags =OPEN_CTREE_PARTIAL |OPEN_CTREE_RESTORE ; + ocf.flags =OPEN_CTREE_PARTIAL |OPEN_CTREE_RESTORE | +OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS ; info =open_ctree_fs_info (&ocf);if (!info) {error ("open ctree failed at %s" , target);
include/kerncompat.h +10 -0
@@ -86,6 +86,7 @@#define _RET_IP_ 0#define TASK_UNINTERRUPTIBLE 0#define SLAB_MEM_SPREAD 0 +#define ALLOW_ERROR_INJECTION (a, b)#ifndef ULONG_MAX #define ULONG_MAX (~0UL)
@@ -418,6 +419,15 @@ do { \ __ret_warn_on; \ }) +#define WARN(c, msg...) ({ \ + int __ret_warn_on = !!(c); \ + if (__ret_warn_on) \ + printf(msg); \ + __ret_warn_on; \ +}) + +#define IS_ENABLED (c) 0 +#define container_of (ptr, type, member) ({ \ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ (type *)( (char *)__mptr - offsetof(type,member) );})
kernel-shared/ctree.c +1 -179
192 lines not on this page · raw message
kernel-shared/ctree.h +1 -13
@@ -185,17 +185,6 @@ struct btrfs_path { sizeof(struct btrfs_item))#define BTRFS_MAX_EXTENT_SIZE 128UL * 1024 * 1024 -enum btrfs_tree_block_status { -BTRFS_TREE_BLOCK_CLEAN , -BTRFS_TREE_BLOCK_INVALID_NRITEMS , -BTRFS_TREE_BLOCK_INVALID_PARENT_KEY , -BTRFS_TREE_BLOCK_BAD_KEY_ORDER , -BTRFS_TREE_BLOCK_INVALID_LEVEL , -BTRFS_TREE_BLOCK_INVALID_FREE_SPACE , -BTRFS_TREE_BLOCK_INVALID_OFFSETS , -BTRFS_TREE_BLOCK_INVALID_BLOCKPTR , -}; -/* * We don't want to overwrite 1M at the beginning of device, even though * there is our 1st superblock at 64k. Some possible reasons:
@@ -373,6 +362,7 @@ struct btrfs_fs_info { unsigned int finalize_on_close:1; unsigned int hide_names:1; unsigned int allow_transid_mismatch:1; + unsigned int skip_leaf_item_checks:1;int transaction_aborted;int force_csum_type;
@@ -958,8 +948,6 @@ int btrfs_convert_one_bg(struct btrfs_trans_handle *trans, u64 bytenr);int btrfs_comp_cpu_keys (const struct btrfs_key *k1,const struct btrfs_key *k2);int btrfs_del_ptr (struct btrfs_root *root,struct btrfs_path *path,int level,int slot); -enum btrfs_tree_block_status __btrfs_check_node (struct extent_buffer *buf); -enum btrfs_tree_block_status __btrfs_check_leaf (struct extent_buffer *buf);struct extent_buffer *read_node_slot (struct btrfs_fs_info *fs_info,struct extent_buffer *parent,int slot); int btrfs_previous_item(struct btrfs_root *root,
kernel-shared/disk-io.c +3 -0
@@ -37,6 +37,7 @@#include "common/device-scan.h" #include "common/device-utils.h" #include "crypto/hash.h" +#include "tree-checker.h" /* specified errno for check_tree_block */ #define BTRFS_BAD_BYTENR (-1)
@@ -1503,6 +1504,8 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, struct open_ctree_flags *oc fs_info->hide_names =1 ;if (flags &OPEN_CTREE_ALLOW_TRANSID_MISMATCH ) fs_info->allow_transid_mismatch =1 ; +if (flags &OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS ) + fs_info->skip_leaf_item_checks =1 ;if ((flags &OPEN_CTREE_RECOVER_SUPER ) && (flags &OPEN_CTREE_TEMPORARY_SUPER )) {
kernel-shared/disk-io.h +6 -0
@@ -98,6 +98,12 @@ enum btrfs_open_ctree_flags {* stored in the csum tree during conversion. */ OPEN_CTREE_SKIP_CSUM_CHECK = (1U <<16 ), + +/* +* Allow certain commands like check/restore to ignore more structure +* specific checks and only do the superficial checks. +*/ + OPEN_CTREE_SKIP_LEAF_ITEM_CHECKS = (1U << 17), };/*
kernel-shared/tree-checker.c new file +2064 -0
2,064 lines not on this page · raw message
kernel-shared/tree-checker.h new file +72 -0
72 lines not on this page · raw message
kernel-shared/volumes.c +1 -95
108 lines not on this page · raw message
kernel-shared/volumes.h +0 -2
@@ -294,8 +294,6 @@ int write_raid56_with_parity(struct btrfs_fs_info *info,struct extent_buffer *eb, struct btrfs_multi_bio *multi, u64 stripe_len, u64 *raid_map); -int btrfs_check_chunk_valid (struct extent_buffer *leaf, -struct btrfs_chunk *chunk,u64 logical);u64 btrfs_stripe_length (struct btrfs_fs_info *fs_info,struct extent_buffer *leaf,struct btrfs_chunk *chunk);
Signature · 1 line
2.40.0