blob: e9903bceb2bf114829bd1b448cc1333e8b593650 [file] [log] [blame]
Vyacheslav Dubeykoaebe17f2014-08-08 14:20:37 -07001/*
2 * sysfs.c - sysfs support implementation.
3 *
4 * Copyright (C) 2005-2014 Nippon Telegraph and Telephone Corporation.
5 * Copyright (C) 2014 HGST, Inc., a Western Digital Company.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * Written by Vyacheslav Dubeyko <Vyacheslav.Dubeyko@hgst.com>
18 */
19
20#include <linux/kobject.h>
21
22#include "nilfs.h"
23#include "mdt.h"
24#include "sufile.h"
25#include "cpfile.h"
26#include "sysfs.h"
27
28/* /sys/fs/<nilfs>/ */
29static struct kset *nilfs_kset;
30
31#define NILFS_SHOW_TIME(time_t_val, buf) ({ \
32 struct tm res; \
33 int count = 0; \
34 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
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -070044#define NILFS_DEV_INT_GROUP_OPS(name, parent_name) \
45static ssize_t nilfs_##name##_attr_show(struct kobject *kobj, \
46 struct attribute *attr, char *buf) \
47{ \
48 struct the_nilfs *nilfs = container_of(kobj->parent, \
49 struct the_nilfs, \
50 ns_##parent_name##_kobj); \
51 struct nilfs_##name##_attr *a = container_of(attr, \
52 struct nilfs_##name##_attr, \
53 attr); \
54 return a->show ? a->show(a, nilfs, buf) : 0; \
55} \
56static ssize_t nilfs_##name##_attr_store(struct kobject *kobj, \
57 struct attribute *attr, \
58 const char *buf, size_t len) \
59{ \
60 struct the_nilfs *nilfs = container_of(kobj->parent, \
61 struct the_nilfs, \
62 ns_##parent_name##_kobj); \
63 struct nilfs_##name##_attr *a = container_of(attr, \
64 struct nilfs_##name##_attr, \
65 attr); \
66 return a->store ? a->store(a, nilfs, buf, len) : 0; \
67} \
68static const struct sysfs_ops nilfs_##name##_attr_ops = { \
69 .show = nilfs_##name##_attr_show, \
70 .store = nilfs_##name##_attr_store, \
Ryusuke Konishifacb9ec2016-05-23 16:23:28 -070071}
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -070072
73#define NILFS_DEV_INT_GROUP_TYPE(name, parent_name) \
74static void nilfs_##name##_attr_release(struct kobject *kobj) \
75{ \
76 struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \
77 struct the_nilfs *nilfs = container_of(kobj->parent, \
78 struct the_nilfs, \
79 ns_##parent_name##_kobj); \
80 subgroups = nilfs->ns_##parent_name##_subgroups; \
81 complete(&subgroups->sg_##name##_kobj_unregister); \
82} \
83static struct kobj_type nilfs_##name##_ktype = { \
84 .default_attrs = nilfs_##name##_attrs, \
85 .sysfs_ops = &nilfs_##name##_attr_ops, \
86 .release = nilfs_##name##_attr_release, \
Ryusuke Konishifacb9ec2016-05-23 16:23:28 -070087}
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -070088
89#define NILFS_DEV_INT_GROUP_FNS(name, parent_name) \
Vyacheslav Dubeykodd70edb2014-08-08 14:20:55 -070090static int nilfs_sysfs_create_##name##_group(struct the_nilfs *nilfs) \
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -070091{ \
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} \
Vyacheslav Dubeykodd70edb2014-08-08 14:20:55 -0700109static void nilfs_sysfs_delete_##name##_group(struct the_nilfs *nilfs) \
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700110{ \
111 kobject_del(&nilfs->ns_##parent_name##_subgroups->sg_##name##_kobj); \
112}
113
114/************************************************************************
Vyacheslav Dubeykoa5a73322014-08-08 14:20:52 -0700115 * NILFS snapshot attrs *
116 ************************************************************************/
117
118static ssize_t
119nilfs_snapshot_inodes_count_show(struct nilfs_snapshot_attr *attr,
120 struct nilfs_root *root, char *buf)
121{
122 return snprintf(buf, PAGE_SIZE, "%llu\n",
123 (unsigned long long)atomic64_read(&root->inodes_count));
124}
125
126static ssize_t
127nilfs_snapshot_blocks_count_show(struct nilfs_snapshot_attr *attr,
128 struct nilfs_root *root, char *buf)
129{
130 return snprintf(buf, PAGE_SIZE, "%llu\n",
131 (unsigned long long)atomic64_read(&root->blocks_count));
132}
133
134static const char snapshot_readme_str[] =
135 "The group contains details about mounted snapshot.\n\n"
136 "(1) inodes_count\n\tshow number of inodes for snapshot.\n\n"
137 "(2) blocks_count\n\tshow number of blocks for snapshot.\n\n";
138
139static ssize_t
140nilfs_snapshot_README_show(struct nilfs_snapshot_attr *attr,
141 struct nilfs_root *root, char *buf)
142{
143 return snprintf(buf, PAGE_SIZE, snapshot_readme_str);
144}
145
146NILFS_SNAPSHOT_RO_ATTR(inodes_count);
147NILFS_SNAPSHOT_RO_ATTR(blocks_count);
148NILFS_SNAPSHOT_RO_ATTR(README);
149
150static struct attribute *nilfs_snapshot_attrs[] = {
151 NILFS_SNAPSHOT_ATTR_LIST(inodes_count),
152 NILFS_SNAPSHOT_ATTR_LIST(blocks_count),
153 NILFS_SNAPSHOT_ATTR_LIST(README),
154 NULL,
155};
156
157static ssize_t nilfs_snapshot_attr_show(struct kobject *kobj,
158 struct attribute *attr, char *buf)
159{
160 struct nilfs_root *root =
161 container_of(kobj, struct nilfs_root, snapshot_kobj);
162 struct nilfs_snapshot_attr *a =
163 container_of(attr, struct nilfs_snapshot_attr, attr);
164
165 return a->show ? a->show(a, root, buf) : 0;
166}
167
168static ssize_t nilfs_snapshot_attr_store(struct kobject *kobj,
169 struct attribute *attr,
170 const char *buf, size_t len)
171{
172 struct nilfs_root *root =
173 container_of(kobj, struct nilfs_root, snapshot_kobj);
174 struct nilfs_snapshot_attr *a =
175 container_of(attr, struct nilfs_snapshot_attr, attr);
176
177 return a->store ? a->store(a, root, buf, len) : 0;
178}
179
180static void nilfs_snapshot_attr_release(struct kobject *kobj)
181{
182 struct nilfs_root *root = container_of(kobj, struct nilfs_root,
183 snapshot_kobj);
184 complete(&root->snapshot_kobj_unregister);
185}
186
187static const struct sysfs_ops nilfs_snapshot_attr_ops = {
188 .show = nilfs_snapshot_attr_show,
189 .store = nilfs_snapshot_attr_store,
190};
191
192static struct kobj_type nilfs_snapshot_ktype = {
193 .default_attrs = nilfs_snapshot_attrs,
194 .sysfs_ops = &nilfs_snapshot_attr_ops,
195 .release = nilfs_snapshot_attr_release,
196};
197
198int nilfs_sysfs_create_snapshot_group(struct nilfs_root *root)
199{
200 struct the_nilfs *nilfs;
201 struct kobject *parent;
202 int err;
203
204 nilfs = root->nilfs;
205 parent = &nilfs->ns_dev_subgroups->sg_mounted_snapshots_kobj;
206 root->snapshot_kobj.kset = nilfs_kset;
207 init_completion(&root->snapshot_kobj_unregister);
208
209 if (root->cno == NILFS_CPTREE_CURRENT_CNO) {
210 err = kobject_init_and_add(&root->snapshot_kobj,
211 &nilfs_snapshot_ktype,
212 &nilfs->ns_dev_kobj,
213 "current_checkpoint");
214 } else {
215 err = kobject_init_and_add(&root->snapshot_kobj,
216 &nilfs_snapshot_ktype,
217 parent,
218 "%llu", root->cno);
219 }
220
221 if (err)
222 return err;
223
224 return 0;
225}
226
227void nilfs_sysfs_delete_snapshot_group(struct nilfs_root *root)
228{
229 kobject_del(&root->snapshot_kobj);
230}
231
232/************************************************************************
Vyacheslav Dubeykoa2ecb792014-08-08 14:20:50 -0700233 * NILFS mounted snapshots attrs *
234 ************************************************************************/
235
236static const char mounted_snapshots_readme_str[] =
237 "The mounted_snapshots group contains group for\n"
238 "every mounted snapshot.\n";
239
240static ssize_t
241nilfs_mounted_snapshots_README_show(struct nilfs_mounted_snapshots_attr *attr,
242 struct the_nilfs *nilfs, char *buf)
243{
244 return snprintf(buf, PAGE_SIZE, mounted_snapshots_readme_str);
245}
246
247NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README);
248
249static struct attribute *nilfs_mounted_snapshots_attrs[] = {
250 NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README),
251 NULL,
252};
253
254NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev);
255NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev);
256NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev);
257
258/************************************************************************
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -0700259 * NILFS checkpoints attrs *
260 ************************************************************************/
261
262static ssize_t
263nilfs_checkpoints_checkpoints_number_show(struct nilfs_checkpoints_attr *attr,
264 struct the_nilfs *nilfs,
265 char *buf)
266{
267 __u64 ncheckpoints;
268 struct nilfs_cpstat cpstat;
269 int err;
270
271 down_read(&nilfs->ns_segctor_sem);
272 err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat);
273 up_read(&nilfs->ns_segctor_sem);
274 if (err < 0) {
Ryusuke Konishifeee8802016-08-02 14:05:10 -0700275 nilfs_msg(nilfs->ns_sb, KERN_ERR,
276 "unable to get checkpoint stat: err=%d", err);
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -0700277 return err;
278 }
279
280 ncheckpoints = cpstat.cs_ncps;
281
282 return snprintf(buf, PAGE_SIZE, "%llu\n", ncheckpoints);
283}
284
285static ssize_t
286nilfs_checkpoints_snapshots_number_show(struct nilfs_checkpoints_attr *attr,
287 struct the_nilfs *nilfs,
288 char *buf)
289{
290 __u64 nsnapshots;
291 struct nilfs_cpstat cpstat;
292 int err;
293
294 down_read(&nilfs->ns_segctor_sem);
295 err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat);
296 up_read(&nilfs->ns_segctor_sem);
297 if (err < 0) {
Ryusuke Konishifeee8802016-08-02 14:05:10 -0700298 nilfs_msg(nilfs->ns_sb, KERN_ERR,
299 "unable to get checkpoint stat: err=%d", err);
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -0700300 return err;
301 }
302
303 nsnapshots = cpstat.cs_nsss;
304
305 return snprintf(buf, PAGE_SIZE, "%llu\n", nsnapshots);
306}
307
308static ssize_t
309nilfs_checkpoints_last_seg_checkpoint_show(struct nilfs_checkpoints_attr *attr,
310 struct the_nilfs *nilfs,
311 char *buf)
312{
313 __u64 last_cno;
314
315 spin_lock(&nilfs->ns_last_segment_lock);
316 last_cno = nilfs->ns_last_cno;
317 spin_unlock(&nilfs->ns_last_segment_lock);
318
319 return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno);
320}
321
322static ssize_t
323nilfs_checkpoints_next_checkpoint_show(struct nilfs_checkpoints_attr *attr,
324 struct the_nilfs *nilfs,
325 char *buf)
326{
327 __u64 cno;
328
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700329 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -0700330 cno = nilfs->ns_cno;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700331 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -0700332
333 return snprintf(buf, PAGE_SIZE, "%llu\n", cno);
334}
335
336static const char checkpoints_readme_str[] =
337 "The checkpoints group contains attributes that describe\n"
338 "details about volume's checkpoints.\n\n"
339 "(1) checkpoints_number\n\tshow number of checkpoints on volume.\n\n"
340 "(2) snapshots_number\n\tshow number of snapshots on volume.\n\n"
341 "(3) last_seg_checkpoint\n"
342 "\tshow checkpoint number of the latest segment.\n\n"
343 "(4) next_checkpoint\n\tshow next checkpoint number.\n\n";
344
345static ssize_t
346nilfs_checkpoints_README_show(struct nilfs_checkpoints_attr *attr,
347 struct the_nilfs *nilfs, char *buf)
348{
349 return snprintf(buf, PAGE_SIZE, checkpoints_readme_str);
350}
351
352NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number);
353NILFS_CHECKPOINTS_RO_ATTR(snapshots_number);
354NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint);
355NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint);
356NILFS_CHECKPOINTS_RO_ATTR(README);
357
358static struct attribute *nilfs_checkpoints_attrs[] = {
359 NILFS_CHECKPOINTS_ATTR_LIST(checkpoints_number),
360 NILFS_CHECKPOINTS_ATTR_LIST(snapshots_number),
361 NILFS_CHECKPOINTS_ATTR_LIST(last_seg_checkpoint),
362 NILFS_CHECKPOINTS_ATTR_LIST(next_checkpoint),
363 NILFS_CHECKPOINTS_ATTR_LIST(README),
364 NULL,
365};
366
367NILFS_DEV_INT_GROUP_OPS(checkpoints, dev);
368NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev);
369NILFS_DEV_INT_GROUP_FNS(checkpoints, dev);
370
371/************************************************************************
Vyacheslav Dubeykoef43d5c2014-08-08 14:20:46 -0700372 * NILFS segments attrs *
373 ************************************************************************/
374
375static ssize_t
376nilfs_segments_segments_number_show(struct nilfs_segments_attr *attr,
377 struct the_nilfs *nilfs,
378 char *buf)
379{
380 return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_nsegments);
381}
382
383static ssize_t
384nilfs_segments_blocks_per_segment_show(struct nilfs_segments_attr *attr,
385 struct the_nilfs *nilfs,
386 char *buf)
387{
388 return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_blocks_per_segment);
389}
390
391static ssize_t
392nilfs_segments_clean_segments_show(struct nilfs_segments_attr *attr,
393 struct the_nilfs *nilfs,
394 char *buf)
395{
396 unsigned long ncleansegs;
397
398 down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
399 ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile);
400 up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
401
402 return snprintf(buf, PAGE_SIZE, "%lu\n", ncleansegs);
403}
404
405static ssize_t
406nilfs_segments_dirty_segments_show(struct nilfs_segments_attr *attr,
407 struct the_nilfs *nilfs,
408 char *buf)
409{
410 struct nilfs_sustat sustat;
411 int err;
412
413 down_read(&nilfs->ns_segctor_sem);
414 err = nilfs_sufile_get_stat(nilfs->ns_sufile, &sustat);
415 up_read(&nilfs->ns_segctor_sem);
416 if (err < 0) {
Ryusuke Konishifeee8802016-08-02 14:05:10 -0700417 nilfs_msg(nilfs->ns_sb, KERN_ERR,
418 "unable to get segment stat: err=%d", err);
Vyacheslav Dubeykoef43d5c2014-08-08 14:20:46 -0700419 return err;
420 }
421
422 return snprintf(buf, PAGE_SIZE, "%llu\n", sustat.ss_ndirtysegs);
423}
424
425static const char segments_readme_str[] =
426 "The segments group contains attributes that describe\n"
427 "details about volume's segments.\n\n"
428 "(1) segments_number\n\tshow number of segments on volume.\n\n"
429 "(2) blocks_per_segment\n\tshow number of blocks in segment.\n\n"
430 "(3) clean_segments\n\tshow count of clean segments.\n\n"
431 "(4) dirty_segments\n\tshow count of dirty segments.\n\n";
432
433static ssize_t
434nilfs_segments_README_show(struct nilfs_segments_attr *attr,
435 struct the_nilfs *nilfs,
436 char *buf)
437{
438 return snprintf(buf, PAGE_SIZE, segments_readme_str);
439}
440
441NILFS_SEGMENTS_RO_ATTR(segments_number);
442NILFS_SEGMENTS_RO_ATTR(blocks_per_segment);
443NILFS_SEGMENTS_RO_ATTR(clean_segments);
444NILFS_SEGMENTS_RO_ATTR(dirty_segments);
445NILFS_SEGMENTS_RO_ATTR(README);
446
447static struct attribute *nilfs_segments_attrs[] = {
448 NILFS_SEGMENTS_ATTR_LIST(segments_number),
449 NILFS_SEGMENTS_ATTR_LIST(blocks_per_segment),
450 NILFS_SEGMENTS_ATTR_LIST(clean_segments),
451 NILFS_SEGMENTS_ATTR_LIST(dirty_segments),
452 NILFS_SEGMENTS_ATTR_LIST(README),
453 NULL,
454};
455
456NILFS_DEV_INT_GROUP_OPS(segments, dev);
457NILFS_DEV_INT_GROUP_TYPE(segments, dev);
458NILFS_DEV_INT_GROUP_FNS(segments, dev);
459
460/************************************************************************
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700461 * NILFS segctor attrs *
462 ************************************************************************/
463
464static ssize_t
465nilfs_segctor_last_pseg_block_show(struct nilfs_segctor_attr *attr,
466 struct the_nilfs *nilfs,
467 char *buf)
468{
469 sector_t last_pseg;
470
471 spin_lock(&nilfs->ns_last_segment_lock);
472 last_pseg = nilfs->ns_last_pseg;
473 spin_unlock(&nilfs->ns_last_segment_lock);
474
475 return snprintf(buf, PAGE_SIZE, "%llu\n",
476 (unsigned long long)last_pseg);
477}
478
479static ssize_t
480nilfs_segctor_last_seg_sequence_show(struct nilfs_segctor_attr *attr,
481 struct the_nilfs *nilfs,
482 char *buf)
483{
484 u64 last_seq;
485
486 spin_lock(&nilfs->ns_last_segment_lock);
487 last_seq = nilfs->ns_last_seq;
488 spin_unlock(&nilfs->ns_last_segment_lock);
489
490 return snprintf(buf, PAGE_SIZE, "%llu\n", last_seq);
491}
492
493static ssize_t
494nilfs_segctor_last_seg_checkpoint_show(struct nilfs_segctor_attr *attr,
495 struct the_nilfs *nilfs,
496 char *buf)
497{
498 __u64 last_cno;
499
500 spin_lock(&nilfs->ns_last_segment_lock);
501 last_cno = nilfs->ns_last_cno;
502 spin_unlock(&nilfs->ns_last_segment_lock);
503
504 return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno);
505}
506
507static ssize_t
508nilfs_segctor_current_seg_sequence_show(struct nilfs_segctor_attr *attr,
509 struct the_nilfs *nilfs,
510 char *buf)
511{
512 u64 seg_seq;
513
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700514 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700515 seg_seq = nilfs->ns_seg_seq;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700516 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700517
518 return snprintf(buf, PAGE_SIZE, "%llu\n", seg_seq);
519}
520
521static ssize_t
522nilfs_segctor_current_last_full_seg_show(struct nilfs_segctor_attr *attr,
523 struct the_nilfs *nilfs,
524 char *buf)
525{
526 __u64 segnum;
527
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700528 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700529 segnum = nilfs->ns_segnum;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700530 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700531
532 return snprintf(buf, PAGE_SIZE, "%llu\n", segnum);
533}
534
535static ssize_t
536nilfs_segctor_next_full_seg_show(struct nilfs_segctor_attr *attr,
537 struct the_nilfs *nilfs,
538 char *buf)
539{
540 __u64 nextnum;
541
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700542 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700543 nextnum = nilfs->ns_nextnum;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700544 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700545
546 return snprintf(buf, PAGE_SIZE, "%llu\n", nextnum);
547}
548
549static ssize_t
550nilfs_segctor_next_pseg_offset_show(struct nilfs_segctor_attr *attr,
551 struct the_nilfs *nilfs,
552 char *buf)
553{
554 unsigned long pseg_offset;
555
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700556 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700557 pseg_offset = nilfs->ns_pseg_offset;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700558 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700559
560 return snprintf(buf, PAGE_SIZE, "%lu\n", pseg_offset);
561}
562
563static ssize_t
564nilfs_segctor_next_checkpoint_show(struct nilfs_segctor_attr *attr,
565 struct the_nilfs *nilfs,
566 char *buf)
567{
568 __u64 cno;
569
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700570 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700571 cno = nilfs->ns_cno;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700572 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700573
574 return snprintf(buf, PAGE_SIZE, "%llu\n", cno);
575}
576
577static ssize_t
578nilfs_segctor_last_seg_write_time_show(struct nilfs_segctor_attr *attr,
579 struct the_nilfs *nilfs,
580 char *buf)
581{
582 time_t ctime;
583
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700584 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700585 ctime = nilfs->ns_ctime;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700586 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700587
588 return NILFS_SHOW_TIME(ctime, buf);
589}
590
591static ssize_t
592nilfs_segctor_last_seg_write_time_secs_show(struct nilfs_segctor_attr *attr,
593 struct the_nilfs *nilfs,
594 char *buf)
595{
596 time_t ctime;
597
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700598 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700599 ctime = nilfs->ns_ctime;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700600 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700601
602 return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)ctime);
603}
604
605static ssize_t
606nilfs_segctor_last_nongc_write_time_show(struct nilfs_segctor_attr *attr,
607 struct the_nilfs *nilfs,
608 char *buf)
609{
610 time_t nongc_ctime;
611
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700612 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700613 nongc_ctime = nilfs->ns_nongc_ctime;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700614 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700615
616 return NILFS_SHOW_TIME(nongc_ctime, buf);
617}
618
619static ssize_t
620nilfs_segctor_last_nongc_write_time_secs_show(struct nilfs_segctor_attr *attr,
621 struct the_nilfs *nilfs,
622 char *buf)
623{
624 time_t nongc_ctime;
625
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700626 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700627 nongc_ctime = nilfs->ns_nongc_ctime;
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700628 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700629
630 return snprintf(buf, PAGE_SIZE, "%llu\n",
631 (unsigned long long)nongc_ctime);
632}
633
634static ssize_t
635nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr,
636 struct the_nilfs *nilfs,
637 char *buf)
638{
639 u32 ndirtyblks;
640
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700641 down_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700642 ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks);
Ryusuke Konishiad980c92016-08-02 14:05:25 -0700643 up_read(&nilfs->ns_segctor_sem);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -0700644
645 return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks);
646}
647
648static 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
678static ssize_t
679nilfs_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
685NILFS_SEGCTOR_RO_ATTR(last_pseg_block);
686NILFS_SEGCTOR_RO_ATTR(last_seg_sequence);
687NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint);
688NILFS_SEGCTOR_RO_ATTR(current_seg_sequence);
689NILFS_SEGCTOR_RO_ATTR(current_last_full_seg);
690NILFS_SEGCTOR_RO_ATTR(next_full_seg);
691NILFS_SEGCTOR_RO_ATTR(next_pseg_offset);
692NILFS_SEGCTOR_RO_ATTR(next_checkpoint);
693NILFS_SEGCTOR_RO_ATTR(last_seg_write_time);
694NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs);
695NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time);
696NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs);
697NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count);
698NILFS_SEGCTOR_RO_ATTR(README);
699
700static 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
718NILFS_DEV_INT_GROUP_OPS(segctor, dev);
719NILFS_DEV_INT_GROUP_TYPE(segctor, dev);
720NILFS_DEV_INT_GROUP_FNS(segctor, dev);
721
722/************************************************************************
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700723 * NILFS superblock attrs *
724 ************************************************************************/
725
726static ssize_t
727nilfs_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
740static ssize_t
741nilfs_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
754static ssize_t
755nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr,
756 struct the_nilfs *nilfs,
757 char *buf)
758{
Ryusuke Konishi0c6c44c2016-05-23 16:23:39 -0700759 unsigned int sbwcount;
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700760
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
768static ssize_t
769nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr,
770 struct the_nilfs *nilfs,
771 char *buf)
772{
Ryusuke Konishi0c6c44c2016-05-23 16:23:39 -0700773 unsigned int sb_update_freq;
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700774
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
782static ssize_t
783nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr,
784 struct the_nilfs *nilfs,
785 const char *buf, size_t count)
786{
Ryusuke Konishi0c6c44c2016-05-23 16:23:39 -0700787 unsigned int val;
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700788 int err;
789
790 err = kstrtouint(skip_spaces(buf), 0, &val);
791 if (err) {
Ryusuke Konishifeee8802016-08-02 14:05:10 -0700792 nilfs_msg(nilfs->ns_sb, KERN_ERR,
793 "unable to convert string: err=%d", err);
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700794 return err;
795 }
796
797 if (val < NILFS_SB_FREQ) {
798 val = NILFS_SB_FREQ;
Ryusuke Konishifeee8802016-08-02 14:05:10 -0700799 nilfs_msg(nilfs->ns_sb, KERN_WARNING,
800 "superblock update frequency cannot be lesser than 10 seconds");
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700801 }
802
803 down_write(&nilfs->ns_sem);
804 nilfs->ns_sb_update_freq = val;
805 up_write(&nilfs->ns_sem);
806
807 return count;
808}
809
810static const char sb_readme_str[] =
811 "The superblock group contains attributes that describe\n"
812 "superblock's details.\n\n"
813 "(1) sb_write_time\n\tshow previous write time of super block "
814 "in human-readable format.\n\n"
815 "(2) sb_write_time_secs\n\tshow previous write time of super block "
816 "in seconds.\n\n"
817 "(3) sb_write_count\n\tshow write count of super block.\n\n"
818 "(4) sb_update_frequency\n"
819 "\tshow/set interval of periodical update of superblock (in seconds).\n\n"
820 "\tYou can set preferable frequency of superblock update by command:\n\n"
821 "\t'echo <val> > /sys/fs/<nilfs>/<dev>/superblock/sb_update_frequency'\n";
822
823static ssize_t
824nilfs_superblock_README_show(struct nilfs_superblock_attr *attr,
825 struct the_nilfs *nilfs, char *buf)
826{
827 return snprintf(buf, PAGE_SIZE, sb_readme_str);
828}
829
830NILFS_SUPERBLOCK_RO_ATTR(sb_write_time);
831NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs);
832NILFS_SUPERBLOCK_RO_ATTR(sb_write_count);
833NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency);
834NILFS_SUPERBLOCK_RO_ATTR(README);
835
836static struct attribute *nilfs_superblock_attrs[] = {
837 NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time),
838 NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time_secs),
839 NILFS_SUPERBLOCK_ATTR_LIST(sb_write_count),
840 NILFS_SUPERBLOCK_ATTR_LIST(sb_update_frequency),
841 NILFS_SUPERBLOCK_ATTR_LIST(README),
842 NULL,
843};
844
845NILFS_DEV_INT_GROUP_OPS(superblock, dev);
846NILFS_DEV_INT_GROUP_TYPE(superblock, dev);
847NILFS_DEV_INT_GROUP_FNS(superblock, dev);
848
Vyacheslav Dubeykoaebe17f2014-08-08 14:20:37 -0700849/************************************************************************
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -0700850 * NILFS device attrs *
851 ************************************************************************/
852
853static
854ssize_t nilfs_dev_revision_show(struct nilfs_dev_attr *attr,
855 struct the_nilfs *nilfs,
856 char *buf)
857{
858 struct nilfs_super_block **sbp = nilfs->ns_sbp;
859 u32 major = le32_to_cpu(sbp[0]->s_rev_level);
860 u16 minor = le16_to_cpu(sbp[0]->s_minor_rev_level);
861
862 return snprintf(buf, PAGE_SIZE, "%d.%d\n", major, minor);
863}
864
865static
866ssize_t nilfs_dev_blocksize_show(struct nilfs_dev_attr *attr,
867 struct the_nilfs *nilfs,
868 char *buf)
869{
870 return snprintf(buf, PAGE_SIZE, "%u\n", nilfs->ns_blocksize);
871}
872
873static
874ssize_t nilfs_dev_device_size_show(struct nilfs_dev_attr *attr,
875 struct the_nilfs *nilfs,
876 char *buf)
877{
878 struct nilfs_super_block **sbp = nilfs->ns_sbp;
879 u64 dev_size = le64_to_cpu(sbp[0]->s_dev_size);
880
881 return snprintf(buf, PAGE_SIZE, "%llu\n", dev_size);
882}
883
884static
885ssize_t nilfs_dev_free_blocks_show(struct nilfs_dev_attr *attr,
886 struct the_nilfs *nilfs,
887 char *buf)
888{
889 sector_t free_blocks = 0;
890
891 nilfs_count_free_blocks(nilfs, &free_blocks);
892 return snprintf(buf, PAGE_SIZE, "%llu\n",
893 (unsigned long long)free_blocks);
894}
895
896static
897ssize_t nilfs_dev_uuid_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 snprintf(buf, PAGE_SIZE, "%pUb\n", sbp[0]->s_uuid);
904}
905
906static
907ssize_t nilfs_dev_volume_name_show(struct nilfs_dev_attr *attr,
908 struct the_nilfs *nilfs,
909 char *buf)
910{
911 struct nilfs_super_block **sbp = nilfs->ns_sbp;
912
913 return scnprintf(buf, sizeof(sbp[0]->s_volume_name), "%s\n",
914 sbp[0]->s_volume_name);
915}
916
917static const char dev_readme_str[] =
918 "The <device> group contains attributes that describe file system\n"
919 "partition's details.\n\n"
920 "(1) revision\n\tshow NILFS file system revision.\n\n"
921 "(2) blocksize\n\tshow volume block size in bytes.\n\n"
922 "(3) device_size\n\tshow volume size in bytes.\n\n"
923 "(4) free_blocks\n\tshow count of free blocks on volume.\n\n"
924 "(5) uuid\n\tshow volume's UUID.\n\n"
925 "(6) volume_name\n\tshow volume's name.\n\n";
926
927static ssize_t nilfs_dev_README_show(struct nilfs_dev_attr *attr,
928 struct the_nilfs *nilfs,
929 char *buf)
930{
931 return snprintf(buf, PAGE_SIZE, dev_readme_str);
932}
933
934NILFS_DEV_RO_ATTR(revision);
935NILFS_DEV_RO_ATTR(blocksize);
936NILFS_DEV_RO_ATTR(device_size);
937NILFS_DEV_RO_ATTR(free_blocks);
938NILFS_DEV_RO_ATTR(uuid);
939NILFS_DEV_RO_ATTR(volume_name);
940NILFS_DEV_RO_ATTR(README);
941
942static struct attribute *nilfs_dev_attrs[] = {
943 NILFS_DEV_ATTR_LIST(revision),
944 NILFS_DEV_ATTR_LIST(blocksize),
945 NILFS_DEV_ATTR_LIST(device_size),
946 NILFS_DEV_ATTR_LIST(free_blocks),
947 NILFS_DEV_ATTR_LIST(uuid),
948 NILFS_DEV_ATTR_LIST(volume_name),
949 NILFS_DEV_ATTR_LIST(README),
950 NULL,
951};
952
953static ssize_t nilfs_dev_attr_show(struct kobject *kobj,
954 struct attribute *attr, char *buf)
955{
956 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs,
957 ns_dev_kobj);
958 struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr,
959 attr);
960
961 return a->show ? a->show(a, nilfs, buf) : 0;
962}
963
964static ssize_t nilfs_dev_attr_store(struct kobject *kobj,
965 struct attribute *attr,
966 const char *buf, size_t len)
967{
968 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs,
969 ns_dev_kobj);
970 struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr,
971 attr);
972
973 return a->store ? a->store(a, nilfs, buf, len) : 0;
974}
975
976static void nilfs_dev_attr_release(struct kobject *kobj)
977{
978 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs,
979 ns_dev_kobj);
980 complete(&nilfs->ns_dev_kobj_unregister);
981}
982
983static const struct sysfs_ops nilfs_dev_attr_ops = {
984 .show = nilfs_dev_attr_show,
985 .store = nilfs_dev_attr_store,
986};
987
988static struct kobj_type nilfs_dev_ktype = {
989 .default_attrs = nilfs_dev_attrs,
990 .sysfs_ops = &nilfs_dev_attr_ops,
991 .release = nilfs_dev_attr_release,
992};
993
994int nilfs_sysfs_create_device_group(struct super_block *sb)
995{
996 struct the_nilfs *nilfs = sb->s_fs_info;
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -0700997 size_t devgrp_size = sizeof(struct nilfs_sysfs_dev_subgroups);
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -0700998 int err;
999
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -07001000 nilfs->ns_dev_subgroups = kzalloc(devgrp_size, GFP_KERNEL);
1001 if (unlikely(!nilfs->ns_dev_subgroups)) {
1002 err = -ENOMEM;
Ryusuke Konishifeee8802016-08-02 14:05:10 -07001003 nilfs_msg(sb, KERN_ERR,
1004 "unable to allocate memory for device group");
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -07001005 goto failed_create_device_group;
1006 }
1007
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -07001008 nilfs->ns_dev_kobj.kset = nilfs_kset;
1009 init_completion(&nilfs->ns_dev_kobj_unregister);
1010 err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL,
1011 "%s", sb->s_id);
1012 if (err)
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -07001013 goto free_dev_subgroups;
1014
Vyacheslav Dubeykoa2ecb792014-08-08 14:20:50 -07001015 err = nilfs_sysfs_create_mounted_snapshots_group(nilfs);
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -07001016 if (err)
1017 goto cleanup_dev_kobject;
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -07001018
Vyacheslav Dubeykoa2ecb792014-08-08 14:20:50 -07001019 err = nilfs_sysfs_create_checkpoints_group(nilfs);
1020 if (err)
1021 goto delete_mounted_snapshots_group;
1022
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -07001023 err = nilfs_sysfs_create_segments_group(nilfs);
1024 if (err)
1025 goto delete_checkpoints_group;
1026
Vyacheslav Dubeykoef43d5c2014-08-08 14:20:46 -07001027 err = nilfs_sysfs_create_superblock_group(nilfs);
1028 if (err)
1029 goto delete_segments_group;
1030
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -07001031 err = nilfs_sysfs_create_segctor_group(nilfs);
1032 if (err)
1033 goto delete_superblock_group;
1034
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -07001035 return 0;
1036
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -07001037delete_superblock_group:
1038 nilfs_sysfs_delete_superblock_group(nilfs);
1039
Vyacheslav Dubeykoef43d5c2014-08-08 14:20:46 -07001040delete_segments_group:
1041 nilfs_sysfs_delete_segments_group(nilfs);
1042
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -07001043delete_checkpoints_group:
1044 nilfs_sysfs_delete_checkpoints_group(nilfs);
1045
Vyacheslav Dubeykoa2ecb792014-08-08 14:20:50 -07001046delete_mounted_snapshots_group:
1047 nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1048
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -07001049cleanup_dev_kobject:
1050 kobject_del(&nilfs->ns_dev_kobj);
1051
1052free_dev_subgroups:
1053 kfree(nilfs->ns_dev_subgroups);
1054
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -07001055failed_create_device_group:
1056 return err;
1057}
1058
1059void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs)
1060{
Vyacheslav Dubeykoa2ecb792014-08-08 14:20:50 -07001061 nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
Vyacheslav Dubeyko02a0ba12014-08-08 14:20:48 -07001062 nilfs_sysfs_delete_checkpoints_group(nilfs);
Vyacheslav Dubeykoef43d5c2014-08-08 14:20:46 -07001063 nilfs_sysfs_delete_segments_group(nilfs);
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -07001064 nilfs_sysfs_delete_superblock_group(nilfs);
Vyacheslav Dubeykoabc968d2014-08-08 14:20:44 -07001065 nilfs_sysfs_delete_segctor_group(nilfs);
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -07001066 kobject_del(&nilfs->ns_dev_kobj);
Pavel Skripkin46c38e22021-06-24 18:39:33 -07001067 kobject_put(&nilfs->ns_dev_kobj);
Vyacheslav Dubeykocaa05d42014-08-08 14:20:42 -07001068 kfree(nilfs->ns_dev_subgroups);
Vyacheslav Dubeykoda7141f2014-08-08 14:20:39 -07001069}
1070
1071/************************************************************************
Vyacheslav Dubeykoaebe17f2014-08-08 14:20:37 -07001072 * NILFS feature attrs *
1073 ************************************************************************/
1074
1075static ssize_t nilfs_feature_revision_show(struct kobject *kobj,
1076 struct attribute *attr, char *buf)
1077{
1078 return snprintf(buf, PAGE_SIZE, "%d.%d\n",
1079 NILFS_CURRENT_REV, NILFS_MINOR_REV);
1080}
1081
1082static const char features_readme_str[] =
1083 "The features group contains attributes that describe NILFS file\n"
1084 "system driver features.\n\n"
1085 "(1) revision\n\tshow current revision of NILFS file system driver.\n";
1086
1087static ssize_t nilfs_feature_README_show(struct kobject *kobj,
1088 struct attribute *attr,
1089 char *buf)
1090{
1091 return snprintf(buf, PAGE_SIZE, features_readme_str);
1092}
1093
1094NILFS_FEATURE_RO_ATTR(revision);
1095NILFS_FEATURE_RO_ATTR(README);
1096
1097static struct attribute *nilfs_feature_attrs[] = {
1098 NILFS_FEATURE_ATTR_LIST(revision),
1099 NILFS_FEATURE_ATTR_LIST(README),
1100 NULL,
1101};
1102
1103static const struct attribute_group nilfs_feature_attr_group = {
1104 .name = "features",
1105 .attrs = nilfs_feature_attrs,
1106};
1107
1108int __init nilfs_sysfs_init(void)
1109{
1110 int err;
1111
1112 nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj);
1113 if (!nilfs_kset) {
1114 err = -ENOMEM;
Ryusuke Konishifeee8802016-08-02 14:05:10 -07001115 nilfs_msg(NULL, KERN_ERR,
1116 "unable to create sysfs entry: err=%d", err);
Vyacheslav Dubeykoaebe17f2014-08-08 14:20:37 -07001117 goto failed_sysfs_init;
1118 }
1119
1120 err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1121 if (unlikely(err)) {
Ryusuke Konishifeee8802016-08-02 14:05:10 -07001122 nilfs_msg(NULL, KERN_ERR,
1123 "unable to create feature group: err=%d", err);
Vyacheslav Dubeykoaebe17f2014-08-08 14:20:37 -07001124 goto cleanup_sysfs_init;
1125 }
1126
1127 return 0;
1128
1129cleanup_sysfs_init:
1130 kset_unregister(nilfs_kset);
1131
1132failed_sysfs_init:
1133 return err;
1134}
1135
1136void nilfs_sysfs_exit(void)
1137{
1138 sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1139 kset_unregister(nilfs_kset);
1140}