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