fs/f2fs/sysfs.c

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