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