| 1 | |
| 2 | |
| 3 | * f2fs debugging statistics
|
| 4 | *
|
| 5 | * Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
| 6 | * http://www.samsung.com/
|
| 7 | * Copyright (c) 2012 Linux Foundation
|
| 8 | * Copyright (c) 2012 Greg Kroah-Hartman <[email protected]>
|
| 9 |
|
| 10 |
|
| 11 | #include <linux/fs.h>
|
| 12 | #include <linux/backing-dev.h>
|
| 13 | #include <linux/f2fs_fs.h>
|
| 14 | #include <linux/blkdev.h>
|
| 15 | #include <linux/debugfs.h>
|
| 16 | #include <linux/seq_file.h>
|
| 17 |
|
| 18 | #include "f2fs.h"
|
| 19 | #include "node.h"
|
| 20 | #include "segment.h"
|
| 21 | #include "gc.h"
|
| 22 |
|
| 23 | static LIST_HEAD(f2fs_stat_list);
|
| 24 | static DEFINE_MUTEX(f2fs_stat_mutex);
|
| 25 | #ifdef CONFIG_DEBUG_FS
|
| 26 | static struct dentry *f2fs_debugfs_root;
|
| 27 | #endif
|
| 28 |
|
| 29 | |
| 30 | * This function calculates BDF of every segments
|
| 31 |
|
| 32 | void f2fs_update_sit_info(struct f2fs_sb_info *sbi)
|
| 33 | {
|
| 34 | struct f2fs_stat_info *si = F2FS_STAT(sbi);
|
| 35 | unsigned long long blks_per_sec, hblks_per_sec, total_vblocks;
|
| 36 | unsigned long long bimodal, dist;
|
| 37 | unsigned int segno, vblocks;
|
| 38 | int ndirty = 0;
|
| 39 |
|
| 40 | bimodal = 0;
|
| 41 | total_vblocks = 0;
|
| 42 | blks_per_sec = BLKS_PER_SEC(sbi);
|
| 43 | hblks_per_sec = blks_per_sec / 2;
|
| 44 | for (segno = 0; segno < MAIN_SEGS(sbi); segno += sbi->segs_per_sec) {
|
| 45 | vblocks = get_valid_blocks(sbi, segno, true);
|
| 46 | dist = abs(vblocks - hblks_per_sec);
|
| 47 | bimodal += dist * dist;
|
| 48 |
|
| 49 | if (vblocks > 0 && vblocks < blks_per_sec) {
|
| 50 | total_vblocks += vblocks;
|
| 51 | ndirty++;
|
| 52 | }
|
| 53 | }
|
| 54 | dist = div_u64(MAIN_SECS(sbi) * hblks_per_sec * hblks_per_sec, 100);
|
| 55 | si->bimodal = div64_u64(bimodal, dist);
|
| 56 | if (si->dirty_count)
|
| 57 | si->avg_vblocks = div_u64(total_vblocks, ndirty);
|
| 58 | else
|
| 59 | si->avg_vblocks = 0;
|
| 60 | }
|
| 61 |
|
| 62 | #ifdef CONFIG_DEBUG_FS
|
| 63 | static void update_general_status(struct f2fs_sb_info *sbi)
|
| 64 | {
|
| 65 | struct f2fs_stat_info *si = F2FS_STAT(sbi);
|
| 66 | struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
|
| 67 | int i;
|
| 68 |
|
| 69 |
|
| 70 | si->main_area_segs = le32_to_cpu(raw_super->segment_count_main);
|
| 71 | si->main_area_sections = le32_to_cpu(raw_super->section_count);
|
| 72 | si->main_area_zones = si->main_area_sections /
|
| 73 | le32_to_cpu(raw_super->secs_per_zone);
|
| 74 |
|
| 75 |
|
| 76 | si->hit_largest = atomic64_read(&sbi->read_hit_largest);
|
| 77 | si->hit_cached = atomic64_read(&sbi->read_hit_cached);
|
| 78 | si->hit_rbtree = atomic64_read(&sbi->read_hit_rbtree);
|
| 79 | si->hit_total = si->hit_largest + si->hit_cached + si->hit_rbtree;
|
| 80 | si->total_ext = atomic64_read(&sbi->total_hit_ext);
|
| 81 | si->ext_tree = atomic_read(&sbi->total_ext_tree);
|
| 82 | si->zombie_tree = atomic_read(&sbi->total_zombie_tree);
|
| 83 | si->ext_node = atomic_read(&sbi->total_ext_node);
|
| 84 | si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
|
| 85 | si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
|
| 86 | si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META);
|
| 87 | si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA);
|
| 88 | si->ndirty_qdata = get_pages(sbi, F2FS_DIRTY_QDATA);
|
| 89 | si->ndirty_imeta = get_pages(sbi, F2FS_DIRTY_IMETA);
|
| 90 | si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE];
|
| 91 | si->ndirty_files = sbi->ndirty_inode[FILE_INODE];
|
| 92 | si->nquota_files = sbi->nquota_files;
|
| 93 | si->ndirty_all = sbi->ndirty_inode[DIRTY_META];
|
| 94 | si->inmem_pages = get_pages(sbi, F2FS_INMEM_PAGES);
|
| 95 | si->aw_cnt = sbi->atomic_files;
|
| 96 | si->vw_cnt = atomic_read(&sbi->vw_cnt);
|
| 97 | si->max_aw_cnt = atomic_read(&sbi->max_aw_cnt);
|
| 98 | si->max_vw_cnt = atomic_read(&sbi->max_vw_cnt);
|
| 99 | si->nr_dio_read = get_pages(sbi, F2FS_DIO_READ);
|
| 100 | si->nr_dio_write = get_pages(sbi, F2FS_DIO_WRITE);
|
| 101 | si->nr_wb_cp_data = get_pages(sbi, F2FS_WB_CP_DATA);
|
| 102 | si->nr_wb_data = get_pages(sbi, F2FS_WB_DATA);
|
| 103 | si->nr_rd_data = get_pages(sbi, F2FS_RD_DATA);
|
| 104 | si->nr_rd_node = get_pages(sbi, F2FS_RD_NODE);
|
| 105 | si->nr_rd_meta = get_pages(sbi, F2FS_RD_META);
|
| 106 | if (SM_I(sbi)->fcc_info) {
|
| 107 | si->nr_flushed =
|
| 108 | atomic_read(&SM_I(sbi)->fcc_info->issued_flush);
|
| 109 | si->nr_flushing =
|
| 110 | atomic_read(&SM_I(sbi)->fcc_info->queued_flush);
|
| 111 | si->flush_list_empty =
|
| 112 | llist_empty(&SM_I(sbi)->fcc_info->issue_list);
|
| 113 | }
|
| 114 | if (SM_I(sbi)->dcc_info) {
|
| 115 | si->nr_discarded =
|
| 116 | atomic_read(&SM_I(sbi)->dcc_info->issued_discard);
|
| 117 | si->nr_discarding =
|
| 118 | atomic_read(&SM_I(sbi)->dcc_info->queued_discard);
|
| 119 | si->nr_discard_cmd =
|
| 120 | atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
|
| 121 | si->undiscard_blks = SM_I(sbi)->dcc_info->undiscard_blks;
|
| 122 | }
|
| 123 | si->nr_issued_ckpt = atomic_read(&sbi->cprc_info.issued_ckpt);
|
| 124 | si->nr_total_ckpt = atomic_read(&sbi->cprc_info.total_ckpt);
|
| 125 | si->nr_queued_ckpt = atomic_read(&sbi->cprc_info.queued_ckpt);
|
| 126 | spin_lock(&sbi->cprc_info.stat_lock);
|
| 127 | si->cur_ckpt_time = sbi->cprc_info.cur_time;
|
| 128 | si->peak_ckpt_time = sbi->cprc_info.peak_time;
|
| 129 | spin_unlock(&sbi->cprc_info.stat_lock);
|
| 130 | si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
|
| 131 | si->rsvd_segs = reserved_segments(sbi);
|
| 132 | si->overp_segs = overprovision_segments(sbi);
|
| 133 | si->valid_count = valid_user_blocks(sbi);
|
| 134 | si->discard_blks = discard_blocks(sbi);
|
| 135 | si->valid_node_count = valid_node_count(sbi);
|
| 136 | si->valid_inode_count = valid_inode_count(sbi);
|
| 137 | si->inline_xattr = atomic_read(&sbi->inline_xattr);
|
| 138 | si->inline_inode = atomic_read(&sbi->inline_inode);
|
| 139 | si->inline_dir = atomic_read(&sbi->inline_dir);
|
| 140 | si->compr_inode = atomic_read(&sbi->compr_inode);
|
| 141 | si->compr_blocks = atomic64_read(&sbi->compr_blocks);
|
| 142 | si->append = sbi->im[APPEND_INO].ino_num;
|
| 143 | si->update = sbi->im[UPDATE_INO].ino_num;
|
| 144 | si->orphans = sbi->im[ORPHAN_INO].ino_num;
|
| 145 | si->utilization = utilization(sbi);
|
| 146 |
|
| 147 | si->free_segs = free_segments(sbi);
|
| 148 | si->free_secs = free_sections(sbi);
|
| 149 | si->prefree_count = prefree_segments(sbi);
|
| 150 | si->dirty_count = dirty_segments(sbi);
|
| 151 | if (sbi->node_inode)
|
| 152 | si->node_pages = NODE_MAPPING(sbi)->nrpages;
|
| 153 | if (sbi->meta_inode)
|
| 154 | si->meta_pages = META_MAPPING(sbi)->nrpages;
|
| 155 | si->nats = NM_I(sbi)->nat_cnt[TOTAL_NAT];
|
| 156 | si->dirty_nats = NM_I(sbi)->nat_cnt[DIRTY_NAT];
|
| 157 | si->sits = MAIN_SEGS(sbi);
|
| 158 | si->dirty_sits = SIT_I(sbi)->dirty_sentries;
|
| 159 | si->free_nids = NM_I(sbi)->nid_cnt[FREE_NID];
|
| 160 | si->avail_nids = NM_I(sbi)->available_nids;
|
| 161 | si->alloc_nids = NM_I(sbi)->nid_cnt[PREALLOC_NID];
|
| 162 | si->io_skip_bggc = sbi->io_skip_bggc;
|
| 163 | si->other_skip_bggc = sbi->other_skip_bggc;
|
| 164 | si->skipped_atomic_files[BG_GC] = sbi->skipped_atomic_files[BG_GC];
|
| 165 | si->skipped_atomic_files[FG_GC] = sbi->skipped_atomic_files[FG_GC];
|
| 166 | si->util_free = (int)(free_user_blocks(sbi) >> sbi->log_blocks_per_seg)
|
| 167 | * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
|
| 168 | / 2;
|
| 169 | si->util_valid = (int)(written_block_count(sbi) >>
|
| 170 | sbi->log_blocks_per_seg)
|
| 171 | * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
|
| 172 | / 2;
|
| 173 | si->util_invalid = 50 - si->util_free - si->util_valid;
|
| 174 | for (i = CURSEG_HOT_DATA; i < NO_CHECK_TYPE; i++) {
|
| 175 | struct curseg_info *curseg = CURSEG_I(sbi, i);
|
| 176 |
|
| 177 | si->curseg[i] = curseg->segno;
|
| 178 | si->cursec[i] = GET_SEC_FROM_SEG(sbi, curseg->segno);
|
| 179 | si->curzone[i] = GET_ZONE_FROM_SEC(sbi, si->cursec[i]);
|
| 180 | }
|
| 181 |
|
| 182 | for (i = META_CP; i < META_MAX; i++)
|
| 183 | si->meta_count[i] = atomic_read(&sbi->meta_count[i]);
|
| 184 |
|
| 185 | for (i = 0; i < NO_CHECK_TYPE; i++) {
|
| 186 | si->dirty_seg[i] = 0;
|
| 187 | si->full_seg[i] = 0;
|
| 188 | si->valid_blks[i] = 0;
|
| 189 | }
|
| 190 |
|
| 191 | for (i = 0; i < MAIN_SEGS(sbi); i++) {
|
| 192 | int blks = get_seg_entry(sbi, i)->valid_blocks;
|
| 193 | int type = get_seg_entry(sbi, i)->type;
|
| 194 |
|
| 195 | if (!blks)
|
| 196 | continue;
|
| 197 |
|
| 198 | if (blks == sbi->blocks_per_seg)
|
| 199 | si->full_seg[type]++;
|
| 200 | else
|
| 201 | si->dirty_seg[type]++;
|
| 202 | si->valid_blks[type] += blks;
|
| 203 | }
|
| 204 |
|
| 205 | for (i = 0; i < 2; i++) {
|
| 206 | si->segment_count[i] = sbi->segment_count[i];
|
| 207 | si->block_count[i] = sbi->block_count[i];
|
| 208 | }
|
| 209 |
|
| 210 | si->inplace_count = atomic_read(&sbi->inplace_count);
|
| 211 | }
|
| 212 |
|
| 213 | |
| 214 | * This function calculates memory footprint.
|
| 215 |
|
| 216 | static void update_mem_info(struct f2fs_sb_info *sbi)
|
| 217 | {
|
| 218 | struct f2fs_stat_info *si = F2FS_STAT(sbi);
|
| 219 | int i;
|
| 220 |
|
| 221 | if (si->base_mem)
|
| 222 | goto get_cache;
|
| 223 |
|
| 224 |
|
| 225 | si->base_mem = sizeof(struct f2fs_stat_info);
|
| 226 |
|
| 227 |
|
| 228 | si->base_mem += sizeof(struct f2fs_sb_info) + sbi->sb->s_blocksize;
|
| 229 | si->base_mem += 2 * sizeof(struct f2fs_inode_info);
|
| 230 | si->base_mem += sizeof(*sbi->ckpt);
|
| 231 |
|
| 232 |
|
| 233 | si->base_mem += sizeof(struct f2fs_sm_info);
|
| 234 |
|
| 235 |
|
| 236 | si->base_mem += sizeof(struct sit_info);
|
| 237 | si->base_mem += MAIN_SEGS(sbi) * sizeof(struct seg_entry);
|
| 238 | si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
|
| 239 | si->base_mem += 2 * SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
|
| 240 | si->base_mem += SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
|
| 241 | si->base_mem += SIT_VBLOCK_MAP_SIZE;
|
| 242 | if (__is_large_section(sbi))
|
| 243 | si->base_mem += MAIN_SECS(sbi) * sizeof(struct sec_entry);
|
| 244 | si->base_mem += __bitmap_size(sbi, SIT_BITMAP);
|
| 245 |
|
| 246 |
|
| 247 | si->base_mem += sizeof(struct free_segmap_info);
|
| 248 | si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
|
| 249 | si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
|
| 250 |
|
| 251 |
|
| 252 | si->base_mem += sizeof(struct curseg_info) * NR_CURSEG_TYPE;
|
| 253 | si->base_mem += PAGE_SIZE * NR_CURSEG_TYPE;
|
| 254 |
|
| 255 |
|
| 256 | si->base_mem += sizeof(struct dirty_seglist_info);
|
| 257 | si->base_mem += NR_DIRTY_TYPE * f2fs_bitmap_size(MAIN_SEGS(sbi));
|
| 258 | si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
|
| 259 |
|
| 260 |
|
| 261 | si->base_mem += sizeof(struct f2fs_nm_info);
|
| 262 | si->base_mem += __bitmap_size(sbi, NAT_BITMAP);
|
| 263 | si->base_mem += (NM_I(sbi)->nat_bits_blocks << F2FS_BLKSIZE_BITS);
|
| 264 | si->base_mem += NM_I(sbi)->nat_blocks *
|
| 265 | f2fs_bitmap_size(NAT_ENTRY_PER_BLOCK);
|
| 266 | si->base_mem += NM_I(sbi)->nat_blocks / 8;
|
| 267 | si->base_mem += NM_I(sbi)->nat_blocks * sizeof(unsigned short);
|
| 268 |
|
| 269 | get_cache:
|
| 270 | si->cache_mem = 0;
|
| 271 |
|
| 272 |
|
| 273 | if (sbi->gc_thread)
|
| 274 | si->cache_mem += sizeof(struct f2fs_gc_kthread);
|
| 275 |
|
| 276 |
|
| 277 | if (SM_I(sbi)->fcc_info)
|
| 278 | si->cache_mem += sizeof(struct flush_cmd_control);
|
| 279 | if (SM_I(sbi)->dcc_info) {
|
| 280 | si->cache_mem += sizeof(struct discard_cmd_control);
|
| 281 | si->cache_mem += sizeof(struct discard_cmd) *
|
| 282 | atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
|
| 283 | }
|
| 284 |
|
| 285 |
|
| 286 | si->cache_mem += (NM_I(sbi)->nid_cnt[FREE_NID] +
|
| 287 | NM_I(sbi)->nid_cnt[PREALLOC_NID]) *
|
| 288 | sizeof(struct free_nid);
|
| 289 | si->cache_mem += NM_I(sbi)->nat_cnt[TOTAL_NAT] *
|
| 290 | sizeof(struct nat_entry);
|
| 291 | si->cache_mem += NM_I(sbi)->nat_cnt[DIRTY_NAT] *
|
| 292 | sizeof(struct nat_entry_set);
|
| 293 | si->cache_mem += si->inmem_pages * sizeof(struct inmem_pages);
|
| 294 | for (i = 0; i < MAX_INO_ENTRY; i++)
|
| 295 | si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry);
|
| 296 | si->cache_mem += atomic_read(&sbi->total_ext_tree) *
|
| 297 | sizeof(struct extent_tree);
|
| 298 | si->cache_mem += atomic_read(&sbi->total_ext_node) *
|
| 299 | sizeof(struct extent_node);
|
| 300 |
|
| 301 | si->page_mem = 0;
|
| 302 | if (sbi->node_inode) {
|
| 303 | unsigned npages = NODE_MAPPING(sbi)->nrpages;
|
| 304 |
|
| 305 | si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
|
| 306 | }
|
| 307 | if (sbi->meta_inode) {
|
| 308 | unsigned npages = META_MAPPING(sbi)->nrpages;
|
| 309 |
|
| 310 | si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
|
| 311 | }
|
| 312 | }
|
| 313 |
|
| 314 | static int stat_show(struct seq_file *s, void *v)
|
| 315 | {
|
| 316 | struct f2fs_stat_info *si;
|
| 317 | int i = 0;
|
| 318 | int j;
|
| 319 |
|
| 320 | mutex_lock(&f2fs_stat_mutex);
|
| 321 | list_for_each_entry(si, &f2fs_stat_list, stat_list) {
|
| 322 | update_general_status(si->sbi);
|
| 323 |
|
| 324 | seq_printf(s, "\n=====[ partition info(%pg). #%d, %s, CP: %s]=====\n",
|
| 325 | si->sbi->sb->s_bdev, i++,
|
| 326 | f2fs_readonly(si->sbi->sb) ? "RO": "RW",
|
| 327 | is_set_ckpt_flags(si->sbi, CP_DISABLED_FLAG) ?
|
| 328 | "Disabled": (f2fs_cp_error(si->sbi) ? "Error": "Good"));
|
| 329 | seq_printf(s, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
|
| 330 | si->sit_area_segs, si->nat_area_segs);
|
| 331 | seq_printf(s, "[SSA: %d] [MAIN: %d",
|
| 332 | si->ssa_area_segs, si->main_area_segs);
|
| 333 | seq_printf(s, "(OverProv:%d Resv:%d)]\n\n",
|
| 334 | si->overp_segs, si->rsvd_segs);
|
| 335 | seq_printf(s, "Current Time Sec: %llu / Mounted Time Sec: %llu\n\n",
|
| 336 | ktime_get_boottime_seconds(),
|
| 337 | SIT_I(si->sbi)->mounted_time);
|
| 338 | if (test_opt(si->sbi, DISCARD))
|
| 339 | seq_printf(s, "Utilization: %u%% (%u valid blocks, %u discard blocks)\n",
|
| 340 | si->utilization, si->valid_count, si->discard_blks);
|
| 341 | else
|
| 342 | seq_printf(s, "Utilization: %u%% (%u valid blocks)\n",
|
| 343 | si->utilization, si->valid_count);
|
| 344 |
|
| 345 | seq_printf(s, " - Node: %u (Inode: %u, ",
|
| 346 | si->valid_node_count, si->valid_inode_count);
|
| 347 | seq_printf(s, "Other: %u)\n - Data: %u\n",
|
| 348 | si->valid_node_count - si->valid_inode_count,
|
| 349 | si->valid_count - si->valid_node_count);
|
| 350 | seq_printf(s, " - Inline_xattr Inode: %u\n",
|
| 351 | si->inline_xattr);
|
| 352 | seq_printf(s, " - Inline_data Inode: %u\n",
|
| 353 | si->inline_inode);
|
| 354 | seq_printf(s, " - Inline_dentry Inode: %u\n",
|
| 355 | si->inline_dir);
|
| 356 | seq_printf(s, " - Compressed Inode: %u, Blocks: %llu\n",
|
| 357 | si->compr_inode, si->compr_blocks);
|
| 358 | seq_printf(s, " - Orphan/Append/Update Inode: %u, %u, %u\n",
|
| 359 | si->orphans, si->append, si->update);
|
| 360 | seq_printf(s, "\nMain area: %d segs, %d secs %d zones\n",
|
| 361 | si->main_area_segs, si->main_area_sections,
|
| 362 | si->main_area_zones);
|
| 363 | seq_printf(s, " TYPE %8s %8s %8s %10s %10s %10s\n",
|
| 364 | "segno", "secno", "zoneno", "dirty_seg", "full_seg", "valid_blk");
|
| 365 | seq_printf(s, " - COLD data: %8d %8d %8d %10u %10u %10u\n",
|
| 366 | si->curseg[CURSEG_COLD_DATA],
|
| 367 | si->cursec[CURSEG_COLD_DATA],
|
| 368 | si->curzone[CURSEG_COLD_DATA],
|
| 369 | si->dirty_seg[CURSEG_COLD_DATA],
|
| 370 | si->full_seg[CURSEG_COLD_DATA],
|
| 371 | si->valid_blks[CURSEG_COLD_DATA]);
|
| 372 | seq_printf(s, " - WARM data: %8d %8d %8d %10u %10u %10u\n",
|
| 373 | si->curseg[CURSEG_WARM_DATA],
|
| 374 | si->cursec[CURSEG_WARM_DATA],
|
| 375 | si->curzone[CURSEG_WARM_DATA],
|
| 376 | si->dirty_seg[CURSEG_WARM_DATA],
|
| 377 | si->full_seg[CURSEG_WARM_DATA],
|
| 378 | si->valid_blks[CURSEG_WARM_DATA]);
|
| 379 | seq_printf(s, " - HOT data: %8d %8d %8d %10u %10u %10u\n",
|
| 380 | si->curseg[CURSEG_HOT_DATA],
|
| 381 | si->cursec[CURSEG_HOT_DATA],
|
| 382 | si->curzone[CURSEG_HOT_DATA],
|
| 383 | si->dirty_seg[CURSEG_HOT_DATA],
|
| 384 | si->full_seg[CURSEG_HOT_DATA],
|
| 385 | si->valid_blks[CURSEG_HOT_DATA]);
|
| 386 | seq_printf(s, " - Dir dnode: %8d %8d %8d %10u %10u %10u\n",
|
| 387 | si->curseg[CURSEG_HOT_NODE],
|
| 388 | si->cursec[CURSEG_HOT_NODE],
|
| 389 | si->curzone[CURSEG_HOT_NODE],
|
| 390 | si->dirty_seg[CURSEG_HOT_NODE],
|
| 391 | si->full_seg[CURSEG_HOT_NODE],
|
| 392 | si->valid_blks[CURSEG_HOT_NODE]);
|
| 393 | seq_printf(s, " - File dnode: %8d %8d %8d %10u %10u %10u\n",
|
| 394 | si->curseg[CURSEG_WARM_NODE],
|
| 395 | si->cursec[CURSEG_WARM_NODE],
|
| 396 | si->curzone[CURSEG_WARM_NODE],
|
| 397 | si->dirty_seg[CURSEG_WARM_NODE],
|
| 398 | si->full_seg[CURSEG_WARM_NODE],
|
| 399 | si->valid_blks[CURSEG_WARM_NODE]);
|
| 400 | seq_printf(s, " - Indir nodes: %8d %8d %8d %10u %10u %10u\n",
|
| 401 | si->curseg[CURSEG_COLD_NODE],
|
| 402 | si->cursec[CURSEG_COLD_NODE],
|
| 403 | si->curzone[CURSEG_COLD_NODE],
|
| 404 | si->dirty_seg[CURSEG_COLD_NODE],
|
| 405 | si->full_seg[CURSEG_COLD_NODE],
|
| 406 | si->valid_blks[CURSEG_COLD_NODE]);
|
| 407 | seq_printf(s, " - Pinned file: %8d %8d %8d\n",
|
| 408 | si->curseg[CURSEG_COLD_DATA_PINNED],
|
| 409 | si->cursec[CURSEG_COLD_DATA_PINNED],
|
| 410 | si->curzone[CURSEG_COLD_DATA_PINNED]);
|
| 411 | seq_printf(s, " - ATGC data: %8d %8d %8d\n",
|
| 412 | si->curseg[CURSEG_ALL_DATA_ATGC],
|
| 413 | si->cursec[CURSEG_ALL_DATA_ATGC],
|
| 414 | si->curzone[CURSEG_ALL_DATA_ATGC]);
|
| 415 | seq_printf(s, "\n - Valid: %d\n - Dirty: %d\n",
|
| 416 | si->main_area_segs - si->dirty_count -
|
| 417 | si->prefree_count - si->free_segs,
|
| 418 | si->dirty_count);
|
| 419 | seq_printf(s, " - Prefree: %d\n - Free: %d (%d)\n\n",
|
| 420 | si->prefree_count, si->free_segs, si->free_secs);
|
| 421 | seq_printf(s, "CP calls: %d (BG: %d)\n",
|
| 422 | si->cp_count, si->bg_cp_count);
|
| 423 | seq_printf(s, " - cp blocks : %u\n", si->meta_count[META_CP]);
|
| 424 | seq_printf(s, " - sit blocks : %u\n",
|
| 425 | si->meta_count[META_SIT]);
|
| 426 | seq_printf(s, " - nat blocks : %u\n",
|
| 427 | si->meta_count[META_NAT]);
|
| 428 | seq_printf(s, " - ssa blocks : %u\n",
|
| 429 | si->meta_count[META_SSA]);
|
| 430 | seq_printf(s, "CP merge (Queued: %4d, Issued: %4d, Total: %4d, "
|
| 431 | "Cur time: %4d(ms), Peak time: %4d(ms))\n",
|
| 432 | si->nr_queued_ckpt, si->nr_issued_ckpt,
|
| 433 | si->nr_total_ckpt, si->cur_ckpt_time,
|
| 434 | si->peak_ckpt_time);
|
| 435 | seq_printf(s, "GC calls: %d (BG: %d)\n",
|
| 436 | si->call_count, si->bg_gc);
|
| 437 | seq_printf(s, " - data segments : %d (%d)\n",
|
| 438 | si->data_segs, si->bg_data_segs);
|
| 439 | seq_printf(s, " - node segments : %d (%d)\n",
|
| 440 | si->node_segs, si->bg_node_segs);
|
| 441 | seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks,
|
| 442 | si->bg_data_blks + si->bg_node_blks);
|
| 443 | seq_printf(s, " - data blocks : %d (%d)\n", si->data_blks,
|
| 444 | si->bg_data_blks);
|
| 445 | seq_printf(s, " - node blocks : %d (%d)\n", si->node_blks,
|
| 446 | si->bg_node_blks);
|
| 447 | seq_printf(s, "Skipped : atomic write %llu (%llu)\n",
|
| 448 | si->skipped_atomic_files[BG_GC] +
|
| 449 | si->skipped_atomic_files[FG_GC],
|
| 450 | si->skipped_atomic_files[BG_GC]);
|
| 451 | seq_printf(s, "BG skip : IO: %u, Other: %u\n",
|
| 452 | si->io_skip_bggc, si->other_skip_bggc);
|
| 453 | seq_puts(s, "\nExtent Cache:\n");
|
| 454 | seq_printf(s, " - Hit Count: L1-1:%llu L1-2:%llu L2:%llu\n",
|
| 455 | si->hit_largest, si->hit_cached,
|
| 456 | si->hit_rbtree);
|
| 457 | seq_printf(s, " - Hit Ratio: %llu%% (%llu / %llu)\n",
|
| 458 | !si->total_ext ? 0 :
|
| 459 | div64_u64(si->hit_total * 100, si->total_ext),
|
| 460 | si->hit_total, si->total_ext);
|
| 461 | seq_printf(s, " - Inner Struct Count: tree: %d(%d), node: %d\n",
|
| 462 | si->ext_tree, si->zombie_tree, si->ext_node);
|
| 463 | seq_puts(s, "\nBalancing F2FS Async:\n");
|
| 464 | seq_printf(s, " - DIO (R: %4d, W: %4d)\n",
|
| 465 | si->nr_dio_read, si->nr_dio_write);
|
| 466 | seq_printf(s, " - IO_R (Data: %4d, Node: %4d, Meta: %4d\n",
|
| 467 | si->nr_rd_data, si->nr_rd_node, si->nr_rd_meta);
|
| 468 | seq_printf(s, " - IO_W (CP: %4d, Data: %4d, Flush: (%4d %4d %4d), "
|
| 469 | "Discard: (%4d %4d)) cmd: %4d undiscard:%4u\n",
|
| 470 | si->nr_wb_cp_data, si->nr_wb_data,
|
| 471 | si->nr_flushing, si->nr_flushed,
|
| 472 | si->flush_list_empty,
|
| 473 | si->nr_discarding, si->nr_discarded,
|
| 474 | si->nr_discard_cmd, si->undiscard_blks);
|
| 475 | seq_printf(s, " - inmem: %4d, atomic IO: %4d (Max. %4d), "
|
| 476 | "volatile IO: %4d (Max. %4d)\n",
|
| 477 | si->inmem_pages, si->aw_cnt, si->max_aw_cnt,
|
| 478 | si->vw_cnt, si->max_vw_cnt);
|
| 479 | seq_printf(s, " - nodes: %4d in %4d\n",
|
| 480 | si->ndirty_node, si->node_pages);
|
| 481 | seq_printf(s, " - dents: %4d in dirs:%4d (%4d)\n",
|
| 482 | si->ndirty_dent, si->ndirty_dirs, si->ndirty_all);
|
| 483 | seq_printf(s, " - datas: %4d in files:%4d\n",
|
| 484 | si->ndirty_data, si->ndirty_files);
|
| 485 | seq_printf(s, " - quota datas: %4d in quota files:%4d\n",
|
| 486 | si->ndirty_qdata, si->nquota_files);
|
| 487 | seq_printf(s, " - meta: %4d in %4d\n",
|
| 488 | si->ndirty_meta, si->meta_pages);
|
| 489 | seq_printf(s, " - imeta: %4d\n",
|
| 490 | si->ndirty_imeta);
|
| 491 | seq_printf(s, " - NATs: %9d/%9d\n - SITs: %9d/%9d\n",
|
| 492 | si->dirty_nats, si->nats, si->dirty_sits, si->sits);
|
| 493 | seq_printf(s, " - free_nids: %9d/%9d\n - alloc_nids: %9d\n",
|
| 494 | si->free_nids, si->avail_nids, si->alloc_nids);
|
| 495 | seq_puts(s, "\nDistribution of User Blocks:");
|
| 496 | seq_puts(s, " [ valid | invalid | free ]\n");
|
| 497 | seq_puts(s, " [");
|
| 498 |
|
| 499 | for (j = 0; j < si->util_valid; j++)
|
| 500 | seq_putc(s, '-');
|
| 501 | seq_putc(s, '|');
|
| 502 |
|
| 503 | for (j = 0; j < si->util_invalid; j++)
|
| 504 | seq_putc(s, '-');
|
| 505 | seq_putc(s, '|');
|
| 506 |
|
| 507 | for (j = 0; j < si->util_free; j++)
|
| 508 | seq_putc(s, '-');
|
| 509 | seq_puts(s, "]\n\n");
|
| 510 | seq_printf(s, "IPU: %u blocks\n", si->inplace_count);
|
| 511 | seq_printf(s, "SSR: %u blocks in %u segments\n",
|
| 512 | si->block_count[SSR], si->segment_count[SSR]);
|
| 513 | seq_printf(s, "LFS: %u blocks in %u segments\n",
|
| 514 | si->block_count[LFS], si->segment_count[LFS]);
|
| 515 |
|
| 516 |
|
| 517 | f2fs_update_sit_info(si->sbi);
|
| 518 | seq_printf(s, "\nBDF: %u, avg. vblocks: %u\n",
|
| 519 | si->bimodal, si->avg_vblocks);
|
| 520 |
|
| 521 |
|
| 522 | update_mem_info(si->sbi);
|
| 523 | seq_printf(s, "\nMemory: %llu KB\n",
|
| 524 | (si->base_mem + si->cache_mem + si->page_mem) >> 10);
|
| 525 | seq_printf(s, " - static: %llu KB\n",
|
| 526 | si->base_mem >> 10);
|
| 527 | seq_printf(s, " - cached: %llu KB\n",
|
| 528 | si->cache_mem >> 10);
|
| 529 | seq_printf(s, " - paged : %llu KB\n",
|
| 530 | si->page_mem >> 10);
|
| 531 | }
|
| 532 | mutex_unlock(&f2fs_stat_mutex);
|
| 533 | return 0;
|
| 534 | }
|
| 535 |
|
| 536 | DEFINE_SHOW_ATTRIBUTE(stat);
|
| 537 | #endif
|
| 538 |
|
| 539 | int f2fs_build_stats(struct f2fs_sb_info *sbi)
|
| 540 | {
|
| 541 | struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
|
| 542 | struct f2fs_stat_info *si;
|
| 543 | int i;
|
| 544 |
|
| 545 | si = f2fs_kzalloc(sbi, sizeof(struct f2fs_stat_info), GFP_KERNEL);
|
| 546 | if (!si)
|
| 547 | return -ENOMEM;
|
| 548 |
|
| 549 | si->all_area_segs = le32_to_cpu(raw_super->segment_count);
|
| 550 | si->sit_area_segs = le32_to_cpu(raw_super->segment_count_sit);
|
| 551 | si->nat_area_segs = le32_to_cpu(raw_super->segment_count_nat);
|
| 552 | si->ssa_area_segs = le32_to_cpu(raw_super->segment_count_ssa);
|
| 553 | si->main_area_segs = le32_to_cpu(raw_super->segment_count_main);
|
| 554 | si->main_area_sections = le32_to_cpu(raw_super->section_count);
|
| 555 | si->main_area_zones = si->main_area_sections /
|
| 556 | le32_to_cpu(raw_super->secs_per_zone);
|
| 557 | si->sbi = sbi;
|
| 558 | sbi->stat_info = si;
|
| 559 |
|
| 560 | atomic64_set(&sbi->total_hit_ext, 0);
|
| 561 | atomic64_set(&sbi->read_hit_rbtree, 0);
|
| 562 | atomic64_set(&sbi->read_hit_largest, 0);
|
| 563 | atomic64_set(&sbi->read_hit_cached, 0);
|
| 564 |
|
| 565 | atomic_set(&sbi->inline_xattr, 0);
|
| 566 | atomic_set(&sbi->inline_inode, 0);
|
| 567 | atomic_set(&sbi->inline_dir, 0);
|
| 568 | atomic_set(&sbi->compr_inode, 0);
|
| 569 | atomic64_set(&sbi->compr_blocks, 0);
|
| 570 | atomic_set(&sbi->inplace_count, 0);
|
| 571 | for (i = META_CP; i < META_MAX; i++)
|
| 572 | atomic_set(&sbi->meta_count[i], 0);
|
| 573 |
|
| 574 | atomic_set(&sbi->vw_cnt, 0);
|
| 575 | atomic_set(&sbi->max_aw_cnt, 0);
|
| 576 | atomic_set(&sbi->max_vw_cnt, 0);
|
| 577 |
|
| 578 | mutex_lock(&f2fs_stat_mutex);
|
| 579 | list_add_tail(&si->stat_list, &f2fs_stat_list);
|
| 580 | mutex_unlock(&f2fs_stat_mutex);
|
| 581 |
|
| 582 | return 0;
|
| 583 | }
|
| 584 |
|
| 585 | void f2fs_destroy_stats(struct f2fs_sb_info *sbi)
|
| 586 | {
|
| 587 | struct f2fs_stat_info *si = F2FS_STAT(sbi);
|
| 588 |
|
| 589 | mutex_lock(&f2fs_stat_mutex);
|
| 590 | list_del(&si->stat_list);
|
| 591 | mutex_unlock(&f2fs_stat_mutex);
|
| 592 |
|
| 593 | kfree(si);
|
| 594 | }
|
| 595 |
|
| 596 | void __init f2fs_create_root_stats(void)
|
| 597 | {
|
| 598 | #ifdef CONFIG_DEBUG_FS
|
| 599 | f2fs_debugfs_root = debugfs_create_dir("f2fs", NULL);
|
| 600 |
|
| 601 | debugfs_create_file("status", S_IRUGO, f2fs_debugfs_root, NULL,
|
| 602 | &stat_fops);
|
| 603 | #endif
|
| 604 | }
|
| 605 |
|
| 606 | void f2fs_destroy_root_stats(void)
|
| 607 | {
|
| 608 | #ifdef CONFIG_DEBUG_FS
|
| 609 | debugfs_remove_recursive(f2fs_debugfs_root);
|
| 610 | f2fs_debugfs_root = NULL;
|
| 611 | #endif
|
| 612 | }
|