/fs/btrfs/tree-log.c
C | 1885 lines | 1297 code | 208 blank | 380 comment | 285 complexity | b12cb3ee297aa4f781374c221fe46198 MD5 | raw file
- /*
- * Copyright (C) 2008 Oracle. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
- #include <linux/sched.h>
- #include <linux/slab.h>
- #include "ctree.h"
- #include "transaction.h"
- #include "disk-io.h"
- #include "locking.h"
- #include "print-tree.h"
- #include "compat.h"
- #include "tree-log.h"
- /* magic values for the inode_only field in btrfs_log_inode:
- *
- * LOG_INODE_ALL means to log everything
- * LOG_INODE_EXISTS means to log just enough to recreate the inode
- * during log replay
- */
- #define LOG_INODE_ALL 0
- #define LOG_INODE_EXISTS 1
- /*
- * directory trouble cases
- *
- * 1) on rename or unlink, if the inode being unlinked isn't in the fsync
- * log, we must force a full commit before doing an fsync of the directory
- * where the unlink was done.
- * ---> record transid of last unlink/rename per directory
- *
- * mkdir foo/some_dir
- * normal commit
- * rename foo/some_dir foo2/some_dir
- * mkdir foo/some_dir
- * fsync foo/some_dir/some_file
- *
- * The fsync above will unlink the original some_dir without recording
- * it in its new location (foo2). After a crash, some_dir will be gone
- * unless the fsync of some_file forces a full commit
- *
- * 2) we must log any new names for any file or dir that is in the fsync
- * log. ---> check inode while renaming/linking.
- *
- * 2a) we must log any new names for any file or dir during rename
- * when the directory they are being removed from was logged.
- * ---> check inode and old parent dir during rename
- *
- * 2a is actually the more important variant. With the extra logging
- * a crash might unlink the old name without recreating the new one
- *
- * 3) after a crash, we must go through any directories with a link count
- * of zero and redo the rm -rf
- *
- * mkdir f1/foo
- * normal commit
- * rm -rf f1/foo
- * fsync(f1)
- *
- * The directory f1 was fully removed from the FS, but fsync was never
- * called on f1, only its parent dir. After a crash the rm -rf must
- * be replayed. This must be able to recurse down the entire
- * directory tree. The inode link count fixup code takes care of the
- * ugly details.
- */
- /*
- * stages for the tree walking. The first
- * stage (0) is to only pin down the blocks we find
- * the second stage (1) is to make sure that all the inodes
- * we find in the log are created in the subvolume.
- *
- * The last stage is to deal with directories and links and extents
- * and all the other fun semantics
- */
- #define LOG_WALK_PIN_ONLY 0
- #define LOG_WALK_REPLAY_INODES 1
- #define LOG_WALK_REPLAY_ALL 2
- static int btrfs_log_inode(struct btrfs_trans_handle *trans,
- struct btrfs_root *root, struct inode *inode,
- int inode_only);
- static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path, u64 objectid);
- static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_root *log,
- struct btrfs_path *path,
- u64 dirid, int del_all);
- /*
- * tree logging is a special write ahead log used to make sure that
- * fsyncs and O_SYNCs can happen without doing full tree commits.
- *
- * Full tree commits are expensive because they require commonly
- * modified blocks to be recowed, creating many dirty pages in the
- * extent tree an 4x-6x higher write load than ext3.
- *
- * Instead of doing a tree commit on every fsync, we use the
- * key ranges and transaction ids to find items for a given file or directory
- * that have changed in this transaction. Those items are copied into
- * a special tree (one per subvolume root), that tree is written to disk
- * and then the fsync is considered complete.
- *
- * After a crash, items are copied out of the log-tree back into the
- * subvolume tree. Any file data extents found are recorded in the extent
- * allocation tree, and the log-tree freed.
- *
- * The log tree is read three times, once to pin down all the extents it is
- * using in ram and once, once to create all the inodes logged in the tree
- * and once to do all the other items.
- */
- /*
- * start a sub transaction and setup the log tree
- * this increments the log tree writer count to make the people
- * syncing the tree wait for us to finish
- */
- static int start_log_trans(struct btrfs_trans_handle *trans,
- struct btrfs_root *root)
- {
- int ret;
- int err = 0;
- mutex_lock(&root->log_mutex);
- if (root->log_root) {
- if (!root->log_start_pid) {
- root->log_start_pid = current->pid;
- root->log_multiple_pids = false;
- } else if (root->log_start_pid != current->pid) {
- root->log_multiple_pids = true;
- }
- root->log_batch++;
- atomic_inc(&root->log_writers);
- mutex_unlock(&root->log_mutex);
- return 0;
- }
- root->log_multiple_pids = false;
- root->log_start_pid = current->pid;
- mutex_lock(&root->fs_info->tree_log_mutex);
- if (!root->fs_info->log_root_tree) {
- ret = btrfs_init_log_root_tree(trans, root->fs_info);
- if (ret)
- err = ret;
- }
- if (err == 0 && !root->log_root) {
- ret = btrfs_add_log_tree(trans, root);
- if (ret)
- err = ret;
- }
- mutex_unlock(&root->fs_info->tree_log_mutex);
- root->log_batch++;
- atomic_inc(&root->log_writers);
- mutex_unlock(&root->log_mutex);
- return err;
- }
- /*
- * returns 0 if there was a log transaction running and we were able
- * to join, or returns -ENOENT if there were not transactions
- * in progress
- */
- static int join_running_log_trans(struct btrfs_root *root)
- {
- int ret = -ENOENT;
- smp_mb();
- if (!root->log_root)
- return -ENOENT;
- mutex_lock(&root->log_mutex);
- if (root->log_root) {
- ret = 0;
- atomic_inc(&root->log_writers);
- }
- mutex_unlock(&root->log_mutex);
- return ret;
- }
- /*
- * This either makes the current running log transaction wait
- * until you call btrfs_end_log_trans() or it makes any future
- * log transactions wait until you call btrfs_end_log_trans()
- */
- int btrfs_pin_log_trans(struct btrfs_root *root)
- {
- int ret = -ENOENT;
- mutex_lock(&root->log_mutex);
- atomic_inc(&root->log_writers);
- mutex_unlock(&root->log_mutex);
- return ret;
- }
- /*
- * indicate we're done making changes to the log tree
- * and wake up anyone waiting to do a sync
- */
- int btrfs_end_log_trans(struct btrfs_root *root)
- {
- if (atomic_dec_and_test(&root->log_writers)) {
- smp_mb();
- if (waitqueue_active(&root->log_writer_wait))
- wake_up(&root->log_writer_wait);
- }
- return 0;
- }
- /*
- * the walk control struct is used to pass state down the chain when
- * processing the log tree. The stage field tells us which part
- * of the log tree processing we are currently doing. The others
- * are state fields used for that specific part
- */
- struct walk_control {
- /* should we free the extent on disk when done? This is used
- * at transaction commit time while freeing a log tree
- */
- int free;
- /* should we write out the extent buffer? This is used
- * while flushing the log tree to disk during a sync
- */
- int write;
- /* should we wait for the extent buffer io to finish? Also used
- * while flushing the log tree to disk for a sync
- */
- int wait;
- /* pin only walk, we record which extents on disk belong to the
- * log trees
- */
- int pin;
- /* what stage of the replay code we're currently in */
- int stage;
- /* the root we are currently replaying */
- struct btrfs_root *replay_dest;
- /* the trans handle for the current replay */
- struct btrfs_trans_handle *trans;
- /* the function that gets used to process blocks we find in the
- * tree. Note the extent_buffer might not be up to date when it is
- * passed in, and it must be checked or read if you need the data
- * inside it
- */
- int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
- struct walk_control *wc, u64 gen);
- };
- /*
- * process_func used to pin down extents, write them or wait on them
- */
- static int process_one_buffer(struct btrfs_root *log,
- struct extent_buffer *eb,
- struct walk_control *wc, u64 gen)
- {
- if (wc->pin)
- btrfs_pin_extent(log->fs_info->extent_root,
- eb->start, eb->len, 0);
- if (btrfs_buffer_uptodate(eb, gen)) {
- if (wc->write)
- btrfs_write_tree_block(eb);
- if (wc->wait)
- btrfs_wait_tree_block_writeback(eb);
- }
- return 0;
- }
- /*
- * Item overwrite used by replay and tree logging. eb, slot and key all refer
- * to the src data we are copying out.
- *
- * root is the tree we are copying into, and path is a scratch
- * path for use in this function (it should be released on entry and
- * will be released on exit).
- *
- * If the key is already in the destination tree the existing item is
- * overwritten. If the existing item isn't big enough, it is extended.
- * If it is too large, it is truncated.
- *
- * If the key isn't in the destination yet, a new item is inserted.
- */
- static noinline int overwrite_item(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct extent_buffer *eb, int slot,
- struct btrfs_key *key)
- {
- int ret;
- u32 item_size;
- u64 saved_i_size = 0;
- int save_old_i_size = 0;
- unsigned long src_ptr;
- unsigned long dst_ptr;
- int overwrite_root = 0;
- if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
- overwrite_root = 1;
- item_size = btrfs_item_size_nr(eb, slot);
- src_ptr = btrfs_item_ptr_offset(eb, slot);
- /* look for the key in the destination tree */
- ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
- if (ret == 0) {
- char *src_copy;
- char *dst_copy;
- u32 dst_size = btrfs_item_size_nr(path->nodes[0],
- path->slots[0]);
- if (dst_size != item_size)
- goto insert;
- if (item_size == 0) {
- btrfs_release_path(path);
- return 0;
- }
- dst_copy = kmalloc(item_size, GFP_NOFS);
- src_copy = kmalloc(item_size, GFP_NOFS);
- if (!dst_copy || !src_copy) {
- btrfs_release_path(path);
- kfree(dst_copy);
- kfree(src_copy);
- return -ENOMEM;
- }
- read_extent_buffer(eb, src_copy, src_ptr, item_size);
- dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
- read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
- item_size);
- ret = memcmp(dst_copy, src_copy, item_size);
- kfree(dst_copy);
- kfree(src_copy);
- /*
- * they have the same contents, just return, this saves
- * us from cowing blocks in the destination tree and doing
- * extra writes that may not have been done by a previous
- * sync
- */
- if (ret == 0) {
- btrfs_release_path(path);
- return 0;
- }
- }
- insert:
- btrfs_release_path(path);
- /* try to insert the key into the destination tree */
- ret = btrfs_insert_empty_item(trans, root, path,
- key, item_size);
- /* make sure any existing item is the correct size */
- if (ret == -EEXIST) {
- u32 found_size;
- found_size = btrfs_item_size_nr(path->nodes[0],
- path->slots[0]);
- if (found_size > item_size) {
- btrfs_truncate_item(trans, root, path, item_size, 1);
- } else if (found_size < item_size) {
- ret = btrfs_extend_item(trans, root, path,
- item_size - found_size);
- }
- } else if (ret) {
- return ret;
- }
- dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
- path->slots[0]);
- /* don't overwrite an existing inode if the generation number
- * was logged as zero. This is done when the tree logging code
- * is just logging an inode to make sure it exists after recovery.
- *
- * Also, don't overwrite i_size on directories during replay.
- * log replay inserts and removes directory items based on the
- * state of the tree found in the subvolume, and i_size is modified
- * as it goes
- */
- if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
- struct btrfs_inode_item *src_item;
- struct btrfs_inode_item *dst_item;
- src_item = (struct btrfs_inode_item *)src_ptr;
- dst_item = (struct btrfs_inode_item *)dst_ptr;
- if (btrfs_inode_generation(eb, src_item) == 0)
- goto no_copy;
- if (overwrite_root &&
- S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
- S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
- save_old_i_size = 1;
- saved_i_size = btrfs_inode_size(path->nodes[0],
- dst_item);
- }
- }
- copy_extent_buffer(path->nodes[0], eb, dst_ptr,
- src_ptr, item_size);
- if (save_old_i_size) {
- struct btrfs_inode_item *dst_item;
- dst_item = (struct btrfs_inode_item *)dst_ptr;
- btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
- }
- /* make sure the generation is filled in */
- if (key->type == BTRFS_INODE_ITEM_KEY) {
- struct btrfs_inode_item *dst_item;
- dst_item = (struct btrfs_inode_item *)dst_ptr;
- if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
- btrfs_set_inode_generation(path->nodes[0], dst_item,
- trans->transid);
- }
- }
- no_copy:
- btrfs_mark_buffer_dirty(path->nodes[0]);
- btrfs_release_path(path);
- return 0;
- }
- /*
- * simple helper to read an inode off the disk from a given root
- * This can only be called for subvolume roots and not for the log
- */
- static noinline struct inode *read_one_inode(struct btrfs_root *root,
- u64 objectid)
- {
- struct btrfs_key key;
- struct inode *inode;
- key.objectid = objectid;
- key.type = BTRFS_INODE_ITEM_KEY;
- key.offset = 0;
- inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
- if (IS_ERR(inode)) {
- inode = NULL;
- } else if (is_bad_inode(inode)) {
- iput(inode);
- inode = NULL;
- }
- return inode;
- }
- /* replays a single extent in 'eb' at 'slot' with 'key' into the
- * subvolume 'root'. path is released on entry and should be released
- * on exit.
- *
- * extents in the log tree have not been allocated out of the extent
- * tree yet. So, this completes the allocation, taking a reference
- * as required if the extent already exists or creating a new extent
- * if it isn't in the extent allocation tree yet.
- *
- * The extent is inserted into the file, dropping any existing extents
- * from the file that overlap the new one.
- */
- static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct extent_buffer *eb, int slot,
- struct btrfs_key *key)
- {
- int found_type;
- u64 mask = root->sectorsize - 1;
- u64 extent_end;
- u64 alloc_hint;
- u64 start = key->offset;
- u64 saved_nbytes;
- struct btrfs_file_extent_item *item;
- struct inode *inode = NULL;
- unsigned long size;
- int ret = 0;
- item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
- found_type = btrfs_file_extent_type(eb, item);
- if (found_type == BTRFS_FILE_EXTENT_REG ||
- found_type == BTRFS_FILE_EXTENT_PREALLOC)
- extent_end = start + btrfs_file_extent_num_bytes(eb, item);
- else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
- size = btrfs_file_extent_inline_len(eb, item);
- extent_end = (start + size + mask) & ~mask;
- } else {
- ret = 0;
- goto out;
- }
- inode = read_one_inode(root, key->objectid);
- if (!inode) {
- ret = -EIO;
- goto out;
- }
- /*
- * first check to see if we already have this extent in the
- * file. This must be done before the btrfs_drop_extents run
- * so we don't try to drop this extent.
- */
- ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
- start, 0);
- if (ret == 0 &&
- (found_type == BTRFS_FILE_EXTENT_REG ||
- found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
- struct btrfs_file_extent_item cmp1;
- struct btrfs_file_extent_item cmp2;
- struct btrfs_file_extent_item *existing;
- struct extent_buffer *leaf;
- leaf = path->nodes[0];
- existing = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_file_extent_item);
- read_extent_buffer(eb, &cmp1, (unsigned long)item,
- sizeof(cmp1));
- read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
- sizeof(cmp2));
- /*
- * we already have a pointer to this exact extent,
- * we don't have to do anything
- */
- if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
- btrfs_release_path(path);
- goto out;
- }
- }
- btrfs_release_path(path);
- saved_nbytes = inode_get_bytes(inode);
- /* drop any overlapping extents */
- ret = btrfs_drop_extents(trans, inode, start, extent_end,
- &alloc_hint, 1);
- BUG_ON(ret);
- if (found_type == BTRFS_FILE_EXTENT_REG ||
- found_type == BTRFS_FILE_EXTENT_PREALLOC) {
- u64 offset;
- unsigned long dest_offset;
- struct btrfs_key ins;
- ret = btrfs_insert_empty_item(trans, root, path, key,
- sizeof(*item));
- BUG_ON(ret);
- dest_offset = btrfs_item_ptr_offset(path->nodes[0],
- path->slots[0]);
- copy_extent_buffer(path->nodes[0], eb, dest_offset,
- (unsigned long)item, sizeof(*item));
- ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
- ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
- ins.type = BTRFS_EXTENT_ITEM_KEY;
- offset = key->offset - btrfs_file_extent_offset(eb, item);
- if (ins.objectid > 0) {
- u64 csum_start;
- u64 csum_end;
- LIST_HEAD(ordered_sums);
- /*
- * is this extent already allocated in the extent
- * allocation tree? If so, just add a reference
- */
- ret = btrfs_lookup_extent(root, ins.objectid,
- ins.offset);
- if (ret == 0) {
- ret = btrfs_inc_extent_ref(trans, root,
- ins.objectid, ins.offset,
- 0, root->root_key.objectid,
- key->objectid, offset);
- BUG_ON(ret);
- } else {
- /*
- * insert the extent pointer in the extent
- * allocation tree
- */
- ret = btrfs_alloc_logged_file_extent(trans,
- root, root->root_key.objectid,
- key->objectid, offset, &ins);
- BUG_ON(ret);
- }
- btrfs_release_path(path);
- if (btrfs_file_extent_compression(eb, item)) {
- csum_start = ins.objectid;
- csum_end = csum_start + ins.offset;
- } else {
- csum_start = ins.objectid +
- btrfs_file_extent_offset(eb, item);
- csum_end = csum_start +
- btrfs_file_extent_num_bytes(eb, item);
- }
- ret = btrfs_lookup_csums_range(root->log_root,
- csum_start, csum_end - 1,
- &ordered_sums, 0);
- BUG_ON(ret);
- while (!list_empty(&ordered_sums)) {
- struct btrfs_ordered_sum *sums;
- sums = list_entry(ordered_sums.next,
- struct btrfs_ordered_sum,
- list);
- ret = btrfs_csum_file_blocks(trans,
- root->fs_info->csum_root,
- sums);
- BUG_ON(ret);
- list_del(&sums->list);
- kfree(sums);
- }
- } else {
- btrfs_release_path(path);
- }
- } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
- /* inline extents are easy, we just overwrite them */
- ret = overwrite_item(trans, root, path, eb, slot, key);
- BUG_ON(ret);
- }
- inode_set_bytes(inode, saved_nbytes);
- btrfs_update_inode(trans, root, inode);
- out:
- if (inode)
- iput(inode);
- return ret;
- }
- /*
- * when cleaning up conflicts between the directory names in the
- * subvolume, directory names in the log and directory names in the
- * inode back references, we may have to unlink inodes from directories.
- *
- * This is a helper function to do the unlink of a specific directory
- * item
- */
- static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct inode *dir,
- struct btrfs_dir_item *di)
- {
- struct inode *inode;
- char *name;
- int name_len;
- struct extent_buffer *leaf;
- struct btrfs_key location;
- int ret;
- leaf = path->nodes[0];
- btrfs_dir_item_key_to_cpu(leaf, di, &location);
- name_len = btrfs_dir_name_len(leaf, di);
- name = kmalloc(name_len, GFP_NOFS);
- if (!name)
- return -ENOMEM;
- read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
- btrfs_release_path(path);
- inode = read_one_inode(root, location.objectid);
- if (!inode) {
- kfree(name);
- return -EIO;
- }
- ret = link_to_fixup_dir(trans, root, path, location.objectid);
- BUG_ON(ret);
- ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
- BUG_ON(ret);
- kfree(name);
- iput(inode);
- return ret;
- }
- /*
- * helper function to see if a given name and sequence number found
- * in an inode back reference are already in a directory and correctly
- * point to this inode
- */
- static noinline int inode_in_dir(struct btrfs_root *root,
- struct btrfs_path *path,
- u64 dirid, u64 objectid, u64 index,
- const char *name, int name_len)
- {
- struct btrfs_dir_item *di;
- struct btrfs_key location;
- int match = 0;
- di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
- index, name, name_len, 0);
- if (di && !IS_ERR(di)) {
- btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
- if (location.objectid != objectid)
- goto out;
- } else
- goto out;
- btrfs_release_path(path);
- di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
- if (di && !IS_ERR(di)) {
- btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
- if (location.objectid != objectid)
- goto out;
- } else
- goto out;
- match = 1;
- out:
- btrfs_release_path(path);
- return match;
- }
- /*
- * helper function to check a log tree for a named back reference in
- * an inode. This is used to decide if a back reference that is
- * found in the subvolume conflicts with what we find in the log.
- *
- * inode backreferences may have multiple refs in a single item,
- * during replay we process one reference at a time, and we don't
- * want to delete valid links to a file from the subvolume if that
- * link is also in the log.
- */
- static noinline int backref_in_log(struct btrfs_root *log,
- struct btrfs_key *key,
- char *name, int namelen)
- {
- struct btrfs_path *path;
- struct btrfs_inode_ref *ref;
- unsigned long ptr;
- unsigned long ptr_end;
- unsigned long name_ptr;
- int found_name_len;
- int item_size;
- int ret;
- int match = 0;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
- 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]);
- ptr_end = ptr + item_size;
- while (ptr < ptr_end) {
- ref = (struct btrfs_inode_ref *)ptr;
- found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref);
- if (found_name_len == namelen) {
- name_ptr = (unsigned long)(ref + 1);
- ret = memcmp_extent_buffer(path->nodes[0], name,
- name_ptr, namelen);
- if (ret == 0) {
- match = 1;
- goto out;
- }
- }
- ptr = (unsigned long)(ref + 1) + found_name_len;
- }
- out:
- btrfs_free_path(path);
- 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,
- 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 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;
- ret = btrfs_search_slot(NULL, root, 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];
- /* 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)
- goto out_nowrite;
- /* check all the names in this back reference to see
- * if they are in the log. if so, we allow them to stay
- * otherwise they must be unlinked as a conflict
- */
- ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
- ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
- while (ptr < ptr_end) {
- victim_ref = (struct btrfs_inode_ref *)ptr;
- victim_name_len = btrfs_inode_ref_name_len(leaf,
- victim_ref);
- victim_name = kmalloc(victim_name_len, GFP_NOFS);
- BUG_ON(!victim_name);
- read_extent_buffer(leaf, victim_name,
- (unsigned long)(victim_ref + 1),
- victim_name_len);
- if (!backref_in_log(log, 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);
- 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.
- */
- search_done = 1;
- }
- btrfs_release_path(path);
- /* 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);
- if (di && !IS_ERR(di)) {
- ret = drop_one_dir_item(trans, root, path, dir, di);
- BUG_ON(ret);
- }
- btrfs_release_path(path);
- /* look for a conflicing name */
- di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir),
- name, namelen, 0);
- if (di && !IS_ERR(di)) {
- ret = drop_one_dir_item(trans, root, path, dir, di);
- BUG_ON(ret);
- }
- 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);
- btrfs_update_inode(trans, root, inode);
- out:
- ref_ptr = (unsigned long)(ref + 1) + namelen;
- kfree(name);
- if (ref_ptr < ref_end)
- goto again;
- /* finally write the back reference in the inode */
- ret = overwrite_item(trans, root, path, eb, slot, key);
- BUG_ON(ret);
- out_nowrite:
- btrfs_release_path(path);
- iput(dir);
- iput(inode);
- return 0;
- }
- static int insert_orphan_item(struct btrfs_trans_handle *trans,
- struct btrfs_root *root, u64 offset)
- {
- int ret;
- ret = btrfs_find_orphan_item(root, offset);
- if (ret > 0)
- ret = btrfs_insert_orphan_item(trans, root, offset);
- return ret;
- }
- /*
- * 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;
- struct btrfs_key key;
- u64 nlink = 0;
- unsigned long ptr;
- unsigned long ptr_end;
- int name_len;
- u64 ino = btrfs_ino(inode);
- key.objectid = ino;
- 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)
- break;
- if (ret > 0) {
- if (path->slots[0] == 0)
- break;
- path->slots[0]--;
- }
- btrfs_item_key_to_cpu(path->nodes[0], &key,
- path->slots[0]);
- if (key.objectid != ino ||
- key.type != BTRFS_INODE_REF_KEY)
- break;
- ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
- ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
- path->slots[0]);
- while (ptr < ptr_end) {
- struct btrfs_inode_ref *ref;
- ref = (struct btrfs_inode_ref *)ptr;
- name_len = btrfs_inode_ref_name_len(path->nodes[0],
- ref);
- ptr = (unsigned long)(ref + 1) + name_len;
- nlink++;
- }
- if (key.offset == 0)
- break;
- key.offset--;
- btrfs_release_path(path);
- }
- btrfs_release_path(path);
- if (nlink != inode->i_nlink) {
- inode->i_nlink = nlink;
- btrfs_update_inode(trans, root, inode);
- }
- BTRFS_I(inode)->index_cnt = (u64)-1;
- if (inode->i_nlink == 0) {
- if (S_ISDIR(inode->i_mode)) {
- ret = replay_dir_deletes(trans, root, NULL, path,
- ino, 1);
- BUG_ON(ret);
- }
- ret = insert_orphan_item(trans, root, ino);
- BUG_ON(ret);
- }
- btrfs_free_path(path);
- return 0;
- }
- static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path)
- {
- int ret;
- struct btrfs_key key;
- struct inode *inode;
- key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
- key.type = BTRFS_ORPHAN_ITEM_KEY;
- key.offset = (u64)-1;
- while (1) {
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret < 0)
- break;
- if (ret == 1) {
- if (path->slots[0] == 0)
- break;
- path->slots[0]--;
- }
- btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
- if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
- key.type != BTRFS_ORPHAN_ITEM_KEY)
- break;
- ret = btrfs_del_item(trans, root, path);
- if (ret)
- goto out;
- btrfs_release_path(path);
- inode = read_one_inode(root, key.offset);
- if (!inode)
- return -EIO;
- ret = fixup_inode_link_count(trans, root, inode);
- BUG_ON(ret);
- iput(inode);
- /*
- * fixup on a directory may create new entries,
- * make sure we always look for the highset possible
- * offset
- */
- key.offset = (u64)-1;
- }
- ret = 0;
- out:
- btrfs_release_path(path);
- return ret;
- }
- /*
- * record a given inode in the fixup dir so we can check its link
- * count when replay is done. The link count is incremented here
- * so the inode won't go away until we check it
- */
- static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 objectid)
- {
- struct btrfs_key key;
- int ret = 0;
- struct inode *inode;
- inode = read_one_inode(root, objectid);
- if (!inode)
- return -EIO;
- key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
- btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
- key.offset = objectid;
- ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
- btrfs_release_path(path);
- if (ret == 0) {
- btrfs_inc_nlink(inode);
- btrfs_update_inode(trans, root, inode);
- } else if (ret == -EEXIST) {
- ret = 0;
- } else {
- BUG();
- }
- iput(inode);
- return ret;
- }
- /*
- * when replaying the log for a directory, we only insert names
- * for inodes that actually exist. This means an fsync on a directory
- * does not implicitly fsync all the new files in it
- */
- static noinline int insert_one_name(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 dirid, u64 index,
- char *name, int name_len, u8 type,
- struct btrfs_key *location)
- {
- struct inode *inode;
- struct inode *dir;
- int ret;
- inode = read_one_inode(root, location->objectid);
- if (!inode)
- return -ENOENT;
- dir = read_one_inode(root, dirid);
- if (!dir) {
- iput(inode);
- return -EIO;
- }
- ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);
- /* FIXME, put inode into FIXUP list */
- iput(inode);
- iput(dir);
- return ret;
- }
- /*
- * take a single entry in a log directory item and replay it into
- * the subvolume.
- *
- * if a conflicting item exists in the subdirectory already,
- * the inode it points to is unlinked and put into the link count
- * fix up tree.
- *
- * If a name from the log points to a file or directory that does
- * not exist in the FS, it is skipped. fsyncs on directories
- * do not force down inodes inside that directory, just changes to the
- * names or unlinks in a directory.
- */
- static noinline int replay_one_name(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct extent_buffer *eb,
- struct btrfs_dir_item *di,
- struct btrfs_key *key)
- {
- char *name;
- int name_len;
- struct btrfs_dir_item *dst_di;
- struct btrfs_key found_key;
- struct btrfs_key log_key;
- struct inode *dir;
- u8 log_type;
- int exists;
- int ret;
- dir = read_one_inode(root, key->objectid);
- if (!dir)
- return -EIO;
- name_len = btrfs_dir_name_len(eb, di);
- name = kmalloc(name_len, GFP_NOFS);
- if (!name)
- return -ENOMEM;
- log_type = btrfs_dir_type(eb, di);
- read_extent_buffer(eb, name, (unsigned long)(di + 1),
- name_len);
- btrfs_dir_item_key_to_cpu(eb, di, &log_key);
- exists = btrfs_lookup_inode(trans, root, path, &log_key, 0);
- if (exists == 0)
- exists = 1;
- else
- exists = 0;
- btrfs_release_path(path);
- if (key->type == BTRFS_DIR_ITEM_KEY) {
- dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
- name, name_len, 1);
- } else if (key->type == BTRFS_DIR_INDEX_KEY) {
- dst_di = btrfs_lookup_dir_index_item(trans, root, path,
- key->objectid,
- key->offset, name,
- name_len, 1);
- } else {
- BUG();
- }
- if (IS_ERR_OR_NULL(dst_di)) {
- /* we need a sequence number to insert, so we only
- * do inserts for the BTRFS_DIR_INDEX_KEY types
- */
- if (key->type != BTRFS_DIR_INDEX_KEY)
- goto out;
- goto insert;
- }
- btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
- /* the existing item matches the logged item */
- if (found_key.objectid == log_key.objectid &&
- found_key.type == log_key.type &&
- found_key.offset == log_key.offset &&
- btrfs_dir_type(path->nodes[0], dst_di) == log_type) {
- goto out;
- }
- /*
- * don't drop the conflicting directory entry if the inode
- * for the new entry doesn't exist
- */
- if (!exists)
- goto out;
- ret = drop_one_dir_item(trans, root, path, dir, dst_di);
- BUG_ON(ret);
- if (key->type == BTRFS_DIR_INDEX_KEY)
- goto insert;
- out:
- btrfs_release_path(path);
- kfree(name);
- iput(dir);
- return 0;
- insert:
- btrfs_release_path(path);
- ret = insert_one_name(trans, root, path, key->objectid, key->offset,
- name, name_len, log_type, &log_key);
- BUG_ON(ret && ret != -ENOENT);
- goto out;
- }
- /*
- * find all the names in a directory item and reconcile them into
- * the subvolume. Only BTRFS_DIR_ITEM_KEY types will have more than
- * one name in a directory item, but the same code gets used for
- * both directory index types
- */
- static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct extent_buffer *eb, int slot,
- struct btrfs_key *key)
- {
- int ret;
- u32 item_size = btrfs_item_size_nr(eb, slot);
- struct btrfs_dir_item *di;
- int name_len;
- unsigned long ptr;
- unsigned long ptr_end;
- ptr = btrfs_item_ptr_offset(eb, slot);
- ptr_end = ptr + item_size;
- while (ptr < ptr_end) {
- di = (struct btrfs_dir_item *)ptr;
- if (verify_dir_item(root, eb, di))
- return -EIO;
- name_len = btrfs_dir_name_len(eb, di);
- ret = replay_one_name(trans, root, path, eb, di, key);
- BUG_ON(ret);
- ptr = (unsigned long)(di + 1);
- ptr += name_len;
- }
- return 0;
- }
- /*
- * directory replay has two parts. There are the standard directory
- * items in the log copied from the subvolume, and range items
- * created in the log while the subvolume was logged.
- *
- * The range items tell us which parts of the key space the log
- * is authoritative for. During replay, if a key in the subvolume
- * directory is in a logged range item, but not actually in the log
- * that means it was deleted from the directory before the fsync
- * and should be removed.
- */
- static noinline int find_dir_range(struct btrfs_root *root,
- struct btrfs_path *path,
- u64 dirid, int key_type,
- u64 *start_ret, u64 *end_ret)
- {
- struct btrfs_key key;
- u64 found_end;
- struct btrfs_dir_log_item *item;
- int ret;
- int nritems;
- if (*start_ret == (u64)-1)
- return 1;
- key.objectid = dirid;
- key.type = key_type;
- key.offset = *start_ret;
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
- if (ret < 0)
- goto out;
- if (ret > 0) {
- if (path->slots[0] == 0)
- goto out;
- path->slots[0]--;
- }
- if (ret != 0)
- btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
- if (key.type != key_type || key.objectid != dirid) {
- ret = 1;
- goto next;
- }
- item = btrfs_item_ptr(path->nodes[0], path->slots[0],
- struct btrfs_dir_log_item);
- found_end = btrfs_dir_log_end(path->nodes[0], item);
- if (*start_ret >= key.offset && *start_ret <= found_end) {
- ret = 0;
- *start_ret = key.offset;
- *end_ret = found_end;
- goto out;
- }
- ret = 1;
- next:
- /* check the next slot in the tree to see if it is a valid item */
- nritems = btrfs_header_nritems(path->nodes[0]);
- if (path->slots[0] >= nritems) {
- ret = btrfs_next_leaf(root, path);
- if (ret)
- goto out;
- } else {
- path->slots[0]++;
- }
- btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
- if (key.type != key_type || key.objectid != dirid) {
- ret = 1;
- goto out;
- }
- item = btrfs_item_ptr(path->nodes[0], path->slots[0],
- struct btrfs_dir_log_item);
- found_end = btrfs_dir_log_end(path->nodes[0], item);
- *start_ret = key.offset;
- *end_ret = found_end;
- ret = 0;
- out:
- btrfs_release_path(path);
- return ret;
- }
- /*
- * this looks for a given directory item in the log. If the directory
- * item is not in the log, the item is removed and the inode it points
- * to is unlinked
- */
- static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_root *log,
- struct btrfs_path *path,
- struct btrfs_path *log_path,
- struct inode *dir,
- struct btrfs_key *dir_key)
- {
- int ret;
- struct extent_buffer *eb;
- int slot;
- u32 item_size;
- struct btrfs_dir_item *di;
- struct btrfs_dir_item *log_di;
- int name_len;
- unsigned long ptr;
- unsigned long ptr_end;
- char *name;
- struct inode *inode;
- struct btrfs_key location;
- again:
- eb = path->nodes[0];
- slot = path->slots[0];
- item_size = btrfs_item_size_nr(eb, slot);
- ptr = btrfs_item_ptr_offset(eb, slot);
- ptr_end = ptr + item_size;
- while (ptr < ptr_end) {
- di = (struct btrfs_dir_item *)ptr;
- if (verify_dir_item(root, eb, di)) {
- ret = -EIO;
- goto out;
- }
- name_len = btrfs_dir_name_len(eb, di);
- name = kmalloc(name_len, GFP_NOFS);
- if (!name) {
- ret = -ENOMEM;
- goto out;
- }
- read_extent_buffer(eb, name, (unsigned long)(di + 1),
- name_len);
- log_di = NULL;
- if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) {
- log_di = btrfs_lookup_dir_item(trans, log, log_path,
- dir_key->objectid,
- name, name_len, 0);
- } else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) {
- log_di = btrfs_lookup_dir_index_item(trans, log,
- log_path,
- dir_key->objectid,
- dir_key->offset,
- name, name_len, 0);
- }
- if (IS_ERR_OR_NULL(log_di)) {
- btrfs_dir_item_key_to_cpu(eb, di, &location);
- btrfs_release_path(path);
- btrfs_release_path(log_path);
- inode = read_one_inode(root, location.objectid);
- if (!inode) {
- kfree(name);
- return -EIO;
- }
- ret = link_to_fixup_dir(trans, root,
- path, location.objectid);
- BUG_ON(ret);
- btrfs_inc_nlink(inode);
- ret = btrfs_unlink_inode(trans, root, dir, inode,
- name, name_len);
- BUG_ON(ret);
- kfree(name);
- iput(inode);
- /* there might still be more names under this key
- * check and repeat if required
- */
- ret = btrfs_search_slot(NULL, root, dir_key, path,
- 0, 0);
- if (ret == 0)
- goto again;
- ret = 0;
- goto out;
- }
- btrfs_release_path(log_path);
- kfree(name);
- ptr = (unsigned long)(di + 1);
- ptr += name_len;
- }
- ret = 0;
- out:
- btrfs_release_path(path);
- btrfs_release_path(log_path);
- return ret;
- }
- /*
- * deletion replay happens before we copy any new directory items
- * out of the log or out of backreferences from inodes. It
- * scans the log to find ranges of keys that log is authoritative for,
- * and then scans the directory to find items in those ranges that are
- * not present in the log.
- *
- * Anything we don't find in the log is unlinked and removed from the
- * directory.
- */
- static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_root *log,
- struct btrfs_path *path,
- u64 dirid, int del_all)
- {
- u64 range_start;
- u64 range_end;
- int key_type = BTRFS_DIR_LOG_ITEM_KEY;
- int ret = 0;
- struct btrfs_key dir_key;
- struct btrfs_key found_key;
- struct btrfs_path *log_path;
- struct inode *dir;
- dir_key.objectid = dirid;
- dir_key.type = BTRFS_DIR_ITEM_KEY;
- log_path = btrfs_alloc_path();
- if (!log_path)
- return -ENOMEM;
- dir = read_one_inode(root, dirid);
- /* it isn't an error if the inode isn't there, that can happen
- * because we replay the deletes before we copy in the inode item
- * from the log
- */
- if (!dir) {
- btrfs_free_path(log_path);
- return 0;
- }
- again:
- range_start = 0;
- range_end = 0;
- while (1) {
- if (del_all)
- range_end = (u64)-1;
- else {
- ret = find_dir_range(log, path, dirid, key_type,
- &range_start, &range_end);
- if (ret != 0)
- break;
- }
- dir_key.offset = range_start;
- while (1) {
- int nritems;
- ret = btrfs_search_slot(NULL, root, &dir_key, path,
- 0, 0);
- if (ret < 0)
- goto out;
- nritems = btrfs_header_nritems(path->nodes[0]);
- if (path->slots[0] >= nritems) {
- ret = btrfs_next_leaf(root, path);
- if (ret)
- break;
- }
- btrfs_item_key_to_cpu(path->nodes[0], &found_key,
- path->slots[0]);
- if (found_key.objectid != dirid ||
- found_key.type != dir_key.type)
- goto next_type;
- if (found_key.offset > range_end)
- break;
- ret = check_item_in_log(trans, root, log, path,
- log_path, dir,
- &found_key);
- BUG_ON(ret);
- if (found_key.offset == (u64)-1)
- break;
- dir_key.offset = found_key.offset + 1;
- }
- btrfs_release_path(path);
- if (range_end == (u64)-1)
- break;
- range_start = range_end + 1;
- }
- next_type:
- ret = 0;
- if (key_type == BTRFS_DIR_LOG_ITEM_KEY) {
- key_type = BTRFS_DIR_LOG_INDEX_KEY;
- dir_key.type = BTRFS_DIR_INDEX_KEY;
- btrfs_release_path(path);
- goto again;
- }
- out:
- btrfs_release_path(path);
- btrfs_free_path(log_path);
- iput(dir);
- return ret;
- }
- /*
- * the process_func used to replay items from the log tree. This
- * gets called in two different stages. The first stage just looks
- * for inodes and makes sure they are all copied into the subvolume.
- *
- * The second stage copies all the other item types from the log into
- * the subvolume. The two stage approach is slower, but gets rid of
- * lots of complexity around inodes referencing other inodes that exist
- * only in the log (references come from either directory items or inode
- * back refs).
- */
- static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
- struct walk_control *wc, u64 gen)
- {
- int nritems;
- struct btrfs_path *path;
- struct btrfs_root *root = wc->replay_dest;
- struct btrfs_key key;
- int level;
- int i;
- int ret;
- btrfs_read_buffer(eb, gen);
- level = btrfs_header_level(eb);
- if (level != 0)
- return 0;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- nritems = btrfs_header_nritems(eb);
- for (i = 0; i < nritems; i++) {
- btrfs_item_key_to_cpu(eb, &key, i);
- /* inode keys are done during the first stage */
- if (key.type == BTRFS_INODE_ITEM_KEY &&
- wc->stage == LOG_WALK_REPLAY_INODES) {
- struct btrfs_inode_item *inode_item;
- u32 mode;
- inode_item = btrfs_item_ptr(eb, i,
- struct btrfs_inode_item);
- mode = btrfs_inode_mode(eb, inode_item);
- if (S_ISDIR(mode)) {
- ret = replay_dir_deletes(wc->trans,
- root, log, path, key.objectid, 0);
- BUG_ON(ret);
- }
- ret = overwrite_item(wc->trans, root, path,
- eb, i, &key);
- BUG_ON(ret);
- /* for regular files, make sure corresponding
- * orhpan item exist. extents past the new EOF
- * will be truncated later by orphan cleanup.
- */
- if (S_ISREG(mode)) {
- ret = insert_orphan_item(wc->trans, root,
- key.objectid);
- BUG_ON(ret);
- }
- ret = link_to_fixup_dir(wc->trans, root,
- path, key.objectid);
- BUG_ON(ret);
- }
- if (wc->stage < LOG_WALK_REPLAY_ALL)
- continue;
- /* these keys are simply copied */
- if (key.type == BTRFS_XATTR_ITEM_KEY) {
- ret = overwrite_item(wc->trans, root, path,
- eb, i, &key);
- BUG_ON(ret);
- } else if (key.type == BTRFS_INODE_REF_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);
- BUG_ON(ret);
- } else if (key.type == BTRFS_DIR_ITEM_KEY ||
- key.type == BTRFS_DIR_INDEX_KEY) {
- ret = replay_one_dir_item(wc->trans, root, path,
- eb, i, &key);
- BUG_ON(ret);
- }
- }
- btrfs_free_path(path);
- return 0;
- }
- static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path, int *level,
- struct walk_control *wc)
- {
- u64 root_owner;
- u64 bytenr;
- u64 ptr_gen;
- struct extent_buffer *next;
- struct extent_buffer *cur;
- struct extent_buffer *parent;
- u32 blocksize;
- int ret = 0;
- WARN_ON(*level < 0);
- WARN_ON(*level >= BTRFS_MAX_LEVEL);
- while (*level > 0) {
- WARN_ON(*level < 0);
- WARN_ON(*level >= BTRFS_MAX_LEVEL);
- cur = path->nodes[*level];
- if (btrfs_header_level(cur) != *level)
- WARN_ON(1);
- if (path->slots[*level] >=
- btrfs_header_nritems(cur))
- break;
- bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
- ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
- blocksize = btrfs_level_size(root, *level - 1);
- parent = path->nodes[*level];
- root_owner = btrfs_header_owner(parent);
- next = btrfs_find_create_tree_block(root, bytenr, blocksize);
- if (!next)
- return -ENOMEM;
- if (*level == 1) {
- ret = wc->process_func(root, next, wc, ptr_gen);
- if (ret)
- return ret;
- path->slots[*level]++;
- if (wc->free) {
- btrfs_read_buffer(next, ptr_gen);
- btrfs_tree_lock(next);
- btrfs_set_lock_blocking(next);
- clean_tree_block(trans, root, next);
- btrfs_wait_tree_block_writeback(next);
- btrfs_tree_unlock(next);
- WARN_ON(root_owner !=
- BTRFS_TREE_LOG_OBJECTID);
- ret = btrfs_free_reserved_extent(root,
- bytenr, blocksize);
- BUG_ON(ret);
- }
- free_extent_buffer(next);
- continue;
- }
- btrfs_read_buffer(next, ptr_gen);
- WARN_ON(*level <= 0);
- if (path->nodes[*level-1])
- free_extent_buffer(path->nodes[*level-1]);
- path->nodes[*level-1] = next;
- *level = btrfs_header_level(next);
- path->slots[*level] = 0;
- cond_resched();
- }
- WARN_ON(*level < 0);
- WARN_ON(*level >= BTRFS_MAX_LEVEL);
- path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
- cond_resched();
- return 0;
- }
- static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path, int *level,
- struct walk_control *wc)
- {
- u64 root_owner;
- int i;
- int slot;
- int ret;
- for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
- slot = path->slots[i];
- if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
- path->slots[i]++;
- *level = i;
- WARN_ON(*level == 0);
- return 0;
- } else {
- struct extent_buffer *parent;
- if (path->nodes[*level] == root->node)
- parent = path->nodes[*level];
- else
- parent = path->nodes[*level + 1];
- root_owner = btrfs_header_owner(parent);
- ret = wc->process_func(root, path->nodes[*level], wc,
- btrfs_header_generation(path->nodes[*level]));
- if (ret)
- return ret;
- if (wc->free) {
- struct extent_buffer *next;
- next = path->nodes[*level];
- btrfs_tree_lock(next);
- btrfs_set_lock_blocking(next);
- clean_tree_block(trans, root, next);
- btrfs_wait_tree_block_writeback(next);
- btrfs_tree_unlock(next);
- WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
- ret = btrfs_free_reserved_extent(root,
- path->nodes[*level]->start,
- path->nodes[*level]->len);
- BUG_ON(ret);
- }
- free_extent_buffer(path->nodes[*level]);
- path->nodes[*level] = NULL;
- *level = i + 1;
- }
- }
- return 1;
- }
- /*
- * drop the reference count on the tree rooted at 'snap'. This traverses
- * the tree freeing any blocks that have a ref count of zero after being
- * decremented.
- */
- static int walk_log_tree(struct btrfs_trans_handle *trans,
- struct btrfs_root *log, struct walk_control *wc)
- {
- int ret = 0;
- int wret;
- int level;
- struct btrfs_path *path;
- int i;
- int orig_level;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- level = btrfs_header_level(log->node);
- orig_level = level;
- path->nodes[level] = log->node;
- extent_buffer_get(log->node);
- path->slots[level] = 0;
- while (1) {
- wret = walk_down_log_tree(trans, log, path, &level, wc);
- if (wret > 0)
- break;
- if (wret < 0)
- ret = wret;
- wret = walk_up_log_tree(trans, log, path, &level, wc);
- if (wret > 0)
- break;
- if (wret < 0)
- ret = wret;
- }
- /* was the root node processed? if not, catch it here */
- if (path->nodes[orig_level]) {
- wc->process_fun