fs/f2fs/sysfs.c

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