From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E92C030C359 for ; Fri, 16 Oct 2026 03:57:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1792123081; cv=none; b=CiYHi7fZcNcDw0DkHh7ZhFF8xWPswnskdFxRLIfBHOy06Ui7xkYPxPxptckHH34eF8wWeOLvNmpLsap4tgaorTl20NNn+VoBziH3tOPG91APxZFoWSzrBqIeO8T1pSG/lXeuDxtZHcXXvgWFsafzlhlptzDznnyYxyb1HW5NV6w= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1792123081; c=relaxed/simple; bh=C1DFDRUkXq9o/DuU3rp2ydPkFXNT1IcY+EDKb3Wlols=; h=Message-ID:Date:MIME-Version:Cc:Subject:To:References:From: In-Reply-To:Content-Type; b=m/6sb8NunhoVvCVTUCCVHeoVkiyGNlvqJtt5Mv8r+DdOffHvxsQC1gGEz1gjogYnTLj04DUadJZ/UTVU3Q5JJyx0HM7guONmjeLklEh7goUdQ7x9vquRtd48wIIUPDFcpTI7n0XRhBdPG9HCe9y0GYLpm+9eR91u+PmTJifXaeE= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=AmONJa52; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="AmONJa52" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 974C01F000C4; Fri, 16 Oct 2026 03:57:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792123079; bh=aZ1SzW5L0l21vwJBgZpB2s3uF3iN01ryTsTbTEF0Pz0=; h=Date:Cc:Subject:To:References:From:In-Reply-To; b=AmONJa52nMO0sgvHI5LJrjPMqgyaiojR9Xa0JKtUKsaPJ1ZoOL88ecn/6Yl5ekFDD G7DTkP7RHyfcMVgh5S2eCMokNeFvr6T3HKzFKBzdoBQdt5KIfH3GjcQV5U9Yykghmn ojbyGV2e2Hm4pqbzk36yXi0wGvY72BmXuWk+WJ7ua/hJ9s2xhEGg/PuLB5kMIpjgS2 r09ap8wgIOd9yH4o60e+TIYtVLe4geDoK1dZDH7LapQ7jc34ls8AO+zmx+sBeBwc7+ cV+VW3ntSG3WbvppFqATmV6DxZzu4/j1jFhA7/T/0xjPT5CD5doyVVArkOLnlXXY8D 1Y6VNpczsDXxw== Message-ID: <36d24c53-25e0-45de-889b-f309ee6a0bdd@kernel.org> Date: Fri, 16 Oct 2026 11:57:53 +0800 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Cc: chao@kernel.org, Barry Song , Nanzhe Zhao , Juan Yescas , Daeho Jeong , Dev Jain , David Hildenbrand , linux-kernel@vger.kernel.org, Bo Zhang , Kalesh Singh , Nanzhe Zhao , Pengfei Li , Ryan Roberts Subject: Re: [PATCH v5 05/16] f2fs: support large folio writeback To: Nanzhe Zhao , linux-f2fs-devel@lists.sourceforge.net, Jaegeuk Kim References: <20261014064445.2835813-1-zhaonanzhe@xiaomi.com> <20261014064445.2835813-6-zhaonanzhe@xiaomi.com> <6be679d1-d8ab-41b3-9975-1f1bcd552579@kernel.org> Content-Language: en-US From: Chao Yu In-Reply-To: <6be679d1-d8ab-41b3-9975-1f1bcd552579@kernel.org> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit On 10/16/26 08:39, Chao Yu wrote: > On 10/14/26 14:44, Nanzhe Zhao wrote: >> Large folio can contain multiple dirty ranges. >> Add a folio-based writeback path for large-folio mapping files >> and keep the legacy f2fs_write_cache_pages() path unchanged for >> non large-folio mapping files. >> >> Signed-off-by: Nanzhe Zhao >> --- >>   fs/f2fs/data.c | 475 ++++++++++++++++++++++++++++++++++++++++++++++++- >>   1 file changed, 470 insertions(+), 5 deletions(-) >> >> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c >> index c9a213a5e6a2..9701d2d2da89 100644 >> --- a/fs/f2fs/data.c >> +++ b/fs/f2fs/data.c >> @@ -373,7 +373,9 @@ static void f2fs_write_end_bio(struct bio *bio) >>       bio_for_each_folio_all(fi, bio) { >>           struct folio *folio = fi.folio; >> +        unsigned int nr_pages = fi.length >> PAGE_SHIFT; >>           enum count_type type; >> +        bool finished = true; >>   #ifdef CONFIG_F2FS_FS_COMPRESSION >>           if (f2fs_is_compressed_page(folio)) { >> @@ -392,7 +394,16 @@ static void f2fs_write_end_bio(struct bio *bio) >>               } >>           } >> -        dec_cache_count(sbi, type); >> +        if (f2fs_folio_has_ffs(folio)) { >> +            struct f2fs_folio_state *ffs = >> +                (struct f2fs_folio_state *)folio->private; >> + >> +            finished = atomic_sub_and_test(nr_pages, >> +                    &ffs->write_pages_pending); >> +        } >> + >> +        while (nr_pages--) >> +            dec_cache_count(sbi, type); >>           /* >>            * we should access sbi before folio_end_writeback() to >> @@ -402,8 +413,10 @@ static void f2fs_write_end_bio(struct bio *bio) >>                   wq_has_sleeper(&sbi->cp_wait)) >>               wake_up(&sbi->cp_wait); >> -        folio_clear_f2fs_gcing(folio); >> -        folio_end_writeback(folio); >> +        if (finished) { >> +            folio_clear_f2fs_gcing(folio); >> +            folio_end_writeback(folio); >> +        } >>       } >>       bio_put(bio); >> @@ -2908,7 +2921,7 @@ static unsigned int __ffs_mark_subrange_dirty(struct folio *folio, >>       return bitmap_weight(ffs->state, 2 * nr_subpages) - before; >>   } >> -static void f2fs_ffs_mark_subrange_dirty(struct folio *folio, >> +void f2fs_ffs_mark_subrange_dirty(struct folio *folio, >>                       size_t offset, size_t len) >>   { >>       struct f2fs_folio_state *ffs; >> @@ -2926,6 +2939,99 @@ static void f2fs_ffs_mark_subrange_dirty(struct folio *folio, >>       spin_unlock_irqrestore(&ffs->state_lock, flags); >>   } >> +static bool __ffs_clear_subrange_dirty(struct folio *folio, >> +            struct f2fs_folio_state *ffs, size_t offset, size_t len) >> +{ >> +    unsigned int nr_subpages = folio_nr_pages(folio); >> +    unsigned int start, end; >> + >> +    start = offset >> PAGE_SHIFT; >> +    end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT; >> +    end = min(end, nr_subpages); >> + >> +    bitmap_clear(ffs->state, nr_subpages + start, end - start); >> +    return find_next_bit(ffs->state, 2 * nr_subpages, nr_subpages) < >> +            2 * nr_subpages; >> +} >> + >> +/** >> + * f2fs_ffs_clear_subrange_dirty_and_test - clear dirty bits and test remaining >> + * @folio: the large folio >> + * @offset: start byte offset within the folio >> + * @len: byte length of the subrange >> + * >> + * Clear the dirty bits of the 4K subpages covered by [offset, offset + len), >> + * and return whether the folio still has any dirty subpage left. >> + */ >> +bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset, >> +                        size_t len) >> +{ >> +    struct f2fs_folio_state *ffs; >> +    unsigned long flags; >> +    bool dirty; >> + >> +    if (!f2fs_folio_has_ffs(folio)) >> +        return false; >> + >> +    ffs = (struct f2fs_folio_state *)folio->private; >> +    spin_lock_irqsave(&ffs->state_lock, flags); >> +    dirty = __ffs_clear_subrange_dirty(folio, ffs, offset, len); >> +    spin_unlock_irqrestore(&ffs->state_lock, flags); >> + >> +    return dirty; >> +} >> + >> +static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs, >> +            const struct folio *folio, unsigned int start, >> +            unsigned int end) >> +{ >> +    unsigned int nr_subpages = folio_nr_pages(folio); >> + >> +    return find_next_bit(ffs->state, nr_subpages + end + 1, >> +            nr_subpages + start) - nr_subpages; >> +} >> + >> +static unsigned int ffs_next_clean_subpage(struct f2fs_folio_state *ffs, >> +            const struct folio *folio, unsigned int start, >> +            unsigned int end) >> +{ >> +    unsigned int nr_subpages = folio_nr_pages(folio); >> + >> +    return find_next_zero_bit(ffs->state, nr_subpages + end + 1, >> +            nr_subpages + start) - nr_subpages; >> +} >> + >> +static unsigned int ffs_find_dirty_range(struct folio *folio, >> +                    u64 *range_start, u64 range_end) >> +{ >> +    struct f2fs_folio_state *ffs; >> +    unsigned int start, end, nr_pages; >> + >> +    if (*range_start >= range_end) >> +        return 0; >> + >> +    if (!f2fs_folio_has_ffs(folio)) >> +        return range_end - *range_start; >> + >> +    ffs = (struct f2fs_folio_state *)folio->private; >> +    start = offset_in_folio(folio, *range_start) >> PAGE_SHIFT; >> +    end = DIV_ROUND_UP(min_not_zero(offset_in_folio(folio, range_end), >> +                    folio_size(folio)), PAGE_SIZE) - 1; >> + >> +    start = ffs_next_dirty_subpage(ffs, folio, start, end); >> +    if (start > end) >> +        return 0; >> + >> +    if (start == end) >> +        nr_pages = 1; >> +    else >> +        nr_pages = ffs_next_clean_subpage(ffs, folio, >> +                         start + 1, end) - start; >> + >> +    *range_start = folio_pos(folio) + ((u64)start << PAGE_SHIFT); >> +    return (u64)nr_pages << PAGE_SHIFT; >> +} >> + >>   static bool find_next_valid_block(const struct folio *folio, >>                     size_t orig_off, size_t *need_off, >>                     size_t len) >> @@ -3509,6 +3615,144 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio) >>       return err; >>   } >> +static int f2fs_write_folio_dirty_range(struct folio *folio, int *submitted, >> +                    struct writeback_control *wbc, >> +                    enum iostat_type io_type, >> +                    u64 *pos, u64 len) >> +{ >> +    struct inode *inode = folio->mapping->host; >> +    struct f2fs_sb_info *sbi = F2FS_I_SB(inode); >> +    bool atomic_commit = f2fs_is_atomic_file(inode) && >> +                folio_test_f2fs_atomic(folio); >> +    struct inode *dn_inode = atomic_commit ? >> +                F2FS_I(inode)->cow_inode : inode; >> +    struct f2fs_folio_state *ffs = NULL; >> +    u64 folio_start = folio_pos(folio); >> +    pgoff_t start_idx = (*pos - folio_start) >> PAGE_SHIFT; >> +    pgoff_t end_idx = (*pos - folio_start + len - 1) >> PAGE_SHIFT; >> +    int err = 0; >> + >> +    for (pgoff_t i = start_idx; i <= end_idx && !err; i++) { >> +        struct dnode_of_data dn; >> +        struct node_info ni; >> +        pgoff_t data_idx = folio->index + i; >> +        bool ipu_force = false; >> +        bool dn_held = false; >> +        bool submitted_blk = false; >> +        struct f2fs_io_info fio = { >> +            .sbi = sbi, >> +            .ino = inode->i_ino, >> +            .type = DATA, >> +            .op = REQ_OP_WRITE, >> +            .op_flags = wbc_to_write_flags(wbc), >> +            .old_blkaddr = NULL_ADDR, >> +            .folio = folio, >> +            .folio_offset = i, >> +            .folio_blkcnt = 1, >> +            .encrypted_page = NULL, >> +            .submitted = 0, >> +            .need_lock = LOCK_DONE, >> +            .meta_gc = f2fs_meta_inode_gc_required(inode) ? 1 : 0, >> +            .io_type = io_type, >> +            .io_wbc = wbc, >> +        }; >> + >> +        if (f2fs_folio_has_ffs(folio)) { >> +            ffs = (struct f2fs_folio_state *)folio->private; >> +            atomic_inc(&ffs->write_pages_pending); >> +        } >> + >> +        set_new_dnode(&dn, dn_inode, NULL, NULL, 0); >> + >> +        if (need_inplace_update(&fio) && >> +            f2fs_lookup_read_extent_cache_block(inode, data_idx, >> +                            &fio.old_blkaddr)) { >> +            if (!f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr, >> +                           DATA_GENERIC_ENHANCE)) { >> +                err = -EFSCORRUPTED; >> +                goto block_done; >> +            } >> +            ipu_force = true; >> +            goto got_it; >> +        } >> + >> +        err = f2fs_get_dnode_of_data(&dn, data_idx, LOOKUP_NODE); >> +        if (err) >> +            goto block_done; >> +        dn_held = true; >> + >> +        fio.old_blkaddr = dn.data_blkaddr; >> + >> +got_it: > > How about handle NULL_ADDR here like f2fs_do_write_data_page() to avoid racing > w/ truncation? > > f2fs_do_write_data_page() > >     /* This page is already truncated */ >     if (fio->old_blkaddr == NULL_ADDR) { >         folio_clear_uptodate(folio); >         folio_clear_f2fs_gcing(folio); >         goto out_writepage; >     } > > > >> +        if (__is_valid_data_blkaddr(fio.old_blkaddr) && >> +            !f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr, >> +                       DATA_GENERIC_ENHANCE)) { >> +            err = -EFSCORRUPTED; >> +            goto block_done; >> +        } >> + >> +        if (fio.meta_gc) >> +            f2fs_wait_on_block_writeback(inode, fio.old_blkaddr); >> + >> +        if (ipu_force || >> +            (__is_valid_data_blkaddr(fio.old_blkaddr) && >> +                        need_inplace_update(&fio))) { >> +            f2fs_put_dnode(&dn); >> +            dn_held = false; >> +            err = f2fs_inplace_write_data(&fio); >> +            trace_f2fs_do_write_data_page(folio, IPU); >> +            if (err) >> +                goto block_done; >> + >> +            if (submitted) >> +                (*submitted)++; >> +            submitted_blk = true; >> +            set_inode_flag(inode, FI_UPDATE_WRITE); >> +            goto block_done; >> +        } >> + >> +        err = f2fs_get_node_info(sbi, dn.nid, &ni, false); >> +        if (err) >> +            goto block_done; >> + >> +        fio.version = ni.version; >> + >> +        f2fs_outplace_write_data(&dn, &fio); >> +        /* >> +         * The outplace write path failed to submit this block. >> +         */ >> +        if (!fio.submitted) { >> +            err = -EIO; >> +            goto block_done; >> +        } >> +        if (submitted) >> +            (*submitted)++; >> +        submitted_blk = true; >> +        set_inode_flag(inode, FI_APPEND_WRITE); >> +        trace_f2fs_do_write_data_page(folio, OPU); >> +block_done: >> +        if (dn_held) >> +            f2fs_put_dnode(&dn); >> +        /* >> +         * If this block was not submitted, roll back its >> +         * write pages pending. >> +         */ >> +        if (!submitted_blk && ffs) >> +            atomic_dec(&ffs->write_pages_pending); >> +        if (!err) { >> +            *pos = ((loff_t)data_idx + 1) << PAGE_SHIFT; >> +            spin_lock(&F2FS_I(inode)->i_size_lock); >> +            if (F2FS_I(inode)->last_disk_size < *pos) >> +                F2FS_I(inode)->last_disk_size = *pos; >> +            spin_unlock(&F2FS_I(inode)->i_size_lock); >> +        } else { >> +            file_set_keep_isize(inode); >> +        } >> +    } >> + >> +    return err; >> +} >> + >>   int f2fs_write_single_data_page(struct folio *folio, int *submitted, >>                   struct bio **bio, >>                   sector_t *last_block, >> @@ -3958,6 +4202,223 @@ static int f2fs_write_cache_pages(struct address_space *mapping, >>       return ret; >>   } >> +static int f2fs_write_cache_folios(struct address_space *mapping, >> +                   struct writeback_control *wbc, >> +                   enum iostat_type io_type) >> +{ >> +    struct folio *folio = NULL; >> +    struct inode *inode = mapping->host; >> +    struct f2fs_sb_info *sbi = F2FS_I_SB(inode); >> +    struct f2fs_lock_context lc; >> +    u64 pos = 0; >> +    u64 end_pos = 0; >> +    u32 r_len = 0; >> +    int err = 0; >> +    int submitted = 0; >> +    int nwritten = 0; >> +    bool op_locked = false; >> +    bool retry = false; >> + >> +    if (get_dirty_pages(inode) <= SM_I(sbi)->min_hot_blocks) >> +        set_inode_flag(inode, FI_HOT_DATA); >> +    else >> +        clear_inode_flag(inode, FI_HOT_DATA); >> + >> +    while ((folio = writeback_iter(mapping, wbc, folio, &err))) { >> +        struct f2fs_folio_state *ffs = NULL; >> +        u64 isize; >> +        size_t poff; >> +        pgoff_t end_index; >> +        bool verity_in_progress; >> +        int folio_submitted = 0; >> +        bool bias_added = false; >> + >> +        submitted = 0; >> +        retry = false; >> + >> +        if (err) { >> +            folio_redirty_for_writepage(wbc, folio); >> +            goto retry_out; >> +        } >> + >> +        if (atomic_read(&sbi->wb_sync_req[DATA]) && >> +            wbc->sync_mode == WB_SYNC_NONE) { >> +            folio_redirty_for_writepage(wbc, folio); >> +            /* >> +             * A WB_SYNC_ALL writeback is in progress, so defer >> +             * this writeback.  Mark the error as -EBUSY to let >> +             * writeback_iter() stop iterating. >> +             */ >> +            err = -EBUSY; >> +            goto retry_out; >> +        } >> + >> +        /* >> +         * If cp_error is set, all subpages of this folio are not written >> +         * back unless the filesystem is mounted with errors=remount-ro. >> +         */ >> +        if (unlikely(f2fs_cp_error(sbi))) { >> +            mapping_set_error(folio->mapping, -EIO); >> +            if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) >> +                folio_redirty_for_writepage(wbc, folio); >> +            else >> +                f2fs_ffs_clear_subrange_dirty_and_test(folio, 0, >> +                                folio_size(folio)); > > if (f2fs_folio_has_ffs()) >     f2fs_ffs_clear_subrange_dirty_and_test() > else >     f2fs_account_dirty_blocks() > > Thanks, > >> +            goto retry_out; >> +        } >> + >> +        /* >> +         * Writing back one large folio performs multiple block allocations, so >> +         * best-effort balance the filesystem before writing it back. >> +         */ >> +        if (!F2FS_I(inode)->wb_task && has_not_enough_free_secs(sbi, 0, 0)) { >> +            folio_redirty_for_writepage(wbc, folio); >> +            retry = true; >> +            folio_unlock(folio); >> +            f2fs_balance_fs(sbi, true); >> +            folio_lock(folio); >> +            goto retry; >> +        } >> +retry: >> +        pos = folio_pos(folio); >> +        end_pos = pos + folio_size(folio); >> +        isize = i_size_read(inode); >> +        verity_in_progress = f2fs_verity_in_progress(inode); >> +        poff = 0; >> +        end_index = 0; >> + >> +        if (retry) { >> + >> +            if (unlikely(folio->mapping != mapping)) >> +                goto retry_out; >> + >> +            if (!folio_test_dirty(folio)) >> +                goto retry_out; >> + >> +            if (folio_test_writeback(folio)) { >> +                if (wbc->sync_mode == WB_SYNC_NONE) >> +                    goto retry_out; >> +                f2fs_folio_wait_writeback(folio, true, true); >> +            } >> + >> +            if (!folio_clear_dirty_for_io(folio)) >> +                goto retry_out; >> +        } >> + >> +        /* To avoid dealing with the complexity for one subrange is in bio >> +         * while we trylock_op failed before writing another subrange. >> +         * Try to lock_op before any subrange write for the folio. >> +         */ >> +        if (!op_locked) { >> +            if (!f2fs_trylock_op(sbi, &lc)) { >> +                folio_redirty_for_writepage(wbc, folio); >> +                err = 0; >> +                if (wbc->sync_mode != WB_SYNC_ALL) >> +                    goto retry_out; >> + >> +                retry = true; >> +                folio_unlock(folio); >> +                f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT); >> +                folio_lock(folio); >> +                goto retry; >> +            } >> +            op_locked = true; >> +        } >> + >> +        if (!verity_in_progress) { >> +            poff = offset_in_folio(folio, isize); >> +            end_index = isize >> PAGE_SHIFT; >> + >> +            if (folio->index > end_index || >> +                (folio->index == end_index && poff == 0)) >> +                goto out; >> + >> +            if (end_pos > isize) { >> +                folio_zero_segment(folio, poff, folio_size(folio)); >> +                end_pos = isize; >> +            } >> +        } >> + >> +        folio_start_writeback(folio); >> + >> +        /* >> +         * Large folios can be submitted as multiple bios, which may >> +         * complete while we are still submitting the remaining dirty >> +         * ranges.  Hold a bias on write_pages_pending to prevent >> +         * folio_end_writeback() from being called early. >> +         */ >> +        if (!bias_added && f2fs_folio_has_ffs(folio)) { >> +            ffs = (struct f2fs_folio_state *)folio->private; >> +            WARN_ON_ONCE(atomic_read(&ffs->write_pages_pending) != 0); >> +            atomic_inc(&ffs->write_pages_pending); >> +            bias_added = true; >> +        } >> + >> +        while ((r_len = ffs_find_dirty_range(folio, &pos, end_pos))) { >> +            err = f2fs_write_folio_dirty_range(folio, &submitted, >> +                    wbc, io_type, &pos, r_len); >> +            folio_submitted += submitted; >> +            nwritten += submitted; >> +            if (err) >> +                goto out; >> +        } >> + >> +        /* If none of the subpages of a folio is submitted, keep the atomic flag */ >> +        if (folio_submitted && >> +            f2fs_is_atomic_file(inode) && >> +            folio_test_f2fs_atomic(folio)) >> +            folio_clear_f2fs_atomic(folio); >> + >> +out: >> +        /* >> +         * Clear the dirty state of the subranges that were written back. >> +         * If some subranges are still dirty (e.g. the folio was only >> +         * partially written back), the folio must stay dirty so that >> +         * the remaining subranges are written back later. >> +         */ >> +        if (f2fs_ffs_clear_subrange_dirty_and_test(folio, 0, >> +                    (err ? pos : end_pos) - folio_pos(folio))) >> +            folio_redirty_for_writepage(wbc, folio); For folio order-0, if f2fs_write_folio_dirty_range() failed, we need to redirty folio anyway, right? so it's need to check err as well? Thanks, >> +        else >> +            inode_dec_dirty_pages(inode); >> + >> +        /* >> +         * Release the bias taken above and we end writeback here if >> +         * no write bio is in flight. >> +         */ >> +        if (bias_added && >> +            atomic_dec_and_test(&ffs->write_pages_pending)) { >> +            folio_end_writeback(folio); >> +        } else if (!folio_submitted && folio_test_writeback(folio)) { >> +            /* >> +             * Order-0 folios take no bias, so end the writeback >> +             * if nothing was submitted. >> +             */ >> +            folio_end_writeback(folio); >> +        } >> + >> +retry_out: >> +        if (op_locked) { >> +            f2fs_unlock_op(sbi, &lc); >> +            op_locked = false; >> +        } >> + >> +        folio_unlock(folio); >> +    } >> + >> +    if (nwritten) >> +        f2fs_submit_merged_write_cond(F2FS_M_SB(mapping), mapping->host, >> +                           NULL); >> + >> +    /* >> +     * Prevent the -EBUSY error that stopped writeback_iter() from >> +     * propagating to the user. >> +     */ >> +    if (err == -EBUSY) >> +        err = 0; >> +    return err; >> +} >> + >>   static inline bool __should_serialize_io(struct inode *inode, >>                       struct writeback_control *wbc) >>   { >> @@ -4052,7 +4513,11 @@ static int __f2fs_write_data_pages(struct address_space *mapping, >>       account_writeback(inode, true); >>       blk_start_plug(&plug); >> -    ret = f2fs_write_cache_pages(mapping, wbc, io_type); >> +    if (mapping_large_folio_support(inode->i_mapping) && >> +        !f2fs_has_inline_data(inode)) >> +        ret = f2fs_write_cache_folios(mapping, wbc, io_type); >> +    else >> +        ret = f2fs_write_cache_pages(mapping, wbc, io_type); >>       blk_finish_plug(&plug); >>       account_writeback(inode, false); >