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