1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * sysfs.c - sysfs support implementation. 4 * 5 * Copyright (C) 2005-2014 Nippon Telegraph and Telephone Corporation. 6 * Copyright (C) 2014 HGST, Inc., a Western Digital Company. 7 * 8 * Written by Vyacheslav Dubeyko <Vyacheslav.Dubeyko@hgst.com> 9 */ 10 11 #include <linux/kobject.h> 12 13 #include "nilfs.h" 14 #include "mdt.h" 15 #include "sufile.h" 16 #include "cpfile.h" 17 #include "sysfs.h" 18 19 /* /sys/fs/<nilfs>/ */ 20 static struct kset *nilfs_kset; 21 22 #define NILFS_DEV_INT_GROUP_OPS(name, parent_name) \ 23 static ssize_t nilfs_##name##_attr_show(struct kobject *kobj, \ 24 struct attribute *attr, char *buf) \ 25 { \ 26 struct the_nilfs *nilfs = container_of(kobj->parent, \ 27 struct the_nilfs, \ 28 ns_##parent_name##_kobj); \ 29 struct nilfs_##name##_attr *a = container_of(attr, \ 30 struct nilfs_##name##_attr, \ 31 attr); \ 32 return a->show ? a->show(a, nilfs, buf) : 0; \ 33 } \ 34 static ssize_t nilfs_##name##_attr_store(struct kobject *kobj, \ 35 struct attribute *attr, \ 36 const char *buf, size_t len) \ 37 { \ 38 struct the_nilfs *nilfs = container_of(kobj->parent, \ 39 struct the_nilfs, \ 40 ns_##parent_name##_kobj); \ 41 struct nilfs_##name##_attr *a = container_of(attr, \ 42 struct nilfs_##name##_attr, \ 43 attr); \ 44 return a->store ? a->store(a, nilfs, buf, len) : 0; \ 45 } \ 46 static const struct sysfs_ops nilfs_##name##_attr_ops = { \ 47 .show = nilfs_##name##_attr_show, \ 48 .store = nilfs_##name##_attr_store, \ 49 } 50 51 #define NILFS_DEV_INT_GROUP_TYPE(name, parent_name) \ 52 static void nilfs_##name##_attr_release(struct kobject *kobj) \ 53 { \ 54 struct nilfs_sysfs_##parent_name##_subgroups *subgroups = container_of(kobj, \ 55 struct nilfs_sysfs_##parent_name##_subgroups, \ 56 sg_##name##_kobj); \ 57 complete(&subgroups->sg_##name##_kobj_unregister); \ 58 } \ 59 static 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) \ 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 snprintf(buf, PAGE_SIZE, "%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 snprintf(buf, PAGE_SIZE, "%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 snprintf(buf, PAGE_SIZE, 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 133 static 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 144 static 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 156 static 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 163 static const struct sysfs_ops nilfs_snapshot_attr_ops = { 164 .show = nilfs_snapshot_attr_show, 165 .store = nilfs_snapshot_attr_store, 166 }; 167 168 static 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 174 int 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 203 void 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 212 static const char mounted_snapshots_readme_str[] = 213 "The mounted_snapshots group contains group for\n" 214 "every mounted snapshot.\n"; 215 216 static ssize_t 217 nilfs_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 223 NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README); 224 225 static struct attribute *nilfs_mounted_snapshots_attrs[] = { 226 NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README), 227 NULL, 228 }; 229 230 NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev); 231 NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev); 232 NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev); 233 234 /************************************************************************ 235 * NILFS checkpoints attrs * 236 ************************************************************************/ 237 238 static ssize_t 239 nilfs_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 261 static ssize_t 262 nilfs_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 284 static ssize_t 285 nilfs_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 298 static ssize_t 299 nilfs_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 312 static 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 321 static ssize_t 322 nilfs_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 328 NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number); 329 NILFS_CHECKPOINTS_RO_ATTR(snapshots_number); 330 NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint); 331 NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint); 332 NILFS_CHECKPOINTS_RO_ATTR(README); 333 334 static 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 343 NILFS_DEV_INT_GROUP_OPS(checkpoints, dev); 344 NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev); 345 NILFS_DEV_INT_GROUP_FNS(checkpoints, dev); 346 347 /************************************************************************ 348 * NILFS segments attrs * 349 ************************************************************************/ 350 351 static ssize_t 352 nilfs_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 359 static ssize_t 360 nilfs_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 367 static ssize_t 368 nilfs_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 381 static ssize_t 382 nilfs_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 401 static 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 409 static ssize_t 410 nilfs_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 417 NILFS_SEGMENTS_RO_ATTR(segments_number); 418 NILFS_SEGMENTS_RO_ATTR(blocks_per_segment); 419 NILFS_SEGMENTS_RO_ATTR(clean_segments); 420 NILFS_SEGMENTS_RO_ATTR(dirty_segments); 421 NILFS_SEGMENTS_RO_ATTR(README); 422 423 static 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 432 NILFS_DEV_INT_GROUP_OPS(segments, dev); 433 NILFS_DEV_INT_GROUP_TYPE(segments, dev); 434 NILFS_DEV_INT_GROUP_FNS(segments, dev); 435 436 /************************************************************************ 437 * NILFS segctor attrs * 438 ************************************************************************/ 439 440 static ssize_t 441 nilfs_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 455 static ssize_t 456 nilfs_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 469 static ssize_t 470 nilfs_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 483 static ssize_t 484 nilfs_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 497 static ssize_t 498 nilfs_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 511 static ssize_t 512 nilfs_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 525 static ssize_t 526 nilfs_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 539 static ssize_t 540 nilfs_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 553 static ssize_t 554 nilfs_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 567 static ssize_t 568 nilfs_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 581 static ssize_t 582 nilfs_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 595 static ssize_t 596 nilfs_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 609 static ssize_t 610 nilfs_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 623 static 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 653 static ssize_t 654 nilfs_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 660 NILFS_SEGCTOR_RO_ATTR(last_pseg_block); 661 NILFS_SEGCTOR_RO_ATTR(last_seg_sequence); 662 NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint); 663 NILFS_SEGCTOR_RO_ATTR(current_seg_sequence); 664 NILFS_SEGCTOR_RO_ATTR(current_last_full_seg); 665 NILFS_SEGCTOR_RO_ATTR(next_full_seg); 666 NILFS_SEGCTOR_RO_ATTR(next_pseg_offset); 667 NILFS_SEGCTOR_RO_ATTR(next_checkpoint); 668 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time); 669 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs); 670 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time); 671 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs); 672 NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count); 673 NILFS_SEGCTOR_RO_ATTR(README); 674 675 static 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 693 NILFS_DEV_INT_GROUP_OPS(segctor, dev); 694 NILFS_DEV_INT_GROUP_TYPE(segctor, dev); 695 NILFS_DEV_INT_GROUP_FNS(segctor, dev); 696 697 /************************************************************************ 698 * NILFS superblock attrs * 699 ************************************************************************/ 700 701 static ssize_t 702 nilfs_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 715 static ssize_t 716 nilfs_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 729 static ssize_t 730 nilfs_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 743 static ssize_t 744 nilfs_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 757 static ssize_t 758 nilfs_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 785 static 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 798 static ssize_t 799 nilfs_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 805 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time); 806 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs); 807 NILFS_SUPERBLOCK_RO_ATTR(sb_write_count); 808 NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency); 809 NILFS_SUPERBLOCK_RO_ATTR(README); 810 811 static 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 820 NILFS_DEV_INT_GROUP_OPS(superblock, dev); 821 NILFS_DEV_INT_GROUP_TYPE(superblock, dev); 822 NILFS_DEV_INT_GROUP_FNS(superblock, dev); 823 824 /************************************************************************ 825 * NILFS device attrs * 826 ************************************************************************/ 827 828 static 829 ssize_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 840 static 841 ssize_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 848 static 849 ssize_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 859 static 860 ssize_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 871 static 872 ssize_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 881 static 882 ssize_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 892 static 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 902 static 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 909 NILFS_DEV_RO_ATTR(revision); 910 NILFS_DEV_RO_ATTR(blocksize); 911 NILFS_DEV_RO_ATTR(device_size); 912 NILFS_DEV_RO_ATTR(free_blocks); 913 NILFS_DEV_RO_ATTR(uuid); 914 NILFS_DEV_RO_ATTR(volume_name); 915 NILFS_DEV_RO_ATTR(README); 916 917 static 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 928 static 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 939 static 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 951 static 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 958 static const struct sysfs_ops nilfs_dev_attr_ops = { 959 .show = nilfs_dev_attr_show, 960 .store = nilfs_dev_attr_store, 961 }; 962 963 static 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 969 int 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 1011 delete_superblock_group: 1012 nilfs_sysfs_delete_superblock_group(nilfs); 1013 1014 delete_segments_group: 1015 nilfs_sysfs_delete_segments_group(nilfs); 1016 1017 delete_checkpoints_group: 1018 nilfs_sysfs_delete_checkpoints_group(nilfs); 1019 1020 delete_mounted_snapshots_group: 1021 nilfs_sysfs_delete_mounted_snapshots_group(nilfs); 1022 1023 cleanup_dev_kobject: 1024 kobject_put(&nilfs->ns_dev_kobj); 1025 kfree(nilfs->ns_dev_subgroups); 1026 1027 failed_create_device_group: 1028 return err; 1029 } 1030 1031 void 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 1047 static 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 1054 static 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 1059 static 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 1066 NILFS_FEATURE_RO_ATTR(revision); 1067 NILFS_FEATURE_RO_ATTR(README); 1068 1069 static struct attribute *nilfs_feature_attrs[] = { 1070 NILFS_FEATURE_ATTR_LIST(revision), 1071 NILFS_FEATURE_ATTR_LIST(README), 1072 NULL, 1073 }; 1074 1075 static const struct attribute_group nilfs_feature_attr_group = { 1076 .name = "features", 1077 .attrs = nilfs_feature_attrs, 1078 }; 1079 1080 int __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 1099 cleanup_sysfs_init: 1100 kset_unregister(nilfs_kset); 1101 1102 failed_sysfs_init: 1103 return err; 1104 } 1105 1106 void nilfs_sysfs_exit(void) 1107 { 1108 sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); 1109 kset_unregister(nilfs_kset); 1110 } 1111