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