f2fs: iostat: support accounting compressed IO

+3 -2

fs/f2fs/checkpoint.c

··· 89 89 return ERR_PTR(err); 90 90 } 91 91 92 - f2fs_update_iostat(sbi, FS_META_READ_IO, F2FS_BLKSIZE); 92 + f2fs_update_iostat(sbi, NULL, FS_META_READ_IO, F2FS_BLKSIZE); 93 93 94 94 lock_page(page); 95 95 if (unlikely(page->mapping != mapping)) { ··· 276 276 f2fs_put_page(page, err ? 1 : 0); 277 277 278 278 if (!err) 279 - f2fs_update_iostat(sbi, FS_META_READ_IO, F2FS_BLKSIZE); 279 + f2fs_update_iostat(sbi, NULL, FS_META_READ_IO, 280 + F2FS_BLKSIZE); 280 281 } 281 282 out: 282 283 blk_finish_plug(&plug);

+4 -4

fs/f2fs/data.c

··· 1083 1083 } 1084 1084 ClearPageError(page); 1085 1085 inc_page_count(sbi, F2FS_RD_DATA); 1086 - f2fs_update_iostat(sbi, FS_DATA_READ_IO, F2FS_BLKSIZE); 1086 + f2fs_update_iostat(sbi, NULL, FS_DATA_READ_IO, F2FS_BLKSIZE); 1087 1087 __submit_bio(sbi, bio, DATA); 1088 1088 return 0; 1089 1089 } ··· 2122 2122 goto submit_and_realloc; 2123 2123 2124 2124 inc_page_count(F2FS_I_SB(inode), F2FS_RD_DATA); 2125 - f2fs_update_iostat(F2FS_I_SB(inode), FS_DATA_READ_IO, F2FS_BLKSIZE); 2125 + f2fs_update_iostat(F2FS_I_SB(inode), NULL, FS_DATA_READ_IO, 2126 + F2FS_BLKSIZE); 2126 2127 ClearPageError(page); 2127 2128 *last_block_in_bio = block_nr; 2128 2129 goto out; ··· 2271 2270 refcount_inc(&dic->refcnt); 2272 2271 2273 2272 inc_page_count(sbi, F2FS_RD_DATA); 2274 - f2fs_update_iostat(sbi, FS_DATA_READ_IO, F2FS_BLKSIZE); 2275 - f2fs_update_iostat(sbi, FS_CDATA_READ_IO, F2FS_BLKSIZE); 2273 + f2fs_update_iostat(sbi, inode, FS_DATA_READ_IO, F2FS_BLKSIZE); 2276 2274 ClearPageError(page); 2277 2275 *last_block_in_bio = blkaddr; 2278 2276 }

+5

fs/f2fs/f2fs.h

··· 1158 1158 APP_BUFFERED_IO, /* app buffered write IOs */ 1159 1159 APP_WRITE_IO, /* app write IOs */ 1160 1160 APP_MAPPED_IO, /* app mapped IOs */ 1161 + APP_BUFFERED_CDATA_IO, /* app buffered write IOs on compressed file */ 1162 + APP_MAPPED_CDATA_IO, /* app mapped write IOs on compressed file */ 1161 1163 FS_DATA_IO, /* data IOs from kworker/fsync/reclaimer */ 1164 + FS_CDATA_IO, /* data IOs from kworker/fsync/reclaimer on compressed file */ 1162 1165 FS_NODE_IO, /* node IOs from kworker/fsync/reclaimer */ 1163 1166 FS_META_IO, /* meta IOs from kworker/reclaimer */ 1164 1167 FS_GC_DATA_IO, /* data IOs from forground gc */ ··· 1175 1172 APP_BUFFERED_READ_IO, /* app buffered read IOs */ 1176 1173 APP_READ_IO, /* app read IOs */ 1177 1174 APP_MAPPED_READ_IO, /* app mapped read IOs */ 1175 + APP_BUFFERED_CDATA_READ_IO, /* app buffered read IOs on compressed file */ 1176 + APP_MAPPED_CDATA_READ_IO, /* app mapped read IOs on compressed file */ 1178 1177 FS_DATA_READ_IO, /* data read IOs */ 1179 1178 FS_GDATA_READ_IO, /* data read IOs from background gc */ 1180 1179 FS_CDATA_READ_IO, /* compressed data read IOs */

+9 -7

fs/f2fs/file.c

··· 43 43 44 44 ret = filemap_fault(vmf); 45 45 if (!ret) 46 - f2fs_update_iostat(F2FS_I_SB(inode), APP_MAPPED_READ_IO, 47 - F2FS_BLKSIZE); 46 + f2fs_update_iostat(F2FS_I_SB(inode), inode, 47 + APP_MAPPED_READ_IO, F2FS_BLKSIZE); 48 48 49 49 trace_f2fs_filemap_fault(inode, vmf->pgoff, (unsigned long)ret); 50 50 ··· 154 154 if (!PageUptodate(page)) 155 155 SetPageUptodate(page); 156 156 157 - f2fs_update_iostat(sbi, APP_MAPPED_IO, F2FS_BLKSIZE); 157 + f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, F2FS_BLKSIZE); 158 158 f2fs_update_time(sbi, REQ_TIME); 159 159 160 160 trace_f2fs_vm_page_mkwrite(page, DATA); ··· 4212 4212 dec_page_count(sbi, F2FS_DIO_READ); 4213 4213 if (error) 4214 4214 return error; 4215 - f2fs_update_iostat(sbi, APP_DIRECT_READ_IO, size); 4215 + f2fs_update_iostat(sbi, NULL, APP_DIRECT_READ_IO, size); 4216 4216 return 0; 4217 4217 } 4218 4218 ··· 4301 4301 } else { 4302 4302 ret = filemap_read(iocb, to, 0); 4303 4303 if (ret > 0) 4304 - f2fs_update_iostat(F2FS_I_SB(inode), APP_BUFFERED_READ_IO, ret); 4304 + f2fs_update_iostat(F2FS_I_SB(inode), inode, 4305 + APP_BUFFERED_READ_IO, ret); 4305 4306 } 4306 4307 if (trace_f2fs_dataread_end_enabled()) 4307 4308 trace_f2fs_dataread_end(inode, pos, ret); ··· 4419 4418 4420 4419 if (ret > 0) { 4421 4420 iocb->ki_pos += ret; 4422 - f2fs_update_iostat(F2FS_I_SB(inode), APP_BUFFERED_IO, ret); 4421 + f2fs_update_iostat(F2FS_I_SB(inode), inode, 4422 + APP_BUFFERED_IO, ret); 4423 4423 } 4424 4424 return ret; 4425 4425 } ··· 4433 4431 dec_page_count(sbi, F2FS_DIO_WRITE); 4434 4432 if (error) 4435 4433 return error; 4436 - f2fs_update_iostat(sbi, APP_DIRECT_IO, size); 4434 + f2fs_update_iostat(sbi, NULL, APP_DIRECT_IO, size); 4437 4435 return 0; 4438 4436 } 4439 4437

+7 -5

fs/f2fs/gc.c

··· 1202 1202 f2fs_put_page(fio.encrypted_page, 0); 1203 1203 f2fs_put_page(page, 1); 1204 1204 1205 - f2fs_update_iostat(sbi, FS_DATA_READ_IO, F2FS_BLKSIZE); 1206 - f2fs_update_iostat(sbi, FS_GDATA_READ_IO, F2FS_BLKSIZE); 1205 + f2fs_update_iostat(sbi, inode, FS_DATA_READ_IO, F2FS_BLKSIZE); 1206 + f2fs_update_iostat(sbi, NULL, FS_GDATA_READ_IO, F2FS_BLKSIZE); 1207 1207 1208 1208 return 0; 1209 1209 put_encrypted_page: ··· 1303 1303 goto up_out; 1304 1304 } 1305 1305 1306 - f2fs_update_iostat(fio.sbi, FS_DATA_READ_IO, F2FS_BLKSIZE); 1307 - f2fs_update_iostat(fio.sbi, FS_GDATA_READ_IO, F2FS_BLKSIZE); 1306 + f2fs_update_iostat(fio.sbi, inode, FS_DATA_READ_IO, 1307 + F2FS_BLKSIZE); 1308 + f2fs_update_iostat(fio.sbi, NULL, FS_GDATA_READ_IO, 1309 + F2FS_BLKSIZE); 1308 1310 1309 1311 lock_page(mpage); 1310 1312 if (unlikely(mpage->mapping != META_MAPPING(fio.sbi) || ··· 1358 1356 goto put_page_out; 1359 1357 } 1360 1358 1361 - f2fs_update_iostat(fio.sbi, FS_GC_DATA_IO, F2FS_BLKSIZE); 1359 + f2fs_update_iostat(fio.sbi, NULL, FS_GC_DATA_IO, F2FS_BLKSIZE); 1362 1360 1363 1361 f2fs_update_data_blkaddr(&dn, newaddr); 1364 1362 set_inode_flag(inode, FI_APPEND_WRITE);

+53 -21

fs/f2fs/iostat.c

··· 31 31 32 32 /* print app write IOs */ 33 33 seq_puts(seq, "[WRITE]\n"); 34 - seq_printf(seq, "app buffered: %-16llu\n", 34 + seq_printf(seq, "app buffered data: %-16llu\n", 35 35 sbi->rw_iostat[APP_BUFFERED_IO]); 36 - seq_printf(seq, "app direct: %-16llu\n", 36 + seq_printf(seq, "app direct data: %-16llu\n", 37 37 sbi->rw_iostat[APP_DIRECT_IO]); 38 - seq_printf(seq, "app mapped: %-16llu\n", 38 + seq_printf(seq, "app mapped data: %-16llu\n", 39 39 sbi->rw_iostat[APP_MAPPED_IO]); 40 + seq_printf(seq, "app buffered cdata: %-16llu\n", 41 + sbi->rw_iostat[APP_BUFFERED_CDATA_IO]); 42 + seq_printf(seq, "app mapped cdata: %-16llu\n", 43 + sbi->rw_iostat[APP_MAPPED_CDATA_IO]); 40 44 41 45 /* print fs write IOs */ 42 - seq_printf(seq, "fs data: %-16llu\n", 46 + seq_printf(seq, "fs data: %-16llu\n", 43 47 sbi->rw_iostat[FS_DATA_IO]); 44 - seq_printf(seq, "fs node: %-16llu\n", 48 + seq_printf(seq, "fs cdata: %-16llu\n", 49 + sbi->rw_iostat[FS_CDATA_IO]); 50 + seq_printf(seq, "fs node: %-16llu\n", 45 51 sbi->rw_iostat[FS_NODE_IO]); 46 - seq_printf(seq, "fs meta: %-16llu\n", 52 + seq_printf(seq, "fs meta: %-16llu\n", 47 53 sbi->rw_iostat[FS_META_IO]); 48 - seq_printf(seq, "fs gc data: %-16llu\n", 54 + seq_printf(seq, "fs gc data: %-16llu\n", 49 55 sbi->rw_iostat[FS_GC_DATA_IO]); 50 - seq_printf(seq, "fs gc node: %-16llu\n", 56 + seq_printf(seq, "fs gc node: %-16llu\n", 51 57 sbi->rw_iostat[FS_GC_NODE_IO]); 52 - seq_printf(seq, "fs cp data: %-16llu\n", 58 + seq_printf(seq, "fs cp data: %-16llu\n", 53 59 sbi->rw_iostat[FS_CP_DATA_IO]); 54 - seq_printf(seq, "fs cp node: %-16llu\n", 60 + seq_printf(seq, "fs cp node: %-16llu\n", 55 61 sbi->rw_iostat[FS_CP_NODE_IO]); 56 - seq_printf(seq, "fs cp meta: %-16llu\n", 62 + seq_printf(seq, "fs cp meta: %-16llu\n", 57 63 sbi->rw_iostat[FS_CP_META_IO]); 58 64 59 65 /* print app read IOs */ 60 66 seq_puts(seq, "[READ]\n"); 61 - seq_printf(seq, "app buffered: %-16llu\n", 67 + seq_printf(seq, "app buffered data: %-16llu\n", 62 68 sbi->rw_iostat[APP_BUFFERED_READ_IO]); 63 - seq_printf(seq, "app direct: %-16llu\n", 69 + seq_printf(seq, "app direct data: %-16llu\n", 64 70 sbi->rw_iostat[APP_DIRECT_READ_IO]); 65 - seq_printf(seq, "app mapped: %-16llu\n", 71 + seq_printf(seq, "app mapped data: %-16llu\n", 66 72 sbi->rw_iostat[APP_MAPPED_READ_IO]); 73 + seq_printf(seq, "app buffered cdata: %-16llu\n", 74 + sbi->rw_iostat[APP_BUFFERED_CDATA_READ_IO]); 75 + seq_printf(seq, "app mapped cdata: %-16llu\n", 76 + sbi->rw_iostat[APP_MAPPED_CDATA_READ_IO]); 67 77 68 78 /* print fs read IOs */ 69 - seq_printf(seq, "fs data: %-16llu\n", 79 + seq_printf(seq, "fs data: %-16llu\n", 70 80 sbi->rw_iostat[FS_DATA_READ_IO]); 71 - seq_printf(seq, "fs gc data: %-16llu\n", 81 + seq_printf(seq, "fs gc data: %-16llu\n", 72 82 sbi->rw_iostat[FS_GDATA_READ_IO]); 73 - seq_printf(seq, "fs compr_data: %-16llu\n", 83 + seq_printf(seq, "fs cdata: %-16llu\n", 74 84 sbi->rw_iostat[FS_CDATA_READ_IO]); 75 - seq_printf(seq, "fs node: %-16llu\n", 85 + seq_printf(seq, "fs node: %-16llu\n", 76 86 sbi->rw_iostat[FS_NODE_READ_IO]); 77 - seq_printf(seq, "fs meta: %-16llu\n", 87 + seq_printf(seq, "fs meta: %-16llu\n", 78 88 sbi->rw_iostat[FS_META_READ_IO]); 79 89 80 90 /* print other IOs */ 81 91 seq_puts(seq, "[OTHER]\n"); 82 - seq_printf(seq, "fs discard: %-16llu\n", 92 + seq_printf(seq, "fs discard: %-16llu\n", 83 93 sbi->rw_iostat[FS_DISCARD]); 84 94 85 95 return 0; ··· 169 159 spin_unlock_irq(&sbi->iostat_lat_lock); 170 160 } 171 161 172 - void f2fs_update_iostat(struct f2fs_sb_info *sbi, 162 + void f2fs_update_iostat(struct f2fs_sb_info *sbi, struct inode *inode, 173 163 enum iostat_type type, unsigned long long io_bytes) 174 164 { 175 165 unsigned long flags; ··· 185 175 186 176 if (type == APP_BUFFERED_READ_IO || type == APP_DIRECT_READ_IO) 187 177 sbi->rw_iostat[APP_READ_IO] += io_bytes; 178 + 179 + #ifdef CONFIG_F2FS_FS_COMPRESSION 180 + if (inode && f2fs_compressed_file(inode)) { 181 + if (type == APP_BUFFERED_IO) 182 + sbi->rw_iostat[APP_BUFFERED_CDATA_IO] += io_bytes; 183 + 184 + if (type == APP_BUFFERED_READ_IO) 185 + sbi->rw_iostat[APP_BUFFERED_CDATA_READ_IO] += io_bytes; 186 + 187 + if (type == APP_MAPPED_READ_IO) 188 + sbi->rw_iostat[APP_MAPPED_CDATA_READ_IO] += io_bytes; 189 + 190 + if (type == APP_MAPPED_IO) 191 + sbi->rw_iostat[APP_MAPPED_CDATA_IO] += io_bytes; 192 + 193 + if (type == FS_DATA_READ_IO) 194 + sbi->rw_iostat[FS_CDATA_READ_IO] += io_bytes; 195 + 196 + if (type == FS_DATA_IO) 197 + sbi->rw_iostat[FS_CDATA_IO] += io_bytes; 198 + } 199 + #endif 188 200 189 201 spin_unlock_irqrestore(&sbi->iostat_lock, flags); 190 202

+2 -2

fs/f2fs/iostat.h

··· 31 31 extern int __maybe_unused iostat_info_seq_show(struct seq_file *seq, 32 32 void *offset); 33 33 extern void f2fs_reset_iostat(struct f2fs_sb_info *sbi); 34 - extern void f2fs_update_iostat(struct f2fs_sb_info *sbi, 34 + extern void f2fs_update_iostat(struct f2fs_sb_info *sbi, struct inode *inode, 35 35 enum iostat_type type, unsigned long long io_bytes); 36 36 37 37 struct bio_iostat_ctx { ··· 65 65 extern int f2fs_init_iostat(struct f2fs_sb_info *sbi); 66 66 extern void f2fs_destroy_iostat(struct f2fs_sb_info *sbi); 67 67 #else 68 - static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi, 68 + static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi, struct inode *inode, 69 69 enum iostat_type type, unsigned long long io_bytes) {} 70 70 static inline void iostat_update_and_unbind_ctx(struct bio *bio, int rw) {} 71 71 static inline void iostat_alloc_and_bind_ctx(struct f2fs_sb_info *sbi,

+1 -1

fs/f2fs/node.c

··· 1369 1369 err = f2fs_submit_page_bio(&fio); 1370 1370 1371 1371 if (!err) 1372 - f2fs_update_iostat(sbi, FS_NODE_READ_IO, F2FS_BLKSIZE); 1372 + f2fs_update_iostat(sbi, NULL, FS_NODE_READ_IO, F2FS_BLKSIZE); 1373 1373 1374 1374 return err; 1375 1375 }

+6 -5

fs/f2fs/segment.c

··· 1171 1171 1172 1172 atomic_inc(&dcc->issued_discard); 1173 1173 1174 - f2fs_update_iostat(sbi, FS_DISCARD, 1); 1174 + f2fs_update_iostat(sbi, NULL, FS_DISCARD, 1); 1175 1175 1176 1176 lstart += len; 1177 1177 start += len; ··· 3388 3388 f2fs_submit_page_write(&fio); 3389 3389 3390 3390 stat_inc_meta_count(sbi, page->index); 3391 - f2fs_update_iostat(sbi, io_type, F2FS_BLKSIZE); 3391 + f2fs_update_iostat(sbi, NULL, io_type, F2FS_BLKSIZE); 3392 3392 } 3393 3393 3394 3394 void f2fs_do_write_node_page(unsigned int nid, struct f2fs_io_info *fio) ··· 3398 3398 set_summary(&sum, nid, 0, 0); 3399 3399 do_write_page(&sum, fio); 3400 3400 3401 - f2fs_update_iostat(fio->sbi, fio->io_type, F2FS_BLKSIZE); 3401 + f2fs_update_iostat(fio->sbi, NULL, fio->io_type, F2FS_BLKSIZE); 3402 3402 } 3403 3403 3404 3404 void f2fs_outplace_write_data(struct dnode_of_data *dn, ··· 3412 3412 do_write_page(&sum, fio); 3413 3413 f2fs_update_data_blkaddr(dn, fio->new_blkaddr); 3414 3414 3415 - f2fs_update_iostat(sbi, fio->io_type, F2FS_BLKSIZE); 3415 + f2fs_update_iostat(sbi, dn->inode, fio->io_type, F2FS_BLKSIZE); 3416 3416 } 3417 3417 3418 3418 int f2fs_inplace_write_data(struct f2fs_io_info *fio) ··· 3453 3453 if (!err) { 3454 3454 f2fs_update_device_state(fio->sbi, fio->ino, 3455 3455 fio->new_blkaddr, 1); 3456 - f2fs_update_iostat(fio->sbi, fio->io_type, F2FS_BLKSIZE); 3456 + f2fs_update_iostat(fio->sbi, fio->page->mapping->host, 3457 + fio->io_type, F2FS_BLKSIZE); 3457 3458 } 3458 3459 3459 3460 return err;

+19 -5

include/trace/events/f2fs.h

··· 1823 1823 __field(unsigned long long, app_bio) 1824 1824 __field(unsigned long long, app_wio) 1825 1825 __field(unsigned long long, app_mio) 1826 + __field(unsigned long long, app_bcdio) 1827 + __field(unsigned long long, app_mcdio) 1826 1828 __field(unsigned long long, fs_dio) 1829 + __field(unsigned long long, fs_cdio) 1827 1830 __field(unsigned long long, fs_nio) 1828 1831 __field(unsigned long long, fs_mio) 1829 1832 __field(unsigned long long, fs_gc_dio) ··· 1838 1835 __field(unsigned long long, app_brio) 1839 1836 __field(unsigned long long, app_rio) 1840 1837 __field(unsigned long long, app_mrio) 1838 + __field(unsigned long long, app_bcrio) 1839 + __field(unsigned long long, app_mcrio) 1841 1840 __field(unsigned long long, fs_drio) 1842 1841 __field(unsigned long long, fs_gdrio) 1843 1842 __field(unsigned long long, fs_cdrio) ··· 1854 1849 __entry->app_bio = iostat[APP_BUFFERED_IO]; 1855 1850 __entry->app_wio = iostat[APP_WRITE_IO]; 1856 1851 __entry->app_mio = iostat[APP_MAPPED_IO]; 1852 + __entry->app_bcdio = iostat[APP_BUFFERED_CDATA_IO]; 1853 + __entry->app_mcdio = iostat[APP_MAPPED_CDATA_IO]; 1857 1854 __entry->fs_dio = iostat[FS_DATA_IO]; 1855 + __entry->fs_cdio = iostat[FS_CDATA_IO]; 1858 1856 __entry->fs_nio = iostat[FS_NODE_IO]; 1859 1857 __entry->fs_mio = iostat[FS_META_IO]; 1860 1858 __entry->fs_gc_dio = iostat[FS_GC_DATA_IO]; ··· 1869 1861 __entry->app_brio = iostat[APP_BUFFERED_READ_IO]; 1870 1862 __entry->app_rio = iostat[APP_READ_IO]; 1871 1863 __entry->app_mrio = iostat[APP_MAPPED_READ_IO]; 1864 + __entry->app_bcrio = iostat[APP_BUFFERED_CDATA_READ_IO]; 1865 + __entry->app_mcrio = iostat[APP_MAPPED_CDATA_READ_IO]; 1872 1866 __entry->fs_drio = iostat[FS_DATA_READ_IO]; 1873 1867 __entry->fs_gdrio = iostat[FS_GDATA_READ_IO]; 1874 1868 __entry->fs_cdrio = iostat[FS_CDATA_READ_IO]; ··· 1880 1870 ), 1881 1871 1882 1872 TP_printk("dev = (%d,%d), " 1883 - "app [write=%llu (direct=%llu, buffered=%llu), mapped=%llu], " 1884 - "fs [data=%llu, node=%llu, meta=%llu, discard=%llu], " 1873 + "app [write=%llu (direct=%llu, buffered=%llu), mapped=%llu, " 1874 + "compr(buffered=%llu, mapped=%llu)], " 1875 + "fs [data=%llu, cdata=%llu, node=%llu, meta=%llu, discard=%llu], " 1885 1876 "gc [data=%llu, node=%llu], " 1886 1877 "cp [data=%llu, node=%llu, meta=%llu], " 1887 1878 "app [read=%llu (direct=%llu, buffered=%llu), mapped=%llu], " 1888 - "fs [data=%llu, (gc_data=%llu, compr_data=%llu), " 1879 + "compr(buffered=%llu, mapped=%llu)], " 1880 + "fs [data=%llu, (gc_data=%llu, cdata=%llu), " 1889 1881 "node=%llu, meta=%llu]", 1890 1882 show_dev(__entry->dev), __entry->app_wio, __entry->app_dio, 1891 - __entry->app_bio, __entry->app_mio, __entry->fs_dio, 1883 + __entry->app_bio, __entry->app_mio, __entry->app_bcdio, 1884 + __entry->app_mcdio, __entry->fs_dio, __entry->fs_cdio, 1892 1885 __entry->fs_nio, __entry->fs_mio, __entry->fs_discard, 1893 1886 __entry->fs_gc_dio, __entry->fs_gc_nio, __entry->fs_cp_dio, 1894 1887 __entry->fs_cp_nio, __entry->fs_cp_mio, 1895 1888 __entry->app_rio, __entry->app_drio, __entry->app_brio, 1896 - __entry->app_mrio, __entry->fs_drio, __entry->fs_gdrio, 1889 + __entry->app_mrio, __entry->app_bcrio, __entry->app_mcrio, 1890 + __entry->fs_drio, __entry->fs_gdrio, 1897 1891 __entry->fs_cdrio, __entry->fs_nrio, __entry->fs_mrio) 1898 1892 ); 1899 1893