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         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 }