lkml.org 
[lkml]   [2012]   [Mar]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 9/9] ext4: Rename ext4_warning to ext4_warn and ext4_error to ext4_err
    Date
    Make the logging macros more like the current kernel logging style.

    Neaten the macro definitions.
    Align arguments and 80 column wrapping.

    Signed-off-by: Joe Perches <joe@perches.com>
    ---
    fs/ext4/balloc.c | 22 ++++----
    fs/ext4/ext4.h | 8 ++--
    fs/ext4/ialloc.c | 32 ++++++------
    fs/ext4/indirect.c | 6 +-
    fs/ext4/inode.c | 20 ++++----
    fs/ext4/mballoc.c | 44 +++++++++---------
    fs/ext4/mmp.c | 30 ++++++------
    fs/ext4/namei.c | 66 +++++++++++++-------------
    fs/ext4/page-io.c | 12 ++--
    fs/ext4/resize.c | 133 +++++++++++++++++++++++++--------------------------
    fs/ext4/super.c | 20 ++++----
    11 files changed, 194 insertions(+), 199 deletions(-)

    diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
    index 82f468f..c77446c 100644
    --- a/fs/ext4/balloc.c
    +++ b/fs/ext4/balloc.c
    @@ -171,7 +171,7 @@ void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
    /* If checksum is bad mark all blocks used to prevent allocation
    * essentially implementing a per-group read-only flag. */
    if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
    - ext4_error(sb, "Checksum bad for group %u", block_group);
    + ext4_err(sb, "Checksum bad for group %u", block_group);
    ext4_free_group_clusters_set(sb, gdp, 0);
    ext4_free_inodes_set(sb, gdp, 0);
    ext4_itable_unused_set(sb, gdp, 0);
    @@ -254,8 +254,8 @@ struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
    struct ext4_sb_info *sbi = EXT4_SB(sb);

    if (block_group >= ngroups) {
    - ext4_error(sb, "block_group >= groups_count - block_group = %u, groups_count = %u",
    - block_group, ngroups);
    + ext4_err(sb, "block_group >= groups_count - block_group = %u, groups_count = %u",
    + block_group, ngroups);

    return NULL;
    }
    @@ -263,8 +263,8 @@ struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
    group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
    offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
    if (!sbi->s_group_desc[group_desc]) {
    - ext4_error(sb, "Group descriptor not loaded - block_group = %u, group_desc = %u, desc = %u",
    - block_group, group_desc, offset);
    + ext4_err(sb, "Group descriptor not loaded - block_group = %u, group_desc = %u, desc = %u",
    + block_group, group_desc, offset);
    return NULL;
    }

    @@ -322,8 +322,8 @@ static int ext4_valid_block_bitmap(struct super_block *sb,
    return 1;

    err_out:
    - ext4_error(sb, "Invalid block bitmap - block_group = %d, block = %llu",
    - block_group, bitmap_blk);
    + ext4_err(sb, "Invalid block bitmap - block_group = %d, block = %llu",
    + block_group, bitmap_blk);
    return 0;
    }
    /**
    @@ -349,8 +349,8 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
    bitmap_blk = ext4_block_bitmap(sb, desc);
    bh = sb_getblk(sb, bitmap_blk);
    if (unlikely(!bh)) {
    - ext4_error(sb, "Cannot get buffer for block bitmap - block_group = %u, block_bitmap = %llu",
    - block_group, bitmap_blk);
    + ext4_err(sb, "Cannot get buffer for block bitmap - block_group = %u, block_bitmap = %llu",
    + block_group, bitmap_blk);
    return NULL;
    }

    @@ -405,8 +405,8 @@ int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
    return 1;
    wait_on_buffer(bh);
    if (!buffer_uptodate(bh)) {
    - ext4_error(sb, "Cannot read block bitmap - block_group = %u, block_bitmap = %llu",
    - block_group, (unsigned long long) bh->b_blocknr);
    + ext4_err(sb, "Cannot read block bitmap - block_group = %u, block_bitmap = %llu",
    + block_group, (unsigned long long) bh->b_blocknr);
    return 1;
    }
    clear_buffer_new(bh);
    diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
    index 2aaf549..348df50 100644
    --- a/fs/ext4/ext4.h
    +++ b/fs/ext4/ext4.h
    @@ -1960,8 +1960,8 @@ extern void ext4_kvfree(void *ptr);
    extern __printf(4, 5)
    void __ext4_error(struct super_block *, const char *, unsigned int,
    const char *, ...);
    -#define ext4_error(sb, message...) __ext4_error(sb, __func__, \
    - __LINE__, ## message)
    +#define ext4_err(sb, fmt, ...) \
    + __ext4_error(sb, __func__, __LINE__, fmt, ##__VA_ARGS__)
    extern __printf(5, 6)
    void ext4_error_inode(struct inode *, const char *, unsigned int, ext4_fsblk_t,
    const char *, ...);
    @@ -1978,8 +1978,8 @@ void __ext4_abort(struct super_block *, const char *, unsigned int,
    extern __printf(4, 5)
    void __ext4_warning(struct super_block *, const char *, unsigned int,
    const char *, ...);
    -#define ext4_warning(sb, message...) __ext4_warning(sb, __func__, \
    - __LINE__, ## message)
    +#define ext4_warn(sb, fmt, ...) \
    + __ext4_warning(sb, __func__, __LINE__, fmt, ##__VA_ARGS__)
    extern __printf(3, 4)
    void ext4_msg(struct super_block *, const char *, const char *, ...);
    extern void __dump_mmp_msg(struct super_block *, struct mmp_struct *mmp,
    diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
    index 29cbd9f..f4522eb 100644
    --- a/fs/ext4/ialloc.c
    +++ b/fs/ext4/ialloc.c
    @@ -79,7 +79,7 @@ static unsigned ext4_init_inode_bitmap(struct super_block *sb,
    /* If checksum is bad mark all blocks and inodes use to prevent
    * allocation, essentially implementing a per-group read-only flag. */
    if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
    - ext4_error(sb, "Checksum bad for group %u", block_group);
    + ext4_err(sb, "Checksum bad for group %u", block_group);
    ext4_free_group_clusters_set(sb, gdp, 0);
    ext4_free_inodes_set(sb, gdp, 0);
    ext4_itable_unused_set(sb, gdp, 0);
    @@ -124,8 +124,8 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
    bitmap_blk = ext4_inode_bitmap(sb, desc);
    bh = sb_getblk(sb, bitmap_blk);
    if (unlikely(!bh)) {
    - ext4_error(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
    - block_group, bitmap_blk);
    + ext4_err(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
    + block_group, bitmap_blk);
    return NULL;
    }
    if (bitmap_uptodate(bh))
    @@ -167,8 +167,8 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
    wait_on_buffer(bh);
    if (!buffer_uptodate(bh)) {
    put_bh(bh);
    - ext4_error(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
    - block_group, bitmap_blk);
    + ext4_err(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
    + block_group, bitmap_blk);
    return NULL;
    }
    return bh;
    @@ -239,7 +239,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)

    es = EXT4_SB(sb)->s_es;
    if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
    - ext4_error(sb, "reserved or nonexistent inode %lu", ino);
    + ext4_err(sb, "reserved or nonexistent inode %lu", ino);
    goto error_return;
    }
    block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
    @@ -294,7 +294,7 @@ out:
    fatal = err;
    ext4_mark_super_dirty(sb);
    } else
    - ext4_error(sb, "bit already cleared for inode %lu", ino);
    + ext4_err(sb, "bit already cleared for inode %lu", ino);

    error_return:
    brelse(bitmap_bh);
    @@ -688,8 +688,8 @@ repeat_in_this_group:
    continue;
    }
    if (group == 0 && (ino+1) < EXT4_FIRST_INO(sb)) {
    - ext4_error(sb, "reserved inode found cleared - inode=%lu",
    - ino + 1);
    + ext4_err(sb, "reserved inode found cleared - inode=%lu",
    + ino + 1);
    continue;
    }
    ext4_lock_group(sb, group);
    @@ -922,7 +922,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)

    /* Error cases - e2fsck has already cleaned up for us */
    if (ino > max_ino) {
    - ext4_warning(sb, "bad orphan ino %lu! e2fsck was run?", ino);
    + ext4_warn(sb, "bad orphan ino %lu! e2fsck was run?", ino);
    goto error;
    }

    @@ -930,7 +930,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
    bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
    bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
    if (!bitmap_bh) {
    - ext4_warning(sb, "inode bitmap error for orphan %lu", ino);
    + ext4_warn(sb, "inode bitmap error for orphan %lu", ino);
    goto error;
    }

    @@ -962,7 +962,7 @@ iget_failed:
    err = PTR_ERR(inode);
    inode = NULL;
    bad_orphan:
    - ext4_warning(sb, "bad orphan inode %lu! e2fsck was run?", ino);
    + ext4_warn(sb, "bad orphan inode %lu! e2fsck was run?", ino);
    pr_notice("ext4_test_bit(bit=%d, block=%llu) = %d\n",
    bit, (unsigned long long)bitmap_bh->b_blocknr,
    ext4_test_bit(bit, bitmap_bh->b_data));
    @@ -1098,10 +1098,10 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
    sbi->s_inodes_per_block);

    if ((used_blks < 0) || (used_blks > sbi->s_itb_per_group)) {
    - ext4_error(sb, "Something is wrong with group %u\n"
    - "Used itable blocks: %d itable unused count: %u",
    - group, used_blks,
    - ext4_itable_unused_count(sb, gdp));
    + ext4_err(sb, "Something is wrong with group %u\n"
    + "Used itable blocks: %d itable unused count: %u",
    + group, used_blks,
    + ext4_itable_unused_count(sb, gdp));
    ret = 1;
    goto err_out;
    }
    diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
    index bd02261..db428a0 100644
    --- a/fs/ext4/indirect.c
    +++ b/fs/ext4/indirect.c
    @@ -101,9 +101,9 @@ static int ext4_block_to_path(struct inode *inode,
    offsets[n++] = i_block & (ptrs - 1);
    final = ptrs;
    } else {
    - ext4_warning(inode->i_sb, "block %lu > max in inode %lu",
    - i_block + direct_blocks +
    - indirect_blocks + double_blocks, inode->i_ino);
    + ext4_warn(inode->i_sb, "block %lu > max in inode %lu",
    + i_block + direct_blocks +
    + indirect_blocks + double_blocks, inode->i_ino);
    }
    if (boundary)
    *boundary = final - 1 - (i_block & (ptrs - 1));
    diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
    index 2fbfee2..29e2f29 100644
    --- a/fs/ext4/inode.c
    +++ b/fs/ext4/inode.c
    @@ -185,8 +185,8 @@ void ext4_evict_inode(struct inode *inode)
    inode->i_size = 0;
    err = ext4_mark_inode_dirty(handle, inode);
    if (err) {
    - ext4_warning(inode->i_sb,
    - "couldn't mark inode dirty (err %d)", err);
    + ext4_warn(inode->i_sb,
    + "couldn't mark inode dirty (err %d)", err);
    goto stop_handle;
    }
    if (inode->i_blocks)
    @@ -203,8 +203,8 @@ void ext4_evict_inode(struct inode *inode)
    if (err > 0)
    err = ext4_journal_restart(handle, 3);
    if (err != 0) {
    - ext4_warning(inode->i_sb,
    - "couldn't extend journal (err %d)", err);
    + ext4_warn(inode->i_sb,
    + "couldn't extend journal (err %d)", err);
    stop_handle:
    ext4_journal_stop(handle);
    ext4_orphan_del(NULL, inode);
    @@ -1578,9 +1578,9 @@ static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
    ext4_update_i_disksize(mpd->inode, disksize);
    err = ext4_mark_inode_dirty(handle, mpd->inode);
    if (err)
    - ext4_error(mpd->inode->i_sb,
    - "Failed to mark inode %lu dirty",
    - mpd->inode->i_ino);
    + ext4_err(mpd->inode->i_sb,
    + "Failed to mark inode %lu dirty",
    + mpd->inode->i_ino);
    }

    submit_io:
    @@ -4442,9 +4442,9 @@ int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
    EXT4_STATE_NO_EXPAND);
    if (mnt_count !=
    le16_to_cpu(sbi->s_es->s_mnt_count)) {
    - ext4_warning(inode->i_sb,
    - "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
    - inode->i_ino);
    + ext4_warn(inode->i_sb,
    + "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
    + inode->i_ino);
    mnt_count =
    le16_to_cpu(sbi->s_es->s_mnt_count);
    }
    diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
    index 185cbac..064c557 100644
    --- a/fs/ext4/mballoc.c
    +++ b/fs/ext4/mballoc.c
    @@ -2758,8 +2758,8 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,

    len = EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
    if (!ext4_data_block_valid(sbi, block, len)) {
    - ext4_error(sb, "Allocating blocks %llu-%llu which overlap fs metadata",
    - block, block + len);
    + ext4_err(sb, "Allocating blocks %llu-%llu which overlap fs metadata",
    + block, block + len);
    /* File system mounted not to panic on error
    * Fix the bitmap and repeat the block allocation
    * We leak some of the blocks here.
    @@ -3656,13 +3656,13 @@ ext4_mb_discard_group_preallocations(struct super_block *sb,

    bitmap_bh = ext4_read_block_bitmap(sb, group);
    if (bitmap_bh == NULL) {
    - ext4_error(sb, "Error reading block bitmap for %u", group);
    + ext4_err(sb, "Error reading block bitmap for %u", group);
    return 0;
    }

    err = ext4_mb_load_buddy(sb, group, &e4b);
    if (err) {
    - ext4_error(sb, "Error loading buddy information for %u", group);
    + ext4_err(sb, "Error loading buddy information for %u", group);
    put_bh(bitmap_bh);
    return 0;
    }
    @@ -3825,15 +3825,15 @@ repeat:

    err = ext4_mb_load_buddy(sb, group, &e4b);
    if (err) {
    - ext4_error(sb, "Error loading buddy information for %u",
    - group);
    + ext4_err(sb, "Error loading buddy information for %u",
    + group);
    continue;
    }

    bitmap_bh = ext4_read_block_bitmap(sb, group);
    if (bitmap_bh == NULL) {
    - ext4_error(sb, "Error reading block bitmap for %u",
    - group);
    + ext4_err(sb, "Error reading block bitmap for %u",
    + group);
    ext4_mb_unload_buddy(&e4b);
    continue;
    }
    @@ -4081,8 +4081,8 @@ ext4_mb_discard_lg_preallocations(struct super_block *sb,

    ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, NULL);
    if (ext4_mb_load_buddy(sb, group, &e4b)) {
    - ext4_error(sb, "Error loading buddy information for %u",
    - group);
    + ext4_err(sb, "Error loading buddy information for %u",
    + group);
    continue;
    }
    ext4_lock_group(sb, group);
    @@ -4488,8 +4488,8 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
    sbi = EXT4_SB(sb);
    if (!(flags & EXT4_FREE_BLOCKS_VALIDATED) &&
    !ext4_data_block_valid(sbi, block, count)) {
    - ext4_error(sb, "Freeing blocks not in datazone - block = %llu, count = %lu",
    - block, count);
    + ext4_err(sb, "Freeing blocks not in datazone - block = %llu, count = %lu",
    + block, count);
    goto error_return;
    }

    @@ -4587,8 +4587,8 @@ do_more:
    in_range(block + count - 1, ext4_inode_table(sb, gdp),
    EXT4_SB(sb)->s_itb_per_group)) {

    - ext4_error(sb, "Freeing blocks in system zone - Block = %llu, count = %lu",
    - block, count);
    + ext4_err(sb, "Freeing blocks in system zone - Block = %llu, count = %lu",
    + block, count);
    /* err = 0. ext4_std_error should be a no op */
    goto error_return;
    }
    @@ -4725,8 +4725,8 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
    * boundary.
    */
    if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
    - ext4_warning(sb, "too much blocks added to group %u\n",
    - block_group);
    + ext4_warn(sb, "too much blocks added to group %u\n",
    + block_group);
    err = -EINVAL;
    goto error_return;
    }
    @@ -4748,8 +4748,8 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
    in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
    in_range(block + count - 1, ext4_inode_table(sb, desc),
    sbi->s_itb_per_group)) {
    - ext4_error(sb, "Adding blocks in system zones - Block = %llu, count = %lu",
    - block, count);
    + ext4_err(sb, "Adding blocks in system zones - Block = %llu, count = %lu",
    + block, count);
    err = -EINVAL;
    goto error_return;
    }
    @@ -4772,8 +4772,8 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
    for (i = 0, blocks_freed = 0; i < count; i++) {
    BUFFER_TRACE(bitmap_bh, "clear bit");
    if (!mb_test_bit(bit + i, bitmap_bh->b_data)) {
    - ext4_error(sb, "bit already cleared for block %llu",
    - (ext4_fsblk_t)(block + i));
    + ext4_err(sb, "bit already cleared for block %llu",
    + (ext4_fsblk_t)(block + i));
    BUFFER_TRACE(bitmap_bh, "bit already cleared");
    } else {
    blocks_freed++;
    @@ -4891,8 +4891,8 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,

    ret = ext4_mb_load_buddy(sb, group, &e4b);
    if (ret) {
    - ext4_error(sb, "Error in loading buddy information for %u",
    - group);
    + ext4_err(sb, "Error in loading buddy information for %u",
    + group);
    return ret;
    }
    bitmap = e4b.bd_bitmap;
    diff --git a/fs/ext4/mmp.c b/fs/ext4/mmp.c
    index 1767b2a..9aba1b4 100644
    --- a/fs/ext4/mmp.c
    +++ b/fs/ext4/mmp.c
    @@ -53,8 +53,7 @@ static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,
    }
    }
    if (!*bh) {
    - ext4_warning(sb, "Error while reading MMP block %llu",
    - mmp_block);
    + ext4_warn(sb, "Error while reading MMP block %llu", mmp_block);
    return -EIO;
    }

    @@ -126,19 +125,19 @@ static int kmmpd(void *data)
    */
    if (retval) {
    if ((failed_writes % 60) == 0)
    - ext4_error(sb, "Error writing to MMP block");
    + ext4_err(sb, "Error writing to MMP block");
    failed_writes++;
    }

    if (!(le32_to_cpu(es->s_feature_incompat) &
    EXT4_FEATURE_INCOMPAT_MMP)) {
    - ext4_warning(sb, "kmmpd being stopped since MMP feature has been disabled");
    + ext4_warn(sb, "kmmpd being stopped since MMP feature has been disabled");
    EXT4_SB(sb)->s_mmp_tsk = NULL;
    goto failed;
    }

    if (sb->s_flags & MS_RDONLY) {
    - ext4_warning(sb, "kmmpd being stopped since filesystem has been remounted as readonly");
    + ext4_warn(sb, "kmmpd being stopped since filesystem has been remounted as readonly");
    EXT4_SB(sb)->s_mmp_tsk = NULL;
    goto failed;
    }
    @@ -160,8 +159,8 @@ static int kmmpd(void *data)

    retval = read_mmp_block(sb, &bh_check, mmp_block);
    if (retval) {
    - ext4_error(sb, "error reading MMP data: %d",
    - retval);
    + ext4_err(sb, "error reading MMP data: %d",
    + retval);

    EXT4_SB(sb)->s_mmp_tsk = NULL;
    goto failed;
    @@ -175,7 +174,7 @@ static int kmmpd(void *data)
    "Error while updating MMP info. "
    "The filesystem seems to have been"
    " multiply mounted.");
    - ext4_error(sb, "abort");
    + ext4_err(sb, "abort");
    goto failed;
    }
    put_bh(bh_check);
    @@ -237,7 +236,7 @@ int ext4_multi_mount_protect(struct super_block *sb,

    if (mmp_block < le32_to_cpu(es->s_first_data_block) ||
    mmp_block >= ext4_blocks_count(es)) {
    - ext4_warning(sb, "Invalid MMP block in superblock");
    + ext4_warn(sb, "Invalid MMP block in superblock");
    goto failed;
    }

    @@ -271,11 +270,11 @@ int ext4_multi_mount_protect(struct super_block *sb,

    /* Print MMP interval if more than 20 secs. */
    if (wait_time > EXT4_MMP_MIN_CHECK_INTERVAL * 4)
    - ext4_warning(sb, "MMP interval %u higher than expected, please wait",
    - wait_time * 2);
    + ext4_warn(sb, "MMP interval %u higher than expected, please wait",
    + wait_time * 2);

    if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
    - ext4_warning(sb, "MMP startup interrupted, failing mount");
    + ext4_warn(sb, "MMP startup interrupted, failing mount");
    goto failed;
    }

    @@ -304,7 +303,7 @@ skip:
    * wait for MMP interval and check mmp_seq.
    */
    if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
    - ext4_warning(sb, "MMP startup interrupted, failing mount");
    + ext4_warn(sb, "MMP startup interrupted, failing mount");
    goto failed;
    }

    @@ -320,7 +319,7 @@ skip:

    mmpd_data = kmalloc(sizeof(struct mmpd_data), GFP_KERNEL);
    if (!mmpd_data) {
    - ext4_warning(sb, "not enough memory for mmpd_data");
    + ext4_warn(sb, "not enough memory for mmpd_data");
    goto failed;
    }
    mmpd_data->sb = sb;
    @@ -335,8 +334,7 @@ skip:
    if (IS_ERR(EXT4_SB(sb)->s_mmp_tsk)) {
    EXT4_SB(sb)->s_mmp_tsk = NULL;
    kfree(mmpd_data);
    - ext4_warning(sb, "Unable to create kmmpd thread for %s",
    - sb->s_id);
    + ext4_warn(sb, "Unable to create kmmpd thread for %s", sb->s_id);
    goto failed;
    }

    diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
    index 99f86a7..ff8a843 100644
    --- a/fs/ext4/namei.c
    +++ b/fs/ext4/namei.c
    @@ -364,8 +364,8 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
    if (root->info.hash_version != DX_HASH_TEA &&
    root->info.hash_version != DX_HASH_HALF_MD4 &&
    root->info.hash_version != DX_HASH_LEGACY) {
    - ext4_warning(dir->i_sb, "Unrecognised inode hash code %d",
    - root->info.hash_version);
    + ext4_warn(dir->i_sb, "Unrecognised inode hash code %d",
    + root->info.hash_version);
    brelse(bh);
    *err = ERR_BAD_DX_DIR;
    goto fail;
    @@ -379,16 +379,16 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
    hash = hinfo->hash;

    if (root->info.unused_flags & 1) {
    - ext4_warning(dir->i_sb, "Unimplemented inode hash flags: %#06x",
    - root->info.unused_flags);
    + ext4_warn(dir->i_sb, "Unimplemented inode hash flags: %#06x",
    + root->info.unused_flags);
    brelse(bh);
    *err = ERR_BAD_DX_DIR;
    goto fail;
    }

    if ((indirect = root->info.indirect_levels) > 1) {
    - ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x",
    - root->info.indirect_levels);
    + ext4_warn(dir->i_sb, "Unimplemented inode hash depth: %#06x",
    + root->info.indirect_levels);
    brelse(bh);
    *err = ERR_BAD_DX_DIR;
    goto fail;
    @@ -399,7 +399,7 @@ dx_probe(const struct qstr *d_name, struct inode *dir,

    if (dx_get_limit(entries) != dx_root_limit(dir,
    root->info.info_length)) {
    - ext4_warning(dir->i_sb, "dx entry: limit != root limit");
    + ext4_warn(dir->i_sb, "dx entry: limit != root limit");
    brelse(bh);
    *err = ERR_BAD_DX_DIR;
    goto fail;
    @@ -410,8 +410,8 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
    {
    count = dx_get_count(entries);
    if (!count || count > dx_get_limit(entries)) {
    - ext4_warning(dir->i_sb,
    - "dx entry: no count or count > limit");
    + ext4_warn(dir->i_sb,
    + "dx entry: no count or count > limit");
    brelse(bh);
    *err = ERR_BAD_DX_DIR;
    goto fail2;
    @@ -457,8 +457,8 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
    goto fail2;
    at = entries = ((struct dx_node *) bh->b_data)->entries;
    if (dx_get_limit(entries) != dx_node_limit (dir)) {
    - ext4_warning(dir->i_sb,
    - "dx entry: limit != node limit");
    + ext4_warn(dir->i_sb,
    + "dx entry: limit != node limit");
    brelse(bh);
    *err = ERR_BAD_DX_DIR;
    goto fail2;
    @@ -473,9 +473,9 @@ fail2:
    }
    fail:
    if (*err == ERR_BAD_DX_DIR)
    - ext4_warning(dir->i_sb,
    - "Corrupt dir inode %lu, running e2fsck is recommended.",
    - dir->i_ino);
    + ext4_warn(dir->i_sb,
    + "Corrupt dir inode %lu, running e2fsck is recommended.",
    + dir->i_ino);
    return NULL;
    }

    @@ -1009,9 +1009,9 @@ static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct q
    retval = ext4_htree_next_block(dir, hinfo.hash, frame,
    frames, NULL);
    if (retval < 0) {
    - ext4_warning(sb,
    - "error reading index page in directory #%lu",
    - dir->i_ino);
    + ext4_warn(sb,
    + "error reading index page in directory #%lu",
    + dir->i_ino);
    *err = retval;
    goto errout;
    }
    @@ -1547,7 +1547,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,

    if (levels && (dx_get_count(frames->entries) ==
    dx_get_limit(frames->entries))) {
    - ext4_warning(sb, "Directory index full!");
    + ext4_warn(sb, "Directory index full!");
    err = -ENOSPC;
    goto cleanup;
    }
    @@ -1913,9 +1913,9 @@ static int empty_dir(struct inode *inode)
    EXT4_ERROR_INODE(inode,
    "error %d reading directory lblock 0", err);
    else
    - ext4_warning(inode->i_sb,
    - "bad directory (dir #%lu) - no data block",
    - inode->i_ino);
    + ext4_warn(inode->i_sb,
    + "bad directory (dir #%lu) - no data block",
    + inode->i_ino);
    return 1;
    }
    de = (struct ext4_dir_entry_2 *) bh->b_data;
    @@ -1924,9 +1924,9 @@ static int empty_dir(struct inode *inode)
    !le32_to_cpu(de1->inode) ||
    strcmp(".", de->name) ||
    strcmp("..", de1->name)) {
    - ext4_warning(inode->i_sb,
    - "bad directory (dir #%lu) - no `.' or `..'",
    - inode->i_ino);
    + ext4_warn(inode->i_sb,
    + "bad directory (dir #%lu) - no `.' or `..'",
    + inode->i_ino);
    brelse(bh);
    return 1;
    }
    @@ -2159,9 +2159,9 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
    if (retval)
    goto end_rmdir;
    if (!EXT4_DIR_LINK_EMPTY(inode))
    - ext4_warning(inode->i_sb,
    - "empty directory has too many links (%d)",
    - inode->i_nlink);
    + ext4_warn(inode->i_sb,
    + "empty directory has too many links (%d)",
    + inode->i_nlink);
    inode->i_version++;
    clear_nlink(inode);
    /* There's no need to set i_disksize: the fact that i_nlink is
    @@ -2214,9 +2214,9 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
    goto end_unlink;

    if (!inode->i_nlink) {
    - ext4_warning(inode->i_sb,
    - "Deleting nonexistent file (%lu), %d",
    - inode->i_ino, inode->i_nlink);
    + ext4_warn(inode->i_sb,
    + "Deleting nonexistent file (%lu), %d",
    + inode->i_ino, inode->i_nlink);
    set_nlink(inode, 1);
    }
    retval = ext4_delete_entry(handle, dir, de, bh);
    @@ -2518,9 +2518,9 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
    }
    }
    if (retval) {
    - ext4_warning(old_dir->i_sb,
    - "Deleting old file (%lu), %d, error=%d",
    - old_dir->i_ino, old_dir->i_nlink, retval);
    + ext4_warn(old_dir->i_sb,
    + "Deleting old file (%lu), %d, error=%d",
    + old_dir->i_ino, old_dir->i_nlink, retval);
    }

    if (new_inode) {
    diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
    index a5afbad..b1b492a 100644
    --- a/fs/ext4/page-io.c
    +++ b/fs/ext4/page-io.c
    @@ -238,12 +238,12 @@ static void ext4_end_bio(struct bio *bio, int error)

    if (error) {
    io_end->flag |= EXT4_IO_END_ERROR;
    - ext4_warning(inode->i_sb, "I/O error writing to inode %lu (offset %llu size %ld starting block %llu)",
    - inode->i_ino,
    - (unsigned long long) io_end->offset,
    - (long) io_end->size,
    - (unsigned long long)
    - bi_sector >> (inode->i_blkbits - 9));
    + ext4_warn(inode->i_sb, "I/O error writing to inode %lu (offset %llu size %ld starting block %llu)",
    + inode->i_ino,
    + (unsigned long long) io_end->offset,
    + (long) io_end->size,
    + (unsigned long long)
    + bi_sector >> (inode->i_blkbits - 9));
    }

    if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
    diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
    index ed3a306..bd133fd 100644
    --- a/fs/ext4/resize.c
    +++ b/fs/ext4/resize.c
    @@ -29,7 +29,7 @@ int ext4_resize_begin(struct super_block *sb)
    * with error, because it can destroy the filesystem easily.
    */
    if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
    - ext4_warning(sb, "There are errors in the filesystem, so online resizing is not allowed");
    + ext4_warn(sb, "There are errors in the filesystem, so online resizing is not allowed");
    return -EPERM;
    }

    @@ -76,53 +76,51 @@ static int verify_group_input(struct super_block *sb,

    ext4_get_group_no_and_offset(sb, start, NULL, &offset);
    if (group != sbi->s_groups_count)
    - ext4_warning(sb, "Cannot add at group %u (only %u groups)",
    - input->group, sbi->s_groups_count);
    + ext4_warn(sb, "Cannot add at group %u (only %u groups)",
    + input->group, sbi->s_groups_count);
    else if (offset != 0)
    - ext4_warning(sb, "Last group not full");
    + ext4_warn(sb, "Last group not full");
    else if (input->reserved_blocks > input->blocks_count / 5)
    - ext4_warning(sb, "Reserved blocks too high (%u)",
    - input->reserved_blocks);
    + ext4_warn(sb, "Reserved blocks too high (%u)",
    + input->reserved_blocks);
    else if (free_blocks_count < 0)
    - ext4_warning(sb, "Bad blocks count %u",
    - input->blocks_count);
    + ext4_warn(sb, "Bad blocks count %u", input->blocks_count);
    else if (!(bh = sb_bread(sb, end - 1)))
    - ext4_warning(sb, "Cannot read last block (%llu)",
    - end - 1);
    + ext4_warn(sb, "Cannot read last block (%llu)", end - 1);
    else if (outside(input->block_bitmap, start, end))
    - ext4_warning(sb, "Block bitmap not in group (block %llu)",
    - (unsigned long long)input->block_bitmap);
    + ext4_warn(sb, "Block bitmap not in group (block %llu)",
    + (unsigned long long)input->block_bitmap);
    else if (outside(input->inode_bitmap, start, end))
    - ext4_warning(sb, "Inode bitmap not in group (block %llu)",
    - (unsigned long long)input->inode_bitmap);
    + ext4_warn(sb, "Inode bitmap not in group (block %llu)",
    + (unsigned long long)input->inode_bitmap);
    else if (outside(input->inode_table, start, end) ||
    outside(itend - 1, start, end))
    - ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)",
    - (unsigned long long)input->inode_table, itend - 1);
    + ext4_warn(sb, "Inode table not in group (blocks %llu-%llu)",
    + (unsigned long long)input->inode_table, itend - 1);
    else if (input->inode_bitmap == input->block_bitmap)
    - ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)",
    - (unsigned long long)input->block_bitmap);
    + ext4_warn(sb, "Block bitmap same as inode bitmap (%llu)",
    + (unsigned long long)input->block_bitmap);
    else if (inside(input->block_bitmap, input->inode_table, itend))
    - ext4_warning(sb, "Block bitmap (%llu) in inode table (%llu-%llu)",
    - (unsigned long long)input->block_bitmap,
    - (unsigned long long)input->inode_table, itend - 1);
    + ext4_warn(sb, "Block bitmap (%llu) in inode table (%llu-%llu)",
    + (unsigned long long)input->block_bitmap,
    + (unsigned long long)input->inode_table, itend - 1);
    else if (inside(input->inode_bitmap, input->inode_table, itend))
    - ext4_warning(sb, "Inode bitmap (%llu) in inode table (%llu-%llu)",
    - (unsigned long long)input->inode_bitmap,
    - (unsigned long long)input->inode_table, itend - 1);
    + ext4_warn(sb, "Inode bitmap (%llu) in inode table (%llu-%llu)",
    + (unsigned long long)input->inode_bitmap,
    + (unsigned long long)input->inode_table, itend - 1);
    else if (inside(input->block_bitmap, start, metaend))
    - ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)",
    - (unsigned long long)input->block_bitmap,
    - start, metaend - 1);
    + ext4_warn(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)",
    + (unsigned long long)input->block_bitmap,
    + start, metaend - 1);
    else if (inside(input->inode_bitmap, start, metaend))
    - ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)",
    - (unsigned long long)input->inode_bitmap,
    - start, metaend - 1);
    + ext4_warn(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)",
    + (unsigned long long)input->inode_bitmap,
    + start, metaend - 1);
    else if (inside(input->inode_table, start, metaend) ||
    inside(itend - 1, start, metaend))
    - ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table (%llu-%llu)",
    - (unsigned long long)input->inode_table,
    - itend - 1, start, metaend - 1);
    + ext4_warn(sb, "Inode table (%llu-%llu) overlaps GDT table (%llu-%llu)",
    + (unsigned long long)input->inode_table,
    + itend - 1, start, metaend - 1);
    else
    err = 0;
    brelse(bh);
    @@ -644,11 +642,11 @@ static int verify_reserved_gdb(struct super_block *sb,
    while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
    if (le32_to_cpu(*p++) !=
    grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
    - ext4_warning(sb, "reserved GDT %llu missing grp %d (%llu)",
    - blk, grp,
    - grp *
    - (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
    - blk);
    + ext4_warn(sb, "reserved GDT %llu missing grp %d (%llu)",
    + blk, grp,
    + grp *
    + (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
    + blk);
    return -EINVAL;
    }
    if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb))
    @@ -696,8 +694,8 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
    */
    if (EXT4_SB(sb)->s_sbh->b_blocknr !=
    le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
    - ext4_warning(sb, "won't resize using backup superblock at %llu",
    - (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
    + ext4_warn(sb, "won't resize using backup superblock at %llu",
    + (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
    return -EPERM;
    }

    @@ -720,8 +718,8 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,

    data = (__le32 *)dind->b_data;
    if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
    - ext4_warning(sb, "new group %u GDT block %llu not reserved",
    - group, gdblock);
    + ext4_warn(sb, "new group %u GDT block %llu not reserved",
    + group, gdblock);
    err = -EINVAL;
    goto exit_dind;
    }
    @@ -748,8 +746,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
    GFP_NOFS);
    if (!n_group_desc) {
    err = -ENOMEM;
    - ext4_warning(sb, "not enough memory for %lu groups",
    - gdb_num + 1);
    + ext4_warn(sb, "not enough memory for %lu groups", gdb_num + 1);
    goto exit_inode;
    }

    @@ -856,9 +853,9 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
    /* Get each reserved primary GDT block and verify it holds backups */
    for (res = 0; res < reserved_gdb; res++, blk++) {
    if (le32_to_cpu(*data) != blk) {
    - ext4_warning(sb, "reserved block %llu not at offset %ld",
    - blk,
    - (long)(data - (__le32 *)dind->b_data));
    + ext4_warn(sb, "reserved block %llu not at offset %ld",
    + blk,
    + (long)(data - (__le32 *)dind->b_data));
    err = -EINVAL;
    goto exit_bh;
    }
    @@ -1003,8 +1000,8 @@ static void update_backups(struct super_block *sb,
    */
    exit_err:
    if (err) {
    - ext4_warning(sb, "can't update backup for group %u (err %d), forcing fsck on next reboot",
    - group, err);
    + ext4_warn(sb, "can't update backup for group %u (err %d), forcing fsck on next reboot",
    + group, err);
    sbi->s_mount_state &= ~EXT4_VALID_FS;
    sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
    mark_buffer_dirty(sbi->s_sbh);
    @@ -1383,19 +1380,19 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)

    if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
    EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
    - ext4_warning(sb, "Can't resize non-sparse filesystem further");
    + ext4_warn(sb, "Can't resize non-sparse filesystem further");
    return -EPERM;
    }

    if (ext4_blocks_count(es) + input->blocks_count <
    ext4_blocks_count(es)) {
    - ext4_warning(sb, "blocks_count overflow");
    + ext4_warn(sb, "blocks_count overflow");
    return -EINVAL;
    }

    if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
    le32_to_cpu(es->s_inodes_count)) {
    - ext4_warning(sb, "inodes_count overflow");
    + ext4_warn(sb, "inodes_count overflow");
    return -EINVAL;
    }

    @@ -1403,13 +1400,13 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
    if (!EXT4_HAS_COMPAT_FEATURE(sb,
    EXT4_FEATURE_COMPAT_RESIZE_INODE)
    || !le16_to_cpu(es->s_reserved_gdt_blocks)) {
    - ext4_warning(sb,
    - "No reserved GDT blocks, can't resize");
    + ext4_warn(sb,
    + "No reserved GDT blocks, can't resize");
    return -EPERM;
    }
    inode = ext4_iget(sb, EXT4_RESIZE_INO);
    if (IS_ERR(inode)) {
    - ext4_warning(sb, "Error opening resize inode");
    + ext4_warn(sb, "Error opening resize inode");
    return PTR_ERR(inode);
    }
    }
    @@ -1444,13 +1441,13 @@ static int ext4_group_extend_no_check(struct super_block *sb,
    handle = ext4_journal_start_sb(sb, 3);
    if (IS_ERR(handle)) {
    err = PTR_ERR(handle);
    - ext4_warning(sb, "error %d on journal start", err);
    + ext4_warn(sb, "error %d on journal start", err);
    return err;
    }

    err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
    if (err) {
    - ext4_warning(sb, "error %d on journal write access", err);
    + ext4_warn(sb, "error %d on journal write access", err);
    goto errout;
    }

    @@ -1512,12 +1509,12 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
    pr_err("filesystem on %s: too large to resize to %llu blocks safely\n",
    sb->s_id, n_blocks_count);
    if (sizeof(sector_t) < 8)
    - ext4_warning(sb, "CONFIG_LBDAF not enabled");
    + ext4_warn(sb, "CONFIG_LBDAF not enabled");
    return -EINVAL;
    }

    if (n_blocks_count < o_blocks_count) {
    - ext4_warning(sb, "can't shrink FS - resize aborted");
    + ext4_warn(sb, "can't shrink FS - resize aborted");
    return -EINVAL;
    }

    @@ -1525,14 +1522,14 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
    ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);

    if (last == 0) {
    - ext4_warning(sb, "need to use ext2online to resize further");
    + ext4_warn(sb, "need to use ext2online to resize further");
    return -EPERM;
    }

    add = EXT4_BLOCKS_PER_GROUP(sb) - last;

    if (o_blocks_count + add < o_blocks_count) {
    - ext4_warning(sb, "blocks_count overflow");
    + ext4_warn(sb, "blocks_count overflow");
    return -EINVAL;
    }

    @@ -1540,13 +1537,13 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
    add = n_blocks_count - o_blocks_count;

    if (o_blocks_count + add < n_blocks_count)
    - ext4_warning(sb, "will only finish group (%llu blocks, %u new)",
    - o_blocks_count + add, add);
    + ext4_warn(sb, "will only finish group (%llu blocks, %u new)",
    + o_blocks_count + add, add);

    /* See if the device is actually as big as what was requested */
    bh = sb_bread(sb, o_blocks_count + add - 1);
    if (!bh) {
    - ext4_warning(sb, "can't read last block, resize aborted");
    + ext4_warn(sb, "can't read last block, resize aborted");
    return -ENOSPC;
    }
    brelse(bh);
    @@ -1585,7 +1582,7 @@ int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)

    if (n_blocks_count < o_blocks_count) {
    /* On-line shrinking not supported */
    - ext4_warning(sb, "can't shrink FS - resize aborted");
    + ext4_warn(sb, "can't shrink FS - resize aborted");
    return -EINVAL;
    }

    @@ -1605,20 +1602,20 @@ int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)
    if (desc_blocks &&
    (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE) ||
    le16_to_cpu(es->s_reserved_gdt_blocks) < desc_blocks)) {
    - ext4_warning(sb, "No reserved GDT blocks, can't resize");
    + ext4_warn(sb, "No reserved GDT blocks, can't resize");
    return -EPERM;
    }

    resize_inode = ext4_iget(sb, EXT4_RESIZE_INO);
    if (IS_ERR(resize_inode)) {
    - ext4_warning(sb, "Error opening resize inode");
    + ext4_warn(sb, "Error opening resize inode");
    return PTR_ERR(resize_inode);
    }

    /* See if the device is actually as big as what was requested */
    bh = sb_bread(sb, n_blocks_count - 1);
    if (!bh) {
    - ext4_warning(sb, "can't read last block, resize aborted");
    + ext4_warn(sb, "can't read last block, resize aborted");
    return -ENOSPC;
    }
    brelse(bh);
    diff --git a/fs/ext4/super.c b/fs/ext4/super.c
    index cade67b..18e68f1 100644
    --- a/fs/ext4/super.c
    +++ b/fs/ext4/super.c
    @@ -621,7 +621,7 @@ void __ext4_std_error(struct super_block *sb, const char *function,
    }

    /*
    - * ext4_abort is a much stronger failure handler than ext4_error. The
    + * ext4_abort is a much stronger failure handler than ext4_err. The
    * abort function may be used to deal with unrecoverable failures such
    * as journal IO errors or ENOMEM at a critical moment in log management.
    *
    @@ -737,9 +737,9 @@ void ext4_update_dynamic_rev(struct super_block *sb)
    if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
    return;

    - ext4_warning(sb,
    - "updating to rev %d because of new feature flag, running e2fsck is recommended",
    - EXT4_DYNAMIC_REV);
    + ext4_warn(sb,
    + "updating to rev %d because of new feature flag, running e2fsck is recommended",
    + EXT4_DYNAMIC_REV);

    es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
    es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
    @@ -3289,8 +3289,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
    }
    } else {
    if (clustersize != blocksize) {
    - ext4_warning(sb, "fragment/cluster size (%d) != block size (%d)",
    - clustersize, blocksize);
    + ext4_warn(sb, "fragment/cluster size (%d) != block size (%d)",
    + clustersize, blocksize);
    clustersize = blocksize;
    }
    if (sbi->s_blocks_per_group > blocksize * 8) {
    @@ -4080,7 +4080,7 @@ static void ext4_clear_journal_err(struct super_block *sb,

    /*
    * Now check for any error status which may have been recorded in the
    - * journal by a prior ext4_error() or ext4_abort()
    + * journal by a prior ext4_err() or ext4_abort()
    */

    j_errno = jbd2_journal_errno(journal);
    @@ -4088,9 +4088,9 @@ static void ext4_clear_journal_err(struct super_block *sb,
    char nbuf[16];

    errstr = ext4_decode_error(sb, j_errno, nbuf);
    - ext4_warning(sb, "Filesystem error recorded from previous mount: %s",
    - errstr);
    - ext4_warning(sb, "Marking fs in need of filesystem check");
    + ext4_warn(sb, "Filesystem error recorded from previous mount: %s",
    + errstr);
    + ext4_warn(sb, "Marking fs in need of filesystem check");

    EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
    es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
    --
    1.7.8.111.gad25c.dirty


    \
     
     \ /
      Last update: 2012-03-16 01:13    [W:0.114 / U:0.772 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site