ldiskfs/kernel_patches/patches/ext4-update-sles11-rhel6.patch

   1 diff -urpN linux-stage.orig/fs/ext4/balloc.c linux-stage/fs/ext4/balloc.c
   2 --- linux-stage.orig/fs/ext4/balloc.c   2011-12-28 08:18:31.000000000 -0500
   3 +++ linux-stage/fs/ext4/balloc.c        2011-12-28 11:24:07.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__,
   9 +                       ext4_error(sb,
  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);
  15
  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);
  23
  24                 return NULL;
  25         }
  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);
  35                 return NULL;
  36 @@ -280,7 +277,7 @@ static int ext4_valid_block_bitmap(struc
  37                 return 1;
  38
  39  err_out:
  40 -       ext4_error(sb, __func__,
  41 +       ext4_error(sb,
  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);
  48         if (unlikely(!bh)) {
  49 -               ext4_error(sb, __func__,
  50 +               ext4_error(sb,
  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) {
  57                 put_bh(bh);
  58 -               ext4_error(sb, __func__,
  59 +               ext4_error(sb,
  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__,
  68 +               ext4_error(sb,
  69                            "Adding blocks in system zones - "
  70                            "Block = %llu, count = %lu",
  71                            block, count);
  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__,
  77 +                       ext4_error(sb,
  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      2011-12-28 08:18:31.000000000 -0500
  83 +++ linux-stage/fs/ext4/dir.c   2011-12-28 11:24:07.000000000 -0500
  84 @@ -83,7 +83,7 @@ int ext4_check_dir_entry(const char *fun
  85                 error_msg = "inode out of bounds";
  86
  87         if (error_msg != NULL)
  88 -               ext4_error(dir->i_sb, function,
  89 +               ext4_error(dir->i_sb,
  90                         "bad entry in directory #%lu: %s - block=%llu"
  91                         "offset=%u(%u), inode=%u, rec_len=%d, name_len=%d",
  92                         dir->i_ino, error_msg,
  93 @@ -152,7 +152,7 @@ static int ext4_readdir(struct file *fil
  94                  */
  95                 if (!bh) {
  96                         if (!dir_has_error) {
  97 -                               ext4_error(sb, __func__, "directory #%lu "
  98 +                               ext4_error(sb, "directory #%lu "
  99                                            "contains a hole at offset %Lu",
 100                                            inode->i_ino,
 101                                            (unsigned long long) filp->f_pos);
 102 diff -urpN linux-stage.orig/fs/ext4/ext4_extents.h linux-stage/fs/ext4/ext4_extents.h
 103 --- linux-stage.orig/fs/ext4/ext4_extents.h     2011-12-28 08:18:31.000000000 -0500
 104 +++ linux-stage/fs/ext4/ext4_extents.h  2011-12-28 11:24:07.000000000 -0500
 105 @@ -138,7 +138,7 @@ typedef int (*ext_prepare_callback)(stru
 106  #define EXT_REPEAT     2
 107
 108  /* Maximum logical block in a file; ext4_extent's ee_block is __le32 */
 109 -#define EXT_MAX_BLOCK  0xffffffff
 110 +#define EXT_MAX_BLOCKS 0xffffffff
 111
 112  /*
 113   * EXT_INIT_MAX_LEN is the maximum number of blocks we can have in an
 114 diff -urpN linux-stage.orig/fs/ext4/ext4.h linux-stage/fs/ext4/ext4.h
 115 --- linux-stage.orig/fs/ext4/ext4.h     2011-12-28 08:18:31.000000000 -0500
 116 +++ linux-stage/fs/ext4/ext4.h  2011-12-28 11:24:07.000000000 -0500
 117 @@ -23,6 +23,7 @@
 118  #include <linux/quota.h>
 119  #include <linux/rwsem.h>
 120  #include <linux/rbtree.h>
 121 +#include <linux/kernel.h>
 122  #include <linux/seqlock.h>
 123  #include <linux/mutex.h>
 124  #include <linux/timer.h>
 125 @@ -56,6 +57,12 @@
 126  #define ext4_debug(f, a...)    do {} while (0)
 127  #endif
 128
 129 +#define EXT4_ERROR_INODE(inode, fmt, a...) \
 130 +       ext4_error_inode(__func__, (inode), (fmt), ## a);
 131 +
 132 +#define EXT4_ERROR_FILE(file, fmt, a...)        \
 133 +       ext4_error_file(__func__, (file), (fmt), ## a);
 134 +
 135  /* data type for block offset of block group */
 136  typedef int ext4_grpblk_t;
 137
 138 @@ -1509,6 +1516,7 @@ extern struct buffer_head *ext4_read_ino
 139                                                   ext4_group_t block_group);
 140
 141  /* mballoc.c */
 142 +struct fstrim_range;
 143  extern long ext4_mb_stats;
 144  extern long ext4_mb_max_to_scan;
 145  extern int ext4_mb_init(struct super_block *, int);
 146 @@ -1526,6 +1534,8 @@ extern int ext4_mb_add_groupinfo(struct
 147  extern int ext4_mb_get_buddy_cache_lock(struct super_block *, ext4_group_t);
 148  extern void ext4_mb_put_buddy_cache_lock(struct super_block *,
 149                                                 ext4_group_t, int);
 150 +extern int ext4_trim_fs(struct super_block *, struct fstrim_range *);
 151 +
 152  /* inode.c */
 153  int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
 154                 struct buffer_head *bh, ext4_fsblk_t blocknr);
 155 @@ -1586,13 +1596,17 @@ extern int ext4_group_extend(struct supe
 156                                 ext4_fsblk_t n_blocks_count);
 157
 158  /* super.c */
 159 -extern void ext4_error(struct super_block *, const char *, const char *, ...)
 160 +extern void __ext4_error(struct super_block *, const char *, const char *, ...)
 161 +       __attribute__ ((format (printf, 3, 4)));
 162 +#define ext4_error(sb, message...)     __ext4_error(sb, __func__, ## message)
 163 +extern void ext4_error_inode(const char *, struct inode *, const char *, ...)
 164         __attribute__ ((format (printf, 3, 4)));
 165  extern void __ext4_std_error(struct super_block *, const char *, int);
 166  extern void ext4_abort(struct super_block *, const char *, const char *, ...)
 167         __attribute__ ((format (printf, 3, 4)));
 168 -extern void ext4_warning(struct super_block *, const char *, const char *, ...)
 169 +extern void __ext4_warning(struct super_block *, const char *, const char *, ...)
 170         __attribute__ ((format (printf, 3, 4)));
 171 +#define ext4_warning(sb, message...)   __ext4_warning(sb, __func__, ## message)
 172  extern void ext4_msg(struct super_block *, const char *, const char *, ...)
 173         __attribute__ ((format (printf, 3, 4)));
 174  extern void ext4_grp_locked_error(struct super_block *, ext4_group_t,
 175 diff -urpN linux-stage.orig/fs/ext4/ext4_jbd2.c linux-stage/fs/ext4/ext4_jbd2.c
 176 --- linux-stage.orig/fs/ext4/ext4_jbd2.c        2011-12-28 08:18:31.000000000 -0500
 177 +++ linux-stage/fs/ext4/ext4_jbd2.c     2011-12-28 11:24:07.000000000 -0500
 178 @@ -96,7 +96,7 @@ int __ext4_handle_dirty_metadata(const c
 179                 if (inode && inode_needs_sync(inode)) {
 180                         sync_dirty_buffer(bh);
 181                         if (buffer_req(bh) && !buffer_uptodate(bh)) {
 182 -                               ext4_error(inode->i_sb, __func__,
 183 +                               ext4_error(inode->i_sb,
 184                                            "IO error syncing inode, "
 185                                            "inode=%lu, block=%llu",
 186                                            inode->i_ino,
 187 diff -urpN linux-stage.orig/fs/ext4/extents.c linux-stage/fs/ext4/extents.c
 188 --- linux-stage.orig/fs/ext4/extents.c  2011-12-28 08:18:31.000000000 -0500
 189 +++ linux-stage/fs/ext4/extents.c       2011-12-28 11:24:07.000000000 -0500
 190 @@ -437,7 +437,7 @@ static int __ext4_ext_check(const char *
 191         return 0;
 192
 193  corrupted:
 194 -       ext4_error(inode->i_sb, function,
 195 +       ext4_error(inode->i_sb,
 196                         "bad header/extent in inode #%lu: %s - magic %x, "
 197                         "entries %u, max %u(%u), depth %u(%u)",
 198                         inode->i_ino, error_msg, le16_to_cpu(eh->eh_magic),
 199 @@ -1329,7 +1329,7 @@ got_index:
 200
 201  /*
 202   * ext4_ext_next_allocated_block:
 203 - * returns allocated block in subsequent extent or EXT_MAX_BLOCK.
 204 + * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
 205   * NOTE: it considers block number from index entry as
 206   * allocated block. Thus, index entries have to be consistent
 207   * with leaves.
 208 @@ -1343,7 +1343,7 @@ ext4_ext_next_allocated_block(struct ext
 209         depth = path->p_depth;
 210
 211         if (depth == 0 && path->p_ext == NULL)
 212 -               return EXT_MAX_BLOCK;
 213 +               return EXT_MAX_BLOCKS;
 214
 215         while (depth >= 0) {
 216                 if (depth == path->p_depth) {
 217 @@ -1360,12 +1360,12 @@ ext4_ext_next_allocated_block(struct ext
 218                 depth--;
 219         }
 220
 221 -       return EXT_MAX_BLOCK;
 222 +       return EXT_MAX_BLOCKS;
 223  }
 224
 225  /*
 226   * ext4_ext_next_leaf_block:
 227 - * returns first allocated block from next leaf or EXT_MAX_BLOCK
 228 + * returns first allocated block from next leaf or EXT_MAX_BLOCKS
 229   */
 230  static ext4_lblk_t ext4_ext_next_leaf_block(struct inode *inode,
 231                                         struct ext4_ext_path *path)
 232 @@ -1377,7 +1377,7 @@ static ext4_lblk_t ext4_ext_next_leaf_bl
 233
 234         /* zero-tree has no leaf blocks at all */
 235         if (depth == 0)
 236 -               return EXT_MAX_BLOCK;
 237 +               return EXT_MAX_BLOCKS;
 238
 239         /* go to index block */
 240         depth--;
 241 @@ -1390,7 +1390,7 @@ static ext4_lblk_t ext4_ext_next_leaf_bl
 242                 depth--;
 243         }
 244
 245 -       return EXT_MAX_BLOCK;
 246 +       return EXT_MAX_BLOCKS;
 247  }
 248
 249  /*
 250 @@ -1534,7 +1534,7 @@ int ext4_ext_try_to_merge(struct inode *
 251                 merge_done = 1;
 252                 WARN_ON(eh->eh_entries == 0);
 253                 if (!eh->eh_entries)
 254 -                       ext4_error(inode->i_sb, "ext4_ext_try_to_merge",
 255 +                       ext4_error(inode->i_sb,
 256                            "inode#%lu, eh->eh_entries = 0!", inode->i_ino);
 257         }
 258
 259 @@ -1570,13 +1570,13 @@ unsigned int ext4_ext_check_overlap(stru
 260          */
 261         if (b2 < b1) {
 262                 b2 = ext4_ext_next_allocated_block(path);
 263 -               if (b2 == EXT_MAX_BLOCK)
 264 +               if (b2 == EXT_MAX_BLOCKS)
 265                         goto out;
 266         }
 267
 268         /* check for wrap through zero on extent logical start block*/
 269         if (b1 + len1 < b1) {
 270 -               len1 = EXT_MAX_BLOCK - b1;
 271 +               len1 = EXT_MAX_BLOCKS - b1;
 272                 newext->ee_len = cpu_to_le16(len1);
 273                 ret = 1;
 274         }
 275 @@ -1652,7 +1652,7 @@ repeat:
 276         fex = EXT_LAST_EXTENT(eh);
 277         next = ext4_ext_next_leaf_block(inode, path);
 278         if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block)
 279 -           && next != EXT_MAX_BLOCK) {
 280 +           && next != EXT_MAX_BLOCKS) {
 281                 ext_debug("next leaf block - %d\n", next);
 282                 BUG_ON(npath != NULL);
 283                 npath = ext4_ext_find_extent(inode, next, NULL);
 284 @@ -1771,7 +1771,7 @@ int ext4_ext_walk_space(struct inode *in
 285         BUG_ON(func == NULL);
 286         BUG_ON(inode == NULL);
 287
 288 -       while (block < last && block != EXT_MAX_BLOCK) {
 289 +       while (block < last && block != EXT_MAX_BLOCKS) {
 290                 num = last - block;
 291                 /* find extent for this block */
 292                 down_read(&EXT4_I(inode)->i_data_sem);
 293 @@ -1784,7 +1784,11 @@ int ext4_ext_walk_space(struct inode *in
 294                 }
 295
 296                 depth = ext_depth(inode);
 297 -               BUG_ON(path[depth].p_hdr == NULL);
 298 +               if (unlikely(path[depth].p_hdr == NULL)) {
 299 +                       EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
 300 +                       err = -EIO;
 301 +                       break;
 302 +               }
 303                 ex = path[depth].p_ext;
 304                 next = ext4_ext_next_allocated_block(path);
 305
 306 @@ -1835,7 +1839,11 @@ int ext4_ext_walk_space(struct inode *in
 307                         cbex.ec_type = EXT4_EXT_CACHE_EXTENT;
 308                 }
 309
 310 -               BUG_ON(cbex.ec_len == 0);
 311 +               if (unlikely(cbex.ec_len == 0)) {
 312 +                       EXT4_ERROR_INODE(inode, "cbex.ec_len == 0");
 313 +                       err = -EIO;
 314 +                       break;
 315 +               }
 316                 err = func(inode, path, &cbex, ex, cbdata);
 317                 ext4_ext_drop_refs(path);
 318
 319 @@ -1899,7 +1907,7 @@ ext4_ext_put_gap_in_cache(struct inode *
 320         if (ex == NULL) {
 321                 /* there is no extent yet, so gap is [0;-] */
 322                 lblock = 0;
 323 -               len = EXT_MAX_BLOCK;
 324 +               len = EXT_MAX_BLOCKS;
 325                 ext_debug("cache gap(whole file):");
 326         } else if (block < le32_to_cpu(ex->ee_block)) {
 327                 lblock = block;
 328 @@ -2144,8 +2152,8 @@ ext4_ext_rm_leaf(handle_t *handle, struc
 329                 path[depth].p_ext = ex;
 330
 331                 a = ex_ee_block > start ? ex_ee_block : start;
 332 -               b = ex_ee_block + ex_ee_len - 1 < EXT_MAX_BLOCK ?
 333 -                       ex_ee_block + ex_ee_len - 1 : EXT_MAX_BLOCK;
 334 +               b = ex_ee_block + ex_ee_len - 1 < EXT_MAX_BLOCKS ?
 335 +                       ex_ee_block + ex_ee_len - 1 : EXT_MAX_BLOCKS;
 336
 337                 ext_debug("  border %u:%u\n", a, b);
 338
 339 @@ -3284,7 +3292,7 @@ int ext4_ext_get_blocks(handle_t *handle
 340          * this is why assert can't be put in ext4_ext_find_extent()
 341          */
 342         if (path[depth].p_ext == NULL && depth != 0) {
 343 -               ext4_error(inode->i_sb, __func__, "bad extent address "
 344 +               ext4_error(inode->i_sb, "bad extent address "
 345                            "inode: %lu, iblock: %lu, depth: %d",
 346                            inode->i_ino, (unsigned long) iblock, depth);
 347                 err = -EIO;
 348 @@ -3415,7 +3423,7 @@ int ext4_ext_get_blocks(handle_t *handle
 349
 350         if (unlikely(ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS))) {
 351                 if (unlikely(!eh->eh_entries)) {
 352 -                       ext4_error(inode->i_sb, __func__,
 353 +                       ext4_error(inode->i_sb,
 354                                    "inode#%lu, eh->eh_entries = 0 and "
 355                                    "EOFBLOCKS_FL set", inode->i_ino);
 356                         err = -EIO;
 357 @@ -3782,15 +3790,15 @@ static int ext4_ext_fiemap_cb(struct ino
 358                 flags |= FIEMAP_EXTENT_UNWRITTEN;
 359
 360         /*
 361 -        * If this extent reaches EXT_MAX_BLOCK, it must be last.
 362 +        * If this extent reaches EXT_MAX_BLOCKS, it must be last.
 363          *
 364 -        * Or if ext4_ext_next_allocated_block is EXT_MAX_BLOCK,
 365 +        * Or if ext4_ext_next_allocated_block is EXT_MAX_BLOCKS,
 366          * this also indicates no more allocated blocks.
 367          *
 368 -        * XXX this might miss a single-block extent at EXT_MAX_BLOCK
 369 +        * XXX this might miss a single-block extent at EXT_MAX_BLOCKS
 370          */
 371 -       if (ext4_ext_next_allocated_block(path) == EXT_MAX_BLOCK ||
 372 -           newex->ec_block + newex->ec_len - 1 == EXT_MAX_BLOCK) {
 373 +       if (ext4_ext_next_allocated_block(path) == EXT_MAX_BLOCKS ||
 374 +           newex->ec_block + newex->ec_len - 1 == EXT_MAX_BLOCKS) {
 375                 loff_t size = i_size_read(inode);
 376                 loff_t bs = EXT4_BLOCK_SIZE(inode->i_sb);
 377
 378 @@ -3870,8 +3878,8 @@ int ext4_fiemap(struct inode *inode, str
 379
 380                 start_blk = start >> inode->i_sb->s_blocksize_bits;
 381                 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
 382 -               if (last_blk >= EXT_MAX_BLOCK)
 383 -                       last_blk = EXT_MAX_BLOCK-1;
 384 +               if (last_blk >= EXT_MAX_BLOCKS)
 385 +                       last_blk = EXT_MAX_BLOCKS-1;
 386                 len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1;
 387
 388                 /*
 389 diff -urpN linux-stage.orig/fs/ext4/ialloc.c linux-stage/fs/ext4/ialloc.c
 390 --- linux-stage.orig/fs/ext4/ialloc.c   2011-12-28 08:18:31.000000000 -0500
 391 +++ linux-stage/fs/ext4/ialloc.c        2011-12-28 11:24:07.000000000 -0500
 392 @@ -76,7 +76,7 @@ unsigned ext4_init_inode_bitmap(struct s
 393         /* If checksum is bad mark all blocks and inodes use to prevent
 394          * allocation, essentially implementing a per-group read-only flag. */
 395         if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
 396 -               ext4_error(sb, __func__, "Checksum bad for group %u",
 397 +               ext4_error(sb, "Checksum bad for group %u",
 398                            block_group);
 399                 ext4_free_blks_set(sb, gdp, 0);
 400                 ext4_free_inodes_set(sb, gdp, 0);
 401 @@ -111,7 +111,7 @@ ext4_read_inode_bitmap(struct super_bloc
 402         bitmap_blk = ext4_inode_bitmap(sb, desc);
 403         bh = sb_getblk(sb, bitmap_blk);
 404         if (unlikely(!bh)) {
 405 -               ext4_error(sb, __func__,
 406 +               ext4_error(sb,
 407                             "Cannot read inode bitmap - "
 408                             "block_group = %u, inode_bitmap = %llu",
 409                             block_group, bitmap_blk);
 410 @@ -153,7 +153,7 @@ ext4_read_inode_bitmap(struct super_bloc
 411         set_bitmap_uptodate(bh);
 412         if (bh_submit_read(bh) < 0) {
 413                 put_bh(bh);
 414 -               ext4_error(sb, __func__,
 415 +               ext4_error(sb,
 416                             "Cannot read inode bitmap - "
 417                             "block_group = %u, inode_bitmap = %llu",
 418                             block_group, bitmap_blk);
 419 @@ -230,8 +230,7 @@ void ext4_free_inode(handle_t *handle, s
 420
 421         es = EXT4_SB(sb)->s_es;
 422         if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
 423 -               ext4_error(sb, "ext4_free_inode",
 424 -                          "reserved or nonexistent inode %lu", ino);
 425 +               ext4_error(sb, "reserved or nonexistent inode %lu", ino);
 426                 goto error_return;
 427         }
 428         block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
 429 @@ -286,11 +285,10 @@ out:
 430                         fatal = err;
 431                 sb->s_dirt = 1;
 432         } else
 433 -               ext4_error(sb, "ext4_free_inode",
 434 -                          "bit already cleared for inode %lu", ino);
 435 +               ext4_error(sb, "bit already cleared for inode %lu", ino);
 436
 437  error_return:
 438 -       brelse(bitmap_bh);
 439 +       brelse(bitmap_bh);
 440         ext4_std_error(sb, fatal);
 441  }
 442
 443 @@ -730,7 +728,7 @@ static int ext4_claim_inode(struct super
 444         if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
 445                         ino > EXT4_INODES_PER_GROUP(sb)) {
 446                 ext4_unlock_group(sb, group);
 447 -               ext4_error(sb, __func__,
 448 +               ext4_error(sb,
 449                            "reserved inode or inode > inodes count - "
 450                            "block_group = %u, inode=%lu", group,
 451                            ino + group * EXT4_INODES_PER_GROUP(sb));
 452 @@ -1094,7 +1092,7 @@ struct inode *ext4_orphan_get(struct sup
 453
 454         /* Error cases - e2fsck has already cleaned up for us */
 455         if (ino > max_ino) {
 456 -               ext4_warning(sb, __func__,
 457 +               ext4_warning(sb,
 458                              "bad orphan ino %lu!  e2fsck was run?", ino);
 459                 goto error;
 460         }
 461 @@ -1103,7 +1101,7 @@ struct inode *ext4_orphan_get(struct sup
 462         bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
 463         bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
 464         if (!bitmap_bh) {
 465 -               ext4_warning(sb, __func__,
 466 +               ext4_warning(sb,
 467                              "inode bitmap error for orphan %lu", ino);
 468                 goto error;
 469         }
 470 @@ -1136,7 +1134,7 @@ iget_failed:
 471         err = PTR_ERR(inode);
 472         inode = NULL;
 473  bad_orphan:
 474 -       ext4_warning(sb, __func__,
 475 +       ext4_warning(sb,
 476                      "bad orphan inode %lu!  e2fsck was run?", ino);
 477         printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
 478                bit, (unsigned long long)bitmap_bh->b_blocknr,
 479 diff -urpN linux-stage.orig/fs/ext4/inode.c linux-stage/fs/ext4/inode.c
 480 --- linux-stage.orig/fs/ext4/inode.c    2011-12-28 08:18:31.000000000 -0500
 481 +++ linux-stage/fs/ext4/inode.c 2011-12-28 11:24:07.000000000 -0500
 482 @@ -246,7 +246,7 @@ void ext4_delete_inode(struct inode *ino
 483         inode->i_size = 0;
 484         err = ext4_mark_inode_dirty(handle, inode);
 485         if (err) {
 486 -               ext4_warning(inode->i_sb, __func__,
 487 +               ext4_warning(inode->i_sb,
 488                              "couldn't mark inode dirty (err %d)", err);
 489                 goto stop_handle;
 490         }
 491 @@ -264,7 +264,7 @@ void ext4_delete_inode(struct inode *ino
 492                 if (err > 0)
 493                         err = ext4_journal_restart(handle, 3);
 494                 if (err != 0) {
 495 -                       ext4_warning(inode->i_sb, __func__,
 496 +                       ext4_warning(inode->i_sb,
 497                                      "couldn't extend journal (err %d)", err);
 498                 stop_handle:
 499                         ext4_journal_stop(handle);
 500 @@ -375,8 +375,7 @@ static int ext4_block_to_path(struct ino
 501                 offsets[n++] = i_block & (ptrs - 1);
 502                 final = ptrs;
 503         } else {
 504 -               ext4_warning(inode->i_sb, "ext4_block_to_path",
 505 -                            "block %lu > max in inode %lu",
 506 +               ext4_warning(inode->i_sb, "block %lu > max in inode %lu",
 507                              i_block + direct_blocks +
 508                              indirect_blocks + double_blocks, inode->i_ino);
 509         }
 510 @@ -396,7 +395,7 @@ static int __ext4_check_blockref(const c
 511                 if (blk &&
 512                     unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
 513                                                     blk, 1))) {
 514 -                       ext4_error(inode->i_sb, function,
 515 +                       ext4_error(inode->i_sb,
 516                                    "invalid block reference %u "
 517                                    "in inode #%lu", blk, inode->i_ino);
 518                         return -EIO;
 519 @@ -1167,7 +1166,7 @@ static int check_block_validity(struct i
 520                                 sector_t logical, sector_t phys, int len)
 521  {
 522         if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), phys, len)) {
 523 -               ext4_error(inode->i_sb, msg,
 524 +               ext4_error(inode->i_sb,
 525                            "inode #%lu logical block %llu mapped to %llu "
 526                            "(size %d)", inode->i_ino,
 527                            (unsigned long long) logical,
 528 @@ -4316,7 +4315,7 @@ static void ext4_free_data(handle_t *han
 529                 if ((EXT4_JOURNAL(inode) == NULL) || bh2jh(this_bh))
 530                         ext4_handle_dirty_metadata(handle, inode, this_bh);
 531                 else
 532 -                       ext4_error(inode->i_sb, __func__,
 533 +                       ext4_error(inode->i_sb,
 534                                    "circular indirect block detected, "
 535                                    "inode=%lu, block=%llu",
 536                                    inode->i_ino,
 537 @@ -4364,7 +4363,7 @@ static void ext4_free_branches(handle_t
 538                          * (should be rare).
 539                          */
 540                         if (!bh) {
 541 -                               ext4_error(inode->i_sb, "ext4_free_branches",
 542 +                               ext4_error(inode->i_sb,
 543                                            "Read failure, inode=%lu, block=%llu",
 544                                            inode->i_ino, nr);
 545                                 continue;
 546 @@ -4680,9 +4679,8 @@ static int __ext4_get_inode_loc(struct i
 547
 548         bh = sb_getblk(sb, block);
 549         if (!bh) {
 550 -               ext4_error(sb, "ext4_get_inode_loc", "unable to read "
 551 -                          "inode block - inode=%lu, block=%llu",
 552 -                          inode->i_ino, block);
 553 +               ext4_error(sb, "unable to read inode block - "
 554 +                          "inode=%lu, block=%llu", inode->i_ino, block);
 555                 return -EIO;
 556         }
 557         if (!buffer_uptodate(bh)) {
 558 @@ -4780,7 +4778,7 @@ make_io:
 559                 submit_bh(READ_META, bh);
 560                 wait_on_buffer(bh);
 561                 if (!buffer_uptodate(bh)) {
 562 -                       ext4_error(sb, __func__,
 563 +                       ext4_error(sb,
 564                                    "unable to read inode block - inode=%lu, "
 565                                    "block=%llu", inode->i_ino, block);
 566                         brelse(bh);
 567 @@ -4999,7 +4997,7 @@ struct inode *ext4_iget(struct super_blo
 568         ret = 0;
 569         if (ei->i_file_acl &&
 570             !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
 571 -               ext4_error(sb, __func__,
 572 +               ext4_error(sb,
 573                            "bad extended attribute block %llu in inode #%lu",
 574                            ei->i_file_acl, inode->i_ino);
 575                 ret = -EIO;
 576 @@ -5046,7 +5044,7 @@ struct inode *ext4_iget(struct super_blo
 577                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
 578         } else {
 579                 ret = -EIO;
 580 -               ext4_error(inode->i_sb, __func__,
 581 +               ext4_error(inode->i_sb,
 582                            "bogus i_mode (%o) for inode=%lu",
 583                            inode->i_mode, inode->i_ino);
 584                 goto bad_inode;
 585 @@ -5286,7 +5284,7 @@ int ext4_write_inode(struct inode *inode
 586                 if (wait)
 587                         sync_dirty_buffer(iloc.bh);
 588                 if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
 589 -                       ext4_error(inode->i_sb, __func__,
 590 +                       ext4_error(inode->i_sb,
 591                                    "IO error syncing inode, "
 592                                    "inode=%lu, block=%llu",
 593                                    inode->i_ino,
 594 @@ -5707,7 +5705,7 @@ int ext4_mark_inode_dirty(handle_t *hand
 595                                                      EXT4_STATE_NO_EXPAND);
 596                                 if (mnt_count !=
 597                                         le16_to_cpu(sbi->s_es->s_mnt_count)) {
 598 -                                       ext4_warning(inode->i_sb, __func__,
 599 +                                       ext4_warning(inode->i_sb,
 600                                         "Unable to expand inode %lu. Delete"
 601                                         " some EAs or run e2fsck.",
 602                                         inode->i_ino);
 603 diff -urpN linux-stage.orig/fs/ext4/mballoc.c linux-stage/fs/ext4/mballoc.c
 604 --- linux-stage.orig/fs/ext4/mballoc.c  2011-12-28 08:18:31.000000000 -0500
 605 +++ linux-stage/fs/ext4/mballoc.c       2011-12-28 11:24:07.000000000 -0500
 606 @@ -1862,7 +1862,6 @@ void ext4_mb_scan_aligned(struct ext4_al
 607         }
 608  }
 609
 610 -/* This is now called BEFORE we load the buddy bitmap. */
 611  static int ext4_mb_good_group(struct ext4_allocation_context *ac,
 612                                 ext4_group_t group, int cr)
 613  {
 614 @@ -2162,6 +2161,11 @@ static void *ext4_mb_seq_groups_next(str
 615         return (void *) ((unsigned long) group);
 616  }
 617
 618 +static inline void ext4_mb_release_desc(struct ext4_buddy *e4b)
 619 +{
 620 +       ext4_mb_unload_buddy(e4b);
 621 +}
 622 +
 623  static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
 624  {
 625         struct super_block *sb = seq->private;
 626 @@ -2193,7 +2197,7 @@ static int ext4_mb_seq_groups_show(struc
 627         ext4_lock_group(sb, group);
 628         memcpy(&sg, ext4_get_group_info(sb, group), i);
 629         ext4_unlock_group(sb, group);
 630 -       ext4_mb_unload_buddy(&e4b);
 631 +       ext4_mb_release_desc(&e4b);
 632
 633         seq_printf(seq, "#%-5u: %-5u %-5u %-5u [", group, sg.info.bb_free,
 634                         sg.info.bb_fragments, sg.info.bb_first_free);
 635 @@ -2562,6 +2566,17 @@ int ext4_mb_release(struct super_block *
 636         return 0;
 637  }
 638
 639 +static inline int ext4_issue_discard(struct super_block *sb,
 640 +               ext4_group_t block_group, ext4_grpblk_t block, int count)
 641 +{
 642 +       ext4_fsblk_t discard_block;
 643 +
 644 +       discard_block = block + ext4_group_first_block_no(sb, block_group);
 645 +       trace_ext4_discard_blocks(sb,
 646 +                       (unsigned long long) discard_block, count);
 647 +       return sb_issue_discard(sb, discard_block, count);
 648 +}
 649 +
 650  /*
 651   * This function is called by the jbd2 layer once the commit has finished,
 652   * so we know we can free the blocks that were released with that commit.
 653 @@ -2583,17 +2598,11 @@ static void release_blocks_on_commit(jou
 654
 655                 if (test_opt(sb, DISCARD)) {
 656                         int ret;
 657 -                       ext4_fsblk_t discard_block;
 658 -
 659 -                       discard_block = entry->start_blk +
 660 -                               ext4_group_first_block_no(sb, entry->group);
 661 -                       trace_ext4_discard_blocks(sb,
 662 -                                       (unsigned long long)discard_block,
 663 -                                       entry->count);
 664 -                       ret = sb_issue_discard(sb, discard_block, entry->count);
 665 -                       if (ret == EOPNOTSUPP) {
 666 -                               ext4_warning(sb, __func__,
 667 -                                       "discard not supported, disabling");
 668 +                       ret = ext4_issue_discard(sb, entry->group,
 669 +                                       entry->start_blk, entry->count);
 670 +                       if (unlikely(ret == -EOPNOTSUPP)) {
 671 +                               ext4_warning(sb, "discard not supported, "
 672 +                                                "disabling");
 673                                 clear_opt(EXT4_SB(sb)->s_mount_opt, DISCARD);
 674                         }
 675                 }
 676 @@ -2620,7 +2629,7 @@ static void release_blocks_on_commit(jou
 677                 }
 678                 ext4_unlock_group(sb, entry->group);
 679                 kmem_cache_free(ext4_free_ext_cachep, entry);
 680 -               ext4_mb_unload_buddy(&e4b);
 681 +               ext4_mb_release_desc(&e4b);
 682         }
 683
 684         mb_debug(1, "freed %u blocks in %u structures\n", count, count2);
 685 @@ -2757,7 +2766,7 @@ ext4_mb_mark_diskspace_used(struct ext4_
 686
 687         len = ac->ac_b_ex.fe_len;
 688         if (!ext4_data_block_valid(sbi, block, len)) {
 689 -               ext4_error(sb, __func__,
 690 +               ext4_error(sb,
 691                            "Allocating blocks %llu-%llu which overlap "
 692                            "fs metadata\n", block, block+len);
 693                 /* File system mounted not to panic on error
 694 @@ -3671,14 +3680,14 @@ ext4_mb_discard_group_preallocations(str
 695
 696         bitmap_bh = ext4_read_block_bitmap(sb, group);
 697         if (bitmap_bh == NULL) {
 698 -               ext4_error(sb, __func__, "Error in reading block "
 699 +               ext4_error(sb, "Error in reading block "
 700                                 "bitmap for %u", group);
 701                 return 0;
 702         }
 703
 704         err = ext4_mb_load_buddy(sb, group, &e4b);
 705         if (err) {
 706 -               ext4_error(sb, __func__, "Error in loading buddy "
 707 +               ext4_error(sb, "Error in loading buddy "
 708                                 "information for %u", group);
 709                 put_bh(bitmap_bh);
 710                 return 0;
 711 @@ -3852,14 +3861,14 @@ repeat:
 712
 713                 err = ext4_mb_load_buddy(sb, group, &e4b);
 714                 if (err) {
 715 -                       ext4_error(sb, __func__, "Error in loading buddy "
 716 -                                       "information for %u", group);
 717 +                       ext4_error(sb, "Error in loading buddy information for %u",
 718 +                                       group);
 719                         continue;
 720                 }
 721
 722                 bitmap_bh = ext4_read_block_bitmap(sb, group);
 723                 if (bitmap_bh == NULL) {
 724 -                       ext4_error(sb, __func__, "Error in reading block "
 725 +                       ext4_error(sb, "Error in reading block "
 726                                         "bitmap for %u", group);
 727                         ext4_mb_unload_buddy(&e4b);
 728                         continue;
 729 @@ -4125,7 +4134,7 @@ ext4_mb_discard_lg_preallocations(struct
 730
 731                 ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, NULL);
 732                 if (ext4_mb_load_buddy(sb, group, &e4b)) {
 733 -                       ext4_error(sb, __func__, "Error in loading buddy "
 734 +                       ext4_error(sb, "Error in loading buddy "
 735                                         "information for %u", group);
 736                         continue;
 737                 }
 738 @@ -4516,7 +4525,7 @@ void ext4_mb_free_blocks(handle_t *handl
 739         if (block < le32_to_cpu(es->s_first_data_block) ||
 740             block + count < block ||
 741             block + count > ext4_blocks_count(es)) {
 742 -               ext4_error(sb, __func__,
 743 +               ext4_error(sb,
 744                             "Freeing blocks not in datazone - "
 745                             "block = %llu, count = %lu", block, count);
 746                 goto error_return;
 747 @@ -4561,7 +4570,7 @@ do_more:
 748             in_range(block + count - 1, ext4_inode_table(sb, gdp),
 749                       EXT4_SB(sb)->s_itb_per_group)) {
 750
 751 -               ext4_error(sb, __func__,
 752 +               ext4_error(sb,
 753                            "Freeing blocks in system zone - "
 754                            "Block = %llu, count = %lu", block, count);
 755                 /* err = 0. ext4_std_error should be a no op */
 756 diff -urpN linux-stage.orig/fs/ext4/move_extent.c linux-stage/fs/ext4/move_extent.c
 757 --- linux-stage.orig/fs/ext4/move_extent.c      2011-12-28 08:18:31.000000000 -0500
 758 +++ linux-stage/fs/ext4/move_extent.c   2011-12-28 11:24:07.000000000 -0500
 759 @@ -152,12 +152,12 @@ mext_check_null_inode(struct inode *inod
 760         int ret = 0;
 761
 762         if (inode1 == NULL) {
 763 -               ext4_error(inode2->i_sb, function,
 764 +               ext4_error(inode2->i_sb,
 765                         "Both inodes should not be NULL: "
 766                         "inode1 NULL inode2 %lu", inode2->i_ino);
 767                 ret = -EIO;
 768         } else if (inode2 == NULL) {
 769 -               ext4_error(inode1->i_sb, function,
 770 +               ext4_error(inode1->i_sb,
 771                         "Both inodes should not be NULL: "
 772                         "inode1 %lu inode2 NULL", inode1->i_ino);
 773                 ret = -EIO;
 774 @@ -528,7 +528,7 @@ mext_leaf_block(handle_t *handle, struct
 775          * new_ext       |-------|
 776          */
 777         if (le32_to_cpu(oext->ee_block) + oext_alen - 1 < new_ext_end) {
 778 -               ext4_error(orig_inode->i_sb, __func__,
 779 +               ext4_error(orig_inode->i_sb,
 780                         "new_ext_end(%u) should be less than or equal to "
 781                         "oext->ee_block(%u) + oext_alen(%d) - 1",
 782                         new_ext_end, le32_to_cpu(oext->ee_block),
 783 @@ -691,12 +691,12 @@ mext_replace_branches(handle_t *handle,
 784         while (1) {
 785                 /* The extent for donor must be found. */
 786                 if (!dext) {
 787 -                       ext4_error(donor_inode->i_sb, __func__,
 788 +                       ext4_error(donor_inode->i_sb,
 789                                    "The extent for donor must be found");
 790                         *err = -EIO;
 791                         goto out;
 792                 } else if (donor_off != le32_to_cpu(tmp_dext.ee_block)) {
 793 -                       ext4_error(donor_inode->i_sb, __func__,
 794 +                       ext4_error(donor_inode->i_sb,
 795                                 "Donor offset(%u) and the first block of donor "
 796                                 "extent(%u) should be equal",
 797                                 donor_off,
 798 @@ -1001,12 +1001,12 @@ mext_check_arguments(struct inode *orig_
 799                 return -EINVAL;
 800         }
 801
 802 -       if ((orig_start > EXT_MAX_BLOCK) ||
 803 -           (donor_start > EXT_MAX_BLOCK) ||
 804 -           (*len > EXT_MAX_BLOCK) ||
 805 -           (orig_start + *len > EXT_MAX_BLOCK))  {
 806 +       if ((orig_start > EXT_MAX_BLOCKS) ||
 807 +           (donor_start > EXT_MAX_BLOCKS) ||
 808 +           (*len > EXT_MAX_BLOCKS) ||
 809 +           (orig_start + *len > EXT_MAX_BLOCKS))  {
 810                 ext4_debug("ext4 move extent: Can't handle over [%u] blocks "
 811 -                       "[ino:orig %lu, donor %lu]\n", EXT_MAX_BLOCK,
 812 +                       "[ino:orig %lu, donor %lu]\n", EXT_MAX_BLOCKS,
 813                         orig_inode->i_ino, donor_inode->i_ino);
 814                 return -EINVAL;
 815         }
 816 @@ -1356,7 +1356,7 @@ ext4_move_extents(struct file *o_filp, s
 817                         if (ret1 < 0)
 818                                 break;
 819                         if (*moved_len > len) {
 820 -                               ext4_error(orig_inode->i_sb, __func__,
 821 +                               ext4_error(orig_inode->i_sb,
 822                                         "We replaced blocks too much! "
 823                                         "sum of replaced: %llu requested: %llu",
 824                                         *moved_len, len);
 825 diff -urpN linux-stage.orig/fs/ext4/namei.c linux-stage/fs/ext4/namei.c
 826 --- linux-stage.orig/fs/ext4/namei.c    2011-12-28 08:18:31.000000000 -0500
 827 +++ linux-stage/fs/ext4/namei.c 2011-12-28 11:28:51.000000000 -0500
 828 @@ -394,8 +394,7 @@ dx_probe(const struct qstr *d_name, stru
 829         if (root->info.hash_version != DX_HASH_TEA &&
 830             root->info.hash_version != DX_HASH_HALF_MD4 &&
 831             root->info.hash_version != DX_HASH_LEGACY) {
 832 -               ext4_warning(dir->i_sb, __func__,
 833 -                            "Unrecognised inode hash code %d",
 834 +               ext4_warning(dir->i_sb, "Unrecognised inode hash code %d",
 835                              root->info.hash_version);
 836                 brelse(bh);
 837                 *err = ERR_BAD_DX_DIR;
 838 @@ -410,8 +409,7 @@ dx_probe(const struct qstr *d_name, stru
 839         hash = hinfo->hash;
 840
 841         if (root->info.unused_flags & 1) {
 842 -               ext4_warning(dir->i_sb, __func__,
 843 -                            "Unimplemented inode hash flags: %#06x",
 844 +               ext4_warning(dir->i_sb, "Unimplemented inode hash flags: %#06x",
 845                              root->info.unused_flags);
 846                 brelse(bh);
 847                 *err = ERR_BAD_DX_DIR;
 848 @@ -419,8 +417,7 @@ dx_probe(const struct qstr *d_name, stru
 849         }
 850
 851         if ((indirect = root->info.indirect_levels) > 1) {
 852 -               ext4_warning(dir->i_sb, __func__,
 853 -                            "Unimplemented inode hash depth: %#06x",
 854 +               ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x",
 855                              root->info.indirect_levels);
 856                 brelse(bh);
 857                 *err = ERR_BAD_DX_DIR;
 858 @@ -432,8 +429,7 @@ dx_probe(const struct qstr *d_name, stru
 859
 860         if (dx_get_limit(entries) != dx_root_limit(dir,
 861                                                    root->info.info_length)) {
 862 -               ext4_warning(dir->i_sb, __func__,
 863 -                            "dx entry: limit != root limit");
 864 +               ext4_warning(dir->i_sb, "dx entry: limit != root limit");
 865                 brelse(bh);
 866                 *err = ERR_BAD_DX_DIR;
 867                 goto fail;
 868 @@ -444,7 +440,7 @@ dx_probe(const struct qstr *d_name, stru
 869         {
 870                 count = dx_get_count(entries);
 871                 if (!count || count > dx_get_limit(entries)) {
 872 -                       ext4_warning(dir->i_sb, __func__,
 873 +                       ext4_warning(dir->i_sb,
 874                                      "dx entry: no count or count > limit");
 875                         brelse(bh);
 876                         *err = ERR_BAD_DX_DIR;
 877 @@ -489,7 +485,7 @@ dx_probe(const struct qstr *d_name, stru
 878                         goto fail2;
 879                 at = entries = ((struct dx_node *) bh->b_data)->entries;
 880                 if (dx_get_limit(entries) != dx_node_limit (dir)) {
 881 -                       ext4_warning(dir->i_sb, __func__,
 882 +                       ext4_warning(dir->i_sb,
 883                                      "dx entry: limit != node limit");
 884                         brelse(bh);
 885                         *err = ERR_BAD_DX_DIR;
 886 @@ -505,7 +501,7 @@ fail2:
 887         }
 888  fail:
 889         if (*err == ERR_BAD_DX_DIR)
 890 -               ext4_warning(dir->i_sb, __func__,
 891 +               ext4_warning(dir->i_sb,
 892                              "Corrupt dir inode %ld, running e2fsck is "
 893                              "recommended.", dir->i_ino);
 894         return NULL;
 895 @@ -969,7 +965,7 @@ restart:
 896                 wait_on_buffer(bh);
 897                 if (!buffer_uptodate(bh)) {
 898                         /* read error, skip block & hope for the best */
 899 -                       ext4_error(sb, __func__, "reading directory #%lu "
 900 +                       ext4_error(sb, "reading directory #%lu "
 901                                    "offset %lu", dir->i_ino,
 902                                    (unsigned long)block);
 903                         brelse(bh);
 904 @@ -1012,8 +1008,9 @@ cleanup_and_exit:
 905  static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct qstr *d_name,
 906                        struct ext4_dir_entry_2 **res_dir, int *err)
 907  {
 908 -       struct super_block * sb = dir->i_sb;
 909 +       struct super_block * sb;
 910         struct dx_hash_info     hinfo;
 911 +       u32 hash;
 912         struct dx_frame frames[2], *frame;
 913         struct ext4_dir_entry_2 *de, *top;
 914         struct buffer_head *bh;
 915 @@ -1022,8 +1019,18 @@ static struct buffer_head * ext4_dx_find
 916         int namelen = d_name->len;
 917         const u8 *name = d_name->name;
 918
 919 -       if (!(frame = dx_probe(d_name, dir, &hinfo, frames, err)))
 920 -               return NULL;
 921 +       sb = dir->i_sb;
 922 +       /* NFS may look up ".." - look at dx_root directory block */
 923 +       if (namelen > 2 || name[0] != '.'||(name[1] != '.' && name[1] != '\0')){
 924 +               if (!(frame = dx_probe(d_name, dir, &hinfo, frames, err)))
 925 +                       return NULL;
 926 +       } else {
 927 +               frame = frames;
 928 +               frame->bh = NULL;                       /* for dx_release() */
 929 +               frame->at = (struct dx_entry *)frames;  /* hack for zero entry*/
 930 +               dx_set_block(frame->at, 0);             /* dx_root block is 0 */
 931 +       }
 932 +       hash = hinfo.hash;
 933         do {
 934                 block = dx_get_block(frame->at);
 935                 if (!(bh = ext4_bread (NULL,dir, block, 0, err)))
 936 @@ -1049,10 +1056,10 @@ static struct buffer_head * ext4_dx_find
 937                 }
 938                 brelse(bh);
 939                 /* Check to see if we should continue to search */
 940 -               retval = ext4_htree_next_block(dir, hinfo.hash, frame,
 941 +               retval = ext4_htree_next_block(dir, hash, frame,
 942                                                frames, NULL);
 943                 if (retval < 0) {
 944 -                       ext4_warning(sb, __func__,
 945 +                       ext4_warning(sb,
 946                              "error reading index page in directory #%lu",
 947                              dir->i_ino);
 948                         *err = retval;
 949 @@ -1082,14 +1089,13 @@ static struct dentry *ext4_lookup(struct
 950                 __u32 ino = le32_to_cpu(de->inode);
 951                 brelse(bh);
 952                 if (!ext4_valid_inum(dir->i_sb, ino)) {
 953 -                       ext4_error(dir->i_sb, "ext4_lookup",
 954 -                                  "bad inode number: %u", ino);
 955 +                       ext4_error(dir->i_sb, "bad inode number: %u", ino);
 956                         return ERR_PTR(-EIO);
 957                 }
 958                 inode = ext4_iget(dir->i_sb, ino);
 959                 if (unlikely(IS_ERR(inode))) {
 960                         if (PTR_ERR(inode) == -ESTALE) {
 961 -                               ext4_error(dir->i_sb, __func__,
 962 +                               ext4_error(dir->i_sb,
 963                                                 "deleted inode referenced: %u",
 964                                                 ino);
 965                                 return ERR_PTR(-EIO);
 966 @@ -1121,7 +1127,7 @@ struct dentry *ext4_get_parent(struct de
 967         brelse(bh);
 968
 969         if (!ext4_valid_inum(child->d_inode->i_sb, ino)) {
 970 -               ext4_error(child->d_inode->i_sb, "ext4_get_parent",
 971 +               ext4_error(child->d_inode->i_sb,
 972                            "bad inode number: %u", ino);
 973                 return ERR_PTR(-EIO);
 974         }
 975 @@ -1421,7 +1427,7 @@ static int make_indexed_dir(handle_t *ha
 976         de = (struct ext4_dir_entry_2 *)((char *)fde +
 977                 ext4_rec_len_from_disk(fde->rec_len, blocksize));
 978         if ((char *) de >= (((char *) root) + blocksize)) {
 979 -               ext4_error(dir->i_sb, __func__,
 980 +               ext4_error(dir->i_sb,
 981                            "invalid rec_len for '..' in inode %lu",
 982                            dir->i_ino);
 983                 brelse(bh);
 984 @@ -1588,8 +1594,7 @@ static int ext4_dx_add_entry(handle_t *h
 985
 986                 if (levels && (dx_get_count(frames->entries) ==
 987                                dx_get_limit(frames->entries))) {
 988 -                       ext4_warning(sb, __func__,
 989 -                                    "Directory index full!");
 990 +                       ext4_warning(sb, "Directory index full!");
 991                         err = -ENOSPC;
 992                         goto cleanup;
 993                 }
 994 @@ -1943,11 +1948,11 @@ static int empty_dir(struct inode *inode
 995         if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2) ||
 996             !(bh = ext4_bread(NULL, inode, 0, 0, &err))) {
 997                 if (err)
 998 -                       ext4_error(inode->i_sb, __func__,
 999 +                       ext4_error(inode->i_sb,
1000                                    "error %d reading directory #%lu offset 0",
1001                                    err, inode->i_ino);
1002                 else
1003 -                       ext4_warning(inode->i_sb, __func__,
1004 +                       ext4_warning(inode->i_sb,
1005                                      "bad directory (dir #%lu) - no data block",
1006                                      inode->i_ino);
1007                 return 1;
1008 @@ -1958,7 +1963,7 @@ static int empty_dir(struct inode *inode
1009                         !le32_to_cpu(de1->inode) ||
1010                         strcmp(".", de->name) ||
1011                         strcmp("..", de1->name)) {
1012 -               ext4_warning(inode->i_sb, "empty_dir",
1013 +               ext4_warning(inode->i_sb,
1014                              "bad directory (dir #%lu) - no `.' or `..'",
1015                              inode->i_ino);
1016                 brelse(bh);
1017 @@ -1976,7 +1981,7 @@ static int empty_dir(struct inode *inode
1018                                 offset >> EXT4_BLOCK_SIZE_BITS(sb), 0, &err);
1019                         if (!bh) {
1020                                 if (err)
1021 -                                       ext4_error(sb, __func__,
1022 +                                       ext4_error(sb,
1023                                                    "error %d reading directory"
1024                                                    " #%lu offset %u",
1025                                                    err, inode->i_ino, offset);
1026 @@ -2198,7 +2203,7 @@ static int ext4_rmdir(struct inode *dir,
1027         if (retval)
1028                 goto end_rmdir;
1029         if (!EXT4_DIR_LINK_EMPTY(inode))
1030 -               ext4_warning(inode->i_sb, "ext4_rmdir",
1031 +               ext4_warning(inode->i_sb,
1032                              "empty directory has too many links (%d)",
1033                              inode->i_nlink);
1034         inode->i_version++;
1035 @@ -2250,7 +2255,7 @@ static int ext4_unlink(struct inode *dir
1036                 goto end_unlink;
1037
1038         if (!inode->i_nlink) {
1039 -               ext4_warning(inode->i_sb, "ext4_unlink",
1040 +               ext4_warning(inode->i_sb,
1041                              "Deleting nonexistent file (%lu), %d",
1042                              inode->i_ino, inode->i_nlink);
1043                 inode->i_nlink = 1;
1044 @@ -2497,7 +2502,7 @@ static int ext4_rename(struct inode *old
1045                 }
1046         }
1047         if (retval) {
1048 -               ext4_warning(old_dir->i_sb, "ext4_rename",
1049 +               ext4_warning(old_dir->i_sb,
1050                                 "Deleting old file (%lu), %d, error=%d",
1051                                 old_dir->i_ino, old_dir->i_nlink, retval);
1052         }
1053 diff -urpN linux-stage.orig/fs/ext4/resize.c linux-stage/fs/ext4/resize.c
1054 --- linux-stage.orig/fs/ext4/resize.c   2011-12-28 08:18:31.000000000 -0500
1055 +++ linux-stage/fs/ext4/resize.c        2011-12-28 11:24:07.000000000 -0500
1056 @@ -48,63 +48,63 @@ static int verify_group_input(struct sup
1057
1058         ext4_get_group_no_and_offset(sb, start, NULL, &offset);
1059         if (group != sbi->s_groups_count)
1060 -               ext4_warning(sb, __func__,
1061 +               ext4_warning(sb,
1062                              "Cannot add at group %u (only %u groups)",
1063                              input->group, sbi->s_groups_count);
1064         else if (offset != 0)
1065 -                       ext4_warning(sb, __func__, "Last group not full");
1066 +                       ext4_warning(sb, "Last group not full");
1067         else if (input->reserved_blocks > input->blocks_count / 5)
1068 -               ext4_warning(sb, __func__, "Reserved blocks too high (%u)",
1069 +               ext4_warning(sb, "Reserved blocks too high (%u)",
1070                              input->reserved_blocks);
1071         else if (free_blocks_count < 0)
1072 -               ext4_warning(sb, __func__, "Bad blocks count %u",
1073 +               ext4_warning(sb, "Bad blocks count %u",
1074                              input->blocks_count);
1075         else if (!(bh = sb_bread(sb, end - 1)))
1076 -               ext4_warning(sb, __func__,
1077 +               ext4_warning(sb,
1078                              "Cannot read last block (%llu)",
1079                              end - 1);
1080         else if (outside(input->block_bitmap, start, end))
1081 -               ext4_warning(sb, __func__,
1082 +               ext4_warning(sb,
1083                              "Block bitmap not in group (block %llu)",
1084                              (unsigned long long)input->block_bitmap);
1085         else if (outside(input->inode_bitmap, start, end))
1086 -               ext4_warning(sb, __func__,
1087 +               ext4_warning(sb,
1088                              "Inode bitmap not in group (block %llu)",
1089                              (unsigned long long)input->inode_bitmap);
1090         else if (outside(input->inode_table, start, end) ||
1091                  outside(itend - 1, start, end))
1092 -               ext4_warning(sb, __func__,
1093 +               ext4_warning(sb,
1094                              "Inode table not in group (blocks %llu-%llu)",
1095                              (unsigned long long)input->inode_table, itend - 1);
1096         else if (input->inode_bitmap == input->block_bitmap)
1097 -               ext4_warning(sb, __func__,
1098 +               ext4_warning(sb,
1099                              "Block bitmap same as inode bitmap (%llu)",
1100                              (unsigned long long)input->block_bitmap);
1101         else if (inside(input->block_bitmap, input->inode_table, itend))
1102 -               ext4_warning(sb, __func__,
1103 +               ext4_warning(sb,
1104                              "Block bitmap (%llu) in inode table (%llu-%llu)",
1105                              (unsigned long long)input->block_bitmap,
1106                              (unsigned long long)input->inode_table, itend - 1);
1107         else if (inside(input->inode_bitmap, input->inode_table, itend))
1108 -               ext4_warning(sb, __func__,
1109 +               ext4_warning(sb,
1110                              "Inode bitmap (%llu) in inode table (%llu-%llu)",
1111                              (unsigned long long)input->inode_bitmap,
1112                              (unsigned long long)input->inode_table, itend - 1);
1113         else if (inside(input->block_bitmap, start, metaend))
1114 -               ext4_warning(sb, __func__,
1115 +               ext4_warning(sb,
1116                              "Block bitmap (%llu) in GDT table"
1117                              " (%llu-%llu)",
1118                              (unsigned long long)input->block_bitmap,
1119                              start, metaend - 1);
1120         else if (inside(input->inode_bitmap, start, metaend))
1121 -               ext4_warning(sb, __func__,
1122 +               ext4_warning(sb,
1123                              "Inode bitmap (%llu) in GDT table"
1124                              " (%llu-%llu)",
1125                              (unsigned long long)input->inode_bitmap,
1126                              start, metaend - 1);
1127         else if (inside(input->inode_table, start, metaend) ||
1128                  inside(itend - 1, start, metaend))
1129 -               ext4_warning(sb, __func__,
1130 +               ext4_warning(sb,
1131                              "Inode table (%llu-%llu) overlaps"
1132                              "GDT table (%llu-%llu)",
1133                              (unsigned long long)input->inode_table,
1134 @@ -364,7 +364,7 @@ static int verify_reserved_gdb(struct su
1135         while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
1136                 if (le32_to_cpu(*p++) !=
1137                     grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
1138 -                       ext4_warning(sb, __func__,
1139 +                       ext4_warning(sb,
1140                                      "reserved GDT %llu"
1141                                      " missing grp %d (%llu)",
1142                                      blk, grp,
1143 @@ -420,7 +420,7 @@ static int add_new_gdb(handle_t *handle,
1144           */
1145         if (EXT4_SB(sb)->s_sbh->b_blocknr !=
1146             le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
1147 -               ext4_warning(sb, __func__,
1148 +               ext4_warning(sb,
1149                         "won't resize using backup superblock at %llu",
1150                         (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
1151                 return -EPERM;
1152 @@ -444,7 +444,7 @@ static int add_new_gdb(handle_t *handle,
1153
1154         data = (__le32 *)dind->b_data;
1155         if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
1156 -               ext4_warning(sb, __func__,
1157 +               ext4_warning(sb,
1158                              "new group %u GDT block %llu not reserved",
1159                              input->group, gdblock);
1160                 err = -EINVAL;
1161 @@ -468,7 +468,7 @@ static int add_new_gdb(handle_t *handle,
1162                         GFP_NOFS);
1163         if (!n_group_desc) {
1164                 err = -ENOMEM;
1165 -               ext4_warning(sb, __func__,
1166 +               ext4_warning(sb,
1167                               "not enough memory for %lu groups", gdb_num + 1);
1168                 goto exit_inode;
1169         }
1170 @@ -567,7 +567,7 @@ static int reserve_backup_gdb(handle_t *
1171         /* Get each reserved primary GDT block and verify it holds backups */
1172         for (res = 0; res < reserved_gdb; res++, blk++) {
1173                 if (le32_to_cpu(*data) != blk) {
1174 -                       ext4_warning(sb, __func__,
1175 +                       ext4_warning(sb,
1176                                      "reserved block %llu"
1177                                      " not at offset %ld",
1178                                      blk,
1179 @@ -713,7 +713,7 @@ static void update_backups(struct super_
1180          */
1181  exit_err:
1182         if (err) {
1183 -               ext4_warning(sb, __func__,
1184 +               ext4_warning(sb,
1185                              "can't update backup for group %u (err %d), "
1186                              "forcing fsck on next reboot", group, err);
1187                 sbi->s_mount_state &= ~EXT4_VALID_FS;
1188 @@ -753,20 +753,20 @@ int ext4_group_add(struct super_block *s
1189
1190         if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
1191                                         EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
1192 -               ext4_warning(sb, __func__,
1193 +               ext4_warning(sb,
1194                              "Can't resize non-sparse filesystem further");
1195                 return -EPERM;
1196         }
1197
1198         if (ext4_blocks_count(es) + input->blocks_count <
1199             ext4_blocks_count(es)) {
1200 -               ext4_warning(sb, __func__, "blocks_count overflow");
1201 +               ext4_warning(sb, "blocks_count overflow");
1202                 return -EINVAL;
1203         }
1204
1205         if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
1206             le32_to_cpu(es->s_inodes_count)) {
1207 -               ext4_warning(sb, __func__, "inodes_count overflow");
1208 +               ext4_warning(sb, "inodes_count overflow");
1209                 return -EINVAL;
1210         }
1211
1212 @@ -774,13 +774,13 @@ int ext4_group_add(struct super_block *s
1213                 if (!EXT4_HAS_COMPAT_FEATURE(sb,
1214                                              EXT4_FEATURE_COMPAT_RESIZE_INODE)
1215                     || !le16_to_cpu(es->s_reserved_gdt_blocks)) {
1216 -                       ext4_warning(sb, __func__,
1217 +                       ext4_warning(sb,
1218                                      "No reserved GDT blocks, can't resize");
1219                         return -EPERM;
1220                 }
1221                 inode = ext4_iget(sb, EXT4_RESIZE_INO);
1222                 if (IS_ERR(inode)) {
1223 -                       ext4_warning(sb, __func__,
1224 +                       ext4_warning(sb,
1225                                      "Error opening resize inode");
1226                         return PTR_ERR(inode);
1227                 }
1228 @@ -810,7 +810,7 @@ int ext4_group_add(struct super_block *s
1229
1230         mutex_lock(&sbi->s_resize_lock);
1231         if (input->group != sbi->s_groups_count) {
1232 -               ext4_warning(sb, __func__,
1233 +               ext4_warning(sb,
1234                              "multiple resizers run on filesystem!");
1235                 err = -EBUSY;
1236                 goto exit_journal;
1237 @@ -998,12 +998,12 @@ int ext4_group_extend(struct super_block
1238                         " too large to resize to %llu blocks safely\n",
1239                         sb->s_id, n_blocks_count);
1240                 if (sizeof(sector_t) < 8)
1241 -                       ext4_warning(sb, __func__, "CONFIG_LBDAF not enabled");
1242 +                       ext4_warning(sb, "CONFIG_LBDAF not enabled");
1243                 return -EINVAL;
1244         }
1245
1246         if (n_blocks_count < o_blocks_count) {
1247 -               ext4_warning(sb, __func__,
1248 +               ext4_warning(sb,
1249                              "can't shrink FS - resize aborted");
1250                 return -EBUSY;
1251         }
1252 @@ -1012,7 +1012,7 @@ int ext4_group_extend(struct super_block
1253         ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1254
1255         if (last == 0) {
1256 -               ext4_warning(sb, __func__,
1257 +               ext4_warning(sb,
1258                              "need to use ext2online to resize further");
1259                 return -EPERM;
1260         }
1261 @@ -1020,7 +1020,7 @@ int ext4_group_extend(struct super_block
1262         add = EXT4_BLOCKS_PER_GROUP(sb) - last;
1263
1264         if (o_blocks_count + add < o_blocks_count) {
1265 -               ext4_warning(sb, __func__, "blocks_count overflow");
1266 +               ext4_warning(sb, "blocks_count overflow");
1267                 return -EINVAL;
1268         }
1269
1270 @@ -1028,7 +1028,7 @@ int ext4_group_extend(struct super_block
1271                 add = n_blocks_count - o_blocks_count;
1272
1273         if (o_blocks_count + add < n_blocks_count)
1274 -               ext4_warning(sb, __func__,
1275 +               ext4_warning(sb,
1276                              "will only finish group (%llu"
1277                              " blocks, %u new)",
1278                              o_blocks_count + add, add);
1279 @@ -1036,7 +1036,7 @@ int ext4_group_extend(struct super_block
1280         /* See if the device is actually as big as what was requested */
1281         bh = sb_bread(sb, o_blocks_count + add - 1);
1282         if (!bh) {
1283 -               ext4_warning(sb, __func__,
1284 +               ext4_warning(sb,
1285                              "can't read last block, resize aborted");
1286                 return -ENOSPC;
1287         }
1288 @@ -1048,13 +1048,13 @@ int ext4_group_extend(struct super_block
1289         handle = ext4_journal_start_sb(sb, 3);
1290         if (IS_ERR(handle)) {
1291                 err = PTR_ERR(handle);
1292 -               ext4_warning(sb, __func__, "error %d on journal start", err);
1293 +               ext4_warning(sb, "error %d on journal start", err);
1294                 goto exit_put;
1295         }
1296
1297         mutex_lock(&EXT4_SB(sb)->s_resize_lock);
1298         if (o_blocks_count != ext4_blocks_count(es)) {
1299 -               ext4_warning(sb, __func__,
1300 +               ext4_warning(sb,
1301                              "multiple resizers run on filesystem!");
1302                 mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
1303                 ext4_journal_stop(handle);
1304 @@ -1064,7 +1064,7 @@ int ext4_group_extend(struct super_block
1305
1306         if ((err = ext4_journal_get_write_access(handle,
1307                                                  EXT4_SB(sb)->s_sbh))) {
1308 -               ext4_warning(sb, __func__,
1309 +               ext4_warning(sb,
1310                              "error %d on journal write access", err);
1311                 mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
1312                 ext4_journal_stop(handle);
1313 diff -urpN linux-stage.orig/fs/ext4/super.c linux-stage/fs/ext4/super.c
1314 --- linux-stage.orig/fs/ext4/super.c    2011-12-28 08:18:31.000000000 -0500
1315 +++ linux-stage/fs/ext4/super.c 2011-12-28 11:24:07.000000000 -0500
1316 @@ -337,7 +337,7 @@ static void ext4_handle_error(struct sup
1317                         sb->s_id);
1318  }
1319
1320 -void ext4_error(struct super_block *sb, const char *function,
1321 +void __ext4_error(struct super_block *sb, const char *function,
1322                 const char *fmt, ...)
1323  {
1324         va_list args;
1325 @@ -351,6 +351,42 @@ void ext4_error(struct super_block *sb,
1326         ext4_handle_error(sb);
1327  }
1328
1329 +void ext4_error_inode(const char *function, struct inode *inode,
1330 +                      const char *fmt, ...)
1331 +{
1332 +       va_list args;
1333 +
1334 +       va_start(args, fmt);
1335 +       printk(KERN_CRIT "EXT4-fs error (device %s): %s: inode #%lu: (comm %s) ",
1336 +              inode->i_sb->s_id, function, inode->i_ino, current->comm);
1337 +       vprintk(fmt, args);
1338 +       printk("\n");
1339 +       va_end(args);
1340 +
1341 +       ext4_handle_error(inode->i_sb);
1342 +}
1343 +
1344 +void ext4_error_file(const char *function, struct file *file,
1345 +                     const char *fmt, ...)
1346 +{
1347 +       va_list args;
1348 +       struct inode *inode = file->f_dentry->d_inode;
1349 +       char pathname[80], *path;
1350 +
1351 +       va_start(args, fmt);
1352 +       path = d_path(&(file->f_path), pathname, sizeof(pathname));
1353 +       if (!path)
1354 +               path = "(unknown)";
1355 +       printk(KERN_CRIT
1356 +              "EXT4-fs error (device %s): %s: inode #%lu (comm %s path %s): ",
1357 +              inode->i_sb->s_id, function, inode->i_ino, current->comm, path);
1358 +       vprintk(fmt, args);
1359 +       printk("\n");
1360 +       va_end(args);
1361 +
1362 +       ext4_handle_error(inode->i_sb);
1363 +}
1364 +
1365  static const char *ext4_decode_error(struct super_block *sb, int errno,
1366                                      char nbuf[16])
1367  {
1368 @@ -454,7 +490,7 @@ void ext4_msg (struct super_block * sb,
1369         va_end(args);
1370  }
1371
1372 -void ext4_warning(struct super_block *sb, const char *function,
1373 +void __ext4_warning(struct super_block *sb, const char *function,
1374                   const char *fmt, ...)
1375  {
1376         va_list args;
1377 @@ -511,7 +547,7 @@ void ext4_update_dynamic_rev(struct supe
1378         if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
1379                 return;
1380
1381 -       ext4_warning(sb, __func__,
1382 +       ext4_warning(sb,
1383                      "updating to rev %d because of new feature flag, "
1384                      "running e2fsck is recommended",
1385                      EXT4_DYNAMIC_REV);
1386 @@ -1096,9 +1132,9 @@ enum {
1387         Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
1388         Opt_data_err_abort, Opt_data_err_ignore,
1389         Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1390 -       Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
1391 -       Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err, Opt_resize,
1392 -       Opt_usrquota, Opt_grpquota, Opt_i_version,
1393 +       Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
1394 +       Opt_noquota, Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err,
1395 +       Opt_resize, Opt_usrquota, Opt_grpquota, Opt_i_version,
1396         Opt_stripe, Opt_delalloc, Opt_nodelalloc,
1397         Opt_block_validity, Opt_noblock_validity,
1398         Opt_inode_readahead_blks, Opt_journal_ioprio,
1399 @@ -2709,6 +2745,21 @@ static int ext4_fill_super(struct super_
1400         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1401         spin_lock_init(&sbi->s_next_gen_lock);
1402
1403 +       err = percpu_counter_init(&sbi->s_freeblocks_counter,
1404 +                                 ext4_count_free_blocks(sb));
1405 +       if (!err)
1406 +               err = percpu_counter_init(&sbi->s_freeinodes_counter,
1407 +                                         ext4_count_free_inodes(sb));
1408 +       if (!err)
1409 +               err = percpu_counter_init(&sbi->s_dirs_counter,
1410 +                                         ext4_count_dirs(sb));
1411 +       if (!err)
1412 +               err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
1413 +       if (err) {
1414 +               ext4_msg(sb, KERN_ERR, "insufficient memory");
1415 +               goto failed_mount3;
1416 +       }
1417 +
1418         sbi->s_stripe = ext4_get_stripe_size(sbi);
1419         sbi->s_max_writeback_mb_bump = 128;
1420
1421 @@ -2828,20 +2879,6 @@ static int ext4_fill_super(struct super_
1422         set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
1423
1424  no_journal:
1425 -       err = percpu_counter_init(&sbi->s_freeblocks_counter,
1426 -                                 ext4_count_free_blocks(sb));
1427 -       if (!err)
1428 -               err = percpu_counter_init(&sbi->s_freeinodes_counter,
1429 -                                         ext4_count_free_inodes(sb));
1430 -       if (!err)
1431 -               err = percpu_counter_init(&sbi->s_dirs_counter,
1432 -                                         ext4_count_dirs(sb));
1433 -       if (!err)
1434 -               err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
1435 -       if (err) {
1436 -               ext4_msg(sb, KERN_ERR, "insufficient memory");
1437 -               goto failed_mount_wq;
1438 -       }
1439         if (test_opt(sb, NOBH)) {
1440                 if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) {
1441                         ext4_msg(sb, KERN_WARNING, "Ignoring nobh option - "
1442 @@ -2974,10 +3011,6 @@ failed_mount_wq:
1443                 jbd2_journal_destroy(sbi->s_journal);
1444                 sbi->s_journal = NULL;
1445         }
1446 -       percpu_counter_destroy(&sbi->s_freeblocks_counter);
1447 -       percpu_counter_destroy(&sbi->s_freeinodes_counter);
1448 -       percpu_counter_destroy(&sbi->s_dirs_counter);
1449 -       percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
1450  failed_mount3:
1451         if (sbi->s_flex_groups) {
1452                 if (is_vmalloc_addr(sbi->s_flex_groups))
1453 @@ -2985,6 +3018,10 @@ failed_mount3:
1454                 else
1455                         kfree(sbi->s_flex_groups);
1456         }
1457 +       percpu_counter_destroy(&sbi->s_freeblocks_counter);
1458 +       percpu_counter_destroy(&sbi->s_freeinodes_counter);
1459 +       percpu_counter_destroy(&sbi->s_dirs_counter);
1460 +       percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
1461  failed_mount2:
1462         for (i = 0; i < db_count; i++)
1463                 brelse(sbi->s_group_desc[i]);
1464 @@ -3377,9 +3414,9 @@ static void ext4_clear_journal_err(struc
1465                 char nbuf[16];
1466
1467                 errstr = ext4_decode_error(sb, j_errno, nbuf);
1468 -               ext4_warning(sb, __func__, "Filesystem error recorded "
1469 +               ext4_warning(sb, "Filesystem error recorded "
1470                              "from previous mount: %s", errstr);
1471 -               ext4_warning(sb, __func__, "Marking fs in need of "
1472 +               ext4_warning(sb, "Marking fs in need of "
1473                              "filesystem check.");
1474
1475                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
1476 diff -urpN linux-stage.orig/fs/ext4/xattr.c linux-stage/fs/ext4/xattr.c
1477 --- linux-stage.orig/fs/ext4/xattr.c    2011-12-28 08:18:31.000000000 -0500
1478 +++ linux-stage/fs/ext4/xattr.c 2011-12-28 11:24:07.000000000 -0500
1479 @@ -227,7 +227,7 @@ ext4_xattr_block_get(struct inode *inode
1480         ea_bdebug(bh, "b_count=%d, refcount=%d",
1481                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
1482         if (ext4_xattr_check_block(bh)) {
1483 -bad_block:     ext4_error(inode->i_sb, __func__,
1484 +bad_block:     ext4_error(inode->i_sb,
1485                            "inode %lu: bad block %llu", inode->i_ino,
1486                            EXT4_I(inode)->i_file_acl);
1487                 error = -EIO;
1488 @@ -369,7 +369,7 @@ ext4_xattr_block_list(struct inode *inod
1489         ea_bdebug(bh, "b_count=%d, refcount=%d",
1490                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
1491         if (ext4_xattr_check_block(bh)) {
1492 -               ext4_error(inode->i_sb, __func__,
1493 +               ext4_error(inode->i_sb,
1494                            "inode %lu: bad block %llu", inode->i_ino,
1495                            EXT4_I(inode)->i_file_acl);
1496                 error = -EIO;
1497 @@ -661,7 +661,7 @@ ext4_xattr_block_find(struct inode *inod
1498                         atomic_read(&(bs->bh->b_count)),
1499                         le32_to_cpu(BHDR(bs->bh)->h_refcount));
1500                 if (ext4_xattr_check_block(bs->bh)) {
1501 -                       ext4_error(sb, __func__,
1502 +                       ext4_error(sb,
1503                                 "inode %lu: bad block %llu", inode->i_ino,
1504                                 EXT4_I(inode)->i_file_acl);
1505                         error = -EIO;
1506 @@ -875,7 +875,7 @@ cleanup_dquot:
1507         goto cleanup;
1508
1509  bad_block:
1510 -       ext4_error(inode->i_sb, __func__,
1511 +       ext4_error(inode->i_sb,
1512                    "inode %lu: bad block %llu", inode->i_ino,
1513                    EXT4_I(inode)->i_file_acl);
1514         goto cleanup;
1515 @@ -1190,7 +1190,7 @@ retry:
1516                 if (!bh)
1517                         goto cleanup;
1518                 if (ext4_xattr_check_block(bh)) {
1519 -                       ext4_error(inode->i_sb, __func__,
1520 +                       ext4_error(inode->i_sb,
1521                                 "inode %lu: bad block %llu", inode->i_ino,
1522                                 EXT4_I(inode)->i_file_acl);
1523                         error = -EIO;
1524 @@ -1367,14 +1367,14 @@ ext4_xattr_delete_inode(handle_t *handle
1525                 goto cleanup;
1526         bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1527         if (!bh) {
1528 -               ext4_error(inode->i_sb, __func__,
1529 +               ext4_error(inode->i_sb,
1530                         "inode %lu: block %llu read error", inode->i_ino,
1531                         EXT4_I(inode)->i_file_acl);
1532                 goto cleanup;
1533         }
1534         if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
1535             BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1536 -               ext4_error(inode->i_sb, __func__,
1537 +               ext4_error(inode->i_sb,
1538                         "inode %lu: bad block %llu", inode->i_ino,
1539                         EXT4_I(inode)->i_file_acl);
1540                 goto cleanup;
1541 @@ -1501,7 +1501,7 @@ again:
1542                 }
1543                 bh = sb_bread(inode->i_sb, ce->e_block);
1544                 if (!bh) {
1545 -                       ext4_error(inode->i_sb, __func__,
1546 +                       ext4_error(inode->i_sb,
1547                                 "inode %lu: block %lu read error",
1548                                 inode->i_ino, (unsigned long) ce->e_block);
1549                 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=