?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
xtensa: remove unnecessary KBUILD_SRC ifeq conditional
[linux/fpc-iii.git] / fs / f2fs / sysfs.c
blob81c0e5337443dee31c5339be2a305f16e91c9ddf
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/compiler.h>
13 #include <linux/proc_fs.h>
14 #include <linux/f2fs_fs.h>
15 #include <linux/seq_file.h>
16
17 #include "f2fs.h"
18 #include "segment.h"
19 #include "gc.h"
20
21 static struct proc_dir_entry *f2fs_proc_root;
22
23 /* Sysfs support for f2fs */
24 enum {
25 GC_THREAD, /* struct f2fs_gc_thread */
26 SM_INFO, /* struct f2fs_sm_info */
27 DCC_INFO, /* struct discard_cmd_control */
28 NM_INFO, /* struct f2fs_nm_info */
29 F2FS_SBI, /* struct f2fs_sb_info */
30 #ifdef CONFIG_F2FS_FAULT_INJECTION
31 FAULT_INFO_RATE, /* struct f2fs_fault_info */
32 FAULT_INFO_TYPE, /* struct f2fs_fault_info */
33 #endif
34 RESERVED_BLOCKS, /* struct f2fs_sb_info */
35 };
36
37 struct f2fs_attr {
38 struct attribute attr;
39 ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *);
40 ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *,
41 const char *, size_t);
42 int struct_type;
43 int offset;
44 int id;
45 };
46
47 static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type)
48 {
49 if (struct_type == GC_THREAD)
50 return (unsigned char *)sbi->gc_thread;
51 else if (struct_type == SM_INFO)
52 return (unsigned char *)SM_I(sbi);
53 else if (struct_type == DCC_INFO)
54 return (unsigned char *)SM_I(sbi)->dcc_info;
55 else if (struct_type == NM_INFO)
56 return (unsigned char *)NM_I(sbi);
57 else if (struct_type == F2FS_SBI || struct_type == RESERVED_BLOCKS)
58 return (unsigned char *)sbi;
59 #ifdef CONFIG_F2FS_FAULT_INJECTION
60 else if (struct_type == FAULT_INFO_RATE ||
61 struct_type == FAULT_INFO_TYPE)
62 return (unsigned char *)&F2FS_OPTION(sbi).fault_info;
63 #endif
64 return NULL;
65 }
66
67 static ssize_t dirty_segments_show(struct f2fs_attr *a,
68 struct f2fs_sb_info *sbi, char *buf)
69 {
70 return snprintf(buf, PAGE_SIZE, "%llu\n",
71 (unsigned long long)(dirty_segments(sbi)));
72 }
73
74 static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a,
75 struct f2fs_sb_info *sbi, char *buf)
76 {
77 struct super_block *sb = sbi->sb;
78
79 if (!sb->s_bdev->bd_part)
80 return snprintf(buf, PAGE_SIZE, "0\n");
81
82 return snprintf(buf, PAGE_SIZE, "%llu\n",
83 (unsigned long long)(sbi->kbytes_written +
84 BD_PART_WRITTEN(sbi)));
85 }
86
87 static ssize_t features_show(struct f2fs_attr *a,
88 struct f2fs_sb_info *sbi, char *buf)
89 {
90 struct super_block *sb = sbi->sb;
91 int len = 0;
92
93 if (!sb->s_bdev->bd_part)
94 return snprintf(buf, PAGE_SIZE, "0\n");
95
96 if (f2fs_sb_has_encrypt(sb))
97 len += snprintf(buf, PAGE_SIZE - len, "%s",
98 "encryption");
99 if (f2fs_sb_has_blkzoned(sb))
100 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
101 len ? ", " : "", "blkzoned");
102 if (f2fs_sb_has_extra_attr(sb))
103 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
104 len ? ", " : "", "extra_attr");
105 if (f2fs_sb_has_project_quota(sb))
106 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
107 len ? ", " : "", "projquota");
108 if (f2fs_sb_has_inode_chksum(sb))
109 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
110 len ? ", " : "", "inode_checksum");
111 if (f2fs_sb_has_flexible_inline_xattr(sb))
112 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
113 len ? ", " : "", "flexible_inline_xattr");
114 if (f2fs_sb_has_quota_ino(sb))
115 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
116 len ? ", " : "", "quota_ino");
117 if (f2fs_sb_has_inode_crtime(sb))
118 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
119 len ? ", " : "", "inode_crtime");
120 if (f2fs_sb_has_lost_found(sb))
121 len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
122 len ? ", " : "", "lost_found");
123 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
124 return len;
125 }
126
127 static ssize_t current_reserved_blocks_show(struct f2fs_attr *a,
128 struct f2fs_sb_info *sbi, char *buf)
129 {
130 return snprintf(buf, PAGE_SIZE, "%u\n", sbi->current_reserved_blocks);
131 }
132
133 static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
134 struct f2fs_sb_info *sbi, char *buf)
135 {
136 unsigned char *ptr = NULL;
137 unsigned int *ui;
138
139 ptr = __struct_ptr(sbi, a->struct_type);
140 if (!ptr)
141 return -EINVAL;
142
143 if (!strcmp(a->attr.name, "extension_list")) {
144 __u8 (*extlist)[F2FS_EXTENSION_LEN] =
145 sbi->raw_super->extension_list;
146 int cold_count = le32_to_cpu(sbi->raw_super->extension_count);
147 int hot_count = sbi->raw_super->hot_ext_count;
148 int len = 0, i;
149
150 len += snprintf(buf + len, PAGE_SIZE - len,
151 "cold file extension:\n");
152 for (i = 0; i < cold_count; i++)
153 len += snprintf(buf + len, PAGE_SIZE - len, "%s\n",
154 extlist[i]);
155
156 len += snprintf(buf + len, PAGE_SIZE - len,
157 "hot file extension:\n");
158 for (i = cold_count; i < cold_count + hot_count; i++)
159 len += snprintf(buf + len, PAGE_SIZE - len, "%s\n",
160 extlist[i]);
161 return len;
162 }
163
164 ui = (unsigned int *)(ptr + a->offset);
165
166 return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
167 }
168
169 static ssize_t __sbi_store(struct f2fs_attr *a,
170 struct f2fs_sb_info *sbi,
171 const char *buf, size_t count)
172 {
173 unsigned char *ptr;
174 unsigned long t;
175 unsigned int *ui;
176 ssize_t ret;
177
178 ptr = __struct_ptr(sbi, a->struct_type);
179 if (!ptr)
180 return -EINVAL;
181
182 if (!strcmp(a->attr.name, "extension_list")) {
183 const char *name = strim((char *)buf);
184 bool set = true, hot;
185
186 if (!strncmp(name, "[h]", 3))
187 hot = true;
188 else if (!strncmp(name, "[c]", 3))
189 hot = false;
190 else
191 return -EINVAL;
192
193 name += 3;
194
195 if (*name == '!') {
196 name++;
197 set = false;
198 }
199
200 if (strlen(name) >= F2FS_EXTENSION_LEN)
201 return -EINVAL;
202
203 down_write(&sbi->sb_lock);
204
205 ret = f2fs_update_extension_list(sbi, name, hot, set);
206 if (ret)
207 goto out;
208
209 ret = f2fs_commit_super(sbi, false);
210 if (ret)
211 f2fs_update_extension_list(sbi, name, hot, !set);
212 out:
213 up_write(&sbi->sb_lock);
214 return ret ? ret : count;
215 }
216
217 ui = (unsigned int *)(ptr + a->offset);
218
219 ret = kstrtoul(skip_spaces(buf), 0, &t);
220 if (ret < 0)
221 return ret;
222 #ifdef CONFIG_F2FS_FAULT_INJECTION
223 if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX))
224 return -EINVAL;
225 #endif
226 if (a->struct_type == RESERVED_BLOCKS) {
227 spin_lock(&sbi->stat_lock);
228 if (t > (unsigned long)(sbi->user_block_count -
229 F2FS_OPTION(sbi).root_reserved_blocks)) {
230 spin_unlock(&sbi->stat_lock);
231 return -EINVAL;
232 }
233 *ui = t;
234 sbi->current_reserved_blocks = min(sbi->reserved_blocks,
235 sbi->user_block_count - valid_user_blocks(sbi));
236 spin_unlock(&sbi->stat_lock);
237 return count;
238 }
239
240 if (!strcmp(a->attr.name, "discard_granularity")) {
241 if (t == 0 || t > MAX_PLIST_NUM)
242 return -EINVAL;
243 if (t == *ui)
244 return count;
245 *ui = t;
246 return count;
247 }
248
249 if (!strcmp(a->attr.name, "trim_sections"))
250 return -EINVAL;
251
252 if (!strcmp(a->attr.name, "gc_urgent")) {
253 if (t >= 1) {
254 sbi->gc_mode = GC_URGENT;
255 if (sbi->gc_thread) {
256 sbi->gc_thread->gc_wake = 1;
257 wake_up_interruptible_all(
258 &sbi->gc_thread->gc_wait_queue_head);
259 wake_up_discard_thread(sbi, true);
260 }
261 } else {
262 sbi->gc_mode = GC_NORMAL;
263 }
264 return count;
265 }
266 if (!strcmp(a->attr.name, "gc_idle")) {
267 if (t == GC_IDLE_CB)
268 sbi->gc_mode = GC_IDLE_CB;
269 else if (t == GC_IDLE_GREEDY)
270 sbi->gc_mode = GC_IDLE_GREEDY;
271 else
272 sbi->gc_mode = GC_NORMAL;
273 return count;
274 }
275
276 *ui = t;
277
278 if (!strcmp(a->attr.name, "iostat_enable") && *ui == 0)
279 f2fs_reset_iostat(sbi);
280 return count;
281 }
282
283 static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
284 struct f2fs_sb_info *sbi,
285 const char *buf, size_t count)
286 {
287 ssize_t ret;
288 bool gc_entry = (!strcmp(a->attr.name, "gc_urgent") ||
289 a->struct_type == GC_THREAD);
290
291 if (gc_entry) {
292 if (!down_read_trylock(&sbi->sb->s_umount))
293 return -EAGAIN;
294 }
295 ret = __sbi_store(a, sbi, buf, count);
296 if (gc_entry)
297 up_read(&sbi->sb->s_umount);
298
299 return ret;
300 }
301
302 static ssize_t f2fs_attr_show(struct kobject *kobj,
303 struct attribute *attr, char *buf)
304 {
305 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
306 s_kobj);
307 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
308
309 return a->show ? a->show(a, sbi, buf) : 0;
310 }
311
312 static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr,
313 const char *buf, size_t len)
314 {
315 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
316 s_kobj);
317 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
318
319 return a->store ? a->store(a, sbi, buf, len) : 0;
320 }
321
322 static void f2fs_sb_release(struct kobject *kobj)
323 {
324 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
325 s_kobj);
326 complete(&sbi->s_kobj_unregister);
327 }
328
329 enum feat_id {
330 FEAT_CRYPTO = 0,
331 FEAT_BLKZONED,
332 FEAT_ATOMIC_WRITE,
333 FEAT_EXTRA_ATTR,
334 FEAT_PROJECT_QUOTA,
335 FEAT_INODE_CHECKSUM,
336 FEAT_FLEXIBLE_INLINE_XATTR,
337 FEAT_QUOTA_INO,
338 FEAT_INODE_CRTIME,
339 FEAT_LOST_FOUND,
340 };
341
342 static ssize_t f2fs_feature_show(struct f2fs_attr *a,
343 struct f2fs_sb_info *sbi, char *buf)
344 {
345 switch (a->id) {
346 case FEAT_CRYPTO:
347 case FEAT_BLKZONED:
348 case FEAT_ATOMIC_WRITE:
349 case FEAT_EXTRA_ATTR:
350 case FEAT_PROJECT_QUOTA:
351 case FEAT_INODE_CHECKSUM:
352 case FEAT_FLEXIBLE_INLINE_XATTR:
353 case FEAT_QUOTA_INO:
354 case FEAT_INODE_CRTIME:
355 case FEAT_LOST_FOUND:
356 return snprintf(buf, PAGE_SIZE, "supported\n");
357 }
358 return 0;
359 }
360
361 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
362 static struct f2fs_attr f2fs_attr_##_name = { \
363 .attr = {.name = __stringify(_name), .mode = _mode }, \
364 .show = _show, \
365 .store = _store, \
366 .struct_type = _struct_type, \
367 .offset = _offset \
368 }
369
370 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \
371 F2FS_ATTR_OFFSET(struct_type, name, 0644, \
372 f2fs_sbi_show, f2fs_sbi_store, \
373 offsetof(struct struct_name, elname))
374
375 #define F2FS_GENERAL_RO_ATTR(name) \
376 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)
377
378 #define F2FS_FEATURE_RO_ATTR(_name, _id) \
379 static struct f2fs_attr f2fs_attr_##_name = { \
380 .attr = {.name = __stringify(_name), .mode = 0444 }, \
381 .show = f2fs_feature_show, \
382 .id = _id, \
383 }
384
385 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_urgent_sleep_time,
386 urgent_sleep_time);
387 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
388 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
389 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
390 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle, gc_mode);
391 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent, gc_mode);
392 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
393 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards);
394 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, discard_granularity, discard_granularity);
395 F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks);
396 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
397 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
398 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
399 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
400 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_seq_blocks, min_seq_blocks);
401 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks);
402 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);
403 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
404 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
405 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio);
406 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
407 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
408 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
409 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
410 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable);
411 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra);
412 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold);
413 F2FS_RW_ATTR(F2FS_SBI, f2fs_super_block, extension_list, extension_list);
414 #ifdef CONFIG_F2FS_FAULT_INJECTION
415 F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate);
416 F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type);
417 #endif
418 F2FS_GENERAL_RO_ATTR(dirty_segments);
419 F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes);
420 F2FS_GENERAL_RO_ATTR(features);
421 F2FS_GENERAL_RO_ATTR(current_reserved_blocks);
422
423 #ifdef CONFIG_F2FS_FS_ENCRYPTION
424 F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO);
425 #endif
426 #ifdef CONFIG_BLK_DEV_ZONED
427 F2FS_FEATURE_RO_ATTR(block_zoned, FEAT_BLKZONED);
428 #endif
429 F2FS_FEATURE_RO_ATTR(atomic_write, FEAT_ATOMIC_WRITE);
430 F2FS_FEATURE_RO_ATTR(extra_attr, FEAT_EXTRA_ATTR);
431 F2FS_FEATURE_RO_ATTR(project_quota, FEAT_PROJECT_QUOTA);
432 F2FS_FEATURE_RO_ATTR(inode_checksum, FEAT_INODE_CHECKSUM);
433 F2FS_FEATURE_RO_ATTR(flexible_inline_xattr, FEAT_FLEXIBLE_INLINE_XATTR);
434 F2FS_FEATURE_RO_ATTR(quota_ino, FEAT_QUOTA_INO);
435 F2FS_FEATURE_RO_ATTR(inode_crtime, FEAT_INODE_CRTIME);
436 F2FS_FEATURE_RO_ATTR(lost_found, FEAT_LOST_FOUND);
437
438 #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
439 static struct attribute *f2fs_attrs[] = {
440 ATTR_LIST(gc_urgent_sleep_time),
441 ATTR_LIST(gc_min_sleep_time),
442 ATTR_LIST(gc_max_sleep_time),
443 ATTR_LIST(gc_no_gc_sleep_time),
444 ATTR_LIST(gc_idle),
445 ATTR_LIST(gc_urgent),
446 ATTR_LIST(reclaim_segments),
447 ATTR_LIST(max_small_discards),
448 ATTR_LIST(discard_granularity),
449 ATTR_LIST(batched_trim_sections),
450 ATTR_LIST(ipu_policy),
451 ATTR_LIST(min_ipu_util),
452 ATTR_LIST(min_fsync_blocks),
453 ATTR_LIST(min_seq_blocks),
454 ATTR_LIST(min_hot_blocks),
455 ATTR_LIST(min_ssr_sections),
456 ATTR_LIST(max_victim_search),
457 ATTR_LIST(dir_level),
458 ATTR_LIST(ram_thresh),
459 ATTR_LIST(ra_nid_pages),
460 ATTR_LIST(dirty_nats_ratio),
461 ATTR_LIST(cp_interval),
462 ATTR_LIST(idle_interval),
463 ATTR_LIST(iostat_enable),
464 ATTR_LIST(readdir_ra),
465 ATTR_LIST(gc_pin_file_thresh),
466 ATTR_LIST(extension_list),
467 #ifdef CONFIG_F2FS_FAULT_INJECTION
468 ATTR_LIST(inject_rate),
469 ATTR_LIST(inject_type),
470 #endif
471 ATTR_LIST(dirty_segments),
472 ATTR_LIST(lifetime_write_kbytes),
473 ATTR_LIST(features),
474 ATTR_LIST(reserved_blocks),
475 ATTR_LIST(current_reserved_blocks),
476 NULL,
477 };
478
479 static struct attribute *f2fs_feat_attrs[] = {
480 #ifdef CONFIG_F2FS_FS_ENCRYPTION
481 ATTR_LIST(encryption),
482 #endif
483 #ifdef CONFIG_BLK_DEV_ZONED
484 ATTR_LIST(block_zoned),
485 #endif
486 ATTR_LIST(atomic_write),
487 ATTR_LIST(extra_attr),
488 ATTR_LIST(project_quota),
489 ATTR_LIST(inode_checksum),
490 ATTR_LIST(flexible_inline_xattr),
491 ATTR_LIST(quota_ino),
492 ATTR_LIST(inode_crtime),
493 ATTR_LIST(lost_found),
494 NULL,
495 };
496
497 static const struct sysfs_ops f2fs_attr_ops = {
498 .show = f2fs_attr_show,
499 .store = f2fs_attr_store,
500 };
501
502 static struct kobj_type f2fs_sb_ktype = {
503 .default_attrs = f2fs_attrs,
504 .sysfs_ops = &f2fs_attr_ops,
505 .release = f2fs_sb_release,
506 };
507
508 static struct kobj_type f2fs_ktype = {
509 .sysfs_ops = &f2fs_attr_ops,
510 };
511
512 static struct kset f2fs_kset = {
513 .kobj = {.ktype = &f2fs_ktype},
514 };
515
516 static struct kobj_type f2fs_feat_ktype = {
517 .default_attrs = f2fs_feat_attrs,
518 .sysfs_ops = &f2fs_attr_ops,
519 };
520
521 static struct kobject f2fs_feat = {
522 .kset = &f2fs_kset,
523 };
524
525 static int __maybe_unused segment_info_seq_show(struct seq_file *seq,
526 void *offset)
527 {
528 struct super_block *sb = seq->private;
529 struct f2fs_sb_info *sbi = F2FS_SB(sb);
530 unsigned int total_segs =
531 le32_to_cpu(sbi->raw_super->segment_count_main);
532 int i;
533
534 seq_puts(seq, "format: segment_type|valid_blocks\n"
535 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
536
537 for (i = 0; i < total_segs; i++) {
538 struct seg_entry *se = get_seg_entry(sbi, i);
539
540 if ((i % 10) == 0)
541 seq_printf(seq, "%-10d", i);
542 seq_printf(seq, "%d|%-3u", se->type,
543 get_valid_blocks(sbi, i, false));
544 if ((i % 10) == 9 || i == (total_segs - 1))
545 seq_putc(seq, '\n');
546 else
547 seq_putc(seq, ' ');
548 }
549
550 return 0;
551 }
552
553 static int __maybe_unused segment_bits_seq_show(struct seq_file *seq,
554 void *offset)
555 {
556 struct super_block *sb = seq->private;
557 struct f2fs_sb_info *sbi = F2FS_SB(sb);
558 unsigned int total_segs =
559 le32_to_cpu(sbi->raw_super->segment_count_main);
560 int i, j;
561
562 seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n"
563 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
564
565 for (i = 0; i < total_segs; i++) {
566 struct seg_entry *se = get_seg_entry(sbi, i);
567
568 seq_printf(seq, "%-10d", i);
569 seq_printf(seq, "%d|%-3u|", se->type,
570 get_valid_blocks(sbi, i, false));
571 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++)
572 seq_printf(seq, " %.2x", se->cur_valid_map[j]);
573 seq_putc(seq, '\n');
574 }
575 return 0;
576 }
577
578 static int __maybe_unused iostat_info_seq_show(struct seq_file *seq,
579 void *offset)
580 {
581 struct super_block *sb = seq->private;
582 struct f2fs_sb_info *sbi = F2FS_SB(sb);
583 time64_t now = ktime_get_real_seconds();
584
585 if (!sbi->iostat_enable)
586 return 0;
587
588 seq_printf(seq, "time: %-16llu\n", now);
589
590 /* print app IOs */
591 seq_printf(seq, "app buffered: %-16llu\n",
592 sbi->write_iostat[APP_BUFFERED_IO]);
593 seq_printf(seq, "app direct: %-16llu\n",
594 sbi->write_iostat[APP_DIRECT_IO]);
595 seq_printf(seq, "app mapped: %-16llu\n",
596 sbi->write_iostat[APP_MAPPED_IO]);
597
598 /* print fs IOs */
599 seq_printf(seq, "fs data: %-16llu\n",
600 sbi->write_iostat[FS_DATA_IO]);
601 seq_printf(seq, "fs node: %-16llu\n",
602 sbi->write_iostat[FS_NODE_IO]);
603 seq_printf(seq, "fs meta: %-16llu\n",
604 sbi->write_iostat[FS_META_IO]);
605 seq_printf(seq, "fs gc data: %-16llu\n",
606 sbi->write_iostat[FS_GC_DATA_IO]);
607 seq_printf(seq, "fs gc node: %-16llu\n",
608 sbi->write_iostat[FS_GC_NODE_IO]);
609 seq_printf(seq, "fs cp data: %-16llu\n",
610 sbi->write_iostat[FS_CP_DATA_IO]);
611 seq_printf(seq, "fs cp node: %-16llu\n",
612 sbi->write_iostat[FS_CP_NODE_IO]);
613 seq_printf(seq, "fs cp meta: %-16llu\n",
614 sbi->write_iostat[FS_CP_META_IO]);
615 seq_printf(seq, "fs discard: %-16llu\n",
616 sbi->write_iostat[FS_DISCARD]);
617
618 return 0;
619 }
620
621 static int __maybe_unused victim_bits_seq_show(struct seq_file *seq,
622 void *offset)
623 {
624 struct super_block *sb = seq->private;
625 struct f2fs_sb_info *sbi = F2FS_SB(sb);
626 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
627 int i;
628
629 seq_puts(seq, "format: victim_secmap bitmaps\n");
630
631 for (i = 0; i < MAIN_SECS(sbi); i++) {
632 if ((i % 10) == 0)
633 seq_printf(seq, "%-10d", i);
634 seq_printf(seq, "%d", test_bit(i, dirty_i->victim_secmap) ? 1 : 0);
635 if ((i % 10) == 9 || i == (MAIN_SECS(sbi) - 1))
636 seq_putc(seq, '\n');
637 else
638 seq_putc(seq, ' ');
639 }
640 return 0;
641 }
642
643 int __init f2fs_init_sysfs(void)
644 {
645 int ret;
646
647 kobject_set_name(&f2fs_kset.kobj, "f2fs");
648 f2fs_kset.kobj.parent = fs_kobj;
649 ret = kset_register(&f2fs_kset);
650 if (ret)
651 return ret;
652
653 ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype,
654 NULL, "features");
655 if (ret)
656 kset_unregister(&f2fs_kset);
657 else
658 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
659 return ret;
660 }
661
662 void f2fs_exit_sysfs(void)
663 {
664 kobject_put(&f2fs_feat);
665 kset_unregister(&f2fs_kset);
666 remove_proc_entry("fs/f2fs", NULL);
667 f2fs_proc_root = NULL;
668 }
669
670 int f2fs_register_sysfs(struct f2fs_sb_info *sbi)
671 {
672 struct super_block *sb = sbi->sb;
673 int err;
674
675 sbi->s_kobj.kset = &f2fs_kset;
676 init_completion(&sbi->s_kobj_unregister);
677 err = kobject_init_and_add(&sbi->s_kobj, &f2fs_sb_ktype, NULL,
678 "%s", sb->s_id);
679 if (err)
680 return err;
681
682 if (f2fs_proc_root)
683 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);
684
685 if (sbi->s_proc) {
686 proc_create_single_data("segment_info", S_IRUGO, sbi->s_proc,
687 segment_info_seq_show, sb);
688 proc_create_single_data("segment_bits", S_IRUGO, sbi->s_proc,
689 segment_bits_seq_show, sb);
690 proc_create_single_data("iostat_info", S_IRUGO, sbi->s_proc,
691 iostat_info_seq_show, sb);
692 proc_create_single_data("victim_bits", S_IRUGO, sbi->s_proc,
693 victim_bits_seq_show, sb);
694 }
695 return 0;
696 }
697
698 void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi)
699 {
700 if (sbi->s_proc) {
701 remove_proc_entry("iostat_info", sbi->s_proc);
702 remove_proc_entry("segment_info", sbi->s_proc);
703 remove_proc_entry("segment_bits", sbi->s_proc);
704 remove_proc_entry("victim_bits", sbi->s_proc);
705 remove_proc_entry(sbi->sb->s_id, f2fs_proc_root);
706 }
707 kobject_del(&sbi->s_kobj);
708 }
Linux with added FPC-III support