Btrfs: fix cur_ino < parent_ino case for send/receive
authorAlexander Block <ablock84@googlemail.com>
Sat, 28 Jul 2012 08:42:24 +0000 (10:42 +0200)
committerChris Mason <chris.mason@fusionio.com>
Mon, 1 Oct 2012 19:18:45 +0000 (15:18 -0400)
When the current inodes inum is smaller then the inum of the
parent directory strange things were happending due to wrong
path resolution and other bugs. Fix this with a new approach
for the problem.

Reported-by: Alex Lyakas <alex.bolshoy.btrfs@gmail.com>
Signed-off-by: Alexander Block <ablock84@googlemail.com>
fs/btrfs/send.c

index 5721401548e839e084e965d2e721730662868439..a5fae484d4e104986a3d8f16df38ac621cb7f511 100644 (file)
@@ -107,7 +107,6 @@ struct send_ctx {
        int cur_inode_new;
        int cur_inode_new_gen;
        int cur_inode_deleted;
-       int cur_inode_first_ref_orphan;
        u64 cur_inode_size;
        u64 cur_inode_mode;
 
@@ -2296,25 +2295,25 @@ out:
  * a valid path yet because we did not process the refs yet. So, the inode
  * is created as orphan.
  */
-static int send_create_inode(struct send_ctx *sctx, struct btrfs_path *path,
-                            struct btrfs_key *key)
+static int send_create_inode(struct send_ctx *sctx, u64 ino)
 {
        int ret = 0;
-       struct extent_buffer *eb = path->nodes[0];
-       struct btrfs_inode_item *ii;
        struct fs_path *p;
-       int slot = path->slots[0];
        int cmd;
+       u64 gen;
        u64 mode;
+       u64 rdev;
 
-verbose_printk("btrfs: send_create_inode %llu\n", sctx->cur_ino);
+verbose_printk("btrfs: send_create_inode %llu\n", ino);
 
        p = fs_path_alloc(sctx);
        if (!p)
                return -ENOMEM;
 
-       ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
-       mode = btrfs_inode_mode(eb, ii);
+       ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode, NULL,
+                       NULL, &rdev);
+       if (ret < 0)
+               goto out;
 
        if (S_ISREG(mode))
                cmd = BTRFS_SEND_C_MKFILE;
@@ -2339,22 +2338,22 @@ verbose_printk("btrfs: send_create_inode %llu\n", sctx->cur_ino);
        if (ret < 0)
                goto out;
 
-       ret = gen_unique_name(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
+       ret = gen_unique_name(sctx, ino, gen, p);
        if (ret < 0)
                goto out;
 
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
-       TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, sctx->cur_ino);
+       TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino);
 
        if (S_ISLNK(mode)) {
                fs_path_reset(p);
-               ret = read_symlink(sctx, sctx->send_root, sctx->cur_ino, p);
+               ret = read_symlink(sctx, sctx->send_root, ino, p);
                if (ret < 0)
                        goto out;
                TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p);
        } else if (S_ISCHR(mode) || S_ISBLK(mode) ||
                   S_ISFIFO(mode) || S_ISSOCK(mode)) {
-               TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, btrfs_inode_rdev(eb, ii));
+               TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, rdev);
        }
 
        ret = send_cmd(sctx);
@@ -2368,6 +2367,92 @@ out:
        return ret;
 }
 
+/*
+ * We need some special handling for inodes that get processed before the parent
+ * directory got created. See process_recorded_refs for details.
+ * This function does the check if we already created the dir out of order.
+ */
+static int did_create_dir(struct send_ctx *sctx, u64 dir)
+{
+       int ret = 0;
+       struct btrfs_path *path = NULL;
+       struct btrfs_key key;
+       struct btrfs_key found_key;
+       struct btrfs_key di_key;
+       struct extent_buffer *eb;
+       struct btrfs_dir_item *di;
+       int slot;
+
+       path = alloc_path_for_send();
+       if (!path) {
+               ret = -ENOMEM;
+               goto out;
+       }
+
+       key.objectid = dir;
+       key.type = BTRFS_DIR_INDEX_KEY;
+       key.offset = 0;
+       while (1) {
+               ret = btrfs_search_slot_for_read(sctx->send_root, &key, path,
+                               1, 0);
+               if (ret < 0)
+                       goto out;
+               if (!ret) {
+                       eb = path->nodes[0];
+                       slot = path->slots[0];
+                       btrfs_item_key_to_cpu(eb, &found_key, slot);
+               }
+               if (ret || found_key.objectid != key.objectid ||
+                   found_key.type != key.type) {
+                       ret = 0;
+                       goto out;
+               }
+
+               di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
+               btrfs_dir_item_key_to_cpu(eb, di, &di_key);
+
+               if (di_key.objectid < sctx->send_progress) {
+                       ret = 1;
+                       goto out;
+               }
+
+               key.offset = found_key.offset + 1;
+               btrfs_release_path(path);
+       }
+
+out:
+       btrfs_free_path(path);
+       return ret;
+}
+
+/*
+ * Only creates the inode if it is:
+ * 1. Not a directory
+ * 2. Or a directory which was not created already due to out of order
+ *    directories. See did_create_dir and process_recorded_refs for details.
+ */
+static int send_create_inode_if_needed(struct send_ctx *sctx)
+{
+       int ret;
+
+       if (S_ISDIR(sctx->cur_inode_mode)) {
+               ret = did_create_dir(sctx, sctx->cur_ino);
+               if (ret < 0)
+                       goto out;
+               if (ret) {
+                       ret = 0;
+                       goto out;
+               }
+       }
+
+       ret = send_create_inode(sctx, sctx->cur_ino);
+       if (ret < 0)
+               goto out;
+
+out:
+       return ret;
+}
+
 struct recorded_ref {
        struct list_head list;
        char *dir_path;
@@ -2517,160 +2602,6 @@ out:
        return ret;
 }
 
-struct finish_unordered_dir_ctx {
-       struct send_ctx *sctx;
-       struct fs_path *cur_path;
-       struct fs_path *dir_path;
-       u64 dir_ino;
-       int need_delete;
-       int delete_pass;
-};
-
-int __finish_unordered_dir(int num, struct btrfs_key *di_key,
-                          const char *name, int name_len,
-                          const char *data, int data_len,
-                          u8 type, void *ctx)
-{
-       int ret = 0;
-       struct finish_unordered_dir_ctx *fctx = ctx;
-       struct send_ctx *sctx = fctx->sctx;
-       u64 di_gen;
-       u64 di_mode;
-       int is_orphan = 0;
-
-       if (di_key->objectid >= fctx->dir_ino)
-               goto out;
-
-       fs_path_reset(fctx->cur_path);
-
-       ret = get_inode_info(sctx->send_root, di_key->objectid,
-                       NULL, &di_gen, &di_mode, NULL, NULL, NULL);
-       if (ret < 0)
-               goto out;
-
-       ret = is_first_ref(sctx, sctx->send_root, di_key->objectid,
-                       fctx->dir_ino, name, name_len);
-       if (ret < 0)
-               goto out;
-       if (ret) {
-               is_orphan = 1;
-               ret = gen_unique_name(sctx, di_key->objectid, di_gen,
-                               fctx->cur_path);
-       } else {
-               ret = get_cur_path(sctx, di_key->objectid, di_gen,
-                               fctx->cur_path);
-       }
-       if (ret < 0)
-               goto out;
-
-       ret = fs_path_add(fctx->dir_path, name, name_len);
-       if (ret < 0)
-               goto out;
-
-       if (!fctx->delete_pass) {
-               if (S_ISDIR(di_mode)) {
-                       ret = send_rename(sctx, fctx->cur_path,
-                                       fctx->dir_path);
-               } else {
-                       ret = send_link(sctx, fctx->dir_path,
-                                       fctx->cur_path);
-                       if (is_orphan)
-                               fctx->need_delete = 1;
-               }
-       } else if (!S_ISDIR(di_mode)) {
-               ret = send_unlink(sctx, fctx->cur_path);
-       } else {
-               ret = 0;
-       }
-
-       fs_path_remove(fctx->dir_path);
-
-out:
-       return ret;
-}
-
-/*
- * Go through all dir items and see if we find refs which could not be created
- * in the past because the dir did not exist at that time.
- */
-static int finish_outoforder_dir(struct send_ctx *sctx, u64 dir, u64 dir_gen)
-{
-       int ret = 0;
-       struct btrfs_path *path = NULL;
-       struct btrfs_key key;
-       struct btrfs_key found_key;
-       struct extent_buffer *eb;
-       struct finish_unordered_dir_ctx fctx;
-       int slot;
-
-       path = alloc_path_for_send();
-       if (!path) {
-               ret = -ENOMEM;
-               goto out;
-       }
-
-       memset(&fctx, 0, sizeof(fctx));
-       fctx.sctx = sctx;
-       fctx.cur_path = fs_path_alloc(sctx);
-       fctx.dir_path = fs_path_alloc(sctx);
-       if (!fctx.cur_path || !fctx.dir_path) {
-               ret = -ENOMEM;
-               goto out;
-       }
-       fctx.dir_ino = dir;
-
-       ret = get_cur_path(sctx, dir, dir_gen, fctx.dir_path);
-       if (ret < 0)
-               goto out;
-
-       /*
-        * We do two passes. The first links in the new refs and the second
-        * deletes orphans if required. Deletion of orphans is not required for
-        * directory inodes, as we always have only one ref and use rename
-        * instead of link for those.
-        */
-
-again:
-       key.objectid = dir;
-       key.type = BTRFS_DIR_ITEM_KEY;
-       key.offset = 0;
-       while (1) {
-               ret = btrfs_search_slot_for_read(sctx->send_root, &key, path,
-                               1, 0);
-               if (ret < 0)
-                       goto out;
-               eb = path->nodes[0];
-               slot = path->slots[0];
-               btrfs_item_key_to_cpu(eb, &found_key, slot);
-
-               if (found_key.objectid != key.objectid ||
-                   found_key.type != key.type) {
-                       btrfs_release_path(path);
-                       break;
-               }
-
-               ret = iterate_dir_item(sctx, sctx->send_root, path,
-                               &found_key, __finish_unordered_dir,
-                               &fctx);
-               if (ret < 0)
-                       goto out;
-
-               key.offset = found_key.offset + 1;
-               btrfs_release_path(path);
-       }
-
-       if (!fctx.delete_pass && fctx.need_delete) {
-               fctx.delete_pass = 1;
-               goto again;
-       }
-
-out:
-       btrfs_free_path(path);
-       fs_path_free(sctx, fctx.cur_path);
-       fs_path_free(sctx, fctx.dir_path);
-       return ret;
-}
-
 /*
  * This does all the move/link/unlink/rmdir magic.
  */
@@ -2678,6 +2609,7 @@ static int process_recorded_refs(struct send_ctx *sctx)
 {
        int ret = 0;
        struct recorded_ref *cur;
+       struct recorded_ref *cur2;
        struct ulist *check_dirs = NULL;
        struct ulist_iterator uit;
        struct ulist_node *un;
@@ -2734,6 +2666,46 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
        }
 
        list_for_each_entry(cur, &sctx->new_refs, list) {
+               /*
+                * We may have refs where the parent directory does not exist
+                * yet. This happens if the parent directories inum is higher
+                * the the current inum. To handle this case, we create the
+                * parent directory out of order. But we need to check if this
+                * did already happen before due to other refs in the same dir.
+                */
+               ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
+               if (ret < 0)
+                       goto out;
+               if (ret == inode_state_will_create) {
+                       ret = 0;
+                       /*
+                        * First check if any of the current inodes refs did
+                        * already create the dir.
+                        */
+                       list_for_each_entry(cur2, &sctx->new_refs, list) {
+                               if (cur == cur2)
+                                       break;
+                               if (cur2->dir == cur->dir) {
+                                       ret = 1;
+                                       break;
+                               }
+                       }
+
+                       /*
+                        * If that did not happen, check if a previous inode
+                        * did already create the dir.
+                        */
+                       if (!ret)
+                               ret = did_create_dir(sctx, cur->dir);
+                       if (ret < 0)
+                               goto out;
+                       if (!ret) {
+                               ret = send_create_inode(sctx, cur->dir);
+                               if (ret < 0)
+                                       goto out;
+                       }
+               }
+
                /*
                 * Check if this new ref would overwrite the first ref of
                 * another unprocessed inode. If yes, orphanize the
@@ -2768,7 +2740,7 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                 * inode, move it and update valid_path. If not, link or move
                 * it depending on the inode mode.
                 */
-               if (is_orphan && !sctx->cur_inode_first_ref_orphan) {
+               if (is_orphan) {
                        ret = send_rename(sctx, valid_path, cur->full_path);
                        if (ret < 0)
                                goto out;
@@ -2844,35 +2816,9 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                        if (ret < 0)
                                goto out;
                        if (!ret) {
-                               /*
-                                * In case the inode was moved to a directory
-                                * that was not created yet (see
-                                * __record_new_ref), we can not unlink the ref
-                                * as it will be needed later when the parent
-                                * directory is created, so that we can move in
-                                * the inode to the new dir.
-                                */
-                               if (!is_orphan &&
-                                   sctx->cur_inode_first_ref_orphan) {
-                                       ret = orphanize_inode(sctx,
-                                                       sctx->cur_ino,
-                                                       sctx->cur_inode_gen,
-                                                       cur->full_path);
-                                       if (ret < 0)
-                                               goto out;
-                                       ret = gen_unique_name(sctx,
-                                                       sctx->cur_ino,
-                                                       sctx->cur_inode_gen,
-                                                       valid_path);
-                                       if (ret < 0)
-                                               goto out;
-                                       is_orphan = 1;
-
-                               } else {
-                                       ret = send_unlink(sctx, cur->full_path);
-                                       if (ret < 0)
-                                               goto out;
-                               }
+                               ret = send_unlink(sctx, cur->full_path);
+                               if (ret < 0)
+                                       goto out;
                        }
                        ret = ulist_add(check_dirs, cur->dir, cur->dir_gen,
                                        GFP_NOFS);
@@ -2885,11 +2831,8 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                 * happen when a previous inode did overwrite the first ref
                 * of this inode and no new refs were added for the current
                 * inode.
-                * We can however not delete the orphan in case the inode relies
-                * in a directory that was not created yet (see
-                * __record_new_ref)
                 */
-               if (is_orphan && !sctx->cur_inode_first_ref_orphan) {
+               if (is_orphan) {
                        ret = send_unlink(sctx, valid_path);
                        if (ret < 0)
                                goto out;
@@ -2939,19 +2882,6 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
         */
        sctx->send_progress = sctx->cur_ino + 1;
 
-       /*
-        * We may have a directory here that has pending refs which could not
-        * be created before (because the dir did not exist before, see
-        * __record_new_ref). finish_outoforder_dir will link/move the pending
-        * refs.
-        */
-       if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_new) {
-               ret = finish_outoforder_dir(sctx, sctx->cur_ino,
-                               sctx->cur_inode_gen);
-               if (ret < 0)
-                       goto out;
-       }
-
        ret = 0;
 
 out:
@@ -2979,31 +2909,6 @@ static int __record_new_ref(int num, u64 dir, int index,
        if (ret < 0)
                goto out;
 
-       /*
-        * The parent may be non-existent at this point in time. This happens
-        * if the ino of the parent dir is higher then the current ino. In this
-        * case, we can not process this ref until the parent dir is finally
-        * created. If we reach the parent dir later, process_recorded_refs
-        * will go through all dir items and process the refs that could not be
-        * processed before. In case this is the first ref, we set
-        * cur_inode_first_ref_orphan to 1 to inform process_recorded_refs to
-        * keep an orphan of the inode so that it later can be used for
-        * link/move
-        */
-       ret = is_inode_existent(sctx, dir, gen);
-       if (ret < 0)
-               goto out;
-       if (!ret) {
-               ret = is_first_ref(sctx, sctx->send_root, sctx->cur_ino, dir,
-                               name->start, fs_path_len(name));
-               if (ret < 0)
-                       goto out;
-               if (ret)
-                       sctx->cur_inode_first_ref_orphan = 1;
-               ret = 0;
-               goto out;
-       }
-
        ret = get_cur_path(sctx, dir, gen, p);
        if (ret < 0)
                goto out;
@@ -4078,7 +3983,6 @@ static int changed_inode(struct send_ctx *sctx,
 
        sctx->cur_ino = key->objectid;
        sctx->cur_inode_new_gen = 0;
-       sctx->cur_inode_first_ref_orphan = 0;
        sctx->send_progress = sctx->cur_ino;
 
        if (result == BTRFS_COMPARE_TREE_NEW ||
@@ -4115,8 +4019,7 @@ static int changed_inode(struct send_ctx *sctx,
                sctx->cur_inode_mode = btrfs_inode_mode(
                                sctx->left_path->nodes[0], left_ii);
                if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
-                       ret = send_create_inode(sctx, sctx->left_path,
-                                       sctx->cmp_key);
+                       ret = send_create_inode_if_needed(sctx);
        } else if (result == BTRFS_COMPARE_TREE_DELETED) {
                sctx->cur_inode_gen = right_gen;
                sctx->cur_inode_new = 0;
@@ -4146,8 +4049,7 @@ static int changed_inode(struct send_ctx *sctx,
                                        sctx->left_path->nodes[0], left_ii);
                        sctx->cur_inode_mode = btrfs_inode_mode(
                                        sctx->left_path->nodes[0], left_ii);
-                       ret = send_create_inode(sctx, sctx->left_path,
-                                       sctx->cmp_key);
+                       ret = send_create_inode_if_needed(sctx);
                        if (ret < 0)
                                goto out;