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