linux/fs/nilfs2/sysfs.c
<<
>>
Prefs
   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>/ */
  20static struct kset *nilfs_kset;
  21
  22#define NILFS_DEV_INT_GROUP_OPS(name, parent_name) \
  23static 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} \
  34static 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} \
  46static 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) \
  52static 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} \
  59static 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) \
  66static 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} \
  85static 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
  94static ssize_t
  95nilfs_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
 102static ssize_t
 103nilfs_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
 110static 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
 115static ssize_t
 116nilfs_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
 122NILFS_SNAPSHOT_RO_ATTR(inodes_count);
 123NILFS_SNAPSHOT_RO_ATTR(blocks_count);
 124NILFS_SNAPSHOT_RO_ATTR(README);
 125
 126static 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
 133static 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
 144static 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
 156static 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
 163static const struct sysfs_ops nilfs_snapshot_attr_ops = {
 164        .show   = nilfs_snapshot_attr_show,
 165        .store  = nilfs_snapshot_attr_store,
 166};
 167
 168static 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
 174int 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
 203void 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
 212static const char mounted_snapshots_readme_str[] =
 213        "The mounted_snapshots group contains group for\n"
 214        "every mounted snapshot.\n";
 215
 216static ssize_t
 217nilfs_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
 223NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README);
 224
 225static struct attribute *nilfs_mounted_snapshots_attrs[] = {
 226        NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README),
 227        NULL,
 228};
 229
 230NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev);
 231NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev);
 232NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev);
 233
 234/************************************************************************
 235 *                      NILFS checkpoints attrs                         *
 236 ************************************************************************/
 237
 238static ssize_t
 239nilfs_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
 261static ssize_t
 262nilfs_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
 284static ssize_t
 285nilfs_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
 298static ssize_t
 299nilfs_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
 312static 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
 321static ssize_t
 322nilfs_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
 328NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number);
 329NILFS_CHECKPOINTS_RO_ATTR(snapshots_number);
 330NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint);
 331NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint);
 332NILFS_CHECKPOINTS_RO_ATTR(README);
 333
 334static 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
 343NILFS_DEV_INT_GROUP_OPS(checkpoints, dev);
 344NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev);
 345NILFS_DEV_INT_GROUP_FNS(checkpoints, dev);
 346
 347/************************************************************************
 348 *                        NILFS segments attrs                          *
 349 ************************************************************************/
 350
 351static ssize_t
 352nilfs_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
 359static ssize_t
 360nilfs_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
 367static ssize_t
 368nilfs_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
 381static ssize_t
 382nilfs_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
 401static 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
 409static ssize_t
 410nilfs_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
 417NILFS_SEGMENTS_RO_ATTR(segments_number);
 418NILFS_SEGMENTS_RO_ATTR(blocks_per_segment);
 419NILFS_SEGMENTS_RO_ATTR(clean_segments);
 420NILFS_SEGMENTS_RO_ATTR(dirty_segments);
 421NILFS_SEGMENTS_RO_ATTR(README);
 422
 423static 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
 432NILFS_DEV_INT_GROUP_OPS(segments, dev);
 433NILFS_DEV_INT_GROUP_TYPE(segments, dev);
 434NILFS_DEV_INT_GROUP_FNS(segments, dev);
 435
 436/************************************************************************
 437 *                        NILFS segctor attrs                           *
 438 ************************************************************************/
 439
 440static ssize_t
 441nilfs_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
 455static ssize_t
 456nilfs_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
 469static ssize_t
 470nilfs_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
 483static ssize_t
 484nilfs_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
 497static ssize_t
 498nilfs_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
 511static ssize_t
 512nilfs_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
 525static ssize_t
 526nilfs_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
 539static ssize_t
 540nilfs_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
 553static ssize_t
 554nilfs_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
 567static ssize_t
 568nilfs_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
 581static ssize_t
 582nilfs_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
 595static ssize_t
 596nilfs_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
 609static ssize_t
 610nilfs_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
 623static 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
 653static ssize_t
 654nilfs_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
 660NILFS_SEGCTOR_RO_ATTR(last_pseg_block);
 661NILFS_SEGCTOR_RO_ATTR(last_seg_sequence);
 662NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint);
 663NILFS_SEGCTOR_RO_ATTR(current_seg_sequence);
 664NILFS_SEGCTOR_RO_ATTR(current_last_full_seg);
 665NILFS_SEGCTOR_RO_ATTR(next_full_seg);
 666NILFS_SEGCTOR_RO_ATTR(next_pseg_offset);
 667NILFS_SEGCTOR_RO_ATTR(next_checkpoint);
 668NILFS_SEGCTOR_RO_ATTR(last_seg_write_time);
 669NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs);
 670NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time);
 671NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs);
 672NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count);
 673NILFS_SEGCTOR_RO_ATTR(README);
 674
 675static 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
 693NILFS_DEV_INT_GROUP_OPS(segctor, dev);
 694NILFS_DEV_INT_GROUP_TYPE(segctor, dev);
 695NILFS_DEV_INT_GROUP_FNS(segctor, dev);
 696
 697/************************************************************************
 698 *                        NILFS superblock attrs                        *
 699 ************************************************************************/
 700
 701static ssize_t
 702nilfs_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
 715static ssize_t
 716nilfs_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
 729static ssize_t
 730nilfs_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
 743static ssize_t
 744nilfs_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
 757static ssize_t
 758nilfs_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
 785static 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
 798static ssize_t
 799nilfs_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
 805NILFS_SUPERBLOCK_RO_ATTR(sb_write_time);
 806NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs);
 807NILFS_SUPERBLOCK_RO_ATTR(sb_write_count);
 808NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency);
 809NILFS_SUPERBLOCK_RO_ATTR(README);
 810
 811static 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
 820NILFS_DEV_INT_GROUP_OPS(superblock, dev);
 821NILFS_DEV_INT_GROUP_TYPE(superblock, dev);
 822NILFS_DEV_INT_GROUP_FNS(superblock, dev);
 823
 824/************************************************************************
 825 *                        NILFS device attrs                            *
 826 ************************************************************************/
 827
 828static
 829ssize_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
 840static
 841ssize_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
 848static
 849ssize_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
 859static
 860ssize_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
 871static
 872ssize_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
 881static
 882ssize_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
 892static 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
 902static 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
 909NILFS_DEV_RO_ATTR(revision);
 910NILFS_DEV_RO_ATTR(blocksize);
 911NILFS_DEV_RO_ATTR(device_size);
 912NILFS_DEV_RO_ATTR(free_blocks);
 913NILFS_DEV_RO_ATTR(uuid);
 914NILFS_DEV_RO_ATTR(volume_name);
 915NILFS_DEV_RO_ATTR(README);
 916
 917static 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
 928static 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
 939static 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
 951static 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
 958static const struct sysfs_ops nilfs_dev_attr_ops = {
 959        .show   = nilfs_dev_attr_show,
 960        .store  = nilfs_dev_attr_store,
 961};
 962
 963static 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
 969int 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
1011delete_superblock_group:
1012        nilfs_sysfs_delete_superblock_group(nilfs);
1013
1014delete_segments_group:
1015        nilfs_sysfs_delete_segments_group(nilfs);
1016
1017delete_checkpoints_group:
1018        nilfs_sysfs_delete_checkpoints_group(nilfs);
1019
1020delete_mounted_snapshots_group:
1021        nilfs_sysfs_delete_mounted_snapshots_group(nilfs);
1022
1023cleanup_dev_kobject:
1024        kobject_put(&nilfs->ns_dev_kobj);
1025        kfree(nilfs->ns_dev_subgroups);
1026
1027failed_create_device_group:
1028        return err;
1029}
1030
1031void 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
1047static 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
1054static 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
1059static 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
1066NILFS_FEATURE_RO_ATTR(revision);
1067NILFS_FEATURE_RO_ATTR(README);
1068
1069static struct attribute *nilfs_feature_attrs[] = {
1070        NILFS_FEATURE_ATTR_LIST(revision),
1071        NILFS_FEATURE_ATTR_LIST(README),
1072        NULL,
1073};
1074
1075static const struct attribute_group nilfs_feature_attr_group = {
1076        .name = "features",
1077        .attrs = nilfs_feature_attrs,
1078};
1079
1080int __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
1099cleanup_sysfs_init:
1100        kset_unregister(nilfs_kset);
1101
1102failed_sysfs_init:
1103        return err;
1104}
1105
1106void nilfs_sysfs_exit(void)
1107{
1108        sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group);
1109        kset_unregister(nilfs_kset);
1110}
1111