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