]>
git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - fs/f2fs/debug.c
1 // SPDX-License-Identifier: GPL-2.0
3 * f2fs debugging statistics
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>
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>
23 static LIST_HEAD(f2fs_stat_list
);
24 static struct dentry
*f2fs_debugfs_root
;
25 static DEFINE_MUTEX(f2fs_stat_mutex
);
27 static void update_general_status(struct f2fs_sb_info
*sbi
)
29 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
32 /* validation check of the segment numbers */
33 si
->hit_largest
= atomic64_read(&sbi
->read_hit_largest
);
34 si
->hit_cached
= atomic64_read(&sbi
->read_hit_cached
);
35 si
->hit_rbtree
= atomic64_read(&sbi
->read_hit_rbtree
);
36 si
->hit_total
= si
->hit_largest
+ si
->hit_cached
+ si
->hit_rbtree
;
37 si
->total_ext
= atomic64_read(&sbi
->total_hit_ext
);
38 si
->ext_tree
= atomic_read(&sbi
->total_ext_tree
);
39 si
->zombie_tree
= atomic_read(&sbi
->total_zombie_tree
);
40 si
->ext_node
= atomic_read(&sbi
->total_ext_node
);
41 si
->ndirty_node
= get_pages(sbi
, F2FS_DIRTY_NODES
);
42 si
->ndirty_dent
= get_pages(sbi
, F2FS_DIRTY_DENTS
);
43 si
->ndirty_meta
= get_pages(sbi
, F2FS_DIRTY_META
);
44 si
->ndirty_data
= get_pages(sbi
, F2FS_DIRTY_DATA
);
45 si
->ndirty_qdata
= get_pages(sbi
, F2FS_DIRTY_QDATA
);
46 si
->ndirty_imeta
= get_pages(sbi
, F2FS_DIRTY_IMETA
);
47 si
->ndirty_dirs
= sbi
->ndirty_inode
[DIR_INODE
];
48 si
->ndirty_files
= sbi
->ndirty_inode
[FILE_INODE
];
49 si
->nquota_files
= sbi
->nquota_files
;
50 si
->ndirty_all
= sbi
->ndirty_inode
[DIRTY_META
];
51 si
->inmem_pages
= get_pages(sbi
, F2FS_INMEM_PAGES
);
52 si
->aw_cnt
= atomic_read(&sbi
->aw_cnt
);
53 si
->vw_cnt
= atomic_read(&sbi
->vw_cnt
);
54 si
->max_aw_cnt
= atomic_read(&sbi
->max_aw_cnt
);
55 si
->max_vw_cnt
= atomic_read(&sbi
->max_vw_cnt
);
56 si
->nr_dio_read
= get_pages(sbi
, F2FS_DIO_READ
);
57 si
->nr_dio_write
= get_pages(sbi
, F2FS_DIO_WRITE
);
58 si
->nr_wb_cp_data
= get_pages(sbi
, F2FS_WB_CP_DATA
);
59 si
->nr_wb_data
= get_pages(sbi
, F2FS_WB_DATA
);
60 si
->nr_rd_data
= get_pages(sbi
, F2FS_RD_DATA
);
61 si
->nr_rd_node
= get_pages(sbi
, F2FS_RD_NODE
);
62 si
->nr_rd_meta
= get_pages(sbi
, F2FS_RD_META
);
63 if (SM_I(sbi
) && SM_I(sbi
)->fcc_info
) {
65 atomic_read(&SM_I(sbi
)->fcc_info
->issued_flush
);
67 atomic_read(&SM_I(sbi
)->fcc_info
->queued_flush
);
68 si
->flush_list_empty
=
69 llist_empty(&SM_I(sbi
)->fcc_info
->issue_list
);
71 if (SM_I(sbi
) && SM_I(sbi
)->dcc_info
) {
73 atomic_read(&SM_I(sbi
)->dcc_info
->issued_discard
);
75 atomic_read(&SM_I(sbi
)->dcc_info
->queued_discard
);
77 atomic_read(&SM_I(sbi
)->dcc_info
->discard_cmd_cnt
);
78 si
->undiscard_blks
= SM_I(sbi
)->dcc_info
->undiscard_blks
;
80 si
->total_count
= (int)sbi
->user_block_count
/ sbi
->blocks_per_seg
;
81 si
->rsvd_segs
= reserved_segments(sbi
);
82 si
->overp_segs
= overprovision_segments(sbi
);
83 si
->valid_count
= valid_user_blocks(sbi
);
84 si
->discard_blks
= discard_blocks(sbi
);
85 si
->valid_node_count
= valid_node_count(sbi
);
86 si
->valid_inode_count
= valid_inode_count(sbi
);
87 si
->inline_xattr
= atomic_read(&sbi
->inline_xattr
);
88 si
->inline_inode
= atomic_read(&sbi
->inline_inode
);
89 si
->inline_dir
= atomic_read(&sbi
->inline_dir
);
90 si
->append
= sbi
->im
[APPEND_INO
].ino_num
;
91 si
->update
= sbi
->im
[UPDATE_INO
].ino_num
;
92 si
->orphans
= sbi
->im
[ORPHAN_INO
].ino_num
;
93 si
->utilization
= utilization(sbi
);
95 si
->free_segs
= free_segments(sbi
);
96 si
->free_secs
= free_sections(sbi
);
97 si
->prefree_count
= prefree_segments(sbi
);
98 si
->dirty_count
= dirty_segments(sbi
);
100 si
->node_pages
= NODE_MAPPING(sbi
)->nrpages
;
102 si
->meta_pages
= META_MAPPING(sbi
)->nrpages
;
103 si
->nats
= NM_I(sbi
)->nat_cnt
;
104 si
->dirty_nats
= NM_I(sbi
)->dirty_nat_cnt
;
105 si
->sits
= MAIN_SEGS(sbi
);
106 si
->dirty_sits
= SIT_I(sbi
)->dirty_sentries
;
107 si
->free_nids
= NM_I(sbi
)->nid_cnt
[FREE_NID
];
108 si
->avail_nids
= NM_I(sbi
)->available_nids
;
109 si
->alloc_nids
= NM_I(sbi
)->nid_cnt
[PREALLOC_NID
];
110 si
->bg_gc
= sbi
->bg_gc
;
111 si
->io_skip_bggc
= sbi
->io_skip_bggc
;
112 si
->other_skip_bggc
= sbi
->other_skip_bggc
;
113 si
->skipped_atomic_files
[BG_GC
] = sbi
->skipped_atomic_files
[BG_GC
];
114 si
->skipped_atomic_files
[FG_GC
] = sbi
->skipped_atomic_files
[FG_GC
];
115 si
->util_free
= (int)(free_user_blocks(sbi
) >> sbi
->log_blocks_per_seg
)
116 * 100 / (int)(sbi
->user_block_count
>> sbi
->log_blocks_per_seg
)
118 si
->util_valid
= (int)(written_block_count(sbi
) >>
119 sbi
->log_blocks_per_seg
)
120 * 100 / (int)(sbi
->user_block_count
>> sbi
->log_blocks_per_seg
)
122 si
->util_invalid
= 50 - si
->util_free
- si
->util_valid
;
123 for (i
= CURSEG_HOT_DATA
; i
<= CURSEG_COLD_NODE
; i
++) {
124 struct curseg_info
*curseg
= CURSEG_I(sbi
, i
);
125 si
->curseg
[i
] = curseg
->segno
;
126 si
->cursec
[i
] = GET_SEC_FROM_SEG(sbi
, curseg
->segno
);
127 si
->curzone
[i
] = GET_ZONE_FROM_SEC(sbi
, si
->cursec
[i
]);
130 for (i
= META_CP
; i
< META_MAX
; i
++)
131 si
->meta_count
[i
] = atomic_read(&sbi
->meta_count
[i
]);
133 for (i
= 0; i
< 2; i
++) {
134 si
->segment_count
[i
] = sbi
->segment_count
[i
];
135 si
->block_count
[i
] = sbi
->block_count
[i
];
138 si
->inplace_count
= atomic_read(&sbi
->inplace_count
);
142 * This function calculates BDF of every segments
144 static void update_sit_info(struct f2fs_sb_info
*sbi
)
146 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
147 unsigned long long blks_per_sec
, hblks_per_sec
, total_vblocks
;
148 unsigned long long bimodal
, dist
;
149 unsigned int segno
, vblocks
;
154 blks_per_sec
= BLKS_PER_SEC(sbi
);
155 hblks_per_sec
= blks_per_sec
/ 2;
156 for (segno
= 0; segno
< MAIN_SEGS(sbi
); segno
+= sbi
->segs_per_sec
) {
157 vblocks
= get_valid_blocks(sbi
, segno
, true);
158 dist
= abs(vblocks
- hblks_per_sec
);
159 bimodal
+= dist
* dist
;
161 if (vblocks
> 0 && vblocks
< blks_per_sec
) {
162 total_vblocks
+= vblocks
;
166 dist
= div_u64(MAIN_SECS(sbi
) * hblks_per_sec
* hblks_per_sec
, 100);
167 si
->bimodal
= div64_u64(bimodal
, dist
);
169 si
->avg_vblocks
= div_u64(total_vblocks
, ndirty
);
175 * This function calculates memory footprint.
177 static void update_mem_info(struct f2fs_sb_info
*sbi
)
179 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
186 si
->base_mem
= sizeof(struct f2fs_stat_info
);
188 /* build superblock */
189 si
->base_mem
+= sizeof(struct f2fs_sb_info
) + sbi
->sb
->s_blocksize
;
190 si
->base_mem
+= 2 * sizeof(struct f2fs_inode_info
);
191 si
->base_mem
+= sizeof(*sbi
->ckpt
);
194 si
->base_mem
+= sizeof(struct f2fs_sm_info
);
197 si
->base_mem
+= sizeof(struct sit_info
);
198 si
->base_mem
+= MAIN_SEGS(sbi
) * sizeof(struct seg_entry
);
199 si
->base_mem
+= f2fs_bitmap_size(MAIN_SEGS(sbi
));
200 si
->base_mem
+= 2 * SIT_VBLOCK_MAP_SIZE
* MAIN_SEGS(sbi
);
201 si
->base_mem
+= SIT_VBLOCK_MAP_SIZE
* MAIN_SEGS(sbi
);
202 si
->base_mem
+= SIT_VBLOCK_MAP_SIZE
;
203 if (__is_large_section(sbi
))
204 si
->base_mem
+= MAIN_SECS(sbi
) * sizeof(struct sec_entry
);
205 si
->base_mem
+= __bitmap_size(sbi
, SIT_BITMAP
);
207 /* build free segmap */
208 si
->base_mem
+= sizeof(struct free_segmap_info
);
209 si
->base_mem
+= f2fs_bitmap_size(MAIN_SEGS(sbi
));
210 si
->base_mem
+= f2fs_bitmap_size(MAIN_SECS(sbi
));
213 si
->base_mem
+= sizeof(struct curseg_info
) * NR_CURSEG_TYPE
;
214 si
->base_mem
+= PAGE_SIZE
* NR_CURSEG_TYPE
;
216 /* build dirty segmap */
217 si
->base_mem
+= sizeof(struct dirty_seglist_info
);
218 si
->base_mem
+= NR_DIRTY_TYPE
* f2fs_bitmap_size(MAIN_SEGS(sbi
));
219 si
->base_mem
+= f2fs_bitmap_size(MAIN_SECS(sbi
));
222 si
->base_mem
+= sizeof(struct f2fs_nm_info
);
223 si
->base_mem
+= __bitmap_size(sbi
, NAT_BITMAP
);
224 si
->base_mem
+= (NM_I(sbi
)->nat_bits_blocks
<< F2FS_BLKSIZE_BITS
);
225 si
->base_mem
+= NM_I(sbi
)->nat_blocks
*
226 f2fs_bitmap_size(NAT_ENTRY_PER_BLOCK
);
227 si
->base_mem
+= NM_I(sbi
)->nat_blocks
/ 8;
228 si
->base_mem
+= NM_I(sbi
)->nat_blocks
* sizeof(unsigned short);
235 si
->cache_mem
+= sizeof(struct f2fs_gc_kthread
);
237 /* build merge flush thread */
238 if (SM_I(sbi
)->fcc_info
)
239 si
->cache_mem
+= sizeof(struct flush_cmd_control
);
240 if (SM_I(sbi
)->dcc_info
) {
241 si
->cache_mem
+= sizeof(struct discard_cmd_control
);
242 si
->cache_mem
+= sizeof(struct discard_cmd
) *
243 atomic_read(&SM_I(sbi
)->dcc_info
->discard_cmd_cnt
);
247 si
->cache_mem
+= (NM_I(sbi
)->nid_cnt
[FREE_NID
] +
248 NM_I(sbi
)->nid_cnt
[PREALLOC_NID
]) *
249 sizeof(struct free_nid
);
250 si
->cache_mem
+= NM_I(sbi
)->nat_cnt
* sizeof(struct nat_entry
);
251 si
->cache_mem
+= NM_I(sbi
)->dirty_nat_cnt
*
252 sizeof(struct nat_entry_set
);
253 si
->cache_mem
+= si
->inmem_pages
* sizeof(struct inmem_pages
);
254 for (i
= 0; i
< MAX_INO_ENTRY
; i
++)
255 si
->cache_mem
+= sbi
->im
[i
].ino_num
* sizeof(struct ino_entry
);
256 si
->cache_mem
+= atomic_read(&sbi
->total_ext_tree
) *
257 sizeof(struct extent_tree
);
258 si
->cache_mem
+= atomic_read(&sbi
->total_ext_node
) *
259 sizeof(struct extent_node
);
262 if (sbi
->node_inode
) {
263 unsigned npages
= NODE_MAPPING(sbi
)->nrpages
;
264 si
->page_mem
+= (unsigned long long)npages
<< PAGE_SHIFT
;
266 if (sbi
->meta_inode
) {
267 unsigned npages
= META_MAPPING(sbi
)->nrpages
;
268 si
->page_mem
+= (unsigned long long)npages
<< PAGE_SHIFT
;
272 static int stat_show(struct seq_file
*s
, void *v
)
274 struct f2fs_stat_info
*si
;
278 mutex_lock(&f2fs_stat_mutex
);
279 list_for_each_entry(si
, &f2fs_stat_list
, stat_list
) {
280 update_general_status(si
->sbi
);
282 seq_printf(s
, "\n=====[ partition info(%pg). #%d, %s, CP: %s]=====\n",
283 si
->sbi
->sb
->s_bdev
, i
++,
284 f2fs_readonly(si
->sbi
->sb
) ? "RO": "RW",
285 is_set_ckpt_flags(si
->sbi
, CP_DISABLED_FLAG
) ?
286 "Disabled": (f2fs_cp_error(si
->sbi
) ? "Error": "Good"));
287 seq_printf(s
, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
288 si
->sit_area_segs
, si
->nat_area_segs
);
289 seq_printf(s
, "[SSA: %d] [MAIN: %d",
290 si
->ssa_area_segs
, si
->main_area_segs
);
291 seq_printf(s
, "(OverProv:%d Resv:%d)]\n\n",
292 si
->overp_segs
, si
->rsvd_segs
);
293 if (test_opt(si
->sbi
, DISCARD
))
294 seq_printf(s
, "Utilization: %u%% (%u valid blocks, %u discard blocks)\n",
295 si
->utilization
, si
->valid_count
, si
->discard_blks
);
297 seq_printf(s
, "Utilization: %u%% (%u valid blocks)\n",
298 si
->utilization
, si
->valid_count
);
300 seq_printf(s
, " - Node: %u (Inode: %u, ",
301 si
->valid_node_count
, si
->valid_inode_count
);
302 seq_printf(s
, "Other: %u)\n - Data: %u\n",
303 si
->valid_node_count
- si
->valid_inode_count
,
304 si
->valid_count
- si
->valid_node_count
);
305 seq_printf(s
, " - Inline_xattr Inode: %u\n",
307 seq_printf(s
, " - Inline_data Inode: %u\n",
309 seq_printf(s
, " - Inline_dentry Inode: %u\n",
311 seq_printf(s
, " - Orphan/Append/Update Inode: %u, %u, %u\n",
312 si
->orphans
, si
->append
, si
->update
);
313 seq_printf(s
, "\nMain area: %d segs, %d secs %d zones\n",
314 si
->main_area_segs
, si
->main_area_sections
,
315 si
->main_area_zones
);
316 seq_printf(s
, " - COLD data: %d, %d, %d\n",
317 si
->curseg
[CURSEG_COLD_DATA
],
318 si
->cursec
[CURSEG_COLD_DATA
],
319 si
->curzone
[CURSEG_COLD_DATA
]);
320 seq_printf(s
, " - WARM data: %d, %d, %d\n",
321 si
->curseg
[CURSEG_WARM_DATA
],
322 si
->cursec
[CURSEG_WARM_DATA
],
323 si
->curzone
[CURSEG_WARM_DATA
]);
324 seq_printf(s
, " - HOT data: %d, %d, %d\n",
325 si
->curseg
[CURSEG_HOT_DATA
],
326 si
->cursec
[CURSEG_HOT_DATA
],
327 si
->curzone
[CURSEG_HOT_DATA
]);
328 seq_printf(s
, " - Dir dnode: %d, %d, %d\n",
329 si
->curseg
[CURSEG_HOT_NODE
],
330 si
->cursec
[CURSEG_HOT_NODE
],
331 si
->curzone
[CURSEG_HOT_NODE
]);
332 seq_printf(s
, " - File dnode: %d, %d, %d\n",
333 si
->curseg
[CURSEG_WARM_NODE
],
334 si
->cursec
[CURSEG_WARM_NODE
],
335 si
->curzone
[CURSEG_WARM_NODE
]);
336 seq_printf(s
, " - Indir nodes: %d, %d, %d\n",
337 si
->curseg
[CURSEG_COLD_NODE
],
338 si
->cursec
[CURSEG_COLD_NODE
],
339 si
->curzone
[CURSEG_COLD_NODE
]);
340 seq_printf(s
, "\n - Valid: %d\n - Dirty: %d\n",
341 si
->main_area_segs
- si
->dirty_count
-
342 si
->prefree_count
- si
->free_segs
,
344 seq_printf(s
, " - Prefree: %d\n - Free: %d (%d)\n\n",
345 si
->prefree_count
, si
->free_segs
, si
->free_secs
);
346 seq_printf(s
, "CP calls: %d (BG: %d)\n",
347 si
->cp_count
, si
->bg_cp_count
);
348 seq_printf(s
, " - cp blocks : %u\n", si
->meta_count
[META_CP
]);
349 seq_printf(s
, " - sit blocks : %u\n",
350 si
->meta_count
[META_SIT
]);
351 seq_printf(s
, " - nat blocks : %u\n",
352 si
->meta_count
[META_NAT
]);
353 seq_printf(s
, " - ssa blocks : %u\n",
354 si
->meta_count
[META_SSA
]);
355 seq_printf(s
, "GC calls: %d (BG: %d)\n",
356 si
->call_count
, si
->bg_gc
);
357 seq_printf(s
, " - data segments : %d (%d)\n",
358 si
->data_segs
, si
->bg_data_segs
);
359 seq_printf(s
, " - node segments : %d (%d)\n",
360 si
->node_segs
, si
->bg_node_segs
);
361 seq_printf(s
, "Try to move %d blocks (BG: %d)\n", si
->tot_blks
,
362 si
->bg_data_blks
+ si
->bg_node_blks
);
363 seq_printf(s
, " - data blocks : %d (%d)\n", si
->data_blks
,
365 seq_printf(s
, " - node blocks : %d (%d)\n", si
->node_blks
,
367 seq_printf(s
, "Skipped : atomic write %llu (%llu)\n",
368 si
->skipped_atomic_files
[BG_GC
] +
369 si
->skipped_atomic_files
[FG_GC
],
370 si
->skipped_atomic_files
[BG_GC
]);
371 seq_printf(s
, "BG skip : IO: %u, Other: %u\n",
372 si
->io_skip_bggc
, si
->other_skip_bggc
);
373 seq_puts(s
, "\nExtent Cache:\n");
374 seq_printf(s
, " - Hit Count: L1-1:%llu L1-2:%llu L2:%llu\n",
375 si
->hit_largest
, si
->hit_cached
,
377 seq_printf(s
, " - Hit Ratio: %llu%% (%llu / %llu)\n",
379 div64_u64(si
->hit_total
* 100, si
->total_ext
),
380 si
->hit_total
, si
->total_ext
);
381 seq_printf(s
, " - Inner Struct Count: tree: %d(%d), node: %d\n",
382 si
->ext_tree
, si
->zombie_tree
, si
->ext_node
);
383 seq_puts(s
, "\nBalancing F2FS Async:\n");
384 seq_printf(s
, " - DIO (R: %4d, W: %4d)\n",
385 si
->nr_dio_read
, si
->nr_dio_write
);
386 seq_printf(s
, " - IO_R (Data: %4d, Node: %4d, Meta: %4d\n",
387 si
->nr_rd_data
, si
->nr_rd_node
, si
->nr_rd_meta
);
388 seq_printf(s
, " - IO_W (CP: %4d, Data: %4d, Flush: (%4d %4d %4d), "
389 "Discard: (%4d %4d)) cmd: %4d undiscard:%4u\n",
390 si
->nr_wb_cp_data
, si
->nr_wb_data
,
391 si
->nr_flushing
, si
->nr_flushed
,
392 si
->flush_list_empty
,
393 si
->nr_discarding
, si
->nr_discarded
,
394 si
->nr_discard_cmd
, si
->undiscard_blks
);
395 seq_printf(s
, " - inmem: %4d, atomic IO: %4d (Max. %4d), "
396 "volatile IO: %4d (Max. %4d)\n",
397 si
->inmem_pages
, si
->aw_cnt
, si
->max_aw_cnt
,
398 si
->vw_cnt
, si
->max_vw_cnt
);
399 seq_printf(s
, " - nodes: %4d in %4d\n",
400 si
->ndirty_node
, si
->node_pages
);
401 seq_printf(s
, " - dents: %4d in dirs:%4d (%4d)\n",
402 si
->ndirty_dent
, si
->ndirty_dirs
, si
->ndirty_all
);
403 seq_printf(s
, " - datas: %4d in files:%4d\n",
404 si
->ndirty_data
, si
->ndirty_files
);
405 seq_printf(s
, " - quota datas: %4d in quota files:%4d\n",
406 si
->ndirty_qdata
, si
->nquota_files
);
407 seq_printf(s
, " - meta: %4d in %4d\n",
408 si
->ndirty_meta
, si
->meta_pages
);
409 seq_printf(s
, " - imeta: %4d\n",
411 seq_printf(s
, " - NATs: %9d/%9d\n - SITs: %9d/%9d\n",
412 si
->dirty_nats
, si
->nats
, si
->dirty_sits
, si
->sits
);
413 seq_printf(s
, " - free_nids: %9d/%9d\n - alloc_nids: %9d\n",
414 si
->free_nids
, si
->avail_nids
, si
->alloc_nids
);
415 seq_puts(s
, "\nDistribution of User Blocks:");
416 seq_puts(s
, " [ valid | invalid | free ]\n");
419 for (j
= 0; j
< si
->util_valid
; j
++)
423 for (j
= 0; j
< si
->util_invalid
; j
++)
427 for (j
= 0; j
< si
->util_free
; j
++)
429 seq_puts(s
, "]\n\n");
430 seq_printf(s
, "IPU: %u blocks\n", si
->inplace_count
);
431 seq_printf(s
, "SSR: %u blocks in %u segments\n",
432 si
->block_count
[SSR
], si
->segment_count
[SSR
]);
433 seq_printf(s
, "LFS: %u blocks in %u segments\n",
434 si
->block_count
[LFS
], si
->segment_count
[LFS
]);
436 /* segment usage info */
437 update_sit_info(si
->sbi
);
438 seq_printf(s
, "\nBDF: %u, avg. vblocks: %u\n",
439 si
->bimodal
, si
->avg_vblocks
);
441 /* memory footprint */
442 update_mem_info(si
->sbi
);
443 seq_printf(s
, "\nMemory: %llu KB\n",
444 (si
->base_mem
+ si
->cache_mem
+ si
->page_mem
) >> 10);
445 seq_printf(s
, " - static: %llu KB\n",
447 seq_printf(s
, " - cached: %llu KB\n",
448 si
->cache_mem
>> 10);
449 seq_printf(s
, " - paged : %llu KB\n",
452 mutex_unlock(&f2fs_stat_mutex
);
456 DEFINE_SHOW_ATTRIBUTE(stat
);
458 int f2fs_build_stats(struct f2fs_sb_info
*sbi
)
460 struct f2fs_super_block
*raw_super
= F2FS_RAW_SUPER(sbi
);
461 struct f2fs_stat_info
*si
;
464 si
= f2fs_kzalloc(sbi
, sizeof(struct f2fs_stat_info
), GFP_KERNEL
);
468 si
->all_area_segs
= le32_to_cpu(raw_super
->segment_count
);
469 si
->sit_area_segs
= le32_to_cpu(raw_super
->segment_count_sit
);
470 si
->nat_area_segs
= le32_to_cpu(raw_super
->segment_count_nat
);
471 si
->ssa_area_segs
= le32_to_cpu(raw_super
->segment_count_ssa
);
472 si
->main_area_segs
= le32_to_cpu(raw_super
->segment_count_main
);
473 si
->main_area_sections
= le32_to_cpu(raw_super
->section_count
);
474 si
->main_area_zones
= si
->main_area_sections
/
475 le32_to_cpu(raw_super
->secs_per_zone
);
479 atomic64_set(&sbi
->total_hit_ext
, 0);
480 atomic64_set(&sbi
->read_hit_rbtree
, 0);
481 atomic64_set(&sbi
->read_hit_largest
, 0);
482 atomic64_set(&sbi
->read_hit_cached
, 0);
484 atomic_set(&sbi
->inline_xattr
, 0);
485 atomic_set(&sbi
->inline_inode
, 0);
486 atomic_set(&sbi
->inline_dir
, 0);
487 atomic_set(&sbi
->inplace_count
, 0);
488 for (i
= META_CP
; i
< META_MAX
; i
++)
489 atomic_set(&sbi
->meta_count
[i
], 0);
491 atomic_set(&sbi
->aw_cnt
, 0);
492 atomic_set(&sbi
->vw_cnt
, 0);
493 atomic_set(&sbi
->max_aw_cnt
, 0);
494 atomic_set(&sbi
->max_vw_cnt
, 0);
496 mutex_lock(&f2fs_stat_mutex
);
497 list_add_tail(&si
->stat_list
, &f2fs_stat_list
);
498 mutex_unlock(&f2fs_stat_mutex
);
503 void f2fs_destroy_stats(struct f2fs_sb_info
*sbi
)
505 struct f2fs_stat_info
*si
= F2FS_STAT(sbi
);
507 mutex_lock(&f2fs_stat_mutex
);
508 list_del(&si
->stat_list
);
509 mutex_unlock(&f2fs_stat_mutex
);
514 void __init
f2fs_create_root_stats(void)
516 f2fs_debugfs_root
= debugfs_create_dir("f2fs", NULL
);
518 debugfs_create_file("status", S_IRUGO
, f2fs_debugfs_root
, NULL
,
522 void f2fs_destroy_root_stats(void)
524 debugfs_remove_recursive(f2fs_debugfs_root
);
525 f2fs_debugfs_root
= NULL
;