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