From: Daeho Jeong <daehoje...@google.com>

Support swap file pinning for zoned devices

Signed-off-by: Daeho Jeong <daehoje...@google.com>
Signed-off-by: Jaegeuk Kim <jaeg...@kernel.org>
---
 fs/f2fs/data.c | 54 ++++++++++++++++++++++++++++++++------------------
 1 file changed, 35 insertions(+), 19 deletions(-)

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 05158f89ef32..5d8ee6e73dbe 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -3905,28 +3905,40 @@ static int f2fs_migrate_blocks(struct inode *inode, 
block_t start_blk,
                                                        unsigned int blkcnt)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_map_blocks map = { .m_next_pgofs = NULL,
+               .m_next_extent = NULL, .m_seg_type = CURSEG_COLD_DATA_PINNED,
+               .m_may_create = true };
        unsigned int blkofs;
        unsigned int blk_per_sec = BLKS_PER_SEC(sbi);
        unsigned int secidx = start_blk / blk_per_sec;
-       unsigned int end_sec = secidx + blkcnt / blk_per_sec;
+       unsigned int end_sec;
        int ret = 0;
 
+       if (!blkcnt)
+               return 0;
+       end_sec = secidx + (blkcnt - 1) / blk_per_sec;
+
        f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        filemap_invalidate_lock(inode->i_mapping);
 
        set_inode_flag(inode, FI_ALIGNED_WRITE);
        set_inode_flag(inode, FI_OPU_WRITE);
 
-       for (; secidx < end_sec; secidx++) {
+       for (; secidx <= end_sec; secidx++) {
+               unsigned int blkofs_end = secidx == end_sec ?
+                       (blkcnt - 1) % blk_per_sec : blk_per_sec - 1;
+
                f2fs_down_write(&sbi->pin_sem);
 
-               f2fs_lock_op(sbi);
-               f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
-               f2fs_unlock_op(sbi);
+               ret = f2fs_allocate_pinning_section(sbi);
+               if (ret) {
+                       f2fs_up_write(&sbi->pin_sem);
+                       break;
+               }
 
                set_inode_flag(inode, FI_SKIP_WRITES);
 
-               for (blkofs = 0; blkofs < blk_per_sec; blkofs++) {
+               for (blkofs = 0; blkofs <= blkofs_end; blkofs++) {
                        struct page *page;
                        unsigned int blkidx = secidx * blk_per_sec + blkofs;
 
@@ -3944,6 +3956,12 @@ static int f2fs_migrate_blocks(struct inode *inode, 
block_t start_blk,
                clear_inode_flag(inode, FI_SKIP_WRITES);
 
                ret = filemap_fdatawrite(inode->i_mapping);
+               if (!ret && blkofs != blk_per_sec) {
+                       map.m_lblk = secidx * blk_per_sec + blkofs;
+                       map.m_len = blk_per_sec - blkofs;
+                       ret = f2fs_map_blocks(inode, &map,
+                                       F2FS_GET_BLOCK_PRE_DIO);
+               }
 
                f2fs_up_write(&sbi->pin_sem);
 
@@ -4015,19 +4033,17 @@ static int check_swap_activate(struct swap_info_struct 
*sis,
                nr_pblocks = map.m_len;
 
                if ((pblock - SM_I(sbi)->main_blkaddr) & sec_blks_mask ||
-                               nr_pblocks & sec_blks_mask) {
+                               nr_pblocks & sec_blks_mask ||
+                               !f2fs_valid_pinned_area(sbi, pblock)) {
                        not_aligned++;
 
                        nr_pblocks = roundup(nr_pblocks, blks_per_sec);
                        if (cur_lblock + nr_pblocks > sis->max)
                                nr_pblocks -= blks_per_sec;
 
-                       if (!nr_pblocks) {
-                               /* this extent is last one */
-                               nr_pblocks = map.m_len;
-                               f2fs_warn(sbi, "Swapfile: last extent is not 
aligned to section");
-                               goto next;
-                       }
+                       /* this extent is last one */
+                       if (!nr_pblocks)
+                               nr_pblocks = last_lblock - cur_lblock;
 
                        ret = f2fs_migrate_blocks(inode, cur_lblock,
                                                        nr_pblocks);
@@ -4035,7 +4051,7 @@ static int check_swap_activate(struct swap_info_struct 
*sis,
                                goto out;
                        goto retry;
                }
-next:
+
                if (cur_lblock + nr_pblocks >= sis->max)
                        nr_pblocks = sis->max - cur_lblock;
 
@@ -4073,17 +4089,17 @@ static int f2fs_swap_activate(struct swap_info_struct 
*sis, struct file *file,
                                sector_t *span)
 {
        struct inode *inode = file_inode(file);
+       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        int ret;
 
        if (!S_ISREG(inode->i_mode))
                return -EINVAL;
 
-       if (f2fs_readonly(F2FS_I_SB(inode)->sb))
+       if (f2fs_readonly(sbi->sb))
                return -EROFS;
 
-       if (f2fs_lfs_mode(F2FS_I_SB(inode))) {
-               f2fs_err(F2FS_I_SB(inode),
-                       "Swapfile not supported in LFS mode");
+       if (f2fs_lfs_mode(sbi) && !f2fs_sb_has_blkzoned(sbi)) {
+               f2fs_err(sbi, "Swapfile not supported in LFS mode");
                return -EINVAL;
        }
 
@@ -4102,7 +4118,7 @@ static int f2fs_swap_activate(struct swap_info_struct 
*sis, struct file *file,
 
        stat_inc_swapfile_inode(inode);
        set_inode_flag(inode, FI_PIN_FILE);
-       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
+       f2fs_update_time(sbi, REQ_TIME);
        return ret;
 }
 
-- 
2.43.0.594.gd9cf4e227d-goog



_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

Reply via email to