Re: [PATCH 1/3] gfs2: stop using pages for log buffers

From: Andreas Gruenbacher

Date: Thu Nov 19 2026 - 19:09:14 EST


On Tue, Nov 17, 2026 at 8:46 AM Tal Zussman <tz2294@xxxxxxxxxxxx> wrote:
>
> The log headers, descriptors, revoke blocks, and escaped block copies
> come from a mempool of pages and share a bio with the buffer heads being
> journaled. The completion handler tells the two apart by checking each
> segment for buffers, which treats a pool page as a folio. That won't
> work once memdescs give these pages a type of their own.
>
> Allocate them from a kmalloc mempool instead and add them to the bio
> with bio_add_virt_nofail(). Give the pool blocks their own completion
> handler, and start a new bio whenever the handler changes so that a bio
> only holds one kind of segment. gfs2_log_write() now takes a folio, so
> the log write path no longer uses struct page.
>
> Each descriptor and each escaped block copy is now a bio of its own.
> They are contiguous and merge under an I/O scheduler, but the flush
> path doesn't plug, so without a scheduler they reach the device as
> separate writes.
>
> Signed-off-by: Tal Zussman <tz2294@xxxxxxxxxxxx>
> ---
> fs/gfs2/log.c | 10 ++-
> fs/gfs2/lops.c | 203 +++++++++++++++++++++++++++++++++++----------------------
> fs/gfs2/lops.h | 6 +-
> fs/gfs2/main.c | 8 +--
> fs/gfs2/util.c | 2 +-
> fs/gfs2/util.h | 2 +-
> 6 files changed, 139 insertions(+), 92 deletions(-)
>
> diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
> index 1baaaf30c4fa..238f6655e15f 100644
> --- a/fs/gfs2/log.c
> +++ b/fs/gfs2/log.c
> @@ -841,7 +841,6 @@ void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> {
> struct gfs2_log_header *lh;
> u32 hash, crc;
> - struct page *page;
> struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
> struct timespec64 tv;
> struct super_block *sb = sdp->sd_vfs;
> @@ -850,9 +849,8 @@ void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> if (gfs2_withdrawn(sdp))
> return;
>
> - page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
> - lh = page_address(page);
> - clear_page(lh);
> + lh = mempool_alloc(gfs2_log_buf_pool, GFP_NOIO);
> + memset(lh, 0, sb->s_blocksize);
>
> lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
> lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
> @@ -905,8 +903,8 @@ void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> sb->s_blocksize - LH_V1_SIZE - 4);
> lh->lh_crc = cpu_to_be32(crc);
>
> - gfs2_log_write(sdp, jd, page, sb->s_blocksize, 0, dblock,
> - REQ_OP_WRITE | op_flags);
> + gfs2_log_write_buf(sdp, jd, lh, sb->s_blocksize, dblock,
> + REQ_OP_WRITE | op_flags);
> gfs2_log_submit_write(&jd->jd_log_bio);
> }
>
> diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
> index 657edd406dd1..c86f92f2e508 100644
> --- a/fs/gfs2/lops.c
> +++ b/fs/gfs2/lops.c
> @@ -196,45 +196,69 @@ static void gfs2_end_log_write_bh(struct gfs2_sbd *sdp, struct folio *folio,
> } while (bh && size);
> }
>
> +static void gfs2_log_write_error(struct bio *bio)
> +{
> + struct gfs2_sbd *sdp = bio->bi_private;
> + int err = blk_status_to_errno(bio->bi_status);
> +
> + if (!cmpxchg(&sdp->sd_log_error, 0, err))
> + fs_err(sdp, "Error %d writing to journal, jid=%u\n",
> + err, sdp->sd_jdesc->jd_jid);
> + gfs2_withdraw(sdp);
> +}
> +
> +static void gfs2_log_write_done(struct bio *bio)
> +{
> + struct gfs2_sbd *sdp = bio->bi_private;
> +
> + bio_put(bio);
> + if (atomic_dec_and_test(&sdp->sd_log_in_flight))
> + wake_up(&sdp->sd_log_flush_wait);
> +}
> +
> /**
> - * gfs2_end_log_write - end of i/o to the log
> + * gfs2_end_log_write - end of I/O to the log for buffers
> * @bio: The bio
> *
> - * Each bio_vec contains either data from the pagecache or data
> - * relating to the log itself. Here we iterate over the bio_vec
> - * array, processing both kinds of data.
> - *
> + * Every folio in the bio comes from the page cache. Unlock the buffers
> + * that were written.
> */
>
> static void gfs2_end_log_write(struct bio *bio)
> {
> struct gfs2_sbd *sdp = bio->bi_private;
> - struct bio_vec *bvec;
> - struct bvec_iter_all iter_all;
> + struct folio_iter fi;
>
> - if (bio->bi_status) {
> - int err = blk_status_to_errno(bio->bi_status);
> + if (bio->bi_status)
> + gfs2_log_write_error(bio);
>
> - if (!cmpxchg(&sdp->sd_log_error, 0, err))
> - fs_err(sdp, "Error %d writing to journal, jid=%u\n",
> - err, sdp->sd_jdesc->jd_jid);
> - gfs2_withdraw(sdp);
> - }
> + bio_for_each_folio_all(fi, bio)
> + gfs2_end_log_write_bh(sdp, fi.folio, fi.offset, fi.length,
> + bio->bi_status);
>
> - bio_for_each_segment_all(bvec, bio, iter_all) {
> - struct page *page = bvec->bv_page;
> - struct folio *folio = page_folio(page);
> + gfs2_log_write_done(bio);
> +}
>
> - if (folio && folio_buffers(folio))
> - gfs2_end_log_write_bh(sdp, folio, bvec->bv_offset,
> - bvec->bv_len, bio->bi_status);
> - else
> - mempool_free(page, gfs2_page_pool);
> - }
> +/**
> + * gfs2_end_log_write_buf - end of I/O to the log for log blocks
> + * @bio: The bio
> + *
> + * Every segment in the bio is a block from the log buffer mempool.
> + * Return them to the pool.
> + */
>
> - bio_put(bio);
> - if (atomic_dec_and_test(&sdp->sd_log_in_flight))
> - wake_up(&sdp->sd_log_flush_wait);
> +static void gfs2_end_log_write_buf(struct bio *bio)
> +{
> + struct bio_vec *bvec;
> + struct bvec_iter_all iter_all;
> +
> + if (bio->bi_status)
> + gfs2_log_write_error(bio);
> +
> + bio_for_each_segment_all(bvec, bio, iter_all)
> + mempool_free(bvec_virt(bvec), gfs2_log_buf_pool);
> +
> + gfs2_log_write_done(bio);
> }
>
> /**
> @@ -291,9 +315,9 @@ static struct bio *gfs2_log_alloc_bio(struct gfs2_sbd *sdp, u64 blkno,
> * @flush: Always flush the current bio and allocate a new one?
> *
> * If there is a cached bio, then if the next block number is sequential
> - * with the previous one, return it, otherwise flush the bio to the
> - * device. If there is no cached bio, or we just flushed it, then
> - * allocate a new one.
> + * with the previous one and the bio has the same completion handler,
> + * return it, otherwise flush the bio to the device. If there is no
> + * cached bio, or we just flushed it, then allocate a new one.
> *
> * Returns: The bio to use for log writes
> */
> @@ -309,7 +333,7 @@ static struct bio *gfs2_log_get_bio(struct gfs2_sbd *sdp, u64 blkno,
>
> nblk = bio_end_sector(bio);
> nblk >>= sdp->sd_fsb2bb_shift;
> - if (blkno == nblk && !flush)
> + if (blkno == nblk && bio->bi_end_io == end_io && !flush)
> return bio;
> gfs2_log_submit_write(biop);
> }
> @@ -319,38 +343,63 @@ static struct bio *gfs2_log_get_bio(struct gfs2_sbd *sdp, u64 blkno,
> }
>
> /**
> - * gfs2_log_write - write to log
> + * gfs2_log_write - write a folio segment to the log
> * @sdp: the filesystem
> * @jd: The journal descriptor
> - * @page: the page to write
> + * @folio: the folio to write
> * @size: the size of the data to write
> - * @offset: the offset within the page
> + * @offset: the offset within the folio
> * @blkno: block number of the log entry
> * @opf: REQ_OP | op_flags
> *
> - * Try and add the page segment to the current bio. If that fails,
> + * Try and add the folio segment to the current bio. If that fails,
> * submit the current bio to the device and create a new one, and
> - * then add the page segment to that.
> + * then add the folio segment to that.
> */
>
> -void gfs2_log_write(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> - struct page *page, unsigned size, unsigned offset,
> - u64 blkno, blk_opf_t opf)
> +static void gfs2_log_write(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> + struct folio *folio, unsigned int size,
> + unsigned int offset, u64 blkno, blk_opf_t opf)
> {
> struct bio *bio;
> - int ret;
>
> bio = gfs2_log_get_bio(sdp, blkno, &jd->jd_log_bio, opf,
> gfs2_end_log_write, false);
> - ret = bio_add_page(bio, page, size, offset);
> - if (ret == 0) {
> + if (!bio_add_folio(bio, folio, size, offset)) {
> bio = gfs2_log_get_bio(sdp, blkno, &jd->jd_log_bio,
> opf, gfs2_end_log_write, true);
> - ret = bio_add_page(bio, page, size, offset);
> - WARN_ON(ret == 0);
> + WARN_ON(!bio_add_folio(bio, folio, size, offset));
> }
> }
>
> +/**
> + * gfs2_log_write_buf - write a log buffer to the log
> + * @sdp: the filesystem
> + * @jd: The journal descriptor
> + * @buf: the buffer to write, from the log buffer mempool
> + * @size: the size of the data to write
> + * @blkno: block number of the log entry
> + * @opf: REQ_OP | op_flags
> + *
> + * Like gfs2_log_write(), for a block allocated from gfs2_log_buf_pool.
> + * Ownership of the buffer passes to the bio, which returns it to the
> + * pool on completion.
> + */
> +
> +void gfs2_log_write_buf(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> + void *buf, unsigned int size, u64 blkno,
> + blk_opf_t opf)
> +{
> + struct bio *bio;
> +
> + bio = gfs2_log_get_bio(sdp, blkno, &jd->jd_log_bio, opf,
> + gfs2_end_log_write_buf, false);
> + if (bio->bi_vcnt >= bio->bi_max_vecs)
> + bio = gfs2_log_get_bio(sdp, blkno, &jd->jd_log_bio,
> + opf, gfs2_end_log_write_buf, true);
> + bio_add_virt_nofail(bio, buf, size);
> +}
> +
> /**
> * gfs2_log_write_bh - write a buffer's content to the log
> * @sdp: The super block
> @@ -367,30 +416,30 @@ static void gfs2_log_write_bh(struct gfs2_sbd *sdp, struct buffer_head *bh)
>
> dblock = gfs2_log_bmap(sdp->sd_jdesc, sdp->sd_log_flush_head);
> gfs2_log_incr_head(sdp);
> - gfs2_log_write(sdp, sdp->sd_jdesc, folio_page(bh->b_folio, 0),
> - bh->b_size, bh_offset(bh), dblock, REQ_OP_WRITE);
> + gfs2_log_write(sdp, sdp->sd_jdesc, bh->b_folio, bh->b_size,
> + bh_offset(bh), dblock, REQ_OP_WRITE);
> }
>
> /**
> - * gfs2_log_write_page - write one block stored in a page, into the log
> + * gfs2_log_write_block - write one block stored in a log buffer, into the log
> * @sdp: The superblock
> - * @page: The struct page
> + * @buf: The buffer
> *
> - * This writes the first block-sized part of the page into the log. Note
> - * that the page must have been allocated from the gfs2_page_pool mempool
> - * and that after this has been called, ownership has been transferred and
> - * the page may be freed at any time.
> + * This writes the first block-sized part of the buffer into the log. Note
> + * that the buffer must have been allocated from the gfs2_log_buf_pool
> + * mempool and that after this has been called, ownership has been
> + * transferred and the buffer may be freed at any time.
> */
>
> -static void gfs2_log_write_page(struct gfs2_sbd *sdp, struct page *page)
> +static void gfs2_log_write_block(struct gfs2_sbd *sdp, void *buf)
> {
> struct super_block *sb = sdp->sd_vfs;
> u64 dblock;
>
> dblock = gfs2_log_bmap(sdp->sd_jdesc, sdp->sd_log_flush_head);
> gfs2_log_incr_head(sdp);
> - gfs2_log_write(sdp, sdp->sd_jdesc, page, sb->s_blocksize, 0, dblock,
> - REQ_OP_WRITE);
> + gfs2_log_write_buf(sdp, sdp->sd_jdesc, buf, sb->s_blocksize, dblock,
> + REQ_OP_WRITE);
> }
>
> /**
> @@ -604,12 +653,14 @@ int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
> return ret;
> }
>
> -static struct page *gfs2_get_log_desc(struct gfs2_sbd *sdp, u32 ld_type,
> - u32 ld_length, u32 ld_data1)
> +static struct gfs2_log_descriptor *gfs2_get_log_desc(struct gfs2_sbd *sdp,
> + u32 ld_type, u32 ld_length,
> + u32 ld_data1)
> {
> - struct page *page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
> - struct gfs2_log_descriptor *ld = page_address(page);
> - clear_page(ld);
> + struct gfs2_log_descriptor *ld;
> +
> + ld = mempool_alloc(gfs2_log_buf_pool, GFP_NOIO);
> + memset(ld, 0, sdp->sd_sb.sb_bsize);
> ld->ld_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
> ld->ld_header.mh_type = cpu_to_be32(GFS2_METATYPE_LD);
> ld->ld_header.mh_format = cpu_to_be32(GFS2_FORMAT_LD);
> @@ -617,7 +668,7 @@ static struct page *gfs2_get_log_desc(struct gfs2_sbd *sdp, u32 ld_type,
> ld->ld_length = cpu_to_be32(ld_length);
> ld->ld_data1 = cpu_to_be32(ld_data1);
> ld->ld_data2 = 0;
> - return page;
> + return ld;
> }
>
> static void gfs2_check_magic(struct buffer_head *bh)
> @@ -652,7 +703,6 @@ static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
> {
> struct gfs2_log_descriptor *ld;
> struct gfs2_bufdata *bd1 = NULL, *bd2;
> - struct page *page;
> unsigned int num;
> unsigned n;
> __be64 *ptr;
> @@ -665,10 +715,9 @@ static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
> if (total > limit)
> num = limit;
> spin_unlock(&sdp->sd_log_lock);
> - page = gfs2_get_log_desc(sdp,
> - is_databuf ? GFS2_LOG_DESC_JDATA :
> - GFS2_LOG_DESC_METADATA, num + 1, num);
> - ld = page_address(page);
> + ld = gfs2_get_log_desc(sdp,
> + is_databuf ? GFS2_LOG_DESC_JDATA :
> + GFS2_LOG_DESC_METADATA, num + 1, num);
> spin_lock(&sdp->sd_log_lock);
> ptr = (__be64 *)(ld + 1);
>
> @@ -684,7 +733,7 @@ static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
> }
>
> spin_unlock(&sdp->sd_log_lock);
> - gfs2_log_write_page(sdp, page);
> + gfs2_log_write_block(sdp, ld);
> spin_lock(&sdp->sd_log_lock);
>
> n = 0;
> @@ -696,8 +745,7 @@ static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
> if (buffer_escaped(bd2->bd_bh)) {
> void *p;
>
> - page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
> - p = page_address(page);
> + p = mempool_alloc(gfs2_log_buf_pool, GFP_NOIO);
> memcpy_from_folio(p, bd2->bd_bh->b_folio,
> bh_offset(bd2->bd_bh),
> bd2->bd_bh->b_size);
> @@ -705,7 +753,7 @@ static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
> clear_buffer_escaped(bd2->bd_bh);
> unlock_buffer(bd2->bd_bh);
> brelse(bd2->bd_bh);
> - gfs2_log_write_page(sdp, page);
> + gfs2_log_write_block(sdp, p);
> } else {
> gfs2_log_write_bh(sdp, bd2->bd_bh);
> }
> @@ -856,7 +904,7 @@ static void revoke_lo_before_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
> struct gfs2_meta_header *mh;
> unsigned int offset;
> struct gfs2_bufdata *bd;
> - struct page *page;
> + void *buf;
> unsigned int length;
>
> gfs2_flush_revokes(sdp);
> @@ -864,29 +912,30 @@ static void revoke_lo_before_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
> return;
>
> length = gfs2_struct2blk(sdp, sdp->sd_log_num_revoke);
> - page = gfs2_get_log_desc(sdp, GFS2_LOG_DESC_REVOKE, length, sdp->sd_log_num_revoke);
> + buf = gfs2_get_log_desc(sdp, GFS2_LOG_DESC_REVOKE, length,
> + sdp->sd_log_num_revoke);
> offset = sizeof(struct gfs2_log_descriptor);
>
> list_for_each_entry(bd, &sdp->sd_log_revokes, bd_list) {
> sdp->sd_log_num_revoke--;
>
> if (offset + sizeof(u64) > sdp->sd_sb.sb_bsize) {
> - gfs2_log_write_page(sdp, page);
> - page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
> - mh = page_address(page);
> - clear_page(mh);
> + gfs2_log_write_block(sdp, buf);
> + buf = mempool_alloc(gfs2_log_buf_pool, GFP_NOIO);
> + mh = buf;
> + memset(mh, 0, sdp->sd_sb.sb_bsize);
> mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
> mh->mh_type = cpu_to_be32(GFS2_METATYPE_LB);
> mh->mh_format = cpu_to_be32(GFS2_FORMAT_LB);
> offset = sizeof(struct gfs2_meta_header);
> }
>
> - *(__be64 *)(page_address(page) + offset) = cpu_to_be64(bd->bd_blkno);
> + *(__be64 *)(buf + offset) = cpu_to_be64(bd->bd_blkno);
> offset += sizeof(u64);
> }
> gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
>
> - gfs2_log_write_page(sdp, page);
> + gfs2_log_write_block(sdp, buf);
> }
>
> void gfs2_drain_revokes(struct gfs2_sbd *sdp)
> diff --git a/fs/gfs2/lops.h b/fs/gfs2/lops.h
> index 772557b63b48..c1d9e6fef7ac 100644
> --- a/fs/gfs2/lops.h
> +++ b/fs/gfs2/lops.h
> @@ -14,9 +14,9 @@ extern const struct gfs2_log_operations *gfs2_log_ops[];
>
> void gfs2_log_incr_head(struct gfs2_sbd *sdp);
> u64 gfs2_log_bmap(struct gfs2_jdesc *jd, unsigned int lbn);
> -void gfs2_log_write(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> - struct page *page, unsigned size, unsigned offset,
> - u64 blkno, blk_opf_t opf);
> +void gfs2_log_write_buf(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
> + void *buf, unsigned int size, u64 blkno,
> + blk_opf_t opf);
> void gfs2_log_submit_write(struct bio **biop);
> void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh);
> int gfs2_find_jhead(struct gfs2_jdesc *jd,
> diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
> index a607e98eb45f..0da4cfbe54ea 100644
> --- a/fs/gfs2/main.c
> +++ b/fs/gfs2/main.c
> @@ -166,8 +166,8 @@ static int __init init_gfs2_fs(void)
> if (!gfs2_freeze_wq)
> goto fail_wq3;
>
> - gfs2_page_pool = mempool_create_page_pool(64, 0);
> - if (!gfs2_page_pool)
> + gfs2_log_buf_pool = mempool_create_kmalloc_pool(64, PAGE_SIZE);

We actually need s_blocksize size rather than PAGE_SIZE buffers here.
How about a per-sbd mempool instead of a global one?

> + if (!gfs2_log_buf_pool)
> goto fail_mempool;
>
> gfs2_register_debugfs();
> @@ -187,7 +187,7 @@ static int __init init_gfs2_fs(void)
> fail_fs2:
> unregister_filesystem(&gfs2_fs_type);
> fail_fs1:
> - mempool_destroy(gfs2_page_pool);
> + mempool_destroy(gfs2_log_buf_pool);
> fail_mempool:
> destroy_workqueue(gfs2_freeze_wq);
> fail_wq3:
> @@ -240,7 +240,7 @@ static void __exit exit_gfs2_fs(void)
>
> rcu_barrier();
>
> - mempool_destroy(gfs2_page_pool);
> + mempool_destroy(gfs2_log_buf_pool);
> kmem_cache_destroy(gfs2_trans_cachep);
> kmem_cache_destroy(gfs2_qadata_cachep);
> kmem_cache_destroy(gfs2_quotad_cachep);
> diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
> index 529c3ec37a18..1fd5f817312b 100644
> --- a/fs/gfs2/util.c
> +++ b/fs/gfs2/util.c
> @@ -34,7 +34,7 @@ struct kmem_cache *gfs2_rgrpd_cachep __read_mostly;
> struct kmem_cache *gfs2_quotad_cachep __read_mostly;
> struct kmem_cache *gfs2_qadata_cachep __read_mostly;
> struct kmem_cache *gfs2_trans_cachep __read_mostly;
> -mempool_t *gfs2_page_pool __read_mostly;
> +mempool_t *gfs2_log_buf_pool __read_mostly;
>
> void gfs2_assert_i(struct gfs2_sbd *sdp)
> {
> diff --git a/fs/gfs2/util.h b/fs/gfs2/util.h
> index ffcc47d6b0b4..399c20004283 100644
> --- a/fs/gfs2/util.h
> +++ b/fs/gfs2/util.h
> @@ -165,7 +165,7 @@ extern struct kmem_cache *gfs2_rgrpd_cachep;
> extern struct kmem_cache *gfs2_quotad_cachep;
> extern struct kmem_cache *gfs2_qadata_cachep;
> extern struct kmem_cache *gfs2_trans_cachep;
> -extern mempool_t *gfs2_page_pool;
> +extern mempool_t *gfs2_log_buf_pool;
> extern struct workqueue_struct *gfs2_control_wq;
>
> static inline unsigned int gfs2_tune_get_i(struct gfs2_tune *gt,
>
> --
> 2.39.5
>

Thanks,
Andreas