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