f2fs: iostat: support accounting compressed IO

Previously, we supported to account FS_CDATA_READ_IO type IO only,
in this patch, it adds to account more type IO for compressed file:
- APP_BUFFERED_CDATA_IO
- APP_MAPPED_CDATA_IO
- FS_CDATA_IO
- APP_BUFFERED_CDATA_READ_IO
- APP_MAPPED_CDATA_READ_IO

Signed-off-by: Chao Yu <chao.yu@oppo.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 8259e0fa97e1fcda7dd6e8ff10044a2ca50ab2f4..7de48e791920cfaf2a3084ee29f508fdc4f90526 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -89,7 +89,7 @@ repeat:
                return ERR_PTR(err);
        }
 
-       f2fs_update_iostat(sbi, FS_META_READ_IO, F2FS_BLKSIZE);
+       f2fs_update_iostat(sbi, NULL, FS_META_READ_IO, F2FS_BLKSIZE);
 
        lock_page(page);
        if (unlikely(page->mapping != mapping)) {
@@ -276,7 +276,8 @@ int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
                f2fs_put_page(page, err ? 1 : 0);
 
                if (!err)
-                       f2fs_update_iostat(sbi, FS_META_READ_IO, F2FS_BLKSIZE);
+                       f2fs_update_iostat(sbi, NULL, FS_META_READ_IO,
+                                                       F2FS_BLKSIZE);
        }
 out:
        blk_finish_plug(&plug);

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index aa3ccddfa037612cf0c63721e1e5f975e5598947..0869fbbb5516f38a295809133682c39f1a073518 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1083,7 +1083,7 @@ static int f2fs_submit_page_read(struct inode *inode, struct page *page,
        }
        ClearPageError(page);
        inc_page_count(sbi, F2FS_RD_DATA);
-       f2fs_update_iostat(sbi, FS_DATA_READ_IO, F2FS_BLKSIZE);
+       f2fs_update_iostat(sbi, NULL, FS_DATA_READ_IO, F2FS_BLKSIZE);
        __submit_bio(sbi, bio, DATA);
        return 0;
 }
@@ -2122,7 +2122,8 @@ submit_and_realloc:
                goto submit_and_realloc;
 
        inc_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);
-       f2fs_update_iostat(F2FS_I_SB(inode), FS_DATA_READ_IO, F2FS_BLKSIZE);
+       f2fs_update_iostat(F2FS_I_SB(inode), NULL, FS_DATA_READ_IO,
+                                                       F2FS_BLKSIZE);
        ClearPageError(page);
        *last_block_in_bio = block_nr;
        goto out;
@@ -2270,8 +2271,7 @@ submit_and_realloc:
                refcount_inc(&dic->refcnt);
 
                inc_page_count(sbi, F2FS_RD_DATA);
-               f2fs_update_iostat(sbi, FS_DATA_READ_IO, F2FS_BLKSIZE);
-               f2fs_update_iostat(sbi, FS_CDATA_READ_IO, F2FS_BLKSIZE);
+               f2fs_update_iostat(sbi, inode, FS_DATA_READ_IO, F2FS_BLKSIZE);
                ClearPageError(page);
                *last_block_in_bio = blkaddr;
        }

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 3c7cdb70fe2efc841379cee0e4968c6b60b6f706..809419a258ed205364ba65dc029a7ea69c81429b 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1158,7 +1158,10 @@ enum iostat_type {
        APP_BUFFERED_IO,                /* app buffered write IOs */
        APP_WRITE_IO,                   /* app write IOs */
        APP_MAPPED_IO,                  /* app mapped IOs */
+       APP_BUFFERED_CDATA_IO,          /* app buffered write IOs on compressed file */
+       APP_MAPPED_CDATA_IO,            /* app mapped write IOs on compressed file */
        FS_DATA_IO,                     /* data IOs from kworker/fsync/reclaimer */
+       FS_CDATA_IO,                    /* data IOs from kworker/fsync/reclaimer on compressed file */
        FS_NODE_IO,                     /* node IOs from kworker/fsync/reclaimer */
        FS_META_IO,                     /* meta IOs from kworker/reclaimer */
        FS_GC_DATA_IO,                  /* data IOs from forground gc */
@@ -1172,6 +1175,8 @@ enum iostat_type {
        APP_BUFFERED_READ_IO,           /* app buffered read IOs */
        APP_READ_IO,                    /* app read IOs */
        APP_MAPPED_READ_IO,             /* app mapped read IOs */
+       APP_BUFFERED_CDATA_READ_IO,     /* app buffered read IOs on compressed file  */
+       APP_MAPPED_CDATA_READ_IO,       /* app mapped read IOs on compressed file  */
        FS_DATA_READ_IO,                /* data read IOs */
        FS_GDATA_READ_IO,               /* data read IOs from background gc */
        FS_CDATA_READ_IO,               /* compressed data read IOs */

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index ce4905a073b3c413a751efc0dec5069a1a5e32c7..771f1f7f3690c030de0e6241eb225c597d9859e4 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -43,8 +43,8 @@ static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
 
        ret = filemap_fault(vmf);
        if (!ret)
-               f2fs_update_iostat(F2FS_I_SB(inode), APP_MAPPED_READ_IO,
-                                                       F2FS_BLKSIZE);
+               f2fs_update_iostat(F2FS_I_SB(inode), inode,
+                                       APP_MAPPED_READ_IO, F2FS_BLKSIZE);
 
        trace_f2fs_filemap_fault(inode, vmf->pgoff, (unsigned long)ret);
 
@@ -154,7 +154,7 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
        if (!PageUptodate(page))
                SetPageUptodate(page);
 
-       f2fs_update_iostat(sbi, APP_MAPPED_IO, F2FS_BLKSIZE);
+       f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, F2FS_BLKSIZE);
        f2fs_update_time(sbi, REQ_TIME);
 
        trace_f2fs_vm_page_mkwrite(page, DATA);
@@ -4212,7 +4212,7 @@ static int f2fs_dio_read_end_io(struct kiocb *iocb, ssize_t size, int error,
        dec_page_count(sbi, F2FS_DIO_READ);
        if (error)
                return error;
-       f2fs_update_iostat(sbi, APP_DIRECT_READ_IO, size);
+       f2fs_update_iostat(sbi, NULL, APP_DIRECT_READ_IO, size);
        return 0;
 }
 
@@ -4301,7 +4301,8 @@ skip_read_trace:
        } else {
                ret = filemap_read(iocb, to, 0);
                if (ret > 0)
-                       f2fs_update_iostat(F2FS_I_SB(inode), APP_BUFFERED_READ_IO, ret);
+                       f2fs_update_iostat(F2FS_I_SB(inode), inode,
+                                               APP_BUFFERED_READ_IO, ret);
        }
        if (trace_f2fs_dataread_end_enabled())
                trace_f2fs_dataread_end(inode, pos, ret);
@@ -4418,7 +4419,8 @@ static ssize_t f2fs_buffered_write_iter(struct kiocb *iocb,
 
        if (ret > 0) {
                iocb->ki_pos += ret;
-               f2fs_update_iostat(F2FS_I_SB(inode), APP_BUFFERED_IO, ret);
+               f2fs_update_iostat(F2FS_I_SB(inode), inode,
+                                               APP_BUFFERED_IO, ret);
        }
        return ret;
 }
@@ -4431,7 +4433,7 @@ static int f2fs_dio_write_end_io(struct kiocb *iocb, ssize_t size, int error,
        dec_page_count(sbi, F2FS_DIO_WRITE);
        if (error)
                return error;
-       f2fs_update_iostat(sbi, APP_DIRECT_IO, size);
+       f2fs_update_iostat(sbi, NULL, APP_DIRECT_IO, size);
        return 0;
 }
 

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 45f90e3c46d4b6d42b67567b4d2ad89f542cfebe..2a3816c20f846e9a765f70f13d4072c7215ff60f 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1202,8 +1202,8 @@ got_it:
        f2fs_put_page(fio.encrypted_page, 0);
        f2fs_put_page(page, 1);
 
-       f2fs_update_iostat(sbi, FS_DATA_READ_IO, F2FS_BLKSIZE);
-       f2fs_update_iostat(sbi, FS_GDATA_READ_IO, F2FS_BLKSIZE);
+       f2fs_update_iostat(sbi, inode, FS_DATA_READ_IO, F2FS_BLKSIZE);
+       f2fs_update_iostat(sbi, NULL, FS_GDATA_READ_IO, F2FS_BLKSIZE);
 
        return 0;
 put_encrypted_page:
@@ -1303,8 +1303,10 @@ static int move_data_block(struct inode *inode, block_t bidx,
                        goto up_out;
                }
 
-               f2fs_update_iostat(fio.sbi, FS_DATA_READ_IO, F2FS_BLKSIZE);
-               f2fs_update_iostat(fio.sbi, FS_GDATA_READ_IO, F2FS_BLKSIZE);
+               f2fs_update_iostat(fio.sbi, inode, FS_DATA_READ_IO,
+                                                       F2FS_BLKSIZE);
+               f2fs_update_iostat(fio.sbi, NULL, FS_GDATA_READ_IO,
+                                                       F2FS_BLKSIZE);
 
                lock_page(mpage);
                if (unlikely(mpage->mapping != META_MAPPING(fio.sbi) ||
@@ -1356,7 +1358,7 @@ static int move_data_block(struct inode *inode, block_t bidx,
                goto put_page_out;
        }
 
-       f2fs_update_iostat(fio.sbi, FS_GC_DATA_IO, F2FS_BLKSIZE);
+       f2fs_update_iostat(fio.sbi, NULL, FS_GC_DATA_IO, F2FS_BLKSIZE);
 
        f2fs_update_data_blkaddr(&dn, newaddr);
        set_inode_flag(inode, FI_APPEND_WRITE);

diff --git a/fs/f2fs/iostat.c b/fs/f2fs/iostat.c
index d84c5f6cc09d74230c42c04ea7efbd03e2af8665..3166a8939ed4f4f3ffae033adc4d462ca9cf26b6 100644 (file)
--- a/fs/f2fs/iostat.c
+++ b/fs/f2fs/iostat.c
@@ -31,55 +31,65 @@ int __maybe_unused iostat_info_seq_show(struct seq_file *seq, void *offset)
 
        /* print app write IOs */
        seq_puts(seq, "[WRITE]\n");
-       seq_printf(seq, "app buffered:  %-16llu\n",
+       seq_printf(seq, "app buffered data:     %-16llu\n",
                                sbi->rw_iostat[APP_BUFFERED_IO]);
-       seq_printf(seq, "app direct:    %-16llu\n",
+       seq_printf(seq, "app direct data:       %-16llu\n",
                                sbi->rw_iostat[APP_DIRECT_IO]);
-       seq_printf(seq, "app mapped:    %-16llu\n",
+       seq_printf(seq, "app mapped data:       %-16llu\n",
                                sbi->rw_iostat[APP_MAPPED_IO]);
+       seq_printf(seq, "app buffered cdata:    %-16llu\n",
+                               sbi->rw_iostat[APP_BUFFERED_CDATA_IO]);
+       seq_printf(seq, "app mapped cdata:      %-16llu\n",
+                               sbi->rw_iostat[APP_MAPPED_CDATA_IO]);
 
        /* print fs write IOs */
-       seq_printf(seq, "fs data:       %-16llu\n",
+       seq_printf(seq, "fs data:               %-16llu\n",
                                sbi->rw_iostat[FS_DATA_IO]);
-       seq_printf(seq, "fs node:       %-16llu\n",
+       seq_printf(seq, "fs cdata:              %-16llu\n",
+                               sbi->rw_iostat[FS_CDATA_IO]);
+       seq_printf(seq, "fs node:               %-16llu\n",
                                sbi->rw_iostat[FS_NODE_IO]);
-       seq_printf(seq, "fs meta:       %-16llu\n",
+       seq_printf(seq, "fs meta:               %-16llu\n",
                                sbi->rw_iostat[FS_META_IO]);
-       seq_printf(seq, "fs gc data:    %-16llu\n",
+       seq_printf(seq, "fs gc data:            %-16llu\n",
                                sbi->rw_iostat[FS_GC_DATA_IO]);
-       seq_printf(seq, "fs gc node:    %-16llu\n",
+       seq_printf(seq, "fs gc node:            %-16llu\n",
                                sbi->rw_iostat[FS_GC_NODE_IO]);
-       seq_printf(seq, "fs cp data:    %-16llu\n",
+       seq_printf(seq, "fs cp data:            %-16llu\n",
                                sbi->rw_iostat[FS_CP_DATA_IO]);
-       seq_printf(seq, "fs cp node:    %-16llu\n",
+       seq_printf(seq, "fs cp node:            %-16llu\n",
                                sbi->rw_iostat[FS_CP_NODE_IO]);
-       seq_printf(seq, "fs cp meta:    %-16llu\n",
+       seq_printf(seq, "fs cp meta:            %-16llu\n",
                                sbi->rw_iostat[FS_CP_META_IO]);
 
        /* print app read IOs */
        seq_puts(seq, "[READ]\n");
-       seq_printf(seq, "app buffered:  %-16llu\n",
+       seq_printf(seq, "app buffered data:     %-16llu\n",
                                sbi->rw_iostat[APP_BUFFERED_READ_IO]);
-       seq_printf(seq, "app direct:    %-16llu\n",
+       seq_printf(seq, "app direct data:       %-16llu\n",
                                sbi->rw_iostat[APP_DIRECT_READ_IO]);
-       seq_printf(seq, "app mapped:    %-16llu\n",
+       seq_printf(seq, "app mapped data:       %-16llu\n",
                                sbi->rw_iostat[APP_MAPPED_READ_IO]);
+       seq_printf(seq, "app buffered cdata:    %-16llu\n",
+                               sbi->rw_iostat[APP_BUFFERED_CDATA_READ_IO]);
+       seq_printf(seq, "app mapped cdata:      %-16llu\n",
+                               sbi->rw_iostat[APP_MAPPED_CDATA_READ_IO]);
 
        /* print fs read IOs */
-       seq_printf(seq, "fs data:       %-16llu\n",
+       seq_printf(seq, "fs data:               %-16llu\n",
                                sbi->rw_iostat[FS_DATA_READ_IO]);
-       seq_printf(seq, "fs gc data:    %-16llu\n",
+       seq_printf(seq, "fs gc data:            %-16llu\n",
                                sbi->rw_iostat[FS_GDATA_READ_IO]);
-       seq_printf(seq, "fs compr_data: %-16llu\n",
+       seq_printf(seq, "fs cdata:              %-16llu\n",
                                sbi->rw_iostat[FS_CDATA_READ_IO]);
-       seq_printf(seq, "fs node:       %-16llu\n",
+       seq_printf(seq, "fs node:               %-16llu\n",
                                sbi->rw_iostat[FS_NODE_READ_IO]);
-       seq_printf(seq, "fs meta:       %-16llu\n",
+       seq_printf(seq, "fs meta:               %-16llu\n",
                                sbi->rw_iostat[FS_META_READ_IO]);
 
        /* print other IOs */
        seq_puts(seq, "[OTHER]\n");
-       seq_printf(seq, "fs discard:    %-16llu\n",
+       seq_printf(seq, "fs discard:            %-16llu\n",
                                sbi->rw_iostat[FS_DISCARD]);
 
        return 0;
@@ -159,7 +169,7 @@ void f2fs_reset_iostat(struct f2fs_sb_info *sbi)
        spin_unlock_irq(&sbi->iostat_lat_lock);
 }
 
-void f2fs_update_iostat(struct f2fs_sb_info *sbi,
+void f2fs_update_iostat(struct f2fs_sb_info *sbi, struct inode *inode,
                        enum iostat_type type, unsigned long long io_bytes)
 {
        unsigned long flags;
@@ -176,6 +186,28 @@ void f2fs_update_iostat(struct f2fs_sb_info *sbi,
        if (type == APP_BUFFERED_READ_IO || type == APP_DIRECT_READ_IO)
                sbi->rw_iostat[APP_READ_IO] += io_bytes;
 
+#ifdef CONFIG_F2FS_FS_COMPRESSION
+       if (inode && f2fs_compressed_file(inode)) {
+               if (type == APP_BUFFERED_IO)
+                       sbi->rw_iostat[APP_BUFFERED_CDATA_IO] += io_bytes;
+
+               if (type == APP_BUFFERED_READ_IO)
+                       sbi->rw_iostat[APP_BUFFERED_CDATA_READ_IO] += io_bytes;
+
+               if (type == APP_MAPPED_READ_IO)
+                       sbi->rw_iostat[APP_MAPPED_CDATA_READ_IO] += io_bytes;
+
+               if (type == APP_MAPPED_IO)
+                       sbi->rw_iostat[APP_MAPPED_CDATA_IO] += io_bytes;
+
+               if (type == FS_DATA_READ_IO)
+                       sbi->rw_iostat[FS_CDATA_READ_IO] += io_bytes;
+
+               if (type == FS_DATA_IO)
+                       sbi->rw_iostat[FS_CDATA_IO] += io_bytes;
+       }
+#endif
+
        spin_unlock_irqrestore(&sbi->iostat_lock, flags);
 
        f2fs_record_iostat(sbi);

diff --git a/fs/f2fs/iostat.h b/fs/f2fs/iostat.h
index 22a2d01f57ef3b6116491502ef01a9c15dc167af..2c048307b6e0b5ebba099872a046f81c0f8fe87a 100644 (file)
--- a/fs/f2fs/iostat.h
+++ b/fs/f2fs/iostat.h
@@ -31,7 +31,7 @@ struct iostat_lat_info {
 extern int __maybe_unused iostat_info_seq_show(struct seq_file *seq,
                        void *offset);
 extern void f2fs_reset_iostat(struct f2fs_sb_info *sbi);
-extern void f2fs_update_iostat(struct f2fs_sb_info *sbi,
+extern void f2fs_update_iostat(struct f2fs_sb_info *sbi, struct inode *inode,
                        enum iostat_type type, unsigned long long io_bytes);
 
 struct bio_iostat_ctx {
@@ -65,7 +65,7 @@ extern void f2fs_destroy_iostat_processing(void);
 extern int f2fs_init_iostat(struct f2fs_sb_info *sbi);
 extern void f2fs_destroy_iostat(struct f2fs_sb_info *sbi);
 #else
-static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi,
+static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi, struct inode *inode,
                enum iostat_type type, unsigned long long io_bytes) {}
 static inline void iostat_update_and_unbind_ctx(struct bio *bio, int rw) {}
 static inline void iostat_alloc_and_bind_ctx(struct f2fs_sb_info *sbi,

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index e06a0c478b39a287c7a7b303a466d59f0fb87bfd..2484285be3ad93d8dc421a1dd3837f039c10d50a 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1369,7 +1369,7 @@ static int read_node_page(struct page *page, blk_opf_t op_flags)
        err = f2fs_submit_page_bio(&fio);
 
        if (!err)
-               f2fs_update_iostat(sbi, FS_NODE_READ_IO, F2FS_BLKSIZE);
+               f2fs_update_iostat(sbi, NULL, FS_NODE_READ_IO, F2FS_BLKSIZE);
 
        return err;
 }

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 0de21f82d7bc835c6df05e1ba8a6b8b6d7918e25..a5054725d0b63ef495ed9ad0bcb36cd5571073a0 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -1171,7 +1171,7 @@ submit:
 
                atomic_inc(&dcc->issued_discard);
 
-               f2fs_update_iostat(sbi, FS_DISCARD, 1);
+               f2fs_update_iostat(sbi, NULL, FS_DISCARD, 1);
 
                lstart += len;
                start += len;
@@ -3388,7 +3388,7 @@ void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct page *page,
        f2fs_submit_page_write(&fio);
 
        stat_inc_meta_count(sbi, page->index);
-       f2fs_update_iostat(sbi, io_type, F2FS_BLKSIZE);
+       f2fs_update_iostat(sbi, NULL, io_type, F2FS_BLKSIZE);
 }
 
 void f2fs_do_write_node_page(unsigned int nid, struct f2fs_io_info *fio)
@@ -3398,7 +3398,7 @@ void f2fs_do_write_node_page(unsigned int nid, struct f2fs_io_info *fio)
        set_summary(&sum, nid, 0, 0);
        do_write_page(&sum, fio);
 
-       f2fs_update_iostat(fio->sbi, fio->io_type, F2FS_BLKSIZE);
+       f2fs_update_iostat(fio->sbi, NULL, fio->io_type, F2FS_BLKSIZE);
 }
 
 void f2fs_outplace_write_data(struct dnode_of_data *dn,
@@ -3412,7 +3412,7 @@ void f2fs_outplace_write_data(struct dnode_of_data *dn,
        do_write_page(&sum, fio);
        f2fs_update_data_blkaddr(dn, fio->new_blkaddr);
 
-       f2fs_update_iostat(sbi, fio->io_type, F2FS_BLKSIZE);
+       f2fs_update_iostat(sbi, dn->inode, fio->io_type, F2FS_BLKSIZE);
 }
 
 int f2fs_inplace_write_data(struct f2fs_io_info *fio)
@@ -3453,7 +3453,8 @@ int f2fs_inplace_write_data(struct f2fs_io_info *fio)
        if (!err) {
                f2fs_update_device_state(fio->sbi, fio->ino,
                                                fio->new_blkaddr, 1);
-               f2fs_update_iostat(fio->sbi, fio->io_type, F2FS_BLKSIZE);
+               f2fs_update_iostat(fio->sbi, fio->page->mapping->host,
+                                               fio->io_type, F2FS_BLKSIZE);
        }
 
        return err;

diff --git a/include/trace/events/f2fs.h b/include/trace/events/f2fs.h
index f1e922237736807d8d4f03357c9d4a3bcbc89309..b262985f0c3a275c24a09f70bfb91492a41ec2e5 100644 (file)
--- a/include/trace/events/f2fs.h
+++ b/include/trace/events/f2fs.h
@@ -1823,7 +1823,10 @@ TRACE_EVENT(f2fs_iostat,
                __field(unsigned long long,     app_bio)
                __field(unsigned long long,     app_wio)
                __field(unsigned long long,     app_mio)
+               __field(unsigned long long,     app_bcdio)
+               __field(unsigned long long,     app_mcdio)
                __field(unsigned long long,     fs_dio)
+               __field(unsigned long long,     fs_cdio)
                __field(unsigned long long,     fs_nio)
                __field(unsigned long long,     fs_mio)
                __field(unsigned long long,     fs_gc_dio)
@@ -1835,6 +1838,8 @@ TRACE_EVENT(f2fs_iostat,
                __field(unsigned long long,     app_brio)
                __field(unsigned long long,     app_rio)
                __field(unsigned long long,     app_mrio)
+               __field(unsigned long long,     app_bcrio)
+               __field(unsigned long long,     app_mcrio)
                __field(unsigned long long,     fs_drio)
                __field(unsigned long long,     fs_gdrio)
                __field(unsigned long long,     fs_cdrio)
@@ -1849,7 +1854,10 @@ TRACE_EVENT(f2fs_iostat,
                __entry->app_bio        = iostat[APP_BUFFERED_IO];
                __entry->app_wio        = iostat[APP_WRITE_IO];
                __entry->app_mio        = iostat[APP_MAPPED_IO];
+               __entry->app_bcdio      = iostat[APP_BUFFERED_CDATA_IO];
+               __entry->app_mcdio      = iostat[APP_MAPPED_CDATA_IO];
                __entry->fs_dio         = iostat[FS_DATA_IO];
+               __entry->fs_cdio        = iostat[FS_CDATA_IO];
                __entry->fs_nio         = iostat[FS_NODE_IO];
                __entry->fs_mio         = iostat[FS_META_IO];
                __entry->fs_gc_dio      = iostat[FS_GC_DATA_IO];
@@ -1861,6 +1869,8 @@ TRACE_EVENT(f2fs_iostat,
                __entry->app_brio       = iostat[APP_BUFFERED_READ_IO];
                __entry->app_rio        = iostat[APP_READ_IO];
                __entry->app_mrio       = iostat[APP_MAPPED_READ_IO];
+               __entry->app_bcrio      = iostat[APP_BUFFERED_CDATA_READ_IO];
+               __entry->app_mcrio      = iostat[APP_MAPPED_CDATA_READ_IO];
                __entry->fs_drio        = iostat[FS_DATA_READ_IO];
                __entry->fs_gdrio       = iostat[FS_GDATA_READ_IO];
                __entry->fs_cdrio       = iostat[FS_CDATA_READ_IO];
@@ -1870,20 +1880,24 @@ TRACE_EVENT(f2fs_iostat,
        ),
 
        TP_printk("dev = (%d,%d), "
-               "app [write=%llu (direct=%llu, buffered=%llu), mapped=%llu], "
-               "fs [data=%llu, node=%llu, meta=%llu, discard=%llu], "
+               "app [write=%llu (direct=%llu, buffered=%llu), mapped=%llu, "
+               "compr(buffered=%llu, mapped=%llu)], "
+               "fs [data=%llu, cdata=%llu, node=%llu, meta=%llu, discard=%llu], "
                "gc [data=%llu, node=%llu], "
                "cp [data=%llu, node=%llu, meta=%llu], "
                "app [read=%llu (direct=%llu, buffered=%llu), mapped=%llu], "
-               "fs [data=%llu, (gc_data=%llu, compr_data=%llu), "
+               "compr(buffered=%llu, mapped=%llu)], "
+               "fs [data=%llu, (gc_data=%llu, cdata=%llu), "
                "node=%llu, meta=%llu]",
                show_dev(__entry->dev), __entry->app_wio, __entry->app_dio,
-               __entry->app_bio, __entry->app_mio, __entry->fs_dio,
+               __entry->app_bio, __entry->app_mio, __entry->app_bcdio,
+               __entry->app_mcdio, __entry->fs_dio, __entry->fs_cdio,
                __entry->fs_nio, __entry->fs_mio, __entry->fs_discard,
                __entry->fs_gc_dio, __entry->fs_gc_nio, __entry->fs_cp_dio,
                __entry->fs_cp_nio, __entry->fs_cp_mio,
                __entry->app_rio, __entry->app_drio, __entry->app_brio,
-               __entry->app_mrio, __entry->fs_drio, __entry->fs_gdrio,
+               __entry->app_mrio, __entry->app_bcrio, __entry->app_mcrio,
+               __entry->fs_drio, __entry->fs_gdrio,
                __entry->fs_cdrio, __entry->fs_nrio, __entry->fs_mrio)
 );