f2fs: use f2fs_io_info to clean up messy parameters during IO path

This patch cleans up parameters on IO paths.
The key idea is to use f2fs_io_info adding a parameter, block address, and then
use this structure as parameters.

Reviewed-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 825158e4855af0b640a29d4199eec9b3595b731b..0ac7c39605edcba12da42dbca4aedc05d856a9f7 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -50,6 +50,11 @@ struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
 {
        struct address_space *mapping = META_MAPPING(sbi);
        struct page *page;
+       struct f2fs_io_info fio = {
+               .type = META,
+               .rw = READ_SYNC | REQ_META | REQ_PRIO,
+               .blk_addr = index,
+       };
 repeat:
        page = grab_cache_page(mapping, index);
        if (!page) {
@@ -59,8 +64,7 @@ repeat:
        if (PageUptodate(page))
                goto out;
 
-       if (f2fs_submit_page_bio(sbi, page, index,
-                               READ_SYNC | REQ_META | REQ_PRIO))
+       if (f2fs_submit_page_bio(sbi, page, &fio))
                goto repeat;
 
        lock_page(page);
@@ -112,14 +116,12 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int type
        block_t prev_blk_addr = 0;
        struct page *page;
        block_t blkno = start;
-
        struct f2fs_io_info fio = {
                .type = META,
                .rw = READ_SYNC | REQ_META | REQ_PRIO
        };
 
        for (; nrpages-- > 0; blkno++) {
-               block_t blk_addr;
 
                if (!is_valid_blkaddr(sbi, blkno, type))
                        goto out;
@@ -130,27 +132,27 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int type
                                        NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid)))
                                blkno = 0;
                        /* get nat block addr */
-                       blk_addr = current_nat_addr(sbi,
+                       fio.blk_addr = current_nat_addr(sbi,
                                        blkno * NAT_ENTRY_PER_BLOCK);
                        break;
                case META_SIT:
                        /* get sit block addr */
-                       blk_addr = current_sit_addr(sbi,
+                       fio.blk_addr = current_sit_addr(sbi,
                                        blkno * SIT_ENTRY_PER_BLOCK);
-                       if (blkno != start && prev_blk_addr + 1 != blk_addr)
+                       if (blkno != start && prev_blk_addr + 1 != fio.blk_addr)
                                goto out;
-                       prev_blk_addr = blk_addr;
+                       prev_blk_addr = fio.blk_addr;
                        break;
                case META_SSA:
                case META_CP:
                case META_POR:
-                       blk_addr = blkno;
+                       fio.blk_addr = blkno;
                        break;
                default:
                        BUG();
                }
 
-               page = grab_cache_page(META_MAPPING(sbi), blk_addr);
+               page = grab_cache_page(META_MAPPING(sbi), fio.blk_addr);
                if (!page)
                        continue;
                if (PageUptodate(page)) {
@@ -158,7 +160,7 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int type
                        continue;
                }
 
-               f2fs_submit_page_mbio(sbi, page, blk_addr, &fio);
+               f2fs_submit_page_mbio(sbi, page, &fio);
                f2fs_put_page(page, 0);
        }
 out:

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index caa08e46697af90de1eb9e2e4b5bdc0a28b27285..d86f8b1413f164e31eadd0ffbd8e15f6e77f8f0f 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -132,14 +132,14 @@ void f2fs_submit_merged_bio(struct f2fs_sb_info *sbi,
  * Return unlocked page.
  */
 int f2fs_submit_page_bio(struct f2fs_sb_info *sbi, struct page *page,
-                                       block_t blk_addr, int rw)
+                                       struct f2fs_io_info *fio)
 {
        struct bio *bio;
 
-       trace_f2fs_submit_page_bio(page, blk_addr, rw);
+       trace_f2fs_submit_page_bio(page, fio->blk_addr, fio->rw);
 
        /* Allocate a new bio */
-       bio = __bio_alloc(sbi, blk_addr, 1, is_read_io(rw));
+       bio = __bio_alloc(sbi, fio->blk_addr, 1, is_read_io(fio->rw));
 
        if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
                bio_put(bio);
@@ -147,12 +147,12 @@ int f2fs_submit_page_bio(struct f2fs_sb_info *sbi, struct page *page,
                return -EFAULT;
        }
 
-       submit_bio(rw, bio);
+       submit_bio(fio->rw, bio);
        return 0;
 }
 
 void f2fs_submit_page_mbio(struct f2fs_sb_info *sbi, struct page *page,
-                       block_t blk_addr, struct f2fs_io_info *fio)
+                                       struct f2fs_io_info *fio)
 {
        enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
        struct f2fs_bio_info *io;
@@ -160,21 +160,21 @@ void f2fs_submit_page_mbio(struct f2fs_sb_info *sbi, struct page *page,
 
        io = is_read ? &sbi->read_io : &sbi->write_io[btype];
 
-       verify_block_addr(sbi, blk_addr);
+       verify_block_addr(sbi, fio->blk_addr);
 
        down_write(&io->io_rwsem);
 
        if (!is_read)
                inc_page_count(sbi, F2FS_WRITEBACK);
 
-       if (io->bio && (io->last_block_in_bio != blk_addr - 1 ||
+       if (io->bio && (io->last_block_in_bio != fio->blk_addr - 1 ||
                                                io->fio.rw != fio->rw))
                __submit_merged_bio(io);
 alloc_new:
        if (io->bio == NULL) {
                int bio_blocks = MAX_BIO_BLOCKS(sbi);
 
-               io->bio = __bio_alloc(sbi, blk_addr, bio_blocks, is_read);
+               io->bio = __bio_alloc(sbi, fio->blk_addr, bio_blocks, is_read);
                io->fio = *fio;
        }
 
@@ -184,10 +184,10 @@ alloc_new:
                goto alloc_new;
        }
 
-       io->last_block_in_bio = blk_addr;
+       io->last_block_in_bio = fio->blk_addr;
 
        up_write(&io->io_rwsem);
-       trace_f2fs_submit_page_mbio(page, fio->rw, fio->type, blk_addr);
+       trace_f2fs_submit_page_mbio(page, fio->rw, fio->type, fio->blk_addr);
 }
 
 /*
@@ -376,6 +376,10 @@ struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
        struct dnode_of_data dn;
        struct page *page;
        int err;
+       struct f2fs_io_info fio = {
+               .type = DATA,
+               .rw = sync ? READ_SYNC : READA,
+       };
 
        page = find_get_page(mapping, index);
        if (page && PageUptodate(page))
@@ -404,8 +408,8 @@ struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
                return page;
        }
 
-       err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, dn.data_blkaddr,
-                                       sync ? READ_SYNC : READA);
+       fio.blk_addr = dn.data_blkaddr;
+       err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
        if (err)
                return ERR_PTR(err);
 
@@ -430,7 +434,10 @@ struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
        struct dnode_of_data dn;
        struct page *page;
        int err;
-
+       struct f2fs_io_info fio = {
+               .type = DATA,
+               .rw = READ_SYNC,
+       };
 repeat:
        page = grab_cache_page(mapping, index);
        if (!page)
@@ -464,8 +471,8 @@ repeat:
                return page;
        }
 
-       err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,
-                                       dn.data_blkaddr, READ_SYNC);
+       fio.blk_addr = dn.data_blkaddr;
+       err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
        if (err)
                return ERR_PTR(err);
 
@@ -515,8 +522,12 @@ repeat:
                zero_user_segment(page, 0, PAGE_CACHE_SIZE);
                SetPageUptodate(page);
        } else {
-               err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,
-                                               dn.data_blkaddr, READ_SYNC);
+               struct f2fs_io_info fio = {
+                       .type = DATA,
+                       .rw = READ_SYNC,
+                       .blk_addr = dn.data_blkaddr,
+               };
+               err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
                if (err)
                        goto put_err;
 
@@ -745,7 +756,6 @@ static int f2fs_read_data_pages(struct file *file,
 int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
 {
        struct inode *inode = page->mapping->host;
-       block_t old_blkaddr, new_blkaddr;
        struct dnode_of_data dn;
        int err = 0;
 
@@ -754,10 +764,10 @@ int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
        if (err)
                return err;
 
-       old_blkaddr = dn.data_blkaddr;
+       fio->blk_addr = dn.data_blkaddr;
 
        /* This page is already truncated */
-       if (old_blkaddr == NULL_ADDR)
+       if (fio->blk_addr == NULL_ADDR)
                goto out_writepage;
 
        set_page_writeback(page);
@@ -766,14 +776,14 @@ int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
         * If current allocation needs SSR,
         * it had better in-place writes for updated data.
         */
-       if (unlikely(old_blkaddr != NEW_ADDR &&
+       if (unlikely(fio->blk_addr != NEW_ADDR &&
                        !is_cold_data(page) &&
                        need_inplace_update(inode))) {
-               rewrite_data_page(page, old_blkaddr, fio);
+               rewrite_data_page(page, fio);
                set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
        } else {
-               write_data_page(page, &dn, &new_blkaddr, fio);
-               update_extent_cache(new_blkaddr, &dn);
+               write_data_page(page, &dn, fio);
+               update_extent_cache(fio->blk_addr, &dn);
                set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
        }
 out_writepage:
@@ -1007,8 +1017,12 @@ put_next:
        if (dn.data_blkaddr == NEW_ADDR) {
                zero_user_segment(page, 0, PAGE_CACHE_SIZE);
        } else {
-               err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr,
-                                          READ_SYNC);
+               struct f2fs_io_info fio = {
+                       .type = DATA,
+                       .rw = READ_SYNC,
+                       .blk_addr = dn.data_blkaddr,
+               };
+               err = f2fs_submit_page_bio(sbi, page, &fio);
                if (err)
                        goto fail;
 

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index a8ccbceb869a880b33ed2e1e5ab8eff224873bc5..3f07b504f6d8aa3b553f97ce4650d64ed1e9babc 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -491,6 +491,7 @@ enum page_type {
 struct f2fs_io_info {
        enum page_type type;    /* contains DATA/NODE/META/META_FLUSH */
        int rw;                 /* contains R/RS/W/WS with REQ_META/REQ_PRIO */
+       block_t blk_addr;       /* block address to be written */
 };
 
 #define is_read_io(rw) (((rw) & 1) == READ)
@@ -1414,10 +1415,10 @@ int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *);
 struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
 void write_meta_page(struct f2fs_sb_info *, struct page *);
 void write_node_page(struct f2fs_sb_info *, struct page *,
-               struct f2fs_io_info *, unsigned int, block_t, block_t *);
-void write_data_page(struct page *, struct dnode_of_data *, block_t *,
-                                       struct f2fs_io_info *);
-void rewrite_data_page(struct page *, block_t, struct f2fs_io_info *);
+                               unsigned int, struct f2fs_io_info *);
+void write_data_page(struct page *, struct dnode_of_data *,
+                       struct f2fs_io_info *);
+void rewrite_data_page(struct page *, struct f2fs_io_info *);
 void recover_data_page(struct f2fs_sb_info *, struct page *,
                                struct f2fs_summary *, block_t, block_t);
 void allocate_data_block(struct f2fs_sb_info *, struct page *,
@@ -1464,8 +1465,9 @@ void destroy_checkpoint_caches(void);
  * data.c
  */
 void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int);
-int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *, block_t, int);
-void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *, block_t,
+int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *,
+                                               struct f2fs_io_info *);
+void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *,
                                                struct f2fs_io_info *);
 int reserve_new_block(struct dnode_of_data *);
 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index f2d3c581e7761b9ba7b82db95b755e6ac034fbac..0c3f3f9b9f88b1d40162979729e603b7b8ca7dfb 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -79,7 +79,6 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page)
 int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
 {
        void *src_addr, *dst_addr;
-       block_t new_blk_addr;
        struct f2fs_io_info fio = {
                .type = DATA,
                .rw = WRITE_SYNC | REQ_PRIO,
@@ -115,9 +114,9 @@ no_update:
 
        /* write data page to try to make data consistent */
        set_page_writeback(page);
-
-       write_data_page(page, dn, &new_blk_addr, &fio);
-       update_extent_cache(new_blk_addr, dn);
+       fio.blk_addr = dn->data_blkaddr;
+       write_data_page(page, dn, &fio);
+       update_extent_cache(fio.blk_addr, dn);
        f2fs_wait_on_page_writeback(page, DATA);
        if (dirty)
                inode_dec_dirty_pages(dn->inode);

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index bcfd67c801960c1435753a214525dc68e6abc208..adc35c9783063b63cee497cc600ce5eacb12a0ff 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -977,6 +977,10 @@ static int read_node_page(struct page *page, int rw)
 {
        struct f2fs_sb_info *sbi = F2FS_P_SB(page);
        struct node_info ni;
+       struct f2fs_io_info fio = {
+               .type = NODE,
+               .rw = rw,
+       };
 
        get_node_info(sbi, page->index, &ni);
 
@@ -988,7 +992,8 @@ static int read_node_page(struct page *page, int rw)
        if (PageUptodate(page))
                return LOCKED_PAGE;
 
-       return f2fs_submit_page_bio(sbi, page, ni.blk_addr, rw);
+       fio.blk_addr = ni.blk_addr;
+       return f2fs_submit_page_bio(sbi, page, &fio);
 }
 
 /*
@@ -1269,7 +1274,6 @@ static int f2fs_write_node_page(struct page *page,
 {
        struct f2fs_sb_info *sbi = F2FS_P_SB(page);
        nid_t nid;
-       block_t new_addr;
        struct node_info ni;
        struct f2fs_io_info fio = {
                .type = NODE,
@@ -1304,9 +1308,11 @@ static int f2fs_write_node_page(struct page *page,
        } else {
                down_read(&sbi->node_write);
        }
+
        set_page_writeback(page);
-       write_node_page(sbi, page, &fio, nid, ni.blk_addr, &new_addr);
-       set_node_addr(sbi, &ni, new_addr, is_fsync_dnode(page));
+       fio.blk_addr = ni.blk_addr;
+       write_node_page(sbi, page, nid, &fio);
+       set_node_addr(sbi, &ni, fio.blk_addr, is_fsync_dnode(page));
        dec_page_count(sbi, F2FS_DIRTY_NODES);
        up_read(&sbi->node_write);
        unlock_page(page);

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index c950c9318e8e1ccbfaf86ad5938a0d7e648cda32..c726f86c2ea0b36dc68a1cbe63493e41f0de01c8 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -1182,39 +1182,39 @@ void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
 }
 
 static void do_write_page(struct f2fs_sb_info *sbi, struct page *page,
-                       block_t old_blkaddr, block_t *new_blkaddr,
-                       struct f2fs_summary *sum, struct f2fs_io_info *fio)
+                       struct f2fs_summary *sum,
+                       struct f2fs_io_info *fio)
 {
        int type = __get_segment_type(page, fio->type);
 
-       allocate_data_block(sbi, page, old_blkaddr, new_blkaddr, sum, type);
+       allocate_data_block(sbi, page, fio->blk_addr, &fio->blk_addr, sum, type);
 
        /* writeout dirty page into bdev */
-       f2fs_submit_page_mbio(sbi, page, *new_blkaddr, fio);
+       f2fs_submit_page_mbio(sbi, page, fio);
 }
 
 void write_meta_page(struct f2fs_sb_info *sbi, struct page *page)
 {
        struct f2fs_io_info fio = {
                .type = META,
-               .rw = WRITE_SYNC | REQ_META | REQ_PRIO
+               .rw = WRITE_SYNC | REQ_META | REQ_PRIO,
+               .blk_addr = page->index,
        };
 
        set_page_writeback(page);
-       f2fs_submit_page_mbio(sbi, page, page->index, &fio);
+       f2fs_submit_page_mbio(sbi, page, &fio);
 }
 
 void write_node_page(struct f2fs_sb_info *sbi, struct page *page,
-               struct f2fs_io_info *fio,
-               unsigned int nid, block_t old_blkaddr, block_t *new_blkaddr)
+                       unsigned int nid, struct f2fs_io_info *fio)
 {
        struct f2fs_summary sum;
        set_summary(&sum, nid, 0, 0);
-       do_write_page(sbi, page, old_blkaddr, new_blkaddr, &sum, fio);
+       do_write_page(sbi, page, &sum, fio);
 }
 
 void write_data_page(struct page *page, struct dnode_of_data *dn,
-               block_t *new_blkaddr, struct f2fs_io_info *fio)
+                               struct f2fs_io_info *fio)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
        struct f2fs_summary sum;
@@ -1223,14 +1223,12 @@ void write_data_page(struct page *page, struct dnode_of_data *dn,
        f2fs_bug_on(sbi, dn->data_blkaddr == NULL_ADDR);
        get_node_info(sbi, dn->nid, &ni);
        set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
-
-       do_write_page(sbi, page, dn->data_blkaddr, new_blkaddr, &sum, fio);
+       do_write_page(sbi, page, &sum, fio);
 }
 
-void rewrite_data_page(struct page *page, block_t old_blkaddr,
-                                       struct f2fs_io_info *fio)
+void rewrite_data_page(struct page *page, struct f2fs_io_info *fio)
 {
-       f2fs_submit_page_mbio(F2FS_P_SB(page), page, old_blkaddr, fio);
+       f2fs_submit_page_mbio(F2FS_P_SB(page), page, fio);
 }
 
 void recover_data_page(struct f2fs_sb_info *sbi,