Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * f2fs debugging statistics
0004  *
0005  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
0006  *             http://www.samsung.com/
0007  * Copyright (c) 2012 Linux Foundation
0008  * Copyright (c) 2012 Greg Kroah-Hartman <gregkh@linuxfoundation.org>
0009  */
0010 
0011 #include <linux/fs.h>
0012 #include <linux/backing-dev.h>
0013 #include <linux/f2fs_fs.h>
0014 #include <linux/blkdev.h>
0015 #include <linux/debugfs.h>
0016 #include <linux/seq_file.h>
0017 
0018 #include "f2fs.h"
0019 #include "node.h"
0020 #include "segment.h"
0021 #include "gc.h"
0022 
0023 static LIST_HEAD(f2fs_stat_list);
0024 static DEFINE_RAW_SPINLOCK(f2fs_stat_lock);
0025 #ifdef CONFIG_DEBUG_FS
0026 static struct dentry *f2fs_debugfs_root;
0027 #endif
0028 
0029 /*
0030  * This function calculates BDF of every segments
0031  */
0032 void f2fs_update_sit_info(struct f2fs_sb_info *sbi)
0033 {
0034     struct f2fs_stat_info *si = F2FS_STAT(sbi);
0035     unsigned long long blks_per_sec, hblks_per_sec, total_vblocks;
0036     unsigned long long bimodal, dist;
0037     unsigned int segno, vblocks;
0038     int ndirty = 0;
0039 
0040     bimodal = 0;
0041     total_vblocks = 0;
0042     blks_per_sec = CAP_BLKS_PER_SEC(sbi);
0043     hblks_per_sec = blks_per_sec / 2;
0044     for (segno = 0; segno < MAIN_SEGS(sbi); segno += sbi->segs_per_sec) {
0045         vblocks = get_valid_blocks(sbi, segno, true);
0046         dist = abs(vblocks - hblks_per_sec);
0047         bimodal += dist * dist;
0048 
0049         if (vblocks > 0 && vblocks < blks_per_sec) {
0050             total_vblocks += vblocks;
0051             ndirty++;
0052         }
0053     }
0054     dist = div_u64(MAIN_SECS(sbi) * hblks_per_sec * hblks_per_sec, 100);
0055     si->bimodal = div64_u64(bimodal, dist);
0056     if (si->dirty_count)
0057         si->avg_vblocks = div_u64(total_vblocks, ndirty);
0058     else
0059         si->avg_vblocks = 0;
0060 }
0061 
0062 #ifdef CONFIG_DEBUG_FS
0063 static void update_general_status(struct f2fs_sb_info *sbi)
0064 {
0065     struct f2fs_stat_info *si = F2FS_STAT(sbi);
0066     struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
0067     int i;
0068 
0069     /* these will be changed if online resize is done */
0070     si->main_area_segs = le32_to_cpu(raw_super->segment_count_main);
0071     si->main_area_sections = le32_to_cpu(raw_super->section_count);
0072     si->main_area_zones = si->main_area_sections /
0073                 le32_to_cpu(raw_super->secs_per_zone);
0074 
0075     /* validation check of the segment numbers */
0076     si->hit_largest = atomic64_read(&sbi->read_hit_largest);
0077     si->hit_cached = atomic64_read(&sbi->read_hit_cached);
0078     si->hit_rbtree = atomic64_read(&sbi->read_hit_rbtree);
0079     si->hit_total = si->hit_largest + si->hit_cached + si->hit_rbtree;
0080     si->total_ext = atomic64_read(&sbi->total_hit_ext);
0081     si->ext_tree = atomic_read(&sbi->total_ext_tree);
0082     si->zombie_tree = atomic_read(&sbi->total_zombie_tree);
0083     si->ext_node = atomic_read(&sbi->total_ext_node);
0084     si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
0085     si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
0086     si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META);
0087     si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA);
0088     si->ndirty_qdata = get_pages(sbi, F2FS_DIRTY_QDATA);
0089     si->ndirty_imeta = get_pages(sbi, F2FS_DIRTY_IMETA);
0090     si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE];
0091     si->ndirty_files = sbi->ndirty_inode[FILE_INODE];
0092     si->nquota_files = sbi->nquota_files;
0093     si->ndirty_all = sbi->ndirty_inode[DIRTY_META];
0094     si->aw_cnt = sbi->atomic_files;
0095     si->max_aw_cnt = atomic_read(&sbi->max_aw_cnt);
0096     si->nr_dio_read = get_pages(sbi, F2FS_DIO_READ);
0097     si->nr_dio_write = get_pages(sbi, F2FS_DIO_WRITE);
0098     si->nr_wb_cp_data = get_pages(sbi, F2FS_WB_CP_DATA);
0099     si->nr_wb_data = get_pages(sbi, F2FS_WB_DATA);
0100     si->nr_rd_data = get_pages(sbi, F2FS_RD_DATA);
0101     si->nr_rd_node = get_pages(sbi, F2FS_RD_NODE);
0102     si->nr_rd_meta = get_pages(sbi, F2FS_RD_META);
0103     if (SM_I(sbi)->fcc_info) {
0104         si->nr_flushed =
0105             atomic_read(&SM_I(sbi)->fcc_info->issued_flush);
0106         si->nr_flushing =
0107             atomic_read(&SM_I(sbi)->fcc_info->queued_flush);
0108         si->flush_list_empty =
0109             llist_empty(&SM_I(sbi)->fcc_info->issue_list);
0110     }
0111     if (SM_I(sbi)->dcc_info) {
0112         si->nr_discarded =
0113             atomic_read(&SM_I(sbi)->dcc_info->issued_discard);
0114         si->nr_discarding =
0115             atomic_read(&SM_I(sbi)->dcc_info->queued_discard);
0116         si->nr_discard_cmd =
0117             atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
0118         si->undiscard_blks = SM_I(sbi)->dcc_info->undiscard_blks;
0119     }
0120     si->nr_issued_ckpt = atomic_read(&sbi->cprc_info.issued_ckpt);
0121     si->nr_total_ckpt = atomic_read(&sbi->cprc_info.total_ckpt);
0122     si->nr_queued_ckpt = atomic_read(&sbi->cprc_info.queued_ckpt);
0123     spin_lock(&sbi->cprc_info.stat_lock);
0124     si->cur_ckpt_time = sbi->cprc_info.cur_time;
0125     si->peak_ckpt_time = sbi->cprc_info.peak_time;
0126     spin_unlock(&sbi->cprc_info.stat_lock);
0127     si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
0128     si->rsvd_segs = reserved_segments(sbi);
0129     si->overp_segs = overprovision_segments(sbi);
0130     si->valid_count = valid_user_blocks(sbi);
0131     si->discard_blks = discard_blocks(sbi);
0132     si->valid_node_count = valid_node_count(sbi);
0133     si->valid_inode_count = valid_inode_count(sbi);
0134     si->inline_xattr = atomic_read(&sbi->inline_xattr);
0135     si->inline_inode = atomic_read(&sbi->inline_inode);
0136     si->inline_dir = atomic_read(&sbi->inline_dir);
0137     si->compr_inode = atomic_read(&sbi->compr_inode);
0138     si->compr_blocks = atomic64_read(&sbi->compr_blocks);
0139     si->append = sbi->im[APPEND_INO].ino_num;
0140     si->update = sbi->im[UPDATE_INO].ino_num;
0141     si->orphans = sbi->im[ORPHAN_INO].ino_num;
0142     si->utilization = utilization(sbi);
0143 
0144     si->free_segs = free_segments(sbi);
0145     si->free_secs = free_sections(sbi);
0146     si->prefree_count = prefree_segments(sbi);
0147     si->dirty_count = dirty_segments(sbi);
0148     if (sbi->node_inode)
0149         si->node_pages = NODE_MAPPING(sbi)->nrpages;
0150     if (sbi->meta_inode)
0151         si->meta_pages = META_MAPPING(sbi)->nrpages;
0152 #ifdef CONFIG_F2FS_FS_COMPRESSION
0153     if (sbi->compress_inode) {
0154         si->compress_pages = COMPRESS_MAPPING(sbi)->nrpages;
0155         si->compress_page_hit = atomic_read(&sbi->compress_page_hit);
0156     }
0157 #endif
0158     si->nats = NM_I(sbi)->nat_cnt[TOTAL_NAT];
0159     si->dirty_nats = NM_I(sbi)->nat_cnt[DIRTY_NAT];
0160     si->sits = MAIN_SEGS(sbi);
0161     si->dirty_sits = SIT_I(sbi)->dirty_sentries;
0162     si->free_nids = NM_I(sbi)->nid_cnt[FREE_NID];
0163     si->avail_nids = NM_I(sbi)->available_nids;
0164     si->alloc_nids = NM_I(sbi)->nid_cnt[PREALLOC_NID];
0165     si->io_skip_bggc = sbi->io_skip_bggc;
0166     si->other_skip_bggc = sbi->other_skip_bggc;
0167     si->util_free = (int)(free_user_blocks(sbi) >> sbi->log_blocks_per_seg)
0168         * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
0169         / 2;
0170     si->util_valid = (int)(written_block_count(sbi) >>
0171                         sbi->log_blocks_per_seg)
0172         * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
0173         / 2;
0174     si->util_invalid = 50 - si->util_free - si->util_valid;
0175     for (i = CURSEG_HOT_DATA; i < NO_CHECK_TYPE; i++) {
0176         struct curseg_info *curseg = CURSEG_I(sbi, i);
0177 
0178         si->curseg[i] = curseg->segno;
0179         si->cursec[i] = GET_SEC_FROM_SEG(sbi, curseg->segno);
0180         si->curzone[i] = GET_ZONE_FROM_SEC(sbi, si->cursec[i]);
0181     }
0182 
0183     for (i = META_CP; i < META_MAX; i++)
0184         si->meta_count[i] = atomic_read(&sbi->meta_count[i]);
0185 
0186     for (i = 0; i < NO_CHECK_TYPE; i++) {
0187         si->dirty_seg[i] = 0;
0188         si->full_seg[i] = 0;
0189         si->valid_blks[i] = 0;
0190     }
0191 
0192     for (i = 0; i < MAIN_SEGS(sbi); i++) {
0193         int blks = get_seg_entry(sbi, i)->valid_blocks;
0194         int type = get_seg_entry(sbi, i)->type;
0195 
0196         if (!blks)
0197             continue;
0198 
0199         if (blks == sbi->blocks_per_seg)
0200             si->full_seg[type]++;
0201         else
0202             si->dirty_seg[type]++;
0203         si->valid_blks[type] += blks;
0204     }
0205 
0206     for (i = 0; i < 2; i++) {
0207         si->segment_count[i] = sbi->segment_count[i];
0208         si->block_count[i] = sbi->block_count[i];
0209     }
0210 
0211     si->inplace_count = atomic_read(&sbi->inplace_count);
0212 }
0213 
0214 /*
0215  * This function calculates memory footprint.
0216  */
0217 static void update_mem_info(struct f2fs_sb_info *sbi)
0218 {
0219     struct f2fs_stat_info *si = F2FS_STAT(sbi);
0220     int i;
0221 
0222     if (si->base_mem)
0223         goto get_cache;
0224 
0225     /* build stat */
0226     si->base_mem = sizeof(struct f2fs_stat_info);
0227 
0228     /* build superblock */
0229     si->base_mem += sizeof(struct f2fs_sb_info) + sbi->sb->s_blocksize;
0230     si->base_mem += 2 * sizeof(struct f2fs_inode_info);
0231     si->base_mem += sizeof(*sbi->ckpt);
0232 
0233     /* build sm */
0234     si->base_mem += sizeof(struct f2fs_sm_info);
0235 
0236     /* build sit */
0237     si->base_mem += sizeof(struct sit_info);
0238     si->base_mem += MAIN_SEGS(sbi) * sizeof(struct seg_entry);
0239     si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
0240     si->base_mem += 2 * SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
0241     si->base_mem += SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
0242     si->base_mem += SIT_VBLOCK_MAP_SIZE;
0243     if (__is_large_section(sbi))
0244         si->base_mem += MAIN_SECS(sbi) * sizeof(struct sec_entry);
0245     si->base_mem += __bitmap_size(sbi, SIT_BITMAP);
0246 
0247     /* build free segmap */
0248     si->base_mem += sizeof(struct free_segmap_info);
0249     si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
0250     si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
0251 
0252     /* build curseg */
0253     si->base_mem += sizeof(struct curseg_info) * NR_CURSEG_TYPE;
0254     si->base_mem += PAGE_SIZE * NR_CURSEG_TYPE;
0255 
0256     /* build dirty segmap */
0257     si->base_mem += sizeof(struct dirty_seglist_info);
0258     si->base_mem += NR_DIRTY_TYPE * f2fs_bitmap_size(MAIN_SEGS(sbi));
0259     si->base_mem += f2fs_bitmap_size(MAIN_SECS(sbi));
0260 
0261     /* build nm */
0262     si->base_mem += sizeof(struct f2fs_nm_info);
0263     si->base_mem += __bitmap_size(sbi, NAT_BITMAP);
0264     si->base_mem += (NM_I(sbi)->nat_bits_blocks << F2FS_BLKSIZE_BITS);
0265     si->base_mem += NM_I(sbi)->nat_blocks *
0266                 f2fs_bitmap_size(NAT_ENTRY_PER_BLOCK);
0267     si->base_mem += NM_I(sbi)->nat_blocks / 8;
0268     si->base_mem += NM_I(sbi)->nat_blocks * sizeof(unsigned short);
0269 
0270 get_cache:
0271     si->cache_mem = 0;
0272 
0273     /* build gc */
0274     if (sbi->gc_thread)
0275         si->cache_mem += sizeof(struct f2fs_gc_kthread);
0276 
0277     /* build merge flush thread */
0278     if (SM_I(sbi)->fcc_info)
0279         si->cache_mem += sizeof(struct flush_cmd_control);
0280     if (SM_I(sbi)->dcc_info) {
0281         si->cache_mem += sizeof(struct discard_cmd_control);
0282         si->cache_mem += sizeof(struct discard_cmd) *
0283             atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
0284     }
0285 
0286     /* free nids */
0287     si->cache_mem += (NM_I(sbi)->nid_cnt[FREE_NID] +
0288                 NM_I(sbi)->nid_cnt[PREALLOC_NID]) *
0289                 sizeof(struct free_nid);
0290     si->cache_mem += NM_I(sbi)->nat_cnt[TOTAL_NAT] *
0291                 sizeof(struct nat_entry);
0292     si->cache_mem += NM_I(sbi)->nat_cnt[DIRTY_NAT] *
0293                 sizeof(struct nat_entry_set);
0294     for (i = 0; i < MAX_INO_ENTRY; i++)
0295         si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry);
0296     si->cache_mem += atomic_read(&sbi->total_ext_tree) *
0297                         sizeof(struct extent_tree);
0298     si->cache_mem += atomic_read(&sbi->total_ext_node) *
0299                         sizeof(struct extent_node);
0300 
0301     si->page_mem = 0;
0302     if (sbi->node_inode) {
0303         unsigned npages = NODE_MAPPING(sbi)->nrpages;
0304 
0305         si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
0306     }
0307     if (sbi->meta_inode) {
0308         unsigned npages = META_MAPPING(sbi)->nrpages;
0309 
0310         si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
0311     }
0312 #ifdef CONFIG_F2FS_FS_COMPRESSION
0313     if (sbi->compress_inode) {
0314         unsigned npages = COMPRESS_MAPPING(sbi)->nrpages;
0315         si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
0316     }
0317 #endif
0318 }
0319 
0320 static char *s_flag[] = {
0321     [SBI_IS_DIRTY]      = " fs_dirty",
0322     [SBI_IS_CLOSE]      = " closing",
0323     [SBI_NEED_FSCK]     = " need_fsck",
0324     [SBI_POR_DOING]     = " recovering",
0325     [SBI_NEED_SB_WRITE] = " sb_dirty",
0326     [SBI_NEED_CP]       = " need_cp",
0327     [SBI_IS_SHUTDOWN]   = " shutdown",
0328     [SBI_IS_RECOVERED]  = " recovered",
0329     [SBI_CP_DISABLED]   = " cp_disabled",
0330     [SBI_CP_DISABLED_QUICK] = " cp_disabled_quick",
0331     [SBI_QUOTA_NEED_FLUSH]  = " quota_need_flush",
0332     [SBI_QUOTA_SKIP_FLUSH]  = " quota_skip_flush",
0333     [SBI_QUOTA_NEED_REPAIR] = " quota_need_repair",
0334     [SBI_IS_RESIZEFS]   = " resizefs",
0335     [SBI_IS_FREEZING]   = " freezefs",
0336 };
0337 
0338 static int stat_show(struct seq_file *s, void *v)
0339 {
0340     struct f2fs_stat_info *si;
0341     int i = 0, j = 0;
0342     unsigned long flags;
0343 
0344     raw_spin_lock_irqsave(&f2fs_stat_lock, flags);
0345     list_for_each_entry(si, &f2fs_stat_list, stat_list) {
0346         update_general_status(si->sbi);
0347 
0348         seq_printf(s, "\n=====[ partition info(%pg). #%d, %s, CP: %s]=====\n",
0349             si->sbi->sb->s_bdev, i++,
0350             f2fs_readonly(si->sbi->sb) ? "RO": "RW",
0351             is_set_ckpt_flags(si->sbi, CP_DISABLED_FLAG) ?
0352             "Disabled" : (f2fs_cp_error(si->sbi) ? "Error" : "Good"));
0353         if (si->sbi->s_flag) {
0354             seq_puts(s, "[SBI:");
0355             for_each_set_bit(j, &si->sbi->s_flag, 32)
0356                 seq_puts(s, s_flag[j]);
0357             seq_puts(s, "]\n");
0358         }
0359         seq_printf(s, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
0360                si->sit_area_segs, si->nat_area_segs);
0361         seq_printf(s, "[SSA: %d] [MAIN: %d",
0362                si->ssa_area_segs, si->main_area_segs);
0363         seq_printf(s, "(OverProv:%d Resv:%d)]\n\n",
0364                si->overp_segs, si->rsvd_segs);
0365         seq_printf(s, "Current Time Sec: %llu / Mounted Time Sec: %llu\n\n",
0366                     ktime_get_boottime_seconds(),
0367                     SIT_I(si->sbi)->mounted_time);
0368         if (test_opt(si->sbi, DISCARD))
0369             seq_printf(s, "Utilization: %u%% (%u valid blocks, %u discard blocks)\n",
0370                 si->utilization, si->valid_count, si->discard_blks);
0371         else
0372             seq_printf(s, "Utilization: %u%% (%u valid blocks)\n",
0373                 si->utilization, si->valid_count);
0374 
0375         seq_printf(s, "  - Node: %u (Inode: %u, ",
0376                si->valid_node_count, si->valid_inode_count);
0377         seq_printf(s, "Other: %u)\n  - Data: %u\n",
0378                si->valid_node_count - si->valid_inode_count,
0379                si->valid_count - si->valid_node_count);
0380         seq_printf(s, "  - Inline_xattr Inode: %u\n",
0381                si->inline_xattr);
0382         seq_printf(s, "  - Inline_data Inode: %u\n",
0383                si->inline_inode);
0384         seq_printf(s, "  - Inline_dentry Inode: %u\n",
0385                si->inline_dir);
0386         seq_printf(s, "  - Compressed Inode: %u, Blocks: %llu\n",
0387                si->compr_inode, si->compr_blocks);
0388         seq_printf(s, "  - Orphan/Append/Update Inode: %u, %u, %u\n",
0389                si->orphans, si->append, si->update);
0390         seq_printf(s, "\nMain area: %d segs, %d secs %d zones\n",
0391                si->main_area_segs, si->main_area_sections,
0392                si->main_area_zones);
0393         seq_printf(s, "    TYPE         %8s %8s %8s %10s %10s %10s\n",
0394                "segno", "secno", "zoneno", "dirty_seg", "full_seg", "valid_blk");
0395         seq_printf(s, "  - COLD   data: %8d %8d %8d %10u %10u %10u\n",
0396                si->curseg[CURSEG_COLD_DATA],
0397                si->cursec[CURSEG_COLD_DATA],
0398                si->curzone[CURSEG_COLD_DATA],
0399                si->dirty_seg[CURSEG_COLD_DATA],
0400                si->full_seg[CURSEG_COLD_DATA],
0401                si->valid_blks[CURSEG_COLD_DATA]);
0402         seq_printf(s, "  - WARM   data: %8d %8d %8d %10u %10u %10u\n",
0403                si->curseg[CURSEG_WARM_DATA],
0404                si->cursec[CURSEG_WARM_DATA],
0405                si->curzone[CURSEG_WARM_DATA],
0406                si->dirty_seg[CURSEG_WARM_DATA],
0407                si->full_seg[CURSEG_WARM_DATA],
0408                si->valid_blks[CURSEG_WARM_DATA]);
0409         seq_printf(s, "  - HOT    data: %8d %8d %8d %10u %10u %10u\n",
0410                si->curseg[CURSEG_HOT_DATA],
0411                si->cursec[CURSEG_HOT_DATA],
0412                si->curzone[CURSEG_HOT_DATA],
0413                si->dirty_seg[CURSEG_HOT_DATA],
0414                si->full_seg[CURSEG_HOT_DATA],
0415                si->valid_blks[CURSEG_HOT_DATA]);
0416         seq_printf(s, "  - Dir   dnode: %8d %8d %8d %10u %10u %10u\n",
0417                si->curseg[CURSEG_HOT_NODE],
0418                si->cursec[CURSEG_HOT_NODE],
0419                si->curzone[CURSEG_HOT_NODE],
0420                si->dirty_seg[CURSEG_HOT_NODE],
0421                si->full_seg[CURSEG_HOT_NODE],
0422                si->valid_blks[CURSEG_HOT_NODE]);
0423         seq_printf(s, "  - File  dnode: %8d %8d %8d %10u %10u %10u\n",
0424                si->curseg[CURSEG_WARM_NODE],
0425                si->cursec[CURSEG_WARM_NODE],
0426                si->curzone[CURSEG_WARM_NODE],
0427                si->dirty_seg[CURSEG_WARM_NODE],
0428                si->full_seg[CURSEG_WARM_NODE],
0429                si->valid_blks[CURSEG_WARM_NODE]);
0430         seq_printf(s, "  - Indir nodes: %8d %8d %8d %10u %10u %10u\n",
0431                si->curseg[CURSEG_COLD_NODE],
0432                si->cursec[CURSEG_COLD_NODE],
0433                si->curzone[CURSEG_COLD_NODE],
0434                si->dirty_seg[CURSEG_COLD_NODE],
0435                si->full_seg[CURSEG_COLD_NODE],
0436                si->valid_blks[CURSEG_COLD_NODE]);
0437         seq_printf(s, "  - Pinned file: %8d %8d %8d\n",
0438                si->curseg[CURSEG_COLD_DATA_PINNED],
0439                si->cursec[CURSEG_COLD_DATA_PINNED],
0440                si->curzone[CURSEG_COLD_DATA_PINNED]);
0441         seq_printf(s, "  - ATGC   data: %8d %8d %8d\n",
0442                si->curseg[CURSEG_ALL_DATA_ATGC],
0443                si->cursec[CURSEG_ALL_DATA_ATGC],
0444                si->curzone[CURSEG_ALL_DATA_ATGC]);
0445         seq_printf(s, "\n  - Valid: %d\n  - Dirty: %d\n",
0446                si->main_area_segs - si->dirty_count -
0447                si->prefree_count - si->free_segs,
0448                si->dirty_count);
0449         seq_printf(s, "  - Prefree: %d\n  - Free: %d (%d)\n\n",
0450                si->prefree_count, si->free_segs, si->free_secs);
0451         seq_printf(s, "CP calls: %d (BG: %d)\n",
0452                 si->cp_count, si->bg_cp_count);
0453         seq_printf(s, "  - cp blocks : %u\n", si->meta_count[META_CP]);
0454         seq_printf(s, "  - sit blocks : %u\n",
0455                 si->meta_count[META_SIT]);
0456         seq_printf(s, "  - nat blocks : %u\n",
0457                 si->meta_count[META_NAT]);
0458         seq_printf(s, "  - ssa blocks : %u\n",
0459                 si->meta_count[META_SSA]);
0460         seq_printf(s, "CP merge (Queued: %4d, Issued: %4d, Total: %4d, "
0461                 "Cur time: %4d(ms), Peak time: %4d(ms))\n",
0462                 si->nr_queued_ckpt, si->nr_issued_ckpt,
0463                 si->nr_total_ckpt, si->cur_ckpt_time,
0464                 si->peak_ckpt_time);
0465         seq_printf(s, "GC calls: %d (BG: %d)\n",
0466                si->call_count, si->bg_gc);
0467         seq_printf(s, "  - data segments : %d (%d)\n",
0468                 si->data_segs, si->bg_data_segs);
0469         seq_printf(s, "  - node segments : %d (%d)\n",
0470                 si->node_segs, si->bg_node_segs);
0471         seq_printf(s, "  - Reclaimed segs : Normal (%d), Idle CB (%d), "
0472                 "Idle Greedy (%d), Idle AT (%d), "
0473                 "Urgent High (%d), Urgent Mid (%d), "
0474                 "Urgent Low (%d)\n",
0475                 si->sbi->gc_reclaimed_segs[GC_NORMAL],
0476                 si->sbi->gc_reclaimed_segs[GC_IDLE_CB],
0477                 si->sbi->gc_reclaimed_segs[GC_IDLE_GREEDY],
0478                 si->sbi->gc_reclaimed_segs[GC_IDLE_AT],
0479                 si->sbi->gc_reclaimed_segs[GC_URGENT_HIGH],
0480                 si->sbi->gc_reclaimed_segs[GC_URGENT_MID],
0481                 si->sbi->gc_reclaimed_segs[GC_URGENT_LOW]);
0482         seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks,
0483                 si->bg_data_blks + si->bg_node_blks);
0484         seq_printf(s, "  - data blocks : %d (%d)\n", si->data_blks,
0485                 si->bg_data_blks);
0486         seq_printf(s, "  - node blocks : %d (%d)\n", si->node_blks,
0487                 si->bg_node_blks);
0488         seq_printf(s, "BG skip : IO: %u, Other: %u\n",
0489                 si->io_skip_bggc, si->other_skip_bggc);
0490         seq_puts(s, "\nExtent Cache:\n");
0491         seq_printf(s, "  - Hit Count: L1-1:%llu L1-2:%llu L2:%llu\n",
0492                 si->hit_largest, si->hit_cached,
0493                 si->hit_rbtree);
0494         seq_printf(s, "  - Hit Ratio: %llu%% (%llu / %llu)\n",
0495                 !si->total_ext ? 0 :
0496                 div64_u64(si->hit_total * 100, si->total_ext),
0497                 si->hit_total, si->total_ext);
0498         seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
0499                 si->ext_tree, si->zombie_tree, si->ext_node);
0500         seq_puts(s, "\nBalancing F2FS Async:\n");
0501         seq_printf(s, "  - DIO (R: %4d, W: %4d)\n",
0502                si->nr_dio_read, si->nr_dio_write);
0503         seq_printf(s, "  - IO_R (Data: %4d, Node: %4d, Meta: %4d\n",
0504                si->nr_rd_data, si->nr_rd_node, si->nr_rd_meta);
0505         seq_printf(s, "  - IO_W (CP: %4d, Data: %4d, Flush: (%4d %4d %4d), "
0506             "Discard: (%4d %4d)) cmd: %4d undiscard:%4u\n",
0507                si->nr_wb_cp_data, si->nr_wb_data,
0508                si->nr_flushing, si->nr_flushed,
0509                si->flush_list_empty,
0510                si->nr_discarding, si->nr_discarded,
0511                si->nr_discard_cmd, si->undiscard_blks);
0512         seq_printf(s, "  - atomic IO: %4d (Max. %4d)\n",
0513                si->aw_cnt, si->max_aw_cnt);
0514         seq_printf(s, "  - compress: %4d, hit:%8d\n", si->compress_pages, si->compress_page_hit);
0515         seq_printf(s, "  - nodes: %4d in %4d\n",
0516                si->ndirty_node, si->node_pages);
0517         seq_printf(s, "  - dents: %4d in dirs:%4d (%4d)\n",
0518                si->ndirty_dent, si->ndirty_dirs, si->ndirty_all);
0519         seq_printf(s, "  - datas: %4d in files:%4d\n",
0520                si->ndirty_data, si->ndirty_files);
0521         seq_printf(s, "  - quota datas: %4d in quota files:%4d\n",
0522                si->ndirty_qdata, si->nquota_files);
0523         seq_printf(s, "  - meta: %4d in %4d\n",
0524                si->ndirty_meta, si->meta_pages);
0525         seq_printf(s, "  - imeta: %4d\n",
0526                si->ndirty_imeta);
0527         seq_printf(s, "  - fsync mark: %4lld\n",
0528                percpu_counter_sum_positive(
0529                     &si->sbi->rf_node_block_count));
0530         seq_printf(s, "  - NATs: %9d/%9d\n  - SITs: %9d/%9d\n",
0531                si->dirty_nats, si->nats, si->dirty_sits, si->sits);
0532         seq_printf(s, "  - free_nids: %9d/%9d\n  - alloc_nids: %9d\n",
0533                si->free_nids, si->avail_nids, si->alloc_nids);
0534         seq_puts(s, "\nDistribution of User Blocks:");
0535         seq_puts(s, " [ valid | invalid | free ]\n");
0536         seq_puts(s, "  [");
0537 
0538         for (j = 0; j < si->util_valid; j++)
0539             seq_putc(s, '-');
0540         seq_putc(s, '|');
0541 
0542         for (j = 0; j < si->util_invalid; j++)
0543             seq_putc(s, '-');
0544         seq_putc(s, '|');
0545 
0546         for (j = 0; j < si->util_free; j++)
0547             seq_putc(s, '-');
0548         seq_puts(s, "]\n\n");
0549         seq_printf(s, "IPU: %u blocks\n", si->inplace_count);
0550         seq_printf(s, "SSR: %u blocks in %u segments\n",
0551                si->block_count[SSR], si->segment_count[SSR]);
0552         seq_printf(s, "LFS: %u blocks in %u segments\n",
0553                si->block_count[LFS], si->segment_count[LFS]);
0554 
0555         /* segment usage info */
0556         f2fs_update_sit_info(si->sbi);
0557         seq_printf(s, "\nBDF: %u, avg. vblocks: %u\n",
0558                si->bimodal, si->avg_vblocks);
0559 
0560         /* memory footprint */
0561         update_mem_info(si->sbi);
0562         seq_printf(s, "\nMemory: %llu KB\n",
0563             (si->base_mem + si->cache_mem + si->page_mem) >> 10);
0564         seq_printf(s, "  - static: %llu KB\n",
0565                 si->base_mem >> 10);
0566         seq_printf(s, "  - cached: %llu KB\n",
0567                 si->cache_mem >> 10);
0568         seq_printf(s, "  - paged : %llu KB\n",
0569                 si->page_mem >> 10);
0570     }
0571     raw_spin_unlock_irqrestore(&f2fs_stat_lock, flags);
0572     return 0;
0573 }
0574 
0575 DEFINE_SHOW_ATTRIBUTE(stat);
0576 #endif
0577 
0578 int f2fs_build_stats(struct f2fs_sb_info *sbi)
0579 {
0580     struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
0581     struct f2fs_stat_info *si;
0582     unsigned long flags;
0583     int i;
0584 
0585     si = f2fs_kzalloc(sbi, sizeof(struct f2fs_stat_info), GFP_KERNEL);
0586     if (!si)
0587         return -ENOMEM;
0588 
0589     si->all_area_segs = le32_to_cpu(raw_super->segment_count);
0590     si->sit_area_segs = le32_to_cpu(raw_super->segment_count_sit);
0591     si->nat_area_segs = le32_to_cpu(raw_super->segment_count_nat);
0592     si->ssa_area_segs = le32_to_cpu(raw_super->segment_count_ssa);
0593     si->main_area_segs = le32_to_cpu(raw_super->segment_count_main);
0594     si->main_area_sections = le32_to_cpu(raw_super->section_count);
0595     si->main_area_zones = si->main_area_sections /
0596                 le32_to_cpu(raw_super->secs_per_zone);
0597     si->sbi = sbi;
0598     sbi->stat_info = si;
0599 
0600     atomic64_set(&sbi->total_hit_ext, 0);
0601     atomic64_set(&sbi->read_hit_rbtree, 0);
0602     atomic64_set(&sbi->read_hit_largest, 0);
0603     atomic64_set(&sbi->read_hit_cached, 0);
0604 
0605     atomic_set(&sbi->inline_xattr, 0);
0606     atomic_set(&sbi->inline_inode, 0);
0607     atomic_set(&sbi->inline_dir, 0);
0608     atomic_set(&sbi->compr_inode, 0);
0609     atomic64_set(&sbi->compr_blocks, 0);
0610     atomic_set(&sbi->inplace_count, 0);
0611     for (i = META_CP; i < META_MAX; i++)
0612         atomic_set(&sbi->meta_count[i], 0);
0613 
0614     atomic_set(&sbi->max_aw_cnt, 0);
0615 
0616     raw_spin_lock_irqsave(&f2fs_stat_lock, flags);
0617     list_add_tail(&si->stat_list, &f2fs_stat_list);
0618     raw_spin_unlock_irqrestore(&f2fs_stat_lock, flags);
0619 
0620     return 0;
0621 }
0622 
0623 void f2fs_destroy_stats(struct f2fs_sb_info *sbi)
0624 {
0625     struct f2fs_stat_info *si = F2FS_STAT(sbi);
0626     unsigned long flags;
0627 
0628     raw_spin_lock_irqsave(&f2fs_stat_lock, flags);
0629     list_del(&si->stat_list);
0630     raw_spin_unlock_irqrestore(&f2fs_stat_lock, flags);
0631 
0632     kfree(si);
0633 }
0634 
0635 void __init f2fs_create_root_stats(void)
0636 {
0637 #ifdef CONFIG_DEBUG_FS
0638     f2fs_debugfs_root = debugfs_create_dir("f2fs", NULL);
0639 
0640     debugfs_create_file("status", 0444, f2fs_debugfs_root, NULL,
0641                 &stat_fops);
0642 #endif
0643 }
0644 
0645 void f2fs_destroy_root_stats(void)
0646 {
0647 #ifdef CONFIG_DEBUG_FS
0648     debugfs_remove_recursive(f2fs_debugfs_root);
0649     f2fs_debugfs_root = NULL;
0650 #endif
0651 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!