Chao Yu | 7c1a000 | 2018-09-12 09:16:07 +0800 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 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> |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 8 | */ |
Randy Dunlap | cb15d1e | 2018-07-06 20:50:57 -0700 | [diff] [blame] | 9 | #include <linux/compiler.h> |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 10 | #include <linux/proc_fs.h> |
| 11 | #include <linux/f2fs_fs.h> |
Jaegeuk Kim | 299aa41 | 2017-07-13 17:45:21 -0700 | [diff] [blame] | 12 | #include <linux/seq_file.h> |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 13 | #include <linux/unicode.h> |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 14 | |
| 15 | #include "f2fs.h" |
| 16 | #include "segment.h" |
| 17 | #include "gc.h" |
Daeho Jeong | 2bc4bea | 2020-03-30 03:30:59 +0000 | [diff] [blame] | 18 | #include <trace/events/f2fs.h> |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 19 | |
| 20 | static struct proc_dir_entry *f2fs_proc_root; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 21 | |
| 22 | /* Sysfs support for f2fs */ |
| 23 | enum { |
| 24 | GC_THREAD, /* struct f2fs_gc_thread */ |
| 25 | SM_INFO, /* struct f2fs_sm_info */ |
| 26 | DCC_INFO, /* struct discard_cmd_control */ |
| 27 | NM_INFO, /* struct f2fs_nm_info */ |
| 28 | F2FS_SBI, /* struct f2fs_sb_info */ |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 29 | #ifdef CONFIG_F2FS_STAT_FS |
Jack Qiu | a87aff1 | 2020-07-24 16:55:28 +0800 | [diff] [blame] | 30 | STAT_INFO, /* struct f2fs_stat_info */ |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 31 | #endif |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 32 | #ifdef CONFIG_F2FS_FAULT_INJECTION |
| 33 | FAULT_INFO_RATE, /* struct f2fs_fault_info */ |
| 34 | FAULT_INFO_TYPE, /* struct f2fs_fault_info */ |
| 35 | #endif |
Yunlong Song | 80d4214 | 2017-10-27 20:45:05 +0800 | [diff] [blame] | 36 | RESERVED_BLOCKS, /* struct f2fs_sb_info */ |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 37 | }; |
| 38 | |
| 39 | struct f2fs_attr { |
| 40 | struct attribute attr; |
| 41 | ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *); |
| 42 | ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *, |
| 43 | const char *, size_t); |
| 44 | int struct_type; |
| 45 | int offset; |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 46 | int id; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 47 | }; |
| 48 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 49 | static ssize_t f2fs_sbi_show(struct f2fs_attr *a, |
| 50 | struct f2fs_sb_info *sbi, char *buf); |
| 51 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 52 | static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type) |
| 53 | { |
| 54 | if (struct_type == GC_THREAD) |
| 55 | return (unsigned char *)sbi->gc_thread; |
| 56 | else if (struct_type == SM_INFO) |
| 57 | return (unsigned char *)SM_I(sbi); |
| 58 | else if (struct_type == DCC_INFO) |
| 59 | return (unsigned char *)SM_I(sbi)->dcc_info; |
| 60 | else if (struct_type == NM_INFO) |
| 61 | return (unsigned char *)NM_I(sbi); |
Chao Yu | daeb433 | 2017-06-26 16:24:41 +0800 | [diff] [blame] | 62 | else if (struct_type == F2FS_SBI || struct_type == RESERVED_BLOCKS) |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 63 | return (unsigned char *)sbi; |
| 64 | #ifdef CONFIG_F2FS_FAULT_INJECTION |
| 65 | else if (struct_type == FAULT_INFO_RATE || |
| 66 | struct_type == FAULT_INFO_TYPE) |
Chao Yu | 63189b7 | 2018-03-08 14:22:56 +0800 | [diff] [blame] | 67 | return (unsigned char *)&F2FS_OPTION(sbi).fault_info; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 68 | #endif |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 69 | #ifdef CONFIG_F2FS_STAT_FS |
| 70 | else if (struct_type == STAT_INFO) |
| 71 | return (unsigned char *)F2FS_STAT(sbi); |
| 72 | #endif |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 73 | return NULL; |
| 74 | } |
| 75 | |
Jaegeuk Kim | 8f1572f | 2017-10-24 09:46:54 +0200 | [diff] [blame] | 76 | static ssize_t dirty_segments_show(struct f2fs_attr *a, |
| 77 | struct f2fs_sb_info *sbi, char *buf) |
| 78 | { |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 79 | return sprintf(buf, "%llu\n", |
| 80 | (unsigned long long)(dirty_segments(sbi))); |
Jaegeuk Kim | 8f1572f | 2017-10-24 09:46:54 +0200 | [diff] [blame] | 81 | } |
| 82 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 83 | static ssize_t free_segments_show(struct f2fs_attr *a, |
Daniel Rosenberg | 4d3aed7 | 2019-05-29 17:49:06 -0700 | [diff] [blame] | 84 | struct f2fs_sb_info *sbi, char *buf) |
| 85 | { |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 86 | return sprintf(buf, "%llu\n", |
| 87 | (unsigned long long)(free_segments(sbi))); |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 88 | } |
Daniel Rosenberg | 4d3aed7 | 2019-05-29 17:49:06 -0700 | [diff] [blame] | 89 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 90 | static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a, |
| 91 | struct f2fs_sb_info *sbi, char *buf) |
| 92 | { |
| 93 | struct super_block *sb = sbi->sb; |
| 94 | |
| 95 | if (!sb->s_bdev->bd_part) |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 96 | return sprintf(buf, "0\n"); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 97 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 98 | return sprintf(buf, "%llu\n", |
| 99 | (unsigned long long)(sbi->kbytes_written + |
Chao Yu | 3a0a9cb | 2020-11-27 21:20:06 +0800 | [diff] [blame] | 100 | ((f2fs_get_sectors_written(sbi) - |
| 101 | sbi->sectors_written_start) >> 1))); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 102 | } |
| 103 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 104 | static ssize_t features_show(struct f2fs_attr *a, |
| 105 | struct f2fs_sb_info *sbi, char *buf) |
| 106 | { |
| 107 | struct super_block *sb = sbi->sb; |
| 108 | int len = 0; |
| 109 | |
| 110 | if (!sb->s_bdev->bd_part) |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 111 | return sprintf(buf, "0\n"); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 112 | |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 113 | if (f2fs_sb_has_encrypt(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 114 | len += scnprintf(buf, PAGE_SIZE - len, "%s", |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 115 | "encryption"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 116 | if (f2fs_sb_has_blkzoned(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 117 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 118 | len ? ", " : "", "blkzoned"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 119 | if (f2fs_sb_has_extra_attr(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 120 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 121 | len ? ", " : "", "extra_attr"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 122 | if (f2fs_sb_has_project_quota(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 123 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 124 | len ? ", " : "", "projquota"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 125 | if (f2fs_sb_has_inode_chksum(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 126 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 127 | len ? ", " : "", "inode_checksum"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 128 | if (f2fs_sb_has_flexible_inline_xattr(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 129 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Chao Yu | 6afc662 | 2017-09-06 21:59:50 +0800 | [diff] [blame] | 130 | len ? ", " : "", "flexible_inline_xattr"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 131 | if (f2fs_sb_has_quota_ino(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 132 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Jaegeuk Kim | 234a968 | 2017-10-05 21:03:06 -0700 | [diff] [blame] | 133 | len ? ", " : "", "quota_ino"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 134 | if (f2fs_sb_has_inode_crtime(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 135 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Chao Yu | 1c1d35d | 2018-01-25 14:54:42 +0800 | [diff] [blame] | 136 | len ? ", " : "", "inode_crtime"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 137 | if (f2fs_sb_has_lost_found(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 138 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Sheng Yong | b7c409d | 2018-03-15 18:51:41 +0800 | [diff] [blame] | 139 | len ? ", " : "", "lost_found"); |
Eric Biggers | 95ae251 | 2019-07-22 09:26:24 -0700 | [diff] [blame] | 140 | if (f2fs_sb_has_verity(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 141 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Eric Biggers | 95ae251 | 2019-07-22 09:26:24 -0700 | [diff] [blame] | 142 | len ? ", " : "", "verity"); |
Chao Yu | 7beb01f | 2018-10-24 18:34:26 +0800 | [diff] [blame] | 143 | if (f2fs_sb_has_sb_chksum(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 144 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Junling Zheng | d440c52 | 2018-09-28 20:25:56 +0800 | [diff] [blame] | 145 | len ? ", " : "", "sb_checksum"); |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 146 | if (f2fs_sb_has_casefold(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 147 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 148 | len ? ", " : "", "casefold"); |
Chao Yu | 4c8ff70 | 2019-11-01 18:07:14 +0800 | [diff] [blame] | 149 | if (f2fs_sb_has_compression(sbi)) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 150 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Chao Yu | 4c8ff70 | 2019-11-01 18:07:14 +0800 | [diff] [blame] | 151 | len ? ", " : "", "compression"); |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 152 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s", |
Jaegeuk Kim | f5a53ed | 2019-10-18 10:06:40 -0700 | [diff] [blame] | 153 | len ? ", " : "", "pin_file"); |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 154 | len += scnprintf(buf + len, PAGE_SIZE - len, "\n"); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 155 | return len; |
| 156 | } |
| 157 | |
Yunlong Song | 80d4214 | 2017-10-27 20:45:05 +0800 | [diff] [blame] | 158 | static ssize_t current_reserved_blocks_show(struct f2fs_attr *a, |
| 159 | struct f2fs_sb_info *sbi, char *buf) |
| 160 | { |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 161 | return sprintf(buf, "%u\n", sbi->current_reserved_blocks); |
Yunlong Song | 80d4214 | 2017-10-27 20:45:05 +0800 | [diff] [blame] | 162 | } |
| 163 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 164 | static ssize_t unusable_show(struct f2fs_attr *a, |
| 165 | struct f2fs_sb_info *sbi, char *buf) |
| 166 | { |
| 167 | block_t unusable; |
| 168 | |
| 169 | if (test_opt(sbi, DISABLE_CHECKPOINT)) |
| 170 | unusable = sbi->unusable_block_count; |
| 171 | else |
| 172 | unusable = f2fs_get_unusable_blocks(sbi); |
| 173 | return sprintf(buf, "%llu\n", (unsigned long long)unusable); |
| 174 | } |
| 175 | |
| 176 | static ssize_t encoding_show(struct f2fs_attr *a, |
| 177 | struct f2fs_sb_info *sbi, char *buf) |
| 178 | { |
| 179 | #ifdef CONFIG_UNICODE |
Daniel Rosenberg | eca4873 | 2020-07-08 02:12:36 -0700 | [diff] [blame] | 180 | struct super_block *sb = sbi->sb; |
| 181 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 182 | if (f2fs_sb_has_casefold(sbi)) |
| 183 | return snprintf(buf, PAGE_SIZE, "%s (%d.%d.%d)\n", |
Daniel Rosenberg | eca4873 | 2020-07-08 02:12:36 -0700 | [diff] [blame] | 184 | sb->s_encoding->charset, |
| 185 | (sb->s_encoding->version >> 16) & 0xff, |
| 186 | (sb->s_encoding->version >> 8) & 0xff, |
| 187 | sb->s_encoding->version & 0xff); |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 188 | #endif |
| 189 | return sprintf(buf, "(none)"); |
| 190 | } |
| 191 | |
Jaegeuk Kim | a7e679b | 2020-02-25 19:08:16 -0800 | [diff] [blame] | 192 | static ssize_t mounted_time_sec_show(struct f2fs_attr *a, |
| 193 | struct f2fs_sb_info *sbi, char *buf) |
| 194 | { |
| 195 | return sprintf(buf, "%llu", SIT_I(sbi)->mounted_time); |
| 196 | } |
| 197 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 198 | #ifdef CONFIG_F2FS_STAT_FS |
| 199 | static ssize_t moved_blocks_foreground_show(struct f2fs_attr *a, |
| 200 | struct f2fs_sb_info *sbi, char *buf) |
| 201 | { |
| 202 | struct f2fs_stat_info *si = F2FS_STAT(sbi); |
| 203 | |
| 204 | return sprintf(buf, "%llu\n", |
| 205 | (unsigned long long)(si->tot_blks - |
| 206 | (si->bg_data_blks + si->bg_node_blks))); |
| 207 | } |
| 208 | |
| 209 | static ssize_t moved_blocks_background_show(struct f2fs_attr *a, |
| 210 | struct f2fs_sb_info *sbi, char *buf) |
| 211 | { |
| 212 | struct f2fs_stat_info *si = F2FS_STAT(sbi); |
| 213 | |
| 214 | return sprintf(buf, "%llu\n", |
| 215 | (unsigned long long)(si->bg_data_blks + si->bg_node_blks)); |
| 216 | } |
| 217 | |
| 218 | static ssize_t avg_vblocks_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 | si->dirty_count = dirty_segments(sbi); |
| 224 | f2fs_update_sit_info(sbi); |
| 225 | return sprintf(buf, "%llu\n", (unsigned long long)(si->avg_vblocks)); |
| 226 | } |
| 227 | #endif |
| 228 | |
Dehe Gu | ffcde4b | 2020-07-03 17:51:29 +0800 | [diff] [blame] | 229 | static ssize_t main_blkaddr_show(struct f2fs_attr *a, |
| 230 | struct f2fs_sb_info *sbi, char *buf) |
| 231 | { |
| 232 | return snprintf(buf, PAGE_SIZE, "%llu\n", |
| 233 | (unsigned long long)MAIN_BLKADDR(sbi)); |
| 234 | } |
| 235 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 236 | static ssize_t f2fs_sbi_show(struct f2fs_attr *a, |
| 237 | struct f2fs_sb_info *sbi, char *buf) |
| 238 | { |
| 239 | unsigned char *ptr = NULL; |
| 240 | unsigned int *ui; |
| 241 | |
| 242 | ptr = __struct_ptr(sbi, a->struct_type); |
| 243 | if (!ptr) |
| 244 | return -EINVAL; |
| 245 | |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 246 | if (!strcmp(a->attr.name, "extension_list")) { |
| 247 | __u8 (*extlist)[F2FS_EXTENSION_LEN] = |
| 248 | sbi->raw_super->extension_list; |
Chao Yu | b6a06cb | 2018-02-28 17:07:27 +0800 | [diff] [blame] | 249 | int cold_count = le32_to_cpu(sbi->raw_super->extension_count); |
| 250 | int hot_count = sbi->raw_super->hot_ext_count; |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 251 | int len = 0, i; |
| 252 | |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 253 | len += scnprintf(buf + len, PAGE_SIZE - len, |
Colin Ian King | 4580038 | 2018-04-30 16:27:44 +0100 | [diff] [blame] | 254 | "cold file extension:\n"); |
Chao Yu | b6a06cb | 2018-02-28 17:07:27 +0800 | [diff] [blame] | 255 | for (i = 0; i < cold_count; i++) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 256 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n", |
Chao Yu | b6a06cb | 2018-02-28 17:07:27 +0800 | [diff] [blame] | 257 | extlist[i]); |
| 258 | |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 259 | len += scnprintf(buf + len, PAGE_SIZE - len, |
Colin Ian King | 4580038 | 2018-04-30 16:27:44 +0100 | [diff] [blame] | 260 | "hot file extension:\n"); |
Chao Yu | b6a06cb | 2018-02-28 17:07:27 +0800 | [diff] [blame] | 261 | for (i = cold_count; i < cold_count + hot_count; i++) |
Takashi Iwai | c6d5789 | 2020-03-11 10:33:53 +0100 | [diff] [blame] | 262 | len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n", |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 263 | extlist[i]); |
| 264 | return len; |
| 265 | } |
| 266 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 267 | ui = (unsigned int *)(ptr + a->offset); |
| 268 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 269 | return sprintf(buf, "%u\n", *ui); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 270 | } |
| 271 | |
Chao Yu | 4d57b86 | 2018-05-30 00:20:41 +0800 | [diff] [blame] | 272 | static ssize_t __sbi_store(struct f2fs_attr *a, |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 273 | struct f2fs_sb_info *sbi, |
| 274 | const char *buf, size_t count) |
| 275 | { |
| 276 | unsigned char *ptr; |
| 277 | unsigned long t; |
| 278 | unsigned int *ui; |
| 279 | ssize_t ret; |
| 280 | |
| 281 | ptr = __struct_ptr(sbi, a->struct_type); |
| 282 | if (!ptr) |
| 283 | return -EINVAL; |
| 284 | |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 285 | if (!strcmp(a->attr.name, "extension_list")) { |
| 286 | const char *name = strim((char *)buf); |
Chao Yu | b6a06cb | 2018-02-28 17:07:27 +0800 | [diff] [blame] | 287 | bool set = true, hot; |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 288 | |
Chao Yu | b6a06cb | 2018-02-28 17:07:27 +0800 | [diff] [blame] | 289 | if (!strncmp(name, "[h]", 3)) |
| 290 | hot = true; |
| 291 | else if (!strncmp(name, "[c]", 3)) |
| 292 | hot = false; |
| 293 | else |
| 294 | return -EINVAL; |
| 295 | |
| 296 | name += 3; |
| 297 | |
| 298 | if (*name == '!') { |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 299 | name++; |
| 300 | set = false; |
| 301 | } |
| 302 | |
| 303 | if (strlen(name) >= F2FS_EXTENSION_LEN) |
| 304 | return -EINVAL; |
| 305 | |
| 306 | down_write(&sbi->sb_lock); |
| 307 | |
Chao Yu | 4d57b86 | 2018-05-30 00:20:41 +0800 | [diff] [blame] | 308 | ret = f2fs_update_extension_list(sbi, name, hot, set); |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 309 | if (ret) |
| 310 | goto out; |
| 311 | |
| 312 | ret = f2fs_commit_super(sbi, false); |
| 313 | if (ret) |
Chao Yu | 4d57b86 | 2018-05-30 00:20:41 +0800 | [diff] [blame] | 314 | f2fs_update_extension_list(sbi, name, hot, !set); |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 315 | out: |
| 316 | up_write(&sbi->sb_lock); |
| 317 | return ret ? ret : count; |
| 318 | } |
| 319 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 320 | ui = (unsigned int *)(ptr + a->offset); |
| 321 | |
| 322 | ret = kstrtoul(skip_spaces(buf), 0, &t); |
| 323 | if (ret < 0) |
| 324 | return ret; |
| 325 | #ifdef CONFIG_F2FS_FAULT_INJECTION |
| 326 | if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX)) |
| 327 | return -EINVAL; |
Chao Yu | 36c5733 | 2019-01-04 17:39:53 +0800 | [diff] [blame] | 328 | if (a->struct_type == FAULT_INFO_RATE && t >= UINT_MAX) |
| 329 | return -EINVAL; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 330 | #endif |
Chao Yu | daeb433 | 2017-06-26 16:24:41 +0800 | [diff] [blame] | 331 | if (a->struct_type == RESERVED_BLOCKS) { |
| 332 | spin_lock(&sbi->stat_lock); |
Jaegeuk Kim | 7e65be4 | 2017-12-27 15:05:52 -0800 | [diff] [blame] | 333 | if (t > (unsigned long)(sbi->user_block_count - |
Chao Yu | 63189b7 | 2018-03-08 14:22:56 +0800 | [diff] [blame] | 334 | F2FS_OPTION(sbi).root_reserved_blocks)) { |
Chao Yu | daeb433 | 2017-06-26 16:24:41 +0800 | [diff] [blame] | 335 | spin_unlock(&sbi->stat_lock); |
| 336 | return -EINVAL; |
| 337 | } |
| 338 | *ui = t; |
Yunlong Song | 80d4214 | 2017-10-27 20:45:05 +0800 | [diff] [blame] | 339 | sbi->current_reserved_blocks = min(sbi->reserved_blocks, |
| 340 | sbi->user_block_count - valid_user_blocks(sbi)); |
Chao Yu | daeb433 | 2017-06-26 16:24:41 +0800 | [diff] [blame] | 341 | spin_unlock(&sbi->stat_lock); |
| 342 | return count; |
| 343 | } |
Chao Yu | 969d1b1 | 2017-08-07 23:09:56 +0800 | [diff] [blame] | 344 | |
| 345 | if (!strcmp(a->attr.name, "discard_granularity")) { |
Chao Yu | 969d1b1 | 2017-08-07 23:09:56 +0800 | [diff] [blame] | 346 | if (t == 0 || t > MAX_PLIST_NUM) |
| 347 | return -EINVAL; |
| 348 | if (t == *ui) |
| 349 | return count; |
Chao Yu | 80647e5 | 2017-09-12 14:25:35 +0800 | [diff] [blame] | 350 | *ui = t; |
Chao Yu | 969d1b1 | 2017-08-07 23:09:56 +0800 | [diff] [blame] | 351 | return count; |
| 352 | } |
| 353 | |
Chao Yu | 3465557 | 2018-10-25 16:19:28 +0800 | [diff] [blame] | 354 | if (!strcmp(a->attr.name, "migration_granularity")) { |
| 355 | if (t == 0 || t > sbi->segs_per_sec) |
| 356 | return -EINVAL; |
| 357 | } |
| 358 | |
Chao Yu | 377224c | 2018-04-09 10:25:23 +0800 | [diff] [blame] | 359 | if (!strcmp(a->attr.name, "trim_sections")) |
| 360 | return -EINVAL; |
| 361 | |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 362 | if (!strcmp(a->attr.name, "gc_urgent")) { |
Daeho Jeong | 0e5e811 | 2020-07-02 13:14:14 +0900 | [diff] [blame] | 363 | if (t == 0) { |
| 364 | sbi->gc_mode = GC_NORMAL; |
| 365 | } else if (t == 1) { |
| 366 | sbi->gc_mode = GC_URGENT_HIGH; |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 367 | if (sbi->gc_thread) { |
Sheng Yong | a690eff | 2018-08-05 12:45:35 +0800 | [diff] [blame] | 368 | sbi->gc_thread->gc_wake = 1; |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 369 | wake_up_interruptible_all( |
| 370 | &sbi->gc_thread->gc_wait_queue_head); |
| 371 | wake_up_discard_thread(sbi, true); |
| 372 | } |
Daeho Jeong | 0e5e811 | 2020-07-02 13:14:14 +0900 | [diff] [blame] | 373 | } else if (t == 2) { |
| 374 | sbi->gc_mode = GC_URGENT_LOW; |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 375 | } else { |
Daeho Jeong | 0e5e811 | 2020-07-02 13:14:14 +0900 | [diff] [blame] | 376 | return -EINVAL; |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 377 | } |
| 378 | return count; |
| 379 | } |
| 380 | if (!strcmp(a->attr.name, "gc_idle")) { |
Chao Yu | 093749e | 2020-08-04 21:14:49 +0800 | [diff] [blame] | 381 | if (t == GC_IDLE_CB) { |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 382 | sbi->gc_mode = GC_IDLE_CB; |
Chao Yu | 093749e | 2020-08-04 21:14:49 +0800 | [diff] [blame] | 383 | } else if (t == GC_IDLE_GREEDY) { |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 384 | sbi->gc_mode = GC_IDLE_GREEDY; |
Chao Yu | 093749e | 2020-08-04 21:14:49 +0800 | [diff] [blame] | 385 | } else if (t == GC_IDLE_AT) { |
| 386 | if (!sbi->am.atgc_enabled) |
| 387 | return -EINVAL; |
| 388 | sbi->gc_mode = GC_AT; |
| 389 | } else { |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 390 | sbi->gc_mode = GC_NORMAL; |
Chao Yu | 093749e | 2020-08-04 21:14:49 +0800 | [diff] [blame] | 391 | } |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 392 | return count; |
| 393 | } |
| 394 | |
Sheng Yong | ac92985 | 2019-01-15 20:02:15 +0000 | [diff] [blame] | 395 | if (!strcmp(a->attr.name, "iostat_enable")) { |
| 396 | sbi->iostat_enable = !!t; |
| 397 | if (!sbi->iostat_enable) |
| 398 | f2fs_reset_iostat(sbi); |
| 399 | return count; |
| 400 | } |
| 401 | |
Daeho Jeong | 2bc4bea | 2020-03-30 03:30:59 +0000 | [diff] [blame] | 402 | if (!strcmp(a->attr.name, "iostat_period_ms")) { |
| 403 | if (t < MIN_IOSTAT_PERIOD_MS || t > MAX_IOSTAT_PERIOD_MS) |
| 404 | return -EINVAL; |
| 405 | spin_lock(&sbi->iostat_lock); |
| 406 | sbi->iostat_period_ms = (unsigned int)t; |
| 407 | spin_unlock(&sbi->iostat_lock); |
| 408 | return count; |
| 409 | } |
| 410 | |
Sheng Yong | ac92985 | 2019-01-15 20:02:15 +0000 | [diff] [blame] | 411 | *ui = (unsigned int)t; |
| 412 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 413 | return count; |
| 414 | } |
| 415 | |
Chao Yu | 250dbf5 | 2018-05-28 16:57:32 +0800 | [diff] [blame] | 416 | static ssize_t f2fs_sbi_store(struct f2fs_attr *a, |
| 417 | struct f2fs_sb_info *sbi, |
| 418 | const char *buf, size_t count) |
| 419 | { |
| 420 | ssize_t ret; |
| 421 | bool gc_entry = (!strcmp(a->attr.name, "gc_urgent") || |
| 422 | a->struct_type == GC_THREAD); |
| 423 | |
Jaegeuk Kim | a1933c0 | 2018-07-15 09:58:08 +0900 | [diff] [blame] | 424 | if (gc_entry) { |
| 425 | if (!down_read_trylock(&sbi->sb->s_umount)) |
| 426 | return -EAGAIN; |
| 427 | } |
Chao Yu | 4d57b86 | 2018-05-30 00:20:41 +0800 | [diff] [blame] | 428 | ret = __sbi_store(a, sbi, buf, count); |
Chao Yu | 250dbf5 | 2018-05-28 16:57:32 +0800 | [diff] [blame] | 429 | if (gc_entry) |
| 430 | up_read(&sbi->sb->s_umount); |
| 431 | |
| 432 | return ret; |
| 433 | } |
| 434 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 435 | static ssize_t f2fs_attr_show(struct kobject *kobj, |
| 436 | struct attribute *attr, char *buf) |
| 437 | { |
| 438 | struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, |
| 439 | s_kobj); |
| 440 | struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); |
| 441 | |
| 442 | return a->show ? a->show(a, sbi, buf) : 0; |
| 443 | } |
| 444 | |
| 445 | static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr, |
| 446 | const char *buf, size_t len) |
| 447 | { |
| 448 | struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, |
| 449 | s_kobj); |
| 450 | struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); |
| 451 | |
| 452 | return a->store ? a->store(a, sbi, buf, len) : 0; |
| 453 | } |
| 454 | |
| 455 | static void f2fs_sb_release(struct kobject *kobj) |
| 456 | { |
| 457 | struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, |
| 458 | s_kobj); |
| 459 | complete(&sbi->s_kobj_unregister); |
| 460 | } |
| 461 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 462 | enum feat_id { |
| 463 | FEAT_CRYPTO = 0, |
| 464 | FEAT_BLKZONED, |
| 465 | FEAT_ATOMIC_WRITE, |
| 466 | FEAT_EXTRA_ATTR, |
| 467 | FEAT_PROJECT_QUOTA, |
| 468 | FEAT_INODE_CHECKSUM, |
Chao Yu | 6afc662 | 2017-09-06 21:59:50 +0800 | [diff] [blame] | 469 | FEAT_FLEXIBLE_INLINE_XATTR, |
Jaegeuk Kim | 234a968 | 2017-10-05 21:03:06 -0700 | [diff] [blame] | 470 | FEAT_QUOTA_INO, |
Chao Yu | 1c1d35d | 2018-01-25 14:54:42 +0800 | [diff] [blame] | 471 | FEAT_INODE_CRTIME, |
Sheng Yong | b7c409d | 2018-03-15 18:51:41 +0800 | [diff] [blame] | 472 | FEAT_LOST_FOUND, |
Eric Biggers | 95ae251 | 2019-07-22 09:26:24 -0700 | [diff] [blame] | 473 | FEAT_VERITY, |
Junling Zheng | d440c52 | 2018-09-28 20:25:56 +0800 | [diff] [blame] | 474 | FEAT_SB_CHECKSUM, |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 475 | FEAT_CASEFOLD, |
Chao Yu | 4c8ff70 | 2019-11-01 18:07:14 +0800 | [diff] [blame] | 476 | FEAT_COMPRESSION, |
Eric Biggers | ed318a6 | 2020-05-12 16:32:50 -0700 | [diff] [blame] | 477 | FEAT_TEST_DUMMY_ENCRYPTION_V2, |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 478 | }; |
| 479 | |
| 480 | static ssize_t f2fs_feature_show(struct f2fs_attr *a, |
| 481 | struct f2fs_sb_info *sbi, char *buf) |
| 482 | { |
| 483 | switch (a->id) { |
| 484 | case FEAT_CRYPTO: |
| 485 | case FEAT_BLKZONED: |
| 486 | case FEAT_ATOMIC_WRITE: |
| 487 | case FEAT_EXTRA_ATTR: |
| 488 | case FEAT_PROJECT_QUOTA: |
| 489 | case FEAT_INODE_CHECKSUM: |
Chao Yu | 6afc662 | 2017-09-06 21:59:50 +0800 | [diff] [blame] | 490 | case FEAT_FLEXIBLE_INLINE_XATTR: |
Jaegeuk Kim | 234a968 | 2017-10-05 21:03:06 -0700 | [diff] [blame] | 491 | case FEAT_QUOTA_INO: |
Chao Yu | 1c1d35d | 2018-01-25 14:54:42 +0800 | [diff] [blame] | 492 | case FEAT_INODE_CRTIME: |
Sheng Yong | b7c409d | 2018-03-15 18:51:41 +0800 | [diff] [blame] | 493 | case FEAT_LOST_FOUND: |
Eric Biggers | 95ae251 | 2019-07-22 09:26:24 -0700 | [diff] [blame] | 494 | case FEAT_VERITY: |
Junling Zheng | d440c52 | 2018-09-28 20:25:56 +0800 | [diff] [blame] | 495 | case FEAT_SB_CHECKSUM: |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 496 | case FEAT_CASEFOLD: |
Chao Yu | 4c8ff70 | 2019-11-01 18:07:14 +0800 | [diff] [blame] | 497 | case FEAT_COMPRESSION: |
Eric Biggers | ed318a6 | 2020-05-12 16:32:50 -0700 | [diff] [blame] | 498 | case FEAT_TEST_DUMMY_ENCRYPTION_V2: |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 499 | return sprintf(buf, "supported\n"); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 500 | } |
| 501 | return 0; |
| 502 | } |
| 503 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 504 | #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ |
| 505 | static struct f2fs_attr f2fs_attr_##_name = { \ |
| 506 | .attr = {.name = __stringify(_name), .mode = _mode }, \ |
| 507 | .show = _show, \ |
| 508 | .store = _store, \ |
| 509 | .struct_type = _struct_type, \ |
| 510 | .offset = _offset \ |
| 511 | } |
| 512 | |
| 513 | #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ |
| 514 | F2FS_ATTR_OFFSET(struct_type, name, 0644, \ |
| 515 | f2fs_sbi_show, f2fs_sbi_store, \ |
| 516 | offsetof(struct struct_name, elname)) |
| 517 | |
| 518 | #define F2FS_GENERAL_RO_ATTR(name) \ |
| 519 | static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL) |
| 520 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 521 | #define F2FS_FEATURE_RO_ATTR(_name, _id) \ |
| 522 | static struct f2fs_attr f2fs_attr_##_name = { \ |
| 523 | .attr = {.name = __stringify(_name), .mode = 0444 }, \ |
| 524 | .show = f2fs_feature_show, \ |
| 525 | .id = _id, \ |
| 526 | } |
| 527 | |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 528 | #define F2FS_STAT_ATTR(_struct_type, _struct_name, _name, _elname) \ |
| 529 | static struct f2fs_attr f2fs_attr_##_name = { \ |
| 530 | .attr = {.name = __stringify(_name), .mode = 0444 }, \ |
| 531 | .show = f2fs_sbi_show, \ |
| 532 | .struct_type = _struct_type, \ |
| 533 | .offset = offsetof(struct _struct_name, _elname), \ |
| 534 | } |
| 535 | |
Jaegeuk Kim | d9872a6 | 2017-08-06 22:09:00 -0700 | [diff] [blame] | 536 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time, |
| 537 | urgent_sleep_time); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 538 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time); |
| 539 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time); |
| 540 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time); |
Jaegeuk Kim | 5b0e953 | 2018-05-07 14:22:40 -0700 | [diff] [blame] | 541 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode); |
| 542 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 543 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments); |
| 544 | F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards); |
Chao Yu | 969d1b1 | 2017-08-07 23:09:56 +0800 | [diff] [blame] | 545 | F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity); |
Chao Yu | daeb433 | 2017-06-26 16:24:41 +0800 | [diff] [blame] | 546 | F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 547 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections); |
| 548 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy); |
| 549 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util); |
| 550 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); |
Jaegeuk Kim | 853137c | 2018-08-09 17:53:34 -0700 | [diff] [blame] | 551 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 552 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks); |
Chao Yu | a2a12b6 | 2017-10-28 16:52:33 +0800 | [diff] [blame] | 553 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 554 | F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh); |
| 555 | F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages); |
| 556 | F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); |
| 557 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search); |
Chao Yu | 3465557 | 2018-10-25 16:19:28 +0800 | [diff] [blame] | 558 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, migration_granularity, migration_granularity); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 559 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level); |
| 560 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]); |
| 561 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]); |
Sahitya Tummala | a7d10cf | 2018-09-19 14:18:47 +0530 | [diff] [blame] | 562 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval, |
| 563 | interval_time[DISCARD_TIME]); |
| 564 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]); |
Jaegeuk Kim | 03f2c02 | 2019-01-14 10:42:11 -0800 | [diff] [blame] | 565 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, |
| 566 | umount_discard_timeout, interval_time[UMOUNT_DISCARD_TIMEOUT]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 567 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable); |
Daeho Jeong | 2bc4bea | 2020-03-30 03:30:59 +0000 | [diff] [blame] | 568 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_period_ms, iostat_period_ms); |
Sheng Yong | f6df8f2 | 2017-11-22 18:23:38 +0800 | [diff] [blame] | 569 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra); |
Jaegeuk Kim | 1020856 | 2020-12-03 09:52:45 -0800 | [diff] [blame^] | 570 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_io_bytes, max_io_bytes); |
Jaegeuk Kim | 1ad71a2 | 2017-12-07 16:25:39 -0800 | [diff] [blame] | 571 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold); |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 572 | F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 573 | #ifdef CONFIG_F2FS_FAULT_INJECTION |
| 574 | F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate); |
| 575 | F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type); |
| 576 | #endif |
Jaegeuk Kim | da9953b | 2020-04-02 09:32:35 -0700 | [diff] [blame] | 577 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag); |
Jaegeuk Kim | 32b6aba | 2020-06-04 11:49:43 -0700 | [diff] [blame] | 578 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag); |
Jaegeuk Kim | 8f1572f | 2017-10-24 09:46:54 +0200 | [diff] [blame] | 579 | F2FS_GENERAL_RO_ATTR(dirty_segments); |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 580 | F2FS_GENERAL_RO_ATTR(free_segments); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 581 | F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 582 | F2FS_GENERAL_RO_ATTR(features); |
Yunlong Song | 80d4214 | 2017-10-27 20:45:05 +0800 | [diff] [blame] | 583 | F2FS_GENERAL_RO_ATTR(current_reserved_blocks); |
Daniel Rosenberg | 4d3aed7 | 2019-05-29 17:49:06 -0700 | [diff] [blame] | 584 | F2FS_GENERAL_RO_ATTR(unusable); |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 585 | F2FS_GENERAL_RO_ATTR(encoding); |
Jaegeuk Kim | a7e679b | 2020-02-25 19:08:16 -0800 | [diff] [blame] | 586 | F2FS_GENERAL_RO_ATTR(mounted_time_sec); |
Dehe Gu | ffcde4b | 2020-07-03 17:51:29 +0800 | [diff] [blame] | 587 | F2FS_GENERAL_RO_ATTR(main_blkaddr); |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 588 | #ifdef CONFIG_F2FS_STAT_FS |
| 589 | F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_foreground_calls, cp_count); |
| 590 | F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_background_calls, bg_cp_count); |
| 591 | F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_foreground_calls, call_count); |
| 592 | F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_background_calls, bg_gc); |
| 593 | F2FS_GENERAL_RO_ATTR(moved_blocks_background); |
| 594 | F2FS_GENERAL_RO_ATTR(moved_blocks_foreground); |
| 595 | F2FS_GENERAL_RO_ATTR(avg_vblocks); |
| 596 | #endif |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 597 | |
Chandan Rajendra | 643fa96 | 2018-12-12 15:20:12 +0530 | [diff] [blame] | 598 | #ifdef CONFIG_FS_ENCRYPTION |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 599 | F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO); |
Eric Biggers | ed318a6 | 2020-05-12 16:32:50 -0700 | [diff] [blame] | 600 | F2FS_FEATURE_RO_ATTR(test_dummy_encryption_v2, FEAT_TEST_DUMMY_ENCRYPTION_V2); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 601 | #endif |
| 602 | #ifdef CONFIG_BLK_DEV_ZONED |
| 603 | F2FS_FEATURE_RO_ATTR(block_zoned, FEAT_BLKZONED); |
| 604 | #endif |
| 605 | F2FS_FEATURE_RO_ATTR(atomic_write, FEAT_ATOMIC_WRITE); |
| 606 | F2FS_FEATURE_RO_ATTR(extra_attr, FEAT_EXTRA_ATTR); |
| 607 | F2FS_FEATURE_RO_ATTR(project_quota, FEAT_PROJECT_QUOTA); |
| 608 | F2FS_FEATURE_RO_ATTR(inode_checksum, FEAT_INODE_CHECKSUM); |
Chao Yu | 6afc662 | 2017-09-06 21:59:50 +0800 | [diff] [blame] | 609 | F2FS_FEATURE_RO_ATTR(flexible_inline_xattr, FEAT_FLEXIBLE_INLINE_XATTR); |
Jaegeuk Kim | 234a968 | 2017-10-05 21:03:06 -0700 | [diff] [blame] | 610 | F2FS_FEATURE_RO_ATTR(quota_ino, FEAT_QUOTA_INO); |
Chao Yu | 1c1d35d | 2018-01-25 14:54:42 +0800 | [diff] [blame] | 611 | F2FS_FEATURE_RO_ATTR(inode_crtime, FEAT_INODE_CRTIME); |
Sheng Yong | b7c409d | 2018-03-15 18:51:41 +0800 | [diff] [blame] | 612 | F2FS_FEATURE_RO_ATTR(lost_found, FEAT_LOST_FOUND); |
Eric Biggers | 95ae251 | 2019-07-22 09:26:24 -0700 | [diff] [blame] | 613 | #ifdef CONFIG_FS_VERITY |
| 614 | F2FS_FEATURE_RO_ATTR(verity, FEAT_VERITY); |
| 615 | #endif |
Junling Zheng | d440c52 | 2018-09-28 20:25:56 +0800 | [diff] [blame] | 616 | F2FS_FEATURE_RO_ATTR(sb_checksum, FEAT_SB_CHECKSUM); |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 617 | F2FS_FEATURE_RO_ATTR(casefold, FEAT_CASEFOLD); |
Chao Yu | 9b6ed14 | 2020-03-27 18:29:00 +0800 | [diff] [blame] | 618 | #ifdef CONFIG_F2FS_FS_COMPRESSION |
Chao Yu | 4c8ff70 | 2019-11-01 18:07:14 +0800 | [diff] [blame] | 619 | F2FS_FEATURE_RO_ATTR(compression, FEAT_COMPRESSION); |
Chao Yu | 9b6ed14 | 2020-03-27 18:29:00 +0800 | [diff] [blame] | 620 | #endif |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 621 | |
| 622 | #define ATTR_LIST(name) (&f2fs_attr_##name.attr) |
| 623 | static struct attribute *f2fs_attrs[] = { |
Jaegeuk Kim | d9872a6 | 2017-08-06 22:09:00 -0700 | [diff] [blame] | 624 | ATTR_LIST(gc_urgent_sleep_time), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 625 | ATTR_LIST(gc_min_sleep_time), |
| 626 | ATTR_LIST(gc_max_sleep_time), |
| 627 | ATTR_LIST(gc_no_gc_sleep_time), |
| 628 | ATTR_LIST(gc_idle), |
Jaegeuk Kim | d9872a6 | 2017-08-06 22:09:00 -0700 | [diff] [blame] | 629 | ATTR_LIST(gc_urgent), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 630 | ATTR_LIST(reclaim_segments), |
Jaegeuk Kim | a4db59a | 2019-11-22 11:53:10 -0800 | [diff] [blame] | 631 | ATTR_LIST(main_blkaddr), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 632 | ATTR_LIST(max_small_discards), |
Chao Yu | 969d1b1 | 2017-08-07 23:09:56 +0800 | [diff] [blame] | 633 | ATTR_LIST(discard_granularity), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 634 | ATTR_LIST(batched_trim_sections), |
| 635 | ATTR_LIST(ipu_policy), |
| 636 | ATTR_LIST(min_ipu_util), |
| 637 | ATTR_LIST(min_fsync_blocks), |
Jaegeuk Kim | 853137c | 2018-08-09 17:53:34 -0700 | [diff] [blame] | 638 | ATTR_LIST(min_seq_blocks), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 639 | ATTR_LIST(min_hot_blocks), |
Chao Yu | a2a12b6 | 2017-10-28 16:52:33 +0800 | [diff] [blame] | 640 | ATTR_LIST(min_ssr_sections), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 641 | ATTR_LIST(max_victim_search), |
Chao Yu | 3465557 | 2018-10-25 16:19:28 +0800 | [diff] [blame] | 642 | ATTR_LIST(migration_granularity), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 643 | ATTR_LIST(dir_level), |
| 644 | ATTR_LIST(ram_thresh), |
| 645 | ATTR_LIST(ra_nid_pages), |
| 646 | ATTR_LIST(dirty_nats_ratio), |
| 647 | ATTR_LIST(cp_interval), |
| 648 | ATTR_LIST(idle_interval), |
Sahitya Tummala | a7d10cf | 2018-09-19 14:18:47 +0530 | [diff] [blame] | 649 | ATTR_LIST(discard_idle_interval), |
| 650 | ATTR_LIST(gc_idle_interval), |
Jaegeuk Kim | 03f2c02 | 2019-01-14 10:42:11 -0800 | [diff] [blame] | 651 | ATTR_LIST(umount_discard_timeout), |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 652 | ATTR_LIST(iostat_enable), |
Daeho Jeong | 2bc4bea | 2020-03-30 03:30:59 +0000 | [diff] [blame] | 653 | ATTR_LIST(iostat_period_ms), |
Sheng Yong | f6df8f2 | 2017-11-22 18:23:38 +0800 | [diff] [blame] | 654 | ATTR_LIST(readdir_ra), |
Jaegeuk Kim | 1020856 | 2020-12-03 09:52:45 -0800 | [diff] [blame^] | 655 | ATTR_LIST(max_io_bytes), |
Jaegeuk Kim | 1ad71a2 | 2017-12-07 16:25:39 -0800 | [diff] [blame] | 656 | ATTR_LIST(gc_pin_file_thresh), |
Chao Yu | 846ae67 | 2018-02-26 22:04:13 +0800 | [diff] [blame] | 657 | ATTR_LIST(extension_list), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 658 | #ifdef CONFIG_F2FS_FAULT_INJECTION |
| 659 | ATTR_LIST(inject_rate), |
| 660 | ATTR_LIST(inject_type), |
| 661 | #endif |
Jaegeuk Kim | da9953b | 2020-04-02 09:32:35 -0700 | [diff] [blame] | 662 | ATTR_LIST(data_io_flag), |
Jaegeuk Kim | 32b6aba | 2020-06-04 11:49:43 -0700 | [diff] [blame] | 663 | ATTR_LIST(node_io_flag), |
Jaegeuk Kim | 8f1572f | 2017-10-24 09:46:54 +0200 | [diff] [blame] | 664 | ATTR_LIST(dirty_segments), |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 665 | ATTR_LIST(free_segments), |
Daniel Rosenberg | 4d3aed7 | 2019-05-29 17:49:06 -0700 | [diff] [blame] | 666 | ATTR_LIST(unusable), |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 667 | ATTR_LIST(lifetime_write_kbytes), |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 668 | ATTR_LIST(features), |
Chao Yu | daeb433 | 2017-06-26 16:24:41 +0800 | [diff] [blame] | 669 | ATTR_LIST(reserved_blocks), |
Yunlong Song | 80d4214 | 2017-10-27 20:45:05 +0800 | [diff] [blame] | 670 | ATTR_LIST(current_reserved_blocks), |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 671 | ATTR_LIST(encoding), |
Jaegeuk Kim | a7e679b | 2020-02-25 19:08:16 -0800 | [diff] [blame] | 672 | ATTR_LIST(mounted_time_sec), |
Hridya Valsaraju | fc7100e | 2020-01-22 10:51:16 -0800 | [diff] [blame] | 673 | #ifdef CONFIG_F2FS_STAT_FS |
| 674 | ATTR_LIST(cp_foreground_calls), |
| 675 | ATTR_LIST(cp_background_calls), |
| 676 | ATTR_LIST(gc_foreground_calls), |
| 677 | ATTR_LIST(gc_background_calls), |
| 678 | ATTR_LIST(moved_blocks_foreground), |
| 679 | ATTR_LIST(moved_blocks_background), |
| 680 | ATTR_LIST(avg_vblocks), |
| 681 | #endif |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 682 | NULL, |
| 683 | }; |
Kimberly Brown | 176ef3c | 2019-06-07 13:40:41 -0400 | [diff] [blame] | 684 | ATTRIBUTE_GROUPS(f2fs); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 685 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 686 | static struct attribute *f2fs_feat_attrs[] = { |
Chandan Rajendra | 643fa96 | 2018-12-12 15:20:12 +0530 | [diff] [blame] | 687 | #ifdef CONFIG_FS_ENCRYPTION |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 688 | ATTR_LIST(encryption), |
Eric Biggers | ed318a6 | 2020-05-12 16:32:50 -0700 | [diff] [blame] | 689 | ATTR_LIST(test_dummy_encryption_v2), |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 690 | #endif |
| 691 | #ifdef CONFIG_BLK_DEV_ZONED |
| 692 | ATTR_LIST(block_zoned), |
| 693 | #endif |
| 694 | ATTR_LIST(atomic_write), |
| 695 | ATTR_LIST(extra_attr), |
| 696 | ATTR_LIST(project_quota), |
| 697 | ATTR_LIST(inode_checksum), |
Chao Yu | 6afc662 | 2017-09-06 21:59:50 +0800 | [diff] [blame] | 698 | ATTR_LIST(flexible_inline_xattr), |
Jaegeuk Kim | 234a968 | 2017-10-05 21:03:06 -0700 | [diff] [blame] | 699 | ATTR_LIST(quota_ino), |
Chao Yu | 1c1d35d | 2018-01-25 14:54:42 +0800 | [diff] [blame] | 700 | ATTR_LIST(inode_crtime), |
Sheng Yong | b7c409d | 2018-03-15 18:51:41 +0800 | [diff] [blame] | 701 | ATTR_LIST(lost_found), |
Eric Biggers | 95ae251 | 2019-07-22 09:26:24 -0700 | [diff] [blame] | 702 | #ifdef CONFIG_FS_VERITY |
| 703 | ATTR_LIST(verity), |
| 704 | #endif |
Junling Zheng | d440c52 | 2018-09-28 20:25:56 +0800 | [diff] [blame] | 705 | ATTR_LIST(sb_checksum), |
Daniel Rosenberg | 5aba543 | 2019-07-23 16:05:28 -0700 | [diff] [blame] | 706 | ATTR_LIST(casefold), |
Chao Yu | 9b6ed14 | 2020-03-27 18:29:00 +0800 | [diff] [blame] | 707 | #ifdef CONFIG_F2FS_FS_COMPRESSION |
Chao Yu | 4c8ff70 | 2019-11-01 18:07:14 +0800 | [diff] [blame] | 708 | ATTR_LIST(compression), |
Chao Yu | 9b6ed14 | 2020-03-27 18:29:00 +0800 | [diff] [blame] | 709 | #endif |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 710 | NULL, |
| 711 | }; |
Kimberly Brown | 176ef3c | 2019-06-07 13:40:41 -0400 | [diff] [blame] | 712 | ATTRIBUTE_GROUPS(f2fs_feat); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 713 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 714 | static const struct sysfs_ops f2fs_attr_ops = { |
| 715 | .show = f2fs_attr_show, |
| 716 | .store = f2fs_attr_store, |
| 717 | }; |
| 718 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 719 | static struct kobj_type f2fs_sb_ktype = { |
Kimberly Brown | 176ef3c | 2019-06-07 13:40:41 -0400 | [diff] [blame] | 720 | .default_groups = f2fs_groups, |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 721 | .sysfs_ops = &f2fs_attr_ops, |
| 722 | .release = f2fs_sb_release, |
| 723 | }; |
| 724 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 725 | static struct kobj_type f2fs_ktype = { |
| 726 | .sysfs_ops = &f2fs_attr_ops, |
| 727 | }; |
| 728 | |
| 729 | static struct kset f2fs_kset = { |
Jack Qiu | a87aff1 | 2020-07-24 16:55:28 +0800 | [diff] [blame] | 730 | .kobj = {.ktype = &f2fs_ktype}, |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 731 | }; |
| 732 | |
| 733 | static struct kobj_type f2fs_feat_ktype = { |
Kimberly Brown | 176ef3c | 2019-06-07 13:40:41 -0400 | [diff] [blame] | 734 | .default_groups = f2fs_feat_groups, |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 735 | .sysfs_ops = &f2fs_attr_ops, |
| 736 | }; |
| 737 | |
| 738 | static struct kobject f2fs_feat = { |
| 739 | .kset = &f2fs_kset, |
| 740 | }; |
| 741 | |
Randy Dunlap | cb15d1e | 2018-07-06 20:50:57 -0700 | [diff] [blame] | 742 | static int __maybe_unused segment_info_seq_show(struct seq_file *seq, |
| 743 | void *offset) |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 744 | { |
| 745 | struct super_block *sb = seq->private; |
| 746 | struct f2fs_sb_info *sbi = F2FS_SB(sb); |
| 747 | unsigned int total_segs = |
| 748 | le32_to_cpu(sbi->raw_super->segment_count_main); |
| 749 | int i; |
| 750 | |
| 751 | seq_puts(seq, "format: segment_type|valid_blocks\n" |
| 752 | "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); |
| 753 | |
| 754 | for (i = 0; i < total_segs; i++) { |
| 755 | struct seg_entry *se = get_seg_entry(sbi, i); |
| 756 | |
| 757 | if ((i % 10) == 0) |
| 758 | seq_printf(seq, "%-10d", i); |
Chao Yu | 8740edc | 2019-06-18 18:00:09 +0800 | [diff] [blame] | 759 | seq_printf(seq, "%d|%-3u", se->type, se->valid_blocks); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 760 | if ((i % 10) == 9 || i == (total_segs - 1)) |
| 761 | seq_putc(seq, '\n'); |
| 762 | else |
| 763 | seq_putc(seq, ' '); |
| 764 | } |
| 765 | |
| 766 | return 0; |
| 767 | } |
| 768 | |
Randy Dunlap | cb15d1e | 2018-07-06 20:50:57 -0700 | [diff] [blame] | 769 | static int __maybe_unused segment_bits_seq_show(struct seq_file *seq, |
| 770 | void *offset) |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 771 | { |
| 772 | struct super_block *sb = seq->private; |
| 773 | struct f2fs_sb_info *sbi = F2FS_SB(sb); |
| 774 | unsigned int total_segs = |
| 775 | le32_to_cpu(sbi->raw_super->segment_count_main); |
| 776 | int i, j; |
| 777 | |
| 778 | seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n" |
| 779 | "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); |
| 780 | |
| 781 | for (i = 0; i < total_segs; i++) { |
| 782 | struct seg_entry *se = get_seg_entry(sbi, i); |
| 783 | |
| 784 | seq_printf(seq, "%-10d", i); |
Chao Yu | 8740edc | 2019-06-18 18:00:09 +0800 | [diff] [blame] | 785 | seq_printf(seq, "%d|%-3u|", se->type, se->valid_blocks); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 786 | for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++) |
| 787 | seq_printf(seq, " %.2x", se->cur_valid_map[j]); |
| 788 | seq_putc(seq, '\n'); |
| 789 | } |
| 790 | return 0; |
| 791 | } |
| 792 | |
Daeho Jeong | 2bc4bea | 2020-03-30 03:30:59 +0000 | [diff] [blame] | 793 | void f2fs_record_iostat(struct f2fs_sb_info *sbi) |
| 794 | { |
| 795 | unsigned long long iostat_diff[NR_IO_TYPE]; |
| 796 | int i; |
| 797 | |
| 798 | if (time_is_after_jiffies(sbi->iostat_next_period)) |
| 799 | return; |
| 800 | |
| 801 | /* Need double check under the lock */ |
| 802 | spin_lock(&sbi->iostat_lock); |
| 803 | if (time_is_after_jiffies(sbi->iostat_next_period)) { |
| 804 | spin_unlock(&sbi->iostat_lock); |
| 805 | return; |
| 806 | } |
| 807 | sbi->iostat_next_period = jiffies + |
| 808 | msecs_to_jiffies(sbi->iostat_period_ms); |
| 809 | |
| 810 | for (i = 0; i < NR_IO_TYPE; i++) { |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 811 | iostat_diff[i] = sbi->rw_iostat[i] - |
| 812 | sbi->prev_rw_iostat[i]; |
| 813 | sbi->prev_rw_iostat[i] = sbi->rw_iostat[i]; |
Daeho Jeong | 2bc4bea | 2020-03-30 03:30:59 +0000 | [diff] [blame] | 814 | } |
| 815 | spin_unlock(&sbi->iostat_lock); |
| 816 | |
| 817 | trace_f2fs_iostat(sbi, iostat_diff); |
| 818 | } |
| 819 | |
Randy Dunlap | cb15d1e | 2018-07-06 20:50:57 -0700 | [diff] [blame] | 820 | static int __maybe_unused iostat_info_seq_show(struct seq_file *seq, |
| 821 | void *offset) |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 822 | { |
| 823 | struct super_block *sb = seq->private; |
| 824 | struct f2fs_sb_info *sbi = F2FS_SB(sb); |
| 825 | time64_t now = ktime_get_real_seconds(); |
| 826 | |
| 827 | if (!sbi->iostat_enable) |
| 828 | return 0; |
| 829 | |
| 830 | seq_printf(seq, "time: %-16llu\n", now); |
| 831 | |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 832 | /* print app write IOs */ |
Chao Yu | 9c12238 | 2020-04-23 18:03:06 +0800 | [diff] [blame] | 833 | seq_puts(seq, "[WRITE]\n"); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 834 | seq_printf(seq, "app buffered: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 835 | sbi->rw_iostat[APP_BUFFERED_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 836 | seq_printf(seq, "app direct: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 837 | sbi->rw_iostat[APP_DIRECT_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 838 | seq_printf(seq, "app mapped: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 839 | sbi->rw_iostat[APP_MAPPED_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 840 | |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 841 | /* print fs write IOs */ |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 842 | seq_printf(seq, "fs data: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 843 | sbi->rw_iostat[FS_DATA_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 844 | seq_printf(seq, "fs node: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 845 | sbi->rw_iostat[FS_NODE_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 846 | seq_printf(seq, "fs meta: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 847 | sbi->rw_iostat[FS_META_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 848 | seq_printf(seq, "fs gc data: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 849 | sbi->rw_iostat[FS_GC_DATA_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 850 | seq_printf(seq, "fs gc node: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 851 | sbi->rw_iostat[FS_GC_NODE_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 852 | seq_printf(seq, "fs cp data: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 853 | sbi->rw_iostat[FS_CP_DATA_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 854 | seq_printf(seq, "fs cp node: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 855 | sbi->rw_iostat[FS_CP_NODE_IO]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 856 | seq_printf(seq, "fs cp meta: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 857 | sbi->rw_iostat[FS_CP_META_IO]); |
| 858 | |
| 859 | /* print app read IOs */ |
Chao Yu | 9c12238 | 2020-04-23 18:03:06 +0800 | [diff] [blame] | 860 | seq_puts(seq, "[READ]\n"); |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 861 | seq_printf(seq, "app buffered: %-16llu\n", |
| 862 | sbi->rw_iostat[APP_BUFFERED_READ_IO]); |
| 863 | seq_printf(seq, "app direct: %-16llu\n", |
| 864 | sbi->rw_iostat[APP_DIRECT_READ_IO]); |
| 865 | seq_printf(seq, "app mapped: %-16llu\n", |
| 866 | sbi->rw_iostat[APP_MAPPED_READ_IO]); |
| 867 | |
| 868 | /* print fs read IOs */ |
| 869 | seq_printf(seq, "fs data: %-16llu\n", |
| 870 | sbi->rw_iostat[FS_DATA_READ_IO]); |
Chao Yu | 9c12238 | 2020-04-23 18:03:06 +0800 | [diff] [blame] | 871 | seq_printf(seq, "fs gc data: %-16llu\n", |
| 872 | sbi->rw_iostat[FS_GDATA_READ_IO]); |
| 873 | seq_printf(seq, "fs compr_data: %-16llu\n", |
| 874 | sbi->rw_iostat[FS_CDATA_READ_IO]); |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 875 | seq_printf(seq, "fs node: %-16llu\n", |
| 876 | sbi->rw_iostat[FS_NODE_READ_IO]); |
| 877 | seq_printf(seq, "fs meta: %-16llu\n", |
| 878 | sbi->rw_iostat[FS_META_READ_IO]); |
| 879 | |
| 880 | /* print other IOs */ |
Chao Yu | 9c12238 | 2020-04-23 18:03:06 +0800 | [diff] [blame] | 881 | seq_puts(seq, "[OTHER]\n"); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 882 | seq_printf(seq, "fs discard: %-16llu\n", |
Chao Yu | 8b83ac8 | 2020-04-16 18:16:56 +0800 | [diff] [blame] | 883 | sbi->rw_iostat[FS_DISCARD]); |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 884 | |
| 885 | return 0; |
| 886 | } |
| 887 | |
Yunlong Song | 970e348 | 2018-07-23 22:10:22 +0800 | [diff] [blame] | 888 | static int __maybe_unused victim_bits_seq_show(struct seq_file *seq, |
| 889 | void *offset) |
| 890 | { |
| 891 | struct super_block *sb = seq->private; |
| 892 | struct f2fs_sb_info *sbi = F2FS_SB(sb); |
| 893 | struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); |
| 894 | int i; |
| 895 | |
| 896 | seq_puts(seq, "format: victim_secmap bitmaps\n"); |
| 897 | |
| 898 | for (i = 0; i < MAIN_SECS(sbi); i++) { |
| 899 | if ((i % 10) == 0) |
| 900 | seq_printf(seq, "%-10d", i); |
| 901 | seq_printf(seq, "%d", test_bit(i, dirty_i->victim_secmap) ? 1 : 0); |
| 902 | if ((i % 10) == 9 || i == (MAIN_SECS(sbi) - 1)) |
| 903 | seq_putc(seq, '\n'); |
| 904 | else |
| 905 | seq_putc(seq, ' '); |
| 906 | } |
| 907 | return 0; |
| 908 | } |
| 909 | |
Jaegeuk Kim | dc6b205 | 2017-07-26 11:24:13 -0700 | [diff] [blame] | 910 | int __init f2fs_init_sysfs(void) |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 911 | { |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 912 | int ret; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 913 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 914 | kobject_set_name(&f2fs_kset.kobj, "f2fs"); |
| 915 | f2fs_kset.kobj.parent = fs_kobj; |
| 916 | ret = kset_register(&f2fs_kset); |
| 917 | if (ret) |
| 918 | return ret; |
| 919 | |
| 920 | ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype, |
| 921 | NULL, "features"); |
Chao Yu | fe396ad | 2019-12-30 17:41:41 +0800 | [diff] [blame] | 922 | if (ret) { |
| 923 | kobject_put(&f2fs_feat); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 924 | kset_unregister(&f2fs_kset); |
Chao Yu | fe396ad | 2019-12-30 17:41:41 +0800 | [diff] [blame] | 925 | } else { |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 926 | f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); |
Chao Yu | fe396ad | 2019-12-30 17:41:41 +0800 | [diff] [blame] | 927 | } |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 928 | return ret; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 929 | } |
| 930 | |
Jaegeuk Kim | dc6b205 | 2017-07-26 11:24:13 -0700 | [diff] [blame] | 931 | void f2fs_exit_sysfs(void) |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 932 | { |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 933 | kobject_put(&f2fs_feat); |
| 934 | kset_unregister(&f2fs_kset); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 935 | remove_proc_entry("fs/f2fs", NULL); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 936 | f2fs_proc_root = NULL; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 937 | } |
| 938 | |
Jaegeuk Kim | dc6b205 | 2017-07-26 11:24:13 -0700 | [diff] [blame] | 939 | int f2fs_register_sysfs(struct f2fs_sb_info *sbi) |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 940 | { |
| 941 | struct super_block *sb = sbi->sb; |
| 942 | int err; |
| 943 | |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 944 | sbi->s_kobj.kset = &f2fs_kset; |
| 945 | init_completion(&sbi->s_kobj_unregister); |
| 946 | err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL, |
| 947 | "%s", sb->s_id); |
Chao Yu | fe396ad | 2019-12-30 17:41:41 +0800 | [diff] [blame] | 948 | if (err) { |
| 949 | kobject_put(&sbi->s_kobj); |
| 950 | wait_for_completion(&sbi->s_kobj_unregister); |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 951 | return err; |
Chao Yu | fe396ad | 2019-12-30 17:41:41 +0800 | [diff] [blame] | 952 | } |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 953 | |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 954 | if (f2fs_proc_root) |
| 955 | sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root); |
| 956 | |
| 957 | if (sbi->s_proc) { |
Christoph Hellwig | 3f3942a | 2018-05-15 15:57:23 +0200 | [diff] [blame] | 958 | proc_create_single_data("segment_info", S_IRUGO, sbi->s_proc, |
| 959 | segment_info_seq_show, sb); |
| 960 | proc_create_single_data("segment_bits", S_IRUGO, sbi->s_proc, |
| 961 | segment_bits_seq_show, sb); |
| 962 | proc_create_single_data("iostat_info", S_IRUGO, sbi->s_proc, |
| 963 | iostat_info_seq_show, sb); |
Yunlong Song | 970e348 | 2018-07-23 22:10:22 +0800 | [diff] [blame] | 964 | proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc, |
| 965 | victim_bits_seq_show, sb); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 966 | } |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 967 | return 0; |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 968 | } |
| 969 | |
Jaegeuk Kim | dc6b205 | 2017-07-26 11:24:13 -0700 | [diff] [blame] | 970 | void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi) |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 971 | { |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 972 | if (sbi->s_proc) { |
Chao Yu | b0af6d4 | 2017-08-02 23:21:48 +0800 | [diff] [blame] | 973 | remove_proc_entry("iostat_info", sbi->s_proc); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 974 | remove_proc_entry("segment_info", sbi->s_proc); |
| 975 | remove_proc_entry("segment_bits", sbi->s_proc); |
Yunlong Song | 970e348 | 2018-07-23 22:10:22 +0800 | [diff] [blame] | 976 | remove_proc_entry("victim_bits", sbi->s_proc); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 977 | remove_proc_entry(sbi->sb->s_id, f2fs_proc_root); |
| 978 | } |
Jaegeuk Kim | bf9e697 | 2017-07-21 17:14:09 -0700 | [diff] [blame] | 979 | kobject_del(&sbi->s_kobj); |
Jaegeuk Kim | 820d366 | 2019-12-13 18:32:16 -0800 | [diff] [blame] | 980 | kobject_put(&sbi->s_kobj); |
Jamie Iles | ae284d8 | 2020-10-12 14:09:48 +0100 | [diff] [blame] | 981 | wait_for_completion(&sbi->s_kobj_unregister); |
Chao Yu | 8ceffcb | 2017-06-14 17:39:47 +0800 | [diff] [blame] | 982 | } |