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

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

382
383 list_for_each_entry_safe(cur, tmp, &fi->inmem_pages, list) {
384 struct page *page = cur->page;
385
386 lock_page(page);
387 if (page->mapping == inode->i_mapping) {
388 trace_f2fs_commit_inmem_page(page, INMEM);
389
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/segment.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

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

382
383 list_for_each_entry_safe(cur, tmp, &fi->inmem_pages, list) {
384 struct page *page = cur->page;
385
386 lock_page(page);
387 if (page->mapping == inode->i_mapping) {
388 trace_f2fs_commit_inmem_page(page, INMEM);
389
390 set_page_dirty(page);
391 f2fs_wait_on_page_writeback(page, DATA, true);
390 f2fs_wait_on_page_writeback(page, DATA, true);
391
392 set_page_dirty(page);
392 if (clear_page_dirty_for_io(page)) {
393 inode_dec_dirty_pages(inode);
394 f2fs_remove_dirty_inode(inode);
395 }
396retry:
397 fio.page = page;
398 fio.old_blkaddr = NULL_ADDR;
399 fio.encrypted_page = NULL;

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

615 struct flush_cmd_control *fcc = SM_I(sbi)->fcc_info;
616 struct flush_cmd cmd;
617 int ret;
618
619 if (test_opt(sbi, NOBARRIER))
620 return 0;
621
622 if (!test_opt(sbi, FLUSH_MERGE)) {
393 if (clear_page_dirty_for_io(page)) {
394 inode_dec_dirty_pages(inode);
395 f2fs_remove_dirty_inode(inode);
396 }
397retry:
398 fio.page = page;
399 fio.old_blkaddr = NULL_ADDR;
400 fio.encrypted_page = NULL;

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

616 struct flush_cmd_control *fcc = SM_I(sbi)->fcc_info;
617 struct flush_cmd cmd;
618 int ret;
619
620 if (test_opt(sbi, NOBARRIER))
621 return 0;
622
623 if (!test_opt(sbi, FLUSH_MERGE)) {
624 atomic_inc(&fcc->issing_flush);
623 ret = submit_flush_wait(sbi, ino);
625 ret = submit_flush_wait(sbi, ino);
626 atomic_dec(&fcc->issing_flush);
624 atomic_inc(&fcc->issued_flush);
625 return ret;
626 }
627
628 if (atomic_inc_return(&fcc->issing_flush) == 1 || sbi->s_ndevs > 1) {
629 ret = submit_flush_wait(sbi, ino);
630 atomic_dec(&fcc->issing_flush);
631

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

698 if (!test_opt(sbi, FLUSH_MERGE))
699 return err;
700
701init_thread:
702 fcc->f2fs_issue_flush = kthread_run(issue_flush_thread, sbi,
703 "f2fs_flush-%u:%u", MAJOR(dev), MINOR(dev));
704 if (IS_ERR(fcc->f2fs_issue_flush)) {
705 err = PTR_ERR(fcc->f2fs_issue_flush);
627 atomic_inc(&fcc->issued_flush);
628 return ret;
629 }
630
631 if (atomic_inc_return(&fcc->issing_flush) == 1 || sbi->s_ndevs > 1) {
632 ret = submit_flush_wait(sbi, ino);
633 atomic_dec(&fcc->issing_flush);
634

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

701 if (!test_opt(sbi, FLUSH_MERGE))
702 return err;
703
704init_thread:
705 fcc->f2fs_issue_flush = kthread_run(issue_flush_thread, sbi,
706 "f2fs_flush-%u:%u", MAJOR(dev), MINOR(dev));
707 if (IS_ERR(fcc->f2fs_issue_flush)) {
708 err = PTR_ERR(fcc->f2fs_issue_flush);
706 kfree(fcc);
709 kvfree(fcc);
707 SM_I(sbi)->fcc_info = NULL;
708 return err;
709 }
710
711 return err;
712}
713
714void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free)
715{
716 struct flush_cmd_control *fcc = SM_I(sbi)->fcc_info;
717
718 if (fcc && fcc->f2fs_issue_flush) {
719 struct task_struct *flush_thread = fcc->f2fs_issue_flush;
720
721 fcc->f2fs_issue_flush = NULL;
722 kthread_stop(flush_thread);
723 }
724 if (free) {
710 SM_I(sbi)->fcc_info = NULL;
711 return err;
712 }
713
714 return err;
715}
716
717void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free)
718{
719 struct flush_cmd_control *fcc = SM_I(sbi)->fcc_info;
720
721 if (fcc && fcc->f2fs_issue_flush) {
722 struct task_struct *flush_thread = fcc->f2fs_issue_flush;
723
724 fcc->f2fs_issue_flush = NULL;
725 kthread_stop(flush_thread);
726 }
727 if (free) {
725 kfree(fcc);
728 kvfree(fcc);
726 SM_I(sbi)->fcc_info = NULL;
727 }
728}
729
730int f2fs_flush_device_cache(struct f2fs_sb_info *sbi)
731{
732 int ret = 0, i;
733

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

1729 }
1730}
1731#endif
1732
1733static int __issue_discard_async(struct f2fs_sb_info *sbi,
1734 struct block_device *bdev, block_t blkstart, block_t blklen)
1735{
1736#ifdef CONFIG_BLK_DEV_ZONED
729 SM_I(sbi)->fcc_info = NULL;
730 }
731}
732
733int f2fs_flush_device_cache(struct f2fs_sb_info *sbi)
734{
735 int ret = 0, i;
736

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

1732 }
1733}
1734#endif
1735
1736static int __issue_discard_async(struct f2fs_sb_info *sbi,
1737 struct block_device *bdev, block_t blkstart, block_t blklen)
1738{
1739#ifdef CONFIG_BLK_DEV_ZONED
1737 if (f2fs_sb_has_blkzoned(sbi->sb) &&
1740 if (f2fs_sb_has_blkzoned(sbi) &&
1738 bdev_zoned_model(bdev) != BLK_ZONED_NONE)
1739 return __f2fs_issue_discard_zone(sbi, bdev, blkstart, blklen);
1740#endif
1741 return __queue_discard_cmd(sbi, bdev, blkstart, blklen);
1742}
1743
1744static int f2fs_issue_discard(struct f2fs_sb_info *sbi,
1745 block_t blkstart, block_t blklen)

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

1877 struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
1878 struct list_head *head = &dcc->entry_list;
1879 struct discard_entry *entry, *this;
1880 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
1881 unsigned long *prefree_map = dirty_i->dirty_segmap[PRE];
1882 unsigned int start = 0, end = -1;
1883 unsigned int secno, start_segno;
1884 bool force = (cpc->reason & CP_DISCARD);
1741 bdev_zoned_model(bdev) != BLK_ZONED_NONE)
1742 return __f2fs_issue_discard_zone(sbi, bdev, blkstart, blklen);
1743#endif
1744 return __queue_discard_cmd(sbi, bdev, blkstart, blklen);
1745}
1746
1747static int f2fs_issue_discard(struct f2fs_sb_info *sbi,
1748 block_t blkstart, block_t blklen)

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

1880 struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
1881 struct list_head *head = &dcc->entry_list;
1882 struct discard_entry *entry, *this;
1883 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
1884 unsigned long *prefree_map = dirty_i->dirty_segmap[PRE];
1885 unsigned int start = 0, end = -1;
1886 unsigned int secno, start_segno;
1887 bool force = (cpc->reason & CP_DISCARD);
1885 bool need_align = test_opt(sbi, LFS) && sbi->segs_per_sec > 1;
1888 bool need_align = test_opt(sbi, LFS) && __is_large_section(sbi);
1886
1887 mutex_lock(&dirty_i->seglist_lock);
1888
1889 while (1) {
1890 int i;
1891
1892 if (need_align && end != -1)
1893 end--;

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

1909
1910 if (!f2fs_realtime_discard_enable(sbi))
1911 continue;
1912
1913 if (force && start >= cpc->trim_start &&
1914 (end - 1) <= cpc->trim_end)
1915 continue;
1916
1889
1890 mutex_lock(&dirty_i->seglist_lock);
1891
1892 while (1) {
1893 int i;
1894
1895 if (need_align && end != -1)
1896 end--;

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

1912
1913 if (!f2fs_realtime_discard_enable(sbi))
1914 continue;
1915
1916 if (force && start >= cpc->trim_start &&
1917 (end - 1) <= cpc->trim_end)
1918 continue;
1919
1917 if (!test_opt(sbi, LFS) || sbi->segs_per_sec == 1) {
1920 if (!test_opt(sbi, LFS) || !__is_large_section(sbi)) {
1918 f2fs_issue_discard(sbi, START_BLOCK(sbi, start),
1919 (end - start) << sbi->log_blocks_per_seg);
1920 continue;
1921 }
1922next:
1923 secno = GET_SEC_FROM_SEG(sbi, start);
1924 start_segno = GET_SEG_FROM_SEC(sbi, secno);
1925 if (!IS_CURSEC(sbi, secno) &&

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

1941 bool is_valid = test_bit_le(0, entry->discard_map);
1942
1943find_next:
1944 if (is_valid) {
1945 next_pos = find_next_zero_bit_le(entry->discard_map,
1946 sbi->blocks_per_seg, cur_pos);
1947 len = next_pos - cur_pos;
1948
1921 f2fs_issue_discard(sbi, START_BLOCK(sbi, start),
1922 (end - start) << sbi->log_blocks_per_seg);
1923 continue;
1924 }
1925next:
1926 secno = GET_SEC_FROM_SEG(sbi, start);
1927 start_segno = GET_SEG_FROM_SEC(sbi, secno);
1928 if (!IS_CURSEC(sbi, secno) &&

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

1944 bool is_valid = test_bit_le(0, entry->discard_map);
1945
1946find_next:
1947 if (is_valid) {
1948 next_pos = find_next_zero_bit_le(entry->discard_map,
1949 sbi->blocks_per_seg, cur_pos);
1950 len = next_pos - cur_pos;
1951
1949 if (f2fs_sb_has_blkzoned(sbi->sb) ||
1952 if (f2fs_sb_has_blkzoned(sbi) ||
1950 (force && len < cpc->trim_minlen))
1951 goto skip;
1952
1953 f2fs_issue_discard(sbi, entry->start_blkaddr + cur_pos,
1954 len);
1955 total_len += len;
1956 } else {
1957 next_pos = find_next_bit_le(entry->discard_map,

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

2005
2006 init_waitqueue_head(&dcc->discard_wait_queue);
2007 SM_I(sbi)->dcc_info = dcc;
2008init_thread:
2009 dcc->f2fs_issue_discard = kthread_run(issue_discard_thread, sbi,
2010 "f2fs_discard-%u:%u", MAJOR(dev), MINOR(dev));
2011 if (IS_ERR(dcc->f2fs_issue_discard)) {
2012 err = PTR_ERR(dcc->f2fs_issue_discard);
1953 (force && len < cpc->trim_minlen))
1954 goto skip;
1955
1956 f2fs_issue_discard(sbi, entry->start_blkaddr + cur_pos,
1957 len);
1958 total_len += len;
1959 } else {
1960 next_pos = find_next_bit_le(entry->discard_map,

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

2008
2009 init_waitqueue_head(&dcc->discard_wait_queue);
2010 SM_I(sbi)->dcc_info = dcc;
2011init_thread:
2012 dcc->f2fs_issue_discard = kthread_run(issue_discard_thread, sbi,
2013 "f2fs_discard-%u:%u", MAJOR(dev), MINOR(dev));
2014 if (IS_ERR(dcc->f2fs_issue_discard)) {
2015 err = PTR_ERR(dcc->f2fs_issue_discard);
2013 kfree(dcc);
2016 kvfree(dcc);
2014 SM_I(sbi)->dcc_info = NULL;
2015 return err;
2016 }
2017
2018 return err;
2019}
2020
2021static void destroy_discard_cmd_control(struct f2fs_sb_info *sbi)
2022{
2023 struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
2024
2025 if (!dcc)
2026 return;
2027
2028 f2fs_stop_discard_thread(sbi);
2029
2017 SM_I(sbi)->dcc_info = NULL;
2018 return err;
2019 }
2020
2021 return err;
2022}
2023
2024static void destroy_discard_cmd_control(struct f2fs_sb_info *sbi)
2025{
2026 struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
2027
2028 if (!dcc)
2029 return;
2030
2031 f2fs_stop_discard_thread(sbi);
2032
2030 kfree(dcc);
2033 kvfree(dcc);
2031 SM_I(sbi)->dcc_info = NULL;
2032}
2033
2034static bool __mark_sit_entry_dirty(struct f2fs_sb_info *sbi, unsigned int segno)
2035{
2036 struct sit_info *sit_i = SIT_I(sbi);
2037
2038 if (!__test_and_set_bit(segno, sit_i->dirty_sentries_bitmap)) {

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

2141 if (!f2fs_test_bit(offset, se->ckpt_valid_map))
2142 se->ckpt_valid_blocks += del;
2143
2144 __mark_sit_entry_dirty(sbi, segno);
2145
2146 /* update total number of valid blocks to be written in ckpt area */
2147 SIT_I(sbi)->written_valid_blocks += del;
2148
2034 SM_I(sbi)->dcc_info = NULL;
2035}
2036
2037static bool __mark_sit_entry_dirty(struct f2fs_sb_info *sbi, unsigned int segno)
2038{
2039 struct sit_info *sit_i = SIT_I(sbi);
2040
2041 if (!__test_and_set_bit(segno, sit_i->dirty_sentries_bitmap)) {

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

2144 if (!f2fs_test_bit(offset, se->ckpt_valid_map))
2145 se->ckpt_valid_blocks += del;
2146
2147 __mark_sit_entry_dirty(sbi, segno);
2148
2149 /* update total number of valid blocks to be written in ckpt area */
2150 SIT_I(sbi)->written_valid_blocks += del;
2151
2149 if (sbi->segs_per_sec > 1)
2152 if (__is_large_section(sbi))
2150 get_sec_entry(sbi, segno)->valid_blocks += del;
2151}
2152
2153void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr)
2154{
2155 unsigned int segno = GET_SEGNO(sbi, addr);
2156 struct sit_info *sit_i = SIT_I(sbi);
2157

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

2407 if (IS_NODESEG(type))
2408 SET_SUM_TYPE(sum_footer, SUM_TYPE_NODE);
2409 __set_sit_entry_type(sbi, type, curseg->segno, modified);
2410}
2411
2412static unsigned int __get_next_segno(struct f2fs_sb_info *sbi, int type)
2413{
2414 /* if segs_per_sec is large than 1, we need to keep original policy. */
2153 get_sec_entry(sbi, segno)->valid_blocks += del;
2154}
2155
2156void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr)
2157{
2158 unsigned int segno = GET_SEGNO(sbi, addr);
2159 struct sit_info *sit_i = SIT_I(sbi);
2160

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

2410 if (IS_NODESEG(type))
2411 SET_SUM_TYPE(sum_footer, SUM_TYPE_NODE);
2412 __set_sit_entry_type(sbi, type, curseg->segno, modified);
2413}
2414
2415static unsigned int __get_next_segno(struct f2fs_sb_info *sbi, int type)
2416{
2417 /* if segs_per_sec is large than 1, we need to keep original policy. */
2415 if (sbi->segs_per_sec != 1)
2418 if (__is_large_section(sbi))
2416 return CURSEG_I(sbi, type)->segno;
2417
2418 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
2419 return 0;
2420
2421 if (test_opt(sbi, NOHEAP) &&
2422 (type == CURSEG_HOT_DATA || IS_NODESEG(type)))
2423 return 0;

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

2717 __u64 start = F2FS_BYTES_TO_BLK(range->start);
2718 __u64 end = start + F2FS_BYTES_TO_BLK(range->len) - 1;
2719 unsigned int start_segno, end_segno;
2720 block_t start_block, end_block;
2721 struct cp_control cpc;
2722 struct discard_policy dpolicy;
2723 unsigned long long trimmed = 0;
2724 int err = 0;
2419 return CURSEG_I(sbi, type)->segno;
2420
2421 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
2422 return 0;
2423
2424 if (test_opt(sbi, NOHEAP) &&
2425 (type == CURSEG_HOT_DATA || IS_NODESEG(type)))
2426 return 0;

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

2720 __u64 start = F2FS_BYTES_TO_BLK(range->start);
2721 __u64 end = start + F2FS_BYTES_TO_BLK(range->len) - 1;
2722 unsigned int start_segno, end_segno;
2723 block_t start_block, end_block;
2724 struct cp_control cpc;
2725 struct discard_policy dpolicy;
2726 unsigned long long trimmed = 0;
2727 int err = 0;
2725 bool need_align = test_opt(sbi, LFS) && sbi->segs_per_sec > 1;
2728 bool need_align = test_opt(sbi, LFS) && __is_large_section(sbi);
2726
2727 if (start >= MAX_BLKADDR(sbi) || range->len < sbi->blocksize)
2728 return -EINVAL;
2729
2730 if (end < MAIN_BLKADDR(sbi))
2731 goto out;
2732
2733 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK)) {

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

3875 if (!sit_i->sentries[start].discard_map)
3876 return -ENOMEM;
3877 }
3878
3879 sit_i->tmp_map = f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
3880 if (!sit_i->tmp_map)
3881 return -ENOMEM;
3882
2729
2730 if (start >= MAX_BLKADDR(sbi) || range->len < sbi->blocksize)
2731 return -EINVAL;
2732
2733 if (end < MAIN_BLKADDR(sbi))
2734 goto out;
2735
2736 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK)) {

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

3878 if (!sit_i->sentries[start].discard_map)
3879 return -ENOMEM;
3880 }
3881
3882 sit_i->tmp_map = f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
3883 if (!sit_i->tmp_map)
3884 return -ENOMEM;
3885
3883 if (sbi->segs_per_sec > 1) {
3886 if (__is_large_section(sbi)) {
3884 sit_i->sec_entries =
3885 f2fs_kvzalloc(sbi, array_size(sizeof(struct sec_entry),
3886 MAIN_SECS(sbi)),
3887 GFP_KERNEL);
3888 if (!sit_i->sec_entries)
3889 return -ENOMEM;
3890 }
3891

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

4030 memcpy(se->discard_map,
4031 se->cur_valid_map,
4032 SIT_VBLOCK_MAP_SIZE);
4033 sbi->discard_blks +=
4034 sbi->blocks_per_seg -
4035 se->valid_blocks;
4036 }
4037
3887 sit_i->sec_entries =
3888 f2fs_kvzalloc(sbi, array_size(sizeof(struct sec_entry),
3889 MAIN_SECS(sbi)),
3890 GFP_KERNEL);
3891 if (!sit_i->sec_entries)
3892 return -ENOMEM;
3893 }
3894

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

4033 memcpy(se->discard_map,
4034 se->cur_valid_map,
4035 SIT_VBLOCK_MAP_SIZE);
4036 sbi->discard_blks +=
4037 sbi->blocks_per_seg -
4038 se->valid_blocks;
4039 }
4040
4038 if (sbi->segs_per_sec > 1)
4041 if (__is_large_section(sbi))
4039 get_sec_entry(sbi, start)->valid_blocks +=
4040 se->valid_blocks;
4041 }
4042 start_blk += readed;
4043 } while (start_blk < sit_blk_cnt);
4044
4045 down_read(&curseg->journal_rwsem);
4046 for (i = 0; i < sits_in_cursum(journal); i++) {

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

4074 memset(se->discard_map, 0xff, SIT_VBLOCK_MAP_SIZE);
4075 } else {
4076 memcpy(se->discard_map, se->cur_valid_map,
4077 SIT_VBLOCK_MAP_SIZE);
4078 sbi->discard_blks += old_valid_blocks;
4079 sbi->discard_blks -= se->valid_blocks;
4080 }
4081
4042 get_sec_entry(sbi, start)->valid_blocks +=
4043 se->valid_blocks;
4044 }
4045 start_blk += readed;
4046 } while (start_blk < sit_blk_cnt);
4047
4048 down_read(&curseg->journal_rwsem);
4049 for (i = 0; i < sits_in_cursum(journal); i++) {

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

4077 memset(se->discard_map, 0xff, SIT_VBLOCK_MAP_SIZE);
4078 } else {
4079 memcpy(se->discard_map, se->cur_valid_map,
4080 SIT_VBLOCK_MAP_SIZE);
4081 sbi->discard_blks += old_valid_blocks;
4082 sbi->discard_blks -= se->valid_blocks;
4083 }
4084
4082 if (sbi->segs_per_sec > 1) {
4085 if (__is_large_section(sbi)) {
4083 get_sec_entry(sbi, start)->valid_blocks +=
4084 se->valid_blocks;
4085 get_sec_entry(sbi, start)->valid_blocks -=
4086 old_valid_blocks;
4087 }
4088 }
4089 up_read(&curseg->journal_rwsem);
4090

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

4309 return;
4310
4311 /* discard pre-free/dirty segments list */
4312 for (i = 0; i < NR_DIRTY_TYPE; i++)
4313 discard_dirty_segmap(sbi, i);
4314
4315 destroy_victim_secmap(sbi);
4316 SM_I(sbi)->dirty_info = NULL;
4086 get_sec_entry(sbi, start)->valid_blocks +=
4087 se->valid_blocks;
4088 get_sec_entry(sbi, start)->valid_blocks -=
4089 old_valid_blocks;
4090 }
4091 }
4092 up_read(&curseg->journal_rwsem);
4093

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

4312 return;
4313
4314 /* discard pre-free/dirty segments list */
4315 for (i = 0; i < NR_DIRTY_TYPE; i++)
4316 discard_dirty_segmap(sbi, i);
4317
4318 destroy_victim_secmap(sbi);
4319 SM_I(sbi)->dirty_info = NULL;
4317 kfree(dirty_i);
4320 kvfree(dirty_i);
4318}
4319
4320static void destroy_curseg(struct f2fs_sb_info *sbi)
4321{
4322 struct curseg_info *array = SM_I(sbi)->curseg_array;
4323 int i;
4324
4325 if (!array)
4326 return;
4327 SM_I(sbi)->curseg_array = NULL;
4328 for (i = 0; i < NR_CURSEG_TYPE; i++) {
4321}
4322
4323static void destroy_curseg(struct f2fs_sb_info *sbi)
4324{
4325 struct curseg_info *array = SM_I(sbi)->curseg_array;
4326 int i;
4327
4328 if (!array)
4329 return;
4330 SM_I(sbi)->curseg_array = NULL;
4331 for (i = 0; i < NR_CURSEG_TYPE; i++) {
4329 kfree(array[i].sum_blk);
4330 kfree(array[i].journal);
4332 kvfree(array[i].sum_blk);
4333 kvfree(array[i].journal);
4331 }
4334 }
4332 kfree(array);
4335 kvfree(array);
4333}
4334
4335static void destroy_free_segmap(struct f2fs_sb_info *sbi)
4336{
4337 struct free_segmap_info *free_i = SM_I(sbi)->free_info;
4338 if (!free_i)
4339 return;
4340 SM_I(sbi)->free_info = NULL;
4341 kvfree(free_i->free_segmap);
4342 kvfree(free_i->free_secmap);
4336}
4337
4338static void destroy_free_segmap(struct f2fs_sb_info *sbi)
4339{
4340 struct free_segmap_info *free_i = SM_I(sbi)->free_info;
4341 if (!free_i)
4342 return;
4343 SM_I(sbi)->free_info = NULL;
4344 kvfree(free_i->free_segmap);
4345 kvfree(free_i->free_secmap);
4343 kfree(free_i);
4346 kvfree(free_i);
4344}
4345
4346static void destroy_sit_info(struct f2fs_sb_info *sbi)
4347{
4348 struct sit_info *sit_i = SIT_I(sbi);
4349 unsigned int start;
4350
4351 if (!sit_i)
4352 return;
4353
4354 if (sit_i->sentries) {
4355 for (start = 0; start < MAIN_SEGS(sbi); start++) {
4347}
4348
4349static void destroy_sit_info(struct f2fs_sb_info *sbi)
4350{
4351 struct sit_info *sit_i = SIT_I(sbi);
4352 unsigned int start;
4353
4354 if (!sit_i)
4355 return;
4356
4357 if (sit_i->sentries) {
4358 for (start = 0; start < MAIN_SEGS(sbi); start++) {
4356 kfree(sit_i->sentries[start].cur_valid_map);
4359 kvfree(sit_i->sentries[start].cur_valid_map);
4357#ifdef CONFIG_F2FS_CHECK_FS
4360#ifdef CONFIG_F2FS_CHECK_FS
4358 kfree(sit_i->sentries[start].cur_valid_map_mir);
4361 kvfree(sit_i->sentries[start].cur_valid_map_mir);
4359#endif
4362#endif
4360 kfree(sit_i->sentries[start].ckpt_valid_map);
4361 kfree(sit_i->sentries[start].discard_map);
4363 kvfree(sit_i->sentries[start].ckpt_valid_map);
4364 kvfree(sit_i->sentries[start].discard_map);
4362 }
4363 }
4365 }
4366 }
4364 kfree(sit_i->tmp_map);
4367 kvfree(sit_i->tmp_map);
4365
4366 kvfree(sit_i->sentries);
4367 kvfree(sit_i->sec_entries);
4368 kvfree(sit_i->dirty_sentries_bitmap);
4369
4370 SM_I(sbi)->sit_info = NULL;
4368
4369 kvfree(sit_i->sentries);
4370 kvfree(sit_i->sec_entries);
4371 kvfree(sit_i->dirty_sentries_bitmap);
4372
4373 SM_I(sbi)->sit_info = NULL;
4371 kfree(sit_i->sit_bitmap);
4374 kvfree(sit_i->sit_bitmap);
4372#ifdef CONFIG_F2FS_CHECK_FS
4375#ifdef CONFIG_F2FS_CHECK_FS
4373 kfree(sit_i->sit_bitmap_mir);
4376 kvfree(sit_i->sit_bitmap_mir);
4374#endif
4377#endif
4375 kfree(sit_i);
4378 kvfree(sit_i);
4376}
4377
4378void f2fs_destroy_segment_manager(struct f2fs_sb_info *sbi)
4379{
4380 struct f2fs_sm_info *sm_info = SM_I(sbi);
4381
4382 if (!sm_info)
4383 return;
4384 f2fs_destroy_flush_cmd_control(sbi, true);
4385 destroy_discard_cmd_control(sbi);
4386 destroy_dirty_segmap(sbi);
4387 destroy_curseg(sbi);
4388 destroy_free_segmap(sbi);
4389 destroy_sit_info(sbi);
4390 sbi->sm_info = NULL;
4379}
4380
4381void f2fs_destroy_segment_manager(struct f2fs_sb_info *sbi)
4382{
4383 struct f2fs_sm_info *sm_info = SM_I(sbi);
4384
4385 if (!sm_info)
4386 return;
4387 f2fs_destroy_flush_cmd_control(sbi, true);
4388 destroy_discard_cmd_control(sbi);
4389 destroy_dirty_segmap(sbi);
4390 destroy_curseg(sbi);
4391 destroy_free_segmap(sbi);
4392 destroy_sit_info(sbi);
4393 sbi->sm_info = NULL;
4391 kfree(sm_info);
4394 kvfree(sm_info);
4392}
4393
4394int __init f2fs_create_segment_manager_caches(void)
4395{
4396 discard_entry_slab = f2fs_kmem_cache_create("discard_entry",
4397 sizeof(struct discard_entry));
4398 if (!discard_entry_slab)
4399 goto fail;

--- 34 unchanged lines hidden --- 		4395}
4396
4397int __init f2fs_create_segment_manager_caches(void)
4398{
4399 discard_entry_slab = f2fs_kmem_cache_create("discard_entry",
4400 sizeof(struct discard_entry));
4401 if (!discard_entry_slab)
4402 goto fail;

--- 34 unchanged lines hidden ---