blob: 989a649cfa8b5397c5bd72ac96be79e499be96ac [file] [log] [blame]
Chao Yu7c1a0002018-09-12 09:16:07 +08001// SPDX-License-Identifier: GPL-2.0
Chao Yu8ceffcb2017-06-14 17:39:47 +08002/*
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 Yu8ceffcb2017-06-14 17:39:47 +08008 */
Randy Dunlapcb15d1e2018-07-06 20:50:57 -07009#include <linux/compiler.h>
Chao Yu8ceffcb2017-06-14 17:39:47 +080010#include <linux/proc_fs.h>
11#include <linux/f2fs_fs.h>
Jaegeuk Kim299aa412017-07-13 17:45:21 -070012#include <linux/seq_file.h>
Daniel Rosenberg5aba5432019-07-23 16:05:28 -070013#include <linux/unicode.h>
Chao Yu8ceffcb2017-06-14 17:39:47 +080014
15#include "f2fs.h"
16#include "segment.h"
17#include "gc.h"
Daeho Jeong2bc4bea2020-03-30 03:30:59 +000018#include <trace/events/f2fs.h>
Chao Yu8ceffcb2017-06-14 17:39:47 +080019
20static struct proc_dir_entry *f2fs_proc_root;
Chao Yu8ceffcb2017-06-14 17:39:47 +080021
22/* Sysfs support for f2fs */
23enum {
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 Valsarajufc7100e2020-01-22 10:51:16 -080029#ifdef CONFIG_F2FS_STAT_FS
Jack Qiua87aff12020-07-24 16:55:28 +080030 STAT_INFO, /* struct f2fs_stat_info */
Hridya Valsarajufc7100e2020-01-22 10:51:16 -080031#endif
Chao Yu8ceffcb2017-06-14 17:39:47 +080032#ifdef CONFIG_F2FS_FAULT_INJECTION
33 FAULT_INFO_RATE, /* struct f2fs_fault_info */
34 FAULT_INFO_TYPE, /* struct f2fs_fault_info */
35#endif
Yunlong Song80d42142017-10-27 20:45:05 +080036 RESERVED_BLOCKS, /* struct f2fs_sb_info */
Chao Yu8ceffcb2017-06-14 17:39:47 +080037};
38
39struct 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 Kimbf9e6972017-07-21 17:14:09 -070046 int id;
Chao Yu8ceffcb2017-06-14 17:39:47 +080047};
48
Hridya Valsarajufc7100e2020-01-22 10:51:16 -080049static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
50 struct f2fs_sb_info *sbi, char *buf);
51
Chao Yu8ceffcb2017-06-14 17:39:47 +080052static 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 Yudaeb4332017-06-26 16:24:41 +080062 else if (struct_type == F2FS_SBI || struct_type == RESERVED_BLOCKS)
Chao Yu8ceffcb2017-06-14 17:39:47 +080063 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 Yu63189b72018-03-08 14:22:56 +080067 return (unsigned char *)&F2FS_OPTION(sbi).fault_info;
Chao Yu8ceffcb2017-06-14 17:39:47 +080068#endif
Hridya Valsarajufc7100e2020-01-22 10:51:16 -080069#ifdef CONFIG_F2FS_STAT_FS
70 else if (struct_type == STAT_INFO)
71 return (unsigned char *)F2FS_STAT(sbi);
72#endif
Chao Yu8ceffcb2017-06-14 17:39:47 +080073 return NULL;
74}
75
Jaegeuk Kim8f1572f2017-10-24 09:46:54 +020076static ssize_t dirty_segments_show(struct f2fs_attr *a,
77 struct f2fs_sb_info *sbi, char *buf)
78{
Hridya Valsarajufc7100e2020-01-22 10:51:16 -080079 return sprintf(buf, "%llu\n",
80 (unsigned long long)(dirty_segments(sbi)));
Jaegeuk Kim8f1572f2017-10-24 09:46:54 +020081}
82
Hridya Valsarajufc7100e2020-01-22 10:51:16 -080083static ssize_t free_segments_show(struct f2fs_attr *a,
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -070084 struct f2fs_sb_info *sbi, char *buf)
85{
Hridya Valsarajufc7100e2020-01-22 10:51:16 -080086 return sprintf(buf, "%llu\n",
87 (unsigned long long)(free_segments(sbi)));
Daniel Rosenberg5aba5432019-07-23 16:05:28 -070088}
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -070089
Chao Yu8ceffcb2017-06-14 17:39:47 +080090static 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 Valsarajufc7100e2020-01-22 10:51:16 -080096 return sprintf(buf, "0\n");
Chao Yu8ceffcb2017-06-14 17:39:47 +080097
Hridya Valsarajufc7100e2020-01-22 10:51:16 -080098 return sprintf(buf, "%llu\n",
99 (unsigned long long)(sbi->kbytes_written +
Chao Yu3a0a9cb2020-11-27 21:20:06 +0800100 ((f2fs_get_sectors_written(sbi) -
101 sbi->sectors_written_start) >> 1)));
Chao Yu8ceffcb2017-06-14 17:39:47 +0800102}
103
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700104static 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 Valsarajufc7100e2020-01-22 10:51:16 -0800111 return sprintf(buf, "0\n");
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700112
Chao Yu7beb01f2018-10-24 18:34:26 +0800113 if (f2fs_sb_has_encrypt(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100114 len += scnprintf(buf, PAGE_SIZE - len, "%s",
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700115 "encryption");
Chao Yu7beb01f2018-10-24 18:34:26 +0800116 if (f2fs_sb_has_blkzoned(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100117 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700118 len ? ", " : "", "blkzoned");
Chao Yu7beb01f2018-10-24 18:34:26 +0800119 if (f2fs_sb_has_extra_attr(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100120 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700121 len ? ", " : "", "extra_attr");
Chao Yu7beb01f2018-10-24 18:34:26 +0800122 if (f2fs_sb_has_project_quota(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100123 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700124 len ? ", " : "", "projquota");
Chao Yu7beb01f2018-10-24 18:34:26 +0800125 if (f2fs_sb_has_inode_chksum(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100126 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700127 len ? ", " : "", "inode_checksum");
Chao Yu7beb01f2018-10-24 18:34:26 +0800128 if (f2fs_sb_has_flexible_inline_xattr(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100129 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Chao Yu6afc6622017-09-06 21:59:50 +0800130 len ? ", " : "", "flexible_inline_xattr");
Chao Yu7beb01f2018-10-24 18:34:26 +0800131 if (f2fs_sb_has_quota_ino(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100132 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Jaegeuk Kim234a9682017-10-05 21:03:06 -0700133 len ? ", " : "", "quota_ino");
Chao Yu7beb01f2018-10-24 18:34:26 +0800134 if (f2fs_sb_has_inode_crtime(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100135 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Chao Yu1c1d35d2018-01-25 14:54:42 +0800136 len ? ", " : "", "inode_crtime");
Chao Yu7beb01f2018-10-24 18:34:26 +0800137 if (f2fs_sb_has_lost_found(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100138 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Sheng Yongb7c409d2018-03-15 18:51:41 +0800139 len ? ", " : "", "lost_found");
Eric Biggers95ae2512019-07-22 09:26:24 -0700140 if (f2fs_sb_has_verity(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100141 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Eric Biggers95ae2512019-07-22 09:26:24 -0700142 len ? ", " : "", "verity");
Chao Yu7beb01f2018-10-24 18:34:26 +0800143 if (f2fs_sb_has_sb_chksum(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100144 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Junling Zhengd440c522018-09-28 20:25:56 +0800145 len ? ", " : "", "sb_checksum");
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700146 if (f2fs_sb_has_casefold(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100147 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700148 len ? ", " : "", "casefold");
Chao Yu4c8ff702019-11-01 18:07:14 +0800149 if (f2fs_sb_has_compression(sbi))
Takashi Iwaic6d57892020-03-11 10:33:53 +0100150 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Chao Yu4c8ff702019-11-01 18:07:14 +0800151 len ? ", " : "", "compression");
Takashi Iwaic6d57892020-03-11 10:33:53 +0100152 len += scnprintf(buf + len, PAGE_SIZE - len, "%s%s",
Jaegeuk Kimf5a53ed2019-10-18 10:06:40 -0700153 len ? ", " : "", "pin_file");
Takashi Iwaic6d57892020-03-11 10:33:53 +0100154 len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700155 return len;
156}
157
Yunlong Song80d42142017-10-27 20:45:05 +0800158static ssize_t current_reserved_blocks_show(struct f2fs_attr *a,
159 struct f2fs_sb_info *sbi, char *buf)
160{
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800161 return sprintf(buf, "%u\n", sbi->current_reserved_blocks);
Yunlong Song80d42142017-10-27 20:45:05 +0800162}
163
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800164static 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
176static ssize_t encoding_show(struct f2fs_attr *a,
177 struct f2fs_sb_info *sbi, char *buf)
178{
179#ifdef CONFIG_UNICODE
Daniel Rosenbergeca48732020-07-08 02:12:36 -0700180 struct super_block *sb = sbi->sb;
181
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800182 if (f2fs_sb_has_casefold(sbi))
183 return snprintf(buf, PAGE_SIZE, "%s (%d.%d.%d)\n",
Daniel Rosenbergeca48732020-07-08 02:12:36 -0700184 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 Valsarajufc7100e2020-01-22 10:51:16 -0800188#endif
189 return sprintf(buf, "(none)");
190}
191
Jaegeuk Kima7e679b2020-02-25 19:08:16 -0800192static 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 Valsarajufc7100e2020-01-22 10:51:16 -0800198#ifdef CONFIG_F2FS_STAT_FS
199static 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
209static 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
218static 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 Guffcde4b2020-07-03 17:51:29 +0800229static 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 Yu8ceffcb2017-06-14 17:39:47 +0800236static 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 Yu846ae672018-02-26 22:04:13 +0800246 if (!strcmp(a->attr.name, "extension_list")) {
247 __u8 (*extlist)[F2FS_EXTENSION_LEN] =
248 sbi->raw_super->extension_list;
Chao Yub6a06cb2018-02-28 17:07:27 +0800249 int cold_count = le32_to_cpu(sbi->raw_super->extension_count);
250 int hot_count = sbi->raw_super->hot_ext_count;
Chao Yu846ae672018-02-26 22:04:13 +0800251 int len = 0, i;
252
Takashi Iwaic6d57892020-03-11 10:33:53 +0100253 len += scnprintf(buf + len, PAGE_SIZE - len,
Colin Ian King45800382018-04-30 16:27:44 +0100254 "cold file extension:\n");
Chao Yub6a06cb2018-02-28 17:07:27 +0800255 for (i = 0; i < cold_count; i++)
Takashi Iwaic6d57892020-03-11 10:33:53 +0100256 len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n",
Chao Yub6a06cb2018-02-28 17:07:27 +0800257 extlist[i]);
258
Takashi Iwaic6d57892020-03-11 10:33:53 +0100259 len += scnprintf(buf + len, PAGE_SIZE - len,
Colin Ian King45800382018-04-30 16:27:44 +0100260 "hot file extension:\n");
Chao Yub6a06cb2018-02-28 17:07:27 +0800261 for (i = cold_count; i < cold_count + hot_count; i++)
Takashi Iwaic6d57892020-03-11 10:33:53 +0100262 len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n",
Chao Yu846ae672018-02-26 22:04:13 +0800263 extlist[i]);
264 return len;
265 }
266
Chao Yu8ceffcb2017-06-14 17:39:47 +0800267 ui = (unsigned int *)(ptr + a->offset);
268
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800269 return sprintf(buf, "%u\n", *ui);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800270}
271
Chao Yu4d57b862018-05-30 00:20:41 +0800272static ssize_t __sbi_store(struct f2fs_attr *a,
Chao Yu8ceffcb2017-06-14 17:39:47 +0800273 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 Yu846ae672018-02-26 22:04:13 +0800285 if (!strcmp(a->attr.name, "extension_list")) {
286 const char *name = strim((char *)buf);
Chao Yub6a06cb2018-02-28 17:07:27 +0800287 bool set = true, hot;
Chao Yu846ae672018-02-26 22:04:13 +0800288
Chao Yub6a06cb2018-02-28 17:07:27 +0800289 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 Yu846ae672018-02-26 22:04:13 +0800299 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 Yu4d57b862018-05-30 00:20:41 +0800308 ret = f2fs_update_extension_list(sbi, name, hot, set);
Chao Yu846ae672018-02-26 22:04:13 +0800309 if (ret)
310 goto out;
311
312 ret = f2fs_commit_super(sbi, false);
313 if (ret)
Chao Yu4d57b862018-05-30 00:20:41 +0800314 f2fs_update_extension_list(sbi, name, hot, !set);
Chao Yu846ae672018-02-26 22:04:13 +0800315out:
316 up_write(&sbi->sb_lock);
317 return ret ? ret : count;
318 }
319
Chao Yu8ceffcb2017-06-14 17:39:47 +0800320 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 Yu36c57332019-01-04 17:39:53 +0800328 if (a->struct_type == FAULT_INFO_RATE && t >= UINT_MAX)
329 return -EINVAL;
Chao Yu8ceffcb2017-06-14 17:39:47 +0800330#endif
Chao Yudaeb4332017-06-26 16:24:41 +0800331 if (a->struct_type == RESERVED_BLOCKS) {
332 spin_lock(&sbi->stat_lock);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800333 if (t > (unsigned long)(sbi->user_block_count -
Chao Yu63189b72018-03-08 14:22:56 +0800334 F2FS_OPTION(sbi).root_reserved_blocks)) {
Chao Yudaeb4332017-06-26 16:24:41 +0800335 spin_unlock(&sbi->stat_lock);
336 return -EINVAL;
337 }
338 *ui = t;
Yunlong Song80d42142017-10-27 20:45:05 +0800339 sbi->current_reserved_blocks = min(sbi->reserved_blocks,
340 sbi->user_block_count - valid_user_blocks(sbi));
Chao Yudaeb4332017-06-26 16:24:41 +0800341 spin_unlock(&sbi->stat_lock);
342 return count;
343 }
Chao Yu969d1b12017-08-07 23:09:56 +0800344
345 if (!strcmp(a->attr.name, "discard_granularity")) {
Chao Yu969d1b12017-08-07 23:09:56 +0800346 if (t == 0 || t > MAX_PLIST_NUM)
347 return -EINVAL;
348 if (t == *ui)
349 return count;
Chao Yu80647e52017-09-12 14:25:35 +0800350 *ui = t;
Chao Yu969d1b12017-08-07 23:09:56 +0800351 return count;
352 }
353
Chao Yu34655572018-10-25 16:19:28 +0800354 if (!strcmp(a->attr.name, "migration_granularity")) {
355 if (t == 0 || t > sbi->segs_per_sec)
356 return -EINVAL;
357 }
358
Chao Yu377224c2018-04-09 10:25:23 +0800359 if (!strcmp(a->attr.name, "trim_sections"))
360 return -EINVAL;
361
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700362 if (!strcmp(a->attr.name, "gc_urgent")) {
Daeho Jeong0e5e8112020-07-02 13:14:14 +0900363 if (t == 0) {
364 sbi->gc_mode = GC_NORMAL;
365 } else if (t == 1) {
366 sbi->gc_mode = GC_URGENT_HIGH;
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700367 if (sbi->gc_thread) {
Sheng Yonga690eff2018-08-05 12:45:35 +0800368 sbi->gc_thread->gc_wake = 1;
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700369 wake_up_interruptible_all(
370 &sbi->gc_thread->gc_wait_queue_head);
371 wake_up_discard_thread(sbi, true);
372 }
Daeho Jeong0e5e8112020-07-02 13:14:14 +0900373 } else if (t == 2) {
374 sbi->gc_mode = GC_URGENT_LOW;
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700375 } else {
Daeho Jeong0e5e8112020-07-02 13:14:14 +0900376 return -EINVAL;
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700377 }
378 return count;
379 }
380 if (!strcmp(a->attr.name, "gc_idle")) {
Chao Yu093749e2020-08-04 21:14:49 +0800381 if (t == GC_IDLE_CB) {
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700382 sbi->gc_mode = GC_IDLE_CB;
Chao Yu093749e2020-08-04 21:14:49 +0800383 } else if (t == GC_IDLE_GREEDY) {
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700384 sbi->gc_mode = GC_IDLE_GREEDY;
Chao Yu093749e2020-08-04 21:14:49 +0800385 } else if (t == GC_IDLE_AT) {
386 if (!sbi->am.atgc_enabled)
387 return -EINVAL;
388 sbi->gc_mode = GC_AT;
389 } else {
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700390 sbi->gc_mode = GC_NORMAL;
Chao Yu093749e2020-08-04 21:14:49 +0800391 }
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700392 return count;
393 }
394
Sheng Yongac929852019-01-15 20:02:15 +0000395 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 Jeong2bc4bea2020-03-30 03:30:59 +0000402 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 Yongac929852019-01-15 20:02:15 +0000411 *ui = (unsigned int)t;
412
Chao Yu8ceffcb2017-06-14 17:39:47 +0800413 return count;
414}
415
Chao Yu250dbf52018-05-28 16:57:32 +0800416static 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 Kima1933c02018-07-15 09:58:08 +0900424 if (gc_entry) {
425 if (!down_read_trylock(&sbi->sb->s_umount))
426 return -EAGAIN;
427 }
Chao Yu4d57b862018-05-30 00:20:41 +0800428 ret = __sbi_store(a, sbi, buf, count);
Chao Yu250dbf52018-05-28 16:57:32 +0800429 if (gc_entry)
430 up_read(&sbi->sb->s_umount);
431
432 return ret;
433}
434
Chao Yu8ceffcb2017-06-14 17:39:47 +0800435static 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
445static 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
455static 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 Kimbf9e6972017-07-21 17:14:09 -0700462enum 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 Yu6afc6622017-09-06 21:59:50 +0800469 FEAT_FLEXIBLE_INLINE_XATTR,
Jaegeuk Kim234a9682017-10-05 21:03:06 -0700470 FEAT_QUOTA_INO,
Chao Yu1c1d35d2018-01-25 14:54:42 +0800471 FEAT_INODE_CRTIME,
Sheng Yongb7c409d2018-03-15 18:51:41 +0800472 FEAT_LOST_FOUND,
Eric Biggers95ae2512019-07-22 09:26:24 -0700473 FEAT_VERITY,
Junling Zhengd440c522018-09-28 20:25:56 +0800474 FEAT_SB_CHECKSUM,
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700475 FEAT_CASEFOLD,
Chao Yu4c8ff702019-11-01 18:07:14 +0800476 FEAT_COMPRESSION,
Eric Biggersed318a62020-05-12 16:32:50 -0700477 FEAT_TEST_DUMMY_ENCRYPTION_V2,
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700478};
479
480static 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 Yu6afc6622017-09-06 21:59:50 +0800490 case FEAT_FLEXIBLE_INLINE_XATTR:
Jaegeuk Kim234a9682017-10-05 21:03:06 -0700491 case FEAT_QUOTA_INO:
Chao Yu1c1d35d2018-01-25 14:54:42 +0800492 case FEAT_INODE_CRTIME:
Sheng Yongb7c409d2018-03-15 18:51:41 +0800493 case FEAT_LOST_FOUND:
Eric Biggers95ae2512019-07-22 09:26:24 -0700494 case FEAT_VERITY:
Junling Zhengd440c522018-09-28 20:25:56 +0800495 case FEAT_SB_CHECKSUM:
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700496 case FEAT_CASEFOLD:
Chao Yu4c8ff702019-11-01 18:07:14 +0800497 case FEAT_COMPRESSION:
Eric Biggersed318a62020-05-12 16:32:50 -0700498 case FEAT_TEST_DUMMY_ENCRYPTION_V2:
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800499 return sprintf(buf, "supported\n");
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700500 }
501 return 0;
502}
503
Chao Yu8ceffcb2017-06-14 17:39:47 +0800504#define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
505static 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) \
519static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)
520
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700521#define F2FS_FEATURE_RO_ATTR(_name, _id) \
522static struct f2fs_attr f2fs_attr_##_name = { \
523 .attr = {.name = __stringify(_name), .mode = 0444 }, \
524 .show = f2fs_feature_show, \
525 .id = _id, \
526}
527
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800528#define F2FS_STAT_ATTR(_struct_type, _struct_name, _name, _elname) \
529static 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 Kimd9872a62017-08-06 22:09:00 -0700536F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time,
537 urgent_sleep_time);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800538F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
539F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
540F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
Jaegeuk Kim5b0e9532018-05-07 14:22:40 -0700541F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode);
542F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800543F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
544F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards);
Chao Yu969d1b12017-08-07 23:09:56 +0800545F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity);
Chao Yudaeb4332017-06-26 16:24:41 +0800546F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800547F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
548F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
549F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
550F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
Jaegeuk Kim853137c2018-08-09 17:53:34 -0700551F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800552F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks);
Chao Yua2a12b62017-10-28 16:52:33 +0800553F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800554F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
555F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
556F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio);
557F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
Chao Yu34655572018-10-25 16:19:28 +0800558F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, migration_granularity, migration_granularity);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800559F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
560F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
561F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
Sahitya Tummalaa7d10cf2018-09-19 14:18:47 +0530562F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval,
563 interval_time[DISCARD_TIME]);
564F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]);
Jaegeuk Kim03f2c022019-01-14 10:42:11 -0800565F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info,
566 umount_discard_timeout, interval_time[UMOUNT_DISCARD_TIMEOUT]);
Chao Yub0af6d42017-08-02 23:21:48 +0800567F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable);
Daeho Jeong2bc4bea2020-03-30 03:30:59 +0000568F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_period_ms, iostat_period_ms);
Sheng Yongf6df8f22017-11-22 18:23:38 +0800569F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra);
Jaegeuk Kim10208562020-12-03 09:52:45 -0800570F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_io_bytes, max_io_bytes);
Jaegeuk Kim1ad71a22017-12-07 16:25:39 -0800571F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold);
Chao Yu846ae672018-02-26 22:04:13 +0800572F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800573#ifdef CONFIG_F2FS_FAULT_INJECTION
574F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate);
575F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type);
576#endif
Jaegeuk Kimda9953b2020-04-02 09:32:35 -0700577F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag);
Jaegeuk Kim32b6aba2020-06-04 11:49:43 -0700578F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag);
Jaegeuk Kim8f1572f2017-10-24 09:46:54 +0200579F2FS_GENERAL_RO_ATTR(dirty_segments);
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800580F2FS_GENERAL_RO_ATTR(free_segments);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800581F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes);
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700582F2FS_GENERAL_RO_ATTR(features);
Yunlong Song80d42142017-10-27 20:45:05 +0800583F2FS_GENERAL_RO_ATTR(current_reserved_blocks);
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -0700584F2FS_GENERAL_RO_ATTR(unusable);
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700585F2FS_GENERAL_RO_ATTR(encoding);
Jaegeuk Kima7e679b2020-02-25 19:08:16 -0800586F2FS_GENERAL_RO_ATTR(mounted_time_sec);
Dehe Guffcde4b2020-07-03 17:51:29 +0800587F2FS_GENERAL_RO_ATTR(main_blkaddr);
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800588#ifdef CONFIG_F2FS_STAT_FS
589F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_foreground_calls, cp_count);
590F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_background_calls, bg_cp_count);
591F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_foreground_calls, call_count);
592F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_background_calls, bg_gc);
593F2FS_GENERAL_RO_ATTR(moved_blocks_background);
594F2FS_GENERAL_RO_ATTR(moved_blocks_foreground);
595F2FS_GENERAL_RO_ATTR(avg_vblocks);
596#endif
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700597
Chandan Rajendra643fa962018-12-12 15:20:12 +0530598#ifdef CONFIG_FS_ENCRYPTION
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700599F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO);
Eric Biggersed318a62020-05-12 16:32:50 -0700600F2FS_FEATURE_RO_ATTR(test_dummy_encryption_v2, FEAT_TEST_DUMMY_ENCRYPTION_V2);
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700601#endif
602#ifdef CONFIG_BLK_DEV_ZONED
603F2FS_FEATURE_RO_ATTR(block_zoned, FEAT_BLKZONED);
604#endif
605F2FS_FEATURE_RO_ATTR(atomic_write, FEAT_ATOMIC_WRITE);
606F2FS_FEATURE_RO_ATTR(extra_attr, FEAT_EXTRA_ATTR);
607F2FS_FEATURE_RO_ATTR(project_quota, FEAT_PROJECT_QUOTA);
608F2FS_FEATURE_RO_ATTR(inode_checksum, FEAT_INODE_CHECKSUM);
Chao Yu6afc6622017-09-06 21:59:50 +0800609F2FS_FEATURE_RO_ATTR(flexible_inline_xattr, FEAT_FLEXIBLE_INLINE_XATTR);
Jaegeuk Kim234a9682017-10-05 21:03:06 -0700610F2FS_FEATURE_RO_ATTR(quota_ino, FEAT_QUOTA_INO);
Chao Yu1c1d35d2018-01-25 14:54:42 +0800611F2FS_FEATURE_RO_ATTR(inode_crtime, FEAT_INODE_CRTIME);
Sheng Yongb7c409d2018-03-15 18:51:41 +0800612F2FS_FEATURE_RO_ATTR(lost_found, FEAT_LOST_FOUND);
Eric Biggers95ae2512019-07-22 09:26:24 -0700613#ifdef CONFIG_FS_VERITY
614F2FS_FEATURE_RO_ATTR(verity, FEAT_VERITY);
615#endif
Junling Zhengd440c522018-09-28 20:25:56 +0800616F2FS_FEATURE_RO_ATTR(sb_checksum, FEAT_SB_CHECKSUM);
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700617F2FS_FEATURE_RO_ATTR(casefold, FEAT_CASEFOLD);
Chao Yu9b6ed142020-03-27 18:29:00 +0800618#ifdef CONFIG_F2FS_FS_COMPRESSION
Chao Yu4c8ff702019-11-01 18:07:14 +0800619F2FS_FEATURE_RO_ATTR(compression, FEAT_COMPRESSION);
Chao Yu9b6ed142020-03-27 18:29:00 +0800620#endif
Chao Yu8ceffcb2017-06-14 17:39:47 +0800621
622#define ATTR_LIST(name) (&f2fs_attr_##name.attr)
623static struct attribute *f2fs_attrs[] = {
Jaegeuk Kimd9872a62017-08-06 22:09:00 -0700624 ATTR_LIST(gc_urgent_sleep_time),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800625 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 Kimd9872a62017-08-06 22:09:00 -0700629 ATTR_LIST(gc_urgent),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800630 ATTR_LIST(reclaim_segments),
Jaegeuk Kima4db59a2019-11-22 11:53:10 -0800631 ATTR_LIST(main_blkaddr),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800632 ATTR_LIST(max_small_discards),
Chao Yu969d1b12017-08-07 23:09:56 +0800633 ATTR_LIST(discard_granularity),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800634 ATTR_LIST(batched_trim_sections),
635 ATTR_LIST(ipu_policy),
636 ATTR_LIST(min_ipu_util),
637 ATTR_LIST(min_fsync_blocks),
Jaegeuk Kim853137c2018-08-09 17:53:34 -0700638 ATTR_LIST(min_seq_blocks),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800639 ATTR_LIST(min_hot_blocks),
Chao Yua2a12b62017-10-28 16:52:33 +0800640 ATTR_LIST(min_ssr_sections),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800641 ATTR_LIST(max_victim_search),
Chao Yu34655572018-10-25 16:19:28 +0800642 ATTR_LIST(migration_granularity),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800643 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 Tummalaa7d10cf2018-09-19 14:18:47 +0530649 ATTR_LIST(discard_idle_interval),
650 ATTR_LIST(gc_idle_interval),
Jaegeuk Kim03f2c022019-01-14 10:42:11 -0800651 ATTR_LIST(umount_discard_timeout),
Chao Yub0af6d42017-08-02 23:21:48 +0800652 ATTR_LIST(iostat_enable),
Daeho Jeong2bc4bea2020-03-30 03:30:59 +0000653 ATTR_LIST(iostat_period_ms),
Sheng Yongf6df8f22017-11-22 18:23:38 +0800654 ATTR_LIST(readdir_ra),
Jaegeuk Kim10208562020-12-03 09:52:45 -0800655 ATTR_LIST(max_io_bytes),
Jaegeuk Kim1ad71a22017-12-07 16:25:39 -0800656 ATTR_LIST(gc_pin_file_thresh),
Chao Yu846ae672018-02-26 22:04:13 +0800657 ATTR_LIST(extension_list),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800658#ifdef CONFIG_F2FS_FAULT_INJECTION
659 ATTR_LIST(inject_rate),
660 ATTR_LIST(inject_type),
661#endif
Jaegeuk Kimda9953b2020-04-02 09:32:35 -0700662 ATTR_LIST(data_io_flag),
Jaegeuk Kim32b6aba2020-06-04 11:49:43 -0700663 ATTR_LIST(node_io_flag),
Jaegeuk Kim8f1572f2017-10-24 09:46:54 +0200664 ATTR_LIST(dirty_segments),
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800665 ATTR_LIST(free_segments),
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -0700666 ATTR_LIST(unusable),
Chao Yu8ceffcb2017-06-14 17:39:47 +0800667 ATTR_LIST(lifetime_write_kbytes),
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700668 ATTR_LIST(features),
Chao Yudaeb4332017-06-26 16:24:41 +0800669 ATTR_LIST(reserved_blocks),
Yunlong Song80d42142017-10-27 20:45:05 +0800670 ATTR_LIST(current_reserved_blocks),
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700671 ATTR_LIST(encoding),
Jaegeuk Kima7e679b2020-02-25 19:08:16 -0800672 ATTR_LIST(mounted_time_sec),
Hridya Valsarajufc7100e2020-01-22 10:51:16 -0800673#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 Yu8ceffcb2017-06-14 17:39:47 +0800682 NULL,
683};
Kimberly Brown176ef3c2019-06-07 13:40:41 -0400684ATTRIBUTE_GROUPS(f2fs);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800685
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700686static struct attribute *f2fs_feat_attrs[] = {
Chandan Rajendra643fa962018-12-12 15:20:12 +0530687#ifdef CONFIG_FS_ENCRYPTION
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700688 ATTR_LIST(encryption),
Eric Biggersed318a62020-05-12 16:32:50 -0700689 ATTR_LIST(test_dummy_encryption_v2),
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700690#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 Yu6afc6622017-09-06 21:59:50 +0800698 ATTR_LIST(flexible_inline_xattr),
Jaegeuk Kim234a9682017-10-05 21:03:06 -0700699 ATTR_LIST(quota_ino),
Chao Yu1c1d35d2018-01-25 14:54:42 +0800700 ATTR_LIST(inode_crtime),
Sheng Yongb7c409d2018-03-15 18:51:41 +0800701 ATTR_LIST(lost_found),
Eric Biggers95ae2512019-07-22 09:26:24 -0700702#ifdef CONFIG_FS_VERITY
703 ATTR_LIST(verity),
704#endif
Junling Zhengd440c522018-09-28 20:25:56 +0800705 ATTR_LIST(sb_checksum),
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700706 ATTR_LIST(casefold),
Chao Yu9b6ed142020-03-27 18:29:00 +0800707#ifdef CONFIG_F2FS_FS_COMPRESSION
Chao Yu4c8ff702019-11-01 18:07:14 +0800708 ATTR_LIST(compression),
Chao Yu9b6ed142020-03-27 18:29:00 +0800709#endif
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700710 NULL,
711};
Kimberly Brown176ef3c2019-06-07 13:40:41 -0400712ATTRIBUTE_GROUPS(f2fs_feat);
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700713
Chao Yu8ceffcb2017-06-14 17:39:47 +0800714static const struct sysfs_ops f2fs_attr_ops = {
715 .show = f2fs_attr_show,
716 .store = f2fs_attr_store,
717};
718
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700719static struct kobj_type f2fs_sb_ktype = {
Kimberly Brown176ef3c2019-06-07 13:40:41 -0400720 .default_groups = f2fs_groups,
Chao Yu8ceffcb2017-06-14 17:39:47 +0800721 .sysfs_ops = &f2fs_attr_ops,
722 .release = f2fs_sb_release,
723};
724
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700725static struct kobj_type f2fs_ktype = {
726 .sysfs_ops = &f2fs_attr_ops,
727};
728
729static struct kset f2fs_kset = {
Jack Qiua87aff12020-07-24 16:55:28 +0800730 .kobj = {.ktype = &f2fs_ktype},
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700731};
732
733static struct kobj_type f2fs_feat_ktype = {
Kimberly Brown176ef3c2019-06-07 13:40:41 -0400734 .default_groups = f2fs_feat_groups,
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700735 .sysfs_ops = &f2fs_attr_ops,
736};
737
738static struct kobject f2fs_feat = {
739 .kset = &f2fs_kset,
740};
741
Randy Dunlapcb15d1e2018-07-06 20:50:57 -0700742static int __maybe_unused segment_info_seq_show(struct seq_file *seq,
743 void *offset)
Chao Yu8ceffcb2017-06-14 17:39:47 +0800744{
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 Yu8740edc2019-06-18 18:00:09 +0800759 seq_printf(seq, "%d|%-3u", se->type, se->valid_blocks);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800760 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 Dunlapcb15d1e2018-07-06 20:50:57 -0700769static int __maybe_unused segment_bits_seq_show(struct seq_file *seq,
770 void *offset)
Chao Yu8ceffcb2017-06-14 17:39:47 +0800771{
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 Yu8740edc2019-06-18 18:00:09 +0800785 seq_printf(seq, "%d|%-3u|", se->type, se->valid_blocks);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800786 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 Jeong2bc4bea2020-03-30 03:30:59 +0000793void 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 Yu8b83ac82020-04-16 18:16:56 +0800811 iostat_diff[i] = sbi->rw_iostat[i] -
812 sbi->prev_rw_iostat[i];
813 sbi->prev_rw_iostat[i] = sbi->rw_iostat[i];
Daeho Jeong2bc4bea2020-03-30 03:30:59 +0000814 }
815 spin_unlock(&sbi->iostat_lock);
816
817 trace_f2fs_iostat(sbi, iostat_diff);
818}
819
Randy Dunlapcb15d1e2018-07-06 20:50:57 -0700820static int __maybe_unused iostat_info_seq_show(struct seq_file *seq,
821 void *offset)
Chao Yub0af6d42017-08-02 23:21:48 +0800822{
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 Yu8b83ac82020-04-16 18:16:56 +0800832 /* print app write IOs */
Chao Yu9c122382020-04-23 18:03:06 +0800833 seq_puts(seq, "[WRITE]\n");
Chao Yub0af6d42017-08-02 23:21:48 +0800834 seq_printf(seq, "app buffered: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800835 sbi->rw_iostat[APP_BUFFERED_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800836 seq_printf(seq, "app direct: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800837 sbi->rw_iostat[APP_DIRECT_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800838 seq_printf(seq, "app mapped: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800839 sbi->rw_iostat[APP_MAPPED_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800840
Chao Yu8b83ac82020-04-16 18:16:56 +0800841 /* print fs write IOs */
Chao Yub0af6d42017-08-02 23:21:48 +0800842 seq_printf(seq, "fs data: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800843 sbi->rw_iostat[FS_DATA_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800844 seq_printf(seq, "fs node: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800845 sbi->rw_iostat[FS_NODE_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800846 seq_printf(seq, "fs meta: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800847 sbi->rw_iostat[FS_META_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800848 seq_printf(seq, "fs gc data: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800849 sbi->rw_iostat[FS_GC_DATA_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800850 seq_printf(seq, "fs gc node: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800851 sbi->rw_iostat[FS_GC_NODE_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800852 seq_printf(seq, "fs cp data: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800853 sbi->rw_iostat[FS_CP_DATA_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800854 seq_printf(seq, "fs cp node: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800855 sbi->rw_iostat[FS_CP_NODE_IO]);
Chao Yub0af6d42017-08-02 23:21:48 +0800856 seq_printf(seq, "fs cp meta: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800857 sbi->rw_iostat[FS_CP_META_IO]);
858
859 /* print app read IOs */
Chao Yu9c122382020-04-23 18:03:06 +0800860 seq_puts(seq, "[READ]\n");
Chao Yu8b83ac82020-04-16 18:16:56 +0800861 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 Yu9c122382020-04-23 18:03:06 +0800871 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 Yu8b83ac82020-04-16 18:16:56 +0800875 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 Yu9c122382020-04-23 18:03:06 +0800881 seq_puts(seq, "[OTHER]\n");
Chao Yub0af6d42017-08-02 23:21:48 +0800882 seq_printf(seq, "fs discard: %-16llu\n",
Chao Yu8b83ac82020-04-16 18:16:56 +0800883 sbi->rw_iostat[FS_DISCARD]);
Chao Yub0af6d42017-08-02 23:21:48 +0800884
885 return 0;
886}
887
Yunlong Song970e3482018-07-23 22:10:22 +0800888static 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 Kimdc6b2052017-07-26 11:24:13 -0700910int __init f2fs_init_sysfs(void)
Chao Yu8ceffcb2017-06-14 17:39:47 +0800911{
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700912 int ret;
Chao Yu8ceffcb2017-06-14 17:39:47 +0800913
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700914 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 Yufe396ad2019-12-30 17:41:41 +0800922 if (ret) {
923 kobject_put(&f2fs_feat);
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700924 kset_unregister(&f2fs_kset);
Chao Yufe396ad2019-12-30 17:41:41 +0800925 } else {
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700926 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
Chao Yufe396ad2019-12-30 17:41:41 +0800927 }
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700928 return ret;
Chao Yu8ceffcb2017-06-14 17:39:47 +0800929}
930
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -0700931void f2fs_exit_sysfs(void)
Chao Yu8ceffcb2017-06-14 17:39:47 +0800932{
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700933 kobject_put(&f2fs_feat);
934 kset_unregister(&f2fs_kset);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800935 remove_proc_entry("fs/f2fs", NULL);
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700936 f2fs_proc_root = NULL;
Chao Yu8ceffcb2017-06-14 17:39:47 +0800937}
938
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -0700939int f2fs_register_sysfs(struct f2fs_sb_info *sbi)
Chao Yu8ceffcb2017-06-14 17:39:47 +0800940{
941 struct super_block *sb = sbi->sb;
942 int err;
943
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700944 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 Yufe396ad2019-12-30 17:41:41 +0800948 if (err) {
949 kobject_put(&sbi->s_kobj);
950 wait_for_completion(&sbi->s_kobj_unregister);
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700951 return err;
Chao Yufe396ad2019-12-30 17:41:41 +0800952 }
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700953
Chao Yu8ceffcb2017-06-14 17:39:47 +0800954 if (f2fs_proc_root)
955 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);
956
957 if (sbi->s_proc) {
Christoph Hellwig3f3942a2018-05-15 15:57:23 +0200958 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 Song970e3482018-07-23 22:10:22 +0800964 proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc,
965 victim_bits_seq_show, sb);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800966 }
Chao Yu8ceffcb2017-06-14 17:39:47 +0800967 return 0;
Chao Yu8ceffcb2017-06-14 17:39:47 +0800968}
969
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -0700970void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi)
Chao Yu8ceffcb2017-06-14 17:39:47 +0800971{
Chao Yu8ceffcb2017-06-14 17:39:47 +0800972 if (sbi->s_proc) {
Chao Yub0af6d42017-08-02 23:21:48 +0800973 remove_proc_entry("iostat_info", sbi->s_proc);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800974 remove_proc_entry("segment_info", sbi->s_proc);
975 remove_proc_entry("segment_bits", sbi->s_proc);
Yunlong Song970e3482018-07-23 22:10:22 +0800976 remove_proc_entry("victim_bits", sbi->s_proc);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800977 remove_proc_entry(sbi->sb->s_id, f2fs_proc_root);
978 }
Jaegeuk Kimbf9e6972017-07-21 17:14:09 -0700979 kobject_del(&sbi->s_kobj);
Jaegeuk Kim820d3662019-12-13 18:32:16 -0800980 kobject_put(&sbi->s_kobj);
Jamie Ilesae284d82020-10-12 14:09:48 +0100981 wait_for_completion(&sbi->s_kobj_unregister);
Chao Yu8ceffcb2017-06-14 17:39:47 +0800982}