Commit | Line | Data |
---|---|---|
ae98043f | 1 | // SPDX-License-Identifier: GPL-2.0+ |
aebe17f6 VD |
2 | /* |
3 | * sysfs.c - sysfs support implementation. | |
4 | * | |
5 | * Copyright (C) 2005-2014 Nippon Telegraph and Telephone Corporation. | |
6 | * Copyright (C) 2014 HGST, Inc., a Western Digital Company. | |
7 | * | |
aebe17f6 VD |
8 | * Written by Vyacheslav Dubeyko <Vyacheslav.Dubeyko@hgst.com> |
9 | */ | |
10 | ||
11 | #include <linux/kobject.h> | |
12 | ||
13 | #include "nilfs.h" | |
14 | #include "mdt.h" | |
15 | #include "sufile.h" | |
16 | #include "cpfile.h" | |
17 | #include "sysfs.h" | |
18 | ||
19 | /* /sys/fs/<nilfs>/ */ | |
20 | static struct kset *nilfs_kset; | |
21 | ||
22 | #define NILFS_SHOW_TIME(time_t_val, buf) ({ \ | |
23 | struct tm res; \ | |
24 | int count = 0; \ | |
fb04b91b | 25 | time64_to_tm(time_t_val, 0, &res); \ |
aebe17f6 VD |
26 | res.tm_year += 1900; \ |
27 | res.tm_mon += 1; \ | |
28 | count = scnprintf(buf, PAGE_SIZE, \ | |
29 | "%ld-%.2d-%.2d %.2d:%.2d:%.2d\n", \ | |
30 | res.tm_year, res.tm_mon, res.tm_mday, \ | |
31 | res.tm_hour, res.tm_min, res.tm_sec);\ | |
32 | count; \ | |
33 | }) | |
34 | ||
caa05d49 VD |
35 | #define NILFS_DEV_INT_GROUP_OPS(name, parent_name) \ |
36 | static ssize_t nilfs_##name##_attr_show(struct kobject *kobj, \ | |
37 | struct attribute *attr, char *buf) \ | |
38 | { \ | |
39 | struct the_nilfs *nilfs = container_of(kobj->parent, \ | |
40 | struct the_nilfs, \ | |
41 | ns_##parent_name##_kobj); \ | |
42 | struct nilfs_##name##_attr *a = container_of(attr, \ | |
43 | struct nilfs_##name##_attr, \ | |
44 | attr); \ | |
45 | return a->show ? a->show(a, nilfs, buf) : 0; \ | |
46 | } \ | |
47 | static ssize_t nilfs_##name##_attr_store(struct kobject *kobj, \ | |
48 | struct attribute *attr, \ | |
49 | const char *buf, size_t len) \ | |
50 | { \ | |
51 | struct the_nilfs *nilfs = container_of(kobj->parent, \ | |
52 | struct the_nilfs, \ | |
53 | ns_##parent_name##_kobj); \ | |
54 | struct nilfs_##name##_attr *a = container_of(attr, \ | |
55 | struct nilfs_##name##_attr, \ | |
56 | attr); \ | |
57 | return a->store ? a->store(a, nilfs, buf, len) : 0; \ | |
58 | } \ | |
59 | static const struct sysfs_ops nilfs_##name##_attr_ops = { \ | |
60 | .show = nilfs_##name##_attr_show, \ | |
61 | .store = nilfs_##name##_attr_store, \ | |
facb9ec5 | 62 | } |
caa05d49 VD |
63 | |
64 | #define NILFS_DEV_INT_GROUP_TYPE(name, parent_name) \ | |
65 | static void nilfs_##name##_attr_release(struct kobject *kobj) \ | |
66 | { \ | |
67 | struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \ | |
68 | struct the_nilfs *nilfs = container_of(kobj->parent, \ | |
69 | struct the_nilfs, \ | |
70 | ns_##parent_name##_kobj); \ | |
71 | subgroups = nilfs->ns_##parent_name##_subgroups; \ | |
72 | complete(&subgroups->sg_##name##_kobj_unregister); \ | |
73 | } \ | |
74 | static struct kobj_type nilfs_##name##_ktype = { \ | |
75 | .default_attrs = nilfs_##name##_attrs, \ | |
76 | .sysfs_ops = &nilfs_##name##_attr_ops, \ | |
77 | .release = nilfs_##name##_attr_release, \ | |
facb9ec5 | 78 | } |
caa05d49 VD |
79 | |
80 | #define NILFS_DEV_INT_GROUP_FNS(name, parent_name) \ | |
dd70edbd | 81 | static int nilfs_sysfs_create_##name##_group(struct the_nilfs *nilfs) \ |
caa05d49 VD |
82 | { \ |
83 | struct kobject *parent; \ | |
84 | struct kobject *kobj; \ | |
85 | struct completion *kobj_unregister; \ | |
86 | struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \ | |
87 | int err; \ | |
88 | subgroups = nilfs->ns_##parent_name##_subgroups; \ | |
89 | kobj = &subgroups->sg_##name##_kobj; \ | |
90 | kobj_unregister = &subgroups->sg_##name##_kobj_unregister; \ | |
91 | parent = &nilfs->ns_##parent_name##_kobj; \ | |
92 | kobj->kset = nilfs_kset; \ | |
93 | init_completion(kobj_unregister); \ | |
94 | err = kobject_init_and_add(kobj, &nilfs_##name##_ktype, parent, \ | |
95 | #name); \ | |
96 | if (err) \ | |
97 | return err; \ | |
98 | return 0; \ | |
99 | } \ | |
dd70edbd | 100 | static void nilfs_sysfs_delete_##name##_group(struct the_nilfs *nilfs) \ |
caa05d49 VD |
101 | { \ |
102 | kobject_del(&nilfs->ns_##parent_name##_subgroups->sg_##name##_kobj); \ | |
103 | } | |
104 | ||
a5a7332a VD |
105 | /************************************************************************ |
106 | * NILFS snapshot attrs * | |
107 | ************************************************************************/ | |
108 | ||
109 | static ssize_t | |
110 | nilfs_snapshot_inodes_count_show(struct nilfs_snapshot_attr *attr, | |
111 | struct nilfs_root *root, char *buf) | |
112 | { | |
113 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
114 | (unsigned long long)atomic64_read(&root->inodes_count)); | |
115 | } | |
116 | ||
117 | static ssize_t | |
118 | nilfs_snapshot_blocks_count_show(struct nilfs_snapshot_attr *attr, | |
119 | struct nilfs_root *root, char *buf) | |
120 | { | |
121 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
122 | (unsigned long long)atomic64_read(&root->blocks_count)); | |
123 | } | |
124 | ||
125 | static const char snapshot_readme_str[] = | |
126 | "The group contains details about mounted snapshot.\n\n" | |
127 | "(1) inodes_count\n\tshow number of inodes for snapshot.\n\n" | |
128 | "(2) blocks_count\n\tshow number of blocks for snapshot.\n\n"; | |
129 | ||
130 | static ssize_t | |
131 | nilfs_snapshot_README_show(struct nilfs_snapshot_attr *attr, | |
132 | struct nilfs_root *root, char *buf) | |
133 | { | |
134 | return snprintf(buf, PAGE_SIZE, snapshot_readme_str); | |
135 | } | |
136 | ||
137 | NILFS_SNAPSHOT_RO_ATTR(inodes_count); | |
138 | NILFS_SNAPSHOT_RO_ATTR(blocks_count); | |
139 | NILFS_SNAPSHOT_RO_ATTR(README); | |
140 | ||
141 | static struct attribute *nilfs_snapshot_attrs[] = { | |
142 | NILFS_SNAPSHOT_ATTR_LIST(inodes_count), | |
143 | NILFS_SNAPSHOT_ATTR_LIST(blocks_count), | |
144 | NILFS_SNAPSHOT_ATTR_LIST(README), | |
145 | NULL, | |
146 | }; | |
147 | ||
148 | static ssize_t nilfs_snapshot_attr_show(struct kobject *kobj, | |
149 | struct attribute *attr, char *buf) | |
150 | { | |
151 | struct nilfs_root *root = | |
152 | container_of(kobj, struct nilfs_root, snapshot_kobj); | |
153 | struct nilfs_snapshot_attr *a = | |
154 | container_of(attr, struct nilfs_snapshot_attr, attr); | |
155 | ||
156 | return a->show ? a->show(a, root, buf) : 0; | |
157 | } | |
158 | ||
159 | static ssize_t nilfs_snapshot_attr_store(struct kobject *kobj, | |
160 | struct attribute *attr, | |
161 | const char *buf, size_t len) | |
162 | { | |
163 | struct nilfs_root *root = | |
164 | container_of(kobj, struct nilfs_root, snapshot_kobj); | |
165 | struct nilfs_snapshot_attr *a = | |
166 | container_of(attr, struct nilfs_snapshot_attr, attr); | |
167 | ||
168 | return a->store ? a->store(a, root, buf, len) : 0; | |
169 | } | |
170 | ||
171 | static void nilfs_snapshot_attr_release(struct kobject *kobj) | |
172 | { | |
173 | struct nilfs_root *root = container_of(kobj, struct nilfs_root, | |
174 | snapshot_kobj); | |
175 | complete(&root->snapshot_kobj_unregister); | |
176 | } | |
177 | ||
178 | static const struct sysfs_ops nilfs_snapshot_attr_ops = { | |
179 | .show = nilfs_snapshot_attr_show, | |
180 | .store = nilfs_snapshot_attr_store, | |
181 | }; | |
182 | ||
183 | static struct kobj_type nilfs_snapshot_ktype = { | |
184 | .default_attrs = nilfs_snapshot_attrs, | |
185 | .sysfs_ops = &nilfs_snapshot_attr_ops, | |
186 | .release = nilfs_snapshot_attr_release, | |
187 | }; | |
188 | ||
189 | int nilfs_sysfs_create_snapshot_group(struct nilfs_root *root) | |
190 | { | |
191 | struct the_nilfs *nilfs; | |
192 | struct kobject *parent; | |
193 | int err; | |
194 | ||
195 | nilfs = root->nilfs; | |
196 | parent = &nilfs->ns_dev_subgroups->sg_mounted_snapshots_kobj; | |
197 | root->snapshot_kobj.kset = nilfs_kset; | |
198 | init_completion(&root->snapshot_kobj_unregister); | |
199 | ||
200 | if (root->cno == NILFS_CPTREE_CURRENT_CNO) { | |
201 | err = kobject_init_and_add(&root->snapshot_kobj, | |
202 | &nilfs_snapshot_ktype, | |
203 | &nilfs->ns_dev_kobj, | |
204 | "current_checkpoint"); | |
205 | } else { | |
206 | err = kobject_init_and_add(&root->snapshot_kobj, | |
207 | &nilfs_snapshot_ktype, | |
208 | parent, | |
209 | "%llu", root->cno); | |
210 | } | |
211 | ||
212 | if (err) | |
213 | return err; | |
214 | ||
215 | return 0; | |
216 | } | |
217 | ||
218 | void nilfs_sysfs_delete_snapshot_group(struct nilfs_root *root) | |
219 | { | |
220 | kobject_del(&root->snapshot_kobj); | |
221 | } | |
222 | ||
a2ecb791 VD |
223 | /************************************************************************ |
224 | * NILFS mounted snapshots attrs * | |
225 | ************************************************************************/ | |
226 | ||
227 | static const char mounted_snapshots_readme_str[] = | |
228 | "The mounted_snapshots group contains group for\n" | |
229 | "every mounted snapshot.\n"; | |
230 | ||
231 | static ssize_t | |
232 | nilfs_mounted_snapshots_README_show(struct nilfs_mounted_snapshots_attr *attr, | |
233 | struct the_nilfs *nilfs, char *buf) | |
234 | { | |
235 | return snprintf(buf, PAGE_SIZE, mounted_snapshots_readme_str); | |
236 | } | |
237 | ||
238 | NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README); | |
239 | ||
240 | static struct attribute *nilfs_mounted_snapshots_attrs[] = { | |
241 | NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README), | |
242 | NULL, | |
243 | }; | |
244 | ||
245 | NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev); | |
246 | NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev); | |
247 | NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev); | |
248 | ||
02a0ba1c VD |
249 | /************************************************************************ |
250 | * NILFS checkpoints attrs * | |
251 | ************************************************************************/ | |
252 | ||
253 | static ssize_t | |
254 | nilfs_checkpoints_checkpoints_number_show(struct nilfs_checkpoints_attr *attr, | |
255 | struct the_nilfs *nilfs, | |
256 | char *buf) | |
257 | { | |
258 | __u64 ncheckpoints; | |
259 | struct nilfs_cpstat cpstat; | |
260 | int err; | |
261 | ||
262 | down_read(&nilfs->ns_segctor_sem); | |
263 | err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat); | |
264 | up_read(&nilfs->ns_segctor_sem); | |
265 | if (err < 0) { | |
feee880f RK |
266 | nilfs_msg(nilfs->ns_sb, KERN_ERR, |
267 | "unable to get checkpoint stat: err=%d", err); | |
02a0ba1c VD |
268 | return err; |
269 | } | |
270 | ||
271 | ncheckpoints = cpstat.cs_ncps; | |
272 | ||
273 | return snprintf(buf, PAGE_SIZE, "%llu\n", ncheckpoints); | |
274 | } | |
275 | ||
276 | static ssize_t | |
277 | nilfs_checkpoints_snapshots_number_show(struct nilfs_checkpoints_attr *attr, | |
278 | struct the_nilfs *nilfs, | |
279 | char *buf) | |
280 | { | |
281 | __u64 nsnapshots; | |
282 | struct nilfs_cpstat cpstat; | |
283 | int err; | |
284 | ||
285 | down_read(&nilfs->ns_segctor_sem); | |
286 | err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat); | |
287 | up_read(&nilfs->ns_segctor_sem); | |
288 | if (err < 0) { | |
feee880f RK |
289 | nilfs_msg(nilfs->ns_sb, KERN_ERR, |
290 | "unable to get checkpoint stat: err=%d", err); | |
02a0ba1c VD |
291 | return err; |
292 | } | |
293 | ||
294 | nsnapshots = cpstat.cs_nsss; | |
295 | ||
296 | return snprintf(buf, PAGE_SIZE, "%llu\n", nsnapshots); | |
297 | } | |
298 | ||
299 | static ssize_t | |
300 | nilfs_checkpoints_last_seg_checkpoint_show(struct nilfs_checkpoints_attr *attr, | |
301 | struct the_nilfs *nilfs, | |
302 | char *buf) | |
303 | { | |
304 | __u64 last_cno; | |
305 | ||
306 | spin_lock(&nilfs->ns_last_segment_lock); | |
307 | last_cno = nilfs->ns_last_cno; | |
308 | spin_unlock(&nilfs->ns_last_segment_lock); | |
309 | ||
310 | return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno); | |
311 | } | |
312 | ||
313 | static ssize_t | |
314 | nilfs_checkpoints_next_checkpoint_show(struct nilfs_checkpoints_attr *attr, | |
315 | struct the_nilfs *nilfs, | |
316 | char *buf) | |
317 | { | |
318 | __u64 cno; | |
319 | ||
ad980c9a | 320 | down_read(&nilfs->ns_segctor_sem); |
02a0ba1c | 321 | cno = nilfs->ns_cno; |
ad980c9a | 322 | up_read(&nilfs->ns_segctor_sem); |
02a0ba1c VD |
323 | |
324 | return snprintf(buf, PAGE_SIZE, "%llu\n", cno); | |
325 | } | |
326 | ||
327 | static const char checkpoints_readme_str[] = | |
328 | "The checkpoints group contains attributes that describe\n" | |
329 | "details about volume's checkpoints.\n\n" | |
330 | "(1) checkpoints_number\n\tshow number of checkpoints on volume.\n\n" | |
331 | "(2) snapshots_number\n\tshow number of snapshots on volume.\n\n" | |
332 | "(3) last_seg_checkpoint\n" | |
333 | "\tshow checkpoint number of the latest segment.\n\n" | |
334 | "(4) next_checkpoint\n\tshow next checkpoint number.\n\n"; | |
335 | ||
336 | static ssize_t | |
337 | nilfs_checkpoints_README_show(struct nilfs_checkpoints_attr *attr, | |
338 | struct the_nilfs *nilfs, char *buf) | |
339 | { | |
340 | return snprintf(buf, PAGE_SIZE, checkpoints_readme_str); | |
341 | } | |
342 | ||
343 | NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number); | |
344 | NILFS_CHECKPOINTS_RO_ATTR(snapshots_number); | |
345 | NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint); | |
346 | NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint); | |
347 | NILFS_CHECKPOINTS_RO_ATTR(README); | |
348 | ||
349 | static struct attribute *nilfs_checkpoints_attrs[] = { | |
350 | NILFS_CHECKPOINTS_ATTR_LIST(checkpoints_number), | |
351 | NILFS_CHECKPOINTS_ATTR_LIST(snapshots_number), | |
352 | NILFS_CHECKPOINTS_ATTR_LIST(last_seg_checkpoint), | |
353 | NILFS_CHECKPOINTS_ATTR_LIST(next_checkpoint), | |
354 | NILFS_CHECKPOINTS_ATTR_LIST(README), | |
355 | NULL, | |
356 | }; | |
357 | ||
358 | NILFS_DEV_INT_GROUP_OPS(checkpoints, dev); | |
359 | NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev); | |
360 | NILFS_DEV_INT_GROUP_FNS(checkpoints, dev); | |
361 | ||
ef43d5cd VD |
362 | /************************************************************************ |
363 | * NILFS segments attrs * | |
364 | ************************************************************************/ | |
365 | ||
366 | static ssize_t | |
367 | nilfs_segments_segments_number_show(struct nilfs_segments_attr *attr, | |
368 | struct the_nilfs *nilfs, | |
369 | char *buf) | |
370 | { | |
371 | return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_nsegments); | |
372 | } | |
373 | ||
374 | static ssize_t | |
375 | nilfs_segments_blocks_per_segment_show(struct nilfs_segments_attr *attr, | |
376 | struct the_nilfs *nilfs, | |
377 | char *buf) | |
378 | { | |
379 | return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_blocks_per_segment); | |
380 | } | |
381 | ||
382 | static ssize_t | |
383 | nilfs_segments_clean_segments_show(struct nilfs_segments_attr *attr, | |
384 | struct the_nilfs *nilfs, | |
385 | char *buf) | |
386 | { | |
387 | unsigned long ncleansegs; | |
388 | ||
389 | down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); | |
390 | ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); | |
391 | up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); | |
392 | ||
393 | return snprintf(buf, PAGE_SIZE, "%lu\n", ncleansegs); | |
394 | } | |
395 | ||
396 | static ssize_t | |
397 | nilfs_segments_dirty_segments_show(struct nilfs_segments_attr *attr, | |
398 | struct the_nilfs *nilfs, | |
399 | char *buf) | |
400 | { | |
401 | struct nilfs_sustat sustat; | |
402 | int err; | |
403 | ||
404 | down_read(&nilfs->ns_segctor_sem); | |
405 | err = nilfs_sufile_get_stat(nilfs->ns_sufile, &sustat); | |
406 | up_read(&nilfs->ns_segctor_sem); | |
407 | if (err < 0) { | |
feee880f RK |
408 | nilfs_msg(nilfs->ns_sb, KERN_ERR, |
409 | "unable to get segment stat: err=%d", err); | |
ef43d5cd VD |
410 | return err; |
411 | } | |
412 | ||
413 | return snprintf(buf, PAGE_SIZE, "%llu\n", sustat.ss_ndirtysegs); | |
414 | } | |
415 | ||
416 | static const char segments_readme_str[] = | |
417 | "The segments group contains attributes that describe\n" | |
418 | "details about volume's segments.\n\n" | |
419 | "(1) segments_number\n\tshow number of segments on volume.\n\n" | |
420 | "(2) blocks_per_segment\n\tshow number of blocks in segment.\n\n" | |
421 | "(3) clean_segments\n\tshow count of clean segments.\n\n" | |
422 | "(4) dirty_segments\n\tshow count of dirty segments.\n\n"; | |
423 | ||
424 | static ssize_t | |
425 | nilfs_segments_README_show(struct nilfs_segments_attr *attr, | |
426 | struct the_nilfs *nilfs, | |
427 | char *buf) | |
428 | { | |
429 | return snprintf(buf, PAGE_SIZE, segments_readme_str); | |
430 | } | |
431 | ||
432 | NILFS_SEGMENTS_RO_ATTR(segments_number); | |
433 | NILFS_SEGMENTS_RO_ATTR(blocks_per_segment); | |
434 | NILFS_SEGMENTS_RO_ATTR(clean_segments); | |
435 | NILFS_SEGMENTS_RO_ATTR(dirty_segments); | |
436 | NILFS_SEGMENTS_RO_ATTR(README); | |
437 | ||
438 | static struct attribute *nilfs_segments_attrs[] = { | |
439 | NILFS_SEGMENTS_ATTR_LIST(segments_number), | |
440 | NILFS_SEGMENTS_ATTR_LIST(blocks_per_segment), | |
441 | NILFS_SEGMENTS_ATTR_LIST(clean_segments), | |
442 | NILFS_SEGMENTS_ATTR_LIST(dirty_segments), | |
443 | NILFS_SEGMENTS_ATTR_LIST(README), | |
444 | NULL, | |
445 | }; | |
446 | ||
447 | NILFS_DEV_INT_GROUP_OPS(segments, dev); | |
448 | NILFS_DEV_INT_GROUP_TYPE(segments, dev); | |
449 | NILFS_DEV_INT_GROUP_FNS(segments, dev); | |
450 | ||
abc968db VD |
451 | /************************************************************************ |
452 | * NILFS segctor attrs * | |
453 | ************************************************************************/ | |
454 | ||
455 | static ssize_t | |
456 | nilfs_segctor_last_pseg_block_show(struct nilfs_segctor_attr *attr, | |
457 | struct the_nilfs *nilfs, | |
458 | char *buf) | |
459 | { | |
460 | sector_t last_pseg; | |
461 | ||
462 | spin_lock(&nilfs->ns_last_segment_lock); | |
463 | last_pseg = nilfs->ns_last_pseg; | |
464 | spin_unlock(&nilfs->ns_last_segment_lock); | |
465 | ||
466 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
467 | (unsigned long long)last_pseg); | |
468 | } | |
469 | ||
470 | static ssize_t | |
471 | nilfs_segctor_last_seg_sequence_show(struct nilfs_segctor_attr *attr, | |
472 | struct the_nilfs *nilfs, | |
473 | char *buf) | |
474 | { | |
475 | u64 last_seq; | |
476 | ||
477 | spin_lock(&nilfs->ns_last_segment_lock); | |
478 | last_seq = nilfs->ns_last_seq; | |
479 | spin_unlock(&nilfs->ns_last_segment_lock); | |
480 | ||
481 | return snprintf(buf, PAGE_SIZE, "%llu\n", last_seq); | |
482 | } | |
483 | ||
484 | static ssize_t | |
485 | nilfs_segctor_last_seg_checkpoint_show(struct nilfs_segctor_attr *attr, | |
486 | struct the_nilfs *nilfs, | |
487 | char *buf) | |
488 | { | |
489 | __u64 last_cno; | |
490 | ||
491 | spin_lock(&nilfs->ns_last_segment_lock); | |
492 | last_cno = nilfs->ns_last_cno; | |
493 | spin_unlock(&nilfs->ns_last_segment_lock); | |
494 | ||
495 | return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno); | |
496 | } | |
497 | ||
498 | static ssize_t | |
499 | nilfs_segctor_current_seg_sequence_show(struct nilfs_segctor_attr *attr, | |
500 | struct the_nilfs *nilfs, | |
501 | char *buf) | |
502 | { | |
503 | u64 seg_seq; | |
504 | ||
ad980c9a | 505 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 506 | seg_seq = nilfs->ns_seg_seq; |
ad980c9a | 507 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
508 | |
509 | return snprintf(buf, PAGE_SIZE, "%llu\n", seg_seq); | |
510 | } | |
511 | ||
512 | static ssize_t | |
513 | nilfs_segctor_current_last_full_seg_show(struct nilfs_segctor_attr *attr, | |
514 | struct the_nilfs *nilfs, | |
515 | char *buf) | |
516 | { | |
517 | __u64 segnum; | |
518 | ||
ad980c9a | 519 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 520 | segnum = nilfs->ns_segnum; |
ad980c9a | 521 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
522 | |
523 | return snprintf(buf, PAGE_SIZE, "%llu\n", segnum); | |
524 | } | |
525 | ||
526 | static ssize_t | |
527 | nilfs_segctor_next_full_seg_show(struct nilfs_segctor_attr *attr, | |
528 | struct the_nilfs *nilfs, | |
529 | char *buf) | |
530 | { | |
531 | __u64 nextnum; | |
532 | ||
ad980c9a | 533 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 534 | nextnum = nilfs->ns_nextnum; |
ad980c9a | 535 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
536 | |
537 | return snprintf(buf, PAGE_SIZE, "%llu\n", nextnum); | |
538 | } | |
539 | ||
540 | static ssize_t | |
541 | nilfs_segctor_next_pseg_offset_show(struct nilfs_segctor_attr *attr, | |
542 | struct the_nilfs *nilfs, | |
543 | char *buf) | |
544 | { | |
545 | unsigned long pseg_offset; | |
546 | ||
ad980c9a | 547 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 548 | pseg_offset = nilfs->ns_pseg_offset; |
ad980c9a | 549 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
550 | |
551 | return snprintf(buf, PAGE_SIZE, "%lu\n", pseg_offset); | |
552 | } | |
553 | ||
554 | static ssize_t | |
555 | nilfs_segctor_next_checkpoint_show(struct nilfs_segctor_attr *attr, | |
556 | struct the_nilfs *nilfs, | |
557 | char *buf) | |
558 | { | |
559 | __u64 cno; | |
560 | ||
ad980c9a | 561 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 562 | cno = nilfs->ns_cno; |
ad980c9a | 563 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
564 | |
565 | return snprintf(buf, PAGE_SIZE, "%llu\n", cno); | |
566 | } | |
567 | ||
568 | static ssize_t | |
569 | nilfs_segctor_last_seg_write_time_show(struct nilfs_segctor_attr *attr, | |
570 | struct the_nilfs *nilfs, | |
571 | char *buf) | |
572 | { | |
fb04b91b | 573 | time64_t ctime; |
abc968db | 574 | |
ad980c9a | 575 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 576 | ctime = nilfs->ns_ctime; |
ad980c9a | 577 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
578 | |
579 | return NILFS_SHOW_TIME(ctime, buf); | |
580 | } | |
581 | ||
582 | static ssize_t | |
583 | nilfs_segctor_last_seg_write_time_secs_show(struct nilfs_segctor_attr *attr, | |
584 | struct the_nilfs *nilfs, | |
585 | char *buf) | |
586 | { | |
fb04b91b | 587 | time64_t ctime; |
abc968db | 588 | |
ad980c9a | 589 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 590 | ctime = nilfs->ns_ctime; |
ad980c9a | 591 | up_read(&nilfs->ns_segctor_sem); |
abc968db | 592 | |
fb04b91b | 593 | return snprintf(buf, PAGE_SIZE, "%llu\n", ctime); |
abc968db VD |
594 | } |
595 | ||
596 | static ssize_t | |
597 | nilfs_segctor_last_nongc_write_time_show(struct nilfs_segctor_attr *attr, | |
598 | struct the_nilfs *nilfs, | |
599 | char *buf) | |
600 | { | |
fb04b91b | 601 | time64_t nongc_ctime; |
abc968db | 602 | |
ad980c9a | 603 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 604 | nongc_ctime = nilfs->ns_nongc_ctime; |
ad980c9a | 605 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
606 | |
607 | return NILFS_SHOW_TIME(nongc_ctime, buf); | |
608 | } | |
609 | ||
610 | static ssize_t | |
611 | nilfs_segctor_last_nongc_write_time_secs_show(struct nilfs_segctor_attr *attr, | |
612 | struct the_nilfs *nilfs, | |
613 | char *buf) | |
614 | { | |
fb04b91b | 615 | time64_t nongc_ctime; |
abc968db | 616 | |
ad980c9a | 617 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 618 | nongc_ctime = nilfs->ns_nongc_ctime; |
ad980c9a | 619 | up_read(&nilfs->ns_segctor_sem); |
abc968db | 620 | |
fb04b91b | 621 | return snprintf(buf, PAGE_SIZE, "%llu\n", nongc_ctime); |
abc968db VD |
622 | } |
623 | ||
624 | static ssize_t | |
625 | nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr, | |
626 | struct the_nilfs *nilfs, | |
627 | char *buf) | |
628 | { | |
629 | u32 ndirtyblks; | |
630 | ||
ad980c9a | 631 | down_read(&nilfs->ns_segctor_sem); |
abc968db | 632 | ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks); |
ad980c9a | 633 | up_read(&nilfs->ns_segctor_sem); |
abc968db VD |
634 | |
635 | return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks); | |
636 | } | |
637 | ||
638 | static const char segctor_readme_str[] = | |
639 | "The segctor group contains attributes that describe\n" | |
640 | "segctor thread activity details.\n\n" | |
641 | "(1) last_pseg_block\n" | |
642 | "\tshow start block number of the latest segment.\n\n" | |
643 | "(2) last_seg_sequence\n" | |
644 | "\tshow sequence value of the latest segment.\n\n" | |
645 | "(3) last_seg_checkpoint\n" | |
646 | "\tshow checkpoint number of the latest segment.\n\n" | |
647 | "(4) current_seg_sequence\n\tshow segment sequence counter.\n\n" | |
648 | "(5) current_last_full_seg\n" | |
649 | "\tshow index number of the latest full segment.\n\n" | |
650 | "(6) next_full_seg\n" | |
651 | "\tshow index number of the full segment index to be used next.\n\n" | |
652 | "(7) next_pseg_offset\n" | |
653 | "\tshow offset of next partial segment in the current full segment.\n\n" | |
654 | "(8) next_checkpoint\n\tshow next checkpoint number.\n\n" | |
655 | "(9) last_seg_write_time\n" | |
656 | "\tshow write time of the last segment in human-readable format.\n\n" | |
657 | "(10) last_seg_write_time_secs\n" | |
658 | "\tshow write time of the last segment in seconds.\n\n" | |
659 | "(11) last_nongc_write_time\n" | |
660 | "\tshow write time of the last segment not for cleaner operation " | |
661 | "in human-readable format.\n\n" | |
662 | "(12) last_nongc_write_time_secs\n" | |
663 | "\tshow write time of the last segment not for cleaner operation " | |
664 | "in seconds.\n\n" | |
665 | "(13) dirty_data_blocks_count\n" | |
666 | "\tshow number of dirty data blocks.\n\n"; | |
667 | ||
668 | static ssize_t | |
669 | nilfs_segctor_README_show(struct nilfs_segctor_attr *attr, | |
670 | struct the_nilfs *nilfs, char *buf) | |
671 | { | |
672 | return snprintf(buf, PAGE_SIZE, segctor_readme_str); | |
673 | } | |
674 | ||
675 | NILFS_SEGCTOR_RO_ATTR(last_pseg_block); | |
676 | NILFS_SEGCTOR_RO_ATTR(last_seg_sequence); | |
677 | NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint); | |
678 | NILFS_SEGCTOR_RO_ATTR(current_seg_sequence); | |
679 | NILFS_SEGCTOR_RO_ATTR(current_last_full_seg); | |
680 | NILFS_SEGCTOR_RO_ATTR(next_full_seg); | |
681 | NILFS_SEGCTOR_RO_ATTR(next_pseg_offset); | |
682 | NILFS_SEGCTOR_RO_ATTR(next_checkpoint); | |
683 | NILFS_SEGCTOR_RO_ATTR(last_seg_write_time); | |
684 | NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs); | |
685 | NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time); | |
686 | NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs); | |
687 | NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count); | |
688 | NILFS_SEGCTOR_RO_ATTR(README); | |
689 | ||
690 | static struct attribute *nilfs_segctor_attrs[] = { | |
691 | NILFS_SEGCTOR_ATTR_LIST(last_pseg_block), | |
692 | NILFS_SEGCTOR_ATTR_LIST(last_seg_sequence), | |
693 | NILFS_SEGCTOR_ATTR_LIST(last_seg_checkpoint), | |
694 | NILFS_SEGCTOR_ATTR_LIST(current_seg_sequence), | |
695 | NILFS_SEGCTOR_ATTR_LIST(current_last_full_seg), | |
696 | NILFS_SEGCTOR_ATTR_LIST(next_full_seg), | |
697 | NILFS_SEGCTOR_ATTR_LIST(next_pseg_offset), | |
698 | NILFS_SEGCTOR_ATTR_LIST(next_checkpoint), | |
699 | NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time), | |
700 | NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time_secs), | |
701 | NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time), | |
702 | NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time_secs), | |
703 | NILFS_SEGCTOR_ATTR_LIST(dirty_data_blocks_count), | |
704 | NILFS_SEGCTOR_ATTR_LIST(README), | |
705 | NULL, | |
706 | }; | |
707 | ||
708 | NILFS_DEV_INT_GROUP_OPS(segctor, dev); | |
709 | NILFS_DEV_INT_GROUP_TYPE(segctor, dev); | |
710 | NILFS_DEV_INT_GROUP_FNS(segctor, dev); | |
711 | ||
caa05d49 VD |
712 | /************************************************************************ |
713 | * NILFS superblock attrs * | |
714 | ************************************************************************/ | |
715 | ||
716 | static ssize_t | |
717 | nilfs_superblock_sb_write_time_show(struct nilfs_superblock_attr *attr, | |
718 | struct the_nilfs *nilfs, | |
719 | char *buf) | |
720 | { | |
fb04b91b | 721 | time64_t sbwtime; |
caa05d49 VD |
722 | |
723 | down_read(&nilfs->ns_sem); | |
724 | sbwtime = nilfs->ns_sbwtime; | |
725 | up_read(&nilfs->ns_sem); | |
726 | ||
727 | return NILFS_SHOW_TIME(sbwtime, buf); | |
728 | } | |
729 | ||
730 | static ssize_t | |
731 | nilfs_superblock_sb_write_time_secs_show(struct nilfs_superblock_attr *attr, | |
732 | struct the_nilfs *nilfs, | |
733 | char *buf) | |
734 | { | |
fb04b91b | 735 | time64_t sbwtime; |
caa05d49 VD |
736 | |
737 | down_read(&nilfs->ns_sem); | |
738 | sbwtime = nilfs->ns_sbwtime; | |
739 | up_read(&nilfs->ns_sem); | |
740 | ||
fb04b91b | 741 | return snprintf(buf, PAGE_SIZE, "%llu\n", sbwtime); |
caa05d49 VD |
742 | } |
743 | ||
744 | static ssize_t | |
745 | nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr, | |
746 | struct the_nilfs *nilfs, | |
747 | char *buf) | |
748 | { | |
0c6c44cb | 749 | unsigned int sbwcount; |
caa05d49 VD |
750 | |
751 | down_read(&nilfs->ns_sem); | |
752 | sbwcount = nilfs->ns_sbwcount; | |
753 | up_read(&nilfs->ns_sem); | |
754 | ||
755 | return snprintf(buf, PAGE_SIZE, "%u\n", sbwcount); | |
756 | } | |
757 | ||
758 | static ssize_t | |
759 | nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr, | |
760 | struct the_nilfs *nilfs, | |
761 | char *buf) | |
762 | { | |
0c6c44cb | 763 | unsigned int sb_update_freq; |
caa05d49 VD |
764 | |
765 | down_read(&nilfs->ns_sem); | |
766 | sb_update_freq = nilfs->ns_sb_update_freq; | |
767 | up_read(&nilfs->ns_sem); | |
768 | ||
769 | return snprintf(buf, PAGE_SIZE, "%u\n", sb_update_freq); | |
770 | } | |
771 | ||
772 | static ssize_t | |
773 | nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr, | |
774 | struct the_nilfs *nilfs, | |
775 | const char *buf, size_t count) | |
776 | { | |
0c6c44cb | 777 | unsigned int val; |
caa05d49 VD |
778 | int err; |
779 | ||
780 | err = kstrtouint(skip_spaces(buf), 0, &val); | |
781 | if (err) { | |
feee880f RK |
782 | nilfs_msg(nilfs->ns_sb, KERN_ERR, |
783 | "unable to convert string: err=%d", err); | |
caa05d49 VD |
784 | return err; |
785 | } | |
786 | ||
787 | if (val < NILFS_SB_FREQ) { | |
788 | val = NILFS_SB_FREQ; | |
feee880f RK |
789 | nilfs_msg(nilfs->ns_sb, KERN_WARNING, |
790 | "superblock update frequency cannot be lesser than 10 seconds"); | |
caa05d49 VD |
791 | } |
792 | ||
793 | down_write(&nilfs->ns_sem); | |
794 | nilfs->ns_sb_update_freq = val; | |
795 | up_write(&nilfs->ns_sem); | |
796 | ||
797 | return count; | |
798 | } | |
799 | ||
800 | static const char sb_readme_str[] = | |
801 | "The superblock group contains attributes that describe\n" | |
802 | "superblock's details.\n\n" | |
803 | "(1) sb_write_time\n\tshow previous write time of super block " | |
804 | "in human-readable format.\n\n" | |
805 | "(2) sb_write_time_secs\n\tshow previous write time of super block " | |
806 | "in seconds.\n\n" | |
807 | "(3) sb_write_count\n\tshow write count of super block.\n\n" | |
808 | "(4) sb_update_frequency\n" | |
809 | "\tshow/set interval of periodical update of superblock (in seconds).\n\n" | |
810 | "\tYou can set preferable frequency of superblock update by command:\n\n" | |
811 | "\t'echo <val> > /sys/fs/<nilfs>/<dev>/superblock/sb_update_frequency'\n"; | |
812 | ||
813 | static ssize_t | |
814 | nilfs_superblock_README_show(struct nilfs_superblock_attr *attr, | |
815 | struct the_nilfs *nilfs, char *buf) | |
816 | { | |
817 | return snprintf(buf, PAGE_SIZE, sb_readme_str); | |
818 | } | |
819 | ||
820 | NILFS_SUPERBLOCK_RO_ATTR(sb_write_time); | |
821 | NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs); | |
822 | NILFS_SUPERBLOCK_RO_ATTR(sb_write_count); | |
823 | NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency); | |
824 | NILFS_SUPERBLOCK_RO_ATTR(README); | |
825 | ||
826 | static struct attribute *nilfs_superblock_attrs[] = { | |
827 | NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time), | |
828 | NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time_secs), | |
829 | NILFS_SUPERBLOCK_ATTR_LIST(sb_write_count), | |
830 | NILFS_SUPERBLOCK_ATTR_LIST(sb_update_frequency), | |
831 | NILFS_SUPERBLOCK_ATTR_LIST(README), | |
832 | NULL, | |
833 | }; | |
834 | ||
835 | NILFS_DEV_INT_GROUP_OPS(superblock, dev); | |
836 | NILFS_DEV_INT_GROUP_TYPE(superblock, dev); | |
837 | NILFS_DEV_INT_GROUP_FNS(superblock, dev); | |
838 | ||
da7141fb VD |
839 | /************************************************************************ |
840 | * NILFS device attrs * | |
841 | ************************************************************************/ | |
842 | ||
843 | static | |
844 | ssize_t nilfs_dev_revision_show(struct nilfs_dev_attr *attr, | |
845 | struct the_nilfs *nilfs, | |
846 | char *buf) | |
847 | { | |
848 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
849 | u32 major = le32_to_cpu(sbp[0]->s_rev_level); | |
850 | u16 minor = le16_to_cpu(sbp[0]->s_minor_rev_level); | |
851 | ||
852 | return snprintf(buf, PAGE_SIZE, "%d.%d\n", major, minor); | |
853 | } | |
854 | ||
855 | static | |
856 | ssize_t nilfs_dev_blocksize_show(struct nilfs_dev_attr *attr, | |
857 | struct the_nilfs *nilfs, | |
858 | char *buf) | |
859 | { | |
860 | return snprintf(buf, PAGE_SIZE, "%u\n", nilfs->ns_blocksize); | |
861 | } | |
862 | ||
863 | static | |
864 | ssize_t nilfs_dev_device_size_show(struct nilfs_dev_attr *attr, | |
865 | struct the_nilfs *nilfs, | |
866 | char *buf) | |
867 | { | |
868 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
869 | u64 dev_size = le64_to_cpu(sbp[0]->s_dev_size); | |
870 | ||
871 | return snprintf(buf, PAGE_SIZE, "%llu\n", dev_size); | |
872 | } | |
873 | ||
874 | static | |
875 | ssize_t nilfs_dev_free_blocks_show(struct nilfs_dev_attr *attr, | |
876 | struct the_nilfs *nilfs, | |
877 | char *buf) | |
878 | { | |
879 | sector_t free_blocks = 0; | |
880 | ||
881 | nilfs_count_free_blocks(nilfs, &free_blocks); | |
882 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
883 | (unsigned long long)free_blocks); | |
884 | } | |
885 | ||
886 | static | |
887 | ssize_t nilfs_dev_uuid_show(struct nilfs_dev_attr *attr, | |
888 | struct the_nilfs *nilfs, | |
889 | char *buf) | |
890 | { | |
891 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
892 | ||
893 | return snprintf(buf, PAGE_SIZE, "%pUb\n", sbp[0]->s_uuid); | |
894 | } | |
895 | ||
896 | static | |
897 | ssize_t nilfs_dev_volume_name_show(struct nilfs_dev_attr *attr, | |
898 | struct the_nilfs *nilfs, | |
899 | char *buf) | |
900 | { | |
901 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
902 | ||
903 | return scnprintf(buf, sizeof(sbp[0]->s_volume_name), "%s\n", | |
904 | sbp[0]->s_volume_name); | |
905 | } | |
906 | ||
907 | static const char dev_readme_str[] = | |
908 | "The <device> group contains attributes that describe file system\n" | |
909 | "partition's details.\n\n" | |
910 | "(1) revision\n\tshow NILFS file system revision.\n\n" | |
911 | "(2) blocksize\n\tshow volume block size in bytes.\n\n" | |
912 | "(3) device_size\n\tshow volume size in bytes.\n\n" | |
913 | "(4) free_blocks\n\tshow count of free blocks on volume.\n\n" | |
914 | "(5) uuid\n\tshow volume's UUID.\n\n" | |
915 | "(6) volume_name\n\tshow volume's name.\n\n"; | |
916 | ||
917 | static ssize_t nilfs_dev_README_show(struct nilfs_dev_attr *attr, | |
918 | struct the_nilfs *nilfs, | |
919 | char *buf) | |
920 | { | |
921 | return snprintf(buf, PAGE_SIZE, dev_readme_str); | |
922 | } | |
923 | ||
924 | NILFS_DEV_RO_ATTR(revision); | |
925 | NILFS_DEV_RO_ATTR(blocksize); | |
926 | NILFS_DEV_RO_ATTR(device_size); | |
927 | NILFS_DEV_RO_ATTR(free_blocks); | |
928 | NILFS_DEV_RO_ATTR(uuid); | |
929 | NILFS_DEV_RO_ATTR(volume_name); | |
930 | NILFS_DEV_RO_ATTR(README); | |
931 | ||
932 | static struct attribute *nilfs_dev_attrs[] = { | |
933 | NILFS_DEV_ATTR_LIST(revision), | |
934 | NILFS_DEV_ATTR_LIST(blocksize), | |
935 | NILFS_DEV_ATTR_LIST(device_size), | |
936 | NILFS_DEV_ATTR_LIST(free_blocks), | |
937 | NILFS_DEV_ATTR_LIST(uuid), | |
938 | NILFS_DEV_ATTR_LIST(volume_name), | |
939 | NILFS_DEV_ATTR_LIST(README), | |
940 | NULL, | |
941 | }; | |
942 | ||
943 | static ssize_t nilfs_dev_attr_show(struct kobject *kobj, | |
944 | struct attribute *attr, char *buf) | |
945 | { | |
946 | struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, | |
947 | ns_dev_kobj); | |
948 | struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, | |
949 | attr); | |
950 | ||
951 | return a->show ? a->show(a, nilfs, buf) : 0; | |
952 | } | |
953 | ||
954 | static ssize_t nilfs_dev_attr_store(struct kobject *kobj, | |
955 | struct attribute *attr, | |
956 | const char *buf, size_t len) | |
957 | { | |
958 | struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, | |
959 | ns_dev_kobj); | |
960 | struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, | |
961 | attr); | |
962 | ||
963 | return a->store ? a->store(a, nilfs, buf, len) : 0; | |
964 | } | |
965 | ||
966 | static void nilfs_dev_attr_release(struct kobject *kobj) | |
967 | { | |
968 | struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, | |
969 | ns_dev_kobj); | |
970 | complete(&nilfs->ns_dev_kobj_unregister); | |
971 | } | |
972 | ||
973 | static const struct sysfs_ops nilfs_dev_attr_ops = { | |
974 | .show = nilfs_dev_attr_show, | |
975 | .store = nilfs_dev_attr_store, | |
976 | }; | |
977 | ||
978 | static struct kobj_type nilfs_dev_ktype = { | |
979 | .default_attrs = nilfs_dev_attrs, | |
980 | .sysfs_ops = &nilfs_dev_attr_ops, | |
981 | .release = nilfs_dev_attr_release, | |
982 | }; | |
983 | ||
984 | int nilfs_sysfs_create_device_group(struct super_block *sb) | |
985 | { | |
986 | struct the_nilfs *nilfs = sb->s_fs_info; | |
caa05d49 | 987 | size_t devgrp_size = sizeof(struct nilfs_sysfs_dev_subgroups); |
da7141fb VD |
988 | int err; |
989 | ||
caa05d49 VD |
990 | nilfs->ns_dev_subgroups = kzalloc(devgrp_size, GFP_KERNEL); |
991 | if (unlikely(!nilfs->ns_dev_subgroups)) { | |
992 | err = -ENOMEM; | |
feee880f RK |
993 | nilfs_msg(sb, KERN_ERR, |
994 | "unable to allocate memory for device group"); | |
caa05d49 VD |
995 | goto failed_create_device_group; |
996 | } | |
997 | ||
da7141fb VD |
998 | nilfs->ns_dev_kobj.kset = nilfs_kset; |
999 | init_completion(&nilfs->ns_dev_kobj_unregister); | |
1000 | err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL, | |
1001 | "%s", sb->s_id); | |
1002 | if (err) | |
caa05d49 VD |
1003 | goto free_dev_subgroups; |
1004 | ||
a2ecb791 | 1005 | err = nilfs_sysfs_create_mounted_snapshots_group(nilfs); |
caa05d49 VD |
1006 | if (err) |
1007 | goto cleanup_dev_kobject; | |
da7141fb | 1008 | |
a2ecb791 VD |
1009 | err = nilfs_sysfs_create_checkpoints_group(nilfs); |
1010 | if (err) | |
1011 | goto delete_mounted_snapshots_group; | |
1012 | ||
02a0ba1c VD |
1013 | err = nilfs_sysfs_create_segments_group(nilfs); |
1014 | if (err) | |
1015 | goto delete_checkpoints_group; | |
1016 | ||
ef43d5cd VD |
1017 | err = nilfs_sysfs_create_superblock_group(nilfs); |
1018 | if (err) | |
1019 | goto delete_segments_group; | |
1020 | ||
abc968db VD |
1021 | err = nilfs_sysfs_create_segctor_group(nilfs); |
1022 | if (err) | |
1023 | goto delete_superblock_group; | |
1024 | ||
da7141fb VD |
1025 | return 0; |
1026 | ||
abc968db VD |
1027 | delete_superblock_group: |
1028 | nilfs_sysfs_delete_superblock_group(nilfs); | |
1029 | ||
ef43d5cd VD |
1030 | delete_segments_group: |
1031 | nilfs_sysfs_delete_segments_group(nilfs); | |
1032 | ||
02a0ba1c VD |
1033 | delete_checkpoints_group: |
1034 | nilfs_sysfs_delete_checkpoints_group(nilfs); | |
1035 | ||
a2ecb791 VD |
1036 | delete_mounted_snapshots_group: |
1037 | nilfs_sysfs_delete_mounted_snapshots_group(nilfs); | |
1038 | ||
caa05d49 VD |
1039 | cleanup_dev_kobject: |
1040 | kobject_del(&nilfs->ns_dev_kobj); | |
1041 | ||
1042 | free_dev_subgroups: | |
1043 | kfree(nilfs->ns_dev_subgroups); | |
1044 | ||
da7141fb VD |
1045 | failed_create_device_group: |
1046 | return err; | |
1047 | } | |
1048 | ||
1049 | void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs) | |
1050 | { | |
a2ecb791 | 1051 | nilfs_sysfs_delete_mounted_snapshots_group(nilfs); |
02a0ba1c | 1052 | nilfs_sysfs_delete_checkpoints_group(nilfs); |
ef43d5cd | 1053 | nilfs_sysfs_delete_segments_group(nilfs); |
caa05d49 | 1054 | nilfs_sysfs_delete_superblock_group(nilfs); |
abc968db | 1055 | nilfs_sysfs_delete_segctor_group(nilfs); |
da7141fb | 1056 | kobject_del(&nilfs->ns_dev_kobj); |
caa05d49 | 1057 | kfree(nilfs->ns_dev_subgroups); |
da7141fb VD |
1058 | } |
1059 | ||
aebe17f6 VD |
1060 | /************************************************************************ |
1061 | * NILFS feature attrs * | |
1062 | ************************************************************************/ | |
1063 | ||
1064 | static ssize_t nilfs_feature_revision_show(struct kobject *kobj, | |
1065 | struct attribute *attr, char *buf) | |
1066 | { | |
1067 | return snprintf(buf, PAGE_SIZE, "%d.%d\n", | |
1068 | NILFS_CURRENT_REV, NILFS_MINOR_REV); | |
1069 | } | |
1070 | ||
1071 | static const char features_readme_str[] = | |
1072 | "The features group contains attributes that describe NILFS file\n" | |
1073 | "system driver features.\n\n" | |
1074 | "(1) revision\n\tshow current revision of NILFS file system driver.\n"; | |
1075 | ||
1076 | static ssize_t nilfs_feature_README_show(struct kobject *kobj, | |
1077 | struct attribute *attr, | |
1078 | char *buf) | |
1079 | { | |
1080 | return snprintf(buf, PAGE_SIZE, features_readme_str); | |
1081 | } | |
1082 | ||
1083 | NILFS_FEATURE_RO_ATTR(revision); | |
1084 | NILFS_FEATURE_RO_ATTR(README); | |
1085 | ||
1086 | static struct attribute *nilfs_feature_attrs[] = { | |
1087 | NILFS_FEATURE_ATTR_LIST(revision), | |
1088 | NILFS_FEATURE_ATTR_LIST(README), | |
1089 | NULL, | |
1090 | }; | |
1091 | ||
1092 | static const struct attribute_group nilfs_feature_attr_group = { | |
1093 | .name = "features", | |
1094 | .attrs = nilfs_feature_attrs, | |
1095 | }; | |
1096 | ||
1097 | int __init nilfs_sysfs_init(void) | |
1098 | { | |
1099 | int err; | |
1100 | ||
1101 | nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj); | |
1102 | if (!nilfs_kset) { | |
1103 | err = -ENOMEM; | |
feee880f RK |
1104 | nilfs_msg(NULL, KERN_ERR, |
1105 | "unable to create sysfs entry: err=%d", err); | |
aebe17f6 VD |
1106 | goto failed_sysfs_init; |
1107 | } | |
1108 | ||
1109 | err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); | |
1110 | if (unlikely(err)) { | |
feee880f RK |
1111 | nilfs_msg(NULL, KERN_ERR, |
1112 | "unable to create feature group: err=%d", err); | |
aebe17f6 VD |
1113 | goto cleanup_sysfs_init; |
1114 | } | |
1115 | ||
1116 | return 0; | |
1117 | ||
1118 | cleanup_sysfs_init: | |
1119 | kset_unregister(nilfs_kset); | |
1120 | ||
1121 | failed_sysfs_init: | |
1122 | return err; | |
1123 | } | |
1124 | ||
1125 | void nilfs_sysfs_exit(void) | |
1126 | { | |
1127 | sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); | |
1128 | kset_unregister(nilfs_kset); | |
1129 | } |