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 f2fs_sbi_show(struct f2fs_attr *a,
 227                         struct f2fs_sb_info *sbi, char *buf)
 228 {
 229         unsigned char *ptr = NULL;
 230         unsigned int *ui;
 231
 232         ptr = __struct_ptr(sbi, a->struct_type);
 233         if (!ptr)
 234                 return -EINVAL;
 235
 236         if (!strcmp(a->attr.name, "extension_list")) {
 237                 __u8 (*extlist)[F2FS_EXTENSION_LEN] =
 238                                         sbi->raw_super->extension_list;
 239                 int cold_count = le32_to_cpu(sbi->raw_super->extension_count);
 240                 int hot_count = sbi->raw_super->hot_ext_count;
 241                 int len = 0, i;
 242
 243                 len += scnprintf(buf + len, PAGE_SIZE - len,
 244                                                 "cold file extension:\n");
 245                 for (i = 0; i < cold_count; i++)
 246                         len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n",
 247                                                                 extlist[i]);
 248
 249                 len += scnprintf(buf + len, PAGE_SIZE - len,
 250                                                 "hot file extension:\n");
 251                 for (i = cold_count; i < cold_count + hot_count; i++)
 252                         len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n",
 253                                                                 extlist[i]);
 254                 return len;
 255         }
 256
 257         ui = (unsigned int *)(ptr + a->offset);
 258
 259         return sprintf(buf, "%u\n", *ui);
 260 }
 261
 262 static ssize_t __sbi_store(struct f2fs_attr *a,
 263                         struct f2fs_sb_info *sbi,
 264                         const char *buf, size_t count)
 265 {
 266         unsigned char *ptr;
 267         unsigned long t;
 268         unsigned int *ui;
 269         ssize_t ret;
 270
 271         ptr = __struct_ptr(sbi, a->struct_type);
 272         if (!ptr)
 273                 return -EINVAL;
 274
 275         if (!strcmp(a->attr.name, "extension_list")) {
 276                 const char *name = strim((char *)buf);
 277                 bool set = true, hot;
 278
 279                 if (!strncmp(name, "[h]", 3))
 280                         hot = true;
 281                 else if (!strncmp(name, "[c]", 3))
 282                         hot = false;
 283                 else
 284                         return -EINVAL;
 285
 286                 name += 3;
 287
 288                 if (*name == '!') {
 289                         name++;
 290                         set = false;
 291                 }
 292
 293                 if (strlen(name) >= F2FS_EXTENSION_LEN)
 294                         return -EINVAL;
 295
 296                 down_write(&sbi->sb_lock);
 297
 298                 ret = f2fs_update_extension_list(sbi, name, hot, set);
 299                 if (ret)
 300                         goto out;
 301
 302                 ret = f2fs_commit_super(sbi, false);
 303                 if (ret)
 304                         f2fs_update_extension_list(sbi, name, hot, !set);
 305 out:
 306                 up_write(&sbi->sb_lock);
 307                 return ret ? ret : count;
 308         }
 309
 310         ui = (unsigned int *)(ptr + a->offset);
 311
 312         ret = kstrtoul(skip_spaces(buf), 0, &t);
 313         if (ret < 0)
 314                 return ret;
 315 #ifdef CONFIG_F2FS_FAULT_INJECTION
 316         if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX))
 317                 return -EINVAL;
 318         if (a->struct_type == FAULT_INFO_RATE && t >= UINT_MAX)
 319                 return -EINVAL;
 320 #endif
 321         if (a->struct_type == RESERVED_BLOCKS) {
 322                 spin_lock(&sbi->stat_lock);
 323                 if (t > (unsigned long)(sbi->user_block_count -
 324                                 F2FS_OPTION(sbi).root_reserved_blocks)) {
 325                         spin_unlock(&sbi->stat_lock);
 326                         return -EINVAL;
 327                 }
 328                 *ui = t;
 329                 sbi->current_reserved_blocks = min(sbi->reserved_blocks,
 330                                 sbi->user_block_count - valid_user_blocks(sbi));
 331                 spin_unlock(&sbi->stat_lock);
 332                 return count;
 333         }
 334
 335         if (!strcmp(a->attr.name, "discard_granularity")) {
 336                 if (t == 0 || t > MAX_PLIST_NUM)
 337                         return -EINVAL;
 338                 if (t == *ui)
 339                         return count;
 340                 *ui = t;
 341                 return count;
 342         }
 343
 344         if (!strcmp(a->attr.name, "migration_granularity")) {
 345                 if (t == 0 || t > sbi->segs_per_sec)
 346                         return -EINVAL;
 347         }
 348
 349         if (!strcmp(a->attr.name, "trim_sections"))
 350                 return -EINVAL;
 351
 352         if (!strcmp(a->attr.name, "gc_urgent")) {
 353                 if (t >= 1) {
 354                         sbi->gc_mode = GC_URGENT;
 355                         if (sbi->gc_thread) {
 356                                 sbi->gc_thread->gc_wake = 1;
 357                                 wake_up_interruptible_all(
 358                                         &sbi->gc_thread->gc_wait_queue_head);
 359                                 wake_up_discard_thread(sbi, true);
 360                         }
 361                 } else {
 362                         sbi->gc_mode = GC_NORMAL;
 363                 }
 364                 return count;
 365         }
 366         if (!strcmp(a->attr.name, "gc_idle")) {
 367                 if (t == GC_IDLE_CB)
 368                         sbi->gc_mode = GC_IDLE_CB;
 369                 else if (t == GC_IDLE_GREEDY)
 370                         sbi->gc_mode = GC_IDLE_GREEDY;
 371                 else
 372                         sbi->gc_mode = GC_NORMAL;
 373                 return count;
 374         }
 375
 376         if (!strcmp(a->attr.name, "iostat_enable")) {
 377                 sbi->iostat_enable = !!t;
 378                 if (!sbi->iostat_enable)
 379                         f2fs_reset_iostat(sbi);
 380                 return count;
 381         }
 382
 383         if (!strcmp(a->attr.name, "iostat_period_ms")) {
 384                 if (t < MIN_IOSTAT_PERIOD_MS || t > MAX_IOSTAT_PERIOD_MS)
 385                         return -EINVAL;
 386                 spin_lock(&sbi->iostat_lock);
 387                 sbi->iostat_period_ms = (unsigned int)t;
 388                 spin_unlock(&sbi->iostat_lock);
 389                 return count;
 390         }
 391
 392         *ui = (unsigned int)t;
 393
 394         return count;
 395 }
 396
 397 static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
 398                         struct f2fs_sb_info *sbi,
 399                         const char *buf, size_t count)
 400 {
 401         ssize_t ret;
 402         bool gc_entry = (!strcmp(a->attr.name, "gc_urgent") ||
 403                                         a->struct_type == GC_THREAD);
 404
 405         if (gc_entry) {
 406                 if (!down_read_trylock(&sbi->sb->s_umount))
 407                         return -EAGAIN;
 408         }
 409         ret = __sbi_store(a, sbi, buf, count);
 410         if (gc_entry)
 411                 up_read(&sbi->sb->s_umount);
 412
 413         return ret;
 414 }
 415
 416 static ssize_t f2fs_attr_show(struct kobject *kobj,
 417                                 struct attribute *attr, char *buf)
 418 {
 419         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
 420                                                                 s_kobj);
 421         struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
 422
 423         return a->show ? a->show(a, sbi, buf) : 0;
 424 }
 425
 426 static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr,
 427                                                 const char *buf, size_t len)
 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->store ? a->store(a, sbi, buf, len) : 0;
 434 }
 435
 436 static void f2fs_sb_release(struct kobject *kobj)
 437 {
 438         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
 439                                                                 s_kobj);
 440         complete(&sbi->s_kobj_unregister);
 441 }
 442
 443 enum feat_id {
 444         FEAT_CRYPTO = 0,
 445         FEAT_BLKZONED,
 446         FEAT_ATOMIC_WRITE,
 447         FEAT_EXTRA_ATTR,
 448         FEAT_PROJECT_QUOTA,
 449         FEAT_INODE_CHECKSUM,
 450         FEAT_FLEXIBLE_INLINE_XATTR,
 451         FEAT_QUOTA_INO,
 452         FEAT_INODE_CRTIME,
 453         FEAT_LOST_FOUND,
 454         FEAT_VERITY,
 455         FEAT_SB_CHECKSUM,
 456         FEAT_CASEFOLD,
 457         FEAT_COMPRESSION,
 458         FEAT_TEST_DUMMY_ENCRYPTION_V2,
 459 };
 460
 461 static ssize_t f2fs_feature_show(struct f2fs_attr *a,
 462                 struct f2fs_sb_info *sbi, char *buf)
 463 {
 464         switch (a->id) {
 465         case FEAT_CRYPTO:
 466         case FEAT_BLKZONED:
 467         case FEAT_ATOMIC_WRITE:
 468         case FEAT_EXTRA_ATTR:
 469         case FEAT_PROJECT_QUOTA:
 470         case FEAT_INODE_CHECKSUM:
 471         case FEAT_FLEXIBLE_INLINE_XATTR:
 472         case FEAT_QUOTA_INO:
 473         case FEAT_INODE_CRTIME:
 474         case FEAT_LOST_FOUND:
 475         case FEAT_VERITY:
 476         case FEAT_SB_CHECKSUM:
 477         case FEAT_CASEFOLD:
 478         case FEAT_COMPRESSION:
 479         case FEAT_TEST_DUMMY_ENCRYPTION_V2:
 480                 return sprintf(buf, "supported\n");
 481         }
 482         return 0;
 483 }
 484
 485 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
 486 static struct f2fs_attr f2fs_attr_##_name = {                   \
 487         .attr = {.name = __stringify(_name), .mode = _mode },   \
 488         .show   = _show,                                        \
 489         .store  = _store,                                       \
 490         .struct_type = _struct_type,                            \
 491         .offset = _offset                                       \
 492 }
 493
 494 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname)    \
 495         F2FS_ATTR_OFFSET(struct_type, name, 0644,               \
 496                 f2fs_sbi_show, f2fs_sbi_store,                  \
 497                 offsetof(struct struct_name, elname))
 498
 499 #define F2FS_GENERAL_RO_ATTR(name) \
 500 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)
 501
 502 #define F2FS_FEATURE_RO_ATTR(_name, _id)                        \
 503 static struct f2fs_attr f2fs_attr_##_name = {                   \
 504         .attr = {.name = __stringify(_name), .mode = 0444 },    \
 505         .show   = f2fs_feature_show,                            \
 506         .id     = _id,                                          \
 507 }
 508
 509 #define F2FS_STAT_ATTR(_struct_type, _struct_name, _name, _elname)      \
 510 static struct f2fs_attr f2fs_attr_##_name = {                   \
 511         .attr = {.name = __stringify(_name), .mode = 0444 },    \
 512         .show = f2fs_sbi_show,                                  \
 513         .struct_type = _struct_type,                            \
 514         .offset = offsetof(struct _struct_name, _elname),       \
 515 }
 516
 517 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time,
 518                                                         urgent_sleep_time);
 519 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
 520 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
 521 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
 522 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode);
 523 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode);
 524 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
 525 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, main_blkaddr, main_blkaddr);
 526 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards);
 527 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity);
 528 F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks);
 529 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
 530 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
 531 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
 532 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
 533 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks);
 534 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks);
 535 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);
 536 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
 537 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
 538 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio);
 539 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
 540 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, migration_granularity, migration_granularity);
 541 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
 542 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
 543 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
 544 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval,
 545                                         interval_time[DISCARD_TIME]);
 546 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]);
 547 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info,
 548                 umount_discard_timeout, interval_time[UMOUNT_DISCARD_TIMEOUT]);
 549 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable);
 550 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_period_ms, iostat_period_ms);
 551 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra);
 552 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold);
 553 F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list);
 554 #ifdef CONFIG_F2FS_FAULT_INJECTION
 555 F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate);
 556 F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type);
 557 #endif
 558 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag);
 559 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag);
 560 F2FS_GENERAL_RO_ATTR(dirty_segments);
 561 F2FS_GENERAL_RO_ATTR(free_segments);
 562 F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes);
 563 F2FS_GENERAL_RO_ATTR(features);
 564 F2FS_GENERAL_RO_ATTR(current_reserved_blocks);
 565 F2FS_GENERAL_RO_ATTR(unusable);
 566 F2FS_GENERAL_RO_ATTR(encoding);
 567 F2FS_GENERAL_RO_ATTR(mounted_time_sec);
 568 #ifdef CONFIG_F2FS_STAT_FS
 569 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_foreground_calls, cp_count);
 570 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_background_calls, bg_cp_count);
 571 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_foreground_calls, call_count);
 572 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_background_calls, bg_gc);
 573 F2FS_GENERAL_RO_ATTR(moved_blocks_background);
 574 F2FS_GENERAL_RO_ATTR(moved_blocks_foreground);
 575 F2FS_GENERAL_RO_ATTR(avg_vblocks);
 576 #endif
 577
 578 #ifdef CONFIG_FS_ENCRYPTION
 579 F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO);
 580 F2FS_FEATURE_RO_ATTR(test_dummy_encryption_v2, FEAT_TEST_DUMMY_ENCRYPTION_V2);
 581 #endif
 582 #ifdef CONFIG_BLK_DEV_ZONED
 583 F2FS_FEATURE_RO_ATTR(block_zoned, FEAT_BLKZONED);
 584 #endif
 585 F2FS_FEATURE_RO_ATTR(atomic_write, FEAT_ATOMIC_WRITE);
 586 F2FS_FEATURE_RO_ATTR(extra_attr, FEAT_EXTRA_ATTR);
 587 F2FS_FEATURE_RO_ATTR(project_quota, FEAT_PROJECT_QUOTA);
 588 F2FS_FEATURE_RO_ATTR(inode_checksum, FEAT_INODE_CHECKSUM);
 589 F2FS_FEATURE_RO_ATTR(flexible_inline_xattr, FEAT_FLEXIBLE_INLINE_XATTR);
 590 F2FS_FEATURE_RO_ATTR(quota_ino, FEAT_QUOTA_INO);
 591 F2FS_FEATURE_RO_ATTR(inode_crtime, FEAT_INODE_CRTIME);
 592 F2FS_FEATURE_RO_ATTR(lost_found, FEAT_LOST_FOUND);
 593 #ifdef CONFIG_FS_VERITY
 594 F2FS_FEATURE_RO_ATTR(verity, FEAT_VERITY);
 595 #endif
 596 F2FS_FEATURE_RO_ATTR(sb_checksum, FEAT_SB_CHECKSUM);
 597 F2FS_FEATURE_RO_ATTR(casefold, FEAT_CASEFOLD);
 598 #ifdef CONFIG_F2FS_FS_COMPRESSION
 599 F2FS_FEATURE_RO_ATTR(compression, FEAT_COMPRESSION);
 600 #endif
 601
 602 #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
 603 static struct attribute *f2fs_attrs[] = {
 604         ATTR_LIST(gc_urgent_sleep_time),
 605         ATTR_LIST(gc_min_sleep_time),
 606         ATTR_LIST(gc_max_sleep_time),
 607         ATTR_LIST(gc_no_gc_sleep_time),
 608         ATTR_LIST(gc_idle),
 609         ATTR_LIST(gc_urgent),
 610         ATTR_LIST(reclaim_segments),
 611         ATTR_LIST(main_blkaddr),
 612         ATTR_LIST(max_small_discards),
 613         ATTR_LIST(discard_granularity),
 614         ATTR_LIST(batched_trim_sections),
 615         ATTR_LIST(ipu_policy),
 616         ATTR_LIST(min_ipu_util),
 617         ATTR_LIST(min_fsync_blocks),
 618         ATTR_LIST(min_seq_blocks),
 619         ATTR_LIST(min_hot_blocks),
 620         ATTR_LIST(min_ssr_sections),
 621         ATTR_LIST(max_victim_search),
 622         ATTR_LIST(migration_granularity),
 623         ATTR_LIST(dir_level),
 624         ATTR_LIST(ram_thresh),
 625         ATTR_LIST(ra_nid_pages),
 626         ATTR_LIST(dirty_nats_ratio),
 627         ATTR_LIST(cp_interval),
 628         ATTR_LIST(idle_interval),
 629         ATTR_LIST(discard_idle_interval),
 630         ATTR_LIST(gc_idle_interval),
 631         ATTR_LIST(umount_discard_timeout),
 632         ATTR_LIST(iostat_enable),
 633         ATTR_LIST(iostat_period_ms),
 634         ATTR_LIST(readdir_ra),
 635         ATTR_LIST(gc_pin_file_thresh),
 636         ATTR_LIST(extension_list),
 637 #ifdef CONFIG_F2FS_FAULT_INJECTION
 638         ATTR_LIST(inject_rate),
 639         ATTR_LIST(inject_type),
 640 #endif
 641         ATTR_LIST(data_io_flag),
 642         ATTR_LIST(node_io_flag),
 643         ATTR_LIST(dirty_segments),
 644         ATTR_LIST(free_segments),
 645         ATTR_LIST(unusable),
 646         ATTR_LIST(lifetime_write_kbytes),
 647         ATTR_LIST(features),
 648         ATTR_LIST(reserved_blocks),
 649         ATTR_LIST(current_reserved_blocks),
 650         ATTR_LIST(encoding),
 651         ATTR_LIST(mounted_time_sec),
 652 #ifdef CONFIG_F2FS_STAT_FS
 653         ATTR_LIST(cp_foreground_calls),
 654         ATTR_LIST(cp_background_calls),
 655         ATTR_LIST(gc_foreground_calls),
 656         ATTR_LIST(gc_background_calls),
 657         ATTR_LIST(moved_blocks_foreground),
 658         ATTR_LIST(moved_blocks_background),
 659         ATTR_LIST(avg_vblocks),
 660 #endif
 661         NULL,
 662 };
 663 ATTRIBUTE_GROUPS(f2fs);
 664
 665 static struct attribute *f2fs_feat_attrs[] = {
 666 #ifdef CONFIG_FS_ENCRYPTION
 667         ATTR_LIST(encryption),
 668         ATTR_LIST(test_dummy_encryption_v2),
 669 #endif
 670 #ifdef CONFIG_BLK_DEV_ZONED
 671         ATTR_LIST(block_zoned),
 672 #endif
 673         ATTR_LIST(atomic_write),
 674         ATTR_LIST(extra_attr),
 675         ATTR_LIST(project_quota),
 676         ATTR_LIST(inode_checksum),
 677         ATTR_LIST(flexible_inline_xattr),
 678         ATTR_LIST(quota_ino),
 679         ATTR_LIST(inode_crtime),
 680         ATTR_LIST(lost_found),
 681 #ifdef CONFIG_FS_VERITY
 682         ATTR_LIST(verity),
 683 #endif
 684         ATTR_LIST(sb_checksum),
 685         ATTR_LIST(casefold),
 686 #ifdef CONFIG_F2FS_FS_COMPRESSION
 687         ATTR_LIST(compression),
 688 #endif
 689         NULL,
 690 };
 691 ATTRIBUTE_GROUPS(f2fs_feat);
 692
 693 static const struct sysfs_ops f2fs_attr_ops = {
 694         .show   = f2fs_attr_show,
 695         .store  = f2fs_attr_store,
 696 };
 697
 698 static struct kobj_type f2fs_sb_ktype = {
 699         .default_groups = f2fs_groups,
 700         .sysfs_ops      = &f2fs_attr_ops,
 701         .release        = f2fs_sb_release,
 702 };
 703
 704 static struct kobj_type f2fs_ktype = {
 705         .sysfs_ops      = &f2fs_attr_ops,
 706 };
 707
 708 static struct kset f2fs_kset = {
 709         .kobj   = {.ktype = &f2fs_ktype},
 710 };
 711
 712 static struct kobj_type f2fs_feat_ktype = {
 713         .default_groups = f2fs_feat_groups,
 714         .sysfs_ops      = &f2fs_attr_ops,
 715 };
 716
 717 static struct kobject f2fs_feat = {
 718         .kset   = &f2fs_kset,
 719 };
 720
 721 static int __maybe_unused segment_info_seq_show(struct seq_file *seq,
 722                                                 void *offset)
 723 {
 724         struct super_block *sb = seq->private;
 725         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 726         unsigned int total_segs =
 727                         le32_to_cpu(sbi->raw_super->segment_count_main);
 728         int i;
 729
 730         seq_puts(seq, "format: segment_type|valid_blocks\n"
 731                 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
 732
 733         for (i = 0; i < total_segs; i++) {
 734                 struct seg_entry *se = get_seg_entry(sbi, i);
 735
 736                 if ((i % 10) == 0)
 737                         seq_printf(seq, "%-10d", i);
 738                 seq_printf(seq, "%d|%-3u", se->type, se->valid_blocks);
 739                 if ((i % 10) == 9 || i == (total_segs - 1))
 740                         seq_putc(seq, '\n');
 741                 else
 742                         seq_putc(seq, ' ');
 743         }
 744
 745         return 0;
 746 }
 747
 748 static int __maybe_unused segment_bits_seq_show(struct seq_file *seq,
 749                                                 void *offset)
 750 {
 751         struct super_block *sb = seq->private;
 752         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 753         unsigned int total_segs =
 754                         le32_to_cpu(sbi->raw_super->segment_count_main);
 755         int i, j;
 756
 757         seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n"
 758                 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
 759
 760         for (i = 0; i < total_segs; i++) {
 761                 struct seg_entry *se = get_seg_entry(sbi, i);
 762
 763                 seq_printf(seq, "%-10d", i);
 764                 seq_printf(seq, "%d|%-3u|", se->type, se->valid_blocks);
 765                 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++)
 766                         seq_printf(seq, " %.2x", se->cur_valid_map[j]);
 767                 seq_putc(seq, '\n');
 768         }
 769         return 0;
 770 }
 771
 772 void f2fs_record_iostat(struct f2fs_sb_info *sbi)
 773 {
 774         unsigned long long iostat_diff[NR_IO_TYPE];
 775         int i;
 776
 777         if (time_is_after_jiffies(sbi->iostat_next_period))
 778                 return;
 779
 780         /* Need double check under the lock */
 781         spin_lock(&sbi->iostat_lock);
 782         if (time_is_after_jiffies(sbi->iostat_next_period)) {
 783                 spin_unlock(&sbi->iostat_lock);
 784                 return;
 785         }
 786         sbi->iostat_next_period = jiffies +
 787                                 msecs_to_jiffies(sbi->iostat_period_ms);
 788
 789         for (i = 0; i < NR_IO_TYPE; i++) {
 790                 iostat_diff[i] = sbi->rw_iostat[i] -
 791                                 sbi->prev_rw_iostat[i];
 792                 sbi->prev_rw_iostat[i] = sbi->rw_iostat[i];
 793         }
 794         spin_unlock(&sbi->iostat_lock);
 795
 796         trace_f2fs_iostat(sbi, iostat_diff);
 797 }
 798
 799 static int __maybe_unused iostat_info_seq_show(struct seq_file *seq,
 800                                                void *offset)
 801 {
 802         struct super_block *sb = seq->private;
 803         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 804         time64_t now = ktime_get_real_seconds();
 805
 806         if (!sbi->iostat_enable)
 807                 return 0;
 808
 809         seq_printf(seq, "time:          %-16llu\n", now);
 810
 811         /* print app write IOs */
 812         seq_puts(seq, "[WRITE]\n");
 813         seq_printf(seq, "app buffered:  %-16llu\n",
 814                                 sbi->rw_iostat[APP_BUFFERED_IO]);
 815         seq_printf(seq, "app direct:    %-16llu\n",
 816                                 sbi->rw_iostat[APP_DIRECT_IO]);
 817         seq_printf(seq, "app mapped:    %-16llu\n",
 818                                 sbi->rw_iostat[APP_MAPPED_IO]);
 819
 820         /* print fs write IOs */
 821         seq_printf(seq, "fs data:       %-16llu\n",
 822                                 sbi->rw_iostat[FS_DATA_IO]);
 823         seq_printf(seq, "fs node:       %-16llu\n",
 824                                 sbi->rw_iostat[FS_NODE_IO]);
 825         seq_printf(seq, "fs meta:       %-16llu\n",
 826                                 sbi->rw_iostat[FS_META_IO]);
 827         seq_printf(seq, "fs gc data:    %-16llu\n",
 828                                 sbi->rw_iostat[FS_GC_DATA_IO]);
 829         seq_printf(seq, "fs gc node:    %-16llu\n",
 830                                 sbi->rw_iostat[FS_GC_NODE_IO]);
 831         seq_printf(seq, "fs cp data:    %-16llu\n",
 832                                 sbi->rw_iostat[FS_CP_DATA_IO]);
 833         seq_printf(seq, "fs cp node:    %-16llu\n",
 834                                 sbi->rw_iostat[FS_CP_NODE_IO]);
 835         seq_printf(seq, "fs cp meta:    %-16llu\n",
 836                                 sbi->rw_iostat[FS_CP_META_IO]);
 837
 838         /* print app read IOs */
 839         seq_puts(seq, "[READ]\n");
 840         seq_printf(seq, "app buffered:  %-16llu\n",
 841                                 sbi->rw_iostat[APP_BUFFERED_READ_IO]);
 842         seq_printf(seq, "app direct:    %-16llu\n",
 843                                 sbi->rw_iostat[APP_DIRECT_READ_IO]);
 844         seq_printf(seq, "app mapped:    %-16llu\n",
 845                                 sbi->rw_iostat[APP_MAPPED_READ_IO]);
 846
 847         /* print fs read IOs */
 848         seq_printf(seq, "fs data:       %-16llu\n",
 849                                 sbi->rw_iostat[FS_DATA_READ_IO]);
 850         seq_printf(seq, "fs gc data:    %-16llu\n",
 851                                 sbi->rw_iostat[FS_GDATA_READ_IO]);
 852         seq_printf(seq, "fs compr_data: %-16llu\n",
 853                                 sbi->rw_iostat[FS_CDATA_READ_IO]);
 854         seq_printf(seq, "fs node:       %-16llu\n",
 855                                 sbi->rw_iostat[FS_NODE_READ_IO]);
 856         seq_printf(seq, "fs meta:       %-16llu\n",
 857                                 sbi->rw_iostat[FS_META_READ_IO]);
 858
 859         /* print other IOs */
 860         seq_puts(seq, "[OTHER]\n");
 861         seq_printf(seq, "fs discard:    %-16llu\n",
 862                                 sbi->rw_iostat[FS_DISCARD]);
 863
 864         return 0;
 865 }
 866
 867 static int __maybe_unused victim_bits_seq_show(struct seq_file *seq,
 868                                                 void *offset)
 869 {
 870         struct super_block *sb = seq->private;
 871         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 872         struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
 873         int i;
 874
 875         seq_puts(seq, "format: victim_secmap bitmaps\n");
 876
 877         for (i = 0; i < MAIN_SECS(sbi); i++) {
 878                 if ((i % 10) == 0)
 879                         seq_printf(seq, "%-10d", i);
 880                 seq_printf(seq, "%d", test_bit(i, dirty_i->victim_secmap) ? 1 : 0);
 881                 if ((i % 10) == 9 || i == (MAIN_SECS(sbi) - 1))
 882                         seq_putc(seq, '\n');
 883                 else
 884                         seq_putc(seq, ' ');
 885         }
 886         return 0;
 887 }
 888
 889 int __init f2fs_init_sysfs(void)
 890 {
 891         int ret;
 892
 893         kobject_set_name(&f2fs_kset.kobj, "f2fs");
 894         f2fs_kset.kobj.parent = fs_kobj;
 895         ret = kset_register(&f2fs_kset);
 896         if (ret)
 897                 return ret;
 898
 899         ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype,
 900                                    NULL, "features");
 901         if (ret) {
 902                 kobject_put(&f2fs_feat);
 903                 kset_unregister(&f2fs_kset);
 904         } else {
 905                 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
 906         }
 907         return ret;
 908 }
 909
 910 void f2fs_exit_sysfs(void)
 911 {
 912         kobject_put(&f2fs_feat);
 913         kset_unregister(&f2fs_kset);
 914         remove_proc_entry("fs/f2fs", NULL);
 915         f2fs_proc_root = NULL;
 916 }
 917
 918 int f2fs_register_sysfs(struct f2fs_sb_info *sbi)
 919 {
 920         struct super_block *sb = sbi->sb;
 921         int err;
 922
 923         sbi->s_kobj.kset = &f2fs_kset;
 924         init_completion(&sbi->s_kobj_unregister);
 925         err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL,
 926                                 "%s", sb->s_id);
 927         if (err) {
 928                 kobject_put(&sbi->s_kobj);
 929                 wait_for_completion(&sbi->s_kobj_unregister);
 930                 return err;
 931         }
 932
 933         if (f2fs_proc_root)
 934                 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);
 935
 936         if (sbi->s_proc) {
 937                 proc_create_single_data("segment_info", S_IRUGO, sbi->s_proc,
 938                                 segment_info_seq_show, sb);
 939                 proc_create_single_data("segment_bits", S_IRUGO, sbi->s_proc,
 940                                 segment_bits_seq_show, sb);
 941                 proc_create_single_data("iostat_info", S_IRUGO, sbi->s_proc,
 942                                 iostat_info_seq_show, sb);
 943                 proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc,
 944                                 victim_bits_seq_show, sb);
 945         }
 946         return 0;
 947 }
 948
 949 void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi)
 950 {
 951         if (sbi->s_proc) {
 952                 remove_proc_entry("iostat_info", sbi->s_proc);
 953                 remove_proc_entry("segment_info", sbi->s_proc);
 954                 remove_proc_entry("segment_bits", sbi->s_proc);
 955                 remove_proc_entry("victim_bits", sbi->s_proc);
 956                 remove_proc_entry(sbi->sb->s_id, f2fs_proc_root);
 957         }
 958         kobject_del(&sbi->s_kobj);
 959         kobject_put(&sbi->s_kobj);
 960 }