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