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