Skip to content

cloud-kernel
cloud-kernel

bug2833 / cloud-kernel
与 Fork 源项目一致

Fork自 openanolis / cloud-kernel

通知 1
Star 0
Fork 0
cloud-kernel
cloud-kernel

体验新版 GitCode，发现更多精彩内容 >>

提交 d397712b 编写于 作者: C Chris Mason
浏览文件
操作

Btrfs: Fix checkpatch.pl warnings 

There were many, most are fixed now.  struct-funcs.c generates some warnings
but these are bogus.
Signed-off-by: NChris Mason <chris.mason@oracle.com>
上级 1f3c79a2
展开全部 隐藏空白更改
内联 并排
Showing with 770 addition and 898 deletion
fs/btrfs/acl.c
浏览文件 @ d397712b
......@@ -161,8 +161,7 @@ static int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
ret = __btrfs_setxattr(inode, name, value, size, 0);
out:
if (value)
kfree(value);
kfree(value);
if (!ret)
btrfs_update_cached_acl(inode, p_acl, acl);
......@@ -213,7 +212,7 @@ static int btrfs_xattr_acl_default_get(struct inode *inode, const char *name,
}
static int btrfs_xattr_acl_default_set(struct inode *inode, const char *name,
const void *value, size_t size, int flags)
const void *value, size_t size, int flags)
{
return btrfs_xattr_set_acl(inode, ACL_TYPE_DEFAULT, value, size);
}
......
fs/btrfs/async-thread.c
浏览文件 @ d397712b
......@@ -104,7 +104,7 @@ static noinline int run_ordered_completions(struct btrfs_workers *workers,
spin_lock_irqsave(&workers->lock, flags);
while(!list_empty(&workers->order_list)) {
while (!list_empty(&workers->order_list)) {
work = list_entry(workers->order_list.next,
struct btrfs_work, order_list);
......@@ -143,7 +143,7 @@ static int worker_loop(void *arg)
struct btrfs_work *work;
do {
spin_lock_irq(&worker->lock);
while(!list_empty(&worker->pending)) {
while (!list_empty(&worker->pending)) {
cur = worker->pending.next;
work = list_entry(cur, struct btrfs_work, list);
list_del(&work->list);
......@@ -188,7 +188,7 @@ int btrfs_stop_workers(struct btrfs_workers *workers)
struct btrfs_worker_thread *worker;
list_splice_init(&workers->idle_list, &workers->worker_list);
while(!list_empty(&workers->worker_list)) {
while (!list_empty(&workers->worker_list)) {
cur = workers->worker_list.next;
worker = list_entry(cur, struct btrfs_worker_thread,
worker_list);
......
fs/btrfs/compat.h
浏览文件 @ d397712b
......@@ -4,7 +4,7 @@
#define btrfs_drop_nlink(inode) drop_nlink(inode)
#define btrfs_inc_nlink(inode) inc_nlink(inode)
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27)
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 27)
static inline struct dentry *d_obtain_alias(struct inode *inode)
{
struct dentry *d;
......@@ -21,7 +21,7 @@ static inline struct dentry *d_obtain_alias(struct inode *inode)
}
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 28)
# define __pagevec_lru_add_file __pagevec_lru_add
# define open_bdev_exclusive open_bdev_excl
# define close_bdev_exclusive(bdev, mode) close_bdev_excl(bdev)
......
fs/btrfs/compression.c
浏览文件 @ d397712b
......@@ -137,7 +137,8 @@ static int check_compressed_csum(struct inode *inode,
kunmap_atomic(kaddr, KM_USER0);
if (csum != *cb_sum) {
printk("btrfs csum failed ino %lu extent %llu csum %u "
printk(KERN_INFO "btrfs csum failed ino %lu "
"extent %llu csum %u "
"wanted %u mirror %d\n", inode->i_ino,
(unsigned long long)disk_start,
csum, *cb_sum, cb->mirror_num);
......@@ -217,7 +218,7 @@ static void end_compressed_bio_read(struct bio *bio, int err)
* we have verified the checksum already, set page
* checked so the end_io handlers know about it
*/
while(bio_index < cb->orig_bio->bi_vcnt) {
while (bio_index < cb->orig_bio->bi_vcnt) {
SetPageChecked(bvec->bv_page);
bvec++;
bio_index++;
......@@ -246,7 +247,7 @@ static noinline int end_compressed_writeback(struct inode *inode, u64 start,
int i;
int ret;
while(nr_pages > 0) {
while (nr_pages > 0) {
ret = find_get_pages_contig(inode->i_mapping, index,
min_t(unsigned long,
nr_pages, ARRAY_SIZE(pages)), pages);
......@@ -463,7 +464,7 @@ static noinline int add_ra_bio_pages(struct inode *inode,
end_index = (i_size_read(inode) - 1) >> PAGE_CACHE_SHIFT;
pagevec_init(&pvec, 0);
while(last_offset < compressed_end) {
while (last_offset < compressed_end) {
page_index = last_offset >> PAGE_CACHE_SHIFT;
if (page_index > end_index)
......@@ -697,9 +698,8 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0);
BUG_ON(ret);
if (!btrfs_test_flag(inode, NODATASUM)) {
if (!btrfs_test_flag(inode, NODATASUM))
btrfs_lookup_bio_sums(root, inode, comp_bio, sums);
}
ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0);
BUG_ON(ret);
......
fs/btrfs/ctree.c
浏览文件 @ d397712b
......@@ -67,7 +67,7 @@ void btrfs_free_path(struct btrfs_path *p)
*
* It is safe to call this on paths that no locks or extent buffers held.
*/
void noinline btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
noinline void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
{
int i;
......@@ -112,7 +112,7 @@ struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root)
{
struct extent_buffer *eb;
while(1) {
while (1) {
eb = btrfs_root_node(root);
btrfs_tree_lock(eb);
......@@ -202,22 +202,22 @@ int btrfs_copy_root(struct btrfs_trans_handle *trans,
}
/*
* does the dirty work in cow of a single block. The parent block
* (if supplied) is updated to point to the new cow copy. The new
* buffer is marked dirty and returned locked. If you modify the block
* it needs to be marked dirty again.
* does the dirty work in cow of a single block. The parent block (if
* supplied) is updated to point to the new cow copy. The new buffer is marked
* dirty and returned locked. If you modify the block it needs to be marked
* dirty again.
*
* search_start -- an allocation hint for the new block
*
* empty_size -- a hint that you plan on doing more cow. This is the size in bytes
* the allocator should try to find free next to the block it returns. This is
* just a hint and may be ignored by the allocator.
* empty_size -- a hint that you plan on doing more cow. This is the size in
* bytes the allocator should try to find free next to the block it returns.
* This is just a hint and may be ignored by the allocator.
*
* prealloc_dest -- if you have already reserved a destination for the cow,
* this uses that block instead of allocating a new one. btrfs_alloc_reserved_extent
* is used to finish the allocation.
* this uses that block instead of allocating a new one.
* btrfs_alloc_reserved_extent is used to finish the allocation.
*/
static int noinline __btrfs_cow_block(struct btrfs_trans_handle *trans,
static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct extent_buffer *buf,
struct extent_buffer *parent, int parent_slot,
......@@ -366,7 +366,7 @@ static int noinline __btrfs_cow_block(struct btrfs_trans_handle *trans,
* This version of it has extra checks so that a block isn't cow'd more than
* once per transaction, as long as it hasn't been written yet
*/
int noinline btrfs_cow_block(struct btrfs_trans_handle *trans,
noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct extent_buffer *buf,
struct extent_buffer *parent, int parent_slot,
struct extent_buffer **cow_ret, u64 prealloc_dest)
......@@ -375,13 +375,16 @@ int noinline btrfs_cow_block(struct btrfs_trans_handle *trans,
int ret;
if (trans->transaction != root->fs_info->running_transaction) {
printk(KERN_CRIT "trans %Lu running %Lu\n", trans->transid,
printk(KERN_CRIT "trans %llu running %llu\n",
(unsigned long long)trans->transid,
(unsigned long long)
root->fs_info->running_transaction->transid);
WARN_ON(1);
}
if (trans->transid != root->fs_info->generation) {
printk(KERN_CRIT "trans %Lu running %Lu\n", trans->transid,
root->fs_info->generation);
printk(KERN_CRIT "trans %llu running %llu\n",
(unsigned long long)trans->transid,
(unsigned long long)root->fs_info->generation);
WARN_ON(1);
}
......@@ -489,16 +492,10 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
if (cache_only && parent_level != 1)
return 0;
if (trans->transaction != root->fs_info->running_transaction) {
printk(KERN_CRIT "trans %Lu running %Lu\n", trans->transid,
root->fs_info->running_transaction->transid);
if (trans->transaction != root->fs_info->running_transaction)
WARN_ON(1);
}
if (trans->transid != root->fs_info->generation) {
printk(KERN_CRIT "trans %Lu running %Lu\n", trans->transid,
root->fs_info->generation);
if (trans->transid != root->fs_info->generation)
WARN_ON(1);
}
parent_nritems = btrfs_header_nritems(parent);
blocksize = btrfs_level_size(root, parent_level - 1);
......@@ -681,51 +678,18 @@ static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
btrfs_header_bytenr(leaf));
}
#if 0
for (i = 0; nritems > 1 && i < nritems - 2; i++) {
btrfs_item_key_to_cpu(leaf, &cpukey, i + 1);
btrfs_item_key(leaf, &leaf_key, i);
if (comp_keys(&leaf_key, &cpukey) >= 0) {
btrfs_print_leaf(root, leaf);
printk("slot %d offset bad key\n", i);
BUG_ON(1);
}
if (btrfs_item_offset_nr(leaf, i) !=
btrfs_item_end_nr(leaf, i + 1)) {
btrfs_print_leaf(root, leaf);
printk("slot %d offset bad\n", i);
BUG_ON(1);
}
if (i == 0) {
if (btrfs_item_offset_nr(leaf, i) +
btrfs_item_size_nr(leaf, i) !=
BTRFS_LEAF_DATA_SIZE(root)) {
btrfs_print_leaf(root, leaf);
printk("slot %d first offset bad\n", i);
BUG_ON(1);
}
}
}
if (nritems > 0) {
if (btrfs_item_size_nr(leaf, nritems - 1) > 4096) {
btrfs_print_leaf(root, leaf);
printk("slot %d bad size \n", nritems - 1);
BUG_ON(1);
}
}
#endif
if (slot != 0 && slot < nritems - 1) {
btrfs_item_key(leaf, &leaf_key, slot);
btrfs_item_key_to_cpu(leaf, &cpukey, slot - 1);
if (comp_keys(&leaf_key, &cpukey) <= 0) {
btrfs_print_leaf(root, leaf);
printk("slot %d offset bad key\n", slot);
printk(KERN_CRIT "slot %d offset bad key\n", slot);
BUG_ON(1);
}
if (btrfs_item_offset_nr(leaf, slot - 1) !=
btrfs_item_end_nr(leaf, slot)) {
btrfs_print_leaf(root, leaf);
printk("slot %d offset bad\n", slot);
printk(KERN_CRIT "slot %d offset bad\n", slot);
BUG_ON(1);
}
}
......@@ -736,7 +700,7 @@ static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
if (btrfs_item_offset_nr(leaf, slot) !=
btrfs_item_end_nr(leaf, slot + 1)) {
btrfs_print_leaf(root, leaf);
printk("slot %d offset bad\n", slot);
printk(KERN_CRIT "slot %d offset bad\n", slot);
BUG_ON(1);
}
}
......@@ -745,30 +709,10 @@ static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
return 0;
}
static int noinline check_block(struct btrfs_root *root,
static noinline int check_block(struct btrfs_root *root,
struct btrfs_path *path, int level)
{
u64 found_start;
return 0;
if (btrfs_header_level(path->nodes[level]) != level)
printk("warning: bad level %Lu wanted %d found %d\n",
path->nodes[level]->start, level,
btrfs_header_level(path->nodes[level]));
found_start = btrfs_header_bytenr(path->nodes[level]);
if (found_start != path->nodes[level]->start) {
printk("warning: bad bytentr %Lu found %Lu\n",
path->nodes[level]->start, found_start);
}
#if 0
struct extent_buffer *buf = path->nodes[level];
if (memcmp_extent_buffer(buf, root->fs_info->fsid,
(unsigned long)btrfs_header_fsid(buf),
BTRFS_FSID_SIZE)) {
printk("warning bad block %Lu\n", buf->start);
return 1;
}
#endif
if (level == 0)
return check_leaf(root, path, level);
return check_node(root, path, level);
......@@ -802,7 +746,7 @@ static noinline int generic_bin_search(struct extent_buffer *eb,
unsigned long map_len = 0;
int err;
while(low < high) {
while (low < high) {
mid = (low + high) / 2;
offset = p + mid * item_size;
......@@ -1130,7 +1074,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
* when they are completely full. This is also done top down, so we
* have to be pessimistic.
*/
static int noinline push_nodes_for_insert(struct btrfs_trans_handle *trans,
static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_path *path, int level)
{
......@@ -1296,7 +1240,7 @@ static noinline void reada_for_search(struct btrfs_root *root,
nritems = btrfs_header_nritems(node);
nr = slot;
while(1) {
while (1) {
if (direction < 0) {
if (nr == 0)
break;
......@@ -1322,7 +1266,8 @@ static noinline void reada_for_search(struct btrfs_root *root,
nscan++;
if (path->reada < 2 && (nread > (64 * 1024) || nscan > 32))
break;
if(nread > (256 * 1024) || nscan > 128)
if (nread > (256 * 1024) || nscan > 128)
break;
if (search < lowest_read)
......@@ -1333,17 +1278,17 @@ static noinline void reada_for_search(struct btrfs_root *root,
}
/*
* when we walk down the tree, it is usually safe to unlock the higher layers in
* the tree. The exceptions are when our path goes through slot 0, because operations
* on the tree might require changing key pointers higher up in the tree.
* when we walk down the tree, it is usually safe to unlock the higher layers
* in the tree. The exceptions are when our path goes through slot 0, because
* operations on the tree might require changing key pointers higher up in the
* tree.
*
* callers might also have set path->keep_locks, which tells this code to
* keep the lock if the path points to the last slot in the block. This is
* part of walking through the tree, and selecting the next slot in the higher
* block.
* callers might also have set path->keep_locks, which tells this code to keep
* the lock if the path points to the last slot in the block. This is part of
* walking through the tree, and selecting the next slot in the higher block.
*
* lowest_unlock sets the lowest level in the tree we're allowed to unlock.
* so if lowest_unlock is 1, level 0 won't be unlocked
* lowest_unlock sets the lowest level in the tree we're allowed to unlock. so
* if lowest_unlock is 1, level 0 won't be unlocked
*/
static noinline void unlock_up(struct btrfs_path *path, int level,
int lowest_unlock)
......@@ -1832,9 +1777,8 @@ static int push_node_left(struct btrfs_trans_handle *trans,
if (!empty && src_nritems <= 8)
return 1;
if (push_items <= 0) {
if (push_items <= 0)
return 1;
}
if (empty) {
push_items = min(src_nritems, push_items);
......@@ -1854,7 +1798,7 @@ static int push_node_left(struct btrfs_trans_handle *trans,
copy_extent_buffer(dst, src,
btrfs_node_key_ptr_offset(dst_nritems),
btrfs_node_key_ptr_offset(0),
push_items * sizeof(struct btrfs_key_ptr));
push_items * sizeof(struct btrfs_key_ptr));
if (push_items < src_nritems) {
memmove_extent_buffer(src, btrfs_node_key_ptr_offset(0),
......@@ -1899,19 +1843,16 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
src_nritems = btrfs_header_nritems(src);
dst_nritems = btrfs_header_nritems(dst);
push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
if (push_items <= 0) {
if (push_items <= 0)
return 1;
}
if (src_nritems < 4) {
if (src_nritems < 4)
return 1;
}
max_push = src_nritems / 2 + 1;
/* don't try to empty the node */
if (max_push >= src_nritems) {
if (max_push >= src_nritems)
return 1;
}
if (max_push < push_items)
push_items = max_push;
......@@ -1924,7 +1865,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
copy_extent_buffer(dst, src,
btrfs_node_key_ptr_offset(0),
btrfs_node_key_ptr_offset(src_nritems - push_items),
push_items * sizeof(struct btrfs_key_ptr));
push_items * sizeof(struct btrfs_key_ptr));
btrfs_set_header_nritems(src, src_nritems - push_items);
btrfs_set_header_nritems(dst, dst_nritems + push_items);
......@@ -1945,7 +1886,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
*
* returns zero on success or < 0 on failure.
*/
static int noinline insert_new_root(struct btrfs_trans_handle *trans,
static noinline int insert_new_root(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_path *path, int level)
{
......@@ -2176,14 +2117,15 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr)
* the start of the leaf data. IOW, how much room
* the leaf has left for both items and data
*/
int noinline btrfs_leaf_free_space(struct btrfs_root *root,
noinline int btrfs_leaf_free_space(struct btrfs_root *root,
struct extent_buffer *leaf)
{
int nritems = btrfs_header_nritems(leaf);
int ret;
ret = BTRFS_LEAF_DATA_SIZE(root) - leaf_space_used(leaf, 0, nritems);
if (ret < 0) {
printk("leaf free space ret %d, leaf data size %lu, used %d nritems %d\n",
printk(KERN_CRIT "leaf free space ret %d, leaf data size %lu, "
"used %d nritems %d\n",
ret, (unsigned long) BTRFS_LEAF_DATA_SIZE(root),
leaf_space_used(leaf, 0, nritems), nritems);
}
......@@ -2219,9 +2161,9 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
int ret;
slot = path->slots[1];
if (!path->nodes[1]) {
if (!path->nodes[1])
return 1;
}
upper = path->nodes[1];
if (slot >= btrfs_header_nritems(upper) - 1)
return 1;
......@@ -2418,9 +2360,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
return 1;
right_nritems = btrfs_header_nritems(right);
if (right_nritems == 0) {
if (right_nritems == 0)
return 1;
}
WARN_ON(!btrfs_tree_locked(path->nodes[1]));
......@@ -2502,7 +2443,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
push_items * sizeof(struct btrfs_item));
push_space = BTRFS_LEAF_DATA_SIZE(root) -
btrfs_item_offset_nr(right, push_items -1);
btrfs_item_offset_nr(right, push_items - 1);
copy_extent_buffer(left, right, btrfs_leaf_data(left) +
leaf_data_end(root, left) - push_space,
......@@ -2537,7 +2478,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
/* fixup right node */
if (push_items > right_nritems) {
printk("push items %d nr %u\n", push_items, right_nritems);
printk(KERN_CRIT "push items %d nr %u\n", push_items,
right_nritems);
WARN_ON(1);
}
......@@ -2640,9 +2582,8 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
/* first try to make some room by pushing left and right */
if (data_size && ins_key->type != BTRFS_DIR_ITEM_KEY) {
wret = push_leaf_right(trans, root, path, data_size, 0);
if (wret < 0) {
if (wret < 0)
return wret;
}
if (wret) {
wret = push_leaf_left(trans, root, path, data_size, 0);
if (wret < 0)
......@@ -2665,7 +2606,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
l = path->nodes[0];
slot = path->slots[0];
nritems = btrfs_header_nritems(l);
mid = (nritems + 1)/ 2;
mid = (nritems + 1) / 2;
right = btrfs_alloc_free_block(trans, root, root->leafsize,
path->nodes[1]->start,
......@@ -2734,7 +2675,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
path->slots[0] = 0;
if (path->slots[1] == 0) {
wret = fixup_low_keys(trans, root,
path, &disk_key, 1);
path, &disk_key, 1);
if (wret)
ret = wret;
}
......@@ -3033,8 +2974,8 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
BTRFS_FILE_EXTENT_INLINE) {
ptr = btrfs_item_ptr_offset(leaf, slot);
memmove_extent_buffer(leaf, ptr,
(unsigned long)fi,
offsetof(struct btrfs_file_extent_item,
(unsigned long)fi,
offsetof(struct btrfs_file_extent_item,
disk_bytenr));
}
}
......@@ -3096,7 +3037,8 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans,
BUG_ON(slot < 0);
if (slot >= nritems) {
btrfs_print_leaf(root, leaf);
printk("slot %d too large, nritems %d\n", slot, nritems);
printk(KERN_CRIT "slot %d too large, nritems %d\n",
slot, nritems);
BUG_ON(1);
}
......@@ -3218,7 +3160,7 @@ int btrfs_insert_some_items(struct btrfs_trans_handle *trans,
if (old_data < data_end) {
btrfs_print_leaf(root, leaf);
printk("slot %d old_data %d data_end %d\n",
printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
slot, old_data, data_end);
BUG_ON(1);
}
......@@ -3317,9 +3259,8 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
unsigned int data_end;
struct btrfs_disk_key disk_key;
for (i = 0; i < nr; i++) {
for (i = 0; i < nr; i++)
total_data += data_size[i];
}
total_size = total_data + (nr * sizeof(struct btrfs_item));
ret = btrfs_search_slot(trans, root, cpu_key, path, total_size, 1);
......@@ -3336,7 +3277,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
if (btrfs_leaf_free_space(root, leaf) < total_size) {
btrfs_print_leaf(root, leaf);
printk("not enough freespace need %u have %d\n",
printk(KERN_CRIT "not enough freespace need %u have %d\n",
total_size, btrfs_leaf_free_space(root, leaf));
BUG();
}
......@@ -3349,7 +3290,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
if (old_data < data_end) {
btrfs_print_leaf(root, leaf);
printk("slot %d old_data %d data_end %d\n",
printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
slot, old_data, data_end);
BUG_ON(1);
}
......@@ -3457,7 +3398,7 @@ static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
int wret;
nritems = btrfs_header_nritems(parent);
if (slot != nritems -1) {
if (slot != nritems - 1) {
memmove_extent_buffer(parent,
btrfs_node_key_ptr_offset(slot),
btrfs_node_key_ptr_offset(slot + 1),
......@@ -3614,7 +3555,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
if (btrfs_header_nritems(leaf) == 0) {
path->slots[1] = slot;
ret = btrfs_del_leaf(trans, root, path, leaf->start);
ret = btrfs_del_leaf(trans, root, path,
leaf->start);
BUG_ON(ret);
free_extent_buffer(leaf);
} else {
......@@ -3717,7 +3659,7 @@ int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
ret = 1;
goto out;
}
while(1) {
while (1) {
nritems = btrfs_header_nritems(cur);
level = btrfs_header_level(cur);
sret = bin_search(cur, min_key, level, &slot);
......@@ -3738,7 +3680,7 @@ int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
* min_trans parameters. If it isn't in cache or is too
* old, skip to the next one.
*/
while(slot < nritems) {
while (slot < nritems) {
u64 blockptr;
u64 gen;
struct extent_buffer *tmp;
......@@ -3830,7 +3772,7 @@ int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
struct extent_buffer *c;
WARN_ON(!path->keep_locks);
while(level < BTRFS_MAX_LEVEL) {
while (level < BTRFS_MAX_LEVEL) {
if (!path->nodes[level])
return 1;
......@@ -3839,9 +3781,8 @@ int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
next:
if (slot >= btrfs_header_nritems(c)) {
level++;
if (level == BTRFS_MAX_LEVEL) {
if (level == BTRFS_MAX_LEVEL)
return 1;
}
continue;
}
if (level == 0)
......@@ -3889,9 +3830,8 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
int ret;
nritems = btrfs_header_nritems(path->nodes[0]);
if (nritems == 0) {
if (nritems == 0)
return 1;
}
btrfs_item_key_to_cpu(path->nodes[0], &key, nritems - 1);
......@@ -3915,7 +3855,7 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
goto done;
}
while(level < BTRFS_MAX_LEVEL) {
while (level < BTRFS_MAX_LEVEL) {
if (!path->nodes[level])
return 1;
......@@ -3923,9 +3863,8 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
c = path->nodes[level];
if (slot >= btrfs_header_nritems(c)) {
level++;
if (level == BTRFS_MAX_LEVEL) {
if (level == BTRFS_MAX_LEVEL)
return 1;
}
continue;
}
......@@ -3946,7 +3885,7 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
break;
}
path->slots[level] = slot;
while(1) {
while (1) {
level--;
c = path->nodes[level];
if (path->locks[level])
......@@ -3986,7 +3925,7 @@ int btrfs_previous_item(struct btrfs_root *root,
u32 nritems;
int ret;
while(1) {
while (1) {
if (path->slots[0] == 0) {
ret = btrfs_prev_leaf(root, path);
if (ret != 0)
......
fs/btrfs/ctree.h
浏览文件 @ d397712b
......@@ -126,7 +126,6 @@ struct btrfs_ordered_sum;
static int btrfs_csum_sizes[] = { 4, 0 };
/* four bytes for CRC32 */
//#define BTRFS_CRC32_SIZE 4
#define BTRFS_EMPTY_DIR_SIZE 0
#define BTRFS_FT_UNKNOWN 0
......@@ -283,8 +282,8 @@ struct btrfs_header {
} __attribute__ ((__packed__));
#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
sizeof(struct btrfs_header)) / \
sizeof(struct btrfs_key_ptr))
sizeof(struct btrfs_header)) / \
sizeof(struct btrfs_key_ptr))
#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
......@@ -1512,7 +1511,7 @@ static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb)
static inline int btrfs_is_leaf(struct extent_buffer *eb)
{
return (btrfs_header_level(eb) == 0);
return btrfs_header_level(eb) == 0;
}
/* struct btrfs_root_item */
......@@ -1597,8 +1596,8 @@ static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
/* struct btrfs_file_extent_item */
BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
static inline unsigned long btrfs_file_extent_inline_start(struct
btrfs_file_extent_item *e)
static inline unsigned long
btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
{
unsigned long offset = (unsigned long)e;
offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
......@@ -1660,20 +1659,20 @@ static inline int btrfs_set_root_name(struct btrfs_root *root,
const char *name, int len)
{
/* if we already have a name just free it */
if (root->name)
kfree(root->name);
kfree(root->name);
root->name = kmalloc(len+1, GFP_KERNEL);
if (!root->name)
return -ENOMEM;
memcpy(root->name, name, len);
root->name[len] ='\0';
root->name[len] = '\0';
return 0;
}
static inline u32 btrfs_level_size(struct btrfs_root *root, int level) {
static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
{
if (level == 0)
return root->leafsize;
return root->nodesize;
......@@ -1707,9 +1706,9 @@ int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
int btrfs_extent_post_op(struct btrfs_trans_handle *trans,
struct btrfs_root *root);
int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy);
struct btrfs_block_group_cache *btrfs_lookup_block_group(struct
btrfs_fs_info *info,
u64 bytenr);
struct btrfs_block_group_cache *btrfs_lookup_block_group(
struct btrfs_fs_info *info,
u64 bytenr);
u64 btrfs_find_block_group(struct btrfs_root *root,
u64 search_start, u64 search_hint, int owner);
struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
......@@ -1908,8 +1907,9 @@ int btrfs_search_root(struct btrfs_root *root, u64 search_start,
int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid,
struct btrfs_root *latest_root);
/* dir-item.c */
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
*root, const char *name, int name_len, u64 dir,
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
struct btrfs_root *root, const char *name,
int name_len, u64 dir,
struct btrfs_key *location, u8 type, u64 index);
struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
......
fs/btrfs/dir-item.c
浏览文件 @ d397712b
......@@ -333,7 +333,7 @@ struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
leaf = path->nodes[0];
dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
total_len = btrfs_item_size_nr(leaf, path->slots[0]);
while(cur < total_len) {
while (cur < total_len) {
this_len = sizeof(*dir_item) +
btrfs_dir_name_len(leaf, dir_item) +
btrfs_dir_data_len(leaf, dir_item);
......
fs/btrfs/disk-io.c
浏览文件 @ d397712b
......@@ -23,7 +23,7 @@
#include <linux/swap.h>
#include <linux/radix-tree.h>
#include <linux/writeback.h>
#include <linux/buffer_head.h> // for block_sync_page
#include <linux/buffer_head.h>
#include <linux/workqueue.h>
#include <linux/kthread.h>
#include <linux/freezer.h>
......@@ -40,19 +40,6 @@
#include "ref-cache.h"
#include "tree-log.h"
#if 0
static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
{
if (extent_buffer_blocknr(buf) != btrfs_header_blocknr(buf)) {
printk(KERN_CRIT "buf blocknr(buf) is %llu, header is %llu\n",
(unsigned long long)extent_buffer_blocknr(buf),
(unsigned long long)btrfs_header_blocknr(buf));
return 1;
}
return 0;
}
#endif
static struct extent_io_ops btree_extent_io_ops;
static void end_workqueue_fn(struct btrfs_work *work);
......@@ -128,23 +115,13 @@ static struct extent_map *btree_get_extent(struct inode *inode,
u64 failed_start = em->start;
u64 failed_len = em->len;
printk("failed to insert %Lu %Lu -> %Lu into tree\n",
em->start, em->len, em->block_start);
free_extent_map(em);
em = lookup_extent_mapping(em_tree, start, len);
if (em) {
printk("after failing, found %Lu %Lu %Lu\n",
em->start, em->len, em->block_start);
ret = 0;
} else {
em = lookup_extent_mapping(em_tree, failed_start,
failed_len);
if (em) {
printk("double failure lookup gives us "
"%Lu %Lu -> %Lu\n", em->start,
em->len, em->block_start);
free_extent_map(em);
}
ret = -EIO;
}
} else if (ret) {
......@@ -191,15 +168,12 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
unsigned long inline_result;
len = buf->len - offset;
while(len > 0) {
while (len > 0) {
err = map_private_extent_buffer(buf, offset, 32,
&map_token, &kaddr,
&map_start, &map_len, KM_USER0);
if (err) {
printk("failed to map extent buffer! %lu\n",
offset);
if (err)
return 1;
}
cur_len = min(len, map_len - (offset - map_start));
crc = btrfs_csum_data(root, kaddr + offset - map_start,
crc, cur_len);
......@@ -218,15 +192,14 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
btrfs_csum_final(crc, result);
if (verify) {
/* FIXME, this is not good */
if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
u32 val;
u32 found = 0;
memcpy(&found, result, csum_size);
read_extent_buffer(buf, &val, 0, csum_size);
printk("btrfs: %s checksum verify failed on %llu "
"wanted %X found %X level %d\n",
printk(KERN_INFO "btrfs: %s checksum verify failed "
"on %llu wanted %X found %X level %d\n",
root->fs_info->sb->s_id,
buf->start, val, found, btrfs_header_level(buf));
if (result != (char *)&inline_result)
......@@ -293,7 +266,7 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
if (!ret &&
!verify_parent_transid(io_tree, eb, parent_transid))
return ret;
printk("read extent buffer pages failed with ret %d mirror no %d\n", ret, mirror_num);
num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
eb->start, eb->len);
if (num_copies == 1)
......@@ -307,9 +280,10 @@ printk("read extent buffer pages failed with ret %d mirror no %d\n", ret, mirror
}
/*
* checksum a dirty tree block before IO. This has extra checks to make
* sure we only fill in the checksum field in the first page of a multi-page block
* checksum a dirty tree block before IO. This has extra checks to make sure
* 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)
{
struct extent_io_tree *tree;
......@@ -327,28 +301,22 @@ static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
if (!page->private)
goto out;
len = page->private >> 2;
if (len == 0) {
WARN_ON(1);
}
WARN_ON(len == 0);
eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
btrfs_header_generation(eb));
BUG_ON(ret);
found_start = btrfs_header_bytenr(eb);
if (found_start != start) {
printk("warning: eb start incorrect %Lu buffer %Lu len %lu\n",
start, found_start, len);
WARN_ON(1);
goto err;
}
if (eb->first_page != page) {
printk("bad first page %lu %lu\n", eb->first_page->index,
page->index);
WARN_ON(1);
goto err;
}
if (!PageUptodate(page)) {
printk("csum not up to date page %lu\n", page->index);
WARN_ON(1);
goto err;
}
......@@ -396,29 +364,30 @@ static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
goto out;
if (!page->private)
goto out;
len = page->private >> 2;
if (len == 0) {
WARN_ON(1);
}
WARN_ON(len == 0);
eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
found_start = btrfs_header_bytenr(eb);
if (found_start != start) {
printk("bad tree block start %llu %llu\n",
printk(KERN_INFO "btrfs bad tree block start %llu %llu\n",
(unsigned long long)found_start,
(unsigned long long)eb->start);
ret = -EIO;
goto err;
}
if (eb->first_page != page) {
printk("bad first page %lu %lu\n", eb->first_page->index,
page->index);
printk(KERN_INFO "btrfs bad first page %lu %lu\n",
eb->first_page->index, page->index);
WARN_ON(1);
ret = -EIO;
goto err;
}
if (check_tree_block_fsid(root, eb)) {
printk("bad fsid on block %Lu\n", eb->start);
printk(KERN_INFO "btrfs bad fsid on block %llu\n",
(unsigned long long)eb->start);
ret = -EIO;
goto err;
}
......@@ -578,7 +547,7 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
HZ/10);
}
#endif
while(atomic_read(&fs_info->async_submit_draining) &&
while (atomic_read(&fs_info->async_submit_draining) &&
atomic_read(&fs_info->nr_async_submits)) {
wait_event(fs_info->async_submit_wait,
(atomic_read(&fs_info->nr_async_submits) == 0));
......@@ -594,7 +563,7 @@ static int btree_csum_one_bio(struct bio *bio)
struct btrfs_root *root;
WARN_ON(bio->bi_vcnt <= 0);
while(bio_index < bio->bi_vcnt) {
while (bio_index < bio->bi_vcnt) {
root = BTRFS_I(bvec->bv_page->mapping->host)->root;
csum_dirty_buffer(root, bvec->bv_page);
bio_index++;
......@@ -680,9 +649,8 @@ static int btree_writepages(struct address_space *mapping,
num_dirty = count_range_bits(tree, &start, (u64)-1,
thresh, EXTENT_DIRTY);
if (num_dirty < thresh) {
if (num_dirty < thresh)
return 0;
}
}
return extent_writepages(tree, mapping, btree_get_extent, wbc);
}
......@@ -701,15 +669,14 @@ static int btree_releasepage(struct page *page, gfp_t gfp_flags)
int ret;
if (PageWriteback(page) || PageDirty(page))
return 0;
return 0;
tree = &BTRFS_I(page->mapping->host)->io_tree;
map = &BTRFS_I(page->mapping->host)->extent_tree;
ret = try_release_extent_state(map, tree, page, gfp_flags);
if (!ret) {
if (!ret)
return 0;
}
ret = try_release_extent_buffer(tree, page);
if (ret == 1) {
......@@ -728,8 +695,8 @@ static void btree_invalidatepage(struct page *page, unsigned long offset)
extent_invalidatepage(tree, page, offset);
btree_releasepage(page, GFP_NOFS);
if (PagePrivate(page)) {
printk("warning page private not zero on page %Lu\n",
page_offset(page));
printk(KERN_WARNING "btrfs warning page private not zero "
"on page %llu\n", (unsigned long long)page_offset(page));
ClearPagePrivate(page);
set_page_private(page, 0);
page_cache_release(page);
......@@ -813,7 +780,7 @@ int btrfs_write_tree_block(struct extent_buffer *buf)
int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
return btrfs_wait_on_page_writeback_range(buf->first_page->mapping,
buf->start, buf->start + buf->len -1);
buf->start, buf->start + buf->len - 1);
}
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
......@@ -832,11 +799,10 @@ struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
if (ret == 0) {
if (ret == 0)
buf->flags |= EXTENT_UPTODATE;
} else {
else
WARN_ON(1);
}
return buf;
}
......@@ -944,7 +910,7 @@ int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
if (!log_root_tree)
return 0;
while(1) {
while (1) {
ret = find_first_extent_bit(&log_root_tree->dirty_log_pages,
0, &start, &end, EXTENT_DIRTY);
if (ret)
......@@ -1165,24 +1131,6 @@ struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
root->in_sysfs = 1;
return root;
}
#if 0
static int add_hasher(struct btrfs_fs_info *info, char *type) {
struct btrfs_hasher *hasher;
hasher = kmalloc(sizeof(*hasher), GFP_NOFS);
if (!hasher)
return -ENOMEM;
hasher->hash_tfm = crypto_alloc_hash(type, 0, CRYPTO_ALG_ASYNC);
if (!hasher->hash_tfm) {
kfree(hasher);
return -EINVAL;
}
spin_lock(&info->hash_lock);
list_add(&hasher->list, &info->hashers);
spin_unlock(&info->hash_lock);
return 0;
}
#endif
static int btrfs_congested_fn(void *congested_data, int bdi_bits)
{
......@@ -1226,9 +1174,8 @@ static void __unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
continue;
bdi = blk_get_backing_dev_info(device->bdev);
if (bdi->unplug_io_fn) {
if (bdi->unplug_io_fn)
bdi->unplug_io_fn(bdi, page);
}
}
}
......@@ -1420,8 +1367,9 @@ static int transaction_kthread(void *arg)
mutex_lock(&root->fs_info->transaction_kthread_mutex);
if (root->fs_info->total_ref_cache_size > 20 * 1024 * 1024) {
printk("btrfs: total reference cache size %Lu\n",
root->fs_info->total_ref_cache_size);
printk(KERN_INFO "btrfs: total reference cache "
"size %llu\n",
root->fs_info->total_ref_cache_size);
}
mutex_lock(&root->fs_info->trans_mutex);
......@@ -1592,14 +1540,6 @@ struct btrfs_root *open_ctree(struct super_block *sb,
atomic_set(&fs_info->tree_log_writers, 0);
fs_info->tree_log_transid = 0;
#if 0
ret = add_hasher(fs_info, "crc32c");
if (ret) {
printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
err = -ENOMEM;
goto fail_iput;
}
#endif
__setup_root(4096, 4096, 4096, 4096, tree_root,
fs_info, BTRFS_ROOT_TREE_OBJECTID);
......@@ -1720,7 +1660,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
sizeof(disk_super->magic))) {
printk("btrfs: valid FS not found on %s\n", sb->s_id);
printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
goto fail_sb_buffer;
}
......@@ -1728,8 +1668,8 @@ struct btrfs_root *open_ctree(struct super_block *sb,
ret = btrfs_read_sys_array(tree_root);
mutex_unlock(&fs_info->chunk_mutex);
if (ret) {
printk("btrfs: failed to read the system array on %s\n",
sb->s_id);
printk(KERN_WARNING "btrfs: failed to read the system "
"array on %s\n", sb->s_id);
goto fail_sys_array;
}
......@@ -1746,14 +1686,15 @@ struct btrfs_root *open_ctree(struct super_block *sb,
BUG_ON(!chunk_root->node);
read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
(unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
BTRFS_UUID_SIZE);
(unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
BTRFS_UUID_SIZE);
mutex_lock(&fs_info->chunk_mutex);
ret = btrfs_read_chunk_tree(chunk_root);
mutex_unlock(&fs_info->chunk_mutex);
if (ret) {
printk("btrfs: failed to read chunk tree on %s\n", sb->s_id);
printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
sb->s_id);
goto fail_chunk_root;
}
......@@ -1812,7 +1753,8 @@ struct btrfs_root *open_ctree(struct super_block *sb,
u64 bytenr = btrfs_super_log_root(disk_super);
if (fs_devices->rw_devices == 0) {
printk("Btrfs log replay required on RO media\n");
printk(KERN_WARNING "Btrfs log replay required "
"on RO media\n");
err = -EIO;
goto fail_trans_kthread;
}
......@@ -2097,7 +2039,8 @@ int write_all_supers(struct btrfs_root *root, int max_mirrors)
total_errors++;
}
if (total_errors > max_errors) {
printk("btrfs: %d errors while writing supers\n", total_errors);
printk(KERN_ERR "btrfs: %d errors while writing supers\n",
total_errors);
BUG();
}
......@@ -2114,7 +2057,8 @@ int write_all_supers(struct btrfs_root *root, int max_mirrors)
total_errors++;
}
if (total_errors > max_errors) {
printk("btrfs: %d errors while writing supers\n", total_errors);
printk(KERN_ERR "btrfs: %d errors while writing supers\n",
total_errors);
BUG();
}
return 0;
......@@ -2137,16 +2081,11 @@ int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
down_write(&root->anon_super.s_umount);
kill_anon_super(&root->anon_super);
}
#if 0
if (root->in_sysfs)
btrfs_sysfs_del_root(root);
#endif
if (root->node)
free_extent_buffer(root->node);
if (root->commit_root)
free_extent_buffer(root->commit_root);
if (root->name)
kfree(root->name);
kfree(root->name);
kfree(root);
return 0;
}
......@@ -2157,7 +2096,7 @@ static int del_fs_roots(struct btrfs_fs_info *fs_info)
struct btrfs_root *gang[8];
int i;
while(1) {
while (1) {
ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
(void **)gang, 0,
ARRAY_SIZE(gang));
......@@ -2228,18 +2167,17 @@ int close_ctree(struct btrfs_root *root)
if (!(fs_info->sb->s_flags & MS_RDONLY)) {
ret = btrfs_commit_super(root);
if (ret) {
printk("btrfs: commit super returns %d\n", ret);
}
if (ret)
printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
}
if (fs_info->delalloc_bytes) {
printk("btrfs: at unmount delalloc count %Lu\n",
printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
fs_info->delalloc_bytes);
}
if (fs_info->total_ref_cache_size) {
printk("btrfs: at umount reference cache size %Lu\n",
fs_info->total_ref_cache_size);
printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
(unsigned long long)fs_info->total_ref_cache_size);
}
if (fs_info->extent_root->node)
......@@ -2248,13 +2186,13 @@ int close_ctree(struct btrfs_root *root)
if (fs_info->tree_root->node)
free_extent_buffer(fs_info->tree_root->node);
if (root->fs_info->chunk_root->node);
if (root->fs_info->chunk_root->node)
free_extent_buffer(root->fs_info->chunk_root->node);
if (root->fs_info->dev_root->node);
if (root->fs_info->dev_root->node)
free_extent_buffer(root->fs_info->dev_root->node);
if (root->fs_info->csum_root->node);
if (root->fs_info->csum_root->node)
free_extent_buffer(root->fs_info->csum_root->node);
btrfs_free_block_groups(root->fs_info);
......@@ -2273,7 +2211,7 @@ int close_ctree(struct btrfs_root *root)
btrfs_stop_workers(&fs_info->submit_workers);
#if 0
while(!list_empty(&fs_info->hashers)) {
while (!list_empty(&fs_info->hashers)) {
struct btrfs_hasher *hasher;
hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,
hashers);
......@@ -2324,9 +2262,11 @@ void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
WARN_ON(!btrfs_tree_locked(buf));
if (transid != root->fs_info->generation) {
printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
"found %llu running %llu\n",
(unsigned long long)buf->start,
transid, root->fs_info->generation);
(unsigned long long)transid,
(unsigned long long)root->fs_info->generation);
WARN_ON(1);
}
set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, buf);
......@@ -2361,9 +2301,8 @@ int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
int ret;
ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
if (ret == 0) {
if (ret == 0)
buf->flags |= EXTENT_UPTODATE;
}
return ret;
}
......
fs/btrfs/export.c
浏览文件 @ d397712b
......@@ -7,9 +7,11 @@
#include "export.h"
#include "compat.h"
#define BTRFS_FID_SIZE_NON_CONNECTABLE (offsetof(struct btrfs_fid, parent_objectid)/4)
#define BTRFS_FID_SIZE_CONNECTABLE (offsetof(struct btrfs_fid, parent_root_objectid)/4)
#define BTRFS_FID_SIZE_CONNECTABLE_ROOT (sizeof(struct btrfs_fid)/4)
#define BTRFS_FID_SIZE_NON_CONNECTABLE (offsetof(struct btrfs_fid, \
parent_objectid) / 4)
#define BTRFS_FID_SIZE_CONNECTABLE (offsetof(struct btrfs_fid, \
parent_root_objectid) / 4)
#define BTRFS_FID_SIZE_CONNECTABLE_ROOT (sizeof(struct btrfs_fid) / 4)
static int btrfs_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
int connectable)
......
fs/btrfs/extent-tree.c
浏览文件 @ d397712b
此差异已折叠。
fs/btrfs/extent_io.c
浏览文件 @ d397712b
此差异已折叠。
fs/btrfs/extent_map.c
浏览文件 @ d397712b
......@@ -89,11 +89,11 @@ EXPORT_SYMBOL(free_extent_map);
static struct rb_node *tree_insert(struct rb_root *root, u64 offset,
struct rb_node *node)
{
struct rb_node ** p = &root->rb_node;
struct rb_node * parent = NULL;
struct rb_node **p = &root->rb_node;
struct rb_node *parent = NULL;
struct extent_map *entry;
while(*p) {
while (*p) {
parent = *p;
entry = rb_entry(parent, struct extent_map, rb_node);
......@@ -122,13 +122,13 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 offset,
struct rb_node **prev_ret,
struct rb_node **next_ret)
{
struct rb_node * n = root->rb_node;
struct rb_node *n = root->rb_node;
struct rb_node *prev = NULL;
struct rb_node *orig_prev = NULL;
struct extent_map *entry;
struct extent_map *prev_entry = NULL;
while(n) {
while (n) {
entry = rb_entry(n, struct extent_map, rb_node);
prev = n;
prev_entry = entry;
......@@ -145,7 +145,7 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 offset,
if (prev_ret) {
orig_prev = prev;
while(prev && offset >= extent_map_end(prev_entry)) {
while (prev && offset >= extent_map_end(prev_entry)) {
prev = rb_next(prev);
prev_entry = rb_entry(prev, struct extent_map, rb_node);
}
......@@ -155,7 +155,7 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 offset,
if (next_ret) {
prev_entry = rb_entry(prev, struct extent_map, rb_node);
while(prev && offset < prev_entry->start) {
while (prev && offset < prev_entry->start) {
prev = rb_prev(prev);
prev_entry = rb_entry(prev, struct extent_map, rb_node);
}
......
fs/btrfs/file-item.c
浏览文件 @ d397712b
......@@ -24,7 +24,7 @@
#include "transaction.h"
#include "print-tree.h"
#define MAX_CSUM_ITEMS(r,size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
#define MAX_CSUM_ITEMS(r, size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
sizeof(struct btrfs_item) * 2) / \
size) - 1))
int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
......@@ -166,7 +166,7 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
WARN_ON(bio->bi_vcnt <= 0);
disk_bytenr = (u64)bio->bi_sector << 9;
while(bio_index < bio->bi_vcnt) {
while (bio_index < bio->bi_vcnt) {
offset = page_offset(bvec->bv_page) + bvec->bv_offset;
ret = btrfs_find_ordered_sum(inode, offset, disk_bytenr, &sum);
if (ret == 0)
......@@ -192,8 +192,9 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
offset + bvec->bv_len - 1,
EXTENT_NODATASUM, GFP_NOFS);
} else {
printk("no csum found for inode %lu "
"start %llu\n", inode->i_ino,
printk(KERN_INFO "btrfs no csum found "
"for inode %lu start %llu\n",
inode->i_ino,
(unsigned long long)offset);
}
item = NULL;
......@@ -373,7 +374,7 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
BUG_ON(!ordered);
sums->bytenr = ordered->start;
while(bio_index < bio->bi_vcnt) {
while (bio_index < bio->bi_vcnt) {
if (!contig)
offset = page_offset(bvec->bv_page) + bvec->bv_offset;
......@@ -507,7 +508,7 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans,
path = btrfs_alloc_path();
while(1) {
while (1) {
key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
key.offset = end_byte - 1;
key.type = BTRFS_EXTENT_CSUM_KEY;
......@@ -715,9 +716,8 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
goto csum;
diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
if (diff != csum_size) {
if (diff != csum_size)
goto insert;
}
ret = btrfs_extend_item(trans, root, path, diff);
BUG_ON(ret);
......@@ -732,7 +732,7 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
u64 next_sector = sector_sum->bytenr;
struct btrfs_sector_sum *next = sector_sum + 1;
while(tmp < sums->len) {
while (tmp < sums->len) {
if (next_sector + root->sectorsize != next->bytenr)
break;
tmp += root->sectorsize;
......
fs/btrfs/file.c
浏览文件 @ d397712b
......@@ -44,10 +44,10 @@
/* simple helper to fault in pages and copy. This should go away
* and be replaced with calls into generic code.
*/
static int noinline btrfs_copy_from_user(loff_t pos, int num_pages,
static noinline int btrfs_copy_from_user(loff_t pos, int num_pages,
int write_bytes,
struct page **prepared_pages,
const char __user * buf)
const char __user *buf)
{
long page_fault = 0;
int i;
......@@ -78,7 +78,7 @@ static int noinline btrfs_copy_from_user(loff_t pos, int num_pages,
/*
* unlocks pages after btrfs_file_write is done with them
*/
static void noinline btrfs_drop_pages(struct page **pages, size_t num_pages)
static noinline void btrfs_drop_pages(struct page **pages, size_t num_pages)
{
size_t i;
for (i = 0; i < num_pages; i++) {
......@@ -103,7 +103,7 @@ static void noinline btrfs_drop_pages(struct page **pages, size_t num_pages)
* this also makes the decision about creating an inline extent vs
* doing real data extents, marking pages dirty and delalloc as required.
*/
static int noinline dirty_and_release_pages(struct btrfs_trans_handle *trans,
static noinline int dirty_and_release_pages(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct file *file,
struct page **pages,
......@@ -137,9 +137,6 @@ static int noinline dirty_and_release_pages(struct btrfs_trans_handle *trans,
btrfs_set_trans_block_group(trans, inode);
hint_byte = 0;
if ((end_of_last_block & 4095) == 0) {
printk("strange end of last %Lu %zu %Lu\n", start_pos, write_bytes, end_of_last_block);
}
set_extent_uptodate(io_tree, start_pos, end_of_last_block, GFP_NOFS);
/* check for reserved extents on each page, we don't want
......@@ -185,7 +182,7 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
len = (u64)-1;
testend = 0;
}
while(1) {
while (1) {
if (!split)
split = alloc_extent_map(GFP_NOFS);
if (!split2)
......@@ -295,7 +292,7 @@ int btrfs_check_file(struct btrfs_root *root, struct inode *inode)
path = btrfs_alloc_path();
ret = btrfs_lookup_file_extent(NULL, root, path, inode->i_ino,
last_offset, 0);
while(1) {
while (1) {
nritems = btrfs_header_nritems(path->nodes[0]);
if (path->slots[0] >= nritems) {
ret = btrfs_next_leaf(root, path);
......@@ -314,8 +311,10 @@ int btrfs_check_file(struct btrfs_root *root, struct inode *inode)
if (found_key.offset < last_offset) {
WARN_ON(1);
btrfs_print_leaf(root, leaf);
printk("inode %lu found offset %Lu expected %Lu\n",
inode->i_ino, found_key.offset, last_offset);
printk(KERN_ERR "inode %lu found offset %llu "
"expected %llu\n", inode->i_ino,
(unsigned long long)found_key.offset,
(unsigned long long)last_offset);
err = 1;
goto out;
}
......@@ -331,7 +330,7 @@ int btrfs_check_file(struct btrfs_root *root, struct inode *inode)
extent_end = found_key.offset +
btrfs_file_extent_inline_len(leaf, extent);
extent_end = (extent_end + root->sectorsize - 1) &
~((u64)root->sectorsize -1 );
~((u64)root->sectorsize - 1);
}
last_offset = extent_end;
path->slots[0]++;
......@@ -339,8 +338,9 @@ int btrfs_check_file(struct btrfs_root *root, struct inode *inode)
if (0 && last_offset < inode->i_size) {
WARN_ON(1);
btrfs_print_leaf(root, leaf);
printk("inode %lu found offset %Lu size %Lu\n", inode->i_ino,
last_offset, inode->i_size);
printk(KERN_ERR "inode %lu found offset %llu size %llu\n",
inode->i_ino, (unsigned long long)last_offset,
(unsigned long long)inode->i_size);
err = 1;
}
......@@ -362,7 +362,7 @@ int btrfs_check_file(struct btrfs_root *root, struct inode *inode)
* inline_limit is used to tell this code which offsets in the file to keep
* if they contain inline extents.
*/
int noinline btrfs_drop_extents(struct btrfs_trans_handle *trans,
noinline int btrfs_drop_extents(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct inode *inode,
u64 start, u64 end, u64 inline_limit, u64 *hint_byte)
{
......@@ -398,7 +398,7 @@ int noinline btrfs_drop_extents(struct btrfs_trans_handle *trans,
path = btrfs_alloc_path();
if (!path)
return -ENOMEM;
while(1) {
while (1) {
recow = 0;
btrfs_release_path(root, path);
ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
......@@ -649,16 +649,15 @@ int noinline btrfs_drop_extents(struct btrfs_trans_handle *trans,
if (disk_bytenr != 0) {
ret = btrfs_update_extent_ref(trans, root,
disk_bytenr, orig_parent,
leaf->start,
leaf->start,
root->root_key.objectid,
trans->transid, ins.objectid);
BUG_ON(ret);
}
btrfs_release_path(root, path);
if (disk_bytenr != 0) {
if (disk_bytenr != 0)
inode_add_bytes(inode, extent_end - end);
}
}
if (found_extent && !keep) {
......@@ -944,7 +943,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
* waits for data=ordered extents to finish before allowing the pages to be
* modified.
*/
static int noinline prepare_pages(struct btrfs_root *root, struct file *file,
static noinline int prepare_pages(struct btrfs_root *root, struct file *file,
struct page **pages, size_t num_pages,
loff_t pos, unsigned long first_index,
unsigned long last_index, size_t write_bytes)
......@@ -979,7 +978,8 @@ static int noinline prepare_pages(struct btrfs_root *root, struct file *file,
struct btrfs_ordered_extent *ordered;
lock_extent(&BTRFS_I(inode)->io_tree,
start_pos, last_pos - 1, GFP_NOFS);
ordered = btrfs_lookup_first_ordered_extent(inode, last_pos -1);
ordered = btrfs_lookup_first_ordered_extent(inode,
last_pos - 1);
if (ordered &&
ordered->file_offset + ordered->len > start_pos &&
ordered->file_offset < last_pos) {
......@@ -1085,7 +1085,7 @@ static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
}
}
while(count > 0) {
while (count > 0) {
size_t offset = pos & (PAGE_CACHE_SIZE - 1);
size_t write_bytes = min(count, nrptrs *
(size_t)PAGE_CACHE_SIZE -
......@@ -1178,7 +1178,7 @@ static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
return num_written ? num_written : err;
}
int btrfs_release_file(struct inode * inode, struct file * filp)
int btrfs_release_file(struct inode *inode, struct file *filp)
{
if (filp->private_data)
btrfs_ioctl_trans_end(filp);
......@@ -1237,9 +1237,8 @@ int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync)
}
ret = btrfs_log_dentry_safe(trans, root, file->f_dentry);
if (ret < 0) {
if (ret < 0)
goto out;
}
/* we've logged all the items and now have a consistent
* version of the file in the log. It is possible that
......
fs/btrfs/free-space-cache.c
浏览文件 @ d397712b
......@@ -213,10 +213,13 @@ static int __btrfs_add_free_space(struct btrfs_block_group_cache *block_group,
info->offset = offset;
info->bytes += bytes;
} else if (right_info && right_info->offset != offset+bytes) {
printk(KERN_ERR "adding space in the middle of an existing "
"free space area. existing: offset=%Lu, bytes=%Lu. "
"new: offset=%Lu, bytes=%Lu\n", right_info->offset,
right_info->bytes, offset, bytes);
printk(KERN_ERR "btrfs adding space in the middle of an "
"existing free space area. existing: "
"offset=%llu, bytes=%llu. new: offset=%llu, "
"bytes=%llu\n", (unsigned long long)right_info->offset,
(unsigned long long)right_info->bytes,
(unsigned long long)offset,
(unsigned long long)bytes);
BUG();
}
......@@ -225,11 +228,14 @@ static int __btrfs_add_free_space(struct btrfs_block_group_cache *block_group,
if (unlikely((left_info->offset + left_info->bytes) !=
offset)) {
printk(KERN_ERR "free space to the left of new free "
"space isn't quite right. existing: offset=%Lu,"
" bytes=%Lu. new: offset=%Lu, bytes=%Lu\n",
left_info->offset, left_info->bytes, offset,
bytes);
printk(KERN_ERR "btrfs free space to the left "
"of new free space isn't "
"quite right. existing: offset=%llu, "
"bytes=%llu. new: offset=%llu, bytes=%llu\n",
(unsigned long long)left_info->offset,
(unsigned long long)left_info->bytes,
(unsigned long long)offset,
(unsigned long long)bytes);
BUG();
}
......@@ -265,8 +271,7 @@ static int __btrfs_add_free_space(struct btrfs_block_group_cache *block_group,
BUG();
}
if (alloc_info)
kfree(alloc_info);
kfree(alloc_info);
return ret;
}
......@@ -283,9 +288,11 @@ __btrfs_remove_free_space(struct btrfs_block_group_cache *block_group,
if (info && info->offset == offset) {
if (info->bytes < bytes) {
printk(KERN_ERR "Found free space at %Lu, size %Lu,"
"trying to use %Lu\n",
info->offset, info->bytes, bytes);
printk(KERN_ERR "Found free space at %llu, size %llu,"
"trying to use %llu\n",
(unsigned long long)info->offset,
(unsigned long long)info->bytes,
(unsigned long long)bytes);
WARN_ON(1);
ret = -EINVAL;
goto out;
......@@ -401,8 +408,6 @@ void btrfs_dump_free_space(struct btrfs_block_group_cache *block_group,
info = rb_entry(n, struct btrfs_free_space, offset_index);
if (info->bytes >= bytes)
count++;
//printk(KERN_INFO "offset=%Lu, bytes=%Lu\n", info->offset,
// info->bytes);
}
printk(KERN_INFO "%d blocks of free space at or bigger than bytes is"
"\n", count);
......
fs/btrfs/inode-map.c
浏览文件 @ d397712b
......@@ -129,7 +129,6 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
last_ino = key.objectid + 1;
path->slots[0]++;
}
// FIXME -ENOSPC
BUG_ON(1);
found:
btrfs_release_path(root, path);
......
fs/btrfs/inode.c
浏览文件 @ d397712b
......@@ -124,7 +124,7 @@ int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
* the btree. The caller should have done a btrfs_drop_extents so that
* no overlapping inline items exist in the btree
*/
static int noinline insert_inline_extent(struct btrfs_trans_handle *trans,
static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct inode *inode,
u64 start, size_t size, size_t compressed_size,
struct page **compressed_pages)
......@@ -148,7 +148,8 @@ static int noinline insert_inline_extent(struct btrfs_trans_handle *trans,
cur_size = compressed_size;
}
path = btrfs_alloc_path(); if (!path)
path = btrfs_alloc_path();
if (!path)
return -ENOMEM;
btrfs_set_trans_block_group(trans, inode);
......@@ -165,7 +166,6 @@ static int noinline insert_inline_extent(struct btrfs_trans_handle *trans,
BUG_ON(ret);
if (ret) {
err = ret;
printk("got bad ret %d\n", ret);
goto fail;
}
leaf = path->nodes[0];
......@@ -181,7 +181,7 @@ static int noinline insert_inline_extent(struct btrfs_trans_handle *trans,
if (use_compress) {
struct page *cpage;
int i = 0;
while(compressed_size > 0) {
while (compressed_size > 0) {
cpage = compressed_pages[i];
cur_size = min_t(unsigned long, compressed_size,
PAGE_CACHE_SIZE);
......@@ -519,8 +519,7 @@ static noinline int compress_file_range(struct inode *inode,
WARN_ON(pages[i]->mapping);
page_cache_release(pages[i]);
}
if (pages)
kfree(pages);
kfree(pages);
goto out;
}
......@@ -549,7 +548,7 @@ static noinline int submit_compressed_extents(struct inode *inode,
trans = btrfs_join_transaction(root, 1);
while(!list_empty(&async_cow->extents)) {
while (!list_empty(&async_cow->extents)) {
async_extent = list_entry(async_cow->extents.next,
struct async_extent, list);
list_del(&async_extent->list);
......@@ -562,8 +561,8 @@ static noinline int submit_compressed_extents(struct inode *inode,
unsigned long nr_written = 0;
lock_extent(io_tree, async_extent->start,
async_extent->start + async_extent->ram_size - 1,
GFP_NOFS);
async_extent->start +
async_extent->ram_size - 1, GFP_NOFS);
/* allocate blocks */
cow_file_range(inode, async_cow->locked_page,
......@@ -581,7 +580,7 @@ static noinline int submit_compressed_extents(struct inode *inode,
if (!page_started)
extent_write_locked_range(io_tree,
inode, async_extent->start,
async_extent->start +
async_extent->start +
async_extent->ram_size - 1,
btrfs_get_extent,
WB_SYNC_ALL);
......@@ -618,7 +617,7 @@ static noinline int submit_compressed_extents(struct inode *inode,
set_bit(EXTENT_FLAG_PINNED, &em->flags);
set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
while(1) {
while (1) {
spin_lock(&em_tree->lock);
ret = add_extent_mapping(em_tree, em);
spin_unlock(&em_tree->lock);
......@@ -651,11 +650,11 @@ static noinline int submit_compressed_extents(struct inode *inode,
NULL, 1, 1, 0, 1, 1, 0);
ret = btrfs_submit_compressed_write(inode,
async_extent->start,
async_extent->ram_size,
ins.objectid,
ins.offset, async_extent->pages,
async_extent->nr_pages);
async_extent->start,
async_extent->ram_size,
ins.objectid,
ins.offset, async_extent->pages,
async_extent->nr_pages);
BUG_ON(ret);
trans = btrfs_join_transaction(root, 1);
......@@ -735,14 +734,13 @@ static noinline int cow_file_range(struct inode *inode,
btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
while(disk_num_bytes > 0) {
while (disk_num_bytes > 0) {
cur_alloc_size = min(disk_num_bytes, root->fs_info->max_extent);
ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
root->sectorsize, 0, alloc_hint,
(u64)-1, &ins, 1);
if (ret) {
BUG();
}
BUG_ON(ret);
em = alloc_extent_map(GFP_NOFS);
em->start = start;
em->orig_start = em->start;
......@@ -755,7 +753,7 @@ static noinline int cow_file_range(struct inode *inode,
em->bdev = root->fs_info->fs_devices->latest_bdev;
set_bit(EXTENT_FLAG_PINNED, &em->flags);
while(1) {
while (1) {
spin_lock(&em_tree->lock);
ret = add_extent_mapping(em_tree, em);
spin_unlock(&em_tree->lock);
......@@ -779,11 +777,9 @@ static noinline int cow_file_range(struct inode *inode,
BUG_ON(ret);
}
if (disk_num_bytes < cur_alloc_size) {
printk("num_bytes %Lu cur_alloc %Lu\n", disk_num_bytes,
cur_alloc_size);
if (disk_num_bytes < cur_alloc_size)
break;
}
/* we're not doing compressed IO, don't unlock the first
* page (which the caller expects to stay locked), don't
* clear any dirty bits and don't set any writeback bits
......@@ -842,9 +838,8 @@ static noinline void async_cow_submit(struct btrfs_work *work)
waitqueue_active(&root->fs_info->async_submit_wait))
wake_up(&root->fs_info->async_submit_wait);
if (async_cow->inode) {
if (async_cow->inode)
submit_compressed_extents(async_cow->inode, async_cow);
}
}
static noinline void async_cow_free(struct btrfs_work *work)
......@@ -871,7 +866,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED |
EXTENT_DELALLOC, 1, 0, GFP_NOFS);
while(start < end) {
while (start < end) {
async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
async_cow->inode = inode;
async_cow->root = root;
......@@ -904,7 +899,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
limit));
}
while(atomic_read(&root->fs_info->async_submit_draining) &&
while (atomic_read(&root->fs_info->async_submit_draining) &&
atomic_read(&root->fs_info->async_delalloc_pages)) {
wait_event(root->fs_info->async_submit_wait,
(atomic_read(&root->fs_info->async_delalloc_pages) ==
......@@ -918,7 +913,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
return 0;
}
static int noinline csum_exist_in_range(struct btrfs_root *root,
static noinline int csum_exist_in_range(struct btrfs_root *root,
u64 bytenr, u64 num_bytes)
{
int ret;
......@@ -1146,13 +1141,13 @@ static int run_delalloc_range(struct inode *inode, struct page *locked_page,
if (btrfs_test_flag(inode, NODATACOW))
ret = run_delalloc_nocow(inode, locked_page, start, end,
page_started, 1, nr_written);
page_started, 1, nr_written);
else if (btrfs_test_flag(inode, PREALLOC))
ret = run_delalloc_nocow(inode, locked_page, start, end,
page_started, 0, nr_written);
page_started, 0, nr_written);
else
ret = cow_file_range_async(inode, locked_page, start, end,
page_started, nr_written);
page_started, nr_written);
return ret;
}
......@@ -1200,8 +1195,11 @@ static int btrfs_clear_bit_hook(struct inode *inode, u64 start, u64 end,
spin_lock(&root->fs_info->delalloc_lock);
if (end - start + 1 > root->fs_info->delalloc_bytes) {
printk("warning: delalloc account %Lu %Lu\n",
end - start + 1, root->fs_info->delalloc_bytes);
printk(KERN_INFO "btrfs warning: delalloc account "
"%llu %llu\n",
(unsigned long long)end - start + 1,
(unsigned long long)
root->fs_info->delalloc_bytes);
root->fs_info->delalloc_bytes = 0;
BTRFS_I(inode)->delalloc_bytes = 0;
} else {
......@@ -1241,9 +1239,8 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
ret = btrfs_map_block(map_tree, READ, logical,
&map_length, NULL, 0);
if (map_length < length + size) {
if (map_length < length + size)
return 1;
}
return 0;
}
......@@ -1255,8 +1252,9 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
* At IO completion time the cums attached on the ordered extent record
* are inserted into the btree
*/
static int __btrfs_submit_bio_start(struct inode *inode, int rw, struct bio *bio,
int mirror_num, unsigned long bio_flags)
static int __btrfs_submit_bio_start(struct inode *inode, int rw,
struct bio *bio, int mirror_num,
unsigned long bio_flags)
{
struct btrfs_root *root = BTRFS_I(inode)->root;
int ret = 0;
......@@ -1341,9 +1339,8 @@ static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end)
{
if ((end & (PAGE_CACHE_SIZE - 1)) == 0) {
if ((end & (PAGE_CACHE_SIZE - 1)) == 0)
WARN_ON(1);
}
return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
GFP_NOFS);
}
......@@ -1755,14 +1752,14 @@ static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
}
local_irq_save(flags);
kaddr = kmap_atomic(page, KM_IRQ0);
if (ret) {
if (ret)
goto zeroit;
}
csum = btrfs_csum_data(root, kaddr + offset, csum, end - start + 1);
btrfs_csum_final(csum, (char *)&csum);
if (csum != private) {
if (csum != private)
goto zeroit;
}
kunmap_atomic(kaddr, KM_IRQ0);
local_irq_restore(flags);
good:
......@@ -1773,9 +1770,10 @@ static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
return 0;
zeroit:
printk("btrfs csum failed ino %lu off %llu csum %u private %Lu\n",
page->mapping->host->i_ino, (unsigned long long)start, csum,
private);
printk(KERN_INFO "btrfs csum failed ino %lu off %llu csum %u "
"private %llu\n", page->mapping->host->i_ino,
(unsigned long long)start, csum,
(unsigned long long)private);
memset(kaddr + offset, 1, end - start + 1);
flush_dcache_page(page);
kunmap_atomic(kaddr, KM_IRQ0);
......@@ -2097,9 +2095,8 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
/*
* copy everything in the in-memory inode into the btree.
*/
int noinline btrfs_update_inode(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct inode *inode)
noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct inode *inode)
{
struct btrfs_inode_item *inode_item;
struct btrfs_path *path;
......@@ -2174,7 +2171,7 @@ int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
inode->i_ino,
dir->i_ino, &index);
if (ret) {
printk("failed to delete reference to %.*s, "
printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
"inode %lu parent %lu\n", name_len, name,
inode->i_ino, dir->i_ino);
goto err;
......@@ -2280,9 +2277,8 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
/* now the directory is empty */
err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
dentry->d_name.name, dentry->d_name.len);
if (!err) {
if (!err)
btrfs_i_size_write(inode, 0);
}
fail_trans:
nr = trans->blocks_used;
......@@ -2516,9 +2512,9 @@ noinline int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
search_again:
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
if (ret < 0) {
if (ret < 0)
goto error;
}
if (ret > 0) {
/* there are no items in the tree for us to truncate, we're
* done
......@@ -2530,7 +2526,7 @@ noinline int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
path->slots[0]--;
}
while(1) {
while (1) {
fi = NULL;
leaf = path->nodes[0];
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
......@@ -2562,19 +2558,18 @@ noinline int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
item_end--;
}
if (item_end < new_size) {
if (found_type == BTRFS_DIR_ITEM_KEY) {
if (found_type == BTRFS_DIR_ITEM_KEY)
found_type = BTRFS_INODE_ITEM_KEY;
} else if (found_type == BTRFS_EXTENT_ITEM_KEY) {
else if (found_type == BTRFS_EXTENT_ITEM_KEY)
found_type = BTRFS_EXTENT_DATA_KEY;
} else if (found_type == BTRFS_EXTENT_DATA_KEY) {
else if (found_type == BTRFS_EXTENT_DATA_KEY)
found_type = BTRFS_XATTR_ITEM_KEY;
} else if (found_type == BTRFS_XATTR_ITEM_KEY) {
else if (found_type == BTRFS_XATTR_ITEM_KEY)
found_type = BTRFS_INODE_REF_KEY;
} else if (found_type) {
else if (found_type)
found_type--;
} else {
else
break;
}
btrfs_set_key_type(&key, found_type);
goto next;
}
......@@ -2656,7 +2651,7 @@ noinline int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
pending_del_nr++;
pending_del_slot = path->slots[0];
} else {
printk("bad pending slot %d pending_del_nr %d pending_del_slot %d\n", path->slots[0], pending_del_nr, pending_del_slot);
BUG();
}
} else {
break;
......@@ -2938,9 +2933,10 @@ static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
namelen, 0);
if (IS_ERR(di))
ret = PTR_ERR(di);
if (!di || IS_ERR(di)) {
if (!di || IS_ERR(di))
goto out_err;
}
btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
out:
btrfs_free_path(path);
......@@ -3020,8 +3016,8 @@ static int btrfs_init_locked_inode(struct inode *inode, void *p)
static int btrfs_find_actor(struct inode *inode, void *opaque)
{
struct btrfs_iget_args *args = opaque;
return (args->ino == inode->i_ino &&
args->root == BTRFS_I(inode)->root);
return args->ino == inode->i_ino &&
args->root == BTRFS_I(inode)->root;
}
struct inode *btrfs_ilookup(struct super_block *s, u64 objectid,
......@@ -3085,7 +3081,7 @@ struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
{
struct inode * inode;
struct inode *inode;
struct btrfs_inode *bi = BTRFS_I(dir);
struct btrfs_root *root = bi->root;
struct btrfs_root *sub_root = root;
......@@ -3385,9 +3381,8 @@ int btrfs_set_inode_index(struct inode *dir, u64 *index)
if (BTRFS_I(dir)->index_cnt == (u64)-1) {
ret = btrfs_set_inode_index_count(dir);
if (ret) {
if (ret)
return ret;
}
}
*index = BTRFS_I(dir)->index_cnt;
......@@ -3879,12 +3874,13 @@ static noinline int uncompress_inline(struct btrfs_path *path,
/*
* a bit scary, this does extent mapping from logical file offset to the disk.
* the ugly parts come from merging extents from the disk with the
* in-ram representation. This gets more complex because of the data=ordered code,
* the ugly parts come from merging extents from the disk with the in-ram
* representation. This gets more complex because of the data=ordered code,
* where the in-ram extents might be locked pending data=ordered completion.
*
* This also copies inline extents directly into the page.
*/
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
size_t pg_offset, u64 start, u64 len,
int create)
......@@ -4081,7 +4077,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
extent_map_end(em) - 1, GFP_NOFS);
goto insert;
} else {
printk("unkknown found_type %d\n", found_type);
printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
WARN_ON(1);
}
not_found:
......@@ -4093,7 +4089,11 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
insert:
btrfs_release_path(root, path);
if (em->start > start || extent_map_end(em) <= start) {
printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->len, start, len);
printk(KERN_ERR "Btrfs: bad extent! em: [%llu %llu] passed "
"[%llu %llu]\n", (unsigned long long)em->start,
(unsigned long long)em->len,
(unsigned long long)start,
(unsigned long long)len);
err = -EIO;
goto out;
}
......@@ -4130,8 +4130,6 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
}
} else {
err = -EIO;
printk("failing to insert %Lu %Lu\n",
start, len);
free_extent_map(em);
em = NULL;
}
......@@ -4147,9 +4145,8 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
btrfs_free_path(path);
if (trans) {
ret = btrfs_end_transaction(trans, root);
if (!err) {
if (!err)
err = ret;
}
}
if (err) {
free_extent_map(em);
......@@ -4482,13 +4479,15 @@ void btrfs_destroy_inode(struct inode *inode)
}
spin_unlock(&BTRFS_I(inode)->root->list_lock);
while(1) {
while (1) {
ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
if (!ordered)
break;
else {
printk("found ordered extent %Lu %Lu\n",
ordered->file_offset, ordered->len);
printk(KERN_ERR "btrfs found ordered "
"extent %llu %llu on inode cleanup\n",
(unsigned long long)ordered->file_offset,
(unsigned long long)ordered->len);
btrfs_remove_ordered_extent(inode, ordered);
btrfs_put_ordered_extent(ordered);
btrfs_put_ordered_extent(ordered);
......@@ -4572,8 +4571,8 @@ static int btrfs_getattr(struct vfsmount *mnt,
return 0;
}
static int btrfs_rename(struct inode * old_dir, struct dentry *old_dentry,
struct inode * new_dir,struct dentry *new_dentry)
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
struct btrfs_trans_handle *trans;
struct btrfs_root *root = BTRFS_I(old_dir)->root;
......@@ -4663,7 +4662,7 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root)
return -EROFS;
spin_lock(&root->fs_info->delalloc_lock);
while(!list_empty(head)) {
while (!list_empty(head)) {
binode = list_entry(head->next, struct btrfs_inode,
delalloc_inodes);
inode = igrab(&binode->vfs_inode);
......@@ -4684,7 +4683,7 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root)
* ordered extents get created before we return
*/
atomic_inc(&root->fs_info->async_submit_draining);
while(atomic_read(&root->fs_info->nr_async_submits) ||
while (atomic_read(&root->fs_info->nr_async_submits) ||
atomic_read(&root->fs_info->async_delalloc_pages)) {
wait_event(root->fs_info->async_submit_wait,
(atomic_read(&root->fs_info->nr_async_submits) == 0 &&
......
fs/btrfs/ioctl.c
浏览文件 @ d397712b
......@@ -311,7 +311,7 @@ static noinline int btrfs_mksubvol(struct path *parent, char *name,
* to see if is references the subvolume where we are
* placing this new snapshot.
*/
while(1) {
while (1) {
if (!test ||
dir == snap_src->fs_info->sb->s_root ||
test == snap_src->fs_info->sb->s_root ||
......@@ -319,7 +319,8 @@ static noinline int btrfs_mksubvol(struct path *parent, char *name,
break;
}
if (S_ISLNK(test->d_inode->i_mode)) {
printk("Symlink in snapshot path, failed\n");
printk(KERN_INFO "Btrfs symlink in snapshot "
"path, failed\n");
error = -EMLINK;
btrfs_free_path(path);
goto out_drop_write;
......@@ -329,7 +330,8 @@ static noinline int btrfs_mksubvol(struct path *parent, char *name,
ret = btrfs_find_root_ref(snap_src->fs_info->tree_root,
path, test_oid, parent_oid);
if (ret == 0) {
printk("Snapshot creation failed, looping\n");
printk(KERN_INFO "Btrfs snapshot creation "
"failed, looping\n");
error = -EMLINK;
btrfs_free_path(path);
goto out_drop_write;
......@@ -617,7 +619,8 @@ static noinline int btrfs_ioctl_snap_create(struct file *file,
src_inode = src_file->f_path.dentry->d_inode;
if (src_inode->i_sb != file->f_path.dentry->d_inode->i_sb) {
printk("btrfs: Snapshot src from another FS\n");
printk(KERN_INFO "btrfs: Snapshot src from "
"another FS\n");
ret = -EINVAL;
fput(src_file);
goto out;
......@@ -810,9 +813,6 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
((off + len) & (bs-1)))
goto out_unlock;
printk("final src extent is %llu~%llu\n", off, len);
printk("final dst extent is %llu~%llu\n", destoff, len);
/* do any pending delalloc/csum calc on src, one way or
another, and lock file content */
while (1) {
......@@ -883,10 +883,13 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
comp = btrfs_file_extent_compression(leaf, extent);
type = btrfs_file_extent_type(leaf, extent);
if (type == BTRFS_FILE_EXTENT_REG) {
disko = btrfs_file_extent_disk_bytenr(leaf, extent);
diskl = btrfs_file_extent_disk_num_bytes(leaf, extent);
disko = btrfs_file_extent_disk_bytenr(leaf,
extent);
diskl = btrfs_file_extent_disk_num_bytes(leaf,
extent);
datao = btrfs_file_extent_offset(leaf, extent);
datal = btrfs_file_extent_num_bytes(leaf, extent);
datal = btrfs_file_extent_num_bytes(leaf,
extent);
} else if (type == BTRFS_FILE_EXTENT_INLINE) {
/* take upper bound, may be compressed */
datal = btrfs_file_extent_ram_bytes(leaf,
......@@ -916,8 +919,6 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
extent = btrfs_item_ptr(leaf, slot,
struct btrfs_file_extent_item);
printk(" orig disk %llu~%llu data %llu~%llu\n",
disko, diskl, datao, datal);
if (off > key.offset) {
datao += off - key.offset;
......@@ -929,8 +930,6 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
/* disko == 0 means it's a hole */
if (!disko)
datao = 0;
printk(" final disk %llu~%llu data %llu~%llu\n",
disko, diskl, datao, datal);
btrfs_set_file_extent_offset(leaf, extent,
datao);
......@@ -952,12 +951,11 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
skip = off - key.offset;
new_key.offset += skip;
}
if (key.offset + datal > off+len)
trim = key.offset + datal - (off+len);
printk("len %lld skip %lld trim %lld\n",
datal, skip, trim);
if (comp && (skip || trim)) {
printk("btrfs clone_range can't split compressed inline extents yet\n");
ret = -EINVAL;
goto out;
}
......@@ -969,7 +967,8 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
goto out;
if (skip) {
u32 start = btrfs_file_extent_calc_inline_size(0);
u32 start =
btrfs_file_extent_calc_inline_size(0);
memmove(buf+start, buf+start+skip,
datal);
}
......@@ -985,7 +984,7 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
btrfs_mark_buffer_dirty(leaf);
}
next:
next:
btrfs_release_path(root, path);
key.offset++;
}
......
fs/btrfs/locking.c
浏览文件 @ d397712b
......@@ -31,9 +31,10 @@
* difference in almost every workload, but spinning for the right amount of
* time needs some help.
*
* In general, we want to spin as long as the lock holder is doing btree searches,
* and we should give up if they are in more expensive code.
* In general, we want to spin as long as the lock holder is doing btree
* searches, and we should give up if they are in more expensive code.
*/
int btrfs_tree_lock(struct extent_buffer *eb)
{
int i;
......
fs/btrfs/ordered-data.c
浏览文件 @ d397712b
......@@ -39,11 +39,11 @@ static u64 entry_end(struct btrfs_ordered_extent *entry)
static struct rb_node *tree_insert(struct rb_root *root, u64 file_offset,
struct rb_node *node)
{
struct rb_node ** p = &root->rb_node;
struct rb_node * parent = NULL;
struct rb_node **p = &root->rb_node;
struct rb_node *parent = NULL;
struct btrfs_ordered_extent *entry;
while(*p) {
while (*p) {
parent = *p;
entry = rb_entry(parent, struct btrfs_ordered_extent, rb_node);
......@@ -67,13 +67,13 @@ static struct rb_node *tree_insert(struct rb_root *root, u64 file_offset,
static struct rb_node *__tree_search(struct rb_root *root, u64 file_offset,
struct rb_node **prev_ret)
{
struct rb_node * n = root->rb_node;
struct rb_node *n = root->rb_node;
struct rb_node *prev = NULL;
struct rb_node *test;
struct btrfs_ordered_extent *entry;
struct btrfs_ordered_extent *prev_entry = NULL;
while(n) {
while (n) {
entry = rb_entry(n, struct btrfs_ordered_extent, rb_node);
prev = n;
prev_entry = entry;
......@@ -88,7 +88,7 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 file_offset,
if (!prev_ret)
return NULL;
while(prev && file_offset >= entry_end(prev_entry)) {
while (prev && file_offset >= entry_end(prev_entry)) {
test = rb_next(prev);
if (!test)
break;
......@@ -102,7 +102,7 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 file_offset,
if (prev)
prev_entry = rb_entry(prev, struct btrfs_ordered_extent,
rb_node);
while(prev && file_offset < entry_end(prev_entry)) {
while (prev && file_offset < entry_end(prev_entry)) {
test = rb_prev(prev);
if (!test)
break;
......@@ -193,10 +193,8 @@ int btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
node = tree_insert(&tree->tree, file_offset,
&entry->rb_node);
if (node) {
printk("warning dup entry from add_ordered_extent\n");
BUG();
}
BUG_ON(node);
set_extent_ordered(&BTRFS_I(inode)->io_tree, file_offset,
entry_end(entry) - 1, GFP_NOFS);
......@@ -282,7 +280,7 @@ int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
struct btrfs_ordered_sum *sum;
if (atomic_dec_and_test(&entry->refs)) {
while(!list_empty(&entry->list)) {
while (!list_empty(&entry->list)) {
cur = entry->list.next;
sum = list_entry(cur, struct btrfs_ordered_sum, list);
list_del(&sum->list);
......@@ -432,11 +430,10 @@ int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
orig_end >> PAGE_CACHE_SHIFT);
end = orig_end;
while(1) {
while (1) {
ordered = btrfs_lookup_first_ordered_extent(inode, end);
if (!ordered) {
if (!ordered)
break;
}
if (ordered->file_offset > orig_end) {
btrfs_put_ordered_extent(ordered);
break;
......@@ -492,7 +489,7 @@ struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode,
* if none is found
*/
struct btrfs_ordered_extent *
btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset)
btrfs_lookup_first_ordered_extent(struct inode *inode, u64 file_offset)
{
struct btrfs_ordered_inode_tree *tree;
struct rb_node *node;
......@@ -553,7 +550,7 @@ int btrfs_ordered_update_i_size(struct inode *inode,
* yet
*/
node = &ordered->rb_node;
while(1) {
while (1) {
node = rb_prev(node);
if (!node)
break;
......@@ -581,9 +578,8 @@ int btrfs_ordered_update_i_size(struct inode *inode,
* between our ordered extent and the next one.
*/
test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
if (test->file_offset > entry_end(ordered)) {
if (test->file_offset > entry_end(ordered))
i_size_test = test->file_offset;
}
} else {
i_size_test = i_size_read(inode);
}
......
fs/btrfs/print-tree.c
浏览文件 @ d397712b
......@@ -24,13 +24,14 @@ static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk)
{
int num_stripes = btrfs_chunk_num_stripes(eb, chunk);
int i;
printk("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n",
printk(KERN_INFO "\t\tchunk length %llu owner %llu type %llu "
"num_stripes %d\n",
(unsigned long long)btrfs_chunk_length(eb, chunk),
(unsigned long long)btrfs_chunk_owner(eb, chunk),
(unsigned long long)btrfs_chunk_type(eb, chunk),
num_stripes);
for (i = 0 ; i < num_stripes ; i++) {
printk("\t\t\tstripe %d devid %llu offset %llu\n", i,
printk(KERN_INFO "\t\t\tstripe %d devid %llu offset %llu\n", i,
(unsigned long long)btrfs_stripe_devid_nr(eb, chunk, i),
(unsigned long long)btrfs_stripe_offset_nr(eb, chunk, i));
}
......@@ -38,8 +39,8 @@ static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk)
static void print_dev_item(struct extent_buffer *eb,
struct btrfs_dev_item *dev_item)
{
printk("\t\tdev item devid %llu "
"total_bytes %llu bytes used %Lu\n",
printk(KERN_INFO "\t\tdev item devid %llu "
"total_bytes %llu bytes used %llu\n",
(unsigned long long)btrfs_device_id(eb, dev_item),
(unsigned long long)btrfs_device_total_bytes(eb, dev_item),
(unsigned long long)btrfs_device_bytes_used(eb, dev_item));
......@@ -61,14 +62,15 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
struct btrfs_dev_extent *dev_extent;
u32 type;
printk("leaf %llu total ptrs %d free space %d\n",
printk(KERN_INFO "leaf %llu total ptrs %d free space %d\n",
(unsigned long long)btrfs_header_bytenr(l), nr,
btrfs_leaf_free_space(root, l));
for (i = 0 ; i < nr ; i++) {
item = btrfs_item_nr(l, i);
btrfs_item_key_to_cpu(l, &key, i);
type = btrfs_key_type(&key);
printk("\titem %d key (%llu %x %llu) itemoff %d itemsize %d\n",
printk(KERN_INFO "\titem %d key (%llu %x %llu) itemoff %d "
"itemsize %d\n",
i,
(unsigned long long)key.objectid, type,
(unsigned long long)key.offset,
......@@ -76,33 +78,36 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
switch (type) {
case BTRFS_INODE_ITEM_KEY:
ii = btrfs_item_ptr(l, i, struct btrfs_inode_item);
printk("\t\tinode generation %llu size %llu mode %o\n",
(unsigned long long)btrfs_inode_generation(l, ii),
printk(KERN_INFO "\t\tinode generation %llu size %llu "
"mode %o\n",
(unsigned long long)
btrfs_inode_generation(l, ii),
(unsigned long long)btrfs_inode_size(l, ii),
btrfs_inode_mode(l, ii));
break;
case BTRFS_DIR_ITEM_KEY:
di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
btrfs_dir_item_key_to_cpu(l, di, &found_key);
printk("\t\tdir oid %llu type %u\n",
printk(KERN_INFO "\t\tdir oid %llu type %u\n",
(unsigned long long)found_key.objectid,
btrfs_dir_type(l, di));
break;
case BTRFS_ROOT_ITEM_KEY:
ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
printk("\t\troot data bytenr %llu refs %u\n",
(unsigned long long)btrfs_disk_root_bytenr(l, ri),
printk(KERN_INFO "\t\troot data bytenr %llu refs %u\n",
(unsigned long long)
btrfs_disk_root_bytenr(l, ri),
btrfs_disk_root_refs(l, ri));
break;
case BTRFS_EXTENT_ITEM_KEY:
ei = btrfs_item_ptr(l, i, struct btrfs_extent_item);
printk("\t\textent data refs %u\n",
printk(KERN_INFO "\t\textent data refs %u\n",
btrfs_extent_refs(l, ei));
break;
case BTRFS_EXTENT_REF_KEY:
ref = btrfs_item_ptr(l, i, struct btrfs_extent_ref);
printk("\t\textent back ref root %llu gen %llu "
"owner %llu num_refs %lu\n",
printk(KERN_INFO "\t\textent back ref root %llu "
"gen %llu owner %llu num_refs %lu\n",
(unsigned long long)btrfs_ref_root(l, ref),
(unsigned long long)btrfs_ref_generation(l, ref),
(unsigned long long)btrfs_ref_objectid(l, ref),
......@@ -114,26 +119,36 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
struct btrfs_file_extent_item);
if (btrfs_file_extent_type(l, fi) ==
BTRFS_FILE_EXTENT_INLINE) {
printk("\t\tinline extent data size %u\n",
btrfs_file_extent_inline_len(l, fi));
printk(KERN_INFO "\t\tinline extent data "
"size %u\n",
btrfs_file_extent_inline_len(l, fi));
break;
}
printk("\t\textent data disk bytenr %llu nr %llu\n",
(unsigned long long)btrfs_file_extent_disk_bytenr(l, fi),
(unsigned long long)btrfs_file_extent_disk_num_bytes(l, fi));
printk("\t\textent data offset %llu nr %llu ram %llu\n",
(unsigned long long)btrfs_file_extent_offset(l, fi),
(unsigned long long)btrfs_file_extent_num_bytes(l, fi),
(unsigned long long)btrfs_file_extent_ram_bytes(l, fi));
printk(KERN_INFO "\t\textent data disk bytenr %llu "
"nr %llu\n",
(unsigned long long)
btrfs_file_extent_disk_bytenr(l, fi),
(unsigned long long)
btrfs_file_extent_disk_num_bytes(l, fi));
printk(KERN_INFO "\t\textent data offset %llu "
"nr %llu ram %llu\n",
(unsigned long long)
btrfs_file_extent_offset(l, fi),
(unsigned long long)
btrfs_file_extent_num_bytes(l, fi),
(unsigned long long)
btrfs_file_extent_ram_bytes(l, fi));
break;
case BTRFS_BLOCK_GROUP_ITEM_KEY:
bi = btrfs_item_ptr(l, i,
struct btrfs_block_group_item);
printk("\t\tblock group used %llu\n",
(unsigned long long)btrfs_disk_block_group_used(l, bi));
printk(KERN_INFO "\t\tblock group used %llu\n",
(unsigned long long)
btrfs_disk_block_group_used(l, bi));
break;
case BTRFS_CHUNK_ITEM_KEY:
print_chunk(l, btrfs_item_ptr(l, i, struct btrfs_chunk));
print_chunk(l, btrfs_item_ptr(l, i,
struct btrfs_chunk));
break;
case BTRFS_DEV_ITEM_KEY:
print_dev_item(l, btrfs_item_ptr(l, i,
......@@ -142,7 +157,7 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
case BTRFS_DEV_EXTENT_KEY:
dev_extent = btrfs_item_ptr(l, i,
struct btrfs_dev_extent);
printk("\t\tdev extent chunk_tree %llu\n"
printk(KERN_INFO "\t\tdev extent chunk_tree %llu\n"
"\t\tchunk objectid %llu chunk offset %llu "
"length %llu\n",
(unsigned long long)
......@@ -171,13 +186,13 @@ void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *c)
btrfs_print_leaf(root, c);
return;
}
printk("node %llu level %d total ptrs %d free spc %u\n",
printk(KERN_INFO "node %llu level %d total ptrs %d free spc %u\n",
(unsigned long long)btrfs_header_bytenr(c),
btrfs_header_level(c), nr,
(u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr);
for (i = 0; i < nr; i++) {
btrfs_node_key_to_cpu(c, &key, i);
printk("\tkey %d (%llu %u %llu) block %llu\n",
printk(KERN_INFO "\tkey %d (%llu %u %llu) block %llu\n",
i,
(unsigned long long)key.objectid,
key.type,
......
fs/btrfs/ref-cache.c
浏览文件 @ d397712b
......@@ -74,11 +74,11 @@ void btrfs_free_leaf_ref(struct btrfs_root *root, struct btrfs_leaf_ref *ref)
static struct rb_node *tree_insert(struct rb_root *root, u64 bytenr,
struct rb_node *node)
{
struct rb_node ** p = &root->rb_node;
struct rb_node * parent = NULL;
struct rb_node **p = &root->rb_node;
struct rb_node *parent = NULL;
struct btrfs_leaf_ref *entry;
while(*p) {
while (*p) {
parent = *p;
entry = rb_entry(parent, struct btrfs_leaf_ref, rb_node);
......@@ -98,10 +98,10 @@ static struct rb_node *tree_insert(struct rb_root *root, u64 bytenr,
static struct rb_node *tree_search(struct rb_root *root, u64 bytenr)
{
struct rb_node * n = root->rb_node;
struct rb_node *n = root->rb_node;
struct btrfs_leaf_ref *entry;
while(n) {
while (n) {
entry = rb_entry(n, struct btrfs_leaf_ref, rb_node);
WARN_ON(!entry->in_tree);
......@@ -127,7 +127,7 @@ int btrfs_remove_leaf_refs(struct btrfs_root *root, u64 max_root_gen,
return 0;
spin_lock(&tree->lock);
while(!list_empty(&tree->list)) {
while (!list_empty(&tree->list)) {
ref = list_entry(tree->list.next, struct btrfs_leaf_ref, list);
BUG_ON(ref->tree != tree);
if (ref->root_gen > max_root_gen)
......
fs/btrfs/root-tree.c
浏览文件 @ d397712b
......@@ -132,8 +132,9 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
if (ret != 0) {
btrfs_print_leaf(root, path->nodes[0]);
printk("unable to update root key %Lu %u %Lu\n",
key->objectid, key->type, key->offset);
printk(KERN_CRIT "unable to update root key %llu %u %llu\n",
(unsigned long long)key->objectid, key->type,
(unsigned long long)key->offset);
BUG_ON(1);
}
......@@ -159,9 +160,9 @@ int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
/*
* at mount time we want to find all the old transaction snapshots that were in
* the process of being deleted if we crashed. This is any root item with an offset
* lower than the latest root. They need to be queued for deletion to finish
* what was happening when we crashed.
* the process of being deleted if we crashed. This is any root item with an
* offset lower than the latest root. They need to be queued for deletion to
* finish what was happening when we crashed.
*/
int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid,
struct btrfs_root *latest)
......@@ -188,7 +189,7 @@ int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid,
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
if (ret < 0)
goto err;
while(1) {
while (1) {
leaf = path->nodes[0];
nritems = btrfs_header_nritems(leaf);
slot = path->slots[0];
......@@ -258,11 +259,7 @@ int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
ret = btrfs_search_slot(trans, root, key, path, -1, 1);
if (ret < 0)
goto out;
if (ret) {
btrfs_print_leaf(root, path->nodes[0]);
printk("failed to del %Lu %u %Lu\n", key->objectid, key->type, key->offset);
}
BUG_ON(ret != 0);
leaf = path->nodes[0];
ri = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_item);
......
fs/btrfs/struct-funcs.c
浏览文件 @ d397712b
......@@ -66,7 +66,7 @@ u##bits btrfs_##name(struct extent_buffer *eb, \
unsigned long map_len; \
u##bits res; \
err = map_extent_buffer(eb, offset, \
sizeof(((type *)0)->member), \
sizeof(((type *)0)->member), \
&map_token, &kaddr, \
&map_start, &map_len, KM_USER1); \
if (err) { \
......@@ -103,7 +103,7 @@ void btrfs_set_##name(struct extent_buffer *eb, \
unsigned long map_start; \
unsigned long map_len; \
err = map_extent_buffer(eb, offset, \
sizeof(((type *)0)->member), \
sizeof(((type *)0)->member), \
&map_token, &kaddr, \
&map_start, &map_len, KM_USER1); \
if (err) { \
......
fs/btrfs/super.c
浏览文件 @ d397712b
......@@ -55,18 +55,12 @@
static struct super_operations btrfs_super_ops;
static void btrfs_put_super (struct super_block * sb)
static void btrfs_put_super(struct super_block *sb)
{
struct btrfs_root *root = btrfs_sb(sb);
int ret;
ret = close_ctree(root);
if (ret) {
printk("close ctree returns %d\n", ret);
}
#if 0
btrfs_sysfs_del_super(root->fs_info);
#endif
sb->s_fs_info = NULL;
}
......@@ -299,12 +293,12 @@ static int btrfs_parse_early_options(const char *options, fmode_t flags,
return error;
}
static int btrfs_fill_super(struct super_block * sb,
static int btrfs_fill_super(struct super_block *sb,
struct btrfs_fs_devices *fs_devices,
void * data, int silent)
void *data, int silent)
{
struct inode * inode;
struct dentry * root_dentry;
struct inode *inode;
struct dentry *root_dentry;
struct btrfs_super_block *disk_super;
struct btrfs_root *tree_root;
struct btrfs_inode *bi;
......@@ -479,8 +473,10 @@ static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
root = dget(s->s_root);
else {
mutex_lock(&s->s_root->d_inode->i_mutex);
root = lookup_one_len(subvol_name, s->s_root, strlen(subvol_name));
root = lookup_one_len(subvol_name, s->s_root,
strlen(subvol_name));
mutex_unlock(&s->s_root->d_inode->i_mutex);
if (IS_ERR(root)) {
up_write(&s->s_umount);
deactivate_super(s);
......@@ -557,8 +553,9 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
buf->f_bavail = buf->f_bfree;
buf->f_bsize = dentry->d_sb->s_blocksize;
buf->f_type = BTRFS_SUPER_MAGIC;
/* We treat it as constant endianness (it doesn't matter _which_)
because we want the fsid to come out the same whether mounted
because we want the fsid to come out the same whether mounted
on a big-endian or little-endian host */
buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
......@@ -658,7 +655,7 @@ static int btrfs_interface_init(void)
static void btrfs_interface_exit(void)
{
if (misc_deregister(&btrfs_misc) < 0)
printk("misc_deregister failed for control device");
printk(KERN_INFO "misc_deregister failed for control device");
}
static int __init init_btrfs_fs(void)
......
fs/btrfs/sysfs.c
浏览文件 @ d397712b
......@@ -67,7 +67,8 @@ struct btrfs_root_attr {
};
#define ROOT_ATTR(name, mode, show, store) \
static struct btrfs_root_attr btrfs_root_attr_##name = __ATTR(name, mode, show, store)
static struct btrfs_root_attr btrfs_root_attr_##name = __ATTR(name, mode, \
show, store)
ROOT_ATTR(blocks_used, 0444, root_blocks_used_show, NULL);
ROOT_ATTR(block_limit, 0644, root_block_limit_show, NULL);
......@@ -86,7 +87,8 @@ struct btrfs_super_attr {
};
#define SUPER_ATTR(name, mode, show, store) \
static struct btrfs_super_attr btrfs_super_attr_##name = __ATTR(name, mode, show, store)
static struct btrfs_super_attr btrfs_super_attr_##name = __ATTR(name, mode, \
show, store)
SUPER_ATTR(blocks_used, 0444, super_blocks_used_show, NULL);
SUPER_ATTR(total_blocks, 0444, super_total_blocks_show, NULL);
......
fs/btrfs/transaction.c
浏览文件 @ d397712b
......@@ -28,9 +28,6 @@
#include "ref-cache.h"
#include "tree-log.h"
extern struct kmem_cache *btrfs_trans_handle_cachep;
extern struct kmem_cache *btrfs_transaction_cachep;
#define BTRFS_ROOT_TRANS_TAG 0
static noinline void put_transaction(struct btrfs_transaction *transaction)
......@@ -85,10 +82,10 @@ static noinline int join_transaction(struct btrfs_root *root)
}
/*
* this does all the record keeping required to make sure that a
* reference counted root is properly recorded in a given transaction.
* This is required to make sure the old root from before we joined the transaction
* is deleted when the transaction commits
* this does all the record keeping required to make sure that a reference
* counted root is properly recorded in a given transaction. This is required
* to make sure the old root from before we joined the transaction is deleted
* when the transaction commits
*/
noinline int btrfs_record_root_in_trans(struct btrfs_root *root)
{
......@@ -144,7 +141,7 @@ static void wait_current_trans(struct btrfs_root *root)
if (cur_trans && cur_trans->blocked) {
DEFINE_WAIT(wait);
cur_trans->use_count++;
while(1) {
while (1) {
prepare_to_wait(&root->fs_info->transaction_wait, &wait,
TASK_UNINTERRUPTIBLE);
if (cur_trans->blocked) {
......@@ -213,7 +210,7 @@ static noinline int wait_for_commit(struct btrfs_root *root,
{
DEFINE_WAIT(wait);
mutex_lock(&root->fs_info->trans_mutex);
while(!commit->commit_done) {
while (!commit->commit_done) {
prepare_to_wait(&commit->commit_wait, &wait,
TASK_UNINTERRUPTIBLE);
if (commit->commit_done)
......@@ -228,8 +225,8 @@ static noinline int wait_for_commit(struct btrfs_root *root,
}
/*
* rate limit against the drop_snapshot code. This helps to slow down new operations
* if the drop_snapshot code isn't able to keep up.
* rate limit against the drop_snapshot code. This helps to slow down new
* operations if the drop_snapshot code isn't able to keep up.
*/
static void throttle_on_drops(struct btrfs_root *root)
{
......@@ -332,12 +329,12 @@ int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
u64 end;
unsigned long index;
while(1) {
while (1) {
ret = find_first_extent_bit(dirty_pages, start, &start, &end,
EXTENT_DIRTY);
if (ret)
break;
while(start <= end) {
while (start <= end) {
cond_resched();
index = start >> PAGE_CACHE_SHIFT;
......@@ -368,14 +365,14 @@ int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
page_cache_release(page);
}
}
while(1) {
while (1) {
ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
EXTENT_DIRTY);
if (ret)
break;
clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
while(start <= end) {
while (start <= end) {
index = start >> PAGE_CACHE_SHIFT;
start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
page = find_get_page(btree_inode->i_mapping, index);
......@@ -431,7 +428,7 @@ static int update_cowonly_root(struct btrfs_trans_handle *trans,
btrfs_write_dirty_block_groups(trans, root);
btrfs_extent_post_op(trans, root);
while(1) {
while (1) {
old_root_bytenr = btrfs_root_bytenr(&root->root_item);
if (old_root_bytenr == root->node->start)
break;
......@@ -472,7 +469,7 @@ int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
btrfs_extent_post_op(trans, fs_info->tree_root);
while(!list_empty(&fs_info->dirty_cowonly_roots)) {
while (!list_empty(&fs_info->dirty_cowonly_roots)) {
next = fs_info->dirty_cowonly_roots.next;
list_del_init(next);
root = list_entry(next, struct btrfs_root, dirty_list);
......@@ -521,7 +518,7 @@ static noinline int add_dirty_roots(struct btrfs_trans_handle *trans,
int err = 0;
u32 refs;
while(1) {
while (1) {
ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
ARRAY_SIZE(gang),
BTRFS_ROOT_TRANS_TAG);
......@@ -653,7 +650,7 @@ static noinline int drop_dirty_roots(struct btrfs_root *tree_root,
int ret = 0;
int err;
while(!list_empty(list)) {
while (!list_empty(list)) {
struct btrfs_root *root;
dirty = list_entry(list->prev, struct btrfs_dirty_root, list);
......@@ -663,13 +660,12 @@ static noinline int drop_dirty_roots(struct btrfs_root *tree_root,
root = dirty->latest_root;
atomic_inc(&root->fs_info->throttles);
while(1) {
while (1) {
trans = btrfs_start_transaction(tree_root, 1);
mutex_lock(&root->fs_info->drop_mutex);
ret = btrfs_drop_snapshot(trans, dirty->root);
if (ret != -EAGAIN) {
if (ret != -EAGAIN)
break;
}
mutex_unlock(&root->fs_info->drop_mutex);
err = btrfs_update_root(trans,
......@@ -874,7 +870,7 @@ static noinline int finish_pending_snapshots(struct btrfs_trans_handle *trans,
struct list_head *head = &trans->transaction->pending_snapshots;
int ret;
while(!list_empty(head)) {
while (!list_empty(head)) {
pending = list_entry(head->next,
struct btrfs_pending_snapshot, list);
ret = finish_pending_snapshot(fs_info, pending);
......@@ -1076,9 +1072,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
kmem_cache_free(btrfs_trans_handle_cachep, trans);
if (root->fs_info->closing) {
if (root->fs_info->closing)
drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
}
return ret;
}
......
fs/btrfs/transaction.h
浏览文件 @ d397712b
......@@ -66,9 +66,9 @@ static inline void btrfs_set_trans_block_group(struct btrfs_trans_handle *trans,
trans->block_group = BTRFS_I(inode)->block_group;
}
static inline void btrfs_update_inode_block_group(struct
btrfs_trans_handle *trans,
struct inode *inode)
static inline void btrfs_update_inode_block_group(
struct btrfs_trans_handle *trans,
struct inode *inode)
{
BTRFS_I(inode)->block_group = trans->block_group;
}
......
fs/btrfs/tree-defrag.c
浏览文件 @ d397712b
......@@ -23,10 +23,11 @@
#include "transaction.h"
#include "locking.h"
/* defrag all the leaves in a given btree. If cache_only == 1, don't read things
* from disk, otherwise read all the leaves and try to get key order to
/* defrag all the leaves in a given btree. If cache_only == 1, don't read
* things from disk, otherwise read all the leaves and try to get key order to
* better reflect disk order
*/
int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
struct btrfs_root *root, int cache_only)
{
......@@ -65,9 +66,9 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
level = btrfs_header_level(root->node);
orig_level = level;
if (level == 0) {
if (level == 0)
goto out;
}
if (root->defrag_progress.objectid == 0) {
struct extent_buffer *root_node;
u32 nritems;
......
fs/btrfs/tree-log.c
浏览文件 @ d397712b
......@@ -829,7 +829,7 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
*/
ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
while(ptr < ptr_end) {
while (ptr < ptr_end) {
victim_ref = (struct btrfs_inode_ref *)ptr;
victim_name_len = btrfs_inode_ref_name_len(leaf,
victim_ref);
......@@ -938,9 +938,8 @@ static noinline int replay_one_csum(struct btrfs_trans_handle *trans,
file_bytes = (item_size / csum_size) * root->sectorsize;
sums = kzalloc(btrfs_ordered_sum_size(root, file_bytes), GFP_NOFS);
if (!sums) {
if (!sums)
return -ENOMEM;
}
INIT_LIST_HEAD(&sums->list);
sums->len = file_bytes;
......@@ -952,7 +951,7 @@ static noinline int replay_one_csum(struct btrfs_trans_handle *trans,
sector_sum = sums->sums;
cur_offset = key->offset;
ptr = btrfs_item_ptr_offset(eb, slot);
while(item_size > 0) {
while (item_size > 0) {
sector_sum->bytenr = cur_offset;
read_extent_buffer(eb, &sector_sum->sum, ptr, csum_size);
sector_sum++;
......@@ -995,7 +994,7 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
path = btrfs_alloc_path();
while(1) {
while (1) {
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
if (ret < 0)
break;
......@@ -1012,7 +1011,7 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
path->slots[0]);
while(ptr < ptr_end) {
while (ptr < ptr_end) {
struct btrfs_inode_ref *ref;
ref = (struct btrfs_inode_ref *)ptr;
......@@ -1048,7 +1047,7 @@ static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
key.type = BTRFS_ORPHAN_ITEM_KEY;
key.offset = (u64)-1;
while(1) {
while (1) {
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
if (ret < 0)
break;
......@@ -1206,8 +1205,7 @@ static noinline int replay_one_name(struct btrfs_trans_handle *trans,
if (key->type == BTRFS_DIR_ITEM_KEY) {
dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
name, name_len, 1);
}
else if (key->type == BTRFS_DIR_INDEX_KEY) {
} else if (key->type == BTRFS_DIR_INDEX_KEY) {
dst_di = btrfs_lookup_dir_index_item(trans, root, path,
key->objectid,
key->offset, name,
......@@ -1282,7 +1280,7 @@ static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
ptr = btrfs_item_ptr_offset(eb, slot);
ptr_end = ptr + item_size;
while(ptr < ptr_end) {
while (ptr < ptr_end) {
di = (struct btrfs_dir_item *)ptr;
name_len = btrfs_dir_name_len(eb, di);
ret = replay_one_name(trans, root, path, eb, di, key);
......@@ -1408,7 +1406,7 @@ static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
item_size = btrfs_item_size_nr(eb, slot);
ptr = btrfs_item_ptr_offset(eb, slot);
ptr_end = ptr + item_size;
while(ptr < ptr_end) {
while (ptr < ptr_end) {
di = (struct btrfs_dir_item *)ptr;
name_len = btrfs_dir_name_len(eb, di);
name = kmalloc(name_len, GFP_NOFS);
......@@ -1513,14 +1511,14 @@ static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
again:
range_start = 0;
range_end = 0;
while(1) {
while (1) {
ret = find_dir_range(log, path, dirid, key_type,
&range_start, &range_end);
if (ret != 0)
break;
dir_key.offset = range_start;
while(1) {
while (1) {
int nritems;
ret = btrfs_search_slot(NULL, root, &dir_key, path,
0, 0);
......@@ -1676,7 +1674,7 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
return 0;
}
static int noinline walk_down_log_tree(struct btrfs_trans_handle *trans,
static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_path *path, int *level,
struct walk_control *wc)
......@@ -1694,7 +1692,7 @@ static int noinline walk_down_log_tree(struct btrfs_trans_handle *trans,
WARN_ON(*level < 0);
WARN_ON(*level >= BTRFS_MAX_LEVEL);
while(*level > 0) {
while (*level > 0) {
WARN_ON(*level < 0);
WARN_ON(*level >= BTRFS_MAX_LEVEL);
cur = path->nodes[*level];
......@@ -1753,11 +1751,11 @@ static int noinline walk_down_log_tree(struct btrfs_trans_handle *trans,
WARN_ON(*level < 0);
WARN_ON(*level >= BTRFS_MAX_LEVEL);
if (path->nodes[*level] == root->node) {
if (path->nodes[*level] == root->node)
parent = path->nodes[*level];
} else {
else
parent = path->nodes[*level + 1];
}
bytenr = path->nodes[*level]->start;
blocksize = btrfs_level_size(root, *level);
......@@ -1790,7 +1788,7 @@ static int noinline walk_down_log_tree(struct btrfs_trans_handle *trans,
return 0;
}
static int noinline walk_up_log_tree(struct btrfs_trans_handle *trans,
static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_path *path, int *level,
struct walk_control *wc)
......@@ -1801,7 +1799,7 @@ static int noinline walk_up_log_tree(struct btrfs_trans_handle *trans,
int slot;
int ret;
for(i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
slot = path->slots[i];
if (slot < btrfs_header_nritems(path->nodes[i]) - 1) {
struct extent_buffer *node;
......@@ -1875,7 +1873,7 @@ static int walk_log_tree(struct btrfs_trans_handle *trans,
extent_buffer_get(log->node);
path->slots[level] = 0;
while(1) {
while (1) {
wret = walk_down_log_tree(trans, log, path, &level, wc);
if (wret > 0)
break;
......@@ -1941,7 +1939,7 @@ static int wait_log_commit(struct btrfs_root *log)
schedule();
finish_wait(&log->fs_info->tree_log_wait, &wait);
mutex_lock(&log->fs_info->tree_log_mutex);
} while(transid == log->fs_info->tree_log_transid &&
} while (transid == log->fs_info->tree_log_transid &&
atomic_read(&log->fs_info->tree_log_commit));
return 0;
}
......@@ -1965,13 +1963,13 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
}
atomic_set(&log->fs_info->tree_log_commit, 1);
while(1) {
while (1) {
batch = log->fs_info->tree_log_batch;
mutex_unlock(&log->fs_info->tree_log_mutex);
schedule_timeout_uninterruptible(1);
mutex_lock(&log->fs_info->tree_log_mutex);
while(atomic_read(&log->fs_info->tree_log_writers)) {
while (atomic_read(&log->fs_info->tree_log_writers)) {
DEFINE_WAIT(wait);
prepare_to_wait(&log->fs_info->tree_log_wait, &wait,
TASK_UNINTERRUPTIBLE);
......@@ -2030,7 +2028,7 @@ int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
ret = walk_log_tree(trans, log, &wc);
BUG_ON(ret);
while(1) {
while (1) {
ret = find_first_extent_bit(&log->dirty_log_pages,
0, &start, &end, EXTENT_DIRTY);
if (ret)
......@@ -2287,9 +2285,8 @@ static noinline int log_dir_items(struct btrfs_trans_handle *trans,
struct btrfs_key tmp;
btrfs_item_key_to_cpu(path->nodes[0], &tmp,
path->slots[0]);
if (key_type == tmp.type) {
if (key_type == tmp.type)
first_offset = max(min_offset, tmp.offset) + 1;
}
}
goto done;
}
......@@ -2319,7 +2316,7 @@ static noinline int log_dir_items(struct btrfs_trans_handle *trans,
* we have a block from this transaction, log every item in it
* from our directory
*/
while(1) {
while (1) {
struct btrfs_key tmp;
src = path->nodes[0];
nritems = btrfs_header_nritems(src);
......@@ -2396,7 +2393,7 @@ static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
again:
min_key = 0;
max_key = 0;
while(1) {
while (1) {
ret = log_dir_items(trans, root, inode, path,
dst_path, key_type, min_key,
&max_key);
......@@ -2432,7 +2429,7 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans,
key.type = max_key_type;
key.offset = (u64)-1;
while(1) {
while (1) {
ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
if (ret != 1)
......@@ -2481,7 +2478,7 @@ static noinline int copy_extent_csums(struct btrfs_trans_handle *trans,
list_add_tail(&sums->list, list);
path = btrfs_alloc_path();
while(disk_bytenr < end) {
while (disk_bytenr < end) {
if (!item || disk_bytenr < item_start_offset ||
disk_bytenr >= item_last_offset) {
struct btrfs_key found_key;
......@@ -2496,7 +2493,8 @@ static noinline int copy_extent_csums(struct btrfs_trans_handle *trans,
if (ret == -ENOENT || ret == -EFBIG)
ret = 0;
sum = 0;
printk("log no csum found for byte %llu\n",
printk(KERN_INFO "log no csum found for "
"byte %llu\n",
(unsigned long long)disk_bytenr);
item = NULL;
btrfs_release_path(root, path);
......@@ -2643,7 +2641,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
* we have to do this after the loop above to avoid changing the
* log tree while trying to change the log tree.
*/
while(!list_empty(&ordered_sums)) {
while (!list_empty(&ordered_sums)) {
struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
struct btrfs_ordered_sum,
list);
......@@ -2736,7 +2734,7 @@ static int __btrfs_log_inode(struct btrfs_trans_handle *trans,
BUG_ON(ret);
path->keep_locks = 1;
while(1) {
while (1) {
ins_nr = 0;
ret = btrfs_search_forward(root, &min_key, &max_key,
path, 0, trans->transid);
......@@ -2848,7 +2846,7 @@ int btrfs_log_dentry(struct btrfs_trans_handle *trans,
start_log_trans(trans, root);
sb = dentry->d_inode->i_sb;
while(1) {
while (1) {
ret = __btrfs_log_inode(trans, root, dentry->d_inode,
inode_only);
BUG_ON(ret);
......@@ -2919,7 +2917,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
key.offset = (u64)-1;
btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
while(1) {
while (1) {
ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
if (ret < 0)
break;
......
fs/btrfs/volumes.c
浏览文件 @ d397712b
......@@ -140,7 +140,7 @@ static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
* the list if the block device is congested. This way, multiple devices
* can make progress from a single worker thread.
*/
static int noinline run_scheduled_bios(struct btrfs_device *device)
static noinline int run_scheduled_bios(struct btrfs_device *device)
{
struct bio *pending;
struct backing_dev_info *bdi;
......@@ -187,7 +187,7 @@ static int noinline run_scheduled_bios(struct btrfs_device *device)
}
spin_unlock(&device->io_lock);
while(pending) {
while (pending) {
cur = pending;
pending = pending->bi_next;
cur->bi_next = NULL;
......@@ -458,7 +458,7 @@ static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
bdev = open_bdev_exclusive(device->name, flags, holder);
if (IS_ERR(bdev)) {
printk("open %s failed\n", device->name);
printk(KERN_INFO "open %s failed\n", device->name);
goto error;
}
set_blocksize(bdev, 4096);
......@@ -570,14 +570,15 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
devid = le64_to_cpu(disk_super->dev_item.devid);
transid = btrfs_super_generation(disk_super);
if (disk_super->label[0])
printk("device label %s ", disk_super->label);
printk(KERN_INFO "device label %s ", disk_super->label);
else {
/* FIXME, make a readl uuid parser */
printk("device fsid %llx-%llx ",
printk(KERN_INFO "device fsid %llx-%llx ",
*(unsigned long long *)disk_super->fsid,
*(unsigned long long *)(disk_super->fsid + 8));
}
printk("devid %Lu transid %Lu %s\n", devid, transid, path);
printk(KERN_INFO "devid %llu transid %llu %s\n",
(unsigned long long)devid, (unsigned long long)transid, path);
ret = device_list_add(path, disk_super, devid, fs_devices_ret);
brelse(bh);
......@@ -683,9 +684,8 @@ static noinline int find_free_dev_extent(struct btrfs_trans_handle *trans,
goto check_pending;
}
}
if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY) {
if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
goto next;
}
start_found = 1;
dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
......@@ -1001,14 +1001,16 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) &&
root->fs_info->fs_devices->rw_devices <= 4) {
printk("btrfs: unable to go below four devices on raid10\n");
printk(KERN_ERR "btrfs: unable to go below four devices "
"on raid10\n");
ret = -EINVAL;
goto out;
}
if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) &&
root->fs_info->fs_devices->rw_devices <= 2) {
printk("btrfs: unable to go below two devices on raid1\n");
printk(KERN_ERR "btrfs: unable to go below two "
"devices on raid1\n");
ret = -EINVAL;
goto out;
}
......@@ -1031,7 +1033,8 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
bh = NULL;
disk_super = NULL;
if (!device) {
printk("btrfs: no missing devices found to remove\n");
printk(KERN_ERR "btrfs: no missing devices found to "
"remove\n");
goto out;
}
} else {
......@@ -1060,7 +1063,8 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
}
if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
printk("btrfs: unable to remove the only writeable device\n");
printk(KERN_ERR "btrfs: unable to remove the only writeable "
"device\n");
ret = -EINVAL;
goto error_brelse;
}
......@@ -1286,9 +1290,8 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
return -EINVAL;
bdev = open_bdev_exclusive(device_path, 0, root->fs_info->bdev_holder);
if (!bdev) {
if (!bdev)
return -EIO;
}
if (root->fs_info->fs_devices->seeding) {
seeding_dev = 1;
......@@ -1401,8 +1404,8 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
goto out;
}
static int noinline btrfs_update_device(struct btrfs_trans_handle *trans,
struct btrfs_device *device)
static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
struct btrfs_device *device)
{
int ret;
struct btrfs_path *path;
......@@ -1563,7 +1566,7 @@ static int btrfs_relocate_chunk(struct btrfs_root *root,
int ret;
int i;
printk("btrfs relocating chunk %llu\n",
printk(KERN_INFO "btrfs relocating chunk %llu\n",
(unsigned long long)chunk_offset);
root = root->fs_info->chunk_root;
extent_root = root->fs_info->extent_root;
......@@ -1748,7 +1751,7 @@ int btrfs_balance(struct btrfs_root *dev_root)
key.offset = (u64)-1;
key.type = BTRFS_CHUNK_ITEM_KEY;
while(1) {
while (1) {
ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
if (ret < 0)
goto error;
......@@ -1916,7 +1919,7 @@ static int btrfs_add_system_chunk(struct btrfs_trans_handle *trans,
return 0;
}
static u64 noinline chunk_bytes_by_type(u64 type, u64 calc_size,
static noinline u64 chunk_bytes_by_type(u64 type, u64 calc_size,
int num_stripes, int sub_stripes)
{
if (type & (BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP))
......@@ -2041,7 +2044,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
min_free += 1024 * 1024;
INIT_LIST_HEAD(&private_devs);
while(index < num_stripes) {
while (index < num_stripes) {
device = list_entry(cur, struct btrfs_device, dev_alloc_list);
BUG_ON(!device->writeable);
if (device->total_bytes > device->bytes_used)
......@@ -2242,7 +2245,7 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
return 0;
}
static int noinline init_first_rw_device(struct btrfs_trans_handle *trans,
static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_device *device)
{
......@@ -2338,7 +2341,7 @@ void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree)
{
struct extent_map *em;
while(1) {
while (1) {
spin_lock(&tree->map_tree.lock);
em = lookup_extent_mapping(&tree->map_tree, 0, (u64)-1);
if (em)
......@@ -2413,9 +2416,8 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
int max_errors = 0;
struct btrfs_multi_bio *multi = NULL;
if (multi_ret && !(rw & (1 << BIO_RW))) {
if (multi_ret && !(rw & (1 << BIO_RW)))
stripes_allocated = 1;
}
again:
if (multi_ret) {
multi = kzalloc(btrfs_multi_bio_size(stripes_allocated),
......@@ -2434,7 +2436,9 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
return 0;
if (!em) {
printk("unable to find logical %Lu len %Lu\n", logical, *length);
printk(KERN_CRIT "unable to find logical %llu len %llu\n",
(unsigned long long)logical,
(unsigned long long)*length);
BUG();
}
......@@ -2541,9 +2545,8 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
device = map->stripes[stripe_index].dev;
if (device->bdev) {
bdi = blk_get_backing_dev_info(device->bdev);
if (bdi->unplug_io_fn) {
if (bdi->unplug_io_fn)
bdi->unplug_io_fn(bdi, unplug_page);
}
}
} else {
multi->stripes[i].physical =
......@@ -2717,7 +2720,7 @@ struct async_sched {
* This will add one bio to the pending list for a device and make sure
* the work struct is scheduled.
*/
static int noinline schedule_bio(struct btrfs_root *root,
static noinline int schedule_bio(struct btrfs_root *root,
struct btrfs_device *device,
int rw, struct bio *bio)
{
......@@ -2785,8 +2788,10 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
total_devs = multi->num_stripes;
if (map_length < length) {
printk("mapping failed logical %Lu bio len %Lu "
"len %Lu\n", logical, length, map_length);
printk(KERN_CRIT "mapping failed logical %llu bio len %llu "
"len %llu\n", (unsigned long long)logical,
(unsigned long long)length,
(unsigned long long)map_length);
BUG();
}
multi->end_io = first_bio->bi_end_io;
......@@ -2794,7 +2799,7 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
multi->orig_bio = first_bio;
atomic_set(&multi->stripes_pending, multi->num_stripes);
while(dev_nr < total_devs) {
while (dev_nr < total_devs) {
if (total_devs > 1) {
if (dev_nr < total_devs - 1) {
bio = bio_clone(first_bio, GFP_NOFS);
......@@ -3058,7 +3063,8 @@ static int read_one_dev(struct btrfs_root *root,
return -EIO;
if (!device) {
printk("warning devid %Lu missing\n", devid);
printk(KERN_WARNING "warning devid %llu missing\n",
(unsigned long long)devid);
device = add_missing_dev(root, devid, dev_uuid);
if (!device)
return -ENOMEM;
......@@ -3078,12 +3084,6 @@ static int read_one_dev(struct btrfs_root *root,
if (device->writeable)
device->fs_devices->total_rw_bytes += device->total_bytes;
ret = 0;
#if 0
ret = btrfs_open_device(device);
if (ret) {
kfree(device);
}
#endif
return ret;
}
......@@ -3174,7 +3174,7 @@ int btrfs_read_chunk_tree(struct btrfs_root *root)
key.type = 0;
again:
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
while(1) {
while (1) {
leaf = path->nodes[0];
slot = path->slots[0];
if (slot >= btrfs_header_nritems(leaf)) {
......
fs/btrfs/xattr.c
浏览文件 @ d397712b
......@@ -264,7 +264,8 @@ struct xattr_handler *btrfs_xattr_handlers[] = {
*/
static bool btrfs_is_valid_xattr(const char *name)
{
return !strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
return !strncmp(name, XATTR_SECURITY_PREFIX,
XATTR_SECURITY_PREFIX_LEN) ||
!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) ||
!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) ||
!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
......
fs/btrfs/zlib.c
浏览文件 @ d397712b
......@@ -152,7 +152,7 @@ static int free_workspace(struct workspace *workspace)
static void free_workspaces(void)
{
struct workspace *workspace;
while(!list_empty(&idle_workspace)) {
while (!list_empty(&idle_workspace)) {
workspace = list_entry(idle_workspace.next, struct workspace,
list);
list_del(&workspace->list);
......@@ -397,12 +397,10 @@ int btrfs_zlib_decompress_biovec(struct page **pages_in,
ret = -1;
goto out;
}
while(workspace->inf_strm.total_in < srclen) {
while (workspace->inf_strm.total_in < srclen) {
ret = zlib_inflate(&workspace->inf_strm, Z_NO_FLUSH);
if (ret != Z_OK && ret != Z_STREAM_END) {
if (ret != Z_OK && ret != Z_STREAM_END)
break;
}
/*
* buf start is the byte offset we're of the start of
* our workspace buffer
......@@ -424,16 +422,14 @@ int btrfs_zlib_decompress_biovec(struct page **pages_in,
/* we didn't make progress in this inflate
* call, we're done
*/
if (ret != Z_STREAM_END) {
if (ret != Z_STREAM_END)
ret = -1;
}
break;
}
/* we haven't yet hit data corresponding to this page */
if (total_out <= start_byte) {
if (total_out <= start_byte)
goto next;
}
/*
* the start of the data we care about is offset into
......@@ -448,7 +444,7 @@ int btrfs_zlib_decompress_biovec(struct page **pages_in,
current_buf_start = buf_start;
/* copy bytes from the working buffer into the pages */
while(working_bytes > 0) {
while (working_bytes > 0) {
bytes = min(PAGE_CACHE_SIZE - pg_offset,
PAGE_CACHE_SIZE - buf_offset);
bytes = min(bytes, working_bytes);
......@@ -471,6 +467,7 @@ int btrfs_zlib_decompress_biovec(struct page **pages_in,
ret = 0;
goto done;
}
page_out = bvec[page_out_index].bv_page;
pg_offset = 0;
page_bytes_left = PAGE_CACHE_SIZE;
......@@ -480,9 +477,8 @@ int btrfs_zlib_decompress_biovec(struct page **pages_in,
* make sure our new page is covered by this
* working buffer
*/
if (total_out <= start_byte) {
if (total_out <= start_byte)
goto next;
}
/* the next page in the biovec might not
* be adjacent to the last page, but it
......@@ -517,11 +513,10 @@ int btrfs_zlib_decompress_biovec(struct page **pages_in,
PAGE_CACHE_SIZE);
}
}
if (ret != Z_STREAM_END) {
if (ret != Z_STREAM_END)
ret = -1;
} else {
else
ret = 0;
}
done:
zlib_inflateEnd(&workspace->inf_strm);
if (data_in)
......@@ -579,16 +574,15 @@ int btrfs_zlib_decompress(unsigned char *data_in,
goto out;
}
while(bytes_left > 0) {
while (bytes_left > 0) {
unsigned long buf_start;
unsigned long buf_offset;
unsigned long bytes;
unsigned long pg_offset = 0;
ret = zlib_inflate(&workspace->inf_strm, Z_NO_FLUSH);
if (ret != Z_OK && ret != Z_STREAM_END) {
if (ret != Z_OK && ret != Z_STREAM_END)
break;
}
buf_start = total_out;
total_out = workspace->inf_strm.total_out;
......@@ -598,15 +592,13 @@ int btrfs_zlib_decompress(unsigned char *data_in,
break;
}
if (total_out <= start_byte) {
if (total_out <= start_byte)
goto next;
}
if (total_out > start_byte && buf_start < start_byte) {
if (total_out > start_byte && buf_start < start_byte)
buf_offset = start_byte - buf_start;
} else {
else
buf_offset = 0;
}
bytes = min(PAGE_CACHE_SIZE - pg_offset,
PAGE_CACHE_SIZE - buf_offset);
......@@ -622,11 +614,12 @@ int btrfs_zlib_decompress(unsigned char *data_in,
workspace->inf_strm.next_out = workspace->buf;
workspace->inf_strm.avail_out = PAGE_CACHE_SIZE;
}
if (ret != Z_STREAM_END && bytes_left != 0) {
if (ret != Z_STREAM_END && bytes_left != 0)
ret = -1;
} else {
else
ret = 0;
}
zlib_inflateEnd(&workspace->inf_strm);
out:
free_workspace(workspace);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或