data.c (0b8fc00601c0d8bea19667bbc66f00e13d954e4a) data.c (859fca6b706e005f7cf19aa2ce7bb4005bcef427)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/data.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 2458 unchanged lines hidden (view full) ---

2467 !f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
2468 return true;
2469
2470 return false;
2471}
2472
2473bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio)
2474{
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/data.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 2458 unchanged lines hidden (view full) ---

2467 !f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
2468 return true;
2469
2470 return false;
2471}
2472
2473bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio)
2474{
2475 /* swap file is migrating in aligned write mode */
2476 if (is_inode_flag_set(inode, FI_ALIGNED_WRITE))
2477 return false;
2478
2475 if (f2fs_is_pinned_file(inode))
2476 return true;
2477
2478 /* if this is cold file, we should overwrite to avoid fragmentation */
2479 if (file_is_cold(inode))
2480 return true;
2481
2482 return check_inplace_update_policy(inode, fio);

--- 6 unchanged lines hidden (view full) ---

2489 if (f2fs_lfs_mode(sbi))
2490 return true;
2491 if (S_ISDIR(inode->i_mode))
2492 return true;
2493 if (IS_NOQUOTA(inode))
2494 return true;
2495 if (f2fs_is_atomic_file(inode))
2496 return true;
2479 if (f2fs_is_pinned_file(inode))
2480 return true;
2481
2482 /* if this is cold file, we should overwrite to avoid fragmentation */
2483 if (file_is_cold(inode))
2484 return true;
2485
2486 return check_inplace_update_policy(inode, fio);

--- 6 unchanged lines hidden (view full) ---

2493 if (f2fs_lfs_mode(sbi))
2494 return true;
2495 if (S_ISDIR(inode->i_mode))
2496 return true;
2497 if (IS_NOQUOTA(inode))
2498 return true;
2499 if (f2fs_is_atomic_file(inode))
2500 return true;
2501
2502 /* swap file is migrating in aligned write mode */
2503 if (is_inode_flag_set(inode, FI_ALIGNED_WRITE))
2504 return true;
2505
2497 if (fio) {
2498 if (page_private_gcing(fio->page))
2499 return true;
2500 if (page_private_dummy(fio->page))
2501 return true;
2502 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
2503 f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
2504 return true;

--- 1320 unchanged lines hidden (view full) ---

3825 else
3826 migrate_page_states(newpage, page);
3827
3828 return MIGRATEPAGE_SUCCESS;
3829}
3830#endif
3831
3832#ifdef CONFIG_SWAP
2506 if (fio) {
2507 if (page_private_gcing(fio->page))
2508 return true;
2509 if (page_private_dummy(fio->page))
2510 return true;
2511 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
2512 f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
2513 return true;

--- 1320 unchanged lines hidden (view full) ---

3834 else
3835 migrate_page_states(newpage, page);
3836
3837 return MIGRATEPAGE_SUCCESS;
3838}
3839#endif
3840
3841#ifdef CONFIG_SWAP
3842static int f2fs_migrate_blocks(struct inode *inode, block_t start_blk,
3843 unsigned int blkcnt)
3844{
3845 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3846 unsigned int blkofs;
3847 unsigned int blk_per_sec = BLKS_PER_SEC(sbi);
3848 unsigned int secidx = start_blk / blk_per_sec;
3849 unsigned int end_sec = secidx + blkcnt / blk_per_sec;
3850 int ret = 0;
3851
3852 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3853 down_write(&F2FS_I(inode)->i_mmap_sem);
3854
3855 set_inode_flag(inode, FI_ALIGNED_WRITE);
3856
3857 for (; secidx < end_sec; secidx++) {
3858 down_write(&sbi->pin_sem);
3859
3860 f2fs_lock_op(sbi);
3861 f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
3862 f2fs_unlock_op(sbi);
3863
3864 set_inode_flag(inode, FI_DO_DEFRAG);
3865
3866 for (blkofs = 0; blkofs < blk_per_sec; blkofs++) {
3867 struct page *page;
3868 unsigned int blkidx = secidx * blk_per_sec + blkofs;
3869
3870 page = f2fs_get_lock_data_page(inode, blkidx, true);
3871 if (IS_ERR(page)) {
3872 up_write(&sbi->pin_sem);
3873 ret = PTR_ERR(page);
3874 goto done;
3875 }
3876
3877 set_page_dirty(page);
3878 f2fs_put_page(page, 1);
3879 }
3880
3881 clear_inode_flag(inode, FI_DO_DEFRAG);
3882
3883 ret = filemap_fdatawrite(inode->i_mapping);
3884
3885 up_write(&sbi->pin_sem);
3886
3887 if (ret)
3888 break;
3889 }
3890
3891done:
3892 clear_inode_flag(inode, FI_DO_DEFRAG);
3893 clear_inode_flag(inode, FI_ALIGNED_WRITE);
3894
3895 up_write(&F2FS_I(inode)->i_mmap_sem);
3896 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3897
3898 return ret;
3899}
3900
3833static int check_swap_activate(struct swap_info_struct *sis,
3834 struct file *swap_file, sector_t *span)
3835{
3836 struct address_space *mapping = swap_file->f_mapping;
3837 struct inode *inode = mapping->host;
3838 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3839 sector_t cur_lblock;
3840 sector_t last_lblock;
3841 sector_t pblock;
3842 sector_t lowest_pblock = -1;
3843 sector_t highest_pblock = 0;
3844 int nr_extents = 0;
3845 unsigned long nr_pblocks;
3901static int check_swap_activate(struct swap_info_struct *sis,
3902 struct file *swap_file, sector_t *span)
3903{
3904 struct address_space *mapping = swap_file->f_mapping;
3905 struct inode *inode = mapping->host;
3906 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3907 sector_t cur_lblock;
3908 sector_t last_lblock;
3909 sector_t pblock;
3910 sector_t lowest_pblock = -1;
3911 sector_t highest_pblock = 0;
3912 int nr_extents = 0;
3913 unsigned long nr_pblocks;
3846 unsigned int blocks_per_sec = BLKS_PER_SEC(sbi);
3914 unsigned int blks_per_sec = BLKS_PER_SEC(sbi);
3915 unsigned int sec_blks_mask = BLKS_PER_SEC(sbi) - 1;
3847 unsigned int not_aligned = 0;
3848 int ret = 0;
3849
3850 /*
3851 * Map all the blocks into the extent list. This code doesn't try
3852 * to be very smart.
3853 */
3854 cur_lblock = 0;
3855 last_lblock = bytes_to_blks(inode, i_size_read(inode));
3856
3857 while (cur_lblock < last_lblock && cur_lblock < sis->max) {
3858 struct f2fs_map_blocks map;
3916 unsigned int not_aligned = 0;
3917 int ret = 0;
3918
3919 /*
3920 * Map all the blocks into the extent list. This code doesn't try
3921 * to be very smart.
3922 */
3923 cur_lblock = 0;
3924 last_lblock = bytes_to_blks(inode, i_size_read(inode));
3925
3926 while (cur_lblock < last_lblock && cur_lblock < sis->max) {
3927 struct f2fs_map_blocks map;
3859
3928retry:
3860 cond_resched();
3861
3862 memset(&map, 0, sizeof(map));
3863 map.m_lblk = cur_lblock;
3864 map.m_len = last_lblock - cur_lblock;
3865 map.m_next_pgofs = NULL;
3866 map.m_next_extent = NULL;
3867 map.m_seg_type = NO_CHECK_TYPE;

--- 8 unchanged lines hidden (view full) ---

3876 f2fs_err(sbi, "Swapfile has holes");
3877 ret = -EINVAL;
3878 goto out;
3879 }
3880
3881 pblock = map.m_pblk;
3882 nr_pblocks = map.m_len;
3883
3929 cond_resched();
3930
3931 memset(&map, 0, sizeof(map));
3932 map.m_lblk = cur_lblock;
3933 map.m_len = last_lblock - cur_lblock;
3934 map.m_next_pgofs = NULL;
3935 map.m_next_extent = NULL;
3936 map.m_seg_type = NO_CHECK_TYPE;

--- 8 unchanged lines hidden (view full) ---

3945 f2fs_err(sbi, "Swapfile has holes");
3946 ret = -EINVAL;
3947 goto out;
3948 }
3949
3950 pblock = map.m_pblk;
3951 nr_pblocks = map.m_len;
3952
3884 if ((pblock - SM_I(sbi)->main_blkaddr) & (blocks_per_sec - 1) ||
3885 nr_pblocks & (blocks_per_sec - 1)) {
3886 if (f2fs_is_pinned_file(inode)) {
3887 f2fs_err(sbi, "Swapfile does not align to section");
3888 ret = -EINVAL;
3889 goto out;
3890 }
3953 if ((pblock - SM_I(sbi)->main_blkaddr) & sec_blks_mask ||
3954 nr_pblocks & sec_blks_mask) {
3891 not_aligned++;
3955 not_aligned++;
3892 }
3893
3956
3957 nr_pblocks = roundup(nr_pblocks, blks_per_sec);
3958 if (cur_lblock + nr_pblocks > sis->max)
3959 nr_pblocks -= blks_per_sec;
3960
3961 if (!nr_pblocks) {
3962 /* this extent is last one */
3963 nr_pblocks = map.m_len;
3964 f2fs_warn(sbi, "Swapfile: last extent is not aligned to section");
3965 goto next;
3966 }
3967
3968 ret = f2fs_migrate_blocks(inode, cur_lblock,
3969 nr_pblocks);
3970 if (ret)
3971 goto out;
3972 goto retry;
3973 }
3974next:
3894 if (cur_lblock + nr_pblocks >= sis->max)
3895 nr_pblocks = sis->max - cur_lblock;
3896
3897 if (cur_lblock) { /* exclude the header page */
3898 if (pblock < lowest_pblock)
3899 lowest_pblock = pblock;
3900 if (pblock + nr_pblocks - 1 > highest_pblock)
3901 highest_pblock = pblock + nr_pblocks - 1;

--- 10 unchanged lines hidden (view full) ---

3912 }
3913 ret = nr_extents;
3914 *span = 1 + highest_pblock - lowest_pblock;
3915 if (cur_lblock == 0)
3916 cur_lblock = 1; /* force Empty message */
3917 sis->max = cur_lblock;
3918 sis->pages = cur_lblock - 1;
3919 sis->highest_bit = cur_lblock - 1;
3975 if (cur_lblock + nr_pblocks >= sis->max)
3976 nr_pblocks = sis->max - cur_lblock;
3977
3978 if (cur_lblock) { /* exclude the header page */
3979 if (pblock < lowest_pblock)
3980 lowest_pblock = pblock;
3981 if (pblock + nr_pblocks - 1 > highest_pblock)
3982 highest_pblock = pblock + nr_pblocks - 1;

--- 10 unchanged lines hidden (view full) ---

3993 }
3994 ret = nr_extents;
3995 *span = 1 + highest_pblock - lowest_pblock;
3996 if (cur_lblock == 0)
3997 cur_lblock = 1; /* force Empty message */
3998 sis->max = cur_lblock;
3999 sis->pages = cur_lblock - 1;
4000 sis->highest_bit = cur_lblock - 1;
3920
3921 if (not_aligned)
3922 f2fs_warn(sbi, "Swapfile (%u) is not align to section: 1) creat(), 2) ioctl(F2FS_IOC_SET_PIN_FILE), 3) fallocate()",
3923 not_aligned);
3924out:
4001out:
4002 if (not_aligned)
4003 f2fs_warn(sbi, "Swapfile (%u) is not align to section: 1) creat(), 2) ioctl(F2FS_IOC_SET_PIN_FILE), 3) fallocate(%u * N)",
4004 not_aligned, blks_per_sec * F2FS_BLKSIZE);
3925 return ret;
3926}
3927
3928static int f2fs_swap_activate(struct swap_info_struct *sis, struct file *file,
3929 sector_t *span)
3930{
3931 struct inode *inode = file_inode(file);
3932 int ret;

--- 139 unchanged lines hidden --- 		4005 return ret;
4006}
4007
4008static int f2fs_swap_activate(struct swap_info_struct *sis, struct file *file,
4009 sector_t *span)
4010{
4011 struct inode *inode = file_inode(file);
4012 int ret;

--- 139 unchanged lines hidden ---