fs/nilfs2/sysfs.c

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