LCOV - code coverage report
Current view: top level - fs/f2fs - debug.c (source / functions) Hit Total Coverage
Test: Real Lines: 4 306 1.3 %
Date: 2020-10-17 15:46:16 Functions: 0 9 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14