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