xref: /openbmc/linux/fs/nilfs2/sysfs.c (revision 0edbfea5)
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>/ */
29 static struct kset *nilfs_kset;
30 
31 #define NILFS_SHOW_TIME(time_t_val, buf) ({ \
32 		struct tm res; \
33 		int count = 0; \
34 		time_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) \
45 static 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 } \
56 static 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 } \
68 static 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) \
74 static 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 } \
83 static 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) \
90 static 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 } \
109 static 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 
118 static ssize_t
119 nilfs_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 
126 static ssize_t
127 nilfs_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 
134 static 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 
139 static ssize_t
140 nilfs_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 
146 NILFS_SNAPSHOT_RO_ATTR(inodes_count);
147 NILFS_SNAPSHOT_RO_ATTR(blocks_count);
148 NILFS_SNAPSHOT_RO_ATTR(README);
149 
150 static 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 
157 static 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 
168 static 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 
180 static 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 
187 static const struct sysfs_ops nilfs_snapshot_attr_ops = {
188 	.show	= nilfs_snapshot_attr_show,
189 	.store	= nilfs_snapshot_attr_store,
190 };
191 
192 static 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 
198 int 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 
227 void 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 
236 static const char mounted_snapshots_readme_str[] =
237 	"The mounted_snapshots group contains group for\n"
238 	"every mounted snapshot.\n";
239 
240 static ssize_t
241 nilfs_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 
247 NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README);
248 
249 static struct attribute *nilfs_mounted_snapshots_attrs[] = {
250 	NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README),
251 	NULL,
252 };
253 
254 NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev);
255 NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev);
256 NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev);
257 
258 /************************************************************************
259  *                      NILFS checkpoints attrs                         *
260  ************************************************************************/
261 
262 static ssize_t
263 nilfs_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 		printk(KERN_ERR "NILFS: unable to get checkpoint stat: err=%d\n",
276 			err);
277 		return err;
278 	}
279 
280 	ncheckpoints = cpstat.cs_ncps;
281 
282 	return snprintf(buf, PAGE_SIZE, "%llu\n", ncheckpoints);
283 }
284 
285 static ssize_t
286 nilfs_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 		printk(KERN_ERR "NILFS: unable to get checkpoint stat: err=%d\n",
299 			err);
300 		return err;
301 	}
302 
303 	nsnapshots = cpstat.cs_nsss;
304 
305 	return snprintf(buf, PAGE_SIZE, "%llu\n", nsnapshots);
306 }
307 
308 static ssize_t
309 nilfs_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 
322 static ssize_t
323 nilfs_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_sem);
330 	cno = nilfs->ns_cno;
331 	up_read(&nilfs->ns_sem);
332 
333 	return snprintf(buf, PAGE_SIZE, "%llu\n", cno);
334 }
335 
336 static 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 
345 static ssize_t
346 nilfs_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 
352 NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number);
353 NILFS_CHECKPOINTS_RO_ATTR(snapshots_number);
354 NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint);
355 NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint);
356 NILFS_CHECKPOINTS_RO_ATTR(README);
357 
358 static 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 
367 NILFS_DEV_INT_GROUP_OPS(checkpoints, dev);
368 NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev);
369 NILFS_DEV_INT_GROUP_FNS(checkpoints, dev);
370 
371 /************************************************************************
372  *                        NILFS segments attrs                          *
373  ************************************************************************/
374 
375 static ssize_t
376 nilfs_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 
383 static ssize_t
384 nilfs_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 
391 static ssize_t
392 nilfs_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 
405 static ssize_t
406 nilfs_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 		printk(KERN_ERR "NILFS: unable to get segment stat: err=%d\n",
418 			err);
419 		return err;
420 	}
421 
422 	return snprintf(buf, PAGE_SIZE, "%llu\n", sustat.ss_ndirtysegs);
423 }
424 
425 static 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 
433 static ssize_t
434 nilfs_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 
441 NILFS_SEGMENTS_RO_ATTR(segments_number);
442 NILFS_SEGMENTS_RO_ATTR(blocks_per_segment);
443 NILFS_SEGMENTS_RO_ATTR(clean_segments);
444 NILFS_SEGMENTS_RO_ATTR(dirty_segments);
445 NILFS_SEGMENTS_RO_ATTR(README);
446 
447 static 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 
456 NILFS_DEV_INT_GROUP_OPS(segments, dev);
457 NILFS_DEV_INT_GROUP_TYPE(segments, dev);
458 NILFS_DEV_INT_GROUP_FNS(segments, dev);
459 
460 /************************************************************************
461  *                        NILFS segctor attrs                           *
462  ************************************************************************/
463 
464 static ssize_t
465 nilfs_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 
479 static ssize_t
480 nilfs_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 
493 static ssize_t
494 nilfs_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 
507 static ssize_t
508 nilfs_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_sem);
515 	seg_seq = nilfs->ns_seg_seq;
516 	up_read(&nilfs->ns_sem);
517 
518 	return snprintf(buf, PAGE_SIZE, "%llu\n", seg_seq);
519 }
520 
521 static ssize_t
522 nilfs_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_sem);
529 	segnum = nilfs->ns_segnum;
530 	up_read(&nilfs->ns_sem);
531 
532 	return snprintf(buf, PAGE_SIZE, "%llu\n", segnum);
533 }
534 
535 static ssize_t
536 nilfs_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_sem);
543 	nextnum = nilfs->ns_nextnum;
544 	up_read(&nilfs->ns_sem);
545 
546 	return snprintf(buf, PAGE_SIZE, "%llu\n", nextnum);
547 }
548 
549 static ssize_t
550 nilfs_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_sem);
557 	pseg_offset = nilfs->ns_pseg_offset;
558 	up_read(&nilfs->ns_sem);
559 
560 	return snprintf(buf, PAGE_SIZE, "%lu\n", pseg_offset);
561 }
562 
563 static ssize_t
564 nilfs_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_sem);
571 	cno = nilfs->ns_cno;
572 	up_read(&nilfs->ns_sem);
573 
574 	return snprintf(buf, PAGE_SIZE, "%llu\n", cno);
575 }
576 
577 static ssize_t
578 nilfs_segctor_last_seg_write_time_show(struct nilfs_segctor_attr *attr,
579 					struct the_nilfs *nilfs,
580 					char *buf)
581 {
582 	time_t ctime;
583 
584 	down_read(&nilfs->ns_sem);
585 	ctime = nilfs->ns_ctime;
586 	up_read(&nilfs->ns_sem);
587 
588 	return NILFS_SHOW_TIME(ctime, buf);
589 }
590 
591 static ssize_t
592 nilfs_segctor_last_seg_write_time_secs_show(struct nilfs_segctor_attr *attr,
593 					    struct the_nilfs *nilfs,
594 					    char *buf)
595 {
596 	time_t ctime;
597 
598 	down_read(&nilfs->ns_sem);
599 	ctime = nilfs->ns_ctime;
600 	up_read(&nilfs->ns_sem);
601 
602 	return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)ctime);
603 }
604 
605 static ssize_t
606 nilfs_segctor_last_nongc_write_time_show(struct nilfs_segctor_attr *attr,
607 					 struct the_nilfs *nilfs,
608 					 char *buf)
609 {
610 	time_t nongc_ctime;
611 
612 	down_read(&nilfs->ns_sem);
613 	nongc_ctime = nilfs->ns_nongc_ctime;
614 	up_read(&nilfs->ns_sem);
615 
616 	return NILFS_SHOW_TIME(nongc_ctime, buf);
617 }
618 
619 static ssize_t
620 nilfs_segctor_last_nongc_write_time_secs_show(struct nilfs_segctor_attr *attr,
621 						struct the_nilfs *nilfs,
622 						char *buf)
623 {
624 	time_t nongc_ctime;
625 
626 	down_read(&nilfs->ns_sem);
627 	nongc_ctime = nilfs->ns_nongc_ctime;
628 	up_read(&nilfs->ns_sem);
629 
630 	return snprintf(buf, PAGE_SIZE, "%llu\n",
631 			(unsigned long long)nongc_ctime);
632 }
633 
634 static ssize_t
635 nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr,
636 					    struct the_nilfs *nilfs,
637 					    char *buf)
638 {
639 	u32 ndirtyblks;
640 
641 	down_read(&nilfs->ns_sem);
642 	ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks);
643 	up_read(&nilfs->ns_sem);
644 
645 	return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks);
646 }
647 
648 static const char segctor_readme_str[] =
649 	"The segctor group contains attributes that describe\n"
650 	"segctor thread activity details.\n\n"
651 	"(1) last_pseg_block\n"
652 	"\tshow start block number of the latest segment.\n\n"
653 	"(2) last_seg_sequence\n"
654 	"\tshow sequence value of the latest segment.\n\n"
655 	"(3) last_seg_checkpoint\n"
656 	"\tshow checkpoint number of the latest segment.\n\n"
657 	"(4) current_seg_sequence\n\tshow segment sequence counter.\n\n"
658 	"(5) current_last_full_seg\n"
659 	"\tshow index number of the latest full segment.\n\n"
660 	"(6) next_full_seg\n"
661 	"\tshow index number of the full segment index to be used next.\n\n"
662 	"(7) next_pseg_offset\n"
663 	"\tshow offset of next partial segment in the current full segment.\n\n"
664 	"(8) next_checkpoint\n\tshow next checkpoint number.\n\n"
665 	"(9) last_seg_write_time\n"
666 	"\tshow write time of the last segment in human-readable format.\n\n"
667 	"(10) last_seg_write_time_secs\n"
668 	"\tshow write time of the last segment in seconds.\n\n"
669 	"(11) last_nongc_write_time\n"
670 	"\tshow write time of the last segment not for cleaner operation "
671 	"in human-readable format.\n\n"
672 	"(12) last_nongc_write_time_secs\n"
673 	"\tshow write time of the last segment not for cleaner operation "
674 	"in seconds.\n\n"
675 	"(13) dirty_data_blocks_count\n"
676 	"\tshow number of dirty data blocks.\n\n";
677 
678 static ssize_t
679 nilfs_segctor_README_show(struct nilfs_segctor_attr *attr,
680 			  struct the_nilfs *nilfs, char *buf)
681 {
682 	return snprintf(buf, PAGE_SIZE, segctor_readme_str);
683 }
684 
685 NILFS_SEGCTOR_RO_ATTR(last_pseg_block);
686 NILFS_SEGCTOR_RO_ATTR(last_seg_sequence);
687 NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint);
688 NILFS_SEGCTOR_RO_ATTR(current_seg_sequence);
689 NILFS_SEGCTOR_RO_ATTR(current_last_full_seg);
690 NILFS_SEGCTOR_RO_ATTR(next_full_seg);
691 NILFS_SEGCTOR_RO_ATTR(next_pseg_offset);
692 NILFS_SEGCTOR_RO_ATTR(next_checkpoint);
693 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time);
694 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs);
695 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time);
696 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs);
697 NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count);
698 NILFS_SEGCTOR_RO_ATTR(README);
699 
700 static struct attribute *nilfs_segctor_attrs[] = {
701 	NILFS_SEGCTOR_ATTR_LIST(last_pseg_block),
702 	NILFS_SEGCTOR_ATTR_LIST(last_seg_sequence),
703 	NILFS_SEGCTOR_ATTR_LIST(last_seg_checkpoint),
704 	NILFS_SEGCTOR_ATTR_LIST(current_seg_sequence),
705 	NILFS_SEGCTOR_ATTR_LIST(current_last_full_seg),
706 	NILFS_SEGCTOR_ATTR_LIST(next_full_seg),
707 	NILFS_SEGCTOR_ATTR_LIST(next_pseg_offset),
708 	NILFS_SEGCTOR_ATTR_LIST(next_checkpoint),
709 	NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time),
710 	NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time_secs),
711 	NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time),
712 	NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time_secs),
713 	NILFS_SEGCTOR_ATTR_LIST(dirty_data_blocks_count),
714 	NILFS_SEGCTOR_ATTR_LIST(README),
715 	NULL,
716 };
717 
718 NILFS_DEV_INT_GROUP_OPS(segctor, dev);
719 NILFS_DEV_INT_GROUP_TYPE(segctor, dev);
720 NILFS_DEV_INT_GROUP_FNS(segctor, dev);
721 
722 /************************************************************************
723  *                        NILFS superblock attrs                        *
724  ************************************************************************/
725 
726 static ssize_t
727 nilfs_superblock_sb_write_time_show(struct nilfs_superblock_attr *attr,
728 				     struct the_nilfs *nilfs,
729 				     char *buf)
730 {
731 	time_t sbwtime;
732 
733 	down_read(&nilfs->ns_sem);
734 	sbwtime = nilfs->ns_sbwtime;
735 	up_read(&nilfs->ns_sem);
736 
737 	return NILFS_SHOW_TIME(sbwtime, buf);
738 }
739 
740 static ssize_t
741 nilfs_superblock_sb_write_time_secs_show(struct nilfs_superblock_attr *attr,
742 					 struct the_nilfs *nilfs,
743 					 char *buf)
744 {
745 	time_t sbwtime;
746 
747 	down_read(&nilfs->ns_sem);
748 	sbwtime = nilfs->ns_sbwtime;
749 	up_read(&nilfs->ns_sem);
750 
751 	return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)sbwtime);
752 }
753 
754 static ssize_t
755 nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr,
756 				      struct the_nilfs *nilfs,
757 				      char *buf)
758 {
759 	unsigned int sbwcount;
760 
761 	down_read(&nilfs->ns_sem);
762 	sbwcount = nilfs->ns_sbwcount;
763 	up_read(&nilfs->ns_sem);
764 
765 	return snprintf(buf, PAGE_SIZE, "%u\n", sbwcount);
766 }
767 
768 static ssize_t
769 nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr,
770 					    struct the_nilfs *nilfs,
771 					    char *buf)
772 {
773 	unsigned int sb_update_freq;
774 
775 	down_read(&nilfs->ns_sem);
776 	sb_update_freq = nilfs->ns_sb_update_freq;
777 	up_read(&nilfs->ns_sem);
778 
779 	return snprintf(buf, PAGE_SIZE, "%u\n", sb_update_freq);
780 }
781 
782 static ssize_t
783 nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr,
784 					    struct the_nilfs *nilfs,
785 					    const char *buf, size_t count)
786 {
787 	unsigned int val;
788 	int err;
789 
790 	err = kstrtouint(skip_spaces(buf), 0, &val);
791 	if (err) {
792 		printk(KERN_ERR "NILFS: unable to convert string: err=%d\n",
793 			err);
794 		return err;
795 	}
796 
797 	if (val < NILFS_SB_FREQ) {
798 		val = NILFS_SB_FREQ;
799 		printk(KERN_WARNING "NILFS: superblock update frequency cannot be lesser than 10 seconds\n");
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 
809 static 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 
822 static ssize_t
823 nilfs_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 
829 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time);
830 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs);
831 NILFS_SUPERBLOCK_RO_ATTR(sb_write_count);
832 NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency);
833 NILFS_SUPERBLOCK_RO_ATTR(README);
834 
835 static 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 
844 NILFS_DEV_INT_GROUP_OPS(superblock, dev);
845 NILFS_DEV_INT_GROUP_TYPE(superblock, dev);
846 NILFS_DEV_INT_GROUP_FNS(superblock, dev);
847 
848 /************************************************************************
849  *                        NILFS device attrs                            *
850  ************************************************************************/
851 
852 static
853 ssize_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 
864 static
865 ssize_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 
872 static
873 ssize_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 
883 static
884 ssize_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 
895 static
896 ssize_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 
905 static
906 ssize_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 
916 static 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 
926 static 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 
933 NILFS_DEV_RO_ATTR(revision);
934 NILFS_DEV_RO_ATTR(blocksize);
935 NILFS_DEV_RO_ATTR(device_size);
936 NILFS_DEV_RO_ATTR(free_blocks);
937 NILFS_DEV_RO_ATTR(uuid);
938 NILFS_DEV_RO_ATTR(volume_name);
939 NILFS_DEV_RO_ATTR(README);
940 
941 static 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 
952 static 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 
963 static 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 
975 static 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 
982 static const struct sysfs_ops nilfs_dev_attr_ops = {
983 	.show	= nilfs_dev_attr_show,
984 	.store	= nilfs_dev_attr_store,
985 };
986 
987 static 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 
993 int 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 		printk(KERN_ERR "NILFS: unable to allocate memory for device group\n");
1003 		goto failed_create_device_group;
1004 	}
1005 
1006 	nilfs->ns_dev_kobj.kset = nilfs_kset;
1007 	init_completion(&nilfs->ns_dev_kobj_unregister);
1008 	err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL,
1009 				    "%s", sb->s_id);
1010 	if (err)
1011 		goto free_dev_subgroups;
1012 
1013 	err = nilfs_sysfs_create_mounted_snapshots_group(nilfs);
1014 	if (err)
1015 		goto cleanup_dev_kobject;
1016 
1017 	err = nilfs_sysfs_create_checkpoints_group(nilfs);
1018 	if (err)
1019 		goto delete_mounted_snapshots_group;
1020 
1021 	err = nilfs_sysfs_create_segments_group(nilfs);
1022 	if (err)
1023 		goto delete_checkpoints_group;
1024 
1025 	err = nilfs_sysfs_create_superblock_group(nilfs);
1026 	if (err)
1027 		goto delete_segments_group;
1028 
1029 	err = nilfs_sysfs_create_segctor_group(nilfs);
1030 	if (err)
1031 		goto delete_superblock_group;
1032 
1033 	return 0;
1034 
1035 delete_superblock_group:
1036 	nilfs_sysfs_delete_superblock_group(nilfs);
1037 
1038 delete_segments_group:
1039 	nilfs_sysfs_delete_segments_group(nilfs);
1040 
1041 delete_checkpoints_group:
1042 	nilfs_sysfs_delete_checkpoints_group(nilfs);
1043 
1044 delete_mounted_snapshots_group:
1045 	nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1046 
1047 cleanup_dev_kobject:
1048 	kobject_del(&nilfs->ns_dev_kobj);
1049 
1050 free_dev_subgroups:
1051 	kfree(nilfs->ns_dev_subgroups);
1052 
1053 failed_create_device_group:
1054 	return err;
1055 }
1056 
1057 void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs)
1058 {
1059 	nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1060 	nilfs_sysfs_delete_checkpoints_group(nilfs);
1061 	nilfs_sysfs_delete_segments_group(nilfs);
1062 	nilfs_sysfs_delete_superblock_group(nilfs);
1063 	nilfs_sysfs_delete_segctor_group(nilfs);
1064 	kobject_del(&nilfs->ns_dev_kobj);
1065 	kfree(nilfs->ns_dev_subgroups);
1066 }
1067 
1068 /************************************************************************
1069  *                        NILFS feature attrs                           *
1070  ************************************************************************/
1071 
1072 static ssize_t nilfs_feature_revision_show(struct kobject *kobj,
1073 					    struct attribute *attr, char *buf)
1074 {
1075 	return snprintf(buf, PAGE_SIZE, "%d.%d\n",
1076 			NILFS_CURRENT_REV, NILFS_MINOR_REV);
1077 }
1078 
1079 static const char features_readme_str[] =
1080 	"The features group contains attributes that describe NILFS file\n"
1081 	"system driver features.\n\n"
1082 	"(1) revision\n\tshow current revision of NILFS file system driver.\n";
1083 
1084 static ssize_t nilfs_feature_README_show(struct kobject *kobj,
1085 					 struct attribute *attr,
1086 					 char *buf)
1087 {
1088 	return snprintf(buf, PAGE_SIZE, features_readme_str);
1089 }
1090 
1091 NILFS_FEATURE_RO_ATTR(revision);
1092 NILFS_FEATURE_RO_ATTR(README);
1093 
1094 static struct attribute *nilfs_feature_attrs[] = {
1095 	NILFS_FEATURE_ATTR_LIST(revision),
1096 	NILFS_FEATURE_ATTR_LIST(README),
1097 	NULL,
1098 };
1099 
1100 static const struct attribute_group nilfs_feature_attr_group = {
1101 	.name = "features",
1102 	.attrs = nilfs_feature_attrs,
1103 };
1104 
1105 int __init nilfs_sysfs_init(void)
1106 {
1107 	int err;
1108 
1109 	nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj);
1110 	if (!nilfs_kset) {
1111 		err = -ENOMEM;
1112 		printk(KERN_ERR "NILFS: unable to create sysfs entry: err %d\n",
1113 			err);
1114 		goto failed_sysfs_init;
1115 	}
1116 
1117 	err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1118 	if (unlikely(err)) {
1119 		printk(KERN_ERR "NILFS: unable to create feature group: err %d\n",
1120 			err);
1121 		goto cleanup_sysfs_init;
1122 	}
1123 
1124 	return 0;
1125 
1126 cleanup_sysfs_init:
1127 	kset_unregister(nilfs_kset);
1128 
1129 failed_sysfs_init:
1130 	return err;
1131 }
1132 
1133 void nilfs_sysfs_exit(void)
1134 {
1135 	sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1136 	kset_unregister(nilfs_kset);
1137 }
1138