xref: /openbmc/linux/fs/f2fs/debug.c (revision f0248ba6)
1 // SPDX-License-Identifier: GPL-2.0
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 <gregkh@linuxfoundation.org>
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_RAW_SPINLOCK(f2fs_stat_lock);
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  */
f2fs_update_sit_info(struct f2fs_sb_info * sbi)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 = CAP_BLKS_PER_SEC(sbi);
43 	hblks_per_sec = blks_per_sec / 2;
44 	for (segno = 0; segno < MAIN_SEGS(sbi); segno += SEGS_PER_SEC(sbi)) {
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
update_general_status(struct f2fs_sb_info * sbi)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 	/* these will be changed if online resize is done */
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 	/* general extent cache stats */
76 	for (i = 0; i < NR_EXTENT_CACHES; i++) {
77 		struct extent_tree_info *eti = &sbi->extent_tree[i];
78 
79 		si->hit_cached[i] = atomic64_read(&sbi->read_hit_cached[i]);
80 		si->hit_rbtree[i] = atomic64_read(&sbi->read_hit_rbtree[i]);
81 		si->total_ext[i] = atomic64_read(&sbi->total_hit_ext[i]);
82 		si->hit_total[i] = si->hit_cached[i] + si->hit_rbtree[i];
83 		si->ext_tree[i] = atomic_read(&eti->total_ext_tree);
84 		si->zombie_tree[i] = atomic_read(&eti->total_zombie_tree);
85 		si->ext_node[i] = atomic_read(&eti->total_ext_node);
86 	}
87 	/* read extent_cache only */
88 	si->hit_largest = atomic64_read(&sbi->read_hit_largest);
89 	si->hit_total[EX_READ] += si->hit_largest;
90 
91 	/* block age extent_cache only */
92 	si->allocated_data_blocks = atomic64_read(&sbi->allocated_data_blocks);
93 
94 	/* validation check of the segment numbers */
95 	si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
96 	si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
97 	si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META);
98 	si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA);
99 	si->ndirty_qdata = get_pages(sbi, F2FS_DIRTY_QDATA);
100 	si->ndirty_imeta = get_pages(sbi, F2FS_DIRTY_IMETA);
101 	si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE];
102 	si->ndirty_files = sbi->ndirty_inode[FILE_INODE];
103 	si->nquota_files = sbi->nquota_files;
104 	si->ndirty_all = sbi->ndirty_inode[DIRTY_META];
105 	si->aw_cnt = atomic_read(&sbi->atomic_files);
106 	si->max_aw_cnt = atomic_read(&sbi->max_aw_cnt);
107 	si->nr_dio_read = get_pages(sbi, F2FS_DIO_READ);
108 	si->nr_dio_write = get_pages(sbi, F2FS_DIO_WRITE);
109 	si->nr_wb_cp_data = get_pages(sbi, F2FS_WB_CP_DATA);
110 	si->nr_wb_data = get_pages(sbi, F2FS_WB_DATA);
111 	si->nr_rd_data = get_pages(sbi, F2FS_RD_DATA);
112 	si->nr_rd_node = get_pages(sbi, F2FS_RD_NODE);
113 	si->nr_rd_meta = get_pages(sbi, F2FS_RD_META);
114 	if (SM_I(sbi)->fcc_info) {
115 		si->nr_flushed =
116 			atomic_read(&SM_I(sbi)->fcc_info->issued_flush);
117 		si->nr_flushing =
118 			atomic_read(&SM_I(sbi)->fcc_info->queued_flush);
119 		si->flush_list_empty =
120 			llist_empty(&SM_I(sbi)->fcc_info->issue_list);
121 	}
122 	if (SM_I(sbi)->dcc_info) {
123 		si->nr_discarded =
124 			atomic_read(&SM_I(sbi)->dcc_info->issued_discard);
125 		si->nr_discarding =
126 			atomic_read(&SM_I(sbi)->dcc_info->queued_discard);
127 		si->nr_discard_cmd =
128 			atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
129 		si->undiscard_blks = SM_I(sbi)->dcc_info->undiscard_blks;
130 	}
131 	si->nr_issued_ckpt = atomic_read(&sbi->cprc_info.issued_ckpt);
132 	si->nr_total_ckpt = atomic_read(&sbi->cprc_info.total_ckpt);
133 	si->nr_queued_ckpt = atomic_read(&sbi->cprc_info.queued_ckpt);
134 	spin_lock(&sbi->cprc_info.stat_lock);
135 	si->cur_ckpt_time = sbi->cprc_info.cur_time;
136 	si->peak_ckpt_time = sbi->cprc_info.peak_time;
137 	spin_unlock(&sbi->cprc_info.stat_lock);
138 	si->total_count = (int)sbi->user_block_count / BLKS_PER_SEG(sbi);
139 	si->rsvd_segs = reserved_segments(sbi);
140 	si->overp_segs = overprovision_segments(sbi);
141 	si->valid_count = valid_user_blocks(sbi);
142 	si->discard_blks = discard_blocks(sbi);
143 	si->valid_node_count = valid_node_count(sbi);
144 	si->valid_inode_count = valid_inode_count(sbi);
145 	si->inline_xattr = atomic_read(&sbi->inline_xattr);
146 	si->inline_inode = atomic_read(&sbi->inline_inode);
147 	si->inline_dir = atomic_read(&sbi->inline_dir);
148 	si->compr_inode = atomic_read(&sbi->compr_inode);
149 	si->swapfile_inode = atomic_read(&sbi->swapfile_inode);
150 	si->compr_blocks = atomic64_read(&sbi->compr_blocks);
151 	si->append = sbi->im[APPEND_INO].ino_num;
152 	si->update = sbi->im[UPDATE_INO].ino_num;
153 	si->orphans = sbi->im[ORPHAN_INO].ino_num;
154 	si->utilization = utilization(sbi);
155 
156 	si->free_segs = free_segments(sbi);
157 	si->free_secs = free_sections(sbi);
158 	si->prefree_count = prefree_segments(sbi);
159 	si->dirty_count = dirty_segments(sbi);
160 	if (sbi->node_inode)
161 		si->node_pages = NODE_MAPPING(sbi)->nrpages;
162 	if (sbi->meta_inode)
163 		si->meta_pages = META_MAPPING(sbi)->nrpages;
164 #ifdef CONFIG_F2FS_FS_COMPRESSION
165 	if (sbi->compress_inode) {
166 		si->compress_pages = COMPRESS_MAPPING(sbi)->nrpages;
167 		si->compress_page_hit = atomic_read(&sbi->compress_page_hit);
168 	}
169 #endif
170 	si->nats = NM_I(sbi)->nat_cnt[TOTAL_NAT];
171 	si->dirty_nats = NM_I(sbi)->nat_cnt[DIRTY_NAT];
172 	si->sits = MAIN_SEGS(sbi);
173 	si->dirty_sits = SIT_I(sbi)->dirty_sentries;
174 	si->free_nids = NM_I(sbi)->nid_cnt[FREE_NID];
175 	si->avail_nids = NM_I(sbi)->available_nids;
176 	si->alloc_nids = NM_I(sbi)->nid_cnt[PREALLOC_NID];
177 	si->io_skip_bggc = sbi->io_skip_bggc;
178 	si->other_skip_bggc = sbi->other_skip_bggc;
179 	si->util_free = (int)(free_user_blocks(sbi) >> sbi->log_blocks_per_seg)
180 		* 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
181 		/ 2;
182 	si->util_valid = (int)(written_block_count(sbi) >>
183 						sbi->log_blocks_per_seg)
184 		* 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
185 		/ 2;
186 	si->util_invalid = 50 - si->util_free - si->util_valid;
187 	for (i = CURSEG_HOT_DATA; i < NO_CHECK_TYPE; i++) {
188 		struct curseg_info *curseg = CURSEG_I(sbi, i);
189 
190 		si->curseg[i] = curseg->segno;
191 		si->cursec[i] = GET_SEC_FROM_SEG(sbi, curseg->segno);
192 		si->curzone[i] = GET_ZONE_FROM_SEC(sbi, si->cursec[i]);
193 	}
194 
195 	for (i = META_CP; i < META_MAX; i++)
196 		si->meta_count[i] = atomic_read(&sbi->meta_count[i]);
197 
198 	for (i = 0; i < NO_CHECK_TYPE; i++) {
199 		si->dirty_seg[i] = 0;
200 		si->full_seg[i] = 0;
201 		si->valid_blks[i] = 0;
202 	}
203 
204 	for (i = 0; i < MAIN_SEGS(sbi); i++) {
205 		int blks = get_seg_entry(sbi, i)->valid_blocks;
206 		int type = get_seg_entry(sbi, i)->type;
207 
208 		if (!blks)
209 			continue;
210 
211 		if (blks == BLKS_PER_SEG(sbi))
212 			si->full_seg[type]++;
213 		else
214 			si->dirty_seg[type]++;
215 		si->valid_blks[type] += blks;
216 	}
217 
218 	for (i = 0; i < MAX_CALL_TYPE; i++)
219 		si->cp_call_count[i] = atomic_read(&sbi->cp_call_count[i]);
220 
221 	for (i = 0; i < 2; i++) {
222 		si->segment_count[i] = sbi->segment_count[i];
223 		si->block_count[i] = sbi->block_count[i];
224 	}
225 
226 	si->inplace_count = atomic_read(&sbi->inplace_count);
227 }
228 
229 /*
230  * This function calculates memory footprint.
231  */
update_mem_info(struct f2fs_sb_info * sbi)232 static void update_mem_info(struct f2fs_sb_info *sbi)
233 {
234 	struct f2fs_stat_info *si = F2FS_STAT(sbi);
235 	int i;
236 
237 	if (si->base_mem)
238 		goto get_cache;
239 
240 	/* build stat */
241 	si->base_mem = sizeof(struct f2fs_stat_info);
242 
243 	/* build superblock */
244 	si->base_mem += sizeof(struct f2fs_sb_info) + sbi->sb->s_blocksize;
245 	si->base_mem += 2 * sizeof(struct f2fs_inode_info);
246 	si->base_mem += sizeof(*sbi->ckpt);
247 
248 	/* build sm */
249 	si->base_mem += sizeof(struct f2fs_sm_info);
250 
251 	/* build sit */
252 	si->base_mem += sizeof(struct sit_info);
253 	si->base_mem += MAIN_SEGS(sbi) * sizeof(struct seg_entry);
254 	si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
255 	si->base_mem += 2 * SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
256 	si->base_mem += SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
257 	si->base_mem += SIT_VBLOCK_MAP_SIZE;
258 	if (__is_large_section(sbi))
259 		si->base_mem += MAIN_SECS(sbi) * sizeof(struct sec_entry);
260 	si->base_mem += __bitmap_size(sbi, SIT_BITMAP);
261 
262 	/* build free segmap */
263 	si->base_mem += sizeof(struct free_segmap_info);
264 	si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
265 	si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
266 
267 	/* build curseg */
268 	si->base_mem += sizeof(struct curseg_info) * NR_CURSEG_TYPE;
269 	si->base_mem += PAGE_SIZE * NR_CURSEG_TYPE;
270 
271 	/* build dirty segmap */
272 	si->base_mem += sizeof(struct dirty_seglist_info);
273 	si->base_mem += NR_DIRTY_TYPE * f2fs_bitmap_size(MAIN_SEGS(sbi));
274 	si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
275 
276 	/* build nm */
277 	si->base_mem += sizeof(struct f2fs_nm_info);
278 	si->base_mem += __bitmap_size(sbi, NAT_BITMAP);
279 	si->base_mem += (NM_I(sbi)->nat_bits_blocks << F2FS_BLKSIZE_BITS);
280 	si->base_mem += NM_I(sbi)->nat_blocks *
281 				f2fs_bitmap_size(NAT_ENTRY_PER_BLOCK);
282 	si->base_mem += NM_I(sbi)->nat_blocks / 8;
283 	si->base_mem += NM_I(sbi)->nat_blocks * sizeof(unsigned short);
284 
285 get_cache:
286 	si->cache_mem = 0;
287 
288 	/* build gc */
289 	if (sbi->gc_thread)
290 		si->cache_mem += sizeof(struct f2fs_gc_kthread);
291 
292 	/* build merge flush thread */
293 	if (SM_I(sbi)->fcc_info)
294 		si->cache_mem += sizeof(struct flush_cmd_control);
295 	if (SM_I(sbi)->dcc_info) {
296 		si->cache_mem += sizeof(struct discard_cmd_control);
297 		si->cache_mem += sizeof(struct discard_cmd) *
298 			atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
299 	}
300 
301 	/* free nids */
302 	si->cache_mem += (NM_I(sbi)->nid_cnt[FREE_NID] +
303 				NM_I(sbi)->nid_cnt[PREALLOC_NID]) *
304 				sizeof(struct free_nid);
305 	si->cache_mem += NM_I(sbi)->nat_cnt[TOTAL_NAT] *
306 				sizeof(struct nat_entry);
307 	si->cache_mem += NM_I(sbi)->nat_cnt[DIRTY_NAT] *
308 				sizeof(struct nat_entry_set);
309 	for (i = 0; i < MAX_INO_ENTRY; i++)
310 		si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry);
311 
312 	for (i = 0; i < NR_EXTENT_CACHES; i++) {
313 		struct extent_tree_info *eti = &sbi->extent_tree[i];
314 
315 		si->ext_mem[i] = atomic_read(&eti->total_ext_tree) *
316 						sizeof(struct extent_tree);
317 		si->ext_mem[i] += atomic_read(&eti->total_ext_node) *
318 						sizeof(struct extent_node);
319 		si->cache_mem += si->ext_mem[i];
320 	}
321 
322 	si->page_mem = 0;
323 	if (sbi->node_inode) {
324 		unsigned long npages = NODE_MAPPING(sbi)->nrpages;
325 
326 		si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
327 	}
328 	if (sbi->meta_inode) {
329 		unsigned long npages = META_MAPPING(sbi)->nrpages;
330 
331 		si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
332 	}
333 #ifdef CONFIG_F2FS_FS_COMPRESSION
334 	if (sbi->compress_inode) {
335 		unsigned long npages = COMPRESS_MAPPING(sbi)->nrpages;
336 
337 		si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
338 	}
339 #endif
340 }
341 
342 static const char *s_flag[MAX_SBI_FLAG] = {
343 	[SBI_IS_DIRTY]		= "fs_dirty",
344 	[SBI_IS_CLOSE]		= "closing",
345 	[SBI_NEED_FSCK]		= "need_fsck",
346 	[SBI_POR_DOING]		= "recovering",
347 	[SBI_NEED_SB_WRITE]	= "sb_dirty",
348 	[SBI_NEED_CP]		= "need_cp",
349 	[SBI_IS_SHUTDOWN]	= "shutdown",
350 	[SBI_IS_RECOVERED]	= "recovered",
351 	[SBI_CP_DISABLED]	= "cp_disabled",
352 	[SBI_CP_DISABLED_QUICK]	= "cp_disabled_quick",
353 	[SBI_QUOTA_NEED_FLUSH]	= "quota_need_flush",
354 	[SBI_QUOTA_SKIP_FLUSH]	= "quota_skip_flush",
355 	[SBI_QUOTA_NEED_REPAIR]	= "quota_need_repair",
356 	[SBI_IS_RESIZEFS]	= "resizefs",
357 	[SBI_IS_FREEZING]	= "freezefs",
358 	[SBI_IS_WRITABLE]	= "writable",
359 };
360 
361 static const char *ipu_mode_names[F2FS_IPU_MAX] = {
362 	[F2FS_IPU_FORCE]	= "FORCE",
363 	[F2FS_IPU_SSR]		= "SSR",
364 	[F2FS_IPU_UTIL]		= "UTIL",
365 	[F2FS_IPU_SSR_UTIL]	= "SSR_UTIL",
366 	[F2FS_IPU_FSYNC]	= "FSYNC",
367 	[F2FS_IPU_ASYNC]	= "ASYNC",
368 	[F2FS_IPU_NOCACHE]	= "NOCACHE",
369 	[F2FS_IPU_HONOR_OPU_WRITE]	= "HONOR_OPU_WRITE",
370 };
371 
stat_show(struct seq_file * s,void * v)372 static int stat_show(struct seq_file *s, void *v)
373 {
374 	struct f2fs_stat_info *si;
375 	int i = 0, j = 0;
376 	unsigned long flags;
377 
378 	raw_spin_lock_irqsave(&f2fs_stat_lock, flags);
379 	list_for_each_entry(si, &f2fs_stat_list, stat_list) {
380 		struct f2fs_sb_info *sbi = si->sbi;
381 
382 		update_general_status(sbi);
383 
384 		seq_printf(s, "\n=====[ partition info(%pg). #%d, %s, CP: %s]=====\n",
385 			sbi->sb->s_bdev, i++,
386 			f2fs_readonly(sbi->sb) ? "RO" : "RW",
387 			is_set_ckpt_flags(sbi, CP_DISABLED_FLAG) ?
388 			"Disabled" : (f2fs_cp_error(sbi) ? "Error" : "Good"));
389 		if (sbi->s_flag) {
390 			seq_puts(s, "[SBI:");
391 			for_each_set_bit(j, &sbi->s_flag, MAX_SBI_FLAG)
392 				seq_printf(s, " %s", s_flag[j]);
393 			seq_puts(s, "]\n");
394 		}
395 		seq_printf(s, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
396 			   si->sit_area_segs, si->nat_area_segs);
397 		seq_printf(s, "[SSA: %d] [MAIN: %d",
398 			   si->ssa_area_segs, si->main_area_segs);
399 		seq_printf(s, "(OverProv:%d Resv:%d)]\n\n",
400 			   si->overp_segs, si->rsvd_segs);
401 		seq_printf(s, "Current Time Sec: %llu / Mounted Time Sec: %llu\n\n",
402 					ktime_get_boottime_seconds(),
403 					SIT_I(sbi)->mounted_time);
404 
405 		seq_puts(s, "Policy:\n");
406 		seq_puts(s, "  - IPU: [");
407 		if (IS_F2FS_IPU_DISABLE(sbi)) {
408 			seq_puts(s, " DISABLE");
409 		} else {
410 			unsigned long policy = SM_I(sbi)->ipu_policy;
411 
412 			for_each_set_bit(j, &policy, F2FS_IPU_MAX)
413 				seq_printf(s, " %s", ipu_mode_names[j]);
414 		}
415 		seq_puts(s, " ]\n\n");
416 
417 		if (test_opt(sbi, DISCARD))
418 			seq_printf(s, "Utilization: %u%% (%u valid blocks, %u discard blocks)\n",
419 				si->utilization, si->valid_count, si->discard_blks);
420 		else
421 			seq_printf(s, "Utilization: %u%% (%u valid blocks)\n",
422 				si->utilization, si->valid_count);
423 
424 		seq_printf(s, "  - Node: %u (Inode: %u, ",
425 			   si->valid_node_count, si->valid_inode_count);
426 		seq_printf(s, "Other: %u)\n  - Data: %u\n",
427 			   si->valid_node_count - si->valid_inode_count,
428 			   si->valid_count - si->valid_node_count);
429 		seq_printf(s, "  - Inline_xattr Inode: %u\n",
430 			   si->inline_xattr);
431 		seq_printf(s, "  - Inline_data Inode: %u\n",
432 			   si->inline_inode);
433 		seq_printf(s, "  - Inline_dentry Inode: %u\n",
434 			   si->inline_dir);
435 		seq_printf(s, "  - Compressed Inode: %u, Blocks: %llu\n",
436 			   si->compr_inode, si->compr_blocks);
437 		seq_printf(s, "  - Swapfile Inode: %u\n",
438 			   si->swapfile_inode);
439 		seq_printf(s, "  - Orphan/Append/Update Inode: %u, %u, %u\n",
440 			   si->orphans, si->append, si->update);
441 		seq_printf(s, "\nMain area: %d segs, %d secs %d zones\n",
442 			   si->main_area_segs, si->main_area_sections,
443 			   si->main_area_zones);
444 		seq_printf(s, "    TYPE         %8s %8s %8s %10s %10s %10s\n",
445 			   "segno", "secno", "zoneno", "dirty_seg", "full_seg", "valid_blk");
446 		seq_printf(s, "  - COLD   data: %8d %8d %8d %10u %10u %10u\n",
447 			   si->curseg[CURSEG_COLD_DATA],
448 			   si->cursec[CURSEG_COLD_DATA],
449 			   si->curzone[CURSEG_COLD_DATA],
450 			   si->dirty_seg[CURSEG_COLD_DATA],
451 			   si->full_seg[CURSEG_COLD_DATA],
452 			   si->valid_blks[CURSEG_COLD_DATA]);
453 		seq_printf(s, "  - WARM   data: %8d %8d %8d %10u %10u %10u\n",
454 			   si->curseg[CURSEG_WARM_DATA],
455 			   si->cursec[CURSEG_WARM_DATA],
456 			   si->curzone[CURSEG_WARM_DATA],
457 			   si->dirty_seg[CURSEG_WARM_DATA],
458 			   si->full_seg[CURSEG_WARM_DATA],
459 			   si->valid_blks[CURSEG_WARM_DATA]);
460 		seq_printf(s, "  - HOT    data: %8d %8d %8d %10u %10u %10u\n",
461 			   si->curseg[CURSEG_HOT_DATA],
462 			   si->cursec[CURSEG_HOT_DATA],
463 			   si->curzone[CURSEG_HOT_DATA],
464 			   si->dirty_seg[CURSEG_HOT_DATA],
465 			   si->full_seg[CURSEG_HOT_DATA],
466 			   si->valid_blks[CURSEG_HOT_DATA]);
467 		seq_printf(s, "  - Dir   dnode: %8d %8d %8d %10u %10u %10u\n",
468 			   si->curseg[CURSEG_HOT_NODE],
469 			   si->cursec[CURSEG_HOT_NODE],
470 			   si->curzone[CURSEG_HOT_NODE],
471 			   si->dirty_seg[CURSEG_HOT_NODE],
472 			   si->full_seg[CURSEG_HOT_NODE],
473 			   si->valid_blks[CURSEG_HOT_NODE]);
474 		seq_printf(s, "  - File  dnode: %8d %8d %8d %10u %10u %10u\n",
475 			   si->curseg[CURSEG_WARM_NODE],
476 			   si->cursec[CURSEG_WARM_NODE],
477 			   si->curzone[CURSEG_WARM_NODE],
478 			   si->dirty_seg[CURSEG_WARM_NODE],
479 			   si->full_seg[CURSEG_WARM_NODE],
480 			   si->valid_blks[CURSEG_WARM_NODE]);
481 		seq_printf(s, "  - Indir nodes: %8d %8d %8d %10u %10u %10u\n",
482 			   si->curseg[CURSEG_COLD_NODE],
483 			   si->cursec[CURSEG_COLD_NODE],
484 			   si->curzone[CURSEG_COLD_NODE],
485 			   si->dirty_seg[CURSEG_COLD_NODE],
486 			   si->full_seg[CURSEG_COLD_NODE],
487 			   si->valid_blks[CURSEG_COLD_NODE]);
488 		seq_printf(s, "  - Pinned file: %8d %8d %8d\n",
489 			   si->curseg[CURSEG_COLD_DATA_PINNED],
490 			   si->cursec[CURSEG_COLD_DATA_PINNED],
491 			   si->curzone[CURSEG_COLD_DATA_PINNED]);
492 		seq_printf(s, "  - ATGC   data: %8d %8d %8d\n",
493 			   si->curseg[CURSEG_ALL_DATA_ATGC],
494 			   si->cursec[CURSEG_ALL_DATA_ATGC],
495 			   si->curzone[CURSEG_ALL_DATA_ATGC]);
496 		seq_printf(s, "\n  - Valid: %d\n  - Dirty: %d\n",
497 			   si->main_area_segs - si->dirty_count -
498 			   si->prefree_count - si->free_segs,
499 			   si->dirty_count);
500 		seq_printf(s, "  - Prefree: %d\n  - Free: %d (%d)\n\n",
501 			   si->prefree_count, si->free_segs, si->free_secs);
502 		seq_printf(s, "CP calls: %d (BG: %d)\n",
503 			   si->cp_call_count[TOTAL_CALL],
504 			   si->cp_call_count[BACKGROUND]);
505 		seq_printf(s, "CP count: %d\n", si->cp_count);
506 		seq_printf(s, "  - cp blocks : %u\n", si->meta_count[META_CP]);
507 		seq_printf(s, "  - sit blocks : %u\n",
508 				si->meta_count[META_SIT]);
509 		seq_printf(s, "  - nat blocks : %u\n",
510 				si->meta_count[META_NAT]);
511 		seq_printf(s, "  - ssa blocks : %u\n",
512 				si->meta_count[META_SSA]);
513 		seq_puts(s, "CP merge:\n");
514 		seq_printf(s, "  - Queued : %4d\n", si->nr_queued_ckpt);
515 		seq_printf(s, "  - Issued : %4d\n", si->nr_issued_ckpt);
516 		seq_printf(s, "  - Total : %4d\n", si->nr_total_ckpt);
517 		seq_printf(s, "  - Cur time : %4d(ms)\n", si->cur_ckpt_time);
518 		seq_printf(s, "  - Peak time : %4d(ms)\n", si->peak_ckpt_time);
519 		seq_printf(s, "GC calls: %d (gc_thread: %d)\n",
520 			   si->gc_call_count[BACKGROUND] +
521 			   si->gc_call_count[FOREGROUND],
522 			   si->gc_call_count[BACKGROUND]);
523 		if (__is_large_section(sbi)) {
524 			seq_printf(s, "  - data sections : %d (BG: %d)\n",
525 					si->gc_secs[DATA][BG_GC] + si->gc_secs[DATA][FG_GC],
526 					si->gc_secs[DATA][BG_GC]);
527 			seq_printf(s, "  - node sections : %d (BG: %d)\n",
528 					si->gc_secs[NODE][BG_GC] + si->gc_secs[NODE][FG_GC],
529 					si->gc_secs[NODE][BG_GC]);
530 		}
531 		seq_printf(s, "  - data segments : %d (BG: %d)\n",
532 				si->gc_segs[DATA][BG_GC] + si->gc_segs[DATA][FG_GC],
533 				si->gc_segs[DATA][BG_GC]);
534 		seq_printf(s, "  - node segments : %d (BG: %d)\n",
535 				si->gc_segs[NODE][BG_GC] + si->gc_segs[NODE][FG_GC],
536 				si->gc_segs[NODE][BG_GC]);
537 		seq_puts(s, "  - Reclaimed segs :\n");
538 		seq_printf(s, "    - Normal : %d\n", sbi->gc_reclaimed_segs[GC_NORMAL]);
539 		seq_printf(s, "    - Idle CB : %d\n", sbi->gc_reclaimed_segs[GC_IDLE_CB]);
540 		seq_printf(s, "    - Idle Greedy : %d\n",
541 				sbi->gc_reclaimed_segs[GC_IDLE_GREEDY]);
542 		seq_printf(s, "    - Idle AT : %d\n", sbi->gc_reclaimed_segs[GC_IDLE_AT]);
543 		seq_printf(s, "    - Urgent High : %d\n",
544 				sbi->gc_reclaimed_segs[GC_URGENT_HIGH]);
545 		seq_printf(s, "    - Urgent Mid : %d\n", sbi->gc_reclaimed_segs[GC_URGENT_MID]);
546 		seq_printf(s, "    - Urgent Low : %d\n", sbi->gc_reclaimed_segs[GC_URGENT_LOW]);
547 		seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks,
548 				si->bg_data_blks + si->bg_node_blks);
549 		seq_printf(s, "  - data blocks : %d (%d)\n", si->data_blks,
550 				si->bg_data_blks);
551 		seq_printf(s, "  - node blocks : %d (%d)\n", si->node_blks,
552 				si->bg_node_blks);
553 		seq_printf(s, "BG skip : IO: %u, Other: %u\n",
554 				si->io_skip_bggc, si->other_skip_bggc);
555 		seq_puts(s, "\nExtent Cache (Read):\n");
556 		seq_printf(s, "  - Hit Count: L1-1:%llu L1-2:%llu L2:%llu\n",
557 				si->hit_largest, si->hit_cached[EX_READ],
558 				si->hit_rbtree[EX_READ]);
559 		seq_printf(s, "  - Hit Ratio: %llu%% (%llu / %llu)\n",
560 				!si->total_ext[EX_READ] ? 0 :
561 				div64_u64(si->hit_total[EX_READ] * 100,
562 				si->total_ext[EX_READ]),
563 				si->hit_total[EX_READ], si->total_ext[EX_READ]);
564 		seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
565 				si->ext_tree[EX_READ], si->zombie_tree[EX_READ],
566 				si->ext_node[EX_READ]);
567 		seq_puts(s, "\nExtent Cache (Block Age):\n");
568 		seq_printf(s, "  - Allocated Data Blocks: %llu\n",
569 				si->allocated_data_blocks);
570 		seq_printf(s, "  - Hit Count: L1:%llu L2:%llu\n",
571 				si->hit_cached[EX_BLOCK_AGE],
572 				si->hit_rbtree[EX_BLOCK_AGE]);
573 		seq_printf(s, "  - Hit Ratio: %llu%% (%llu / %llu)\n",
574 				!si->total_ext[EX_BLOCK_AGE] ? 0 :
575 				div64_u64(si->hit_total[EX_BLOCK_AGE] * 100,
576 				si->total_ext[EX_BLOCK_AGE]),
577 				si->hit_total[EX_BLOCK_AGE],
578 				si->total_ext[EX_BLOCK_AGE]);
579 		seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
580 				si->ext_tree[EX_BLOCK_AGE],
581 				si->zombie_tree[EX_BLOCK_AGE],
582 				si->ext_node[EX_BLOCK_AGE]);
583 		seq_puts(s, "\nBalancing F2FS Async:\n");
584 		seq_printf(s, "  - DIO (R: %4d, W: %4d)\n",
585 			   si->nr_dio_read, si->nr_dio_write);
586 		seq_printf(s, "  - IO_R (Data: %4d, Node: %4d, Meta: %4d\n",
587 			   si->nr_rd_data, si->nr_rd_node, si->nr_rd_meta);
588 		seq_printf(s, "  - IO_W (CP: %4d, Data: %4d, Flush: (%4d %4d %4d), ",
589 			   si->nr_wb_cp_data, si->nr_wb_data,
590 			   si->nr_flushing, si->nr_flushed,
591 			   si->flush_list_empty);
592 		seq_printf(s, "Discard: (%4d %4d)) cmd: %4d undiscard:%4u\n",
593 			   si->nr_discarding, si->nr_discarded,
594 			   si->nr_discard_cmd, si->undiscard_blks);
595 		seq_printf(s, "  - atomic IO: %4d (Max. %4d)\n",
596 			   si->aw_cnt, si->max_aw_cnt);
597 		seq_printf(s, "  - compress: %4d, hit:%8d\n", si->compress_pages, si->compress_page_hit);
598 		seq_printf(s, "  - nodes: %4d in %4d\n",
599 			   si->ndirty_node, si->node_pages);
600 		seq_printf(s, "  - dents: %4d in dirs:%4d (%4d)\n",
601 			   si->ndirty_dent, si->ndirty_dirs, si->ndirty_all);
602 		seq_printf(s, "  - datas: %4d in files:%4d\n",
603 			   si->ndirty_data, si->ndirty_files);
604 		seq_printf(s, "  - quota datas: %4d in quota files:%4d\n",
605 			   si->ndirty_qdata, si->nquota_files);
606 		seq_printf(s, "  - meta: %4d in %4d\n",
607 			   si->ndirty_meta, si->meta_pages);
608 		seq_printf(s, "  - imeta: %4d\n",
609 			   si->ndirty_imeta);
610 		seq_printf(s, "  - fsync mark: %4lld\n",
611 			   percpu_counter_sum_positive(
612 					&sbi->rf_node_block_count));
613 		seq_printf(s, "  - NATs: %9d/%9d\n  - SITs: %9d/%9d\n",
614 			   si->dirty_nats, si->nats, si->dirty_sits, si->sits);
615 		seq_printf(s, "  - free_nids: %9d/%9d\n  - alloc_nids: %9d\n",
616 			   si->free_nids, si->avail_nids, si->alloc_nids);
617 		seq_puts(s, "\nDistribution of User Blocks:");
618 		seq_puts(s, " [ valid | invalid | free ]\n");
619 		seq_puts(s, "  [");
620 
621 		for (j = 0; j < si->util_valid; j++)
622 			seq_putc(s, '-');
623 		seq_putc(s, '|');
624 
625 		for (j = 0; j < si->util_invalid; j++)
626 			seq_putc(s, '-');
627 		seq_putc(s, '|');
628 
629 		for (j = 0; j < si->util_free; j++)
630 			seq_putc(s, '-');
631 		seq_puts(s, "]\n\n");
632 		seq_printf(s, "IPU: %u blocks\n", si->inplace_count);
633 		seq_printf(s, "SSR: %u blocks in %u segments\n",
634 			   si->block_count[SSR], si->segment_count[SSR]);
635 		seq_printf(s, "LFS: %u blocks in %u segments\n",
636 			   si->block_count[LFS], si->segment_count[LFS]);
637 
638 		/* segment usage info */
639 		f2fs_update_sit_info(sbi);
640 		seq_printf(s, "\nBDF: %u, avg. vblocks: %u\n",
641 			   si->bimodal, si->avg_vblocks);
642 
643 		/* memory footprint */
644 		update_mem_info(sbi);
645 		seq_printf(s, "\nMemory: %llu KB\n",
646 			(si->base_mem + si->cache_mem + si->page_mem) >> 10);
647 		seq_printf(s, "  - static: %llu KB\n",
648 				si->base_mem >> 10);
649 		seq_printf(s, "  - cached all: %llu KB\n",
650 				si->cache_mem >> 10);
651 		seq_printf(s, "  - read extent cache: %llu KB\n",
652 				si->ext_mem[EX_READ] >> 10);
653 		seq_printf(s, "  - block age extent cache: %llu KB\n",
654 				si->ext_mem[EX_BLOCK_AGE] >> 10);
655 		seq_printf(s, "  - paged : %llu KB\n",
656 				si->page_mem >> 10);
657 	}
658 	raw_spin_unlock_irqrestore(&f2fs_stat_lock, flags);
659 	return 0;
660 }
661 
662 DEFINE_SHOW_ATTRIBUTE(stat);
663 #endif
664 
f2fs_build_stats(struct f2fs_sb_info * sbi)665 int f2fs_build_stats(struct f2fs_sb_info *sbi)
666 {
667 	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
668 	struct f2fs_stat_info *si;
669 	unsigned long flags;
670 	int i;
671 
672 	si = f2fs_kzalloc(sbi, sizeof(struct f2fs_stat_info), GFP_KERNEL);
673 	if (!si)
674 		return -ENOMEM;
675 
676 	si->all_area_segs = le32_to_cpu(raw_super->segment_count);
677 	si->sit_area_segs = le32_to_cpu(raw_super->segment_count_sit);
678 	si->nat_area_segs = le32_to_cpu(raw_super->segment_count_nat);
679 	si->ssa_area_segs = le32_to_cpu(raw_super->segment_count_ssa);
680 	si->main_area_segs = le32_to_cpu(raw_super->segment_count_main);
681 	si->main_area_sections = le32_to_cpu(raw_super->section_count);
682 	si->main_area_zones = si->main_area_sections /
683 				le32_to_cpu(raw_super->secs_per_zone);
684 	si->sbi = sbi;
685 	sbi->stat_info = si;
686 
687 	/* general extent cache stats */
688 	for (i = 0; i < NR_EXTENT_CACHES; i++) {
689 		atomic64_set(&sbi->total_hit_ext[i], 0);
690 		atomic64_set(&sbi->read_hit_rbtree[i], 0);
691 		atomic64_set(&sbi->read_hit_cached[i], 0);
692 	}
693 
694 	/* read extent_cache only */
695 	atomic64_set(&sbi->read_hit_largest, 0);
696 
697 	atomic_set(&sbi->inline_xattr, 0);
698 	atomic_set(&sbi->inline_inode, 0);
699 	atomic_set(&sbi->inline_dir, 0);
700 	atomic_set(&sbi->compr_inode, 0);
701 	atomic64_set(&sbi->compr_blocks, 0);
702 	atomic_set(&sbi->swapfile_inode, 0);
703 	atomic_set(&sbi->atomic_files, 0);
704 	atomic_set(&sbi->inplace_count, 0);
705 	for (i = META_CP; i < META_MAX; i++)
706 		atomic_set(&sbi->meta_count[i], 0);
707 	for (i = 0; i < MAX_CALL_TYPE; i++)
708 		atomic_set(&sbi->cp_call_count[i], 0);
709 
710 	atomic_set(&sbi->max_aw_cnt, 0);
711 
712 	raw_spin_lock_irqsave(&f2fs_stat_lock, flags);
713 	list_add_tail(&si->stat_list, &f2fs_stat_list);
714 	raw_spin_unlock_irqrestore(&f2fs_stat_lock, flags);
715 
716 	return 0;
717 }
718 
f2fs_destroy_stats(struct f2fs_sb_info * sbi)719 void f2fs_destroy_stats(struct f2fs_sb_info *sbi)
720 {
721 	struct f2fs_stat_info *si = F2FS_STAT(sbi);
722 	unsigned long flags;
723 
724 	raw_spin_lock_irqsave(&f2fs_stat_lock, flags);
725 	list_del(&si->stat_list);
726 	raw_spin_unlock_irqrestore(&f2fs_stat_lock, flags);
727 
728 	kfree(si);
729 }
730 
f2fs_create_root_stats(void)731 void __init f2fs_create_root_stats(void)
732 {
733 #ifdef CONFIG_DEBUG_FS
734 	f2fs_debugfs_root = debugfs_create_dir("f2fs", NULL);
735 
736 	debugfs_create_file("status", 0444, f2fs_debugfs_root, NULL,
737 			    &stat_fops);
738 #endif
739 }
740 
f2fs_destroy_root_stats(void)741 void f2fs_destroy_root_stats(void)
742 {
743 #ifdef CONFIG_DEBUG_FS
744 	debugfs_remove_recursive(f2fs_debugfs_root);
745 	f2fs_debugfs_root = NULL;
746 #endif
747 }
748