Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d397712b authored by Chris Mason's avatar Chris Mason
Browse files

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: default avatarChris Mason <chris.mason@oracle.com>
parent 1f3c79a2

fs/btrfs/acl.c

+2 −3
Original line number Diff line number Diff line
@@ -161,7 +161,6 @@ 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);



	if (!ret)

fs/btrfs/compression.c

+6 −6
Original line number Diff line number Diff line
@@ -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);
@@ -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

+78 −139
Original line number Diff line number Diff line
@@ -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;
@@ -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);
@@ -1130,7 +1074,7 @@ enospc: 
 * 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)

{
@@ -1322,6 +1266,7 @@ 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)

			break;
@@ -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);
@@ -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;
@@ -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]));
@@ -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)
@@ -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);

		}
@@ -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 {
@@ -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);
@@ -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;

		}

fs/btrfs/ctree.h

+15 −15
Original line number Diff line number Diff line
@@ -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
@@ -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,7 +1659,6 @@ 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);



	root->name = kmalloc(len+1, GFP_KERNEL);
@@ -1673,7 +1671,8 @@ static inline int btrfs_set_root_name(struct btrfs_root *root, 
	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,8 +1706,8 @@ 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,

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);
@@ -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/disk-io.c

+63 −124

File changed.

Preview size limit exceeded, changes collapsed.