/fs/btrfs/extent-tree.c
C | 1831 lines | 1426 code | 184 blank | 221 comment | 284 complexity | 900047df3aed2c5100bcfe2b68762246 MD5 | raw file
- /*
- * Copyright (C) 2007 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/pagemap.h>
- #include <linux/writeback.h>
- #include <linux/blkdev.h>
- #include <linux/sort.h>
- #include <linux/rcupdate.h>
- #include <linux/kthread.h>
- #include <linux/slab.h>
- #include "compat.h"
- #include "hash.h"
- #include "ctree.h"
- #include "disk-io.h"
- #include "print-tree.h"
- #include "transaction.h"
- #include "volumes.h"
- #include "locking.h"
- #include "free-space-cache.h"
- /* control flags for do_chunk_alloc's force field
- * CHUNK_ALLOC_NO_FORCE means to only allocate a chunk
- * if we really need one.
- *
- * CHUNK_ALLOC_FORCE means it must try to allocate one
- *
- * CHUNK_ALLOC_LIMITED means to only try and allocate one
- * if we have very few chunks already allocated. This is
- * used as part of the clustering code to help make sure
- * we have a good pool of storage to cluster in, without
- * filling the FS with empty chunks
- *
- */
- enum {
- CHUNK_ALLOC_NO_FORCE = 0,
- CHUNK_ALLOC_FORCE = 1,
- CHUNK_ALLOC_LIMITED = 2,
- };
- static int update_block_group(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 bytenr, u64 num_bytes, int alloc);
- static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 bytenr, u64 num_bytes, u64 parent,
- u64 root_objectid, u64 owner_objectid,
- u64 owner_offset, int refs_to_drop,
- struct btrfs_delayed_extent_op *extra_op);
- static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
- struct extent_buffer *leaf,
- struct btrfs_extent_item *ei);
- static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 parent, u64 root_objectid,
- u64 flags, u64 owner, u64 offset,
- struct btrfs_key *ins, int ref_mod);
- static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 parent, u64 root_objectid,
- u64 flags, struct btrfs_disk_key *key,
- int level, struct btrfs_key *ins);
- static int do_chunk_alloc(struct btrfs_trans_handle *trans,
- struct btrfs_root *extent_root, u64 alloc_bytes,
- u64 flags, int force);
- static int find_next_key(struct btrfs_path *path, int level,
- struct btrfs_key *key);
- static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
- int dump_block_groups);
- static noinline int
- block_group_cache_done(struct btrfs_block_group_cache *cache)
- {
- smp_mb();
- return cache->cached == BTRFS_CACHE_FINISHED;
- }
- static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
- {
- return (cache->flags & bits) == bits;
- }
- static void btrfs_get_block_group(struct btrfs_block_group_cache *cache)
- {
- atomic_inc(&cache->count);
- }
- void btrfs_put_block_group(struct btrfs_block_group_cache *cache)
- {
- if (atomic_dec_and_test(&cache->count)) {
- WARN_ON(cache->pinned > 0);
- WARN_ON(cache->reserved > 0);
- WARN_ON(cache->reserved_pinned > 0);
- kfree(cache->free_space_ctl);
- kfree(cache);
- }
- }
- /*
- * this adds the block group to the fs_info rb tree for the block group
- * cache
- */
- static int btrfs_add_block_group_cache(struct btrfs_fs_info *info,
- struct btrfs_block_group_cache *block_group)
- {
- struct rb_node **p;
- struct rb_node *parent = NULL;
- struct btrfs_block_group_cache *cache;
- spin_lock(&info->block_group_cache_lock);
- p = &info->block_group_cache_tree.rb_node;
- while (*p) {
- parent = *p;
- cache = rb_entry(parent, struct btrfs_block_group_cache,
- cache_node);
- if (block_group->key.objectid < cache->key.objectid) {
- p = &(*p)->rb_left;
- } else if (block_group->key.objectid > cache->key.objectid) {
- p = &(*p)->rb_right;
- } else {
- spin_unlock(&info->block_group_cache_lock);
- return -EEXIST;
- }
- }
- rb_link_node(&block_group->cache_node, parent, p);
- rb_insert_color(&block_group->cache_node,
- &info->block_group_cache_tree);
- spin_unlock(&info->block_group_cache_lock);
- return 0;
- }
- /*
- * This will return the block group at or after bytenr if contains is 0, else
- * it will return the block group that contains the bytenr
- */
- static struct btrfs_block_group_cache *
- block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr,
- int contains)
- {
- struct btrfs_block_group_cache *cache, *ret = NULL;
- struct rb_node *n;
- u64 end, start;
- spin_lock(&info->block_group_cache_lock);
- n = info->block_group_cache_tree.rb_node;
- while (n) {
- cache = rb_entry(n, struct btrfs_block_group_cache,
- cache_node);
- end = cache->key.objectid + cache->key.offset - 1;
- start = cache->key.objectid;
- if (bytenr < start) {
- if (!contains && (!ret || start < ret->key.objectid))
- ret = cache;
- n = n->rb_left;
- } else if (bytenr > start) {
- if (contains && bytenr <= end) {
- ret = cache;
- break;
- }
- n = n->rb_right;
- } else {
- ret = cache;
- break;
- }
- }
- if (ret)
- btrfs_get_block_group(ret);
- spin_unlock(&info->block_group_cache_lock);
- return ret;
- }
- static int add_excluded_extent(struct btrfs_root *root,
- u64 start, u64 num_bytes)
- {
- u64 end = start + num_bytes - 1;
- set_extent_bits(&root->fs_info->freed_extents[0],
- start, end, EXTENT_UPTODATE, GFP_NOFS);
- set_extent_bits(&root->fs_info->freed_extents[1],
- start, end, EXTENT_UPTODATE, GFP_NOFS);
- return 0;
- }
- static void free_excluded_extents(struct btrfs_root *root,
- struct btrfs_block_group_cache *cache)
- {
- u64 start, end;
- start = cache->key.objectid;
- end = start + cache->key.offset - 1;
- clear_extent_bits(&root->fs_info->freed_extents[0],
- start, end, EXTENT_UPTODATE, GFP_NOFS);
- clear_extent_bits(&root->fs_info->freed_extents[1],
- start, end, EXTENT_UPTODATE, GFP_NOFS);
- }
- static int exclude_super_stripes(struct btrfs_root *root,
- struct btrfs_block_group_cache *cache)
- {
- u64 bytenr;
- u64 *logical;
- int stripe_len;
- int i, nr, ret;
- if (cache->key.objectid < BTRFS_SUPER_INFO_OFFSET) {
- stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->key.objectid;
- cache->bytes_super += stripe_len;
- ret = add_excluded_extent(root, cache->key.objectid,
- stripe_len);
- BUG_ON(ret);
- }
- for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
- bytenr = btrfs_sb_offset(i);
- ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
- cache->key.objectid, bytenr,
- 0, &logical, &nr, &stripe_len);
- BUG_ON(ret);
- while (nr--) {
- cache->bytes_super += stripe_len;
- ret = add_excluded_extent(root, logical[nr],
- stripe_len);
- BUG_ON(ret);
- }
- kfree(logical);
- }
- return 0;
- }
- static struct btrfs_caching_control *
- get_caching_control(struct btrfs_block_group_cache *cache)
- {
- struct btrfs_caching_control *ctl;
- spin_lock(&cache->lock);
- if (cache->cached != BTRFS_CACHE_STARTED) {
- spin_unlock(&cache->lock);
- return NULL;
- }
- /* We're loading it the fast way, so we don't have a caching_ctl. */
- if (!cache->caching_ctl) {
- spin_unlock(&cache->lock);
- return NULL;
- }
- ctl = cache->caching_ctl;
- atomic_inc(&ctl->count);
- spin_unlock(&cache->lock);
- return ctl;
- }
- static void put_caching_control(struct btrfs_caching_control *ctl)
- {
- if (atomic_dec_and_test(&ctl->count))
- kfree(ctl);
- }
- /*
- * this is only called by cache_block_group, since we could have freed extents
- * we need to check the pinned_extents for any extents that can't be used yet
- * since their free space will be released as soon as the transaction commits.
- */
- static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
- struct btrfs_fs_info *info, u64 start, u64 end)
- {
- u64 extent_start, extent_end, size, total_added = 0;
- int ret;
- while (start < end) {
- ret = find_first_extent_bit(info->pinned_extents, start,
- &extent_start, &extent_end,
- EXTENT_DIRTY | EXTENT_UPTODATE);
- if (ret)
- break;
- if (extent_start <= start) {
- start = extent_end + 1;
- } else if (extent_start > start && extent_start < end) {
- size = extent_start - start;
- total_added += size;
- ret = btrfs_add_free_space(block_group, start,
- size);
- BUG_ON(ret);
- start = extent_end + 1;
- } else {
- break;
- }
- }
- if (start < end) {
- size = end - start;
- total_added += size;
- ret = btrfs_add_free_space(block_group, start, size);
- BUG_ON(ret);
- }
- return total_added;
- }
- static noinline void caching_thread(struct btrfs_work *work)
- {
- struct btrfs_block_group_cache *block_group;
- struct btrfs_fs_info *fs_info;
- struct btrfs_caching_control *caching_ctl;
- struct btrfs_root *extent_root;
- struct btrfs_path *path;
- struct extent_buffer *leaf;
- struct btrfs_key key;
- u64 total_found = 0;
- u64 last = 0;
- u32 nritems;
- int ret = 0;
- caching_ctl = container_of(work, struct btrfs_caching_control, work);
- block_group = caching_ctl->block_group;
- fs_info = block_group->fs_info;
- extent_root = fs_info->extent_root;
- path = btrfs_alloc_path();
- if (!path)
- goto out;
- last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET);
- /*
- * We don't want to deadlock with somebody trying to allocate a new
- * extent for the extent root while also trying to search the extent
- * root to add free space. So we skip locking and search the commit
- * root, since its read-only
- */
- path->skip_locking = 1;
- path->search_commit_root = 1;
- path->reada = 1;
- key.objectid = last;
- key.offset = 0;
- key.type = BTRFS_EXTENT_ITEM_KEY;
- again:
- mutex_lock(&caching_ctl->mutex);
- /* need to make sure the commit_root doesn't disappear */
- down_read(&fs_info->extent_commit_sem);
- ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
- if (ret < 0)
- goto err;
- leaf = path->nodes[0];
- nritems = btrfs_header_nritems(leaf);
- while (1) {
- if (btrfs_fs_closing(fs_info) > 1) {
- last = (u64)-1;
- break;
- }
- if (path->slots[0] < nritems) {
- btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
- } else {
- ret = find_next_key(path, 0, &key);
- if (ret)
- break;
- if (need_resched() ||
- btrfs_next_leaf(extent_root, path)) {
- caching_ctl->progress = last;
- btrfs_release_path(path);
- up_read(&fs_info->extent_commit_sem);
- mutex_unlock(&caching_ctl->mutex);
- cond_resched();
- goto again;
- }
- leaf = path->nodes[0];
- nritems = btrfs_header_nritems(leaf);
- continue;
- }
- if (key.objectid < block_group->key.objectid) {
- path->slots[0]++;
- continue;
- }
- if (key.objectid >= block_group->key.objectid +
- block_group->key.offset)
- break;
- if (key.type == BTRFS_EXTENT_ITEM_KEY) {
- total_found += add_new_free_space(block_group,
- fs_info, last,
- key.objectid);
- last = key.objectid + key.offset;
- if (total_found > (1024 * 1024 * 2)) {
- total_found = 0;
- wake_up(&caching_ctl->wait);
- }
- }
- path->slots[0]++;
- }
- ret = 0;
- total_found += add_new_free_space(block_group, fs_info, last,
- block_group->key.objectid +
- block_group->key.offset);
- caching_ctl->progress = (u64)-1;
- spin_lock(&block_group->lock);
- block_group->caching_ctl = NULL;
- block_group->cached = BTRFS_CACHE_FINISHED;
- spin_unlock(&block_group->lock);
- err:
- btrfs_free_path(path);
- up_read(&fs_info->extent_commit_sem);
- free_excluded_extents(extent_root, block_group);
- mutex_unlock(&caching_ctl->mutex);
- out:
- wake_up(&caching_ctl->wait);
- put_caching_control(caching_ctl);
- btrfs_put_block_group(block_group);
- }
- static int cache_block_group(struct btrfs_block_group_cache *cache,
- struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- int load_cache_only)
- {
- struct btrfs_fs_info *fs_info = cache->fs_info;
- struct btrfs_caching_control *caching_ctl;
- int ret = 0;
- smp_mb();
- if (cache->cached != BTRFS_CACHE_NO)
- return 0;
- /*
- * We can't do the read from on-disk cache during a commit since we need
- * to have the normal tree locking. Also if we are currently trying to
- * allocate blocks for the tree root we can't do the fast caching since
- * we likely hold important locks.
- */
- if (trans && (!trans->transaction->in_commit) &&
- (root && root != root->fs_info->tree_root)) {
- spin_lock(&cache->lock);
- if (cache->cached != BTRFS_CACHE_NO) {
- spin_unlock(&cache->lock);
- return 0;
- }
- cache->cached = BTRFS_CACHE_STARTED;
- spin_unlock(&cache->lock);
- ret = load_free_space_cache(fs_info, cache);
- spin_lock(&cache->lock);
- if (ret == 1) {
- cache->cached = BTRFS_CACHE_FINISHED;
- cache->last_byte_to_unpin = (u64)-1;
- } else {
- cache->cached = BTRFS_CACHE_NO;
- }
- spin_unlock(&cache->lock);
- if (ret == 1) {
- free_excluded_extents(fs_info->extent_root, cache);
- return 0;
- }
- }
- if (load_cache_only)
- return 0;
- caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
- BUG_ON(!caching_ctl);
- INIT_LIST_HEAD(&caching_ctl->list);
- mutex_init(&caching_ctl->mutex);
- init_waitqueue_head(&caching_ctl->wait);
- caching_ctl->block_group = cache;
- caching_ctl->progress = cache->key.objectid;
- /* one for caching kthread, one for caching block group list */
- atomic_set(&caching_ctl->count, 2);
- caching_ctl->work.func = caching_thread;
- spin_lock(&cache->lock);
- if (cache->cached != BTRFS_CACHE_NO) {
- spin_unlock(&cache->lock);
- kfree(caching_ctl);
- return 0;
- }
- cache->caching_ctl = caching_ctl;
- cache->cached = BTRFS_CACHE_STARTED;
- spin_unlock(&cache->lock);
- down_write(&fs_info->extent_commit_sem);
- list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
- up_write(&fs_info->extent_commit_sem);
- btrfs_get_block_group(cache);
- btrfs_queue_worker(&fs_info->caching_workers, &caching_ctl->work);
- return ret;
- }
- /*
- * return the block group that starts at or after bytenr
- */
- static struct btrfs_block_group_cache *
- btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
- {
- struct btrfs_block_group_cache *cache;
- cache = block_group_cache_tree_search(info, bytenr, 0);
- return cache;
- }
- /*
- * return the block group that contains the given bytenr
- */
- struct btrfs_block_group_cache *btrfs_lookup_block_group(
- struct btrfs_fs_info *info,
- u64 bytenr)
- {
- struct btrfs_block_group_cache *cache;
- cache = block_group_cache_tree_search(info, bytenr, 1);
- return cache;
- }
- static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
- u64 flags)
- {
- struct list_head *head = &info->space_info;
- struct btrfs_space_info *found;
- flags &= BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_SYSTEM |
- BTRFS_BLOCK_GROUP_METADATA;
- rcu_read_lock();
- list_for_each_entry_rcu(found, head, list) {
- if (found->flags & flags) {
- rcu_read_unlock();
- return found;
- }
- }
- rcu_read_unlock();
- return NULL;
- }
- /*
- * after adding space to the filesystem, we need to clear the full flags
- * on all the space infos.
- */
- void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
- {
- struct list_head *head = &info->space_info;
- struct btrfs_space_info *found;
- rcu_read_lock();
- list_for_each_entry_rcu(found, head, list)
- found->full = 0;
- rcu_read_unlock();
- }
- static u64 div_factor(u64 num, int factor)
- {
- if (factor == 10)
- return num;
- num *= factor;
- do_div(num, 10);
- return num;
- }
- static u64 div_factor_fine(u64 num, int factor)
- {
- if (factor == 100)
- return num;
- num *= factor;
- do_div(num, 100);
- return num;
- }
- u64 btrfs_find_block_group(struct btrfs_root *root,
- u64 search_start, u64 search_hint, int owner)
- {
- struct btrfs_block_group_cache *cache;
- u64 used;
- u64 last = max(search_hint, search_start);
- u64 group_start = 0;
- int full_search = 0;
- int factor = 9;
- int wrapped = 0;
- again:
- while (1) {
- cache = btrfs_lookup_first_block_group(root->fs_info, last);
- if (!cache)
- break;
- spin_lock(&cache->lock);
- last = cache->key.objectid + cache->key.offset;
- used = btrfs_block_group_used(&cache->item);
- if ((full_search || !cache->ro) &&
- block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
- if (used + cache->pinned + cache->reserved <
- div_factor(cache->key.offset, factor)) {
- group_start = cache->key.objectid;
- spin_unlock(&cache->lock);
- btrfs_put_block_group(cache);
- goto found;
- }
- }
- spin_unlock(&cache->lock);
- btrfs_put_block_group(cache);
- cond_resched();
- }
- if (!wrapped) {
- last = search_start;
- wrapped = 1;
- goto again;
- }
- if (!full_search && factor < 10) {
- last = search_start;
- full_search = 1;
- factor = 10;
- goto again;
- }
- found:
- return group_start;
- }
- /* simple helper to search for an existing extent at a given offset */
- int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
- {
- int ret;
- struct btrfs_key key;
- struct btrfs_path *path;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = start;
- key.offset = len;
- btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
- ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
- 0, 0);
- btrfs_free_path(path);
- return ret;
- }
- /*
- * helper function to lookup reference count and flags of extent.
- *
- * the head node for delayed ref is used to store the sum of all the
- * reference count modifications queued up in the rbtree. the head
- * node may also store the extent flags to set. This way you can check
- * to see what the reference count and extent flags would be if all of
- * the delayed refs are not processed.
- */
- int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
- struct btrfs_root *root, u64 bytenr,
- u64 num_bytes, u64 *refs, u64 *flags)
- {
- struct btrfs_delayed_ref_head *head;
- struct btrfs_delayed_ref_root *delayed_refs;
- struct btrfs_path *path;
- struct btrfs_extent_item *ei;
- struct extent_buffer *leaf;
- struct btrfs_key key;
- u32 item_size;
- u64 num_refs;
- u64 extent_flags;
- int ret;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = bytenr;
- key.type = BTRFS_EXTENT_ITEM_KEY;
- key.offset = num_bytes;
- if (!trans) {
- path->skip_locking = 1;
- path->search_commit_root = 1;
- }
- again:
- ret = btrfs_search_slot(trans, root->fs_info->extent_root,
- &key, path, 0, 0);
- if (ret < 0)
- goto out_free;
- if (ret == 0) {
- leaf = path->nodes[0];
- item_size = btrfs_item_size_nr(leaf, path->slots[0]);
- if (item_size >= sizeof(*ei)) {
- ei = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_item);
- num_refs = btrfs_extent_refs(leaf, ei);
- extent_flags = btrfs_extent_flags(leaf, ei);
- } else {
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- struct btrfs_extent_item_v0 *ei0;
- BUG_ON(item_size != sizeof(*ei0));
- ei0 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_item_v0);
- num_refs = btrfs_extent_refs_v0(leaf, ei0);
- /* FIXME: this isn't correct for data */
- extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
- #else
- BUG();
- #endif
- }
- BUG_ON(num_refs == 0);
- } else {
- num_refs = 0;
- extent_flags = 0;
- ret = 0;
- }
- if (!trans)
- goto out;
- delayed_refs = &trans->transaction->delayed_refs;
- spin_lock(&delayed_refs->lock);
- head = btrfs_find_delayed_ref_head(trans, bytenr);
- if (head) {
- if (!mutex_trylock(&head->mutex)) {
- atomic_inc(&head->node.refs);
- spin_unlock(&delayed_refs->lock);
- btrfs_release_path(path);
- /*
- * Mutex was contended, block until it's released and try
- * again
- */
- mutex_lock(&head->mutex);
- mutex_unlock(&head->mutex);
- btrfs_put_delayed_ref(&head->node);
- goto again;
- }
- if (head->extent_op && head->extent_op->update_flags)
- extent_flags |= head->extent_op->flags_to_set;
- else
- BUG_ON(num_refs == 0);
- num_refs += head->node.ref_mod;
- mutex_unlock(&head->mutex);
- }
- spin_unlock(&delayed_refs->lock);
- out:
- WARN_ON(num_refs == 0);
- if (refs)
- *refs = num_refs;
- if (flags)
- *flags = extent_flags;
- out_free:
- btrfs_free_path(path);
- return ret;
- }
- /*
- * Back reference rules. Back refs have three main goals:
- *
- * 1) differentiate between all holders of references to an extent so that
- * when a reference is dropped we can make sure it was a valid reference
- * before freeing the extent.
- *
- * 2) Provide enough information to quickly find the holders of an extent
- * if we notice a given block is corrupted or bad.
- *
- * 3) Make it easy to migrate blocks for FS shrinking or storage pool
- * maintenance. This is actually the same as #2, but with a slightly
- * different use case.
- *
- * There are two kinds of back refs. The implicit back refs is optimized
- * for pointers in non-shared tree blocks. For a given pointer in a block,
- * back refs of this kind provide information about the block's owner tree
- * and the pointer's key. These information allow us to find the block by
- * b-tree searching. The full back refs is for pointers in tree blocks not
- * referenced by their owner trees. The location of tree block is recorded
- * in the back refs. Actually the full back refs is generic, and can be
- * used in all cases the implicit back refs is used. The major shortcoming
- * of the full back refs is its overhead. Every time a tree block gets
- * COWed, we have to update back refs entry for all pointers in it.
- *
- * For a newly allocated tree block, we use implicit back refs for
- * pointers in it. This means most tree related operations only involve
- * implicit back refs. For a tree block created in old transaction, the
- * only way to drop a reference to it is COW it. So we can detect the
- * event that tree block loses its owner tree's reference and do the
- * back refs conversion.
- *
- * When a tree block is COW'd through a tree, there are four cases:
- *
- * The reference count of the block is one and the tree is the block's
- * owner tree. Nothing to do in this case.
- *
- * The reference count of the block is one and the tree is not the
- * block's owner tree. In this case, full back refs is used for pointers
- * in the block. Remove these full back refs, add implicit back refs for
- * every pointers in the new block.
- *
- * The reference count of the block is greater than one and the tree is
- * the block's owner tree. In this case, implicit back refs is used for
- * pointers in the block. Add full back refs for every pointers in the
- * block, increase lower level extents' reference counts. The original
- * implicit back refs are entailed to the new block.
- *
- * The reference count of the block is greater than one and the tree is
- * not the block's owner tree. Add implicit back refs for every pointer in
- * the new block, increase lower level extents' reference count.
- *
- * Back Reference Key composing:
- *
- * The key objectid corresponds to the first byte in the extent,
- * The key type is used to differentiate between types of back refs.
- * There are different meanings of the key offset for different types
- * of back refs.
- *
- * File extents can be referenced by:
- *
- * - multiple snapshots, subvolumes, or different generations in one subvol
- * - different files inside a single subvolume
- * - different offsets inside a file (bookend extents in file.c)
- *
- * The extent ref structure for the implicit back refs has fields for:
- *
- * - Objectid of the subvolume root
- * - objectid of the file holding the reference
- * - original offset in the file
- * - how many bookend extents
- *
- * The key offset for the implicit back refs is hash of the first
- * three fields.
- *
- * The extent ref structure for the full back refs has field for:
- *
- * - number of pointers in the tree leaf
- *
- * The key offset for the implicit back refs is the first byte of
- * the tree leaf
- *
- * When a file extent is allocated, The implicit back refs is used.
- * the fields are filled in:
- *
- * (root_key.objectid, inode objectid, offset in file, 1)
- *
- * When a file extent is removed file truncation, we find the
- * corresponding implicit back refs and check the following fields:
- *
- * (btrfs_header_owner(leaf), inode objectid, offset in file)
- *
- * Btree extents can be referenced by:
- *
- * - Different subvolumes
- *
- * Both the implicit back refs and the full back refs for tree blocks
- * only consist of key. The key offset for the implicit back refs is
- * objectid of block's owner tree. The key offset for the full back refs
- * is the first byte of parent block.
- *
- * When implicit back refs is used, information about the lowest key and
- * level of the tree block are required. These information are stored in
- * tree block info structure.
- */
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- static int convert_extent_item_v0(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 owner, u32 extra_size)
- {
- struct btrfs_extent_item *item;
- struct btrfs_extent_item_v0 *ei0;
- struct btrfs_extent_ref_v0 *ref0;
- struct btrfs_tree_block_info *bi;
- struct extent_buffer *leaf;
- struct btrfs_key key;
- struct btrfs_key found_key;
- u32 new_size = sizeof(*item);
- u64 refs;
- int ret;
- leaf = path->nodes[0];
- BUG_ON(btrfs_item_size_nr(leaf, path->slots[0]) != sizeof(*ei0));
- btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
- ei0 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_item_v0);
- refs = btrfs_extent_refs_v0(leaf, ei0);
- if (owner == (u64)-1) {
- while (1) {
- if (path->slots[0] >= btrfs_header_nritems(leaf)) {
- ret = btrfs_next_leaf(root, path);
- if (ret < 0)
- return ret;
- BUG_ON(ret > 0);
- leaf = path->nodes[0];
- }
- btrfs_item_key_to_cpu(leaf, &found_key,
- path->slots[0]);
- BUG_ON(key.objectid != found_key.objectid);
- if (found_key.type != BTRFS_EXTENT_REF_V0_KEY) {
- path->slots[0]++;
- continue;
- }
- ref0 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_ref_v0);
- owner = btrfs_ref_objectid_v0(leaf, ref0);
- break;
- }
- }
- btrfs_release_path(path);
- if (owner < BTRFS_FIRST_FREE_OBJECTID)
- new_size += sizeof(*bi);
- new_size -= sizeof(*ei0);
- ret = btrfs_search_slot(trans, root, &key, path,
- new_size + extra_size, 1);
- if (ret < 0)
- return ret;
- BUG_ON(ret);
- ret = btrfs_extend_item(trans, root, path, new_size);
- leaf = path->nodes[0];
- item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
- btrfs_set_extent_refs(leaf, item, refs);
- /* FIXME: get real generation */
- btrfs_set_extent_generation(leaf, item, 0);
- if (owner < BTRFS_FIRST_FREE_OBJECTID) {
- btrfs_set_extent_flags(leaf, item,
- BTRFS_EXTENT_FLAG_TREE_BLOCK |
- BTRFS_BLOCK_FLAG_FULL_BACKREF);
- bi = (struct btrfs_tree_block_info *)(item + 1);
- /* FIXME: get first key of the block */
- memset_extent_buffer(leaf, 0, (unsigned long)bi, sizeof(*bi));
- btrfs_set_tree_block_level(leaf, bi, (int)owner);
- } else {
- btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_DATA);
- }
- btrfs_mark_buffer_dirty(leaf);
- return 0;
- }
- #endif
- static u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
- {
- u32 high_crc = ~(u32)0;
- u32 low_crc = ~(u32)0;
- __le64 lenum;
- lenum = cpu_to_le64(root_objectid);
- high_crc = crc32c(high_crc, &lenum, sizeof(lenum));
- lenum = cpu_to_le64(owner);
- low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
- lenum = cpu_to_le64(offset);
- low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
- return ((u64)high_crc << 31) ^ (u64)low_crc;
- }
- static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
- struct btrfs_extent_data_ref *ref)
- {
- return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
- btrfs_extent_data_ref_objectid(leaf, ref),
- btrfs_extent_data_ref_offset(leaf, ref));
- }
- static int match_extent_data_ref(struct extent_buffer *leaf,
- struct btrfs_extent_data_ref *ref,
- u64 root_objectid, u64 owner, u64 offset)
- {
- if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
- btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
- btrfs_extent_data_ref_offset(leaf, ref) != offset)
- return 0;
- return 1;
- }
- static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 bytenr, u64 parent,
- u64 root_objectid,
- u64 owner, u64 offset)
- {
- struct btrfs_key key;
- struct btrfs_extent_data_ref *ref;
- struct extent_buffer *leaf;
- u32 nritems;
- int ret;
- int recow;
- int err = -ENOENT;
- key.objectid = bytenr;
- if (parent) {
- key.type = BTRFS_SHARED_DATA_REF_KEY;
- key.offset = parent;
- } else {
- key.type = BTRFS_EXTENT_DATA_REF_KEY;
- key.offset = hash_extent_data_ref(root_objectid,
- owner, offset);
- }
- again:
- recow = 0;
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret < 0) {
- err = ret;
- goto fail;
- }
- if (parent) {
- if (!ret)
- return 0;
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- key.type = BTRFS_EXTENT_REF_V0_KEY;
- btrfs_release_path(path);
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret < 0) {
- err = ret;
- goto fail;
- }
- if (!ret)
- return 0;
- #endif
- goto fail;
- }
- leaf = path->nodes[0];
- nritems = btrfs_header_nritems(leaf);
- while (1) {
- if (path->slots[0] >= nritems) {
- ret = btrfs_next_leaf(root, path);
- if (ret < 0)
- err = ret;
- if (ret)
- goto fail;
- leaf = path->nodes[0];
- nritems = btrfs_header_nritems(leaf);
- recow = 1;
- }
- btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
- if (key.objectid != bytenr ||
- key.type != BTRFS_EXTENT_DATA_REF_KEY)
- goto fail;
- ref = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_data_ref);
- if (match_extent_data_ref(leaf, ref, root_objectid,
- owner, offset)) {
- if (recow) {
- btrfs_release_path(path);
- goto again;
- }
- err = 0;
- break;
- }
- path->slots[0]++;
- }
- fail:
- return err;
- }
- static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 bytenr, u64 parent,
- u64 root_objectid, u64 owner,
- u64 offset, int refs_to_add)
- {
- struct btrfs_key key;
- struct extent_buffer *leaf;
- u32 size;
- u32 num_refs;
- int ret;
- key.objectid = bytenr;
- if (parent) {
- key.type = BTRFS_SHARED_DATA_REF_KEY;
- key.offset = parent;
- size = sizeof(struct btrfs_shared_data_ref);
- } else {
- key.type = BTRFS_EXTENT_DATA_REF_KEY;
- key.offset = hash_extent_data_ref(root_objectid,
- owner, offset);
- size = sizeof(struct btrfs_extent_data_ref);
- }
- ret = btrfs_insert_empty_item(trans, root, path, &key, size);
- if (ret && ret != -EEXIST)
- goto fail;
- leaf = path->nodes[0];
- if (parent) {
- struct btrfs_shared_data_ref *ref;
- ref = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_shared_data_ref);
- if (ret == 0) {
- btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
- } else {
- num_refs = btrfs_shared_data_ref_count(leaf, ref);
- num_refs += refs_to_add;
- btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
- }
- } else {
- struct btrfs_extent_data_ref *ref;
- while (ret == -EEXIST) {
- ref = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_data_ref);
- if (match_extent_data_ref(leaf, ref, root_objectid,
- owner, offset))
- break;
- btrfs_release_path(path);
- key.offset++;
- ret = btrfs_insert_empty_item(trans, root, path, &key,
- size);
- if (ret && ret != -EEXIST)
- goto fail;
- leaf = path->nodes[0];
- }
- ref = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_data_ref);
- if (ret == 0) {
- btrfs_set_extent_data_ref_root(leaf, ref,
- root_objectid);
- btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
- btrfs_set_extent_data_ref_offset(leaf, ref, offset);
- btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
- } else {
- num_refs = btrfs_extent_data_ref_count(leaf, ref);
- num_refs += refs_to_add;
- btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
- }
- }
- btrfs_mark_buffer_dirty(leaf);
- ret = 0;
- fail:
- btrfs_release_path(path);
- return ret;
- }
- static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- int refs_to_drop)
- {
- struct btrfs_key key;
- struct btrfs_extent_data_ref *ref1 = NULL;
- struct btrfs_shared_data_ref *ref2 = NULL;
- struct extent_buffer *leaf;
- u32 num_refs = 0;
- int ret = 0;
- leaf = path->nodes[0];
- btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
- if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
- ref1 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_data_ref);
- num_refs = btrfs_extent_data_ref_count(leaf, ref1);
- } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
- ref2 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_shared_data_ref);
- num_refs = btrfs_shared_data_ref_count(leaf, ref2);
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
- struct btrfs_extent_ref_v0 *ref0;
- ref0 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_ref_v0);
- num_refs = btrfs_ref_count_v0(leaf, ref0);
- #endif
- } else {
- BUG();
- }
- BUG_ON(num_refs < refs_to_drop);
- num_refs -= refs_to_drop;
- if (num_refs == 0) {
- ret = btrfs_del_item(trans, root, path);
- } else {
- if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
- btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
- else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
- btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- else {
- struct btrfs_extent_ref_v0 *ref0;
- ref0 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_ref_v0);
- btrfs_set_ref_count_v0(leaf, ref0, num_refs);
- }
- #endif
- btrfs_mark_buffer_dirty(leaf);
- }
- return ret;
- }
- static noinline u32 extent_data_ref_count(struct btrfs_root *root,
- struct btrfs_path *path,
- struct btrfs_extent_inline_ref *iref)
- {
- struct btrfs_key key;
- struct extent_buffer *leaf;
- struct btrfs_extent_data_ref *ref1;
- struct btrfs_shared_data_ref *ref2;
- u32 num_refs = 0;
- leaf = path->nodes[0];
- btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
- if (iref) {
- if (btrfs_extent_inline_ref_type(leaf, iref) ==
- BTRFS_EXTENT_DATA_REF_KEY) {
- ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
- num_refs = btrfs_extent_data_ref_count(leaf, ref1);
- } else {
- ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
- num_refs = btrfs_shared_data_ref_count(leaf, ref2);
- }
- } else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
- ref1 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_data_ref);
- num_refs = btrfs_extent_data_ref_count(leaf, ref1);
- } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
- ref2 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_shared_data_ref);
- num_refs = btrfs_shared_data_ref_count(leaf, ref2);
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
- struct btrfs_extent_ref_v0 *ref0;
- ref0 = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_extent_ref_v0);
- num_refs = btrfs_ref_count_v0(leaf, ref0);
- #endif
- } else {
- WARN_ON(1);
- }
- return num_refs;
- }
- static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 bytenr, u64 parent,
- u64 root_objectid)
- {
- struct btrfs_key key;
- int ret;
- key.objectid = bytenr;
- if (parent) {
- key.type = BTRFS_SHARED_BLOCK_REF_KEY;
- key.offset = parent;
- } else {
- key.type = BTRFS_TREE_BLOCK_REF_KEY;
- key.offset = root_objectid;
- }
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret > 0)
- ret = -ENOENT;
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- if (ret == -ENOENT && parent) {
- btrfs_release_path(path);
- key.type = BTRFS_EXTENT_REF_V0_KEY;
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret > 0)
- ret = -ENOENT;
- }
- #endif
- return ret;
- }
- static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 bytenr, u64 parent,
- u64 root_objectid)
- {
- struct btrfs_key key;
- int ret;
- key.objectid = bytenr;
- if (parent) {
- key.type = BTRFS_SHARED_BLOCK_REF_KEY;
- key.offset = parent;
- } else {
- key.type = BTRFS_TREE_BLOCK_REF_KEY;
- key.offset = root_objectid;
- }
- ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
- btrfs_release_path(path);
- return ret;
- }
- static inline int extent_ref_type(u64 parent, u64 owner)
- {
- int type;
- if (owner < BTRFS_FIRST_FREE_OBJECTID) {
- if (parent > 0)
- type = BTRFS_SHARED_BLOCK_REF_KEY;
- else
- type = BTRFS_TREE_BLOCK_REF_KEY;
- } else {
- if (parent > 0)
- type = BTRFS_SHARED_DATA_REF_KEY;
- else
- type = BTRFS_EXTENT_DATA_REF_KEY;
- }
- return type;
- }
- static int find_next_key(struct btrfs_path *path, int level,
- struct btrfs_key *key)
- {
- for (; level < BTRFS_MAX_LEVEL; level++) {
- if (!path->nodes[level])
- break;
- if (path->slots[level] + 1 >=
- btrfs_header_nritems(path->nodes[level]))
- continue;
- if (level == 0)
- btrfs_item_key_to_cpu(path->nodes[level], key,
- path->slots[level] + 1);
- else
- btrfs_node_key_to_cpu(path->nodes[level], key,
- path->slots[level] + 1);
- return 0;
- }
- return 1;
- }
- /*
- * look for inline back ref. if back ref is found, *ref_ret is set
- * to the address of inline back ref, and 0 is returned.
- *
- * if back ref isn't found, *ref_ret is set to the address where it
- * should be inserted, and -ENOENT is returned.
- *
- * if insert is true and there are too many inline back refs, the path
- * points to the extent item, and -EAGAIN is returned.
- *
- * NOTE: inline back refs are ordered in the same way that back ref
- * items in the tree are ordered.
- */
- static noinline_for_stack
- int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct btrfs_extent_inline_ref **ref_ret,
- u64 bytenr, u64 num_bytes,
- u64 parent, u64 root_objectid,
- u64 owner, u64 offset, int insert)
- {
- struct btrfs_key key;
- struct extent_buffer *leaf;
- struct btrfs_extent_item *ei;
- struct btrfs_extent_inline_ref *iref;
- u64 flags;
- u64 item_size;
- unsigned long ptr;
- unsigned long end;
- int extra_size;
- int type;
- int want;
- int ret;
- int err = 0;
- key.objectid = bytenr;
- key.type = BTRFS_EXTENT_ITEM_KEY;
- key.offset = num_bytes;
- want = extent_ref_type(parent, owner);
- if (insert) {
- extra_size = btrfs_extent_inline_ref_size(want);
- path->keep_locks = 1;
- } else
- extra_size = -1;
- ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
- if (ret < 0) {
- err = ret;
- goto out;
- }
- BUG_ON(ret);
- leaf = path->nodes[0];
- item_size = btrfs_item_size_nr(leaf, path->slots[0]);
- #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- if (item_size < sizeof(*ei)) {
- if (!insert) {
- err = -ENOENT;
- goto out;
- }
- ret = convert_extent_item_v0(trans, root, path, owner,
- extra_size);
- if (ret < 0) {
- err = ret;
- goto out;
- }
- leaf = path->nodes[0];
- item_size = btrfs_item_size_nr(leaf, path->slots[0]);
- }
- #endif
- BUG_ON(item_size < sizeof(*ei));
- ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
- flags = btrfs_extent_flags(leaf, ei);
- ptr = (unsigned long)(ei + 1);
- end = (unsigned long)ei + item_size;
- if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
- ptr += sizeof(struct btrfs_tree_block_info);
- BUG_ON(ptr > end);
- } else {
- BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
- }
- err = -ENOENT;
- while (1) {
- if (ptr >= end) {
- WARN_ON(ptr > end);
- break;
- }
- iref = (struct btrfs_extent_inline_ref *)ptr;
- type = btrfs_extent_inline_ref_type(leaf, iref);
- if (want < type)
- break;
- if (want > type) {
- ptr += btrfs_extent_inline_ref_size(type);
- continue;
- }
- if (type == BTRFS_EXTENT_DATA_REF_KEY) {
- struct btrfs_extent_data_ref *dref;
- dref = (struct btrfs_extent_data_ref *)(&iref->offset);
- if (match_extent_data_ref(leaf, dref, root_objectid,
- owner, offset)) {
- err = 0;
- break;
- }
- if (hash_extent_data_ref_item(leaf, dref) <
- hash_extent_data_ref(root_objectid, owner, offset))
- break;
- } else {
- u64 ref_offset;
- ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
- if (parent > 0) {
- if (parent == ref_offset) {
- err = 0;
- break;
- }
- if (ref_offset < parent)
- break;
- } else {
- if (root_objectid == ref_offset) {
- err = 0;
- break;
- }
- if (ref_offset < root_objectid)
- break;
- }
- }
- ptr += btrfs_extent_inline_ref_size(type);
- }
- if (err == -ENOENT && insert) {
- if (item_size + extra_size >=
- BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
- err = -EAGAIN;
- goto out;
- }
- /*
- * To add new inline back ref, we have to make sure
- * there is no corresponding back ref item.
- * For simplicity, we just do not add new inline back
- * ref if there is any kind of item for this block
- */
- if (find_next_key(path, 0, &key) == 0 &&
- key.objectid == bytenr &&
- key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
- err = -EAGAIN;
- goto out;
- }
- }
- *ref_ret = (struct btrfs_extent_inline_ref *)ptr;
- out:
- if (insert) {
- path->keep_locks = 0;
- btrfs_unlock_up_safe(path, 1);
- }
- return err;
- }
- /*
- * helper to add new inline back ref
- */
- static noinline_for_stack
- int setup_inline_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct btrfs_extent_inline_ref *iref,
- u64 parent, u64 root_objectid,
- u64 owner, u64 offset, int refs_to_add,
- struct btrfs_delayed_extent_op *extent_op)
- {
- struct extent_buffer *leaf;
- struct btrfs_extent_item *ei;
- unsigned long ptr;
- unsigned long end;
- unsigned long item_offset;
- u64 refs;
- int size;
- int type;
- int ret;
- leaf = path->nodes[0];
- ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
- item_offset = (unsigned long)iref - (unsigned long)ei;
- type = extent_ref_type(parent, owner);
- size = btrfs_extent_inline_ref_size(type);
- ret = btrfs_extend_item(trans, root, path, size);
- ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
- refs = btrfs_extent_refs(leaf, ei);
- refs += refs_to_add;
- btrfs_set_extent_refs(leaf, ei, refs);
- if (extent_op)
- __run_delayed_extent_op(extent_op, leaf, ei);
- ptr = (unsigned long)ei + item_offset;
- end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
- if (ptr < end - size)
- memmove_extent_buffer(leaf, ptr + size, ptr,
- end - size - ptr);
- iref = (struct btrfs_extent_inline_ref *)ptr;
- btrfs_set_extent_inline_ref_type(leaf, iref, type);
- if (type == BTRFS_EXTENT_DATA_REF_KEY) {
- struct btrfs_extent_data_ref *dref;
- dref = (struct btrfs_extent_data_ref *)(&iref->offset);
- btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
- btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
- btrfs_set_extent_data_ref_offset(leaf, dref, offset);
- btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
- } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
- struct btrfs_shared_data_ref *sref;
- sref = (struct btrfs_shared_data_ref *)(iref + 1);
- btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
- btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
- } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
- btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
- } else {
- btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
- }
- btrfs_mark_buffer_dirty(leaf);
- return 0;
- }
- static int lookup_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct btrfs_extent_inline_ref **ref_ret,
- u64 bytenr, u64 num_bytes, u64 parent,
- u64 root_objectid, u64 owner, u64 offset)
- {
- int ret;
- ret = lookup_inline_extent_backref(trans, root, path, ref_ret,
- bytenr, num_bytes, parent,
- root_objectid, owner, offset, 0);
- if (ret != -ENOENT)
- return ret;
- btrfs_release_path(path);
- *ref_ret = NULL;
- if (owner < BTRFS_FIRST_FREE_OBJECTID) {
- ret = lookup_tree_block_ref(trans, root, path, bytenr, parent,
- root_objectid);
- } else {
- ret = lookup_extent_data_ref(trans, root, path, bytenr, parent,
- root_objectid, owner, offset);
- }
- return ret;
- }
- /*
- * helper to update/remove inline back ref
- */
- static noinline_for_stack
- int update_inline_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct btrfs_extent_inline_ref *iref,
- int refs_to_mod,
- struct btrfs_delayed_extent_op *extent_op)
- {
- struct extent_buffer *leaf;
- struct btrfs_extent_item *ei;
- struct btrfs_extent_data_ref *dref = NULL;
- struct btrfs_shared_data_ref *sref = NULL;
- unsigned long ptr;
- unsigned long end;
- u32 item_size;
- int size;
- int type;
- int ret;
- u64 refs;
- leaf = path->nodes[0];
- ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
- refs = btrfs_extent_refs(leaf, ei);
- WARN_ON(refs_to_mod < 0 && refs + refs_to_mod <= 0);
- refs += refs_to_mod;
- btrfs_set_extent_refs(leaf, ei, refs);
- if (extent_op)
- __run_delayed_extent_op(extent_op, leaf, ei);
- type = btrfs_extent_inline_ref_type(leaf, iref);
- if (type == BTRFS_EXTENT_DATA_REF_KEY) {
- dref = (struct btrfs_extent_data_ref *)(&iref->offset);
- refs = btrfs_extent_data_ref_count(leaf, dref);
- } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
- sref = (struct btrfs_shared_data_ref *)(iref + 1);
- refs = btrfs_shared_data_ref_count(leaf, sref);
- } else {
- refs = 1;
- BUG_ON(refs_to_mod != -1);
- }
- BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);
- refs += refs_to_mod;
- if (refs > 0) {
- if (type == BTRFS_EXTENT_DATA_REF_KEY)
- btrfs_set_extent_data_ref_count(leaf, dref, refs);
- else
- btrfs_set_shared_data_ref_count(leaf, sref, refs);
- } else {
- size = btrfs_extent_inline_ref_size(type);
- item_size = btrfs_item_size_nr(leaf, path->slots[0]);
- ptr = (unsigned long)iref;
- end = (unsigned long)ei + item_size;
- if (ptr + size < end)
- memmove_extent_buffer(leaf, ptr, ptr + size,
- end - ptr - size);
- item_size -= size;
- ret = btrfs_truncate_item(trans, root, path, item_size, 1);
- }
- btrfs_mark_buffer_dirty(leaf);
- return 0;
- }
- static noinline_for_stack
- int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 bytenr, u64 num_bytes, u64 parent,
- u64 root_objectid, u64 owner,
- u64 offset, int refs_to_add,
- struct btrfs_delayed_extent_op *extent_op)
- {
- struct btrfs_extent_inline_ref *iref;
- int ret;
- ret = lookup_inline_extent_backref(trans, root, path, &iref,
- bytenr, num_bytes, parent,
- root_objectid, owner, offset, 1);
- if (ret == 0) {
- BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID);
- ret = update_inline_extent_backref(trans, root, path, iref,
- refs_to_add, extent_op);
- } else if (ret == -ENOENT) {
- ret = setup_inline_extent_backref(trans, root, path, iref,
- parent, root_objectid,
- owner, offset, refs_to_add,
- extent_op);
- }
- return ret;
- }
- static int insert_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 bytenr, u64 parent, u64 root_objectid,
- u64 owner, u64 offset, int refs_to_add)
- {
- int ret;
- if (owner < BTRFS_FIRST_FREE_OBJECTID) {
- BUG_ON(refs_to_add != 1);
- ret = insert_tree_block_ref(trans, root, path, bytenr,
- parent, root_objectid);
- } else {
- ret = insert_extent_data_ref(trans, root, path, bytenr,
- parent, root_objectid,
- owner, offset, refs_to_add);
- }
- return ret;
- }
- static int remove_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- struct btrfs_extent_inline_ref *iref,
- int refs_to_drop, int is_data)
- {
- int ret;
- BUG_ON(!is_data && refs_to_drop != 1);
- if (iref) {
- ret = update_inline_extent_backref(trans, root, path, iref,
- -refs_to_drop, NULL);
- } else if (is_data) {
- ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
- } else {
- ret = btrfs_del_item(trans, root, path);
- }
- return ret;
- }
- static int btrfs_issue_discard(struct block_device *bdev,
- u64 start, u64 len)
- {
- return blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_NOFS, 0);
- }
- static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
- u64 num_bytes, u64 *actual_bytes)
- {
- int ret;
- u64 discarded_bytes = 0;
- struct btrfs_multi_bio *multi = NULL;
- /* Tell the block device(s) that the sectors can be discarded */
- ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD,
- bytenr, &num_bytes, &multi, 0);
- if (!ret) {
- struct btrfs_bio_stripe *stripe = multi->stripes;
- int i;
- for (i = 0; i < multi->num_stripes; i++, stripe++) {
- if (!stripe->dev->can_discard)
- continue;
- ret = btrfs_issue_discard(stripe->dev->bdev,
- stripe->physical,
- stripe->length);
- if (!ret)
- discarded_bytes += stripe->length;
- else if (ret != -EOPNOTSUPP)
- break;
- /*
- * Just in case we get back EOPNOTSUPP for some reason,
- * just ignore the return value so we don't screw up
- * people calling discard_extent.
- */
- ret = 0;
- }
- kfree(multi);
- }
- if (actual_bytes)
- *actual_bytes = discarded_bytes;
- return ret;
- }
- int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 bytenr, u64 num_bytes, u64 parent,
- u64 root_objectid, u64 owner, u64 offset)
- {
- int ret;
- BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
- root_objectid == BTRFS_TREE_LOG_OBJECTID);
- if (owner < BTRFS_FIRST_FREE_OBJECTID) {
- ret = btrfs_add_delayed_tree_ref(trans, bytenr, num_bytes,
- parent, root_objectid, (int)owner,
- BTRFS_ADD_DELAYED_REF, NULL);
- } else {
- ret = btrfs_add_delayed_data_ref(trans, bytenr, num_bytes,
- parent, root_objectid, owner, offset,
- BTRFS_ADD_DELAYED_REF, NULL);
- }
- return