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 enum feat_id { 570 FEAT_CRYPTO = 0, 571 FEAT_BLKZONED, 572 FEAT_ATOMIC_WRITE, 573 FEAT_EXTRA_ATTR, 574 FEAT_PROJECT_QUOTA, 575 FEAT_INODE_CHECKSUM, 576 FEAT_FLEXIBLE_INLINE_XATTR, 577 FEAT_QUOTA_INO, 578 FEAT_INODE_CRTIME, 579 FEAT_LOST_FOUND, 580 FEAT_VERITY, 581 FEAT_SB_CHECKSUM, 582 FEAT_CASEFOLD, 583 FEAT_COMPRESSION, 584 FEAT_RO, 585 FEAT_TEST_DUMMY_ENCRYPTION_V2, 586 }; 587 588 static ssize_t f2fs_feature_show(struct f2fs_attr *a, 589 struct f2fs_sb_info *sbi, char *buf) 590 { 591 switch (a->id) { 592 case FEAT_CRYPTO: 593 case FEAT_BLKZONED: 594 case FEAT_ATOMIC_WRITE: 595 case FEAT_EXTRA_ATTR: 596 case FEAT_PROJECT_QUOTA: 597 case FEAT_INODE_CHECKSUM: 598 case FEAT_FLEXIBLE_INLINE_XATTR: 599 case FEAT_QUOTA_INO: 600 case FEAT_INODE_CRTIME: 601 case FEAT_LOST_FOUND: 602 case FEAT_VERITY: 603 case FEAT_SB_CHECKSUM: 604 case FEAT_CASEFOLD: 605 case FEAT_COMPRESSION: 606 case FEAT_RO: 607 case FEAT_TEST_DUMMY_ENCRYPTION_V2: 608 return sprintf(buf, "supported\n"); 609 } 610 return 0; 611 } 612 613 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ 614 static struct f2fs_attr f2fs_attr_##_name = { \ 615 .attr = {.name = __stringify(_name), .mode = _mode }, \ 616 .show = _show, \ 617 .store = _store, \ 618 .struct_type = _struct_type, \ 619 .offset = _offset \ 620 } 621 622 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ 623 F2FS_ATTR_OFFSET(struct_type, name, 0644, \ 624 f2fs_sbi_show, f2fs_sbi_store, \ 625 offsetof(struct struct_name, elname)) 626 627 #define F2FS_GENERAL_RO_ATTR(name) \ 628 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL) 629 630 #define F2FS_FEATURE_RO_ATTR(_name, _id) \ 631 static struct f2fs_attr f2fs_attr_##_name = { \ 632 .attr = {.name = __stringify(_name), .mode = 0444 }, \ 633 .show = f2fs_feature_show, \ 634 .id = _id, \ 635 } 636 637 #define F2FS_STAT_ATTR(_struct_type, _struct_name, _name, _elname) \ 638 static struct f2fs_attr f2fs_attr_##_name = { \ 639 .attr = {.name = __stringify(_name), .mode = 0444 }, \ 640 .show = f2fs_sbi_show, \ 641 .struct_type = _struct_type, \ 642 .offset = offsetof(struct _struct_name, _elname), \ 643 } 644 645 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time, 646 urgent_sleep_time); 647 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time); 648 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time); 649 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time); 650 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode); 651 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode); 652 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments); 653 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards); 654 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity); 655 F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks); 656 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections); 657 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy); 658 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util); 659 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); 660 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks); 661 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks); 662 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections); 663 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh); 664 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages); 665 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); 666 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search); 667 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, migration_granularity, migration_granularity); 668 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level); 669 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]); 670 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]); 671 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval, 672 interval_time[DISCARD_TIME]); 673 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]); 674 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, 675 umount_discard_timeout, interval_time[UMOUNT_DISCARD_TIMEOUT]); 676 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable); 677 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_period_ms, iostat_period_ms); 678 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra); 679 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_io_bytes, max_io_bytes); 680 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold); 681 F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list); 682 #ifdef CONFIG_F2FS_FAULT_INJECTION 683 F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate); 684 F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type); 685 #endif 686 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag); 687 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag); 688 F2FS_RW_ATTR(CPRC_INFO, ckpt_req_control, ckpt_thread_ioprio, ckpt_thread_ioprio); 689 F2FS_GENERAL_RO_ATTR(dirty_segments); 690 F2FS_GENERAL_RO_ATTR(free_segments); 691 F2FS_GENERAL_RO_ATTR(ovp_segments); 692 F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes); 693 F2FS_GENERAL_RO_ATTR(features); 694 F2FS_GENERAL_RO_ATTR(current_reserved_blocks); 695 F2FS_GENERAL_RO_ATTR(unusable); 696 F2FS_GENERAL_RO_ATTR(encoding); 697 F2FS_GENERAL_RO_ATTR(mounted_time_sec); 698 F2FS_GENERAL_RO_ATTR(main_blkaddr); 699 #ifdef CONFIG_F2FS_STAT_FS 700 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_foreground_calls, cp_count); 701 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_background_calls, bg_cp_count); 702 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_foreground_calls, call_count); 703 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_background_calls, bg_gc); 704 F2FS_GENERAL_RO_ATTR(moved_blocks_background); 705 F2FS_GENERAL_RO_ATTR(moved_blocks_foreground); 706 F2FS_GENERAL_RO_ATTR(avg_vblocks); 707 #endif 708 709 #ifdef CONFIG_FS_ENCRYPTION 710 F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO); 711 F2FS_FEATURE_RO_ATTR(test_dummy_encryption_v2, FEAT_TEST_DUMMY_ENCRYPTION_V2); 712 #endif 713 #ifdef CONFIG_BLK_DEV_ZONED 714 F2FS_FEATURE_RO_ATTR(block_zoned, FEAT_BLKZONED); 715 #endif 716 F2FS_FEATURE_RO_ATTR(atomic_write, FEAT_ATOMIC_WRITE); 717 F2FS_FEATURE_RO_ATTR(extra_attr, FEAT_EXTRA_ATTR); 718 F2FS_FEATURE_RO_ATTR(project_quota, FEAT_PROJECT_QUOTA); 719 F2FS_FEATURE_RO_ATTR(inode_checksum, FEAT_INODE_CHECKSUM); 720 F2FS_FEATURE_RO_ATTR(flexible_inline_xattr, FEAT_FLEXIBLE_INLINE_XATTR); 721 F2FS_FEATURE_RO_ATTR(quota_ino, FEAT_QUOTA_INO); 722 F2FS_FEATURE_RO_ATTR(inode_crtime, FEAT_INODE_CRTIME); 723 F2FS_FEATURE_RO_ATTR(lost_found, FEAT_LOST_FOUND); 724 #ifdef CONFIG_FS_VERITY 725 F2FS_FEATURE_RO_ATTR(verity, FEAT_VERITY); 726 #endif 727 F2FS_FEATURE_RO_ATTR(sb_checksum, FEAT_SB_CHECKSUM); 728 F2FS_FEATURE_RO_ATTR(casefold, FEAT_CASEFOLD); 729 F2FS_FEATURE_RO_ATTR(readonly, FEAT_RO); 730 #ifdef CONFIG_F2FS_FS_COMPRESSION 731 F2FS_FEATURE_RO_ATTR(compression, FEAT_COMPRESSION); 732 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_written_block, compr_written_block); 733 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_saved_block, compr_saved_block); 734 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_new_inode, compr_new_inode); 735 #endif 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 #endif 824 #ifdef CONFIG_BLK_DEV_ZONED 825 ATTR_LIST(block_zoned), 826 #endif 827 ATTR_LIST(atomic_write), 828 ATTR_LIST(extra_attr), 829 ATTR_LIST(project_quota), 830 ATTR_LIST(inode_checksum), 831 ATTR_LIST(flexible_inline_xattr), 832 ATTR_LIST(quota_ino), 833 ATTR_LIST(inode_crtime), 834 ATTR_LIST(lost_found), 835 #ifdef CONFIG_FS_VERITY 836 ATTR_LIST(verity), 837 #endif 838 ATTR_LIST(sb_checksum), 839 ATTR_LIST(casefold), 840 ATTR_LIST(readonly), 841 #ifdef CONFIG_F2FS_FS_COMPRESSION 842 ATTR_LIST(compression), 843 #endif 844 NULL, 845 }; 846 ATTRIBUTE_GROUPS(f2fs_feat); 847 848 F2FS_GENERAL_RO_ATTR(sb_status); 849 static struct attribute *f2fs_stat_attrs[] = { 850 ATTR_LIST(sb_status), 851 NULL, 852 }; 853 ATTRIBUTE_GROUPS(f2fs_stat); 854 855 static const struct sysfs_ops f2fs_attr_ops = { 856 .show = f2fs_attr_show, 857 .store = f2fs_attr_store, 858 }; 859 860 static struct kobj_type f2fs_sb_ktype = { 861 .default_groups = f2fs_groups, 862 .sysfs_ops = &f2fs_attr_ops, 863 .release = f2fs_sb_release, 864 }; 865 866 static struct kobj_type f2fs_ktype = { 867 .sysfs_ops = &f2fs_attr_ops, 868 }; 869 870 static struct kset f2fs_kset = { 871 .kobj = {.ktype = &f2fs_ktype}, 872 }; 873 874 static struct kobj_type f2fs_feat_ktype = { 875 .default_groups = f2fs_feat_groups, 876 .sysfs_ops = &f2fs_attr_ops, 877 }; 878 879 static struct kobject f2fs_feat = { 880 .kset = &f2fs_kset, 881 }; 882 883 static ssize_t f2fs_stat_attr_show(struct kobject *kobj, 884 struct attribute *attr, char *buf) 885 { 886 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 887 s_stat_kobj); 888 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 889 890 return a->show ? a->show(a, sbi, buf) : 0; 891 } 892 893 static ssize_t f2fs_stat_attr_store(struct kobject *kobj, struct attribute *attr, 894 const char *buf, size_t len) 895 { 896 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 897 s_stat_kobj); 898 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 899 900 return a->store ? a->store(a, sbi, buf, len) : 0; 901 } 902 903 static void f2fs_stat_kobj_release(struct kobject *kobj) 904 { 905 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 906 s_stat_kobj); 907 complete(&sbi->s_stat_kobj_unregister); 908 } 909 910 static const struct sysfs_ops f2fs_stat_attr_ops = { 911 .show = f2fs_stat_attr_show, 912 .store = f2fs_stat_attr_store, 913 }; 914 915 static struct kobj_type f2fs_stat_ktype = { 916 .default_groups = f2fs_stat_groups, 917 .sysfs_ops = &f2fs_stat_attr_ops, 918 .release = f2fs_stat_kobj_release, 919 }; 920 921 static int __maybe_unused segment_info_seq_show(struct seq_file *seq, 922 void *offset) 923 { 924 struct super_block *sb = seq->private; 925 struct f2fs_sb_info *sbi = F2FS_SB(sb); 926 unsigned int total_segs = 927 le32_to_cpu(sbi->raw_super->segment_count_main); 928 int i; 929 930 seq_puts(seq, "format: segment_type|valid_blocks\n" 931 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 932 933 for (i = 0; i < total_segs; i++) { 934 struct seg_entry *se = get_seg_entry(sbi, i); 935 936 if ((i % 10) == 0) 937 seq_printf(seq, "%-10d", i); 938 seq_printf(seq, "%d|%-3u", se->type, se->valid_blocks); 939 if ((i % 10) == 9 || i == (total_segs - 1)) 940 seq_putc(seq, '\n'); 941 else 942 seq_putc(seq, ' '); 943 } 944 945 return 0; 946 } 947 948 static int __maybe_unused segment_bits_seq_show(struct seq_file *seq, 949 void *offset) 950 { 951 struct super_block *sb = seq->private; 952 struct f2fs_sb_info *sbi = F2FS_SB(sb); 953 unsigned int total_segs = 954 le32_to_cpu(sbi->raw_super->segment_count_main); 955 int i, j; 956 957 seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n" 958 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 959 960 for (i = 0; i < total_segs; i++) { 961 struct seg_entry *se = get_seg_entry(sbi, i); 962 963 seq_printf(seq, "%-10d", i); 964 seq_printf(seq, "%d|%-3u|", se->type, se->valid_blocks); 965 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++) 966 seq_printf(seq, " %.2x", se->cur_valid_map[j]); 967 seq_putc(seq, '\n'); 968 } 969 return 0; 970 } 971 972 void f2fs_record_iostat(struct f2fs_sb_info *sbi) 973 { 974 unsigned long long iostat_diff[NR_IO_TYPE]; 975 int i; 976 977 if (time_is_after_jiffies(sbi->iostat_next_period)) 978 return; 979 980 /* Need double check under the lock */ 981 spin_lock(&sbi->iostat_lock); 982 if (time_is_after_jiffies(sbi->iostat_next_period)) { 983 spin_unlock(&sbi->iostat_lock); 984 return; 985 } 986 sbi->iostat_next_period = jiffies + 987 msecs_to_jiffies(sbi->iostat_period_ms); 988 989 for (i = 0; i < NR_IO_TYPE; i++) { 990 iostat_diff[i] = sbi->rw_iostat[i] - 991 sbi->prev_rw_iostat[i]; 992 sbi->prev_rw_iostat[i] = sbi->rw_iostat[i]; 993 } 994 spin_unlock(&sbi->iostat_lock); 995 996 trace_f2fs_iostat(sbi, iostat_diff); 997 } 998 999 static int __maybe_unused iostat_info_seq_show(struct seq_file *seq, 1000 void *offset) 1001 { 1002 struct super_block *sb = seq->private; 1003 struct f2fs_sb_info *sbi = F2FS_SB(sb); 1004 time64_t now = ktime_get_real_seconds(); 1005 1006 if (!sbi->iostat_enable) 1007 return 0; 1008 1009 seq_printf(seq, "time: %-16llu\n", now); 1010 1011 /* print app write IOs */ 1012 seq_puts(seq, "[WRITE]\n"); 1013 seq_printf(seq, "app buffered: %-16llu\n", 1014 sbi->rw_iostat[APP_BUFFERED_IO]); 1015 seq_printf(seq, "app direct: %-16llu\n", 1016 sbi->rw_iostat[APP_DIRECT_IO]); 1017 seq_printf(seq, "app mapped: %-16llu\n", 1018 sbi->rw_iostat[APP_MAPPED_IO]); 1019 1020 /* print fs write IOs */ 1021 seq_printf(seq, "fs data: %-16llu\n", 1022 sbi->rw_iostat[FS_DATA_IO]); 1023 seq_printf(seq, "fs node: %-16llu\n", 1024 sbi->rw_iostat[FS_NODE_IO]); 1025 seq_printf(seq, "fs meta: %-16llu\n", 1026 sbi->rw_iostat[FS_META_IO]); 1027 seq_printf(seq, "fs gc data: %-16llu\n", 1028 sbi->rw_iostat[FS_GC_DATA_IO]); 1029 seq_printf(seq, "fs gc node: %-16llu\n", 1030 sbi->rw_iostat[FS_GC_NODE_IO]); 1031 seq_printf(seq, "fs cp data: %-16llu\n", 1032 sbi->rw_iostat[FS_CP_DATA_IO]); 1033 seq_printf(seq, "fs cp node: %-16llu\n", 1034 sbi->rw_iostat[FS_CP_NODE_IO]); 1035 seq_printf(seq, "fs cp meta: %-16llu\n", 1036 sbi->rw_iostat[FS_CP_META_IO]); 1037 1038 /* print app read IOs */ 1039 seq_puts(seq, "[READ]\n"); 1040 seq_printf(seq, "app buffered: %-16llu\n", 1041 sbi->rw_iostat[APP_BUFFERED_READ_IO]); 1042 seq_printf(seq, "app direct: %-16llu\n", 1043 sbi->rw_iostat[APP_DIRECT_READ_IO]); 1044 seq_printf(seq, "app mapped: %-16llu\n", 1045 sbi->rw_iostat[APP_MAPPED_READ_IO]); 1046 1047 /* print fs read IOs */ 1048 seq_printf(seq, "fs data: %-16llu\n", 1049 sbi->rw_iostat[FS_DATA_READ_IO]); 1050 seq_printf(seq, "fs gc data: %-16llu\n", 1051 sbi->rw_iostat[FS_GDATA_READ_IO]); 1052 seq_printf(seq, "fs compr_data: %-16llu\n", 1053 sbi->rw_iostat[FS_CDATA_READ_IO]); 1054 seq_printf(seq, "fs node: %-16llu\n", 1055 sbi->rw_iostat[FS_NODE_READ_IO]); 1056 seq_printf(seq, "fs meta: %-16llu\n", 1057 sbi->rw_iostat[FS_META_READ_IO]); 1058 1059 /* print other IOs */ 1060 seq_puts(seq, "[OTHER]\n"); 1061 seq_printf(seq, "fs discard: %-16llu\n", 1062 sbi->rw_iostat[FS_DISCARD]); 1063 1064 return 0; 1065 } 1066 1067 static int __maybe_unused victim_bits_seq_show(struct seq_file *seq, 1068 void *offset) 1069 { 1070 struct super_block *sb = seq->private; 1071 struct f2fs_sb_info *sbi = F2FS_SB(sb); 1072 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 1073 int i; 1074 1075 seq_puts(seq, "format: victim_secmap bitmaps\n"); 1076 1077 for (i = 0; i < MAIN_SECS(sbi); i++) { 1078 if ((i % 10) == 0) 1079 seq_printf(seq, "%-10d", i); 1080 seq_printf(seq, "%d", test_bit(i, dirty_i->victim_secmap) ? 1 : 0); 1081 if ((i % 10) == 9 || i == (MAIN_SECS(sbi) - 1)) 1082 seq_putc(seq, '\n'); 1083 else 1084 seq_putc(seq, ' '); 1085 } 1086 return 0; 1087 } 1088 1089 int __init f2fs_init_sysfs(void) 1090 { 1091 int ret; 1092 1093 kobject_set_name(&f2fs_kset.kobj, "f2fs"); 1094 f2fs_kset.kobj.parent = fs_kobj; 1095 ret = kset_register(&f2fs_kset); 1096 if (ret) 1097 return ret; 1098 1099 ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype, 1100 NULL, "features"); 1101 if (ret) { 1102 kobject_put(&f2fs_feat); 1103 kset_unregister(&f2fs_kset); 1104 } else { 1105 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); 1106 } 1107 return ret; 1108 } 1109 1110 void f2fs_exit_sysfs(void) 1111 { 1112 kobject_put(&f2fs_feat); 1113 kset_unregister(&f2fs_kset); 1114 remove_proc_entry("fs/f2fs", NULL); 1115 f2fs_proc_root = NULL; 1116 } 1117 1118 int f2fs_register_sysfs(struct f2fs_sb_info *sbi) 1119 { 1120 struct super_block *sb = sbi->sb; 1121 int err; 1122 1123 sbi->s_kobj.kset = &f2fs_kset; 1124 init_completion(&sbi->s_kobj_unregister); 1125 err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL, 1126 "%s", sb->s_id); 1127 if (err) 1128 goto put_sb_kobj; 1129 1130 sbi->s_stat_kobj.kset = &f2fs_kset; 1131 init_completion(&sbi->s_stat_kobj_unregister); 1132 err = kobject_init_and_add(&sbi->s_stat_kobj, &f2fs_stat_ktype, 1133 &sbi->s_kobj, "stat"); 1134 if (err) 1135 goto put_stat_kobj; 1136 1137 if (f2fs_proc_root) 1138 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root); 1139 1140 if (sbi->s_proc) { 1141 proc_create_single_data("segment_info", S_IRUGO, sbi->s_proc, 1142 segment_info_seq_show, sb); 1143 proc_create_single_data("segment_bits", S_IRUGO, sbi->s_proc, 1144 segment_bits_seq_show, sb); 1145 proc_create_single_data("iostat_info", S_IRUGO, sbi->s_proc, 1146 iostat_info_seq_show, sb); 1147 proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc, 1148 victim_bits_seq_show, sb); 1149 } 1150 return 0; 1151 put_stat_kobj: 1152 kobject_put(&sbi->s_stat_kobj); 1153 wait_for_completion(&sbi->s_stat_kobj_unregister); 1154 put_sb_kobj: 1155 kobject_put(&sbi->s_kobj); 1156 wait_for_completion(&sbi->s_kobj_unregister); 1157 return err; 1158 } 1159 1160 void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi) 1161 { 1162 if (sbi->s_proc) { 1163 remove_proc_entry("iostat_info", sbi->s_proc); 1164 remove_proc_entry("segment_info", sbi->s_proc); 1165 remove_proc_entry("segment_bits", sbi->s_proc); 1166 remove_proc_entry("victim_bits", sbi->s_proc); 1167 remove_proc_entry(sbi->sb->s_id, f2fs_proc_root); 1168 } 1169 1170 kobject_del(&sbi->s_stat_kobj); 1171 kobject_put(&sbi->s_stat_kobj); 1172 wait_for_completion(&sbi->s_stat_kobj_unregister); 1173 1174 kobject_del(&sbi->s_kobj); 1175 kobject_put(&sbi->s_kobj); 1176 wait_for_completion(&sbi->s_kobj_unregister); 1177 } 1178