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