reiserfs: run scripts/Lindent on reiserfs code

This was a pure indentation change, using:

	scripts/Lindent fs/reiserfs/*.c include/linux/reiserfs_*.h

to make reiserfs match the regular Linux indentation style.  As Jeff
Mahoney <jeffm@suse.com> writes:

 The ReiserFS code is a mix of a number of different coding styles, sometimes
 different even from line-to-line. Since the code has been relatively stable
 for quite some time and there are few outstanding patches to be applied, it
 is time to reformat the code to conform to the Linux style standard outlined
 in Documentation/CodingStyle.

 This patch contains the result of running scripts/Lindent against
 fs/reiserfs/*.c and include/linux/reiserfs_*.h. There are places where the
 code can be made to look better, but I'd rather keep those patches separate
 so that there isn't a subtle by-hand hand accident in the middle of a huge
 patch. To be clear: This patch is reformatting *only*.

 A number of patches may follow that continue to make the code more consistent
 with the Linux coding style.

 Hans wasn't particularly enthusiastic about these patches, but said he
 wouldn't really oppose them either.
Signed-off-by: NLinus Torvalds <torvalds@osdl.org>

fs/reiserfs/dir.c

@@ -14,8 +14,9 @@
 
 extern struct reiserfs_key MIN_KEY;
 
-static int reiserfs_readdir (struct file *, void *, filldir_t);
-static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry, int datasync) ;
+static int reiserfs_readdir(struct file *, void *, filldir_t);
+static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry,
+			      int datasync);
 
 struct file_operations reiserfs_dir_operations = {
 	.read = generic_read_dir,
@@ -24,54 +25,58 @@ struct file_operations reiserfs_dir_operations = {
 	.ioctl = reiserfs_ioctl,
 };
 
-static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry, int datasync) {
+static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry,
+			      int datasync)
+{
 	struct inode *inode = dentry->d_inode;
 	int err;
 	reiserfs_write_lock(inode->i_sb);
-  err = reiserfs_commit_for_inode(inode) ;
-  reiserfs_write_unlock(inode->i_sb) ;
+	err = reiserfs_commit_for_inode(inode);
+	reiserfs_write_unlock(inode->i_sb);
 	if (err < 0)
 		return err;
 	return 0;
 }
 
-
 #define store_ih(where,what) copy_item_head (where, what)
 
 //
-static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldir)
+static int reiserfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
 	struct inode *inode = filp->f_dentry->d_inode;
 	struct cpu_key pos_key;	/* key of current position in the directory (key of directory entry) */
-    INITIALIZE_PATH (path_to_entry);
-    struct buffer_head * bh;
+	INITIALIZE_PATH(path_to_entry);
+	struct buffer_head *bh;
 	int item_num, entry_num;
-    const struct reiserfs_key * rkey;
-    struct item_head * ih, tmp_ih;
+	const struct reiserfs_key *rkey;
+	struct item_head *ih, tmp_ih;
 	int search_res;
-    char * local_buf;
+	char *local_buf;
 	loff_t next_pos;
-    char small_buf[32] ; /* avoid kmalloc if we can */
+	char small_buf[32];	/* avoid kmalloc if we can */
 	struct reiserfs_dir_entry de;
 	int ret = 0;
 
 	reiserfs_write_lock(inode->i_sb);
 
-    reiserfs_check_lock_depth(inode->i_sb, "readdir") ;
+	reiserfs_check_lock_depth(inode->i_sb, "readdir");
 
 	/* form key for search the next directory entry using f_pos field of
 	   file structure */
-    make_cpu_key (&pos_key, inode, (filp->f_pos) ? (filp->f_pos) : DOT_OFFSET,
-		  TYPE_DIRENTRY, 3);
-    next_pos = cpu_key_k_offset (&pos_key);
+	make_cpu_key(&pos_key, inode,
+		     (filp->f_pos) ? (filp->f_pos) : DOT_OFFSET, TYPE_DIRENTRY,
+		     3);
+	next_pos = cpu_key_k_offset(&pos_key);
 
-    /*  reiserfs_warning (inode->i_sb, "reiserfs_readdir 1: f_pos = %Ld", filp->f_pos);*/
+	/*  reiserfs_warning (inode->i_sb, "reiserfs_readdir 1: f_pos = %Ld", filp->f_pos); */
 
 	path_to_entry.reada = PATH_READA;
 	while (1) {
 	      research:
 		/* search the directory item, containing entry with specified key */
-	search_res = search_by_entry_key (inode->i_sb, &pos_key, &path_to_entry, &de);
+		search_res =
+		    search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
+					&de);
 		if (search_res == IO_ERROR) {
 			// FIXME: we could just skip part of directory which could
 			// not be read
@@ -82,68 +87,81 @@ static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldi
 		bh = de.de_bh;
 		item_num = de.de_item_num;
 		ih = de.de_ih;
-	store_ih (&tmp_ih, ih);
+		store_ih(&tmp_ih, ih);
 
 		/* we must have found item, that is item of this directory, */
-	RFALSE( COMP_SHORT_KEYS (&(ih->ih_key), &pos_key),
+		RFALSE(COMP_SHORT_KEYS(&(ih->ih_key), &pos_key),
 		       "vs-9000: found item %h does not match to dir we readdir %K",
 		       ih, &pos_key);
-	RFALSE( item_num > B_NR_ITEMS (bh) - 1,
+		RFALSE(item_num > B_NR_ITEMS(bh) - 1,
 		       "vs-9005 item_num == %d, item amount == %d",
-		item_num, B_NR_ITEMS (bh));
+		       item_num, B_NR_ITEMS(bh));
 
 		/* and entry must be not more than number of entries in the item */
-	RFALSE( I_ENTRY_COUNT (ih) < entry_num,
+		RFALSE(I_ENTRY_COUNT(ih) < entry_num,
 		       "vs-9010: entry number is too big %d (%d)",
-		entry_num, I_ENTRY_COUNT (ih));
+		       entry_num, I_ENTRY_COUNT(ih));
 
-	if (search_res == POSITION_FOUND || entry_num < I_ENTRY_COUNT (ih)) {
+		if (search_res == POSITION_FOUND
+		    || entry_num < I_ENTRY_COUNT(ih)) {
 			/* go through all entries in the directory item beginning from the entry, that has been found */
-	    struct reiserfs_de_head * deh = B_I_DEH (bh, ih) + entry_num;
+			struct reiserfs_de_head *deh =
+			    B_I_DEH(bh, ih) + entry_num;
 
-	    for (; entry_num < I_ENTRY_COUNT (ih); entry_num ++, deh ++) {
+			for (; entry_num < I_ENTRY_COUNT(ih);
+			     entry_num++, deh++) {
 				int d_reclen;
-		char * d_name;
+				char *d_name;
 				off_t d_off;
 				ino_t d_ino;
 
-		if (!de_visible (deh))
+				if (!de_visible(deh))
 					/* it is hidden entry */
 					continue;
-		d_reclen = entry_length (bh, ih, entry_num);
-		d_name = B_I_DEH_ENTRY_FILE_NAME (bh, ih, deh);
+				d_reclen = entry_length(bh, ih, entry_num);
+				d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);
 				if (!d_name[d_reclen - 1])
-		    d_reclen = strlen (d_name);
+					d_reclen = strlen(d_name);
 
-		if (d_reclen > REISERFS_MAX_NAME(inode->i_sb->s_blocksize)){
+				if (d_reclen >
+				    REISERFS_MAX_NAME(inode->i_sb->
+						      s_blocksize)) {
 					/* too big to send back to VFS */
-		    continue ;
+					continue;
 				}
 
 				/* Ignore the .reiserfs_priv entry */
-                if (reiserfs_xattrs (inode->i_sb) &&
+				if (reiserfs_xattrs(inode->i_sb) &&
 				    !old_format_only(inode->i_sb) &&
 				    filp->f_dentry == inode->i_sb->s_root &&
 				    REISERFS_SB(inode->i_sb)->priv_root &&
-                    REISERFS_SB(inode->i_sb)->priv_root->d_inode &&
-                    deh_objectid(deh) == le32_to_cpu (INODE_PKEY(REISERFS_SB(inode->i_sb)->priv_root->d_inode)->k_objectid)) {
+				    REISERFS_SB(inode->i_sb)->priv_root->d_inode
+				    && deh_objectid(deh) ==
+				    le32_to_cpu(INODE_PKEY
+						(REISERFS_SB(inode->i_sb)->
+						 priv_root->d_inode)->
+						k_objectid)) {
 					continue;
 				}
 
-		d_off = deh_offset (deh);
-		filp->f_pos = d_off ;
-		d_ino = deh_objectid (deh);
+				d_off = deh_offset(deh);
+				filp->f_pos = d_off;
+				d_ino = deh_objectid(deh);
 				if (d_reclen <= 32) {
-		  local_buf = small_buf ;
+					local_buf = small_buf;
 				} else {
-		    local_buf = reiserfs_kmalloc(d_reclen, GFP_NOFS, inode->i_sb) ;
+					local_buf =
+					    reiserfs_kmalloc(d_reclen, GFP_NOFS,
+							     inode->i_sb);
 					if (!local_buf) {
-			pathrelse (&path_to_entry);
-			ret = -ENOMEM ;
+						pathrelse(&path_to_entry);
+						ret = -ENOMEM;
 						goto out;
 					}
-		    if (item_moved (&tmp_ih, &path_to_entry)) {
-			reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
+					if (item_moved(&tmp_ih, &path_to_entry)) {
+						reiserfs_kfree(local_buf,
+							       d_reclen,
+							       inode->i_sb);
 						goto research;
 					}
 				}
@@ -151,56 +169,59 @@ static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldi
 				// buffer (local_buf) because filldir will block if
 				// user space buffer is swapped out. At that time
 				// entry can move to somewhere else
-		memcpy (local_buf, d_name, d_reclen);
-		if (filldir (dirent, local_buf, d_reclen, d_off, d_ino, 
+				memcpy(local_buf, d_name, d_reclen);
+				if (filldir
+				    (dirent, local_buf, d_reclen, d_off, d_ino,
 				     DT_UNKNOWN) < 0) {
 					if (local_buf != small_buf) {
-			reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
+						reiserfs_kfree(local_buf,
+							       d_reclen,
+							       inode->i_sb);
 					}
 					goto end;
 				}
 				if (local_buf != small_buf) {
-		    reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
+					reiserfs_kfree(local_buf, d_reclen,
+						       inode->i_sb);
 				}
-
 				// next entry should be looked for with such offset
-		next_pos = deh_offset (deh) + 1;
+				next_pos = deh_offset(deh) + 1;
 
-		if (item_moved (&tmp_ih, &path_to_entry)) {
+				if (item_moved(&tmp_ih, &path_to_entry)) {
 					goto research;
 				}
 			}	/* for */
 		}
 
-	if (item_num != B_NR_ITEMS (bh) - 1)
+		if (item_num != B_NR_ITEMS(bh) - 1)
 			// end of directory has been reached
 			goto end;
 
 		/* item we went through is last item of node. Using right
 		   delimiting key check is it directory end */
-	rkey = get_rkey (&path_to_entry, inode->i_sb);
-	if (! comp_le_keys (rkey, &MIN_KEY)) {
+		rkey = get_rkey(&path_to_entry, inode->i_sb);
+		if (!comp_le_keys(rkey, &MIN_KEY)) {
 			/* set pos_key to key, that is the smallest and greater
 			   that key of the last entry in the item */
-	    set_cpu_key_k_offset (&pos_key, next_pos);
+			set_cpu_key_k_offset(&pos_key, next_pos);
 			continue;
 		}
 
-	if ( COMP_SHORT_KEYS (rkey, &pos_key)) {
+		if (COMP_SHORT_KEYS(rkey, &pos_key)) {
 			// end of directory has been reached
 			goto end;
 		}
 
 		/* directory continues in the right neighboring block */
-	set_cpu_key_k_offset (&pos_key, le_key_k_offset (KEY_FORMAT_3_5, rkey));
+		set_cpu_key_k_offset(&pos_key,
+				     le_key_k_offset(KEY_FORMAT_3_5, rkey));
 
 	}			/* while */
 
-
       end:
 	filp->f_pos = next_pos;
-    pathrelse (&path_to_entry);
-    reiserfs_check_path(&path_to_entry) ;
+	pathrelse(&path_to_entry);
+	reiserfs_check_path(&path_to_entry);
       out:
 	reiserfs_write_unlock(inode->i_sb);
 	return ret;
@@ -209,67 +230,68 @@ static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldi
 /* compose directory item containing "." and ".." entries (entries are
    not aligned to 4 byte boundary) */
 /* the last four params are LE */
-void make_empty_dir_item_v1 (char * body, __le32 dirid, __le32 objid,
+void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
 			    __le32 par_dirid, __le32 par_objid)
 {
-    struct reiserfs_de_head * deh;
+	struct reiserfs_de_head *deh;
 
-    memset (body, 0, EMPTY_DIR_SIZE_V1);
+	memset(body, 0, EMPTY_DIR_SIZE_V1);
 	deh = (struct reiserfs_de_head *)body;
 
 	/* direntry header of "." */
-    put_deh_offset( &(deh[0]), DOT_OFFSET );
+	put_deh_offset(&(deh[0]), DOT_OFFSET);
 	/* these two are from make_le_item_head, and are are LE */
 	deh[0].deh_dir_id = dirid;
 	deh[0].deh_objectid = objid;
 	deh[0].deh_state = 0;	/* Endian safe if 0 */
-    put_deh_location( &(deh[0]), EMPTY_DIR_SIZE_V1 - strlen( "." ));
+	put_deh_location(&(deh[0]), EMPTY_DIR_SIZE_V1 - strlen("."));
 	mark_de_visible(&(deh[0]));
 
 	/* direntry header of ".." */
-    put_deh_offset( &(deh[1]), DOT_DOT_OFFSET);
+	put_deh_offset(&(deh[1]), DOT_DOT_OFFSET);
 	/* key of ".." for the root directory */
 	/* these two are from the inode, and are are LE */
 	deh[1].deh_dir_id = par_dirid;
 	deh[1].deh_objectid = par_objid;
 	deh[1].deh_state = 0;	/* Endian safe if 0 */
-    put_deh_location( &(deh[1]), deh_location( &(deh[0]) ) - strlen( ".." ) );
+	put_deh_location(&(deh[1]), deh_location(&(deh[0])) - strlen(".."));
 	mark_de_visible(&(deh[1]));
 
 	/* copy ".." and "." */
-    memcpy (body + deh_location( &(deh[0]) ), ".", 1);
-    memcpy (body + deh_location( &(deh[1]) ), "..", 2);
+	memcpy(body + deh_location(&(deh[0])), ".", 1);
+	memcpy(body + deh_location(&(deh[1])), "..", 2);
 }
 
 /* compose directory item containing "." and ".." entries */
-void make_empty_dir_item (char * body, __le32 dirid, __le32 objid,
+void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,
 			 __le32 par_dirid, __le32 par_objid)
 {
-    struct reiserfs_de_head * deh;
+	struct reiserfs_de_head *deh;
 
-    memset (body, 0, EMPTY_DIR_SIZE);
+	memset(body, 0, EMPTY_DIR_SIZE);
 	deh = (struct reiserfs_de_head *)body;
 
 	/* direntry header of "." */
-    put_deh_offset( &(deh[0]), DOT_OFFSET );
+	put_deh_offset(&(deh[0]), DOT_OFFSET);
 	/* these two are from make_le_item_head, and are are LE */
 	deh[0].deh_dir_id = dirid;
 	deh[0].deh_objectid = objid;
 	deh[0].deh_state = 0;	/* Endian safe if 0 */
-    put_deh_location( &(deh[0]), EMPTY_DIR_SIZE - ROUND_UP( strlen( "." ) ) );
+	put_deh_location(&(deh[0]), EMPTY_DIR_SIZE - ROUND_UP(strlen(".")));
 	mark_de_visible(&(deh[0]));
 
 	/* direntry header of ".." */
-    put_deh_offset( &(deh[1]), DOT_DOT_OFFSET );
+	put_deh_offset(&(deh[1]), DOT_DOT_OFFSET);
 	/* key of ".." for the root directory */
 	/* these two are from the inode, and are are LE */
 	deh[1].deh_dir_id = par_dirid;
 	deh[1].deh_objectid = par_objid;
 	deh[1].deh_state = 0;	/* Endian safe if 0 */
-    put_deh_location( &(deh[1]), deh_location( &(deh[0])) - ROUND_UP( strlen( ".." ) ) );
+	put_deh_location(&(deh[1]),
+			 deh_location(&(deh[0])) - ROUND_UP(strlen("..")));
 	mark_de_visible(&(deh[1]));
 
 	/* copy ".." and "." */
-    memcpy (body + deh_location( &(deh[0]) ), ".", 1);
-    memcpy (body + deh_location( &(deh[1]) ), "..", 2);
+	memcpy(body + deh_location(&(deh[0])), ".", 1);
+	memcpy(body + deh_location(&(deh[1])), "..", 2);
 }

fs/reiserfs/hashes.c

@@ -22,7 +22,6 @@
 #include <asm/types.h>
 #include <asm/bug.h>
 
-
 #define DELTA 0x9E3779B9
 #define FULLROUNDS 10		/* 32 is overkill, 16 is strong crypto */
 #define PARTROUNDS 6		/* 6 gets complete mixing */
@@ -48,10 +47,9 @@
 		h1 += b1;						\
 	} while(0)
 
-
 u32 keyed_hash(const signed char *msg, int len)
 {
-	u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3}; 
+	u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3 };
 
 	u32 h0 = k[0], h1 = k[1];
 	u32 a, b, c, d;
@@ -60,27 +58,20 @@ u32 keyed_hash(const signed char *msg, int len)
 
 	//      assert(len >= 0 && len < 256);
 
-	pad = (u32)len | ((u32)len << 8);
+	pad = (u32) len | ((u32) len << 8);
 	pad |= pad << 16;
 
-	while(len >= 16)
-	{
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
-		b = (u32)msg[ 4]      |
-		    (u32)msg[ 5] << 8 |
-		    (u32)msg[ 6] << 16|
-		    (u32)msg[ 7] << 24;
-		c = (u32)msg[ 8]      |
-		    (u32)msg[ 9] << 8 |
-		    (u32)msg[10] << 16|
-		    (u32)msg[11] << 24;
-		d = (u32)msg[12]      |
-		    (u32)msg[13] << 8 |
-		    (u32)msg[14] << 16|
-		    (u32)msg[15] << 24;
+	while (len >= 16) {
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
+		b = (u32) msg[4] |
+		    (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
+		c = (u32) msg[8] |
+		    (u32) msg[9] << 8 |
+		    (u32) msg[10] << 16 | (u32) msg[11] << 24;
+		d = (u32) msg[12] |
+		    (u32) msg[13] << 8 |
+		    (u32) msg[14] << 16 | (u32) msg[15] << 24;
 
 		TEACORE(PARTROUNDS);
 
@@ -88,65 +79,43 @@ u32 keyed_hash(const signed char *msg, int len)
 		msg += 16;
 	}
 
-	if (len >= 12)
-	{
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
-		b = (u32)msg[ 4]      |
-		    (u32)msg[ 5] << 8 |
-		    (u32)msg[ 6] << 16|
-		    (u32)msg[ 7] << 24;
-		c = (u32)msg[ 8]      |
-		    (u32)msg[ 9] << 8 |
-		    (u32)msg[10] << 16|
-		    (u32)msg[11] << 24;
+	if (len >= 12) {
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
+		b = (u32) msg[4] |
+		    (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
+		c = (u32) msg[8] |
+		    (u32) msg[9] << 8 |
+		    (u32) msg[10] << 16 | (u32) msg[11] << 24;
 
 		d = pad;
-		for(i = 12; i < len; i++)
-		{
+		for (i = 12; i < len; i++) {
 			d <<= 8;
 			d |= msg[i];
 		}
-	}
-	else if (len >= 8)
-	{
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
-		b = (u32)msg[ 4]      |
-		    (u32)msg[ 5] << 8 |
-		    (u32)msg[ 6] << 16|
-		    (u32)msg[ 7] << 24;
+	} else if (len >= 8) {
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
+		b = (u32) msg[4] |
+		    (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
 
 		c = d = pad;
-		for(i = 8; i < len; i++)
-		{
+		for (i = 8; i < len; i++) {
 			c <<= 8;
 			c |= msg[i];
 		}
-	}
-	else if (len >= 4)
-	{
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
+	} else if (len >= 4) {
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
 
 		b = c = d = pad;
-		for(i = 4; i < len; i++)
-		{
+		for (i = 4; i < len; i++) {
 			b <<= 8;
 			b |= msg[i];
 		}
-	}
-	else
-	{
+	} else {
 		a = b = c = d = pad;
-		for(i = 0; i < len; i++)
-		{
+		for (i = 0; i < len; i++) {
 			a <<= 8;
 			a |= msg[i];
 		}
@@ -155,40 +124,44 @@ u32 keyed_hash(const signed char *msg, int len)
 	TEACORE(FULLROUNDS);
 
 /*	return 0;*/
-	return h0^h1;
+	return h0 ^ h1;
 }
 
 /* What follows in this file is copyright 2000 by Hans Reiser, and the
  * licensing of what follows is governed by reiserfs/README */
 
-u32 yura_hash (const signed char *msg, int len)
+u32 yura_hash(const signed char *msg, int len)
 {
 	int j, pow;
 	u32 a, c;
 	int i;
 
-    for (pow=1,i=1; i < len; i++) pow = pow * 10; 
+	for (pow = 1, i = 1; i < len; i++)
+		pow = pow * 10;
 
 	if (len == 1)
-	a = msg[0]-48;
+		a = msg[0] - 48;
 	else
 		a = (msg[0] - 48) * pow;
 
-    for (i=1; i < len; i++) {
+	for (i = 1; i < len; i++) {
 		c = msg[i] - 48;
-	for (pow=1,j=i; j < len-1; j++) pow = pow * 10; 
+		for (pow = 1, j = i; j < len - 1; j++)
+			pow = pow * 10;
 		a = a + c * pow;
 	}
 
 	for (; i < 40; i++) {
 		c = '0' - 48;
-	for (pow=1,j=i; j < len-1; j++) pow = pow * 10; 
+		for (pow = 1, j = i; j < len - 1; j++)
+			pow = pow * 10;
 		a = a + c * pow;
 	}
 
 	for (; i < 256; i++) {
 		c = i;
-	for (pow=1,j=i; j < len-1; j++) pow = pow * 10; 
+		for (pow = 1, j = i; j < len - 1; j++)
+			pow = pow * 10;
 		a = a + c * pow;
 	}
 
@@ -196,10 +169,10 @@ u32 yura_hash (const signed char *msg, int len)
 	return a;
 }
 
-u32 r5_hash (const signed char *msg, int len)
+u32 r5_hash(const signed char *msg, int len)
 {
-  u32 a=0;
-  while(*msg) { 
+	u32 a = 0;
+	while (*msg) {
 		a += *msg << 4;
 		a += *msg >> 4;
 		a *= 11;

fs/reiserfs/ioctl.c

@@ -9,7 +9,7 @@
 #include <linux/pagemap.h>
 #include <linux/smp_lock.h>
 
-static int reiserfs_unpack (struct inode * inode, struct file * filp);
+static int reiserfs_unpack(struct inode *inode, struct file *filp);
 
 /*
 ** reiserfs_ioctl - handler for ioctl for inode
@@ -19,16 +19,16 @@ static int reiserfs_unpack (struct inode * inode, struct file * filp);
 **  2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION
 **  3) That's all for a while ...
 */
-int reiserfs_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
+int reiserfs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
 		   unsigned long arg)
 {
 	unsigned int flags;
 
 	switch (cmd) {
 	case REISERFS_IOC_UNPACK:
-		if( S_ISREG( inode -> i_mode ) ) {
+		if (S_ISREG(inode->i_mode)) {
 			if (arg)
-		    return reiserfs_unpack (inode, filp);
+				return reiserfs_unpack(inode, filp);
 			else
 				return 0;
 		} else
@@ -36,51 +36,54 @@ int reiserfs_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
 		/* following two cases are taken from fs/ext2/ioctl.c by Remy
 		   Card (card@masi.ibp.fr) */
 	case REISERFS_IOC_GETFLAGS:
-		if (!reiserfs_attrs (inode->i_sb))
+		if (!reiserfs_attrs(inode->i_sb))
 			return -ENOTTY;
 
-		flags = REISERFS_I(inode) -> i_attrs;
-		i_attrs_to_sd_attrs( inode, ( __u16 * ) &flags );
-		return put_user(flags, (int __user *) arg);
-	case REISERFS_IOC_SETFLAGS: {
-		if (!reiserfs_attrs (inode->i_sb))
+		flags = REISERFS_I(inode)->i_attrs;
+		i_attrs_to_sd_attrs(inode, (__u16 *) & flags);
+		return put_user(flags, (int __user *)arg);
+	case REISERFS_IOC_SETFLAGS:{
+			if (!reiserfs_attrs(inode->i_sb))
 				return -ENOTTY;
 
 			if (IS_RDONLY(inode))
 				return -EROFS;
 
-		if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+			if ((current->fsuid != inode->i_uid)
+			    && !capable(CAP_FOWNER))
 				return -EPERM;
 
-		if (get_user(flags, (int __user *) arg))
+			if (get_user(flags, (int __user *)arg))
 				return -EFAULT;
 
-		if ( ( ( flags ^ REISERFS_I(inode) -> i_attrs) & ( REISERFS_IMMUTABLE_FL | REISERFS_APPEND_FL)) &&
-		     !capable( CAP_LINUX_IMMUTABLE ) )
+			if (((flags ^ REISERFS_I(inode)->
+			      i_attrs) & (REISERFS_IMMUTABLE_FL |
+					  REISERFS_APPEND_FL))
+			    && !capable(CAP_LINUX_IMMUTABLE))
 				return -EPERM;
 
-		if( ( flags & REISERFS_NOTAIL_FL ) &&
-		    S_ISREG( inode -> i_mode ) ) {
+			if ((flags & REISERFS_NOTAIL_FL) &&
+			    S_ISREG(inode->i_mode)) {
 				int result;
 
-				result = reiserfs_unpack( inode, filp );
-				if( result )
+				result = reiserfs_unpack(inode, filp);
+				if (result)
 					return result;
 			}
-		sd_attrs_to_i_attrs( flags, inode );
-		REISERFS_I(inode) -> i_attrs = flags;
+			sd_attrs_to_i_attrs(flags, inode);
+			REISERFS_I(inode)->i_attrs = flags;
 			inode->i_ctime = CURRENT_TIME_SEC;
 			mark_inode_dirty(inode);
 			return 0;
 		}
 	case REISERFS_IOC_GETVERSION:
-		return put_user(inode->i_generation, (int __user *) arg);
+		return put_user(inode->i_generation, (int __user *)arg);
 	case REISERFS_IOC_SETVERSION:
 		if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
 			return -EPERM;
 		if (IS_RDONLY(inode))
 			return -EROFS;
-		if (get_user(inode->i_generation, (int __user *) arg))
+		if (get_user(inode->i_generation, (int __user *)arg))
 			return -EFAULT;
 		inode->i_ctime = CURRENT_TIME_SEC;
 		mark_inode_dirty(inode);
@@ -95,63 +98,65 @@ int reiserfs_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
 ** Function try to convert tail from direct item into indirect.
 ** It set up nopack attribute in the REISERFS_I(inode)->nopack
 */
-static int reiserfs_unpack (struct inode * inode, struct file * filp)
+static int reiserfs_unpack(struct inode *inode, struct file *filp)
 {
 	int retval = 0;
-    int index ;
-    struct page *page ;
-    struct address_space *mapping ;
-    unsigned long write_from ;
-    unsigned long blocksize = inode->i_sb->s_blocksize ;
+	int index;
+	struct page *page;
+	struct address_space *mapping;
+	unsigned long write_from;
+	unsigned long blocksize = inode->i_sb->s_blocksize;
 
 	if (inode->i_size == 0) {
 		REISERFS_I(inode)->i_flags |= i_nopack_mask;
-        return 0 ;
+		return 0;
 	}
 	/* ioctl already done */
 	if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
-        return 0 ;
+		return 0;
 	}
 	reiserfs_write_lock(inode->i_sb);
 
 	/* we need to make sure nobody is changing the file size beneath
 	 ** us
 	 */
-    down(&inode->i_sem) ;
+	down(&inode->i_sem);
 
-    write_from = inode->i_size & (blocksize - 1) ;
+	write_from = inode->i_size & (blocksize - 1);
 	/* if we are on a block boundary, we are already unpacked.  */
-    if ( write_from == 0) {
+	if (write_from == 0) {
 		REISERFS_I(inode)->i_flags |= i_nopack_mask;
-	goto out ;
+		goto out;
 	}
 
 	/* we unpack by finding the page with the tail, and calling
 	 ** reiserfs_prepare_write on that page.  This will force a 
 	 ** reiserfs_get_block to unpack the tail for us.
 	 */
-    index = inode->i_size >> PAGE_CACHE_SHIFT ;
-    mapping = inode->i_mapping ;
-    page = grab_cache_page(mapping, index) ;
+	index = inode->i_size >> PAGE_CACHE_SHIFT;
+	mapping = inode->i_mapping;
+	page = grab_cache_page(mapping, index);
 	retval = -ENOMEM;
 	if (!page) {
-        goto out ;
+		goto out;
 	}
-    retval = mapping->a_ops->prepare_write(NULL, page, write_from, write_from) ;
+	retval =
+	    mapping->a_ops->prepare_write(NULL, page, write_from, write_from);
 	if (retval)
-        goto out_unlock ;
+		goto out_unlock;
 
 	/* conversion can change page contents, must flush */
-    flush_dcache_page(page) ;
-    retval = mapping->a_ops->commit_write(NULL, page, write_from, write_from) ;
+	flush_dcache_page(page);
+	retval =
+	    mapping->a_ops->commit_write(NULL, page, write_from, write_from);
 	REISERFS_I(inode)->i_flags |= i_nopack_mask;
 
-out_unlock:
-    unlock_page(page) ;
-    page_cache_release(page) ;
+      out_unlock:
+	unlock_page(page);
+	page_cache_release(page);
 
-out:
-    up(&inode->i_sem) ;
+      out:
+	up(&inode->i_sem);
 	reiserfs_write_unlock(inode->i_sb);
 	return retval;
 }

fs/reiserfs/objectid.c

@@ -14,24 +14,24 @@
                          (__le32 *)((struct reiserfs_super_block_v1 *)(rs) + 1) :\
 			 (__le32 *)((rs) + 1))
 
-
 #ifdef CONFIG_REISERFS_CHECK
 
-static void check_objectid_map (struct super_block * s, __le32 * map)
+static void check_objectid_map(struct super_block *s, __le32 * map)
 {
-    if (le32_to_cpu (map[0]) != 1)
-	reiserfs_panic (s, "vs-15010: check_objectid_map: map corrupted: %lx",
-			( long unsigned int ) le32_to_cpu (map[0]));
+	if (le32_to_cpu(map[0]) != 1)
+		reiserfs_panic(s,
+			       "vs-15010: check_objectid_map: map corrupted: %lx",
+			       (long unsigned int)le32_to_cpu(map[0]));
 
 	// FIXME: add something else here
 }
 
 #else
-static void check_objectid_map (struct super_block * s, __le32 * map)
-{;}
+static void check_objectid_map(struct super_block *s, __le32 * map)
+{;
+}
 #endif
 
-
 /* When we allocate objectids we allocate the first unused objectid.
    Each sequence of objectids in use (the odd sequences) is followed
    by a sequence of objectids not in use (the even sequences).  We
@@ -46,25 +46,24 @@ static void check_objectid_map (struct super_block * s, __le32 * map)
    interesting optimizations of layout could result from complicating
    objectid assignment, but we have deferred making them for now. */
 
-
 /* get unique object identifier */
-__u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th)
+__u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th)
 {
-    struct super_block * s = th->t_super;
-    struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK (s);
-    __le32 * map = objectid_map (s, rs);
+	struct super_block *s = th->t_super;
+	struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
+	__le32 *map = objectid_map(s, rs);
 	__u32 unused_objectid;
 
-    BUG_ON (!th->t_trans_id);
+	BUG_ON(!th->t_trans_id);
 
-    check_objectid_map (s, map);
+	check_objectid_map(s, map);
 
-    reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
+	reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
 	/* comment needed -Hans */
-    unused_objectid = le32_to_cpu (map[1]);
+	unused_objectid = le32_to_cpu(map[1]);
 	if (unused_objectid == U32_MAX) {
-	reiserfs_warning (s, "%s: no more object ids", __FUNCTION__);
-	reiserfs_restore_prepared_buffer(s, SB_BUFFER_WITH_SB(s)) ;
+		reiserfs_warning(s, "%s: no more object ids", __FUNCTION__);
+		reiserfs_restore_prepared_buffer(s, SB_BUFFER_WITH_SB(s));
 		return 0;
 	}
 
@@ -73,7 +72,7 @@ __u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th)
 	   unused objectid, and by incrementing it we use it.  See below
 	   where we check to see if we eliminated a sequence of unused
 	   objectids.... */
-    map[1] = cpu_to_le32 (unused_objectid + 1);
+	map[1] = cpu_to_le32(unused_objectid + 1);
 
 	/* Now we check to see if we eliminated the last remaining member of
 	   the first even sequence (and can eliminate the sequence by
@@ -82,30 +81,30 @@ __u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th)
 	   result is to eliminate a pair of objectids from oids.  We do this
 	   by shifting the entire map to the left. */
 	if (sb_oid_cursize(rs) > 2 && map[1] == map[2]) {
-	memmove (map + 1, map + 3, (sb_oid_cursize(rs) - 3) * sizeof(__u32));
-        set_sb_oid_cursize( rs, sb_oid_cursize(rs) - 2 );
+		memmove(map + 1, map + 3,
+			(sb_oid_cursize(rs) - 3) * sizeof(__u32));
+		set_sb_oid_cursize(rs, sb_oid_cursize(rs) - 2);
 	}
 
-    journal_mark_dirty(th, s, SB_BUFFER_WITH_SB (s));
+	journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
 	return unused_objectid;
 }
 
-
 /* makes object identifier unused */
-void reiserfs_release_objectid (struct reiserfs_transaction_handle *th, 
+void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
 			       __u32 objectid_to_release)
 {
-    struct super_block * s = th->t_super;
-    struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK (s);
-    __le32 * map = objectid_map (s, rs);
+	struct super_block *s = th->t_super;
+	struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
+	__le32 *map = objectid_map(s, rs);
 	int i = 0;
 
-    BUG_ON (!th->t_trans_id);
+	BUG_ON(!th->t_trans_id);
 	//return;
-    check_objectid_map (s, map);
+	check_objectid_map(s, map);
 
-    reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
-    journal_mark_dirty(th, s, SB_BUFFER_WITH_SB (s)); 
+	reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
+	journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
 
 	/* start at the beginning of the objectid map (i = 0) and go to
 	   the end of it (i = disk_sb->s_oid_cursize).  Linear search is
@@ -113,20 +112,21 @@ void reiserfs_release_objectid (struct reiserfs_transaction_handle *th,
 	   more efficient after performing lots of deletions (which is
 	   when oids is large.)  We only check even i's. */
 	while (i < sb_oid_cursize(rs)) {
-	if (objectid_to_release == le32_to_cpu (map[i])) {
+		if (objectid_to_release == le32_to_cpu(map[i])) {
 			/* This incrementation unallocates the objectid. */
 			//map[i]++;
-	    map[i] = cpu_to_le32 (le32_to_cpu (map[i]) + 1);
+			map[i] = cpu_to_le32(le32_to_cpu(map[i]) + 1);
 
 			/* Did we unallocate the last member of an odd sequence, and can shrink oids? */
-	    if (map[i] == map[i+1]) {
+			if (map[i] == map[i + 1]) {
 				/* shrink objectid map */
-		memmove (map + i, map + i + 2, 
-			 (sb_oid_cursize(rs) - i - 2) * sizeof (__u32));
+				memmove(map + i, map + i + 2,
+					(sb_oid_cursize(rs) - i -
+					 2) * sizeof(__u32));
 				//disk_sb->s_oid_cursize -= 2;
-                set_sb_oid_cursize( rs, sb_oid_cursize(rs) - 2 );
+				set_sb_oid_cursize(rs, sb_oid_cursize(rs) - 2);
 
-		RFALSE( sb_oid_cursize(rs) < 2 || 
+				RFALSE(sb_oid_cursize(rs) < 2 ||
 				       sb_oid_cursize(rs) > sb_oid_maxsize(rs),
 				       "vs-15005: objectid map corrupted cur_size == %d (max == %d)",
 				       sb_oid_cursize(rs), sb_oid_maxsize(rs));
@@ -134,73 +134,74 @@ void reiserfs_release_objectid (struct reiserfs_transaction_handle *th,
 			return;
 		}
 
-	if (objectid_to_release > le32_to_cpu (map[i]) && 
-	    objectid_to_release < le32_to_cpu (map[i + 1])) {
+		if (objectid_to_release > le32_to_cpu(map[i]) &&
+		    objectid_to_release < le32_to_cpu(map[i + 1])) {
 			/* size of objectid map is not changed */
-	    if (objectid_to_release + 1 == le32_to_cpu (map[i + 1])) {
+			if (objectid_to_release + 1 == le32_to_cpu(map[i + 1])) {
 				//objectid_map[i+1]--;
-		map[i + 1] = cpu_to_le32 (le32_to_cpu (map[i + 1]) - 1);
+				map[i + 1] =
+				    cpu_to_le32(le32_to_cpu(map[i + 1]) - 1);
 				return;
 			}
 
 			/* JDM comparing two little-endian values for equality -- safe */
 			if (sb_oid_cursize(rs) == sb_oid_maxsize(rs)) {
 				/* objectid map must be expanded, but there is no space */
-		PROC_INFO_INC( s, leaked_oid );
+				PROC_INFO_INC(s, leaked_oid);
 				return;
 			}
 
-	    /* expand the objectid map*/
-	    memmove (map + i + 3, map + i + 1, 
+			/* expand the objectid map */
+			memmove(map + i + 3, map + i + 1,
 				(sb_oid_cursize(rs) - i - 1) * sizeof(__u32));
-	    map[i + 1] = cpu_to_le32 (objectid_to_release);
-	    map[i + 2] = cpu_to_le32 (objectid_to_release + 1);
-            set_sb_oid_cursize( rs, sb_oid_cursize(rs) + 2 );
+			map[i + 1] = cpu_to_le32(objectid_to_release);
+			map[i + 2] = cpu_to_le32(objectid_to_release + 1);
+			set_sb_oid_cursize(rs, sb_oid_cursize(rs) + 2);
 			return;
 		}
 		i += 2;
 	}
 
-    reiserfs_warning (s, "vs-15011: reiserfs_release_objectid: tried to free free object id (%lu)",
-		      ( long unsigned ) objectid_to_release);
+	reiserfs_warning(s,
+			 "vs-15011: reiserfs_release_objectid: tried to free free object id (%lu)",
+			 (long unsigned)objectid_to_release);
 }
 
-
-int reiserfs_convert_objectid_map_v1(struct super_block *s) {
-    struct reiserfs_super_block *disk_sb = SB_DISK_SUPER_BLOCK (s);
+int reiserfs_convert_objectid_map_v1(struct super_block *s)
+{
+	struct reiserfs_super_block *disk_sb = SB_DISK_SUPER_BLOCK(s);
 	int cur_size = sb_oid_cursize(disk_sb);
-    int new_size = (s->s_blocksize - SB_SIZE) / sizeof(__u32) / 2 * 2 ;
+	int new_size = (s->s_blocksize - SB_SIZE) / sizeof(__u32) / 2 * 2;
 	int old_max = sb_oid_maxsize(disk_sb);
-    struct reiserfs_super_block_v1 *disk_sb_v1 ;
-    __le32 *objectid_map, *new_objectid_map ;
-    int i ;
+	struct reiserfs_super_block_v1 *disk_sb_v1;
+	__le32 *objectid_map, *new_objectid_map;
+	int i;
 
-    disk_sb_v1=(struct reiserfs_super_block_v1 *)(SB_BUFFER_WITH_SB(s)->b_data);
-    objectid_map = (__le32 *)(disk_sb_v1 + 1) ;
-    new_objectid_map = (__le32 *)(disk_sb + 1) ;
+	disk_sb_v1 =
+	    (struct reiserfs_super_block_v1 *)(SB_BUFFER_WITH_SB(s)->b_data);
+	objectid_map = (__le32 *) (disk_sb_v1 + 1);
+	new_objectid_map = (__le32 *) (disk_sb + 1);
 
 	if (cur_size > new_size) {
 		/* mark everyone used that was listed as free at the end of the objectid
 		 ** map 
 		 */
-	objectid_map[new_size - 1] = objectid_map[cur_size - 1] ;
-	set_sb_oid_cursize(disk_sb,new_size) ;
+		objectid_map[new_size - 1] = objectid_map[cur_size - 1];
+		set_sb_oid_cursize(disk_sb, new_size);
 	}
 	/* move the smaller objectid map past the end of the new super */
-    for (i = new_size - 1 ; i >= 0 ; i--) {
-        objectid_map[i + (old_max - new_size)] = objectid_map[i] ; 
+	for (i = new_size - 1; i >= 0; i--) {
+		objectid_map[i + (old_max - new_size)] = objectid_map[i];
 	}
 
-
 	/* set the max size so we don't overflow later */
-    set_sb_oid_maxsize(disk_sb,new_size) ;
+	set_sb_oid_maxsize(disk_sb, new_size);
 
 	/* Zero out label and generate random UUID */
-    memset(disk_sb->s_label, 0, sizeof(disk_sb->s_label)) ;
+	memset(disk_sb->s_label, 0, sizeof(disk_sb->s_label));
 	generate_random_uuid(disk_sb->s_uuid);
 
 	/* finally, zero out the unused chunk of the new super */
-    memset(disk_sb->s_unused, 0, sizeof(disk_sb->s_unused)) ;
-    return 0 ;
+	memset(disk_sb->s_unused, 0, sizeof(disk_sb->s_unused));
+	return 0;
 }
-

fs/reiserfs/xattr_security.c

@@ -9,7 +9,7 @@
 #define XATTR_SECURITY_PREFIX "security."
 
 static int
-security_get (struct inode *inode, const char *name, void *buffer, size_t size)
+security_get(struct inode *inode, const char *name, void *buffer, size_t size)
 {
 	if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
 		return -EINVAL;
@@ -17,11 +17,11 @@ security_get (struct inode *inode, const char *name, void *buffer, size_t size)
 	if (is_reiserfs_priv_object(inode))
 		return -EPERM;
 
-    return reiserfs_xattr_get (inode, name, buffer, size);
+	return reiserfs_xattr_get(inode, name, buffer, size);
 }
 
 static int
-security_set (struct inode *inode, const char *name, const void *buffer,
+security_set(struct inode *inode, const char *name, const void *buffer,
 	     size_t size, int flags)
 {
 	if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
@@ -30,11 +30,10 @@ security_set (struct inode *inode, const char *name, const void *buffer,
 	if (is_reiserfs_priv_object(inode))
 		return -EPERM;
 
-    return reiserfs_xattr_set (inode, name, buffer, size, flags);
+	return reiserfs_xattr_set(inode, name, buffer, size, flags);
 }
 
-static int
-security_del (struct inode *inode, const char *name)
+static int security_del(struct inode *inode, const char *name)
 {
 	if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
 		return -EINVAL;
@@ -46,7 +45,7 @@ security_del (struct inode *inode, const char *name)
 }
 
 static int
-security_list (struct inode *inode, const char *name, int namelen, char *out)
+security_list(struct inode *inode, const char *name, int namelen, char *out)
 {
 	int len = namelen;
 
@@ -54,12 +53,11 @@ security_list (struct inode *inode, const char *name, int namelen, char *out)
 		return 0;
 
 	if (out)
-        memcpy (out, name, len);
+		memcpy(out, name, len);
 
 	return len;
 }
 
-
 struct reiserfs_xattr_handler security_handler = {
 	.prefix = XATTR_SECURITY_PREFIX,
 	.get = security_get,

include/linux/reiserfs_fs_i.h

@@ -27,9 +27,8 @@ typedef enum {
 	i_data_log = 0x0080,
 } reiserfs_inode_flags;
 
-
 struct reiserfs_inode_info {
-    __u32 i_key [4];/* key is still 4 32 bit integers */
+	__u32 i_key[4];		/* key is still 4 32 bit integers */
     /** transient inode flags that are never stored on disk. Bitmasks
       for this field are defined above. */
 	__u32 i_flags;
@@ -51,7 +50,7 @@ struct reiserfs_inode_info {
 	/* we use these for fsync or O_SYNC to decide which transaction
 	 ** needs to be committed in order for this inode to be properly
 	 ** flushed */
-    unsigned long i_trans_id ;
+	unsigned long i_trans_id;
 	struct reiserfs_journal_list *i_jl;
 
 	struct posix_acl *i_acl_access;