2 * f2fs debugging statistics
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 * Copyright (c) 2012 Linux Foundation
7 * Copyright (c) 2012 Greg Kroah-Hartman <gregkh@linuxfoundation.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
15 #include <linux/backing-dev.h>
16 #include <linux/f2fs_fs.h>
17 #include <linux/blkdev.h>
18 #include <linux/debugfs.h>
19 #include <linux/seq_file.h>
26 static LIST_HEAD(f2fs_stat_list
);
27 static struct dentry
*f2fs_debugfs_root
;
28 static DEFINE_MUTEX(f2fs_stat_mutex
);
30 static void update_general_status(struct f2fs_sb_info
*sbi
)
32 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
35 /* validation check of the segment numbers */
36 si
->hit_largest
= atomic64_read(&sbi
->read_hit_largest
);
37 si
->hit_cached
= atomic64_read(&sbi
->read_hit_cached
);
38 si
->hit_rbtree
= atomic64_read(&sbi
->read_hit_rbtree
);
39 si
->hit_total
= si
->hit_largest
+ si
->hit_cached
+ si
->hit_rbtree
;
40 si
->total_ext
= atomic64_read(&sbi
->total_hit_ext
);
41 si
->ext_tree
= atomic_read(&sbi
->total_ext_tree
);
42 si
->zombie_tree
= atomic_read(&sbi
->total_zombie_tree
);
43 si
->ext_node
= atomic_read(&sbi
->total_ext_node
);
44 si
->ndirty_node
= get_pages(sbi
, F2FS_DIRTY_NODES
);
45 si
->ndirty_dent
= get_pages(sbi
, F2FS_DIRTY_DENTS
);
46 si
->ndirty_meta
= get_pages(sbi
, F2FS_DIRTY_META
);
47 si
->ndirty_data
= get_pages(sbi
, F2FS_DIRTY_DATA
);
48 si
->ndirty_dirs
= sbi
->ndirty_inode
[DIR_INODE
];
49 si
->ndirty_files
= sbi
->ndirty_inode
[FILE_INODE
];
50 si
->inmem_pages
= get_pages(sbi
, F2FS_INMEM_PAGES
);
51 si
->wb_bios
= atomic_read(&sbi
->nr_wb_bios
);
52 si
->total_count
= (int)sbi
->user_block_count
/ sbi
->blocks_per_seg
;
53 si
->rsvd_segs
= reserved_segments(sbi
);
54 si
->overp_segs
= overprovision_segments(sbi
);
55 si
->valid_count
= valid_user_blocks(sbi
);
56 si
->valid_node_count
= valid_node_count(sbi
);
57 si
->valid_inode_count
= valid_inode_count(sbi
);
58 si
->inline_xattr
= atomic_read(&sbi
->inline_xattr
);
59 si
->inline_inode
= atomic_read(&sbi
->inline_inode
);
60 si
->inline_dir
= atomic_read(&sbi
->inline_dir
);
61 si
->orphans
= sbi
->im
[ORPHAN_INO
].ino_num
;
62 si
->utilization
= utilization(sbi
);
64 si
->free_segs
= free_segments(sbi
);
65 si
->free_secs
= free_sections(sbi
);
66 si
->prefree_count
= prefree_segments(sbi
);
67 si
->dirty_count
= dirty_segments(sbi
);
68 si
->node_pages
= NODE_MAPPING(sbi
)->nrpages
;
69 si
->meta_pages
= META_MAPPING(sbi
)->nrpages
;
70 si
->nats
= NM_I(sbi
)->nat_cnt
;
71 si
->dirty_nats
= NM_I(sbi
)->dirty_nat_cnt
;
72 si
->sits
= MAIN_SEGS(sbi
);
73 si
->dirty_sits
= SIT_I(sbi
)->dirty_sentries
;
74 si
->fnids
= NM_I(sbi
)->fcnt
;
75 si
->bg_gc
= sbi
->bg_gc
;
76 si
->util_free
= (int)(free_user_blocks(sbi
) >> sbi
->log_blocks_per_seg
)
77 * 100 / (int)(sbi
->user_block_count
>> sbi
->log_blocks_per_seg
)
79 si
->util_valid
= (int)(written_block_count(sbi
) >>
80 sbi
->log_blocks_per_seg
)
81 * 100 / (int)(sbi
->user_block_count
>> sbi
->log_blocks_per_seg
)
83 si
->util_invalid
= 50 - si
->util_free
- si
->util_valid
;
84 for (i
= CURSEG_HOT_DATA
; i
<= CURSEG_COLD_NODE
; i
++) {
85 struct curseg_info
*curseg
= CURSEG_I(sbi
, i
);
86 si
->curseg
[i
] = curseg
->segno
;
87 si
->cursec
[i
] = curseg
->segno
/ sbi
->segs_per_sec
;
88 si
->curzone
[i
] = si
->cursec
[i
] / sbi
->secs_per_zone
;
91 for (i
= 0; i
< 2; i
++) {
92 si
->segment_count
[i
] = sbi
->segment_count
[i
];
93 si
->block_count
[i
] = sbi
->block_count
[i
];
96 si
->inplace_count
= atomic_read(&sbi
->inplace_count
);
100 * This function calculates BDF of every segments
102 static void update_sit_info(struct f2fs_sb_info
*sbi
)
104 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
105 unsigned long long blks_per_sec
, hblks_per_sec
, total_vblocks
;
106 unsigned long long bimodal
, dist
;
107 unsigned int segno
, vblocks
;
112 blks_per_sec
= sbi
->segs_per_sec
* sbi
->blocks_per_seg
;
113 hblks_per_sec
= blks_per_sec
/ 2;
114 for (segno
= 0; segno
< MAIN_SEGS(sbi
); segno
+= sbi
->segs_per_sec
) {
115 vblocks
= get_valid_blocks(sbi
, segno
, sbi
->segs_per_sec
);
116 dist
= abs(vblocks
- hblks_per_sec
);
117 bimodal
+= dist
* dist
;
119 if (vblocks
> 0 && vblocks
< blks_per_sec
) {
120 total_vblocks
+= vblocks
;
124 dist
= div_u64(MAIN_SECS(sbi
) * hblks_per_sec
* hblks_per_sec
, 100);
125 si
->bimodal
= div64_u64(bimodal
, dist
);
127 si
->avg_vblocks
= div_u64(total_vblocks
, ndirty
);
133 * This function calculates memory footprint.
135 static void update_mem_info(struct f2fs_sb_info
*sbi
)
137 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
144 si
->base_mem
= sizeof(struct f2fs_sb_info
) + sbi
->sb
->s_blocksize
;
145 si
->base_mem
+= 2 * sizeof(struct f2fs_inode_info
);
146 si
->base_mem
+= sizeof(*sbi
->ckpt
);
147 si
->base_mem
+= sizeof(struct percpu_counter
) * NR_COUNT_TYPE
;
150 si
->base_mem
+= sizeof(struct f2fs_sm_info
);
153 si
->base_mem
+= sizeof(struct sit_info
);
154 si
->base_mem
+= MAIN_SEGS(sbi
) * sizeof(struct seg_entry
);
155 si
->base_mem
+= f2fs_bitmap_size(MAIN_SEGS(sbi
));
156 si
->base_mem
+= 3 * SIT_VBLOCK_MAP_SIZE
* MAIN_SEGS(sbi
);
157 si
->base_mem
+= SIT_VBLOCK_MAP_SIZE
;
158 if (sbi
->segs_per_sec
> 1)
159 si
->base_mem
+= MAIN_SECS(sbi
) * sizeof(struct sec_entry
);
160 si
->base_mem
+= __bitmap_size(sbi
, SIT_BITMAP
);
162 /* build free segmap */
163 si
->base_mem
+= sizeof(struct free_segmap_info
);
164 si
->base_mem
+= f2fs_bitmap_size(MAIN_SEGS(sbi
));
165 si
->base_mem
+= f2fs_bitmap_size(MAIN_SECS(sbi
));
168 si
->base_mem
+= sizeof(struct curseg_info
) * NR_CURSEG_TYPE
;
169 si
->base_mem
+= PAGE_SIZE
* NR_CURSEG_TYPE
;
171 /* build dirty segmap */
172 si
->base_mem
+= sizeof(struct dirty_seglist_info
);
173 si
->base_mem
+= NR_DIRTY_TYPE
* f2fs_bitmap_size(MAIN_SEGS(sbi
));
174 si
->base_mem
+= f2fs_bitmap_size(MAIN_SECS(sbi
));
177 si
->base_mem
+= sizeof(struct f2fs_nm_info
);
178 si
->base_mem
+= __bitmap_size(sbi
, NAT_BITMAP
);
185 si
->cache_mem
+= sizeof(struct f2fs_gc_kthread
);
187 /* build merge flush thread */
188 if (SM_I(sbi
)->cmd_control_info
)
189 si
->cache_mem
+= sizeof(struct flush_cmd_control
);
192 si
->cache_mem
+= NM_I(sbi
)->fcnt
* sizeof(struct free_nid
);
193 si
->cache_mem
+= NM_I(sbi
)->nat_cnt
* sizeof(struct nat_entry
);
194 si
->cache_mem
+= NM_I(sbi
)->dirty_nat_cnt
*
195 sizeof(struct nat_entry_set
);
196 si
->cache_mem
+= si
->inmem_pages
* sizeof(struct inmem_pages
);
197 for (i
= 0; i
<= ORPHAN_INO
; i
++)
198 si
->cache_mem
+= sbi
->im
[i
].ino_num
* sizeof(struct ino_entry
);
199 si
->cache_mem
+= atomic_read(&sbi
->total_ext_tree
) *
200 sizeof(struct extent_tree
);
201 si
->cache_mem
+= atomic_read(&sbi
->total_ext_node
) *
202 sizeof(struct extent_node
);
205 npages
= NODE_MAPPING(sbi
)->nrpages
;
206 si
->page_mem
+= (unsigned long long)npages
<< PAGE_SHIFT
;
207 npages
= META_MAPPING(sbi
)->nrpages
;
208 si
->page_mem
+= (unsigned long long)npages
<< PAGE_SHIFT
;
211 static int stat_show(struct seq_file
*s
, void *v
)
213 struct f2fs_stat_info
*si
;
217 mutex_lock(&f2fs_stat_mutex
);
218 list_for_each_entry(si
, &f2fs_stat_list
, stat_list
) {
219 update_general_status(si
->sbi
);
221 seq_printf(s
, "\n=====[ partition info(%pg). #%d, %s]=====\n",
222 si
->sbi
->sb
->s_bdev
, i
++,
223 f2fs_readonly(si
->sbi
->sb
) ? "RO": "RW");
224 seq_printf(s
, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
225 si
->sit_area_segs
, si
->nat_area_segs
);
226 seq_printf(s
, "[SSA: %d] [MAIN: %d",
227 si
->ssa_area_segs
, si
->main_area_segs
);
228 seq_printf(s
, "(OverProv:%d Resv:%d)]\n\n",
229 si
->overp_segs
, si
->rsvd_segs
);
230 seq_printf(s
, "Utilization: %d%% (%d valid blocks)\n",
231 si
->utilization
, si
->valid_count
);
232 seq_printf(s
, " - Node: %u (Inode: %u, ",
233 si
->valid_node_count
, si
->valid_inode_count
);
234 seq_printf(s
, "Other: %u)\n - Data: %u\n",
235 si
->valid_node_count
- si
->valid_inode_count
,
236 si
->valid_count
- si
->valid_node_count
);
237 seq_printf(s
, " - Inline_xattr Inode: %u\n",
239 seq_printf(s
, " - Inline_data Inode: %u\n",
241 seq_printf(s
, " - Inline_dentry Inode: %u\n",
243 seq_printf(s
, " - Orphan Inode: %u\n",
245 seq_printf(s
, "\nMain area: %d segs, %d secs %d zones\n",
246 si
->main_area_segs
, si
->main_area_sections
,
247 si
->main_area_zones
);
248 seq_printf(s
, " - COLD data: %d, %d, %d\n",
249 si
->curseg
[CURSEG_COLD_DATA
],
250 si
->cursec
[CURSEG_COLD_DATA
],
251 si
->curzone
[CURSEG_COLD_DATA
]);
252 seq_printf(s
, " - WARM data: %d, %d, %d\n",
253 si
->curseg
[CURSEG_WARM_DATA
],
254 si
->cursec
[CURSEG_WARM_DATA
],
255 si
->curzone
[CURSEG_WARM_DATA
]);
256 seq_printf(s
, " - HOT data: %d, %d, %d\n",
257 si
->curseg
[CURSEG_HOT_DATA
],
258 si
->cursec
[CURSEG_HOT_DATA
],
259 si
->curzone
[CURSEG_HOT_DATA
]);
260 seq_printf(s
, " - Dir dnode: %d, %d, %d\n",
261 si
->curseg
[CURSEG_HOT_NODE
],
262 si
->cursec
[CURSEG_HOT_NODE
],
263 si
->curzone
[CURSEG_HOT_NODE
]);
264 seq_printf(s
, " - File dnode: %d, %d, %d\n",
265 si
->curseg
[CURSEG_WARM_NODE
],
266 si
->cursec
[CURSEG_WARM_NODE
],
267 si
->curzone
[CURSEG_WARM_NODE
]);
268 seq_printf(s
, " - Indir nodes: %d, %d, %d\n",
269 si
->curseg
[CURSEG_COLD_NODE
],
270 si
->cursec
[CURSEG_COLD_NODE
],
271 si
->curzone
[CURSEG_COLD_NODE
]);
272 seq_printf(s
, "\n - Valid: %d\n - Dirty: %d\n",
273 si
->main_area_segs
- si
->dirty_count
-
274 si
->prefree_count
- si
->free_segs
,
276 seq_printf(s
, " - Prefree: %d\n - Free: %d (%d)\n\n",
277 si
->prefree_count
, si
->free_segs
, si
->free_secs
);
278 seq_printf(s
, "CP calls: %d (BG: %d)\n",
279 si
->cp_count
, si
->bg_cp_count
);
280 seq_printf(s
, "GC calls: %d (BG: %d)\n",
281 si
->call_count
, si
->bg_gc
);
282 seq_printf(s
, " - data segments : %d (%d)\n",
283 si
->data_segs
, si
->bg_data_segs
);
284 seq_printf(s
, " - node segments : %d (%d)\n",
285 si
->node_segs
, si
->bg_node_segs
);
286 seq_printf(s
, "Try to move %d blocks (BG: %d)\n", si
->tot_blks
,
287 si
->bg_data_blks
+ si
->bg_node_blks
);
288 seq_printf(s
, " - data blocks : %d (%d)\n", si
->data_blks
,
290 seq_printf(s
, " - node blocks : %d (%d)\n", si
->node_blks
,
292 seq_puts(s
, "\nExtent Cache:\n");
293 seq_printf(s
, " - Hit Count: L1-1:%llu L1-2:%llu L2:%llu\n",
294 si
->hit_largest
, si
->hit_cached
,
296 seq_printf(s
, " - Hit Ratio: %llu%% (%llu / %llu)\n",
298 div64_u64(si
->hit_total
* 100, si
->total_ext
),
299 si
->hit_total
, si
->total_ext
);
300 seq_printf(s
, " - Inner Struct Count: tree: %d(%d), node: %d\n",
301 si
->ext_tree
, si
->zombie_tree
, si
->ext_node
);
302 seq_puts(s
, "\nBalancing F2FS Async:\n");
303 seq_printf(s
, " - inmem: %4lld, wb_bios: %4d\n",
304 si
->inmem_pages
, si
->wb_bios
);
305 seq_printf(s
, " - nodes: %4lld in %4d\n",
306 si
->ndirty_node
, si
->node_pages
);
307 seq_printf(s
, " - dents: %4lld in dirs:%4d\n",
308 si
->ndirty_dent
, si
->ndirty_dirs
);
309 seq_printf(s
, " - datas: %4lld in files:%4d\n",
310 si
->ndirty_data
, si
->ndirty_files
);
311 seq_printf(s
, " - meta: %4lld in %4d\n",
312 si
->ndirty_meta
, si
->meta_pages
);
313 seq_printf(s
, " - NATs: %9d/%9d\n - SITs: %9d/%9d\n",
314 si
->dirty_nats
, si
->nats
, si
->dirty_sits
, si
->sits
);
315 seq_printf(s
, " - free_nids: %9d\n",
317 seq_puts(s
, "\nDistribution of User Blocks:");
318 seq_puts(s
, " [ valid | invalid | free ]\n");
321 for (j
= 0; j
< si
->util_valid
; j
++)
325 for (j
= 0; j
< si
->util_invalid
; j
++)
329 for (j
= 0; j
< si
->util_free
; j
++)
331 seq_puts(s
, "]\n\n");
332 seq_printf(s
, "IPU: %u blocks\n", si
->inplace_count
);
333 seq_printf(s
, "SSR: %u blocks in %u segments\n",
334 si
->block_count
[SSR
], si
->segment_count
[SSR
]);
335 seq_printf(s
, "LFS: %u blocks in %u segments\n",
336 si
->block_count
[LFS
], si
->segment_count
[LFS
]);
338 /* segment usage info */
339 update_sit_info(si
->sbi
);
340 seq_printf(s
, "\nBDF: %u, avg. vblocks: %u\n",
341 si
->bimodal
, si
->avg_vblocks
);
343 /* memory footprint */
344 update_mem_info(si
->sbi
);
345 seq_printf(s
, "\nMemory: %llu KB\n",
346 (si
->base_mem
+ si
->cache_mem
+ si
->page_mem
) >> 10);
347 seq_printf(s
, " - static: %llu KB\n",
349 seq_printf(s
, " - cached: %llu KB\n",
350 si
->cache_mem
>> 10);
351 seq_printf(s
, " - paged : %llu KB\n",
354 mutex_unlock(&f2fs_stat_mutex
);
358 static int stat_open(struct inode
*inode
, struct file
*file
)
360 return single_open(file
, stat_show
, inode
->i_private
);
363 static const struct file_operations stat_fops
= {
367 .release
= single_release
,
370 int f2fs_build_stats(struct f2fs_sb_info
*sbi
)
372 struct f2fs_super_block
*raw_super
= F2FS_RAW_SUPER(sbi
);
373 struct f2fs_stat_info
*si
;
375 si
= kzalloc(sizeof(struct f2fs_stat_info
), GFP_KERNEL
);
379 si
->all_area_segs
= le32_to_cpu(raw_super
->segment_count
);
380 si
->sit_area_segs
= le32_to_cpu(raw_super
->segment_count_sit
);
381 si
->nat_area_segs
= le32_to_cpu(raw_super
->segment_count_nat
);
382 si
->ssa_area_segs
= le32_to_cpu(raw_super
->segment_count_ssa
);
383 si
->main_area_segs
= le32_to_cpu(raw_super
->segment_count_main
);
384 si
->main_area_sections
= le32_to_cpu(raw_super
->section_count
);
385 si
->main_area_zones
= si
->main_area_sections
/
386 le32_to_cpu(raw_super
->secs_per_zone
);
390 atomic64_set(&sbi
->total_hit_ext
, 0);
391 atomic64_set(&sbi
->read_hit_rbtree
, 0);
392 atomic64_set(&sbi
->read_hit_largest
, 0);
393 atomic64_set(&sbi
->read_hit_cached
, 0);
395 atomic_set(&sbi
->inline_xattr
, 0);
396 atomic_set(&sbi
->inline_inode
, 0);
397 atomic_set(&sbi
->inline_dir
, 0);
398 atomic_set(&sbi
->inplace_count
, 0);
400 mutex_lock(&f2fs_stat_mutex
);
401 list_add_tail(&si
->stat_list
, &f2fs_stat_list
);
402 mutex_unlock(&f2fs_stat_mutex
);
407 void f2fs_destroy_stats(struct f2fs_sb_info
*sbi
)
409 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
411 mutex_lock(&f2fs_stat_mutex
);
412 list_del(&si
->stat_list
);
413 mutex_unlock(&f2fs_stat_mutex
);
418 int __init
f2fs_create_root_stats(void)
422 f2fs_debugfs_root
= debugfs_create_dir("f2fs", NULL
);
423 if (!f2fs_debugfs_root
)
426 file
= debugfs_create_file("status", S_IRUGO
, f2fs_debugfs_root
,
429 debugfs_remove(f2fs_debugfs_root
);
430 f2fs_debugfs_root
= NULL
;
437 void f2fs_destroy_root_stats(void)
439 if (!f2fs_debugfs_root
)
442 debugfs_remove_recursive(f2fs_debugfs_root
);
443 f2fs_debugfs_root
= NULL
;