Re: [PATCH 1/2] UDF: coding style conversion - lindent

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Mon, May 28, 2007 at 06:30:38PM +0400, Cyrill Gorcunov wrote:
>This patch converts UDF coding style to kernel
>coding style using Lindent.
>
>Signed-off-by: Cyrill Gorcunov <[email protected]>
>---
>
> fs/udf/balloc.c    |  709 ++++++++++++-----------
> fs/udf/crc.c       |   19 +-
> fs/udf/dir.c       |  132 ++---
> fs/udf/directory.c |  207 ++++----
> fs/udf/ecma_167.h  |  875 +++++++++++++---------------
> fs/udf/file.c      |  114 ++--
> fs/udf/fsync.c     |    4 +-
> fs/udf/ialloc.c    |   69 ++--
> fs/udf/inode.c     | 1494 ++++++++++++++++++++++++-----------------------
> fs/udf/lowlevel.c  |   25 +-
> fs/udf/misc.c      |  172 +++---
> fs/udf/namei.c     |  720 +++++++++++------------
> fs/udf/osta_udf.h  |  239 ++++----
> fs/udf/partition.c |  273 ++++++----
> fs/udf/super.c     | 1630 ++++++++++++++++++++++++++++------------------------
> fs/udf/symlink.c   |   56 +-
> fs/udf/truncate.c  |  230 +++++----
> fs/udf/udf_i.h     |    2 +-
> fs/udf/udf_sb.h    |    6 +-
> fs/udf/udfdecl.h   |  106 +++--
> fs/udf/udfend.h    |    2 +-
> fs/udf/udftime.c   |   93 ++--
> fs/udf/unicode.c   |  299 +++++------
> 23 files changed, 3812 insertions(+), 3664 deletions(-)
>
>diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
>index 4cec910..ef48d09 100644
>--- a/fs/udf/balloc.c
>+++ b/fs/udf/balloc.c
>@@ -41,18 +41,17 @@
> #define uint(x) xuint(x)
> #define xuint(x) __le ## x
> 
>-static inline int find_next_one_bit (void * addr, int size, int offset)
>+static inline int find_next_one_bit(void *addr, int size, int offset)
> {
>-	uintBPL_t * p = ((uintBPL_t *) addr) + (offset / BITS_PER_LONG);
>-	int result = offset & ~(BITS_PER_LONG-1);
>+	uintBPL_t *p = ((uintBPL_t *) addr) + (offset / BITS_PER_LONG);
>+	int result = offset & ~(BITS_PER_LONG - 1);
> 	unsigned long tmp;
> 
> 	if (offset >= size)
> 		return size;
> 	size -= result;
>-	offset &= (BITS_PER_LONG-1);
>-	if (offset)
>-	{
>+	offset &= (BITS_PER_LONG - 1);
>+	if (offset) {
> 		tmp = leBPL_to_cpup(p++);
> 		tmp &= ~0UL << offset;
> 		if (size < BITS_PER_LONG)
>@@ -62,8 +61,7 @@ static inline int find_next_one_bit (void * addr, int size, int offset)
> 		size -= BITS_PER_LONG;
> 		result += BITS_PER_LONG;
> 	}
>-	while (size & ~(BITS_PER_LONG-1))
>-	{
>+	while (size & ~(BITS_PER_LONG - 1)) {
> 		if ((tmp = leBPL_to_cpup(p++)))
> 			goto found_middle;
> 		result += BITS_PER_LONG;
>@@ -72,17 +70,18 @@ static inline int find_next_one_bit (void * addr, int size, int offset)
> 	if (!size)
> 		return result;
> 	tmp = leBPL_to_cpup(p);
>-found_first:
>-	tmp &= ~0UL >> (BITS_PER_LONG-size);
>-found_middle:
>+      found_first:
>+	tmp &= ~0UL >> (BITS_PER_LONG - size);
>+      found_middle:


I doubt about this change. First, it seems that you replace a tab with whitespaces. Second, IMO, the labels should not be aligned with the statements.


> 	return result + ffz(~tmp);
> }
> 
> #define find_first_one_bit(addr, size)\
> 	find_next_one_bit((addr), (size), 0)
> 
>-static int read_block_bitmap(struct super_block * sb,
>-	struct udf_bitmap *bitmap, unsigned int block, unsigned long bitmap_nr)
>+static int read_block_bitmap(struct super_block *sb,
>+			     struct udf_bitmap *bitmap, unsigned int block,
>+			     unsigned long bitmap_nr)
> {
> 	struct buffer_head *bh = NULL;
> 	int retval = 0;
>@@ -92,38 +91,39 @@ static int read_block_bitmap(struct super_block * sb,
> 	loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
> 
> 	bh = udf_tread(sb, udf_get_lb_pblock(sb, loc, block));
>-	if (!bh)
>-	{
>+	if (!bh) {
> 		retval = -EIO;
> 	}
> 	bitmap->s_block_bitmap[bitmap_nr] = bh;
> 	return retval;
> }
> 
>-static int __load_block_bitmap(struct super_block * sb,
>-	struct udf_bitmap *bitmap, unsigned int block_group)
>+static int __load_block_bitmap(struct super_block *sb,
>+			       struct udf_bitmap *bitmap,
>+			       unsigned int block_group)
> {
> 	int retval = 0;
> 	int nr_groups = bitmap->s_nr_groups;
> 
>-	if (block_group >= nr_groups)
>-	{
>-		udf_debug("block_group (%d) > nr_groups (%d)\n", block_group, nr_groups);
>+	if (block_group >= nr_groups) {
>+		udf_debug("block_group (%d) > nr_groups (%d)\n", block_group,
>+			  nr_groups);
> 	}
> 
> 	if (bitmap->s_block_bitmap[block_group])
> 		return block_group;
>-	else
>-	{
>-		retval = read_block_bitmap(sb, bitmap, block_group, block_group);
>+	else {
>+		retval =
>+		    read_block_bitmap(sb, bitmap, block_group, block_group);
> 		if (retval < 0)
> 			return retval;
> 		return block_group;
> 	}
> }
> 
>-static inline int load_block_bitmap(struct super_block * sb,
>-	struct udf_bitmap *bitmap, unsigned int block_group)
>+static inline int load_block_bitmap(struct super_block *sb,
>+				    struct udf_bitmap *bitmap,
>+				    unsigned int block_group)
> {
> 	int slot;
> 
>@@ -138,13 +138,14 @@ static inline int load_block_bitmap(struct super_block * sb,
> 	return slot;
> }
> 
>-static void udf_bitmap_free_blocks(struct super_block * sb,
>-	struct inode * inode,
>-	struct udf_bitmap *bitmap,
>-	kernel_lb_addr bloc, uint32_t offset, uint32_t count)
>+static void udf_bitmap_free_blocks(struct super_block *sb,
>+				   struct inode *inode,
>+				   struct udf_bitmap *bitmap,
>+				   kernel_lb_addr bloc, uint32_t offset,
>+				   uint32_t count)
> {
> 	struct udf_sb_info *sbi = UDF_SB(sb);
>-	struct buffer_head * bh = NULL;
>+	struct buffer_head *bh = NULL;
> 	unsigned long block;
> 	unsigned long block_group;
> 	unsigned long bit;
>@@ -154,17 +155,22 @@ static void udf_bitmap_free_blocks(struct super_block * sb,
> 
> 	mutex_lock(&sbi->s_alloc_mutex);
> 	if (bloc.logicalBlockNum < 0 ||
>-		(bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum))
>-	{
>-		udf_debug("%d < %d || %d + %d > %d\n",
>-			bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
>-			UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
>+	    (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb,
>+							    bloc.
>+							    partitionReferenceNum))
>+	{
>+		udf_debug("%d < %d || %d + %d > %d\n", bloc.logicalBlockNum, 0,
>+			  bloc.logicalBlockNum, count, UDF_SB_PARTLEN(sb,
>+								      bloc.
>+								      partitionReferenceNum));
> 		goto error_return;
> 	}
> 
>-	block = bloc.logicalBlockNum + offset + (sizeof(struct spaceBitmapDesc) << 3);
>+	block =
>+	    bloc.logicalBlockNum + offset +
>+	    (sizeof(struct spaceBitmapDesc) << 3);
> 
>-do_more:
>+      do_more:
> 	overflow = 0;
> 	block_group = block >> (sb->s_blocksize_bits + 3);
> 	bit = block % (sb->s_blocksize << 3);
>@@ -172,8 +178,7 @@ do_more:
> 	/*
> 	 * Check to see if we are freeing blocks across a group boundary.
> 	 */
>-	if (bit + count > (sb->s_blocksize << 3))
>-	{
>+	if (bit + count > (sb->s_blocksize << 3)) {
> 		overflow = bit + count - (sb->s_blocksize << 3);
> 		count -= overflow;
> 	}
>@@ -182,32 +187,31 @@ do_more:
> 		goto error_return;
> 
> 	bh = bitmap->s_block_bitmap[bitmap_nr];
>-	for (i=0; i < count; i++)
>-	{
>-		if (udf_set_bit(bit + i, bh->b_data))
>-		{
>+	for (i = 0; i < count; i++) {
>+		if (udf_set_bit(bit + i, bh->b_data)) {
> 			udf_debug("bit %ld already set\n", bit + i);
>-			udf_debug("byte=%2x\n", ((char *)bh->b_data)[(bit + i) >> 3]);
>-		}
>-		else
>-		{
>+			udf_debug("byte=%2x\n",
>+				  ((char *)bh->b_data)[(bit + i) >> 3]);
>+		} else {
> 			if (inode)
> 				DQUOT_FREE_BLOCK(inode, 1);
>-			if (UDF_SB_LVIDBH(sb))
>-			{
>-				UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
>-					cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)])+1);
>+			if (UDF_SB_LVIDBH(sb)) {
>+				UDF_SB_LVID(sb)->
>+				    freeSpaceTable[UDF_SB_PARTITION(sb)] =
>+				    cpu_to_le32(le32_to_cpu
>+						(UDF_SB_LVID(sb)->
>+						 freeSpaceTable[UDF_SB_PARTITION
>+								(sb)]) + 1);
> 			}
> 		}
> 	}
> 	mark_buffer_dirty(bh);
>-	if (overflow)
>-	{
>+	if (overflow) {
> 		block += count;
> 		count = overflow;
> 		goto do_more;
> 	}
>-error_return:
>+      error_return:
> 	sb->s_dirt = 1;
> 	if (UDF_SB_LVIDBH(sb))
> 		mark_buffer_dirty(UDF_SB_LVIDBH(sb));
>@@ -215,10 +219,11 @@ error_return:
> 	return;
> }
> 
>-static int udf_bitmap_prealloc_blocks(struct super_block * sb,
>-	struct inode * inode,
>-	struct udf_bitmap *bitmap, uint16_t partition, uint32_t first_block,
>-	uint32_t block_count)
>+static int udf_bitmap_prealloc_blocks(struct super_block *sb,
>+				      struct inode *inode,
>+				      struct udf_bitmap *bitmap,
>+				      uint16_t partition, uint32_t first_block,
>+				      uint32_t block_count)
> {
> 	struct udf_sb_info *sbi = UDF_SB(sb);
> 	int alloc_count = 0;
>@@ -233,9 +238,10 @@ static int udf_bitmap_prealloc_blocks(struct super_block * sb,
> 	if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))
> 		block_count = UDF_SB_PARTLEN(sb, partition) - first_block;
> 
>-repeat:
>+      repeat:
> 	nr_groups = (UDF_SB_PARTLEN(sb, partition) +
>-		(sizeof(struct spaceBitmapDesc) << 3) + (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
>+		     (sizeof(struct spaceBitmapDesc) << 3) +
>+		     (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
> 	block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
> 	block_group = block >> (sb->s_blocksize_bits + 3);
> 	group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
>@@ -247,31 +253,30 @@ repeat:
> 
> 	bit = block % (sb->s_blocksize << 3);
> 
>-	while (bit < (sb->s_blocksize << 3) && block_count > 0)
>-	{
>+	while (bit < (sb->s_blocksize << 3) && block_count > 0) {
> 		if (!udf_test_bit(bit, bh->b_data))
> 			goto out;
> 		else if (DQUOT_PREALLOC_BLOCK(inode, 1))
> 			goto out;
>-		else if (!udf_clear_bit(bit, bh->b_data))
>-		{
>+		else if (!udf_clear_bit(bit, bh->b_data)) {
> 			udf_debug("bit already cleared for block %d\n", bit);
> 			DQUOT_FREE_BLOCK(inode, 1);
> 			goto out;
> 		}
>-		block_count --;
>-		alloc_count ++;
>-		bit ++;
>-		block ++;
>+		block_count--;
>+		alloc_count++;
>+		bit++;
>+		block++;
> 	}
> 	mark_buffer_dirty(bh);
> 	if (block_count > 0)
> 		goto repeat;
>-out:
>-	if (UDF_SB_LVIDBH(sb))
>-	{
>+      out:
>+	if (UDF_SB_LVIDBH(sb)) {
> 		UDF_SB_LVID(sb)->freeSpaceTable[partition] =
>-			cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition])-alloc_count);
>+		    cpu_to_le32(le32_to_cpu
>+				(UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
>+				alloc_count);
> 		mark_buffer_dirty(UDF_SB_LVIDBH(sb));
> 	}
> 	sb->s_dirt = 1;
>@@ -279,12 +284,13 @@ out:
> 	return alloc_count;
> }
> 
>-static int udf_bitmap_new_block(struct super_block * sb,
>-	struct inode * inode,
>-	struct udf_bitmap *bitmap, uint16_t partition, uint32_t goal, int *err)
>+static int udf_bitmap_new_block(struct super_block *sb,
>+				struct inode *inode,
>+				struct udf_bitmap *bitmap, uint16_t partition,
>+				uint32_t goal, int *err)
> {
> 	struct udf_sb_info *sbi = UDF_SB(sb);
>-	int newbit, bit=0, block, block_group, group_start;
>+	int newbit, bit = 0, block, block_group, group_start;
> 	int end_goal, nr_groups, bitmap_nr, i;
> 	struct buffer_head *bh = NULL;
> 	char *ptr;
>@@ -293,7 +299,7 @@ static int udf_bitmap_new_block(struct super_block * sb,
> 	*err = -ENOSPC;
> 	mutex_lock(&sbi->s_alloc_mutex);
> 
>-repeat:
>+      repeat:
> 	if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
> 		goal = 0;
> 
>@@ -306,38 +312,39 @@ repeat:
> 	if (bitmap_nr < 0)
> 		goto error_return;
> 	bh = bitmap->s_block_bitmap[bitmap_nr];
>-	ptr = memscan((char *)bh->b_data + group_start, 0xFF, sb->s_blocksize - group_start);
>+	ptr =
>+	    memscan((char *)bh->b_data + group_start, 0xFF,
>+		    sb->s_blocksize - group_start);
> 
>-	if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize)
>-	{
>+	if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
> 		bit = block % (sb->s_blocksize << 3);
> 
>-		if (udf_test_bit(bit, bh->b_data))
>-		{
>+		if (udf_test_bit(bit, bh->b_data)) {
> 			goto got_block;
> 		}
> 		end_goal = (bit + 63) & ~63;
> 		bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
> 		if (bit < end_goal)
> 			goto got_block;
>-		ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF, sb->s_blocksize - ((bit + 7) >> 3));
>+		ptr =
>+		    memscan((char *)bh->b_data + (bit >> 3), 0xFF,
>+			    sb->s_blocksize - ((bit + 7) >> 3));
> 		newbit = (ptr - ((char *)bh->b_data)) << 3;
>-		if (newbit < sb->s_blocksize << 3)
>-		{
>+		if (newbit < sb->s_blocksize << 3) {
> 			bit = newbit;
> 			goto search_back;
> 		}
>-		newbit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, bit);
>-		if (newbit < sb->s_blocksize << 3)
>-		{
>+		newbit =
>+		    udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
>+					  bit);
>+		if (newbit < sb->s_blocksize << 3) {
> 			bit = newbit;
> 			goto got_block;
> 		}
> 	}
> 
>-	for (i=0; i<(nr_groups*2); i++)
>-	{
>-		block_group ++;
>+	for (i = 0; i < (nr_groups * 2); i++) {
>+		block_group++;
> 		if (block_group >= nr_groups)
> 			block_group = 0;
> 		group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
>@@ -346,67 +353,69 @@ repeat:
> 		if (bitmap_nr < 0)
> 			goto error_return;
> 		bh = bitmap->s_block_bitmap[bitmap_nr];
>-		if (i < nr_groups)
>-		{
>-			ptr = memscan((char *)bh->b_data + group_start, 0xFF, sb->s_blocksize - group_start);
>-			if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize)
>-			{
>+		if (i < nr_groups) {
>+			ptr =
>+			    memscan((char *)bh->b_data + group_start, 0xFF,
>+				    sb->s_blocksize - group_start);
>+			if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
> 				bit = (ptr - ((char *)bh->b_data)) << 3;
> 				break;
> 			}
>-		}
>-		else
>-		{
>-			bit = udf_find_next_one_bit((char *)bh->b_data, sb->s_blocksize << 3, group_start << 3);
>+		} else {
>+			bit =
>+			    udf_find_next_one_bit((char *)bh->b_data,
>+						  sb->s_blocksize << 3,
>+						  group_start << 3);
> 			if (bit < sb->s_blocksize << 3)
> 				break;
> 		}
> 	}
>-	if (i >= (nr_groups*2))
>-	{
>+	if (i >= (nr_groups * 2)) {
> 		mutex_unlock(&sbi->s_alloc_mutex);
> 		return newblock;
> 	}
> 	if (bit < sb->s_blocksize << 3)
> 		goto search_back;
> 	else
>-		bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, group_start << 3);
>-	if (bit >= sb->s_blocksize << 3)
>-	{
>+		bit =
>+		    udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
>+					  group_start << 3);
>+	if (bit >= sb->s_blocksize << 3) {
> 		mutex_unlock(&sbi->s_alloc_mutex);
> 		return 0;
> 	}
> 
>-search_back:
>-	for (i=0; i<7 && bit > (group_start << 3) && udf_test_bit(bit - 1, bh->b_data); i++, bit--);
>+      search_back:
>+	for (i = 0;
>+	     i < 7 && bit > (group_start << 3)
>+	     && udf_test_bit(bit - 1, bh->b_data); i++, bit--) ;
> 
>-got_block:
>+      got_block:
> 
> 	/*
> 	 * Check quota for allocation of this block.
> 	 */
>-	if (inode && DQUOT_ALLOC_BLOCK(inode, 1))
>-	{
>+	if (inode && DQUOT_ALLOC_BLOCK(inode, 1)) {
> 		mutex_unlock(&sbi->s_alloc_mutex);
> 		*err = -EDQUOT;
> 		return 0;
> 	}
> 
> 	newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
>-		(sizeof(struct spaceBitmapDesc) << 3);
>+	    (sizeof(struct spaceBitmapDesc) << 3);
> 
>-	if (!udf_clear_bit(bit, bh->b_data))
>-	{
>+	if (!udf_clear_bit(bit, bh->b_data)) {
> 		udf_debug("bit already cleared for block %d\n", bit);
> 		goto repeat;
> 	}
> 
> 	mark_buffer_dirty(bh);
> 
>-	if (UDF_SB_LVIDBH(sb))
>-	{
>+	if (UDF_SB_LVIDBH(sb)) {
> 		UDF_SB_LVID(sb)->freeSpaceTable[partition] =
>-			cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition])-1);
>+		    cpu_to_le32(le32_to_cpu
>+				(UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
>+				1);
> 		mark_buffer_dirty(UDF_SB_LVIDBH(sb));
> 	}
> 	sb->s_dirt = 1;
>@@ -414,16 +423,17 @@ got_block:
> 	*err = 0;
> 	return newblock;
> 
>-error_return:
>+      error_return:

Also here.

<snip>

> 
>-error_return:
>+      error_return:

Here again.

<snip>

> 
>-#endif /* defined(TEST) */
>+#endif				/* defined(TEST) */

Is this necessary?


-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[Index of Archives]     [Kernel Newbies]     [Netfilter]     [Bugtraq]     [Photo]     [Stuff]     [Gimp]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux RAID]     [Video 4 Linux]     [Linux for the blind]     [Linux Resources]
  Powered by Linux