segment.c (3689f9f8b0c52dfd8f5995e4b58917f8f3ac3ee3) segment.c (e4544b63a7ee49e7fbebf35ece0a6acd3b9617ae)
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>

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

466int f2fs_commit_inmem_pages(struct inode *inode)
467{
468 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
469 struct f2fs_inode_info *fi = F2FS_I(inode);
470 int err;
471
472 f2fs_balance_fs(sbi, true);
473
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>

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

466int f2fs_commit_inmem_pages(struct inode *inode)
467{
468 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
469 struct f2fs_inode_info *fi = F2FS_I(inode);
470 int err;
471
472 f2fs_balance_fs(sbi, true);
473
474 down_write(&fi->i_gc_rwsem[WRITE]);
474 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
475
476 f2fs_lock_op(sbi);
477 set_inode_flag(inode, FI_ATOMIC_COMMIT);
478
479 mutex_lock(&fi->inmem_lock);
480 err = __f2fs_commit_inmem_pages(inode);
481 mutex_unlock(&fi->inmem_lock);
482
483 clear_inode_flag(inode, FI_ATOMIC_COMMIT);
484
485 f2fs_unlock_op(sbi);
475
476 f2fs_lock_op(sbi);
477 set_inode_flag(inode, FI_ATOMIC_COMMIT);
478
479 mutex_lock(&fi->inmem_lock);
480 err = __f2fs_commit_inmem_pages(inode);
481 mutex_unlock(&fi->inmem_lock);
482
483 clear_inode_flag(inode, FI_ATOMIC_COMMIT);
484
485 f2fs_unlock_op(sbi);
486 up_write(&fi->i_gc_rwsem[WRITE]);
486 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
487
488 return err;
489}
490
491/*
492 * This function balances dirty node and dentry pages.
493 * In addition, it controls garbage collection.
494 */

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

516 DEFINE_WAIT(wait);
517
518 prepare_to_wait(&sbi->gc_thread->fggc_wq, &wait,
519 TASK_UNINTERRUPTIBLE);
520 wake_up(&sbi->gc_thread->gc_wait_queue_head);
521 io_schedule();
522 finish_wait(&sbi->gc_thread->fggc_wq, &wait);
523 } else {
487
488 return err;
489}
490
491/*
492 * This function balances dirty node and dentry pages.
493 * In addition, it controls garbage collection.
494 */

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

516 DEFINE_WAIT(wait);
517
518 prepare_to_wait(&sbi->gc_thread->fggc_wq, &wait,
519 TASK_UNINTERRUPTIBLE);
520 wake_up(&sbi->gc_thread->gc_wait_queue_head);
521 io_schedule();
522 finish_wait(&sbi->gc_thread->fggc_wq, &wait);
523 } else {
524 down_write(&sbi->gc_lock);
524 f2fs_down_write(&sbi->gc_lock);
525 f2fs_gc(sbi, false, false, false, NULL_SEGNO);
526 }
527 }
528}
529
530static inline bool excess_dirty_threshold(struct f2fs_sb_info *sbi)
531{
525 f2fs_gc(sbi, false, false, false, NULL_SEGNO);
526 }
527 }
528}
529
530static inline bool excess_dirty_threshold(struct f2fs_sb_info *sbi)
531{
532 int factor = rwsem_is_locked(&sbi->cp_rwsem) ? 3 : 2;
532 int factor = f2fs_rwsem_is_locked(&sbi->cp_rwsem) ? 3 : 2;
533 unsigned int dents = get_pages(sbi, F2FS_DIRTY_DENTS);
534 unsigned int qdata = get_pages(sbi, F2FS_DIRTY_QDATA);
535 unsigned int nodes = get_pages(sbi, F2FS_DIRTY_NODES);
536 unsigned int meta = get_pages(sbi, F2FS_DIRTY_META);
537 unsigned int imeta = get_pages(sbi, F2FS_DIRTY_IMETA);
538 unsigned int threshold = sbi->blocks_per_seg * factor *
539 DEFAULT_DIRTY_THRESHOLD;
540 unsigned int global_threshold = threshold * 3 / 2;

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

565 f2fs_build_free_nids(sbi, false, false);
566
567 if (excess_dirty_nats(sbi) || excess_dirty_threshold(sbi) ||
568 excess_prefree_segs(sbi) || !f2fs_space_for_roll_forward(sbi))
569 goto do_sync;
570
571 /* there is background inflight IO or foreground operation recently */
572 if (is_inflight_io(sbi, REQ_TIME) ||
533 unsigned int dents = get_pages(sbi, F2FS_DIRTY_DENTS);
534 unsigned int qdata = get_pages(sbi, F2FS_DIRTY_QDATA);
535 unsigned int nodes = get_pages(sbi, F2FS_DIRTY_NODES);
536 unsigned int meta = get_pages(sbi, F2FS_DIRTY_META);
537 unsigned int imeta = get_pages(sbi, F2FS_DIRTY_IMETA);
538 unsigned int threshold = sbi->blocks_per_seg * factor *
539 DEFAULT_DIRTY_THRESHOLD;
540 unsigned int global_threshold = threshold * 3 / 2;

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

565 f2fs_build_free_nids(sbi, false, false);
566
567 if (excess_dirty_nats(sbi) || excess_dirty_threshold(sbi) ||
568 excess_prefree_segs(sbi) || !f2fs_space_for_roll_forward(sbi))
569 goto do_sync;
570
571 /* there is background inflight IO or foreground operation recently */
572 if (is_inflight_io(sbi, REQ_TIME) ||
573 (!f2fs_time_over(sbi, REQ_TIME) && rwsem_is_locked(&sbi->cp_rwsem)))
573 (!f2fs_time_over(sbi, REQ_TIME) && f2fs_rwsem_is_locked(&sbi->cp_rwsem)))
574 return;
575
576 /* exceed periodical checkpoint timeout threshold */
577 if (f2fs_time_over(sbi, CP_TIME))
578 goto do_sync;
579
580 /* checkpoint is the only way to shrink partial cached entries */
581 if (f2fs_available_free_memory(sbi, NAT_ENTRIES) &&

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

2816
2817static void __f2fs_init_atgc_curseg(struct f2fs_sb_info *sbi)
2818{
2819 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_ALL_DATA_ATGC);
2820
2821 if (!sbi->am.atgc_enabled)
2822 return;
2823
574 return;
575
576 /* exceed periodical checkpoint timeout threshold */
577 if (f2fs_time_over(sbi, CP_TIME))
578 goto do_sync;
579
580 /* checkpoint is the only way to shrink partial cached entries */
581 if (f2fs_available_free_memory(sbi, NAT_ENTRIES) &&

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

2816
2817static void __f2fs_init_atgc_curseg(struct f2fs_sb_info *sbi)
2818{
2819 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_ALL_DATA_ATGC);
2820
2821 if (!sbi->am.atgc_enabled)
2822 return;
2823
2824 down_read(&SM_I(sbi)->curseg_lock);
2824 f2fs_down_read(&SM_I(sbi)->curseg_lock);
2825
2826 mutex_lock(&curseg->curseg_mutex);
2827 down_write(&SIT_I(sbi)->sentry_lock);
2828
2829 get_atssr_segment(sbi, CURSEG_ALL_DATA_ATGC, CURSEG_COLD_DATA, SSR, 0);
2830
2831 up_write(&SIT_I(sbi)->sentry_lock);
2832 mutex_unlock(&curseg->curseg_mutex);
2833
2825
2826 mutex_lock(&curseg->curseg_mutex);
2827 down_write(&SIT_I(sbi)->sentry_lock);
2828
2829 get_atssr_segment(sbi, CURSEG_ALL_DATA_ATGC, CURSEG_COLD_DATA, SSR, 0);
2830
2831 up_write(&SIT_I(sbi)->sentry_lock);
2832 mutex_unlock(&curseg->curseg_mutex);
2833
2834 up_read(&SM_I(sbi)->curseg_lock);
2834 f2fs_up_read(&SM_I(sbi)->curseg_lock);
2835
2836}
2837void f2fs_init_inmem_curseg(struct f2fs_sb_info *sbi)
2838{
2839 __f2fs_init_atgc_curseg(sbi);
2840}
2841
2842static void __f2fs_save_inmem_curseg(struct f2fs_sb_info *sbi, int type)

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

2977}
2978
2979void f2fs_allocate_segment_for_resize(struct f2fs_sb_info *sbi, int type,
2980 unsigned int start, unsigned int end)
2981{
2982 struct curseg_info *curseg = CURSEG_I(sbi, type);
2983 unsigned int segno;
2984
2835
2836}
2837void f2fs_init_inmem_curseg(struct f2fs_sb_info *sbi)
2838{
2839 __f2fs_init_atgc_curseg(sbi);
2840}
2841
2842static void __f2fs_save_inmem_curseg(struct f2fs_sb_info *sbi, int type)

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

2977}
2978
2979void f2fs_allocate_segment_for_resize(struct f2fs_sb_info *sbi, int type,
2980 unsigned int start, unsigned int end)
2981{
2982 struct curseg_info *curseg = CURSEG_I(sbi, type);
2983 unsigned int segno;
2984
2985 down_read(&SM_I(sbi)->curseg_lock);
2985 f2fs_down_read(&SM_I(sbi)->curseg_lock);
2986 mutex_lock(&curseg->curseg_mutex);
2987 down_write(&SIT_I(sbi)->sentry_lock);
2988
2989 segno = CURSEG_I(sbi, type)->segno;
2990 if (segno < start || segno > end)
2991 goto unlock;
2992
2993 if (f2fs_need_SSR(sbi) && get_ssr_segment(sbi, type, SSR, 0))

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

3001unlock:
3002 up_write(&SIT_I(sbi)->sentry_lock);
3003
3004 if (segno != curseg->segno)
3005 f2fs_notice(sbi, "For resize: curseg of type %d: %u ==> %u",
3006 type, segno, curseg->segno);
3007
3008 mutex_unlock(&curseg->curseg_mutex);
2986 mutex_lock(&curseg->curseg_mutex);
2987 down_write(&SIT_I(sbi)->sentry_lock);
2988
2989 segno = CURSEG_I(sbi, type)->segno;
2990 if (segno < start || segno > end)
2991 goto unlock;
2992
2993 if (f2fs_need_SSR(sbi) && get_ssr_segment(sbi, type, SSR, 0))

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

3001unlock:
3002 up_write(&SIT_I(sbi)->sentry_lock);
3003
3004 if (segno != curseg->segno)
3005 f2fs_notice(sbi, "For resize: curseg of type %d: %u ==> %u",
3006 type, segno, curseg->segno);
3007
3008 mutex_unlock(&curseg->curseg_mutex);
3009 up_read(&SM_I(sbi)->curseg_lock);
3009 f2fs_up_read(&SM_I(sbi)->curseg_lock);
3010}
3011
3012static void __allocate_new_segment(struct f2fs_sb_info *sbi, int type,
3013 bool new_sec, bool force)
3014{
3015 struct curseg_info *curseg = CURSEG_I(sbi, type);
3016 unsigned int old_segno;
3017

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

3033static void __allocate_new_section(struct f2fs_sb_info *sbi,
3034 int type, bool force)
3035{
3036 __allocate_new_segment(sbi, type, true, force);
3037}
3038
3039void f2fs_allocate_new_section(struct f2fs_sb_info *sbi, int type, bool force)
3040{
3010}
3011
3012static void __allocate_new_segment(struct f2fs_sb_info *sbi, int type,
3013 bool new_sec, bool force)
3014{
3015 struct curseg_info *curseg = CURSEG_I(sbi, type);
3016 unsigned int old_segno;
3017

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

3033static void __allocate_new_section(struct f2fs_sb_info *sbi,
3034 int type, bool force)
3035{
3036 __allocate_new_segment(sbi, type, true, force);
3037}
3038
3039void f2fs_allocate_new_section(struct f2fs_sb_info *sbi, int type, bool force)
3040{
3041 down_read(&SM_I(sbi)->curseg_lock);
3041 f2fs_down_read(&SM_I(sbi)->curseg_lock);
3042 down_write(&SIT_I(sbi)->sentry_lock);
3043 __allocate_new_section(sbi, type, force);
3044 up_write(&SIT_I(sbi)->sentry_lock);
3042 down_write(&SIT_I(sbi)->sentry_lock);
3043 __allocate_new_section(sbi, type, force);
3044 up_write(&SIT_I(sbi)->sentry_lock);
3045 up_read(&SM_I(sbi)->curseg_lock);
3045 f2fs_up_read(&SM_I(sbi)->curseg_lock);
3046}
3047
3048void f2fs_allocate_new_segments(struct f2fs_sb_info *sbi)
3049{
3050 int i;
3051
3046}
3047
3048void f2fs_allocate_new_segments(struct f2fs_sb_info *sbi)
3049{
3050 int i;
3051
3052 down_read(&SM_I(sbi)->curseg_lock);
3052 f2fs_down_read(&SM_I(sbi)->curseg_lock);
3053 down_write(&SIT_I(sbi)->sentry_lock);
3054 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++)
3055 __allocate_new_segment(sbi, i, false, false);
3056 up_write(&SIT_I(sbi)->sentry_lock);
3053 down_write(&SIT_I(sbi)->sentry_lock);
3054 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++)
3055 __allocate_new_segment(sbi, i, false, false);
3056 up_write(&SIT_I(sbi)->sentry_lock);
3057 up_read(&SM_I(sbi)->curseg_lock);
3057 f2fs_up_read(&SM_I(sbi)->curseg_lock);
3058}
3059
3060static const struct segment_allocation default_salloc_ops = {
3061 .allocate_segment = allocate_segment_by_default,
3062};
3063
3064bool f2fs_exist_trim_candidates(struct f2fs_sb_info *sbi,
3065 struct cp_control *cpc)

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

3187 cpc.reason = CP_DISCARD;
3188 cpc.trim_minlen = max_t(__u64, 1, F2FS_BYTES_TO_BLK(range->minlen));
3189 cpc.trim_start = start_segno;
3190 cpc.trim_end = end_segno;
3191
3192 if (sbi->discard_blks == 0)
3193 goto out;
3194
3058}
3059
3060static const struct segment_allocation default_salloc_ops = {
3061 .allocate_segment = allocate_segment_by_default,
3062};
3063
3064bool f2fs_exist_trim_candidates(struct f2fs_sb_info *sbi,
3065 struct cp_control *cpc)

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

3187 cpc.reason = CP_DISCARD;
3188 cpc.trim_minlen = max_t(__u64, 1, F2FS_BYTES_TO_BLK(range->minlen));
3189 cpc.trim_start = start_segno;
3190 cpc.trim_end = end_segno;
3191
3192 if (sbi->discard_blks == 0)
3193 goto out;
3194
3195 down_write(&sbi->gc_lock);
3195 f2fs_down_write(&sbi->gc_lock);
3196 err = f2fs_write_checkpoint(sbi, &cpc);
3196 err = f2fs_write_checkpoint(sbi, &cpc);
3197 up_write(&sbi->gc_lock);
3197 f2fs_up_write(&sbi->gc_lock);
3198 if (err)
3199 goto out;
3200
3201 /*
3202 * We filed discard candidates, but actually we don't need to wait for
3203 * all of them, since they'll be issued in idle time along with runtime
3204 * discard option. User configuration looks like using runtime discard
3205 * or periodic fstrim instead of it.

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

3426 struct f2fs_io_info *fio)
3427{
3428 struct sit_info *sit_i = SIT_I(sbi);
3429 struct curseg_info *curseg = CURSEG_I(sbi, type);
3430 unsigned long long old_mtime;
3431 bool from_gc = (type == CURSEG_ALL_DATA_ATGC);
3432 struct seg_entry *se = NULL;
3433
3198 if (err)
3199 goto out;
3200
3201 /*
3202 * We filed discard candidates, but actually we don't need to wait for
3203 * all of them, since they'll be issued in idle time along with runtime
3204 * discard option. User configuration looks like using runtime discard
3205 * or periodic fstrim instead of it.

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

3426 struct f2fs_io_info *fio)
3427{
3428 struct sit_info *sit_i = SIT_I(sbi);
3429 struct curseg_info *curseg = CURSEG_I(sbi, type);
3430 unsigned long long old_mtime;
3431 bool from_gc = (type == CURSEG_ALL_DATA_ATGC);
3432 struct seg_entry *se = NULL;
3433
3434 down_read(&SM_I(sbi)->curseg_lock);
3434 f2fs_down_read(&SM_I(sbi)->curseg_lock);
3435
3436 mutex_lock(&curseg->curseg_mutex);
3437 down_write(&sit_i->sentry_lock);
3438
3439 if (from_gc) {
3440 f2fs_bug_on(sbi, GET_SEGNO(sbi, old_blkaddr) == NULL_SEGNO);
3441 se = get_seg_entry(sbi, GET_SEGNO(sbi, old_blkaddr));
3442 sanity_check_seg_type(sbi, se->type);

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

3509 io = sbi->write_io[fio->type] + fio->temp;
3510 spin_lock(&io->io_lock);
3511 list_add_tail(&fio->list, &io->io_list);
3512 spin_unlock(&io->io_lock);
3513 }
3514
3515 mutex_unlock(&curseg->curseg_mutex);
3516
3435
3436 mutex_lock(&curseg->curseg_mutex);
3437 down_write(&sit_i->sentry_lock);
3438
3439 if (from_gc) {
3440 f2fs_bug_on(sbi, GET_SEGNO(sbi, old_blkaddr) == NULL_SEGNO);
3441 se = get_seg_entry(sbi, GET_SEGNO(sbi, old_blkaddr));
3442 sanity_check_seg_type(sbi, se->type);

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

3509 io = sbi->write_io[fio->type] + fio->temp;
3510 spin_lock(&io->io_lock);
3511 list_add_tail(&fio->list, &io->io_list);
3512 spin_unlock(&io->io_lock);
3513 }
3514
3515 mutex_unlock(&curseg->curseg_mutex);
3516
3517 up_read(&SM_I(sbi)->curseg_lock);
3517 f2fs_up_read(&SM_I(sbi)->curseg_lock);
3518}
3519
3520void f2fs_update_device_state(struct f2fs_sb_info *sbi, nid_t ino,
3521 block_t blkaddr, unsigned int blkcnt)
3522{
3523 if (!f2fs_is_multi_device(sbi))
3524 return;
3525

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

3545}
3546
3547static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
3548{
3549 int type = __get_segment_type(fio);
3550 bool keep_order = (f2fs_lfs_mode(fio->sbi) && type == CURSEG_COLD_DATA);
3551
3552 if (keep_order)
3518}
3519
3520void f2fs_update_device_state(struct f2fs_sb_info *sbi, nid_t ino,
3521 block_t blkaddr, unsigned int blkcnt)
3522{
3523 if (!f2fs_is_multi_device(sbi))
3524 return;
3525

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

3545}
3546
3547static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
3548{
3549 int type = __get_segment_type(fio);
3550 bool keep_order = (f2fs_lfs_mode(fio->sbi) && type == CURSEG_COLD_DATA);
3551
3552 if (keep_order)
3553 down_read(&fio->sbi->io_order_lock);
3553 f2fs_down_read(&fio->sbi->io_order_lock);
3554reallocate:
3555 f2fs_allocate_data_block(fio->sbi, fio->page, fio->old_blkaddr,
3556 &fio->new_blkaddr, sum, type, fio);
3557 if (GET_SEGNO(fio->sbi, fio->old_blkaddr) != NULL_SEGNO) {
3558 invalidate_mapping_pages(META_MAPPING(fio->sbi),
3559 fio->old_blkaddr, fio->old_blkaddr);
3560 f2fs_invalidate_compress_page(fio->sbi, fio->old_blkaddr);
3561 }
3562
3563 /* writeout dirty page into bdev */
3564 f2fs_submit_page_write(fio);
3565 if (fio->retry) {
3566 fio->old_blkaddr = fio->new_blkaddr;
3567 goto reallocate;
3568 }
3569
3570 f2fs_update_device_state(fio->sbi, fio->ino, fio->new_blkaddr, 1);
3571
3572 if (keep_order)
3554reallocate:
3555 f2fs_allocate_data_block(fio->sbi, fio->page, fio->old_blkaddr,
3556 &fio->new_blkaddr, sum, type, fio);
3557 if (GET_SEGNO(fio->sbi, fio->old_blkaddr) != NULL_SEGNO) {
3558 invalidate_mapping_pages(META_MAPPING(fio->sbi),
3559 fio->old_blkaddr, fio->old_blkaddr);
3560 f2fs_invalidate_compress_page(fio->sbi, fio->old_blkaddr);
3561 }
3562
3563 /* writeout dirty page into bdev */
3564 f2fs_submit_page_write(fio);
3565 if (fio->retry) {
3566 fio->old_blkaddr = fio->new_blkaddr;
3567 goto reallocate;
3568 }
3569
3570 f2fs_update_device_state(fio->sbi, fio->ino, fio->new_blkaddr, 1);
3571
3572 if (keep_order)
3573 up_read(&fio->sbi->io_order_lock);
3573 f2fs_up_read(&fio->sbi->io_order_lock);
3574}
3575
3576void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct page *page,
3577 enum iostat_type io_type)
3578{
3579 struct f2fs_io_info fio = {
3580 .sbi = sbi,
3581 .type = META,

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

3700 int type;
3701 unsigned short old_blkoff;
3702 unsigned char old_alloc_type;
3703
3704 segno = GET_SEGNO(sbi, new_blkaddr);
3705 se = get_seg_entry(sbi, segno);
3706 type = se->type;
3707
3574}
3575
3576void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct page *page,
3577 enum iostat_type io_type)
3578{
3579 struct f2fs_io_info fio = {
3580 .sbi = sbi,
3581 .type = META,

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

3700 int type;
3701 unsigned short old_blkoff;
3702 unsigned char old_alloc_type;
3703
3704 segno = GET_SEGNO(sbi, new_blkaddr);
3705 se = get_seg_entry(sbi, segno);
3706 type = se->type;
3707
3708 down_write(&SM_I(sbi)->curseg_lock);
3708 f2fs_down_write(&SM_I(sbi)->curseg_lock);
3709
3710 if (!recover_curseg) {
3711 /* for recovery flow */
3712 if (se->valid_blocks == 0 && !IS_CURSEG(sbi, segno)) {
3713 if (old_blkaddr == NULL_ADDR)
3714 type = CURSEG_COLD_DATA;
3715 else
3716 type = CURSEG_WARM_DATA;

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

3769 change_curseg(sbi, type, true);
3770 }
3771 curseg->next_blkoff = old_blkoff;
3772 curseg->alloc_type = old_alloc_type;
3773 }
3774
3775 up_write(&sit_i->sentry_lock);
3776 mutex_unlock(&curseg->curseg_mutex);
3709
3710 if (!recover_curseg) {
3711 /* for recovery flow */
3712 if (se->valid_blocks == 0 && !IS_CURSEG(sbi, segno)) {
3713 if (old_blkaddr == NULL_ADDR)
3714 type = CURSEG_COLD_DATA;
3715 else
3716 type = CURSEG_WARM_DATA;

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

3769 change_curseg(sbi, type, true);
3770 }
3771 curseg->next_blkoff = old_blkoff;
3772 curseg->alloc_type = old_alloc_type;
3773 }
3774
3775 up_write(&sit_i->sentry_lock);
3776 mutex_unlock(&curseg->curseg_mutex);
3777 up_write(&SM_I(sbi)->curseg_lock);
3777 f2fs_up_write(&SM_I(sbi)->curseg_lock);
3778}
3779
3780void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
3781 block_t old_addr, block_t new_addr,
3782 unsigned char version, bool recover_curseg,
3783 bool recover_newaddr)
3784{
3785 struct f2fs_summary sum;

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

5253 sm_info->min_ipu_util = DEF_MIN_IPU_UTIL;
5254 sm_info->min_fsync_blocks = DEF_MIN_FSYNC_BLOCKS;
5255 sm_info->min_seq_blocks = sbi->blocks_per_seg;
5256 sm_info->min_hot_blocks = DEF_MIN_HOT_BLOCKS;
5257 sm_info->min_ssr_sections = reserved_sections(sbi);
5258
5259 INIT_LIST_HEAD(&sm_info->sit_entry_set);
5260
3778}
3779
3780void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
3781 block_t old_addr, block_t new_addr,
3782 unsigned char version, bool recover_curseg,
3783 bool recover_newaddr)
3784{
3785 struct f2fs_summary sum;

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

5253 sm_info->min_ipu_util = DEF_MIN_IPU_UTIL;
5254 sm_info->min_fsync_blocks = DEF_MIN_FSYNC_BLOCKS;
5255 sm_info->min_seq_blocks = sbi->blocks_per_seg;
5256 sm_info->min_hot_blocks = DEF_MIN_HOT_BLOCKS;
5257 sm_info->min_ssr_sections = reserved_sections(sbi);
5258
5259 INIT_LIST_HEAD(&sm_info->sit_entry_set);
5260
5261 init_rwsem(&sm_info->curseg_lock);
5261 init_f2fs_rwsem(&sm_info->curseg_lock);
5262
5263 if (!f2fs_readonly(sbi->sb)) {
5264 err = f2fs_create_flush_cmd_control(sbi);
5265 if (err)
5266 return err;
5267 }
5268
5269 err = create_discard_cmd_control(sbi);

--- 179 unchanged lines hidden --- 		5262
5263 if (!f2fs_readonly(sbi->sb)) {
5264 err = f2fs_create_flush_cmd_control(sbi);
5265 if (err)
5266 return err;
5267 }
5268
5269 err = create_discard_cmd_control(sbi);

--- 179 unchanged lines hidden ---