hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'cleanups-post-3.19' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux into for-linus-4.1 

Signed-off-by: Chris Mason <clm@fb.com>

Conflicts:
	fs/btrfs/disk-io.c
This commit is contained in:
Chris Mason 2015-03-25 10:52:48 -07:00
parent 9deed229fa a4f3d2c4ef
commit fc4c3c872f
25 changed files with 384 additions and 350 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fs/btrfs/async-thread.c
View File

@ -87,7 +87,7 @@ BTRFS_WORK_HELPER(scrubwrc_helper);
BTRFS_WORK_HELPER(scrubnc_helper); BTRFS_WORK_HELPER(scrubnc_helper);
static struct __btrfs_workqueue * static struct __btrfs_workqueue *
__btrfs_alloc_workqueue(const char *name, int flags, int max_active, __btrfs_alloc_workqueue(const char *name, unsigned int flags, int max_active,
int thresh) int thresh)
{ {
struct __btrfs_workqueue *ret = kzalloc(sizeof(*ret), GFP_NOFS); struct __btrfs_workqueue *ret = kzalloc(sizeof(*ret), GFP_NOFS);
@ -132,7 +132,7 @@ static inline void
__btrfs_destroy_workqueue(struct __btrfs_workqueue *wq); __btrfs_destroy_workqueue(struct __btrfs_workqueue *wq);
struct btrfs_workqueue *btrfs_alloc_workqueue(const char *name, struct btrfs_workqueue *btrfs_alloc_workqueue(const char *name,
int flags, unsigned int flags,
int max_active, int max_active,
int thresh) int thresh)
{ {

2
fs/btrfs/async-thread.h
View File

@ -66,7 +66,7 @@ BTRFS_WORK_HELPER_PROTO(scrubwrc_helper);
BTRFS_WORK_HELPER_PROTO(scrubnc_helper); BTRFS_WORK_HELPER_PROTO(scrubnc_helper);
struct btrfs_workqueue *btrfs_alloc_workqueue(const char *name, struct btrfs_workqueue *btrfs_alloc_workqueue(const char *name,
int flags, unsigned int flags,
int max_active, int max_active,
int thresh); int thresh);
void btrfs_init_work(struct btrfs_work *work, btrfs_work_func_t helper, void btrfs_init_work(struct btrfs_work *work, btrfs_work_func_t helper,

5
fs/btrfs/check-integrity.c
View File

@ -3241,8 +3241,5 @@ void btrfsic_unmount(struct btrfs_root *root,
mutex_unlock(&btrfsic_mutex); mutex_unlock(&btrfsic_mutex);
if (is_vmalloc_addr(state)) kvfree(state);
vfree(state);
else
kfree(state);
} }

2
fs/btrfs/compression.c
View File

@ -750,7 +750,7 @@ static int comp_num_workspace[BTRFS_COMPRESS_TYPES];
static atomic_t comp_alloc_workspace[BTRFS_COMPRESS_TYPES]; static atomic_t comp_alloc_workspace[BTRFS_COMPRESS_TYPES];
static wait_queue_head_t comp_workspace_wait[BTRFS_COMPRESS_TYPES]; static wait_queue_head_t comp_workspace_wait[BTRFS_COMPRESS_TYPES];
static struct btrfs_compress_op *btrfs_compress_op[] = { static const struct btrfs_compress_op * const btrfs_compress_op[] = {
&btrfs_zlib_compress, &btrfs_zlib_compress,
&btrfs_lzo_compress, &btrfs_lzo_compress,
}; };

4
fs/btrfs/compression.h
View File

@ -77,7 +77,7 @@ struct btrfs_compress_op {
size_t srclen, size_t destlen); size_t srclen, size_t destlen);
}; };
extern struct btrfs_compress_op btrfs_zlib_compress; extern const struct btrfs_compress_op btrfs_zlib_compress;
extern struct btrfs_compress_op btrfs_lzo_compress; extern const struct btrfs_compress_op btrfs_lzo_compress;
#endif #endif

53
fs/btrfs/ctree.c
View File

@ -1072,7 +1072,7 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans,
ret = btrfs_dec_ref(trans, root, buf, 1); ret = btrfs_dec_ref(trans, root, buf, 1);
BUG_ON(ret); /* -ENOMEM */ BUG_ON(ret); /* -ENOMEM */
} }
clean_tree_block(trans, root, buf); clean_tree_block(trans, root->fs_info, buf);
*last_ref = 1; *last_ref = 1;
} }
return 0; return 0;
@ -1677,7 +1677,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
continue; continue;
} }
cur = btrfs_find_tree_block(root, blocknr); cur = btrfs_find_tree_block(root->fs_info, blocknr);
if (cur) if (cur)
uptodate = btrfs_buffer_uptodate(cur, gen, 0); uptodate = btrfs_buffer_uptodate(cur, gen, 0);
else else
@ -1942,7 +1942,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
path->locks[level] = 0; path->locks[level] = 0;
path->nodes[level] = NULL; path->nodes[level] = NULL;
clean_tree_block(trans, root, mid); clean_tree_block(trans, root->fs_info, mid);
btrfs_tree_unlock(mid); btrfs_tree_unlock(mid);
/* once for the path */ /* once for the path */
free_extent_buffer(mid); free_extent_buffer(mid);
@ -1996,7 +1996,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
if (wret < 0 && wret != -ENOSPC) if (wret < 0 && wret != -ENOSPC)
ret = wret; ret = wret;
if (btrfs_header_nritems(right) == 0) { if (btrfs_header_nritems(right) == 0) {
clean_tree_block(trans, root, right); clean_tree_block(trans, root->fs_info, right);
btrfs_tree_unlock(right); btrfs_tree_unlock(right);
del_ptr(root, path, level + 1, pslot + 1); del_ptr(root, path, level + 1, pslot + 1);
root_sub_used(root, right->len); root_sub_used(root, right->len);
@ -2040,7 +2040,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
BUG_ON(wret == 1); BUG_ON(wret == 1);
} }
if (btrfs_header_nritems(mid) == 0) { if (btrfs_header_nritems(mid) == 0) {
clean_tree_block(trans, root, mid); clean_tree_block(trans, root->fs_info, mid);
btrfs_tree_unlock(mid); btrfs_tree_unlock(mid);
del_ptr(root, path, level + 1, pslot); del_ptr(root, path, level + 1, pslot);
root_sub_used(root, mid->len); root_sub_used(root, mid->len);
@ -2258,7 +2258,7 @@ static void reada_for_search(struct btrfs_root *root,
search = btrfs_node_blockptr(node, slot); search = btrfs_node_blockptr(node, slot);
blocksize = root->nodesize; blocksize = root->nodesize;
eb = btrfs_find_tree_block(root, search); eb = btrfs_find_tree_block(root->fs_info, search);
if (eb) { if (eb) {
free_extent_buffer(eb); free_extent_buffer(eb);
return; return;
@ -2318,7 +2318,7 @@ static noinline void reada_for_balance(struct btrfs_root *root,
if (slot > 0) { if (slot > 0) {
block1 = btrfs_node_blockptr(parent, slot - 1); block1 = btrfs_node_blockptr(parent, slot - 1);
gen = btrfs_node_ptr_generation(parent, slot - 1); gen = btrfs_node_ptr_generation(parent, slot - 1);
eb = btrfs_find_tree_block(root, block1); eb = btrfs_find_tree_block(root->fs_info, block1);
/* /*
* if we get -eagain from btrfs_buffer_uptodate, we * if we get -eagain from btrfs_buffer_uptodate, we
* don't want to return eagain here. That will loop * don't want to return eagain here. That will loop
@ -2331,7 +2331,7 @@ static noinline void reada_for_balance(struct btrfs_root *root,
if (slot + 1 < nritems) { if (slot + 1 < nritems) {
block2 = btrfs_node_blockptr(parent, slot + 1); block2 = btrfs_node_blockptr(parent, slot + 1);
gen = btrfs_node_ptr_generation(parent, slot + 1); gen = btrfs_node_ptr_generation(parent, slot + 1);
eb = btrfs_find_tree_block(root, block2); eb = btrfs_find_tree_block(root->fs_info, block2);
if (eb && btrfs_buffer_uptodate(eb, gen, 1) != 0) if (eb && btrfs_buffer_uptodate(eb, gen, 1) != 0)
block2 = 0; block2 = 0;
free_extent_buffer(eb); free_extent_buffer(eb);
@ -2449,7 +2449,7 @@ read_block_for_search(struct btrfs_trans_handle *trans,
blocknr = btrfs_node_blockptr(b, slot); blocknr = btrfs_node_blockptr(b, slot);
gen = btrfs_node_ptr_generation(b, slot); gen = btrfs_node_ptr_generation(b, slot);
tmp = btrfs_find_tree_block(root, blocknr); tmp = btrfs_find_tree_block(root->fs_info, blocknr);
if (tmp) { if (tmp) {
/* first we do an atomic uptodate check */ /* first we do an atomic uptodate check */
if (btrfs_buffer_uptodate(tmp, gen, 1) > 0) { if (btrfs_buffer_uptodate(tmp, gen, 1) > 0) {
@ -3125,7 +3125,8 @@ again:
* higher levels * higher levels
* *
*/ */
static void fixup_low_keys(struct btrfs_root *root, struct btrfs_path *path, static void fixup_low_keys(struct btrfs_fs_info *fs_info,
struct btrfs_path *path,
struct btrfs_disk_key *key, int level) struct btrfs_disk_key *key, int level)
{ {
int i; int i;
@ -3136,7 +3137,7 @@ static void fixup_low_keys(struct btrfs_root *root, struct btrfs_path *path,
if (!path->nodes[i]) if (!path->nodes[i])
break; break;
t = path->nodes[i]; t = path->nodes[i];
tree_mod_log_set_node_key(root->fs_info, t, tslot, 1); tree_mod_log_set_node_key(fs_info, t, tslot, 1);
btrfs_set_node_key(t, key, tslot); btrfs_set_node_key(t, key, tslot);
btrfs_mark_buffer_dirty(path->nodes[i]); btrfs_mark_buffer_dirty(path->nodes[i]);
if (tslot != 0) if (tslot != 0)
@ -3150,7 +3151,8 @@ static void fixup_low_keys(struct btrfs_root *root, struct btrfs_path *path,
* This function isn't completely safe. It's the caller's responsibility * This function isn't completely safe. It's the caller's responsibility
* that the new key won't break the order * that the new key won't break the order
*/ */
void btrfs_set_item_key_safe(struct btrfs_root *root, struct btrfs_path *path, void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info,
struct btrfs_path *path,
struct btrfs_key *new_key) struct btrfs_key *new_key)
{ {
struct btrfs_disk_key disk_key; struct btrfs_disk_key disk_key;
@ -3172,7 +3174,7 @@ void btrfs_set_item_key_safe(struct btrfs_root *root, struct btrfs_path *path,
btrfs_set_item_key(eb, &disk_key, slot); btrfs_set_item_key(eb, &disk_key, slot);
btrfs_mark_buffer_dirty(eb); btrfs_mark_buffer_dirty(eb);
if (slot == 0) if (slot == 0)
fixup_low_keys(root, path, &disk_key, 1); fixup_low_keys(fs_info, path, &disk_key, 1);
} }
/* /*
@ -3691,7 +3693,7 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
if (left_nritems) if (left_nritems)
btrfs_mark_buffer_dirty(left); btrfs_mark_buffer_dirty(left);
else else
clean_tree_block(trans, root, left); clean_tree_block(trans, root->fs_info, left);
btrfs_mark_buffer_dirty(right); btrfs_mark_buffer_dirty(right);
@ -3703,7 +3705,7 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
if (path->slots[0] >= left_nritems) { if (path->slots[0] >= left_nritems) {
path->slots[0] -= left_nritems; path->slots[0] -= left_nritems;
if (btrfs_header_nritems(path->nodes[0]) == 0) if (btrfs_header_nritems(path->nodes[0]) == 0)
clean_tree_block(trans, root, path->nodes[0]); clean_tree_block(trans, root->fs_info, path->nodes[0]);
btrfs_tree_unlock(path->nodes[0]); btrfs_tree_unlock(path->nodes[0]);
free_extent_buffer(path->nodes[0]); free_extent_buffer(path->nodes[0]);
path->nodes[0] = right; path->nodes[0] = right;
@ -3927,10 +3929,10 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
if (right_nritems) if (right_nritems)
btrfs_mark_buffer_dirty(right); btrfs_mark_buffer_dirty(right);
else else
clean_tree_block(trans, root, right); clean_tree_block(trans, root->fs_info, right);
btrfs_item_key(right, &disk_key, 0); btrfs_item_key(right, &disk_key, 0);
fixup_low_keys(root, path, &disk_key, 1); fixup_low_keys(root->fs_info, path, &disk_key, 1);
/* then fixup the leaf pointer in the path */ /* then fixup the leaf pointer in the path */
if (path->slots[0] < push_items) { if (path->slots[0] < push_items) {
@ -4167,6 +4169,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
int mid; int mid;
int slot; int slot;
struct extent_buffer *right; struct extent_buffer *right;
struct btrfs_fs_info *fs_info = root->fs_info;
int ret = 0; int ret = 0;
int wret; int wret;
int split; int split;
@ -4270,10 +4273,10 @@ again:
btrfs_set_header_backref_rev(right, BTRFS_MIXED_BACKREF_REV); btrfs_set_header_backref_rev(right, BTRFS_MIXED_BACKREF_REV);
btrfs_set_header_owner(right, root->root_key.objectid); btrfs_set_header_owner(right, root->root_key.objectid);
btrfs_set_header_level(right, 0); btrfs_set_header_level(right, 0);
write_extent_buffer(right, root->fs_info->fsid, write_extent_buffer(right, fs_info->fsid,
btrfs_header_fsid(), BTRFS_FSID_SIZE); btrfs_header_fsid(), BTRFS_FSID_SIZE);
write_extent_buffer(right, root->fs_info->chunk_tree_uuid, write_extent_buffer(right, fs_info->chunk_tree_uuid,
btrfs_header_chunk_tree_uuid(right), btrfs_header_chunk_tree_uuid(right),
BTRFS_UUID_SIZE); BTRFS_UUID_SIZE);
@ -4296,7 +4299,7 @@ again:
path->nodes[0] = right; path->nodes[0] = right;
path->slots[0] = 0; path->slots[0] = 0;
if (path->slots[1] == 0) if (path->slots[1] == 0)
fixup_low_keys(root, path, &disk_key, 1); fixup_low_keys(fs_info, path, &disk_key, 1);
} }
btrfs_mark_buffer_dirty(right); btrfs_mark_buffer_dirty(right);
return ret; return ret;
@ -4614,7 +4617,7 @@ void btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path,
btrfs_set_disk_key_offset(&disk_key, offset + size_diff); btrfs_set_disk_key_offset(&disk_key, offset + size_diff);
btrfs_set_item_key(leaf, &disk_key, slot); btrfs_set_item_key(leaf, &disk_key, slot);
if (slot == 0) if (slot == 0)
fixup_low_keys(root, path, &disk_key, 1); fixup_low_keys(root->fs_info, path, &disk_key, 1);
} }
item = btrfs_item_nr(slot); item = btrfs_item_nr(slot);
@ -4715,7 +4718,7 @@ void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
if (path->slots[0] == 0) { if (path->slots[0] == 0) {
btrfs_cpu_key_to_disk(&disk_key, cpu_key); btrfs_cpu_key_to_disk(&disk_key, cpu_key);
fixup_low_keys(root, path, &disk_key, 1); fixup_low_keys(root->fs_info, path, &disk_key, 1);
} }
btrfs_unlock_up_safe(path, 1); btrfs_unlock_up_safe(path, 1);
@ -4887,7 +4890,7 @@ static void del_ptr(struct btrfs_root *root, struct btrfs_path *path,
struct btrfs_disk_key disk_key; struct btrfs_disk_key disk_key;
btrfs_node_key(parent, &disk_key, 0); btrfs_node_key(parent, &disk_key, 0);
fixup_low_keys(root, path, &disk_key, level + 1); fixup_low_keys(root->fs_info, path, &disk_key, level + 1);
} }
btrfs_mark_buffer_dirty(parent); btrfs_mark_buffer_dirty(parent);
} }
@ -4980,7 +4983,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
btrfs_set_header_level(leaf, 0); btrfs_set_header_level(leaf, 0);
} else { } else {
btrfs_set_path_blocking(path); btrfs_set_path_blocking(path);
clean_tree_block(trans, root, leaf); clean_tree_block(trans, root->fs_info, leaf);
btrfs_del_leaf(trans, root, path, leaf); btrfs_del_leaf(trans, root, path, leaf);
} }
} else { } else {
@ -4989,7 +4992,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_disk_key disk_key; struct btrfs_disk_key disk_key;
btrfs_item_key(leaf, &disk_key, 0); btrfs_item_key(leaf, &disk_key, 0);
fixup_low_keys(root, path, &disk_key, 1); fixup_low_keys(root->fs_info, path, &disk_key, 1);
} }
/* delete the leaf if it is mostly empty */ /* delete the leaf if it is mostly empty */

3
fs/btrfs/ctree.h
View File

@ -3488,7 +3488,8 @@ int btrfs_previous_item(struct btrfs_root *root,
int type); int type);
int btrfs_previous_extent_item(struct btrfs_root *root, int btrfs_previous_extent_item(struct btrfs_root *root,
struct btrfs_path *path, u64 min_objectid); struct btrfs_path *path, u64 min_objectid);
void btrfs_set_item_key_safe(struct btrfs_root *root, struct btrfs_path *path, void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info,
struct btrfs_path *path,
struct btrfs_key *new_key); struct btrfs_key *new_key);
struct extent_buffer *btrfs_root_node(struct btrfs_root *root); struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root); struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);

9
fs/btrfs/delayed-inode.c
View File

@ -1383,7 +1383,7 @@ out:
static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root, static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root,
struct btrfs_root *root, int nr) struct btrfs_fs_info *fs_info, int nr)
{ {
struct btrfs_async_delayed_work *async_work; struct btrfs_async_delayed_work *async_work;
@ -1399,7 +1399,7 @@ static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root,
btrfs_async_run_delayed_root, NULL, NULL); btrfs_async_run_delayed_root, NULL, NULL);
async_work->nr = nr; async_work->nr = nr;
btrfs_queue_work(root->fs_info->delayed_workers, &async_work->work); btrfs_queue_work(fs_info->delayed_workers, &async_work->work);
return 0; return 0;
} }
@ -1426,6 +1426,7 @@ static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)
void btrfs_balance_delayed_items(struct btrfs_root *root) void btrfs_balance_delayed_items(struct btrfs_root *root)
{ {
struct btrfs_delayed_root *delayed_root; struct btrfs_delayed_root *delayed_root;
struct btrfs_fs_info *fs_info = root->fs_info;
delayed_root = btrfs_get_delayed_root(root); delayed_root = btrfs_get_delayed_root(root);
@ -1438,7 +1439,7 @@ void btrfs_balance_delayed_items(struct btrfs_root *root)
seq = atomic_read(&delayed_root->items_seq); seq = atomic_read(&delayed_root->items_seq);
ret = btrfs_wq_run_delayed_node(delayed_root, root, 0); ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0);
if (ret) if (ret)
return; return;
@ -1447,7 +1448,7 @@ void btrfs_balance_delayed_items(struct btrfs_root *root)
return; return;
} }
btrfs_wq_run_delayed_node(delayed_root, root, BTRFS_DELAYED_BATCH); btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH);
} }
/* Will return 0 or -ENOMEM */ /* Will return 0 or -ENOMEM */

554
fs/btrfs/disk-io.c
View File

@ -54,7 +54,7 @@
#include <asm/cpufeature.h> #include <asm/cpufeature.h>
#endif #endif
static struct extent_io_ops btree_extent_io_ops; static const struct extent_io_ops btree_extent_io_ops;
static void end_workqueue_fn(struct btrfs_work *work); static void end_workqueue_fn(struct btrfs_work *work);
static void free_fs_root(struct btrfs_root *root); static void free_fs_root(struct btrfs_root *root);
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info, static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
@ -274,10 +274,11 @@ void btrfs_csum_final(u32 crc, char *result)
* compute the csum for a btree block, and either verify it or write it * compute the csum for a btree block, and either verify it or write it
* into the csum field of the block. * into the csum field of the block.
*/ */
static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf, static int csum_tree_block(struct btrfs_fs_info *fs_info,
struct extent_buffer *buf,
int verify) int verify)
{ {
u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
char *result = NULL; char *result = NULL;
unsigned long len; unsigned long len;
unsigned long cur_len; unsigned long cur_len;
@ -321,7 +322,7 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
printk_ratelimited(KERN_WARNING printk_ratelimited(KERN_WARNING
"BTRFS: %s checksum verify failed on %llu wanted %X found %X " "BTRFS: %s checksum verify failed on %llu wanted %X found %X "
"level %d\n", "level %d\n",
root->fs_info->sb->s_id, buf->start, fs_info->sb->s_id, buf->start,
val, found, btrfs_header_level(buf)); val, found, btrfs_header_level(buf));
if (result != (char *)&inline_result) if (result != (char *)&inline_result)
kfree(result); kfree(result);
@ -501,7 +502,7 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
* we only fill in the checksum field in the first page of a multi-page block * we only fill in the checksum field in the first page of a multi-page block
*/ */
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page) static int csum_dirty_buffer(struct btrfs_fs_info *fs_info, struct page *page)
{ {
u64 start = page_offset(page); u64 start = page_offset(page);
u64 found_start; u64 found_start;
@ -513,14 +514,14 @@ static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
found_start = btrfs_header_bytenr(eb); found_start = btrfs_header_bytenr(eb);
if (WARN_ON(found_start != start || !PageUptodate(page))) if (WARN_ON(found_start != start || !PageUptodate(page)))
return 0; return 0;
csum_tree_block(root, eb, 0); csum_tree_block(fs_info, eb, 0);
return 0; return 0;
} }
static int check_tree_block_fsid(struct btrfs_root *root, static int check_tree_block_fsid(struct btrfs_fs_info *fs_info,
struct extent_buffer *eb) struct extent_buffer *eb)
{ {
struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices; struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
u8 fsid[BTRFS_UUID_SIZE]; u8 fsid[BTRFS_UUID_SIZE];
int ret = 1; int ret = 1;
@ -640,7 +641,7 @@ static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
ret = -EIO; ret = -EIO;
goto err; goto err;
} }
if (check_tree_block_fsid(root, eb)) { if (check_tree_block_fsid(root->fs_info, eb)) {
printk_ratelimited(KERN_ERR "BTRFS (device %s): bad fsid on block %llu\n", printk_ratelimited(KERN_ERR "BTRFS (device %s): bad fsid on block %llu\n",
eb->fs_info->sb->s_id, eb->start); eb->fs_info->sb->s_id, eb->start);
ret = -EIO; ret = -EIO;
@ -657,7 +658,7 @@ static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb), btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
eb, found_level); eb, found_level);
ret = csum_tree_block(root, eb, 1); ret = csum_tree_block(root->fs_info, eb, 1);
if (ret) { if (ret) {
ret = -EIO; ret = -EIO;
goto err; goto err;
@ -882,7 +883,7 @@ static int btree_csum_one_bio(struct bio *bio)
bio_for_each_segment_all(bvec, bio, i) { bio_for_each_segment_all(bvec, bio, i) {
root = BTRFS_I(bvec->bv_page->mapping->host)->root; root = BTRFS_I(bvec->bv_page->mapping->host)->root;
ret = csum_dirty_buffer(root, bvec->bv_page); ret = csum_dirty_buffer(root->fs_info, bvec->bv_page);
if (ret) if (ret)
break; break;
} }
@ -1119,10 +1120,10 @@ int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr,
return 0; return 0;
} }
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root, struct extent_buffer *btrfs_find_tree_block(struct btrfs_fs_info *fs_info,
u64 bytenr) u64 bytenr)
{ {
return find_extent_buffer(root->fs_info, bytenr); return find_extent_buffer(fs_info, bytenr);
} }
struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root, struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
@ -1165,11 +1166,10 @@ struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
} }
void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, void clean_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *fs_info,
struct extent_buffer *buf) struct extent_buffer *buf)
{ {
struct btrfs_fs_info *fs_info = root->fs_info;
if (btrfs_header_generation(buf) == if (btrfs_header_generation(buf) ==
fs_info->running_transaction->transid) { fs_info->running_transaction->transid) {
btrfs_assert_tree_locked(buf); btrfs_assert_tree_locked(buf);
@ -2146,6 +2146,267 @@ void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
} }
} }
static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
{
mutex_init(&fs_info->scrub_lock);
atomic_set(&fs_info->scrubs_running, 0);
atomic_set(&fs_info->scrub_pause_req, 0);
atomic_set(&fs_info->scrubs_paused, 0);
atomic_set(&fs_info->scrub_cancel_req, 0);
init_waitqueue_head(&fs_info->scrub_pause_wait);
fs_info->scrub_workers_refcnt = 0;
}
static void btrfs_init_balance(struct btrfs_fs_info *fs_info)
{
spin_lock_init(&fs_info->balance_lock);
mutex_init(&fs_info->balance_mutex);
atomic_set(&fs_info->balance_running, 0);
atomic_set(&fs_info->balance_pause_req, 0);
atomic_set(&fs_info->balance_cancel_req, 0);
fs_info->balance_ctl = NULL;
init_waitqueue_head(&fs_info->balance_wait_q);
}
static void btrfs_init_btree_inode(struct btrfs_fs_info *fs_info,
struct btrfs_root *tree_root)
{
fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
set_nlink(fs_info->btree_inode, 1);
/*
* we set the i_size on the btree inode to the max possible int.
* the real end of the address space is determined by all of
* the devices in the system
*/
fs_info->btree_inode->i_size = OFFSET_MAX;
fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
fs_info->btree_inode->i_mapping);
BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
BTRFS_I(fs_info->btree_inode)->root = tree_root;
memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
sizeof(struct btrfs_key));
set_bit(BTRFS_INODE_DUMMY,
&BTRFS_I(fs_info->btree_inode)->runtime_flags);
btrfs_insert_inode_hash(fs_info->btree_inode);
}
static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
{
fs_info->dev_replace.lock_owner = 0;
atomic_set(&fs_info->dev_replace.nesting_level, 0);
mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
mutex_init(&fs_info->dev_replace.lock_management_lock);
mutex_init(&fs_info->dev_replace.lock);
init_waitqueue_head(&fs_info->replace_wait);
}
static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
{
spin_lock_init(&fs_info->qgroup_lock);
mutex_init(&fs_info->qgroup_ioctl_lock);
fs_info->qgroup_tree = RB_ROOT;
fs_info->qgroup_op_tree = RB_ROOT;
INIT_LIST_HEAD(&fs_info->dirty_qgroups);
fs_info->qgroup_seq = 1;
fs_info->quota_enabled = 0;
fs_info->pending_quota_state = 0;
fs_info->qgroup_ulist = NULL;
mutex_init(&fs_info->qgroup_rescan_lock);
}
static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info,
struct btrfs_fs_devices *fs_devices)
{
int max_active = fs_info->thread_pool_size;
unsigned int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
fs_info->workers =
btrfs_alloc_workqueue("worker", flags | WQ_HIGHPRI,
max_active, 16);
fs_info->delalloc_workers =
btrfs_alloc_workqueue("delalloc", flags, max_active, 2);
fs_info->flush_workers =
btrfs_alloc_workqueue("flush_delalloc", flags, max_active, 0);
fs_info->caching_workers =
btrfs_alloc_workqueue("cache", flags, max_active, 0);
/*
* a higher idle thresh on the submit workers makes it much more
* likely that bios will be send down in a sane order to the
* devices
*/
fs_info->submit_workers =
btrfs_alloc_workqueue("submit", flags,
min_t(u64, fs_devices->num_devices,
max_active), 64);
fs_info->fixup_workers =
btrfs_alloc_workqueue("fixup", flags, 1, 0);
/*
* endios are largely parallel and should have a very
* low idle thresh
*/
fs_info->endio_workers =
btrfs_alloc_workqueue("endio", flags, max_active, 4);
fs_info->endio_meta_workers =
btrfs_alloc_workqueue("endio-meta", flags, max_active, 4);
fs_info->endio_meta_write_workers =
btrfs_alloc_workqueue("endio-meta-write", flags, max_active, 2);
fs_info->endio_raid56_workers =
btrfs_alloc_workqueue("endio-raid56", flags, max_active, 4);
fs_info->endio_repair_workers =
btrfs_alloc_workqueue("endio-repair", flags, 1, 0);
fs_info->rmw_workers =
btrfs_alloc_workqueue("rmw", flags, max_active, 2);
fs_info->endio_write_workers =
btrfs_alloc_workqueue("endio-write", flags, max_active, 2);
fs_info->endio_freespace_worker =
btrfs_alloc_workqueue("freespace-write", flags, max_active, 0);
fs_info->delayed_workers =
btrfs_alloc_workqueue("delayed-meta", flags, max_active, 0);
fs_info->readahead_workers =
btrfs_alloc_workqueue("readahead", flags, max_active, 2);
fs_info->qgroup_rescan_workers =
btrfs_alloc_workqueue("qgroup-rescan", flags, 1, 0);
fs_info->extent_workers =
btrfs_alloc_workqueue("extent-refs", flags,
min_t(u64, fs_devices->num_devices,
max_active), 8);
if (!(fs_info->workers && fs_info->delalloc_workers &&
fs_info->submit_workers && fs_info->flush_workers &&
fs_info->endio_workers && fs_info->endio_meta_workers &&
fs_info->endio_meta_write_workers &&
fs_info->endio_repair_workers &&
fs_info->endio_write_workers && fs_info->endio_raid56_workers &&
fs_info->endio_freespace_worker && fs_info->rmw_workers &&
fs_info->caching_workers && fs_info->readahead_workers &&
fs_info->fixup_workers && fs_info->delayed_workers &&
fs_info->extent_workers &&
fs_info->qgroup_rescan_workers)) {
return -ENOMEM;
}
return 0;
}
static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
struct btrfs_fs_devices *fs_devices)
{
int ret;
struct btrfs_root *tree_root = fs_info->tree_root;
struct btrfs_root *log_tree_root;
struct btrfs_super_block *disk_super = fs_info->super_copy;
u64 bytenr = btrfs_super_log_root(disk_super);
if (fs_devices->rw_devices == 0) {
printk(KERN_WARNING "BTRFS: log replay required "
"on RO media\n");
return -EIO;
}
log_tree_root = btrfs_alloc_root(fs_info);
if (!log_tree_root)
return -ENOMEM;
__setup_root(tree_root->nodesize, tree_root->sectorsize,
tree_root->stripesize, log_tree_root, fs_info,
BTRFS_TREE_LOG_OBJECTID);
log_tree_root->node = read_tree_block(tree_root, bytenr,
fs_info->generation + 1);
if (!log_tree_root->node ||
!extent_buffer_uptodate(log_tree_root->node)) {
printk(KERN_ERR "BTRFS: failed to read log tree\n");
free_extent_buffer(log_tree_root->node);
kfree(log_tree_root);
return -EIO;
}
/* returns with log_tree_root freed on success */
ret = btrfs_recover_log_trees(log_tree_root);
if (ret) {
btrfs_error(tree_root->fs_info, ret,
"Failed to recover log tree");
free_extent_buffer(log_tree_root->node);
kfree(log_tree_root);
return ret;
}
if (fs_info->sb->s_flags & MS_RDONLY) {
ret = btrfs_commit_super(tree_root);
if (ret)
return ret;
}
return 0;
}
static int btrfs_read_roots(struct btrfs_fs_info *fs_info,
struct btrfs_root *tree_root)
{
struct btrfs_root *root;
struct btrfs_key location;
int ret;
location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
location.type = BTRFS_ROOT_ITEM_KEY;
location.offset = 0;
root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(root))
return PTR_ERR(root);
set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
fs_info->extent_root = root;
location.objectid = BTRFS_DEV_TREE_OBJECTID;
root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(root))
return PTR_ERR(root);
set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
fs_info->dev_root = root;
btrfs_init_devices_late(fs_info);
location.objectid = BTRFS_CSUM_TREE_OBJECTID;
root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(root))
return PTR_ERR(root);
set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
fs_info->csum_root = root;
location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
root = btrfs_read_tree_root(tree_root, &location);
if (!IS_ERR(root)) {
set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
fs_info->quota_enabled = 1;
fs_info->pending_quota_state = 1;
fs_info->quota_root = root;
}
location.objectid = BTRFS_UUID_TREE_OBJECTID;
root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(root)) {
ret = PTR_ERR(root);
if (ret != -ENOENT)
return ret;
} else {
set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
fs_info->uuid_root = root;
}
return 0;
}
int open_ctree(struct super_block *sb, int open_ctree(struct super_block *sb,
struct btrfs_fs_devices *fs_devices, struct btrfs_fs_devices *fs_devices,
char *options) char *options)
@ -2160,21 +2421,12 @@ int open_ctree(struct super_block *sb,
struct btrfs_super_block *disk_super; struct btrfs_super_block *disk_super;
struct btrfs_fs_info *fs_info = btrfs_sb(sb); struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_root *tree_root; struct btrfs_root *tree_root;
struct btrfs_root *extent_root;
struct btrfs_root *csum_root;
struct btrfs_root *chunk_root; struct btrfs_root *chunk_root;
struct btrfs_root *dev_root;
struct btrfs_root *quota_root;
struct btrfs_root *uuid_root;
struct btrfs_root *log_tree_root;
int ret; int ret;
int err = -EINVAL; int err = -EINVAL;
int num_backups_tried = 0; int num_backups_tried = 0;
int backup_index = 0; int backup_index = 0;
int max_active; int max_active;
int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
bool create_uuid_tree;
bool check_uuid_tree;
tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info); tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info); chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
@ -2294,55 +2546,18 @@ int open_ctree(struct super_block *sb,
} }
btrfs_init_delayed_root(fs_info->delayed_root); btrfs_init_delayed_root(fs_info->delayed_root);
mutex_init(&fs_info->scrub_lock); btrfs_init_scrub(fs_info);
atomic_set(&fs_info->scrubs_running, 0);
atomic_set(&fs_info->scrub_pause_req, 0);
atomic_set(&fs_info->scrubs_paused, 0);
atomic_set(&fs_info->scrub_cancel_req, 0);
init_waitqueue_head(&fs_info->replace_wait);
init_waitqueue_head(&fs_info->scrub_pause_wait);
fs_info->scrub_workers_refcnt = 0;
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
fs_info->check_integrity_print_mask = 0; fs_info->check_integrity_print_mask = 0;
#endif #endif
btrfs_init_balance(fs_info);
spin_lock_init(&fs_info->balance_lock);
mutex_init(&fs_info->balance_mutex);
atomic_set(&fs_info->balance_running, 0);
atomic_set(&fs_info->balance_pause_req, 0);
atomic_set(&fs_info->balance_cancel_req, 0);
fs_info->balance_ctl = NULL;
init_waitqueue_head(&fs_info->balance_wait_q);
btrfs_init_async_reclaim_work(&fs_info->async_reclaim_work); btrfs_init_async_reclaim_work(&fs_info->async_reclaim_work);
sb->s_blocksize = 4096; sb->s_blocksize = 4096;
sb->s_blocksize_bits = blksize_bits(4096); sb->s_blocksize_bits = blksize_bits(4096);
sb->s_bdi = &fs_info->bdi; sb->s_bdi = &fs_info->bdi;
fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID; btrfs_init_btree_inode(fs_info, tree_root);
set_nlink(fs_info->btree_inode, 1);
/*
* we set the i_size on the btree inode to the max possible int.
* the real end of the address space is determined by all of
* the devices in the system
*/
fs_info->btree_inode->i_size = OFFSET_MAX;
fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
fs_info->btree_inode->i_mapping);
BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
BTRFS_I(fs_info->btree_inode)->root = tree_root;
memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
sizeof(struct btrfs_key));
set_bit(BTRFS_INODE_DUMMY,
&BTRFS_I(fs_info->btree_inode)->runtime_flags);
btrfs_insert_inode_hash(fs_info->btree_inode);
spin_lock_init(&fs_info->block_group_cache_lock); spin_lock_init(&fs_info->block_group_cache_lock);
fs_info->block_group_cache_tree = RB_ROOT; fs_info->block_group_cache_tree = RB_ROOT;
@ -2367,22 +2582,9 @@ int open_ctree(struct super_block *sb,
init_rwsem(&fs_info->cleanup_work_sem); init_rwsem(&fs_info->cleanup_work_sem);
init_rwsem(&fs_info->subvol_sem); init_rwsem(&fs_info->subvol_sem);
sema_init(&fs_info->uuid_tree_rescan_sem, 1); sema_init(&fs_info->uuid_tree_rescan_sem, 1);
fs_info->dev_replace.lock_owner = 0;
atomic_set(&fs_info->dev_replace.nesting_level, 0);
mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
mutex_init(&fs_info->dev_replace.lock_management_lock);
mutex_init(&fs_info->dev_replace.lock);
spin_lock_init(&fs_info->qgroup_lock); btrfs_init_dev_replace_locks(fs_info);
mutex_init(&fs_info->qgroup_ioctl_lock); btrfs_init_qgroup(fs_info);
fs_info->qgroup_tree = RB_ROOT;
fs_info->qgroup_op_tree = RB_ROOT;
INIT_LIST_HEAD(&fs_info->dirty_qgroups);
fs_info->qgroup_seq = 1;
fs_info->quota_enabled = 0;
fs_info->pending_quota_state = 0;
fs_info->qgroup_ulist = NULL;
mutex_init(&fs_info->qgroup_rescan_lock);
btrfs_init_free_cluster(&fs_info->meta_alloc_cluster); btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
btrfs_init_free_cluster(&fs_info->data_alloc_cluster); btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
@ -2554,75 +2756,9 @@ int open_ctree(struct super_block *sb,
max_active = fs_info->thread_pool_size; max_active = fs_info->thread_pool_size;
fs_info->workers = ret = btrfs_init_workqueues(fs_info, fs_devices);
btrfs_alloc_workqueue("worker", flags | WQ_HIGHPRI, if (ret) {
max_active, 16); err = ret;
fs_info->delalloc_workers =
btrfs_alloc_workqueue("delalloc", flags, max_active, 2);
fs_info->flush_workers =
btrfs_alloc_workqueue("flush_delalloc", flags, max_active, 0);
fs_info->caching_workers =
btrfs_alloc_workqueue("cache", flags, max_active, 0);
/*
* a higher idle thresh on the submit workers makes it much more
* likely that bios will be send down in a sane order to the
* devices
*/
fs_info->submit_workers =
btrfs_alloc_workqueue("submit", flags,
min_t(u64, fs_devices->num_devices,
max_active), 64);
fs_info->fixup_workers =
btrfs_alloc_workqueue("fixup", flags, 1, 0);
/*
* endios are largely parallel and should have a very
* low idle thresh
*/
fs_info->endio_workers =
btrfs_alloc_workqueue("endio", flags, max_active, 4);
fs_info->endio_meta_workers =
btrfs_alloc_workqueue("endio-meta", flags, max_active, 4);
fs_info->endio_meta_write_workers =
btrfs_alloc_workqueue("endio-meta-write", flags, max_active, 2);
fs_info->endio_raid56_workers =
btrfs_alloc_workqueue("endio-raid56", flags, max_active, 4);
fs_info->endio_repair_workers =
btrfs_alloc_workqueue("endio-repair", flags, 1, 0);
fs_info->rmw_workers =
btrfs_alloc_workqueue("rmw", flags, max_active, 2);
fs_info->endio_write_workers =
btrfs_alloc_workqueue("endio-write", flags, max_active, 2);
fs_info->endio_freespace_worker =
btrfs_alloc_workqueue("freespace-write", flags, max_active, 0);
fs_info->delayed_workers =
btrfs_alloc_workqueue("delayed-meta", flags, max_active, 0);
fs_info->readahead_workers =
btrfs_alloc_workqueue("readahead", flags, max_active, 2);
fs_info->qgroup_rescan_workers =
btrfs_alloc_workqueue("qgroup-rescan", flags, 1, 0);
fs_info->extent_workers =
btrfs_alloc_workqueue("extent-refs", flags,
min_t(u64, fs_devices->num_devices,
max_active), 8);
if (!(fs_info->workers && fs_info->delalloc_workers &&
fs_info->submit_workers && fs_info->flush_workers &&
fs_info->endio_workers && fs_info->endio_meta_workers &&
fs_info->endio_meta_write_workers &&
fs_info->endio_repair_workers &&
fs_info->endio_write_workers && fs_info->endio_raid56_workers &&
fs_info->endio_freespace_worker && fs_info->rmw_workers &&
fs_info->caching_workers && fs_info->readahead_workers &&
fs_info->fixup_workers && fs_info->delayed_workers &&
fs_info->extent_workers &&
fs_info->qgroup_rescan_workers)) {
err = -ENOMEM;
goto fail_sb_buffer; goto fail_sb_buffer;
} }
@ -2688,7 +2824,7 @@ int open_ctree(struct super_block *sb,
* keep the device that is marked to be the target device for the * keep the device that is marked to be the target device for the
* dev_replace procedure * dev_replace procedure
*/ */
btrfs_close_extra_devices(fs_info, fs_devices, 0); btrfs_close_extra_devices(fs_devices, 0);
if (!fs_devices->latest_bdev) { if (!fs_devices->latest_bdev) {
printk(KERN_ERR "BTRFS: failed to read devices on %s\n", printk(KERN_ERR "BTRFS: failed to read devices on %s\n",
@ -2714,61 +2850,9 @@ retry_root_backup:
tree_root->commit_root = btrfs_root_node(tree_root); tree_root->commit_root = btrfs_root_node(tree_root);
btrfs_set_root_refs(&tree_root->root_item, 1); btrfs_set_root_refs(&tree_root->root_item, 1);
location.objectid = BTRFS_EXTENT_TREE_OBJECTID; ret = btrfs_read_roots(fs_info, tree_root);
location.type = BTRFS_ROOT_ITEM_KEY; if (ret)
location.offset = 0;
extent_root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(extent_root)) {
ret = PTR_ERR(extent_root);
goto recovery_tree_root; goto recovery_tree_root;
}
set_bit(BTRFS_ROOT_TRACK_DIRTY, &extent_root->state);
fs_info->extent_root = extent_root;
location.objectid = BTRFS_DEV_TREE_OBJECTID;
dev_root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(dev_root)) {
ret = PTR_ERR(dev_root);
goto recovery_tree_root;
}
set_bit(BTRFS_ROOT_TRACK_DIRTY, &dev_root->state);
fs_info->dev_root = dev_root;
btrfs_init_devices_late(fs_info);
location.objectid = BTRFS_CSUM_TREE_OBJECTID;
csum_root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(csum_root)) {
ret = PTR_ERR(csum_root);
goto recovery_tree_root;
}
set_bit(BTRFS_ROOT_TRACK_DIRTY, &csum_root->state);
fs_info->csum_root = csum_root;
location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
quota_root = btrfs_read_tree_root(tree_root, &location);
if (!IS_ERR(quota_root)) {
set_bit(BTRFS_ROOT_TRACK_DIRTY, &quota_root->state);
fs_info->quota_enabled = 1;
fs_info->pending_quota_state = 1;
fs_info->quota_root = quota_root;
}
location.objectid = BTRFS_UUID_TREE_OBJECTID;
uuid_root = btrfs_read_tree_root(tree_root, &location);
if (IS_ERR(uuid_root)) {
ret = PTR_ERR(uuid_root);
if (ret != -ENOENT)
goto recovery_tree_root;
create_uuid_tree = true;
check_uuid_tree = false;
} else {
set_bit(BTRFS_ROOT_TRACK_DIRTY, &uuid_root->state);
fs_info->uuid_root = uuid_root;
create_uuid_tree = false;
check_uuid_tree =
generation != btrfs_super_uuid_tree_generation(disk_super);
}
fs_info->generation = generation; fs_info->generation = generation;
fs_info->last_trans_committed = generation; fs_info->last_trans_committed = generation;
@ -2792,7 +2876,7 @@ retry_root_backup:
goto fail_block_groups; goto fail_block_groups;
} }
btrfs_close_extra_devices(fs_info, fs_devices, 1); btrfs_close_extra_devices(fs_devices, 1);
ret = btrfs_sysfs_add_one(fs_info); ret = btrfs_sysfs_add_one(fs_info);
if (ret) { if (ret) {
@ -2806,7 +2890,7 @@ retry_root_backup:
goto fail_sysfs; goto fail_sysfs;
} }
ret = btrfs_read_block_groups(extent_root); ret = btrfs_read_block_groups(fs_info->extent_root);
if (ret) { if (ret) {
printk(KERN_ERR "BTRFS: Failed to read block groups: %d\n", ret); printk(KERN_ERR "BTRFS: Failed to read block groups: %d\n", ret);
goto fail_sysfs; goto fail_sysfs;
@ -2864,46 +2948,9 @@ retry_root_backup:
/* do not make disk changes in broken FS */ /* do not make disk changes in broken FS */
if (btrfs_super_log_root(disk_super) != 0) { if (btrfs_super_log_root(disk_super) != 0) {
u64 bytenr = btrfs_super_log_root(disk_super); ret = btrfs_replay_log(fs_info, fs_devices);
if (fs_devices->rw_devices == 0) {
printk(KERN_WARNING "BTRFS: log replay required "
"on RO media\n");
err = -EIO;
goto fail_qgroup;
}
log_tree_root = btrfs_alloc_root(fs_info);
if (!log_tree_root) {
err = -ENOMEM;
goto fail_qgroup;
}
__setup_root(nodesize, sectorsize, stripesize,
log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
log_tree_root->node = read_tree_block(tree_root, bytenr,
generation + 1);
if (!log_tree_root->node ||
!extent_buffer_uptodate(log_tree_root->node)) {
printk(KERN_ERR "BTRFS: failed to read log tree\n");
free_extent_buffer(log_tree_root->node);
kfree(log_tree_root);
goto fail_qgroup;
}
/* returns with log_tree_root freed on success */
ret = btrfs_recover_log_trees(log_tree_root);
if (ret) { if (ret) {
btrfs_error(tree_root->fs_info, ret, err = ret;
"Failed to recover log tree");
free_extent_buffer(log_tree_root->node);
kfree(log_tree_root);
goto fail_qgroup;
}
if (sb->s_flags & MS_RDONLY) {
ret = btrfs_commit_super(tree_root);
if (ret)
goto fail_qgroup; goto fail_qgroup;
} }
} }
@ -2966,7 +3013,7 @@ retry_root_backup:
btrfs_qgroup_rescan_resume(fs_info); btrfs_qgroup_rescan_resume(fs_info);
if (create_uuid_tree) { if (!fs_info->uuid_root) {
pr_info("BTRFS: creating UUID tree\n"); pr_info("BTRFS: creating UUID tree\n");
ret = btrfs_create_uuid_tree(fs_info); ret = btrfs_create_uuid_tree(fs_info);
if (ret) { if (ret) {
@ -2975,8 +3022,9 @@ retry_root_backup:
close_ctree(tree_root); close_ctree(tree_root);
return ret; return ret;
} }
} else if (check_uuid_tree || } else if (btrfs_test_opt(tree_root, RESCAN_UUID_TREE) ||
btrfs_test_opt(tree_root, RESCAN_UUID_TREE)) { fs_info->generation !=
btrfs_super_uuid_tree_generation(disk_super)) {
pr_info("BTRFS: checking UUID tree\n"); pr_info("BTRFS: checking UUID tree\n");
ret = btrfs_check_uuid_tree(fs_info); ret = btrfs_check_uuid_tree(fs_info);
if (ret) { if (ret) {
@ -3668,7 +3716,7 @@ void close_ctree(struct btrfs_root *root)
if (!(fs_info->sb->s_flags & MS_RDONLY)) { if (!(fs_info->sb->s_flags & MS_RDONLY)) {
ret = btrfs_commit_super(root); ret = btrfs_commit_super(root);
if (ret) if (ret)
btrfs_err(root->fs_info, "commit super ret %d", ret); btrfs_err(fs_info, "commit super ret %d", ret);
} }
if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
@ -3680,10 +3728,10 @@ void close_ctree(struct btrfs_root *root)
fs_info->closing = 2; fs_info->closing = 2;
smp_mb(); smp_mb();
btrfs_free_qgroup_config(root->fs_info); btrfs_free_qgroup_config(fs_info);
if (percpu_counter_sum(&fs_info->delalloc_bytes)) { if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
btrfs_info(root->fs_info, "at unmount delalloc count %lld", btrfs_info(fs_info, "at unmount delalloc count %lld",
percpu_counter_sum(&fs_info->delalloc_bytes)); percpu_counter_sum(&fs_info->delalloc_bytes));
} }
@ -4134,7 +4182,7 @@ static int btrfs_destroy_marked_extents(struct btrfs_root *root,
clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS); clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
while (start <= end) { while (start <= end) {
eb = btrfs_find_tree_block(root, start); eb = btrfs_find_tree_block(root->fs_info, start);
start += root->nodesize; start += root->nodesize;
if (!eb) if (!eb)
continue; continue;
@ -4285,7 +4333,7 @@ static int btrfs_cleanup_transaction(struct btrfs_root *root)
return 0; return 0;
} }
static struct extent_io_ops btree_extent_io_ops = { static const struct extent_io_ops btree_extent_io_ops = {
.readpage_end_io_hook = btree_readpage_end_io_hook, .readpage_end_io_hook = btree_readpage_end_io_hook,
.readpage_io_failed_hook = btree_io_failed_hook, .readpage_io_failed_hook = btree_io_failed_hook,
.submit_bio_hook = btree_submit_bio_hook, .submit_bio_hook = btree_submit_bio_hook,

4
fs/btrfs/disk-io.h
View File

@ -52,7 +52,7 @@ int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr,
struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root, struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
u64 bytenr); u64 bytenr);
void clean_tree_block(struct btrfs_trans_handle *trans, void clean_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct extent_buffer *buf); struct btrfs_fs_info *fs_info, struct extent_buffer *buf);
int open_ctree(struct super_block *sb, int open_ctree(struct super_block *sb,
struct btrfs_fs_devices *fs_devices, struct btrfs_fs_devices *fs_devices,
char *options); char *options);
@ -61,7 +61,7 @@ int write_ctree_super(struct btrfs_trans_handle *trans,
struct btrfs_root *root, int max_mirrors); struct btrfs_root *root, int max_mirrors);
struct buffer_head *btrfs_read_dev_super(struct block_device *bdev); struct buffer_head *btrfs_read_dev_super(struct block_device *bdev);
int btrfs_commit_super(struct btrfs_root *root); int btrfs_commit_super(struct btrfs_root *root);
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root, struct extent_buffer *btrfs_find_tree_block(struct btrfs_fs_info *fs_info,
u64 bytenr); u64 bytenr);
struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root, struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,
struct btrfs_key *location); struct btrfs_key *location);

10
fs/btrfs/extent-tree.c
View File

@ -3640,7 +3640,7 @@ int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
struct btrfs_root *root = BTRFS_I(inode)->root; struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_fs_info *fs_info = root->fs_info; struct btrfs_fs_info *fs_info = root->fs_info;
u64 used; u64 used;
int ret = 0, committed = 0, alloc_chunk = 1; int ret = 0, committed = 0;
/* make sure bytes are sectorsize aligned */ /* make sure bytes are sectorsize aligned */
bytes = ALIGN(bytes, root->sectorsize); bytes = ALIGN(bytes, root->sectorsize);
@ -3668,7 +3668,7 @@ again:
* if we don't have enough free bytes in this space then we need * if we don't have enough free bytes in this space then we need
* to alloc a new chunk. * to alloc a new chunk.
*/ */
if (!data_sinfo->full && alloc_chunk) { if (!data_sinfo->full) {
u64 alloc_target; u64 alloc_target;
data_sinfo->force_alloc = CHUNK_ALLOC_FORCE; data_sinfo->force_alloc = CHUNK_ALLOC_FORCE;
@ -7216,7 +7216,7 @@ btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root,
btrfs_set_header_generation(buf, trans->transid); btrfs_set_header_generation(buf, trans->transid);
btrfs_set_buffer_lockdep_class(root->root_key.objectid, buf, level); btrfs_set_buffer_lockdep_class(root->root_key.objectid, buf, level);
btrfs_tree_lock(buf); btrfs_tree_lock(buf);
clean_tree_block(trans, root, buf); clean_tree_block(trans, root->fs_info, buf);
clear_bit(EXTENT_BUFFER_STALE, &buf->bflags); clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);
btrfs_set_lock_blocking(buf); btrfs_set_lock_blocking(buf);
@ -7814,7 +7814,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]); bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
blocksize = root->nodesize; blocksize = root->nodesize;
next = btrfs_find_tree_block(root, bytenr); next = btrfs_find_tree_block(root->fs_info, bytenr);
if (!next) { if (!next) {
next = btrfs_find_create_tree_block(root, bytenr); next = btrfs_find_create_tree_block(root, bytenr);
if (!next) if (!next)
@ -8015,7 +8015,7 @@ static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
btrfs_set_lock_blocking(eb); btrfs_set_lock_blocking(eb);
path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING; path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
} }
clean_tree_block(trans, root, eb); clean_tree_block(trans, root->fs_info, eb);
} }
if (eb == root->node) { if (eb == root->node) {

2
fs/btrfs/extent_io.h
View File

@ -97,7 +97,7 @@ struct extent_io_tree {
u64 dirty_bytes; u64 dirty_bytes;
int track_uptodate; int track_uptodate;
spinlock_t lock; spinlock_t lock;
struct extent_io_ops *ops; const struct extent_io_ops *ops;
}; };
struct extent_state { struct extent_state {

2
fs/btrfs/file-item.c
View File

@ -553,7 +553,7 @@ static noinline void truncate_one_csum(struct btrfs_root *root,
btrfs_truncate_item(root, path, new_size, 0); btrfs_truncate_item(root, path, new_size, 0);
key->offset = end_byte; key->offset = end_byte;
btrfs_set_item_key_safe(root, path, key); btrfs_set_item_key_safe(root->fs_info, path, key);
} else { } else {
BUG(); BUG();
} }

8
fs/btrfs/file.c
View File

@ -864,7 +864,7 @@ next_slot:
memcpy(&new_key, &key, sizeof(new_key)); memcpy(&new_key, &key, sizeof(new_key));
new_key.offset = end; new_key.offset = end;
btrfs_set_item_key_safe(root, path, &new_key); btrfs_set_item_key_safe(root->fs_info, path, &new_key);
extent_offset += end - key.offset; extent_offset += end - key.offset;
btrfs_set_file_extent_offset(leaf, fi, extent_offset); btrfs_set_file_extent_offset(leaf, fi, extent_offset);
@ -1122,7 +1122,7 @@ again:
ino, bytenr, orig_offset, ino, bytenr, orig_offset,
&other_start, &other_end)) { &other_start, &other_end)) {
new_key.offset = end; new_key.offset = end;
btrfs_set_item_key_safe(root, path, &new_key); btrfs_set_item_key_safe(root->fs_info, path, &new_key);
fi = btrfs_item_ptr(leaf, path->slots[0], fi = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item); struct btrfs_file_extent_item);
btrfs_set_file_extent_generation(leaf, fi, btrfs_set_file_extent_generation(leaf, fi,
@ -1156,7 +1156,7 @@ again:
trans->transid); trans->transid);
path->slots[0]++; path->slots[0]++;
new_key.offset = start; new_key.offset = start;
btrfs_set_item_key_safe(root, path, &new_key); btrfs_set_item_key_safe(root->fs_info, path, &new_key);
fi = btrfs_item_ptr(leaf, path->slots[0], fi = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item); struct btrfs_file_extent_item);
@ -2164,7 +2164,7 @@ static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
u64 num_bytes; u64 num_bytes;
key.offset = offset; key.offset = offset;
btrfs_set_item_key_safe(root, path, &key); btrfs_set_item_key_safe(root->fs_info, path, &key);
fi = btrfs_item_ptr(leaf, path->slots[0], fi = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item); struct btrfs_file_extent_item);
num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end - num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -

2
fs/btrfs/lzo.c
View File

@ -434,7 +434,7 @@ out:
return ret; return ret;
} }
struct btrfs_compress_op btrfs_lzo_compress = { const struct btrfs_compress_op btrfs_lzo_compress = {
.alloc_workspace = lzo_alloc_workspace, .alloc_workspace = lzo_alloc_workspace,
.free_workspace = lzo_free_workspace, .free_workspace = lzo_free_workspace,
.compress_pages = lzo_compress_pages, .compress_pages = lzo_compress_pages,

2
fs/btrfs/props.c
View File

@ -425,3 +425,5 @@ static const char *prop_compression_extract(struct inode *inode)
return NULL; return NULL;
} }

2
fs/btrfs/qgroup.c
View File

@ -982,7 +982,7 @@ int btrfs_quota_disable(struct btrfs_trans_handle *trans,
list_del(&quota_root->dirty_list); list_del(&quota_root->dirty_list);
btrfs_tree_lock(quota_root->node); btrfs_tree_lock(quota_root->node);
clean_tree_block(trans, tree_root, quota_root->node); clean_tree_block(trans, tree_root->fs_info, quota_root->node);
btrfs_tree_unlock(quota_root->node); btrfs_tree_unlock(quota_root->node);
btrfs_free_tree_block(trans, quota_root, quota_root->node, 0, 1); btrfs_free_tree_block(trans, quota_root, quota_root->node, 0, 1);

13
fs/btrfs/raid56.c
View File

@ -237,12 +237,8 @@ int btrfs_alloc_stripe_hash_table(struct btrfs_fs_info *info)
} }
x = cmpxchg(&info->stripe_hash_table, NULL, table); x = cmpxchg(&info->stripe_hash_table, NULL, table);
if (x) { if (x)
if (is_vmalloc_addr(x)) kvfree(x);
vfree(x);
else
kfree(x);
}
return 0; return 0;
} }
@ -453,10 +449,7 @@ void btrfs_free_stripe_hash_table(struct btrfs_fs_info *info)
if (!info->stripe_hash_table) if (!info->stripe_hash_table)
return; return;
btrfs_clear_rbio_cache(info); btrfs_clear_rbio_cache(info);
if (is_vmalloc_addr(info->stripe_hash_table)) kvfree(info->stripe_hash_table);
vfree(info->stripe_hash_table);
else
kfree(info->stripe_hash_table);
info->stripe_hash_table = NULL; info->stripe_hash_table = NULL;
} }

2
fs/btrfs/scrub.c
View File

@ -3560,7 +3560,7 @@ static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info,
int is_dev_replace) int is_dev_replace)
{ {
int ret = 0; int ret = 0;
int flags = WQ_FREEZABLE | WQ_UNBOUND; unsigned int flags = WQ_FREEZABLE | WQ_UNBOUND;
int max_active = fs_info->thread_pool_size; int max_active = fs_info->thread_pool_size;
if (fs_info->scrub_workers_refcnt == 0) { if (fs_info->scrub_workers_refcnt == 0) {

2
fs/btrfs/sysfs.c
View File

@ -459,7 +459,7 @@ static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj)
static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13]; static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13];
static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS]; static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS];
static u64 supported_feature_masks[3] = { static const u64 supported_feature_masks[3] = {
[FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP, [FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP,
[FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP, [FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP,
[FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP, [FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP,

2
fs/btrfs/transaction.c
View File

@ -35,7 +35,7 @@
#define BTRFS_ROOT_TRANS_TAG 0 #define BTRFS_ROOT_TRANS_TAG 0
static unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
[TRANS_STATE_RUNNING] = 0U, [TRANS_STATE_RUNNING] = 0U,
[TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE | [TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE |
__TRANS_START), __TRANS_START),

8
fs/btrfs/tree-log.c
View File

@ -2230,7 +2230,8 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
if (trans) { if (trans) {
btrfs_tree_lock(next); btrfs_tree_lock(next);
btrfs_set_lock_blocking(next); btrfs_set_lock_blocking(next);
clean_tree_block(trans, root, next); clean_tree_block(trans, root->fs_info,
next);
btrfs_wait_tree_block_writeback(next); btrfs_wait_tree_block_writeback(next);
btrfs_tree_unlock(next); btrfs_tree_unlock(next);
} }
@ -2308,7 +2309,8 @@ static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
if (trans) { if (trans) {
btrfs_tree_lock(next); btrfs_tree_lock(next);
btrfs_set_lock_blocking(next); btrfs_set_lock_blocking(next);
clean_tree_block(trans, root, next); clean_tree_block(trans, root->fs_info,
next);
btrfs_wait_tree_block_writeback(next); btrfs_wait_tree_block_writeback(next);
btrfs_tree_unlock(next); btrfs_tree_unlock(next);
} }
@ -2384,7 +2386,7 @@ static int walk_log_tree(struct btrfs_trans_handle *trans,
if (trans) { if (trans) {
btrfs_tree_lock(next); btrfs_tree_lock(next);
btrfs_set_lock_blocking(next); btrfs_set_lock_blocking(next);
clean_tree_block(trans, log, next); clean_tree_block(trans, log->fs_info, next);
btrfs_wait_tree_block_writeback(next); btrfs_wait_tree_block_writeback(next);
btrfs_tree_unlock(next); btrfs_tree_unlock(next);
} }

32
fs/btrfs/volumes.c
View File

@ -608,8 +608,7 @@ error:
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info, void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step)
struct btrfs_fs_devices *fs_devices, int step)
{ {
struct btrfs_device *device, *next; struct btrfs_device *device, *next;
struct btrfs_device *latest_dev = NULL; struct btrfs_device *latest_dev = NULL;
@ -2486,8 +2485,7 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans,
} }
static int btrfs_free_chunk(struct btrfs_trans_handle *trans, static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct btrfs_root *root, u64 chunk_objectid,
u64 chunk_tree, u64 chunk_objectid,
u64 chunk_offset) u64 chunk_offset)
{ {
int ret; int ret;
@ -2579,7 +2577,6 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
struct map_lookup *map; struct map_lookup *map;
u64 dev_extent_len = 0; u64 dev_extent_len = 0;
u64 chunk_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; u64 chunk_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
u64 chunk_tree = root->fs_info->chunk_root->objectid;
int i, ret = 0; int i, ret = 0;
/* Just in case */ /* Just in case */
@ -2633,8 +2630,7 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
} }
} }
} }
ret = btrfs_free_chunk(trans, root, chunk_tree, chunk_objectid, ret = btrfs_free_chunk(trans, root, chunk_objectid, chunk_offset);
chunk_offset);
if (ret) { if (ret) {
btrfs_abort_transaction(trans, root, ret); btrfs_abort_transaction(trans, root, ret);
goto out; goto out;
@ -2663,7 +2659,7 @@ out:
} }
static int btrfs_relocate_chunk(struct btrfs_root *root, static int btrfs_relocate_chunk(struct btrfs_root *root,
u64 chunk_tree, u64 chunk_objectid, u64 chunk_objectid,
u64 chunk_offset) u64 chunk_offset)
{ {
struct btrfs_root *extent_root; struct btrfs_root *extent_root;
@ -2706,7 +2702,6 @@ static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
struct btrfs_chunk *chunk; struct btrfs_chunk *chunk;
struct btrfs_key key; struct btrfs_key key;
struct btrfs_key found_key; struct btrfs_key found_key;
u64 chunk_tree = chunk_root->root_key.objectid;
u64 chunk_type; u64 chunk_type;
bool retried = false; bool retried = false;
int failed = 0; int failed = 0;
@ -2743,7 +2738,7 @@ again:
btrfs_release_path(path); btrfs_release_path(path);
if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) { if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
ret = btrfs_relocate_chunk(chunk_root, chunk_tree, ret = btrfs_relocate_chunk(chunk_root,
found_key.objectid, found_key.objectid,
found_key.offset); found_key.offset);
if (ret == -ENOSPC) if (ret == -ENOSPC)
@ -3254,7 +3249,6 @@ again:
} }
ret = btrfs_relocate_chunk(chunk_root, ret = btrfs_relocate_chunk(chunk_root,
chunk_root->root_key.objectid,
found_key.objectid, found_key.objectid,
found_key.offset); found_key.offset);
if (ret && ret != -ENOSPC) if (ret && ret != -ENOSPC)
@ -3956,7 +3950,6 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
struct btrfs_dev_extent *dev_extent = NULL; struct btrfs_dev_extent *dev_extent = NULL;
struct btrfs_path *path; struct btrfs_path *path;
u64 length; u64 length;
u64 chunk_tree;
u64 chunk_objectid; u64 chunk_objectid;
u64 chunk_offset; u64 chunk_offset;
int ret; int ret;
@ -4026,13 +4019,11 @@ again:
break; break;
} }
chunk_tree = btrfs_dev_extent_chunk_tree(l, dev_extent);
chunk_objectid = btrfs_dev_extent_chunk_objectid(l, dev_extent); chunk_objectid = btrfs_dev_extent_chunk_objectid(l, dev_extent);
chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent); chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent);
btrfs_release_path(path); btrfs_release_path(path);
ret = btrfs_relocate_chunk(root, chunk_tree, chunk_objectid, ret = btrfs_relocate_chunk(root, chunk_objectid, chunk_offset);
chunk_offset);
if (ret && ret != -ENOSPC) if (ret && ret != -ENOSPC)
goto done; goto done;
if (ret == -ENOSPC) if (ret == -ENOSPC)
@ -4130,7 +4121,7 @@ static int btrfs_cmp_device_info(const void *a, const void *b)
return 0; return 0;
} }
static struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = { static const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = {
[BTRFS_RAID_RAID10] = { [BTRFS_RAID_RAID10] = {
.sub_stripes = 2, .sub_stripes = 2,
.dev_stripes = 1, .dev_stripes = 1,
@ -5833,8 +5824,8 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
u64 length = 0; u64 length = 0;
u64 map_length; u64 map_length;
int ret; int ret;
int dev_nr = 0; int dev_nr;
int total_devs = 1; int total_devs;
struct btrfs_bio *bbio = NULL; struct btrfs_bio *bbio = NULL;
length = bio->bi_iter.bi_size; length = bio->bi_iter.bi_size;
@ -5875,11 +5866,10 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
BUG(); BUG();
} }
while (dev_nr < total_devs) { for (dev_nr = 0; dev_nr < total_devs; dev_nr++) {
dev = bbio->stripes[dev_nr].dev; dev = bbio->stripes[dev_nr].dev;
if (!dev || !dev->bdev || (rw & WRITE && !dev->writeable)) { if (!dev || !dev->bdev || (rw & WRITE && !dev->writeable)) {
bbio_error(bbio, first_bio, logical); bbio_error(bbio, first_bio, logical);
dev_nr++;
continue; continue;
} }
@ -5892,7 +5882,6 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
ret = breakup_stripe_bio(root, bbio, first_bio, dev, ret = breakup_stripe_bio(root, bbio, first_bio, dev,
dev_nr, rw, async_submit); dev_nr, rw, async_submit);
BUG_ON(ret); BUG_ON(ret);
dev_nr++;
continue; continue;
} }
@ -5907,7 +5896,6 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
submit_stripe_bio(root, bbio, bio, submit_stripe_bio(root, bbio, bio,
bbio->stripes[dev_nr].physical, dev_nr, rw, bbio->stripes[dev_nr].physical, dev_nr, rw,
async_submit); async_submit);
dev_nr++;
} }
btrfs_bio_counter_dec(root->fs_info); btrfs_bio_counter_dec(root->fs_info);
return 0; return 0;

3
fs/btrfs/volumes.h
View File

@ -421,8 +421,7 @@ int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder, int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
struct btrfs_fs_devices **fs_devices_ret); struct btrfs_fs_devices **fs_devices_ret);
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices); int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info, void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step);
struct btrfs_fs_devices *fs_devices, int step);
int btrfs_find_device_missing_or_by_path(struct btrfs_root *root, int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
char *device_path, char *device_path,
struct btrfs_device **device); struct btrfs_device **device);

2
fs/btrfs/zlib.c
View File

@ -403,7 +403,7 @@ next:
return ret; return ret;
} }
struct btrfs_compress_op btrfs_zlib_compress = { const struct btrfs_compress_op btrfs_zlib_compress = {
.alloc_workspace = zlib_alloc_workspace, .alloc_workspace = zlib_alloc_workspace,
.free_workspace = zlib_free_workspace, .free_workspace = zlib_free_workspace,
.compress_pages = zlib_compress_pages, .compress_pages = zlib_compress_pages,