1 files changed, 234 insertions, 152 deletions

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 5904a411c86f..6f16b39f0b52 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -191,70 +191,145 @@ void register_inmem_page(struct inode *inode, struct page *page)
         trace_f2fs_register_inmem_page(page, INMEM);
 }
 
-int commit_inmem_pages(struct inode *inode, bool abort)
+static int __revoke_inmem_pages(struct inode *inode,
+                                struct list_head *head, bool drop, bool recover)
+{
+        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+        struct inmem_pages *cur, *tmp;
+        int err = 0;
+
+        list_for_each_entry_safe(cur, tmp, head, list) {
+                struct page *page = cur->page;
+
+                if (drop)
+                        trace_f2fs_commit_inmem_page(page, INMEM_DROP);
+
+                lock_page(page);
+
+                if (recover) {
+                        struct dnode_of_data dn;
+                        struct node_info ni;
+
+                        trace_f2fs_commit_inmem_page(page, INMEM_REVOKE);
+
+                        set_new_dnode(&dn, inode, NULL, NULL, 0);
+                        if (get_dnode_of_data(&dn, page->index, LOOKUP_NODE)) {
+                                err = -EAGAIN;
+                                goto next;
+                        }
+                        get_node_info(sbi, dn.nid, &ni);
+                        f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
+                                        cur->old_addr, ni.version, true, true);
+                        f2fs_put_dnode(&dn);
+                }
+next:
+                ClearPageUptodate(page);
+                set_page_private(page, 0);
+                ClearPageUptodate(page);
+                f2fs_put_page(page, 1);
+
+                list_del(&cur->list);
+                kmem_cache_free(inmem_entry_slab, cur);
+                dec_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
+        }
+        return err;
+}
+
+void drop_inmem_pages(struct inode *inode)
+{
+        struct f2fs_inode_info *fi = F2FS_I(inode);
+
+        mutex_lock(&fi->inmem_lock);
+        __revoke_inmem_pages(inode, &fi->inmem_pages, true, false);
+        mutex_unlock(&fi->inmem_lock);
+}
+
+static int __commit_inmem_pages(struct inode *inode,
+                                        struct list_head *revoke_list)
 {
         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
         struct f2fs_inode_info *fi = F2FS_I(inode);
         struct inmem_pages *cur, *tmp;
-        bool submit_bio = false;
         struct f2fs_io_info fio = {
                 .sbi = sbi,
                 .type = DATA,
                 .rw = WRITE_SYNC | REQ_PRIO,
                 .encrypted_page = NULL,
         };
+        bool submit_bio = false;
         int err = 0;
 
-        /*
-         * The abort is true only when f2fs_evict_inode is called.
-         * Basically, the f2fs_evict_inode doesn't produce any data writes, so
-         * that we don't need to call f2fs_balance_fs.
-         * Otherwise, f2fs_gc in f2fs_balance_fs can wait forever until this
-         * inode becomes free by iget_locked in f2fs_iget.
-         */
-        if (!abort) {
-                f2fs_balance_fs(sbi, true);
-                f2fs_lock_op(sbi);
-        }
-
-        mutex_lock(&fi->inmem_lock);
         list_for_each_entry_safe(cur, tmp, &fi->inmem_pages, list) {
-                lock_page(cur->page);
-                if (!abort) {
-                        if (cur->page->mapping == inode->i_mapping) {
-                                set_page_dirty(cur->page);
-                                f2fs_wait_on_page_writeback(cur->page, DATA);
-                                if (clear_page_dirty_for_io(cur->page))
-                                        inode_dec_dirty_pages(inode);
-                                trace_f2fs_commit_inmem_page(cur->page, INMEM);
-                                fio.page = cur->page;
-                                err = do_write_data_page(&fio);
-                                if (err) {
-                                        unlock_page(cur->page);
-                                        break;
-                                }
-                                clear_cold_data(cur->page);
-                                submit_bio = true;
+                struct page *page = cur->page;
+
+                lock_page(page);
+                if (page->mapping == inode->i_mapping) {
+                        trace_f2fs_commit_inmem_page(page, INMEM);
+
+                        set_page_dirty(page);
+                        f2fs_wait_on_page_writeback(page, DATA, true);
+                        if (clear_page_dirty_for_io(page))
+                                inode_dec_dirty_pages(inode);
+
+                        fio.page = page;
+                        err = do_write_data_page(&fio);
+                        if (err) {
+                                unlock_page(page);
+                                break;
                         }
-                } else {
-                        ClearPageUptodate(cur->page);
-                        trace_f2fs_commit_inmem_page(cur->page, INMEM_DROP);
+
+                        /* record old blkaddr for revoking */
+                        cur->old_addr = fio.old_blkaddr;
+
+                        clear_cold_data(page);
+                        submit_bio = true;
                 }
-                set_page_private(cur->page, 0);
-                ClearPagePrivate(cur->page);
-                f2fs_put_page(cur->page, 1);
+                unlock_page(page);
+                list_move_tail(&cur->list, revoke_list);
+        }
 
-                list_del(&cur->list);
-                kmem_cache_free(inmem_entry_slab, cur);
-                dec_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
+        if (submit_bio)
+                f2fs_submit_merged_bio_cond(sbi, inode, NULL, 0, DATA, WRITE);
+
+        if (!err)
+                __revoke_inmem_pages(inode, revoke_list, false, false);
+
+        return err;
+}
+
+int commit_inmem_pages(struct inode *inode)
+{
+        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+        struct f2fs_inode_info *fi = F2FS_I(inode);
+        struct list_head revoke_list;
+        int err;
+
+        INIT_LIST_HEAD(&revoke_list);
+        f2fs_balance_fs(sbi, true);
+        f2fs_lock_op(sbi);
+
+        mutex_lock(&fi->inmem_lock);
+        err = __commit_inmem_pages(inode, &revoke_list);
+        if (err) {
+                int ret;
+                /*
+                 * try to revoke all committed pages, but still we could fail
+                 * due to no memory or other reason, if that happened, EAGAIN
+                 * will be returned, which means in such case, transaction is
+                 * already not integrity, caller should use journal to do the
+                 * recovery or rewrite & commit last transaction. For other
+                 * error number, revoking was done by filesystem itself.
+                 */
+                ret = __revoke_inmem_pages(inode, &revoke_list, false, true);
+                if (ret)
+                        err = ret;
+
+                /* drop all uncommitted pages */
+                __revoke_inmem_pages(inode, &fi->inmem_pages, true, false);
         }
         mutex_unlock(&fi->inmem_lock);
 
-        if (!abort) {
-                f2fs_unlock_op(sbi);
-                if (submit_bio)
-                        f2fs_submit_merged_bio(sbi, DATA, WRITE);
-        }
+        f2fs_unlock_op(sbi);
         return err;
 }
 
@@ -291,11 +366,17 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi)
 
         /* checkpoint is the only way to shrink partial cached entries */
         if (!available_free_memory(sbi, NAT_ENTRIES) ||
-                        excess_prefree_segs(sbi) ||
                         !available_free_memory(sbi, INO_ENTRIES) ||
+                        excess_prefree_segs(sbi) ||
+                        excess_dirty_nats(sbi) ||
                         (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) {
-                if (test_opt(sbi, DATA_FLUSH))
+                if (test_opt(sbi, DATA_FLUSH)) {
+                        struct blk_plug plug;
+
+                        blk_start_plug(&plug);
                         sync_dirty_inodes(sbi, FILE_INODE);
+                        blk_finish_plug(&plug);
+                }
                 f2fs_sync_fs(sbi->sb, true);
                 stat_inc_bg_cp_count(sbi->stat_info);
         }
@@ -502,7 +583,7 @@ static int f2fs_issue_discard(struct f2fs_sb_info *sbi,
 
 bool discard_next_dnode(struct f2fs_sb_info *sbi, block_t blkaddr)
 {
-        int err = -ENOTSUPP;
+        int err = -EOPNOTSUPP;
 
         if (test_opt(sbi, DISCARD)) {
                 struct seg_entry *se = get_seg_entry(sbi,
@@ -841,6 +922,31 @@ static void write_sum_page(struct f2fs_sb_info *sbi,
         update_meta_page(sbi, (void *)sum_blk, blk_addr);
 }
 
+static void write_current_sum_page(struct f2fs_sb_info *sbi,
+                                                int type, block_t blk_addr)
+{
+        struct curseg_info *curseg = CURSEG_I(sbi, type);
+        struct page *page = grab_meta_page(sbi, blk_addr);
+        struct f2fs_summary_block *src = curseg->sum_blk;
+        struct f2fs_summary_block *dst;
+
+        dst = (struct f2fs_summary_block *)page_address(page);
+
+        mutex_lock(&curseg->curseg_mutex);
+
+        down_read(&curseg->journal_rwsem);
+        memcpy(&dst->journal, curseg->journal, SUM_JOURNAL_SIZE);
+        up_read(&curseg->journal_rwsem);
+
+        memcpy(dst->entries, src->entries, SUM_ENTRY_SIZE);
+        memcpy(&dst->footer, &src->footer, SUM_FOOTER_SIZE);
+
+        mutex_unlock(&curseg->curseg_mutex);
+
+        set_page_dirty(page);
+        f2fs_put_page(page, 1);
+}
+
 static int is_next_segment_free(struct f2fs_sb_info *sbi, int type)
 {
         struct curseg_info *curseg = CURSEG_I(sbi, type);
@@ -873,9 +979,8 @@ static void get_new_segment(struct f2fs_sb_info *sbi,
 
         if (!new_sec && ((*newseg + 1) % sbi->segs_per_sec)) {
                 segno = find_next_zero_bit(free_i->free_segmap,
-                                        MAIN_SEGS(sbi), *newseg + 1);
-                if (segno - *newseg < sbi->segs_per_sec -
-                                        (*newseg % sbi->segs_per_sec))
+                                (hint + 1) * sbi->segs_per_sec, *newseg + 1);
+                if (segno < (hint + 1) * sbi->segs_per_sec)
                         goto got_it;
         }
 find_other_zone:
@@ -1280,8 +1385,8 @@ static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
 {
         int type = __get_segment_type(fio->page, fio->type);
 
-        allocate_data_block(fio->sbi, fio->page, fio->blk_addr,
-                                        &fio->blk_addr, sum, type);
+        allocate_data_block(fio->sbi, fio->page, fio->old_blkaddr,
+                                        &fio->new_blkaddr, sum, type);
 
         /* writeout dirty page into bdev */
         f2fs_submit_page_mbio(fio);
@@ -1293,7 +1398,8 @@ void write_meta_page(struct f2fs_sb_info *sbi, struct page *page)
                 .sbi = sbi,
                 .type = META,
                 .rw = WRITE_SYNC | REQ_META | REQ_PRIO,
-                .blk_addr = page->index,
+                .old_blkaddr = page->index,
+                .new_blkaddr = page->index,
                 .page = page,
                 .encrypted_page = NULL,
         };
@@ -1323,19 +1429,19 @@ void write_data_page(struct dnode_of_data *dn, struct f2fs_io_info *fio)
         get_node_info(sbi, dn->nid, &ni);
         set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
         do_write_page(&sum, fio);
-        dn->data_blkaddr = fio->blk_addr;
+        f2fs_update_data_blkaddr(dn, fio->new_blkaddr);
 }
 
 void rewrite_data_page(struct f2fs_io_info *fio)
 {
+        fio->new_blkaddr = fio->old_blkaddr;
         stat_inc_inplace_blocks(fio->sbi);
         f2fs_submit_page_mbio(fio);
 }
 
-static void __f2fs_replace_block(struct f2fs_sb_info *sbi,
-                                struct f2fs_summary *sum,
+void __f2fs_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
                                 block_t old_blkaddr, block_t new_blkaddr,
-                                bool recover_curseg)
+                                bool recover_curseg, bool recover_newaddr)
 {
         struct sit_info *sit_i = SIT_I(sbi);
         struct curseg_info *curseg;
@@ -1378,7 +1484,7 @@ static void __f2fs_replace_block(struct f2fs_sb_info *sbi,
         curseg->next_blkoff = GET_BLKOFF_FROM_SEG0(sbi, new_blkaddr);
         __add_sum_entry(sbi, type, sum);
 
-        if (!recover_curseg)
+        if (!recover_curseg || recover_newaddr)
                 update_sit_entry(sbi, new_blkaddr, 1);
         if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO)
                 update_sit_entry(sbi, old_blkaddr, -1);
@@ -1402,66 +1508,30 @@ static void __f2fs_replace_block(struct f2fs_sb_info *sbi,
 
 void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
                                 block_t old_addr, block_t new_addr,
-                                unsigned char version, bool recover_curseg)
+                                unsigned char version, bool recover_curseg,
+                                bool recover_newaddr)
 {
         struct f2fs_summary sum;
 
         set_summary(&sum, dn->nid, dn->ofs_in_node, version);
 
-        __f2fs_replace_block(sbi, &sum, old_addr, new_addr, recover_curseg);
+        __f2fs_replace_block(sbi, &sum, old_addr, new_addr,
+                                        recover_curseg, recover_newaddr);
 
-        dn->data_blkaddr = new_addr;
-        set_data_blkaddr(dn);
-        f2fs_update_extent_cache(dn);
-}
-
-static inline bool is_merged_page(struct f2fs_sb_info *sbi,
-                                        struct page *page, enum page_type type)
-{
-        enum page_type btype = PAGE_TYPE_OF_BIO(type);
-        struct f2fs_bio_info *io = &sbi->write_io[btype];
-        struct bio_vec *bvec;
-        struct page *target;
-        int i;
-
-        down_read(&io->io_rwsem);
-        if (!io->bio) {
-                up_read(&io->io_rwsem);
-                return false;
-        }
-
-        bio_for_each_segment_all(bvec, io->bio, i) {
-
-                if (bvec->bv_page->mapping) {
-                        target = bvec->bv_page;
-                } else {
-                        struct f2fs_crypto_ctx *ctx;
-
-                        /* encrypted page */
-                        ctx = (struct f2fs_crypto_ctx *)page_private(
-                                                                bvec->bv_page);
-                        target = ctx->w.control_page;
-                }
-
-                if (page == target) {
-                        up_read(&io->io_rwsem);
-                        return true;
-                }
-        }
-
-        up_read(&io->io_rwsem);
-        return false;
+        f2fs_update_data_blkaddr(dn, new_addr);
 }
 
 void f2fs_wait_on_page_writeback(struct page *page,
-                                enum page_type type)
+                                enum page_type type, bool ordered)
 {
         if (PageWriteback(page)) {
                 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
 
-                if (is_merged_page(sbi, page, type))
-                        f2fs_submit_merged_bio(sbi, type, WRITE);
-                wait_on_page_writeback(page);
+                f2fs_submit_merged_bio_cond(sbi, NULL, page, 0, type, WRITE);
+                if (ordered)
+                        wait_on_page_writeback(page);
+                else
+                        wait_for_stable_page(page);
         }
 }
 
@@ -1477,7 +1547,7 @@ void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *sbi,
 
         cpage = find_lock_page(META_MAPPING(sbi), blkaddr);
         if (cpage) {
-                f2fs_wait_on_page_writeback(cpage, DATA);
+                f2fs_wait_on_page_writeback(cpage, DATA, true);
                 f2fs_put_page(cpage, 1);
         }
 }
@@ -1498,12 +1568,11 @@ static int read_compacted_summaries(struct f2fs_sb_info *sbi)
 
         /* Step 1: restore nat cache */
         seg_i = CURSEG_I(sbi, CURSEG_HOT_DATA);
-        memcpy(&seg_i->sum_blk->n_nats, kaddr, SUM_JOURNAL_SIZE);
+        memcpy(seg_i->journal, kaddr, SUM_JOURNAL_SIZE);
 
         /* Step 2: restore sit cache */
         seg_i = CURSEG_I(sbi, CURSEG_COLD_DATA);
-        memcpy(&seg_i->sum_blk->n_sits, kaddr + SUM_JOURNAL_SIZE,
-                                                SUM_JOURNAL_SIZE);
+        memcpy(seg_i->journal, kaddr + SUM_JOURNAL_SIZE, SUM_JOURNAL_SIZE);
         offset = 2 * SUM_JOURNAL_SIZE;
 
         /* Step 3: restore summary entries */
@@ -1599,7 +1668,14 @@ static int read_normal_summaries(struct f2fs_sb_info *sbi, int type)
         /* set uncompleted segment to curseg */
         curseg = CURSEG_I(sbi, type);
         mutex_lock(&curseg->curseg_mutex);
-        memcpy(curseg->sum_blk, sum, PAGE_CACHE_SIZE);
+
+        /* update journal info */
+        down_write(&curseg->journal_rwsem);
+        memcpy(curseg->journal, &sum->journal, SUM_JOURNAL_SIZE);
+        up_write(&curseg->journal_rwsem);
+
+        memcpy(curseg->sum_blk->entries, sum->entries, SUM_ENTRY_SIZE);
+        memcpy(&curseg->sum_blk->footer, &sum->footer, SUM_FOOTER_SIZE);
         curseg->next_segno = segno;
         reset_curseg(sbi, type, 0);
         curseg->alloc_type = ckpt->alloc_type[type];
@@ -1654,13 +1730,12 @@ static void write_compacted_summaries(struct f2fs_sb_info *sbi, block_t blkaddr)
 
         /* Step 1: write nat cache */
         seg_i = CURSEG_I(sbi, CURSEG_HOT_DATA);
-        memcpy(kaddr, &seg_i->sum_blk->n_nats, SUM_JOURNAL_SIZE);
+        memcpy(kaddr, seg_i->journal, SUM_JOURNAL_SIZE);
         written_size += SUM_JOURNAL_SIZE;
 
         /* Step 2: write sit cache */
         seg_i = CURSEG_I(sbi, CURSEG_COLD_DATA);
-        memcpy(kaddr + written_size, &seg_i->sum_blk->n_sits,
-                                                SUM_JOURNAL_SIZE);
+        memcpy(kaddr + written_size, seg_i->journal, SUM_JOURNAL_SIZE);
         written_size += SUM_JOURNAL_SIZE;
 
         /* Step 3: write summary entries */
@@ -1706,12 +1781,8 @@ static void write_normal_summaries(struct f2fs_sb_info *sbi,
         else
                 end = type + NR_CURSEG_NODE_TYPE;
 
-        for (i = type; i < end; i++) {
-                struct curseg_info *sum = CURSEG_I(sbi, i);
-                mutex_lock(&sum->curseg_mutex);
-                write_sum_page(sbi, sum->sum_blk, blkaddr + (i - type));
-                mutex_unlock(&sum->curseg_mutex);
-        }
+        for (i = type; i < end; i++)
+                write_current_sum_page(sbi, i, blkaddr + (i - type));
 }
 
 void write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk)
@@ -1727,24 +1798,24 @@ void write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk)
         write_normal_summaries(sbi, start_blk, CURSEG_HOT_NODE);
 }
 
-int lookup_journal_in_cursum(struct f2fs_summary_block *sum, int type,
+int lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
                                         unsigned int val, int alloc)
 {
         int i;
 
         if (type == NAT_JOURNAL) {
-                for (i = 0; i < nats_in_cursum(sum); i++) {
-                        if (le32_to_cpu(nid_in_journal(sum, i)) == val)
+                for (i = 0; i < nats_in_cursum(journal); i++) {
+                        if (le32_to_cpu(nid_in_journal(journal, i)) == val)
                                 return i;
                 }
-                if (alloc && __has_cursum_space(sum, 1, NAT_JOURNAL))
-                        return update_nats_in_cursum(sum, 1);
+                if (alloc && __has_cursum_space(journal, 1, NAT_JOURNAL))
+                        return update_nats_in_cursum(journal, 1);
         } else if (type == SIT_JOURNAL) {
-                for (i = 0; i < sits_in_cursum(sum); i++)
-                        if (le32_to_cpu(segno_in_journal(sum, i)) == val)
+                for (i = 0; i < sits_in_cursum(journal); i++)
+                        if (le32_to_cpu(segno_in_journal(journal, i)) == val)
                                 return i;
-                if (alloc && __has_cursum_space(sum, 1, SIT_JOURNAL))
-                        return update_sits_in_cursum(sum, 1);
+                if (alloc && __has_cursum_space(journal, 1, SIT_JOURNAL))
+                        return update_sits_in_cursum(journal, 1);
         }
         return -1;
 }
@@ -1848,20 +1919,22 @@ static void add_sits_in_set(struct f2fs_sb_info *sbi)
 static void remove_sits_in_journal(struct f2fs_sb_info *sbi)
 {
         struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
-        struct f2fs_summary_block *sum = curseg->sum_blk;
+        struct f2fs_journal *journal = curseg->journal;
         int i;
 
-        for (i = sits_in_cursum(sum) - 1; i >= 0; i--) {
+        down_write(&curseg->journal_rwsem);
+        for (i = 0; i < sits_in_cursum(journal); i++) {
                 unsigned int segno;
                 bool dirtied;
 
-                segno = le32_to_cpu(segno_in_journal(sum, i));
+                segno = le32_to_cpu(segno_in_journal(journal, i));
                 dirtied = __mark_sit_entry_dirty(sbi, segno);
 
                 if (!dirtied)
                         add_sit_entry(segno, &SM_I(sbi)->sit_entry_set);
         }
-        update_sits_in_cursum(sum, -sits_in_cursum(sum));
+        update_sits_in_cursum(journal, -i);
+        up_write(&curseg->journal_rwsem);
 }
 
 /*
@@ -1873,13 +1946,12 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
         struct sit_info *sit_i = SIT_I(sbi);
         unsigned long *bitmap = sit_i->dirty_sentries_bitmap;
         struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
-        struct f2fs_summary_block *sum = curseg->sum_blk;
+        struct f2fs_journal *journal = curseg->journal;
         struct sit_entry_set *ses, *tmp;
         struct list_head *head = &SM_I(sbi)->sit_entry_set;
         bool to_journal = true;
         struct seg_entry *se;
 
-        mutex_lock(&curseg->curseg_mutex);
         mutex_lock(&sit_i->sentry_lock);
 
         if (!sit_i->dirty_sentries)
@@ -1896,7 +1968,7 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
          * entries, remove all entries from journal and add and account
          * them in sit entry set.
          */
-        if (!__has_cursum_space(sum, sit_i->dirty_sentries, SIT_JOURNAL))
+        if (!__has_cursum_space(journal, sit_i->dirty_sentries, SIT_JOURNAL))
                 remove_sits_in_journal(sbi);
 
         /*
@@ -1913,10 +1985,12 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
                 unsigned int segno = start_segno;
 
                 if (to_journal &&
-                        !__has_cursum_space(sum, ses->entry_cnt, SIT_JOURNAL))
+                        !__has_cursum_space(journal, ses->entry_cnt, SIT_JOURNAL))
                         to_journal = false;
 
-                if (!to_journal) {
+                if (to_journal) {
+                        down_write(&curseg->journal_rwsem);
+                } else {
                         page = get_next_sit_page(sbi, start_segno);
                         raw_sit = page_address(page);
                 }
@@ -1934,13 +2008,13 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
                         }
 
                         if (to_journal) {
-                                offset = lookup_journal_in_cursum(sum,
+                                offset = lookup_journal_in_cursum(journal,
                                                         SIT_JOURNAL, segno, 1);
                                 f2fs_bug_on(sbi, offset < 0);
-                                segno_in_journal(sum, offset) =
+                                segno_in_journal(journal, offset) =
                                                         cpu_to_le32(segno);
                                 seg_info_to_raw_sit(se,
-                                                &sit_in_journal(sum, offset));
+                                        &sit_in_journal(journal, offset));
                         } else {
                                 sit_offset = SIT_ENTRY_OFFSET(sit_i, segno);
                                 seg_info_to_raw_sit(se,
@@ -1952,7 +2026,9 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
                         ses->entry_cnt--;
                 }
 
-                if (!to_journal)
+                if (to_journal)
+                        up_write(&curseg->journal_rwsem);
+                else
                         f2fs_put_page(page, 1);
 
                 f2fs_bug_on(sbi, ses->entry_cnt);
@@ -1967,7 +2043,6 @@ out:
                         add_discard_addrs(sbi, cpc);
         }
         mutex_unlock(&sit_i->sentry_lock);
-        mutex_unlock(&curseg->curseg_mutex);
 
         set_prefree_as_free_segments(sbi);
 }
@@ -2099,6 +2174,11 @@ static int build_curseg(struct f2fs_sb_info *sbi)
                 array[i].sum_blk = kzalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
                 if (!array[i].sum_blk)
                         return -ENOMEM;
+                init_rwsem(&array[i].journal_rwsem);
+                array[i].journal = kzalloc(sizeof(struct f2fs_journal),
+                                                        GFP_KERNEL);
+                if (!array[i].journal)
+                        return -ENOMEM;
                 array[i].segno = NULL_SEGNO;
                 array[i].next_blkoff = 0;
         }
@@ -2109,11 +2189,11 @@ static void build_sit_entries(struct f2fs_sb_info *sbi)
 {
         struct sit_info *sit_i = SIT_I(sbi);
         struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
-        struct f2fs_summary_block *sum = curseg->sum_blk;
+        struct f2fs_journal *journal = curseg->journal;
         int sit_blk_cnt = SIT_BLK_CNT(sbi);
         unsigned int i, start, end;
         unsigned int readed, start_blk = 0;
-        int nrpages = MAX_BIO_BLOCKS(sbi);
+        int nrpages = MAX_BIO_BLOCKS(sbi) * 8;
 
         do {
                 readed = ra_meta_pages(sbi, start_blk, nrpages, META_SIT, true);
@@ -2127,16 +2207,16 @@ static void build_sit_entries(struct f2fs_sb_info *sbi)
                         struct f2fs_sit_entry sit;
                         struct page *page;
 
-                        mutex_lock(&curseg->curseg_mutex);
-                        for (i = 0; i < sits_in_cursum(sum); i++) {
-                                if (le32_to_cpu(segno_in_journal(sum, i))
+                        down_read(&curseg->journal_rwsem);
+                        for (i = 0; i < sits_in_cursum(journal); i++) {
+                                if (le32_to_cpu(segno_in_journal(journal, i))
                                                                 == start) {
-                                        sit = sit_in_journal(sum, i);
-                                        mutex_unlock(&curseg->curseg_mutex);
+                                        sit = sit_in_journal(journal, i);
+                                        up_read(&curseg->journal_rwsem);
                                         goto got_it;
                                 }
                         }
-                        mutex_unlock(&curseg->curseg_mutex);
+                        up_read(&curseg->journal_rwsem);
 
                         page = get_current_sit_page(sbi, start);
                         sit_blk = (struct f2fs_sit_block *)page_address(page);
@@ -2371,8 +2451,10 @@ static void destroy_curseg(struct f2fs_sb_info *sbi)
         if (!array)
                 return;
         SM_I(sbi)->curseg_array = NULL;
-        for (i = 0; i < NR_CURSEG_TYPE; i++)
+        for (i = 0; i < NR_CURSEG_TYPE; i++) {
                 kfree(array[i].sum_blk);
+                kfree(array[i].journal);
+        }
         kfree(array);
 }