lkml.org 
[lkml]   [2018]   [Apr]   [4]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[RFC PATCH 70/79] mm: add struct address_space to mark_buffer_dirty()
    Date
    From: Jérôme Glisse <jglisse@redhat.com>

    For the holy crusade to stop relying on struct page mapping field, add
    struct address_space to mark_buffer_dirty() arguments.

    <---------------------------------------------------------------------
    @@
    identifier I1;
    type T1;
    @@
    void
    -mark_buffer_dirty(T1 I1)
    +mark_buffer_dirty(struct address_space *_mapping, T1 I1)
    {...}

    @@
    type T1;
    @@
    void
    -mark_buffer_dirty(T1)
    +mark_buffer_dirty(struct address_space *, T1)
    ;

    @@
    identifier I1;
    type T1;
    @@
    void
    -mark_buffer_dirty(T1 I1)
    +mark_buffer_dirty(struct address_space *, T1)
    ;

    @@
    expression E1;
    @@
    -mark_buffer_dirty(E1)
    +mark_buffer_dirty(NULL, E1)
    --------------------------------------------------------------------->

    Signed-off-by: Jérôme Glisse <jglisse@redhat.com>
    CC: Andrew Morton <akpm@linux-foundation.org>
    Cc: Alexander Viro <viro@zeniv.linux.org.uk>
    Cc: linux-fsdevel@vger.kernel.org
    Cc: Tejun Heo <tj@kernel.org>
    Cc: Jan Kara <jack@suse.cz>
    Cc: Josef Bacik <jbacik@fb.com>
    Cc: Mel Gorman <mgorman@techsingularity.net>
    ---
    fs/adfs/dir_f.c | 2 +-
    fs/affs/bitmap.c | 6 +++---
    fs/affs/super.c | 2 +-
    fs/bfs/file.c | 2 +-
    fs/bfs/inode.c | 4 ++--
    fs/buffer.c | 12 ++++++------
    fs/ext2/balloc.c | 6 +++---
    fs/ext2/ialloc.c | 8 ++++----
    fs/ext2/inode.c | 2 +-
    fs/ext2/super.c | 4 ++--
    fs/ext2/xattr.c | 8 ++++----
    fs/ext4/ext4_jbd2.c | 4 ++--
    fs/ext4/inode.c | 4 ++--
    fs/ext4/mmp.c | 2 +-
    fs/ext4/resize.c | 2 +-
    fs/ext4/super.c | 2 +-
    fs/fat/inode.c | 4 ++--
    fs/fat/misc.c | 2 +-
    fs/gfs2/bmap.c | 4 ++--
    fs/gfs2/lops.c | 6 +++---
    fs/hfs/mdb.c | 10 +++++-----
    fs/hpfs/anode.c | 34 +++++++++++++++++-----------------
    fs/hpfs/buffer.c | 8 ++++----
    fs/hpfs/dnode.c | 4 ++--
    fs/hpfs/ea.c | 4 ++--
    fs/hpfs/inode.c | 2 +-
    fs/hpfs/namei.c | 10 +++++-----
    fs/hpfs/super.c | 6 +++---
    fs/jbd2/recovery.c | 2 +-
    fs/jbd2/transaction.c | 2 +-
    fs/jfs/jfs_imap.c | 2 +-
    fs/jfs/jfs_mount.c | 2 +-
    fs/jfs/resize.c | 6 +++---
    fs/jfs/super.c | 2 +-
    fs/minix/bitmap.c | 10 +++++-----
    fs/minix/inode.c | 12 ++++++------
    fs/nilfs2/alloc.c | 12 ++++++------
    fs/nilfs2/btnode.c | 4 ++--
    fs/nilfs2/btree.c | 38 +++++++++++++++++++-------------------
    fs/nilfs2/cpfile.c | 24 ++++++++++++------------
    fs/nilfs2/dat.c | 4 ++--
    fs/nilfs2/gcinode.c | 2 +-
    fs/nilfs2/ifile.c | 4 ++--
    fs/nilfs2/inode.c | 2 +-
    fs/nilfs2/ioctl.c | 2 +-
    fs/nilfs2/mdt.c | 2 +-
    fs/nilfs2/segment.c | 4 ++--
    fs/nilfs2/sufile.c | 26 +++++++++++++-------------
    fs/ntfs/file.c | 8 ++++----
    fs/ntfs/super.c | 2 +-
    fs/ocfs2/alloc.c | 2 +-
    fs/ocfs2/aops.c | 4 ++--
    fs/ocfs2/inode.c | 2 +-
    fs/omfs/bitmap.c | 6 +++---
    fs/omfs/dir.c | 8 ++++----
    fs/omfs/file.c | 4 ++--
    fs/omfs/inode.c | 4 ++--
    fs/reiserfs/file.c | 2 +-
    fs/reiserfs/inode.c | 4 ++--
    fs/reiserfs/journal.c | 10 +++++-----
    fs/reiserfs/resize.c | 2 +-
    fs/sysv/balloc.c | 2 +-
    fs/sysv/ialloc.c | 2 +-
    fs/sysv/inode.c | 8 ++++----
    fs/sysv/sysv.h | 4 ++--
    fs/udf/balloc.c | 6 +++---
    fs/udf/inode.c | 2 +-
    fs/udf/partition.c | 4 ++--
    fs/udf/super.c | 8 ++++----
    fs/ufs/balloc.c | 4 ++--
    fs/ufs/ialloc.c | 4 ++--
    fs/ufs/inode.c | 8 ++++----
    fs/ufs/util.c | 2 +-
    include/linux/buffer_head.h | 2 +-
    74 files changed, 220 insertions(+), 220 deletions(-)

    diff --git a/fs/adfs/dir_f.c b/fs/adfs/dir_f.c
    index 0fbfd0b04ae0..3d92f8d187bc 100644
    --- a/fs/adfs/dir_f.c
    +++ b/fs/adfs/dir_f.c
    @@ -434,7 +434,7 @@ adfs_f_update(struct adfs_dir *dir, struct object_info *obj)
    }
    #endif
    for (i = dir->nr_buffers - 1; i >= 0; i--)
    - mark_buffer_dirty(dir->bh[i]);
    + mark_buffer_dirty(NULL, dir->bh[i]);

    ret = 0;
    out:
    diff --git a/fs/affs/bitmap.c b/fs/affs/bitmap.c
    index 5ba9ef2742f6..59b352075505 100644
    --- a/fs/affs/bitmap.c
    +++ b/fs/affs/bitmap.c
    @@ -79,7 +79,7 @@ affs_free_block(struct super_block *sb, u32 block)
    tmp = be32_to_cpu(*(__be32 *)bh->b_data);
    *(__be32 *)bh->b_data = cpu_to_be32(tmp - mask);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    affs_mark_sb_dirty(sb);
    bm->bm_free++;

    @@ -223,7 +223,7 @@ affs_alloc_block(struct inode *inode, u32 goal)
    tmp = be32_to_cpu(*(__be32 *)bh->b_data);
    *(__be32 *)bh->b_data = cpu_to_be32(tmp + mask);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    affs_mark_sb_dirty(sb);

    mutex_unlock(&sbi->s_bmlock);
    @@ -338,7 +338,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
    ((__be32 *)bh->b_data)[offset] = 0;
    ((__be32 *)bh->b_data)[0] = 0;
    ((__be32 *)bh->b_data)[0] = cpu_to_be32(-affs_checksum_block(sb, bh));
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);

    /* recalculate bitmap count for last block */
    bm--;
    diff --git a/fs/affs/super.c b/fs/affs/super.c
    index e602619aed9d..515388985607 100644
    --- a/fs/affs/super.c
    +++ b/fs/affs/super.c
    @@ -40,7 +40,7 @@ affs_commit_super(struct super_block *sb, int wait)
    affs_fix_checksum(sb, bh);
    unlock_buffer(bh);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (wait)
    sync_dirty_buffer(bh);
    }
    diff --git a/fs/bfs/file.c b/fs/bfs/file.c
    index 6d66cc137bc3..e74e1b72df80 100644
    --- a/fs/bfs/file.c
    +++ b/fs/bfs/file.c
    @@ -40,7 +40,7 @@ static int bfs_move_block(unsigned long from, unsigned long to,
    return -EIO;
    new = sb_getblk(sb, to);
    memcpy(new->b_data, bh->b_data, bh->b_size);
    - mark_buffer_dirty(new);
    + mark_buffer_dirty(NULL, new);
    bforget(sb, bh);
    brelse(new);
    return 0;
    diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
    index 9a69392f1fb3..a41edad61187 100644
    --- a/fs/bfs/inode.c
    +++ b/fs/bfs/inode.c
    @@ -149,7 +149,7 @@ static int bfs_write_inode(struct inode *inode, struct writeback_control *wbc)
    di->i_eblock = cpu_to_le32(BFS_I(inode)->i_eblock);
    di->i_eoffset = cpu_to_le32(i_sblock * BFS_BSIZE + inode->i_size - 1);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (wbc->sync_mode == WB_SYNC_ALL) {
    sync_dirty_buffer(bh);
    if (buffer_req(bh) && !buffer_uptodate(bh))
    @@ -185,7 +185,7 @@ static void bfs_evict_inode(struct inode *inode)
    mutex_lock(&info->bfs_lock);
    /* clear on-disk inode */
    memset(di, 0, sizeof(struct bfs_inode));
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);

    if (bi->i_dsk_ino) {
    diff --git a/fs/buffer.c b/fs/buffer.c
    index 27b19c629308..24872b077269 100644
    --- a/fs/buffer.c
    +++ b/fs/buffer.c
    @@ -574,7 +574,7 @@ void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)

    buffer_mapping = fs_page_mapping_get_with_bh(bh->b_page, bh);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (!mapping->private_data) {
    mapping->private_data = buffer_mapping;
    } else {
    @@ -1102,7 +1102,7 @@ __getblk_slow(struct block_device *bdev, sector_t block,
    * mark_buffer_dirty() is atomic. It takes bh->b_page->mapping->private_lock,
    * mapping->tree_lock and mapping->host->i_lock.
    */
    -void mark_buffer_dirty(struct buffer_head *bh)
    +void mark_buffer_dirty(struct address_space *_mapping, struct buffer_head *bh)
    {
    WARN_ON_ONCE(!buffer_uptodate(bh));

    @@ -1891,7 +1891,7 @@ void page_zero_new_buffers(struct address_space *buffer, struct page *page,
    }

    clear_buffer_new(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    }

    @@ -2006,7 +2006,7 @@ int __block_write_begin_int(struct address_space *mapping, struct page *page,
    if (PageUptodate(page)) {
    clear_buffer_new(bh);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    continue;
    }
    if (block_end > to || block_start < from)
    @@ -2068,7 +2068,7 @@ static int __block_commit_write(struct inode *inode, struct page *page,
    partial = 1;
    } else {
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    clear_buffer_new(bh);

    @@ -2937,7 +2937,7 @@ int block_truncate_page(struct address_space *mapping,
    }

    zero_user(page, offset, length);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    err = 0;

    unlock:
    diff --git a/fs/ext2/balloc.c b/fs/ext2/balloc.c
    index 33db13365c5e..e9e4a9f477fe 100644
    --- a/fs/ext2/balloc.c
    +++ b/fs/ext2/balloc.c
    @@ -172,7 +172,7 @@ static void group_adjust_blocks(struct super_block *sb, int group_no,
    free_blocks = le16_to_cpu(desc->bg_free_blocks_count);
    desc->bg_free_blocks_count = cpu_to_le16(free_blocks + count);
    spin_unlock(sb_bgl_lock(sbi, group_no));
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    }

    @@ -547,7 +547,7 @@ void ext2_free_blocks (struct inode * inode, unsigned long block,
    }
    }

    - mark_buffer_dirty(bitmap_bh);
    + mark_buffer_dirty(NULL, bitmap_bh);
    if (sb->s_flags & SB_SYNCHRONOUS)
    sync_dirty_buffer(bitmap_bh);

    @@ -1423,7 +1423,7 @@ ext2_fsblk_t ext2_new_blocks(struct inode *inode, ext2_fsblk_t goal,
    group_adjust_blocks(sb, group_no, gdp, gdp_bh, -num);
    percpu_counter_sub(&sbi->s_freeblocks_counter, num);

    - mark_buffer_dirty(bitmap_bh);
    + mark_buffer_dirty(NULL, bitmap_bh);
    if (sb->s_flags & SB_SYNCHRONOUS)
    sync_dirty_buffer(bitmap_bh);

    diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
    index 6484199b35d1..c444c3c1ebcb 100644
    --- a/fs/ext2/ialloc.c
    +++ b/fs/ext2/ialloc.c
    @@ -82,7 +82,7 @@ static void ext2_release_inode(struct super_block *sb, int group, int dir)
    spin_unlock(sb_bgl_lock(EXT2_SB(sb), group));
    if (dir)
    percpu_counter_dec(&EXT2_SB(sb)->s_dirs_counter);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }

    /*
    @@ -144,7 +144,7 @@ void ext2_free_inode (struct inode * inode)
    "bit already cleared for inode %lu", ino);
    else
    ext2_release_inode(sb, block_group, is_directory);
    - mark_buffer_dirty(bitmap_bh);
    + mark_buffer_dirty(NULL, bitmap_bh);
    if (sb->s_flags & SB_SYNCHRONOUS)
    sync_dirty_buffer(bitmap_bh);

    @@ -516,7 +516,7 @@ struct inode *ext2_new_inode(struct inode *dir, umode_t mode,
    err = -ENOSPC;
    goto fail;
    got:
    - mark_buffer_dirty(bitmap_bh);
    + mark_buffer_dirty(NULL, bitmap_bh);
    if (sb->s_flags & SB_SYNCHRONOUS)
    sync_dirty_buffer(bitmap_bh);
    brelse(bitmap_bh);
    @@ -547,7 +547,7 @@ struct inode *ext2_new_inode(struct inode *dir, umode_t mode,
    }
    spin_unlock(sb_bgl_lock(sbi, group));

    - mark_buffer_dirty(bh2);
    + mark_buffer_dirty(NULL, bh2);
    if (test_opt(sb, GRPID)) {
    inode->i_mode = mode;
    inode->i_uid = current_fsuid();
    diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
    index bc12273e393a..4c1782d0d0c0 100644
    --- a/fs/ext2/inode.c
    +++ b/fs/ext2/inode.c
    @@ -1621,7 +1621,7 @@ static int __ext2_write_inode(struct inode *inode, int do_sync)
    }
    } else for (n = 0; n < EXT2_N_BLOCKS; n++)
    raw_inode->i_block[n] = ei->i_data[n];
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (do_sync) {
    sync_dirty_buffer(bh);
    if (buffer_req(bh) && !buffer_uptodate(bh)) {
    diff --git a/fs/ext2/super.c b/fs/ext2/super.c
    index 7666c065b96f..62cab57b448f 100644
    --- a/fs/ext2/super.c
    +++ b/fs/ext2/super.c
    @@ -1247,7 +1247,7 @@ void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
    es->s_wtime = cpu_to_le32(get_seconds());
    /* unlock before we do IO */
    spin_unlock(&EXT2_SB(sb)->s_lock);
    - mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
    + mark_buffer_dirty(NULL, EXT2_SB(sb)->s_sbh);
    if (wait)
    sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
    }
    @@ -1562,7 +1562,7 @@ static ssize_t ext2_quota_write(struct super_block *sb, int type,
    memcpy(bh->b_data+offset, data, tocopy);
    flush_dcache_page(bh->b_page);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    unlock_buffer(bh);
    brelse(bh);
    offset = 0;
    diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
    index c77edf9afbce..8f3b1950248b 100644
    --- a/fs/ext2/xattr.c
    +++ b/fs/ext2/xattr.c
    @@ -344,7 +344,7 @@ static void ext2_xattr_update_super_block(struct super_block *sb)
    spin_lock(&EXT2_SB(sb)->s_lock);
    EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR);
    spin_unlock(&EXT2_SB(sb)->s_lock);
    - mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
    + mark_buffer_dirty(NULL, EXT2_SB(sb)->s_sbh);
    }

    /*
    @@ -683,7 +683,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,

    ext2_xattr_update_super_block(sb);
    }
    - mark_buffer_dirty(new_bh);
    + mark_buffer_dirty(NULL, new_bh);
    if (IS_SYNC(inode)) {
    sync_dirty_buffer(new_bh);
    error = -EIO;
    @@ -739,7 +739,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
    le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
    dquot_free_block_nodirty(inode, 1);
    mark_inode_dirty(inode);
    - mark_buffer_dirty(old_bh);
    + mark_buffer_dirty(NULL, old_bh);
    ea_bdebug(old_bh, "refcount now=%d",
    le32_to_cpu(HDR(old_bh)->h_refcount));
    }
    @@ -809,7 +809,7 @@ ext2_xattr_delete_inode(struct inode *inode)
    ea_bdebug(bh, "refcount now=%d",
    le32_to_cpu(HDR(bh)->h_refcount));
    unlock_buffer(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (IS_SYNC(inode))
    sync_dirty_buffer(bh);
    dquot_free_block_nodirty(inode, 1);
    diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
    index 60fbf5336059..72209e854a19 100644
    --- a/fs/ext4/ext4_jbd2.c
    +++ b/fs/ext4/ext4_jbd2.c
    @@ -302,7 +302,7 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
    if (inode)
    mark_buffer_dirty_inode(bh, inode);
    else
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (inode && inode_needs_sync(inode)) {
    sync_dirty_buffer(bh);
    if (buffer_req(bh) && !buffer_uptodate(bh)) {
    @@ -334,6 +334,6 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line,
    ext4_journal_abort_handle(where, line, __func__,
    bh, handle, err);
    } else
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    return err;
    }
    diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
    index ef53a57d9768..c0ae0dc7af58 100644
    --- a/fs/ext4/inode.c
    +++ b/fs/ext4/inode.c
    @@ -1202,7 +1202,7 @@ static int ext4_block_write_begin(struct address_space *mapping,
    if (PageUptodate(page)) {
    clear_buffer_new(bh);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    continue;
    }
    if (block_end > to || block_start < from)
    @@ -4070,7 +4070,7 @@ static int __ext4_block_zero_page_range(handle_t *handle,
    err = ext4_handle_dirty_metadata(handle, inode, bh);
    } else {
    err = 0;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (ext4_should_order_data(inode))
    err = ext4_jbd2_inode_add_write(handle, inode);
    }
    diff --git a/fs/ext4/mmp.c b/fs/ext4/mmp.c
    index 27b9a76a0dfa..6fcd8d624ef7 100644
    --- a/fs/ext4/mmp.c
    +++ b/fs/ext4/mmp.c
    @@ -49,7 +49,7 @@ static int write_mmp_block(struct super_block *sb, struct buffer_head *bh)
    */
    sb_start_write(sb);
    ext4_mmp_csum_set(sb, mmp);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    lock_buffer(bh);
    bh->b_end_io = end_buffer_write_sync;
    get_bh(bh);
    diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
    index b6bec270a8e4..398cd8c7dd40 100644
    --- a/fs/ext4/resize.c
    +++ b/fs/ext4/resize.c
    @@ -1160,7 +1160,7 @@ static void update_backups(struct super_block *sb, sector_t blk_off, char *data,
    "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);
    + mark_buffer_dirty(NULL, sbi->s_sbh);
    }
    }

    diff --git a/fs/ext4/super.c b/fs/ext4/super.c
    index cf2b74137fb2..ebef69e45f74 100644
    --- a/fs/ext4/super.c
    +++ b/fs/ext4/super.c
    @@ -4738,7 +4738,7 @@ static int ext4_commit_super(struct super_block *sb, int sync)
    clear_buffer_write_io_error(sbh);
    set_buffer_uptodate(sbh);
    }
    - mark_buffer_dirty(sbh);
    + mark_buffer_dirty(NULL, sbh);
    if (sync) {
    unlock_buffer(sbh);
    error = __sync_dirty_buffer(sbh,
    diff --git a/fs/fat/inode.c b/fs/fat/inode.c
    index 9e6bc6364468..a5cac466caf2 100644
    --- a/fs/fat/inode.c
    +++ b/fs/fat/inode.c
    @@ -695,7 +695,7 @@ static void fat_set_state(struct super_block *sb,
    b->fat16.state &= ~FAT_STATE_DIRTY;
    }

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh);
    brelse(bh);
    }
    @@ -875,7 +875,7 @@ static int __fat_write_inode(struct inode *inode, int wait)
    &raw_entry->adate, NULL);
    }
    spin_unlock(&sbi->inode_hash_lock);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    err = 0;
    if (wait)
    err = sync_dirty_buffer(bh);
    diff --git a/fs/fat/misc.c b/fs/fat/misc.c
    index f9bdc1e01c98..2f1a027684c4 100644
    --- a/fs/fat/misc.c
    +++ b/fs/fat/misc.c
    @@ -85,7 +85,7 @@ int fat_clusters_flush(struct super_block *sb)
    fsinfo->free_clusters = cpu_to_le32(sbi->free_clusters);
    if (sbi->prev_free != -1)
    fsinfo->next_cluster = cpu_to_le32(sbi->prev_free);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    brelse(bh);

    diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
    index 12e10758b0f2..32028225306a 100644
    --- a/fs/gfs2/bmap.c
    +++ b/fs/gfs2/bmap.c
    @@ -90,7 +90,7 @@ static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,

    set_buffer_uptodate(bh);
    if (!gfs2_is_jdata(ip))
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (!gfs2_is_writeback(ip))
    gfs2_trans_add_data(ip->i_gl, bh);

    @@ -955,7 +955,7 @@ static int gfs2_block_zero_range(struct inode *inode, loff_t from,
    gfs2_trans_add_data(ip->i_gl, bh);

    zero_user(page, offset, length);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    unlock:
    unlock_page(page);
    put_page(page);
    diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
    index 3b672378d358..1c7dbf3b1227 100644
    --- a/fs/gfs2/lops.c
    +++ b/fs/gfs2/lops.c
    @@ -105,7 +105,7 @@ static void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh,
    BUG_ON(!buffer_pinned(bh));

    lock_buffer(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    clear_buffer_pinned(bh);

    if (buffer_is_rgrp(bd))
    @@ -558,7 +558,7 @@ static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
    if (gfs2_meta_check(sdp, bh_ip))
    error = -EIO;
    else
    - mark_buffer_dirty(bh_ip);
    + mark_buffer_dirty(NULL, bh_ip);

    brelse(bh_log);
    brelse(bh_ip);
    @@ -797,7 +797,7 @@ static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
    __be32 *eptr = (__be32 *)bh_ip->b_data;
    *eptr = cpu_to_be32(GFS2_MAGIC);
    }
    - mark_buffer_dirty(bh_ip);
    + mark_buffer_dirty(NULL, bh_ip);

    brelse(bh_log);
    brelse(bh_ip);
    diff --git a/fs/hfs/mdb.c b/fs/hfs/mdb.c
    index 460281b1299e..6be25d949b5d 100644
    --- a/fs/hfs/mdb.c
    +++ b/fs/hfs/mdb.c
    @@ -218,7 +218,7 @@ int hfs_mdb_get(struct super_block *sb)
    be32_add_cpu(&mdb->drWrCnt, 1);
    mdb->drLsMod = hfs_mtime();

    - mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
    + mark_buffer_dirty(NULL, HFS_SB(sb)->mdb_bh);
    sync_dirty_buffer(HFS_SB(sb)->mdb_bh);
    }

    @@ -274,7 +274,7 @@ void hfs_mdb_commit(struct super_block *sb)
    mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);

    /* write MDB to disk */
    - mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
    + mark_buffer_dirty(NULL, HFS_SB(sb)->mdb_bh);
    }

    /* write the backup MDB, not returning until it is written.
    @@ -293,7 +293,7 @@ void hfs_mdb_commit(struct super_block *sb)
    HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
    unlock_buffer(HFS_SB(sb)->alt_mdb_bh);

    - mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
    + mark_buffer_dirty(NULL, HFS_SB(sb)->alt_mdb_bh);
    sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
    }

    @@ -320,7 +320,7 @@ void hfs_mdb_commit(struct super_block *sb)
    memcpy(bh->b_data + off, ptr, len);
    unlock_buffer(bh);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    block++;
    off = 0;
    @@ -338,7 +338,7 @@ void hfs_mdb_close(struct super_block *sb)
    return;
    HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
    HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
    - mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
    + mark_buffer_dirty(NULL, HFS_SB(sb)->mdb_bh);
    }

    /*
    diff --git a/fs/hpfs/anode.c b/fs/hpfs/anode.c
    index c14c9a035ee0..38944a8cc677 100644
    --- a/fs/hpfs/anode.c
    +++ b/fs/hpfs/anode.c
    @@ -86,7 +86,7 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    if (bp_internal(btree)) {
    a = le32_to_cpu(btree->u.internal[n].down);
    btree->u.internal[n].file_secno = cpu_to_le32(-1);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    if (hpfs_sb(s)->sb_chk)
    if (hpfs_stop_cycles(s, a, &c1, &c2, "hpfs_add_sector_to_btree #1")) return -1;
    @@ -104,7 +104,7 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    }
    if (hpfs_alloc_if_possible(s, se = le32_to_cpu(btree->u.external[n].disk_secno) + le32_to_cpu(btree->u.external[n].length))) {
    le32_add_cpu(&btree->u.external[n].length, 1);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    return se;
    }
    @@ -141,7 +141,7 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    btree->first_free = cpu_to_le16((char *)&(btree->u.internal[1]) - (char *)btree);
    btree->u.internal[0].file_secno = cpu_to_le32(-1);
    btree->u.internal[0].down = cpu_to_le32(na);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    } else if (!(ranode = hpfs_alloc_anode(s, /*a*/0, &ra, &bh2))) {
    brelse(bh);
    brelse(bh1);
    @@ -158,7 +158,7 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    btree->u.external[n].disk_secno = cpu_to_le32(se);
    btree->u.external[n].file_secno = cpu_to_le32(fs);
    btree->u.external[n].length = cpu_to_le32(1);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    if ((a == node && fnod) || na == -1) return se;
    c2 = 0;
    @@ -179,7 +179,7 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    btree->u.internal[n].file_secno = cpu_to_le32(-1);
    btree->u.internal[n].down = cpu_to_le32(na);
    btree->u.internal[n-1].file_secno = cpu_to_le32(fs);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    brelse(bh2);
    hpfs_free_sectors(s, ra, 1);
    @@ -189,14 +189,14 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    anode->btree.flags |= BP_fnode_parent;
    else
    anode->btree.flags &= ~BP_fnode_parent;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }
    return se;
    }
    up = up != node ? le32_to_cpu(anode->up) : -1;
    btree->u.internal[btree->n_used_nodes - 1].file_secno = cpu_to_le32(/*fs*/-1);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    a = na;
    if ((new_anode = hpfs_alloc_anode(s, a, &na, &bh))) {
    @@ -208,11 +208,11 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    anode->btree.first_free = cpu_to_le16(16);
    anode->btree.u.internal[0].down = cpu_to_le32(a);
    anode->btree.u.internal[0].file_secno = cpu_to_le32(-1);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    if ((anode = hpfs_map_anode(s, a, &bh))) {
    anode->up = cpu_to_le32(na);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }
    } else na = a;
    @@ -221,7 +221,7 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    anode->up = cpu_to_le32(node);
    if (fnod)
    anode->btree.flags |= BP_fnode_parent;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }
    if (!fnod) {
    @@ -247,7 +247,7 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    if ((unode = hpfs_map_anode(s, le32_to_cpu(ranode->u.internal[n].down), &bh1))) {
    unode->up = cpu_to_le32(ra);
    unode->btree.flags &= ~BP_fnode_parent;
    - mark_buffer_dirty(bh1);
    + mark_buffer_dirty(NULL, bh1);
    brelse(bh1);
    }
    }
    @@ -259,9 +259,9 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi
    btree->u.internal[0].down = cpu_to_le32(ra);
    btree->u.internal[1].file_secno = cpu_to_le32(-1);
    btree->u.internal[1].down = cpu_to_le32(na);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    - mark_buffer_dirty(bh2);
    + mark_buffer_dirty(NULL, bh2);
    brelse(bh2);
    return se;
    }
    @@ -375,7 +375,7 @@ int hpfs_ea_write(struct super_block *s, secno a, int ano, unsigned pos,
    return -1;
    l = 0x200 - (pos & 0x1ff); if (l > len) l = len;
    memcpy(data + (pos & 0x1ff), buf, l);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    buf += l; pos += l; len -= l;
    }
    @@ -419,7 +419,7 @@ void hpfs_truncate_btree(struct super_block *s, secno f, int fno, unsigned secs)
    btree->n_used_nodes = 0;
    btree->first_free = cpu_to_le16(8);
    btree->flags &= ~BP_internal;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    } else hpfs_free_sectors(s, f, 1);
    brelse(bh);
    return;
    @@ -437,7 +437,7 @@ void hpfs_truncate_btree(struct super_block *s, secno f, int fno, unsigned secs)
    btree->n_used_nodes = i + 1;
    btree->n_free_nodes = nodes - btree->n_used_nodes;
    btree->first_free = cpu_to_le16(8 + 8 * btree->n_used_nodes);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (btree->u.internal[i].file_secno == cpu_to_le32(secs)) {
    brelse(bh);
    return;
    @@ -471,7 +471,7 @@ void hpfs_truncate_btree(struct super_block *s, secno f, int fno, unsigned secs)
    btree->n_used_nodes = i + 1;
    btree->n_free_nodes = nodes - btree->n_used_nodes;
    btree->first_free = cpu_to_le16(8 + 12 * btree->n_used_nodes);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }

    diff --git a/fs/hpfs/buffer.c b/fs/hpfs/buffer.c
    index e285d6b3bba4..dbb0a4d72bc8 100644
    --- a/fs/hpfs/buffer.c
    +++ b/fs/hpfs/buffer.c
    @@ -225,8 +225,8 @@ void hpfs_mark_4buffers_dirty(struct quad_buffer_head *qbh)
    memcpy(qbh->bh[2]->b_data, qbh->data + 2 * 512, 512);
    memcpy(qbh->bh[3]->b_data, qbh->data + 3 * 512, 512);
    }
    - mark_buffer_dirty(qbh->bh[0]);
    - mark_buffer_dirty(qbh->bh[1]);
    - mark_buffer_dirty(qbh->bh[2]);
    - mark_buffer_dirty(qbh->bh[3]);
    + mark_buffer_dirty(NULL, qbh->bh[0]);
    + mark_buffer_dirty(NULL, qbh->bh[1]);
    + mark_buffer_dirty(NULL, qbh->bh[2]);
    + mark_buffer_dirty(NULL, qbh->bh[3]);
    }
    diff --git a/fs/hpfs/dnode.c b/fs/hpfs/dnode.c
    index a4ad18afbdec..6bc5449d0fd1 100644
    --- a/fs/hpfs/dnode.c
    +++ b/fs/hpfs/dnode.c
    @@ -359,7 +359,7 @@ static int hpfs_add_to_dnode(struct inode *i, dnode_secno dno,
    return 1;
    }
    fnode->u.external[0].disk_secno = cpu_to_le32(rdno);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    hpfs_i(i)->i_dno = rdno;
    d->up = ad->up = cpu_to_le32(rdno);
    @@ -562,7 +562,7 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
    }
    if ((fnode = hpfs_map_fnode(i->i_sb, up, &bh))) {
    fnode->u.external[0].disk_secno = cpu_to_le32(down);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }
    hpfs_inode->i_dno = down;
    diff --git a/fs/hpfs/ea.c b/fs/hpfs/ea.c
    index 102ba18e561f..a600bac34172 100644
    --- a/fs/hpfs/ea.c
    +++ b/fs/hpfs/ea.c
    @@ -278,7 +278,7 @@ void hpfs_set_ea(struct inode *inode, struct fnode *fnode, const char *key,
    fnode->ea_size_s = cpu_to_le16(0);
    fnode->ea_secno = cpu_to_le32(n);
    fnode->flags &= ~FNODE_anode;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }
    pos = le32_to_cpu(fnode->ea_size_l) + 5 + strlen(key) + size;
    @@ -331,7 +331,7 @@ void hpfs_set_ea(struct inode *inode, struct fnode *fnode, const char *key,
    }
    memcpy(b2, b1, 512);
    brelse(bh1);
    - mark_buffer_dirty(bh2);
    + mark_buffer_dirty(NULL, bh2);
    brelse(bh2);
    }
    hpfs_free_sectors(s, le32_to_cpu(fnode->ea_secno), len);
    diff --git a/fs/hpfs/inode.c b/fs/hpfs/inode.c
    index eb8b4baf0f2e..134313fa85fe 100644
    --- a/fs/hpfs/inode.c
    +++ b/fs/hpfs/inode.c
    @@ -253,7 +253,7 @@ void hpfs_write_inode_nolock(struct inode *i)
    "directory %08lx doesn't have '.' entry",
    (unsigned long)i->i_ino);
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }

    diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
    index e79bd8760f3f..75e2b5597bd6 100644
    --- a/fs/hpfs/namei.c
    +++ b/fs/hpfs/namei.c
    @@ -96,7 +96,7 @@ static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
    de->first = de->directory = 1;
    /*de->hidden = de->system = 0;*/
    de->fnode = cpu_to_le32(fno);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    hpfs_mark_4buffers_dirty(&qbh0);
    hpfs_brelse4(&qbh0);
    @@ -187,7 +187,7 @@ static int hpfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, b
    fnode->len = len;
    memcpy(fnode->name, name, len > 15 ? 15 : len);
    fnode->up = cpu_to_le32(dir->i_ino);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);

    insert_inode_hash(result);
    @@ -269,7 +269,7 @@ static int hpfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, de
    fnode->len = len;
    memcpy(fnode->name, name, len > 15 ? 15 : len);
    fnode->up = cpu_to_le32(dir->i_ino);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);

    insert_inode_hash(result);

    @@ -348,7 +348,7 @@ static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *sy
    memcpy(fnode->name, name, len > 15 ? 15 : len);
    fnode->up = cpu_to_le32(dir->i_ino);
    hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);

    insert_inode_hash(result);
    @@ -604,7 +604,7 @@ static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
    fnode->len = new_len;
    memcpy(fnode->name, new_name, new_len>15?15:new_len);
    if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }
    end1:
    diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
    index f2c3ebcd309c..93b9908f300f 100644
    --- a/fs/hpfs/super.c
    +++ b/fs/hpfs/super.c
    @@ -27,7 +27,7 @@ static void mark_dirty(struct super_block *s, int remount)
    if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
    sb->dirty = 1;
    sb->old_wrote = 0;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh);
    brelse(bh);
    }
    @@ -46,7 +46,7 @@ static void unmark_dirty(struct super_block *s)
    if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
    sb->dirty = hpfs_sb(s)->sb_chkdsk > 1 - hpfs_sb(s)->sb_was_error;
    sb->old_wrote = hpfs_sb(s)->sb_chkdsk >= 2 && !hpfs_sb(s)->sb_was_error;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh);
    brelse(bh);
    }
    @@ -667,7 +667,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
    if (!sb_rdonly(s)) {
    spareblock->dirty = 1;
    spareblock->old_wrote = 0;
    - mark_buffer_dirty(bh2);
    + mark_buffer_dirty(NULL, bh2);
    }

    if (le32_to_cpu(spareblock->n_dnode_spares) != le32_to_cpu(spareblock->n_dnode_spares_free)) {
    diff --git a/fs/jbd2/recovery.c b/fs/jbd2/recovery.c
    index f99910b69c78..936d74bf4c40 100644
    --- a/fs/jbd2/recovery.c
    +++ b/fs/jbd2/recovery.c
    @@ -631,7 +631,7 @@ static int do_one_pass(journal_t *journal,

    BUFFER_TRACE(nbh, "marking dirty");
    set_buffer_uptodate(nbh);
    - mark_buffer_dirty(nbh);
    + mark_buffer_dirty(NULL, nbh);
    BUFFER_TRACE(nbh, "marking uptodate");
    ++info->nr_replays;
    /* ll_rw_block(WRITE, 1, &nbh); */
    diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
    index 6899e7b4036d..01c31d021b47 100644
    --- a/fs/jbd2/transaction.c
    +++ b/fs/jbd2/transaction.c
    @@ -1885,7 +1885,7 @@ static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
    if (transaction && is_journal_aborted(transaction->t_journal))
    clear_buffer_jbddirty(bh);
    else if (test_clear_buffer_jbddirty(bh))
    - mark_buffer_dirty(bh); /* Expose it to the VM */
    + mark_buffer_dirty(NULL, bh); /* Expose it to the VM */
    }

    /*
    diff --git a/fs/jfs/jfs_imap.c b/fs/jfs/jfs_imap.c
    index f36ef68905a7..69a10c8d9605 100644
    --- a/fs/jfs/jfs_imap.c
    +++ b/fs/jfs/jfs_imap.c
    @@ -3009,7 +3009,7 @@ static void duplicateIXtree(struct super_block *sb, s64 blkno,
    j_sb = (struct jfs_superblock *)bh->b_data;
    j_sb->s_flag |= cpu_to_le32(JFS_BAD_SAIT);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh);
    brelse(bh);
    return;
    diff --git a/fs/jfs/jfs_mount.c b/fs/jfs/jfs_mount.c
    index d8658607bf46..3cf9d794d08a 100644
    --- a/fs/jfs/jfs_mount.c
    +++ b/fs/jfs/jfs_mount.c
    @@ -448,7 +448,7 @@ int updateSuper(struct super_block *sb, uint state)
    j_sb->s_flag |= cpu_to_le32(JFS_DASD_PRIME);
    }

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh);
    brelse(bh);

    diff --git a/fs/jfs/resize.c b/fs/jfs/resize.c
    index c1f417b94fe6..7d800d80a9d1 100644
    --- a/fs/jfs/resize.c
    +++ b/fs/jfs/resize.c
    @@ -247,7 +247,7 @@ int jfs_extendfs(struct super_block *sb, s64 newLVSize, int newLogSize)
    PXDlength(&j_sb->s_xlogpxd, newLogSize);

    /* synchronously update superblock */
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh);
    brelse(bh);

    @@ -523,13 +523,13 @@ int jfs_extendfs(struct super_block *sb, s64 newLVSize, int newLogSize)
    j_sb2 = (struct jfs_superblock *)bh2->b_data;
    memcpy(j_sb2, j_sb, sizeof (struct jfs_superblock));

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh2);
    brelse(bh2);
    }

    /* write primary superblock */
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sync_dirty_buffer(bh);
    brelse(bh);

    diff --git a/fs/jfs/super.c b/fs/jfs/super.c
    index 1b9264fd54b6..96cc8c79f0d7 100644
    --- a/fs/jfs/super.c
    +++ b/fs/jfs/super.c
    @@ -838,7 +838,7 @@ static ssize_t jfs_quota_write(struct super_block *sb, int type,
    memcpy(bh->b_data+offset, data, tocopy);
    flush_dcache_page(bh->b_page);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    unlock_buffer(bh);
    brelse(bh);
    offset = 0;
    diff --git a/fs/minix/bitmap.c b/fs/minix/bitmap.c
    index f4e5e5181a14..61c7f0d4d00a 100644
    --- a/fs/minix/bitmap.c
    +++ b/fs/minix/bitmap.c
    @@ -64,7 +64,7 @@ void minix_free_block(struct inode *inode, unsigned long block)
    printk("minix_free_block (%s:%lu): bit already cleared\n",
    sb->s_id, block);
    spin_unlock(&bitmap_lock);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    return;
    }

    @@ -83,7 +83,7 @@ int minix_new_block(struct inode * inode)
    if (j < bits_per_zone) {
    minix_set_bit(j, bh->b_data);
    spin_unlock(&bitmap_lock);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    j += i * bits_per_zone + sbi->s_firstdatazone-1;
    if (j < sbi->s_firstdatazone || j >= sbi->s_nzones)
    break;
    @@ -175,7 +175,7 @@ static void minix_clear_inode(struct inode *inode)
    }
    }
    if (bh) {
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse (bh);
    }
    }
    @@ -207,7 +207,7 @@ void minix_free_inode(struct inode * inode)
    if (!minix_test_and_clear_bit(bit, bh->b_data))
    printk("minix_free_inode: bit %lu already cleared\n", bit);
    spin_unlock(&bitmap_lock);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }

    struct inode *minix_new_inode(const struct inode *dir, umode_t mode, int *error)
    @@ -246,7 +246,7 @@ struct inode *minix_new_inode(const struct inode *dir, umode_t mode, int *error)
    return NULL;
    }
    spin_unlock(&bitmap_lock);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    j += i * bits_per_zone;
    if (!j || j > sbi->s_ninodes) {
    iput(inode);
    diff --git a/fs/minix/inode.c b/fs/minix/inode.c
    index 450aa4e87cd9..e8550a58fe83 100644
    --- a/fs/minix/inode.c
    +++ b/fs/minix/inode.c
    @@ -45,7 +45,7 @@ static void minix_put_super(struct super_block *sb)
    if (!sb_rdonly(sb)) {
    if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
    sbi->s_ms->s_state = sbi->s_mount_state;
    - mark_buffer_dirty(sbi->s_sbh);
    + mark_buffer_dirty(NULL, sbi->s_sbh);
    }
    for (i = 0; i < sbi->s_imap_blocks; i++)
    brelse(sbi->s_imap[i]);
    @@ -134,7 +134,7 @@ static int minix_remount (struct super_block * sb, int * flags, char * data)
    /* Mounting a rw partition read-only. */
    if (sbi->s_version != MINIX_V3)
    ms->s_state = sbi->s_mount_state;
    - mark_buffer_dirty(sbi->s_sbh);
    + mark_buffer_dirty(NULL, sbi->s_sbh);
    } else {
    /* Mount a partition which is read-only, read-write. */
    if (sbi->s_version != MINIX_V3) {
    @@ -143,7 +143,7 @@ static int minix_remount (struct super_block * sb, int * flags, char * data)
    } else {
    sbi->s_mount_state = MINIX_VALID_FS;
    }
    - mark_buffer_dirty(sbi->s_sbh);
    + mark_buffer_dirty(NULL, sbi->s_sbh);

    if (!(sbi->s_mount_state & MINIX_VALID_FS))
    printk("MINIX-fs warning: remounting unchecked fs, "
    @@ -296,7 +296,7 @@ static int minix_fill_super(struct super_block *s, void *data, int silent)
    if (!sb_rdonly(s)) {
    if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
    ms->s_state &= ~MINIX_VALID_FS;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    if (!(sbi->s_mount_state & MINIX_VALID_FS))
    printk("MINIX-fs: mounting unchecked file system, "
    @@ -570,7 +570,7 @@ static struct buffer_head * V1_minix_update_inode(struct inode * inode)
    raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
    else for (i = 0; i < 9; i++)
    raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    return bh;
    }

    @@ -599,7 +599,7 @@ static struct buffer_head * V2_minix_update_inode(struct inode * inode)
    raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
    else for (i = 0; i < 10; i++)
    raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    return bh;
    }

    diff --git a/fs/nilfs2/alloc.c b/fs/nilfs2/alloc.c
    index 03b8ba933eb2..7e3d3a8dc3f9 100644
    --- a/fs/nilfs2/alloc.c
    +++ b/fs/nilfs2/alloc.c
    @@ -591,8 +591,8 @@ int nilfs_palloc_prepare_alloc_entry(struct inode *inode,
    void nilfs_palloc_commit_alloc_entry(struct inode *inode,
    struct nilfs_palloc_req *req)
    {
    - mark_buffer_dirty(req->pr_bitmap_bh);
    - mark_buffer_dirty(req->pr_desc_bh);
    + mark_buffer_dirty(NULL, req->pr_bitmap_bh);
    + mark_buffer_dirty(NULL, req->pr_desc_bh);
    nilfs_mdt_mark_dirty(inode);

    brelse(req->pr_bitmap_bh);
    @@ -632,8 +632,8 @@ void nilfs_palloc_commit_free_entry(struct inode *inode,
    kunmap(req->pr_bitmap_bh->b_page);
    kunmap(req->pr_desc_bh->b_page);

    - mark_buffer_dirty(req->pr_desc_bh);
    - mark_buffer_dirty(req->pr_bitmap_bh);
    + mark_buffer_dirty(NULL, req->pr_desc_bh);
    + mark_buffer_dirty(NULL, req->pr_bitmap_bh);
    nilfs_mdt_mark_dirty(inode);

    brelse(req->pr_bitmap_bh);
    @@ -810,7 +810,7 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
    } while (true);

    kunmap(bitmap_bh->b_page);
    - mark_buffer_dirty(bitmap_bh);
    + mark_buffer_dirty(NULL, bitmap_bh);
    brelse(bitmap_bh);

    for (k = 0; k < nempties; k++) {
    @@ -828,7 +828,7 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
    inode, group, desc_bh, desc_kaddr);
    nfree = nilfs_palloc_group_desc_add_entries(desc, lock, n);
    kunmap_atomic(desc_kaddr);
    - mark_buffer_dirty(desc_bh);
    + mark_buffer_dirty(NULL, desc_bh);
    nilfs_mdt_mark_dirty(inode);
    brelse(desc_bh);

    diff --git a/fs/nilfs2/btnode.c b/fs/nilfs2/btnode.c
    index c21e0b4454a6..a2d7844b1ff4 100644
    --- a/fs/nilfs2/btnode.c
    +++ b/fs/nilfs2/btnode.c
    @@ -249,7 +249,7 @@ void nilfs_btnode_commit_change_key(struct address_space *btnc,
    "invalid oldkey %lld (newkey=%lld)",
    (unsigned long long)oldkey,
    (unsigned long long)newkey);
    - mark_buffer_dirty(obh);
    + mark_buffer_dirty(NULL, obh);

    spin_lock_irq(&btnc->tree_lock);
    radix_tree_delete(&btnc->page_tree, oldkey);
    @@ -261,7 +261,7 @@ void nilfs_btnode_commit_change_key(struct address_space *btnc,
    unlock_page(opage);
    } else {
    nilfs_copy_buffer(nbh, obh);
    - mark_buffer_dirty(nbh);
    + mark_buffer_dirty(NULL, nbh);

    nbh->b_blocknr = newkey;
    ctxt->bh = nbh;
    diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c
    index 16a7a67a11c9..39edf8a267d7 100644
    --- a/fs/nilfs2/btree.c
    +++ b/fs/nilfs2/btree.c
    @@ -792,7 +792,7 @@ static void nilfs_btree_promote_key(struct nilfs_bmap *btree,
    nilfs_btree_get_nonroot_node(path, level),
    path[level].bp_index, key);
    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);
    } while ((path[level].bp_index == 0) &&
    (++level < nilfs_btree_height(btree) - 1));
    }
    @@ -817,7 +817,7 @@ static void nilfs_btree_do_insert(struct nilfs_bmap *btree,
    nilfs_btree_node_insert(node, path[level].bp_index,
    *keyp, *ptrp, ncblk);
    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);

    if (path[level].bp_index == 0)
    nilfs_btree_promote_key(btree, path, level + 1,
    @@ -855,9 +855,9 @@ static void nilfs_btree_carry_left(struct nilfs_bmap *btree,
    nilfs_btree_node_move_left(left, node, n, ncblk, ncblk);

    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);
    if (!buffer_dirty(path[level].bp_sib_bh))
    - mark_buffer_dirty(path[level].bp_sib_bh);
    + mark_buffer_dirty(NULL, path[level].bp_sib_bh);

    nilfs_btree_promote_key(btree, path, level + 1,
    nilfs_btree_node_get_key(node, 0));
    @@ -901,9 +901,9 @@ static void nilfs_btree_carry_right(struct nilfs_bmap *btree,
    nilfs_btree_node_move_right(node, right, n, ncblk, ncblk);

    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);
    if (!buffer_dirty(path[level].bp_sib_bh))
    - mark_buffer_dirty(path[level].bp_sib_bh);
    + mark_buffer_dirty(NULL, path[level].bp_sib_bh);

    path[level + 1].bp_index++;
    nilfs_btree_promote_key(btree, path, level + 1,
    @@ -946,9 +946,9 @@ static void nilfs_btree_split(struct nilfs_bmap *btree,
    nilfs_btree_node_move_right(node, right, n, ncblk, ncblk);

    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);
    if (!buffer_dirty(path[level].bp_sib_bh))
    - mark_buffer_dirty(path[level].bp_sib_bh);
    + mark_buffer_dirty(NULL, path[level].bp_sib_bh);

    if (move) {
    path[level].bp_index -= nilfs_btree_node_get_nchildren(node);
    @@ -992,7 +992,7 @@ static void nilfs_btree_grow(struct nilfs_bmap *btree,
    nilfs_btree_node_set_level(root, level + 1);

    if (!buffer_dirty(path[level].bp_sib_bh))
    - mark_buffer_dirty(path[level].bp_sib_bh);
    + mark_buffer_dirty(NULL, path[level].bp_sib_bh);

    path[level].bp_bh = path[level].bp_sib_bh;
    path[level].bp_sib_bh = NULL;
    @@ -1267,7 +1267,7 @@ static void nilfs_btree_do_delete(struct nilfs_bmap *btree,
    nilfs_btree_node_delete(node, path[level].bp_index,
    keyp, ptrp, ncblk);
    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);
    if (path[level].bp_index == 0)
    nilfs_btree_promote_key(btree, path, level + 1,
    nilfs_btree_node_get_key(node, 0));
    @@ -1299,9 +1299,9 @@ static void nilfs_btree_borrow_left(struct nilfs_bmap *btree,
    nilfs_btree_node_move_right(left, node, n, ncblk, ncblk);

    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);
    if (!buffer_dirty(path[level].bp_sib_bh))
    - mark_buffer_dirty(path[level].bp_sib_bh);
    + mark_buffer_dirty(NULL, path[level].bp_sib_bh);

    nilfs_btree_promote_key(btree, path, level + 1,
    nilfs_btree_node_get_key(node, 0));
    @@ -1331,9 +1331,9 @@ static void nilfs_btree_borrow_right(struct nilfs_bmap *btree,
    nilfs_btree_node_move_left(node, right, n, ncblk, ncblk);

    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);
    if (!buffer_dirty(path[level].bp_sib_bh))
    - mark_buffer_dirty(path[level].bp_sib_bh);
    + mark_buffer_dirty(NULL, path[level].bp_sib_bh);

    path[level + 1].bp_index++;
    nilfs_btree_promote_key(btree, path, level + 1,
    @@ -1362,7 +1362,7 @@ static void nilfs_btree_concat_left(struct nilfs_bmap *btree,
    nilfs_btree_node_move_left(left, node, n, ncblk, ncblk);

    if (!buffer_dirty(path[level].bp_sib_bh))
    - mark_buffer_dirty(path[level].bp_sib_bh);
    + mark_buffer_dirty(NULL, path[level].bp_sib_bh);

    nilfs_btnode_delete(path[level].bp_bh);
    path[level].bp_bh = path[level].bp_sib_bh;
    @@ -1388,7 +1388,7 @@ static void nilfs_btree_concat_right(struct nilfs_bmap *btree,
    nilfs_btree_node_move_left(node, right, n, ncblk, ncblk);

    if (!buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);

    nilfs_btnode_delete(path[level].bp_sib_bh);
    path[level].bp_sib_bh = NULL;
    @@ -1818,7 +1818,7 @@ nilfs_btree_commit_convert_and_insert(struct nilfs_bmap *btree,
    nilfs_btree_node_init(node, 0, 1, n, ncblk, keys, ptrs);
    nilfs_btree_node_insert(node, n, key, dreq->bpr_ptr, ncblk);
    if (!buffer_dirty(bh))
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (!nilfs_bmap_dirty(btree))
    nilfs_bmap_set_dirty(btree);

    @@ -1896,7 +1896,7 @@ static int nilfs_btree_propagate_p(struct nilfs_bmap *btree,
    {
    while ((++level < nilfs_btree_height(btree) - 1) &&
    !buffer_dirty(path[level].bp_bh))
    - mark_buffer_dirty(path[level].bp_bh);
    + mark_buffer_dirty(NULL, path[level].bp_bh);

    return 0;
    }
    @@ -2339,7 +2339,7 @@ static int nilfs_btree_mark(struct nilfs_bmap *btree, __u64 key, int level)
    }

    if (!buffer_dirty(bh))
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    if (!nilfs_bmap_dirty(btree))
    nilfs_bmap_set_dirty(btree);
    diff --git a/fs/nilfs2/cpfile.c b/fs/nilfs2/cpfile.c
    index a15a1601e931..9e4558a8e4da 100644
    --- a/fs/nilfs2/cpfile.c
    +++ b/fs/nilfs2/cpfile.c
    @@ -258,14 +258,14 @@ int nilfs_cpfile_get_checkpoint(struct inode *cpfile,
    if (!nilfs_cpfile_is_in_first(cpfile, cno))
    nilfs_cpfile_block_add_valid_checkpoints(cpfile, cp_bh,
    kaddr, 1);
    - mark_buffer_dirty(cp_bh);
    + mark_buffer_dirty(NULL, cp_bh);

    kaddr = kmap_atomic(header_bh->b_page);
    header = nilfs_cpfile_block_get_header(cpfile, header_bh,
    kaddr);
    le64_add_cpu(&header->ch_ncheckpoints, 1);
    kunmap_atomic(kaddr);
    - mark_buffer_dirty(header_bh);
    + mark_buffer_dirty(NULL, header_bh);
    nilfs_mdt_mark_dirty(cpfile);
    }

    @@ -370,7 +370,7 @@ int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
    }
    if (nicps > 0) {
    tnicps += nicps;
    - mark_buffer_dirty(cp_bh);
    + mark_buffer_dirty(NULL, cp_bh);
    nilfs_mdt_mark_dirty(cpfile);
    if (!nilfs_cpfile_is_in_first(cpfile, cno)) {
    count =
    @@ -402,7 +402,7 @@ int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
    header = nilfs_cpfile_block_get_header(cpfile, header_bh,
    kaddr);
    le64_add_cpu(&header->ch_ncheckpoints, -(u64)tnicps);
    - mark_buffer_dirty(header_bh);
    + mark_buffer_dirty(NULL, header_bh);
    nilfs_mdt_mark_dirty(cpfile);
    kunmap_atomic(kaddr);
    }
    @@ -720,10 +720,10 @@ static int nilfs_cpfile_set_snapshot(struct inode *cpfile, __u64 cno)
    le64_add_cpu(&header->ch_nsnapshots, 1);
    kunmap_atomic(kaddr);

    - mark_buffer_dirty(prev_bh);
    - mark_buffer_dirty(curr_bh);
    - mark_buffer_dirty(cp_bh);
    - mark_buffer_dirty(header_bh);
    + mark_buffer_dirty(NULL, prev_bh);
    + mark_buffer_dirty(NULL, curr_bh);
    + mark_buffer_dirty(NULL, cp_bh);
    + mark_buffer_dirty(NULL, header_bh);
    nilfs_mdt_mark_dirty(cpfile);

    brelse(prev_bh);
    @@ -823,10 +823,10 @@ static int nilfs_cpfile_clear_snapshot(struct inode *cpfile, __u64 cno)
    le64_add_cpu(&header->ch_nsnapshots, -1);
    kunmap_atomic(kaddr);

    - mark_buffer_dirty(next_bh);
    - mark_buffer_dirty(prev_bh);
    - mark_buffer_dirty(cp_bh);
    - mark_buffer_dirty(header_bh);
    + mark_buffer_dirty(NULL, next_bh);
    + mark_buffer_dirty(NULL, prev_bh);
    + mark_buffer_dirty(NULL, cp_bh);
    + mark_buffer_dirty(NULL, header_bh);
    nilfs_mdt_mark_dirty(cpfile);

    brelse(prev_bh);
    diff --git a/fs/nilfs2/dat.c b/fs/nilfs2/dat.c
    index dffedb2f8817..8db180ed9812 100644
    --- a/fs/nilfs2/dat.c
    +++ b/fs/nilfs2/dat.c
    @@ -56,7 +56,7 @@ static int nilfs_dat_prepare_entry(struct inode *dat,
    static void nilfs_dat_commit_entry(struct inode *dat,
    struct nilfs_palloc_req *req)
    {
    - mark_buffer_dirty(req->pr_entry_bh);
    + mark_buffer_dirty(NULL, req->pr_entry_bh);
    nilfs_mdt_mark_dirty(dat);
    brelse(req->pr_entry_bh);
    }
    @@ -362,7 +362,7 @@ int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
    entry->de_blocknr = cpu_to_le64(blocknr);
    kunmap_atomic(kaddr);

    - mark_buffer_dirty(entry_bh);
    + mark_buffer_dirty(NULL, entry_bh);
    nilfs_mdt_mark_dirty(dat);

    brelse(entry_bh);
    diff --git a/fs/nilfs2/gcinode.c b/fs/nilfs2/gcinode.c
    index 853a831dcde0..ba2af926b39a 100644
    --- a/fs/nilfs2/gcinode.c
    +++ b/fs/nilfs2/gcinode.c
    @@ -164,7 +164,7 @@ int nilfs_gccache_wait_and_mark_dirty(struct buffer_head *bh)
    clear_buffer_uptodate(bh);
    return -EIO;
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    return 0;
    }

    diff --git a/fs/nilfs2/ifile.c b/fs/nilfs2/ifile.c
    index b8fa45c20c63..11262c2f46f4 100644
    --- a/fs/nilfs2/ifile.c
    +++ b/fs/nilfs2/ifile.c
    @@ -82,7 +82,7 @@ int nilfs_ifile_create_inode(struct inode *ifile, ino_t *out_ino,
    return ret;
    }
    nilfs_palloc_commit_alloc_entry(ifile, &req);
    - mark_buffer_dirty(req.pr_entry_bh);
    + mark_buffer_dirty(NULL, req.pr_entry_bh);
    nilfs_mdt_mark_dirty(ifile);
    *out_ino = (ino_t)req.pr_entry_nr;
    *out_bh = req.pr_entry_bh;
    @@ -130,7 +130,7 @@ int nilfs_ifile_delete_inode(struct inode *ifile, ino_t ino)
    raw_inode->i_flags = 0;
    kunmap_atomic(kaddr);

    - mark_buffer_dirty(req.pr_entry_bh);
    + mark_buffer_dirty(NULL, req.pr_entry_bh);
    brelse(req.pr_entry_bh);

    nilfs_palloc_commit_free_entry(ifile, &req);
    diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
    index 7cc0268d68ce..811e4d952511 100644
    --- a/fs/nilfs2/inode.c
    +++ b/fs/nilfs2/inode.c
    @@ -968,7 +968,7 @@ int __nilfs_mark_inode_dirty(struct inode *inode, int flags)
    return err;
    }
    nilfs_update_inode(inode, ibh, flags);
    - mark_buffer_dirty(ibh);
    + mark_buffer_dirty(NULL, ibh);
    nilfs_mdt_mark_dirty(NILFS_I(inode)->i_root->ifile);
    brelse(ibh);
    return 0;
    diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c
    index 1d2c3d7711fe..18b550252ff2 100644
    --- a/fs/nilfs2/ioctl.c
    +++ b/fs/nilfs2/ioctl.c
    @@ -801,7 +801,7 @@ static int nilfs_ioctl_mark_blocks_dirty(struct the_nilfs *nilfs,
    WARN_ON(ret == -ENOENT);
    return ret;
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    nilfs_mdt_mark_dirty(nilfs->ns_dat);
    put_bh(bh);
    } else {
    diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
    index ca7bc0fba624..ad41b67eb25f 100644
    --- a/fs/nilfs2/mdt.c
    +++ b/fs/nilfs2/mdt.c
    @@ -64,7 +64,7 @@ nilfs_mdt_insert_new_block(struct inode *inode, unsigned long block,
    kunmap_atomic(kaddr);

    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    nilfs_mdt_mark_dirty(inode);

    trace_nilfs2_mdt_insert_new_block(inode, inode->i_ino, block);
    diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
    index 0952d0acab4a..8dc544e3fe6a 100644
    --- a/fs/nilfs2/segment.c
    +++ b/fs/nilfs2/segment.c
    @@ -883,7 +883,7 @@ static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci)
    * needed to collect the checkpoint even if it was not newly
    * created.
    */
    - mark_buffer_dirty(bh_cp);
    + mark_buffer_dirty(NULL, bh_cp);
    nilfs_mdt_mark_dirty(nilfs->ns_cpfile);
    nilfs_cpfile_put_checkpoint(
    nilfs->ns_cpfile, nilfs->ns_cno, bh_cp);
    @@ -1964,7 +1964,7 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
    }

    // Always redirty the buffer to avoid race condition
    - mark_buffer_dirty(ii->i_bh);
    + mark_buffer_dirty(NULL, ii->i_bh);
    nilfs_mdt_mark_dirty(ifile);

    clear_bit(NILFS_I_QUEUED, &ii->i_state);
    diff --git a/fs/nilfs2/sufile.c b/fs/nilfs2/sufile.c
    index c7fa139d50e8..707f2231d348 100644
    --- a/fs/nilfs2/sufile.c
    +++ b/fs/nilfs2/sufile.c
    @@ -122,7 +122,7 @@ static void nilfs_sufile_mod_counter(struct buffer_head *header_bh,
    le64_add_cpu(&header->sh_ndirtysegs, ndirtyadd);
    kunmap_atomic(kaddr);

    - mark_buffer_dirty(header_bh);
    + mark_buffer_dirty(NULL, header_bh);
    }

    /**
    @@ -383,8 +383,8 @@ int nilfs_sufile_alloc(struct inode *sufile, __u64 *segnump)
    kunmap_atomic(kaddr);

    sui->ncleansegs--;
    - mark_buffer_dirty(header_bh);
    - mark_buffer_dirty(su_bh);
    + mark_buffer_dirty(NULL, header_bh);
    + mark_buffer_dirty(NULL, su_bh);
    nilfs_mdt_mark_dirty(sufile);
    brelse(su_bh);
    *segnump = segnum;
    @@ -431,7 +431,7 @@ void nilfs_sufile_do_cancel_free(struct inode *sufile, __u64 segnum,
    nilfs_sufile_mod_counter(header_bh, -1, 1);
    NILFS_SUI(sufile)->ncleansegs--;

    - mark_buffer_dirty(su_bh);
    + mark_buffer_dirty(NULL, su_bh);
    nilfs_mdt_mark_dirty(sufile);
    }

    @@ -462,7 +462,7 @@ void nilfs_sufile_do_scrap(struct inode *sufile, __u64 segnum,
    nilfs_sufile_mod_counter(header_bh, clean ? (u64)-1 : 0, dirty ? 0 : 1);
    NILFS_SUI(sufile)->ncleansegs -= clean;

    - mark_buffer_dirty(su_bh);
    + mark_buffer_dirty(NULL, su_bh);
    nilfs_mdt_mark_dirty(sufile);
    }

    @@ -489,7 +489,7 @@ void nilfs_sufile_do_free(struct inode *sufile, __u64 segnum,
    sudirty = nilfs_segment_usage_dirty(su);
    nilfs_segment_usage_set_clean(su);
    kunmap_atomic(kaddr);
    - mark_buffer_dirty(su_bh);
    + mark_buffer_dirty(NULL, su_bh);

    nilfs_sufile_mod_counter(header_bh, 1, sudirty ? (u64)-1 : 0);
    NILFS_SUI(sufile)->ncleansegs++;
    @@ -511,7 +511,7 @@ int nilfs_sufile_mark_dirty(struct inode *sufile, __u64 segnum)

    ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &bh);
    if (!ret) {
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    nilfs_mdt_mark_dirty(sufile);
    brelse(bh);
    }
    @@ -546,7 +546,7 @@ int nilfs_sufile_set_segment_usage(struct inode *sufile, __u64 segnum,
    su->su_nblocks = cpu_to_le32(nblocks);
    kunmap_atomic(kaddr);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    nilfs_mdt_mark_dirty(sufile);
    brelse(bh);

    @@ -625,7 +625,7 @@ void nilfs_sufile_do_set_error(struct inode *sufile, __u64 segnum,
    nilfs_sufile_mod_counter(header_bh, -1, 0);
    NILFS_SUI(sufile)->ncleansegs--;
    }
    - mark_buffer_dirty(su_bh);
    + mark_buffer_dirty(NULL, su_bh);
    nilfs_mdt_mark_dirty(sufile);
    }

    @@ -711,7 +711,7 @@ static int nilfs_sufile_truncate_range(struct inode *sufile,
    }
    kunmap_atomic(kaddr);
    if (nc > 0) {
    - mark_buffer_dirty(su_bh);
    + mark_buffer_dirty(NULL, su_bh);
    ncleaned += nc;
    }
    brelse(su_bh);
    @@ -790,7 +790,7 @@ int nilfs_sufile_resize(struct inode *sufile, __u64 newnsegs)
    header->sh_ncleansegs = cpu_to_le64(sui->ncleansegs);
    kunmap_atomic(kaddr);

    - mark_buffer_dirty(header_bh);
    + mark_buffer_dirty(NULL, header_bh);
    nilfs_mdt_mark_dirty(sufile);
    nilfs_set_nsegments(nilfs, newnsegs);

    @@ -984,13 +984,13 @@ ssize_t nilfs_sufile_set_suinfo(struct inode *sufile, void *buf,
    continue;

    /* get different block */
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    put_bh(bh);
    ret = nilfs_mdt_get_block(sufile, blkoff, 1, NULL, &bh);
    if (unlikely(ret < 0))
    goto out_mark;
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    put_bh(bh);

    out_mark:
    diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
    index 860b3b2ff47d..bf07c0ca127e 100644
    --- a/fs/ntfs/file.c
    +++ b/fs/ntfs/file.c
    @@ -743,7 +743,7 @@ static int ntfs_prepare_pages_for_non_resident_write(struct page **pages,
    /* We allocated the buffer. */
    clean_bdev_bh_alias(bh);
    if (bh_end <= pos || bh_pos >= end)
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    else
    set_buffer_new(bh);
    }
    @@ -799,7 +799,7 @@ static int ntfs_prepare_pages_for_non_resident_write(struct page **pages,
    blocksize);
    set_buffer_uptodate(bh);
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    continue;
    }
    set_buffer_new(bh);
    @@ -1365,7 +1365,7 @@ static int ntfs_prepare_pages_for_non_resident_write(struct page **pages,
    set_buffer_uptodate(bh);
    }
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    } while ((bh = bh->b_this_page) != head);
    } while (++u <= nr_pages);
    ntfs_error(vol->sb, "Failed. Returning error code %i.", err);
    @@ -1434,7 +1434,7 @@ static inline int ntfs_commit_pages_after_non_resident_write(
    partial = true;
    } else {
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    } while (bh_pos += blocksize, (bh = bh->b_this_page) != head);
    /*
    diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
    index bb7159f697f2..0d21744db6ba 100644
    --- a/fs/ntfs/super.c
    +++ b/fs/ntfs/super.c
    @@ -737,7 +737,7 @@ static struct buffer_head *read_ntfs_boot_sector(struct super_block *sb,
    "boot sector from backup copy.");
    memcpy(bh_primary->b_data, bh_backup->b_data,
    NTFS_BLOCK_SIZE);
    - mark_buffer_dirty(bh_primary);
    + mark_buffer_dirty(NULL, bh_primary);
    sync_dirty_buffer(bh_primary);
    if (buffer_uptodate(bh_primary)) {
    brelse(bh_backup);
    diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
    index 9a876bb07cac..7ab61d67e89e 100644
    --- a/fs/ocfs2/alloc.c
    +++ b/fs/ocfs2/alloc.c
    @@ -6815,7 +6815,7 @@ static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
    static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh)
    {
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    return 0;
    }

    diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
    index 515e0a00839b..64002c13bdd1 100644
    --- a/fs/ocfs2/aops.c
    +++ b/fs/ocfs2/aops.c
    @@ -701,7 +701,7 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,

    zero_user(page, block_start, bh->b_size);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);

    next_bh:
    block_start = block_end;
    @@ -930,7 +930,7 @@ static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to
    }

    clear_buffer_new(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    }

    diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
    index d51b80edd972..7a4e5e9db53d 100644
    --- a/fs/ocfs2/inode.c
    +++ b/fs/ocfs2/inode.c
    @@ -1568,7 +1568,7 @@ static int ocfs2_filecheck_repair_inode_block(struct super_block *sb,

    if (changed || ocfs2_validate_meta_ecc(sb, bh->b_data, &di->i_check)) {
    ocfs2_compute_meta_ecc(sb, bh->b_data, &di->i_check);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    mlog(ML_ERROR,
    "Filecheck: reset dinode #%llu: compute meta ecc\n",
    (unsigned long long)bh->b_blocknr);
    diff --git a/fs/omfs/bitmap.c b/fs/omfs/bitmap.c
    index 7147ba6a6afc..0a4a756e2865 100644
    --- a/fs/omfs/bitmap.c
    +++ b/fs/omfs/bitmap.c
    @@ -63,7 +63,7 @@ static int set_run(struct super_block *sb, int map,
    bit = 0;
    map++;

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    bh = sb_bread(sb,
    clus_to_blk(sbi, sbi->s_bitmap_ino) + map);
    @@ -78,7 +78,7 @@ static int set_run(struct super_block *sb, int map,
    clear_bit(bit, (unsigned long *)bh->b_data);
    }
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    err = 0;
    out:
    @@ -111,7 +111,7 @@ int omfs_allocate_block(struct super_block *sb, u64 block)
    goto out;

    set_bit(bit, (unsigned long *)bh->b_data);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    }
    ret = 1;
    diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c
    index b7146526afff..a5c6f506a0a0 100644
    --- a/fs/omfs/dir.c
    +++ b/fs/omfs/dir.c
    @@ -103,7 +103,7 @@ int omfs_make_empty(struct inode *inode, struct super_block *sb)
    oi->i_head.h_self = cpu_to_be64(inode->i_ino);
    oi->i_sibling = ~cpu_to_be64(0ULL);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);
    return 0;
    }
    @@ -127,7 +127,7 @@ static int omfs_add_link(struct dentry *dentry, struct inode *inode)
    entry = (__be64 *) &bh->b_data[ofs];
    block = be64_to_cpu(*entry);
    *entry = cpu_to_be64(inode->i_ino);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);

    /* now set the sibling and parent pointers on the new inode */
    @@ -140,7 +140,7 @@ static int omfs_add_link(struct dentry *dentry, struct inode *inode)
    memset(oi->i_name + namelen, 0, OMFS_NAMELEN - namelen);
    oi->i_sibling = cpu_to_be64(block);
    oi->i_parent = cpu_to_be64(dir->i_ino);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);

    dir->i_ctime = current_time(dir);
    @@ -196,7 +196,7 @@ static int omfs_delete_entry(struct dentry *dentry)
    }

    *entry = next;
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);

    if (prev != ~0) {
    dirty = omfs_iget(dir->i_sb, prev);
    diff --git a/fs/omfs/file.c b/fs/omfs/file.c
    index ac27a4b2186a..4dbfb35b1a40 100644
    --- a/fs/omfs/file.c
    +++ b/fs/omfs/file.c
    @@ -80,7 +80,7 @@ int omfs_shrink_inode(struct inode *inode)
    entry++;
    }
    omfs_make_empty_table(bh, (char *) oe - bh->b_data);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    brelse(bh);

    if (last != inode->i_ino)
    @@ -272,7 +272,7 @@ static int omfs_get_block(struct inode *inode, sector_t block,
    if (create) {
    ret = omfs_grow_extent(inode, oe, &new_block);
    if (ret == 0) {
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    mark_inode_dirty(inode);
    map_bh(bh_result, inode->i_sb,
    clus_to_blk(sbi, new_block));
    diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c
    index ee14af9e26f2..4213ef2cd088 100644
    --- a/fs/omfs/inode.c
    +++ b/fs/omfs/inode.c
    @@ -140,7 +140,7 @@ static int __omfs_write_inode(struct inode *inode, int wait)

    omfs_update_checksums(oi);

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (wait) {
    sync_dirty_buffer(bh);
    if (buffer_req(bh) && !buffer_uptodate(bh))
    @@ -154,7 +154,7 @@ static int __omfs_write_inode(struct inode *inode, int wait)
    goto out_brelse;

    memcpy(bh2->b_data, bh->b_data, bh->b_size);
    - mark_buffer_dirty(bh2);
    + mark_buffer_dirty(NULL, bh2);
    if (wait) {
    sync_dirty_buffer(bh2);
    if (buffer_req(bh2) && !buffer_uptodate(bh2))
    diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
    index 843aadcc123c..804b13c45f53 100644
    --- a/fs/reiserfs/file.c
    +++ b/fs/reiserfs/file.c
    @@ -214,7 +214,7 @@ int reiserfs_commit_page(struct inode *inode, struct page *page,
    reiserfs_prepare_for_journal(s, bh, 1);
    journal_mark_dirty(&th, bh);
    } else if (!buffer_dirty(bh)) {
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    /*
    * do data=ordered on any page past the end
    * of file and any buffer marked BH_New.
    diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
    index bc64ca190848..e438aed1b622 100644
    --- a/fs/reiserfs/inode.c
    +++ b/fs/reiserfs/inode.c
    @@ -999,7 +999,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
    * VM (which was also the case with
    * __mark_buffer_dirty())
    */
    - mark_buffer_dirty(unbh);
    + mark_buffer_dirty(NULL, unbh);
    }
    } else {
    /*
    @@ -2336,7 +2336,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
    length = blocksize - length;
    zero_user(page, offset, length);
    if (buffer_mapped(bh) && bh->b_blocknr != 0) {
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    }
    unlock_page(page);
    diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
    index ee74c6cddbbe..68cbaba7b2e6 100644
    --- a/fs/reiserfs/journal.c
    +++ b/fs/reiserfs/journal.c
    @@ -1111,7 +1111,7 @@ static int flush_commit_list(struct super_block *s,
    if (likely(!retval && !reiserfs_is_journal_aborted (journal))) {
    if (buffer_dirty(jl->j_commit_bh))
    BUG();
    - mark_buffer_dirty(jl->j_commit_bh) ;
    + mark_buffer_dirty(NULL, jl->j_commit_bh);
    depth = reiserfs_write_unlock_nested(s);
    if (reiserfs_barrier_flush(s))
    __sync_dirty_buffer(jl->j_commit_bh,
    @@ -1712,7 +1712,7 @@ static int dirty_one_transaction(struct super_block *s,
    set_buffer_journal_restore_dirty(cn->bh);
    } else {
    set_buffer_journal_test(cn->bh);
    - mark_buffer_dirty(cn->bh);
    + mark_buffer_dirty(NULL, cn->bh);
    }
    }
    cn = cn->next;
    @@ -3935,7 +3935,7 @@ void reiserfs_restore_prepared_buffer(struct super_block *sb,
    bh->b_blocknr);
    if (cn && can_dirty(cn)) {
    set_buffer_journal_test(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    reiserfs_write_unlock(sb);
    }
    @@ -4183,7 +4183,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, int flags)
    * dirty now too. Don't mark the commit block dirty until all the
    * others are on disk
    */
    - mark_buffer_dirty(d_bh);
    + mark_buffer_dirty(NULL, d_bh);

    /*
    * first data block is j_start + 1, so add one to
    @@ -4212,7 +4212,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, int flags)
    addr + offset_in_page(cn->bh->b_data),
    cn->bh->b_size);
    kunmap(page);
    - mark_buffer_dirty(tmp_bh);
    + mark_buffer_dirty(NULL, tmp_bh);
    jindex++;
    set_buffer_journal_dirty(cn->bh);
    clear_buffer_journaled(cn->bh);
    diff --git a/fs/reiserfs/resize.c b/fs/reiserfs/resize.c
    index 2196afda6e28..f80e8a7e7ac4 100644
    --- a/fs/reiserfs/resize.c
    +++ b/fs/reiserfs/resize.c
    @@ -156,7 +156,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
    reiserfs_cache_bitmap_metadata(s, bh, bitmap + i);

    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    depth = reiserfs_write_unlock_nested(s);
    sync_dirty_buffer(bh);
    reiserfs_write_lock_nested(s, depth);
    diff --git a/fs/sysv/balloc.c b/fs/sysv/balloc.c
    index 0e69dbdf7277..bfee0260f869 100644
    --- a/fs/sysv/balloc.c
    +++ b/fs/sysv/balloc.c
    @@ -84,7 +84,7 @@ void sysv_free_block(struct super_block * sb, sysv_zone_t nr)
    memset(bh->b_data, 0, sb->s_blocksize);
    *(__fs16*)bh->b_data = cpu_to_fs16(sbi, count);
    memcpy(get_chunk(sb,bh), blocks, count * sizeof(sysv_zone_t));
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    set_buffer_uptodate(bh);
    brelse(bh);
    count = 0;
    diff --git a/fs/sysv/ialloc.c b/fs/sysv/ialloc.c
    index 6c9801986af6..c3f09d9761a8 100644
    --- a/fs/sysv/ialloc.c
    +++ b/fs/sysv/ialloc.c
    @@ -128,7 +128,7 @@ void sysv_free_inode(struct inode * inode)
    fs16_add(sbi, sbi->s_sb_total_free_inodes, 1);
    dirty_sb(sb);
    memset(raw_inode, 0, sizeof(struct sysv_inode));
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    mutex_unlock(&sbi->s_lock);
    brelse(bh);
    }
    diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
    index bec9f79adb25..d7494995157a 100644
    --- a/fs/sysv/inode.c
    +++ b/fs/sysv/inode.c
    @@ -49,7 +49,7 @@ static int sysv_sync_fs(struct super_block *sb, int wait)
    if (*sbi->s_sb_state == cpu_to_fs32(sbi, 0x7c269d38 - old_time))
    *sbi->s_sb_state = cpu_to_fs32(sbi, 0x7c269d38 - time);
    *sbi->s_sb_time = cpu_to_fs32(sbi, time);
    - mark_buffer_dirty(sbi->s_bh2);
    + mark_buffer_dirty(NULL, sbi->s_bh2);
    }

    mutex_unlock(&sbi->s_lock);
    @@ -73,9 +73,9 @@ static void sysv_put_super(struct super_block *sb)

    if (!sb_rdonly(sb)) {
    /* XXX ext2 also updates the state here */
    - mark_buffer_dirty(sbi->s_bh1);
    + mark_buffer_dirty(NULL, sbi->s_bh1);
    if (sbi->s_bh1 != sbi->s_bh2)
    - mark_buffer_dirty(sbi->s_bh2);
    + mark_buffer_dirty(NULL, sbi->s_bh2);
    }

    brelse(sbi->s_bh1);
    @@ -265,7 +265,7 @@ static int __sysv_write_inode(struct inode *inode, int wait)
    for (block = 0; block < 10+1+1+1; block++)
    write3byte(sbi, (u8 *)&si->i_data[block],
    &raw_inode->i_data[3*block]);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (wait) {
    sync_dirty_buffer(bh);
    if (buffer_req(bh) && !buffer_uptodate(bh)) {
    diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
    index e913698779c0..3a3b5c16095a 100644
    --- a/fs/sysv/sysv.h
    +++ b/fs/sysv/sysv.h
    @@ -116,9 +116,9 @@ static inline void dirty_sb(struct super_block *sb)
    {
    struct sysv_sb_info *sbi = SYSV_SB(sb);

    - mark_buffer_dirty(sbi->s_bh1);
    + mark_buffer_dirty(NULL, sbi->s_bh1);
    if (sbi->s_bh1 != sbi->s_bh2)
    - mark_buffer_dirty(sbi->s_bh2);
    + mark_buffer_dirty(NULL, sbi->s_bh2);
    }


    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index 1b961b1d9699..9fa31c59835f 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -157,7 +157,7 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
    }
    }
    udf_add_free_space(sb, sbi->s_partition, count);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (overflow) {
    block += count;
    count = overflow;
    @@ -209,7 +209,7 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    bit++;
    block++;
    }
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    } while (block_count > 0);

    out:
    @@ -332,7 +332,7 @@ static udf_pblk_t udf_bitmap_new_block(struct super_block *sb,
    goto repeat;
    }

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);

    udf_add_free_space(sb, partition, -1);
    mutex_unlock(&sbi->s_alloc_mutex);
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 56cf8e70d298..6194f4c4bf12 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1817,7 +1817,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    unlock_buffer(bh);

    /* write the data blocks */
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (do_sync) {
    sync_dirty_buffer(bh);
    if (buffer_write_io_error(bh)) {
    diff --git a/fs/udf/partition.c b/fs/udf/partition.c
    index 090baff83990..0e4e05a41bee 100644
    --- a/fs/udf/partition.c
    +++ b/fs/udf/partition.c
    @@ -204,7 +204,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    reallocationTableLen *
    sizeof(struct sparingEntry);
    udf_update_tag((char *)st, len);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    *new_block = le32_to_cpu(
    entry->mappedLocation) +
    @@ -250,7 +250,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    sizeof(struct sparingTable) +
    reallocationTableLen *
    sizeof(struct sparingEntry));
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    }
    *new_block =
    le32_to_cpu(
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index f73239a9a97d..79c2bfd32986 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -2001,7 +2001,7 @@ static void udf_open_lvid(struct super_block *sb)
    le16_to_cpu(lvid->descTag.descCRCLength)));

    lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sbi->s_lvid_dirty = 0;
    mutex_unlock(&sbi->s_alloc_mutex);
    /* Make opening of filesystem visible on the media immediately */
    @@ -2047,7 +2047,7 @@ static void udf_close_lvid(struct super_block *sb)
    * the buffer as !uptodate
    */
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    sbi->s_lvid_dirty = 0;
    mutex_unlock(&sbi->s_alloc_mutex);
    /* Make closing of filesystem visible on the media immediately */
    @@ -2076,7 +2076,7 @@ u64 lvid_get_unique_id(struct super_block *sb)
    uniqueID += 16;
    lvhd->uniqueID = cpu_to_le64(uniqueID);
    mutex_unlock(&sbi->s_alloc_mutex);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);

    return ret;
    }
    @@ -2351,7 +2351,7 @@ static int udf_sync_fs(struct super_block *sb, int wait)
    * Blockdevice will be synced later so we don't have to submit
    * the buffer for IO
    */
    - mark_buffer_dirty(sbi->s_lvid_bh);
    + mark_buffer_dirty(NULL, sbi->s_lvid_bh);
    sbi->s_lvid_dirty = 0;
    }
    mutex_unlock(&sbi->s_alloc_mutex);
    diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
    index e727ee07dbe4..3648422218dc 100644
    --- a/fs/ufs/balloc.c
    +++ b/fs/ufs/balloc.c
    @@ -311,7 +311,7 @@ static void ufs_change_blocknr(struct inode *inode, sector_t beg,

    bh->b_blocknr = newb + pos;
    clean_bdev_bh_alias(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    ++j;
    bh = bh->b_this_page;
    } while (bh != head);
    @@ -333,7 +333,7 @@ static void ufs_clear_frags(struct inode *inode, sector_t beg, unsigned int n,
    lock_buffer(bh);
    memset(bh->b_data, 0, inode->i_sb->s_blocksize);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    unlock_buffer(bh);
    if (IS_SYNC(inode) || sync)
    sync_dirty_buffer(bh);
    diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
    index e1ef0f0a1353..3a6dd9eea6a9 100644
    --- a/fs/ufs/ialloc.c
    +++ b/fs/ufs/ialloc.c
    @@ -144,7 +144,7 @@ static void ufs2_init_inodes_chunk(struct super_block *sb,
    lock_buffer(bh);
    memset(bh->b_data, 0, sb->s_blocksize);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    unlock_buffer(bh);
    if (sb->s_flags & SB_SYNCHRONOUS)
    sync_dirty_buffer(bh);
    @@ -328,7 +328,7 @@ struct inode *ufs_new_inode(struct inode *dir, umode_t mode)
    ktime_get_real_ts64(&ts);
    ufs2_inode->ui_birthtime = cpu_to_fs64(sb, ts.tv_sec);
    ufs2_inode->ui_birthnsec = cpu_to_fs32(sb, ts.tv_nsec);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    unlock_buffer(bh);
    if (sb->s_flags & SB_SYNCHRONOUS)
    sync_dirty_buffer(bh);
    diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
    index fcaa60bfad49..c96630059d9e 100644
    --- a/fs/ufs/inode.c
    +++ b/fs/ufs/inode.c
    @@ -375,7 +375,7 @@ ufs_inode_getblock(struct inode *inode, u64 ind_block,
    if (new)
    *new = 1;

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (IS_SYNC(inode))
    sync_dirty_buffer(bh);
    inode->i_ctime = current_time(inode);
    @@ -829,7 +829,7 @@ static int ufs_update_inode(struct inode * inode, int do_sync)
    ufs1_update_inode(inode, ufs_inode + ufs_inotofsbo(inode->i_ino));
    }

    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    if (do_sync)
    sync_dirty_buffer(bh);
    brelse (bh);
    @@ -1095,7 +1095,7 @@ static int ufs_alloc_lastblock(struct inode *inode, loff_t size)
    * if it maped to hole, it already contains zeroes
    */
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    set_page_dirty(lastpage);
    }

    @@ -1107,7 +1107,7 @@ static int ufs_alloc_lastblock(struct inode *inode, loff_t size)
    lock_buffer(bh);
    memset(bh->b_data, 0, sb->s_blocksize);
    set_buffer_uptodate(bh);
    - mark_buffer_dirty(bh);
    + mark_buffer_dirty(NULL, bh);
    unlock_buffer(bh);
    sync_dirty_buffer(bh);
    brelse(bh);
    diff --git a/fs/ufs/util.c b/fs/ufs/util.c
    index e8b3d6b70ca9..131f6ad2311f 100644
    --- a/fs/ufs/util.c
    +++ b/fs/ufs/util.c
    @@ -96,7 +96,7 @@ void ubh_mark_buffer_dirty (struct ufs_buffer_head * ubh)
    if (!ubh)
    return;
    for ( i = 0; i < ubh->count; i++ )
    - mark_buffer_dirty (ubh->bh[i]);
    + mark_buffer_dirty(NULL, ubh->bh[i]);
    }

    void ubh_mark_buffer_uptodate (struct ufs_buffer_head * ubh, int flag)
    diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
    index 6c355f43b46b..5e77654f8e81 100644
    --- a/include/linux/buffer_head.h
    +++ b/include/linux/buffer_head.h
    @@ -175,7 +175,7 @@ void buffer_check_dirty_writeback(struct page *page,
    * Declarations
    */

    -void mark_buffer_dirty(struct buffer_head *bh);
    +void mark_buffer_dirty(struct address_space *, struct buffer_head *);
    void mark_buffer_write_io_error(struct address_space *mapping,
    struct page *page, struct buffer_head *bh);
    void touch_buffer(struct buffer_head *bh);
    --
    2.14.3
    \
     
     \ /
      Last update: 2018-04-04 21:23    [W:5.557 / U:0.260 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site