f2fs: remove the create argument to f2fs_map_blocks

The create argument is always identicaly to map->m_may_create, so use
that consistently.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index e6f94591717b8a59a341550b389d269757a08b94..1cc5c6cb314687d2cb7095c8f6a4db348b3e46b2 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1477,8 +1477,7 @@ int f2fs_get_block_locked(struct dnode_of_data *dn, pgoff_t index)
  * maps continuous logical blocks to physical blocks, and return such
  * info via f2fs_map_blocks structure.
  */
-int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
-                                               int create, int flag)
+int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, int flag)
 {
        unsigned int maxblocks = map->m_len;
        struct dnode_of_data dn;
@@ -1507,38 +1506,31 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
        pgofs = (pgoff_t)map->m_lblk;
        end = pgofs + maxblocks;
 
-       if (!create && f2fs_lookup_read_extent_cache(inode, pgofs, &ei)) {
-               if (f2fs_lfs_mode(sbi) && flag == F2FS_GET_BLOCK_DIO &&
-                                                       map->m_may_create)
-                       goto next_dnode;
+       if (map->m_may_create ||
+           !f2fs_lookup_read_extent_cache(inode, pgofs, &ei))
+               goto next_dnode;
 
-               map->m_pblk = ei.blk + pgofs - ei.fofs;
-               map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
-               map->m_flags = F2FS_MAP_MAPPED;
-               if (map->m_next_extent)
-                       *map->m_next_extent = pgofs + map->m_len;
+       /* Found the map in read extent cache */
+       map->m_pblk = ei.blk + pgofs - ei.fofs;
+       map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
+       map->m_flags = F2FS_MAP_MAPPED;
+       if (map->m_next_extent)
+               *map->m_next_extent = pgofs + map->m_len;
 
-               /* for hardware encryption, but to avoid potential issue in future */
-               if (flag == F2FS_GET_BLOCK_DIO)
-                       f2fs_wait_on_block_writeback_range(inode,
+       /* for hardware encryption, but to avoid potential issue in future */
+       if (flag == F2FS_GET_BLOCK_DIO)
+               f2fs_wait_on_block_writeback_range(inode,
                                                map->m_pblk, map->m_len);
 
-               if (map->m_multidev_dio) {
-                       block_t blk_addr = map->m_pblk;
-
-                       bidx = f2fs_target_device_index(sbi, map->m_pblk);
+       if (map->m_multidev_dio) {
+               bidx = f2fs_target_device_index(sbi, map->m_pblk);
 
-                       map->m_bdev = FDEV(bidx).bdev;
-                       map->m_pblk -= FDEV(bidx).start_blk;
-                       map->m_len = min(map->m_len,
+               map->m_bdev = FDEV(bidx).bdev;
+               map->m_pblk -= FDEV(bidx).start_blk;
+               map->m_len = min(map->m_len,
                                FDEV(bidx).end_blk + 1 - map->m_pblk);
-
-                       if (map->m_may_create)
-                               f2fs_update_device_state(sbi, inode->i_ino,
-                                                       blk_addr, map->m_len);
-               }
-               goto out;
        }
+       goto out;
 
 next_dnode:
        if (map->m_may_create)
@@ -1602,7 +1594,7 @@ next_block:
                        set_inode_flag(inode, FI_APPEND_WRITE);
                }
        } else {
-               if (create) {
+               if (map->m_may_create) {
                        if (unlikely(f2fs_cp_error(sbi))) {
                                err = -EIO;
                                goto sync_out;
@@ -1776,7 +1768,7 @@ unlock_out:
                f2fs_balance_fs(sbi, dn.node_changed);
        }
 out:
-       trace_f2fs_map_blocks(inode, map, create, flag, err);
+       trace_f2fs_map_blocks(inode, map, flag, err);
        return err;
 }
 
@@ -1798,7 +1790,7 @@ bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len)
 
        while (map.m_lblk < last_lblk) {
                map.m_len = last_lblk - map.m_lblk;
-               err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
+               err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
                if (err || map.m_len == 0)
                        return false;
                map.m_lblk += map.m_len;
@@ -1972,7 +1964,7 @@ next:
                map.m_len = cluster_size - count_in_cluster;
        }
 
-       ret = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_FIEMAP);
+       ret = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_FIEMAP);
        if (ret)
                goto out;
 
@@ -2105,7 +2097,7 @@ static int f2fs_read_single_page(struct inode *inode, struct page *page,
        map->m_lblk = block_in_file;
        map->m_len = last_block - block_in_file;
 
-       ret = f2fs_map_blocks(inode, map, 0, F2FS_GET_BLOCK_DEFAULT);
+       ret = f2fs_map_blocks(inode, map, F2FS_GET_BLOCK_DEFAULT);
        if (ret)
                goto out;
 got_it:
@@ -3807,7 +3799,7 @@ static sector_t f2fs_bmap(struct address_space *mapping, sector_t block)
                map.m_next_pgofs = NULL;
                map.m_seg_type = NO_CHECK_TYPE;
 
-               if (!f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_BMAP))
+               if (!f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_BMAP))
                        blknr = map.m_pblk;
        }
 out:
@@ -3915,7 +3907,7 @@ retry:
                map.m_seg_type = NO_CHECK_TYPE;
                map.m_may_create = false;
 
-               ret = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_FIEMAP);
+               ret = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_FIEMAP);
                if (ret)
                        goto out;
 
@@ -4140,8 +4132,7 @@ static int f2fs_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
        if (flags & IOMAP_WRITE)
                map.m_may_create = true;
 
-       err = f2fs_map_blocks(inode, &map, flags & IOMAP_WRITE,
-                             F2FS_GET_BLOCK_DIO);
+       err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DIO);
        if (err)
                return err;
 

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 744cb442085f6229e097e1f0cae8dafeea0e2a0e..60f421fe14eee387bf9064581795a12a3e58e0bb 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3811,8 +3811,7 @@ struct page *f2fs_get_lock_data_page(struct inode *inode, pgoff_t index,
 struct page *f2fs_get_new_data_page(struct inode *inode,
                        struct page *ipage, pgoff_t index, bool new_i_size);
 int f2fs_do_write_data_page(struct f2fs_io_info *fio);
-int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
-                       int create, int flag);
+int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, int flag);
 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                        u64 start, u64 len);
 int f2fs_encrypt_one_page(struct f2fs_io_info *fio);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 705a7eb4df99b9a72237f637c7d1f4316c2a59f9..939c7247c367829437b0d8d69c44fe6cff2194d8 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1743,7 +1743,7 @@ next_alloc:
                f2fs_unlock_op(sbi);
 
                map.m_seg_type = CURSEG_COLD_DATA_PINNED;
-               err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);
+               err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_DIO);
                file_dont_truncate(inode);
 
                f2fs_up_write(&sbi->pin_sem);
@@ -1756,7 +1756,7 @@ next_alloc:
 
                map.m_len = expanded;
        } else {
-               err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
+               err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
                expanded = map.m_len;
        }
 out_err:
@@ -2604,7 +2604,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
         */
        while (map.m_lblk < pg_end) {
                map.m_len = pg_end - map.m_lblk;
-               err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
+               err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
                if (err)
                        goto out;
 
@@ -2651,7 +2651,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
 
 do_map:
                map.m_len = pg_end - map.m_lblk;
-               err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
+               err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
                if (err)
                        goto clear_out;
 
@@ -3225,7 +3225,7 @@ int f2fs_precache_extents(struct inode *inode)
                map.m_len = end - map.m_lblk;
 
                f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
-               err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
+               err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRECACHE);
                f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
                if (err)
                        return err;
@@ -4464,7 +4464,7 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
                flag = F2FS_GET_BLOCK_PRE_AIO;
        }
 
-       ret = f2fs_map_blocks(inode, &map, 1, flag);
+       ret = f2fs_map_blocks(inode, &map, flag);
        /* -ENOSPC|-EDQUOT are fine to report the number of allocated blocks. */
        if (ret < 0 && !((ret == -ENOSPC || ret == -EDQUOT) && map.m_len > 0))
                return ret;

diff --git a/include/trace/events/f2fs.h b/include/trace/events/f2fs.h
index 31d994e6b4ca9fcc811675f1c0f04f7c00d314ac..9183a0a11e26fde014eb31710ade4ea2f7ee4990 100644 (file)
--- a/include/trace/events/f2fs.h
+++ b/include/trace/events/f2fs.h
@@ -569,10 +569,10 @@ TRACE_EVENT(f2fs_file_write_iter,
 );
 
 TRACE_EVENT(f2fs_map_blocks,
-       TP_PROTO(struct inode *inode, struct f2fs_map_blocks *map,
-                               int create, int flag, int ret),
+       TP_PROTO(struct inode *inode, struct f2fs_map_blocks *map, int flag,
+                int ret),
 
-       TP_ARGS(inode, map, create, flag, ret),
+       TP_ARGS(inode, map, flag, ret),
 
        TP_STRUCT__entry(
                __field(dev_t,  dev)
@@ -584,7 +584,6 @@ TRACE_EVENT(f2fs_map_blocks,
                __field(int,    m_seg_type)
                __field(bool,   m_may_create)
                __field(bool,   m_multidev_dio)
-               __field(int,    create)
                __field(int,    flag)
                __field(int,    ret)
        ),
@@ -599,7 +598,6 @@ TRACE_EVENT(f2fs_map_blocks,
                __entry->m_seg_type     = map->m_seg_type;
                __entry->m_may_create   = map->m_may_create;
                __entry->m_multidev_dio = map->m_multidev_dio;
-               __entry->create         = create;
                __entry->flag           = flag;
                __entry->ret            = ret;
        ),
@@ -607,7 +605,7 @@ TRACE_EVENT(f2fs_map_blocks,
        TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
                "start blkaddr = 0x%llx, len = 0x%llx, flags = %u, "
                "seg_type = %d, may_create = %d, multidevice = %d, "
-               "create = %d, flag = %d, err = %d",
+               "flag = %d, err = %d",
                show_dev_ino(__entry),
                (unsigned long long)__entry->m_lblk,
                (unsigned long long)__entry->m_pblk,
@@ -616,7 +614,6 @@ TRACE_EVENT(f2fs_map_blocks,
                __entry->m_seg_type,
                __entry->m_may_create,
                __entry->m_multidev_dio,
-               __entry->create,
                __entry->flag,
                __entry->ret)
 );