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