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
*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 /* valid check of the segment numbers */
36 si
->hit_ext
= sbi
->read_hit_ext
;
37 si
->total_ext
= sbi
->total_hit_ext
;
38 si
->ndirty_node
= get_pages(sbi
, F2FS_DIRTY_NODES
);
39 si
->ndirty_dent
= get_pages(sbi
, F2FS_DIRTY_DENTS
);
40 si
->ndirty_dirs
= sbi
->n_dirty_dirs
;
41 si
->ndirty_meta
= get_pages(sbi
, F2FS_DIRTY_META
);
42 si
->total_count
= (int)sbi
->user_block_count
/ sbi
->blocks_per_seg
;
43 si
->rsvd_segs
= reserved_segments(sbi
);
44 si
->overp_segs
= overprovision_segments(sbi
);
45 si
->valid_count
= valid_user_blocks(sbi
);
46 si
->valid_node_count
= valid_node_count(sbi
);
47 si
->valid_inode_count
= valid_inode_count(sbi
);
48 si
->utilization
= utilization(sbi
);
50 si
->free_segs
= free_segments(sbi
);
51 si
->free_secs
= free_sections(sbi
);
52 si
->prefree_count
= prefree_segments(sbi
);
53 si
->dirty_count
= dirty_segments(sbi
);
54 si
->node_pages
= sbi
->node_inode
->i_mapping
->nrpages
;
55 si
->meta_pages
= sbi
->meta_inode
->i_mapping
->nrpages
;
56 si
->nats
= NM_I(sbi
)->nat_cnt
;
57 si
->sits
= SIT_I(sbi
)->dirty_sentries
;
58 si
->fnids
= NM_I(sbi
)->fcnt
;
59 si
->bg_gc
= sbi
->bg_gc
;
60 si
->util_free
= (int)(free_user_blocks(sbi
) >> sbi
->log_blocks_per_seg
)
61 * 100 / (int)(sbi
->user_block_count
>> sbi
->log_blocks_per_seg
)
63 si
->util_valid
= (int)(written_block_count(sbi
) >>
64 sbi
->log_blocks_per_seg
)
65 * 100 / (int)(sbi
->user_block_count
>> sbi
->log_blocks_per_seg
)
67 si
->util_invalid
= 50 - si
->util_free
- si
->util_valid
;
68 for (i
= CURSEG_HOT_DATA
; i
<= CURSEG_COLD_NODE
; i
++) {
69 struct curseg_info
*curseg
= CURSEG_I(sbi
, i
);
70 si
->curseg
[i
] = curseg
->segno
;
71 si
->cursec
[i
] = curseg
->segno
/ sbi
->segs_per_sec
;
72 si
->curzone
[i
] = si
->cursec
[i
] / sbi
->secs_per_zone
;
75 for (i
= 0; i
< 2; i
++) {
76 si
->segment_count
[i
] = sbi
->segment_count
[i
];
77 si
->block_count
[i
] = sbi
->block_count
[i
];
82 * This function calculates BDF of every segments
84 static void update_sit_info(struct f2fs_sb_info
*sbi
)
86 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
87 unsigned int blks_per_sec
, hblks_per_sec
, total_vblocks
, bimodal
, dist
;
88 struct sit_info
*sit_i
= SIT_I(sbi
);
89 unsigned int segno
, vblocks
;
94 blks_per_sec
= sbi
->segs_per_sec
* (1 << sbi
->log_blocks_per_seg
);
95 hblks_per_sec
= blks_per_sec
/ 2;
96 mutex_lock(&sit_i
->sentry_lock
);
97 for (segno
= 0; segno
< TOTAL_SEGS(sbi
); segno
+= sbi
->segs_per_sec
) {
98 vblocks
= get_valid_blocks(sbi
, segno
, sbi
->segs_per_sec
);
99 dist
= abs(vblocks
- hblks_per_sec
);
100 bimodal
+= dist
* dist
;
102 if (vblocks
> 0 && vblocks
< blks_per_sec
) {
103 total_vblocks
+= vblocks
;
107 mutex_unlock(&sit_i
->sentry_lock
);
108 dist
= TOTAL_SECS(sbi
) * hblks_per_sec
* hblks_per_sec
/ 100;
109 si
->bimodal
= bimodal
/ dist
;
111 si
->avg_vblocks
= total_vblocks
/ ndirty
;
117 * This function calculates memory footprint.
119 static void update_mem_info(struct f2fs_sb_info
*sbi
)
121 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
127 si
->base_mem
= sizeof(struct f2fs_sb_info
) + sbi
->sb
->s_blocksize
;
128 si
->base_mem
+= 2 * sizeof(struct f2fs_inode_info
);
129 si
->base_mem
+= sizeof(*sbi
->ckpt
);
132 si
->base_mem
+= sizeof(struct f2fs_sm_info
);
135 si
->base_mem
+= sizeof(struct sit_info
);
136 si
->base_mem
+= TOTAL_SEGS(sbi
) * sizeof(struct seg_entry
);
137 si
->base_mem
+= f2fs_bitmap_size(TOTAL_SEGS(sbi
));
138 si
->base_mem
+= 2 * SIT_VBLOCK_MAP_SIZE
* TOTAL_SEGS(sbi
);
139 if (sbi
->segs_per_sec
> 1)
140 si
->base_mem
+= TOTAL_SECS(sbi
) * sizeof(struct sec_entry
);
141 si
->base_mem
+= __bitmap_size(sbi
, SIT_BITMAP
);
143 /* build free segmap */
144 si
->base_mem
+= sizeof(struct free_segmap_info
);
145 si
->base_mem
+= f2fs_bitmap_size(TOTAL_SEGS(sbi
));
146 si
->base_mem
+= f2fs_bitmap_size(TOTAL_SECS(sbi
));
149 si
->base_mem
+= sizeof(struct curseg_info
) * NR_CURSEG_TYPE
;
150 si
->base_mem
+= PAGE_CACHE_SIZE
* NR_CURSEG_TYPE
;
152 /* build dirty segmap */
153 si
->base_mem
+= sizeof(struct dirty_seglist_info
);
154 si
->base_mem
+= NR_DIRTY_TYPE
* f2fs_bitmap_size(TOTAL_SEGS(sbi
));
155 si
->base_mem
+= f2fs_bitmap_size(TOTAL_SECS(sbi
));
158 si
->base_mem
+= sizeof(struct f2fs_nm_info
);
159 si
->base_mem
+= __bitmap_size(sbi
, NAT_BITMAP
);
162 si
->base_mem
+= sizeof(struct f2fs_gc_kthread
);
166 si
->cache_mem
= NM_I(sbi
)->fcnt
;
167 si
->cache_mem
+= NM_I(sbi
)->nat_cnt
;
168 npages
= sbi
->node_inode
->i_mapping
->nrpages
;
169 si
->cache_mem
+= npages
<< PAGE_CACHE_SHIFT
;
170 npages
= sbi
->meta_inode
->i_mapping
->nrpages
;
171 si
->cache_mem
+= npages
<< PAGE_CACHE_SHIFT
;
172 si
->cache_mem
+= sbi
->n_orphans
* sizeof(struct orphan_inode_entry
);
173 si
->cache_mem
+= sbi
->n_dirty_dirs
* sizeof(struct dir_inode_entry
);
176 static int stat_show(struct seq_file
*s
, void *v
)
178 struct f2fs_stat_info
*si
;
182 mutex_lock(&f2fs_stat_mutex
);
183 list_for_each_entry(si
, &f2fs_stat_list
, stat_list
) {
184 char devname
[BDEVNAME_SIZE
];
186 update_general_status(si
->sbi
);
188 seq_printf(s
, "\n=====[ partition info(%s). #%d ]=====\n",
189 bdevname(si
->sbi
->sb
->s_bdev
, devname
), i
++);
190 seq_printf(s
, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
191 si
->sit_area_segs
, si
->nat_area_segs
);
192 seq_printf(s
, "[SSA: %d] [MAIN: %d",
193 si
->ssa_area_segs
, si
->main_area_segs
);
194 seq_printf(s
, "(OverProv:%d Resv:%d)]\n\n",
195 si
->overp_segs
, si
->rsvd_segs
);
196 seq_printf(s
, "Utilization: %d%% (%d valid blocks)\n",
197 si
->utilization
, si
->valid_count
);
198 seq_printf(s
, " - Node: %u (Inode: %u, ",
199 si
->valid_node_count
, si
->valid_inode_count
);
200 seq_printf(s
, "Other: %u)\n - Data: %u\n",
201 si
->valid_node_count
- si
->valid_inode_count
,
202 si
->valid_count
- si
->valid_node_count
);
203 seq_printf(s
, "\nMain area: %d segs, %d secs %d zones\n",
204 si
->main_area_segs
, si
->main_area_sections
,
205 si
->main_area_zones
);
206 seq_printf(s
, " - COLD data: %d, %d, %d\n",
207 si
->curseg
[CURSEG_COLD_DATA
],
208 si
->cursec
[CURSEG_COLD_DATA
],
209 si
->curzone
[CURSEG_COLD_DATA
]);
210 seq_printf(s
, " - WARM data: %d, %d, %d\n",
211 si
->curseg
[CURSEG_WARM_DATA
],
212 si
->cursec
[CURSEG_WARM_DATA
],
213 si
->curzone
[CURSEG_WARM_DATA
]);
214 seq_printf(s
, " - HOT data: %d, %d, %d\n",
215 si
->curseg
[CURSEG_HOT_DATA
],
216 si
->cursec
[CURSEG_HOT_DATA
],
217 si
->curzone
[CURSEG_HOT_DATA
]);
218 seq_printf(s
, " - Dir dnode: %d, %d, %d\n",
219 si
->curseg
[CURSEG_HOT_NODE
],
220 si
->cursec
[CURSEG_HOT_NODE
],
221 si
->curzone
[CURSEG_HOT_NODE
]);
222 seq_printf(s
, " - File dnode: %d, %d, %d\n",
223 si
->curseg
[CURSEG_WARM_NODE
],
224 si
->cursec
[CURSEG_WARM_NODE
],
225 si
->curzone
[CURSEG_WARM_NODE
]);
226 seq_printf(s
, " - Indir nodes: %d, %d, %d\n",
227 si
->curseg
[CURSEG_COLD_NODE
],
228 si
->cursec
[CURSEG_COLD_NODE
],
229 si
->curzone
[CURSEG_COLD_NODE
]);
230 seq_printf(s
, "\n - Valid: %d\n - Dirty: %d\n",
231 si
->main_area_segs
- si
->dirty_count
-
232 si
->prefree_count
- si
->free_segs
,
234 seq_printf(s
, " - Prefree: %d\n - Free: %d (%d)\n\n",
235 si
->prefree_count
, si
->free_segs
, si
->free_secs
);
236 seq_printf(s
, "GC calls: %d (BG: %d)\n",
237 si
->call_count
, si
->bg_gc
);
238 seq_printf(s
, " - data segments : %d\n", si
->data_segs
);
239 seq_printf(s
, " - node segments : %d\n", si
->node_segs
);
240 seq_printf(s
, "Try to move %d blocks\n", si
->tot_blks
);
241 seq_printf(s
, " - data blocks : %d\n", si
->data_blks
);
242 seq_printf(s
, " - node blocks : %d\n", si
->node_blks
);
243 seq_printf(s
, "\nExtent Hit Ratio: %d / %d\n",
244 si
->hit_ext
, si
->total_ext
);
245 seq_printf(s
, "\nBalancing F2FS Async:\n");
246 seq_printf(s
, " - nodes %4d in %4d\n",
247 si
->ndirty_node
, si
->node_pages
);
248 seq_printf(s
, " - dents %4d in dirs:%4d\n",
249 si
->ndirty_dent
, si
->ndirty_dirs
);
250 seq_printf(s
, " - meta %4d in %4d\n",
251 si
->ndirty_meta
, si
->meta_pages
);
252 seq_printf(s
, " - NATs %5d > %lu\n",
253 si
->nats
, NM_WOUT_THRESHOLD
);
254 seq_printf(s
, " - SITs: %5d\n - free_nids: %5d\n",
255 si
->sits
, si
->fnids
);
256 seq_puts(s
, "\nDistribution of User Blocks:");
257 seq_puts(s
, " [ valid | invalid | free ]\n");
260 for (j
= 0; j
< si
->util_valid
; j
++)
264 for (j
= 0; j
< si
->util_invalid
; j
++)
268 for (j
= 0; j
< si
->util_free
; j
++)
270 seq_puts(s
, "]\n\n");
271 seq_printf(s
, "SSR: %u blocks in %u segments\n",
272 si
->block_count
[SSR
], si
->segment_count
[SSR
]);
273 seq_printf(s
, "LFS: %u blocks in %u segments\n",
274 si
->block_count
[LFS
], si
->segment_count
[LFS
]);
276 /* segment usage info */
277 update_sit_info(si
->sbi
);
278 seq_printf(s
, "\nBDF: %u, avg. vblocks: %u\n",
279 si
->bimodal
, si
->avg_vblocks
);
281 /* memory footprint */
282 update_mem_info(si
->sbi
);
283 seq_printf(s
, "\nMemory: %u KB = static: %u + cached: %u\n",
284 (si
->base_mem
+ si
->cache_mem
) >> 10,
285 si
->base_mem
>> 10, si
->cache_mem
>> 10);
287 mutex_unlock(&f2fs_stat_mutex
);
291 static int stat_open(struct inode
*inode
, struct file
*file
)
293 return single_open(file
, stat_show
, inode
->i_private
);
296 static const struct file_operations stat_fops
= {
300 .release
= single_release
,
303 int f2fs_build_stats(struct f2fs_sb_info
*sbi
)
305 struct f2fs_super_block
*raw_super
= F2FS_RAW_SUPER(sbi
);
306 struct f2fs_stat_info
*si
;
308 si
= kzalloc(sizeof(struct f2fs_stat_info
), GFP_KERNEL
);
312 si
->all_area_segs
= le32_to_cpu(raw_super
->segment_count
);
313 si
->sit_area_segs
= le32_to_cpu(raw_super
->segment_count_sit
);
314 si
->nat_area_segs
= le32_to_cpu(raw_super
->segment_count_nat
);
315 si
->ssa_area_segs
= le32_to_cpu(raw_super
->segment_count_ssa
);
316 si
->main_area_segs
= le32_to_cpu(raw_super
->segment_count_main
);
317 si
->main_area_sections
= le32_to_cpu(raw_super
->section_count
);
318 si
->main_area_zones
= si
->main_area_sections
/
319 le32_to_cpu(raw_super
->secs_per_zone
);
323 mutex_lock(&f2fs_stat_mutex
);
324 list_add_tail(&si
->stat_list
, &f2fs_stat_list
);
325 mutex_unlock(&f2fs_stat_mutex
);
330 void f2fs_destroy_stats(struct f2fs_sb_info
*sbi
)
332 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
334 mutex_lock(&f2fs_stat_mutex
);
335 list_del(&si
->stat_list
);
336 mutex_unlock(&f2fs_stat_mutex
);
341 void __init
f2fs_create_root_stats(void)
343 debugfs_root
= debugfs_create_dir("f2fs", NULL
);
345 debugfs_create_file("status", S_IRUGO
, debugfs_root
,
349 void f2fs_destroy_root_stats(void)
351 debugfs_remove_recursive(debugfs_root
);