2 * linux/fs/ext4/sysfs.c
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Theodore Ts'o (tytso@mit.edu)
10 #include <linux/time.h>
12 #include <linux/seq_file.h>
13 #include <linux/proc_fs.h>
16 #include "ext4_jbd2.h"
20 attr_delayed_allocation_blocks
,
21 attr_session_write_kbytes
,
22 attr_lifetime_write_kbytes
,
23 attr_reserved_clusters
,
25 attr_trigger_test_error
,
33 ptr_ext4_sb_info_offset
,
34 ptr_ext4_super_block_offset
,
37 static const char *proc_dirname
= "fs/ext4";
38 static struct proc_dir_entry
*ext4_proc_root
;
41 struct attribute attr
;
50 static ssize_t
session_write_kbytes_show(struct ext4_attr
*a
,
51 struct ext4_sb_info
*sbi
, char *buf
)
53 struct super_block
*sb
= sbi
->s_buddy_cache
->i_sb
;
55 if (!sb
->s_bdev
->bd_part
)
56 return snprintf(buf
, PAGE_SIZE
, "0\n");
57 return snprintf(buf
, PAGE_SIZE
, "%lu\n",
58 (part_stat_read(sb
->s_bdev
->bd_part
, sectors
[1]) -
59 sbi
->s_sectors_written_start
) >> 1);
62 static ssize_t
lifetime_write_kbytes_show(struct ext4_attr
*a
,
63 struct ext4_sb_info
*sbi
, char *buf
)
65 struct super_block
*sb
= sbi
->s_buddy_cache
->i_sb
;
67 if (!sb
->s_bdev
->bd_part
)
68 return snprintf(buf
, PAGE_SIZE
, "0\n");
69 return snprintf(buf
, PAGE_SIZE
, "%llu\n",
70 (unsigned long long)(sbi
->s_kbytes_written
+
71 ((part_stat_read(sb
->s_bdev
->bd_part
, sectors
[1]) -
72 EXT4_SB(sb
)->s_sectors_written_start
) >> 1)));
75 static ssize_t
inode_readahead_blks_store(struct ext4_attr
*a
,
76 struct ext4_sb_info
*sbi
,
77 const char *buf
, size_t count
)
82 ret
= kstrtoul(skip_spaces(buf
), 0, &t
);
86 if (t
&& (!is_power_of_2(t
) || t
> 0x40000000))
89 sbi
->s_inode_readahead_blks
= t
;
93 static ssize_t
reserved_clusters_store(struct ext4_attr
*a
,
94 struct ext4_sb_info
*sbi
,
95 const char *buf
, size_t count
)
97 unsigned long long val
;
98 ext4_fsblk_t clusters
= (ext4_blocks_count(sbi
->s_es
) >>
102 ret
= kstrtoull(skip_spaces(buf
), 0, &val
);
103 if (ret
|| val
>= clusters
)
106 atomic64_set(&sbi
->s_resv_clusters
, val
);
110 static ssize_t
trigger_test_error(struct ext4_attr
*a
,
111 struct ext4_sb_info
*sbi
,
112 const char *buf
, size_t count
)
116 if (!capable(CAP_SYS_ADMIN
))
119 if (len
&& buf
[len
-1] == '\n')
123 ext4_error(sbi
->s_sb
, "%.*s", len
, buf
);
127 #define EXT4_ATTR(_name,_mode,_id) \
128 static struct ext4_attr ext4_attr_##_name = { \
129 .attr = {.name = __stringify(_name), .mode = _mode }, \
130 .attr_id = attr_##_id, \
133 #define EXT4_ATTR_FUNC(_name,_mode) EXT4_ATTR(_name,_mode,_name)
135 #define EXT4_ATTR_FEATURE(_name) EXT4_ATTR(_name, 0444, feature)
137 #define EXT4_ATTR_OFFSET(_name,_mode,_id,_struct,_elname) \
138 static struct ext4_attr ext4_attr_##_name = { \
139 .attr = {.name = __stringify(_name), .mode = _mode }, \
140 .attr_id = attr_##_id, \
141 .attr_ptr = ptr_##_struct##_offset, \
143 .offset = offsetof(struct _struct, _elname),\
147 #define EXT4_RO_ATTR_ES_UI(_name,_elname) \
148 EXT4_ATTR_OFFSET(_name, 0444, pointer_ui, ext4_super_block, _elname)
150 #define EXT4_RW_ATTR_SBI_UI(_name,_elname) \
151 EXT4_ATTR_OFFSET(_name, 0644, pointer_ui, ext4_sb_info, _elname)
153 #define EXT4_ATTR_PTR(_name,_mode,_id,_ptr) \
154 static struct ext4_attr ext4_attr_##_name = { \
155 .attr = {.name = __stringify(_name), .mode = _mode }, \
156 .attr_id = attr_##_id, \
157 .attr_ptr = ptr_explicit, \
159 .explicit_ptr = _ptr, \
163 #define ATTR_LIST(name) &ext4_attr_##name.attr
165 EXT4_ATTR_FUNC(delayed_allocation_blocks
, 0444);
166 EXT4_ATTR_FUNC(session_write_kbytes
, 0444);
167 EXT4_ATTR_FUNC(lifetime_write_kbytes
, 0444);
168 EXT4_ATTR_FUNC(reserved_clusters
, 0644);
170 EXT4_ATTR_OFFSET(inode_readahead_blks
, 0644, inode_readahead
,
171 ext4_sb_info
, s_inode_readahead_blks
);
172 EXT4_RW_ATTR_SBI_UI(inode_goal
, s_inode_goal
);
173 EXT4_RW_ATTR_SBI_UI(mb_stats
, s_mb_stats
);
174 EXT4_RW_ATTR_SBI_UI(mb_max_to_scan
, s_mb_max_to_scan
);
175 EXT4_RW_ATTR_SBI_UI(mb_min_to_scan
, s_mb_min_to_scan
);
176 EXT4_RW_ATTR_SBI_UI(mb_order2_req
, s_mb_order2_reqs
);
177 EXT4_RW_ATTR_SBI_UI(mb_stream_req
, s_mb_stream_request
);
178 EXT4_RW_ATTR_SBI_UI(mb_group_prealloc
, s_mb_group_prealloc
);
179 EXT4_RW_ATTR_SBI_UI(extent_max_zeroout_kb
, s_extent_max_zeroout_kb
);
180 EXT4_ATTR(trigger_fs_error
, 0200, trigger_test_error
);
181 EXT4_RW_ATTR_SBI_UI(err_ratelimit_interval_ms
, s_err_ratelimit_state
.interval
);
182 EXT4_RW_ATTR_SBI_UI(err_ratelimit_burst
, s_err_ratelimit_state
.burst
);
183 EXT4_RW_ATTR_SBI_UI(warning_ratelimit_interval_ms
, s_warning_ratelimit_state
.interval
);
184 EXT4_RW_ATTR_SBI_UI(warning_ratelimit_burst
, s_warning_ratelimit_state
.burst
);
185 EXT4_RW_ATTR_SBI_UI(msg_ratelimit_interval_ms
, s_msg_ratelimit_state
.interval
);
186 EXT4_RW_ATTR_SBI_UI(msg_ratelimit_burst
, s_msg_ratelimit_state
.burst
);
187 EXT4_RO_ATTR_ES_UI(errors_count
, s_error_count
);
188 EXT4_RO_ATTR_ES_UI(first_error_time
, s_first_error_time
);
189 EXT4_RO_ATTR_ES_UI(last_error_time
, s_last_error_time
);
191 static unsigned int old_bump_val
= 128;
192 EXT4_ATTR_PTR(max_writeback_mb_bump
, 0444, pointer_ui
, &old_bump_val
);
194 static struct attribute
*ext4_attrs
[] = {
195 ATTR_LIST(delayed_allocation_blocks
),
196 ATTR_LIST(session_write_kbytes
),
197 ATTR_LIST(lifetime_write_kbytes
),
198 ATTR_LIST(reserved_clusters
),
199 ATTR_LIST(inode_readahead_blks
),
200 ATTR_LIST(inode_goal
),
202 ATTR_LIST(mb_max_to_scan
),
203 ATTR_LIST(mb_min_to_scan
),
204 ATTR_LIST(mb_order2_req
),
205 ATTR_LIST(mb_stream_req
),
206 ATTR_LIST(mb_group_prealloc
),
207 ATTR_LIST(max_writeback_mb_bump
),
208 ATTR_LIST(extent_max_zeroout_kb
),
209 ATTR_LIST(trigger_fs_error
),
210 ATTR_LIST(err_ratelimit_interval_ms
),
211 ATTR_LIST(err_ratelimit_burst
),
212 ATTR_LIST(warning_ratelimit_interval_ms
),
213 ATTR_LIST(warning_ratelimit_burst
),
214 ATTR_LIST(msg_ratelimit_interval_ms
),
215 ATTR_LIST(msg_ratelimit_burst
),
216 ATTR_LIST(errors_count
),
217 ATTR_LIST(first_error_time
),
218 ATTR_LIST(last_error_time
),
222 /* Features this copy of ext4 supports */
223 EXT4_ATTR_FEATURE(lazy_itable_init
);
224 EXT4_ATTR_FEATURE(batched_discard
);
225 EXT4_ATTR_FEATURE(meta_bg_resize
);
226 #ifdef CONFIG_EXT4_FS_ENCRYPTION
227 EXT4_ATTR_FEATURE(encryption
);
229 EXT4_ATTR_FEATURE(metadata_csum_seed
);
231 static struct attribute
*ext4_feat_attrs
[] = {
232 ATTR_LIST(lazy_itable_init
),
233 ATTR_LIST(batched_discard
),
234 ATTR_LIST(meta_bg_resize
),
235 #ifdef CONFIG_EXT4_FS_ENCRYPTION
236 ATTR_LIST(encryption
),
238 ATTR_LIST(metadata_csum_seed
),
242 static void *calc_ptr(struct ext4_attr
*a
, struct ext4_sb_info
*sbi
)
244 switch (a
->attr_ptr
) {
246 return a
->u
.explicit_ptr
;
247 case ptr_ext4_sb_info_offset
:
248 return (void *) (((char *) sbi
) + a
->u
.offset
);
249 case ptr_ext4_super_block_offset
:
250 return (void *) (((char *) sbi
->s_es
) + a
->u
.offset
);
255 static ssize_t
ext4_attr_show(struct kobject
*kobj
,
256 struct attribute
*attr
, char *buf
)
258 struct ext4_sb_info
*sbi
= container_of(kobj
, struct ext4_sb_info
,
260 struct ext4_attr
*a
= container_of(attr
, struct ext4_attr
, attr
);
261 void *ptr
= calc_ptr(a
, sbi
);
263 switch (a
->attr_id
) {
264 case attr_delayed_allocation_blocks
:
265 return snprintf(buf
, PAGE_SIZE
, "%llu\n",
267 percpu_counter_sum(&sbi
->s_dirtyclusters_counter
)));
268 case attr_session_write_kbytes
:
269 return session_write_kbytes_show(a
, sbi
, buf
);
270 case attr_lifetime_write_kbytes
:
271 return lifetime_write_kbytes_show(a
, sbi
, buf
);
272 case attr_reserved_clusters
:
273 return snprintf(buf
, PAGE_SIZE
, "%llu\n",
275 atomic64_read(&sbi
->s_resv_clusters
));
276 case attr_inode_readahead
:
277 case attr_pointer_ui
:
280 if (a
->attr_ptr
== ptr_ext4_super_block_offset
)
281 return snprintf(buf
, PAGE_SIZE
, "%u\n",
284 return snprintf(buf
, PAGE_SIZE
, "%u\n",
285 *((unsigned int *) ptr
));
286 case attr_pointer_atomic
:
289 return snprintf(buf
, PAGE_SIZE
, "%d\n",
290 atomic_read((atomic_t
*) ptr
));
292 return snprintf(buf
, PAGE_SIZE
, "supported\n");
298 static ssize_t
ext4_attr_store(struct kobject
*kobj
,
299 struct attribute
*attr
,
300 const char *buf
, size_t len
)
302 struct ext4_sb_info
*sbi
= container_of(kobj
, struct ext4_sb_info
,
304 struct ext4_attr
*a
= container_of(attr
, struct ext4_attr
, attr
);
305 void *ptr
= calc_ptr(a
, sbi
);
309 switch (a
->attr_id
) {
310 case attr_reserved_clusters
:
311 return reserved_clusters_store(a
, sbi
, buf
, len
);
312 case attr_pointer_ui
:
315 ret
= kstrtoul(skip_spaces(buf
), 0, &t
);
318 if (a
->attr_ptr
== ptr_ext4_super_block_offset
)
319 *((__le32
*) ptr
) = cpu_to_le32(t
);
321 *((unsigned int *) ptr
) = t
;
323 case attr_inode_readahead
:
324 return inode_readahead_blks_store(a
, sbi
, buf
, len
);
325 case attr_trigger_test_error
:
326 return trigger_test_error(a
, sbi
, buf
, len
);
331 static void ext4_sb_release(struct kobject
*kobj
)
333 struct ext4_sb_info
*sbi
= container_of(kobj
, struct ext4_sb_info
,
335 complete(&sbi
->s_kobj_unregister
);
338 static const struct sysfs_ops ext4_attr_ops
= {
339 .show
= ext4_attr_show
,
340 .store
= ext4_attr_store
,
343 static struct kobj_type ext4_sb_ktype
= {
344 .default_attrs
= ext4_attrs
,
345 .sysfs_ops
= &ext4_attr_ops
,
346 .release
= ext4_sb_release
,
349 static struct kobj_type ext4_ktype
= {
350 .sysfs_ops
= &ext4_attr_ops
,
353 static struct kset ext4_kset
= {
354 .kobj
= {.ktype
= &ext4_ktype
},
357 static struct kobj_type ext4_feat_ktype
= {
358 .default_attrs
= ext4_feat_attrs
,
359 .sysfs_ops
= &ext4_attr_ops
,
362 static struct kobject ext4_feat
= {
366 #define PROC_FILE_SHOW_DEFN(name) \
367 static int name##_open(struct inode *inode, struct file *file) \
369 return single_open(file, ext4_seq_##name##_show, PDE_DATA(inode)); \
372 static const struct file_operations ext4_seq_##name##_fops = { \
373 .owner = THIS_MODULE, \
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 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 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 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
;