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