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

Commit 2753cc28 authored by Anton Salikhmetov's avatar Anton Salikhmetov Committed by Christoph Hellwig
Browse files

hfsplus: over 80 character lines clean-up 



Match coding style line length limitation where checkpatch.pl
reported over-80-character-line warnings.

Signed-off-by: default avatarAnton Salikhmetov <alexo@tuxera.com>
Signed-off-by: default avatarChristoph Hellwig <hch@tuxera.com>
parent 596276c3

fs/hfsplus/bfind.c

+4 −2
Original line number Diff line number Diff line
@@ -22,7 +22,8 @@ int hfs_find_init(struct hfs_btree *tree, struct hfs_find_data *fd) 
		return -ENOMEM;

	fd->search_key = ptr;

	fd->key = ptr + tree->max_key_len + 2;

	dprint(DBG_BNODE_REFS, "find_init: %d (%p)\n", tree->cnid, __builtin_return_address(0));

	dprint(DBG_BNODE_REFS, "find_init: %d (%p)\n",

		tree->cnid, __builtin_return_address(0));

	mutex_lock(&tree->tree_lock);

	return 0;

}
@@ -31,7 +32,8 @@ void hfs_find_exit(struct hfs_find_data *fd) 
{

	hfs_bnode_put(fd->bnode);

	kfree(fd->search_key);

	dprint(DBG_BNODE_REFS, "find_exit: %d (%p)\n", fd->tree->cnid, __builtin_return_address(0));

	dprint(DBG_BNODE_REFS, "find_exit: %d (%p)\n",

		fd->tree->cnid, __builtin_return_address(0));

	mutex_unlock(&fd->tree->tree_lock);

	fd->tree = NULL;

}

fs/hfsplus/bitmap.c

+2 −1
Original line number Diff line number Diff line
@@ -15,7 +15,8 @@ 


#define PAGE_CACHE_BITS	(PAGE_CACHE_SIZE * 8)



int hfsplus_block_allocate(struct super_block *sb, u32 size, u32 offset, u32 *max)

int hfsplus_block_allocate(struct super_block *sb, u32 size,

		u32 offset, u32 *max)

{

	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);

	struct page *page;

fs/hfsplus/bnode.c

+28 −13
Original line number Diff line number Diff line
@@ -212,7 +212,8 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len) 
				dst_page--;

			}

			src -= len;

			memmove(kmap(*dst_page) + src, kmap(*src_page) + src, len);

			memmove(kmap(*dst_page) + src,

				kmap(*src_page) + src, len);

			kunmap(*src_page);

			set_page_dirty(*dst_page);

			kunmap(*dst_page);
@@ -250,14 +251,16 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len) 


		if (src == dst) {

			l = min(len, (int)PAGE_CACHE_SIZE - src);

			memmove(kmap(*dst_page) + src, kmap(*src_page) + src, l);

			memmove(kmap(*dst_page) + src,

				kmap(*src_page) + src, l);

			kunmap(*src_page);

			set_page_dirty(*dst_page);

			kunmap(*dst_page);



			while ((len -= l) != 0) {

				l = min(len, (int)PAGE_CACHE_SIZE);

				memmove(kmap(*++dst_page), kmap(*++src_page), l);

				memmove(kmap(*++dst_page),

					kmap(*++src_page), l);

				kunmap(*src_page);

				set_page_dirty(*dst_page);

				kunmap(*dst_page);
@@ -268,7 +271,8 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len) 
			do {

				src_ptr = kmap(*src_page) + src;

				dst_ptr = kmap(*dst_page) + dst;

				if (PAGE_CACHE_SIZE - src < PAGE_CACHE_SIZE - dst) {

				if (PAGE_CACHE_SIZE - src <

						PAGE_CACHE_SIZE - dst) {

					l = PAGE_CACHE_SIZE - src;

					src = 0;

					dst += l;
@@ -340,7 +344,8 @@ void hfs_bnode_unlink(struct hfs_bnode *node) 
			return;

		tmp->next = node->next;

		cnid = cpu_to_be32(tmp->next);

		hfs_bnode_write(tmp, &cnid, offsetof(struct hfs_bnode_desc, next), 4);

		hfs_bnode_write(tmp, &cnid,

			offsetof(struct hfs_bnode_desc, next), 4);

		hfs_bnode_put(tmp);

	} else if (node->type == HFS_NODE_LEAF)

		tree->leaf_head = node->next;
@@ -351,7 +356,8 @@ void hfs_bnode_unlink(struct hfs_bnode *node) 
			return;

		tmp->prev = node->prev;

		cnid = cpu_to_be32(tmp->prev);

		hfs_bnode_write(tmp, &cnid, offsetof(struct hfs_bnode_desc, prev), 4);

		hfs_bnode_write(tmp, &cnid,

			offsetof(struct hfs_bnode_desc, prev), 4);

		hfs_bnode_put(tmp);

	} else if (node->type == HFS_NODE_LEAF)

		tree->leaf_tail = node->prev;
@@ -379,7 +385,9 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid) 
	struct hfs_bnode *node;



	if (cnid >= tree->node_count) {

		printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid);

		printk(KERN_ERR "hfs: request for non-existent node "

				"%d in B*Tree\n",

			cnid);

		return NULL;

	}
@@ -402,7 +410,9 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid) 
	loff_t off;



	if (cnid >= tree->node_count) {

		printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid);

		printk(KERN_ERR "hfs: request for non-existent node "

				"%d in B*Tree\n",

			cnid);

		return NULL;

	}
@@ -429,7 +439,8 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid) 
	} else {

		spin_unlock(&tree->hash_lock);

		kfree(node);

		wait_event(node2->lock_wq, !test_bit(HFS_BNODE_NEW, &node2->flags));

		wait_event(node2->lock_wq,

			!test_bit(HFS_BNODE_NEW, &node2->flags));

		return node2;

	}

	spin_unlock(&tree->hash_lock);
@@ -483,7 +494,8 @@ struct hfs_bnode *hfs_bnode_find(struct hfs_btree *tree, u32 num) 
	if (node) {

		hfs_bnode_get(node);

		spin_unlock(&tree->hash_lock);

		wait_event(node->lock_wq, !test_bit(HFS_BNODE_NEW, &node->flags));

		wait_event(node->lock_wq,

			!test_bit(HFS_BNODE_NEW, &node->flags));

		if (test_bit(HFS_BNODE_ERROR, &node->flags))

			goto node_error;

		return node;
@@ -497,7 +509,8 @@ struct hfs_bnode *hfs_bnode_find(struct hfs_btree *tree, u32 num) 
	if (!test_bit(HFS_BNODE_NEW, &node->flags))

		return node;



	desc = (struct hfs_bnode_desc *)(kmap(node->page[0]) + node->page_offset);

	desc = (struct hfs_bnode_desc *)(kmap(node->page[0]) +

			node->page_offset);

	node->prev = be32_to_cpu(desc->prev);

	node->next = be32_to_cpu(desc->next);

	node->num_recs = be16_to_cpu(desc->num_recs);
@@ -607,7 +620,8 @@ void hfs_bnode_get(struct hfs_bnode *node) 
	if (node) {

		atomic_inc(&node->refcnt);

		dprint(DBG_BNODE_REFS, "get_node(%d:%d): %d\n",

		       node->tree->cnid, node->this, atomic_read(&node->refcnt));

			node->tree->cnid, node->this,

			atomic_read(&node->refcnt));

	}

}
@@ -619,7 +633,8 @@ void hfs_bnode_put(struct hfs_bnode *node) 
		int i;



		dprint(DBG_BNODE_REFS, "put_node(%d:%d): %d\n",

		       node->tree->cnid, node->this, atomic_read(&node->refcnt));

			node->tree->cnid, node->this,

			atomic_read(&node->refcnt));

		BUG_ON(!atomic_read(&node->refcnt));

		if (!atomic_dec_and_lock(&node->refcnt, &tree->hash_lock))

			return;

fs/hfsplus/brec.c

+18 −8
Original line number Diff line number Diff line
@@ -39,7 +39,8 @@ u16 hfs_brec_keylen(struct hfs_bnode *node, u16 rec) 
	   !(node->tree->attributes & HFS_TREE_VARIDXKEYS)) {

		retval = node->tree->max_key_len + 2;

	} else {

		recoff = hfs_bnode_read_u16(node, node->tree->node_size - (rec + 1) * 2);

		recoff = hfs_bnode_read_u16(node,

			node->tree->node_size - (rec + 1) * 2);

		if (!recoff)

			return 0;
@@ -84,7 +85,8 @@ int hfs_brec_insert(struct hfs_find_data *fd, void *entry, int entry_len) 
	end_rec_off = tree->node_size - (node->num_recs + 1) * 2;

	end_off = hfs_bnode_read_u16(node, end_rec_off);

	end_rec_off -= 2;

	dprint(DBG_BNODE_MOD, "insert_rec: %d, %d, %d, %d\n", rec, size, end_off, end_rec_off);

	dprint(DBG_BNODE_MOD, "insert_rec: %d, %d, %d, %d\n",

		rec, size, end_off, end_rec_off);

	if (size > end_rec_off - end_off) {

		if (new_node)

			panic("not enough room!\n");
@@ -99,7 +101,9 @@ int hfs_brec_insert(struct hfs_find_data *fd, void *entry, int entry_len) 
	}

	node->num_recs++;

	/* write new last offset */

	hfs_bnode_write_u16(node, offsetof(struct hfs_bnode_desc, num_recs), node->num_recs);

	hfs_bnode_write_u16(node,

		offsetof(struct hfs_bnode_desc, num_recs),

		node->num_recs);

	hfs_bnode_write_u16(node, end_rec_off, end_off + size);

	data_off = end_off;

	data_rec_off = end_rec_off + 2;
@@ -151,7 +155,8 @@ int hfs_brec_insert(struct hfs_find_data *fd, void *entry, int entry_len) 
		if (tree->attributes & HFS_TREE_VARIDXKEYS)

			key_len = be16_to_cpu(fd->search_key->key_len) + 2;

		else {

			fd->search_key->key_len = cpu_to_be16(tree->max_key_len);

			fd->search_key->key_len =

				cpu_to_be16(tree->max_key_len);

			key_len = tree->max_key_len + 2;

		}

		goto again;
@@ -180,7 +185,8 @@ int hfs_brec_remove(struct hfs_find_data *fd) 
		mark_inode_dirty(tree->inode);

	}

	hfs_bnode_dump(node);

	dprint(DBG_BNODE_MOD, "remove_rec: %d, %d\n", fd->record, fd->keylength + fd->entrylength);

	dprint(DBG_BNODE_MOD, "remove_rec: %d, %d\n",

		fd->record, fd->keylength + fd->entrylength);

	if (!--node->num_recs) {

		hfs_bnode_unlink(node);

		if (!node->parent)
@@ -194,7 +200,9 @@ int hfs_brec_remove(struct hfs_find_data *fd) 
		__hfs_brec_find(node, fd);

		goto again;

	}

	hfs_bnode_write_u16(node, offsetof(struct hfs_bnode_desc, num_recs), node->num_recs);

	hfs_bnode_write_u16(node,

		offsetof(struct hfs_bnode_desc, num_recs),

		node->num_recs);



	if (rec_off == end_off)

		goto skip;
@@ -364,7 +372,8 @@ static int hfs_brec_update_parent(struct hfs_find_data *fd) 
		newkeylen = hfs_bnode_read_u16(node, 14) + 2;

	else

		fd->keylength = newkeylen = tree->max_key_len + 2;

	dprint(DBG_BNODE_MOD, "update_rec: %d, %d, %d\n", rec, fd->keylength, newkeylen);

	dprint(DBG_BNODE_MOD, "update_rec: %d, %d, %d\n",

		rec, fd->keylength, newkeylen);



	rec_off = tree->node_size - (rec + 2) * 2;

	end_rec_off = tree->node_size - (parent->num_recs + 1) * 2;
@@ -383,7 +392,8 @@ static int hfs_brec_update_parent(struct hfs_find_data *fd) 
			parent = fd->bnode;

			rec = fd->record;

			rec_off = tree->node_size - (rec + 2) * 2;

			end_rec_off = tree->node_size - (parent->num_recs + 1) * 2;

			end_rec_off = tree->node_size -

				(parent->num_recs + 1) * 2;

		}

	}

fs/hfsplus/btree.c

+22 −9
Original line number Diff line number Diff line
@@ -51,7 +51,8 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id) 
		goto free_inode;



	/* Load the header */

	head = (struct hfs_btree_header_rec *)(kmap(page) + sizeof(struct hfs_bnode_desc));

	head = (struct hfs_btree_header_rec *)(kmap(page) +

		sizeof(struct hfs_bnode_desc));

	tree->root = be32_to_cpu(head->root);

	tree->leaf_count = be32_to_cpu(head->leaf_count);

	tree->leaf_head = be32_to_cpu(head->leaf_head);
@@ -115,7 +116,9 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id) 


	tree->node_size_shift = ffs(size) - 1;



	tree->pages_per_bnode = (tree->node_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;

	tree->pages_per_bnode =

		(tree->node_size + PAGE_CACHE_SIZE - 1) >>

		PAGE_CACHE_SHIFT;



	kunmap(page);

	page_cache_release(page);
@@ -144,8 +147,10 @@ void hfs_btree_close(struct hfs_btree *tree) 
		while ((node = tree->node_hash[i])) {

			tree->node_hash[i] = node->next_hash;

			if (atomic_read(&node->refcnt))

				printk(KERN_CRIT "hfs: node %d:%d still has %d user(s)!\n",

					node->tree->cnid, node->this, atomic_read(&node->refcnt));

				printk(KERN_CRIT "hfs: node %d:%d "

						"still has %d user(s)!\n",

					node->tree->cnid, node->this,

					atomic_read(&node->refcnt));

			hfs_bnode_free(node);

			tree->node_hash_cnt--;

		}
@@ -166,7 +171,8 @@ void hfs_btree_write(struct hfs_btree *tree) 
		return;

	/* Load the header */

	page = node->page[0];

	head = (struct hfs_btree_header_rec *)(kmap(page) + sizeof(struct hfs_bnode_desc));

	head = (struct hfs_btree_header_rec *)(kmap(page) +

		sizeof(struct hfs_bnode_desc));



	head->root = cpu_to_be32(tree->root);

	head->leaf_count = cpu_to_be32(tree->leaf_count);
@@ -272,7 +278,8 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree) 
						tree->free_nodes--;

						mark_inode_dirty(tree->inode);

						hfs_bnode_put(node);

						return hfs_bnode_create(tree, idx);

						return hfs_bnode_create(tree,

							idx);

					}

				}

			}
@@ -329,7 +336,9 @@ void hfs_bmap_free(struct hfs_bnode *node) 
		hfs_bnode_put(node);

		if (!i) {

			/* panic */;

			printk(KERN_CRIT "hfs: unable to free bnode %u. bmap not found!\n", node->this);

			printk(KERN_CRIT "hfs: unable to free bnode %u. "

					"bmap not found!\n",

				node->this);

			return;

		}

		node = hfs_bnode_find(tree, i);
@@ -337,7 +346,9 @@ void hfs_bmap_free(struct hfs_bnode *node) 
			return;

		if (node->type != HFS_NODE_MAP) {

			/* panic */;

			printk(KERN_CRIT "hfs: invalid bmap found! (%u,%d)\n", node->this, node->type);

			printk(KERN_CRIT "hfs: invalid bmap found! "

					"(%u,%d)\n",

				node->this, node->type);

			hfs_bnode_put(node);

			return;

		}
@@ -350,7 +361,9 @@ void hfs_bmap_free(struct hfs_bnode *node) 
	m = 1 << (~nidx & 7);

	byte = data[off];

	if (!(byte & m)) {

		printk(KERN_CRIT "hfs: trying to free free bnode %u(%d)\n", node->this, node->type);

		printk(KERN_CRIT "hfs: trying to free free bnode "

				"%u(%d)\n",

			node->this, node->type);

		kunmap(page);

		hfs_bnode_put(node);

		return;