]>
Commit | Line | Data |
---|---|---|
8ceffcb2 CY |
1 | /* |
2 | * f2fs sysfs interface | |
3 | * | |
4 | * Copyright (c) 2012 Samsung Electronics Co., Ltd. | |
5 | * http://www.samsung.com/ | |
6 | * Copyright (c) 2017 Chao Yu <chao@kernel.org> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | */ | |
12 | #include <linux/proc_fs.h> | |
13 | #include <linux/f2fs_fs.h> | |
299aa41a | 14 | #include <linux/seq_file.h> |
8ceffcb2 CY |
15 | |
16 | #include "f2fs.h" | |
17 | #include "segment.h" | |
18 | #include "gc.h" | |
19 | ||
20 | static struct proc_dir_entry *f2fs_proc_root; | |
8ceffcb2 CY |
21 | |
22 | /* Sysfs support for f2fs */ | |
23 | enum { | |
24 | GC_THREAD, /* struct f2fs_gc_thread */ | |
25 | SM_INFO, /* struct f2fs_sm_info */ | |
26 | DCC_INFO, /* struct discard_cmd_control */ | |
27 | NM_INFO, /* struct f2fs_nm_info */ | |
28 | F2FS_SBI, /* struct f2fs_sb_info */ | |
29 | #ifdef CONFIG_F2FS_FAULT_INJECTION | |
30 | FAULT_INFO_RATE, /* struct f2fs_fault_info */ | |
31 | FAULT_INFO_TYPE, /* struct f2fs_fault_info */ | |
32 | #endif | |
80d42145 | 33 | RESERVED_BLOCKS, /* struct f2fs_sb_info */ |
8ceffcb2 CY |
34 | }; |
35 | ||
36 | struct f2fs_attr { | |
37 | struct attribute attr; | |
38 | ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *); | |
39 | ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *, | |
40 | const char *, size_t); | |
41 | int struct_type; | |
42 | int offset; | |
bf9e697e | 43 | int id; |
8ceffcb2 CY |
44 | }; |
45 | ||
46 | static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type) | |
47 | { | |
48 | if (struct_type == GC_THREAD) | |
49 | return (unsigned char *)sbi->gc_thread; | |
50 | else if (struct_type == SM_INFO) | |
51 | return (unsigned char *)SM_I(sbi); | |
52 | else if (struct_type == DCC_INFO) | |
53 | return (unsigned char *)SM_I(sbi)->dcc_info; | |
54 | else if (struct_type == NM_INFO) | |
55 | return (unsigned char *)NM_I(sbi); | |
daeb433e | 56 | else if (struct_type == F2FS_SBI || struct_type == RESERVED_BLOCKS) |
8ceffcb2 CY |
57 | return (unsigned char *)sbi; |
58 | #ifdef CONFIG_F2FS_FAULT_INJECTION | |
59 | else if (struct_type == FAULT_INFO_RATE || | |
60 | struct_type == FAULT_INFO_TYPE) | |
61 | return (unsigned char *)&sbi->fault_info; | |
62 | #endif | |
63 | return NULL; | |
64 | } | |
65 | ||
8f1572f7 JK |
66 | static ssize_t dirty_segments_show(struct f2fs_attr *a, |
67 | struct f2fs_sb_info *sbi, char *buf) | |
68 | { | |
69 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
70 | (unsigned long long)(dirty_segments(sbi))); | |
71 | } | |
72 | ||
8ceffcb2 CY |
73 | static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a, |
74 | struct f2fs_sb_info *sbi, char *buf) | |
75 | { | |
76 | struct super_block *sb = sbi->sb; | |
77 | ||
78 | if (!sb->s_bdev->bd_part) | |
79 | return snprintf(buf, PAGE_SIZE, "0\n"); | |
80 | ||
81 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
82 | (unsigned long long)(sbi->kbytes_written + | |
83 | BD_PART_WRITTEN(sbi))); | |
84 | } | |
85 | ||
bf9e697e JK |
86 | static ssize_t features_show(struct f2fs_attr *a, |
87 | struct f2fs_sb_info *sbi, char *buf) | |
88 | { | |
89 | struct super_block *sb = sbi->sb; | |
90 | int len = 0; | |
91 | ||
92 | if (!sb->s_bdev->bd_part) | |
93 | return snprintf(buf, PAGE_SIZE, "0\n"); | |
94 | ||
95 | if (f2fs_sb_has_crypto(sb)) | |
96 | len += snprintf(buf, PAGE_SIZE - len, "%s", | |
97 | "encryption"); | |
98 | if (f2fs_sb_mounted_blkzoned(sb)) | |
99 | len += snprintf(buf + len, PAGE_SIZE - len, "%s%s", | |
100 | len ? ", " : "", "blkzoned"); | |
101 | if (f2fs_sb_has_extra_attr(sb)) | |
102 | len += snprintf(buf + len, PAGE_SIZE - len, "%s%s", | |
103 | len ? ", " : "", "extra_attr"); | |
104 | if (f2fs_sb_has_project_quota(sb)) | |
105 | len += snprintf(buf + len, PAGE_SIZE - len, "%s%s", | |
106 | len ? ", " : "", "projquota"); | |
107 | if (f2fs_sb_has_inode_chksum(sb)) | |
108 | len += snprintf(buf + len, PAGE_SIZE - len, "%s%s", | |
109 | len ? ", " : "", "inode_checksum"); | |
6afc662e CY |
110 | if (f2fs_sb_has_flexible_inline_xattr(sb)) |
111 | len += snprintf(buf + len, PAGE_SIZE - len, "%s%s", | |
112 | len ? ", " : "", "flexible_inline_xattr"); | |
234a9689 JK |
113 | if (f2fs_sb_has_quota_ino(sb)) |
114 | len += snprintf(buf + len, PAGE_SIZE - len, "%s%s", | |
115 | len ? ", " : "", "quota_ino"); | |
bf9e697e JK |
116 | len += snprintf(buf + len, PAGE_SIZE - len, "\n"); |
117 | return len; | |
118 | } | |
119 | ||
80d42145 YS |
120 | static ssize_t current_reserved_blocks_show(struct f2fs_attr *a, |
121 | struct f2fs_sb_info *sbi, char *buf) | |
122 | { | |
123 | return snprintf(buf, PAGE_SIZE, "%u\n", sbi->current_reserved_blocks); | |
124 | } | |
125 | ||
8ceffcb2 CY |
126 | static ssize_t f2fs_sbi_show(struct f2fs_attr *a, |
127 | struct f2fs_sb_info *sbi, char *buf) | |
128 | { | |
129 | unsigned char *ptr = NULL; | |
130 | unsigned int *ui; | |
131 | ||
132 | ptr = __struct_ptr(sbi, a->struct_type); | |
133 | if (!ptr) | |
134 | return -EINVAL; | |
135 | ||
136 | ui = (unsigned int *)(ptr + a->offset); | |
137 | ||
138 | return snprintf(buf, PAGE_SIZE, "%u\n", *ui); | |
139 | } | |
140 | ||
141 | static ssize_t f2fs_sbi_store(struct f2fs_attr *a, | |
142 | struct f2fs_sb_info *sbi, | |
143 | const char *buf, size_t count) | |
144 | { | |
145 | unsigned char *ptr; | |
146 | unsigned long t; | |
147 | unsigned int *ui; | |
148 | ssize_t ret; | |
149 | ||
150 | ptr = __struct_ptr(sbi, a->struct_type); | |
151 | if (!ptr) | |
152 | return -EINVAL; | |
153 | ||
154 | ui = (unsigned int *)(ptr + a->offset); | |
155 | ||
156 | ret = kstrtoul(skip_spaces(buf), 0, &t); | |
157 | if (ret < 0) | |
158 | return ret; | |
159 | #ifdef CONFIG_F2FS_FAULT_INJECTION | |
160 | if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX)) | |
161 | return -EINVAL; | |
162 | #endif | |
daeb433e CY |
163 | if (a->struct_type == RESERVED_BLOCKS) { |
164 | spin_lock(&sbi->stat_lock); | |
80d42145 | 165 | if (t > (unsigned long)sbi->user_block_count) { |
daeb433e CY |
166 | spin_unlock(&sbi->stat_lock); |
167 | return -EINVAL; | |
168 | } | |
169 | *ui = t; | |
80d42145 YS |
170 | sbi->current_reserved_blocks = min(sbi->reserved_blocks, |
171 | sbi->user_block_count - valid_user_blocks(sbi)); | |
daeb433e CY |
172 | spin_unlock(&sbi->stat_lock); |
173 | return count; | |
174 | } | |
969d1b18 CY |
175 | |
176 | if (!strcmp(a->attr.name, "discard_granularity")) { | |
969d1b18 CY |
177 | if (t == 0 || t > MAX_PLIST_NUM) |
178 | return -EINVAL; | |
179 | if (t == *ui) | |
180 | return count; | |
80647e5f | 181 | *ui = t; |
969d1b18 CY |
182 | return count; |
183 | } | |
184 | ||
8ceffcb2 | 185 | *ui = t; |
b0af6d49 CY |
186 | |
187 | if (!strcmp(a->attr.name, "iostat_enable") && *ui == 0) | |
188 | f2fs_reset_iostat(sbi); | |
d9872a69 JK |
189 | if (!strcmp(a->attr.name, "gc_urgent") && t == 1 && sbi->gc_thread) { |
190 | sbi->gc_thread->gc_wake = 1; | |
191 | wake_up_interruptible_all(&sbi->gc_thread->gc_wait_queue_head); | |
01983c71 | 192 | wake_up_discard_thread(sbi, true); |
d9872a69 | 193 | } |
b0af6d49 | 194 | |
8ceffcb2 CY |
195 | return count; |
196 | } | |
197 | ||
198 | static ssize_t f2fs_attr_show(struct kobject *kobj, | |
199 | struct attribute *attr, char *buf) | |
200 | { | |
201 | struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, | |
202 | s_kobj); | |
203 | struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); | |
204 | ||
205 | return a->show ? a->show(a, sbi, buf) : 0; | |
206 | } | |
207 | ||
208 | static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr, | |
209 | const char *buf, size_t len) | |
210 | { | |
211 | struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, | |
212 | s_kobj); | |
213 | struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); | |
214 | ||
215 | return a->store ? a->store(a, sbi, buf, len) : 0; | |
216 | } | |
217 | ||
218 | static void f2fs_sb_release(struct kobject *kobj) | |
219 | { | |
220 | struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, | |
221 | s_kobj); | |
222 | complete(&sbi->s_kobj_unregister); | |
223 | } | |
224 | ||
bf9e697e JK |
225 | enum feat_id { |
226 | FEAT_CRYPTO = 0, | |
227 | FEAT_BLKZONED, | |
228 | FEAT_ATOMIC_WRITE, | |
229 | FEAT_EXTRA_ATTR, | |
230 | FEAT_PROJECT_QUOTA, | |
231 | FEAT_INODE_CHECKSUM, | |
6afc662e | 232 | FEAT_FLEXIBLE_INLINE_XATTR, |
234a9689 | 233 | FEAT_QUOTA_INO, |
bf9e697e JK |
234 | }; |
235 | ||
236 | static ssize_t f2fs_feature_show(struct f2fs_attr *a, | |
237 | struct f2fs_sb_info *sbi, char *buf) | |
238 | { | |
239 | switch (a->id) { | |
240 | case FEAT_CRYPTO: | |
241 | case FEAT_BLKZONED: | |
242 | case FEAT_ATOMIC_WRITE: | |
243 | case FEAT_EXTRA_ATTR: | |
244 | case FEAT_PROJECT_QUOTA: | |
245 | case FEAT_INODE_CHECKSUM: | |
6afc662e | 246 | case FEAT_FLEXIBLE_INLINE_XATTR: |
234a9689 | 247 | case FEAT_QUOTA_INO: |
bf9e697e JK |
248 | return snprintf(buf, PAGE_SIZE, "supported\n"); |
249 | } | |
250 | return 0; | |
251 | } | |
252 | ||
8ceffcb2 CY |
253 | #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ |
254 | static struct f2fs_attr f2fs_attr_##_name = { \ | |
255 | .attr = {.name = __stringify(_name), .mode = _mode }, \ | |
256 | .show = _show, \ | |
257 | .store = _store, \ | |
258 | .struct_type = _struct_type, \ | |
259 | .offset = _offset \ | |
260 | } | |
261 | ||
262 | #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ | |
263 | F2FS_ATTR_OFFSET(struct_type, name, 0644, \ | |
264 | f2fs_sbi_show, f2fs_sbi_store, \ | |
265 | offsetof(struct struct_name, elname)) | |
266 | ||
267 | #define F2FS_GENERAL_RO_ATTR(name) \ | |
268 | static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL) | |
269 | ||
bf9e697e JK |
270 | #define F2FS_FEATURE_RO_ATTR(_name, _id) \ |
271 | static struct f2fs_attr f2fs_attr_##_name = { \ | |
272 | .attr = {.name = __stringify(_name), .mode = 0444 }, \ | |
273 | .show = f2fs_feature_show, \ | |
274 | .id = _id, \ | |
275 | } | |
276 | ||
d9872a69 JK |
277 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time, |
278 | urgent_sleep_time); | |
8ceffcb2 CY |
279 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time); |
280 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time); | |
281 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time); | |
282 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_idle, gc_idle); | |
d9872a69 | 283 | F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent, gc_urgent); |
8ceffcb2 CY |
284 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments); |
285 | F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards); | |
969d1b18 | 286 | F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity); |
daeb433e | 287 | F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks); |
8ceffcb2 CY |
288 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections); |
289 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy); | |
290 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util); | |
291 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); | |
292 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks); | |
a2a12b67 | 293 | F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections); |
8ceffcb2 CY |
294 | F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh); |
295 | F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages); | |
296 | F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); | |
297 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search); | |
298 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level); | |
299 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]); | |
300 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]); | |
b0af6d49 | 301 | F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable); |
8ceffcb2 CY |
302 | #ifdef CONFIG_F2FS_FAULT_INJECTION |
303 | F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate); | |
304 | F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type); | |
305 | #endif | |
8f1572f7 | 306 | F2FS_GENERAL_RO_ATTR(dirty_segments); |
8ceffcb2 | 307 | F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes); |
bf9e697e | 308 | F2FS_GENERAL_RO_ATTR(features); |
80d42145 | 309 | F2FS_GENERAL_RO_ATTR(current_reserved_blocks); |
bf9e697e JK |
310 | |
311 | #ifdef CONFIG_F2FS_FS_ENCRYPTION | |
312 | F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO); | |
313 | #endif | |
314 | #ifdef CONFIG_BLK_DEV_ZONED | |
315 | F2FS_FEATURE_RO_ATTR(block_zoned, FEAT_BLKZONED); | |
316 | #endif | |
317 | F2FS_FEATURE_RO_ATTR(atomic_write, FEAT_ATOMIC_WRITE); | |
318 | F2FS_FEATURE_RO_ATTR(extra_attr, FEAT_EXTRA_ATTR); | |
319 | F2FS_FEATURE_RO_ATTR(project_quota, FEAT_PROJECT_QUOTA); | |
320 | F2FS_FEATURE_RO_ATTR(inode_checksum, FEAT_INODE_CHECKSUM); | |
6afc662e | 321 | F2FS_FEATURE_RO_ATTR(flexible_inline_xattr, FEAT_FLEXIBLE_INLINE_XATTR); |
234a9689 | 322 | F2FS_FEATURE_RO_ATTR(quota_ino, FEAT_QUOTA_INO); |
8ceffcb2 CY |
323 | |
324 | #define ATTR_LIST(name) (&f2fs_attr_##name.attr) | |
325 | static struct attribute *f2fs_attrs[] = { | |
d9872a69 | 326 | ATTR_LIST(gc_urgent_sleep_time), |
8ceffcb2 CY |
327 | ATTR_LIST(gc_min_sleep_time), |
328 | ATTR_LIST(gc_max_sleep_time), | |
329 | ATTR_LIST(gc_no_gc_sleep_time), | |
330 | ATTR_LIST(gc_idle), | |
d9872a69 | 331 | ATTR_LIST(gc_urgent), |
8ceffcb2 CY |
332 | ATTR_LIST(reclaim_segments), |
333 | ATTR_LIST(max_small_discards), | |
969d1b18 | 334 | ATTR_LIST(discard_granularity), |
8ceffcb2 CY |
335 | ATTR_LIST(batched_trim_sections), |
336 | ATTR_LIST(ipu_policy), | |
337 | ATTR_LIST(min_ipu_util), | |
338 | ATTR_LIST(min_fsync_blocks), | |
339 | ATTR_LIST(min_hot_blocks), | |
a2a12b67 | 340 | ATTR_LIST(min_ssr_sections), |
8ceffcb2 CY |
341 | ATTR_LIST(max_victim_search), |
342 | ATTR_LIST(dir_level), | |
343 | ATTR_LIST(ram_thresh), | |
344 | ATTR_LIST(ra_nid_pages), | |
345 | ATTR_LIST(dirty_nats_ratio), | |
346 | ATTR_LIST(cp_interval), | |
347 | ATTR_LIST(idle_interval), | |
b0af6d49 | 348 | ATTR_LIST(iostat_enable), |
8ceffcb2 CY |
349 | #ifdef CONFIG_F2FS_FAULT_INJECTION |
350 | ATTR_LIST(inject_rate), | |
351 | ATTR_LIST(inject_type), | |
352 | #endif | |
8f1572f7 | 353 | ATTR_LIST(dirty_segments), |
8ceffcb2 | 354 | ATTR_LIST(lifetime_write_kbytes), |
bf9e697e | 355 | ATTR_LIST(features), |
daeb433e | 356 | ATTR_LIST(reserved_blocks), |
80d42145 | 357 | ATTR_LIST(current_reserved_blocks), |
8ceffcb2 CY |
358 | NULL, |
359 | }; | |
360 | ||
bf9e697e JK |
361 | static struct attribute *f2fs_feat_attrs[] = { |
362 | #ifdef CONFIG_F2FS_FS_ENCRYPTION | |
363 | ATTR_LIST(encryption), | |
364 | #endif | |
365 | #ifdef CONFIG_BLK_DEV_ZONED | |
366 | ATTR_LIST(block_zoned), | |
367 | #endif | |
368 | ATTR_LIST(atomic_write), | |
369 | ATTR_LIST(extra_attr), | |
370 | ATTR_LIST(project_quota), | |
371 | ATTR_LIST(inode_checksum), | |
6afc662e | 372 | ATTR_LIST(flexible_inline_xattr), |
234a9689 | 373 | ATTR_LIST(quota_ino), |
bf9e697e JK |
374 | NULL, |
375 | }; | |
376 | ||
8ceffcb2 CY |
377 | static const struct sysfs_ops f2fs_attr_ops = { |
378 | .show = f2fs_attr_show, | |
379 | .store = f2fs_attr_store, | |
380 | }; | |
381 | ||
bf9e697e | 382 | static struct kobj_type f2fs_sb_ktype = { |
8ceffcb2 CY |
383 | .default_attrs = f2fs_attrs, |
384 | .sysfs_ops = &f2fs_attr_ops, | |
385 | .release = f2fs_sb_release, | |
386 | }; | |
387 | ||
bf9e697e JK |
388 | static struct kobj_type f2fs_ktype = { |
389 | .sysfs_ops = &f2fs_attr_ops, | |
390 | }; | |
391 | ||
392 | static struct kset f2fs_kset = { | |
393 | .kobj = {.ktype = &f2fs_ktype}, | |
394 | }; | |
395 | ||
396 | static struct kobj_type f2fs_feat_ktype = { | |
397 | .default_attrs = f2fs_feat_attrs, | |
398 | .sysfs_ops = &f2fs_attr_ops, | |
399 | }; | |
400 | ||
401 | static struct kobject f2fs_feat = { | |
402 | .kset = &f2fs_kset, | |
403 | }; | |
404 | ||
8ceffcb2 CY |
405 | static int segment_info_seq_show(struct seq_file *seq, void *offset) |
406 | { | |
407 | struct super_block *sb = seq->private; | |
408 | struct f2fs_sb_info *sbi = F2FS_SB(sb); | |
409 | unsigned int total_segs = | |
410 | le32_to_cpu(sbi->raw_super->segment_count_main); | |
411 | int i; | |
412 | ||
413 | seq_puts(seq, "format: segment_type|valid_blocks\n" | |
414 | "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); | |
415 | ||
416 | for (i = 0; i < total_segs; i++) { | |
417 | struct seg_entry *se = get_seg_entry(sbi, i); | |
418 | ||
419 | if ((i % 10) == 0) | |
420 | seq_printf(seq, "%-10d", i); | |
421 | seq_printf(seq, "%d|%-3u", se->type, | |
422 | get_valid_blocks(sbi, i, false)); | |
423 | if ((i % 10) == 9 || i == (total_segs - 1)) | |
424 | seq_putc(seq, '\n'); | |
425 | else | |
426 | seq_putc(seq, ' '); | |
427 | } | |
428 | ||
429 | return 0; | |
430 | } | |
431 | ||
432 | static int segment_bits_seq_show(struct seq_file *seq, void *offset) | |
433 | { | |
434 | struct super_block *sb = seq->private; | |
435 | struct f2fs_sb_info *sbi = F2FS_SB(sb); | |
436 | unsigned int total_segs = | |
437 | le32_to_cpu(sbi->raw_super->segment_count_main); | |
438 | int i, j; | |
439 | ||
440 | seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n" | |
441 | "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); | |
442 | ||
443 | for (i = 0; i < total_segs; i++) { | |
444 | struct seg_entry *se = get_seg_entry(sbi, i); | |
445 | ||
446 | seq_printf(seq, "%-10d", i); | |
447 | seq_printf(seq, "%d|%-3u|", se->type, | |
448 | get_valid_blocks(sbi, i, false)); | |
449 | for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++) | |
450 | seq_printf(seq, " %.2x", se->cur_valid_map[j]); | |
451 | seq_putc(seq, '\n'); | |
452 | } | |
453 | return 0; | |
454 | } | |
455 | ||
b0af6d49 CY |
456 | static int iostat_info_seq_show(struct seq_file *seq, void *offset) |
457 | { | |
458 | struct super_block *sb = seq->private; | |
459 | struct f2fs_sb_info *sbi = F2FS_SB(sb); | |
460 | time64_t now = ktime_get_real_seconds(); | |
461 | ||
462 | if (!sbi->iostat_enable) | |
463 | return 0; | |
464 | ||
465 | seq_printf(seq, "time: %-16llu\n", now); | |
466 | ||
467 | /* print app IOs */ | |
468 | seq_printf(seq, "app buffered: %-16llu\n", | |
469 | sbi->write_iostat[APP_BUFFERED_IO]); | |
470 | seq_printf(seq, "app direct: %-16llu\n", | |
471 | sbi->write_iostat[APP_DIRECT_IO]); | |
472 | seq_printf(seq, "app mapped: %-16llu\n", | |
473 | sbi->write_iostat[APP_MAPPED_IO]); | |
474 | ||
475 | /* print fs IOs */ | |
476 | seq_printf(seq, "fs data: %-16llu\n", | |
477 | sbi->write_iostat[FS_DATA_IO]); | |
478 | seq_printf(seq, "fs node: %-16llu\n", | |
479 | sbi->write_iostat[FS_NODE_IO]); | |
480 | seq_printf(seq, "fs meta: %-16llu\n", | |
481 | sbi->write_iostat[FS_META_IO]); | |
482 | seq_printf(seq, "fs gc data: %-16llu\n", | |
483 | sbi->write_iostat[FS_GC_DATA_IO]); | |
484 | seq_printf(seq, "fs gc node: %-16llu\n", | |
485 | sbi->write_iostat[FS_GC_NODE_IO]); | |
486 | seq_printf(seq, "fs cp data: %-16llu\n", | |
487 | sbi->write_iostat[FS_CP_DATA_IO]); | |
488 | seq_printf(seq, "fs cp node: %-16llu\n", | |
489 | sbi->write_iostat[FS_CP_NODE_IO]); | |
490 | seq_printf(seq, "fs cp meta: %-16llu\n", | |
491 | sbi->write_iostat[FS_CP_META_IO]); | |
492 | seq_printf(seq, "fs discard: %-16llu\n", | |
493 | sbi->write_iostat[FS_DISCARD]); | |
494 | ||
495 | return 0; | |
496 | } | |
497 | ||
8ceffcb2 CY |
498 | #define F2FS_PROC_FILE_DEF(_name) \ |
499 | static int _name##_open_fs(struct inode *inode, struct file *file) \ | |
500 | { \ | |
501 | return single_open(file, _name##_seq_show, PDE_DATA(inode)); \ | |
502 | } \ | |
503 | \ | |
504 | static const struct file_operations f2fs_seq_##_name##_fops = { \ | |
505 | .open = _name##_open_fs, \ | |
506 | .read = seq_read, \ | |
507 | .llseek = seq_lseek, \ | |
508 | .release = single_release, \ | |
509 | }; | |
510 | ||
511 | F2FS_PROC_FILE_DEF(segment_info); | |
512 | F2FS_PROC_FILE_DEF(segment_bits); | |
b0af6d49 | 513 | F2FS_PROC_FILE_DEF(iostat_info); |
8ceffcb2 | 514 | |
dc6b2055 | 515 | int __init f2fs_init_sysfs(void) |
8ceffcb2 | 516 | { |
bf9e697e | 517 | int ret; |
8ceffcb2 | 518 | |
bf9e697e JK |
519 | kobject_set_name(&f2fs_kset.kobj, "f2fs"); |
520 | f2fs_kset.kobj.parent = fs_kobj; | |
521 | ret = kset_register(&f2fs_kset); | |
522 | if (ret) | |
523 | return ret; | |
524 | ||
525 | ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype, | |
526 | NULL, "features"); | |
527 | if (ret) | |
528 | kset_unregister(&f2fs_kset); | |
529 | else | |
530 | f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); | |
531 | return ret; | |
8ceffcb2 CY |
532 | } |
533 | ||
dc6b2055 | 534 | void f2fs_exit_sysfs(void) |
8ceffcb2 | 535 | { |
bf9e697e JK |
536 | kobject_put(&f2fs_feat); |
537 | kset_unregister(&f2fs_kset); | |
8ceffcb2 | 538 | remove_proc_entry("fs/f2fs", NULL); |
bf9e697e | 539 | f2fs_proc_root = NULL; |
8ceffcb2 CY |
540 | } |
541 | ||
dc6b2055 | 542 | int f2fs_register_sysfs(struct f2fs_sb_info *sbi) |
8ceffcb2 CY |
543 | { |
544 | struct super_block *sb = sbi->sb; | |
545 | int err; | |
546 | ||
bf9e697e JK |
547 | sbi->s_kobj.kset = &f2fs_kset; |
548 | init_completion(&sbi->s_kobj_unregister); | |
549 | err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL, | |
550 | "%s", sb->s_id); | |
551 | if (err) | |
552 | return err; | |
553 | ||
8ceffcb2 CY |
554 | if (f2fs_proc_root) |
555 | sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root); | |
556 | ||
557 | if (sbi->s_proc) { | |
558 | proc_create_data("segment_info", S_IRUGO, sbi->s_proc, | |
559 | &f2fs_seq_segment_info_fops, sb); | |
560 | proc_create_data("segment_bits", S_IRUGO, sbi->s_proc, | |
561 | &f2fs_seq_segment_bits_fops, sb); | |
b0af6d49 CY |
562 | proc_create_data("iostat_info", S_IRUGO, sbi->s_proc, |
563 | &f2fs_seq_iostat_info_fops, sb); | |
8ceffcb2 | 564 | } |
8ceffcb2 | 565 | return 0; |
8ceffcb2 CY |
566 | } |
567 | ||
dc6b2055 | 568 | void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi) |
8ceffcb2 | 569 | { |
8ceffcb2 | 570 | if (sbi->s_proc) { |
b0af6d49 | 571 | remove_proc_entry("iostat_info", sbi->s_proc); |
8ceffcb2 CY |
572 | remove_proc_entry("segment_info", sbi->s_proc); |
573 | remove_proc_entry("segment_bits", sbi->s_proc); | |
574 | remove_proc_entry(sbi->sb->s_id, f2fs_proc_root); | |
575 | } | |
bf9e697e | 576 | kobject_del(&sbi->s_kobj); |
8ceffcb2 | 577 | } |