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 };
  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         FEAT_ENCRYPTED_CASEFOLD,
 566 };
 567
 568 static ssize_t f2fs_feature_show(struct f2fs_attr *a,
 569                 struct f2fs_sb_info *sbi, char *buf)
 570 {
 571         switch (a->id) {
 572         case FEAT_CRYPTO:
 573         case FEAT_BLKZONED:
 574         case FEAT_ATOMIC_WRITE:
 575         case FEAT_EXTRA_ATTR:
 576         case FEAT_PROJECT_QUOTA:
 577         case FEAT_INODE_CHECKSUM:
 578         case FEAT_FLEXIBLE_INLINE_XATTR:
 579         case FEAT_QUOTA_INO:
 580         case FEAT_INODE_CRTIME:
 581         case FEAT_LOST_FOUND:
 582         case FEAT_VERITY:
 583         case FEAT_SB_CHECKSUM:
 584         case FEAT_CASEFOLD:
 585         case FEAT_COMPRESSION:
 586         case FEAT_TEST_DUMMY_ENCRYPTION_V2:
 587         case FEAT_ENCRYPTED_CASEFOLD:
 588                 return sprintf(buf, "supported\n");
 589         }
 590         return 0;
 591 }
 592
 593 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
 594 static struct f2fs_attr f2fs_attr_##_name = {                   \
 595         .attr = {.name = __stringify(_name), .mode = _mode },   \
 596         .show   = _show,                                        \
 597         .store  = _store,                                       \
 598         .struct_type = _struct_type,                            \
 599         .offset = _offset                                       \
 600 }
 601
 602 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname)    \
 603         F2FS_ATTR_OFFSET(struct_type, name, 0644,               \
 604                 f2fs_sbi_show, f2fs_sbi_store,                  \
 605                 offsetof(struct struct_name, elname))
 606
 607 #define F2FS_GENERAL_RO_ATTR(name) \
 608 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)
 609
 610 #define F2FS_FEATURE_RO_ATTR(_name, _id)                        \
 611 static struct f2fs_attr f2fs_attr_##_name = {                   \
 612         .attr = {.name = __stringify(_name), .mode = 0444 },    \
 613         .show   = f2fs_feature_show,                            \
 614         .id     = _id,                                          \
 615 }
 616
 617 #define F2FS_STAT_ATTR(_struct_type, _struct_name, _name, _elname)      \
 618 static struct f2fs_attr f2fs_attr_##_name = {                   \
 619         .attr = {.name = __stringify(_name), .mode = 0444 },    \
 620         .show = f2fs_sbi_show,                                  \
 621         .struct_type = _struct_type,                            \
 622         .offset = offsetof(struct _struct_name, _elname),       \
 623 }
 624
 625 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time,
 626                                                         urgent_sleep_time);
 627 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
 628 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
 629 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
 630 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode);
 631 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode);
 632 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
 633 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards);
 634 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity);
 635 F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks);
 636 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
 637 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
 638 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
 639 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
 640 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks);
 641 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks);
 642 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);
 643 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
 644 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
 645 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio);
 646 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
 647 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, migration_granularity, migration_granularity);
 648 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
 649 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
 650 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
 651 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval,
 652                                         interval_time[DISCARD_TIME]);
 653 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]);
 654 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info,
 655                 umount_discard_timeout, interval_time[UMOUNT_DISCARD_TIMEOUT]);
 656 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable);
 657 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_period_ms, iostat_period_ms);
 658 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra);
 659 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_io_bytes, max_io_bytes);
 660 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold);
 661 F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list);
 662 #ifdef CONFIG_F2FS_FAULT_INJECTION
 663 F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate);
 664 F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type);
 665 #endif
 666 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag);
 667 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag);
 668 F2FS_RW_ATTR(CPRC_INFO, ckpt_req_control, ckpt_thread_ioprio, ckpt_thread_ioprio);
 669 F2FS_GENERAL_RO_ATTR(dirty_segments);
 670 F2FS_GENERAL_RO_ATTR(free_segments);
 671 F2FS_GENERAL_RO_ATTR(ovp_segments);
 672 F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes);
 673 F2FS_GENERAL_RO_ATTR(features);
 674 F2FS_GENERAL_RO_ATTR(current_reserved_blocks);
 675 F2FS_GENERAL_RO_ATTR(unusable);
 676 F2FS_GENERAL_RO_ATTR(encoding);
 677 F2FS_GENERAL_RO_ATTR(mounted_time_sec);
 678 F2FS_GENERAL_RO_ATTR(main_blkaddr);
 679 #ifdef CONFIG_F2FS_STAT_FS
 680 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_foreground_calls, cp_count);
 681 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_background_calls, bg_cp_count);
 682 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_foreground_calls, call_count);
 683 F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_background_calls, bg_gc);
 684 F2FS_GENERAL_RO_ATTR(moved_blocks_background);
 685 F2FS_GENERAL_RO_ATTR(moved_blocks_foreground);
 686 F2FS_GENERAL_RO_ATTR(avg_vblocks);
 687 #endif
 688
 689 #ifdef CONFIG_FS_ENCRYPTION
 690 F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO);
 691 F2FS_FEATURE_RO_ATTR(test_dummy_encryption_v2, FEAT_TEST_DUMMY_ENCRYPTION_V2);
 692 #ifdef CONFIG_UNICODE
 693 F2FS_FEATURE_RO_ATTR(encrypted_casefold, FEAT_ENCRYPTED_CASEFOLD);
 694 #endif
 695 #endif /* CONFIG_FS_ENCRYPTION */
 696 #ifdef CONFIG_BLK_DEV_ZONED
 697 F2FS_FEATURE_RO_ATTR(block_zoned, FEAT_BLKZONED);
 698 #endif
 699 F2FS_FEATURE_RO_ATTR(atomic_write, FEAT_ATOMIC_WRITE);
 700 F2FS_FEATURE_RO_ATTR(extra_attr, FEAT_EXTRA_ATTR);
 701 F2FS_FEATURE_RO_ATTR(project_quota, FEAT_PROJECT_QUOTA);
 702 F2FS_FEATURE_RO_ATTR(inode_checksum, FEAT_INODE_CHECKSUM);
 703 F2FS_FEATURE_RO_ATTR(flexible_inline_xattr, FEAT_FLEXIBLE_INLINE_XATTR);
 704 F2FS_FEATURE_RO_ATTR(quota_ino, FEAT_QUOTA_INO);
 705 F2FS_FEATURE_RO_ATTR(inode_crtime, FEAT_INODE_CRTIME);
 706 F2FS_FEATURE_RO_ATTR(lost_found, FEAT_LOST_FOUND);
 707 #ifdef CONFIG_FS_VERITY
 708 F2FS_FEATURE_RO_ATTR(verity, FEAT_VERITY);
 709 #endif
 710 F2FS_FEATURE_RO_ATTR(sb_checksum, FEAT_SB_CHECKSUM);
 711 #ifdef CONFIG_UNICODE
 712 F2FS_FEATURE_RO_ATTR(casefold, FEAT_CASEFOLD);
 713 #endif
 714 #ifdef CONFIG_F2FS_FS_COMPRESSION
 715 F2FS_FEATURE_RO_ATTR(compression, FEAT_COMPRESSION);
 716 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_written_block, compr_written_block);
 717 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_saved_block, compr_saved_block);
 718 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_new_inode, compr_new_inode);
 719 #endif
 720
 721 #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
 722 static struct attribute *f2fs_attrs[] = {
 723         ATTR_LIST(gc_urgent_sleep_time),
 724         ATTR_LIST(gc_min_sleep_time),
 725         ATTR_LIST(gc_max_sleep_time),
 726         ATTR_LIST(gc_no_gc_sleep_time),
 727         ATTR_LIST(gc_idle),
 728         ATTR_LIST(gc_urgent),
 729         ATTR_LIST(reclaim_segments),
 730         ATTR_LIST(main_blkaddr),
 731         ATTR_LIST(max_small_discards),
 732         ATTR_LIST(discard_granularity),
 733         ATTR_LIST(batched_trim_sections),
 734         ATTR_LIST(ipu_policy),
 735         ATTR_LIST(min_ipu_util),
 736         ATTR_LIST(min_fsync_blocks),
 737         ATTR_LIST(min_seq_blocks),
 738         ATTR_LIST(min_hot_blocks),
 739         ATTR_LIST(min_ssr_sections),
 740         ATTR_LIST(max_victim_search),
 741         ATTR_LIST(migration_granularity),
 742         ATTR_LIST(dir_level),
 743         ATTR_LIST(ram_thresh),
 744         ATTR_LIST(ra_nid_pages),
 745         ATTR_LIST(dirty_nats_ratio),
 746         ATTR_LIST(cp_interval),
 747         ATTR_LIST(idle_interval),
 748         ATTR_LIST(discard_idle_interval),
 749         ATTR_LIST(gc_idle_interval),
 750         ATTR_LIST(umount_discard_timeout),
 751         ATTR_LIST(iostat_enable),
 752         ATTR_LIST(iostat_period_ms),
 753         ATTR_LIST(readdir_ra),
 754         ATTR_LIST(max_io_bytes),
 755         ATTR_LIST(gc_pin_file_thresh),
 756         ATTR_LIST(extension_list),
 757 #ifdef CONFIG_F2FS_FAULT_INJECTION
 758         ATTR_LIST(inject_rate),
 759         ATTR_LIST(inject_type),
 760 #endif
 761         ATTR_LIST(data_io_flag),
 762         ATTR_LIST(node_io_flag),
 763         ATTR_LIST(ckpt_thread_ioprio),
 764         ATTR_LIST(dirty_segments),
 765         ATTR_LIST(free_segments),
 766         ATTR_LIST(ovp_segments),
 767         ATTR_LIST(unusable),
 768         ATTR_LIST(lifetime_write_kbytes),
 769         ATTR_LIST(features),
 770         ATTR_LIST(reserved_blocks),
 771         ATTR_LIST(current_reserved_blocks),
 772         ATTR_LIST(encoding),
 773         ATTR_LIST(mounted_time_sec),
 774 #ifdef CONFIG_F2FS_STAT_FS
 775         ATTR_LIST(cp_foreground_calls),
 776         ATTR_LIST(cp_background_calls),
 777         ATTR_LIST(gc_foreground_calls),
 778         ATTR_LIST(gc_background_calls),
 779         ATTR_LIST(moved_blocks_foreground),
 780         ATTR_LIST(moved_blocks_background),
 781         ATTR_LIST(avg_vblocks),
 782 #endif
 783 #ifdef CONFIG_F2FS_FS_COMPRESSION
 784         ATTR_LIST(compr_written_block),
 785         ATTR_LIST(compr_saved_block),
 786         ATTR_LIST(compr_new_inode),
 787 #endif
 788         NULL,
 789 };
 790 ATTRIBUTE_GROUPS(f2fs);
 791
 792 static struct attribute *f2fs_feat_attrs[] = {
 793 #ifdef CONFIG_FS_ENCRYPTION
 794         ATTR_LIST(encryption),
 795         ATTR_LIST(test_dummy_encryption_v2),
 796 #ifdef CONFIG_UNICODE
 797         ATTR_LIST(encrypted_casefold),
 798 #endif
 799 #endif /* CONFIG_FS_ENCRYPTION */
 800 #ifdef CONFIG_BLK_DEV_ZONED
 801         ATTR_LIST(block_zoned),
 802 #endif
 803         ATTR_LIST(atomic_write),
 804         ATTR_LIST(extra_attr),
 805         ATTR_LIST(project_quota),
 806         ATTR_LIST(inode_checksum),
 807         ATTR_LIST(flexible_inline_xattr),
 808         ATTR_LIST(quota_ino),
 809         ATTR_LIST(inode_crtime),
 810         ATTR_LIST(lost_found),
 811 #ifdef CONFIG_FS_VERITY
 812         ATTR_LIST(verity),
 813 #endif
 814         ATTR_LIST(sb_checksum),
 815 #ifdef CONFIG_UNICODE
 816         ATTR_LIST(casefold),
 817 #endif
 818 #ifdef CONFIG_F2FS_FS_COMPRESSION
 819         ATTR_LIST(compression),
 820 #endif
 821         NULL,
 822 };
 823 ATTRIBUTE_GROUPS(f2fs_feat);
 824
 825 F2FS_GENERAL_RO_ATTR(sb_status);
 826 static struct attribute *f2fs_stat_attrs[] = {
 827         ATTR_LIST(sb_status),
 828         NULL,
 829 };
 830 ATTRIBUTE_GROUPS(f2fs_stat);
 831
 832 static const struct sysfs_ops f2fs_attr_ops = {
 833         .show   = f2fs_attr_show,
 834         .store  = f2fs_attr_store,
 835 };
 836
 837 static struct kobj_type f2fs_sb_ktype = {
 838         .default_groups = f2fs_groups,
 839         .sysfs_ops      = &f2fs_attr_ops,
 840         .release        = f2fs_sb_release,
 841 };
 842
 843 static struct kobj_type f2fs_ktype = {
 844         .sysfs_ops      = &f2fs_attr_ops,
 845 };
 846
 847 static struct kset f2fs_kset = {
 848         .kobj   = {.ktype = &f2fs_ktype},
 849 };
 850
 851 static struct kobj_type f2fs_feat_ktype = {
 852         .default_groups = f2fs_feat_groups,
 853         .sysfs_ops      = &f2fs_attr_ops,
 854 };
 855
 856 static struct kobject f2fs_feat = {
 857         .kset   = &f2fs_kset,
 858 };
 859
 860 static ssize_t f2fs_stat_attr_show(struct kobject *kobj,
 861                                 struct attribute *attr, char *buf)
 862 {
 863         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
 864                                                                 s_stat_kobj);
 865         struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
 866
 867         return a->show ? a->show(a, sbi, buf) : 0;
 868 }
 869
 870 static ssize_t f2fs_stat_attr_store(struct kobject *kobj, struct attribute *attr,
 871                                                 const char *buf, size_t len)
 872 {
 873         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
 874                                                                 s_stat_kobj);
 875         struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
 876
 877         return a->store ? a->store(a, sbi, buf, len) : 0;
 878 }
 879
 880 static void f2fs_stat_kobj_release(struct kobject *kobj)
 881 {
 882         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
 883                                                                 s_stat_kobj);
 884         complete(&sbi->s_stat_kobj_unregister);
 885 }
 886
 887 static const struct sysfs_ops f2fs_stat_attr_ops = {
 888         .show   = f2fs_stat_attr_show,
 889         .store  = f2fs_stat_attr_store,
 890 };
 891
 892 static struct kobj_type f2fs_stat_ktype = {
 893         .default_groups = f2fs_stat_groups,
 894         .sysfs_ops      = &f2fs_stat_attr_ops,
 895         .release        = f2fs_stat_kobj_release,
 896 };
 897
 898 static int __maybe_unused segment_info_seq_show(struct seq_file *seq,
 899                                                 void *offset)
 900 {
 901         struct super_block *sb = seq->private;
 902         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 903         unsigned int total_segs =
 904                         le32_to_cpu(sbi->raw_super->segment_count_main);
 905         int i;
 906
 907         seq_puts(seq, "format: segment_type|valid_blocks\n"
 908                 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
 909
 910         for (i = 0; i < total_segs; i++) {
 911                 struct seg_entry *se = get_seg_entry(sbi, i);
 912
 913                 if ((i % 10) == 0)
 914                         seq_printf(seq, "%-10d", i);
 915                 seq_printf(seq, "%d|%-3u", se->type, se->valid_blocks);
 916                 if ((i % 10) == 9 || i == (total_segs - 1))
 917                         seq_putc(seq, '\n');
 918                 else
 919                         seq_putc(seq, ' ');
 920         }
 921
 922         return 0;
 923 }
 924
 925 static int __maybe_unused segment_bits_seq_show(struct seq_file *seq,
 926                                                 void *offset)
 927 {
 928         struct super_block *sb = seq->private;
 929         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 930         unsigned int total_segs =
 931                         le32_to_cpu(sbi->raw_super->segment_count_main);
 932         int i, j;
 933
 934         seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n"
 935                 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
 936
 937         for (i = 0; i < total_segs; i++) {
 938                 struct seg_entry *se = get_seg_entry(sbi, i);
 939
 940                 seq_printf(seq, "%-10d", i);
 941                 seq_printf(seq, "%d|%-3u|", se->type, se->valid_blocks);
 942                 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++)
 943                         seq_printf(seq, " %.2x", se->cur_valid_map[j]);
 944                 seq_putc(seq, '\n');
 945         }
 946         return 0;
 947 }
 948
 949 void f2fs_record_iostat(struct f2fs_sb_info *sbi)
 950 {
 951         unsigned long long iostat_diff[NR_IO_TYPE];
 952         int i;
 953
 954         if (time_is_after_jiffies(sbi->iostat_next_period))
 955                 return;
 956
 957         /* Need double check under the lock */
 958         spin_lock(&sbi->iostat_lock);
 959         if (time_is_after_jiffies(sbi->iostat_next_period)) {
 960                 spin_unlock(&sbi->iostat_lock);
 961                 return;
 962         }
 963         sbi->iostat_next_period = jiffies +
 964                                 msecs_to_jiffies(sbi->iostat_period_ms);
 965
 966         for (i = 0; i < NR_IO_TYPE; i++) {
 967                 iostat_diff[i] = sbi->rw_iostat[i] -
 968                                 sbi->prev_rw_iostat[i];
 969                 sbi->prev_rw_iostat[i] = sbi->rw_iostat[i];
 970         }
 971         spin_unlock(&sbi->iostat_lock);
 972
 973         trace_f2fs_iostat(sbi, iostat_diff);
 974 }
 975
 976 static int __maybe_unused iostat_info_seq_show(struct seq_file *seq,
 977                                                void *offset)
 978 {
 979         struct super_block *sb = seq->private;
 980         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 981         time64_t now = ktime_get_real_seconds();
 982
 983         if (!sbi->iostat_enable)
 984                 return 0;
 985
 986         seq_printf(seq, "time:          %-16llu\n", now);
 987
 988         /* print app write IOs */
 989         seq_puts(seq, "[WRITE]\n");
 990         seq_printf(seq, "app buffered:  %-16llu\n",
 991                                 sbi->rw_iostat[APP_BUFFERED_IO]);
 992         seq_printf(seq, "app direct:    %-16llu\n",
 993                                 sbi->rw_iostat[APP_DIRECT_IO]);
 994         seq_printf(seq, "app mapped:    %-16llu\n",
 995                                 sbi->rw_iostat[APP_MAPPED_IO]);
 996
 997         /* print fs write IOs */
 998         seq_printf(seq, "fs data:       %-16llu\n",
 999                                 sbi->rw_iostat[FS_DATA_IO]);
1000         seq_printf(seq, "fs node:       %-16llu\n",
1001                                 sbi->rw_iostat[FS_NODE_IO]);
1002         seq_printf(seq, "fs meta:       %-16llu\n",
1003                                 sbi->rw_iostat[FS_META_IO]);
1004         seq_printf(seq, "fs gc data:    %-16llu\n",
1005                                 sbi->rw_iostat[FS_GC_DATA_IO]);
1006         seq_printf(seq, "fs gc node:    %-16llu\n",
1007                                 sbi->rw_iostat[FS_GC_NODE_IO]);
1008         seq_printf(seq, "fs cp data:    %-16llu\n",
1009                                 sbi->rw_iostat[FS_CP_DATA_IO]);
1010         seq_printf(seq, "fs cp node:    %-16llu\n",
1011                                 sbi->rw_iostat[FS_CP_NODE_IO]);
1012         seq_printf(seq, "fs cp meta:    %-16llu\n",
1013                                 sbi->rw_iostat[FS_CP_META_IO]);
1014
1015         /* print app read IOs */
1016         seq_puts(seq, "[READ]\n");
1017         seq_printf(seq, "app buffered:  %-16llu\n",
1018                                 sbi->rw_iostat[APP_BUFFERED_READ_IO]);
1019         seq_printf(seq, "app direct:    %-16llu\n",
1020                                 sbi->rw_iostat[APP_DIRECT_READ_IO]);
1021         seq_printf(seq, "app mapped:    %-16llu\n",
1022                                 sbi->rw_iostat[APP_MAPPED_READ_IO]);
1023
1024         /* print fs read IOs */
1025         seq_printf(seq, "fs data:       %-16llu\n",
1026                                 sbi->rw_iostat[FS_DATA_READ_IO]);
1027         seq_printf(seq, "fs gc data:    %-16llu\n",
1028                                 sbi->rw_iostat[FS_GDATA_READ_IO]);
1029         seq_printf(seq, "fs compr_data: %-16llu\n",
1030                                 sbi->rw_iostat[FS_CDATA_READ_IO]);
1031         seq_printf(seq, "fs node:       %-16llu\n",
1032                                 sbi->rw_iostat[FS_NODE_READ_IO]);
1033         seq_printf(seq, "fs meta:       %-16llu\n",
1034                                 sbi->rw_iostat[FS_META_READ_IO]);
1035
1036         /* print other IOs */
1037         seq_puts(seq, "[OTHER]\n");
1038         seq_printf(seq, "fs discard:    %-16llu\n",
1039                                 sbi->rw_iostat[FS_DISCARD]);
1040
1041         return 0;
1042 }
1043
1044 static int __maybe_unused victim_bits_seq_show(struct seq_file *seq,
1045                                                 void *offset)
1046 {
1047         struct super_block *sb = seq->private;
1048         struct f2fs_sb_info *sbi = F2FS_SB(sb);
1049         struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
1050         int i;
1051
1052         seq_puts(seq, "format: victim_secmap bitmaps\n");
1053
1054         for (i = 0; i < MAIN_SECS(sbi); i++) {
1055                 if ((i % 10) == 0)
1056                         seq_printf(seq, "%-10d", i);
1057                 seq_printf(seq, "%d", test_bit(i, dirty_i->victim_secmap) ? 1 : 0);
1058                 if ((i % 10) == 9 || i == (MAIN_SECS(sbi) - 1))
1059                         seq_putc(seq, '\n');
1060                 else
1061                         seq_putc(seq, ' ');
1062         }
1063         return 0;
1064 }
1065
1066 int __init f2fs_init_sysfs(void)
1067 {
1068         int ret;
1069
1070         kobject_set_name(&f2fs_kset.kobj, "f2fs");
1071         f2fs_kset.kobj.parent = fs_kobj;
1072         ret = kset_register(&f2fs_kset);
1073         if (ret)
1074                 return ret;
1075
1076         ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype,
1077                                    NULL, "features");
1078         if (ret) {
1079                 kobject_put(&f2fs_feat);
1080                 kset_unregister(&f2fs_kset);
1081         } else {
1082                 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
1083         }
1084         return ret;
1085 }
1086
1087 void f2fs_exit_sysfs(void)
1088 {
1089         kobject_put(&f2fs_feat);
1090         kset_unregister(&f2fs_kset);
1091         remove_proc_entry("fs/f2fs", NULL);
1092         f2fs_proc_root = NULL;
1093 }
1094
1095 int f2fs_register_sysfs(struct f2fs_sb_info *sbi)
1096 {
1097         struct super_block *sb = sbi->sb;
1098         int err;
1099
1100         sbi->s_kobj.kset = &f2fs_kset;
1101         init_completion(&sbi->s_kobj_unregister);
1102         err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL,
1103                                 "%s", sb->s_id);
1104         if (err)
1105                 goto put_sb_kobj;
1106
1107         sbi->s_stat_kobj.kset = &f2fs_kset;
1108         init_completion(&sbi->s_stat_kobj_unregister);
1109         err = kobject_init_and_add(&sbi->s_stat_kobj, &f2fs_stat_ktype,
1110                                                 &sbi->s_kobj, "stat");
1111         if (err)
1112                 goto put_stat_kobj;
1113
1114         if (f2fs_proc_root)
1115                 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);
1116
1117         if (sbi->s_proc) {
1118                 proc_create_single_data("segment_info", S_IRUGO, sbi->s_proc,
1119                                 segment_info_seq_show, sb);
1120                 proc_create_single_data("segment_bits", S_IRUGO, sbi->s_proc,
1121                                 segment_bits_seq_show, sb);
1122                 proc_create_single_data("iostat_info", S_IRUGO, sbi->s_proc,
1123                                 iostat_info_seq_show, sb);
1124                 proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc,
1125                                 victim_bits_seq_show, sb);
1126         }
1127         return 0;
1128 put_stat_kobj:
1129         kobject_put(&sbi->s_stat_kobj);
1130         wait_for_completion(&sbi->s_stat_kobj_unregister);
1131 put_sb_kobj:
1132         kobject_put(&sbi->s_kobj);
1133         wait_for_completion(&sbi->s_kobj_unregister);
1134         return err;
1135 }
1136
1137 void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi)
1138 {
1139         if (sbi->s_proc) {
1140                 remove_proc_entry("iostat_info", sbi->s_proc);
1141                 remove_proc_entry("segment_info", sbi->s_proc);
1142                 remove_proc_entry("segment_bits", sbi->s_proc);
1143                 remove_proc_entry("victim_bits", sbi->s_proc);
1144                 remove_proc_entry(sbi->sb->s_id, f2fs_proc_root);
1145         }
1146
1147         kobject_del(&sbi->s_stat_kobj);
1148         kobject_put(&sbi->s_stat_kobj);
1149         wait_for_completion(&sbi->s_stat_kobj_unregister);
1150
1151         kobject_del(&sbi->s_kobj);
1152         kobject_put(&sbi->s_kobj);
1153         wait_for_completion(&sbi->s_kobj_unregister);
1154 }