When applying this patch I get: warning: 2 lines add whitespace errors.
More comments inline. On Wed, August 08, 2012 at 20:55 (+0200), Mark Fasheh wrote: > Teach tree-log.c about extended inode refs. In particular, we have to adjust > the behavior of inode ref replay as well as log tree recovery to account for > the existence of extended refs. > > Signed-off-by: Mark Fasheh <[email protected]> > --- > fs/btrfs/backref.c | 68 ++++++++++++ > fs/btrfs/backref.h | 5 + > fs/btrfs/tree-log.c | 297 > ++++++++++++++++++++++++++++++++++++++++++--------- > 3 files changed, 319 insertions(+), 51 deletions(-) > > diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c > index a383c18..658e09c 100644 > --- a/fs/btrfs/backref.c > +++ b/fs/btrfs/backref.c > @@ -1111,6 +1111,74 @@ static int inode_ref_info(u64 inum, u64 ioff, struct > btrfs_root *fs_root, > found_key); > } > > +int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid, > + u64 start_off, struct btrfs_path *path, > + struct btrfs_inode_extref **ret_extref, > + u64 *found_off) > +{ > + int ret, slot; > + struct btrfs_key key; > + struct btrfs_key found_key; > + struct btrfs_inode_extref *extref; > + struct extent_buffer *leaf; > + unsigned long ptr; > + > + key.objectid = inode_objectid; > + btrfs_set_key_type(&key, BTRFS_INODE_EXTREF_KEY); > + key.offset = start_off; > + > + ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); > + if (ret < 0) > + return ret; > + > + while (1) { > + leaf = path->nodes[0]; > + slot = path->slots[0]; > + if (slot >= btrfs_header_nritems(leaf)) { > + /* > + * If the item at offset is not found, > + * btrfs_search_slot will point us to the slot > + * where it should be inserted. In our case > + * that will be the slot directly before the > + * next INODE_REF_KEY_V2 item. In the case > + * that we're pointing to the last slot in a > + * leaf, we must move one leaf over. > + */ > + ret = btrfs_next_leaf(root, path); > + if (ret) { > + if (ret >= 1) > + ret = -ENOENT; > + break; > + } We can finally replace this with btrfs_search_slot_for_read, according to my first suggestion. It's merged now. Saves that long comment and the whole while-1-continue construct, which is quite cumbersome to read. > + continue; > + } > + > + btrfs_item_key_to_cpu(leaf, &found_key, slot); > + > + /* > + * Check that we're still looking at an extended ref key for > + * this particular objectid. If we have different > + * objectid or type then there are no more to be found > + * in the tree and we can exit. > + */ > + ret = -ENOENT; > + if (found_key.objectid != inode_objectid) > + break; > + if (btrfs_key_type(&found_key) != BTRFS_INODE_EXTREF_KEY) > + break; > + > + ret = 0; > + ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); > + extref = (struct btrfs_inode_extref *)ptr; > + *ret_extref = extref; > + if (found_off) > + *found_off = found_key.offset; > + break; > + } > + > + return ret; > +} > + > /* > * this iterates to turn a btrfs_inode_ref into a full filesystem path. > elements > * of the path are separated by '/' and the path is guaranteed to be > diff --git a/fs/btrfs/backref.h b/fs/btrfs/backref.h > index c18d8ac..9f3e251 100644 > --- a/fs/btrfs/backref.h > +++ b/fs/btrfs/backref.h > @@ -66,4 +66,9 @@ struct inode_fs_paths *init_ipath(s32 total_bytes, struct > btrfs_root *fs_root, > struct btrfs_path *path); > void free_ipath(struct inode_fs_paths *ipath); > > +int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid, > + u64 start_off, struct btrfs_path *path, > + struct btrfs_inode_extref **ret_extref, > + u64 *found_off); > + > #endif > diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c > index 8abeae4..e5ba0a4 100644 > --- a/fs/btrfs/tree-log.c > +++ b/fs/btrfs/tree-log.c > @@ -23,8 +23,10 @@ > #include "disk-io.h" > #include "locking.h" > #include "print-tree.h" > +#include "backref.h" > #include "compat.h" > #include "tree-log.h" > +#include "hash.h" > > /* magic values for the inode_only field in btrfs_log_inode: > * > @@ -764,8 +766,16 @@ static noinline int backref_in_log(struct btrfs_root > *log, > if (ret != 0) > goto out; > > - item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]); > ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]); > + > + if (key->type == BTRFS_INODE_EXTREF_KEY) { > + if (btrfs_find_name_in_ext_backref(path, name, namelen, NULL)) > + match = 1; > + > + goto out; > + } > + > + item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]); > ptr_end = ptr + item_size; > while (ptr < ptr_end) { > ref = (struct btrfs_inode_ref *)ptr; > @@ -786,6 +796,47 @@ out: > return match; > } > > +static int extref_get_fields(struct extent_buffer *eb, int slot, > + u32 *namelen, char **name, u64 *index, > + u64 *parent_objectid) > +{ > + struct btrfs_inode_extref *extref; > + > + extref = (struct btrfs_inode_extref *)btrfs_item_ptr_offset(eb, slot); > + > + *namelen = btrfs_inode_extref_name_len(eb, extref); > + *name = kmalloc(*namelen, GFP_NOFS); > + if (*name == NULL) > + return -ENOMEM; > + > + read_extent_buffer(eb, *name, (unsigned long)&extref->name, > + *namelen); > + > + *index = btrfs_inode_extref_index(eb, extref); > + if (parent_objectid) > + *parent_objectid = btrfs_inode_extref_parent(eb, extref); > + > + return 0; > +} > + > +static int ref_get_fields(struct extent_buffer *eb, int slot, u32 *namelen, > + char **name, u64 *index) > +{ > + struct btrfs_inode_ref *ref; > + > + ref = (struct btrfs_inode_ref *)btrfs_item_ptr_offset(eb, slot); > + > + *namelen = btrfs_inode_ref_name_len(eb, ref); > + *name = kmalloc(*namelen, GFP_NOFS); > + if (*name == NULL) > + return -ENOMEM; > + > + read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen); > + > + *index = btrfs_inode_ref_index(eb, ref); > + > + return 0; > +} > > /* > * replay one inode back reference item found in the log tree. > @@ -801,15 +852,50 @@ static noinline int add_inode_ref(struct > btrfs_trans_handle *trans, > struct btrfs_key *key) Control flow in this function is horrible. I finally failed to understand it. That's why I made a patch that replaces most gotos by if blocks and uses a sub function (see the end of this email). I hope that it's getting easier to extend that patched version. Cannot comment on changes to code I don't understand, sorry. If you find my patch helps understanding that function and makes patching easier, you can include that patch in your patch set as patch 2/4 and then do your extension afterwards. > { > struct btrfs_inode_ref *ref; > + struct btrfs_inode_extref *extref; > struct btrfs_dir_item *di; > + struct btrfs_key search_key; > struct inode *dir; > struct inode *inode; > unsigned long ref_ptr; > unsigned long ref_end; > char *name; > + char *victim_name; > int namelen; > + int victim_name_len; > int ret; > int search_done = 0; > + int log_ref_ver = 0; > + u64 parent_objectid; > + u64 inode_objectid; > + u64 ref_index; > + struct extent_buffer *leaf; > + int ref_struct_size; > + > + > + ref_ptr = btrfs_item_ptr_offset(eb, slot); > + ref_end = ref_ptr + btrfs_item_size_nr(eb, slot); > + > + if (key->type == BTRFS_INODE_EXTREF_KEY) { > + ref_struct_size = sizeof(*extref); > + log_ref_ver = 1; > + > + ret = extref_get_fields(eb, slot, &namelen, &name, &ref_index, > + &parent_objectid); > + if (ret) > + return ret; > + } else { > + ref_struct_size = sizeof(*ref); > + > + ret = ref_get_fields(eb, slot, &namelen, &name, &ref_index); > + if (ret) > + return ret; > + > + > + parent_objectid = key->offset; > + } > + > + inode_objectid = key->objectid; > > /* > * it is possible that we didn't log all the parent directories > @@ -817,32 +903,20 @@ static noinline int add_inode_ref(struct > btrfs_trans_handle *trans, > * copy the back ref in. The link count fixup code will take > * care of the rest > */ > - dir = read_one_inode(root, key->offset); > + dir = read_one_inode(root, parent_objectid); > if (!dir) > return -ENOENT; > > - inode = read_one_inode(root, key->objectid); > + inode = read_one_inode(root, inode_objectid); > if (!inode) { > iput(dir); > return -EIO; > } > > - ref_ptr = btrfs_item_ptr_offset(eb, slot); > - ref_end = ref_ptr + btrfs_item_size_nr(eb, slot); > - > again: > - ref = (struct btrfs_inode_ref *)ref_ptr; > - > - namelen = btrfs_inode_ref_name_len(eb, ref); > - name = kmalloc(namelen, GFP_NOFS); > - BUG_ON(!name); > - > - read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen); > - > /* if we already have a perfect match, we're done */ > if (inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode), > - btrfs_inode_ref_index(eb, ref), > - name, namelen)) { > + ref_index, name, namelen)) { > goto out; > } > > @@ -857,19 +931,23 @@ again: > if (search_done) > goto insert; > > - ret = btrfs_search_slot(NULL, root, key, path, 0, 0); > + /* Search old style refs */ > + search_key.objectid = inode_objectid; > + search_key.type = BTRFS_INODE_REF_KEY; > + search_key.offset = parent_objectid; > + > + ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0); > if (ret == 0) { > - char *victim_name; > - int victim_name_len; > struct btrfs_inode_ref *victim_ref; > unsigned long ptr; > unsigned long ptr_end; > - struct extent_buffer *leaf = path->nodes[0]; > + > + leaf = path->nodes[0]; > > /* are we trying to overwrite a back ref for the root directory > * if so, just jump out, we're done > */ > - if (key->objectid == key->offset) > + if (search_key.objectid == search_key.offset) > goto out_nowrite; > > /* check all the names in this back reference to see > @@ -889,7 +967,7 @@ again: > (unsigned long)(victim_ref + 1), > victim_name_len); > > - if (!backref_in_log(log, key, victim_name, > + if (!backref_in_log(log, &search_key, victim_name, > victim_name_len)) { > btrfs_inc_nlink(inode); > btrfs_release_path(path); > @@ -903,19 +981,61 @@ again: > ptr = (unsigned long)(victim_ref + 1) + victim_name_len; > } > BUG_ON(ret); > - > /* > * NOTE: we have searched root tree and checked the > - * coresponding ref, it does not need to check again. > + * coresponding refs, it does not need to be checked again. > */ > search_done = 1; > } > btrfs_release_path(path); > > + /* Same search but for extended refs */ > + extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen, > + inode_objectid, parent_objectid, 0, > + 0); > + if (!IS_ERR_OR_NULL(extref)) { Okay, one obvious comment at least: You don't execute this block on IS_ERR(extref), but you don't act on that situation either. Is that on purpose? > + u32 item_size; > + u32 cur_offset = 0; > + unsigned long base; > + > + leaf = path->nodes[0]; > + > + item_size = btrfs_item_size_nr(leaf, path->slots[0]); > + base = btrfs_item_ptr_offset(leaf, path->slots[0]); > + > + while (cur_offset < item_size) { > + extref = (struct btrfs_inode_extref *)base + cur_offset; > + > + victim_name_len = btrfs_inode_extref_name_len(eb, > extref); > + victim_name = kmalloc(namelen, GFP_NOFS); > + leaf = path->nodes[0]; > + read_extent_buffer(eb, name, (unsigned > long)&extref->name, namelen); > + > + search_key.objectid = inode_objectid; > + search_key.type = BTRFS_INODE_EXTREF_KEY; > + search_key.offset = btrfs_extref_hash(parent_objectid, > + name, namelen); > + if (!backref_in_log(log, &search_key, victim_name, > + victim_name_len)) { > + btrfs_inc_nlink(inode); > + btrfs_release_path(path); > + > + ret = btrfs_unlink_inode(trans, root, dir, > + inode, victim_name, > + victim_name_len); > + } > + kfree(victim_name); > + BUG_ON(ret); > + > + cur_offset += victim_name_len + sizeof(*extref); > + } > + search_done = 1; > + } > + > + > /* look for a conflicting sequence number */ > di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir), > - btrfs_inode_ref_index(eb, ref), > - name, namelen, 0); > + ref_index, name, namelen, 0); > if (di && !IS_ERR(di)) { > ret = drop_one_dir_item(trans, root, path, dir, di); > BUG_ON(ret); > @@ -933,17 +1053,25 @@ again: > > insert: > /* insert our name */ > - ret = btrfs_add_link(trans, dir, inode, name, namelen, 0, > - btrfs_inode_ref_index(eb, ref)); > + ret = btrfs_add_link(trans, dir, inode, name, namelen, 0, ref_index); > BUG_ON(ret); > > btrfs_update_inode(trans, root, inode); > > out: > - ref_ptr = (unsigned long)(ref + 1) + namelen; > + ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen; > kfree(name); > - if (ref_ptr < ref_end) > + if (ref_ptr < ref_end) { > + if (log_ref_ver) { > + ret = extref_get_fields(eb, slot, &namelen, &name, > + &ref_index, NULL); > + } else { > + ret = ref_get_fields(eb, slot, &namelen, &name, > + &ref_index); > + } > + BUG_ON(ret); > goto again; > + } > > /* finally write the back reference in the inode */ > ret = overwrite_item(trans, root, path, eb, slot, key); > @@ -966,25 +1094,52 @@ static int insert_orphan_item(struct > btrfs_trans_handle *trans, > return ret; > } > > +static int count_inode_extrefs(struct btrfs_root *root, > + struct inode *inode, struct btrfs_path *path) > +{ > + int ret = 0; > + int name_len; > + unsigned int nlink = 0; > + u32 item_size; > + u32 cur_offset = 0; > + u64 inode_objectid = btrfs_ino(inode); > + u64 offset = 0; > + unsigned long ptr; > + struct btrfs_inode_extref *extref; > + struct extent_buffer *leaf; > + > + while (1) { > + ret = btrfs_find_one_extref(root, inode_objectid, offset, path, > + &extref, &offset); > + if (ret) > + break; > > -/* > - * There are a few corners where the link count of the file can't > - * be properly maintained during replay. So, instead of adding > - * lots of complexity to the log code, we just scan the backrefs > - * for any file that has been through replay. > - * > - * The scan will update the link count on the inode to reflect the > - * number of back refs found. If it goes down to zero, the iput > - * will free the inode. > - */ > -static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans, > - struct btrfs_root *root, > - struct inode *inode) > + leaf = path->nodes[0]; > + item_size = btrfs_item_size_nr(leaf, path->slots[0]); > + ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); > + > + while (cur_offset < item_size) { > + extref = (struct btrfs_inode_extref *) (ptr + > cur_offset); > + name_len = btrfs_inode_extref_name_len(leaf, extref); > + > + nlink++; > + > + cur_offset += name_len + sizeof(*extref); > + } > + > + offset++; > + } > + btrfs_release_path(path); > + > + return (ret == 0) ? nlink : ret; You depend on btrfs_find_one_extref never returning >0 here. I'd make that ... if (ret < 0) return ret; return nlink; This ignores ret > 0 explicitly, which is in my opinion better than a spurious link count. > +} > + > +static int count_inode_refs(struct btrfs_root *root, > + struct inode *inode, struct btrfs_path *path) > { > - struct btrfs_path *path; > int ret; > struct btrfs_key key; > - u64 nlink = 0; > + unsigned int nlink = 0; > unsigned long ptr; > unsigned long ptr_end; > int name_len; > @@ -994,10 +1149,6 @@ static noinline int fixup_inode_link_count(struct > btrfs_trans_handle *trans, > key.type = BTRFS_INODE_REF_KEY; > key.offset = (u64)-1; > > - path = btrfs_alloc_path(); > - if (!path) > - return -ENOMEM; > - > while (1) { > ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); > if (ret < 0) > @@ -1031,6 +1182,45 @@ static noinline int fixup_inode_link_count(struct > btrfs_trans_handle *trans, > btrfs_release_path(path); > } > btrfs_release_path(path); > + > + return nlink; > +} > + > +/* > + * There are a few corners where the link count of the file can't > + * be properly maintained during replay. So, instead of adding > + * lots of complexity to the log code, we just scan the backrefs > + * for any file that has been through replay. > + * > + * The scan will update the link count on the inode to reflect the > + * number of back refs found. If it goes down to zero, the iput > + * will free the inode. > + */ > +static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans, > + struct btrfs_root *root, > + struct inode *inode) > +{ > + struct btrfs_path *path; > + int ret; > + u64 nlink = 0; > + u64 ino = btrfs_ino(inode); > + > + path = btrfs_alloc_path(); > + if (!path) > + return -ENOMEM; > + > + ret = count_inode_refs(root, inode, path); > + if (ret < 0) > + goto out; > + > + nlink = ret; > + > + ret = count_inode_extrefs(root, inode, path); > + if (ret < 0) > + goto out; > + > + nlink += ret; > + > if (nlink != inode->i_nlink) { > set_nlink(inode, nlink); > btrfs_update_inode(trans, root, inode); > @@ -1046,9 +1236,10 @@ static noinline int fixup_inode_link_count(struct > btrfs_trans_handle *trans, > ret = insert_orphan_item(trans, root, ino); > BUG_ON(ret); > } > - btrfs_free_path(path); > > - return 0; > +out: > + btrfs_free_path(path); > + return ret; > } > > static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans, > @@ -1695,6 +1886,10 @@ static int replay_one_buffer(struct btrfs_root *log, > struct extent_buffer *eb, > ret = add_inode_ref(wc->trans, root, log, path, > eb, i, &key); > BUG_ON(ret && ret != -ENOENT); > + } else if (key.type == BTRFS_INODE_EXTREF_KEY) { > + ret = add_inode_ref(wc->trans, root, log, path, > + eb, i, &key); > + BUG_ON(ret && ret != -ENOENT); > } else if (key.type == BTRFS_EXTENT_DATA_KEY) { > ret = replay_one_extent(wc->trans, root, path, > eb, i, &key); That's it for this round, here comes the promised patch. Should apply with "git am --scissors". Can you please add a version to the subject before sending the revised patches? Like "git format-patch --subject-prefix v4". Thanks, -Jan -- >8 -- Subject: [PATCH] Btrfs: improved readablity for add_inode_ref Moved part of the code into a sub function and replaced most of the gotos by ifs, hoping that it will be easier to read now. Signed-off-by: Jan Schmidt <[email protected]> --- fs/btrfs/tree-log.c | 178 ++++++++++++++++++++++++++++----------------------- 1 files changed, 97 insertions(+), 81 deletions(-) diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c index c86670f..59f3071 100644 --- a/fs/btrfs/tree-log.c +++ b/fs/btrfs/tree-log.c @@ -786,76 +786,18 @@ out: return match; } - -/* - * replay one inode back reference item found in the log tree. - * eb, slot and key refer to the buffer and key found in the log tree. - * root is the destination we are replaying into, and path is for temp - * use by this function. (it should be released on return). - */ -static noinline int add_inode_ref(struct btrfs_trans_handle *trans, +static inline int __add_inode_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, - struct btrfs_root *log, struct btrfs_path *path, - struct extent_buffer *eb, int slot, - struct btrfs_key *key) + struct btrfs_root *log_root, + struct inode *dir, struct inode *inode, + struct btrfs_key *key, + struct extent_buffer *eb, + struct btrfs_inode_ref *ref, + char *name, int namelen, int *search_done) { - struct btrfs_inode_ref *ref; - struct btrfs_dir_item *di; - struct inode *dir; - struct inode *inode; - unsigned long ref_ptr; - unsigned long ref_end; - char *name; - int namelen; int ret; - int search_done = 0; - - /* - * it is possible that we didn't log all the parent directories - * for a given inode. If we don't find the dir, just don't - * copy the back ref in. The link count fixup code will take - * care of the rest - */ - dir = read_one_inode(root, key->offset); - if (!dir) - return -ENOENT; - - inode = read_one_inode(root, key->objectid); - if (!inode) { - iput(dir); - return -EIO; - } - - ref_ptr = btrfs_item_ptr_offset(eb, slot); - ref_end = ref_ptr + btrfs_item_size_nr(eb, slot); - -again: - ref = (struct btrfs_inode_ref *)ref_ptr; - - namelen = btrfs_inode_ref_name_len(eb, ref); - name = kmalloc(namelen, GFP_NOFS); - BUG_ON(!name); - - read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen); - - /* if we already have a perfect match, we're done */ - if (inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode), - btrfs_inode_ref_index(eb, ref), - name, namelen)) { - goto out; - } - - /* - * look for a conflicting back reference in the metadata. - * if we find one we have to unlink that name of the file - * before we add our new link. Later on, we overwrite any - * existing back reference, and we don't want to create - * dangling pointers in the directory. - */ - - if (search_done) - goto insert; + struct btrfs_dir_item *di; ret = btrfs_search_slot(NULL, root, key, path, 0, 0); if (ret == 0) { @@ -870,7 +812,7 @@ again: * if so, just jump out, we're done */ if (key->objectid == key->offset) - goto out_nowrite; + return 1; /* check all the names in this back reference to see * if they are in the log. if so, we allow them to stay @@ -889,7 +831,7 @@ again: (unsigned long)(victim_ref + 1), victim_name_len); - if (!backref_in_log(log, key, victim_name, + if (!backref_in_log(log_root, key, victim_name, victim_name_len)) { btrfs_inc_nlink(inode); btrfs_release_path(path); @@ -908,7 +850,7 @@ again: * NOTE: we have searched root tree and checked the * coresponding ref, it does not need to check again. */ - search_done = 1; + *search_done = 1; } btrfs_release_path(path); @@ -931,25 +873,99 @@ again: } btrfs_release_path(path); -insert: - /* insert our name */ - ret = btrfs_add_link(trans, dir, inode, name, namelen, 0, - btrfs_inode_ref_index(eb, ref)); - BUG_ON(ret); + return 0; +} + +/* + * replay one inode back reference item found in the log tree. + * eb, slot and key refer to the buffer and key found in the log tree. + * root is the destination we are replaying into, and path is for temp + * use by this function. (it should be released on return). + */ +static noinline int add_inode_ref(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_root *log, + struct btrfs_path *path, + struct extent_buffer *eb, int slot, + struct btrfs_key *key) +{ + struct btrfs_inode_ref *ref; + struct inode *dir; + struct inode *inode; + unsigned long ref_ptr; + unsigned long ref_end; + char *name; + int namelen; + int ret; + int search_done = 0; + + /* + * it is possible that we didn't log all the parent directories + * for a given inode. If we don't find the dir, just don't + * copy the back ref in. The link count fixup code will take + * care of the rest + */ + dir = read_one_inode(root, key->offset); + if (!dir) + return -ENOENT; - btrfs_update_inode(trans, root, inode); + inode = read_one_inode(root, key->objectid); + if (!inode) { + iput(dir); + return -EIO; + } -out: - ref_ptr = (unsigned long)(ref + 1) + namelen; - kfree(name); - if (ref_ptr < ref_end) - goto again; + ref_ptr = btrfs_item_ptr_offset(eb, slot); + ref_end = ref_ptr + btrfs_item_size_nr(eb, slot); + + while (ref_ptr < ref_end) { + ref = (struct btrfs_inode_ref *)ref_ptr; + + namelen = btrfs_inode_ref_name_len(eb, ref); + name = kmalloc(namelen, GFP_NOFS); + BUG_ON(!name); + + read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen); + + /* if we already have a perfect match, we're done */ + if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode), + btrfs_inode_ref_index(eb, ref), + name, namelen)) { + /* + * look for a conflicting back reference in the + * metadata. if we find one we have to unlink that name + * of the file before we add our new link. Later on, we + * overwrite any existing back reference, and we don't + * want to create dangling pointers in the directory. + */ + + if (!search_done) { + ret = __add_inode_ref(trans, root, path, log, + dir, inode, key, eb, ref, + name, namelen, + &search_done); + if (ret == 1) + goto out; + BUG_ON(ret); + } + + /* insert our name */ + ret = btrfs_add_link(trans, dir, inode, name, namelen, + 0, btrfs_inode_ref_index(eb, ref)); + BUG_ON(ret); + + btrfs_update_inode(trans, root, inode); + } + + ref_ptr = (unsigned long)(ref + 1) + namelen; + kfree(name); + } /* finally write the back reference in the inode */ ret = overwrite_item(trans, root, path, eb, slot, key); BUG_ON(ret); -out_nowrite: +out: btrfs_release_path(path); iput(dir); iput(inode); -- 1.7.1 -- To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
