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 } 1141