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

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

100 sbi->gc_mode = GC_NORMAL;
101 continue;
102 }
103 sbi->gc_urgent_high_remaining--;
104 }
105 spin_unlock(&sbi->gc_urgent_high_lock);
106
107 wait_ms = gc_th->urgent_sleep_time;
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/gc.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

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

100 sbi->gc_mode = GC_NORMAL;
101 continue;
102 }
103 sbi->gc_urgent_high_remaining--;
104 }
105 spin_unlock(&sbi->gc_urgent_high_lock);
106
107 wait_ms = gc_th->urgent_sleep_time;
108 down_write(&sbi->gc_lock);
108 f2fs_down_write(&sbi->gc_lock);
109 goto do_gc;
110 }
111
112 if (foreground) {
109 goto do_gc;
110 }
111
112 if (foreground) {
113 down_write(&sbi->gc_lock);
113 f2fs_down_write(&sbi->gc_lock);
114 goto do_gc;
114 goto do_gc;
115 } else if (!down_write_trylock(&sbi->gc_lock)) {
115 } else if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
116 stat_other_skip_bggc_count(sbi);
117 goto next;
118 }
119
120 if (!is_idle(sbi, GC_TIME)) {
121 increase_sleep_time(gc_th, &wait_ms);
116 stat_other_skip_bggc_count(sbi);
117 goto next;
118 }
119
120 if (!is_idle(sbi, GC_TIME)) {
121 increase_sleep_time(gc_th, &wait_ms);
122 up_write(&sbi->gc_lock);
122 f2fs_up_write(&sbi->gc_lock);
123 stat_io_skip_bggc_count(sbi);
124 goto next;
125 }
126
127 if (has_enough_invalid_blocks(sbi))
128 decrease_sleep_time(gc_th, &wait_ms);
129 else
130 increase_sleep_time(gc_th, &wait_ms);

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

1225 if (err)
1226 goto put_out;
1227
1228 /* read page */
1229 fio.page = page;
1230 fio.new_blkaddr = fio.old_blkaddr = dn.data_blkaddr;
1231
1232 if (lfs_mode)
123 stat_io_skip_bggc_count(sbi);
124 goto next;
125 }
126
127 if (has_enough_invalid_blocks(sbi))
128 decrease_sleep_time(gc_th, &wait_ms);
129 else
130 increase_sleep_time(gc_th, &wait_ms);

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

1225 if (err)
1226 goto put_out;
1227
1228 /* read page */
1229 fio.page = page;
1230 fio.new_blkaddr = fio.old_blkaddr = dn.data_blkaddr;
1231
1232 if (lfs_mode)
1233 down_write(&fio.sbi->io_order_lock);
1233 f2fs_down_write(&fio.sbi->io_order_lock);
1234
1235 mpage = f2fs_grab_cache_page(META_MAPPING(fio.sbi),
1236 fio.old_blkaddr, false);
1237 if (!mpage) {
1238 err = -ENOMEM;
1239 goto up_out;
1240 }
1241

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

1311put_page_out:
1312 f2fs_put_page(fio.encrypted_page, 1);
1313recover_block:
1314 if (err)
1315 f2fs_do_replace_block(fio.sbi, &sum, newaddr, fio.old_blkaddr,
1316 true, true, true);
1317up_out:
1318 if (lfs_mode)
1234
1235 mpage = f2fs_grab_cache_page(META_MAPPING(fio.sbi),
1236 fio.old_blkaddr, false);
1237 if (!mpage) {
1238 err = -ENOMEM;
1239 goto up_out;
1240 }
1241

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

1311put_page_out:
1312 f2fs_put_page(fio.encrypted_page, 1);
1313recover_block:
1314 if (err)
1315 f2fs_do_replace_block(fio.sbi, &sum, newaddr, fio.old_blkaddr,
1316 true, true, true);
1317up_out:
1318 if (lfs_mode)
1319 up_write(&fio.sbi->io_order_lock);
1319 f2fs_up_write(&fio.sbi->io_order_lock);
1320put_out:
1321 f2fs_put_dnode(&dn);
1322out:
1323 f2fs_put_page(page, 1);
1324 return err;
1325}
1326
1327static int move_data_page(struct inode *inode, block_t bidx, int gc_type,

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

1470 ofs_in_node = le16_to_cpu(entry->ofs_in_node);
1471
1472 if (phase == 3) {
1473 inode = f2fs_iget(sb, dni.ino);
1474 if (IS_ERR(inode) || is_bad_inode(inode) ||
1475 special_file(inode->i_mode))
1476 continue;
1477
1320put_out:
1321 f2fs_put_dnode(&dn);
1322out:
1323 f2fs_put_page(page, 1);
1324 return err;
1325}
1326
1327static int move_data_page(struct inode *inode, block_t bidx, int gc_type,

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

1470 ofs_in_node = le16_to_cpu(entry->ofs_in_node);
1471
1472 if (phase == 3) {
1473 inode = f2fs_iget(sb, dni.ino);
1474 if (IS_ERR(inode) || is_bad_inode(inode) ||
1475 special_file(inode->i_mode))
1476 continue;
1477
1478 if (!down_write_trylock(
1478 if (!f2fs_down_write_trylock(
1479 &F2FS_I(inode)->i_gc_rwsem[WRITE])) {
1480 iput(inode);
1481 sbi->skipped_gc_rwsem++;
1482 continue;
1483 }
1484
1485 start_bidx = f2fs_start_bidx_of_node(nofs, inode) +
1486 ofs_in_node;
1487
1488 if (f2fs_post_read_required(inode)) {
1489 int err = ra_data_block(inode, start_bidx);
1490
1479 &F2FS_I(inode)->i_gc_rwsem[WRITE])) {
1480 iput(inode);
1481 sbi->skipped_gc_rwsem++;
1482 continue;
1483 }
1484
1485 start_bidx = f2fs_start_bidx_of_node(nofs, inode) +
1486 ofs_in_node;
1487
1488 if (f2fs_post_read_required(inode)) {
1489 int err = ra_data_block(inode, start_bidx);
1490
1491 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1491 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1492 if (err) {
1493 iput(inode);
1494 continue;
1495 }
1496 add_gc_inode(gc_list, inode);
1497 continue;
1498 }
1499
1500 data_page = f2fs_get_read_data_page(inode,
1501 start_bidx, REQ_RAHEAD, true);
1492 if (err) {
1493 iput(inode);
1494 continue;
1495 }
1496 add_gc_inode(gc_list, inode);
1497 continue;
1498 }
1499
1500 data_page = f2fs_get_read_data_page(inode,
1501 start_bidx, REQ_RAHEAD, true);
1502 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1502 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1503 if (IS_ERR(data_page)) {
1504 iput(inode);
1505 continue;
1506 }
1507
1508 f2fs_put_page(data_page, 0);
1509 add_gc_inode(gc_list, inode);
1510 continue;
1511 }
1512
1513 /* phase 4 */
1514 inode = find_gc_inode(gc_list, dni.ino);
1515 if (inode) {
1516 struct f2fs_inode_info *fi = F2FS_I(inode);
1517 bool locked = false;
1518 int err;
1519
1520 if (S_ISREG(inode->i_mode)) {
1503 if (IS_ERR(data_page)) {
1504 iput(inode);
1505 continue;
1506 }
1507
1508 f2fs_put_page(data_page, 0);
1509 add_gc_inode(gc_list, inode);
1510 continue;
1511 }
1512
1513 /* phase 4 */
1514 inode = find_gc_inode(gc_list, dni.ino);
1515 if (inode) {
1516 struct f2fs_inode_info *fi = F2FS_I(inode);
1517 bool locked = false;
1518 int err;
1519
1520 if (S_ISREG(inode->i_mode)) {
1521 if (!down_write_trylock(&fi->i_gc_rwsem[READ])) {
1521 if (!f2fs_down_write_trylock(&fi->i_gc_rwsem[READ])) {
1522 sbi->skipped_gc_rwsem++;
1523 continue;
1524 }
1522 sbi->skipped_gc_rwsem++;
1523 continue;
1524 }
1525 if (!down_write_trylock(
1525 if (!f2fs_down_write_trylock(
1526 &fi->i_gc_rwsem[WRITE])) {
1527 sbi->skipped_gc_rwsem++;
1526 &fi->i_gc_rwsem[WRITE])) {
1527 sbi->skipped_gc_rwsem++;
1528 up_write(&fi->i_gc_rwsem[READ]);
1528 f2fs_up_write(&fi->i_gc_rwsem[READ]);
1529 continue;
1530 }
1531 locked = true;
1532
1533 /* wait for all inflight aio data */
1534 inode_dio_wait(inode);
1535 }
1536

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

1543 err = move_data_page(inode, start_bidx, gc_type,
1544 segno, off);
1545
1546 if (!err && (gc_type == FG_GC ||
1547 f2fs_post_read_required(inode)))
1548 submitted++;
1549
1550 if (locked) {
1529 continue;
1530 }
1531 locked = true;
1532
1533 /* wait for all inflight aio data */
1534 inode_dio_wait(inode);
1535 }
1536

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

1543 err = move_data_page(inode, start_bidx, gc_type,
1544 segno, off);
1545
1546 if (!err && (gc_type == FG_GC ||
1547 f2fs_post_read_required(inode)))
1548 submitted++;
1549
1550 if (locked) {
1551 up_write(&fi->i_gc_rwsem[WRITE]);
1552 up_write(&fi->i_gc_rwsem[READ]);
1551 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
1552 f2fs_up_write(&fi->i_gc_rwsem[READ]);
1553 }
1554
1555 stat_inc_data_blk_count(sbi, 1, gc_type);
1556 }
1557 }
1558
1559 if (++phase < 5)
1560 goto next_step;

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

1802 get_pages(sbi, F2FS_DIRTY_NODES),
1803 get_pages(sbi, F2FS_DIRTY_DENTS),
1804 get_pages(sbi, F2FS_DIRTY_IMETA),
1805 free_sections(sbi),
1806 free_segments(sbi),
1807 reserved_segments(sbi),
1808 prefree_segments(sbi));
1809
1553 }
1554
1555 stat_inc_data_blk_count(sbi, 1, gc_type);
1556 }
1557 }
1558
1559 if (++phase < 5)
1560 goto next_step;

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

1802 get_pages(sbi, F2FS_DIRTY_NODES),
1803 get_pages(sbi, F2FS_DIRTY_DENTS),
1804 get_pages(sbi, F2FS_DIRTY_IMETA),
1805 free_sections(sbi),
1806 free_segments(sbi),
1807 reserved_segments(sbi),
1808 prefree_segments(sbi));
1809
1810 up_write(&sbi->gc_lock);
1810 f2fs_up_write(&sbi->gc_lock);
1811
1812 put_gc_inode(&gc_list);
1813
1814 if (sync && !ret)
1815 ret = sec_freed ? 0 : -EAGAIN;
1816 return ret;
1817}
1818

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

1931{
1932 struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
1933 int section_count;
1934 int segment_count;
1935 int segment_count_main;
1936 long long block_count;
1937 int segs = secs * sbi->segs_per_sec;
1938
1811
1812 put_gc_inode(&gc_list);
1813
1814 if (sync && !ret)
1815 ret = sec_freed ? 0 : -EAGAIN;
1816 return ret;
1817}
1818

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

1931{
1932 struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
1933 int section_count;
1934 int segment_count;
1935 int segment_count_main;
1936 long long block_count;
1937 int segs = secs * sbi->segs_per_sec;
1938
1939 down_write(&sbi->sb_lock);
1939 f2fs_down_write(&sbi->sb_lock);
1940
1941 section_count = le32_to_cpu(raw_sb->section_count);
1942 segment_count = le32_to_cpu(raw_sb->segment_count);
1943 segment_count_main = le32_to_cpu(raw_sb->segment_count_main);
1944 block_count = le64_to_cpu(raw_sb->block_count);
1945
1946 raw_sb->section_count = cpu_to_le32(section_count + secs);
1947 raw_sb->segment_count = cpu_to_le32(segment_count + segs);

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

1952 int last_dev = sbi->s_ndevs - 1;
1953 int dev_segs =
1954 le32_to_cpu(raw_sb->devs[last_dev].total_segments);
1955
1956 raw_sb->devs[last_dev].total_segments =
1957 cpu_to_le32(dev_segs + segs);
1958 }
1959
1940
1941 section_count = le32_to_cpu(raw_sb->section_count);
1942 segment_count = le32_to_cpu(raw_sb->segment_count);
1943 segment_count_main = le32_to_cpu(raw_sb->segment_count_main);
1944 block_count = le64_to_cpu(raw_sb->block_count);
1945
1946 raw_sb->section_count = cpu_to_le32(section_count + secs);
1947 raw_sb->segment_count = cpu_to_le32(segment_count + segs);

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

1952 int last_dev = sbi->s_ndevs - 1;
1953 int dev_segs =
1954 le32_to_cpu(raw_sb->devs[last_dev].total_segments);
1955
1956 raw_sb->devs[last_dev].total_segments =
1957 cpu_to_le32(dev_segs + segs);
1958 }
1959
1960 up_write(&sbi->sb_lock);
1960 f2fs_up_write(&sbi->sb_lock);
1961}
1962
1963static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
1964{
1965 int segs = secs * sbi->segs_per_sec;
1966 long long blks = (long long)segs * sbi->blocks_per_seg;
1967 long long user_block_count =
1968 le64_to_cpu(F2FS_CKPT(sbi)->user_block_count);

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

2026 f2fs_err(sbi, "Checkpoint should be enabled.");
2027 return -EINVAL;
2028 }
2029
2030 shrunk_blocks = old_block_count - block_count;
2031 secs = div_u64(shrunk_blocks, BLKS_PER_SEC(sbi));
2032
2033 /* stop other GC */
1961}
1962
1963static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
1964{
1965 int segs = secs * sbi->segs_per_sec;
1966 long long blks = (long long)segs * sbi->blocks_per_seg;
1967 long long user_block_count =
1968 le64_to_cpu(F2FS_CKPT(sbi)->user_block_count);

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

2026 f2fs_err(sbi, "Checkpoint should be enabled.");
2027 return -EINVAL;
2028 }
2029
2030 shrunk_blocks = old_block_count - block_count;
2031 secs = div_u64(shrunk_blocks, BLKS_PER_SEC(sbi));
2032
2033 /* stop other GC */
2034 if (!down_write_trylock(&sbi->gc_lock))
2034 if (!f2fs_down_write_trylock(&sbi->gc_lock))
2035 return -EAGAIN;
2036
2037 /* stop CP to protect MAIN_SEC in free_segment_range */
2038 f2fs_lock_op(sbi);
2039
2040 spin_lock(&sbi->stat_lock);
2041 if (shrunk_blocks + valid_user_blocks(sbi) +
2042 sbi->current_reserved_blocks + sbi->unusable_block_count +
2043 F2FS_OPTION(sbi).root_reserved_blocks > sbi->user_block_count)
2044 err = -ENOSPC;
2045 spin_unlock(&sbi->stat_lock);
2046
2047 if (err)
2048 goto out_unlock;
2049
2050 err = free_segment_range(sbi, secs, true);
2051
2052out_unlock:
2053 f2fs_unlock_op(sbi);
2035 return -EAGAIN;
2036
2037 /* stop CP to protect MAIN_SEC in free_segment_range */
2038 f2fs_lock_op(sbi);
2039
2040 spin_lock(&sbi->stat_lock);
2041 if (shrunk_blocks + valid_user_blocks(sbi) +
2042 sbi->current_reserved_blocks + sbi->unusable_block_count +
2043 F2FS_OPTION(sbi).root_reserved_blocks > sbi->user_block_count)
2044 err = -ENOSPC;
2045 spin_unlock(&sbi->stat_lock);
2046
2047 if (err)
2048 goto out_unlock;
2049
2050 err = free_segment_range(sbi, secs, true);
2051
2052out_unlock:
2053 f2fs_unlock_op(sbi);
2054 up_write(&sbi->gc_lock);
2054 f2fs_up_write(&sbi->gc_lock);
2055 if (err)
2056 return err;
2057
2058 set_sbi_flag(sbi, SBI_IS_RESIZEFS);
2059
2060 freeze_super(sbi->sb);
2055 if (err)
2056 return err;
2057
2058 set_sbi_flag(sbi, SBI_IS_RESIZEFS);
2059
2060 freeze_super(sbi->sb);
2061 down_write(&sbi->gc_lock);
2062 down_write(&sbi->cp_global_sem);
2061 f2fs_down_write(&sbi->gc_lock);
2062 f2fs_down_write(&sbi->cp_global_sem);
2063
2064 spin_lock(&sbi->stat_lock);
2065 if (shrunk_blocks + valid_user_blocks(sbi) +
2066 sbi->current_reserved_blocks + sbi->unusable_block_count +
2067 F2FS_OPTION(sbi).root_reserved_blocks > sbi->user_block_count)
2068 err = -ENOSPC;
2069 else
2070 sbi->user_block_count -= shrunk_blocks;

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

2099 set_sbi_flag(sbi, SBI_NEED_FSCK);
2100 f2fs_err(sbi, "resize_fs failed, should run fsck to repair!");
2101
2102 spin_lock(&sbi->stat_lock);
2103 sbi->user_block_count += shrunk_blocks;
2104 spin_unlock(&sbi->stat_lock);
2105 }
2106out_err:
2063
2064 spin_lock(&sbi->stat_lock);
2065 if (shrunk_blocks + valid_user_blocks(sbi) +
2066 sbi->current_reserved_blocks + sbi->unusable_block_count +
2067 F2FS_OPTION(sbi).root_reserved_blocks > sbi->user_block_count)
2068 err = -ENOSPC;
2069 else
2070 sbi->user_block_count -= shrunk_blocks;

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

2099 set_sbi_flag(sbi, SBI_NEED_FSCK);
2100 f2fs_err(sbi, "resize_fs failed, should run fsck to repair!");
2101
2102 spin_lock(&sbi->stat_lock);
2103 sbi->user_block_count += shrunk_blocks;
2104 spin_unlock(&sbi->stat_lock);
2105 }
2106out_err:
2107 up_write(&sbi->cp_global_sem);
2108 up_write(&sbi->gc_lock);
2107 f2fs_up_write(&sbi->cp_global_sem);
2108 f2fs_up_write(&sbi->gc_lock);
2109 thaw_super(sbi->sb);
2110 clear_sbi_flag(sbi, SBI_IS_RESIZEFS);
2111 return err;
2112}
2109 thaw_super(sbi->sb);
2110 clear_sbi_flag(sbi, SBI_IS_RESIZEFS);
2111 return err;
2112}