~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/f2fs/debug.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 struct dentry *f2fs_debugfs_root;
 25 static DEFINE_MUTEX(f2fs_stat_mutex);
 26 
 27 static void update_general_status(struct f2fs_sb_info *sbi)
 28 {
 29         struct f2fs_stat_info *si = F2FS_STAT(sbi);
 30         int i;
 31 
 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_wb_cp_data = get_pages(sbi, F2FS_WB_CP_DATA);
 57         si->nr_wb_data = get_pages(sbi, F2FS_WB_DATA);
 58         si->nr_rd_data = get_pages(sbi, F2FS_RD_DATA);
 59         si->nr_rd_node = get_pages(sbi, F2FS_RD_NODE);
 60         si->nr_rd_meta = get_pages(sbi, F2FS_RD_META);
 61         if (SM_I(sbi) && SM_I(sbi)->fcc_info) {
 62                 si->nr_flushed =
 63                         atomic_read(&SM_I(sbi)->fcc_info->issued_flush);
 64                 si->nr_flushing =
 65                         atomic_read(&SM_I(sbi)->fcc_info->issing_flush);
 66                 si->flush_list_empty =
 67                         llist_empty(&SM_I(sbi)->fcc_info->issue_list);
 68         }
 69         if (SM_I(sbi) && SM_I(sbi)->dcc_info) {
 70                 si->nr_discarded =
 71                         atomic_read(&SM_I(sbi)->dcc_info->issued_discard);
 72                 si->nr_discarding =
 73                         atomic_read(&SM_I(sbi)->dcc_info->issing_discard);
 74                 si->nr_discard_cmd =
 75                         atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
 76                 si->undiscard_blks = SM_I(sbi)->dcc_info->undiscard_blks;
 77         }
 78         si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
 79         si->rsvd_segs = reserved_segments(sbi);
 80         si->overp_segs = overprovision_segments(sbi);
 81         si->valid_count = valid_user_blocks(sbi);
 82         si->discard_blks = discard_blocks(sbi);
 83         si->valid_node_count = valid_node_count(sbi);
 84         si->valid_inode_count = valid_inode_count(sbi);
 85         si->inline_xattr = atomic_read(&sbi->inline_xattr);
 86         si->inline_inode = atomic_read(&sbi->inline_inode);
 87         si->inline_dir = atomic_read(&sbi->inline_dir);
 88         si->append = sbi->im[APPEND_INO].ino_num;
 89         si->update = sbi->im[UPDATE_INO].ino_num;
 90         si->orphans = sbi->im[ORPHAN_INO].ino_num;
 91         si->utilization = utilization(sbi);
 92 
 93         si->free_segs = free_segments(sbi);
 94         si->free_secs = free_sections(sbi);
 95         si->prefree_count = prefree_segments(sbi);
 96         si->dirty_count = dirty_segments(sbi);
 97         si->node_pages = NODE_MAPPING(sbi)->nrpages;
 98         si->meta_pages = META_MAPPING(sbi)->nrpages;
 99         si->nats = NM_I(sbi)->nat_cnt;
100         si->dirty_nats = NM_I(sbi)->dirty_nat_cnt;
101         si->sits = MAIN_SEGS(sbi);
102         si->dirty_sits = SIT_I(sbi)->dirty_sentries;
103         si->free_nids = NM_I(sbi)->nid_cnt[FREE_NID];
104         si->avail_nids = NM_I(sbi)->available_nids;
105         si->alloc_nids = NM_I(sbi)->nid_cnt[PREALLOC_NID];
106         si->bg_gc = sbi->bg_gc;
107         si->io_skip_bggc = sbi->io_skip_bggc;
108         si->other_skip_bggc = sbi->other_skip_bggc;
109         si->skipped_atomic_files[BG_GC] = sbi->skipped_atomic_files[BG_GC];
110         si->skipped_atomic_files[FG_GC] = sbi->skipped_atomic_files[FG_GC];
111         si->util_free = (int)(free_user_blocks(sbi) >> sbi->log_blocks_per_seg)
112                 * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
113                 / 2;
114         si->util_valid = (int)(written_block_count(sbi) >>
115                                                 sbi->log_blocks_per_seg)
116                 * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
117                 / 2;
118         si->util_invalid = 50 - si->util_free - si->util_valid;
119         for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_NODE; i++) {
120                 struct curseg_info *curseg = CURSEG_I(sbi, i);
121                 si->curseg[i] = curseg->segno;
122                 si->cursec[i] = GET_SEC_FROM_SEG(sbi, curseg->segno);
123                 si->curzone[i] = GET_ZONE_FROM_SEC(sbi, si->cursec[i]);
124         }
125 
126         for (i = META_CP; i < META_MAX; i++)
127                 si->meta_count[i] = atomic_read(&sbi->meta_count[i]);
128 
129         for (i = 0; i < 2; i++) {
130                 si->segment_count[i] = sbi->segment_count[i];
131                 si->block_count[i] = sbi->block_count[i];
132         }
133 
134         si->inplace_count = atomic_read(&sbi->inplace_count);
135 }
136 
137 /*
138  * This function calculates BDF of every segments
139  */
140 static void update_sit_info(struct f2fs_sb_info *sbi)
141 {
142         struct f2fs_stat_info *si = F2FS_STAT(sbi);
143         unsigned long long blks_per_sec, hblks_per_sec, total_vblocks;
144         unsigned long long bimodal, dist;
145         unsigned int segno, vblocks;
146         int ndirty = 0;
147 
148         bimodal = 0;
149         total_vblocks = 0;
150         blks_per_sec = BLKS_PER_SEC(sbi);
151         hblks_per_sec = blks_per_sec / 2;
152         for (segno = 0; segno < MAIN_SEGS(sbi); segno += sbi->segs_per_sec) {
153                 vblocks = get_valid_blocks(sbi, segno, true);
154                 dist = abs(vblocks - hblks_per_sec);
155                 bimodal += dist * dist;
156 
157                 if (vblocks > 0 && vblocks < blks_per_sec) {
158                         total_vblocks += vblocks;
159                         ndirty++;
160                 }
161         }
162         dist = div_u64(MAIN_SECS(sbi) * hblks_per_sec * hblks_per_sec, 100);
163         si->bimodal = div64_u64(bimodal, dist);
164         if (si->dirty_count)
165                 si->avg_vblocks = div_u64(total_vblocks, ndirty);
166         else
167                 si->avg_vblocks = 0;
168 }
169 
170 /*
171  * This function calculates memory footprint.
172  */
173 static void update_mem_info(struct f2fs_sb_info *sbi)
174 {
175         struct f2fs_stat_info *si = F2FS_STAT(sbi);
176         unsigned npages;
177         int i;
178 
179         if (si->base_mem)
180                 goto get_cache;
181 
182         /* build stat */
183         si->base_mem = sizeof(struct f2fs_stat_info);
184 
185         /* build superblock */
186         si->base_mem += sizeof(struct f2fs_sb_info) + sbi->sb->s_blocksize;
187         si->base_mem += 2 * sizeof(struct f2fs_inode_info);
188         si->base_mem += sizeof(*sbi->ckpt);
189 
190         /* build sm */
191         si->base_mem += sizeof(struct f2fs_sm_info);
192 
193         /* build sit */
194         si->base_mem += sizeof(struct sit_info);
195         si->base_mem += MAIN_SEGS(sbi) * sizeof(struct seg_entry);
196         si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
197         si->base_mem += 2 * SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
198         si->base_mem += SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
199         si->base_mem += SIT_VBLOCK_MAP_SIZE;
200         if (sbi->segs_per_sec > 1)
201                 si->base_mem += MAIN_SECS(sbi) * sizeof(struct sec_entry);
202         si->base_mem += __bitmap_size(sbi, SIT_BITMAP);
203 
204         /* build free segmap */
205         si->base_mem += sizeof(struct free_segmap_info);
206         si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
207         si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
208 
209         /* build curseg */
210         si->base_mem += sizeof(struct curseg_info) * NR_CURSEG_TYPE;
211         si->base_mem += PAGE_SIZE * NR_CURSEG_TYPE;
212 
213         /* build dirty segmap */
214         si->base_mem += sizeof(struct dirty_seglist_info);
215         si->base_mem += NR_DIRTY_TYPE * f2fs_bitmap_size(MAIN_SEGS(sbi));
216         si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
217 
218         /* build nm */
219         si->base_mem += sizeof(struct f2fs_nm_info);
220         si->base_mem += __bitmap_size(sbi, NAT_BITMAP);
221         si->base_mem += (NM_I(sbi)->nat_bits_blocks << F2FS_BLKSIZE_BITS);
222         si->base_mem += NM_I(sbi)->nat_blocks *
223                                 f2fs_bitmap_size(NAT_ENTRY_PER_BLOCK);
224         si->base_mem += NM_I(sbi)->nat_blocks / 8;
225         si->base_mem += NM_I(sbi)->nat_blocks * sizeof(unsigned short);
226 
227 get_cache:
228         si->cache_mem = 0;
229 
230         /* build gc */
231         if (sbi->gc_thread)
232                 si->cache_mem += sizeof(struct f2fs_gc_kthread);
233 
234         /* build merge flush thread */
235         if (SM_I(sbi)->fcc_info)
236                 si->cache_mem += sizeof(struct flush_cmd_control);
237         if (SM_I(sbi)->dcc_info) {
238                 si->cache_mem += sizeof(struct discard_cmd_control);
239                 si->cache_mem += sizeof(struct discard_cmd) *
240                         atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
241         }
242 
243         /* free nids */
244         si->cache_mem += (NM_I(sbi)->nid_cnt[FREE_NID] +
245                                 NM_I(sbi)->nid_cnt[PREALLOC_NID]) *
246                                 sizeof(struct free_nid);
247         si->cache_mem += NM_I(sbi)->nat_cnt * sizeof(struct nat_entry);
248         si->cache_mem += NM_I(sbi)->dirty_nat_cnt *
249                                         sizeof(struct nat_entry_set);
250         si->cache_mem += si->inmem_pages * sizeof(struct inmem_pages);
251         for (i = 0; i < MAX_INO_ENTRY; i++)
252                 si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry);
253         si->cache_mem += atomic_read(&sbi->total_ext_tree) *
254                                                 sizeof(struct extent_tree);
255         si->cache_mem += atomic_read(&sbi->total_ext_node) *
256                                                 sizeof(struct extent_node);
257 
258         si->page_mem = 0;
259         npages = NODE_MAPPING(sbi)->nrpages;
260         si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
261         npages = META_MAPPING(sbi)->nrpages;
262         si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
263 }
264 
265 static int stat_show(struct seq_file *s, void *v)
266 {
267         struct f2fs_stat_info *si;
268         int i = 0;
269         int j;
270 
271         mutex_lock(&f2fs_stat_mutex);
272         list_for_each_entry(si, &f2fs_stat_list, stat_list) {
273                 update_general_status(si->sbi);
274 
275                 seq_printf(s, "\n=====[ partition info(%pg). #%d, %s, CP: %s]=====\n",
276                         si->sbi->sb->s_bdev, i++,
277                         f2fs_readonly(si->sbi->sb) ? "RO": "RW",
278                         is_set_ckpt_flags(si->sbi, CP_DISABLED_FLAG) ?
279                         "Disabled": (f2fs_cp_error(si->sbi) ? "Error": "Good"));
280                 seq_printf(s, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
281                            si->sit_area_segs, si->nat_area_segs);
282                 seq_printf(s, "[SSA: %d] [MAIN: %d",
283                            si->ssa_area_segs, si->main_area_segs);
284                 seq_printf(s, "(OverProv:%d Resv:%d)]\n\n",
285                            si->overp_segs, si->rsvd_segs);
286                 if (test_opt(si->sbi, DISCARD))
287                         seq_printf(s, "Utilization: %u%% (%u valid blocks, %u discard blocks)\n",
288                                 si->utilization, si->valid_count, si->discard_blks);
289                 else
290                         seq_printf(s, "Utilization: %u%% (%u valid blocks)\n",
291                                 si->utilization, si->valid_count);
292 
293                 seq_printf(s, "  - Node: %u (Inode: %u, ",
294                            si->valid_node_count, si->valid_inode_count);
295                 seq_printf(s, "Other: %u)\n  - Data: %u\n",
296                            si->valid_node_count - si->valid_inode_count,
297                            si->valid_count - si->valid_node_count);
298                 seq_printf(s, "  - Inline_xattr Inode: %u\n",
299                            si->inline_xattr);
300                 seq_printf(s, "  - Inline_data Inode: %u\n",
301                            si->inline_inode);
302                 seq_printf(s, "  - Inline_dentry Inode: %u\n",
303                            si->inline_dir);
304                 seq_printf(s, "  - Orphan/Append/Update Inode: %u, %u, %u\n",
305                            si->orphans, si->append, si->update);
306                 seq_printf(s, "\nMain area: %d segs, %d secs %d zones\n",
307                            si->main_area_segs, si->main_area_sections,
308                            si->main_area_zones);
309                 seq_printf(s, "  - COLD  data: %d, %d, %d\n",
310                            si->curseg[CURSEG_COLD_DATA],
311                            si->cursec[CURSEG_COLD_DATA],
312                            si->curzone[CURSEG_COLD_DATA]);
313                 seq_printf(s, "  - WARM  data: %d, %d, %d\n",
314                            si->curseg[CURSEG_WARM_DATA],
315                            si->cursec[CURSEG_WARM_DATA],
316                            si->curzone[CURSEG_WARM_DATA]);
317                 seq_printf(s, "  - HOT   data: %d, %d, %d\n",
318                            si->curseg[CURSEG_HOT_DATA],
319                            si->cursec[CURSEG_HOT_DATA],
320                            si->curzone[CURSEG_HOT_DATA]);
321                 seq_printf(s, "  - Dir   dnode: %d, %d, %d\n",
322                            si->curseg[CURSEG_HOT_NODE],
323                            si->cursec[CURSEG_HOT_NODE],
324                            si->curzone[CURSEG_HOT_NODE]);
325                 seq_printf(s, "  - File   dnode: %d, %d, %d\n",
326                            si->curseg[CURSEG_WARM_NODE],
327                            si->cursec[CURSEG_WARM_NODE],
328                            si->curzone[CURSEG_WARM_NODE]);
329                 seq_printf(s, "  - Indir nodes: %d, %d, %d\n",
330                            si->curseg[CURSEG_COLD_NODE],
331                            si->cursec[CURSEG_COLD_NODE],
332                            si->curzone[CURSEG_COLD_NODE]);
333                 seq_printf(s, "\n  - Valid: %d\n  - Dirty: %d\n",
334                            si->main_area_segs - si->dirty_count -
335                            si->prefree_count - si->free_segs,
336                            si->dirty_count);
337                 seq_printf(s, "  - Prefree: %d\n  - Free: %d (%d)\n\n",
338                            si->prefree_count, si->free_segs, si->free_secs);
339                 seq_printf(s, "CP calls: %d (BG: %d)\n",
340                                 si->cp_count, si->bg_cp_count);
341                 seq_printf(s, "  - cp blocks : %u\n", si->meta_count[META_CP]);
342                 seq_printf(s, "  - sit blocks : %u\n",
343                                 si->meta_count[META_SIT]);
344                 seq_printf(s, "  - nat blocks : %u\n",
345                                 si->meta_count[META_NAT]);
346                 seq_printf(s, "  - ssa blocks : %u\n",
347                                 si->meta_count[META_SSA]);
348                 seq_printf(s, "GC calls: %d (BG: %d)\n",
349                            si->call_count, si->bg_gc);
350                 seq_printf(s, "  - data segments : %d (%d)\n",
351                                 si->data_segs, si->bg_data_segs);
352                 seq_printf(s, "  - node segments : %d (%d)\n",
353                                 si->node_segs, si->bg_node_segs);
354                 seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks,
355                                 si->bg_data_blks + si->bg_node_blks);
356                 seq_printf(s, "  - data blocks : %d (%d)\n", si->data_blks,
357                                 si->bg_data_blks);
358                 seq_printf(s, "  - node blocks : %d (%d)\n", si->node_blks,
359                                 si->bg_node_blks);
360                 seq_printf(s, "Skipped : atomic write %llu (%llu)\n",
361                                 si->skipped_atomic_files[BG_GC] +
362                                 si->skipped_atomic_files[FG_GC],
363                                 si->skipped_atomic_files[BG_GC]);
364                 seq_printf(s, "BG skip : IO: %u, Other: %u\n",
365                                 si->io_skip_bggc, si->other_skip_bggc);
366                 seq_puts(s, "\nExtent Cache:\n");
367                 seq_printf(s, "  - Hit Count: L1-1:%llu L1-2:%llu L2:%llu\n",
368                                 si->hit_largest, si->hit_cached,
369                                 si->hit_rbtree);
370                 seq_printf(s, "  - Hit Ratio: %llu%% (%llu / %llu)\n",
371                                 !si->total_ext ? 0 :
372                                 div64_u64(si->hit_total * 100, si->total_ext),
373                                 si->hit_total, si->total_ext);
374                 seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
375                                 si->ext_tree, si->zombie_tree, si->ext_node);
376                 seq_puts(s, "\nBalancing F2FS Async:\n");
377                 seq_printf(s, "  - IO_R (Data: %4d, Node: %4d, Meta: %4d\n",
378                            si->nr_rd_data, si->nr_rd_node, si->nr_rd_meta);
379                 seq_printf(s, "  - IO_W (CP: %4d, Data: %4d, Flush: (%4d %4d %4d), "
380                         "Discard: (%4d %4d)) cmd: %4d undiscard:%4u\n",
381                            si->nr_wb_cp_data, si->nr_wb_data,
382                            si->nr_flushing, si->nr_flushed,
383                            si->flush_list_empty,
384                            si->nr_discarding, si->nr_discarded,
385                            si->nr_discard_cmd, si->undiscard_blks);
386                 seq_printf(s, "  - inmem: %4d, atomic IO: %4d (Max. %4d), "
387                         "volatile IO: %4d (Max. %4d)\n",
388                            si->inmem_pages, si->aw_cnt, si->max_aw_cnt,
389                            si->vw_cnt, si->max_vw_cnt);
390                 seq_printf(s, "  - nodes: %4d in %4d\n",
391                            si->ndirty_node, si->node_pages);
392                 seq_printf(s, "  - dents: %4d in dirs:%4d (%4d)\n",
393                            si->ndirty_dent, si->ndirty_dirs, si->ndirty_all);
394                 seq_printf(s, "  - datas: %4d in files:%4d\n",
395                            si->ndirty_data, si->ndirty_files);
396                 seq_printf(s, "  - quota datas: %4d in quota files:%4d\n",
397                            si->ndirty_qdata, si->nquota_files);
398                 seq_printf(s, "  - meta: %4d in %4d\n",
399                            si->ndirty_meta, si->meta_pages);
400                 seq_printf(s, "  - imeta: %4d\n",
401                            si->ndirty_imeta);
402                 seq_printf(s, "  - NATs: %9d/%9d\n  - SITs: %9d/%9d\n",
403                            si->dirty_nats, si->nats, si->dirty_sits, si->sits);
404                 seq_printf(s, "  - free_nids: %9d/%9d\n  - alloc_nids: %9d\n",
405                            si->free_nids, si->avail_nids, si->alloc_nids);
406                 seq_puts(s, "\nDistribution of User Blocks:");
407                 seq_puts(s, " [ valid | invalid | free ]\n");
408                 seq_puts(s, "  [");
409 
410                 for (j = 0; j < si->util_valid; j++)
411                         seq_putc(s, '-');
412                 seq_putc(s, '|');
413 
414                 for (j = 0; j < si->util_invalid; j++)
415                         seq_putc(s, '-');
416                 seq_putc(s, '|');
417 
418                 for (j = 0; j < si->util_free; j++)
419                         seq_putc(s, '-');
420                 seq_puts(s, "]\n\n");
421                 seq_printf(s, "IPU: %u blocks\n", si->inplace_count);
422                 seq_printf(s, "SSR: %u blocks in %u segments\n",
423                            si->block_count[SSR], si->segment_count[SSR]);
424                 seq_printf(s, "LFS: %u blocks in %u segments\n",
425                            si->block_count[LFS], si->segment_count[LFS]);
426 
427                 /* segment usage info */
428                 update_sit_info(si->sbi);
429                 seq_printf(s, "\nBDF: %u, avg. vblocks: %u\n",
430                            si->bimodal, si->avg_vblocks);
431 
432                 /* memory footprint */
433                 update_mem_info(si->sbi);
434                 seq_printf(s, "\nMemory: %llu KB\n",
435                         (si->base_mem + si->cache_mem + si->page_mem) >> 10);
436                 seq_printf(s, "  - static: %llu KB\n",
437                                 si->base_mem >> 10);
438                 seq_printf(s, "  - cached: %llu KB\n",
439                                 si->cache_mem >> 10);
440                 seq_printf(s, "  - paged : %llu KB\n",
441                                 si->page_mem >> 10);
442         }
443         mutex_unlock(&f2fs_stat_mutex);
444         return 0;
445 }
446 
447 static int stat_open(struct inode *inode, struct file *file)
448 {
449         return single_open(file, stat_show, inode->i_private);
450 }
451 
452 static const struct file_operations stat_fops = {
453         .owner = THIS_MODULE,
454         .open = stat_open,
455         .read = seq_read,
456         .llseek = seq_lseek,
457         .release = single_release,
458 };
459 
460 int f2fs_build_stats(struct f2fs_sb_info *sbi)
461 {
462         struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
463         struct f2fs_stat_info *si;
464         int i;
465 
466         si = f2fs_kzalloc(sbi, sizeof(struct f2fs_stat_info), GFP_KERNEL);
467         if (!si)
468                 return -ENOMEM;
469 
470         si->all_area_segs = le32_to_cpu(raw_super->segment_count);
471         si->sit_area_segs = le32_to_cpu(raw_super->segment_count_sit);
472         si->nat_area_segs = le32_to_cpu(raw_super->segment_count_nat);
473         si->ssa_area_segs = le32_to_cpu(raw_super->segment_count_ssa);
474         si->main_area_segs = le32_to_cpu(raw_super->segment_count_main);
475         si->main_area_sections = le32_to_cpu(raw_super->section_count);
476         si->main_area_zones = si->main_area_sections /
477                                 le32_to_cpu(raw_super->secs_per_zone);
478         si->sbi = sbi;
479         sbi->stat_info = si;
480 
481         atomic64_set(&sbi->total_hit_ext, 0);
482         atomic64_set(&sbi->read_hit_rbtree, 0);
483         atomic64_set(&sbi->read_hit_largest, 0);
484         atomic64_set(&sbi->read_hit_cached, 0);
485 
486         atomic_set(&sbi->inline_xattr, 0);
487         atomic_set(&sbi->inline_inode, 0);
488         atomic_set(&sbi->inline_dir, 0);
489         atomic_set(&sbi->inplace_count, 0);
490         for (i = META_CP; i < META_MAX; i++)
491                 atomic_set(&sbi->meta_count[i], 0);
492 
493         atomic_set(&sbi->aw_cnt, 0);
494         atomic_set(&sbi->vw_cnt, 0);
495         atomic_set(&sbi->max_aw_cnt, 0);
496         atomic_set(&sbi->max_vw_cnt, 0);
497 
498         mutex_lock(&f2fs_stat_mutex);
499         list_add_tail(&si->stat_list, &f2fs_stat_list);
500         mutex_unlock(&f2fs_stat_mutex);
501 
502         return 0;
503 }
504 
505 void f2fs_destroy_stats(struct f2fs_sb_info *sbi)
506 {
507         struct f2fs_stat_info *si = F2FS_STAT(sbi);
508 
509         mutex_lock(&f2fs_stat_mutex);
510         list_del(&si->stat_list);
511         mutex_unlock(&f2fs_stat_mutex);
512 
513         kfree(si);
514 }
515 
516 int __init f2fs_create_root_stats(void)
517 {
518         struct dentry *file;
519 
520         f2fs_debugfs_root = debugfs_create_dir("f2fs", NULL);
521         if (!f2fs_debugfs_root)
522                 return -ENOMEM;
523 
524         file = debugfs_create_file("status", S_IRUGO, f2fs_debugfs_root,
525                         NULL, &stat_fops);
526         if (!file) {
527                 debugfs_remove(f2fs_debugfs_root);
528                 f2fs_debugfs_root = NULL;
529                 return -ENOMEM;
530         }
531 
532         return 0;
533 }
534 
535 void f2fs_destroy_root_stats(void)
536 {
537         if (!f2fs_debugfs_root)
538                 return;
539 
540         debugfs_remove_recursive(f2fs_debugfs_root);
541         f2fs_debugfs_root = NULL;
542 }
543 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp