fs/f2fs/sysfs.c

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