~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nilfs2/sysfs.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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                 time64_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                 nilfs_msg(nilfs->ns_sb, KERN_ERR,
276                           "unable to get checkpoint stat: err=%d", 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                 nilfs_msg(nilfs->ns_sb, KERN_ERR,
299                           "unable to get checkpoint stat: err=%d", 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_segctor_sem);
330         cno = nilfs->ns_cno;
331         up_read(&nilfs->ns_segctor_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                 nilfs_msg(nilfs->ns_sb, KERN_ERR,
418                           "unable to get segment stat: err=%d", 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_segctor_sem);
515         seg_seq = nilfs->ns_seg_seq;
516         up_read(&nilfs->ns_segctor_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_segctor_sem);
529         segnum = nilfs->ns_segnum;
530         up_read(&nilfs->ns_segctor_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_segctor_sem);
543         nextnum = nilfs->ns_nextnum;
544         up_read(&nilfs->ns_segctor_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_segctor_sem);
557         pseg_offset = nilfs->ns_pseg_offset;
558         up_read(&nilfs->ns_segctor_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_segctor_sem);
571         cno = nilfs->ns_cno;
572         up_read(&nilfs->ns_segctor_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         time64_t ctime;
583 
584         down_read(&nilfs->ns_segctor_sem);
585         ctime = nilfs->ns_ctime;
586         up_read(&nilfs->ns_segctor_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         time64_t ctime;
597 
598         down_read(&nilfs->ns_segctor_sem);
599         ctime = nilfs->ns_ctime;
600         up_read(&nilfs->ns_segctor_sem);
601 
602         return snprintf(buf, PAGE_SIZE, "%llu\n", 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         time64_t nongc_ctime;
611 
612         down_read(&nilfs->ns_segctor_sem);
613         nongc_ctime = nilfs->ns_nongc_ctime;
614         up_read(&nilfs->ns_segctor_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         time64_t nongc_ctime;
625 
626         down_read(&nilfs->ns_segctor_sem);
627         nongc_ctime = nilfs->ns_nongc_ctime;
628         up_read(&nilfs->ns_segctor_sem);
629 
630         return snprintf(buf, PAGE_SIZE, "%llu\n", nongc_ctime);
631 }
632 
633 static ssize_t
634 nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr,
635                                             struct the_nilfs *nilfs,
636                                             char *buf)
637 {
638         u32 ndirtyblks;
639 
640         down_read(&nilfs->ns_segctor_sem);
641         ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks);
642         up_read(&nilfs->ns_segctor_sem);
643 
644         return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks);
645 }
646 
647 static const char segctor_readme_str[] =
648         "The segctor group contains attributes that describe\n"
649         "segctor thread activity details.\n\n"
650         "(1) last_pseg_block\n"
651         "\tshow start block number of the latest segment.\n\n"
652         "(2) last_seg_sequence\n"
653         "\tshow sequence value of the latest segment.\n\n"
654         "(3) last_seg_checkpoint\n"
655         "\tshow checkpoint number of the latest segment.\n\n"
656         "(4) current_seg_sequence\n\tshow segment sequence counter.\n\n"
657         "(5) current_last_full_seg\n"
658         "\tshow index number of the latest full segment.\n\n"
659         "(6) next_full_seg\n"
660         "\tshow index number of the full segment index to be used next.\n\n"
661         "(7) next_pseg_offset\n"
662         "\tshow offset of next partial segment in the current full segment.\n\n"
663         "(8) next_checkpoint\n\tshow next checkpoint number.\n\n"
664         "(9) last_seg_write_time\n"
665         "\tshow write time of the last segment in human-readable format.\n\n"
666         "(10) last_seg_write_time_secs\n"
667         "\tshow write time of the last segment in seconds.\n\n"
668         "(11) last_nongc_write_time\n"
669         "\tshow write time of the last segment not for cleaner operation "
670         "in human-readable format.\n\n"
671         "(12) last_nongc_write_time_secs\n"
672         "\tshow write time of the last segment not for cleaner operation "
673         "in seconds.\n\n"
674         "(13) dirty_data_blocks_count\n"
675         "\tshow number of dirty data blocks.\n\n";
676 
677 static ssize_t
678 nilfs_segctor_README_show(struct nilfs_segctor_attr *attr,
679                           struct the_nilfs *nilfs, char *buf)
680 {
681         return snprintf(buf, PAGE_SIZE, segctor_readme_str);
682 }
683 
684 NILFS_SEGCTOR_RO_ATTR(last_pseg_block);
685 NILFS_SEGCTOR_RO_ATTR(last_seg_sequence);
686 NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint);
687 NILFS_SEGCTOR_RO_ATTR(current_seg_sequence);
688 NILFS_SEGCTOR_RO_ATTR(current_last_full_seg);
689 NILFS_SEGCTOR_RO_ATTR(next_full_seg);
690 NILFS_SEGCTOR_RO_ATTR(next_pseg_offset);
691 NILFS_SEGCTOR_RO_ATTR(next_checkpoint);
692 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time);
693 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs);
694 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time);
695 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs);
696 NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count);
697 NILFS_SEGCTOR_RO_ATTR(README);
698 
699 static struct attribute *nilfs_segctor_attrs[] = {
700         NILFS_SEGCTOR_ATTR_LIST(last_pseg_block),
701         NILFS_SEGCTOR_ATTR_LIST(last_seg_sequence),
702         NILFS_SEGCTOR_ATTR_LIST(last_seg_checkpoint),
703         NILFS_SEGCTOR_ATTR_LIST(current_seg_sequence),
704         NILFS_SEGCTOR_ATTR_LIST(current_last_full_seg),
705         NILFS_SEGCTOR_ATTR_LIST(next_full_seg),
706         NILFS_SEGCTOR_ATTR_LIST(next_pseg_offset),
707         NILFS_SEGCTOR_ATTR_LIST(next_checkpoint),
708         NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time),
709         NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time_secs),
710         NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time),
711         NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time_secs),
712         NILFS_SEGCTOR_ATTR_LIST(dirty_data_blocks_count),
713         NILFS_SEGCTOR_ATTR_LIST(README),
714         NULL,
715 };
716 
717 NILFS_DEV_INT_GROUP_OPS(segctor, dev);
718 NILFS_DEV_INT_GROUP_TYPE(segctor, dev);
719 NILFS_DEV_INT_GROUP_FNS(segctor, dev);
720 
721 /************************************************************************
722  *                        NILFS superblock attrs                        *
723  ************************************************************************/
724 
725 static ssize_t
726 nilfs_superblock_sb_write_time_show(struct nilfs_superblock_attr *attr,
727                                      struct the_nilfs *nilfs,
728                                      char *buf)
729 {
730         time64_t sbwtime;
731 
732         down_read(&nilfs->ns_sem);
733         sbwtime = nilfs->ns_sbwtime;
734         up_read(&nilfs->ns_sem);
735 
736         return NILFS_SHOW_TIME(sbwtime, buf);
737 }
738 
739 static ssize_t
740 nilfs_superblock_sb_write_time_secs_show(struct nilfs_superblock_attr *attr,
741                                          struct the_nilfs *nilfs,
742                                          char *buf)
743 {
744         time64_t sbwtime;
745 
746         down_read(&nilfs->ns_sem);
747         sbwtime = nilfs->ns_sbwtime;
748         up_read(&nilfs->ns_sem);
749 
750         return snprintf(buf, PAGE_SIZE, "%llu\n", sbwtime);
751 }
752 
753 static ssize_t
754 nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr,
755                                       struct the_nilfs *nilfs,
756                                       char *buf)
757 {
758         unsigned int sbwcount;
759 
760         down_read(&nilfs->ns_sem);
761         sbwcount = nilfs->ns_sbwcount;
762         up_read(&nilfs->ns_sem);
763 
764         return snprintf(buf, PAGE_SIZE, "%u\n", sbwcount);
765 }
766 
767 static ssize_t
768 nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr,
769                                             struct the_nilfs *nilfs,
770                                             char *buf)
771 {
772         unsigned int sb_update_freq;
773 
774         down_read(&nilfs->ns_sem);
775         sb_update_freq = nilfs->ns_sb_update_freq;
776         up_read(&nilfs->ns_sem);
777 
778         return snprintf(buf, PAGE_SIZE, "%u\n", sb_update_freq);
779 }
780 
781 static ssize_t
782 nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr,
783                                             struct the_nilfs *nilfs,
784                                             const char *buf, size_t count)
785 {
786         unsigned int val;
787         int err;
788 
789         err = kstrtouint(skip_spaces(buf), 0, &val);
790         if (err) {
791                 nilfs_msg(nilfs->ns_sb, KERN_ERR,
792                           "unable to convert string: err=%d", err);
793                 return err;
794         }
795 
796         if (val < NILFS_SB_FREQ) {
797                 val = NILFS_SB_FREQ;
798                 nilfs_msg(nilfs->ns_sb, KERN_WARNING,
799                           "superblock update frequency cannot be lesser than 10 seconds");
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                 nilfs_msg(sb, KERN_ERR,
1003                           "unable to allocate memory for device group");
1004                 goto failed_create_device_group;
1005         }
1006 
1007         nilfs->ns_dev_kobj.kset = nilfs_kset;
1008         init_completion(&nilfs->ns_dev_kobj_unregister);
1009         err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL,
1010                                     "%s", sb->s_id);
1011         if (err)
1012                 goto free_dev_subgroups;
1013 
1014         err = nilfs_sysfs_create_mounted_snapshots_group(nilfs);
1015         if (err)
1016                 goto cleanup_dev_kobject;
1017 
1018         err = nilfs_sysfs_create_checkpoints_group(nilfs);
1019         if (err)
1020                 goto delete_mounted_snapshots_group;
1021 
1022         err = nilfs_sysfs_create_segments_group(nilfs);
1023         if (err)
1024                 goto delete_checkpoints_group;
1025 
1026         err = nilfs_sysfs_create_superblock_group(nilfs);
1027         if (err)
1028                 goto delete_segments_group;
1029 
1030         err = nilfs_sysfs_create_segctor_group(nilfs);
1031         if (err)
1032                 goto delete_superblock_group;
1033 
1034         return 0;
1035 
1036 delete_superblock_group:
1037         nilfs_sysfs_delete_superblock_group(nilfs);
1038 
1039 delete_segments_group:
1040         nilfs_sysfs_delete_segments_group(nilfs);
1041 
1042 delete_checkpoints_group:
1043         nilfs_sysfs_delete_checkpoints_group(nilfs);
1044 
1045 delete_mounted_snapshots_group:
1046         nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1047 
1048 cleanup_dev_kobject:
1049         kobject_del(&nilfs->ns_dev_kobj);
1050 
1051 free_dev_subgroups:
1052         kfree(nilfs->ns_dev_subgroups);
1053 
1054 failed_create_device_group:
1055         return err;
1056 }
1057 
1058 void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs)
1059 {
1060         nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1061         nilfs_sysfs_delete_checkpoints_group(nilfs);
1062         nilfs_sysfs_delete_segments_group(nilfs);
1063         nilfs_sysfs_delete_superblock_group(nilfs);
1064         nilfs_sysfs_delete_segctor_group(nilfs);
1065         kobject_del(&nilfs->ns_dev_kobj);
1066         kfree(nilfs->ns_dev_subgroups);
1067 }
1068 
1069 /************************************************************************
1070  *                        NILFS feature attrs                           *
1071  ************************************************************************/
1072 
1073 static ssize_t nilfs_feature_revision_show(struct kobject *kobj,
1074                                             struct attribute *attr, char *buf)
1075 {
1076         return snprintf(buf, PAGE_SIZE, "%d.%d\n",
1077                         NILFS_CURRENT_REV, NILFS_MINOR_REV);
1078 }
1079 
1080 static const char features_readme_str[] =
1081         "The features group contains attributes that describe NILFS file\n"
1082         "system driver features.\n\n"
1083         "(1) revision\n\tshow current revision of NILFS file system driver.\n";
1084 
1085 static ssize_t nilfs_feature_README_show(struct kobject *kobj,
1086                                          struct attribute *attr,
1087                                          char *buf)
1088 {
1089         return snprintf(buf, PAGE_SIZE, features_readme_str);
1090 }
1091 
1092 NILFS_FEATURE_RO_ATTR(revision);
1093 NILFS_FEATURE_RO_ATTR(README);
1094 
1095 static struct attribute *nilfs_feature_attrs[] = {
1096         NILFS_FEATURE_ATTR_LIST(revision),
1097         NILFS_FEATURE_ATTR_LIST(README),
1098         NULL,
1099 };
1100 
1101 static const struct attribute_group nilfs_feature_attr_group = {
1102         .name = "features",
1103         .attrs = nilfs_feature_attrs,
1104 };
1105 
1106 int __init nilfs_sysfs_init(void)
1107 {
1108         int err;
1109 
1110         nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj);
1111         if (!nilfs_kset) {
1112                 err = -ENOMEM;
1113                 nilfs_msg(NULL, KERN_ERR,
1114                           "unable to create sysfs entry: err=%d", err);
1115                 goto failed_sysfs_init;
1116         }
1117 
1118         err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1119         if (unlikely(err)) {
1120                 nilfs_msg(NULL, KERN_ERR,
1121                           "unable to create feature group: err=%d", err);
1122                 goto cleanup_sysfs_init;
1123         }
1124 
1125         return 0;
1126 
1127 cleanup_sysfs_init:
1128         kset_unregister(nilfs_kset);
1129 
1130 failed_sysfs_init:
1131         return err;
1132 }
1133 
1134 void nilfs_sysfs_exit(void)
1135 {
1136         sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1137         kset_unregister(nilfs_kset);
1138 }
1139 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp