1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/ext4/sysfs.c
5 * Copyright (C) 1992, 1993, 1994, 1995
6 * Remy Card (card@masi.ibp.fr)
7 * Theodore Ts'o (tytso@mit.edu)
11 #include <linux/time.h>
13 #include <linux/seq_file.h>
14 #include <linux/proc_fs.h>
17 #include "ext4_jbd2.h"
21 attr_delayed_allocation_blocks
,
22 attr_session_write_kbytes
,
23 attr_lifetime_write_kbytes
,
24 attr_reserved_clusters
,
26 attr_trigger_test_error
,
34 ptr_ext4_sb_info_offset
,
35 ptr_ext4_super_block_offset
,
38 static const char proc_dirname
[] = "fs/ext4";
39 static struct proc_dir_entry
*ext4_proc_root
;
42 struct attribute attr
;
51 static ssize_t
session_write_kbytes_show(struct ext4_attr
*a
,
52 struct ext4_sb_info
*sbi
, char *buf
)
54 struct super_block
*sb
= sbi
->s_buddy_cache
->i_sb
;
56 if (!sb
->s_bdev
->bd_part
)
57 return snprintf(buf
, PAGE_SIZE
, "0\n");
58 return snprintf(buf
, PAGE_SIZE
, "%lu\n",
59 (part_stat_read(sb
->s_bdev
->bd_part
, sectors
[1]) -
60 sbi
->s_sectors_written_start
) >> 1);
63 static ssize_t
lifetime_write_kbytes_show(struct ext4_attr
*a
,
64 struct ext4_sb_info
*sbi
, char *buf
)
66 struct super_block
*sb
= sbi
->s_buddy_cache
->i_sb
;
68 if (!sb
->s_bdev
->bd_part
)
69 return snprintf(buf
, PAGE_SIZE
, "0\n");
70 return snprintf(buf
, PAGE_SIZE
, "%llu\n",
71 (unsigned long long)(sbi
->s_kbytes_written
+
72 ((part_stat_read(sb
->s_bdev
->bd_part
, sectors
[1]) -
73 EXT4_SB(sb
)->s_sectors_written_start
) >> 1)));
76 static ssize_t
inode_readahead_blks_store(struct ext4_attr
*a
,
77 struct ext4_sb_info
*sbi
,
78 const char *buf
, size_t count
)
83 ret
= kstrtoul(skip_spaces(buf
), 0, &t
);
87 if (t
&& (!is_power_of_2(t
) || t
> 0x40000000))
90 sbi
->s_inode_readahead_blks
= t
;
94 static ssize_t
reserved_clusters_store(struct ext4_attr
*a
,
95 struct ext4_sb_info
*sbi
,
96 const char *buf
, size_t count
)
98 unsigned long long val
;
99 ext4_fsblk_t clusters
= (ext4_blocks_count(sbi
->s_es
) >>
100 sbi
->s_cluster_bits
);
103 ret
= kstrtoull(skip_spaces(buf
), 0, &val
);
104 if (ret
|| val
>= clusters
)
107 atomic64_set(&sbi
->s_resv_clusters
, val
);
111 static ssize_t
trigger_test_error(struct ext4_attr
*a
,
112 struct ext4_sb_info
*sbi
,
113 const char *buf
, size_t count
)
117 if (!capable(CAP_SYS_ADMIN
))
120 if (len
&& buf
[len
-1] == '\n')
124 ext4_error(sbi
->s_sb
, "%.*s", len
, buf
);
128 #define EXT4_ATTR(_name,_mode,_id) \
129 static struct ext4_attr ext4_attr_##_name = { \
130 .attr = {.name = __stringify(_name), .mode = _mode }, \
131 .attr_id = attr_##_id, \
134 #define EXT4_ATTR_FUNC(_name,_mode) EXT4_ATTR(_name,_mode,_name)
136 #define EXT4_ATTR_FEATURE(_name) EXT4_ATTR(_name, 0444, feature)
138 #define EXT4_ATTR_OFFSET(_name,_mode,_id,_struct,_elname) \
139 static struct ext4_attr ext4_attr_##_name = { \
140 .attr = {.name = __stringify(_name), .mode = _mode }, \
141 .attr_id = attr_##_id, \
142 .attr_ptr = ptr_##_struct##_offset, \
144 .offset = offsetof(struct _struct, _elname),\
148 #define EXT4_RO_ATTR_ES_UI(_name,_elname) \
149 EXT4_ATTR_OFFSET(_name, 0444, pointer_ui, ext4_super_block, _elname)
151 #define EXT4_RW_ATTR_SBI_UI(_name,_elname) \
152 EXT4_ATTR_OFFSET(_name, 0644, pointer_ui, ext4_sb_info, _elname)
154 #define EXT4_ATTR_PTR(_name,_mode,_id,_ptr) \
155 static struct ext4_attr ext4_attr_##_name = { \
156 .attr = {.name = __stringify(_name), .mode = _mode }, \
157 .attr_id = attr_##_id, \
158 .attr_ptr = ptr_explicit, \
160 .explicit_ptr = _ptr, \
164 #define ATTR_LIST(name) &ext4_attr_##name.attr
166 EXT4_ATTR_FUNC(delayed_allocation_blocks
, 0444);
167 EXT4_ATTR_FUNC(session_write_kbytes
, 0444);
168 EXT4_ATTR_FUNC(lifetime_write_kbytes
, 0444);
169 EXT4_ATTR_FUNC(reserved_clusters
, 0644);
171 EXT4_ATTR_OFFSET(inode_readahead_blks
, 0644, inode_readahead
,
172 ext4_sb_info
, s_inode_readahead_blks
);
173 EXT4_RW_ATTR_SBI_UI(inode_goal
, s_inode_goal
);
174 EXT4_RW_ATTR_SBI_UI(mb_stats
, s_mb_stats
);
175 EXT4_RW_ATTR_SBI_UI(mb_max_to_scan
, s_mb_max_to_scan
);
176 EXT4_RW_ATTR_SBI_UI(mb_min_to_scan
, s_mb_min_to_scan
);
177 EXT4_RW_ATTR_SBI_UI(mb_order2_req
, s_mb_order2_reqs
);
178 EXT4_RW_ATTR_SBI_UI(mb_stream_req
, s_mb_stream_request
);
179 EXT4_RW_ATTR_SBI_UI(mb_group_prealloc
, s_mb_group_prealloc
);
180 EXT4_RW_ATTR_SBI_UI(extent_max_zeroout_kb
, s_extent_max_zeroout_kb
);
181 EXT4_ATTR(trigger_fs_error
, 0200, trigger_test_error
);
182 EXT4_RW_ATTR_SBI_UI(err_ratelimit_interval_ms
, s_err_ratelimit_state
.interval
);
183 EXT4_RW_ATTR_SBI_UI(err_ratelimit_burst
, s_err_ratelimit_state
.burst
);
184 EXT4_RW_ATTR_SBI_UI(warning_ratelimit_interval_ms
, s_warning_ratelimit_state
.interval
);
185 EXT4_RW_ATTR_SBI_UI(warning_ratelimit_burst
, s_warning_ratelimit_state
.burst
);
186 EXT4_RW_ATTR_SBI_UI(msg_ratelimit_interval_ms
, s_msg_ratelimit_state
.interval
);
187 EXT4_RW_ATTR_SBI_UI(msg_ratelimit_burst
, s_msg_ratelimit_state
.burst
);
188 EXT4_RO_ATTR_ES_UI(errors_count
, s_error_count
);
189 EXT4_RO_ATTR_ES_UI(first_error_time
, s_first_error_time
);
190 EXT4_RO_ATTR_ES_UI(last_error_time
, s_last_error_time
);
192 static unsigned int old_bump_val
= 128;
193 EXT4_ATTR_PTR(max_writeback_mb_bump
, 0444, pointer_ui
, &old_bump_val
);
195 static struct attribute
*ext4_attrs
[] = {
196 ATTR_LIST(delayed_allocation_blocks
),
197 ATTR_LIST(session_write_kbytes
),
198 ATTR_LIST(lifetime_write_kbytes
),
199 ATTR_LIST(reserved_clusters
),
200 ATTR_LIST(inode_readahead_blks
),
201 ATTR_LIST(inode_goal
),
203 ATTR_LIST(mb_max_to_scan
),
204 ATTR_LIST(mb_min_to_scan
),
205 ATTR_LIST(mb_order2_req
),
206 ATTR_LIST(mb_stream_req
),
207 ATTR_LIST(mb_group_prealloc
),
208 ATTR_LIST(max_writeback_mb_bump
),
209 ATTR_LIST(extent_max_zeroout_kb
),
210 ATTR_LIST(trigger_fs_error
),
211 ATTR_LIST(err_ratelimit_interval_ms
),
212 ATTR_LIST(err_ratelimit_burst
),
213 ATTR_LIST(warning_ratelimit_interval_ms
),
214 ATTR_LIST(warning_ratelimit_burst
),
215 ATTR_LIST(msg_ratelimit_interval_ms
),
216 ATTR_LIST(msg_ratelimit_burst
),
217 ATTR_LIST(errors_count
),
218 ATTR_LIST(first_error_time
),
219 ATTR_LIST(last_error_time
),
223 /* Features this copy of ext4 supports */
224 EXT4_ATTR_FEATURE(lazy_itable_init
);
225 EXT4_ATTR_FEATURE(batched_discard
);
226 EXT4_ATTR_FEATURE(meta_bg_resize
);
227 #ifdef CONFIG_EXT4_FS_ENCRYPTION
228 EXT4_ATTR_FEATURE(encryption
);
230 EXT4_ATTR_FEATURE(metadata_csum_seed
);
232 static struct attribute
*ext4_feat_attrs
[] = {
233 ATTR_LIST(lazy_itable_init
),
234 ATTR_LIST(batched_discard
),
235 ATTR_LIST(meta_bg_resize
),
236 #ifdef CONFIG_EXT4_FS_ENCRYPTION
237 ATTR_LIST(encryption
),
239 ATTR_LIST(metadata_csum_seed
),
243 static void *calc_ptr(struct ext4_attr
*a
, struct ext4_sb_info
*sbi
)
245 switch (a
->attr_ptr
) {
247 return a
->u
.explicit_ptr
;
248 case ptr_ext4_sb_info_offset
:
249 return (void *) (((char *) sbi
) + a
->u
.offset
);
250 case ptr_ext4_super_block_offset
:
251 return (void *) (((char *) sbi
->s_es
) + a
->u
.offset
);
256 static ssize_t
ext4_attr_show(struct kobject
*kobj
,
257 struct attribute
*attr
, char *buf
)
259 struct ext4_sb_info
*sbi
= container_of(kobj
, struct ext4_sb_info
,
261 struct ext4_attr
*a
= container_of(attr
, struct ext4_attr
, attr
);
262 void *ptr
= calc_ptr(a
, sbi
);
264 switch (a
->attr_id
) {
265 case attr_delayed_allocation_blocks
:
266 return snprintf(buf
, PAGE_SIZE
, "%llu\n",
268 percpu_counter_sum(&sbi
->s_dirtyclusters_counter
)));
269 case attr_session_write_kbytes
:
270 return session_write_kbytes_show(a
, sbi
, buf
);
271 case attr_lifetime_write_kbytes
:
272 return lifetime_write_kbytes_show(a
, sbi
, buf
);
273 case attr_reserved_clusters
:
274 return snprintf(buf
, PAGE_SIZE
, "%llu\n",
276 atomic64_read(&sbi
->s_resv_clusters
));
277 case attr_inode_readahead
:
278 case attr_pointer_ui
:
281 if (a
->attr_ptr
== ptr_ext4_super_block_offset
)
282 return snprintf(buf
, PAGE_SIZE
, "%u\n",
285 return snprintf(buf
, PAGE_SIZE
, "%u\n",
286 *((unsigned int *) ptr
));
287 case attr_pointer_atomic
:
290 return snprintf(buf
, PAGE_SIZE
, "%d\n",
291 atomic_read((atomic_t
*) ptr
));
293 return snprintf(buf
, PAGE_SIZE
, "supported\n");
299 static ssize_t
ext4_attr_store(struct kobject
*kobj
,
300 struct attribute
*attr
,
301 const char *buf
, size_t len
)
303 struct ext4_sb_info
*sbi
= container_of(kobj
, struct ext4_sb_info
,
305 struct ext4_attr
*a
= container_of(attr
, struct ext4_attr
, attr
);
306 void *ptr
= calc_ptr(a
, sbi
);
310 switch (a
->attr_id
) {
311 case attr_reserved_clusters
:
312 return reserved_clusters_store(a
, sbi
, buf
, len
);
313 case attr_pointer_ui
:
316 ret
= kstrtoul(skip_spaces(buf
), 0, &t
);
319 if (a
->attr_ptr
== ptr_ext4_super_block_offset
)
320 *((__le32
*) ptr
) = cpu_to_le32(t
);
322 *((unsigned int *) ptr
) = t
;
324 case attr_inode_readahead
:
325 return inode_readahead_blks_store(a
, sbi
, buf
, len
);
326 case attr_trigger_test_error
:
327 return trigger_test_error(a
, sbi
, buf
, len
);
332 static void ext4_sb_release(struct kobject
*kobj
)
334 struct ext4_sb_info
*sbi
= container_of(kobj
, struct ext4_sb_info
,
336 complete(&sbi
->s_kobj_unregister
);
339 static const struct sysfs_ops ext4_attr_ops
= {
340 .show
= ext4_attr_show
,
341 .store
= ext4_attr_store
,
344 static struct kobj_type ext4_sb_ktype
= {
345 .default_attrs
= ext4_attrs
,
346 .sysfs_ops
= &ext4_attr_ops
,
347 .release
= ext4_sb_release
,
350 static struct kobj_type ext4_ktype
= {
351 .sysfs_ops
= &ext4_attr_ops
,
354 static struct kset ext4_kset
= {
355 .kobj
= {.ktype
= &ext4_ktype
},
358 static struct kobj_type ext4_feat_ktype
= {
359 .default_attrs
= ext4_feat_attrs
,
360 .sysfs_ops
= &ext4_attr_ops
,
363 static struct kobject ext4_feat
= {
367 #define PROC_FILE_SHOW_DEFN(name) \
368 static int name##_open(struct inode *inode, struct file *file) \
370 return single_open(file, ext4_seq_##name##_show, PDE_DATA(inode)); \
373 static const struct file_operations ext4_seq_##name##_fops = { \
374 .open = name##_open, \
376 .llseek = seq_lseek, \
377 .release = single_release, \
380 #define PROC_FILE_LIST(name) \
381 { __stringify(name), &ext4_seq_##name##_fops }
383 PROC_FILE_SHOW_DEFN(es_shrinker_info
);
384 PROC_FILE_SHOW_DEFN(options
);
386 static const struct ext4_proc_files
{
388 const struct file_operations
*fops
;
390 PROC_FILE_LIST(options
),
391 PROC_FILE_LIST(es_shrinker_info
),
392 PROC_FILE_LIST(mb_groups
),
396 int ext4_register_sysfs(struct super_block
*sb
)
398 struct ext4_sb_info
*sbi
= EXT4_SB(sb
);
399 const struct ext4_proc_files
*p
;
402 sbi
->s_kobj
.kset
= &ext4_kset
;
403 init_completion(&sbi
->s_kobj_unregister
);
404 err
= kobject_init_and_add(&sbi
->s_kobj
, &ext4_sb_ktype
, NULL
,
410 sbi
->s_proc
= proc_mkdir(sb
->s_id
, ext4_proc_root
);
413 for (p
= proc_files
; p
->name
; p
++)
414 proc_create_data(p
->name
, S_IRUGO
, sbi
->s_proc
,
420 void ext4_unregister_sysfs(struct super_block
*sb
)
422 struct ext4_sb_info
*sbi
= EXT4_SB(sb
);
423 const struct ext4_proc_files
*p
;
426 for (p
= proc_files
; p
->name
; p
++)
427 remove_proc_entry(p
->name
, sbi
->s_proc
);
428 remove_proc_entry(sb
->s_id
, ext4_proc_root
);
430 kobject_del(&sbi
->s_kobj
);
433 int __init
ext4_init_sysfs(void)
437 kobject_set_name(&ext4_kset
.kobj
, "ext4");
438 ext4_kset
.kobj
.parent
= fs_kobj
;
439 ret
= kset_register(&ext4_kset
);
443 ret
= kobject_init_and_add(&ext4_feat
, &ext4_feat_ktype
,
446 kset_unregister(&ext4_kset
);
448 ext4_proc_root
= proc_mkdir(proc_dirname
, NULL
);
452 void ext4_exit_sysfs(void)
454 kobject_put(&ext4_feat
);
455 kset_unregister(&ext4_kset
);
456 remove_proc_entry(proc_dirname
, NULL
);
457 ext4_proc_root
= NULL
;