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>/ */ 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_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) \ 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 sysfs_emit(buf, "%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 sysfs_emit(buf, "%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 sysfs_emit(buf, 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}; 132ATTRIBUTE_GROUPS(nilfs_snapshot); 133 134static 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 145static 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 157static 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 164static const struct sysfs_ops nilfs_snapshot_attr_ops = { 165 .show = nilfs_snapshot_attr_show, 166 .store = nilfs_snapshot_attr_store, 167}; 168 169static 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 175int 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 204void 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 213static const char mounted_snapshots_readme_str[] = 214 "The mounted_snapshots group contains group for\n" 215 "every mounted snapshot.\n"; 216 217static ssize_t 218nilfs_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 224NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README); 225 226static struct attribute *nilfs_mounted_snapshots_attrs[] = { 227 NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README), 228 NULL, 229}; 230ATTRIBUTE_GROUPS(nilfs_mounted_snapshots); 231 232NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev); 233NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev); 234NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev); 235 236/************************************************************************ 237 * NILFS checkpoints attrs * 238 ************************************************************************/ 239 240static ssize_t 241nilfs_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 263static ssize_t 264nilfs_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 286static ssize_t 287nilfs_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 300static ssize_t 301nilfs_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 314static 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 323static ssize_t 324nilfs_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 330NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number); 331NILFS_CHECKPOINTS_RO_ATTR(snapshots_number); 332NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint); 333NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint); 334NILFS_CHECKPOINTS_RO_ATTR(README); 335 336static 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}; 344ATTRIBUTE_GROUPS(nilfs_checkpoints); 345 346NILFS_DEV_INT_GROUP_OPS(checkpoints, dev); 347NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev); 348NILFS_DEV_INT_GROUP_FNS(checkpoints, dev); 349 350/************************************************************************ 351 * NILFS segments attrs * 352 ************************************************************************/ 353 354static ssize_t 355nilfs_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 362static ssize_t 363nilfs_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 370static ssize_t 371nilfs_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 384static ssize_t 385nilfs_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 404static 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 412static ssize_t 413nilfs_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 420NILFS_SEGMENTS_RO_ATTR(segments_number); 421NILFS_SEGMENTS_RO_ATTR(blocks_per_segment); 422NILFS_SEGMENTS_RO_ATTR(clean_segments); 423NILFS_SEGMENTS_RO_ATTR(dirty_segments); 424NILFS_SEGMENTS_RO_ATTR(README); 425 426static 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}; 434ATTRIBUTE_GROUPS(nilfs_segments); 435 436NILFS_DEV_INT_GROUP_OPS(segments, dev); 437NILFS_DEV_INT_GROUP_TYPE(segments, dev); 438NILFS_DEV_INT_GROUP_FNS(segments, dev); 439 440/************************************************************************ 441 * NILFS segctor attrs * 442 ************************************************************************/ 443 444static ssize_t 445nilfs_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 459static ssize_t 460nilfs_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 473static ssize_t 474nilfs_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 487static ssize_t 488nilfs_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 501static ssize_t 502nilfs_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 515static ssize_t 516nilfs_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 529static ssize_t 530nilfs_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 543static ssize_t 544nilfs_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 557static ssize_t 558nilfs_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 571static ssize_t 572nilfs_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 585static ssize_t 586nilfs_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 599static ssize_t 600nilfs_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 613static ssize_t 614nilfs_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 627static 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 657static ssize_t 658nilfs_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 664NILFS_SEGCTOR_RO_ATTR(last_pseg_block); 665NILFS_SEGCTOR_RO_ATTR(last_seg_sequence); 666NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint); 667NILFS_SEGCTOR_RO_ATTR(current_seg_sequence); 668NILFS_SEGCTOR_RO_ATTR(current_last_full_seg); 669NILFS_SEGCTOR_RO_ATTR(next_full_seg); 670NILFS_SEGCTOR_RO_ATTR(next_pseg_offset); 671NILFS_SEGCTOR_RO_ATTR(next_checkpoint); 672NILFS_SEGCTOR_RO_ATTR(last_seg_write_time); 673NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs); 674NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time); 675NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs); 676NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count); 677NILFS_SEGCTOR_RO_ATTR(README); 678 679static 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}; 696ATTRIBUTE_GROUPS(nilfs_segctor); 697 698NILFS_DEV_INT_GROUP_OPS(segctor, dev); 699NILFS_DEV_INT_GROUP_TYPE(segctor, dev); 700NILFS_DEV_INT_GROUP_FNS(segctor, dev); 701 702/************************************************************************ 703 * NILFS superblock attrs * 704 ************************************************************************/ 705 706static ssize_t 707nilfs_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 720static ssize_t 721nilfs_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 734static ssize_t 735nilfs_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 748static ssize_t 749nilfs_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 762static ssize_t 763nilfs_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 790static 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 803static ssize_t 804nilfs_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 810NILFS_SUPERBLOCK_RO_ATTR(sb_write_time); 811NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs); 812NILFS_SUPERBLOCK_RO_ATTR(sb_write_count); 813NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency); 814NILFS_SUPERBLOCK_RO_ATTR(README); 815 816static 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}; 824ATTRIBUTE_GROUPS(nilfs_superblock); 825 826NILFS_DEV_INT_GROUP_OPS(superblock, dev); 827NILFS_DEV_INT_GROUP_TYPE(superblock, dev); 828NILFS_DEV_INT_GROUP_FNS(superblock, dev); 829 830/************************************************************************ 831 * NILFS device attrs * 832 ************************************************************************/ 833 834static 835ssize_t nilfs_dev_revision_show(struct nilfs_dev_attr *attr, 836 struct the_nilfs *nilfs, 837 char *buf) 838{ 839 struct nilfs_super_block **sbp = nilfs->ns_sbp; 840 u32 major = le32_to_cpu(sbp[0]->s_rev_level); 841 u16 minor = le16_to_cpu(sbp[0]->s_minor_rev_level); 842 843 return sysfs_emit(buf, "%d.%d\n", major, minor); 844} 845 846static 847ssize_t nilfs_dev_blocksize_show(struct nilfs_dev_attr *attr, 848 struct the_nilfs *nilfs, 849 char *buf) 850{ 851 return sysfs_emit(buf, "%u\n", nilfs->ns_blocksize); 852} 853 854static 855ssize_t nilfs_dev_device_size_show(struct nilfs_dev_attr *attr, 856 struct the_nilfs *nilfs, 857 char *buf) 858{ 859 struct nilfs_super_block **sbp = nilfs->ns_sbp; 860 u64 dev_size = le64_to_cpu(sbp[0]->s_dev_size); 861 862 return sysfs_emit(buf, "%llu\n", dev_size); 863} 864 865static 866ssize_t nilfs_dev_free_blocks_show(struct nilfs_dev_attr *attr, 867 struct the_nilfs *nilfs, 868 char *buf) 869{ 870 sector_t free_blocks = 0; 871 872 nilfs_count_free_blocks(nilfs, &free_blocks); 873 return sysfs_emit(buf, "%llu\n", 874 (unsigned long long)free_blocks); 875} 876 877static 878ssize_t nilfs_dev_uuid_show(struct nilfs_dev_attr *attr, 879 struct the_nilfs *nilfs, 880 char *buf) 881{ 882 struct nilfs_super_block **sbp = nilfs->ns_sbp; 883 884 return sysfs_emit(buf, "%pUb\n", sbp[0]->s_uuid); 885} 886 887static 888ssize_t nilfs_dev_volume_name_show(struct nilfs_dev_attr *attr, 889 struct the_nilfs *nilfs, 890 char *buf) 891{ 892 struct nilfs_super_block **sbp = nilfs->ns_sbp; 893 894 return scnprintf(buf, sizeof(sbp[0]->s_volume_name), "%s\n", 895 sbp[0]->s_volume_name); 896} 897 898static const char dev_readme_str[] = 899 "The <device> group contains attributes that describe file system\n" 900 "partition's details.\n\n" 901 "(1) revision\n\tshow NILFS file system revision.\n\n" 902 "(2) blocksize\n\tshow volume block size in bytes.\n\n" 903 "(3) device_size\n\tshow volume size in bytes.\n\n" 904 "(4) free_blocks\n\tshow count of free blocks on volume.\n\n" 905 "(5) uuid\n\tshow volume's UUID.\n\n" 906 "(6) volume_name\n\tshow volume's name.\n\n"; 907 908static ssize_t nilfs_dev_README_show(struct nilfs_dev_attr *attr, 909 struct the_nilfs *nilfs, 910 char *buf) 911{ 912 return sysfs_emit(buf, dev_readme_str); 913} 914 915NILFS_DEV_RO_ATTR(revision); 916NILFS_DEV_RO_ATTR(blocksize); 917NILFS_DEV_RO_ATTR(device_size); 918NILFS_DEV_RO_ATTR(free_blocks); 919NILFS_DEV_RO_ATTR(uuid); 920NILFS_DEV_RO_ATTR(volume_name); 921NILFS_DEV_RO_ATTR(README); 922 923static struct attribute *nilfs_dev_attrs[] = { 924 NILFS_DEV_ATTR_LIST(revision), 925 NILFS_DEV_ATTR_LIST(blocksize), 926 NILFS_DEV_ATTR_LIST(device_size), 927 NILFS_DEV_ATTR_LIST(free_blocks), 928 NILFS_DEV_ATTR_LIST(uuid), 929 NILFS_DEV_ATTR_LIST(volume_name), 930 NILFS_DEV_ATTR_LIST(README), 931 NULL, 932}; 933ATTRIBUTE_GROUPS(nilfs_dev); 934 935static ssize_t nilfs_dev_attr_show(struct kobject *kobj, 936 struct attribute *attr, char *buf) 937{ 938 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, 939 ns_dev_kobj); 940 struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, 941 attr); 942 943 return a->show ? a->show(a, nilfs, buf) : 0; 944} 945 946static ssize_t nilfs_dev_attr_store(struct kobject *kobj, 947 struct attribute *attr, 948 const char *buf, size_t len) 949{ 950 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, 951 ns_dev_kobj); 952 struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, 953 attr); 954 955 return a->store ? a->store(a, nilfs, buf, len) : 0; 956} 957 958static void nilfs_dev_attr_release(struct kobject *kobj) 959{ 960 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, 961 ns_dev_kobj); 962 complete(&nilfs->ns_dev_kobj_unregister); 963} 964 965static const struct sysfs_ops nilfs_dev_attr_ops = { 966 .show = nilfs_dev_attr_show, 967 .store = nilfs_dev_attr_store, 968}; 969 970static struct kobj_type nilfs_dev_ktype = { 971 .default_groups = nilfs_dev_groups, 972 .sysfs_ops = &nilfs_dev_attr_ops, 973 .release = nilfs_dev_attr_release, 974}; 975 976int nilfs_sysfs_create_device_group(struct super_block *sb) 977{ 978 struct the_nilfs *nilfs = sb->s_fs_info; 979 size_t devgrp_size = sizeof(struct nilfs_sysfs_dev_subgroups); 980 int err; 981 982 nilfs->ns_dev_subgroups = kzalloc(devgrp_size, GFP_KERNEL); 983 if (unlikely(!nilfs->ns_dev_subgroups)) { 984 err = -ENOMEM; 985 nilfs_err(sb, "unable to allocate memory for device group"); 986 goto failed_create_device_group; 987 } 988 989 nilfs->ns_dev_kobj.kset = nilfs_kset; 990 init_completion(&nilfs->ns_dev_kobj_unregister); 991 err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL, 992 "%s", sb->s_id); 993 if (err) 994 goto cleanup_dev_kobject; 995 996 err = nilfs_sysfs_create_mounted_snapshots_group(nilfs); 997 if (err) 998 goto cleanup_dev_kobject; 999 1000 err = nilfs_sysfs_create_checkpoints_group(nilfs); 1001 if (err) 1002 goto delete_mounted_snapshots_group; 1003 1004 err = nilfs_sysfs_create_segments_group(nilfs); 1005 if (err) 1006 goto delete_checkpoints_group; 1007 1008 err = nilfs_sysfs_create_superblock_group(nilfs); 1009 if (err) 1010 goto delete_segments_group; 1011 1012 err = nilfs_sysfs_create_segctor_group(nilfs); 1013 if (err) 1014 goto delete_superblock_group; 1015 1016 return 0; 1017 1018delete_superblock_group: 1019 nilfs_sysfs_delete_superblock_group(nilfs); 1020 1021delete_segments_group: 1022 nilfs_sysfs_delete_segments_group(nilfs); 1023 1024delete_checkpoints_group: 1025 nilfs_sysfs_delete_checkpoints_group(nilfs); 1026 1027delete_mounted_snapshots_group: 1028 nilfs_sysfs_delete_mounted_snapshots_group(nilfs); 1029 1030cleanup_dev_kobject: 1031 kobject_put(&nilfs->ns_dev_kobj); 1032 kfree(nilfs->ns_dev_subgroups); 1033 1034failed_create_device_group: 1035 return err; 1036} 1037 1038void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs) 1039{ 1040 nilfs_sysfs_delete_mounted_snapshots_group(nilfs); 1041 nilfs_sysfs_delete_checkpoints_group(nilfs); 1042 nilfs_sysfs_delete_segments_group(nilfs); 1043 nilfs_sysfs_delete_superblock_group(nilfs); 1044 nilfs_sysfs_delete_segctor_group(nilfs); 1045 kobject_del(&nilfs->ns_dev_kobj); 1046 kobject_put(&nilfs->ns_dev_kobj); 1047 kfree(nilfs->ns_dev_subgroups); 1048} 1049 1050/************************************************************************ 1051 * NILFS feature attrs * 1052 ************************************************************************/ 1053 1054static ssize_t nilfs_feature_revision_show(struct kobject *kobj, 1055 struct attribute *attr, char *buf) 1056{ 1057 return sysfs_emit(buf, "%d.%d\n", 1058 NILFS_CURRENT_REV, NILFS_MINOR_REV); 1059} 1060 1061static const char features_readme_str[] = 1062 "The features group contains attributes that describe NILFS file\n" 1063 "system driver features.\n\n" 1064 "(1) revision\n\tshow current revision of NILFS file system driver.\n"; 1065 1066static ssize_t nilfs_feature_README_show(struct kobject *kobj, 1067 struct attribute *attr, 1068 char *buf) 1069{ 1070 return sysfs_emit(buf, features_readme_str); 1071} 1072 1073NILFS_FEATURE_RO_ATTR(revision); 1074NILFS_FEATURE_RO_ATTR(README); 1075 1076static struct attribute *nilfs_feature_attrs[] = { 1077 NILFS_FEATURE_ATTR_LIST(revision), 1078 NILFS_FEATURE_ATTR_LIST(README), 1079 NULL, 1080}; 1081 1082static const struct attribute_group nilfs_feature_attr_group = { 1083 .name = "features", 1084 .attrs = nilfs_feature_attrs, 1085}; 1086 1087int __init nilfs_sysfs_init(void) 1088{ 1089 int err; 1090 1091 nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj); 1092 if (!nilfs_kset) { 1093 err = -ENOMEM; 1094 nilfs_err(NULL, "unable to create sysfs entry: err=%d", err); 1095 goto failed_sysfs_init; 1096 } 1097 1098 err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); 1099 if (unlikely(err)) { 1100 nilfs_err(NULL, "unable to create feature group: err=%d", err); 1101 goto cleanup_sysfs_init; 1102 } 1103 1104 return 0; 1105 1106cleanup_sysfs_init: 1107 kset_unregister(nilfs_kset); 1108 1109failed_sysfs_init: 1110 return err; 1111} 1112 1113void nilfs_sysfs_exit(void) 1114{ 1115 sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); 1116 kset_unregister(nilfs_kset); 1117} 1118