| blob | 4493d1ebfcc9169c49957e930a1cf7738a16c47f |
1 diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
2 index c864450..27323cd 100644
3 --- a/fs/ext4/balloc.c
4 +++ b/fs/ext4/balloc.c
5 @@ -379,26 +379,28 @@ restart:
6 bad = 0;
7 prev = NULL;
9 - printk("Block Allocation Reservation Windows Map (%s):\n", fn);
10 + printk(KERN_DEBUG "Block Allocation Reservation "
11 + "Windows Map (%s):\n", fn);
12 while (n) {
13 rsv = rb_entry(n, struct ext4_reserve_window_node, rsv_node);
14 if (verbose)
15 - printk("reservation window 0x%p "
16 + printk(KERN_DEBUG "reservation window 0x%p "
17 "start: %llu, end: %llu\n",
18 rsv, rsv->rsv_start, rsv->rsv_end);
19 if (rsv->rsv_start && rsv->rsv_start >= rsv->rsv_end) {
20 - printk("Bad reservation %p (start >= end)\n",
21 + printk(KERN_DEBUG "Bad reservation %p (start >= end)\n",
22 rsv);
23 bad = 1;
24 }
25 if (prev && prev->rsv_end >= rsv->rsv_start) {
26 - printk("Bad reservation %p (prev->end >= start)\n",
27 - rsv);
28 + printk(KERN_DEBUG "Bad reservation %p "
29 + "(prev->end >= start)\n", rsv);
30 bad = 1;
31 }
32 if (bad) {
33 if (!verbose) {
34 - printk("Restarting reservation walk in verbose mode\n");
35 + printk(KERN_DEBUG "Restarting reservation "
36 + "walk in verbose mode\n");
37 verbose = 1;
38 goto restart;
39 }
40 @@ -406,7 +408,7 @@ restart:
41 n = rb_next(n);
42 prev = rsv;
43 }
44 - printk("Window map complete.\n");
45 + printk(KERN_DEBUG "Window map complete.\n");
46 BUG_ON(bad);
47 }
48 #define rsv_window_dump(root, verbose) \
49 @@ -1699,7 +1701,7 @@ ext4_fsblk_t ext4_old_new_blocks(handle_t *handle, struct inode *inode,
50 sb = inode->i_sb;
51 if (!sb) {
52 *errp = -ENODEV;
53 - printk("ext4_new_block: nonexistent device");
54 + printk(KERN_ERR "ext4_new_block: nonexistent superblock");
55 return 0;
56 }
58 @@ -1881,8 +1883,8 @@ allocated:
59 for (i = 0; i < num; i++) {
60 if (ext4_test_bit(grp_alloc_blk+i,
61 bh2jh(bitmap_bh)->b_committed_data)) {
62 - printk("%s: block was unexpectedly set in "
63 - "b_committed_data\n", __func__);
64 + printk(KERN_ERR "%s: block was unexpectedly "
65 + "set in b_committed_data\n", __func__);
66 }
67 }
68 }
69 @@ -2090,10 +2092,9 @@ ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb)
70 bitmap_count += x;
71 }
72 brelse(bitmap_bh);
73 - printk("ext4_count_free_blocks: stored = %llu"
74 - ", computed = %llu, %llu\n",
75 - ext4_free_blocks_count(es),
76 - desc_count, bitmap_count);
77 + printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu"
78 + ", computed = %llu, %llu\n", ext4_free_blocks_count(es),
79 + desc_count, bitmap_count);
80 return bitmap_count;
81 #else
82 desc_count = 0;
83 diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
84 index d3d23d7..05346fb 100644
85 --- a/fs/ext4/dir.c
86 +++ b/fs/ext4/dir.c
87 @@ -400,7 +400,8 @@ static int call_filldir(struct file * filp, void * dirent,
88 sb = inode->i_sb;
90 if (!fname) {
91 - printk("call_filldir: called with null fname?!?\n");
92 + printk(KERN_ERR "ext4: call_filldir: called with "
93 + "null fname?!?\n");
94 return 0;
95 }
96 curr_pos = hash2pos(fname->hash, fname->minor_hash);
97 diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
98 index d14d925..3c82ab1 100644
99 --- a/fs/ext4/extents.c
100 +++ b/fs/ext4/extents.c
101 @@ -447,9 +447,10 @@ ext4_ext_binsearch_idx(struct inode *inode,
102 for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) {
103 if (k != 0 &&
104 le32_to_cpu(ix->ei_block) <= le32_to_cpu(ix[-1].ei_block)) {
105 - printk("k=%d, ix=0x%p, first=0x%p\n", k,
106 - ix, EXT_FIRST_INDEX(eh));
107 - printk("%u <= %u\n",
108 + printk(KERN_DEBUG "k=%d, ix=0x%p, "
109 + "first=0x%p\n", k,
110 + ix, EXT_FIRST_INDEX(eh));
111 + printk(KERN_DEBUG "%u <= %u\n",
112 le32_to_cpu(ix->ei_block),
113 le32_to_cpu(ix[-1].ei_block));
114 }
115 diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
116 index 655e760..54f56ed 100644
117 --- a/fs/ext4/ialloc.c
118 +++ b/fs/ext4/ialloc.c
119 @@ -170,17 +170,18 @@ void ext4_free_inode (handle_t *handle, struct inode * inode)
120 ext4_group_t flex_group;
122 if (atomic_read(&inode->i_count) > 1) {
123 - printk ("ext4_free_inode: inode has count=%d\n",
124 - atomic_read(&inode->i_count));
125 + printk(KERN_ERR "ext4_free_inode: inode has count=%d\n",
126 + atomic_read(&inode->i_count));
127 return;
128 }
129 if (inode->i_nlink) {
130 - printk ("ext4_free_inode: inode has nlink=%d\n",
131 - inode->i_nlink);
132 + printk(KERN_ERR "ext4_free_inode: inode has nlink=%d\n",
133 + inode->i_nlink);
134 return;
135 }
136 if (!sb) {
137 - printk("ext4_free_inode: inode on nonexistent device\n");
138 + printk(KERN_ERR "ext4_free_inode: inode on "
139 + "nonexistent device\n");
140 return;
141 }
142 sbi = EXT4_SB(sb);
143 @@ -204,8 +205,8 @@ void ext4_free_inode (handle_t *handle, struct inode * inode)
145 es = EXT4_SB(sb)->s_es;
146 if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
147 - ext4_error (sb, "ext4_free_inode",
148 - "reserved or nonexistent inode %lu", ino);
149 + ext4_error(sb, "ext4_free_inode",
150 + "reserved or nonexistent inode %lu", ino);
151 goto error_return;
152 }
153 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
154 @@ -222,10 +223,10 @@ void ext4_free_inode (handle_t *handle, struct inode * inode)
155 /* Ok, now we can actually update the inode bitmaps.. */
156 if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
157 bit, bitmap_bh->b_data))
158 - ext4_error (sb, "ext4_free_inode",
159 - "bit already cleared for inode %lu", ino);
160 + ext4_error(sb, "ext4_free_inode",
161 + "bit already cleared for inode %lu", ino);
162 else {
163 - gdp = ext4_get_group_desc (sb, block_group, &bh2);
164 + gdp = ext4_get_group_desc(sb, block_group, &bh2);
166 BUFFER_TRACE(bh2, "get_write_access");
167 fatal = ext4_journal_get_write_access(handle, bh2);
168 @@ -576,7 +577,7 @@ static int find_group_other(struct super_block *sb, struct inode *parent,
169 * For other inodes, search forward from the parent directory's block
170 * group to find a free inode.
171 */
172 -struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
173 +struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode)
174 {
175 struct super_block *sb;
176 struct buffer_head *bitmap_bh = NULL;
177 @@ -989,8 +990,9 @@ unsigned long ext4_count_free_inodes (struct super_block * sb)
178 bitmap_count += x;
179 }
180 brelse(bitmap_bh);
181 - printk("ext4_count_free_inodes: stored = %u, computed = %lu, %lu\n",
182 - le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
183 + printk(KERN_DEBUG "ext4_count_free_inodes: "
184 + "stored = %u, computed = %lu, %lu\n",
185 + le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
186 return desc_count;
187 #else
188 desc_count = 0;
189 diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
190 index 1bdf56c..b14a7c7 100644
191 --- a/fs/ext4/mballoc.c
192 +++ b/fs/ext4/mballoc.c
193 @@ -477,9 +477,10 @@ static void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)
194 b2 = (unsigned char *) bitmap;
195 for (i = 0; i < e4b->bd_sb->s_blocksize; i++) {
196 if (b1[i] != b2[i]) {
197 - printk("corruption in group %lu at byte %u(%u):"
198 - " %x in copy != %x on disk/prealloc\n",
199 - e4b->bd_group, i, i * 8, b1[i], b2[i]);
200 + printk(KERN_ERR "corruption in group %lu "
201 + "at byte %u(%u): %x in copy != %x "
202 + "on disk/prealloc\n",
203 + e4b->bd_group, i, i * 8, b1[i], b2[i]);
204 BUG();
205 }
206 }
207 @@ -2564,7 +2565,7 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery)
208 ext4_mb_init_per_dev_proc(sb);
209 ext4_mb_history_init(sb);
211 - printk("EXT4-fs: mballoc enabled\n");
212 + printk(KERN_INFO "EXT4-fs: mballoc enabled\n");
213 return 0;
214 }
216 diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
217 index 387ad98..3265c57 100644
218 --- a/fs/ext4/namei.c
219 +++ b/fs/ext4/namei.c
220 @@ -207,44 +207,44 @@ static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
221 entry->block = cpu_to_le32(value);
222 }
224 -static inline unsigned dx_get_hash (struct dx_entry *entry)
225 +static inline unsigned dx_get_hash(struct dx_entry *entry)
226 {
227 return le32_to_cpu(entry->hash);
228 }
230 -static inline void dx_set_hash (struct dx_entry *entry, unsigned value)
231 +static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
232 {
233 entry->hash = cpu_to_le32(value);
234 }
236 -static inline unsigned dx_get_count (struct dx_entry *entries)
237 +static inline unsigned dx_get_count(struct dx_entry *entries)
238 {
239 return le16_to_cpu(((struct dx_countlimit *) entries)->count);
240 }
242 -static inline unsigned dx_get_limit (struct dx_entry *entries)
243 +static inline unsigned dx_get_limit(struct dx_entry *entries)
244 {
245 return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
246 }
248 -static inline void dx_set_count (struct dx_entry *entries, unsigned value)
249 +static inline void dx_set_count(struct dx_entry *entries, unsigned value)
250 {
251 ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
252 }
254 -static inline void dx_set_limit (struct dx_entry *entries, unsigned value)
255 +static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
256 {
257 ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
258 }
260 -static inline unsigned dx_root_limit (struct inode *dir, unsigned infosize)
261 +static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
262 {
263 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
264 EXT4_DIR_REC_LEN(2) - infosize;
265 return entry_space / sizeof(struct dx_entry);
266 }
268 -static inline unsigned dx_node_limit (struct inode *dir)
269 +static inline unsigned dx_node_limit(struct inode *dir)
270 {
271 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
272 return entry_space / sizeof(struct dx_entry);
273 @@ -254,12 +254,12 @@ static inline unsigned dx_node_limit (struct inode *dir)
274 * Debug
275 */
276 #ifdef DX_DEBUG
277 -static void dx_show_index (char * label, struct dx_entry *entries)
278 +static void dx_show_index(char * label, struct dx_entry *entries)
279 {
280 int i, n = dx_get_count (entries);
281 - printk("%s index ", label);
282 + printk(KERN_DEBUG "%s index ", label);
283 for (i = 0; i < n; i++) {
284 - printk("%x->%lu ", i? dx_get_hash(entries + i) :
285 + printk("%x->%lu ", i ? dx_get_hash(entries + i) :
286 0, (unsigned long)dx_get_block(entries + i));
287 }
288 printk("\n");
289 @@ -328,8 +328,9 @@ struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
290 brelse (bh);
291 }
292 if (bcount)
293 - printk("%snames %u, fullness %u (%u%%)\n", levels?"":" ",
294 - names, space/bcount,(space/bcount)*100/blocksize);
295 + printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
296 + levels ? "" : " ", names, space/bcount,
297 + (space/bcount)*100/blocksize);
298 return (struct stats) { names, space, bcount};
299 }
300 #endif /* DX_DEBUG */
301 @@ -406,7 +407,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
302 goto fail;
303 }
305 - dxtrace (printk("Look up %x", hash));
306 + dxtrace(printk("Look up %x", hash));
307 while (1)
308 {
309 count = dx_get_count(entries);
310 @@ -635,8 +636,8 @@ int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
311 int ret, err;
312 __u32 hashval;
314 - dxtrace(printk("In htree_fill_tree, start hash: %x:%x\n", start_hash,
315 - start_minor_hash));
316 + dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
317 + start_hash, start_minor_hash));
318 dir = dir_file->f_path.dentry->d_inode;
319 if (!(EXT4_I(dir)->i_flags & EXT4_INDEX_FL)) {
320 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
321 @@ -694,8 +695,8 @@ int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
322 break;
323 }
324 dx_release(frames);
325 - dxtrace(printk("Fill tree: returned %d entries, next hash: %x\n",
326 - count, *next_hash));
327 + dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
328 + "next hash: %x\n", count, *next_hash));
329 return count;
330 errout:
331 dx_release(frames);
332 @@ -882,7 +883,8 @@ static struct buffer_head * ext4_find_entry (struct dentry *dentry,
333 */
334 if (bh || (err != ERR_BAD_DX_DIR))
335 return bh;
336 - dxtrace(printk("ext4_find_entry: dx failed, falling back\n"));
337 + dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
338 + "falling back\n"));
339 }
340 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
341 start = EXT4_I(dir)->i_dir_start_lookup;
342 @@ -1025,7 +1027,7 @@ static struct buffer_head * ext4_dx_find_entry(struct dentry *dentry,
344 *err = -ENOENT;
345 errout:
346 - dxtrace(printk("%s not found\n", name));
347 + dxtrace(printk(KERN_DEBUG "%s not found\n", name));
348 dx_release (frames);
349 return NULL;
350 }
351 @@ -1377,7 +1379,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
352 struct fake_dirent *fde;
354 blocksize = dir->i_sb->s_blocksize;
355 - dxtrace(printk("Creating index\n"));
356 + dxtrace(printk(KERN_DEBUG "Creating index\n"));
357 retval = ext4_journal_get_write_access(handle, bh);
358 if (retval) {
359 ext4_std_error(dir->i_sb, retval);
360 @@ -1443,8 +1445,8 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
361 * may not sleep between calling this and putting something into
362 * the entry, as someone else might have used it while you slept.
363 */
364 -static int ext4_add_entry (handle_t *handle, struct dentry *dentry,
365 - struct inode *inode)
366 +static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
367 + struct inode *inode)
368 {
369 struct inode *dir = dentry->d_parent->d_inode;
370 unsigned long offset;
371 @@ -1527,7 +1529,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
372 }
374 /* Block full, should compress but for now just split */
375 - dxtrace(printk("using %u of %u node entries\n",
376 + dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
377 dx_get_count(entries), dx_get_limit(entries)));
378 /* Need to split index? */
379 if (dx_get_count(entries) == dx_get_limit(entries)) {
380 @@ -1559,7 +1561,8 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
381 if (levels) {
382 unsigned icount1 = icount/2, icount2 = icount - icount1;
383 unsigned hash2 = dx_get_hash(entries + icount1);
384 - dxtrace(printk("Split index %i/%i\n", icount1, icount2));
385 + dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
386 + icount1, icount2));
388 BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
389 err = ext4_journal_get_write_access(handle,
390 @@ -1567,11 +1570,11 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
391 if (err)
392 goto journal_error;
394 - memcpy ((char *) entries2, (char *) (entries + icount1),
395 - icount2 * sizeof(struct dx_entry));
396 - dx_set_count (entries, icount1);
397 - dx_set_count (entries2, icount2);
398 - dx_set_limit (entries2, dx_node_limit(dir));
399 + memcpy((char *) entries2, (char *) (entries + icount1),
400 + icount2 * sizeof(struct dx_entry));
401 + dx_set_count(entries, icount1);
402 + dx_set_count(entries2, icount2);
403 + dx_set_limit(entries2, dx_node_limit(dir));
405 /* Which index block gets the new entry? */
406 if (at - entries >= icount1) {
407 @@ -1579,16 +1582,17 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
408 frame->entries = entries = entries2;
409 swap(frame->bh, bh2);
410 }
411 - dx_insert_block (frames + 0, hash2, newblock);
412 - dxtrace(dx_show_index ("node", frames[1].entries));
413 - dxtrace(dx_show_index ("node",
414 + dx_insert_block(frames + 0, hash2, newblock);
415 + dxtrace(dx_show_index("node", frames[1].entries));
416 + dxtrace(dx_show_index("node",
417 ((struct dx_node *) bh2->b_data)->entries));
418 err = ext4_journal_dirty_metadata(handle, bh2);
419 if (err)
420 goto journal_error;
421 brelse (bh2);
422 } else {
423 - dxtrace(printk("Creating second level index...\n"));
424 + dxtrace(printk(KERN_DEBUG
425 + "Creating second level index...\n"));
426 memcpy((char *) entries2, (char *) entries,
427 icount * sizeof(struct dx_entry));
428 dx_set_limit(entries2, dx_node_limit(dir));
429 @@ -1630,12 +1634,12 @@ cleanup:
430 * ext4_delete_entry deletes a directory entry by merging it with the
431 * previous entry
432 */
433 -static int ext4_delete_entry (handle_t *handle,
434 - struct inode * dir,
435 - struct ext4_dir_entry_2 * de_del,
436 - struct buffer_head * bh)
437 +static int ext4_delete_entry(handle_t *handle,
438 + struct inode *dir,
439 + struct ext4_dir_entry_2 *de_del,
440 + struct buffer_head *bh)
441 {
442 - struct ext4_dir_entry_2 * de, * pde;
443 + struct ext4_dir_entry_2 *de, *pde;
444 int i;
446 i = 0;
447 @@ -1716,11 +1720,11 @@ static int ext4_add_nondir(handle_t *handle,
448 * If the create succeeds, we fill in the inode information
449 * with d_instantiate().
450 */
451 -static int ext4_create (struct inode * dir, struct dentry * dentry, int mode,
452 - struct nameidata *nd)
453 +static int ext4_create(struct inode *dir, struct dentry *dentry, int mode,
454 + struct nameidata *nd)
455 {
456 handle_t *handle;
457 - struct inode * inode;
458 + struct inode *inode;
459 int err, retries = 0;
461 retry:
462 @@ -1747,8 +1751,8 @@ retry:
463 return err;
464 }
466 -static int ext4_mknod (struct inode * dir, struct dentry *dentry,
467 - int mode, dev_t rdev)
468 +static int ext4_mknod(struct inode *dir, struct dentry *dentry,
469 + int mode, dev_t rdev)
470 {
471 handle_t *handle;
472 struct inode *inode;
473 @@ -1767,7 +1771,7 @@ retry:
474 if (IS_DIRSYNC(dir))
475 handle->h_sync = 1;
477 - inode = ext4_new_inode (handle, dir, mode);
478 + inode = ext4_new_inode(handle, dir, mode);
479 err = PTR_ERR(inode);
480 if (!IS_ERR(inode)) {
481 init_special_inode(inode, inode->i_mode, rdev);
482 @@ -1782,12 +1786,12 @@ retry:
483 return err;
484 }
486 -static int ext4_mkdir(struct inode * dir, struct dentry * dentry, int mode)
487 +static int ext4_mkdir(struct inode *dir, struct dentry *dentry, int mode)
488 {
489 handle_t *handle;
490 - struct inode * inode;
491 - struct buffer_head * dir_block;
492 - struct ext4_dir_entry_2 * de;
493 + struct inode *inode;
494 + struct buffer_head *dir_block;
495 + struct ext4_dir_entry_2 *de;
496 int err, retries = 0;
498 if (EXT4_DIR_LINK_MAX(dir))
499 @@ -1803,7 +1807,7 @@ retry:
500 if (IS_DIRSYNC(dir))
501 handle->h_sync = 1;
503 - inode = ext4_new_inode (handle, dir, S_IFDIR | mode);
504 + inode = ext4_new_inode(handle, dir, S_IFDIR | mode);
505 err = PTR_ERR(inode);
506 if (IS_ERR(inode))
507 goto out_stop;
508 @@ -1811,7 +1815,7 @@ retry:
509 inode->i_op = &ext4_dir_inode_operations;
510 inode->i_fop = &ext4_dir_operations;
511 inode->i_size = EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize;
512 - dir_block = ext4_bread (handle, inode, 0, 1, &err);
513 + dir_block = ext4_bread(handle, inode, 0, 1, &err);
514 if (!dir_block)
515 goto out_clear_inode;
516 BUFFER_TRACE(dir_block, "get_write_access");
517 @@ -1820,26 +1824,26 @@ retry:
518 de->inode = cpu_to_le32(inode->i_ino);
519 de->name_len = 1;
520 de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len));
521 - strcpy (de->name, ".");
522 + strcpy(de->name, ".");
523 ext4_set_de_type(dir->i_sb, de, S_IFDIR);
524 de = ext4_next_entry(de);
525 de->inode = cpu_to_le32(dir->i_ino);
526 de->rec_len = ext4_rec_len_to_disk(inode->i_sb->s_blocksize -
527 EXT4_DIR_REC_LEN(1));
528 de->name_len = 2;
529 - strcpy (de->name, "..");
530 + strcpy(de->name, "..");
531 ext4_set_de_type(dir->i_sb, de, S_IFDIR);
532 inode->i_nlink = 2;
533 BUFFER_TRACE(dir_block, "call ext4_journal_dirty_metadata");
534 ext4_journal_dirty_metadata(handle, dir_block);
535 - brelse (dir_block);
536 + brelse(dir_block);
537 ext4_mark_inode_dirty(handle, inode);
538 - err = ext4_add_entry (handle, dentry, inode);
539 + err = ext4_add_entry(handle, dentry, inode);
540 if (err) {
541 out_clear_inode:
542 clear_nlink(inode);
543 ext4_mark_inode_dirty(handle, inode);
544 - iput (inode);
545 + iput(inode);
546 goto out_stop;
547 }
548 ext4_inc_count(handle, dir);
549 @@ -1856,17 +1860,17 @@ out_stop:
550 /*
551 * routine to check that the specified directory is empty (for rmdir)
552 */
553 -static int empty_dir (struct inode * inode)
554 +static int empty_dir(struct inode *inode)
555 {
556 unsigned long offset;
557 - struct buffer_head * bh;
558 - struct ext4_dir_entry_2 * de, * de1;
559 - struct super_block * sb;
560 + struct buffer_head *bh;
561 + struct ext4_dir_entry_2 *de, *de1;
562 + struct super_block *sb;
563 int err = 0;
565 sb = inode->i_sb;
566 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2) ||
567 - !(bh = ext4_bread (NULL, inode, 0, 0, &err))) {
568 + !(bh = ext4_bread(NULL, inode, 0, 0, &err))) {
569 if (err)
570 ext4_error(inode->i_sb, __func__,
571 "error %d reading directory #%lu offset 0",
572 @@ -1881,23 +1885,23 @@ static int empty_dir (struct inode * inode)
573 de1 = ext4_next_entry(de);
574 if (le32_to_cpu(de->inode) != inode->i_ino ||
575 !le32_to_cpu(de1->inode) ||
576 - strcmp (".", de->name) ||
577 - strcmp ("..", de1->name)) {
578 - ext4_warning (inode->i_sb, "empty_dir",
579 - "bad directory (dir #%lu) - no `.' or `..'",
580 - inode->i_ino);
581 - brelse (bh);
582 + strcmp(".", de->name) ||
583 + strcmp("..", de1->name)) {
584 + ext4_warning(inode->i_sb, "empty_dir",
585 + "bad directory (dir #%lu) - no `.' or `..'",
586 + inode->i_ino);
587 + brelse(bh);
588 return 1;
589 }
590 offset = ext4_rec_len_from_disk(de->rec_len) +
591 ext4_rec_len_from_disk(de1->rec_len);
592 de = ext4_next_entry(de1);
593 - while (offset < inode->i_size ) {
594 + while (offset < inode->i_size) {
595 if (!bh ||
596 (void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
597 err = 0;
598 - brelse (bh);
599 - bh = ext4_bread (NULL, inode,
600 + brelse(bh);
601 + bh = ext4_bread(NULL, inode,
602 offset >> EXT4_BLOCK_SIZE_BITS(sb), 0, &err);
603 if (!bh) {
604 if (err)
605 @@ -1917,13 +1921,13 @@ static int empty_dir (struct inode * inode)
606 continue;
607 }
608 if (le32_to_cpu(de->inode)) {
609 - brelse (bh);
610 + brelse(bh);
611 return 0;
612 }
613 offset += ext4_rec_len_from_disk(de->rec_len);
614 de = ext4_next_entry(de);
615 }
616 - brelse (bh);
617 + brelse(bh);
618 return 1;
619 }
621 @@ -1954,8 +1958,8 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
622 * ->i_nlink. For, say it, character device. Not a regular file,
623 * not a directory, not a symlink and ->i_nlink > 0.
624 */
625 - J_ASSERT ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
626 - S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
627 + J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
628 + S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
630 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
631 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
632 @@ -2069,12 +2073,12 @@ out_brelse:
633 goto out_err;
634 }
636 -static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
637 +static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
638 {
639 int retval;
640 - struct inode * inode;
641 - struct buffer_head * bh;
642 - struct ext4_dir_entry_2 * de;
643 + struct inode *inode;
644 + struct buffer_head *bh;
645 + struct ext4_dir_entry_2 *de;
646 handle_t *handle;
648 /* Initialize quotas before so that eventual writes go in
649 @@ -2085,7 +2089,7 @@ static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
650 return PTR_ERR(handle);
652 retval = -ENOENT;
653 - bh = ext4_find_entry (dentry, &de);
654 + bh = ext4_find_entry(dentry, &de);
655 if (!bh)
656 goto end_rmdir;
658 @@ -2099,16 +2103,16 @@ static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
659 goto end_rmdir;
661 retval = -ENOTEMPTY;
662 - if (!empty_dir (inode))
663 + if (!empty_dir(inode))
664 goto end_rmdir;
666 retval = ext4_delete_entry(handle, dir, de, bh);
667 if (retval)
668 goto end_rmdir;
669 if (!EXT4_DIR_LINK_EMPTY(inode))
670 - ext4_warning (inode->i_sb, "ext4_rmdir",
671 - "empty directory has too many links (%d)",
672 - inode->i_nlink);
673 + ext4_warning(inode->i_sb, "ext4_rmdir",
674 + "empty directory has too many links (%d)",
675 + inode->i_nlink);
676 inode->i_version++;
677 clear_nlink(inode);
678 /* There's no need to set i_disksize: the fact that i_nlink is
679 @@ -2124,16 +2128,16 @@ static int ext4_rmdir (struct inode * dir, struct dentry *dentry)
681 end_rmdir:
682 ext4_journal_stop(handle);
683 - brelse (bh);
684 + brelse(bh);
685 return retval;
686 }
688 -static int ext4_unlink(struct inode * dir, struct dentry *dentry)
689 +static int ext4_unlink(struct inode *dir, struct dentry *dentry)
690 {
691 int retval;
692 - struct inode * inode;
693 - struct buffer_head * bh;
694 - struct ext4_dir_entry_2 * de;
695 + struct inode *inode;
696 + struct buffer_head *bh;
697 + struct ext4_dir_entry_2 *de;
698 handle_t *handle;
700 /* Initialize quotas before so that eventual writes go
701 @@ -2147,7 +2151,7 @@ static int ext4_unlink(struct inode * dir, struct dentry *dentry)
702 handle->h_sync = 1;
704 retval = -ENOENT;
705 - bh = ext4_find_entry (dentry, &de);
706 + bh = ext4_find_entry(dentry, &de);
707 if (!bh)
708 goto end_unlink;
710 @@ -2158,9 +2162,9 @@ static int ext4_unlink(struct inode * dir, struct dentry *dentry)
711 goto end_unlink;
713 if (!inode->i_nlink) {
714 - ext4_warning (inode->i_sb, "ext4_unlink",
715 - "Deleting nonexistent file (%lu), %d",
716 - inode->i_ino, inode->i_nlink);
717 + ext4_warning(inode->i_sb, "ext4_unlink",
718 + "Deleting nonexistent file (%lu), %d",
719 + inode->i_ino, inode->i_nlink);
720 inode->i_nlink = 1;
721 }
722 retval = ext4_delete_entry(handle, dir, de, bh);
723 @@ -2178,15 +2182,15 @@ static int ext4_unlink(struct inode * dir, struct dentry *dentry)
725 end_unlink:
726 ext4_journal_stop(handle);
727 - brelse (bh);
728 + brelse(bh);
729 return retval;
730 }
732 -static int ext4_symlink (struct inode * dir,
733 - struct dentry *dentry, const char * symname)
734 +static int ext4_symlink(struct inode *dir,
735 + struct dentry *dentry, const char *symname)
736 {
737 handle_t *handle;
738 - struct inode * inode;
739 + struct inode *inode;
740 int l, err, retries = 0;
742 l = strlen(symname)+1;
743 @@ -2203,12 +2207,12 @@ retry:
744 if (IS_DIRSYNC(dir))
745 handle->h_sync = 1;
747 - inode = ext4_new_inode (handle, dir, S_IFLNK|S_IRWXUGO);
748 + inode = ext4_new_inode(handle, dir, S_IFLNK|S_IRWXUGO);
749 err = PTR_ERR(inode);
750 if (IS_ERR(inode))
751 goto out_stop;
753 - if (l > sizeof (EXT4_I(inode)->i_data)) {
754 + if (l > sizeof(EXT4_I(inode)->i_data)) {
755 inode->i_op = &ext4_symlink_inode_operations;
756 ext4_set_aops(inode);
757 /*
758 @@ -2221,14 +2225,14 @@ retry:
759 if (err) {
760 clear_nlink(inode);
761 ext4_mark_inode_dirty(handle, inode);
762 - iput (inode);
763 + iput(inode);
764 goto out_stop;
765 }
766 } else {
767 /* clear the extent format for fast symlink */
768 EXT4_I(inode)->i_flags &= ~EXT4_EXTENTS_FL;
769 inode->i_op = &ext4_fast_symlink_inode_operations;
770 - memcpy((char*)&EXT4_I(inode)->i_data,symname,l);
771 + memcpy((char *)&EXT4_I(inode)->i_data, symname, l);
772 inode->i_size = l-1;
773 }
774 EXT4_I(inode)->i_disksize = inode->i_size;
775 @@ -2240,8 +2244,8 @@ out_stop:
776 return err;
777 }
779 -static int ext4_link (struct dentry * old_dentry,
780 - struct inode * dir, struct dentry *dentry)
781 +static int ext4_link(struct dentry *old_dentry,
782 + struct inode *dir, struct dentry *dentry)
783 {
784 handle_t *handle;
785 struct inode *inode = old_dentry->d_inode;
786 @@ -2284,13 +2288,13 @@ retry:
787 * Anybody can rename anything with this: the permission checks are left to the
788 * higher-level routines.
789 */
790 -static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
791 - struct inode * new_dir,struct dentry *new_dentry)
792 +static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
793 + struct inode *new_dir, struct dentry *new_dentry)
794 {
795 handle_t *handle;
796 - struct inode * old_inode, * new_inode;
797 - struct buffer_head * old_bh, * new_bh, * dir_bh;
798 - struct ext4_dir_entry_2 * old_de, * new_de;
799 + struct inode *old_inode, *new_inode;
800 + struct buffer_head *old_bh, *new_bh, *dir_bh;
801 + struct ext4_dir_entry_2 *old_de, *new_de;
802 int retval;
804 old_bh = new_bh = dir_bh = NULL;
805 @@ -2308,7 +2312,7 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
806 if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
807 handle->h_sync = 1;
809 - old_bh = ext4_find_entry (old_dentry, &old_de);
810 + old_bh = ext4_find_entry(old_dentry, &old_de);
811 /*
812 * Check for inode number is _not_ due to possible IO errors.
813 * We might rmdir the source, keep it as pwd of some process
814 @@ -2321,32 +2325,32 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
815 goto end_rename;
817 new_inode = new_dentry->d_inode;
818 - new_bh = ext4_find_entry (new_dentry, &new_de);
819 + new_bh = ext4_find_entry(new_dentry, &new_de);
820 if (new_bh) {
821 if (!new_inode) {
822 - brelse (new_bh);
823 + brelse(new_bh);
824 new_bh = NULL;
825 }
826 }
827 if (S_ISDIR(old_inode->i_mode)) {
828 if (new_inode) {
829 retval = -ENOTEMPTY;
830 - if (!empty_dir (new_inode))
831 + if (!empty_dir(new_inode))
832 goto end_rename;
833 }
834 retval = -EIO;
835 - dir_bh = ext4_bread (handle, old_inode, 0, 0, &retval);
836 + dir_bh = ext4_bread(handle, old_inode, 0, 0, &retval);
837 if (!dir_bh)
838 goto end_rename;
839 if (le32_to_cpu(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino)
840 goto end_rename;
841 retval = -EMLINK;
842 - if (!new_inode && new_dir!=old_dir &&
843 + if (!new_inode && new_dir != old_dir &&
844 new_dir->i_nlink >= EXT4_LINK_MAX)
845 goto end_rename;
846 }
847 if (!new_bh) {
848 - retval = ext4_add_entry (handle, new_dentry, old_inode);
849 + retval = ext4_add_entry(handle, new_dentry, old_inode);
850 if (retval)
851 goto end_rename;
852 } else {
853 @@ -2433,9 +2437,9 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
854 retval = 0;
856 end_rename:
857 - brelse (dir_bh);
858 - brelse (old_bh);
859 - brelse (new_bh);
860 + brelse(dir_bh);
861 + brelse(old_bh);
862 + brelse(new_bh);
863 ext4_journal_stop(handle);
864 return retval;
865 }
866 diff --git a/fs/ext4/super.c b/fs/ext4/super.c
867 index 09e3c56..a76731b 100644
868 --- a/fs/ext4/super.c
869 +++ b/fs/ext4/super.c
870 @@ -653,7 +653,7 @@ static inline void ext4_show_quota_options(struct seq_file *seq,
872 if (sbi->s_jquota_fmt)
873 seq_printf(seq, ",jqfmt=%s",
874 - (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold": "vfsv0");
875 + (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold" : "vfsv0");
877 if (sbi->s_qf_names[USRQUOTA])
878 seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
879 @@ -980,7 +980,7 @@ static ext4_fsblk_t get_sb_block(void **data)
880 /*todo: use simple_strtoll with >32bit ext4 */
881 sb_block = simple_strtoul(options, &options, 0);
882 if (*options && *options != ',') {
883 - printk("EXT4-fs: Invalid sb specification: %s\n",
884 + printk(KERN_ERR "EXT4-fs: Invalid sb specification: %s\n",
885 (char *) *data);
886 return 1;
887 }
888 @@ -1081,7 +1081,8 @@ static int parse_options(char *options, struct super_block *sb,
889 #else
890 case Opt_user_xattr:
891 case Opt_nouser_xattr:
892 - printk("EXT4 (no)user_xattr options not supported\n");
893 + printk(KERN_ERR "EXT4 (no)user_xattr options "
894 + "not supported\n");
895 break;
896 #endif
897 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
898 @@ -1094,7 +1095,8 @@ static int parse_options(char *options, struct super_block *sb,
899 #else
900 case Opt_acl:
901 case Opt_noacl:
902 - printk("EXT4 (no)acl options not supported\n");
903 + printk(KERN_ERR "EXT4 (no)acl options "
904 + "not supported\n");
905 break;
906 #endif
907 case Opt_reservation:
908 @@ -1188,8 +1190,8 @@ set_qf_name:
909 sb_any_quota_suspended(sb)) &&
910 !sbi->s_qf_names[qtype]) {
911 printk(KERN_ERR
912 - "EXT4-fs: Cannot change journaled "
913 - "quota options when quota turned on.\n");
914 + "EXT4-fs: Cannot change journaled "
915 + "quota options when quota turned on.\n");
916 return 0;
917 }
918 qname = match_strdup(&args[0]);
919 @@ -1472,14 +1474,14 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
920 EXT4_INODES_PER_GROUP(sb),
921 sbi->s_mount_opt);
923 - printk(KERN_INFO "EXT4 FS on %s, ", sb->s_id);
924 if (EXT4_SB(sb)->s_journal->j_inode == NULL) {
925 char b[BDEVNAME_SIZE];
927 - printk("external journal on %s\n",
928 - bdevname(EXT4_SB(sb)->s_journal->j_dev, b));
929 + printk(KERN_INFO "EXT4 FS on %s, external journal on %s\n",
930 + sb->s_id, bdevname(EXT4_SB(sb)->s_journal->j_dev, b));
931 } else {
932 - printk("internal journal\n");
933 + printk(KERN_INFO "EXT4 FS on %s, internal journal\n",
934 + sb->s_id);
935 }
936 return res;
937 }
938 @@ -1583,7 +1585,7 @@ static int ext4_check_descriptors(struct super_block *sb)
939 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
940 flexbg_flag = 1;
942 - ext4_debug ("Checking group descriptors");
943 + ext4_debug("Checking group descriptors");
945 for (i = 0; i < sbi->s_groups_count; i++) {
946 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
947 @@ -1713,9 +1715,9 @@ static void ext4_orphan_cleanup(struct super_block *sb,
948 DQUOT_INIT(inode);
949 if (inode->i_nlink) {
950 printk(KERN_DEBUG
951 - "%s: truncating inode %lu to %Ld bytes\n",
952 + "%s: truncating inode %lu to %lld bytes\n",
953 __func__, inode->i_ino, inode->i_size);
954 - jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
955 + jbd_debug(2, "truncating inode %lu to %lld bytes\n",
956 inode->i_ino, inode->i_size);
957 ext4_truncate(inode);
958 nr_truncates++;
959 @@ -2551,7 +2553,7 @@ static journal_t *ext4_get_journal(struct super_block *sb,
960 return NULL;
961 }
963 - jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
964 + jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
965 journal_inode, journal_inode->i_size);
966 if (!S_ISREG(journal_inode->i_mode)) {
967 printk(KERN_ERR "EXT4-fs: invalid journal inode.\n");
968 @@ -3430,7 +3432,7 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type,
969 handle_t *handle = journal_current_handle();
971 if (!handle) {
972 - printk(KERN_WARNING "EXT4-fs: Quota write (off=%Lu, len=%Lu)"
973 + printk(KERN_WARNING "EXT4-fs: Quota write (off=%llu, len=%llu)"
974 " cancelled because transaction is not started.\n",
975 (unsigned long long)off, (unsigned long long)len);
976 return -EIO;