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