fs/nilfs2/sysfs.c

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