sysfs.c revision 202bc942
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	ui = (unsigned int *)(ptr + a->offset);
311
312	return sprintf(buf, "%u\n", *ui);
313}
314
315static ssize_t __sbi_store(struct f2fs_attr *a,
316			struct f2fs_sb_info *sbi,
317			const char *buf, size_t count)
318{
319	unsigned char *ptr;
320	unsigned long t;
321	unsigned int *ui;
322	ssize_t ret;
323
324	ptr = __struct_ptr(sbi, a->struct_type);
325	if (!ptr)
326		return -EINVAL;
327
328	if (!strcmp(a->attr.name, "extension_list")) {
329		const char *name = strim((char *)buf);
330		bool set = true, hot;
331
332		if (!strncmp(name, "[h]", 3))
333			hot = true;
334		else if (!strncmp(name, "[c]", 3))
335			hot = false;
336		else
337			return -EINVAL;
338
339		name += 3;
340
341		if (*name == '!') {
342			name++;
343			set = false;
344		}
345
346		if (strlen(name) >= F2FS_EXTENSION_LEN)
347			return -EINVAL;
348
349		down_write(&sbi->sb_lock);
350
351		ret = f2fs_update_extension_list(sbi, name, hot, set);
352		if (ret)
353			goto out;
354
355		ret = f2fs_commit_super(sbi, false);
356		if (ret)
357			f2fs_update_extension_list(sbi, name, hot, !set);
358out:
359		up_write(&sbi->sb_lock);
360		return ret ? ret : count;
361	}
362
363	if (!strcmp(a->attr.name, "ckpt_thread_ioprio")) {
364		const char *name = strim((char *)buf);
365		struct ckpt_req_control *cprc = &sbi->cprc_info;
366		int class;
367		long data;
368		int ret;
369
370		if (!strncmp(name, "rt,", 3))
371			class = IOPRIO_CLASS_RT;
372		else if (!strncmp(name, "be,", 3))
373			class = IOPRIO_CLASS_BE;
374		else
375			return -EINVAL;
376
377		name += 3;
378		ret = kstrtol(name, 10, &data);
379		if (ret)
380			return ret;
381		if (data >= IOPRIO_NR_LEVELS || data < 0)
382			return -EINVAL;
383
384		cprc->ckpt_thread_ioprio = IOPRIO_PRIO_VALUE(class, data);
385		if (test_opt(sbi, MERGE_CHECKPOINT)) {
386			ret = set_task_ioprio(cprc->f2fs_issue_ckpt,
387					cprc->ckpt_thread_ioprio);
388			if (ret)
389				return ret;
390		}
391
392		return count;
393	}
394
395	ui = (unsigned int *)(ptr + a->offset);
396
397	ret = kstrtoul(skip_spaces(buf), 0, &t);
398	if (ret < 0)
399		return ret;
400#ifdef CONFIG_F2FS_FAULT_INJECTION
401	if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX))
402		return -EINVAL;
403	if (a->struct_type == FAULT_INFO_RATE && t >= UINT_MAX)
404		return -EINVAL;
405#endif
406	if (a->struct_type == RESERVED_BLOCKS) {
407		spin_lock(&sbi->stat_lock);
408		if (t > (unsigned long)(sbi->user_block_count -
409				F2FS_OPTION(sbi).root_reserved_blocks)) {
410			spin_unlock(&sbi->stat_lock);
411			return -EINVAL;
412		}
413		*ui = t;
414		sbi->current_reserved_blocks = min(sbi->reserved_blocks,
415				sbi->user_block_count - valid_user_blocks(sbi));
416		spin_unlock(&sbi->stat_lock);
417		return count;
418	}
419
420	if (!strcmp(a->attr.name, "discard_granularity")) {
421		if (t == 0 || t > MAX_PLIST_NUM)
422			return -EINVAL;
423		if (t == *ui)
424			return count;
425		*ui = t;
426		return count;
427	}
428
429	if (!strcmp(a->attr.name, "migration_granularity")) {
430		if (t == 0 || t > sbi->segs_per_sec)
431			return -EINVAL;
432	}
433
434	if (!strcmp(a->attr.name, "trim_sections"))
435		return -EINVAL;
436
437	if (!strcmp(a->attr.name, "gc_urgent")) {
438		if (t == 0) {
439			sbi->gc_mode = GC_NORMAL;
440		} else if (t == 1) {
441			sbi->gc_mode = GC_URGENT_HIGH;
442			if (sbi->gc_thread) {
443				sbi->gc_thread->gc_wake = 1;
444				wake_up_interruptible_all(
445					&sbi->gc_thread->gc_wait_queue_head);
446				wake_up_discard_thread(sbi, true);
447			}
448		} else if (t == 2) {
449			sbi->gc_mode = GC_URGENT_LOW;
450		} else {
451			return -EINVAL;
452		}
453		return count;
454	}
455	if (!strcmp(a->attr.name, "gc_idle")) {
456		if (t == GC_IDLE_CB) {
457			sbi->gc_mode = GC_IDLE_CB;
458		} else if (t == GC_IDLE_GREEDY) {
459			sbi->gc_mode = GC_IDLE_GREEDY;
460		} else if (t == GC_IDLE_AT) {
461			if (!sbi->am.atgc_enabled)
462				return -EINVAL;
463			sbi->gc_mode = GC_AT;
464		} else {
465			sbi->gc_mode = GC_NORMAL;
466		}
467		return count;
468	}
469
470	if (!strcmp(a->attr.name, "iostat_enable")) {
471		sbi->iostat_enable = !!t;
472		if (!sbi->iostat_enable)
473			f2fs_reset_iostat(sbi);
474		return count;
475	}
476
477	if (!strcmp(a->attr.name, "iostat_period_ms")) {
478		if (t < MIN_IOSTAT_PERIOD_MS || t > MAX_IOSTAT_PERIOD_MS)
479			return -EINVAL;
480		spin_lock(&sbi->iostat_lock);
481		sbi->iostat_period_ms = (unsigned int)t;
482		spin_unlock(&sbi->iostat_lock);
483		return count;
484	}
485
486#ifdef CONFIG_F2FS_FS_COMPRESSION
487	if (!strcmp(a->attr.name, "compr_written_block") ||
488		!strcmp(a->attr.name, "compr_saved_block")) {
489		if (t != 0)
490			return -EINVAL;
491		sbi->compr_written_block = 0;
492		sbi->compr_saved_block = 0;
493		return count;
494	}
495
496	if (!strcmp(a->attr.name, "compr_new_inode")) {
497		if (t != 0)
498			return -EINVAL;
499		sbi->compr_new_inode = 0;
500		return count;
501	}
502#endif
503
504	if (!strcmp(a->attr.name, "atgc_candidate_ratio")) {
505		if (t > 100)
506			return -EINVAL;
507		sbi->am.candidate_ratio = t;
508		return count;
509	}
510
511	if (!strcmp(a->attr.name, "atgc_age_weight")) {
512		if (t > 100)
513			return -EINVAL;
514		sbi->am.age_weight = t;
515		return count;
516	}
517
518	*ui = (unsigned int)t;
519
520	return count;
521}
522
523static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
524			struct f2fs_sb_info *sbi,
525			const char *buf, size_t count)
526{
527	ssize_t ret;
528	bool gc_entry = (!strcmp(a->attr.name, "gc_urgent") ||
529					a->struct_type == GC_THREAD);
530
531	if (gc_entry) {
532		if (!down_read_trylock(&sbi->sb->s_umount))
533			return -EAGAIN;
534	}
535	ret = __sbi_store(a, sbi, buf, count);
536	if (gc_entry)
537		up_read(&sbi->sb->s_umount);
538
539	return ret;
540}
541
542static ssize_t f2fs_attr_show(struct kobject *kobj,
543				struct attribute *attr, char *buf)
544{
545	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
546								s_kobj);
547	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
548
549	return a->show ? a->show(a, sbi, buf) : 0;
550}
551
552static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr,
553						const char *buf, size_t len)
554{
555	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
556									s_kobj);
557	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
558
559	return a->store ? a->store(a, sbi, buf, len) : 0;
560}
561
562static void f2fs_sb_release(struct kobject *kobj)
563{
564	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
565								s_kobj);
566	complete(&sbi->s_kobj_unregister);
567}
568
569/*
570 * Note that there are three feature list entries:
571 * 1) /sys/fs/f2fs/features
572 *   : shows runtime features supported by in-kernel f2fs along with Kconfig.
573 *     - ref. F2FS_FEATURE_RO_ATTR()
574 *
575 * 2) /sys/fs/f2fs/$s_id/features <deprecated>
576 *   : shows on-disk features enabled by mkfs.f2fs, used for old kernels. This
577 *     won't add new feature anymore, and thus, users should check entries in 3)
578 *     instead of this 2).
579 *
580 * 3) /sys/fs/f2fs/$s_id/feature_list
581 *   : shows on-disk features enabled by mkfs.f2fs per instance, which follows
582 *     sysfs entry rule where each entry should expose single value.
583 *     This list covers old feature list provided by 2) and beyond. Therefore,
584 *     please add new on-disk feature in this list only.
585 *     - ref. F2FS_SB_FEATURE_RO_ATTR()
586 */
587static ssize_t f2fs_feature_show(struct f2fs_attr *a,
588		struct f2fs_sb_info *sbi, char *buf)
589{
590	return sprintf(buf, "supported\n");
591}
592
593#define F2FS_FEATURE_RO_ATTR(_name)				\
594static struct f2fs_attr f2fs_attr_##_name = {			\
595	.attr = {.name = __stringify(_name), .mode = 0444 },	\
596	.show	= f2fs_feature_show,				\
597}
598
599static ssize_t f2fs_sb_feature_show(struct f2fs_attr *a,
600		struct f2fs_sb_info *sbi, char *buf)
601{
602	if (F2FS_HAS_FEATURE(sbi, a->id))
603		return sprintf(buf, "supported\n");
604	return sprintf(buf, "unsupported\n");
605}
606
607#define F2FS_SB_FEATURE_RO_ATTR(_name, _feat)			\
608static struct f2fs_attr f2fs_attr_sb_##_name = {		\
609	.attr = {.name = __stringify(_name), .mode = 0444 },	\
610	.show	= f2fs_sb_feature_show,				\
611	.id	= F2FS_FEATURE_##_feat,				\
612}
613
614#define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
615static struct f2fs_attr f2fs_attr_##_name = {			\
616	.attr = {.name = __stringify(_name), .mode = _mode },	\
617	.show	= _show,					\
618	.store	= _store,					\
619	.struct_type = _struct_type,				\
620	.offset = _offset					\
621}
622
623#define F2FS_RW_ATTR(struct_type, struct_name, name, elname)	\
624	F2FS_ATTR_OFFSET(struct_type, name, 0644,		\
625		f2fs_sbi_show, f2fs_sbi_store,			\
626		offsetof(struct struct_name, elname))
627
628#define F2FS_GENERAL_RO_ATTR(name) \
629static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)
630
631#define F2FS_STAT_ATTR(_struct_type, _struct_name, _name, _elname)	\
632static struct f2fs_attr f2fs_attr_##_name = {			\
633	.attr = {.name = __stringify(_name), .mode = 0444 },	\
634	.show = f2fs_sbi_show,					\
635	.struct_type = _struct_type,				\
636	.offset = offsetof(struct _struct_name, _elname),       \
637}
638
639F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time,
640							urgent_sleep_time);
641F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
642F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
643F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
644F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode);
645F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode);
646F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
647F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards);
648F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity);
649F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks);
650F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
651F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
652F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
653F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
654F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks);
655F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks);
656F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);
657F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
658F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
659F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio);
660F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
661F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, migration_granularity, migration_granularity);
662F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
663F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
664F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
665F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval,
666					interval_time[DISCARD_TIME]);
667F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]);
668F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info,
669		umount_discard_timeout, interval_time[UMOUNT_DISCARD_TIMEOUT]);
670F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable);
671F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_period_ms, iostat_period_ms);
672F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra);
673F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_io_bytes, max_io_bytes);
674F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold);
675F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list);
676#ifdef CONFIG_F2FS_FAULT_INJECTION
677F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate);
678F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type);
679#endif
680F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag);
681F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag);
682F2FS_RW_ATTR(CPRC_INFO, ckpt_req_control, ckpt_thread_ioprio, ckpt_thread_ioprio);
683F2FS_GENERAL_RO_ATTR(dirty_segments);
684F2FS_GENERAL_RO_ATTR(free_segments);
685F2FS_GENERAL_RO_ATTR(ovp_segments);
686F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes);
687F2FS_GENERAL_RO_ATTR(features);
688F2FS_GENERAL_RO_ATTR(current_reserved_blocks);
689F2FS_GENERAL_RO_ATTR(unusable);
690F2FS_GENERAL_RO_ATTR(encoding);
691F2FS_GENERAL_RO_ATTR(mounted_time_sec);
692F2FS_GENERAL_RO_ATTR(main_blkaddr);
693#ifdef CONFIG_F2FS_STAT_FS
694F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_foreground_calls, cp_count);
695F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, cp_background_calls, bg_cp_count);
696F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_foreground_calls, call_count);
697F2FS_STAT_ATTR(STAT_INFO, f2fs_stat_info, gc_background_calls, bg_gc);
698F2FS_GENERAL_RO_ATTR(moved_blocks_background);
699F2FS_GENERAL_RO_ATTR(moved_blocks_foreground);
700F2FS_GENERAL_RO_ATTR(avg_vblocks);
701#endif
702
703#ifdef CONFIG_FS_ENCRYPTION
704F2FS_FEATURE_RO_ATTR(encryption);
705F2FS_FEATURE_RO_ATTR(test_dummy_encryption_v2);
706#ifdef CONFIG_UNICODE
707F2FS_FEATURE_RO_ATTR(encrypted_casefold);
708#endif
709#endif /* CONFIG_FS_ENCRYPTION */
710#ifdef CONFIG_BLK_DEV_ZONED
711F2FS_FEATURE_RO_ATTR(block_zoned);
712#endif
713F2FS_FEATURE_RO_ATTR(atomic_write);
714F2FS_FEATURE_RO_ATTR(extra_attr);
715F2FS_FEATURE_RO_ATTR(project_quota);
716F2FS_FEATURE_RO_ATTR(inode_checksum);
717F2FS_FEATURE_RO_ATTR(flexible_inline_xattr);
718F2FS_FEATURE_RO_ATTR(quota_ino);
719F2FS_FEATURE_RO_ATTR(inode_crtime);
720F2FS_FEATURE_RO_ATTR(lost_found);
721#ifdef CONFIG_FS_VERITY
722F2FS_FEATURE_RO_ATTR(verity);
723#endif
724F2FS_FEATURE_RO_ATTR(sb_checksum);
725#ifdef CONFIG_UNICODE
726F2FS_FEATURE_RO_ATTR(casefold);
727#endif
728F2FS_FEATURE_RO_ATTR(readonly);
729#ifdef CONFIG_F2FS_FS_COMPRESSION
730F2FS_FEATURE_RO_ATTR(compression);
731F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_written_block, compr_written_block);
732F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_saved_block, compr_saved_block);
733F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, compr_new_inode, compr_new_inode);
734#endif
735F2FS_FEATURE_RO_ATTR(pin_file);
736
737/* For ATGC */
738F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_candidate_ratio, candidate_ratio);
739F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_candidate_count, max_candidate_count);
740F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_age_weight, age_weight);
741F2FS_RW_ATTR(ATGC_INFO, atgc_management, atgc_age_threshold, age_threshold);
742
743#define ATTR_LIST(name) (&f2fs_attr_##name.attr)
744static struct attribute *f2fs_attrs[] = {
745	ATTR_LIST(gc_urgent_sleep_time),
746	ATTR_LIST(gc_min_sleep_time),
747	ATTR_LIST(gc_max_sleep_time),
748	ATTR_LIST(gc_no_gc_sleep_time),
749	ATTR_LIST(gc_idle),
750	ATTR_LIST(gc_urgent),
751	ATTR_LIST(reclaim_segments),
752	ATTR_LIST(main_blkaddr),
753	ATTR_LIST(max_small_discards),
754	ATTR_LIST(discard_granularity),
755	ATTR_LIST(batched_trim_sections),
756	ATTR_LIST(ipu_policy),
757	ATTR_LIST(min_ipu_util),
758	ATTR_LIST(min_fsync_blocks),
759	ATTR_LIST(min_seq_blocks),
760	ATTR_LIST(min_hot_blocks),
761	ATTR_LIST(min_ssr_sections),
762	ATTR_LIST(max_victim_search),
763	ATTR_LIST(migration_granularity),
764	ATTR_LIST(dir_level),
765	ATTR_LIST(ram_thresh),
766	ATTR_LIST(ra_nid_pages),
767	ATTR_LIST(dirty_nats_ratio),
768	ATTR_LIST(cp_interval),
769	ATTR_LIST(idle_interval),
770	ATTR_LIST(discard_idle_interval),
771	ATTR_LIST(gc_idle_interval),
772	ATTR_LIST(umount_discard_timeout),
773	ATTR_LIST(iostat_enable),
774	ATTR_LIST(iostat_period_ms),
775	ATTR_LIST(readdir_ra),
776	ATTR_LIST(max_io_bytes),
777	ATTR_LIST(gc_pin_file_thresh),
778	ATTR_LIST(extension_list),
779#ifdef CONFIG_F2FS_FAULT_INJECTION
780	ATTR_LIST(inject_rate),
781	ATTR_LIST(inject_type),
782#endif
783	ATTR_LIST(data_io_flag),
784	ATTR_LIST(node_io_flag),
785	ATTR_LIST(ckpt_thread_ioprio),
786	ATTR_LIST(dirty_segments),
787	ATTR_LIST(free_segments),
788	ATTR_LIST(ovp_segments),
789	ATTR_LIST(unusable),
790	ATTR_LIST(lifetime_write_kbytes),
791	ATTR_LIST(features),
792	ATTR_LIST(reserved_blocks),
793	ATTR_LIST(current_reserved_blocks),
794	ATTR_LIST(encoding),
795	ATTR_LIST(mounted_time_sec),
796#ifdef CONFIG_F2FS_STAT_FS
797	ATTR_LIST(cp_foreground_calls),
798	ATTR_LIST(cp_background_calls),
799	ATTR_LIST(gc_foreground_calls),
800	ATTR_LIST(gc_background_calls),
801	ATTR_LIST(moved_blocks_foreground),
802	ATTR_LIST(moved_blocks_background),
803	ATTR_LIST(avg_vblocks),
804#endif
805#ifdef CONFIG_F2FS_FS_COMPRESSION
806	ATTR_LIST(compr_written_block),
807	ATTR_LIST(compr_saved_block),
808	ATTR_LIST(compr_new_inode),
809#endif
810	/* For ATGC */
811	ATTR_LIST(atgc_candidate_ratio),
812	ATTR_LIST(atgc_candidate_count),
813	ATTR_LIST(atgc_age_weight),
814	ATTR_LIST(atgc_age_threshold),
815	NULL,
816};
817ATTRIBUTE_GROUPS(f2fs);
818
819static struct attribute *f2fs_feat_attrs[] = {
820#ifdef CONFIG_FS_ENCRYPTION
821	ATTR_LIST(encryption),
822	ATTR_LIST(test_dummy_encryption_v2),
823#ifdef CONFIG_UNICODE
824	ATTR_LIST(encrypted_casefold),
825#endif
826#endif /* CONFIG_FS_ENCRYPTION */
827#ifdef CONFIG_BLK_DEV_ZONED
828	ATTR_LIST(block_zoned),
829#endif
830	ATTR_LIST(atomic_write),
831	ATTR_LIST(extra_attr),
832	ATTR_LIST(project_quota),
833	ATTR_LIST(inode_checksum),
834	ATTR_LIST(flexible_inline_xattr),
835	ATTR_LIST(quota_ino),
836	ATTR_LIST(inode_crtime),
837	ATTR_LIST(lost_found),
838#ifdef CONFIG_FS_VERITY
839	ATTR_LIST(verity),
840#endif
841	ATTR_LIST(sb_checksum),
842#ifdef CONFIG_UNICODE
843	ATTR_LIST(casefold),
844#endif
845	ATTR_LIST(readonly),
846#ifdef CONFIG_F2FS_FS_COMPRESSION
847	ATTR_LIST(compression),
848#endif
849	ATTR_LIST(pin_file),
850	NULL,
851};
852ATTRIBUTE_GROUPS(f2fs_feat);
853
854F2FS_GENERAL_RO_ATTR(sb_status);
855static struct attribute *f2fs_stat_attrs[] = {
856	ATTR_LIST(sb_status),
857	NULL,
858};
859ATTRIBUTE_GROUPS(f2fs_stat);
860
861F2FS_SB_FEATURE_RO_ATTR(encryption, ENCRYPT);
862F2FS_SB_FEATURE_RO_ATTR(block_zoned, BLKZONED);
863F2FS_SB_FEATURE_RO_ATTR(extra_attr, EXTRA_ATTR);
864F2FS_SB_FEATURE_RO_ATTR(project_quota, PRJQUOTA);
865F2FS_SB_FEATURE_RO_ATTR(inode_checksum, INODE_CHKSUM);
866F2FS_SB_FEATURE_RO_ATTR(flexible_inline_xattr, FLEXIBLE_INLINE_XATTR);
867F2FS_SB_FEATURE_RO_ATTR(quota_ino, QUOTA_INO);
868F2FS_SB_FEATURE_RO_ATTR(inode_crtime, INODE_CRTIME);
869F2FS_SB_FEATURE_RO_ATTR(lost_found, LOST_FOUND);
870F2FS_SB_FEATURE_RO_ATTR(verity, VERITY);
871F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM);
872F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD);
873F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION);
874F2FS_SB_FEATURE_RO_ATTR(readonly, RO);
875
876static struct attribute *f2fs_sb_feat_attrs[] = {
877	ATTR_LIST(sb_encryption),
878	ATTR_LIST(sb_block_zoned),
879	ATTR_LIST(sb_extra_attr),
880	ATTR_LIST(sb_project_quota),
881	ATTR_LIST(sb_inode_checksum),
882	ATTR_LIST(sb_flexible_inline_xattr),
883	ATTR_LIST(sb_quota_ino),
884	ATTR_LIST(sb_inode_crtime),
885	ATTR_LIST(sb_lost_found),
886	ATTR_LIST(sb_verity),
887	ATTR_LIST(sb_sb_checksum),
888	ATTR_LIST(sb_casefold),
889	ATTR_LIST(sb_compression),
890	ATTR_LIST(sb_readonly),
891	NULL,
892};
893ATTRIBUTE_GROUPS(f2fs_sb_feat);
894
895static const struct sysfs_ops f2fs_attr_ops = {
896	.show	= f2fs_attr_show,
897	.store	= f2fs_attr_store,
898};
899
900static struct kobj_type f2fs_sb_ktype = {
901	.default_groups = f2fs_groups,
902	.sysfs_ops	= &f2fs_attr_ops,
903	.release	= f2fs_sb_release,
904};
905
906static struct kobj_type f2fs_ktype = {
907	.sysfs_ops	= &f2fs_attr_ops,
908};
909
910static struct kset f2fs_kset = {
911	.kobj	= {.ktype = &f2fs_ktype},
912};
913
914static struct kobj_type f2fs_feat_ktype = {
915	.default_groups = f2fs_feat_groups,
916	.sysfs_ops	= &f2fs_attr_ops,
917};
918
919static struct kobject f2fs_feat = {
920	.kset	= &f2fs_kset,
921};
922
923static ssize_t f2fs_stat_attr_show(struct kobject *kobj,
924				struct attribute *attr, char *buf)
925{
926	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
927								s_stat_kobj);
928	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
929
930	return a->show ? a->show(a, sbi, buf) : 0;
931}
932
933static ssize_t f2fs_stat_attr_store(struct kobject *kobj, struct attribute *attr,
934						const char *buf, size_t len)
935{
936	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
937								s_stat_kobj);
938	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
939
940	return a->store ? a->store(a, sbi, buf, len) : 0;
941}
942
943static void f2fs_stat_kobj_release(struct kobject *kobj)
944{
945	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
946								s_stat_kobj);
947	complete(&sbi->s_stat_kobj_unregister);
948}
949
950static const struct sysfs_ops f2fs_stat_attr_ops = {
951	.show	= f2fs_stat_attr_show,
952	.store	= f2fs_stat_attr_store,
953};
954
955static struct kobj_type f2fs_stat_ktype = {
956	.default_groups = f2fs_stat_groups,
957	.sysfs_ops	= &f2fs_stat_attr_ops,
958	.release	= f2fs_stat_kobj_release,
959};
960
961static ssize_t f2fs_sb_feat_attr_show(struct kobject *kobj,
962				struct attribute *attr, char *buf)
963{
964	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
965							s_feature_list_kobj);
966	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
967
968	return a->show ? a->show(a, sbi, buf) : 0;
969}
970
971static void f2fs_feature_list_kobj_release(struct kobject *kobj)
972{
973	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
974							s_feature_list_kobj);
975	complete(&sbi->s_feature_list_kobj_unregister);
976}
977
978static const struct sysfs_ops f2fs_feature_list_attr_ops = {
979	.show	= f2fs_sb_feat_attr_show,
980};
981
982static struct kobj_type f2fs_feature_list_ktype = {
983	.default_groups = f2fs_sb_feat_groups,
984	.sysfs_ops	= &f2fs_feature_list_attr_ops,
985	.release	= f2fs_feature_list_kobj_release,
986};
987
988static int __maybe_unused segment_info_seq_show(struct seq_file *seq,
989						void *offset)
990{
991	struct super_block *sb = seq->private;
992	struct f2fs_sb_info *sbi = F2FS_SB(sb);
993	unsigned int total_segs =
994			le32_to_cpu(sbi->raw_super->segment_count_main);
995	int i;
996
997	seq_puts(seq, "format: segment_type|valid_blocks\n"
998		"segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
999
1000	for (i = 0; i < total_segs; i++) {
1001		struct seg_entry *se = get_seg_entry(sbi, i);
1002
1003		if ((i % 10) == 0)
1004			seq_printf(seq, "%-10d", i);
1005		seq_printf(seq, "%d|%-3u", se->type, se->valid_blocks);
1006		if ((i % 10) == 9 || i == (total_segs - 1))
1007			seq_putc(seq, '\n');
1008		else
1009			seq_putc(seq, ' ');
1010	}
1011
1012	return 0;
1013}
1014
1015static int __maybe_unused segment_bits_seq_show(struct seq_file *seq,
1016						void *offset)
1017{
1018	struct super_block *sb = seq->private;
1019	struct f2fs_sb_info *sbi = F2FS_SB(sb);
1020	unsigned int total_segs =
1021			le32_to_cpu(sbi->raw_super->segment_count_main);
1022	int i, j;
1023
1024	seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n"
1025		"segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
1026
1027	for (i = 0; i < total_segs; i++) {
1028		struct seg_entry *se = get_seg_entry(sbi, i);
1029
1030		seq_printf(seq, "%-10d", i);
1031		seq_printf(seq, "%d|%-3u|", se->type, se->valid_blocks);
1032		for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++)
1033			seq_printf(seq, " %.2x", se->cur_valid_map[j]);
1034		seq_putc(seq, '\n');
1035	}
1036	return 0;
1037}
1038
1039void f2fs_record_iostat(struct f2fs_sb_info *sbi)
1040{
1041	unsigned long long iostat_diff[NR_IO_TYPE];
1042	int i;
1043
1044	if (time_is_after_jiffies(sbi->iostat_next_period))
1045		return;
1046
1047	/* Need double check under the lock */
1048	spin_lock(&sbi->iostat_lock);
1049	if (time_is_after_jiffies(sbi->iostat_next_period)) {
1050		spin_unlock(&sbi->iostat_lock);
1051		return;
1052	}
1053	sbi->iostat_next_period = jiffies +
1054				msecs_to_jiffies(sbi->iostat_period_ms);
1055
1056	for (i = 0; i < NR_IO_TYPE; i++) {
1057		iostat_diff[i] = sbi->rw_iostat[i] -
1058				sbi->prev_rw_iostat[i];
1059		sbi->prev_rw_iostat[i] = sbi->rw_iostat[i];
1060	}
1061	spin_unlock(&sbi->iostat_lock);
1062
1063	trace_f2fs_iostat(sbi, iostat_diff);
1064}
1065
1066static int __maybe_unused iostat_info_seq_show(struct seq_file *seq,
1067					       void *offset)
1068{
1069	struct super_block *sb = seq->private;
1070	struct f2fs_sb_info *sbi = F2FS_SB(sb);
1071	time64_t now = ktime_get_real_seconds();
1072
1073	if (!sbi->iostat_enable)
1074		return 0;
1075
1076	seq_printf(seq, "time:		%-16llu\n", now);
1077
1078	/* print app write IOs */
1079	seq_puts(seq, "[WRITE]\n");
1080	seq_printf(seq, "app buffered:	%-16llu\n",
1081				sbi->rw_iostat[APP_BUFFERED_IO]);
1082	seq_printf(seq, "app direct:	%-16llu\n",
1083				sbi->rw_iostat[APP_DIRECT_IO]);
1084	seq_printf(seq, "app mapped:	%-16llu\n",
1085				sbi->rw_iostat[APP_MAPPED_IO]);
1086
1087	/* print fs write IOs */
1088	seq_printf(seq, "fs data:	%-16llu\n",
1089				sbi->rw_iostat[FS_DATA_IO]);
1090	seq_printf(seq, "fs node:	%-16llu\n",
1091				sbi->rw_iostat[FS_NODE_IO]);
1092	seq_printf(seq, "fs meta:	%-16llu\n",
1093				sbi->rw_iostat[FS_META_IO]);
1094	seq_printf(seq, "fs gc data:	%-16llu\n",
1095				sbi->rw_iostat[FS_GC_DATA_IO]);
1096	seq_printf(seq, "fs gc node:	%-16llu\n",
1097				sbi->rw_iostat[FS_GC_NODE_IO]);
1098	seq_printf(seq, "fs cp data:	%-16llu\n",
1099				sbi->rw_iostat[FS_CP_DATA_IO]);
1100	seq_printf(seq, "fs cp node:	%-16llu\n",
1101				sbi->rw_iostat[FS_CP_NODE_IO]);
1102	seq_printf(seq, "fs cp meta:	%-16llu\n",
1103				sbi->rw_iostat[FS_CP_META_IO]);
1104
1105	/* print app read IOs */
1106	seq_puts(seq, "[READ]\n");
1107	seq_printf(seq, "app buffered:	%-16llu\n",
1108				sbi->rw_iostat[APP_BUFFERED_READ_IO]);
1109	seq_printf(seq, "app direct:	%-16llu\n",
1110				sbi->rw_iostat[APP_DIRECT_READ_IO]);
1111	seq_printf(seq, "app mapped:	%-16llu\n",
1112				sbi->rw_iostat[APP_MAPPED_READ_IO]);
1113
1114	/* print fs read IOs */
1115	seq_printf(seq, "fs data:	%-16llu\n",
1116				sbi->rw_iostat[FS_DATA_READ_IO]);
1117	seq_printf(seq, "fs gc data:	%-16llu\n",
1118				sbi->rw_iostat[FS_GDATA_READ_IO]);
1119	seq_printf(seq, "fs compr_data:	%-16llu\n",
1120				sbi->rw_iostat[FS_CDATA_READ_IO]);
1121	seq_printf(seq, "fs node:	%-16llu\n",
1122				sbi->rw_iostat[FS_NODE_READ_IO]);
1123	seq_printf(seq, "fs meta:	%-16llu\n",
1124				sbi->rw_iostat[FS_META_READ_IO]);
1125
1126	/* print other IOs */
1127	seq_puts(seq, "[OTHER]\n");
1128	seq_printf(seq, "fs discard:	%-16llu\n",
1129				sbi->rw_iostat[FS_DISCARD]);
1130
1131	return 0;
1132}
1133
1134static int __maybe_unused victim_bits_seq_show(struct seq_file *seq,
1135						void *offset)
1136{
1137	struct super_block *sb = seq->private;
1138	struct f2fs_sb_info *sbi = F2FS_SB(sb);
1139	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
1140	int i;
1141
1142	seq_puts(seq, "format: victim_secmap bitmaps\n");
1143
1144	for (i = 0; i < MAIN_SECS(sbi); i++) {
1145		if ((i % 10) == 0)
1146			seq_printf(seq, "%-10d", i);
1147		seq_printf(seq, "%d", test_bit(i, dirty_i->victim_secmap) ? 1 : 0);
1148		if ((i % 10) == 9 || i == (MAIN_SECS(sbi) - 1))
1149			seq_putc(seq, '\n');
1150		else
1151			seq_putc(seq, ' ');
1152	}
1153	return 0;
1154}
1155
1156int __init f2fs_init_sysfs(void)
1157{
1158	int ret;
1159
1160	kobject_set_name(&f2fs_kset.kobj, "f2fs");
1161	f2fs_kset.kobj.parent = fs_kobj;
1162	ret = kset_register(&f2fs_kset);
1163	if (ret)
1164		return ret;
1165
1166	ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype,
1167				   NULL, "features");
1168	if (ret) {
1169		kobject_put(&f2fs_feat);
1170		kset_unregister(&f2fs_kset);
1171	} else {
1172		f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
1173	}
1174	return ret;
1175}
1176
1177void f2fs_exit_sysfs(void)
1178{
1179	kobject_put(&f2fs_feat);
1180	kset_unregister(&f2fs_kset);
1181	remove_proc_entry("fs/f2fs", NULL);
1182	f2fs_proc_root = NULL;
1183}
1184
1185int f2fs_register_sysfs(struct f2fs_sb_info *sbi)
1186{
1187	struct super_block *sb = sbi->sb;
1188	int err;
1189
1190	sbi->s_kobj.kset = &f2fs_kset;
1191	init_completion(&sbi->s_kobj_unregister);
1192	err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL,
1193				"%s", sb->s_id);
1194	if (err)
1195		goto put_sb_kobj;
1196
1197	sbi->s_stat_kobj.kset = &f2fs_kset;
1198	init_completion(&sbi->s_stat_kobj_unregister);
1199	err = kobject_init_and_add(&sbi->s_stat_kobj, &f2fs_stat_ktype,
1200						&sbi->s_kobj, "stat");
1201	if (err)
1202		goto put_stat_kobj;
1203
1204	sbi->s_feature_list_kobj.kset = &f2fs_kset;
1205	init_completion(&sbi->s_feature_list_kobj_unregister);
1206	err = kobject_init_and_add(&sbi->s_feature_list_kobj,
1207					&f2fs_feature_list_ktype,
1208					&sbi->s_kobj, "feature_list");
1209	if (err)
1210		goto put_feature_list_kobj;
1211
1212	if (f2fs_proc_root)
1213		sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);
1214
1215	if (sbi->s_proc) {
1216		proc_create_single_data("segment_info", S_IRUGO, sbi->s_proc,
1217				segment_info_seq_show, sb);
1218		proc_create_single_data("segment_bits", S_IRUGO, sbi->s_proc,
1219				segment_bits_seq_show, sb);
1220		proc_create_single_data("iostat_info", S_IRUGO, sbi->s_proc,
1221				iostat_info_seq_show, sb);
1222		proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc,
1223				victim_bits_seq_show, sb);
1224	}
1225	return 0;
1226put_feature_list_kobj:
1227	kobject_put(&sbi->s_feature_list_kobj);
1228	wait_for_completion(&sbi->s_feature_list_kobj_unregister);
1229put_stat_kobj:
1230	kobject_put(&sbi->s_stat_kobj);
1231	wait_for_completion(&sbi->s_stat_kobj_unregister);
1232put_sb_kobj:
1233	kobject_put(&sbi->s_kobj);
1234	wait_for_completion(&sbi->s_kobj_unregister);
1235	return err;
1236}
1237
1238void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi)
1239{
1240	if (sbi->s_proc) {
1241		remove_proc_entry("iostat_info", sbi->s_proc);
1242		remove_proc_entry("segment_info", sbi->s_proc);
1243		remove_proc_entry("segment_bits", sbi->s_proc);
1244		remove_proc_entry("victim_bits", sbi->s_proc);
1245		remove_proc_entry(sbi->sb->s_id, f2fs_proc_root);
1246	}
1247
1248	kobject_del(&sbi->s_stat_kobj);
1249	kobject_put(&sbi->s_stat_kobj);
1250	wait_for_completion(&sbi->s_stat_kobj_unregister);
1251	kobject_del(&sbi->s_feature_list_kobj);
1252	kobject_put(&sbi->s_feature_list_kobj);
1253	wait_for_completion(&sbi->s_feature_list_kobj_unregister);
1254
1255	kobject_del(&sbi->s_kobj);
1256	kobject_put(&sbi->s_kobj);
1257	wait_for_completion(&sbi->s_kobj_unregister);
1258}
1259