1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * f2fs sysfs interface 4 * 5 * Copyright (c) 2012 Samsung Electronics Co., Ltd. 6 * http://www.samsung.com/ 7 * Copyright (c) 2017 Chao Yu <chao@kernel.org> 8 */ 9 #include <linux/compiler.h> 10 #include <linux/proc_fs.h> 11 #include <linux/f2fs_fs.h> 12 #include <linux/seq_file.h> 13 #include <linux/unicode.h> 14 #include <linux/ioprio.h> 15 #include <linux/sysfs.h> 16 17 #include "f2fs.h" 18 #include "segment.h" 19 #include "gc.h" 20 #include <trace/events/f2fs.h> 21 22 static struct proc_dir_entry *f2fs_proc_root; 23 24 /* Sysfs support for f2fs */ 25 enum { 26 GC_THREAD, /* struct f2fs_gc_thread */ 27 SM_INFO, /* struct f2fs_sm_info */ 28 DCC_INFO, /* struct discard_cmd_control */ 29 NM_INFO, /* struct f2fs_nm_info */ 30 F2FS_SBI, /* struct f2fs_sb_info */ 31 #ifdef CONFIG_F2FS_STAT_FS 32 STAT_INFO, /* struct f2fs_stat_info */ 33 #endif 34 #ifdef CONFIG_F2FS_FAULT_INJECTION 35 FAULT_INFO_RATE, /* struct f2fs_fault_info */ 36 FAULT_INFO_TYPE, /* struct f2fs_fault_info */ 37 #endif 38 RESERVED_BLOCKS, /* struct f2fs_sb_info */ 39 CPRC_INFO, /* struct ckpt_req_control */ 40 ATGC_INFO, /* struct atgc_management */ 41 }; 42 43 struct f2fs_attr { 44 struct attribute attr; 45 ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *); 46 ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *, 47 const char *, size_t); 48 int struct_type; 49 int offset; 50 int id; 51 }; 52 53 static ssize_t f2fs_sbi_show(struct f2fs_attr *a, 54 struct f2fs_sb_info *sbi, char *buf); 55 56 static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type) 57 { 58 if (struct_type == GC_THREAD) 59 return (unsigned char *)sbi->gc_thread; 60 else if (struct_type == SM_INFO) 61 return (unsigned char *)SM_I(sbi); 62 else if (struct_type == DCC_INFO) 63 return (unsigned char *)SM_I(sbi)->dcc_info; 64 else if (struct_type == NM_INFO) 65 return (unsigned char *)NM_I(sbi); 66 else if (struct_type == F2FS_SBI || struct_type == RESERVED_BLOCKS) 67 return (unsigned char *)sbi; 68 #ifdef CONFIG_F2FS_FAULT_INJECTION 69 else if (struct_type == FAULT_INFO_RATE || 70 struct_type == FAULT_INFO_TYPE) 71 return (unsigned char *)&F2FS_OPTION(sbi).fault_info; 72 #endif 73 #ifdef CONFIG_F2FS_STAT_FS 74 else if (struct_type == STAT_INFO) 75 return (unsigned char *)F2FS_STAT(sbi); 76 #endif 77 else if (struct_type == CPRC_INFO) 78 return (unsigned char *)&sbi->cprc_info; 79 else if (struct_type == ATGC_INFO) 80 return (unsigned char *)&sbi->am; 81 return NULL; 82 } 83 84 static ssize_t dirty_segments_show(struct f2fs_attr *a, 85 struct f2fs_sb_info *sbi, char *buf) 86 { 87 return sprintf(buf, "%llu\n", 88 (unsigned long long)(dirty_segments(sbi))); 89 } 90 91 static ssize_t free_segments_show(struct f2fs_attr *a, 92 struct f2fs_sb_info *sbi, char *buf) 93 { 94 return sprintf(buf, "%llu\n", 95 (unsigned long long)(free_segments(sbi))); 96 } 97 98 static ssize_t ovp_segments_show(struct f2fs_attr *a, 99 struct f2fs_sb_info *sbi, char *buf) 100 { 101 return sprintf(buf, "%llu\n", 102 (unsigned long long)(overprovision_segments(sbi))); 103 } 104 105 static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a, 106 struct f2fs_sb_info *sbi, char *buf) 107 { 108 return sprintf(buf, "%llu\n", 109 (unsigned long long)(sbi->kbytes_written + 110 ((f2fs_get_sectors_written(sbi) - 111 sbi->sectors_written_start) >> 1))); 112 } 113 114 static ssize_t sb_status_show(struct f2fs_attr *a, 115 struct f2fs_sb_info *sbi, char *buf) 116 { 117 return sprintf(buf, "%lx\n", sbi->s_flag); 118 } 119 120 static ssize_t features_show(struct f2fs_attr *a, 121 struct f2fs_sb_info *sbi, char *buf) 122 { 123 int len = 0; 124 125 if (f2fs_sb_has_encrypt(sbi)) 126 len += scnprintf(buf, PAGE_SIZE - len, "%s", 127 "encryption"); 128 if (f2fs_sb_has_blkzoned(sbi)) 129 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 130 len ? ", " : "", "blkzoned"); 131 if (f2fs_sb_has_extra_attr(sbi)) 132 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 133 len ? ", " : "", "extra_attr"); 134 if (f2fs_sb_has_project_quota(sbi)) 135 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 136 len ? ", " : "", "projquota"); 137 if (f2fs_sb_has_inode_chksum(sbi)) 138 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 139 len ? ", " : "", "inode_checksum"); 140 if (f2fs_sb_has_flexible_inline_xattr(sbi)) 141 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 142 len ? ", " : "", "flexible_inline_xattr"); 143 if (f2fs_sb_has_quota_ino(sbi)) 144 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 145 len ? ", " : "", "quota_ino"); 146 if (f2fs_sb_has_inode_crtime(sbi)) 147 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 148 len ? ", " : "", "inode_crtime"); 149 if (f2fs_sb_has_lost_found(sbi)) 150 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 151 len ? ", " : "", "lost_found"); 152 if (f2fs_sb_has_verity(sbi)) 153 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 154 len ? ", " : "", "verity"); 155 if (f2fs_sb_has_sb_chksum(sbi)) 156 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 157 len ? ", " : "", "sb_checksum"); 158 if (f2fs_sb_has_casefold(sbi)) 159 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 160 len ? ", " : "", "casefold"); 161 if (f2fs_sb_has_readonly(sbi)) 162 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 163 len ? ", " : "", "readonly"); 164 if (f2fs_sb_has_compression(sbi)) 165 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 166 len ? ", " : "", "compression"); 167 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", 168 len ? ", " : "", "pin_file"); 169 len += scnprintf(buf + len, PAGE_SIZE - len, "\n"); 170 return len; 171 } 172 173 static ssize_t current_reserved_blocks_show(struct f2fs_attr *a, 174 struct f2fs_sb_info *sbi, char *buf) 175 { 176 return sprintf(buf, "%u\n", sbi->current_reserved_blocks); 177 } 178 179 static ssize_t unusable_show(struct f2fs_attr *a, 180 struct f2fs_sb_info *sbi, char *buf) 181 { 182 block_t unusable; 183 184 if (test_opt(sbi, DISABLE_CHECKPOINT)) 185 unusable = sbi->unusable_block_count; 186 else 187 unusable = f2fs_get_unusable_blocks(sbi); 188 return sprintf(buf, "%llu\n", (unsigned long long)unusable); 189 } 190 191 static ssize_t encoding_show(struct f2fs_attr *a, 192 struct f2fs_sb_info *sbi, char *buf) 193 { 194 #ifdef CONFIG_UNICODE 195 struct super_block *sb = sbi->sb; 196 197 if (f2fs_sb_has_casefold(sbi)) 198 return snprintf(buf, PAGE_SIZE, "%s (%d.%d.%d)\n", 199 sb->s_encoding->charset, 200 (sb->s_encoding->version >> 16) & 0xff, 201 (sb->s_encoding->version >> 8) & 0xff, 202 sb->s_encoding->version & 0xff); 203 #endif 204 return sprintf(buf, "(none)"); 205 } 206 207 static ssize_t mounted_time_sec_show(struct f2fs_attr *a, 208 struct f2fs_sb_info *sbi, char *buf) 209 { 210 return sprintf(buf, "%llu", SIT_I(sbi)->mounted_time); 211 } 212 213 #ifdef CONFIG_F2FS_STAT_FS 214 static ssize_t moved_blocks_foreground_show(struct f2fs_attr *a, 215 struct f2fs_sb_info *sbi, char *buf) 216 { 217 struct f2fs_stat_info *si = F2FS_STAT(sbi); 218 219 return sprintf(buf, "%llu\n", 220 (unsigned long long)(si->tot_blks - 221 (si->bg_data_blks + si->bg_node_blks))); 222 } 223 224 static ssize_t moved_blocks_background_show(struct f2fs_attr *a, 225 struct f2fs_sb_info *sbi, char *buf) 226 { 227 struct f2fs_stat_info *si = F2FS_STAT(sbi); 228 229 return sprintf(buf, "%llu\n", 230 (unsigned long long)(si->bg_data_blks + si->bg_node_blks)); 231 } 232 233 static ssize_t avg_vblocks_show(struct f2fs_attr *a, 234 struct f2fs_sb_info *sbi, char *buf) 235 { 236 struct f2fs_stat_info *si = F2FS_STAT(sbi); 237 238 si->dirty_count = dirty_segments(sbi); 239 f2fs_update_sit_info(sbi); 240 return sprintf(buf, "%llu\n", (unsigned long long)(si->avg_vblocks)); 241 } 242 #endif 243 244 static ssize_t main_blkaddr_show(struct f2fs_attr *a, 245 struct f2fs_sb_info *sbi, char *buf) 246 { 247 return snprintf(buf, PAGE_SIZE, "%llu\n", 248 (unsigned long long)MAIN_BLKADDR(sbi)); 249 } 250 251 static ssize_t f2fs_sbi_show(struct f2fs_attr *a, 252 struct f2fs_sb_info *sbi, char *buf) 253 { 254 unsigned char *ptr = NULL; 255 unsigned int *ui; 256 257 ptr = __struct_ptr(sbi, a->struct_type); 258 if (!ptr) 259 return -EINVAL; 260 261 if (!strcmp(a->attr.name, "extension_list")) { 262 __u8 (*extlist)[F2FS_EXTENSION_LEN] = 263 sbi->raw_super->extension_list; 264 int cold_count = le32_to_cpu(sbi->raw_super->extension_count); 265 int hot_count = sbi->raw_super->hot_ext_count; 266 int len = 0, i; 267 268 len += scnprintf(buf + len, PAGE_SIZE - len, 269 "cold file extension:\n"); 270 for (i = 0; i < cold_count; i++) 271 len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n", 272 extlist[i]); 273 274 len += scnprintf(buf + len, PAGE_SIZE - len, 275 "hot file extension:\n"); 276 for (i = cold_count; i < cold_count + hot_count; i++) 277 len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n", 278 extlist[i]); 279 return len; 280 } 281 282 if (!strcmp(a->attr.name, "ckpt_thread_ioprio")) { 283 struct ckpt_req_control *cprc = &sbi->cprc_info; 284 int len = 0; 285 int class = IOPRIO_PRIO_CLASS(cprc->ckpt_thread_ioprio); 286 int data = IOPRIO_PRIO_DATA(cprc->ckpt_thread_ioprio); 287 288 if (class == IOPRIO_CLASS_RT) 289 len += scnprintf(buf + len, PAGE_SIZE - len, "rt,"); 290 else if (class == IOPRIO_CLASS_BE) 291 len += scnprintf(buf + len, PAGE_SIZE - len, "be,"); 292 else 293 return -EINVAL; 294 295 len += scnprintf(buf + len, PAGE_SIZE - len, "%d\n", data); 296 return len; 297 } 298 299 #ifdef CONFIG_F2FS_FS_COMPRESSION 300 if (!strcmp(a->attr.name, "compr_written_block")) 301 return sysfs_emit(buf, "%llu\n", sbi->compr_written_block); 302 303 if (!strcmp(a->attr.name, "compr_saved_block")) 304 return sysfs_emit(buf, "%llu\n", sbi->compr_saved_block); 305 306 if (!strcmp(a->attr.name, "compr_new_inode")) 307 return sysfs_emit(buf, "%u\n", sbi->compr_new_inode); 308 #endif 309 310 ui = (unsigned int *)(ptr + a->offset); 311 312 return sprintf(buf, "%u\n", *ui); 313 } 314 315 static ssize_t __sbi_store(struct f2fs_attr *a, 316 struct f2fs_sb_info *sbi, 317 const char *buf, size_t count) 318 { 319 unsigned char *ptr; 320 unsigned long t; 321 unsigned int *ui; 322 ssize_t ret; 323 324 ptr = __struct_ptr(sbi, a->struct_type); 325 if (!ptr) 326 return -EINVAL; 327 328 if (!strcmp(a->attr.name, "extension_list")) { 329 const char *name = strim((char *)buf); 330 bool set = true, hot; 331 332 if (!strncmp(name, "[h]", 3)) 333 hot = true; 334 else if (!strncmp(name, "[c]", 3)) 335 hot = false; 336 else 337 return -EINVAL; 338 339 name += 3; 340 341 if (*name == '!') { 342 name++; 343 set = false; 344 } 345 346 if (strlen(name) >= F2FS_EXTENSION_LEN) 347 return -EINVAL; 348 349 down_write(&sbi->sb_lock); 350 351 ret = f2fs_update_extension_list(sbi, name, hot, set); 352 if (ret) 353 goto out; 354 355 ret = f2fs_commit_super(sbi, false); 356 if (ret) 357 f2fs_update_extension_list(sbi, name, hot, !set); 358 out: 359 up_write(&sbi->sb_lock); 360 return ret ? ret : count; 361 } 362 363 if (!strcmp(a->attr.name, "ckpt_thread_ioprio")) { 364 const char *name = strim((char *)buf); 365 struct ckpt_req_control *cprc = &sbi->cprc_info; 366 int class; 367 long data; 368 int ret; 369 370 if (!strncmp(name, "rt,", 3)) 371 class = IOPRIO_CLASS_RT; 372 else if (!strncmp(name, "be,", 3)) 373 class = IOPRIO_CLASS_BE; 374 else 375 return -EINVAL; 376 377 name += 3; 378 ret = kstrtol(name, 10, &data); 379 if (ret) 380 return ret; 381 if (data >= IOPRIO_BE_NR || data < 0) 382 return -EINVAL; 383 384 cprc->ckpt_thread_ioprio = IOPRIO_PRIO_VALUE(class, data); 385 if (test_opt(sbi, MERGE_CHECKPOINT)) { 386 ret = set_task_ioprio(cprc->f2fs_issue_ckpt, 387 cprc->ckpt_thread_ioprio); 388 if (ret) 389 return ret; 390 } 391 392 return count; 393 } 394 395 ui = (unsigned int *)(ptr + a->offset); 396 397 ret = kstrtoul(skip_spaces(buf), 0, &t); 398 if (ret < 0) 399 return ret; 400 #ifdef CONFIG_F2FS_FAULT_INJECTION 401 if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX)) 402 return -EINVAL; 403 if (a->struct_type == FAULT_INFO_RATE && t >= UINT_MAX) 404 return -EINVAL; 405 #endif 406 if (a->struct_type == RESERVED_BLOCKS) { 407 spin_lock(&sbi->stat_lock); 408 if (t > (unsigned long)(sbi->user_block_count - 409 F2FS_OPTION(sbi).root_reserved_blocks)) { 410 spin_unlock(&sbi->stat_lock); 411 return -EINVAL; 412 } 413 *ui = t; 414 sbi->current_reserved_blocks = min(sbi->reserved_blocks, 415 sbi->user_block_count - valid_user_blocks(sbi)); 416 spin_unlock(&sbi->stat_lock); 417 return count; 418 } 419 420 if (!strcmp(a->attr.name, "discard_granularity")) { 421 if (t == 0 || t > MAX_PLIST_NUM) 422 return -EINVAL; 423 if (t == *ui) 424 return count; 425 *ui = t; 426 return count; 427 } 428 429 if (!strcmp(a->attr.name, "migration_granularity")) { 430 if (t == 0 || t > sbi->segs_per_sec) 431 return -EINVAL; 432 } 433 434 if (!strcmp(a->attr.name, "trim_sections")) 435 return -EINVAL; 436 437 if (!strcmp(a->attr.name, "gc_urgent")) { 438 if (t == 0) { 439 sbi->gc_mode = GC_NORMAL; 440 } else if (t == 1) { 441 sbi->gc_mode = GC_URGENT_HIGH; 442 if (sbi->gc_thread) { 443 sbi->gc_thread->gc_wake = 1; 444 wake_up_interruptible_all( 445 &sbi->gc_thread->gc_wait_queue_head); 446 wake_up_discard_thread(sbi, true); 447 } 448 } else if (t == 2) { 449 sbi->gc_mode = GC_URGENT_LOW; 450 } else { 451 return -EINVAL; 452 } 453 return count; 454 } 455 if (!strcmp(a->attr.name, "gc_idle")) { 456 if (t == GC_IDLE_CB) { 457 sbi->gc_mode = GC_IDLE_CB; 458 } else if (t == GC_IDLE_GREEDY) { 459 sbi->gc_mode = GC_IDLE_GREEDY; 460 } else if (t == GC_IDLE_AT) { 461 if (!sbi->am.atgc_enabled) 462 return -EINVAL; 463 sbi->gc_mode = GC_AT; 464 } else { 465 sbi->gc_mode = GC_NORMAL; 466 } 467 return count; 468 } 469 470 if (!strcmp(a->attr.name, "iostat_enable")) { 471 sbi->iostat_enable = !!t; 472 if (!sbi->iostat_enable) 473 f2fs_reset_iostat(sbi); 474 return count; 475 } 476 477 if (!strcmp(a->attr.name, "iostat_period_ms")) { 478 if (t < MIN_IOSTAT_PERIOD_MS || t > MAX_IOSTAT_PERIOD_MS) 479 return -EINVAL; 480 spin_lock(&sbi->iostat_lock); 481 sbi->iostat_period_ms = (unsigned int)t; 482 spin_unlock(&sbi->iostat_lock); 483 return count; 484 } 485 486 #ifdef CONFIG_F2FS_FS_COMPRESSION 487 if (!strcmp(a->attr.name, "compr_written_block") || 488 !strcmp(a->attr.name, "compr_saved_block")) { 489 if (t != 0) 490 return -EINVAL; 491 sbi->compr_written_block = 0; 492 sbi->compr_saved_block = 0; 493 return count; 494 } 495 496 if (!strcmp(a->attr.name, "compr_new_inode")) { 497 if (t != 0) 498 return -EINVAL; 499 sbi->compr_new_inode = 0; 500 return count; 501 } 502 #endif 503 504 if (!strcmp(a->attr.name, "atgc_candidate_ratio")) { 505 if (t > 100) 506 return -EINVAL; 507 sbi->am.candidate_ratio = t; 508 return count; 509 } 510 511 if (!strcmp(a->attr.name, "atgc_age_weight")) { 512 if (t > 100) 513 return -EINVAL; 514 sbi->am.age_weight = t; 515 return count; 516 } 517 518 *ui = (unsigned int)t; 519 520 return count; 521 } 522 523 static ssize_t f2fs_sbi_store(struct f2fs_attr *a, 524 struct f2fs_sb_info *sbi, 525 const char *buf, size_t count) 526 { 527 ssize_t ret; 528 bool gc_entry = (!strcmp(a->attr.name, "gc_urgent") || 529 a->struct_type == GC_THREAD); 530 531 if (gc_entry) { 532 if (!down_read_trylock(&sbi->sb->s_umount)) 533 return -EAGAIN; 534 } 535 ret = __sbi_store(a, sbi, buf, count); 536 if (gc_entry) 537 up_read(&sbi->sb->s_umount); 538 539 return ret; 540 } 541 542 static ssize_t f2fs_attr_show(struct kobject *kobj, 543 struct attribute *attr, char *buf) 544 { 545 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 546 s_kobj); 547 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 548 549 return a->show ? a->show(a, sbi, buf) : 0; 550 } 551 552 static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr, 553 const char *buf, size_t len) 554 { 555 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 556 s_kobj); 557 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 558 559 return a->store ? a->store(a, sbi, buf, len) : 0; 560 } 561 562 static void f2fs_sb_release(struct kobject *kobj) 563 { 564 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 565 s_kobj); 566 complete(&sbi->s_kobj_unregister); 567 } 568 569 /* 570 * Note that there are three feature list entries: 571 * 1) /sys/fs/f2fs/features 572 * : shows runtime features supported by in-kernel f2fs along with Kconfig. 573 * - ref. F2FS_FEATURE_RO_ATTR() 574 * 575 * 2) /sys/fs/f2fs/$s_id/features <deprecated> 576 * : shows on-disk features enabled by mkfs.f2fs, used for old kernels. This 577 * won't add new feature anymore, and thus, users should check entries in 3) 578 * instead of this 2). 579 * 580 * 3) /sys/fs/f2fs/$s_id/feature_list 581 * : shows on-disk features enabled by mkfs.f2fs per instance, which follows 582 * sysfs entry rule where each entry should expose single value. 583 * This list covers old feature list provided by 2) and beyond. Therefore, 584 * please add new on-disk feature in this list only. 585 * - ref. F2FS_SB_FEATURE_RO_ATTR() 586 */ 587 static ssize_t f2fs_feature_show(struct f2fs_attr *a, 588 struct f2fs_sb_info *sbi, char *buf) 589 { 590 return sprintf(buf, "supported\n"); 591 } 592 593 #define F2FS_FEATURE_RO_ATTR(_name) \ 594 static struct f2fs_attr f2fs_attr_##_name = { \ 595 .attr = {.name = __stringify(_name), .mode = 0444 }, \ 596 .show = f2fs_feature_show, \ 597 } 598 599 static ssize_t f2fs_sb_feature_show(struct f2fs_attr *a, 600 struct f2fs_sb_info *sbi, char *buf) 601 { 602 if (F2FS_HAS_FEATURE(sbi, a->id)) 603 return sprintf(buf, "supported\n"); 604 return sprintf(buf, "unsupported\n"); 605 } 606 607 #define F2FS_SB_FEATURE_RO_ATTR(_name, _feat) \ 608 static struct f2fs_attr f2fs_attr_sb_##_name = { \ 609 .attr = {.name = __stringify(_name), .mode = 0444 }, \ 610 .show = f2fs_sb_feature_show, \ 611 .id = F2FS_FEATURE_##_feat, \ 612 } 613 614 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ 615 static struct f2fs_attr f2fs_attr_##_name = { \ 616 .attr = {.name = __stringify(_name), .mode = _mode }, \ 617 .show = _show, \ 618 .store = _store, \ 619 .struct_type = _struct_type, \ 620 .offset = _offset \ 621 } 622 623 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ 624 F2FS_ATTR_OFFSET(struct_type, name, 0644, \ 625 f2fs_sbi_show, f2fs_sbi_store, \ 626 offsetof(struct struct_name, elname)) 627 628 #define F2FS_GENERAL_RO_ATTR(name) \ 629 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL) 630 631 #define F2FS_STAT_ATTR(_struct_type, _struct_name, _name, _elname) \ 632 static struct f2fs_attr f2fs_attr_##_name = { \ 633 .attr = {.name = __stringify(_name), .mode = 0444 }, \ 634 .show = f2fs_sbi_show, \ 635 .struct_type = _struct_type, \ 636 .offset = offsetof(struct _struct_name, _elname), \ 637 } 638 639 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time, 640 urgent_sleep_time); 641 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time); 642 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time); 643 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time); 644 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode); 645 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode); 646 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments); 647 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards); 648 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity); 649 F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks); 650 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections); 651 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy); 652 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util); 653 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); 654 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks); 655 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks); 656 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections); 657 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh); 658 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages); 659 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); 660 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search); 661 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, migration_granularity, migration_granularity); 662 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level); 663 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]); 664 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]); 665 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval, 666 interval_time[DISCARD_TIME]); 667 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]); 668 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, 669 umount_discard_timeout, interval_time[UMOUNT_DISCARD_TIMEOUT]); 670 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable); 671 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_period_ms, iostat_period_ms); 672 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra); 673 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_io_bytes, max_io_bytes); 674 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold); 675 F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list); 676 #ifdef CONFIG_F2FS_FAULT_INJECTION 677 F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate); 678 F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type); 679 #endif 680 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag); 681 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag); 682 F2FS_RW_ATTR(CPRC_INFO, ckpt_req_control, ckpt_thread_ioprio, ckpt_thread_ioprio); 683 F2FS_GENERAL_RO_ATTR(dirty_segments); 684 F2FS_GENERAL_RO_ATTR(free_segments); 685 F2FS_GENERAL_RO_ATTR(ovp_segments); 686 F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes); 687 F2FS_GENERAL_RO_ATTR(features); 688 F2FS_GENERAL_RO_ATTR(current_reserved_blocks); 689 F2FS_GENERAL_RO_ATTR(unusable); 690 F2FS_GENERAL_RO_ATTR(encoding); 691 F2FS_GENERAL_RO_ATTR(mounted_time_sec); 692 F2FS_GENERAL_RO_ATTR(main_blkaddr); 693 #ifdef CONFIG_F2FS_STAT_FS 694 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_foreground_calls, cp_count); 695 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_background_calls, bg_cp_count); 696 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_foreground_calls, call_count); 697 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_background_calls, bg_gc); 698 F2FS_GENERAL_RO_ATTR(moved_blocks_background); 699 F2FS_GENERAL_RO_ATTR(moved_blocks_foreground); 700 F2FS_GENERAL_RO_ATTR(avg_vblocks); 701 #endif 702 703 #ifdef CONFIG_FS_ENCRYPTION 704 F2FS_FEATURE_RO_ATTR(encryption); 705 F2FS_FEATURE_RO_ATTR(test_dummy_encryption_v2); 706 #ifdef CONFIG_UNICODE 707 F2FS_FEATURE_RO_ATTR(encrypted_casefold); 708 #endif 709 #endif /* CONFIG_FS_ENCRYPTION */ 710 #ifdef CONFIG_BLK_DEV_ZONED 711 F2FS_FEATURE_RO_ATTR(block_zoned); 712 #endif 713 F2FS_FEATURE_RO_ATTR(atomic_write); 714 F2FS_FEATURE_RO_ATTR(extra_attr); 715 F2FS_FEATURE_RO_ATTR(project_quota); 716 F2FS_FEATURE_RO_ATTR(inode_checksum); 717 F2FS_FEATURE_RO_ATTR(flexible_inline_xattr); 718 F2FS_FEATURE_RO_ATTR(quota_ino); 719 F2FS_FEATURE_RO_ATTR(inode_crtime); 720 F2FS_FEATURE_RO_ATTR(lost_found); 721 #ifdef CONFIG_FS_VERITY 722 F2FS_FEATURE_RO_ATTR(verity); 723 #endif 724 F2FS_FEATURE_RO_ATTR(sb_checksum); 725 #ifdef CONFIG_UNICODE 726 F2FS_FEATURE_RO_ATTR(casefold); 727 #endif 728 F2FS_FEATURE_RO_ATTR(readonly); 729 #ifdef CONFIG_F2FS_FS_COMPRESSION 730 F2FS_FEATURE_RO_ATTR(compression); 731 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_written_block, compr_written_block); 732 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_saved_block, compr_saved_block); 733 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_new_inode, compr_new_inode); 734 #endif 735 F2FS_FEATURE_RO_ATTR(pin_file); 736 737 /* For ATGC */ 738 F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_candidate_ratio, candidate_ratio); 739 F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_candidate_count, max_candidate_count); 740 F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_age_weight, age_weight); 741 F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_age_threshold, age_threshold); 742 743 #define ATTR_LIST(name) (&f2fs_attr_##name.attr) 744 static struct attribute *f2fs_attrs[] = { 745 ATTR_LIST(gc_urgent_sleep_time), 746 ATTR_LIST(gc_min_sleep_time), 747 ATTR_LIST(gc_max_sleep_time), 748 ATTR_LIST(gc_no_gc_sleep_time), 749 ATTR_LIST(gc_idle), 750 ATTR_LIST(gc_urgent), 751 ATTR_LIST(reclaim_segments), 752 ATTR_LIST(main_blkaddr), 753 ATTR_LIST(max_small_discards), 754 ATTR_LIST(discard_granularity), 755 ATTR_LIST(batched_trim_sections), 756 ATTR_LIST(ipu_policy), 757 ATTR_LIST(min_ipu_util), 758 ATTR_LIST(min_fsync_blocks), 759 ATTR_LIST(min_seq_blocks), 760 ATTR_LIST(min_hot_blocks), 761 ATTR_LIST(min_ssr_sections), 762 ATTR_LIST(max_victim_search), 763 ATTR_LIST(migration_granularity), 764 ATTR_LIST(dir_level), 765 ATTR_LIST(ram_thresh), 766 ATTR_LIST(ra_nid_pages), 767 ATTR_LIST(dirty_nats_ratio), 768 ATTR_LIST(cp_interval), 769 ATTR_LIST(idle_interval), 770 ATTR_LIST(discard_idle_interval), 771 ATTR_LIST(gc_idle_interval), 772 ATTR_LIST(umount_discard_timeout), 773 ATTR_LIST(iostat_enable), 774 ATTR_LIST(iostat_period_ms), 775 ATTR_LIST(readdir_ra), 776 ATTR_LIST(max_io_bytes), 777 ATTR_LIST(gc_pin_file_thresh), 778 ATTR_LIST(extension_list), 779 #ifdef CONFIG_F2FS_FAULT_INJECTION 780 ATTR_LIST(inject_rate), 781 ATTR_LIST(inject_type), 782 #endif 783 ATTR_LIST(data_io_flag), 784 ATTR_LIST(node_io_flag), 785 ATTR_LIST(ckpt_thread_ioprio), 786 ATTR_LIST(dirty_segments), 787 ATTR_LIST(free_segments), 788 ATTR_LIST(ovp_segments), 789 ATTR_LIST(unusable), 790 ATTR_LIST(lifetime_write_kbytes), 791 ATTR_LIST(features), 792 ATTR_LIST(reserved_blocks), 793 ATTR_LIST(current_reserved_blocks), 794 ATTR_LIST(encoding), 795 ATTR_LIST(mounted_time_sec), 796 #ifdef CONFIG_F2FS_STAT_FS 797 ATTR_LIST(cp_foreground_calls), 798 ATTR_LIST(cp_background_calls), 799 ATTR_LIST(gc_foreground_calls), 800 ATTR_LIST(gc_background_calls), 801 ATTR_LIST(moved_blocks_foreground), 802 ATTR_LIST(moved_blocks_background), 803 ATTR_LIST(avg_vblocks), 804 #endif 805 #ifdef CONFIG_F2FS_FS_COMPRESSION 806 ATTR_LIST(compr_written_block), 807 ATTR_LIST(compr_saved_block), 808 ATTR_LIST(compr_new_inode), 809 #endif 810 /* For ATGC */ 811 ATTR_LIST(atgc_candidate_ratio), 812 ATTR_LIST(atgc_candidate_count), 813 ATTR_LIST(atgc_age_weight), 814 ATTR_LIST(atgc_age_threshold), 815 NULL, 816 }; 817 ATTRIBUTE_GROUPS(f2fs); 818 819 static struct attribute *f2fs_feat_attrs[] = { 820 #ifdef CONFIG_FS_ENCRYPTION 821 ATTR_LIST(encryption), 822 ATTR_LIST(test_dummy_encryption_v2), 823 #ifdef CONFIG_UNICODE 824 ATTR_LIST(encrypted_casefold), 825 #endif 826 #endif /* CONFIG_FS_ENCRYPTION */ 827 #ifdef CONFIG_BLK_DEV_ZONED 828 ATTR_LIST(block_zoned), 829 #endif 830 ATTR_LIST(atomic_write), 831 ATTR_LIST(extra_attr), 832 ATTR_LIST(project_quota), 833 ATTR_LIST(inode_checksum), 834 ATTR_LIST(flexible_inline_xattr), 835 ATTR_LIST(quota_ino), 836 ATTR_LIST(inode_crtime), 837 ATTR_LIST(lost_found), 838 #ifdef CONFIG_FS_VERITY 839 ATTR_LIST(verity), 840 #endif 841 ATTR_LIST(sb_checksum), 842 #ifdef CONFIG_UNICODE 843 ATTR_LIST(casefold), 844 #endif 845 ATTR_LIST(readonly), 846 #ifdef CONFIG_F2FS_FS_COMPRESSION 847 ATTR_LIST(compression), 848 #endif 849 ATTR_LIST(pin_file), 850 NULL, 851 }; 852 ATTRIBUTE_GROUPS(f2fs_feat); 853 854 F2FS_GENERAL_RO_ATTR(sb_status); 855 static struct attribute *f2fs_stat_attrs[] = { 856 ATTR_LIST(sb_status), 857 NULL, 858 }; 859 ATTRIBUTE_GROUPS(f2fs_stat); 860 861 F2FS_SB_FEATURE_RO_ATTR(encryption, ENCRYPT); 862 F2FS_SB_FEATURE_RO_ATTR(block_zoned, BLKZONED); 863 F2FS_SB_FEATURE_RO_ATTR(extra_attr, EXTRA_ATTR); 864 F2FS_SB_FEATURE_RO_ATTR(project_quota, PRJQUOTA); 865 F2FS_SB_FEATURE_RO_ATTR(inode_checksum, INODE_CHKSUM); 866 F2FS_SB_FEATURE_RO_ATTR(flexible_inline_xattr, FLEXIBLE_INLINE_XATTR); 867 F2FS_SB_FEATURE_RO_ATTR(quota_ino, QUOTA_INO); 868 F2FS_SB_FEATURE_RO_ATTR(inode_crtime, INODE_CRTIME); 869 F2FS_SB_FEATURE_RO_ATTR(lost_found, LOST_FOUND); 870 F2FS_SB_FEATURE_RO_ATTR(verity, VERITY); 871 F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM); 872 F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD); 873 F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION); 874 F2FS_SB_FEATURE_RO_ATTR(readonly, RO); 875 876 static struct attribute *f2fs_sb_feat_attrs[] = { 877 ATTR_LIST(sb_encryption), 878 ATTR_LIST(sb_block_zoned), 879 ATTR_LIST(sb_extra_attr), 880 ATTR_LIST(sb_project_quota), 881 ATTR_LIST(sb_inode_checksum), 882 ATTR_LIST(sb_flexible_inline_xattr), 883 ATTR_LIST(sb_quota_ino), 884 ATTR_LIST(sb_inode_crtime), 885 ATTR_LIST(sb_lost_found), 886 ATTR_LIST(sb_verity), 887 ATTR_LIST(sb_sb_checksum), 888 ATTR_LIST(sb_casefold), 889 ATTR_LIST(sb_compression), 890 ATTR_LIST(sb_readonly), 891 NULL, 892 }; 893 ATTRIBUTE_GROUPS(f2fs_sb_feat); 894 895 static const struct sysfs_ops f2fs_attr_ops = { 896 .show = f2fs_attr_show, 897 .store = f2fs_attr_store, 898 }; 899 900 static struct kobj_type f2fs_sb_ktype = { 901 .default_groups = f2fs_groups, 902 .sysfs_ops = &f2fs_attr_ops, 903 .release = f2fs_sb_release, 904 }; 905 906 static struct kobj_type f2fs_ktype = { 907 .sysfs_ops = &f2fs_attr_ops, 908 }; 909 910 static struct kset f2fs_kset = { 911 .kobj = {.ktype = &f2fs_ktype}, 912 }; 913 914 static struct kobj_type f2fs_feat_ktype = { 915 .default_groups = f2fs_feat_groups, 916 .sysfs_ops = &f2fs_attr_ops, 917 }; 918 919 static struct kobject f2fs_feat = { 920 .kset = &f2fs_kset, 921 }; 922 923 static ssize_t f2fs_stat_attr_show(struct kobject *kobj, 924 struct attribute *attr, char *buf) 925 { 926 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 927 s_stat_kobj); 928 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 929 930 return a->show ? a->show(a, sbi, buf) : 0; 931 } 932 933 static ssize_t f2fs_stat_attr_store(struct kobject *kobj, struct attribute *attr, 934 const char *buf, size_t len) 935 { 936 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 937 s_stat_kobj); 938 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 939 940 return a->store ? a->store(a, sbi, buf, len) : 0; 941 } 942 943 static void f2fs_stat_kobj_release(struct kobject *kobj) 944 { 945 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 946 s_stat_kobj); 947 complete(&sbi->s_stat_kobj_unregister); 948 } 949 950 static const struct sysfs_ops f2fs_stat_attr_ops = { 951 .show = f2fs_stat_attr_show, 952 .store = f2fs_stat_attr_store, 953 }; 954 955 static struct kobj_type f2fs_stat_ktype = { 956 .default_groups = f2fs_stat_groups, 957 .sysfs_ops = &f2fs_stat_attr_ops, 958 .release = f2fs_stat_kobj_release, 959 }; 960 961 static ssize_t f2fs_sb_feat_attr_show(struct kobject *kobj, 962 struct attribute *attr, char *buf) 963 { 964 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 965 s_feature_list_kobj); 966 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 967 968 return a->show ? a->show(a, sbi, buf) : 0; 969 } 970 971 static void f2fs_feature_list_kobj_release(struct kobject *kobj) 972 { 973 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 974 s_feature_list_kobj); 975 complete(&sbi->s_feature_list_kobj_unregister); 976 } 977 978 static const struct sysfs_ops f2fs_feature_list_attr_ops = { 979 .show = f2fs_sb_feat_attr_show, 980 }; 981 982 static struct kobj_type f2fs_feature_list_ktype = { 983 .default_groups = f2fs_sb_feat_groups, 984 .sysfs_ops = &f2fs_feature_list_attr_ops, 985 .release = f2fs_feature_list_kobj_release, 986 }; 987 988 static int __maybe_unused segment_info_seq_show(struct seq_file *seq, 989 void *offset) 990 { 991 struct super_block *sb = seq->private; 992 struct f2fs_sb_info *sbi = F2FS_SB(sb); 993 unsigned int total_segs = 994 le32_to_cpu(sbi->raw_super->segment_count_main); 995 int i; 996 997 seq_puts(seq, "format: segment_type|valid_blocks\n" 998 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 999 1000 for (i = 0; i < total_segs; i++) { 1001 struct seg_entry *se = get_seg_entry(sbi, i); 1002 1003 if ((i % 10) == 0) 1004 seq_printf(seq, "%-10d", i); 1005 seq_printf(seq, "%d|%-3u", se->type, se->valid_blocks); 1006 if ((i % 10) == 9 || i == (total_segs - 1)) 1007 seq_putc(seq, '\n'); 1008 else 1009 seq_putc(seq, ' '); 1010 } 1011 1012 return 0; 1013 } 1014 1015 static int __maybe_unused segment_bits_seq_show(struct seq_file *seq, 1016 void *offset) 1017 { 1018 struct super_block *sb = seq->private; 1019 struct f2fs_sb_info *sbi = F2FS_SB(sb); 1020 unsigned int total_segs = 1021 le32_to_cpu(sbi->raw_super->segment_count_main); 1022 int i, j; 1023 1024 seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n" 1025 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 1026 1027 for (i = 0; i < total_segs; i++) { 1028 struct seg_entry *se = get_seg_entry(sbi, i); 1029 1030 seq_printf(seq, "%-10d", i); 1031 seq_printf(seq, "%d|%-3u|", se->type, se->valid_blocks); 1032 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++) 1033 seq_printf(seq, " %.2x", se->cur_valid_map[j]); 1034 seq_putc(seq, '\n'); 1035 } 1036 return 0; 1037 } 1038 1039 void f2fs_record_iostat(struct f2fs_sb_info *sbi) 1040 { 1041 unsigned long long iostat_diff[NR_IO_TYPE]; 1042 int i; 1043 1044 if (time_is_after_jiffies(sbi->iostat_next_period)) 1045 return; 1046 1047 /* Need double check under the lock */ 1048 spin_lock(&sbi->iostat_lock); 1049 if (time_is_after_jiffies(sbi->iostat_next_period)) { 1050 spin_unlock(&sbi->iostat_lock); 1051 return; 1052 } 1053 sbi->iostat_next_period = jiffies + 1054 msecs_to_jiffies(sbi->iostat_period_ms); 1055 1056 for (i = 0; i < NR_IO_TYPE; i++) { 1057 iostat_diff[i] = sbi->rw_iostat[i] - 1058 sbi->prev_rw_iostat[i]; 1059 sbi->prev_rw_iostat[i] = sbi->rw_iostat[i]; 1060 } 1061 spin_unlock(&sbi->iostat_lock); 1062 1063 trace_f2fs_iostat(sbi, iostat_diff); 1064 } 1065 1066 static int __maybe_unused iostat_info_seq_show(struct seq_file *seq, 1067 void *offset) 1068 { 1069 struct super_block *sb = seq->private; 1070 struct f2fs_sb_info *sbi = F2FS_SB(sb); 1071 time64_t now = ktime_get_real_seconds(); 1072 1073 if (!sbi->iostat_enable) 1074 return 0; 1075 1076 seq_printf(seq, "time: %-16llu\n", now); 1077 1078 /* print app write IOs */ 1079 seq_puts(seq, "[WRITE]\n"); 1080 seq_printf(seq, "app buffered: %-16llu\n", 1081 sbi->rw_iostat[APP_BUFFERED_IO]); 1082 seq_printf(seq, "app direct: %-16llu\n", 1083 sbi->rw_iostat[APP_DIRECT_IO]); 1084 seq_printf(seq, "app mapped: %-16llu\n", 1085 sbi->rw_iostat[APP_MAPPED_IO]); 1086 1087 /* print fs write IOs */ 1088 seq_printf(seq, "fs data: %-16llu\n", 1089 sbi->rw_iostat[FS_DATA_IO]); 1090 seq_printf(seq, "fs node: %-16llu\n", 1091 sbi->rw_iostat[FS_NODE_IO]); 1092 seq_printf(seq, "fs meta: %-16llu\n", 1093 sbi->rw_iostat[FS_META_IO]); 1094 seq_printf(seq, "fs gc data: %-16llu\n", 1095 sbi->rw_iostat[FS_GC_DATA_IO]); 1096 seq_printf(seq, "fs gc node: %-16llu\n", 1097 sbi->rw_iostat[FS_GC_NODE_IO]); 1098 seq_printf(seq, "fs cp data: %-16llu\n", 1099 sbi->rw_iostat[FS_CP_DATA_IO]); 1100 seq_printf(seq, "fs cp node: %-16llu\n", 1101 sbi->rw_iostat[FS_CP_NODE_IO]); 1102 seq_printf(seq, "fs cp meta: %-16llu\n", 1103 sbi->rw_iostat[FS_CP_META_IO]); 1104 1105 /* print app read IOs */ 1106 seq_puts(seq, "[READ]\n"); 1107 seq_printf(seq, "app buffered: %-16llu\n", 1108 sbi->rw_iostat[APP_BUFFERED_READ_IO]); 1109 seq_printf(seq, "app direct: %-16llu\n", 1110 sbi->rw_iostat[APP_DIRECT_READ_IO]); 1111 seq_printf(seq, "app mapped: %-16llu\n", 1112 sbi->rw_iostat[APP_MAPPED_READ_IO]); 1113 1114 /* print fs read IOs */ 1115 seq_printf(seq, "fs data: %-16llu\n", 1116 sbi->rw_iostat[FS_DATA_READ_IO]); 1117 seq_printf(seq, "fs gc data: %-16llu\n", 1118 sbi->rw_iostat[FS_GDATA_READ_IO]); 1119 seq_printf(seq, "fs compr_data: %-16llu\n", 1120 sbi->rw_iostat[FS_CDATA_READ_IO]); 1121 seq_printf(seq, "fs node: %-16llu\n", 1122 sbi->rw_iostat[FS_NODE_READ_IO]); 1123 seq_printf(seq, "fs meta: %-16llu\n", 1124 sbi->rw_iostat[FS_META_READ_IO]); 1125 1126 /* print other IOs */ 1127 seq_puts(seq, "[OTHER]\n"); 1128 seq_printf(seq, "fs discard: %-16llu\n", 1129 sbi->rw_iostat[FS_DISCARD]); 1130 1131 return 0; 1132 } 1133 1134 static int __maybe_unused victim_bits_seq_show(struct seq_file *seq, 1135 void *offset) 1136 { 1137 struct super_block *sb = seq->private; 1138 struct f2fs_sb_info *sbi = F2FS_SB(sb); 1139 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 1140 int i; 1141 1142 seq_puts(seq, "format: victim_secmap bitmaps\n"); 1143 1144 for (i = 0; i < MAIN_SECS(sbi); i++) { 1145 if ((i % 10) == 0) 1146 seq_printf(seq, "%-10d", i); 1147 seq_printf(seq, "%d", test_bit(i, dirty_i->victim_secmap) ? 1 : 0); 1148 if ((i % 10) == 9 || i == (MAIN_SECS(sbi) - 1)) 1149 seq_putc(seq, '\n'); 1150 else 1151 seq_putc(seq, ' '); 1152 } 1153 return 0; 1154 } 1155 1156 int __init f2fs_init_sysfs(void) 1157 { 1158 int ret; 1159 1160 kobject_set_name(&f2fs_kset.kobj, "f2fs"); 1161 f2fs_kset.kobj.parent = fs_kobj; 1162 ret = kset_register(&f2fs_kset); 1163 if (ret) 1164 return ret; 1165 1166 ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype, 1167 NULL, "features"); 1168 if (ret) { 1169 kobject_put(&f2fs_feat); 1170 kset_unregister(&f2fs_kset); 1171 } else { 1172 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); 1173 } 1174 return ret; 1175 } 1176 1177 void f2fs_exit_sysfs(void) 1178 { 1179 kobject_put(&f2fs_feat); 1180 kset_unregister(&f2fs_kset); 1181 remove_proc_entry("fs/f2fs", NULL); 1182 f2fs_proc_root = NULL; 1183 } 1184 1185 int f2fs_register_sysfs(struct f2fs_sb_info *sbi) 1186 { 1187 struct super_block *sb = sbi->sb; 1188 int err; 1189 1190 sbi->s_kobj.kset = &f2fs_kset; 1191 init_completion(&sbi->s_kobj_unregister); 1192 err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL, 1193 "%s", sb->s_id); 1194 if (err) 1195 goto put_sb_kobj; 1196 1197 sbi->s_stat_kobj.kset = &f2fs_kset; 1198 init_completion(&sbi->s_stat_kobj_unregister); 1199 err = kobject_init_and_add(&sbi->s_stat_kobj, &f2fs_stat_ktype, 1200 &sbi->s_kobj, "stat"); 1201 if (err) 1202 goto put_stat_kobj; 1203 1204 sbi->s_feature_list_kobj.kset = &f2fs_kset; 1205 init_completion(&sbi->s_feature_list_kobj_unregister); 1206 err = kobject_init_and_add(&sbi->s_feature_list_kobj, 1207 &f2fs_feature_list_ktype, 1208 &sbi->s_kobj, "feature_list"); 1209 if (err) 1210 goto put_feature_list_kobj; 1211 1212 if (f2fs_proc_root) 1213 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root); 1214 1215 if (sbi->s_proc) { 1216 proc_create_single_data("segment_info", S_IRUGO, sbi->s_proc, 1217 segment_info_seq_show, sb); 1218 proc_create_single_data("segment_bits", S_IRUGO, sbi->s_proc, 1219 segment_bits_seq_show, sb); 1220 proc_create_single_data("iostat_info", S_IRUGO, sbi->s_proc, 1221 iostat_info_seq_show, sb); 1222 proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc, 1223 victim_bits_seq_show, sb); 1224 } 1225 return 0; 1226 put_feature_list_kobj: 1227 kobject_put(&sbi->s_feature_list_kobj); 1228 wait_for_completion(&sbi->s_feature_list_kobj_unregister); 1229 put_stat_kobj: 1230 kobject_put(&sbi->s_stat_kobj); 1231 wait_for_completion(&sbi->s_stat_kobj_unregister); 1232 put_sb_kobj: 1233 kobject_put(&sbi->s_kobj); 1234 wait_for_completion(&sbi->s_kobj_unregister); 1235 return err; 1236 } 1237 1238 void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi) 1239 { 1240 if (sbi->s_proc) { 1241 remove_proc_entry("iostat_info", sbi->s_proc); 1242 remove_proc_entry("segment_info", sbi->s_proc); 1243 remove_proc_entry("segment_bits", sbi->s_proc); 1244 remove_proc_entry("victim_bits", sbi->s_proc); 1245 remove_proc_entry(sbi->sb->s_id, f2fs_proc_root); 1246 } 1247 1248 kobject_del(&sbi->s_stat_kobj); 1249 kobject_put(&sbi->s_stat_kobj); 1250 wait_for_completion(&sbi->s_stat_kobj_unregister); 1251 kobject_del(&sbi->s_feature_list_kobj); 1252 kobject_put(&sbi->s_feature_list_kobj); 1253 wait_for_completion(&sbi->s_feature_list_kobj_unregister); 1254 1255 kobject_del(&sbi->s_kobj); 1256 kobject_put(&sbi->s_kobj); 1257 wait_for_completion(&sbi->s_kobj_unregister); 1258 } 1259