gc.c (1136fa0c07de570dc17858745af8be169d1440ba) gc.c (d98af5f4552058a5c22030641ef79cee92c61f54)
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>

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

98 sbi->gc_urgent_high_limited = false;
99 spin_unlock(&sbi->gc_urgent_high_lock);
100 sbi->gc_mode = GC_NORMAL;
101 continue;
102 }
103 sbi->gc_urgent_high_remaining--;
104 }
105 spin_unlock(&sbi->gc_urgent_high_lock);
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>

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

98 sbi->gc_urgent_high_limited = false;
99 spin_unlock(&sbi->gc_urgent_high_lock);
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 }
106
107
108 if (sbi->gc_mode == GC_URGENT_HIGH ||
109 sbi->gc_mode == GC_URGENT_MID) {
107 wait_ms = gc_th->urgent_sleep_time;
110 wait_ms = gc_th->urgent_sleep_time;
108 down_write(&sbi->gc_lock);
111 f2fs_down_write(&sbi->gc_lock);
109 goto do_gc;
110 }
111
112 if (foreground) {
112 goto do_gc;
113 }
114
115 if (foreground) {
113 down_write(&sbi->gc_lock);
116 f2fs_down_write(&sbi->gc_lock);
114 goto do_gc;
117 goto do_gc;
115 } else if (!down_write_trylock(&sbi->gc_lock)) {
118 } 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);
119 stat_other_skip_bggc_count(sbi);
120 goto next;
121 }
122
123 if (!is_idle(sbi, GC_TIME)) {
124 increase_sleep_time(gc_th, &wait_ms);
122 up_write(&sbi->gc_lock);
125 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);

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

1033 }
1034
1035 if (sum->version != dni->version) {
1036 f2fs_warn(sbi, "%s: valid data with mismatched node version.",
1037 __func__);
1038 set_sbi_flag(sbi, SBI_NEED_FSCK);
1039 }
1040
126 stat_io_skip_bggc_count(sbi);
127 goto next;
128 }
129
130 if (has_enough_invalid_blocks(sbi))
131 decrease_sleep_time(gc_th, &wait_ms);
132 else
133 increase_sleep_time(gc_th, &wait_ms);

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

1036 }
1037
1038 if (sum->version != dni->version) {
1039 f2fs_warn(sbi, "%s: valid data with mismatched node version.",
1040 __func__);
1041 set_sbi_flag(sbi, SBI_NEED_FSCK);
1042 }
1043
1041 if (f2fs_check_nid_range(sbi, dni->ino))
1044 if (f2fs_check_nid_range(sbi, dni->ino)) {
1045 f2fs_put_page(node_page, 1);
1042 return false;
1046 return false;
1047 }
1043
1044 *nofs = ofs_of_node(node_page);
1045 source_blkaddr = data_blkaddr(NULL, node_page, ofs_in_node);
1046 f2fs_put_page(node_page, 1);
1047
1048 if (source_blkaddr != blkaddr) {
1049#ifdef CONFIG_F2FS_CHECK_FS
1050 unsigned int segno = GET_SEGNO(sbi, blkaddr);

--- 174 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)
1048
1049 *nofs = ofs_of_node(node_page);
1050 source_blkaddr = data_blkaddr(NULL, node_page, ofs_in_node);
1051 f2fs_put_page(node_page, 1);
1052
1053 if (source_blkaddr != blkaddr) {
1054#ifdef CONFIG_F2FS_CHECK_FS
1055 unsigned int segno = GET_SEGNO(sbi, blkaddr);

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

1230 if (err)
1231 goto put_out;
1232
1233 /* read page */
1234 fio.page = page;
1235 fio.new_blkaddr = fio.old_blkaddr = dn.data_blkaddr;
1236
1237 if (lfs_mode)
1233 down_write(&fio.sbi->io_order_lock);
1238 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)
1239
1240 mpage = f2fs_grab_cache_page(META_MAPPING(fio.sbi),
1241 fio.old_blkaddr, false);
1242 if (!mpage) {
1243 err = -ENOMEM;
1244 goto up_out;
1245 }
1246

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

1316put_page_out:
1317 f2fs_put_page(fio.encrypted_page, 1);
1318recover_block:
1319 if (err)
1320 f2fs_do_replace_block(fio.sbi, &sum, newaddr, fio.old_blkaddr,
1321 true, true, true);
1322up_out:
1323 if (lfs_mode)
1319 up_write(&fio.sbi->io_order_lock);
1324 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
1325put_out:
1326 f2fs_put_dnode(&dn);
1327out:
1328 f2fs_put_page(page, 1);
1329 return err;
1330}
1331
1332static int move_data_page(struct inode *inode, block_t bidx, int gc_type,

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

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

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

1548 err = move_data_page(inode, start_bidx, gc_type,
1549 segno, off);
1550
1551 if (!err && (gc_type == FG_GC ||
1552 f2fs_post_read_required(inode)))
1553 submitted++;
1554
1555 if (locked) {
1551 up_write(&fi->i_gc_rwsem[WRITE]);
1552 up_write(&fi->i_gc_rwsem[READ]);
1556 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
1557 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
1558 }
1559
1560 stat_inc_data_blk_count(sbi, 1, gc_type);
1561 }
1562 }
1563
1564 if (++phase < 5)
1565 goto next_step;

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

1807 get_pages(sbi, F2FS_DIRTY_NODES),
1808 get_pages(sbi, F2FS_DIRTY_DENTS),
1809 get_pages(sbi, F2FS_DIRTY_IMETA),
1810 free_sections(sbi),
1811 free_segments(sbi),
1812 reserved_segments(sbi),
1813 prefree_segments(sbi));
1814
1810 up_write(&sbi->gc_lock);
1815 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
1816
1817 put_gc_inode(&gc_list);
1818
1819 if (sync && !ret)
1820 ret = sec_freed ? 0 : -EAGAIN;
1821 return ret;
1822}
1823

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

1936{
1937 struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
1938 int section_count;
1939 int segment_count;
1940 int segment_count_main;
1941 long long block_count;
1942 int segs = secs * sbi->segs_per_sec;
1943
1939 down_write(&sbi->sb_lock);
1944 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
1945
1946 section_count = le32_to_cpu(raw_sb->section_count);
1947 segment_count = le32_to_cpu(raw_sb->segment_count);
1948 segment_count_main = le32_to_cpu(raw_sb->segment_count_main);
1949 block_count = le64_to_cpu(raw_sb->block_count);
1950
1951 raw_sb->section_count = cpu_to_le32(section_count + secs);
1952 raw_sb->segment_count = cpu_to_le32(segment_count + segs);

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

1957 int last_dev = sbi->s_ndevs - 1;
1958 int dev_segs =
1959 le32_to_cpu(raw_sb->devs[last_dev].total_segments);
1960
1961 raw_sb->devs[last_dev].total_segments =
1962 cpu_to_le32(dev_segs + segs);
1963 }
1964
1960 up_write(&sbi->sb_lock);
1965 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 */
1966}
1967
1968static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
1969{
1970 int segs = secs * sbi->segs_per_sec;
1971 long long blks = (long long)segs * sbi->blocks_per_seg;
1972 long long user_block_count =
1973 le64_to_cpu(F2FS_CKPT(sbi)->user_block_count);

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

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

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

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