fs/f2fs/sysfs.c

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