fs: export inode_to_bdi and use it in favor of mapping->backing_dev_info

Now that we got rid of the bdi abuse on character devices we can always use
sb->s_bdi to get at the backing_dev_info for a file, except for the block
device special case.  Export inode_to_bdi and replace uses of
mapping->backing_dev_info with it to prepare for the removal of
mapping->backing_dev_info.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Jan Kara <jack@suse.cz>
Signed-off-by: Jens Axboe <axboe@fb.com>

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index e4090259569bccfdb3ec788481814e769ff84615..835c04a874fd8bc65f8f1c3c3b897304d9860f59 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1746,7 +1746,7 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
 
        mutex_lock(&inode->i_mutex);
 
-       current->backing_dev_info = inode->i_mapping->backing_dev_info;
+       current->backing_dev_info = inode_to_bdi(inode);
        err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
        if (err) {
                mutex_unlock(&inode->i_mutex);

diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index ce74b394b49dd4affb91d2b23be4eb47915e9e75..905986dd4c3c9dabaf5bf3ea5e584e0ecc719a5b 100644 (file)
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -945,7 +945,7 @@ static ssize_t ceph_write_iter(struct kiocb *iocb, struct iov_iter *from)
        mutex_lock(&inode->i_mutex);
 
        /* We can write back this queue in page reclaim */
-       current->backing_dev_info = file->f_mapping->backing_dev_info;
+       current->backing_dev_info = inode_to_bdi(inode);
 
        err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
        if (err)

diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index 7d66fb0e4cca87e2ae9be18fb5f7862d1df1a2af..6c14bb8322fabefa14cf6f59e51e179f66a8c71d 100644 (file)
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -170,7 +170,7 @@ static void ext2_preread_inode(struct inode *inode)
        struct ext2_group_desc * gdp;
        struct backing_dev_info *bdi;
 
-       bdi = inode->i_mapping->backing_dev_info;
+       bdi = inode_to_bdi(inode);
        if (bdi_read_congested(bdi))
                return;
        if (bdi_write_congested(bdi))

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 74c5f53595fbd1d236026f0d78b3071982f89075..ad88e601a6cde34740bf519a3307432315f80423 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -334,7 +334,7 @@ static void save_error_info(struct super_block *sb, const char *func,
 static int block_device_ejected(struct super_block *sb)
 {
        struct inode *bd_inode = sb->s_bdev->bd_inode;
-       struct backing_dev_info *bdi = bd_inode->i_mapping->backing_dev_info;
+       struct backing_dev_info *bdi = inode_to_bdi(bd_inode);
 
        return bdi->dev == NULL;
 }

diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index e8116a44cc29e280fb438574849298649891d7a6..a20b1145f4d57783a08c1a8524a6e6a66c6162fb 100644 (file)
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -66,7 +66,7 @@ int writeback_in_progress(struct backing_dev_info *bdi)
 }
 EXPORT_SYMBOL(writeback_in_progress);
 
-static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
+struct backing_dev_info *inode_to_bdi(struct inode *inode)
 {
        struct super_block *sb = inode->i_sb;
 #ifdef CONFIG_BLOCK
@@ -75,6 +75,7 @@ static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
 #endif
        return sb->s_bdi;
 }
+EXPORT_SYMBOL_GPL(inode_to_bdi);
 
 static inline struct inode *wb_inode(struct list_head *head)
 {

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 760b2c55219741a48e0e444d482cb9e08535f938..19d80b82d344890b67644e4b716daad9e12377e1 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1159,7 +1159,7 @@ static ssize_t fuse_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        mutex_lock(&inode->i_mutex);
 
        /* We can write back this queue in page reclaim */
-       current->backing_dev_info = mapping->backing_dev_info;
+       current->backing_dev_info = inode_to_bdi(inode);
 
        err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
        if (err)
@@ -1464,7 +1464,7 @@ static void fuse_writepage_finish(struct fuse_conn *fc, struct fuse_req *req)
 {
        struct inode *inode = req->inode;
        struct fuse_inode *fi = get_fuse_inode(inode);
-       struct backing_dev_info *bdi = inode->i_mapping->backing_dev_info;
+       struct backing_dev_info *bdi = inode_to_bdi(inode);
        int i;
 
        list_del(&req->writepages_entry);
@@ -1658,7 +1658,7 @@ static int fuse_writepage_locked(struct page *page)
        req->end = fuse_writepage_end;
        req->inode = inode;
 
-       inc_bdi_stat(mapping->backing_dev_info, BDI_WRITEBACK);
+       inc_bdi_stat(inode_to_bdi(inode), BDI_WRITEBACK);
        inc_zone_page_state(tmp_page, NR_WRITEBACK_TEMP);
 
        spin_lock(&fc->lock);
@@ -1768,7 +1768,7 @@ static bool fuse_writepage_in_flight(struct fuse_req *new_req,
 
        if (old_req->num_pages == 1 && (old_req->state == FUSE_REQ_INIT ||
                                        old_req->state == FUSE_REQ_PENDING)) {
-               struct backing_dev_info *bdi = page->mapping->backing_dev_info;
+               struct backing_dev_info *bdi = inode_to_bdi(page->mapping->host);
 
                copy_highpage(old_req->pages[0], page);
                spin_unlock(&fc->lock);
@@ -1872,7 +1872,7 @@ static int fuse_writepages_fill(struct page *page,
        req->page_descs[req->num_pages].offset = 0;
        req->page_descs[req->num_pages].length = PAGE_SIZE;
 
-       inc_bdi_stat(page->mapping->backing_dev_info, BDI_WRITEBACK);
+       inc_bdi_stat(inode_to_bdi(inode), BDI_WRITEBACK);
        inc_zone_page_state(tmp_page, NR_WRITEBACK_TEMP);
 
        err = 0;

diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index 805b37fed6383fc71abcb573de809ee8f3e41c53..4ad4f94edebe25cc8afa3fa7c4ec35913cb00642 100644 (file)
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
@@ -289,7 +289,7 @@ continue_unlock:
                if (!clear_page_dirty_for_io(page))
                        goto continue_unlock;
 
-               trace_wbc_writepage(wbc, mapping->backing_dev_info);
+               trace_wbc_writepage(wbc, inode_to_bdi(inode));
 
                ret = __gfs2_jdata_writepage(page, wbc);
                if (unlikely(ret)) {

diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index 5b327f837de7187a1ac6fd1b35e01b5be058f211..1666382b198db6463a75446578a7ee358ef66933 100644 (file)
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -743,7 +743,7 @@ static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc)
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_sbd *sdp = GFS2_SB(inode);
        struct address_space *metamapping = gfs2_glock2aspace(ip->i_gl);
-       struct backing_dev_info *bdi = metamapping->backing_dev_info;
+       struct backing_dev_info *bdi = inode_to_bdi(metamapping->host);
        int ret = 0;
 
        if (wbc->sync_mode == WB_SYNC_ALL)

diff --git a/fs/nfs/filelayout/filelayout.c b/fs/nfs/filelayout/filelayout.c
index 7afb52f6a25a1b412bffac5829705bd8137eafbc..51aa889611cf290832745fa0094e2cab6c60423a 100644 (file)
--- a/fs/nfs/filelayout/filelayout.c
+++ b/fs/nfs/filelayout/filelayout.c
@@ -1081,7 +1081,7 @@ mds_commit:
        spin_unlock(cinfo->lock);
        if (!cinfo->dreq) {
                inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
-               inc_bdi_stat(page_file_mapping(req->wb_page)->backing_dev_info,
+               inc_bdi_stat(inode_to_bdi(page_file_mapping(req->wb_page)->host),
                             BDI_RECLAIMABLE);
                __mark_inode_dirty(req->wb_context->dentry->d_inode,
                                   I_DIRTY_DATASYNC);

diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index af3af685a9e3791a361413976939bd8bc9668f05..298abcc5281b66c9a2266cf2ffd4228bd791f3cc 100644 (file)
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -786,7 +786,7 @@ nfs_request_add_commit_list(struct nfs_page *req, struct list_head *dst,
        spin_unlock(cinfo->lock);
        if (!cinfo->dreq) {
                inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
-               inc_bdi_stat(page_file_mapping(req->wb_page)->backing_dev_info,
+               inc_bdi_stat(inode_to_bdi(page_file_mapping(req->wb_page)->host),
                             BDI_RECLAIMABLE);
                __mark_inode_dirty(req->wb_context->dentry->d_inode,
                                   I_DIRTY_DATASYNC);
@@ -853,7 +853,7 @@ static void
 nfs_clear_page_commit(struct page *page)
 {
        dec_zone_page_state(page, NR_UNSTABLE_NFS);
-       dec_bdi_stat(page_file_mapping(page)->backing_dev_info, BDI_RECLAIMABLE);
+       dec_bdi_stat(inode_to_bdi(page_file_mapping(page)->host), BDI_RECLAIMABLE);
 }
 
 /* Called holding inode (/cinfo) lock */
@@ -1564,7 +1564,7 @@ void nfs_retry_commit(struct list_head *page_list,
                nfs_mark_request_commit(req, lseg, cinfo);
                if (!cinfo->dreq) {
                        dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
-                       dec_bdi_stat(page_file_mapping(req->wb_page)->backing_dev_info,
+                       dec_bdi_stat(inode_to_bdi(page_file_mapping(req->wb_page)->host),
                                     BDI_RECLAIMABLE);
                }
                nfs_unlock_and_release_request(req);

diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 643faa44f22b0b0a97b493cbbce0db6f745670d2..1da9b2d184dc4e32d9ac9a95eb0ee2553c5a1e46 100644 (file)
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -19,6 +19,7 @@
  * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <linux/backing-dev.h>
 #include <linux/buffer_head.h>
 #include <linux/gfp.h>
 #include <linux/pagemap.h>
@@ -2091,7 +2092,7 @@ static ssize_t ntfs_file_aio_write_nolock(struct kiocb *iocb,
        count = iov_length(iov, nr_segs);
        pos = *ppos;
        /* We can write back this queue in page reclaim. */
-       current->backing_dev_info = mapping->backing_dev_info;
+       current->backing_dev_info = inode_to_bdi(inode);
        written = 0;
        err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
        if (err)

diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 3950693dd0f6d9026587ac71e85037c555790f77..abe7d98d6178683613194bd6a875f732fa56b4b8 100644 (file)
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -2363,7 +2363,7 @@ relock:
                        goto out_dio;
                }
        } else {
-               current->backing_dev_info = file->f_mapping->backing_dev_info;
+               current->backing_dev_info = inode_to_bdi(inode);
                written = generic_perform_write(file, from, *ppos);
                if (likely(written >= 0))
                        iocb->ki_pos = *ppos + written;

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 13e974e6a889fa0270b5679be2b1db5baca81bea..5684ac3e7d18311c7880247a08359e6029d1374b 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -699,7 +699,7 @@ xfs_file_buffered_aio_write(
 
        iov_iter_truncate(from, count);
        /* We can write back this queue in page reclaim */
-       current->backing_dev_info = mapping->backing_dev_info;
+       current->backing_dev_info = inode_to_bdi(inode);
 
 write_retry:
        trace_xfs_file_buffered_write(ip, count, iocb->ki_pos, 0);

diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 478f95d92d73be43967aeef9d8f3c859016bf972..ed59dee03a7133a1816851fdd1664520d5a6bb52 100644 (file)
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -106,6 +106,8 @@ struct backing_dev_info {
 #endif
 };
 
+struct backing_dev_info *inode_to_bdi(struct inode *inode);
+
 int __must_check bdi_init(struct backing_dev_info *bdi);
 void bdi_destroy(struct backing_dev_info *bdi);
 
@@ -303,12 +305,12 @@ static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi)
 
 static inline bool mapping_cap_writeback_dirty(struct address_space *mapping)
 {
-       return bdi_cap_writeback_dirty(mapping->backing_dev_info);
+       return bdi_cap_writeback_dirty(inode_to_bdi(mapping->host));
 }
 
 static inline bool mapping_cap_account_dirty(struct address_space *mapping)
 {
-       return bdi_cap_account_dirty(mapping->backing_dev_info);
+       return bdi_cap_account_dirty(inode_to_bdi(mapping->host));
 }
 
 static inline int bdi_sched_wait(void *word)

diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
index cee02d65ab3f1707080902de3375d828f1e0a526..74f5207bd09070b8d493d9c975e753ac0c9817d4 100644 (file)
--- a/include/trace/events/writeback.h
+++ b/include/trace/events/writeback.h
@@ -47,7 +47,7 @@ TRACE_EVENT(writeback_dirty_page,
 
        TP_fast_assign(
                strncpy(__entry->name,
-                       mapping ? dev_name(mapping->backing_dev_info->dev) : "(unknown)", 32);
+                       mapping ? dev_name(inode_to_bdi(mapping->host)->dev) : "(unknown)", 32);
                __entry->ino = mapping ? mapping->host->i_ino : 0;
                __entry->index = page->index;
        ),
@@ -72,7 +72,7 @@ DECLARE_EVENT_CLASS(writeback_dirty_inode_template,
        ),
 
        TP_fast_assign(
-               struct backing_dev_info *bdi = inode->i_mapping->backing_dev_info;
+               struct backing_dev_info *bdi = inode_to_bdi(inode);
 
                /* may be called for files on pseudo FSes w/ unregistered bdi */
                strncpy(__entry->name,
@@ -116,7 +116,7 @@ DECLARE_EVENT_CLASS(writeback_write_inode_template,
 
        TP_fast_assign(
                strncpy(__entry->name,
-                       dev_name(inode->i_mapping->backing_dev_info->dev), 32);
+                       dev_name(inode_to_bdi(inode)->dev), 32);
                __entry->ino            = inode->i_ino;
                __entry->sync_mode      = wbc->sync_mode;
        ),

diff --git a/mm/fadvise.c b/mm/fadvise.c
index 2ad7adf4f0a459bcd3be1860d30a6382c8083a40..fac23ecf8d7229eb0de2a2292f44e4cfcbe88c6f 100644 (file)
--- a/mm/fadvise.c
+++ b/mm/fadvise.c
@@ -73,7 +73,7 @@ SYSCALL_DEFINE4(fadvise64_64, int, fd, loff_t, offset, loff_t, len, int, advice)
        else
                endbyte--;              /* inclusive */
 
-       bdi = mapping->backing_dev_info;
+       bdi = inode_to_bdi(mapping->host);
 
        switch (advice) {
        case POSIX_FADV_NORMAL:
@@ -113,7 +113,7 @@ SYSCALL_DEFINE4(fadvise64_64, int, fd, loff_t, offset, loff_t, len, int, advice)
        case POSIX_FADV_NOREUSE:
                break;
        case POSIX_FADV_DONTNEED:
-               if (!bdi_write_congested(mapping->backing_dev_info))
+               if (!bdi_write_congested(bdi))
                        __filemap_fdatawrite_range(mapping, offset, endbyte,
                                                   WB_SYNC_NONE);
 

diff --git a/mm/filemap.c b/mm/filemap.c
index 673e4581a2e541b44b02cd8ef201772dad5311a1..5d7c23c26f81bc978124f3a7c326e12a066c3f26 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -211,7 +211,7 @@ void __delete_from_page_cache(struct page *page, void *shadow)
         */
        if (PageDirty(page) && mapping_cap_account_dirty(mapping)) {
                dec_zone_page_state(page, NR_FILE_DIRTY);
-               dec_bdi_stat(mapping->backing_dev_info, BDI_RECLAIMABLE);
+               dec_bdi_stat(inode_to_bdi(mapping->host), BDI_RECLAIMABLE);
        }
 }
 
@@ -2565,7 +2565,7 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        size_t          count = iov_iter_count(from);
 
        /* We can write back this queue in page reclaim */
-       current->backing_dev_info = mapping->backing_dev_info;
+       current->backing_dev_info = inode_to_bdi(inode);
        err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
        if (err)
                goto out;

diff --git a/mm/filemap_xip.c b/mm/filemap_xip.c
index 0d105aeff82fe258f06eaacbb8205ade160436cb..26897fbfbe1977940e4e7a219ea32ebaad73f4ee 100644 (file)
--- a/mm/filemap_xip.c
+++ b/mm/filemap_xip.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/fs.h>
+#include <linux/backing-dev.h>
 #include <linux/pagemap.h>
 #include <linux/export.h>
 #include <linux/uio.h>
@@ -410,7 +411,7 @@ xip_file_write(struct file *filp, const char __user *buf, size_t len,
        count = len;
 
        /* We can write back this queue in page reclaim */
-       current->backing_dev_info = mapping->backing_dev_info;
+       current->backing_dev_info = inode_to_bdi(inode);
 
        ret = generic_write_checks(filp, &pos, &count, S_ISBLK(inode->i_mode));
        if (ret)

diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 6f4335238e33311de251a647fe725d06d5897060..d4cbb4bd7d1cf30c859f510dc636ef39d9e8f016 100644 (file)
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -1351,7 +1351,7 @@ static void balance_dirty_pages(struct address_space *mapping,
        unsigned long task_ratelimit;
        unsigned long dirty_ratelimit;
        unsigned long pos_ratio;
-       struct backing_dev_info *bdi = mapping->backing_dev_info;
+       struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
        bool strictlimit = bdi->capabilities & BDI_CAP_STRICTLIMIT;
        unsigned long start_time = jiffies;
 
@@ -1574,7 +1574,7 @@ DEFINE_PER_CPU(int, dirty_throttle_leaks) = 0;
  */
 void balance_dirty_pages_ratelimited(struct address_space *mapping)
 {
-       struct backing_dev_info *bdi = mapping->backing_dev_info;
+       struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
        int ratelimit;
        int *p;
 
@@ -1929,7 +1929,7 @@ continue_unlock:
                        if (!clear_page_dirty_for_io(page))
                                goto continue_unlock;
 
-                       trace_wbc_writepage(wbc, mapping->backing_dev_info);
+                       trace_wbc_writepage(wbc, inode_to_bdi(mapping->host));
                        ret = (*writepage)(page, wbc, data);
                        if (unlikely(ret)) {
                                if (ret == AOP_WRITEPAGE_ACTIVATE) {
@@ -2094,10 +2094,12 @@ void account_page_dirtied(struct page *page, struct address_space *mapping)
        trace_writeback_dirty_page(page, mapping);
 
        if (mapping_cap_account_dirty(mapping)) {
+               struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
+
                __inc_zone_page_state(page, NR_FILE_DIRTY);
                __inc_zone_page_state(page, NR_DIRTIED);
-               __inc_bdi_stat(mapping->backing_dev_info, BDI_RECLAIMABLE);
-               __inc_bdi_stat(mapping->backing_dev_info, BDI_DIRTIED);
+               __inc_bdi_stat(bdi, BDI_RECLAIMABLE);
+               __inc_bdi_stat(bdi, BDI_DIRTIED);
                task_io_account_write(PAGE_CACHE_SIZE);
                current->nr_dirtied++;
                this_cpu_inc(bdp_ratelimits);
@@ -2156,7 +2158,7 @@ void account_page_redirty(struct page *page)
        if (mapping && mapping_cap_account_dirty(mapping)) {
                current->nr_dirtied--;
                dec_zone_page_state(page, NR_DIRTIED);
-               dec_bdi_stat(mapping->backing_dev_info, BDI_DIRTIED);
+               dec_bdi_stat(inode_to_bdi(mapping->host), BDI_DIRTIED);
        }
 }
 EXPORT_SYMBOL(account_page_redirty);
@@ -2295,7 +2297,7 @@ int clear_page_dirty_for_io(struct page *page)
                 */
                if (TestClearPageDirty(page)) {
                        dec_zone_page_state(page, NR_FILE_DIRTY);
-                       dec_bdi_stat(mapping->backing_dev_info,
+                       dec_bdi_stat(inode_to_bdi(mapping->host),
                                        BDI_RECLAIMABLE);
                        return 1;
                }
@@ -2315,7 +2317,7 @@ int test_clear_page_writeback(struct page *page)
 
        memcg = mem_cgroup_begin_page_stat(page, &locked, &memcg_flags);
        if (mapping) {
-               struct backing_dev_info *bdi = mapping->backing_dev_info;
+               struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
                unsigned long flags;
 
                spin_lock_irqsave(&mapping->tree_lock, flags);
@@ -2352,7 +2354,7 @@ int __test_set_page_writeback(struct page *page, bool keep_write)
 
        memcg = mem_cgroup_begin_page_stat(page, &locked, &memcg_flags);
        if (mapping) {
-               struct backing_dev_info *bdi = mapping->backing_dev_info;
+               struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
                unsigned long flags;
 
                spin_lock_irqsave(&mapping->tree_lock, flags);
@@ -2406,12 +2408,7 @@ EXPORT_SYMBOL(mapping_tagged);
  */
 void wait_for_stable_page(struct page *page)
 {
-       struct address_space *mapping = page_mapping(page);
-       struct backing_dev_info *bdi = mapping->backing_dev_info;
-
-       if (!bdi_cap_stable_pages_required(bdi))
-               return;
-
-       wait_on_page_writeback(page);
+       if (bdi_cap_stable_pages_required(inode_to_bdi(page->mapping->host)))
+               wait_on_page_writeback(page);
 }
 EXPORT_SYMBOL_GPL(wait_for_stable_page);

diff --git a/mm/readahead.c b/mm/readahead.c
index 17b9172ec37f1ef05d49b45f244ec23f6d934ed1..935675844b2ee45fb29447c7098be1d4869f2c65 100644 (file)
--- a/mm/readahead.c
+++ b/mm/readahead.c
@@ -27,7 +27,7 @@
 void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping)
 {
-       ra->ra_pages = mapping->backing_dev_info->ra_pages;
+       ra->ra_pages = inode_to_bdi(mapping->host)->ra_pages;
        ra->prev_pos = -1;
 }
 EXPORT_SYMBOL_GPL(file_ra_state_init);
@@ -541,7 +541,7 @@ page_cache_async_readahead(struct address_space *mapping,
        /*
         * Defer asynchronous read-ahead on IO congestion.
         */
-       if (bdi_read_congested(mapping->backing_dev_info))
+       if (bdi_read_congested(inode_to_bdi(mapping->host)))
                return;
 
        /* do read-ahead */

diff --git a/mm/truncate.c b/mm/truncate.c
index f1e4d60523694eb758b93fcd6487866c203956dd..ddec5a5966d74a90c1e88b53d260e119b0a5f097 100644 (file)
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -112,7 +112,7 @@ void cancel_dirty_page(struct page *page, unsigned int account_size)
                struct address_space *mapping = page->mapping;
                if (mapping && mapping_cap_account_dirty(mapping)) {
                        dec_zone_page_state(page, NR_FILE_DIRTY);
-                       dec_bdi_stat(mapping->backing_dev_info,
+                       dec_bdi_stat(inode_to_bdi(mapping->host),
                                        BDI_RECLAIMABLE);
                        if (account_size)
                                task_io_account_cancelled_write(account_size);

diff --git a/mm/vmscan.c b/mm/vmscan.c
index ab2505c3ef5460e23facf80725633e977882ec8b..e00a16393f21e18c3ce156dbdd2777e15ba7e7f8 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -497,7 +497,7 @@ static pageout_t pageout(struct page *page, struct address_space *mapping,
        }
        if (mapping->a_ops->writepage == NULL)
                return PAGE_ACTIVATE;
-       if (!may_write_to_queue(mapping->backing_dev_info, sc))
+       if (!may_write_to_queue(inode_to_bdi(mapping->host), sc))
                return PAGE_KEEP;
 
        if (clear_page_dirty_for_io(page)) {
@@ -876,7 +876,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                 */
                mapping = page_mapping(page);
                if (((dirty || writeback) && mapping &&
-                    bdi_write_congested(mapping->backing_dev_info)) ||
+                    bdi_write_congested(inode_to_bdi(mapping->host))) ||
                    (writeback && PageReclaim(page)))
                        nr_congested++;