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