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