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