add led

hc

2024-05-10 10ebd8556b7990499c896a550e3d416b444211e6

 kernel/fs/f2fs/debug.c
..
..
@@ -72,15 +72,26 @@
72
72
 	si->main_area_zones = si->main_area_sections /
73
73
 				le32_to_cpu(raw_super->secs_per_zone);
74
74
 
75
-	/* validation check of the segment numbers */
75
+	/* general extent cache stats */
76
+	for (i = 0; i < NR_EXTENT_CACHES; i++) {
77
+		struct extent_tree_info *eti = &sbi->extent_tree[i];
78
+
79
+		si->hit_cached[i] = atomic64_read(&sbi->read_hit_cached[i]);
80
+		si->hit_rbtree[i] = atomic64_read(&sbi->read_hit_rbtree[i]);
81
+		si->total_ext[i] = atomic64_read(&sbi->total_hit_ext[i]);
82
+		si->hit_total[i] = si->hit_cached[i] + si->hit_rbtree[i];
83
+		si->ext_tree[i] = atomic_read(&eti->total_ext_tree);
84
+		si->zombie_tree[i] = atomic_read(&eti->total_zombie_tree);
85
+		si->ext_node[i] = atomic_read(&eti->total_ext_node);
86
+	}
87
+	/* read extent_cache only */
76
88
 	si->hit_largest = atomic64_read(&sbi->read_hit_largest);
77
-	si->hit_cached = atomic64_read(&sbi->read_hit_cached);
78
-	si->hit_rbtree = atomic64_read(&sbi->read_hit_rbtree);
79
-	si->hit_total = si->hit_largest + si->hit_cached + si->hit_rbtree;
80
-	si->total_ext = atomic64_read(&sbi->total_hit_ext);
81
-	si->ext_tree = atomic_read(&sbi->total_ext_tree);
82
-	si->zombie_tree = atomic_read(&sbi->total_zombie_tree);
83
-	si->ext_node = atomic_read(&sbi->total_ext_node);
89
+	si->hit_total[EX_READ] += si->hit_largest;
90
+
91
+	/* block age extent_cache only */
92
+	si->allocated_data_blocks = atomic64_read(&sbi->allocated_data_blocks);
93
+
94
+	/* validation check of the segment numbers */
84
95
 	si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
85
96
 	si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
86
97
 	si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META);
..
..
@@ -120,6 +131,13 @@
120
131
 			atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);
121
132
 		si->undiscard_blks = SM_I(sbi)->dcc_info->undiscard_blks;
122
133
 	}
134
+	si->nr_issued_ckpt = atomic_read(&sbi->cprc_info.issued_ckpt);
135
+	si->nr_total_ckpt = atomic_read(&sbi->cprc_info.total_ckpt);
136
+	si->nr_queued_ckpt = atomic_read(&sbi->cprc_info.queued_ckpt);
137
+	spin_lock(&sbi->cprc_info.stat_lock);
138
+	si->cur_ckpt_time = sbi->cprc_info.cur_time;
139
+	si->peak_ckpt_time = sbi->cprc_info.peak_time;
140
+	spin_unlock(&sbi->cprc_info.stat_lock);
123
141
 	si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
124
142
 	si->rsvd_segs = reserved_segments(sbi);
125
143
 	si->overp_segs = overprovision_segments(sbi);
..
..
@@ -131,7 +149,7 @@
131
149
 	si->inline_inode = atomic_read(&sbi->inline_inode);
132
150
 	si->inline_dir = atomic_read(&sbi->inline_dir);
133
151
 	si->compr_inode = atomic_read(&sbi->compr_inode);
134
-	si->compr_blocks = atomic_read(&sbi->compr_blocks);
152
+	si->compr_blocks = atomic64_read(&sbi->compr_blocks);
135
153
 	si->append = sbi->im[APPEND_INO].ino_num;
136
154
 	si->update = sbi->im[UPDATE_INO].ino_num;
137
155
 	si->orphans = sbi->im[ORPHAN_INO].ino_num;
..
..
@@ -145,8 +163,14 @@
145
163
 		si->node_pages = NODE_MAPPING(sbi)->nrpages;
146
164
 	if (sbi->meta_inode)
147
165
 		si->meta_pages = META_MAPPING(sbi)->nrpages;
148
-	si->nats = NM_I(sbi)->nat_cnt;
149
-	si->dirty_nats = NM_I(sbi)->dirty_nat_cnt;
166
+#ifdef CONFIG_F2FS_FS_COMPRESSION
167
+	if (sbi->compress_inode) {
168
+		si->compress_pages = COMPRESS_MAPPING(sbi)->nrpages;
169
+		si->compress_page_hit = atomic_read(&sbi->compress_page_hit);
170
+	}
171
+#endif
172
+	si->nats = NM_I(sbi)->nat_cnt[TOTAL_NAT];
173
+	si->dirty_nats = NM_I(sbi)->nat_cnt[DIRTY_NAT];
150
174
 	si->sits = MAIN_SEGS(sbi);
151
175
 	si->dirty_sits = SIT_I(sbi)->dirty_sentries;
152
176
 	si->free_nids = NM_I(sbi)->nid_cnt[FREE_NID];
..
..
@@ -164,8 +188,9 @@
164
188
 		* 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
165
189
 		/ 2;
166
190
 	si->util_invalid = 50 - si->util_free - si->util_valid;
167
-	for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_NODE; i++) {
191
+	for (i = CURSEG_HOT_DATA; i < NO_CHECK_TYPE; i++) {
168
192
 		struct curseg_info *curseg = CURSEG_I(sbi, i);
193
+
169
194
 		si->curseg[i] = curseg->segno;
170
195
 		si->cursec[i] = GET_SEC_FROM_SEG(sbi, curseg->segno);
171
196
 		si->curzone[i] = GET_ZONE_FROM_SEC(sbi, si->cursec[i]);
..
..
@@ -173,6 +198,26 @@
173
198
 
174
199
 	for (i = META_CP; i < META_MAX; i++)
175
200
 		si->meta_count[i] = atomic_read(&sbi->meta_count[i]);
201
+
202
+	for (i = 0; i < NO_CHECK_TYPE; i++) {
203
+		si->dirty_seg[i] = 0;
204
+		si->full_seg[i] = 0;
205
+		si->valid_blks[i] = 0;
206
+	}
207
+
208
+	for (i = 0; i < MAIN_SEGS(sbi); i++) {
209
+		int blks = get_seg_entry(sbi, i)->valid_blocks;
210
+		int type = get_seg_entry(sbi, i)->type;
211
+
212
+		if (!blks)
213
+			continue;
214
+
215
+		if (blks == sbi->blocks_per_seg)
216
+			si->full_seg[type]++;
217
+		else
218
+			si->dirty_seg[type]++;
219
+		si->valid_blks[type] += blks;
220
+	}
176
221
 
177
222
 	for (i = 0; i < 2; i++) {
178
223
 		si->segment_count[i] = sbi->segment_count[i];
..
..
@@ -258,26 +303,41 @@
258
303
 	si->cache_mem += (NM_I(sbi)->nid_cnt[FREE_NID] +
259
304
 				NM_I(sbi)->nid_cnt[PREALLOC_NID]) *
260
305
 				sizeof(struct free_nid);
261
-	si->cache_mem += NM_I(sbi)->nat_cnt * sizeof(struct nat_entry);
262
-	si->cache_mem += NM_I(sbi)->dirty_nat_cnt *
263
-					sizeof(struct nat_entry_set);
306
+	si->cache_mem += NM_I(sbi)->nat_cnt[TOTAL_NAT] *
307
+				sizeof(struct nat_entry);
308
+	si->cache_mem += NM_I(sbi)->nat_cnt[DIRTY_NAT] *
309
+				sizeof(struct nat_entry_set);
264
310
 	si->cache_mem += si->inmem_pages * sizeof(struct inmem_pages);
265
311
 	for (i = 0; i < MAX_INO_ENTRY; i++)
266
312
 		si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry);
267
-	si->cache_mem += atomic_read(&sbi->total_ext_tree) *
313
+
314
+	for (i = 0; i < NR_EXTENT_CACHES; i++) {
315
+		struct extent_tree_info *eti = &sbi->extent_tree[i];
316
+
317
+		si->ext_mem[i] = atomic_read(&eti->total_ext_tree) *
268
318
 						sizeof(struct extent_tree);
269
-	si->cache_mem += atomic_read(&sbi->total_ext_node) *
319
+		si->ext_mem[i] += atomic_read(&eti->total_ext_node) *
270
320
 						sizeof(struct extent_node);
321
+		si->cache_mem += si->ext_mem[i];
322
+	}
271
323
 
272
324
 	si->page_mem = 0;
273
325
 	if (sbi->node_inode) {
274
326
 		unsigned npages = NODE_MAPPING(sbi)->nrpages;
327
+
275
328
 		si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
276
329
 	}
277
330
 	if (sbi->meta_inode) {
278
331
 		unsigned npages = META_MAPPING(sbi)->nrpages;
332
+
279
333
 		si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
280
334
 	}
335
+#ifdef CONFIG_F2FS_FS_COMPRESSION
336
+	if (sbi->compress_inode) {
337
+		unsigned npages = COMPRESS_MAPPING(sbi)->nrpages;
338
+		si->page_mem += (unsigned long long)npages << PAGE_SHIFT;
339
+	}
340
+#endif
281
341
 }
282
342
 
283
343
 static int stat_show(struct seq_file *s, void *v)
..
..
@@ -322,37 +382,65 @@
322
382
 			   si->inline_inode);
323
383
 		seq_printf(s, "  - Inline_dentry Inode: %u\n",
324
384
 			   si->inline_dir);
325
-		seq_printf(s, "  - Compressed Inode: %u, Blocks: %u\n",
385
+		seq_printf(s, "  - Compressed Inode: %u, Blocks: %llu\n",
326
386
 			   si->compr_inode, si->compr_blocks);
327
387
 		seq_printf(s, "  - Orphan/Append/Update Inode: %u, %u, %u\n",
328
388
 			   si->orphans, si->append, si->update);
329
389
 		seq_printf(s, "\nMain area: %d segs, %d secs %d zones\n",
330
390
 			   si->main_area_segs, si->main_area_sections,
331
391
 			   si->main_area_zones);
332
-		seq_printf(s, "  - COLD  data: %d, %d, %d\n",
392
+		seq_printf(s, "    TYPE         %8s %8s %8s %10s %10s %10s\n",
393
+			   "segno", "secno", "zoneno", "dirty_seg", "full_seg", "valid_blk");
394
+		seq_printf(s, "  - COLD   data: %8d %8d %8d %10u %10u %10u\n",
333
395
 			   si->curseg[CURSEG_COLD_DATA],
334
396
 			   si->cursec[CURSEG_COLD_DATA],
335
-			   si->curzone[CURSEG_COLD_DATA]);
336
-		seq_printf(s, "  - WARM  data: %d, %d, %d\n",
397
+			   si->curzone[CURSEG_COLD_DATA],
398
+			   si->dirty_seg[CURSEG_COLD_DATA],
399
+			   si->full_seg[CURSEG_COLD_DATA],
400
+			   si->valid_blks[CURSEG_COLD_DATA]);
401
+		seq_printf(s, "  - WARM   data: %8d %8d %8d %10u %10u %10u\n",
337
402
 			   si->curseg[CURSEG_WARM_DATA],
338
403
 			   si->cursec[CURSEG_WARM_DATA],
339
-			   si->curzone[CURSEG_WARM_DATA]);
340
-		seq_printf(s, "  - HOT   data: %d, %d, %d\n",
404
+			   si->curzone[CURSEG_WARM_DATA],
405
+			   si->dirty_seg[CURSEG_WARM_DATA],
406
+			   si->full_seg[CURSEG_WARM_DATA],
407
+			   si->valid_blks[CURSEG_WARM_DATA]);
408
+		seq_printf(s, "  - HOT    data: %8d %8d %8d %10u %10u %10u\n",
341
409
 			   si->curseg[CURSEG_HOT_DATA],
342
410
 			   si->cursec[CURSEG_HOT_DATA],
343
-			   si->curzone[CURSEG_HOT_DATA]);
344
-		seq_printf(s, "  - Dir   dnode: %d, %d, %d\n",
411
+			   si->curzone[CURSEG_HOT_DATA],
412
+			   si->dirty_seg[CURSEG_HOT_DATA],
413
+			   si->full_seg[CURSEG_HOT_DATA],
414
+			   si->valid_blks[CURSEG_HOT_DATA]);
415
+		seq_printf(s, "  - Dir   dnode: %8d %8d %8d %10u %10u %10u\n",
345
416
 			   si->curseg[CURSEG_HOT_NODE],
346
417
 			   si->cursec[CURSEG_HOT_NODE],
347
-			   si->curzone[CURSEG_HOT_NODE]);
348
-		seq_printf(s, "  - File   dnode: %d, %d, %d\n",
418
+			   si->curzone[CURSEG_HOT_NODE],
419
+			   si->dirty_seg[CURSEG_HOT_NODE],
420
+			   si->full_seg[CURSEG_HOT_NODE],
421
+			   si->valid_blks[CURSEG_HOT_NODE]);
422
+		seq_printf(s, "  - File  dnode: %8d %8d %8d %10u %10u %10u\n",
349
423
 			   si->curseg[CURSEG_WARM_NODE],
350
424
 			   si->cursec[CURSEG_WARM_NODE],
351
-			   si->curzone[CURSEG_WARM_NODE]);
352
-		seq_printf(s, "  - Indir nodes: %d, %d, %d\n",
425
+			   si->curzone[CURSEG_WARM_NODE],
426
+			   si->dirty_seg[CURSEG_WARM_NODE],
427
+			   si->full_seg[CURSEG_WARM_NODE],
428
+			   si->valid_blks[CURSEG_WARM_NODE]);
429
+		seq_printf(s, "  - Indir nodes: %8d %8d %8d %10u %10u %10u\n",
353
430
 			   si->curseg[CURSEG_COLD_NODE],
354
431
 			   si->cursec[CURSEG_COLD_NODE],
355
-			   si->curzone[CURSEG_COLD_NODE]);
432
+			   si->curzone[CURSEG_COLD_NODE],
433
+			   si->dirty_seg[CURSEG_COLD_NODE],
434
+			   si->full_seg[CURSEG_COLD_NODE],
435
+			   si->valid_blks[CURSEG_COLD_NODE]);
436
+		seq_printf(s, "  - Pinned file: %8d %8d %8d\n",
437
+			   si->curseg[CURSEG_COLD_DATA_PINNED],
438
+			   si->cursec[CURSEG_COLD_DATA_PINNED],
439
+			   si->curzone[CURSEG_COLD_DATA_PINNED]);
440
+		seq_printf(s, "  - ATGC   data: %8d %8d %8d\n",
441
+			   si->curseg[CURSEG_ALL_DATA_ATGC],
442
+			   si->cursec[CURSEG_ALL_DATA_ATGC],
443
+			   si->curzone[CURSEG_ALL_DATA_ATGC]);
356
444
 		seq_printf(s, "\n  - Valid: %d\n  - Dirty: %d\n",
357
445
 			   si->main_area_segs - si->dirty_count -
358
446
 			   si->prefree_count - si->free_segs,
..
..
@@ -368,12 +456,28 @@
368
456
 				si->meta_count[META_NAT]);
369
457
 		seq_printf(s, "  - ssa blocks : %u\n",
370
458
 				si->meta_count[META_SSA]);
459
+		seq_printf(s, "CP merge (Queued: %4d, Issued: %4d, Total: %4d, "
460
+				"Cur time: %4d(ms), Peak time: %4d(ms))\n",
461
+				si->nr_queued_ckpt, si->nr_issued_ckpt,
462
+				si->nr_total_ckpt, si->cur_ckpt_time,
463
+				si->peak_ckpt_time);
371
464
 		seq_printf(s, "GC calls: %d (BG: %d)\n",
372
465
 			   si->call_count, si->bg_gc);
373
466
 		seq_printf(s, "  - data segments : %d (%d)\n",
374
467
 				si->data_segs, si->bg_data_segs);
375
468
 		seq_printf(s, "  - node segments : %d (%d)\n",
376
469
 				si->node_segs, si->bg_node_segs);
470
+		seq_printf(s, "  - Reclaimed segs : Normal (%d), Idle CB (%d), "
471
+				"Idle Greedy (%d), Idle AT (%d), "
472
+				"Urgent High (%d), Urgent Mid (%d), "
473
+				"Urgent Low (%d)\n",
474
+				si->sbi->gc_reclaimed_segs[GC_NORMAL],
475
+				si->sbi->gc_reclaimed_segs[GC_IDLE_CB],
476
+				si->sbi->gc_reclaimed_segs[GC_IDLE_GREEDY],
477
+				si->sbi->gc_reclaimed_segs[GC_IDLE_AT],
478
+				si->sbi->gc_reclaimed_segs[GC_URGENT_HIGH],
479
+				si->sbi->gc_reclaimed_segs[GC_URGENT_MID],
480
+				si->sbi->gc_reclaimed_segs[GC_URGENT_LOW]);
377
481
 		seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks,
378
482
 				si->bg_data_blks + si->bg_node_blks);
379
483
 		seq_printf(s, "  - data blocks : %d (%d)\n", si->data_blks,
..
..
@@ -386,16 +490,34 @@
386
490
 				si->skipped_atomic_files[BG_GC]);
387
491
 		seq_printf(s, "BG skip : IO: %u, Other: %u\n",
388
492
 				si->io_skip_bggc, si->other_skip_bggc);
389
-		seq_puts(s, "\nExtent Cache:\n");
493
+		seq_puts(s, "\nExtent Cache (Read):\n");
390
494
 		seq_printf(s, "  - Hit Count: L1-1:%llu L1-2:%llu L2:%llu\n",
391
-				si->hit_largest, si->hit_cached,
392
-				si->hit_rbtree);
495
+				si->hit_largest, si->hit_cached[EX_READ],
496
+				si->hit_rbtree[EX_READ]);
393
497
 		seq_printf(s, "  - Hit Ratio: %llu%% (%llu / %llu)\n",
394
-				!si->total_ext ? 0 :
395
-				div64_u64(si->hit_total * 100, si->total_ext),
396
-				si->hit_total, si->total_ext);
498
+				!si->total_ext[EX_READ] ? 0 :
499
+				div64_u64(si->hit_total[EX_READ] * 100,
500
+				si->total_ext[EX_READ]),
501
+				si->hit_total[EX_READ], si->total_ext[EX_READ]);
397
502
 		seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
398
-				si->ext_tree, si->zombie_tree, si->ext_node);
503
+				si->ext_tree[EX_READ], si->zombie_tree[EX_READ],
504
+				si->ext_node[EX_READ]);
505
+		seq_puts(s, "\nExtent Cache (Block Age):\n");
506
+		seq_printf(s, "  - Allocated Data Blocks: %llu\n",
507
+				si->allocated_data_blocks);
508
+		seq_printf(s, "  - Hit Count: L1:%llu L2:%llu\n",
509
+				si->hit_cached[EX_BLOCK_AGE],
510
+				si->hit_rbtree[EX_BLOCK_AGE]);
511
+		seq_printf(s, "  - Hit Ratio: %llu%% (%llu / %llu)\n",
512
+				!si->total_ext[EX_BLOCK_AGE] ? 0 :
513
+				div64_u64(si->hit_total[EX_BLOCK_AGE] * 100,
514
+				si->total_ext[EX_BLOCK_AGE]),
515
+				si->hit_total[EX_BLOCK_AGE],
516
+				si->total_ext[EX_BLOCK_AGE]);
517
+		seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
518
+				si->ext_tree[EX_BLOCK_AGE],
519
+				si->zombie_tree[EX_BLOCK_AGE],
520
+				si->ext_node[EX_BLOCK_AGE]);
399
521
 		seq_puts(s, "\nBalancing F2FS Async:\n");
400
522
 		seq_printf(s, "  - DIO (R: %4d, W: %4d)\n",
401
523
 			   si->nr_dio_read, si->nr_dio_write);
..
..
@@ -412,6 +534,7 @@
412
534
 			"volatile IO: %4d (Max. %4d)\n",
413
535
 			   si->inmem_pages, si->aw_cnt, si->max_aw_cnt,
414
536
 			   si->vw_cnt, si->max_vw_cnt);
537
+		seq_printf(s, "  - compress: %4d, hit:%8d\n", si->compress_pages, si->compress_page_hit);
415
538
 		seq_printf(s, "  - nodes: %4d in %4d\n",
416
539
 			   si->ndirty_node, si->node_pages);
417
540
 		seq_printf(s, "  - dents: %4d in dirs:%4d (%4d)\n",
..
..
@@ -460,8 +583,12 @@
460
583
 			(si->base_mem + si->cache_mem + si->page_mem) >> 10);
461
584
 		seq_printf(s, "  - static: %llu KB\n",
462
585
 				si->base_mem >> 10);
463
-		seq_printf(s, "  - cached: %llu KB\n",
586
+		seq_printf(s, "  - cached all: %llu KB\n",
464
587
 				si->cache_mem >> 10);
588
+		seq_printf(s, "  - read extent cache: %llu KB\n",
589
+				si->ext_mem[EX_READ] >> 10);
590
+		seq_printf(s, "  - block age extent cache: %llu KB\n",
591
+				si->ext_mem[EX_BLOCK_AGE] >> 10);
465
592
 		seq_printf(s, "  - paged : %llu KB\n",
466
593
 				si->page_mem >> 10);
467
594
 	}
..
..
@@ -493,16 +620,21 @@
493
620
 	si->sbi = sbi;
494
621
 	sbi->stat_info = si;
495
622
 
496
-	atomic64_set(&sbi->total_hit_ext, 0);
497
-	atomic64_set(&sbi->read_hit_rbtree, 0);
623
+	/* general extent cache stats */
624
+	for (i = 0; i < NR_EXTENT_CACHES; i++) {
625
+		atomic64_set(&sbi->total_hit_ext[i], 0);
626
+		atomic64_set(&sbi->read_hit_rbtree[i], 0);
627
+		atomic64_set(&sbi->read_hit_cached[i], 0);
628
+	}
629
+
630
+	/* read extent_cache only */
498
631
 	atomic64_set(&sbi->read_hit_largest, 0);
499
-	atomic64_set(&sbi->read_hit_cached, 0);
500
632
 
501
633
 	atomic_set(&sbi->inline_xattr, 0);
502
634
 	atomic_set(&sbi->inline_inode, 0);
503
635
 	atomic_set(&sbi->inline_dir, 0);
504
636
 	atomic_set(&sbi->compr_inode, 0);
505
-	atomic_set(&sbi->compr_blocks, 0);
637
+	atomic64_set(&sbi->compr_blocks, 0);
506
638
 	atomic_set(&sbi->inplace_count, 0);
507
639
 	for (i = META_CP; i < META_MAX; i++)
508
640
 		atomic_set(&sbi->meta_count[i], 0);
..
..
@@ -526,7 +658,7 @@
526
658
 	list_del(&si->stat_list);
527
659
 	mutex_unlock(&f2fs_stat_mutex);
528
660
 
529
-	kvfree(si);
661
+	kfree(si);
530
662
 }
531
663
 
532
664
 void __init f2fs_create_root_stats(void)