fs/nilfs2/sysfs.c

   1 /*
   2  * sysfs.c - sysfs support implementation.
   3  *
   4  * Copyright (C) 2005-2014 Nippon Telegraph and Telephone Corporation.
   5  * Copyright (C) 2014 HGST, Inc., a Western Digital Company.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * Written by Vyacheslav Dubeyko <Vyacheslav.Dubeyko@hgst.com>
  18  */
  19
  20 #include <linux/kobject.h>
  21
  22 #include "nilfs.h"
  23 #include "mdt.h"
  24 #include "sufile.h"
  25 #include "cpfile.h"
  26 #include "sysfs.h"
  27
  28 /* /sys/fs/<nilfs>/ */
  29 static struct kset *nilfs_kset;
  30
  31 #define NILFS_SHOW_TIME(time_t_val, buf) ({ \
  32                 struct tm res; \
  33                 int count = 0; \
  34                 time_to_tm(time_t_val, 0, &res); \
  35                 res.tm_year += 1900; \
  36                 res.tm_mon += 1; \
  37                 count = scnprintf(buf, PAGE_SIZE, \
  38                                     "%ld-%.2d-%.2d %.2d:%.2d:%.2d\n", \
  39                                     res.tm_year, res.tm_mon, res.tm_mday, \
  40                                     res.tm_hour, res.tm_min, res.tm_sec);\
  41                 count; \
  42 })
  43
  44 #define NILFS_DEV_INT_GROUP_OPS(name, parent_name) \
  45 static ssize_t nilfs_##name##_attr_show(struct kobject *kobj, \
  46                                         struct attribute *attr, char *buf) \
  47 { \
  48         struct the_nilfs *nilfs = container_of(kobj->parent, \
  49                                                 struct the_nilfs, \
  50                                                 ns_##parent_name##_kobj); \
  51         struct nilfs_##name##_attr *a = container_of(attr, \
  52                                                 struct nilfs_##name##_attr, \
  53                                                 attr); \
  54         return a->show ? a->show(a, nilfs, buf) : 0; \
  55 } \
  56 static ssize_t nilfs_##name##_attr_store(struct kobject *kobj, \
  57                                          struct attribute *attr, \
  58                                          const char *buf, size_t len) \
  59 { \
  60         struct the_nilfs *nilfs = container_of(kobj->parent, \
  61                                                 struct the_nilfs, \
  62                                                 ns_##parent_name##_kobj); \
  63         struct nilfs_##name##_attr *a = container_of(attr, \
  64                                                 struct nilfs_##name##_attr, \
  65                                                 attr); \
  66         return a->store ? a->store(a, nilfs, buf, len) : 0; \
  67 } \
  68 static const struct sysfs_ops nilfs_##name##_attr_ops = { \
  69         .show   = nilfs_##name##_attr_show, \
  70         .store  = nilfs_##name##_attr_store, \
  71 }
  72
  73 #define NILFS_DEV_INT_GROUP_TYPE(name, parent_name) \
  74 static void nilfs_##name##_attr_release(struct kobject *kobj) \
  75 { \
  76         struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \
  77         struct the_nilfs *nilfs = container_of(kobj->parent, \
  78                                                 struct the_nilfs, \
  79                                                 ns_##parent_name##_kobj); \
  80         subgroups = nilfs->ns_##parent_name##_subgroups; \
  81         complete(&subgroups->sg_##name##_kobj_unregister); \
  82 } \
  83 static struct kobj_type nilfs_##name##_ktype = { \
  84         .default_attrs  = nilfs_##name##_attrs, \
  85         .sysfs_ops      = &nilfs_##name##_attr_ops, \
  86         .release        = nilfs_##name##_attr_release, \
  87 }
  88
  89 #define NILFS_DEV_INT_GROUP_FNS(name, parent_name) \
  90 static int nilfs_sysfs_create_##name##_group(struct the_nilfs *nilfs) \
  91 { \
  92         struct kobject *parent; \
  93         struct kobject *kobj; \
  94         struct completion *kobj_unregister; \
  95         struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \
  96         int err; \
  97         subgroups = nilfs->ns_##parent_name##_subgroups; \
  98         kobj = &subgroups->sg_##name##_kobj; \
  99         kobj_unregister = &subgroups->sg_##name##_kobj_unregister; \
 100         parent = &nilfs->ns_##parent_name##_kobj; \
 101         kobj->kset = nilfs_kset; \
 102         init_completion(kobj_unregister); \
 103         err = kobject_init_and_add(kobj, &nilfs_##name##_ktype, parent, \
 104                                     #name); \
 105         if (err) \
 106                 return err; \
 107         return 0; \
 108 } \
 109 static void nilfs_sysfs_delete_##name##_group(struct the_nilfs *nilfs) \
 110 { \
 111         kobject_del(&nilfs->ns_##parent_name##_subgroups->sg_##name##_kobj); \
 112 }
 113
 114 /************************************************************************
 115  *                        NILFS snapshot attrs                          *
 116  ************************************************************************/
 117
 118 static ssize_t
 119 nilfs_snapshot_inodes_count_show(struct nilfs_snapshot_attr *attr,
 120                                  struct nilfs_root *root, char *buf)
 121 {
 122         return snprintf(buf, PAGE_SIZE, "%llu\n",
 123                         (unsigned long long)atomic64_read(&root->inodes_count));
 124 }
 125
 126 static ssize_t
 127 nilfs_snapshot_blocks_count_show(struct nilfs_snapshot_attr *attr,
 128                                  struct nilfs_root *root, char *buf)
 129 {
 130         return snprintf(buf, PAGE_SIZE, "%llu\n",
 131                         (unsigned long long)atomic64_read(&root->blocks_count));
 132 }
 133
 134 static const char snapshot_readme_str[] =
 135         "The group contains details about mounted snapshot.\n\n"
 136         "(1) inodes_count\n\tshow number of inodes for snapshot.\n\n"
 137         "(2) blocks_count\n\tshow number of blocks for snapshot.\n\n";
 138
 139 static ssize_t
 140 nilfs_snapshot_README_show(struct nilfs_snapshot_attr *attr,
 141                             struct nilfs_root *root, char *buf)
 142 {
 143         return snprintf(buf, PAGE_SIZE, snapshot_readme_str);
 144 }
 145
 146 NILFS_SNAPSHOT_RO_ATTR(inodes_count);
 147 NILFS_SNAPSHOT_RO_ATTR(blocks_count);
 148 NILFS_SNAPSHOT_RO_ATTR(README);
 149
 150 static struct attribute *nilfs_snapshot_attrs[] = {
 151         NILFS_SNAPSHOT_ATTR_LIST(inodes_count),
 152         NILFS_SNAPSHOT_ATTR_LIST(blocks_count),
 153         NILFS_SNAPSHOT_ATTR_LIST(README),
 154         NULL,
 155 };
 156
 157 static ssize_t nilfs_snapshot_attr_show(struct kobject *kobj,
 158                                         struct attribute *attr, char *buf)
 159 {
 160         struct nilfs_root *root =
 161                         container_of(kobj, struct nilfs_root, snapshot_kobj);
 162         struct nilfs_snapshot_attr *a =
 163                         container_of(attr, struct nilfs_snapshot_attr, attr);
 164
 165         return a->show ? a->show(a, root, buf) : 0;
 166 }
 167
 168 static ssize_t nilfs_snapshot_attr_store(struct kobject *kobj,
 169                                          struct attribute *attr,
 170                                          const char *buf, size_t len)
 171 {
 172         struct nilfs_root *root =
 173                         container_of(kobj, struct nilfs_root, snapshot_kobj);
 174         struct nilfs_snapshot_attr *a =
 175                         container_of(attr, struct nilfs_snapshot_attr, attr);
 176
 177         return a->store ? a->store(a, root, buf, len) : 0;
 178 }
 179
 180 static void nilfs_snapshot_attr_release(struct kobject *kobj)
 181 {
 182         struct nilfs_root *root = container_of(kobj, struct nilfs_root,
 183                                                 snapshot_kobj);
 184         complete(&root->snapshot_kobj_unregister);
 185 }
 186
 187 static const struct sysfs_ops nilfs_snapshot_attr_ops = {
 188         .show   = nilfs_snapshot_attr_show,
 189         .store  = nilfs_snapshot_attr_store,
 190 };
 191
 192 static struct kobj_type nilfs_snapshot_ktype = {
 193         .default_attrs  = nilfs_snapshot_attrs,
 194         .sysfs_ops      = &nilfs_snapshot_attr_ops,
 195         .release        = nilfs_snapshot_attr_release,
 196 };
 197
 198 int nilfs_sysfs_create_snapshot_group(struct nilfs_root *root)
 199 {
 200         struct the_nilfs *nilfs;
 201         struct kobject *parent;
 202         int err;
 203
 204         nilfs = root->nilfs;
 205         parent = &nilfs->ns_dev_subgroups->sg_mounted_snapshots_kobj;
 206         root->snapshot_kobj.kset = nilfs_kset;
 207         init_completion(&root->snapshot_kobj_unregister);
 208
 209         if (root->cno == NILFS_CPTREE_CURRENT_CNO) {
 210                 err = kobject_init_and_add(&root->snapshot_kobj,
 211                                             &nilfs_snapshot_ktype,
 212                                             &nilfs->ns_dev_kobj,
 213                                             "current_checkpoint");
 214         } else {
 215                 err = kobject_init_and_add(&root->snapshot_kobj,
 216                                             &nilfs_snapshot_ktype,
 217                                             parent,
 218                                             "%llu", root->cno);
 219         }
 220
 221         if (err)
 222                 return err;
 223
 224         return 0;
 225 }
 226
 227 void nilfs_sysfs_delete_snapshot_group(struct nilfs_root *root)
 228 {
 229         kobject_del(&root->snapshot_kobj);
 230 }
 231
 232 /************************************************************************
 233  *                    NILFS mounted snapshots attrs                     *
 234  ************************************************************************/
 235
 236 static const char mounted_snapshots_readme_str[] =
 237         "The mounted_snapshots group contains group for\n"
 238         "every mounted snapshot.\n";
 239
 240 static ssize_t
 241 nilfs_mounted_snapshots_README_show(struct nilfs_mounted_snapshots_attr *attr,
 242                                     struct the_nilfs *nilfs, char *buf)
 243 {
 244         return snprintf(buf, PAGE_SIZE, mounted_snapshots_readme_str);
 245 }
 246
 247 NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README);
 248
 249 static struct attribute *nilfs_mounted_snapshots_attrs[] = {
 250         NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README),
 251         NULL,
 252 };
 253
 254 NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev);
 255 NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev);
 256 NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev);
 257
 258 /************************************************************************
 259  *                      NILFS checkpoints attrs                         *
 260  ************************************************************************/
 261
 262 static ssize_t
 263 nilfs_checkpoints_checkpoints_number_show(struct nilfs_checkpoints_attr *attr,
 264                                             struct the_nilfs *nilfs,
 265                                             char *buf)
 266 {
 267         __u64 ncheckpoints;
 268         struct nilfs_cpstat cpstat;
 269         int err;
 270
 271         down_read(&nilfs->ns_segctor_sem);
 272         err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat);
 273         up_read(&nilfs->ns_segctor_sem);
 274         if (err < 0) {
 275                 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         time_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         time_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", (unsigned long long)ctime);
 603 }
 604
 605 static ssize_t
 606 nilfs_segctor_last_nongc_write_time_show(struct nilfs_segctor_attr *attr,
 607                                          struct the_nilfs *nilfs,
 608                                          char *buf)
 609 {
 610         time_t nongc_ctime;
 611
 612         down_read(&nilfs->ns_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         time_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",
 631                         (unsigned long long)nongc_ctime);
 632 }
 633
 634 static ssize_t
 635 nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr,
 636                                             struct the_nilfs *nilfs,
 637                                             char *buf)
 638 {
 639         u32 ndirtyblks;
 640
 641         down_read(&nilfs->ns_segctor_sem);
 642         ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks);
 643         up_read(&nilfs->ns_segctor_sem);
 644
 645         return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks);
 646 }
 647
 648 static const char segctor_readme_str[] =
 649         "The segctor group contains attributes that describe\n"
 650         "segctor thread activity details.\n\n"
 651         "(1) last_pseg_block\n"
 652         "\tshow start block number of the latest segment.\n\n"
 653         "(2) last_seg_sequence\n"
 654         "\tshow sequence value of the latest segment.\n\n"
 655         "(3) last_seg_checkpoint\n"
 656         "\tshow checkpoint number of the latest segment.\n\n"
 657         "(4) current_seg_sequence\n\tshow segment sequence counter.\n\n"
 658         "(5) current_last_full_seg\n"
 659         "\tshow index number of the latest full segment.\n\n"
 660         "(6) next_full_seg\n"
 661         "\tshow index number of the full segment index to be used next.\n\n"
 662         "(7) next_pseg_offset\n"
 663         "\tshow offset of next partial segment in the current full segment.\n\n"
 664         "(8) next_checkpoint\n\tshow next checkpoint number.\n\n"
 665         "(9) last_seg_write_time\n"
 666         "\tshow write time of the last segment in human-readable format.\n\n"
 667         "(10) last_seg_write_time_secs\n"
 668         "\tshow write time of the last segment in seconds.\n\n"
 669         "(11) last_nongc_write_time\n"
 670         "\tshow write time of the last segment not for cleaner operation "
 671         "in human-readable format.\n\n"
 672         "(12) last_nongc_write_time_secs\n"
 673         "\tshow write time of the last segment not for cleaner operation "
 674         "in seconds.\n\n"
 675         "(13) dirty_data_blocks_count\n"
 676         "\tshow number of dirty data blocks.\n\n";
 677
 678 static ssize_t
 679 nilfs_segctor_README_show(struct nilfs_segctor_attr *attr,
 680                           struct the_nilfs *nilfs, char *buf)
 681 {
 682         return snprintf(buf, PAGE_SIZE, segctor_readme_str);
 683 }
 684
 685 NILFS_SEGCTOR_RO_ATTR(last_pseg_block);
 686 NILFS_SEGCTOR_RO_ATTR(last_seg_sequence);
 687 NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint);
 688 NILFS_SEGCTOR_RO_ATTR(current_seg_sequence);
 689 NILFS_SEGCTOR_RO_ATTR(current_last_full_seg);
 690 NILFS_SEGCTOR_RO_ATTR(next_full_seg);
 691 NILFS_SEGCTOR_RO_ATTR(next_pseg_offset);
 692 NILFS_SEGCTOR_RO_ATTR(next_checkpoint);
 693 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time);
 694 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs);
 695 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time);
 696 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs);
 697 NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count);
 698 NILFS_SEGCTOR_RO_ATTR(README);
 699
 700 static struct attribute *nilfs_segctor_attrs[] = {
 701         NILFS_SEGCTOR_ATTR_LIST(last_pseg_block),
 702         NILFS_SEGCTOR_ATTR_LIST(last_seg_sequence),
 703         NILFS_SEGCTOR_ATTR_LIST(last_seg_checkpoint),
 704         NILFS_SEGCTOR_ATTR_LIST(current_seg_sequence),
 705         NILFS_SEGCTOR_ATTR_LIST(current_last_full_seg),
 706         NILFS_SEGCTOR_ATTR_LIST(next_full_seg),
 707         NILFS_SEGCTOR_ATTR_LIST(next_pseg_offset),
 708         NILFS_SEGCTOR_ATTR_LIST(next_checkpoint),
 709         NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time),
 710         NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time_secs),
 711         NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time),
 712         NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time_secs),
 713         NILFS_SEGCTOR_ATTR_LIST(dirty_data_blocks_count),
 714         NILFS_SEGCTOR_ATTR_LIST(README),
 715         NULL,
 716 };
 717
 718 NILFS_DEV_INT_GROUP_OPS(segctor, dev);
 719 NILFS_DEV_INT_GROUP_TYPE(segctor, dev);
 720 NILFS_DEV_INT_GROUP_FNS(segctor, dev);
 721
 722 /************************************************************************
 723  *                        NILFS superblock attrs                        *
 724  ************************************************************************/
 725
 726 static ssize_t
 727 nilfs_superblock_sb_write_time_show(struct nilfs_superblock_attr *attr,
 728                                      struct the_nilfs *nilfs,
 729                                      char *buf)
 730 {
 731         time_t sbwtime;
 732
 733         down_read(&nilfs->ns_sem);
 734         sbwtime = nilfs->ns_sbwtime;
 735         up_read(&nilfs->ns_sem);
 736
 737         return NILFS_SHOW_TIME(sbwtime, buf);
 738 }
 739
 740 static ssize_t
 741 nilfs_superblock_sb_write_time_secs_show(struct nilfs_superblock_attr *attr,
 742                                          struct the_nilfs *nilfs,
 743                                          char *buf)
 744 {
 745         time_t sbwtime;
 746
 747         down_read(&nilfs->ns_sem);
 748         sbwtime = nilfs->ns_sbwtime;
 749         up_read(&nilfs->ns_sem);
 750
 751         return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)sbwtime);
 752 }
 753
 754 static ssize_t
 755 nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr,
 756                                       struct the_nilfs *nilfs,
 757                                       char *buf)
 758 {
 759         unsigned int sbwcount;
 760
 761         down_read(&nilfs->ns_sem);
 762         sbwcount = nilfs->ns_sbwcount;
 763         up_read(&nilfs->ns_sem);
 764
 765         return snprintf(buf, PAGE_SIZE, "%u\n", sbwcount);
 766 }
 767
 768 static ssize_t
 769 nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr,
 770                                             struct the_nilfs *nilfs,
 771                                             char *buf)
 772 {
 773         unsigned int sb_update_freq;
 774
 775         down_read(&nilfs->ns_sem);
 776         sb_update_freq = nilfs->ns_sb_update_freq;
 777         up_read(&nilfs->ns_sem);
 778
 779         return snprintf(buf, PAGE_SIZE, "%u\n", sb_update_freq);
 780 }
 781
 782 static ssize_t
 783 nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr,
 784                                             struct the_nilfs *nilfs,
 785                                             const char *buf, size_t count)
 786 {
 787         unsigned int val;
 788         int err;
 789
 790         err = kstrtouint(skip_spaces(buf), 0, &val);
 791         if (err) {
 792                 nilfs_msg(nilfs->ns_sb, KERN_ERR,
 793                           "unable to convert string: err=%d", err);
 794                 return err;
 795         }
 796
 797         if (val < NILFS_SB_FREQ) {
 798                 val = NILFS_SB_FREQ;
 799                 nilfs_msg(nilfs->ns_sb, KERN_WARNING,
 800                           "superblock update frequency cannot be lesser than 10 seconds");
 801         }
 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
 810 static 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
 823 static ssize_t
 824 nilfs_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
 830 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time);
 831 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs);
 832 NILFS_SUPERBLOCK_RO_ATTR(sb_write_count);
 833 NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency);
 834 NILFS_SUPERBLOCK_RO_ATTR(README);
 835
 836 static 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
 845 NILFS_DEV_INT_GROUP_OPS(superblock, dev);
 846 NILFS_DEV_INT_GROUP_TYPE(superblock, dev);
 847 NILFS_DEV_INT_GROUP_FNS(superblock, dev);
 848
 849 /************************************************************************
 850  *                        NILFS device attrs                            *
 851  ************************************************************************/
 852
 853 static
 854 ssize_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
 865 static
 866 ssize_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
 873 static
 874 ssize_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
 884 static
 885 ssize_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
 896 static
 897 ssize_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
 906 static
 907 ssize_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
 917 static 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
 927 static 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
 934 NILFS_DEV_RO_ATTR(revision);
 935 NILFS_DEV_RO_ATTR(blocksize);
 936 NILFS_DEV_RO_ATTR(device_size);
 937 NILFS_DEV_RO_ATTR(free_blocks);
 938 NILFS_DEV_RO_ATTR(uuid);
 939 NILFS_DEV_RO_ATTR(volume_name);
 940 NILFS_DEV_RO_ATTR(README);
 941
 942 static 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
 953 static 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
 964 static 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
 976 static 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
 983 static const struct sysfs_ops nilfs_dev_attr_ops = {
 984         .show   = nilfs_dev_attr_show,
 985         .store  = nilfs_dev_attr_store,
 986 };
 987
 988 static 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
 994 int nilfs_sysfs_create_device_group(struct super_block *sb)
 995 {
 996         struct the_nilfs *nilfs = sb->s_fs_info;
 997         size_t devgrp_size = sizeof(struct nilfs_sysfs_dev_subgroups);
 998         int err;
 999
1000         nilfs->ns_dev_subgroups = kzalloc(devgrp_size, GFP_KERNEL);
1001         if (unlikely(!nilfs->ns_dev_subgroups)) {
1002                 err = -ENOMEM;
1003                 nilfs_msg(sb, KERN_ERR,
1004                           "unable to allocate memory for device group");
1005                 goto failed_create_device_group;
1006         }
1007
1008         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)
1013                 goto free_dev_subgroups;
1014
1015         err = nilfs_sysfs_create_mounted_snapshots_group(nilfs);
1016         if (err)
1017                 goto cleanup_dev_kobject;
1018
1019         err = nilfs_sysfs_create_checkpoints_group(nilfs);
1020         if (err)
1021                 goto delete_mounted_snapshots_group;
1022
1023         err = nilfs_sysfs_create_segments_group(nilfs);
1024         if (err)
1025                 goto delete_checkpoints_group;
1026
1027         err = nilfs_sysfs_create_superblock_group(nilfs);
1028         if (err)
1029                 goto delete_segments_group;
1030
1031         err = nilfs_sysfs_create_segctor_group(nilfs);
1032         if (err)
1033                 goto delete_superblock_group;
1034
1035         return 0;
1036
1037 delete_superblock_group:
1038         nilfs_sysfs_delete_superblock_group(nilfs);
1039
1040 delete_segments_group:
1041         nilfs_sysfs_delete_segments_group(nilfs);
1042
1043 delete_checkpoints_group:
1044         nilfs_sysfs_delete_checkpoints_group(nilfs);
1045
1046 delete_mounted_snapshots_group:
1047         nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1048
1049 cleanup_dev_kobject:
1050         kobject_del(&nilfs->ns_dev_kobj);
1051
1052 free_dev_subgroups:
1053         kfree(nilfs->ns_dev_subgroups);
1054
1055 failed_create_device_group:
1056         return err;
1057 }
1058
1059 void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs)
1060 {
1061         nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1062         nilfs_sysfs_delete_checkpoints_group(nilfs);
1063         nilfs_sysfs_delete_segments_group(nilfs);
1064         nilfs_sysfs_delete_superblock_group(nilfs);
1065         nilfs_sysfs_delete_segctor_group(nilfs);
1066         kobject_del(&nilfs->ns_dev_kobj);
1067         kfree(nilfs->ns_dev_subgroups);
1068 }
1069
1070 /************************************************************************
1071  *                        NILFS feature attrs                           *
1072  ************************************************************************/
1073
1074 static ssize_t nilfs_feature_revision_show(struct kobject *kobj,
1075                                             struct attribute *attr, char *buf)
1076 {
1077         return snprintf(buf, PAGE_SIZE, "%d.%d\n",
1078                         NILFS_CURRENT_REV, NILFS_MINOR_REV);
1079 }
1080
1081 static const char features_readme_str[] =
1082         "The features group contains attributes that describe NILFS file\n"
1083         "system driver features.\n\n"
1084         "(1) revision\n\tshow current revision of NILFS file system driver.\n";
1085
1086 static ssize_t nilfs_feature_README_show(struct kobject *kobj,
1087                                          struct attribute *attr,
1088                                          char *buf)
1089 {
1090         return snprintf(buf, PAGE_SIZE, features_readme_str);
1091 }
1092
1093 NILFS_FEATURE_RO_ATTR(revision);
1094 NILFS_FEATURE_RO_ATTR(README);
1095
1096 static struct attribute *nilfs_feature_attrs[] = {
1097         NILFS_FEATURE_ATTR_LIST(revision),
1098         NILFS_FEATURE_ATTR_LIST(README),
1099         NULL,
1100 };
1101
1102 static const struct attribute_group nilfs_feature_attr_group = {
1103         .name = "features",
1104         .attrs = nilfs_feature_attrs,
1105 };
1106
1107 int __init nilfs_sysfs_init(void)
1108 {
1109         int err;
1110
1111         nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj);
1112         if (!nilfs_kset) {
1113                 err = -ENOMEM;
1114                 nilfs_msg(NULL, KERN_ERR,
1115                           "unable to create sysfs entry: err=%d", err);
1116                 goto failed_sysfs_init;
1117         }
1118
1119         err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1120         if (unlikely(err)) {
1121                 nilfs_msg(NULL, KERN_ERR,
1122                           "unable to create feature group: err=%d", err);
1123                 goto cleanup_sysfs_init;
1124         }
1125
1126         return 0;
1127
1128 cleanup_sysfs_init:
1129         kset_unregister(nilfs_kset);
1130
1131 failed_sysfs_init:
1132         return err;
1133 }
1134
1135 void nilfs_sysfs_exit(void)
1136 {
1137         sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1138         kset_unregister(nilfs_kset);
1139 }