Btrfs: Create orphan inode records to prevent lost files after a crash

Signed-off-by: Chris Mason <chris.mason@oracle.com>

1 files changed, 234 insertions, 3 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 2d8853543a71..0c9ec8aa304a 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -78,6 +78,8 @@ static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
         [S_IFLNK >> S_SHIFT]    = BTRFS_FT_SYMLINK,
 };
 
+static void btrfs_truncate(struct inode *inode);
+
 int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
                            int for_del)
 {
@@ -826,6 +828,190 @@ zeroit:
         return -EIO;
 }
 
+/*
+ * This creates an orphan entry for the given inode in case something goes
+ * wrong in the middle of an unlink/truncate.
+ */
+int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret = 0;
+
+        spin_lock(&root->orphan_lock);
+
+        /* already on the orphan list, we're good */
+        if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
+                spin_unlock(&root->orphan_lock);
+                return 0;
+        }
+
+        list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
+
+        spin_unlock(&root->orphan_lock);
+
+        /*
+         * insert an orphan item to track this unlinked/truncated file
+         */
+        ret = btrfs_insert_orphan_item(trans, root, inode->i_ino);
+
+        return ret;
+}
+
+/*
+ * We have done the truncate/delete so we can go ahead and remove the orphan
+ * item for this particular inode.
+ */
+int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret = 0;
+
+        spin_lock(&root->orphan_lock);
+
+        if (list_empty(&BTRFS_I(inode)->i_orphan)) {
+                spin_unlock(&root->orphan_lock);
+                return 0;
+        }
+
+        list_del_init(&BTRFS_I(inode)->i_orphan);
+        if (!trans) {
+                spin_unlock(&root->orphan_lock);
+                return 0;
+        }
+
+        spin_unlock(&root->orphan_lock);
+
+        ret = btrfs_del_orphan_item(trans, root, inode->i_ino);
+
+        return ret;
+}
+
+/*
+ * this cleans up any orphans that may be left on the list from the last use
+ * of this root.
+ */
+void btrfs_orphan_cleanup(struct btrfs_root *root)
+{
+        struct btrfs_path *path;
+        struct extent_buffer *leaf;
+        struct btrfs_item *item;
+        struct btrfs_key key, found_key;
+        struct btrfs_trans_handle *trans;
+        struct inode *inode;
+        int ret = 0, nr_unlink = 0, nr_truncate = 0;
+
+        /* don't do orphan cleanup if the fs is readonly. */
+        if (root->inode->i_sb->s_flags & MS_RDONLY)
+                return;
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return;
+        path->reada = -1;
+
+        key.objectid = BTRFS_ORPHAN_OBJECTID;
+        btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
+        key.offset = (u64)-1;
+
+        trans = btrfs_start_transaction(root, 1);
+        btrfs_set_trans_block_group(trans, root->inode);
+
+        while (1) {
+                ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+                if (ret < 0) {
+                        printk(KERN_ERR "Error searching slot for orphan: %d"
+                               "\n", ret);
+                        break;
+                }
+
+                /*
+                 * if ret == 0 means we found what we were searching for, which
+                 * is weird, but possible, so only screw with path if we didnt
+                 * find the key and see if we have stuff that matches
+                 */
+                if (ret > 0) {
+                        if (path->slots[0] == 0)
+                                break;
+                        path->slots[0]--;
+                }
+
+                /* pull out the item */
+                leaf = path->nodes[0];
+                item = btrfs_item_nr(leaf, path->slots[0]);
+                btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+
+                /* make sure the item matches what we want */
+                if (found_key.objectid != BTRFS_ORPHAN_OBJECTID)
+                        break;
+                if (btrfs_key_type(&found_key) != BTRFS_ORPHAN_ITEM_KEY)
+                        break;
+
+                /* release the path since we're done with it */
+                btrfs_release_path(root, path);
+
+                /*
+                 * this is where we are basically btrfs_lookup, without the
+                 * crossing root thing.  we store the inode number in the
+                 * offset of the orphan item.
+                 */
+                inode = btrfs_iget_locked(root->inode->i_sb,
+                                          found_key.offset, root);
+                if (!inode)
+                        break;
+
+                if (inode->i_state & I_NEW) {
+                        BTRFS_I(inode)->root = root;
+
+                        /* have to set the location manually */
+                        BTRFS_I(inode)->location.objectid = inode->i_ino;
+                        BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
+                        BTRFS_I(inode)->location.offset = 0;
+
+                        btrfs_read_locked_inode(inode);
+                        unlock_new_inode(inode);
+                }
+
+                /*
+                 * add this inode to the orphan list so btrfs_orphan_del does
+                 * the proper thing when we hit it
+                 */
+                spin_lock(&root->orphan_lock);
+                list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
+                spin_unlock(&root->orphan_lock);
+
+                /*
+                 * if this is a bad inode, means we actually succeeded in
+                 * removing the inode, but not the orphan record, which means
+                 * we need to manually delete the orphan since iput will just
+                 * do a destroy_inode
+                 */
+                if (is_bad_inode(inode)) {
+                        btrfs_orphan_del(trans, inode);
+                        iput(inode);
+                        continue;
+                }
+
+                /* if we have links, this was a truncate, lets do that */
+                if (inode->i_nlink) {
+                        nr_truncate++;
+                        btrfs_truncate(inode);
+                } else {
+                        nr_unlink++;
+                }
+
+                /* this will do delete_inode and everything for us */
+                iput(inode);
+        }
+
+        if (nr_unlink)
+                printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
+        if (nr_truncate)
+                printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
+
+        btrfs_free_path(path);
+        btrfs_end_transaction(trans, root);
+}
+
 void btrfs_read_locked_inode(struct inode *inode)
 {
         struct btrfs_path *path;
@@ -1067,6 +1253,7 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct btrfs_root *root;
         struct btrfs_trans_handle *trans;
+        struct inode *inode = dentry->d_inode;
         int ret;
         unsigned long nr = 0;
 
@@ -1080,6 +1267,10 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 
         btrfs_set_trans_block_group(trans, dir);
         ret = btrfs_unlink_trans(trans, root, dir, dentry);
+
+        if (inode->i_nlink == 0)
+                ret = btrfs_orphan_add(trans, inode);
+
         nr = trans->blocks_used;
 
         btrfs_end_transaction_throttle(trans, root);
@@ -1108,12 +1299,17 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
         trans = btrfs_start_transaction(root, 1);
         btrfs_set_trans_block_group(trans, dir);
 
+        err = btrfs_orphan_add(trans, inode);
+        if (err)
+                goto fail_trans;
+
         /* now the directory is empty */
         err = btrfs_unlink_trans(trans, root, dir, dentry);
         if (!err) {
                 btrfs_i_size_write(inode, 0);
         }
 
+fail_trans:
         nr = trans->blocks_used;
         ret = btrfs_end_transaction_throttle(trans, root);
 fail:
@@ -1131,6 +1327,9 @@ fail:
  *
  * csum items that cross the new i_size are truncated to the new size
  * as well.
+ *
+ * min_type is the minimum key type to truncate down to.  If set to 0, this
+ * will kill all the items on this inode, including the INODE_ITEM_KEY.
  */
 static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
                                    struct btrfs_root *root,
@@ -1495,6 +1694,7 @@ void btrfs_delete_inode(struct inode *inode)
 
         truncate_inode_pages(&inode->i_data, 0);
         if (is_bad_inode(inode)) {
+                btrfs_orphan_del(NULL, inode);
                 goto no_delete;
         }
         btrfs_wait_ordered_range(inode, 0, (u64)-1);
@@ -1504,8 +1704,12 @@ void btrfs_delete_inode(struct inode *inode)
 
         btrfs_set_trans_block_group(trans, inode);
         ret = btrfs_truncate_in_trans(trans, root, inode, 0);
-        if (ret)
+        if (ret) {
+                btrfs_orphan_del(NULL, inode);
                 goto no_delete_lock;
+        }
+
+        btrfs_orphan_del(trans, inode);
 
         nr = trans->blocks_used;
         clear_inode(inode);
@@ -1688,7 +1892,7 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
         struct btrfs_root *root = bi->root;
         struct btrfs_root *sub_root = root;
         struct btrfs_key location;
-        int ret;
+        int ret, do_orphan = 0;
 
         if (dentry->d_name.len > BTRFS_NAME_LEN)
                 return ERR_PTR(-ENAMETOOLONG);
@@ -1706,6 +1910,7 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
                         return ERR_PTR(ret);
                 if (ret > 0)
                         return ERR_PTR(-ENOENT);
+
                 inode = btrfs_iget_locked(dir->i_sb, location.objectid,
                                           sub_root);
                 if (!inode)
@@ -1715,6 +1920,7 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
                         if (sub_root != root) {
                                 igrab(inode);
                                 sub_root->inode = inode;
+                                do_orphan = 1;
                         }
                         BTRFS_I(inode)->root = sub_root;
                         memcpy(&BTRFS_I(inode)->location, &location,
@@ -1723,6 +1929,10 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
                         unlock_new_inode(inode);
                 }
         }
+
+        if (unlikely(do_orphan))
+                btrfs_orphan_cleanup(sub_root);
+
         return d_splice_alias(inode, dentry);
 }
 
@@ -2964,12 +3174,19 @@ static void btrfs_truncate(struct inode *inode)
         btrfs_set_trans_block_group(trans, inode);
         btrfs_i_size_write(inode, inode->i_size);
 
+        ret = btrfs_orphan_add(trans, inode);
+        if (ret)
+                goto out;
         /* FIXME, add redo link to tree so we don't leak on crash */
         ret = btrfs_truncate_in_trans(trans, root, inode,
                                       BTRFS_EXTENT_DATA_KEY);
         btrfs_update_inode(trans, root, inode);
-        nr = trans->blocks_used;
 
+        ret = btrfs_orphan_del(trans, inode);
+        BUG_ON(ret);
+
+out:
+        nr = trans->blocks_used;
         ret = btrfs_end_transaction_throttle(trans, root);
         BUG_ON(ret);
         btrfs_btree_balance_dirty(root, nr);
@@ -3046,6 +3263,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         btrfs_ordered_inode_tree_init(&ei->ordered_tree);
         ei->i_acl = BTRFS_ACL_NOT_CACHED;
         ei->i_default_acl = BTRFS_ACL_NOT_CACHED;
+        INIT_LIST_HEAD(&ei->i_orphan);
         return &ei->vfs_inode;
 }
 
@@ -3062,6 +3280,14 @@ void btrfs_destroy_inode(struct inode *inode)
             BTRFS_I(inode)->i_default_acl != BTRFS_ACL_NOT_CACHED)
                 posix_acl_release(BTRFS_I(inode)->i_default_acl);
 
+        spin_lock(&BTRFS_I(inode)->root->orphan_lock);
+        if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
+                printk(KERN_ERR "BTRFS: inode %lu: inode still on the orphan"
+                       " list\n", inode->i_ino);
+                dump_stack();
+        }
+        spin_unlock(&BTRFS_I(inode)->root->orphan_lock);
+
         while(1) {
                 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
                 if (!ordered)
@@ -3202,6 +3428,11 @@ static int btrfs_rename(struct inode * old_dir, struct dentry *old_dentry,
                 ret = btrfs_unlink_trans(trans, root, new_dir, new_dentry);
                 if (ret)
                         goto out_fail;
+                if (new_inode->i_nlink == 0) {
+                        ret = btrfs_orphan_add(trans, new_inode);
+                        if (ret)
+                                goto out_fail;
+                }
         }
         ret = btrfs_set_inode_index(new_dir, old_inode);
         if (ret)