1 diff -urpN linux-stage.orig/fs/ext4/balloc.c linux-stage/fs/ext4/balloc.c
2 --- linux-stage.orig/fs/ext4/balloc.c 2012-02-16 07:54:55.000000000 -0500
3 +++ linux-stage/fs/ext4/balloc.c 2012-02-16 08:05:47.000000000 -0500
4 @@ -97,7 +97,7 @@ unsigned ext4_init_block_bitmap(struct s
5 /* If checksum is bad mark all blocks used to prevent allocation
6 * essentially implementing a per-group read-only flag. */
7 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
8 - ext4_error(sb, __func__,
10 "Checksum bad for group %u", block_group);
11 ext4_free_blks_set(sb, gdp, 0);
12 ext4_free_inodes_set(sb, gdp, 0);
13 @@ -207,10 +207,8 @@ struct ext4_group_desc * ext4_get_group_
14 struct ext4_sb_info *sbi = EXT4_SB(sb);
16 if (block_group >= ngroups) {
17 - ext4_error(sb, "ext4_get_group_desc",
18 - "block_group >= groups_count - "
19 - "block_group = %u, groups_count = %u",
20 - block_group, ngroups);
21 + ext4_error(sb, "block_group >= groups_count - block_group = %u,"
22 + " groups_count = %u", block_group, ngroups);
26 @@ -218,8 +216,7 @@ struct ext4_group_desc * ext4_get_group_
27 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
28 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
29 if (!sbi->s_group_desc[group_desc]) {
30 - ext4_error(sb, "ext4_get_group_desc",
31 - "Group descriptor not loaded - "
32 + ext4_error(sb, "Group descriptor not loaded - "
33 "block_group = %u, group_desc = %u, desc = %u",
34 block_group, group_desc, offset);
36 @@ -280,7 +277,7 @@ static int ext4_valid_block_bitmap(struc
40 - ext4_error(sb, __func__,
42 "Invalid block bitmap - "
43 "block_group = %d, block = %llu",
44 block_group, bitmap_blk);
45 @@ -309,7 +306,7 @@ ext4_read_block_bitmap(struct super_bloc
46 bitmap_blk = ext4_block_bitmap(sb, desc);
47 bh = sb_getblk(sb, bitmap_blk);
49 - ext4_error(sb, __func__,
51 "Cannot read block bitmap - "
52 "block_group = %u, block_bitmap = %llu",
53 block_group, bitmap_blk);
54 @@ -352,7 +349,7 @@ ext4_read_block_bitmap(struct super_bloc
55 set_bitmap_uptodate(bh);
56 if (bh_submit_read(bh) < 0) {
58 - ext4_error(sb, __func__,
60 "Cannot read block bitmap - "
61 "block_group = %u, block_bitmap = %llu",
62 block_group, bitmap_blk);
63 @@ -417,7 +414,7 @@ void ext4_add_groupblocks(handle_t *hand
64 in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
65 in_range(block + count - 1, ext4_inode_table(sb, desc),
66 sbi->s_itb_per_group)) {
67 - ext4_error(sb, __func__,
69 "Adding blocks in system zones - "
70 "Block = %llu, count = %lu",
72 @@ -451,7 +448,7 @@ void ext4_add_groupblocks(handle_t *hand
73 BUFFER_TRACE(bitmap_bh, "clear bit");
74 if (!ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group),
75 bit + i, bitmap_bh->b_data)) {
76 - ext4_error(sb, __func__,
78 "bit already cleared for block %llu",
79 (ext4_fsblk_t)(block + i));
80 BUFFER_TRACE(bitmap_bh, "bit already cleared");
81 diff -urpN linux-stage.orig/fs/ext4/dir.c linux-stage/fs/ext4/dir.c
82 --- linux-stage.orig/fs/ext4/dir.c 2012-02-16 07:54:55.000000000 -0500
83 +++ linux-stage/fs/ext4/dir.c 2012-02-16 08:05:47.000000000 -0500
84 @@ -70,28 +70,29 @@ int ext4_check_dir_entry(const char *fun
85 const int rlen = ext4_rec_len_from_disk(de->rec_len,
86 dir->i_sb->s_blocksize);
88 - if (rlen < EXT4_DIR_REC_LEN(1))
89 + if (unlikely(rlen < EXT4_DIR_REC_LEN(1)))
90 error_msg = "rec_len is smaller than minimal";
91 - else if (rlen % 4 != 0)
92 + else if (unlikely(rlen % 4 != 0))
93 error_msg = "rec_len % 4 != 0";
94 - else if (rlen < EXT4_DIR_REC_LEN(de->name_len))
95 + else if (unlikely(rlen < EXT4_DIR_REC_LEN(de->name_len)))
96 error_msg = "rec_len is too small for name_len";
97 - else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
98 + else if (unlikely(((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize))
99 error_msg = "directory entry across blocks";
100 - else if (le32_to_cpu(de->inode) >
101 - le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count))
102 + else if (unlikely(le32_to_cpu(de->inode) >
103 + le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count)))
104 error_msg = "inode out of bounds";
108 - if (error_msg != NULL)
109 - ext4_error(dir->i_sb, function,
110 - "bad entry in directory #%lu: %s - block=%llu"
111 - "offset=%u(%u), inode=%u, rec_len=%d, name_len=%d",
112 - dir->i_ino, error_msg,
113 - (unsigned long long) bh->b_blocknr,
114 - (unsigned) (offset%bh->b_size), offset,
115 - le32_to_cpu(de->inode),
116 - rlen, de->name_len);
117 - return error_msg == NULL ? 1 : 0;
118 + ext4_error(dir->i_sb,
119 + "bad entry in directory #%lu: %s - block=%llu"
120 + "offset=%u(%u), inode=%u, rec_len=%d, name_len=%d",
121 + dir->i_ino, error_msg,
122 + (unsigned long long) bh->b_blocknr,
123 + (unsigned) (offset%bh->b_size), offset,
124 + le32_to_cpu(de->inode),
125 + rlen, de->name_len);
129 static int ext4_readdir(struct file *filp,
130 @@ -152,7 +153,7 @@ static int ext4_readdir(struct file *fil
133 if (!dir_has_error) {
134 - ext4_error(sb, __func__, "directory #%lu "
135 + ext4_error(sb, "directory #%lu "
136 "contains a hole at offset %Lu",
138 (unsigned long long) filp->f_pos);
139 diff -urpN linux-stage.orig/fs/ext4/ext4_extents.h linux-stage/fs/ext4/ext4_extents.h
140 --- linux-stage.orig/fs/ext4/ext4_extents.h 2012-02-16 07:54:55.000000000 -0500
141 +++ linux-stage/fs/ext4/ext4_extents.h 2012-02-16 08:05:47.000000000 -0500
142 @@ -138,7 +138,7 @@ typedef int (*ext_prepare_callback)(stru
145 /* Maximum logical block in a file; ext4_extent's ee_block is __le32 */
146 -#define EXT_MAX_BLOCK 0xffffffff
147 +#define EXT_MAX_BLOCKS 0xffffffff
150 * EXT_INIT_MAX_LEN is the maximum number of blocks we can have in an
151 diff -urpN linux-stage.orig/fs/ext4/ext4.h linux-stage/fs/ext4/ext4.h
152 --- linux-stage.orig/fs/ext4/ext4.h 2012-02-16 07:54:55.000000000 -0500
153 +++ linux-stage/fs/ext4/ext4.h 2012-02-16 08:06:56.000000000 -0500
155 #include <linux/quota.h>
156 #include <linux/rwsem.h>
157 #include <linux/rbtree.h>
158 +#include <linux/kernel.h>
159 #include <linux/seqlock.h>
160 #include <linux/mutex.h>
161 #include <linux/timer.h>
163 #define ext4_debug(f, a...) do {} while (0)
166 +#define EXT4_ERROR_INODE(inode, fmt, a...) \
167 + ext4_error_inode(__func__, (inode), (fmt), ## a);
169 +#define EXT4_ERROR_FILE(file, fmt, a...) \
170 + ext4_error_file(__func__, (file), (fmt), ## a);
172 /* data type for block offset of block group */
173 typedef int ext4_grpblk_t;
175 @@ -1110,6 +1117,9 @@ struct ext4_sb_info {
177 /* workqueue for dio unwritten */
178 struct workqueue_struct *dio_unwritten_wq;
180 + /* Lazy inode table initialization info */
181 + struct ext4_li_request *s_li_request;
184 static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
185 @@ -1431,6 +1441,23 @@ void ext4_get_group_no_and_offset(struct
186 extern struct proc_dir_entry *ext4_proc_root;
189 + * Timeout and state flag for lazy initialization inode thread.
191 +#define EXT4_DEF_LI_WAIT_MULT 10
192 +#define EXT4_DEF_LI_MAX_START_DELAY 5
193 +#define EXT4_LAZYINIT_QUIT 0x0001
194 +#define EXT4_LAZYINIT_RUNNING 0x0002
197 + * Lazy inode table initialization info
199 +struct ext4_lazy_init {
200 + unsigned long li_state;
201 + struct list_head li_request_list;
202 + struct mutex li_list_mtx;
206 * Function prototypes
209 @@ -1509,6 +1536,7 @@ extern struct buffer_head *ext4_read_ino
210 extern void mark_bitmap_end(int start_bit, int end_bit, char *bitmap);
213 +struct fstrim_range;
214 extern long ext4_mb_stats;
215 extern long ext4_mb_max_to_scan;
216 extern int ext4_mb_init(struct super_block *, int);
217 @@ -1526,6 +1554,8 @@ extern int ext4_mb_add_groupinfo(struct
218 extern int ext4_mb_get_buddy_cache_lock(struct super_block *, ext4_group_t);
219 extern void ext4_mb_put_buddy_cache_lock(struct super_block *,
221 +extern int ext4_trim_fs(struct super_block *, struct fstrim_range *);
224 int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
225 struct buffer_head *bh, ext4_fsblk_t blocknr);
226 @@ -1586,13 +1616,17 @@ extern int ext4_group_extend(struct supe
227 ext4_fsblk_t n_blocks_count);
230 -extern void ext4_error(struct super_block *, const char *, const char *, ...)
231 +extern void __ext4_error(struct super_block *, const char *, const char *, ...)
232 + __attribute__ ((format (printf, 3, 4)));
233 +#define ext4_error(sb, message...) __ext4_error(sb, __func__, ## message)
234 +extern void ext4_error_inode(const char *, struct inode *, const char *, ...)
235 __attribute__ ((format (printf, 3, 4)));
236 extern void __ext4_std_error(struct super_block *, const char *, int);
237 extern void ext4_abort(struct super_block *, const char *, const char *, ...)
238 __attribute__ ((format (printf, 3, 4)));
239 -extern void ext4_warning(struct super_block *, const char *, const char *, ...)
240 +extern void __ext4_warning(struct super_block *, const char *, const char *, ...)
241 __attribute__ ((format (printf, 3, 4)));
242 +#define ext4_warning(sb, message...) __ext4_warning(sb, __func__, ## message)
243 extern void ext4_msg(struct super_block *, const char *, const char *, ...)
244 __attribute__ ((format (printf, 3, 4)));
245 extern void ext4_grp_locked_error(struct super_block *, ext4_group_t,
246 diff -urpN linux-stage.orig/fs/ext4/ext4_jbd2.c linux-stage/fs/ext4/ext4_jbd2.c
247 --- linux-stage.orig/fs/ext4/ext4_jbd2.c 2012-02-16 07:54:55.000000000 -0500
248 +++ linux-stage/fs/ext4/ext4_jbd2.c 2012-02-16 08:05:47.000000000 -0500
249 @@ -96,7 +96,7 @@ int __ext4_handle_dirty_metadata(const c
250 if (inode && inode_needs_sync(inode)) {
251 sync_dirty_buffer(bh);
252 if (buffer_req(bh) && !buffer_uptodate(bh)) {
253 - ext4_error(inode->i_sb, __func__,
254 + ext4_error(inode->i_sb,
255 "IO error syncing inode, "
256 "inode=%lu, block=%llu",
258 diff -urpN linux-stage.orig/fs/ext4/extents.c linux-stage/fs/ext4/extents.c
259 --- linux-stage.orig/fs/ext4/extents.c 2012-02-16 07:54:55.000000000 -0500
260 +++ linux-stage/fs/ext4/extents.c 2012-02-16 08:05:47.000000000 -0500
261 @@ -437,7 +437,7 @@ static int __ext4_ext_check(const char *
265 - ext4_error(inode->i_sb, function,
266 + ext4_error(inode->i_sb,
267 "bad header/extent in inode #%lu: %s - magic %x, "
268 "entries %u, max %u(%u), depth %u(%u)",
269 inode->i_ino, error_msg, le16_to_cpu(eh->eh_magic),
270 @@ -1329,7 +1329,7 @@ got_index:
273 * ext4_ext_next_allocated_block:
274 - * returns allocated block in subsequent extent or EXT_MAX_BLOCK.
275 + * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
276 * NOTE: it considers block number from index entry as
277 * allocated block. Thus, index entries have to be consistent
279 @@ -1343,7 +1343,7 @@ ext4_ext_next_allocated_block(struct ext
280 depth = path->p_depth;
282 if (depth == 0 && path->p_ext == NULL)
283 - return EXT_MAX_BLOCK;
284 + return EXT_MAX_BLOCKS;
287 if (depth == path->p_depth) {
288 @@ -1360,12 +1360,12 @@ ext4_ext_next_allocated_block(struct ext
292 - return EXT_MAX_BLOCK;
293 + return EXT_MAX_BLOCKS;
297 * ext4_ext_next_leaf_block:
298 - * returns first allocated block from next leaf or EXT_MAX_BLOCK
299 + * returns first allocated block from next leaf or EXT_MAX_BLOCKS
301 static ext4_lblk_t ext4_ext_next_leaf_block(struct inode *inode,
302 struct ext4_ext_path *path)
303 @@ -1377,7 +1377,7 @@ static ext4_lblk_t ext4_ext_next_leaf_bl
305 /* zero-tree has no leaf blocks at all */
307 - return EXT_MAX_BLOCK;
308 + return EXT_MAX_BLOCKS;
310 /* go to index block */
312 @@ -1390,7 +1390,7 @@ static ext4_lblk_t ext4_ext_next_leaf_bl
316 - return EXT_MAX_BLOCK;
317 + return EXT_MAX_BLOCKS;
321 @@ -1534,7 +1534,7 @@ int ext4_ext_try_to_merge(struct inode *
323 WARN_ON(eh->eh_entries == 0);
325 - ext4_error(inode->i_sb, "ext4_ext_try_to_merge",
326 + ext4_error(inode->i_sb,
327 "inode#%lu, eh->eh_entries = 0!", inode->i_ino);
330 @@ -1570,13 +1570,13 @@ unsigned int ext4_ext_check_overlap(stru
333 b2 = ext4_ext_next_allocated_block(path);
334 - if (b2 == EXT_MAX_BLOCK)
335 + if (b2 == EXT_MAX_BLOCKS)
339 /* check for wrap through zero on extent logical start block*/
340 if (b1 + len1 < b1) {
341 - len1 = EXT_MAX_BLOCK - b1;
342 + len1 = EXT_MAX_BLOCKS - b1;
343 newext->ee_len = cpu_to_le16(len1);
346 @@ -1652,7 +1652,7 @@ repeat:
347 fex = EXT_LAST_EXTENT(eh);
348 next = ext4_ext_next_leaf_block(inode, path);
349 if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block)
350 - && next != EXT_MAX_BLOCK) {
351 + && next != EXT_MAX_BLOCKS) {
352 ext_debug("next leaf block - %d\n", next);
353 BUG_ON(npath != NULL);
354 npath = ext4_ext_find_extent(inode, next, NULL);
355 @@ -1771,7 +1771,7 @@ int ext4_ext_walk_space(struct inode *in
356 BUG_ON(func == NULL);
357 BUG_ON(inode == NULL);
359 - while (block < last && block != EXT_MAX_BLOCK) {
360 + while (block < last && block != EXT_MAX_BLOCKS) {
362 /* find extent for this block */
363 down_read(&EXT4_I(inode)->i_data_sem);
364 @@ -1784,7 +1784,11 @@ int ext4_ext_walk_space(struct inode *in
367 depth = ext_depth(inode);
368 - BUG_ON(path[depth].p_hdr == NULL);
369 + if (unlikely(path[depth].p_hdr == NULL)) {
370 + EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
374 ex = path[depth].p_ext;
375 next = ext4_ext_next_allocated_block(path);
377 @@ -1835,7 +1839,11 @@ int ext4_ext_walk_space(struct inode *in
378 cbex.ec_type = EXT4_EXT_CACHE_EXTENT;
381 - BUG_ON(cbex.ec_len == 0);
382 + if (unlikely(cbex.ec_len == 0)) {
383 + EXT4_ERROR_INODE(inode, "cbex.ec_len == 0");
387 err = func(inode, path, &cbex, ex, cbdata);
388 ext4_ext_drop_refs(path);
390 @@ -1899,7 +1907,7 @@ ext4_ext_put_gap_in_cache(struct inode *
392 /* there is no extent yet, so gap is [0;-] */
394 - len = EXT_MAX_BLOCK;
395 + len = EXT_MAX_BLOCKS;
396 ext_debug("cache gap(whole file):");
397 } else if (block < le32_to_cpu(ex->ee_block)) {
399 @@ -2144,8 +2152,8 @@ ext4_ext_rm_leaf(handle_t *handle, struc
400 path[depth].p_ext = ex;
402 a = ex_ee_block > start ? ex_ee_block : start;
403 - b = ex_ee_block + ex_ee_len - 1 < EXT_MAX_BLOCK ?
404 - ex_ee_block + ex_ee_len - 1 : EXT_MAX_BLOCK;
405 + b = ex_ee_block + ex_ee_len - 1 < EXT_MAX_BLOCKS ?
406 + ex_ee_block + ex_ee_len - 1 : EXT_MAX_BLOCKS;
408 ext_debug(" border %u:%u\n", a, b);
410 @@ -3284,7 +3292,7 @@ int ext4_ext_get_blocks(handle_t *handle
411 * this is why assert can't be put in ext4_ext_find_extent()
413 if (path[depth].p_ext == NULL && depth != 0) {
414 - ext4_error(inode->i_sb, __func__, "bad extent address "
415 + ext4_error(inode->i_sb, "bad extent address "
416 "inode: %lu, iblock: %lu, depth: %d",
417 inode->i_ino, (unsigned long) iblock, depth);
419 @@ -3415,7 +3423,7 @@ int ext4_ext_get_blocks(handle_t *handle
421 if (unlikely(ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS))) {
422 if (unlikely(!eh->eh_entries)) {
423 - ext4_error(inode->i_sb, __func__,
424 + ext4_error(inode->i_sb,
425 "inode#%lu, eh->eh_entries = 0 and "
426 "EOFBLOCKS_FL set", inode->i_ino);
428 @@ -3782,15 +3790,15 @@ static int ext4_ext_fiemap_cb(struct ino
429 flags |= FIEMAP_EXTENT_UNWRITTEN;
432 - * If this extent reaches EXT_MAX_BLOCK, it must be last.
433 + * If this extent reaches EXT_MAX_BLOCKS, it must be last.
435 - * Or if ext4_ext_next_allocated_block is EXT_MAX_BLOCK,
436 + * Or if ext4_ext_next_allocated_block is EXT_MAX_BLOCKS,
437 * this also indicates no more allocated blocks.
439 - * XXX this might miss a single-block extent at EXT_MAX_BLOCK
440 + * XXX this might miss a single-block extent at EXT_MAX_BLOCKS
442 - if (ext4_ext_next_allocated_block(path) == EXT_MAX_BLOCK ||
443 - newex->ec_block + newex->ec_len - 1 == EXT_MAX_BLOCK) {
444 + if (ext4_ext_next_allocated_block(path) == EXT_MAX_BLOCKS ||
445 + newex->ec_block + newex->ec_len - 1 == EXT_MAX_BLOCKS) {
446 loff_t size = i_size_read(inode);
447 loff_t bs = EXT4_BLOCK_SIZE(inode->i_sb);
449 @@ -3870,8 +3878,8 @@ int ext4_fiemap(struct inode *inode, str
451 start_blk = start >> inode->i_sb->s_blocksize_bits;
452 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
453 - if (last_blk >= EXT_MAX_BLOCK)
454 - last_blk = EXT_MAX_BLOCK-1;
455 + if (last_blk >= EXT_MAX_BLOCKS)
456 + last_blk = EXT_MAX_BLOCKS-1;
457 len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1;
460 diff -urpN linux-stage.orig/fs/ext4/ialloc.c linux-stage/fs/ext4/ialloc.c
461 --- linux-stage.orig/fs/ext4/ialloc.c 2012-02-16 07:54:55.000000000 -0500
462 +++ linux-stage/fs/ext4/ialloc.c 2012-02-16 08:05:47.000000000 -0500
463 @@ -76,7 +76,7 @@ unsigned ext4_init_inode_bitmap(struct s
464 /* If checksum is bad mark all blocks and inodes use to prevent
465 * allocation, essentially implementing a per-group read-only flag. */
466 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
467 - ext4_error(sb, __func__, "Checksum bad for group %u",
468 + ext4_error(sb, "Checksum bad for group %u",
470 ext4_free_blks_set(sb, gdp, 0);
471 ext4_free_inodes_set(sb, gdp, 0);
472 @@ -111,7 +111,7 @@ ext4_read_inode_bitmap(struct super_bloc
473 bitmap_blk = ext4_inode_bitmap(sb, desc);
474 bh = sb_getblk(sb, bitmap_blk);
476 - ext4_error(sb, __func__,
478 "Cannot read inode bitmap - "
479 "block_group = %u, inode_bitmap = %llu",
480 block_group, bitmap_blk);
481 @@ -153,7 +153,7 @@ ext4_read_inode_bitmap(struct super_bloc
482 set_bitmap_uptodate(bh);
483 if (bh_submit_read(bh) < 0) {
485 - ext4_error(sb, __func__,
487 "Cannot read inode bitmap - "
488 "block_group = %u, inode_bitmap = %llu",
489 block_group, bitmap_blk);
490 @@ -230,8 +230,7 @@ void ext4_free_inode(handle_t *handle, s
492 es = EXT4_SB(sb)->s_es;
493 if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
494 - ext4_error(sb, "ext4_free_inode",
495 - "reserved or nonexistent inode %lu", ino);
496 + ext4_error(sb, "reserved or nonexistent inode %lu", ino);
499 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
500 @@ -286,11 +285,10 @@ out:
504 - ext4_error(sb, "ext4_free_inode",
505 - "bit already cleared for inode %lu", ino);
506 + ext4_error(sb, "bit already cleared for inode %lu", ino);
511 ext4_std_error(sb, fatal);
514 @@ -730,7 +728,7 @@ static int ext4_claim_inode(struct super
515 if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
516 ino > EXT4_INODES_PER_GROUP(sb)) {
517 ext4_unlock_group(sb, group);
518 - ext4_error(sb, __func__,
520 "reserved inode or inode > inodes count - "
521 "block_group = %u, inode=%lu", group,
522 ino + group * EXT4_INODES_PER_GROUP(sb));
523 @@ -1094,7 +1092,7 @@ struct inode *ext4_orphan_get(struct sup
525 /* Error cases - e2fsck has already cleaned up for us */
527 - ext4_warning(sb, __func__,
529 "bad orphan ino %lu! e2fsck was run?", ino);
532 @@ -1103,7 +1101,7 @@ struct inode *ext4_orphan_get(struct sup
533 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
534 bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
536 - ext4_warning(sb, __func__,
538 "inode bitmap error for orphan %lu", ino);
541 @@ -1136,7 +1134,7 @@ iget_failed:
542 err = PTR_ERR(inode);
545 - ext4_warning(sb, __func__,
547 "bad orphan inode %lu! e2fsck was run?", ino);
548 printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
549 bit, (unsigned long long)bitmap_bh->b_blocknr,
550 diff -urpN linux-stage.orig/fs/ext4/inode.c linux-stage/fs/ext4/inode.c
551 --- linux-stage.orig/fs/ext4/inode.c 2012-02-16 07:54:55.000000000 -0500
552 +++ linux-stage/fs/ext4/inode.c 2012-02-16 08:05:47.000000000 -0500
553 @@ -246,7 +246,7 @@ void ext4_delete_inode(struct inode *ino
555 err = ext4_mark_inode_dirty(handle, inode);
557 - ext4_warning(inode->i_sb, __func__,
558 + ext4_warning(inode->i_sb,
559 "couldn't mark inode dirty (err %d)", err);
562 @@ -264,7 +264,7 @@ void ext4_delete_inode(struct inode *ino
564 err = ext4_journal_restart(handle, 3);
566 - ext4_warning(inode->i_sb, __func__,
567 + ext4_warning(inode->i_sb,
568 "couldn't extend journal (err %d)", err);
570 ext4_journal_stop(handle);
571 @@ -375,8 +375,7 @@ static int ext4_block_to_path(struct ino
572 offsets[n++] = i_block & (ptrs - 1);
575 - ext4_warning(inode->i_sb, "ext4_block_to_path",
576 - "block %lu > max in inode %lu",
577 + ext4_warning(inode->i_sb, "block %lu > max in inode %lu",
578 i_block + direct_blocks +
579 indirect_blocks + double_blocks, inode->i_ino);
581 @@ -396,7 +395,7 @@ static int __ext4_check_blockref(const c
583 unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
585 - ext4_error(inode->i_sb, function,
586 + ext4_error(inode->i_sb,
587 "invalid block reference %u "
588 "in inode #%lu", blk, inode->i_ino);
590 @@ -1167,7 +1166,7 @@ static int check_block_validity(struct i
591 sector_t logical, sector_t phys, int len)
593 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), phys, len)) {
594 - ext4_error(inode->i_sb, msg,
595 + ext4_error(inode->i_sb,
596 "inode #%lu logical block %llu mapped to %llu "
597 "(size %d)", inode->i_ino,
598 (unsigned long long) logical,
599 @@ -4316,7 +4315,7 @@ static void ext4_free_data(handle_t *han
600 if ((EXT4_JOURNAL(inode) == NULL) || bh2jh(this_bh))
601 ext4_handle_dirty_metadata(handle, inode, this_bh);
603 - ext4_error(inode->i_sb, __func__,
604 + ext4_error(inode->i_sb,
605 "circular indirect block detected, "
606 "inode=%lu, block=%llu",
608 @@ -4364,7 +4363,7 @@ static void ext4_free_branches(handle_t
612 - ext4_error(inode->i_sb, "ext4_free_branches",
613 + ext4_error(inode->i_sb,
614 "Read failure, inode=%lu, block=%llu",
617 @@ -4680,9 +4679,8 @@ static int __ext4_get_inode_loc(struct i
619 bh = sb_getblk(sb, block);
621 - ext4_error(sb, "ext4_get_inode_loc", "unable to read "
622 - "inode block - inode=%lu, block=%llu",
623 - inode->i_ino, block);
624 + ext4_error(sb, "unable to read inode block - "
625 + "inode=%lu, block=%llu", inode->i_ino, block);
628 if (!buffer_uptodate(bh)) {
629 @@ -4780,7 +4778,7 @@ make_io:
630 submit_bh(READ_META, bh);
632 if (!buffer_uptodate(bh)) {
633 - ext4_error(sb, __func__,
635 "unable to read inode block - inode=%lu, "
636 "block=%llu", inode->i_ino, block);
638 @@ -4999,7 +4997,7 @@ struct inode *ext4_iget(struct super_blo
640 if (ei->i_file_acl &&
641 !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
642 - ext4_error(sb, __func__,
644 "bad extended attribute block %llu in inode #%lu",
645 ei->i_file_acl, inode->i_ino);
647 @@ -5046,7 +5044,7 @@ struct inode *ext4_iget(struct super_blo
648 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
651 - ext4_error(inode->i_sb, __func__,
652 + ext4_error(inode->i_sb,
653 "bogus i_mode (%o) for inode=%lu",
654 inode->i_mode, inode->i_ino);
656 @@ -5286,7 +5284,7 @@ int ext4_write_inode(struct inode *inode
658 sync_dirty_buffer(iloc.bh);
659 if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
660 - ext4_error(inode->i_sb, __func__,
661 + ext4_error(inode->i_sb,
662 "IO error syncing inode, "
663 "inode=%lu, block=%llu",
665 @@ -5707,7 +5705,7 @@ int ext4_mark_inode_dirty(handle_t *hand
666 EXT4_STATE_NO_EXPAND);
668 le16_to_cpu(sbi->s_es->s_mnt_count)) {
669 - ext4_warning(inode->i_sb, __func__,
670 + ext4_warning(inode->i_sb,
671 "Unable to expand inode %lu. Delete"
672 " some EAs or run e2fsck.",
674 diff -urpN linux-stage.orig/fs/ext4/mballoc.c linux-stage/fs/ext4/mballoc.c
675 --- linux-stage.orig/fs/ext4/mballoc.c 2012-02-16 07:54:55.000000000 -0500
676 +++ linux-stage/fs/ext4/mballoc.c 2012-02-16 08:05:47.000000000 -0500
677 @@ -862,8 +862,6 @@ static int ext4_mb_init_cache(struct pag
680 first_block = page->index * blocks_per_page;
681 - /* init the page */
682 - memset(page_address(page), 0xff, PAGE_CACHE_SIZE);
683 for (i = 0; i < blocks_per_page; i++) {
685 struct ext4_group_info *grinfo;
686 @@ -899,6 +897,8 @@ static int ext4_mb_init_cache(struct pag
687 * incore got set to the group block bitmap below
689 ext4_lock_group(sb, group);
690 + /* init the page */
691 + memset(data, 0xff, blocksize);
692 ext4_mb_generate_buddy(sb, data, incore, group);
693 ext4_unlock_group(sb, group);
695 @@ -1862,7 +1862,6 @@ void ext4_mb_scan_aligned(struct ext4_al
699 -/* This is now called BEFORE we load the buddy bitmap. */
700 static int ext4_mb_good_group(struct ext4_allocation_context *ac,
701 ext4_group_t group, int cr)
703 @@ -2162,6 +2161,11 @@ static void *ext4_mb_seq_groups_next(str
704 return (void *) ((unsigned long) group);
707 +static inline void ext4_mb_release_desc(struct ext4_buddy *e4b)
709 + ext4_mb_unload_buddy(e4b);
712 static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
714 struct super_block *sb = seq->private;
715 @@ -2193,7 +2197,7 @@ static int ext4_mb_seq_groups_show(struc
716 ext4_lock_group(sb, group);
717 memcpy(&sg, ext4_get_group_info(sb, group), i);
718 ext4_unlock_group(sb, group);
719 - ext4_mb_unload_buddy(&e4b);
720 + ext4_mb_release_desc(&e4b);
722 seq_printf(seq, "#%-5u: %-5u %-5u %-5u [", group, sg.info.bb_free,
723 sg.info.bb_fragments, sg.info.bb_first_free);
724 @@ -2562,6 +2566,17 @@ int ext4_mb_release(struct super_block *
728 +static inline int ext4_issue_discard(struct super_block *sb,
729 + ext4_group_t block_group, ext4_grpblk_t block, int count)
731 + ext4_fsblk_t discard_block;
733 + discard_block = block + ext4_group_first_block_no(sb, block_group);
734 + trace_ext4_discard_blocks(sb,
735 + (unsigned long long) discard_block, count);
736 + return sb_issue_discard(sb, discard_block, count);
740 * This function is called by the jbd2 layer once the commit has finished,
741 * so we know we can free the blocks that were released with that commit.
742 @@ -2583,17 +2598,11 @@ static void release_blocks_on_commit(jou
744 if (test_opt(sb, DISCARD)) {
746 - ext4_fsblk_t discard_block;
748 - discard_block = entry->start_blk +
749 - ext4_group_first_block_no(sb, entry->group);
750 - trace_ext4_discard_blocks(sb,
751 - (unsigned long long)discard_block,
753 - ret = sb_issue_discard(sb, discard_block, entry->count);
754 - if (ret == EOPNOTSUPP) {
755 - ext4_warning(sb, __func__,
756 - "discard not supported, disabling");
757 + ret = ext4_issue_discard(sb, entry->group,
758 + entry->start_blk, entry->count);
759 + if (unlikely(ret == -EOPNOTSUPP)) {
760 + ext4_warning(sb, "discard not supported, "
762 clear_opt(EXT4_SB(sb)->s_mount_opt, DISCARD);
765 @@ -2620,7 +2629,7 @@ static void release_blocks_on_commit(jou
767 ext4_unlock_group(sb, entry->group);
768 kmem_cache_free(ext4_free_ext_cachep, entry);
769 - ext4_mb_unload_buddy(&e4b);
770 + ext4_mb_release_desc(&e4b);
773 mb_debug(1, "freed %u blocks in %u structures\n", count, count2);
774 @@ -2757,7 +2766,7 @@ ext4_mb_mark_diskspace_used(struct ext4_
776 len = ac->ac_b_ex.fe_len;
777 if (!ext4_data_block_valid(sbi, block, len)) {
778 - ext4_error(sb, __func__,
780 "Allocating blocks %llu-%llu which overlap "
781 "fs metadata\n", block, block+len);
782 /* File system mounted not to panic on error
783 @@ -3671,14 +3680,14 @@ ext4_mb_discard_group_preallocations(str
785 bitmap_bh = ext4_read_block_bitmap(sb, group);
786 if (bitmap_bh == NULL) {
787 - ext4_error(sb, __func__, "Error in reading block "
788 + ext4_error(sb, "Error in reading block "
789 "bitmap for %u", group);
793 err = ext4_mb_load_buddy(sb, group, &e4b);
795 - ext4_error(sb, __func__, "Error in loading buddy "
796 + ext4_error(sb, "Error in loading buddy "
797 "information for %u", group);
800 @@ -3852,14 +3861,14 @@ repeat:
802 err = ext4_mb_load_buddy(sb, group, &e4b);
804 - ext4_error(sb, __func__, "Error in loading buddy "
805 - "information for %u", group);
806 + ext4_error(sb, "Error in loading buddy information for %u",
811 bitmap_bh = ext4_read_block_bitmap(sb, group);
812 if (bitmap_bh == NULL) {
813 - ext4_error(sb, __func__, "Error in reading block "
814 + ext4_error(sb, "Error in reading block "
815 "bitmap for %u", group);
816 ext4_mb_unload_buddy(&e4b);
818 @@ -4125,7 +4134,7 @@ ext4_mb_discard_lg_preallocations(struct
820 ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, NULL);
821 if (ext4_mb_load_buddy(sb, group, &e4b)) {
822 - ext4_error(sb, __func__, "Error in loading buddy "
823 + ext4_error(sb, "Error in loading buddy "
824 "information for %u", group);
827 @@ -4516,7 +4525,7 @@ void ext4_mb_free_blocks(handle_t *handl
828 if (block < le32_to_cpu(es->s_first_data_block) ||
829 block + count < block ||
830 block + count > ext4_blocks_count(es)) {
831 - ext4_error(sb, __func__,
833 "Freeing blocks not in datazone - "
834 "block = %llu, count = %lu", block, count);
836 @@ -4561,7 +4570,7 @@ do_more:
837 in_range(block + count - 1, ext4_inode_table(sb, gdp),
838 EXT4_SB(sb)->s_itb_per_group)) {
840 - ext4_error(sb, __func__,
842 "Freeing blocks in system zone - "
843 "Block = %llu, count = %lu", block, count);
844 /* err = 0. ext4_std_error should be a no op */
845 diff -urpN linux-stage.orig/fs/ext4/move_extent.c linux-stage/fs/ext4/move_extent.c
846 --- linux-stage.orig/fs/ext4/move_extent.c 2012-02-16 07:54:55.000000000 -0500
847 +++ linux-stage/fs/ext4/move_extent.c 2012-02-16 08:05:47.000000000 -0500
848 @@ -152,12 +152,12 @@ mext_check_null_inode(struct inode *inod
851 if (inode1 == NULL) {
852 - ext4_error(inode2->i_sb, function,
853 + ext4_error(inode2->i_sb,
854 "Both inodes should not be NULL: "
855 "inode1 NULL inode2 %lu", inode2->i_ino);
857 } else if (inode2 == NULL) {
858 - ext4_error(inode1->i_sb, function,
859 + ext4_error(inode1->i_sb,
860 "Both inodes should not be NULL: "
861 "inode1 %lu inode2 NULL", inode1->i_ino);
863 @@ -528,7 +528,7 @@ mext_leaf_block(handle_t *handle, struct
866 if (le32_to_cpu(oext->ee_block) + oext_alen - 1 < new_ext_end) {
867 - ext4_error(orig_inode->i_sb, __func__,
868 + ext4_error(orig_inode->i_sb,
869 "new_ext_end(%u) should be less than or equal to "
870 "oext->ee_block(%u) + oext_alen(%d) - 1",
871 new_ext_end, le32_to_cpu(oext->ee_block),
872 @@ -691,12 +691,12 @@ mext_replace_branches(handle_t *handle,
874 /* The extent for donor must be found. */
876 - ext4_error(donor_inode->i_sb, __func__,
877 + ext4_error(donor_inode->i_sb,
878 "The extent for donor must be found");
881 } else if (donor_off != le32_to_cpu(tmp_dext.ee_block)) {
882 - ext4_error(donor_inode->i_sb, __func__,
883 + ext4_error(donor_inode->i_sb,
884 "Donor offset(%u) and the first block of donor "
885 "extent(%u) should be equal",
887 @@ -1001,12 +1001,12 @@ mext_check_arguments(struct inode *orig_
891 - if ((orig_start > EXT_MAX_BLOCK) ||
892 - (donor_start > EXT_MAX_BLOCK) ||
893 - (*len > EXT_MAX_BLOCK) ||
894 - (orig_start + *len > EXT_MAX_BLOCK)) {
895 + if ((orig_start > EXT_MAX_BLOCKS) ||
896 + (donor_start > EXT_MAX_BLOCKS) ||
897 + (*len > EXT_MAX_BLOCKS) ||
898 + (orig_start + *len > EXT_MAX_BLOCKS)) {
899 ext4_debug("ext4 move extent: Can't handle over [%u] blocks "
900 - "[ino:orig %lu, donor %lu]\n", EXT_MAX_BLOCK,
901 + "[ino:orig %lu, donor %lu]\n", EXT_MAX_BLOCKS,
902 orig_inode->i_ino, donor_inode->i_ino);
905 @@ -1356,7 +1356,7 @@ ext4_move_extents(struct file *o_filp, s
908 if (*moved_len > len) {
909 - ext4_error(orig_inode->i_sb, __func__,
910 + ext4_error(orig_inode->i_sb,
911 "We replaced blocks too much! "
912 "sum of replaced: %llu requested: %llu",
914 diff -urpN linux-stage.orig/fs/ext4/namei.c linux-stage/fs/ext4/namei.c
915 --- linux-stage.orig/fs/ext4/namei.c 2012-02-16 07:54:55.000000000 -0500
916 +++ linux-stage/fs/ext4/namei.c 2012-02-16 08:05:47.000000000 -0500
917 @@ -394,8 +394,7 @@ dx_probe(const struct qstr *d_name, stru
918 if (root->info.hash_version != DX_HASH_TEA &&
919 root->info.hash_version != DX_HASH_HALF_MD4 &&
920 root->info.hash_version != DX_HASH_LEGACY) {
921 - ext4_warning(dir->i_sb, __func__,
922 - "Unrecognised inode hash code %d",
923 + ext4_warning(dir->i_sb, "Unrecognised inode hash code %d",
924 root->info.hash_version);
926 *err = ERR_BAD_DX_DIR;
927 @@ -410,8 +409,7 @@ dx_probe(const struct qstr *d_name, stru
930 if (root->info.unused_flags & 1) {
931 - ext4_warning(dir->i_sb, __func__,
932 - "Unimplemented inode hash flags: %#06x",
933 + ext4_warning(dir->i_sb, "Unimplemented inode hash flags: %#06x",
934 root->info.unused_flags);
936 *err = ERR_BAD_DX_DIR;
937 @@ -419,8 +417,7 @@ dx_probe(const struct qstr *d_name, stru
940 if ((indirect = root->info.indirect_levels) > 1) {
941 - ext4_warning(dir->i_sb, __func__,
942 - "Unimplemented inode hash depth: %#06x",
943 + ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x",
944 root->info.indirect_levels);
946 *err = ERR_BAD_DX_DIR;
947 @@ -432,8 +429,7 @@ dx_probe(const struct qstr *d_name, stru
949 if (dx_get_limit(entries) != dx_root_limit(dir,
950 root->info.info_length)) {
951 - ext4_warning(dir->i_sb, __func__,
952 - "dx entry: limit != root limit");
953 + ext4_warning(dir->i_sb, "dx entry: limit != root limit");
955 *err = ERR_BAD_DX_DIR;
957 @@ -444,7 +440,7 @@ dx_probe(const struct qstr *d_name, stru
959 count = dx_get_count(entries);
960 if (!count || count > dx_get_limit(entries)) {
961 - ext4_warning(dir->i_sb, __func__,
962 + ext4_warning(dir->i_sb,
963 "dx entry: no count or count > limit");
965 *err = ERR_BAD_DX_DIR;
966 @@ -489,7 +485,7 @@ dx_probe(const struct qstr *d_name, stru
968 at = entries = ((struct dx_node *) bh->b_data)->entries;
969 if (dx_get_limit(entries) != dx_node_limit (dir)) {
970 - ext4_warning(dir->i_sb, __func__,
971 + ext4_warning(dir->i_sb,
972 "dx entry: limit != node limit");
974 *err = ERR_BAD_DX_DIR;
975 @@ -505,7 +501,7 @@ fail2:
978 if (*err == ERR_BAD_DX_DIR)
979 - ext4_warning(dir->i_sb, __func__,
980 + ext4_warning(dir->i_sb,
981 "Corrupt dir inode %ld, running e2fsck is "
982 "recommended.", dir->i_ino);
984 @@ -969,7 +965,7 @@ restart:
986 if (!buffer_uptodate(bh)) {
987 /* read error, skip block & hope for the best */
988 - ext4_error(sb, __func__, "reading directory #%lu "
989 + ext4_error(sb, "reading directory #%lu "
990 "offset %lu", dir->i_ino,
991 (unsigned long)block);
993 @@ -1012,8 +1008,9 @@ cleanup_and_exit:
994 static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct qstr *d_name,
995 struct ext4_dir_entry_2 **res_dir, int *err)
997 - struct super_block * sb = dir->i_sb;
998 + struct super_block * sb;
999 struct dx_hash_info hinfo;
1001 struct dx_frame frames[2], *frame;
1002 struct ext4_dir_entry_2 *de, *top;
1003 struct buffer_head *bh;
1004 @@ -1022,8 +1019,18 @@ static struct buffer_head * ext4_dx_find
1005 int namelen = d_name->len;
1006 const u8 *name = d_name->name;
1008 - if (!(frame = dx_probe(d_name, dir, &hinfo, frames, err)))
1011 + /* NFS may look up ".." - look at dx_root directory block */
1012 + if (namelen > 2 || name[0] != '.'||(name[1] != '.' && name[1] != '\0')){
1013 + if (!(frame = dx_probe(d_name, dir, &hinfo, frames, err)))
1017 + frame->bh = NULL; /* for dx_release() */
1018 + frame->at = (struct dx_entry *)frames; /* hack for zero entry*/
1019 + dx_set_block(frame->at, 0); /* dx_root block is 0 */
1021 + hash = hinfo.hash;
1023 block = dx_get_block(frame->at);
1024 if (!(bh = ext4_bread (NULL,dir, block, 0, err)))
1025 @@ -1049,10 +1056,10 @@ static struct buffer_head * ext4_dx_find
1028 /* Check to see if we should continue to search */
1029 - retval = ext4_htree_next_block(dir, hinfo.hash, frame,
1030 + retval = ext4_htree_next_block(dir, hash, frame,
1033 - ext4_warning(sb, __func__,
1035 "error reading index page in directory #%lu",
1038 @@ -1082,14 +1089,13 @@ static struct dentry *ext4_lookup(struct
1039 __u32 ino = le32_to_cpu(de->inode);
1041 if (!ext4_valid_inum(dir->i_sb, ino)) {
1042 - ext4_error(dir->i_sb, "ext4_lookup",
1043 - "bad inode number: %u", ino);
1044 + ext4_error(dir->i_sb, "bad inode number: %u", ino);
1045 return ERR_PTR(-EIO);
1047 inode = ext4_iget(dir->i_sb, ino);
1048 if (unlikely(IS_ERR(inode))) {
1049 if (PTR_ERR(inode) == -ESTALE) {
1050 - ext4_error(dir->i_sb, __func__,
1051 + ext4_error(dir->i_sb,
1052 "deleted inode referenced: %u",
1054 return ERR_PTR(-EIO);
1055 @@ -1121,7 +1127,7 @@ struct dentry *ext4_get_parent(struct de
1058 if (!ext4_valid_inum(child->d_inode->i_sb, ino)) {
1059 - ext4_error(child->d_inode->i_sb, "ext4_get_parent",
1060 + ext4_error(child->d_inode->i_sb,
1061 "bad inode number: %u", ino);
1062 return ERR_PTR(-EIO);
1064 @@ -1421,7 +1427,7 @@ static int make_indexed_dir(handle_t *ha
1065 de = (struct ext4_dir_entry_2 *)((char *)fde +
1066 ext4_rec_len_from_disk(fde->rec_len, blocksize));
1067 if ((char *) de >= (((char *) root) + blocksize)) {
1068 - ext4_error(dir->i_sb, __func__,
1069 + ext4_error(dir->i_sb,
1070 "invalid rec_len for '..' in inode %lu",
1073 @@ -1588,8 +1594,7 @@ static int ext4_dx_add_entry(handle_t *h
1075 if (levels && (dx_get_count(frames->entries) ==
1076 dx_get_limit(frames->entries))) {
1077 - ext4_warning(sb, __func__,
1078 - "Directory index full!");
1079 + ext4_warning(sb, "Directory index full!");
1083 @@ -1943,11 +1948,11 @@ static int empty_dir(struct inode *inode
1084 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2) ||
1085 !(bh = ext4_bread(NULL, inode, 0, 0, &err))) {
1087 - ext4_error(inode->i_sb, __func__,
1088 + ext4_error(inode->i_sb,
1089 "error %d reading directory #%lu offset 0",
1092 - ext4_warning(inode->i_sb, __func__,
1093 + ext4_warning(inode->i_sb,
1094 "bad directory (dir #%lu) - no data block",
1097 @@ -1958,7 +1963,7 @@ static int empty_dir(struct inode *inode
1098 !le32_to_cpu(de1->inode) ||
1099 strcmp(".", de->name) ||
1100 strcmp("..", de1->name)) {
1101 - ext4_warning(inode->i_sb, "empty_dir",
1102 + ext4_warning(inode->i_sb,
1103 "bad directory (dir #%lu) - no `.' or `..'",
1106 @@ -1976,7 +1981,7 @@ static int empty_dir(struct inode *inode
1107 offset >> EXT4_BLOCK_SIZE_BITS(sb), 0, &err);
1110 - ext4_error(sb, __func__,
1112 "error %d reading directory"
1114 err, inode->i_ino, offset);
1115 @@ -2198,7 +2203,7 @@ static int ext4_rmdir(struct inode *dir,
1118 if (!EXT4_DIR_LINK_EMPTY(inode))
1119 - ext4_warning(inode->i_sb, "ext4_rmdir",
1120 + ext4_warning(inode->i_sb,
1121 "empty directory has too many links (%d)",
1124 @@ -2250,7 +2255,7 @@ static int ext4_unlink(struct inode *dir
1127 if (!inode->i_nlink) {
1128 - ext4_warning(inode->i_sb, "ext4_unlink",
1129 + ext4_warning(inode->i_sb,
1130 "Deleting nonexistent file (%lu), %d",
1131 inode->i_ino, inode->i_nlink);
1133 @@ -2497,7 +2502,7 @@ static int ext4_rename(struct inode *old
1137 - ext4_warning(old_dir->i_sb, "ext4_rename",
1138 + ext4_warning(old_dir->i_sb,
1139 "Deleting old file (%lu), %d, error=%d",
1140 old_dir->i_ino, old_dir->i_nlink, retval);
1142 diff -urpN linux-stage.orig/fs/ext4/resize.c linux-stage/fs/ext4/resize.c
1143 --- linux-stage.orig/fs/ext4/resize.c 2012-02-16 07:54:55.000000000 -0500
1144 +++ linux-stage/fs/ext4/resize.c 2012-02-16 08:05:47.000000000 -0500
1145 @@ -48,63 +48,63 @@ static int verify_group_input(struct sup
1147 ext4_get_group_no_and_offset(sb, start, NULL, &offset);
1148 if (group != sbi->s_groups_count)
1149 - ext4_warning(sb, __func__,
1151 "Cannot add at group %u (only %u groups)",
1152 input->group, sbi->s_groups_count);
1153 else if (offset != 0)
1154 - ext4_warning(sb, __func__, "Last group not full");
1155 + ext4_warning(sb, "Last group not full");
1156 else if (input->reserved_blocks > input->blocks_count / 5)
1157 - ext4_warning(sb, __func__, "Reserved blocks too high (%u)",
1158 + ext4_warning(sb, "Reserved blocks too high (%u)",
1159 input->reserved_blocks);
1160 else if (free_blocks_count < 0)
1161 - ext4_warning(sb, __func__, "Bad blocks count %u",
1162 + ext4_warning(sb, "Bad blocks count %u",
1163 input->blocks_count);
1164 else if (!(bh = sb_bread(sb, end - 1)))
1165 - ext4_warning(sb, __func__,
1167 "Cannot read last block (%llu)",
1169 else if (outside(input->block_bitmap, start, end))
1170 - ext4_warning(sb, __func__,
1172 "Block bitmap not in group (block %llu)",
1173 (unsigned long long)input->block_bitmap);
1174 else if (outside(input->inode_bitmap, start, end))
1175 - ext4_warning(sb, __func__,
1177 "Inode bitmap not in group (block %llu)",
1178 (unsigned long long)input->inode_bitmap);
1179 else if (outside(input->inode_table, start, end) ||
1180 outside(itend - 1, start, end))
1181 - ext4_warning(sb, __func__,
1183 "Inode table not in group (blocks %llu-%llu)",
1184 (unsigned long long)input->inode_table, itend - 1);
1185 else if (input->inode_bitmap == input->block_bitmap)
1186 - ext4_warning(sb, __func__,
1188 "Block bitmap same as inode bitmap (%llu)",
1189 (unsigned long long)input->block_bitmap);
1190 else if (inside(input->block_bitmap, input->inode_table, itend))
1191 - ext4_warning(sb, __func__,
1193 "Block bitmap (%llu) in inode table (%llu-%llu)",
1194 (unsigned long long)input->block_bitmap,
1195 (unsigned long long)input->inode_table, itend - 1);
1196 else if (inside(input->inode_bitmap, input->inode_table, itend))
1197 - ext4_warning(sb, __func__,
1199 "Inode bitmap (%llu) in inode table (%llu-%llu)",
1200 (unsigned long long)input->inode_bitmap,
1201 (unsigned long long)input->inode_table, itend - 1);
1202 else if (inside(input->block_bitmap, start, metaend))
1203 - ext4_warning(sb, __func__,
1205 "Block bitmap (%llu) in GDT table"
1207 (unsigned long long)input->block_bitmap,
1208 start, metaend - 1);
1209 else if (inside(input->inode_bitmap, start, metaend))
1210 - ext4_warning(sb, __func__,
1212 "Inode bitmap (%llu) in GDT table"
1214 (unsigned long long)input->inode_bitmap,
1215 start, metaend - 1);
1216 else if (inside(input->inode_table, start, metaend) ||
1217 inside(itend - 1, start, metaend))
1218 - ext4_warning(sb, __func__,
1220 "Inode table (%llu-%llu) overlaps"
1221 "GDT table (%llu-%llu)",
1222 (unsigned long long)input->inode_table,
1223 @@ -364,7 +364,7 @@ static int verify_reserved_gdb(struct su
1224 while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
1225 if (le32_to_cpu(*p++) !=
1226 grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
1227 - ext4_warning(sb, __func__,
1230 " missing grp %d (%llu)",
1232 @@ -420,7 +420,7 @@ static int add_new_gdb(handle_t *handle,
1234 if (EXT4_SB(sb)->s_sbh->b_blocknr !=
1235 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
1236 - ext4_warning(sb, __func__,
1238 "won't resize using backup superblock at %llu",
1239 (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
1241 @@ -444,7 +444,7 @@ static int add_new_gdb(handle_t *handle,
1243 data = (__le32 *)dind->b_data;
1244 if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
1245 - ext4_warning(sb, __func__,
1247 "new group %u GDT block %llu not reserved",
1248 input->group, gdblock);
1250 @@ -468,7 +468,7 @@ static int add_new_gdb(handle_t *handle,
1252 if (!n_group_desc) {
1254 - ext4_warning(sb, __func__,
1256 "not enough memory for %lu groups", gdb_num + 1);
1259 @@ -567,7 +567,7 @@ static int reserve_backup_gdb(handle_t *
1260 /* Get each reserved primary GDT block and verify it holds backups */
1261 for (res = 0; res < reserved_gdb; res++, blk++) {
1262 if (le32_to_cpu(*data) != blk) {
1263 - ext4_warning(sb, __func__,
1265 "reserved block %llu"
1266 " not at offset %ld",
1268 @@ -713,7 +713,7 @@ static void update_backups(struct super_
1272 - ext4_warning(sb, __func__,
1274 "can't update backup for group %u (err %d), "
1275 "forcing fsck on next reboot", group, err);
1276 sbi->s_mount_state &= ~EXT4_VALID_FS;
1277 @@ -753,20 +753,20 @@ int ext4_group_add(struct super_block *s
1279 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
1280 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
1281 - ext4_warning(sb, __func__,
1283 "Can't resize non-sparse filesystem further");
1287 if (ext4_blocks_count(es) + input->blocks_count <
1288 ext4_blocks_count(es)) {
1289 - ext4_warning(sb, __func__, "blocks_count overflow");
1290 + ext4_warning(sb, "blocks_count overflow");
1294 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
1295 le32_to_cpu(es->s_inodes_count)) {
1296 - ext4_warning(sb, __func__, "inodes_count overflow");
1297 + ext4_warning(sb, "inodes_count overflow");
1301 @@ -774,13 +774,13 @@ int ext4_group_add(struct super_block *s
1302 if (!EXT4_HAS_COMPAT_FEATURE(sb,
1303 EXT4_FEATURE_COMPAT_RESIZE_INODE)
1304 || !le16_to_cpu(es->s_reserved_gdt_blocks)) {
1305 - ext4_warning(sb, __func__,
1307 "No reserved GDT blocks, can't resize");
1310 inode = ext4_iget(sb, EXT4_RESIZE_INO);
1311 if (IS_ERR(inode)) {
1312 - ext4_warning(sb, __func__,
1314 "Error opening resize inode");
1315 return PTR_ERR(inode);
1317 @@ -810,7 +810,7 @@ int ext4_group_add(struct super_block *s
1319 mutex_lock(&sbi->s_resize_lock);
1320 if (input->group != sbi->s_groups_count) {
1321 - ext4_warning(sb, __func__,
1323 "multiple resizers run on filesystem!");
1326 @@ -998,12 +998,12 @@ int ext4_group_extend(struct super_block
1327 " too large to resize to %llu blocks safely\n",
1328 sb->s_id, n_blocks_count);
1329 if (sizeof(sector_t) < 8)
1330 - ext4_warning(sb, __func__, "CONFIG_LBDAF not enabled");
1331 + ext4_warning(sb, "CONFIG_LBDAF not enabled");
1335 if (n_blocks_count < o_blocks_count) {
1336 - ext4_warning(sb, __func__,
1338 "can't shrink FS - resize aborted");
1341 @@ -1012,7 +1012,7 @@ int ext4_group_extend(struct super_block
1342 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1345 - ext4_warning(sb, __func__,
1347 "need to use ext2online to resize further");
1350 @@ -1020,7 +1020,7 @@ int ext4_group_extend(struct super_block
1351 add = EXT4_BLOCKS_PER_GROUP(sb) - last;
1353 if (o_blocks_count + add < o_blocks_count) {
1354 - ext4_warning(sb, __func__, "blocks_count overflow");
1355 + ext4_warning(sb, "blocks_count overflow");
1359 @@ -1028,7 +1028,7 @@ int ext4_group_extend(struct super_block
1360 add = n_blocks_count - o_blocks_count;
1362 if (o_blocks_count + add < n_blocks_count)
1363 - ext4_warning(sb, __func__,
1365 "will only finish group (%llu"
1367 o_blocks_count + add, add);
1368 @@ -1036,7 +1036,7 @@ int ext4_group_extend(struct super_block
1369 /* See if the device is actually as big as what was requested */
1370 bh = sb_bread(sb, o_blocks_count + add - 1);
1372 - ext4_warning(sb, __func__,
1374 "can't read last block, resize aborted");
1377 @@ -1048,13 +1048,13 @@ int ext4_group_extend(struct super_block
1378 handle = ext4_journal_start_sb(sb, 3);
1379 if (IS_ERR(handle)) {
1380 err = PTR_ERR(handle);
1381 - ext4_warning(sb, __func__, "error %d on journal start", err);
1382 + ext4_warning(sb, "error %d on journal start", err);
1386 mutex_lock(&EXT4_SB(sb)->s_resize_lock);
1387 if (o_blocks_count != ext4_blocks_count(es)) {
1388 - ext4_warning(sb, __func__,
1390 "multiple resizers run on filesystem!");
1391 mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
1392 ext4_journal_stop(handle);
1393 @@ -1064,7 +1064,7 @@ int ext4_group_extend(struct super_block
1395 if ((err = ext4_journal_get_write_access(handle,
1396 EXT4_SB(sb)->s_sbh))) {
1397 - ext4_warning(sb, __func__,
1399 "error %d on journal write access", err);
1400 mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
1401 ext4_journal_stop(handle);
1402 diff -urpN linux-stage.orig/fs/ext4/super.c linux-stage/fs/ext4/super.c
1403 --- linux-stage.orig/fs/ext4/super.c 2012-02-16 07:54:55.000000000 -0500
1404 +++ linux-stage/fs/ext4/super.c 2012-02-16 08:05:47.000000000 -0500
1407 struct proc_dir_entry *ext4_proc_root;
1408 static struct kset *ext4_kset;
1409 +static struct ext4_lazy_init *ext4_li_info;
1410 +static struct mutex ext4_li_mtx;
1412 static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
1413 unsigned long journal_devnum);
1414 @@ -337,7 +339,7 @@ static void ext4_handle_error(struct sup
1418 -void ext4_error(struct super_block *sb, const char *function,
1419 +void __ext4_error(struct super_block *sb, const char *function,
1420 const char *fmt, ...)
1423 @@ -351,6 +353,42 @@ void ext4_error(struct super_block *sb,
1424 ext4_handle_error(sb);
1427 +void ext4_error_inode(const char *function, struct inode *inode,
1428 + const char *fmt, ...)
1432 + va_start(args, fmt);
1433 + printk(KERN_CRIT "EXT4-fs error (device %s): %s: inode #%lu: (comm %s) ",
1434 + inode->i_sb->s_id, function, inode->i_ino, current->comm);
1435 + vprintk(fmt, args);
1439 + ext4_handle_error(inode->i_sb);
1442 +void ext4_error_file(const char *function, struct file *file,
1443 + const char *fmt, ...)
1446 + struct inode *inode = file->f_dentry->d_inode;
1447 + char pathname[80], *path;
1449 + va_start(args, fmt);
1450 + path = d_path(&(file->f_path), pathname, sizeof(pathname));
1452 + path = "(unknown)";
1454 + "EXT4-fs error (device %s): %s: inode #%lu (comm %s path %s): ",
1455 + inode->i_sb->s_id, function, inode->i_ino, current->comm, path);
1456 + vprintk(fmt, args);
1460 + ext4_handle_error(inode->i_sb);
1463 static const char *ext4_decode_error(struct super_block *sb, int errno,
1466 @@ -454,7 +492,7 @@ void ext4_msg (struct super_block * sb,
1470 -void ext4_warning(struct super_block *sb, const char *function,
1471 +void __ext4_warning(struct super_block *sb, const char *function,
1472 const char *fmt, ...)
1475 @@ -511,7 +549,7 @@ void ext4_update_dynamic_rev(struct supe
1476 if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
1479 - ext4_warning(sb, __func__,
1481 "updating to rev %d because of new feature flag, "
1482 "running e2fsck is recommended",
1484 @@ -1096,13 +1134,14 @@ enum {
1485 Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
1486 Opt_data_err_abort, Opt_data_err_ignore,
1487 Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1488 - Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
1489 - Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err, Opt_resize,
1490 - Opt_usrquota, Opt_grpquota, Opt_i_version,
1491 + Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
1492 + Opt_noquota, Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err,
1493 + Opt_resize, Opt_usrquota, Opt_grpquota, Opt_i_version,
1494 Opt_stripe, Opt_delalloc, Opt_nodelalloc,
1495 Opt_block_validity, Opt_noblock_validity,
1496 Opt_inode_readahead_blks, Opt_journal_ioprio,
1497 Opt_discard, Opt_nodiscard,
1498 + Opt_init_inode_table, Opt_noinit_inode_table,
1501 static const match_table_t tokens = {
1502 @@ -2709,6 +2748,21 @@ static int ext4_fill_super(struct super_
1503 get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1504 spin_lock_init(&sbi->s_next_gen_lock);
1506 + err = percpu_counter_init(&sbi->s_freeblocks_counter,
1507 + ext4_count_free_blocks(sb));
1509 + err = percpu_counter_init(&sbi->s_freeinodes_counter,
1510 + ext4_count_free_inodes(sb));
1512 + err = percpu_counter_init(&sbi->s_dirs_counter,
1513 + ext4_count_dirs(sb));
1515 + err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
1517 + ext4_msg(sb, KERN_ERR, "insufficient memory");
1518 + goto failed_mount3;
1521 sbi->s_stripe = ext4_get_stripe_size(sbi);
1522 sbi->s_max_writeback_mb_bump = 128;
1524 @@ -2828,20 +2882,6 @@ static int ext4_fill_super(struct super_
1525 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
1528 - err = percpu_counter_init(&sbi->s_freeblocks_counter,
1529 - ext4_count_free_blocks(sb));
1531 - err = percpu_counter_init(&sbi->s_freeinodes_counter,
1532 - ext4_count_free_inodes(sb));
1534 - err = percpu_counter_init(&sbi->s_dirs_counter,
1535 - ext4_count_dirs(sb));
1537 - err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
1539 - ext4_msg(sb, KERN_ERR, "insufficient memory");
1540 - goto failed_mount_wq;
1542 if (test_opt(sb, NOBH)) {
1543 if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) {
1544 ext4_msg(sb, KERN_WARNING, "Ignoring nobh option - "
1545 @@ -2974,10 +3014,6 @@ failed_mount_wq:
1546 jbd2_journal_destroy(sbi->s_journal);
1547 sbi->s_journal = NULL;
1549 - percpu_counter_destroy(&sbi->s_freeblocks_counter);
1550 - percpu_counter_destroy(&sbi->s_freeinodes_counter);
1551 - percpu_counter_destroy(&sbi->s_dirs_counter);
1552 - percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
1554 if (sbi->s_flex_groups) {
1555 if (is_vmalloc_addr(sbi->s_flex_groups))
1556 @@ -2985,6 +3021,10 @@ failed_mount3:
1558 kfree(sbi->s_flex_groups);
1560 + percpu_counter_destroy(&sbi->s_freeblocks_counter);
1561 + percpu_counter_destroy(&sbi->s_freeinodes_counter);
1562 + percpu_counter_destroy(&sbi->s_dirs_counter);
1563 + percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
1565 for (i = 0; i < db_count; i++)
1566 brelse(sbi->s_group_desc[i]);
1567 @@ -3377,9 +3417,9 @@ static void ext4_clear_journal_err(struc
1570 errstr = ext4_decode_error(sb, j_errno, nbuf);
1571 - ext4_warning(sb, __func__, "Filesystem error recorded "
1572 + ext4_warning(sb, "Filesystem error recorded "
1573 "from previous mount: %s", errstr);
1574 - ext4_warning(sb, __func__, "Marking fs in need of "
1575 + ext4_warning(sb, "Marking fs in need of "
1576 "filesystem check.");
1578 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
1579 @@ -4007,11 +4047,21 @@ static struct file_system_type ext4_fs_t
1580 .fs_flags = FS_REQUIRES_DEV,
1583 +static int __init ext4_init_feat_adverts(void)
1588 +static void ext4_exit_feat_adverts(void)
1592 static int __init init_ext4_fs(void)
1596 ext4_check_flag_values();
1598 err = init_ext4_system_zone();
1601 @@ -4019,6 +4069,9 @@ static int __init init_ext4_fs(void)
1604 ext4_proc_root = proc_mkdir("fs/ext4", NULL);
1606 + err = ext4_init_feat_adverts();
1608 err = init_ext4_mballoc();
1611 @@ -4032,6 +4085,9 @@ static int __init init_ext4_fs(void)
1612 err = register_filesystem(&ext4_fs_type);
1616 + ext4_li_info = NULL;
1617 + mutex_init(&ext4_li_mtx);
1620 destroy_inodecache();
1621 @@ -4040,6 +4096,7 @@ out1:
1623 exit_ext4_mballoc();
1625 + ext4_exit_feat_adverts();
1626 remove_proc_entry("fs/ext4", NULL);
1627 kset_unregister(ext4_kset);
1629 @@ -4053,6 +4110,7 @@ static void __exit exit_ext4_fs(void)
1630 destroy_inodecache();
1632 exit_ext4_mballoc();
1633 + ext4_exit_feat_adverts();
1634 remove_proc_entry("fs/ext4", NULL);
1635 kset_unregister(ext4_kset);
1636 exit_ext4_system_zone();
1637 diff -urpN linux-stage.orig/fs/ext4/xattr.c linux-stage/fs/ext4/xattr.c
1638 --- linux-stage.orig/fs/ext4/xattr.c 2012-02-16 07:54:55.000000000 -0500
1639 +++ linux-stage/fs/ext4/xattr.c 2012-02-16 08:05:47.000000000 -0500
1640 @@ -227,7 +227,7 @@ ext4_xattr_block_get(struct inode *inode
1641 ea_bdebug(bh, "b_count=%d, refcount=%d",
1642 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
1643 if (ext4_xattr_check_block(bh)) {
1644 -bad_block: ext4_error(inode->i_sb, __func__,
1645 +bad_block: ext4_error(inode->i_sb,
1646 "inode %lu: bad block %llu", inode->i_ino,
1647 EXT4_I(inode)->i_file_acl);
1649 @@ -369,7 +369,7 @@ ext4_xattr_block_list(struct inode *inod
1650 ea_bdebug(bh, "b_count=%d, refcount=%d",
1651 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
1652 if (ext4_xattr_check_block(bh)) {
1653 - ext4_error(inode->i_sb, __func__,
1654 + ext4_error(inode->i_sb,
1655 "inode %lu: bad block %llu", inode->i_ino,
1656 EXT4_I(inode)->i_file_acl);
1658 @@ -661,7 +661,7 @@ ext4_xattr_block_find(struct inode *inod
1659 atomic_read(&(bs->bh->b_count)),
1660 le32_to_cpu(BHDR(bs->bh)->h_refcount));
1661 if (ext4_xattr_check_block(bs->bh)) {
1662 - ext4_error(sb, __func__,
1664 "inode %lu: bad block %llu", inode->i_ino,
1665 EXT4_I(inode)->i_file_acl);
1667 @@ -875,7 +875,7 @@ cleanup_dquot:
1671 - ext4_error(inode->i_sb, __func__,
1672 + ext4_error(inode->i_sb,
1673 "inode %lu: bad block %llu", inode->i_ino,
1674 EXT4_I(inode)->i_file_acl);
1676 @@ -1190,7 +1190,7 @@ retry:
1679 if (ext4_xattr_check_block(bh)) {
1680 - ext4_error(inode->i_sb, __func__,
1681 + ext4_error(inode->i_sb,
1682 "inode %lu: bad block %llu", inode->i_ino,
1683 EXT4_I(inode)->i_file_acl);
1685 @@ -1367,14 +1367,14 @@ ext4_xattr_delete_inode(handle_t *handle
1687 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1689 - ext4_error(inode->i_sb, __func__,
1690 + ext4_error(inode->i_sb,
1691 "inode %lu: block %llu read error", inode->i_ino,
1692 EXT4_I(inode)->i_file_acl);
1695 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
1696 BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1697 - ext4_error(inode->i_sb, __func__,
1698 + ext4_error(inode->i_sb,
1699 "inode %lu: bad block %llu", inode->i_ino,
1700 EXT4_I(inode)->i_file_acl);
1702 @@ -1501,7 +1501,7 @@ again:
1704 bh = sb_bread(inode->i_sb, ce->e_block);
1706 - ext4_error(inode->i_sb, __func__,
1707 + ext4_error(inode->i_sb,
1708 "inode %lu: block %lu read error",
1709 inode->i_ino, (unsigned long) ce->e_block);
1710 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=