| blob | e7408f622327d717663b466aa6546dc2fc7efaea |
1 ext4: Fix whitespace checkpatch warnings/errors
3 Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
5 diff --git a/fs/ext4/acl.h b/fs/ext4/acl.h
6 index cd2b855..4c9948f 100644
7 --- a/fs/ext4/acl.h
8 +++ b/fs/ext4/acl.h
9 @@ -58,9 +58,9 @@ static inline int ext4_acl_count(size_t size)
10 #define EXT4_ACL_NOT_CACHED ((void *)-1)
12 /* acl.c */
13 -extern int ext4_permission (struct inode *, int);
14 -extern int ext4_acl_chmod (struct inode *);
15 -extern int ext4_init_acl (handle_t *, struct inode *, struct inode *);
16 +extern int ext4_permission(struct inode *, int);
17 +extern int ext4_acl_chmod(struct inode *);
18 +extern int ext4_init_acl(handle_t *, struct inode *, struct inode *);
20 #else /* CONFIG_EXT4DEV_FS_POSIX_ACL */
21 #include <linux/sched.h>
22 diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
23 index 7aac202..58005c0 100644
24 --- a/fs/ext4/balloc.c
25 +++ b/fs/ext4/balloc.c
26 @@ -132,7 +132,7 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
27 */
28 group_blocks = ext4_blocks_count(sbi->s_es) -
29 le32_to_cpu(sbi->s_es->s_first_data_block) -
30 - (EXT4_BLOCKS_PER_GROUP(sb) * (sbi->s_groups_count -1));
31 + (EXT4_BLOCKS_PER_GROUP(sb) * (sbi->s_groups_count - 1));
32 } else {
33 group_blocks = EXT4_BLOCKS_PER_GROUP(sb);
34 }
35 @@ -200,20 +200,20 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
36 * @bh: pointer to the buffer head to store the block
37 * group descriptor
38 */
39 -struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
40 +struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
41 ext4_group_t block_group,
42 - struct buffer_head ** bh)
43 + struct buffer_head **bh)
44 {
45 unsigned long group_desc;
46 unsigned long offset;
47 - struct ext4_group_desc * desc;
48 + struct ext4_group_desc *desc;
49 struct ext4_sb_info *sbi = EXT4_SB(sb);
51 if (block_group >= sbi->s_groups_count) {
52 - ext4_error (sb, "ext4_get_group_desc",
53 - "block_group >= groups_count - "
54 - "block_group = %lu, groups_count = %lu",
55 - block_group, sbi->s_groups_count);
56 + ext4_error(sb, "ext4_get_group_desc",
57 + "block_group >= groups_count - "
58 + "block_group = %lu, groups_count = %lu",
59 + block_group, sbi->s_groups_count);
61 return NULL;
62 }
63 @@ -222,10 +222,10 @@ struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
64 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
65 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
66 if (!sbi->s_group_desc[group_desc]) {
67 - ext4_error (sb, "ext4_get_group_desc",
68 - "Group descriptor not loaded - "
69 - "block_group = %lu, group_desc = %lu, desc = %lu",
70 - block_group, group_desc, offset);
71 + ext4_error(sb, "ext4_get_group_desc",
72 + "Group descriptor not loaded - "
73 + "block_group = %lu, group_desc = %lu, desc = %lu",
74 + block_group, group_desc, offset);
75 return NULL;
76 }
78 @@ -302,8 +302,8 @@ err_out:
79 struct buffer_head *
80 ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
81 {
82 - struct ext4_group_desc * desc;
83 - struct buffer_head * bh = NULL;
84 + struct ext4_group_desc *desc;
85 + struct buffer_head *bh = NULL;
86 ext4_fsblk_t bitmap_blk;
88 desc = ext4_get_group_desc(sb, block_group, NULL);
89 @@ -506,8 +506,8 @@ void ext4_rsv_window_add(struct super_block *sb,
90 struct rb_node *node = &rsv->rsv_node;
91 ext4_fsblk_t start = rsv->rsv_start;
93 - struct rb_node ** p = &root->rb_node;
94 - struct rb_node * parent = NULL;
95 + struct rb_node **p = &root->rb_node;
96 + struct rb_node *parent = NULL;
97 struct ext4_reserve_window_node *this;
99 while (*p)
100 @@ -661,8 +661,8 @@ void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
101 ext4_grpblk_t bit;
102 unsigned long i;
103 unsigned long overflow;
104 - struct ext4_group_desc * desc;
105 - struct ext4_super_block * es;
106 + struct ext4_group_desc *desc;
107 + struct ext4_super_block *es;
108 struct ext4_sb_info *sbi;
109 int err = 0, ret;
110 ext4_grpblk_t group_freed;
111 @@ -673,13 +673,13 @@ void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
112 if (block < le32_to_cpu(es->s_first_data_block) ||
113 block + count < block ||
114 block + count > ext4_blocks_count(es)) {
115 - ext4_error (sb, "ext4_free_blocks",
116 - "Freeing blocks not in datazone - "
117 - "block = %llu, count = %lu", block, count);
118 + ext4_error(sb, "ext4_free_blocks",
119 + "Freeing blocks not in datazone - "
120 + "block = %llu, count = %lu", block, count);
121 goto error_return;
122 }
124 - ext4_debug ("freeing block(s) %llu-%llu\n", block, block + count - 1);
125 + ext4_debug("freeing block(s) %llu-%llu\n", block, block + count - 1);
127 do_more:
128 overflow = 0;
129 @@ -696,7 +696,7 @@ do_more:
130 bitmap_bh = ext4_read_block_bitmap(sb, block_group);
131 if (!bitmap_bh)
132 goto error_return;
133 - desc = ext4_get_group_desc (sb, block_group, &gd_bh);
134 + desc = ext4_get_group_desc(sb, block_group, &gd_bh);
135 if (!desc)
136 goto error_return;
138 @@ -705,10 +705,10 @@ do_more:
139 in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
140 in_range(block + count - 1, ext4_inode_table(sb, desc),
141 sbi->s_itb_per_group)) {
142 - ext4_error (sb, "ext4_free_blocks",
143 - "Freeing blocks in system zones - "
144 - "Block = %llu, count = %lu",
145 - block, count);
146 + ext4_error(sb, "ext4_free_blocks",
147 + "Freeing blocks in system zones - "
148 + "Block = %llu, count = %lu",
149 + block, count);
150 goto error_return;
151 }
153 @@ -850,7 +850,7 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
154 ext4_fsblk_t block, unsigned long count,
155 int metadata)
156 {
157 - struct super_block * sb;
158 + struct super_block *sb;
159 unsigned long dquot_freed_blocks;
161 /* this isn't the right place to decide whether block is metadata
162 @@ -1019,7 +1019,7 @@ claim_block(spinlock_t *lock, ext4_grpblk_t block, struct buffer_head *bh)
163 if (ext4_set_bit_atomic(lock, block, bh->b_data))
164 return 0;
165 jbd_lock_bh_state(bh);
166 - if (jh->b_committed_data && ext4_test_bit(block,jh->b_committed_data)) {
167 + if (jh->b_committed_data && ext4_test_bit(block, jh->b_committed_data)) {
168 ext4_clear_bit_atomic(lock, block, bh->b_data);
169 ret = 0;
170 } else {
171 @@ -1170,7 +1170,7 @@ fail_access:
172 static int find_next_reservable_window(
173 struct ext4_reserve_window_node *search_head,
174 struct ext4_reserve_window_node *my_rsv,
175 - struct super_block * sb,
176 + struct super_block *sb,
177 ext4_fsblk_t start_block,
178 ext4_fsblk_t last_block)
179 {
180 @@ -1204,7 +1204,7 @@ static int find_next_reservable_window(
182 prev = rsv;
183 next = rb_next(&rsv->rsv_node);
184 - rsv = rb_entry(next,struct ext4_reserve_window_node,rsv_node);
185 + rsv = rb_entry(next, struct ext4_reserve_window_node, rsv_node);
187 /*
188 * Reached the last reservation, we can just append to the
189 @@ -1342,7 +1342,7 @@ static int alloc_new_reservation(struct ext4_reserve_window_node *my_rsv,
190 size = size * 2;
191 if (size > EXT4_MAX_RESERVE_BLOCKS)
192 size = EXT4_MAX_RESERVE_BLOCKS;
193 - my_rsv->rsv_goal_size= size;
194 + my_rsv->rsv_goal_size = size;
195 }
196 }
198 @@ -1491,7 +1491,7 @@ static ext4_grpblk_t
199 ext4_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
200 ext4_group_t group, struct buffer_head *bitmap_bh,
201 ext4_grpblk_t grp_goal,
202 - struct ext4_reserve_window_node * my_rsv,
203 + struct ext4_reserve_window_node *my_rsv,
204 unsigned long *count, int *errp)
205 {
206 ext4_fsblk_t group_first_block, group_last_block;
207 @@ -1519,7 +1519,7 @@ ext4_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
208 * or the file is not a regular file
209 * or last attempt to allocate a block with reservation turned on failed
210 */
211 - if (my_rsv == NULL ) {
212 + if (my_rsv == NULL) {
213 ret = ext4_try_to_allocate(sb, handle, group, bitmap_bh,
214 grp_goal, count, NULL);
215 goto out;
216 @@ -2184,7 +2184,7 @@ unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
218 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) ||
219 metagroup < first_meta_bg)
220 - return ext4_bg_num_gdb_nometa(sb,group);
221 + return ext4_bg_num_gdb_nometa(sb, group);
223 return ext4_bg_num_gdb_meta(sb,group);
225 diff --git a/fs/ext4/bitmap.c b/fs/ext4/bitmap.c
226 index d37ea67..0a7a666 100644
227 --- a/fs/ext4/bitmap.c
228 +++ b/fs/ext4/bitmap.c
229 @@ -15,17 +15,17 @@
231 static const int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
233 -unsigned long ext4_count_free (struct buffer_head * map, unsigned int numchars)
234 +unsigned long ext4_count_free(struct buffer_head *map, unsigned int numchars)
235 {
236 unsigned int i;
237 unsigned long sum = 0;
239 if (!map)
240 - return (0);
241 + return 0;
242 for (i = 0; i < numchars; i++)
243 sum += nibblemap[map->b_data[i] & 0xf] +
244 nibblemap[(map->b_data[i] >> 4) & 0xf];
245 - return (sum);
246 + return sum;
247 }
249 #endif /* EXT4FS_DEBUG */
250 diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
251 index ac873db..d40da31 100644
252 --- a/fs/ext4/dir.c
253 +++ b/fs/ext4/dir.c
254 @@ -33,10 +33,10 @@ static unsigned char ext4_filetype_table[] = {
255 };
257 static int ext4_readdir(struct file *, void *, filldir_t);
258 -static int ext4_dx_readdir(struct file * filp,
259 - void * dirent, filldir_t filldir);
260 -static int ext4_release_dir (struct inode * inode,
261 - struct file * filp);
262 +static int ext4_dx_readdir(struct file *filp,
263 + void *dirent, filldir_t filldir);
264 +static int ext4_release_dir(struct inode *inode,
265 + struct file *filp);
267 const struct file_operations ext4_dir_operations = {
268 .llseek = generic_file_llseek,
269 @@ -61,12 +61,12 @@ static unsigned char get_dtype(struct super_block *sb, int filetype)
270 }
273 -int ext4_check_dir_entry (const char * function, struct inode * dir,
274 - struct ext4_dir_entry_2 * de,
275 - struct buffer_head * bh,
276 - unsigned long offset)
277 +int ext4_check_dir_entry(const char *function, struct inode *dir,
278 + struct ext4_dir_entry_2 *de,
279 + struct buffer_head *bh,
280 + unsigned long offset)
281 {
282 - const char * error_msg = NULL;
283 + const char *error_msg = NULL;
284 const int rlen = ext4_rec_len_from_disk(de->rec_len);
286 if (rlen < EXT4_DIR_REC_LEN(1))
287 @@ -82,7 +82,7 @@ int ext4_check_dir_entry (const char * function, struct inode * dir,
288 error_msg = "inode out of bounds";
290 if (error_msg != NULL)
291 - ext4_error (dir->i_sb, function,
292 + ext4_error(dir->i_sb, function,
293 "bad entry in directory #%lu: %s - "
294 "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
295 dir->i_ino, error_msg, offset,
296 @@ -91,8 +91,8 @@ int ext4_check_dir_entry (const char * function, struct inode * dir,
297 return error_msg == NULL ? 1 : 0;
298 }
300 -static int ext4_readdir(struct file * filp,
301 - void * dirent, filldir_t filldir)
302 +static int ext4_readdir(struct file *filp,
303 + void *dirent, filldir_t filldir)
304 {
305 int error = 0;
306 unsigned long offset;
307 @@ -148,7 +148,7 @@ static int ext4_readdir(struct file * filp,
308 * of recovering data when there's a bad sector
309 */
310 if (!bh) {
311 - ext4_error (sb, "ext4_readdir",
312 + ext4_error(sb, "ext4_readdir",
313 "directory #%lu contains a hole at offset %lu",
314 inode->i_ino, (unsigned long)filp->f_pos);
315 /* corrupt size? Maybe no more blocks to read */
316 @@ -187,14 +187,14 @@ revalidate:
317 while (!error && filp->f_pos < inode->i_size
318 && offset < sb->s_blocksize) {
319 de = (struct ext4_dir_entry_2 *) (bh->b_data + offset);
320 - if (!ext4_check_dir_entry ("ext4_readdir", inode, de,
321 - bh, offset)) {
322 + if (!ext4_check_dir_entry("ext4_readdir", inode, de,
323 + bh, offset)) {
324 /*
325 * On error, skip the f_pos to the next block
326 */
327 filp->f_pos = (filp->f_pos |
328 (sb->s_blocksize - 1)) + 1;
329 - brelse (bh);
330 + brelse(bh);
331 ret = stored;
332 goto out;
333 }
334 @@ -218,12 +218,12 @@ revalidate:
335 break;
336 if (version != filp->f_version)
337 goto revalidate;
338 - stored ++;
339 + stored++;
340 }
341 filp->f_pos += ext4_rec_len_from_disk(de->rec_len);
342 }
343 offset = 0;
344 - brelse (bh);
345 + brelse(bh);
346 }
347 out:
348 return ret;
349 @@ -290,9 +290,9 @@ static void free_rb_tree_fname(struct rb_root *root)
350 parent = rb_parent(n);
351 fname = rb_entry(n, struct fname, rb_hash);
352 while (fname) {
353 - struct fname * old = fname;
354 + struct fname *old = fname;
355 fname = fname->next;
356 - kfree (old);
357 + kfree(old);
358 }
359 if (!parent)
360 root->rb_node = NULL;
361 @@ -331,7 +331,7 @@ int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
362 struct ext4_dir_entry_2 *dirent)
363 {
364 struct rb_node **p, *parent = NULL;
365 - struct fname * fname, *new_fn;
366 + struct fname *fname, *new_fn;
367 struct dir_private_info *info;
368 int len;
370 @@ -388,13 +388,13 @@ int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
371 * for all entres on the fname linked list. (Normally there is only
372 * one entry on the linked list, unless there are 62 bit hash collisions.)
373 */
374 -static int call_filldir(struct file * filp, void * dirent,
375 +static int call_filldir(struct file *filp, void *dirent,
376 filldir_t filldir, struct fname *fname)
377 {
378 struct dir_private_info *info = filp->private_data;
379 loff_t curr_pos;
380 struct inode *inode = filp->f_path.dentry->d_inode;
381 - struct super_block * sb;
382 + struct super_block *sb;
383 int error;
385 sb = inode->i_sb;
386 @@ -420,8 +420,8 @@ static int call_filldir(struct file * filp, void * dirent,
387 return 0;
388 }
390 -static int ext4_dx_readdir(struct file * filp,
391 - void * dirent, filldir_t filldir)
392 +static int ext4_dx_readdir(struct file *filp,
393 + void *dirent, filldir_t filldir)
394 {
395 struct dir_private_info *info = filp->private_data;
396 struct inode *inode = filp->f_path.dentry->d_inode;
397 @@ -512,7 +512,7 @@ finished:
398 return 0;
399 }
401 -static int ext4_release_dir (struct inode * inode, struct file * filp)
402 +static int ext4_release_dir(struct inode *inode, struct file *filp)
403 {
404 if (filp->private_data)
405 ext4_htree_free_dir_info(filp->private_data);
406 diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
407 index 2950032..8c70131 100644
408 --- a/fs/ext4/ext4.h
409 +++ b/fs/ext4/ext4.h
410 @@ -44,9 +44,9 @@
411 #ifdef EXT4FS_DEBUG
412 #define ext4_debug(f, a...) \
413 do { \
414 - printk (KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:", \
415 + printk(KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:", \
416 __FILE__, __LINE__, __func__); \
417 - printk (KERN_DEBUG f, ## a); \
418 + printk(KERN_DEBUG f, ## a); \
419 } while (0)
420 #else
421 #define ext4_debug(f, a...) do {} while (0)
422 @@ -128,7 +128,7 @@ struct ext4_allocation_request {
423 #else
424 # define EXT4_BLOCK_SIZE(s) (EXT4_MIN_BLOCK_SIZE << (s)->s_log_block_size)
425 #endif
426 -#define EXT4_ADDR_PER_BLOCK(s) (EXT4_BLOCK_SIZE(s) / sizeof (__u32))
427 +#define EXT4_ADDR_PER_BLOCK(s) (EXT4_BLOCK_SIZE(s) / sizeof(__u32))
428 #ifdef __KERNEL__
429 # define EXT4_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits)
430 #else
431 @@ -292,7 +292,7 @@ struct ext4_new_group_data {
432 #define EXT4_IOC_GETVERSION _IOR('f', 3, long)
433 #define EXT4_IOC_SETVERSION _IOW('f', 4, long)
434 #define EXT4_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long)
435 -#define EXT4_IOC_GROUP_ADD _IOW('f', 8,struct ext4_new_group_input)
436 +#define EXT4_IOC_GROUP_ADD _IOW('f', 8, struct ext4_new_group_input)
437 #define EXT4_IOC_GETVERSION_OLD FS_IOC_GETVERSION
438 #define EXT4_IOC_SETVERSION_OLD FS_IOC_SETVERSION
439 #ifdef CONFIG_JBD2_DEBUG
440 @@ -667,7 +667,7 @@ struct ext4_super_block {
441 };
443 #ifdef __KERNEL__
444 -static inline struct ext4_sb_info * EXT4_SB(struct super_block *sb)
445 +static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
446 {
447 return sb->s_fs_info;
448 }
449 @@ -725,11 +725,11 @@ static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
450 */
452 #define EXT4_HAS_COMPAT_FEATURE(sb,mask) \
453 - ( EXT4_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
454 + (EXT4_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask))
455 #define EXT4_HAS_RO_COMPAT_FEATURE(sb,mask) \
456 - ( EXT4_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
457 + (EXT4_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask))
458 #define EXT4_HAS_INCOMPAT_FEATURE(sb,mask) \
459 - ( EXT4_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
460 + (EXT4_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask))
461 #define EXT4_SET_COMPAT_FEATURE(sb,mask) \
462 EXT4_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
463 #define EXT4_SET_RO_COMPAT_FEATURE(sb,mask) \
464 @@ -985,13 +985,13 @@ extern ext4_fsblk_t ext4_old_new_blocks(handle_t *handle, struct inode *inode,
465 ext4_fsblk_t goal, unsigned long *count, int *errp);
466 extern ext4_fsblk_t ext4_has_free_blocks(struct ext4_sb_info *sbi,
467 ext4_fsblk_t nblocks);
468 -extern void ext4_free_blocks (handle_t *handle, struct inode *inode,
469 +extern void ext4_free_blocks(handle_t *handle, struct inode *inode,
470 ext4_fsblk_t block, unsigned long count, int metadata);
471 -extern void ext4_free_blocks_sb (handle_t *handle, struct super_block *sb,
472 - ext4_fsblk_t block, unsigned long count,
473 +extern void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
474 + ext4_fsblk_t block, unsigned long count,
475 unsigned long *pdquot_freed_blocks);
476 -extern ext4_fsblk_t ext4_count_free_blocks (struct super_block *);
477 -extern void ext4_check_blocks_bitmap (struct super_block *);
478 +extern ext4_fsblk_t ext4_count_free_blocks(struct super_block *);
479 +extern void ext4_check_blocks_bitmap(struct super_block *);
480 extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
481 ext4_group_t block_group,
482 struct buffer_head ** bh);
483 @@ -1009,20 +1009,20 @@ extern int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
484 extern void ext4_htree_free_dir_info(struct dir_private_info *p);
486 /* fsync.c */
487 -extern int ext4_sync_file (struct file *, struct dentry *, int);
488 +extern int ext4_sync_file(struct file *, struct dentry *, int);
490 /* hash.c */
491 extern int ext4fs_dirhash(const char *name, int len, struct
492 dx_hash_info *hinfo);
494 /* ialloc.c */
495 -extern struct inode * ext4_new_inode (handle_t *, struct inode *, int);
496 -extern void ext4_free_inode (handle_t *, struct inode *);
497 -extern struct inode * ext4_orphan_get (struct super_block *, unsigned long);
498 -extern unsigned long ext4_count_free_inodes (struct super_block *);
499 -extern unsigned long ext4_count_dirs (struct super_block *);
500 -extern void ext4_check_inodes_bitmap (struct super_block *);
501 -extern unsigned long ext4_count_free (struct buffer_head *, unsigned);
502 +extern struct inode * ext4_new_inode(handle_t *, struct inode *, int);
503 +extern void ext4_free_inode(handle_t *, struct inode *);
504 +extern struct inode * ext4_orphan_get(struct super_block *, unsigned long);
505 +extern unsigned long ext4_count_free_inodes(struct super_block *);
506 +extern unsigned long ext4_count_dirs(struct super_block *);
507 +extern void ext4_check_inodes_bitmap(struct super_block *);
508 +extern unsigned long ext4_count_free(struct buffer_head *, unsigned);
510 /* mballoc.c */
511 extern long ext4_mb_stats;
512 @@ -1056,18 +1056,18 @@ int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
513 int create, int extend_disksize);
515 extern struct inode *ext4_iget(struct super_block *, unsigned long);
516 -extern int ext4_write_inode (struct inode *, int);
517 -extern int ext4_setattr (struct dentry *, struct iattr *);
518 +extern int ext4_write_inode(struct inode *, int);
519 +extern int ext4_setattr(struct dentry *, struct iattr *);
520 extern int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
521 struct kstat *stat);
522 -extern void ext4_delete_inode (struct inode *);
523 -extern int ext4_sync_inode (handle_t *, struct inode *);
524 -extern void ext4_discard_reservation (struct inode *);
525 +extern void ext4_delete_inode(struct inode *);
526 +extern int ext4_sync_inode(handle_t *, struct inode *);
527 +extern void ext4_discard_reservation(struct inode *);
528 extern void ext4_dirty_inode(struct inode *);
529 extern int ext4_change_inode_journal_flag(struct inode *, int);
530 extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *);
531 extern int ext4_can_truncate(struct inode *inode);
532 -extern void ext4_truncate (struct inode *);
533 +extern void ext4_truncate(struct inode *);
534 extern void ext4_set_inode_flags(struct inode *);
535 extern void ext4_get_inode_flags(struct ext4_inode_info *);
536 extern void ext4_set_aops(struct inode *inode);
537 @@ -1080,7 +1080,7 @@ extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page);
539 /* ioctl.c */
540 extern long ext4_ioctl(struct file *, unsigned int, unsigned long);
541 -extern long ext4_compat_ioctl (struct file *, unsigned int, unsigned long);
542 +extern long ext4_compat_ioctl(struct file *, unsigned int, unsigned long);
544 /* migrate.c */
545 extern int ext4_ext_migrate(struct inode *, struct file *, unsigned int,
546 @@ -1099,14 +1099,14 @@ extern int ext4_group_extend(struct super_block *sb,
547 ext4_fsblk_t n_blocks_count);
549 /* super.c */
550 -extern void ext4_error (struct super_block *, const char *, const char *, ...)
551 +extern void ext4_error(struct super_block *, const char *, const char *, ...)
552 __attribute__ ((format (printf, 3, 4)));
553 -extern void __ext4_std_error (struct super_block *, const char *, int);
554 -extern void ext4_abort (struct super_block *, const char *, const char *, ...)
555 +extern void __ext4_std_error(struct super_block *, const char *, int);
556 +extern void ext4_abort(struct super_block *, const char *, const char *, ...)
557 __attribute__ ((format (printf, 3, 4)));
558 -extern void ext4_warning (struct super_block *, const char *, const char *, ...)
559 +extern void ext4_warning(struct super_block *, const char *, const char *, ...)
560 __attribute__ ((format (printf, 3, 4)));
561 -extern void ext4_update_dynamic_rev (struct super_block *sb);
562 +extern void ext4_update_dynamic_rev(struct super_block *sb);
563 extern int ext4_update_compat_feature(handle_t *handle, struct super_block *sb,
564 __u32 compat);
565 extern int ext4_update_rocompat_feature(handle_t *handle,
566 @@ -1179,7 +1179,7 @@ static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
568 static inline
569 struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
570 - ext4_group_t group)
571 + ext4_group_t group)
572 {
573 struct ext4_group_info ***grp_info;
574 long indexv, indexh;
575 diff --git a/fs/ext4/ext4_sb.h b/fs/ext4/ext4_sb.h
576 index 6300226..69810a2 100644
577 --- a/fs/ext4/ext4_sb.h
578 +++ b/fs/ext4/ext4_sb.h
579 @@ -40,8 +40,8 @@ struct ext4_sb_info {
580 unsigned long s_blocks_last; /* Last seen block count */
581 loff_t s_bitmap_maxbytes; /* max bytes for bitmap files */
582 struct buffer_head * s_sbh; /* Buffer containing the super block */
583 - struct ext4_super_block * s_es; /* Pointer to the super block in the buffer */
584 - struct buffer_head ** s_group_desc;
585 + struct ext4_super_block *s_es; /* Pointer to the super block in the buffer */
586 + struct buffer_head **s_group_desc;
587 unsigned long s_mount_opt;
588 ext4_fsblk_t s_sb_block;
589 uid_t s_resuid;
590 @@ -67,8 +67,8 @@ struct ext4_sb_info {
591 struct ext4_reserve_window_node s_rsv_window_head;
593 /* Journaling */
594 - struct inode * s_journal_inode;
595 - struct journal_s * s_journal;
596 + struct inode *s_journal_inode;
597 + struct journal_s *s_journal;
598 struct list_head s_orphan;
599 unsigned long s_commit_interval;
600 struct block_device *journal_bdev;
601 diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
602 index a8db7fd..797f060 100644
603 --- a/fs/ext4/extents.c
604 +++ b/fs/ext4/extents.c
605 @@ -383,8 +383,8 @@ static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
606 ext_debug("\n");
607 }
608 #else
609 -#define ext4_ext_show_path(inode,path)
610 -#define ext4_ext_show_leaf(inode,path)
611 +#define ext4_ext_show_path(inode, path)
612 +#define ext4_ext_show_leaf(inode, path)
613 #endif
615 void ext4_ext_drop_refs(struct ext4_ext_path *path)
616 @@ -1476,7 +1476,7 @@ int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
617 struct ext4_ext_path *path,
618 struct ext4_extent *newext)
619 {
620 - struct ext4_extent_header * eh;
621 + struct ext4_extent_header *eh;
622 struct ext4_extent *ex, *fex;
623 struct ext4_extent *nearex; /* nearest extent */
624 struct ext4_ext_path *npath = NULL;
625 diff --git a/fs/ext4/file.c b/fs/ext4/file.c
626 index 430eb79..11b289f 100644
627 --- a/fs/ext4/file.c
628 +++ b/fs/ext4/file.c
629 @@ -31,7 +31,7 @@
630 * from ext4_file_open: open gets called at every open, but release
631 * gets called only when /all/ the files are closed.
632 */
633 -static int ext4_release_file (struct inode * inode, struct file * filp)
634 +static int ext4_release_file(struct inode *inode, struct file *filp)
635 {
636 /* if we are the last writer on the inode, drop the block reservation */
637 if ((filp->f_mode & FMODE_WRITE) &&
638 diff --git a/fs/ext4/fsync.c b/fs/ext4/fsync.c
639 index a45c373..c37d1e8 100644
640 --- a/fs/ext4/fsync.c
641 +++ b/fs/ext4/fsync.c
642 @@ -43,7 +43,7 @@
643 * inode to disk.
644 */
646 -int ext4_sync_file(struct file * file, struct dentry *dentry, int datasync)
647 +int ext4_sync_file(struct file *file, struct dentry *dentry, int datasync)
648 {
649 struct inode *inode = dentry->d_inode;
650 journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
651 diff --git a/fs/ext4/hash.c b/fs/ext4/hash.c
652 index 1d6329d..556ca8e 100644
653 --- a/fs/ext4/hash.c
654 +++ b/fs/ext4/hash.c
655 @@ -27,7 +27,7 @@ static void TEA_transform(__u32 buf[4], __u32 const in[])
656 sum += DELTA;
657 b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);
658 b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);
659 - } while(--n);
660 + } while (--n);
662 buf[0] += b0;
663 buf[1] += b1;
664 @@ -35,7 +35,7 @@ static void TEA_transform(__u32 buf[4], __u32 const in[])
667 /* The old legacy hash */
668 -static __u32 dx_hack_hash (const char *name, int len)
669 +static __u32 dx_hack_hash(const char *name, int len)
670 {
671 __u32 hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9;
672 while (len--) {
673 @@ -59,7 +59,7 @@ static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
674 val = pad;
675 if (len > num*4)
676 len = num * 4;
677 - for (i=0; i < len; i++) {
678 + for (i = 0; i < len; i++) {
679 if ((i % 4) == 0)
680 val = pad;
681 val = msg[i] + (val << 8);
682 @@ -104,7 +104,7 @@ int ext4fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo)
684 /* Check to see if the seed is all zero's */
685 if (hinfo->seed) {
686 - for (i=0; i < 4; i++) {
687 + for (i = 0; i < 4; i++) {
688 if (hinfo->seed[i])
689 break;
690 }
691 diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
692 index 45c66a0..5e66a2f 100644
693 --- a/fs/ext4/ialloc.c
694 +++ b/fs/ext4/ialloc.c
695 @@ -154,17 +154,17 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
696 * though), and then we'd have two inodes sharing the
697 * same inode number and space on the harddisk.
698 */
699 -void ext4_free_inode (handle_t *handle, struct inode * inode)
700 +void ext4_free_inode(handle_t *handle, struct inode *inode)
701 {
702 - struct super_block * sb = inode->i_sb;
703 + struct super_block *sb = inode->i_sb;
704 int is_directory;
705 unsigned long ino;
706 struct buffer_head *bitmap_bh = NULL;
707 struct buffer_head *bh2;
708 ext4_group_t block_group;
709 unsigned long bit;
710 - struct ext4_group_desc * gdp;
711 - struct ext4_super_block * es;
712 + struct ext4_group_desc *gdp;
713 + struct ext4_super_block *es;
714 struct ext4_sb_info *sbi;
715 int fatal = 0, err;
716 ext4_group_t flex_group;
717 @@ -187,7 +187,7 @@ void ext4_free_inode (handle_t *handle, struct inode * inode)
718 sbi = EXT4_SB(sb);
720 ino = inode->i_ino;
721 - ext4_debug ("freeing inode %lu\n", ino);
722 + ext4_debug("freeing inode %lu\n", ino);
724 /*
725 * Note: we must free any quota before locking the superblock,
726 @@ -201,12 +201,12 @@ void ext4_free_inode (handle_t *handle, struct inode * inode)
727 is_directory = S_ISDIR(inode->i_mode);
729 /* Do this BEFORE marking the inode not in use or returning an error */
730 - clear_inode (inode);
731 + clear_inode(inode);
733 es = EXT4_SB(sb)->s_es;
734 if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
735 - ext4_error (sb, "ext4_free_inode",
736 - "reserved or nonexistent inode %lu", ino);
737 + ext4_error(sb, "ext4_free_inode",
738 + "reserved or nonexistent inode %lu", ino);
739 goto error_return;
740 }
741 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
742 @@ -223,10 +223,10 @@ void ext4_free_inode (handle_t *handle, struct inode * inode)
743 /* Ok, now we can actually update the inode bitmaps.. */
744 if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
745 bit, bitmap_bh->b_data))
746 - ext4_error (sb, "ext4_free_inode",
747 - "bit already cleared for inode %lu", ino);
748 + ext4_error(sb, "ext4_free_inode",
749 + "bit already cleared for inode %lu", ino);
750 else {
751 - gdp = ext4_get_group_desc (sb, block_group, &bh2);
752 + gdp = ext4_get_group_desc(sb, block_group, &bh2);
754 BUFFER_TRACE(bh2, "get_write_access");
755 fatal = ext4_journal_get_write_access(handle, bh2);
756 @@ -288,7 +288,7 @@ static int find_group_dir(struct super_block *sb, struct inode *parent,
757 avefreei = freei / ngroups;
759 for (group = 0; group < ngroups; group++) {
760 - desc = ext4_get_group_desc (sb, group, NULL);
761 + desc = ext4_get_group_desc(sb, group, NULL);
762 if (!desc || !desc->bg_free_inodes_count)
763 continue;
764 if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
765 @@ -577,16 +577,16 @@ static int find_group_other(struct super_block *sb, struct inode *parent,
766 * For other inodes, search forward from the parent directory's block
767 * group to find a free inode.
768 */
769 -struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
770 +struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode)
771 {
772 struct super_block *sb;
773 struct buffer_head *bitmap_bh = NULL;
774 struct buffer_head *bh2;
775 ext4_group_t group = 0;
776 unsigned long ino = 0;
777 - struct inode * inode;
778 - struct ext4_group_desc * gdp = NULL;
779 - struct ext4_super_block * es;
780 + struct inode *inode;
781 + struct ext4_group_desc *gdp = NULL;
782 + struct ext4_super_block *es;
783 struct ext4_inode_info *ei;
784 struct ext4_sb_info *sbi;
785 int ret2, err = 0;
786 @@ -614,7 +614,7 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
787 }
789 if (S_ISDIR(mode)) {
790 - if (test_opt (sb, OLDALLOC))
791 + if (test_opt(sb, OLDALLOC))
792 ret2 = find_group_dir(sb, dir, &group);
793 else
794 ret2 = find_group_orlov(sb, dir, &group);
795 @@ -784,7 +784,7 @@ got:
796 }
798 inode->i_uid = current->fsuid;
799 - if (test_opt (sb, GRPID))
800 + if (test_opt(sb, GRPID))
801 inode->i_gid = dir->i_gid;
802 else if (dir->i_mode & S_ISGID) {
803 inode->i_gid = dir->i_gid;
804 @@ -833,7 +833,7 @@ got:
805 ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
807 ret = inode;
808 - if(DQUOT_ALLOC_INODE(inode)) {
809 + if (DQUOT_ALLOC_INODE(inode)) {
810 err = -EDQUOT;
811 goto fail_drop;
812 }
813 @@ -842,7 +842,7 @@ got:
814 if (err)
815 goto fail_free_drop;
817 - err = ext4_init_security(handle,inode, dir);
818 + err = ext4_init_security(handle, inode, dir);
819 if (err)
820 goto fail_free_drop;
822 @@ -960,7 +960,7 @@ error:
823 return ERR_PTR(err);
824 }
826 -unsigned long ext4_count_free_inodes (struct super_block * sb)
827 +unsigned long ext4_count_free_inodes(struct super_block *sb)
828 {
829 unsigned long desc_count;
830 struct ext4_group_desc *gdp;
831 @@ -975,7 +975,7 @@ unsigned long ext4_count_free_inodes (struct super_block * sb)
832 bitmap_count = 0;
833 gdp = NULL;
834 for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
835 - gdp = ext4_get_group_desc (sb, i, NULL);
836 + gdp = ext4_get_group_desc(sb, i, NULL);
837 if (!gdp)
838 continue;
839 desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
840 @@ -997,7 +997,7 @@ unsigned long ext4_count_free_inodes (struct super_block * sb)
841 #else
842 desc_count = 0;
843 for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
844 - gdp = ext4_get_group_desc (sb, i, NULL);
845 + gdp = ext4_get_group_desc(sb, i, NULL);
846 if (!gdp)
847 continue;
848 desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
849 @@ -1008,13 +1008,13 @@ unsigned long ext4_count_free_inodes (struct super_block * sb)
850 }
852 /* Called at mount-time, super-block is locked */
853 -unsigned long ext4_count_dirs (struct super_block * sb)
854 +unsigned long ext4_count_dirs(struct super_block * sb)
855 {
856 unsigned long count = 0;
857 ext4_group_t i;
859 for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
860 - struct ext4_group_desc *gdp = ext4_get_group_desc (sb, i, NULL);
861 + struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
862 if (!gdp)
863 continue;
864 count += le16_to_cpu(gdp->bg_used_dirs_count);
865 diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
866 index 7e91913..89c92c0 100644
867 --- a/fs/ext4/inode.c
868 +++ b/fs/ext4/inode.c
869 @@ -190,7 +190,7 @@ static int ext4_journal_test_restart(handle_t *handle, struct inode *inode)
870 /*
871 * Called at the last iput() if i_nlink is zero.
872 */
873 -void ext4_delete_inode (struct inode * inode)
874 +void ext4_delete_inode(struct inode *inode)
875 {
876 handle_t *handle;
877 int err;
878 @@ -330,11 +330,11 @@ static int ext4_block_to_path(struct inode *inode,
879 int final = 0;
881 if (i_block < 0) {
882 - ext4_warning (inode->i_sb, "ext4_block_to_path", "block < 0");
883 + ext4_warning(inode->i_sb, "ext4_block_to_path", "block < 0");
884 } else if (i_block < direct_blocks) {
885 offsets[n++] = i_block;
886 final = direct_blocks;
887 - } else if ( (i_block -= direct_blocks) < indirect_blocks) {
888 + } else if ((i_block -= direct_blocks) < indirect_blocks) {
889 offsets[n++] = EXT4_IND_BLOCK;
890 offsets[n++] = i_block;
891 final = ptrs;
892 @@ -400,14 +400,14 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
894 *err = 0;
895 /* i_data is not going away, no lock needed */
896 - add_chain (chain, NULL, EXT4_I(inode)->i_data + *offsets);
897 + add_chain(chain, NULL, EXT4_I(inode)->i_data + *offsets);
898 if (!p->key)
899 goto no_block;
900 while (--depth) {
901 bh = sb_bread(sb, le32_to_cpu(p->key));
902 if (!bh)
903 goto failure;
904 - add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
905 + add_chain(++p, bh, (__le32 *)bh->b_data + *++offsets);
906 /* Reader: end */
907 if (!p->key)
908 goto no_block;
909 @@ -443,7 +443,7 @@ no_block:
910 static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
911 {
912 struct ext4_inode_info *ei = EXT4_I(inode);
913 - __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
914 + __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
915 __le32 *p;
916 ext4_fsblk_t bg_start;
917 ext4_fsblk_t last_block;
918 @@ -630,7 +630,7 @@ allocated:
919 *err = 0;
920 return ret;
921 failed_out:
922 - for (i = 0; i <index; i++)
923 + for (i = 0; i < index; i++)
924 ext4_free_blocks(handle, inode, new_blocks[i], 1, 0);
925 return ret;
926 }
927 @@ -703,7 +703,7 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
928 branch[n].p = (__le32 *) bh->b_data + offsets[n];
929 branch[n].key = cpu_to_le32(new_blocks[n]);
930 *branch[n].p = branch[n].key;
931 - if ( n == indirect_blks) {
932 + if (n == indirect_blks) {
933 current_block = new_blocks[n];
934 /*
935 * End of chain, update the last new metablock of
936 @@ -730,7 +730,7 @@ failed:
937 BUFFER_TRACE(branch[i].bh, "call jbd2_journal_forget");
938 ext4_journal_forget(handle, branch[i].bh);
939 }
940 - for (i = 0; i <indirect_blks; i++)
941 + for (i = 0; i < indirect_blks; i++)
942 ext4_free_blocks(handle, inode, new_blocks[i], 1, 0);
944 ext4_free_blocks(handle, inode, new_blocks[i], num, 0);
945 @@ -783,7 +783,7 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
946 if (num == 0 && blks > 1) {
947 current_block = le32_to_cpu(where->key) + 1;
948 for (i = 1; i < blks; i++)
949 - *(where->p + i ) = cpu_to_le32(current_block++);
950 + *(where->p + i) = cpu_to_le32(current_block++);
951 }
953 /*
954 @@ -1241,7 +1241,7 @@ struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
955 BUFFER_TRACE(bh, "call get_create_access");
956 fatal = ext4_journal_get_create_access(handle, bh);
957 if (!fatal && !buffer_uptodate(bh)) {
958 - memset(bh->b_data,0,inode->i_sb->s_blocksize);
959 + memset(bh->b_data, 0, inode->i_sb->s_blocksize);
960 set_buffer_uptodate(bh);
961 }
962 unlock_buffer(bh);
963 @@ -1266,7 +1266,7 @@ err:
964 struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
965 ext4_lblk_t block, int create, int *err)
966 {
967 - struct buffer_head * bh;
968 + struct buffer_head *bh;
970 bh = ext4_getblk(handle, inode, block, create, err);
971 if (!bh)
972 @@ -1282,13 +1282,13 @@ struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
973 return NULL;
974 }
976 -static int walk_page_buffers( handle_t *handle,
977 - struct buffer_head *head,
978 - unsigned from,
979 - unsigned to,
980 - int *partial,
981 - int (*fn)( handle_t *handle,
982 - struct buffer_head *bh))
983 +static int walk_page_buffers(handle_t *handle,
984 + struct buffer_head *head,
985 + unsigned from,
986 + unsigned to,
987 + int *partial,
988 + int (*fn)(handle_t *handle,
989 + struct buffer_head *bh))
990 {
991 struct buffer_head *bh;
992 unsigned block_start, block_end;
993 @@ -1296,9 +1296,9 @@ static int walk_page_buffers( handle_t *handle,
994 int err, ret = 0;
995 struct buffer_head *next;
997 - for ( bh = head, block_start = 0;
998 - ret == 0 && (bh != head || !block_start);
999 - block_start = block_end, bh = next)
1000 + for (bh = head, block_start = 0;
1001 + ret == 0 && (bh != head || !block_start);
1002 + block_start = block_end, bh = next)
1003 {
1004 next = bh->b_this_page;
1005 block_end = block_start + blocksize;
1006 @@ -1351,23 +1351,23 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
1007 loff_t pos, unsigned len, unsigned flags,
1008 struct page **pagep, void **fsdata)
1009 {
1010 - struct inode *inode = mapping->host;
1011 + struct inode *inode = mapping->host;
1012 int ret, needed_blocks = ext4_writepage_trans_blocks(inode);
1013 handle_t *handle;
1014 int retries = 0;
1015 - struct page *page;
1016 + struct page *page;
1017 pgoff_t index;
1018 - unsigned from, to;
1019 + unsigned from, to;
1021 index = pos >> PAGE_CACHE_SHIFT;
1022 - from = pos & (PAGE_CACHE_SIZE - 1);
1023 - to = from + len;
1024 + from = pos & (PAGE_CACHE_SIZE - 1);
1025 + to = from + len;
1027 retry:
1028 - handle = ext4_journal_start(inode, needed_blocks);
1029 - if (IS_ERR(handle)) {
1030 - ret = PTR_ERR(handle);
1031 - goto out;
1032 + handle = ext4_journal_start(inode, needed_blocks);
1033 + if (IS_ERR(handle)) {
1034 + ret = PTR_ERR(handle);
1035 + goto out;
1036 }
1038 page = __grab_cache_page(mapping, index);
1039 @@ -1387,9 +1387,9 @@ retry:
1040 }
1042 if (ret) {
1043 - unlock_page(page);
1044 + unlock_page(page);
1045 ext4_journal_stop(handle);
1046 - page_cache_release(page);
1047 + page_cache_release(page);
1048 }
1050 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
1051 @@ -2456,7 +2456,7 @@ static int ext4_da_should_update_i_disksize(struct page *page,
1052 bh = page_buffers(page);
1053 idx = offset >> inode->i_blkbits;
1055 - for (i=0; i < idx; i++)
1056 + for (i = 0; i < idx; i++)
1057 bh = bh->b_this_page;
1059 if (!buffer_mapped(bh) || (buffer_delay(bh)))
1060 @@ -2476,7 +2476,7 @@ static int ext4_da_write_end(struct file *file,
1061 unsigned long start, end;
1063 start = pos & (PAGE_CACHE_SIZE - 1);
1064 - end = start + copied -1;
1065 + end = start + copied - 1;
1067 /*
1068 * generic_write_end() will run mark_inode_dirty() if i_size
1069 @@ -2591,7 +2591,7 @@ static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
1070 return 0;
1071 }
1073 - return generic_block_bmap(mapping,block,ext4_get_block);
1074 + return generic_block_bmap(mapping, block, ext4_get_block);
1075 }
1077 static int bget_one(handle_t *handle, struct buffer_head *bh)
1078 @@ -3197,7 +3197,7 @@ static Indirect *ext4_find_shared(struct inode *inode, int depth,
1079 if (!partial->key && *partial->p)
1080 /* Writer: end */
1081 goto no_top;
1082 - for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
1083 + for (p = partial; (p > chain) && all_zeroes((__le32 *) p->bh->b_data, p->p); p--)
1084 ;
1085 /*
1086 * OK, we've found the last block that must survive. The rest of our
1087 @@ -3216,7 +3216,7 @@ static Indirect *ext4_find_shared(struct inode *inode, int depth,
1088 }
1089 /* Writer: end */
1091 - while(partial > p) {
1092 + while (partial > p) {
1093 brelse(partial->bh);
1094 partial--;
1095 }
1096 @@ -3408,9 +3408,9 @@ static void ext4_free_branches(handle_t *handle, struct inode *inode,
1097 /* This zaps the entire block. Bottom up. */
1098 BUFFER_TRACE(bh, "free child branches");
1099 ext4_free_branches(handle, inode, bh,
1100 - (__le32*)bh->b_data,
1101 - (__le32*)bh->b_data + addr_per_block,
1102 - depth);
1103 + (__le32 *) bh->b_data,
1104 + (__le32 *) bh->b_data + addr_per_block,
1105 + depth);
1107 /*
1108 * We've probably journalled the indirect block several
1109 @@ -3927,7 +3927,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
1110 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
1111 inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
1112 inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
1113 - if(!(test_opt (inode->i_sb, NO_UID32))) {
1114 + if (!(test_opt(inode->i_sb, NO_UID32))) {
1115 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
1116 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
1117 }
1118 @@ -3945,7 +3945,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
1119 if (inode->i_mode == 0 ||
1120 !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
1121 /* this inode is deleted */
1122 - brelse (bh);
1123 + brelse(bh);
1124 ret = -ESTALE;
1125 goto bad_inode;
1126 }
1127 @@ -3978,7 +3978,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
1128 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
1129 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
1130 EXT4_INODE_SIZE(inode->i_sb)) {
1131 - brelse (bh);
1132 + brelse(bh);
1133 ret = -EIO;
1134 goto bad_inode;
1135 }
1136 @@ -4031,7 +4031,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
1137 init_special_inode(inode, inode->i_mode,
1138 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
1139 }
1140 - brelse (iloc.bh);
1141 + brelse(iloc.bh);
1142 ext4_set_inode_flags(inode);
1143 unlock_new_inode(inode);
1144 return inode;
1145 @@ -4113,14 +4113,14 @@ static int ext4_do_update_inode(handle_t *handle,
1147 ext4_get_inode_flags(ei);
1148 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
1149 - if(!(test_opt(inode->i_sb, NO_UID32))) {
1150 + if (!(test_opt(inode->i_sb, NO_UID32))) {
1151 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
1152 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
1153 /*
1154 * Fix up interoperability with old kernels. Otherwise, old inodes get
1155 * re-used with the upper 16 bits of the uid/gid intact
1156 */
1157 - if(!ei->i_dtime) {
1158 + if (!ei->i_dtime) {
1159 raw_inode->i_uid_high =
1160 cpu_to_le16(high_16_bits(inode->i_uid));
1161 raw_inode->i_gid_high =
1162 @@ -4208,7 +4208,7 @@ static int ext4_do_update_inode(handle_t *handle,
1163 ei->i_state &= ~EXT4_STATE_NEW;
1165 out_brelse:
1166 - brelse (bh);
1167 + brelse(bh);
1168 ext4_std_error(inode->i_sb, err);
1169 return err;
1170 }
1171 diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
1172 index 7a6c2f1..ca09dd1 100644
1173 --- a/fs/ext4/ioctl.c
1174 +++ b/fs/ext4/ioctl.c
1175 @@ -25,7 +25,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1176 unsigned int flags;
1177 unsigned short rsv_window_size;
1179 - ext4_debug ("cmd = %u, arg = %lu\n", cmd, arg);
1180 + ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
1182 switch (cmd) {
1183 case EXT4_IOC_GETFLAGS:
1184 @@ -186,7 +186,7 @@ setversion_out:
1185 case EXT4_IOC_SETRSVSZ: {
1186 int err;
1188 - if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode))
1189 + if (!test_opt(inode->i_sb, RESERVATION) || !S_ISREG(inode->i_mode))
1190 return -ENOTTY;
1192 if (!is_owner_or_cap(inode))
1193 diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
1194 index 978b57f..a1f72d2 100644
1195 --- a/fs/ext4/namei.c
1196 +++ b/fs/ext4/namei.c
1197 @@ -151,26 +151,26 @@ struct dx_map_entry
1199 static inline ext4_lblk_t dx_get_block(struct dx_entry *entry);
1200 static void dx_set_block(struct dx_entry *entry, ext4_lblk_t value);
1201 -static inline unsigned dx_get_hash (struct dx_entry *entry);
1202 -static void dx_set_hash (struct dx_entry *entry, unsigned value);
1203 -static unsigned dx_get_count (struct dx_entry *entries);
1204 -static unsigned dx_get_limit (struct dx_entry *entries);
1205 -static void dx_set_count (struct dx_entry *entries, unsigned value);
1206 -static void dx_set_limit (struct dx_entry *entries, unsigned value);
1207 -static unsigned dx_root_limit (struct inode *dir, unsigned infosize);
1208 -static unsigned dx_node_limit (struct inode *dir);
1209 +static inline unsigned dx_get_hash(struct dx_entry *entry);
1210 +static void dx_set_hash(struct dx_entry *entry, unsigned value);
1211 +static unsigned dx_get_count(struct dx_entry *entries);
1212 +static unsigned dx_get_limit(struct dx_entry *entries);
1213 +static void dx_set_count(struct dx_entry *entries, unsigned value);
1214 +static void dx_set_limit(struct dx_entry *entries, unsigned value);
1215 +static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
1216 +static unsigned dx_node_limit(struct inode *dir);
1217 static struct dx_frame *dx_probe(struct dentry *dentry,
1218 struct inode *dir,
1219 struct dx_hash_info *hinfo,
1220 struct dx_frame *frame,
1221 int *err);
1222 -static void dx_release (struct dx_frame *frames);
1223 -static int dx_make_map (struct ext4_dir_entry_2 *de, int size,
1224 - struct dx_hash_info *hinfo, struct dx_map_entry map[]);
1225 +static void dx_release(struct dx_frame *frames);
1226 +static int dx_make_map(struct ext4_dir_entry_2 *de, int size,
1227 + struct dx_hash_info *hinfo, struct dx_map_entry map[]);
1228 static void dx_sort_map(struct dx_map_entry *map, unsigned count);
1229 -static struct ext4_dir_entry_2 *dx_move_dirents (char *from, char *to,
1230 +static struct ext4_dir_entry_2 *dx_move_dirents(char *from, char *to,
1231 struct dx_map_entry *offsets, int count);
1232 -static struct ext4_dir_entry_2* dx_pack_dirents (char *base, int size);
1233 +static struct ext4_dir_entry_2* dx_pack_dirents(char *base, int size);
1234 static void dx_insert_block(struct dx_frame *frame,
1235 u32 hash, ext4_lblk_t block);
1236 static int ext4_htree_next_block(struct inode *dir, __u32 hash,
1237 @@ -207,44 +207,44 @@ static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
1238 entry->block = cpu_to_le32(value);
1239 }
1241 -static inline unsigned dx_get_hash (struct dx_entry *entry)
1242 +static inline unsigned dx_get_hash(struct dx_entry *entry)
1243 {
1244 return le32_to_cpu(entry->hash);
1245 }
1247 -static inline void dx_set_hash (struct dx_entry *entry, unsigned value)
1248 +static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
1249 {
1250 entry->hash = cpu_to_le32(value);
1251 }
1253 -static inline unsigned dx_get_count (struct dx_entry *entries)
1254 +static inline unsigned dx_get_count(struct dx_entry *entries)
1255 {
1256 return le16_to_cpu(((struct dx_countlimit *) entries)->count);
1257 }
1259 -static inline unsigned dx_get_limit (struct dx_entry *entries)
1260 +static inline unsigned dx_get_limit(struct dx_entry *entries)
1261 {
1262 return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
1263 }
1265 -static inline void dx_set_count (struct dx_entry *entries, unsigned value)
1266 +static inline void dx_set_count(struct dx_entry *entries, unsigned value)
1267 {
1268 ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
1269 }
1271 -static inline void dx_set_limit (struct dx_entry *entries, unsigned value)
1272 +static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
1273 {
1274 ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
1275 }
1277 -static inline unsigned dx_root_limit (struct inode *dir, unsigned infosize)
1278 +static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
1279 {
1280 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
1281 EXT4_DIR_REC_LEN(2) - infosize;
1282 return entry_space / sizeof(struct dx_entry);
1283 }
1285 -static inline unsigned dx_node_limit (struct inode *dir)
1286 +static inline unsigned dx_node_limit(struct inode *dir)
1287 {
1288 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
1289 return entry_space / sizeof(struct dx_entry);
1290 @@ -306,7 +306,7 @@ struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
1291 struct dx_entry *entries, int levels)
1292 {
1293 unsigned blocksize = dir->i_sb->s_blocksize;
1294 - unsigned count = dx_get_count (entries), names = 0, space = 0, i;
1295 + unsigned count = dx_get_count(entries), names = 0, space = 0, i;
1296 unsigned bcount = 0;
1297 struct buffer_head *bh;
1298 int err;
1299 @@ -325,7 +325,7 @@ struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
1300 names += stats.names;
1301 space += stats.space;
1302 bcount += stats.bcount;
1303 - brelse (bh);
1304 + brelse(bh);
1305 }
1306 if (bcount)
1307 printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
1308 @@ -407,7 +407,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
1309 goto fail;
1310 }
1312 - dxtrace (printk("Look up %x", hash));
1313 + dxtrace(printk("Look up %x", hash));
1314 while (1)
1315 {
1316 count = dx_get_count(entries);
1317 @@ -556,7 +556,7 @@ static int ext4_htree_next_block(struct inode *dir, __u32 hash,
1318 0, &err)))
1319 return err; /* Failure */
1320 p++;
1321 - brelse (p->bh);
1322 + brelse(p->bh);
1323 p->bh = bh;
1324 p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
1325 }
1326 @@ -594,7 +594,7 @@ static int htree_dirblock_to_tree(struct file *dir_file,
1327 /* On error, skip the f_pos to the next block. */
1328 dir_file->f_pos = (dir_file->f_pos |
1329 (dir->i_sb->s_blocksize - 1)) + 1;
1330 - brelse (bh);
1331 + brelse(bh);
1332 return count;
1333 }
1334 ext4fs_dirhash(de->name, de->name_len, hinfo);
1335 @@ -803,7 +803,7 @@ static inline int ext4_match (int len, const char * const name,
1336 /*
1337 * Returns 0 if not found, -1 on failure, and 1 on success
1338 */
1339 -static inline int search_dirblock(struct buffer_head * bh,
1340 +static inline int search_dirblock(struct buffer_head *bh,
1341 struct inode *dir,
1342 struct dentry *dentry,
1343 unsigned long offset,
1344 @@ -855,9 +855,9 @@ static inline int search_dirblock(struct buffer_head * bh,
1345 static struct buffer_head * ext4_find_entry (struct dentry *dentry,
1346 struct ext4_dir_entry_2 ** res_dir)
1347 {
1348 - struct super_block * sb;
1349 - struct buffer_head * bh_use[NAMEI_RA_SIZE];
1350 - struct buffer_head * bh, *ret = NULL;
1351 + struct super_block *sb;
1352 + struct buffer_head *bh_use[NAMEI_RA_SIZE];
1353 + struct buffer_head *bh, *ret = NULL;
1354 ext4_lblk_t start, block, b;
1355 int ra_max = 0; /* Number of bh's in the readahead
1356 buffer, bh_use[] */
1357 @@ -958,7 +958,7 @@ restart:
1358 cleanup_and_exit:
1359 /* Clean up the read-ahead blocks */
1360 for (; ra_ptr < ra_max; ra_ptr++)
1361 - brelse (bh_use[ra_ptr]);
1362 + brelse(bh_use[ra_ptr]);
1363 return ret;
1364 }
1366 @@ -1012,7 +1012,7 @@ static struct buffer_head * ext4_dx_find_entry(struct dentry *dentry,
1367 return bh;
1368 }
1369 }
1370 - brelse (bh);
1371 + brelse(bh);
1372 /* Check to see if we should continue to search */
1373 retval = ext4_htree_next_block(dir, hash, frame,
1374 frames, NULL);
1375 @@ -1032,11 +1032,11 @@ errout:
1376 return NULL;
1377 }
1379 -static struct dentry *ext4_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
1380 +static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
1381 {
1382 - struct inode * inode;
1383 - struct ext4_dir_entry_2 * de;
1384 - struct buffer_head * bh;
1385 + struct inode *inode;
1386 + struct ext4_dir_entry_2 *de;
1387 + struct buffer_head *bh;
1389 if (dentry->d_name.len > EXT4_NAME_LEN)
1390 return ERR_PTR(-ENAMETOOLONG);
1391 @@ -1045,7 +1045,7 @@ static struct dentry *ext4_lookup(struct inode * dir, struct dentry *dentry, str
1392 inode = NULL;
1393 if (bh) {
1394 unsigned long ino = le32_to_cpu(de->inode);
1395 - brelse (bh);
1396 + brelse(bh);
1397 if (!ext4_valid_inum(dir->i_sb, ino)) {
1398 ext4_error(dir->i_sb, "ext4_lookup",
1399 "bad inode number: %lu", ino);
1400 @@ -1203,10 +1203,10 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1402 /* create map in the end of data2 block */
1403 map = (struct dx_map_entry *) (data2 + blocksize);
1404 - count = dx_make_map ((struct ext4_dir_entry_2 *) data1,
1405 + count = dx_make_map((struct ext4_dir_entry_2 *) data1,
1406 blocksize, hinfo, map);
1407 map -= count;
1408 - dx_sort_map (map, count);
1409 + dx_sort_map(map, count);
1410 /* Split the existing block in the middle, size-wise */
1411 size = 0;
1412 move = 0;
1413 @@ -1227,7 +1227,7 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1415 /* Fancy dance to stay within two buffers */
1416 de2 = dx_move_dirents(data1, data2, map + split, count - split);
1417 - de = dx_pack_dirents(data1,blocksize);
1418 + de = dx_pack_dirents(data1, blocksize);
1419 de->rec_len = ext4_rec_len_to_disk(data1 + blocksize - (char *) de);
1420 de2->rec_len = ext4_rec_len_to_disk(data2 + blocksize - (char *) de2);
1421 dxtrace(dx_show_leaf (hinfo, (struct ext4_dir_entry_2 *) data1, blocksize, 1));
1422 @@ -1239,15 +1239,15 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1423 swap(*bh, bh2);
1424 de = de2;
1425 }
1426 - dx_insert_block (frame, hash2 + continued, newblock);
1427 - err = ext4_journal_dirty_metadata (handle, bh2);
1428 + dx_insert_block(frame, hash2 + continued, newblock);
1429 + err = ext4_journal_dirty_metadata(handle, bh2);
1430 if (err)
1431 goto journal_error;
1432 - err = ext4_journal_dirty_metadata (handle, frame->bh);
1433 + err = ext4_journal_dirty_metadata(handle, frame->bh);
1434 if (err)
1435 goto journal_error;
1436 - brelse (bh2);
1437 - dxtrace(dx_show_index ("frame", frame->entries));
1438 + brelse(bh2);
1439 + dxtrace(dx_show_index("frame", frame->entries));
1440 return de;
1442 journal_error:
1443 @@ -1273,7 +1273,7 @@ errout:
1444 */
1445 static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
1446 struct inode *inode, struct ext4_dir_entry_2 *de,
1447 - struct buffer_head * bh)
1448 + struct buffer_head *bh)
1449 {
1450 struct inode *dir = dentry->d_parent->d_inode;
1451 const char *name = dentry->d_name.name;
1452 @@ -1290,11 +1290,11 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
1453 while ((char *) de <= top) {
1454 if (!ext4_check_dir_entry("ext4_add_entry", dir, de,
1455 bh, offset)) {
1456 - brelse (bh);
1457 + brelse(bh);
1458 return -EIO;
1459 }
1460 - if (ext4_match (namelen, name, de)) {
1461 - brelse (bh);
1462 + if (ext4_match(namelen, name, de)) {
1463 + brelse(bh);
1464 return -EEXIST;
1465 }
1466 nlen = EXT4_DIR_REC_LEN(de->name_len);
1467 @@ -1331,7 +1331,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
1468 } else
1469 de->inode = 0;
1470 de->name_len = namelen;
1471 - memcpy (de->name, name, namelen);
1472 + memcpy(de->name, name, namelen);
1473 /*
1474 * XXX shouldn't update any times until successful
1475 * completion of syscall, but too many callers depend
1476 @@ -1388,7 +1388,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
1477 }
1478 root = (struct dx_root *) bh->b_data;
1480 - bh2 = ext4_append (handle, dir, &block, &retval);
1481 + bh2 = ext4_append(handle, dir, &block, &retval);
1482 if (!(bh2)) {
1483 brelse(bh);
1484 return retval;
1485 @@ -1414,9 +1414,9 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
1486 root->info.info_length = sizeof(root->info);
1487 root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
1488 entries = root->entries;
1489 - dx_set_block (entries, 1);
1490 - dx_set_count (entries, 1);
1491 - dx_set_limit (entries, dx_root_limit(dir, sizeof(root->info)));
1492 + dx_set_block(entries, 1);
1493 + dx_set_count(entries, 1);
1494 + dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
1496 /* Initialize as for dx_probe */
1497 hinfo.hash_version = root->info.hash_version;
1498 @@ -1445,14 +1445,14 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
1499 * may not sleep between calling this and putting something into
1500 * the entry, as someone else might have used it while you slept.
1501 */
1502 -static int ext4_add_entry (handle_t *handle, struct dentry *dentry,
1503 - struct inode *inode)
1504 +static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
1505 + struct inode *inode)
1506 {
1507 struct inode *dir = dentry->d_parent->d_inode;
1508 unsigned long offset;
1509 - struct buffer_head * bh;
1510 + struct buffer_head *bh;
1511 struct ext4_dir_entry_2 *de;
1512 - struct super_block * sb;
1513 + struct super_block *sb;
1514 int retval;
1515 int dx_fallback=0;
1516 unsigned blocksize;
1517 @@ -1502,9 +1502,9 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
1518 struct dx_frame frames[2], *frame;
1519 struct dx_entry *entries, *at;
1520 struct dx_hash_info hinfo;
1521 - struct buffer_head * bh;
1522 + struct buffer_head *bh;
1523 struct inode *dir = dentry->d_parent->d_inode;
1524 - struct super_block * sb = dir->i_sb;
1525 + struct super_block *sb = dir->i_sb;
1526 struct ext4_dir_entry_2 *de;
1527 int err;
1529 @@ -1570,11 +1570,11 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
1530 if (err)
1531 goto journal_error;
1533 - memcpy ((char *) entries2, (char *) (entries + icount1),
1534 - icount2 * sizeof(struct dx_entry));
1535 - dx_set_count (entries, icount1);
1536 - dx_set_count (entries2, icount2);
1537 - dx_set_limit (entries2, dx_node_limit(dir));
1538 + memcpy((char *) entries2, (char *) (entries + icount1),
1539 + icount2 * sizeof(struct dx_entry));
1540 + dx_set_count(entries, icount1);
1541 + dx_set_count(entries2, icount2);
1542 + dx_set_limit(entries2, dx_node_limit(dir));
1544 /* Which index block gets the new entry? */
1545 if (at - entries >= icount1) {
1546 @@ -1582,9 +1582,9 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
1547 frame->entries = entries = entries2;
1548 swap(frame->bh, bh2);
1549 }
1550 - dx_insert_block (frames + 0, hash2, newblock);
1551 - dxtrace(dx_show_index ("node", frames[1].entries));
1552 - dxtrace(dx_show_index ("node",
1553 + dx_insert_block(frames + 0, hash2, newblock);
1554 + dxtrace(dx_show_index("node", frames[1].entries));
1555 + dxtrace(dx_show_index("node",
1556 ((struct dx_node *) bh2->b_data)->entries));
1557 err = ext4_journal_dirty_metadata(handle, bh2);
1558 if (err)
1559 @@ -1634,12 +1634,12 @@ cleanup:
1560 * ext4_delete_entry deletes a directory entry by merging it with the
1561 * previous entry
1562 */
1563 -static int ext4_delete_entry (handle_t *handle,
1564 - struct inode * dir,
1565 - struct ext4_dir_entry_2 * de_del,
1566 - struct buffer_head * bh)
1567 +static int ext4_delete_entry(handle_t *handle,
1568 + struct inode *dir,
1569 + struct ext4_dir_entry_2 *de_del,
1570 + struct buffer_head *bh)
1571 {
1572 - struct ext4_dir_entry_2 * de, * pde;
1573 + struct ext4_dir_entry_2 *de, *pde;
1574 int i;
1576 i = 0;
1577 @@ -1720,11 +1720,11 @@ static int ext4_add_nondir(handle_t *handle,
1578 * If the create succeeds, we fill in the inode information
1579 * with d_instantiate().
1580 */
1581 -static int ext4_create (struct inode * dir, struct dentry * dentry, int mode,
1582 - struct nameidata *nd)
1583 +static int ext4_create(struct inode *dir, struct dentry *dentry, int mode,
1584 + struct nameidata *nd)
1585 {
1586 handle_t *handle;
1587 - struct inode * inode;
1588 + struct inode *inode;
1589 int err, retries = 0;
1591 retry:
1592 @@ -1751,8 +1751,8 @@ retry:
1593 return err;
1594 }
1596 -static int ext4_mknod (struct inode * dir, struct dentry *dentry,
1597 - int mode, dev_t rdev)
1598 +static int ext4_mknod(struct inode *dir, struct dentry *dentry,
1599 + int mode, dev_t rdev)
1600 {
1601 handle_t *handle;
1602 struct inode *inode;
1603 @@ -1771,7 +1771,7 @@ retry:
1604 if (IS_DIRSYNC(dir))
1605 handle->h_sync = 1;
1607 - inode = ext4_new_inode (handle, dir, mode);
1608 + inode = ext4_new_inode(handle, dir, mode);
1609 err = PTR_ERR(inode);
1610 if (!IS_ERR(inode)) {
1611 init_special_inode(inode, inode->i_mode, rdev);
1612 @@ -1786,12 +1786,12 @@ retry:
1613 return err;
1614 }
1616 -static int ext4_mkdir(struct inode * dir, struct dentry * dentry, int mode)
1617 +static int ext4_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1618 {
1619 handle_t *handle;
1620 - struct inode * inode;
1621 - struct buffer_head * dir_block;
1622 - struct ext4_dir_entry_2 * de;
1623 + struct inode *inode;
1624 + struct buffer_head *dir_block;
1625 + struct ext4_dir_entry_2 *de;
1626 int err, retries = 0;
1628 if (EXT4_DIR_LINK_MAX(dir))
1629 @@ -1807,7 +1807,7 @@ retry:
1630 if (IS_DIRSYNC(dir))
1631 handle->h_sync = 1;
1633 - inode = ext4_new_inode (handle, dir, S_IFDIR | mode);
1634 + inode = ext4_new_inode(handle, dir, S_IFDIR | mode);
1635 err = PTR_ERR(inode);
1636 if (IS_ERR(inode))
1637 goto out_stop;
1638 @@ -1815,7 +1815,7 @@ retry:
1639 inode->i_op = &ext4_dir_inode_operations;
1640 inode->i_fop = &ext4_dir_operations;
1641 inode->i_size = EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize;
1642 - dir_block = ext4_bread (handle, inode, 0, 1, &err);
1643 + dir_block = ext4_bread(handle, inode, 0, 1, &err);
1644 if (!dir_block)
1645 goto out_clear_inode;
1646 BUFFER_TRACE(dir_block, "get_write_access");
1647 @@ -1824,26 +1824,26 @@ retry:
1648 de->inode = cpu_to_le32(inode->i_ino);
1649 de->name_len = 1;
1650 de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len));
1651 - strcpy (de->name, ".");
1652 + strcpy(de->name, ".");
1653 ext4_set_de_type(dir->i_sb, de, S_IFDIR);
1654 de = ext4_next_entry(de);
1655 de->inode = cpu_to_le32(dir->i_ino);
1656 de->rec_len = ext4_rec_len_to_disk(inode->i_sb->s_blocksize -
1657 EXT4_DIR_REC_LEN(1));
1658 de->name_len = 2;
1659 - strcpy (de->name, "..");
1660 + strcpy(de->name, "..");
1661 ext4_set_de_type(dir->i_sb, de, S_IFDIR);
1662 inode->i_nlink = 2;
1663 BUFFER_TRACE(dir_block, "call ext4_journal_dirty_metadata");
1664 ext4_journal_dirty_metadata(handle, dir_block);
1665 - brelse (dir_block);
1666 + brelse(dir_block);
1667 ext4_mark_inode_dirty(handle, inode);
1668 - err = ext4_add_entry (handle, dentry, inode);
1669 + err = ext4_add_entry(handle, dentry, inode);
1670 if (err) {
1671 out_clear_inode:
1672 clear_nlink(inode);
1673 ext4_mark_inode_dirty(handle, inode);
1674 - iput (inode);
1675 + iput(inode);
1676 goto out_stop;
1677 }
1678 ext4_inc_count(handle, dir);
1679 @@ -1860,17 +1860,17 @@ out_stop:
1680 /*
1681 * routine to check that the specified directory is empty (for rmdir)
1682 */
1683 -static int empty_dir (struct inode * inode)
1684 +static int empty_dir(struct inode *inode)
1685 {
1686 unsigned long offset;
1687 - struct buffer_head * bh;
1688 - struct ext4_dir_entry_2 * de, * de1;
1689 - struct super_block * sb;
1690 + struct buffer_head *bh;
1691 + struct ext4_dir_entry_2 *de, *de1;
1692 + struct super_block *sb;
1693 int err = 0;
1695 sb = inode->i_sb;
1696 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2) ||
1697 - !(bh = ext4_bread (NULL, inode, 0, 0, &err))) {
1698 + !(bh = ext4_bread(NULL, inode, 0, 0, &err))) {
1699 if (err)
1700 ext4_error(inode->i_sb, __func__,
1701 "error %d reading directory #%lu offset 0",
1702 @@ -1885,23 +1885,23 @@ static int empty_dir (struct inode * inode)
1703 de1 = ext4_next_entry(de);
1704 if (le32_to_cpu(de->inode) != inode->i_ino ||
1705 !le32_to_cpu(de1->inode) ||
1706 - strcmp (".", de->name) ||
1707 - strcmp ("..", de1->name)) {
1708 - ext4_warning (inode->i_sb, "empty_dir",
1709 - "bad directory (dir #%lu) - no `.' or `..'",
1710 - inode->i_ino);
1711 - brelse (bh);
1712 + strcmp(".", de->name) ||
1713 + strcmp("..", de1->name)) {
1714 + ext4_warning(inode->i_sb, "empty_dir",
1715 + "bad directory (dir #%lu) - no `.' or `..'",
1716 + inode->i_ino);
1717 + brelse(bh);
1718 return 1;
1719 }
1720 offset = ext4_rec_len_from_disk(de->rec_len) +
1721 ext4_rec_len_from_disk(de1->rec_len);
1722 de = ext4_next_entry(de1);
1723 - while (offset < inode->i_size ) {
1724 + while (offset < inode->i_size) {
1725 if (!bh ||
1726 (void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
1727 err = 0;
1728 - brelse (bh);
1729 - bh = ext4_bread (NULL, inode,
1730 + brelse(bh);
1731 + bh = ext4_bread(NULL, inode,
1732 offset >> EXT4_BLOCK_SIZE_BITS(sb), 0, &err);
1733 if (!bh) {
1734 if (err)
1735 @@ -1921,13 +1921,13 @@ static int empty_dir (struct inode * inode)
1736 continue;
1737 }
1738 if (le32_to_cpu(de->inode)) {
1739 - brelse (bh);
1740 + brelse(bh);
1741 return 0;
1742 }
1743 offset += ext4_rec_len_from_disk(de->rec_len);
1744 de = ext4_next_entry(de);
1745 }
1746 - brelse (bh);
1747 + brelse(bh);
1748 return 1;
1749 }
1751 @@ -1958,8 +1958,8 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
1752 * ->i_nlink. For, say it, character device. Not a regular file,
1753 * not a directory, not a symlink and ->i_nlink > 0.
1754 */
1755 - J_ASSERT ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1756 - S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
1757 + J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1758 + S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
1760 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
1761 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
1762 @@ -2073,12 +2073,12 @@ out_brelse:
1763 goto out_err;
1764 }
1766 -static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
1767 +static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
1768 {
1769 int retval;
1770 - struct inode * inode;
1771 - struct buffer_head * bh;
1772 - struct ext4_dir_entry_2 * de;
1773 + struct inode *inode;
1774 + struct buffer_head *bh;
1775 + struct ext4_dir_entry_2 *de;
1776 handle_t *handle;
1778 /* Initialize quotas before so that eventual writes go in
1779 @@ -2089,7 +2089,7 @@ static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
1780 return PTR_ERR(handle);
1782 retval = -ENOENT;
1783 - bh = ext4_find_entry (dentry, &de);
1784 + bh = ext4_find_entry(dentry, &de);
1785 if (!bh)
1786 goto end_rmdir;
1788 @@ -2103,16 +2103,16 @@ static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
1789 goto end_rmdir;
1791 retval = -ENOTEMPTY;
1792 - if (!empty_dir (inode))
1793 + if (!empty_dir(inode))
1794 goto end_rmdir;
1796 retval = ext4_delete_entry(handle, dir, de, bh);
1797 if (retval)
1798 goto end_rmdir;
1799 if (!EXT4_DIR_LINK_EMPTY(inode))
1800 - ext4_warning (inode->i_sb, "ext4_rmdir",
1801 - "empty directory has too many links (%d)",
1802 - inode->i_nlink);
1803 + ext4_warning(inode->i_sb, "ext4_rmdir",
1804 + "empty directory has too many links (%d)",
1805 + inode->i_nlink);
1806 inode->i_version++;
1807 clear_nlink(inode);
1808 /* There's no need to set i_disksize: the fact that i_nlink is
1809 @@ -2128,16 +2128,16 @@ static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
1811 end_rmdir:
1812 ext4_journal_stop(handle);
1813 - brelse (bh);
1814 + brelse(bh);
1815 return retval;
1816 }
1818 -static int ext4_unlink(struct inode * dir, struct dentry *dentry)
1819 +static int ext4_unlink(struct inode *dir, struct dentry *dentry)
1820 {
1821 int retval;
1822 - struct inode * inode;
1823 - struct buffer_head * bh;
1824 - struct ext4_dir_entry_2 * de;
1825 + struct inode *inode;
1826 + struct buffer_head *bh;
1827 + struct ext4_dir_entry_2 *de;
1828 handle_t *handle;
1830 /* Initialize quotas before so that eventual writes go
1831 @@ -2151,7 +2151,7 @@ static int ext4_unlink(struct inode * dir, struct dentry *dentry)
1832 handle->h_sync = 1;
1834 retval = -ENOENT;
1835 - bh = ext4_find_entry (dentry, &de);
1836 + bh = ext4_find_entry(dentry, &de);
1837 if (!bh)
1838 goto end_unlink;
1840 @@ -2162,9 +2162,9 @@ static int ext4_unlink(struct inode * dir, struct dentry *dentry)
1841 goto end_unlink;
1843 if (!inode->i_nlink) {
1844 - ext4_warning (inode->i_sb, "ext4_unlink",
1845 - "Deleting nonexistent file (%lu), %d",
1846 - inode->i_ino, inode->i_nlink);
1847 + ext4_warning(inode->i_sb, "ext4_unlink",
1848 + "Deleting nonexistent file (%lu), %d",
1849 + inode->i_ino, inode->i_nlink);
1850 inode->i_nlink = 1;
1851 }
1852 retval = ext4_delete_entry(handle, dir, de, bh);
1853 @@ -2182,15 +2182,15 @@ static int ext4_unlink(struct inode * dir, struct dentry *dentry)
1855 end_unlink:
1856 ext4_journal_stop(handle);
1857 - brelse (bh);
1858 + brelse(bh);
1859 return retval;
1860 }
1862 -static int ext4_symlink (struct inode * dir,
1863 - struct dentry *dentry, const char * symname)
1864 +static int ext4_symlink(struct inode *dir,
1865 + struct dentry *dentry, const char *symname)
1866 {
1867 handle_t *handle;
1868 - struct inode * inode;
1869 + struct inode *inode;
1870 int l, err, retries = 0;
1872 l = strlen(symname)+1;
1873 @@ -2207,12 +2207,12 @@ retry:
1874 if (IS_DIRSYNC(dir))
1875 handle->h_sync = 1;
1877 - inode = ext4_new_inode (handle, dir, S_IFLNK|S_IRWXUGO);
1878 + inode = ext4_new_inode(handle, dir, S_IFLNK|S_IRWXUGO);
1879 err = PTR_ERR(inode);
1880 if (IS_ERR(inode))
1881 goto out_stop;
1883 - if (l > sizeof (EXT4_I(inode)->i_data)) {
1884 + if (l > sizeof(EXT4_I(inode)->i_data)) {
1885 inode->i_op = &ext4_symlink_inode_operations;
1886 ext4_set_aops(inode);
1887 /*
1888 @@ -2225,14 +2225,14 @@ retry:
1889 if (err) {
1890 clear_nlink(inode);
1891 ext4_mark_inode_dirty(handle, inode);
1892 - iput (inode);
1893 + iput(inode);
1894 goto out_stop;
1895 }
1896 } else {
1897 /* clear the extent format for fast symlink */
1898 EXT4_I(inode)->i_flags &= ~EXT4_EXTENTS_FL;
1899 inode->i_op = &ext4_fast_symlink_inode_operations;
1900 - memcpy((char*)&EXT4_I(inode)->i_data,symname,l);
1901 + memcpy((char *)&EXT4_I(inode)->i_data, symname, l);
1902 inode->i_size = l-1;
1903 }
1904 EXT4_I(inode)->i_disksize = inode->i_size;
1905 @@ -2244,8 +2244,8 @@ out_stop:
1906 return err;
1907 }
1909 -static int ext4_link (struct dentry * old_dentry,
1910 - struct inode * dir, struct dentry *dentry)
1911 +static int ext4_link(struct dentry *old_dentry,
1912 + struct inode *dir, struct dentry *dentry)
1913 {
1914 handle_t *handle;
1915 struct inode *inode = old_dentry->d_inode;
1916 @@ -2288,13 +2288,13 @@ retry:
1917 * Anybody can rename anything with this: the permission checks are left to the
1918 * higher-level routines.
1919 */
1920 -static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
1921 - struct inode * new_dir,struct dentry *new_dentry)
1922 +static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
1923 + struct inode *new_dir, struct dentry *new_dentry)
1924 {
1925 handle_t *handle;
1926 - struct inode * old_inode, * new_inode;
1927 - struct buffer_head * old_bh, * new_bh, * dir_bh;
1928 - struct ext4_dir_entry_2 * old_de, * new_de;
1929 + struct inode *old_inode, *new_inode;
1930 + struct buffer_head *old_bh, *new_bh, *dir_bh;
1931 + struct ext4_dir_entry_2 *old_de, *new_de;
1932 int retval;
1934 old_bh = new_bh = dir_bh = NULL;
1935 @@ -2312,7 +2312,7 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
1936 if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
1937 handle->h_sync = 1;
1939 - old_bh = ext4_find_entry (old_dentry, &old_de);
1940 + old_bh = ext4_find_entry(old_dentry, &old_de);
1941 /*
1942 * Check for inode number is _not_ due to possible IO errors.
1943 * We might rmdir the source, keep it as pwd of some process
1944 @@ -2325,32 +2325,32 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
1945 goto end_rename;
1947 new_inode = new_dentry->d_inode;
1948 - new_bh = ext4_find_entry (new_dentry, &new_de);
1949 + new_bh = ext4_find_entry(new_dentry, &new_de);
1950 if (new_bh) {
1951 if (!new_inode) {
1952 - brelse (new_bh);
1953 + brelse(new_bh);
1954 new_bh = NULL;
1955 }
1956 }
1957 if (S_ISDIR(old_inode->i_mode)) {
1958 if (new_inode) {
1959 retval = -ENOTEMPTY;
1960 - if (!empty_dir (new_inode))
1961 + if (!empty_dir(new_inode))
1962 goto end_rename;
1963 }
1964 retval = -EIO;
1965 - dir_bh = ext4_bread (handle, old_inode, 0, 0, &retval);
1966 + dir_bh = ext4_bread(handle, old_inode, 0, 0, &retval);
1967 if (!dir_bh)
1968 goto end_rename;
1969 if (le32_to_cpu(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino)
1970 goto end_rename;
1971 retval = -EMLINK;
1972 - if (!new_inode && new_dir!=old_dir &&
1973 + if (!new_inode && new_dir != old_dir &&
1974 new_dir->i_nlink >= EXT4_LINK_MAX)
1975 goto end_rename;
1976 }
1977 if (!new_bh) {
1978 - retval = ext4_add_entry (handle, new_dentry, old_inode);
1979 + retval = ext4_add_entry(handle, new_dentry, old_inode);
1980 if (retval)
1981 goto end_rename;
1982 } else {
1983 @@ -2437,9 +2437,9 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
1984 retval = 0;
1986 end_rename:
1987 - brelse (dir_bh);
1988 - brelse (old_bh);
1989 - brelse (new_bh);
1990 + brelse(dir_bh);
1991 + brelse(old_bh);
1992 + brelse(new_bh);
1993 ext4_journal_stop(handle);
1994 return retval;
1995 }
1996 diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
1997 index b3d3560..4392e3f 100644
1998 --- a/fs/ext4/resize.c
1999 +++ b/fs/ext4/resize.c
2000 @@ -416,8 +416,8 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
2001 "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n",
2002 gdb_num);
2004 - /*
2005 - * If we are not using the primary superblock/GDT copy don't resize,
2006 + /*
2007 + * If we are not using the primary superblock/GDT copy don't resize,
2008 * because the user tools have no way of handling this. Probably a
2009 * bad time to do it anyways.
2010 */
2011 @@ -964,7 +964,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
2012 ext4_group_t o_groups_count;
2013 ext4_grpblk_t last;
2014 ext4_grpblk_t add;
2015 - struct buffer_head * bh;
2016 + struct buffer_head *bh;
2017 handle_t *handle;
2018 int err;
2019 unsigned long freed_blocks;
2020 diff --git a/fs/ext4/super.c b/fs/ext4/super.c
2021 index c10aaf7..7de6ca0 100644
2022 --- a/fs/ext4/super.c
2023 +++ b/fs/ext4/super.c
2024 @@ -654,7 +654,7 @@ static inline void ext4_show_quota_options(struct seq_file *seq,
2026 if (sbi->s_jquota_fmt)
2027 seq_printf(seq, ",jqfmt=%s",
2028 - (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold": "vfsv0");
2029 + (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold" : "vfsv0");
2031 if (sbi->s_qf_names[USRQUOTA])
2032 seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
2033 @@ -822,7 +822,7 @@ static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
2034 }
2036 #ifdef CONFIG_QUOTA
2037 -#define QTYPE2NAME(t) ((t) == USRQUOTA?"user":"group")
2038 +#define QTYPE2NAME(t) ((t) == USRQUOTA ? "user" : "group")
2039 #define QTYPE2MOPT(on, t) ((t) == USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
2041 static int ext4_dquot_initialize(struct inode *inode, int type);
2042 @@ -1586,7 +1586,7 @@ static int ext4_check_descriptors(struct super_block *sb)
2043 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
2044 flexbg_flag = 1;
2046 - ext4_debug ("Checking group descriptors");
2047 + ext4_debug("Checking group descriptors");
2049 for (i = 0; i < sbi->s_groups_count; i++) {
2050 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
2051 diff --git a/fs/ext4/symlink.c b/fs/ext4/symlink.c
2052 index e917864..0013d52 100644
2053 --- a/fs/ext4/symlink.c
2054 +++ b/fs/ext4/symlink.c
2055 @@ -23,10 +23,10 @@
2056 #include "ext4.h"
2057 #include "xattr.h"
2059 -static void * ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
2060 +static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
2061 {
2062 struct ext4_inode_info *ei = EXT4_I(dentry->d_inode);
2063 - nd_set_link(nd, (char*)ei->i_data);
2064 + nd_set_link(nd, (char *) ei->i_data);
2065 return NULL;
2066 }
2068 diff --git a/fs/ext4/xattr.h b/fs/ext4/xattr.h
2069 index 5992fe9..814ea58 100644
2070 --- a/fs/ext4/xattr.h
2071 +++ b/fs/ext4/xattr.h
2072 @@ -51,8 +51,8 @@ struct ext4_xattr_entry {
2073 (((name_len) + EXT4_XATTR_ROUND + \
2074 sizeof(struct ext4_xattr_entry)) & ~EXT4_XATTR_ROUND)
2075 #define EXT4_XATTR_NEXT(entry) \
2076 - ( (struct ext4_xattr_entry *)( \
2077 - (char *)(entry) + EXT4_XATTR_LEN((entry)->e_name_len)) )
2078 + ((struct ext4_xattr_entry *)( \
2079 + (char *)(entry) + EXT4_XATTR_LEN((entry)->e_name_len)))
2080 #define EXT4_XATTR_SIZE(size) \
2081 (((size) + EXT4_XATTR_ROUND) & ~EXT4_XATTR_ROUND)