1 /* 2 * sysfs.c - sysfs support implementation. 3 * 4 * Copyright (C) 2005-2014 Nippon Telegraph and Telephone Corporation. 5 * Copyright (C) 2014 HGST, Inc., a Western Digital Company. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * Written by Vyacheslav Dubeyko <Vyacheslav.Dubeyko@hgst.com> 18 */ 19 20 #include <linux/kobject.h> 21 22 #include "nilfs.h" 23 #include "mdt.h" 24 #include "sufile.h" 25 #include "cpfile.h" 26 #include "sysfs.h" 27 28 /* /sys/fs/<nilfs>/ */ 29 static struct kset *nilfs_kset; 30 31 #define NILFS_SHOW_TIME(time_t_val, buf) ({ \ 32 struct tm res; \ 33 int count = 0; \ 34 time64_to_tm(time_t_val, 0, &res); \ 35 res.tm_year += 1900; \ 36 res.tm_mon += 1; \ 37 count = scnprintf(buf, PAGE_SIZE, \ 38 "%ld-%.2d-%.2d %.2d:%.2d:%.2d\n", \ 39 res.tm_year, res.tm_mon, res.tm_mday, \ 40 res.tm_hour, res.tm_min, res.tm_sec);\ 41 count; \ 42 }) 43 44 #define NILFS_DEV_INT_GROUP_OPS(name, parent_name) \ 45 static ssize_t nilfs_##name##_attr_show(struct kobject *kobj, \ 46 struct attribute *attr, char *buf) \ 47 { \ 48 struct the_nilfs *nilfs = container_of(kobj->parent, \ 49 struct the_nilfs, \ 50 ns_##parent_name##_kobj); \ 51 struct nilfs_##name##_attr *a = container_of(attr, \ 52 struct nilfs_##name##_attr, \ 53 attr); \ 54 return a->show ? a->show(a, nilfs, buf) : 0; \ 55 } \ 56 static ssize_t nilfs_##name##_attr_store(struct kobject *kobj, \ 57 struct attribute *attr, \ 58 const char *buf, size_t len) \ 59 { \ 60 struct the_nilfs *nilfs = container_of(kobj->parent, \ 61 struct the_nilfs, \ 62 ns_##parent_name##_kobj); \ 63 struct nilfs_##name##_attr *a = container_of(attr, \ 64 struct nilfs_##name##_attr, \ 65 attr); \ 66 return a->store ? a->store(a, nilfs, buf, len) : 0; \ 67 } \ 68 static const struct sysfs_ops nilfs_##name##_attr_ops = { \ 69 .show = nilfs_##name##_attr_show, \ 70 .store = nilfs_##name##_attr_store, \ 71 } 72 73 #define NILFS_DEV_INT_GROUP_TYPE(name, parent_name) \ 74 static void nilfs_##name##_attr_release(struct kobject *kobj) \ 75 { \ 76 struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \ 77 struct the_nilfs *nilfs = container_of(kobj->parent, \ 78 struct the_nilfs, \ 79 ns_##parent_name##_kobj); \ 80 subgroups = nilfs->ns_##parent_name##_subgroups; \ 81 complete(&subgroups->sg_##name##_kobj_unregister); \ 82 } \ 83 static struct kobj_type nilfs_##name##_ktype = { \ 84 .default_attrs = nilfs_##name##_attrs, \ 85 .sysfs_ops = &nilfs_##name##_attr_ops, \ 86 .release = nilfs_##name##_attr_release, \ 87 } 88 89 #define NILFS_DEV_INT_GROUP_FNS(name, parent_name) \ 90 static int nilfs_sysfs_create_##name##_group(struct the_nilfs *nilfs) \ 91 { \ 92 struct kobject *parent; \ 93 struct kobject *kobj; \ 94 struct completion *kobj_unregister; \ 95 struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \ 96 int err; \ 97 subgroups = nilfs->ns_##parent_name##_subgroups; \ 98 kobj = &subgroups->sg_##name##_kobj; \ 99 kobj_unregister = &subgroups->sg_##name##_kobj_unregister; \ 100 parent = &nilfs->ns_##parent_name##_kobj; \ 101 kobj->kset = nilfs_kset; \ 102 init_completion(kobj_unregister); \ 103 err = kobject_init_and_add(kobj, &nilfs_##name##_ktype, parent, \ 104 #name); \ 105 if (err) \ 106 return err; \ 107 return 0; \ 108 } \ 109 static void nilfs_sysfs_delete_##name##_group(struct the_nilfs *nilfs) \ 110 { \ 111 kobject_del(&nilfs->ns_##parent_name##_subgroups->sg_##name##_kobj); \ 112 } 113 114 /************************************************************************ 115 * NILFS snapshot attrs * 116 ************************************************************************/ 117 118 static ssize_t 119 nilfs_snapshot_inodes_count_show(struct nilfs_snapshot_attr *attr, 120 struct nilfs_root *root, char *buf) 121 { 122 return snprintf(buf, PAGE_SIZE, "%llu\n", 123 (unsigned long long)atomic64_read(&root->inodes_count)); 124 } 125 126 static ssize_t 127 nilfs_snapshot_blocks_count_show(struct nilfs_snapshot_attr *attr, 128 struct nilfs_root *root, char *buf) 129 { 130 return snprintf(buf, PAGE_SIZE, "%llu\n", 131 (unsigned long long)atomic64_read(&root->blocks_count)); 132 } 133 134 static const char snapshot_readme_str[] = 135 "The group contains details about mounted snapshot.\n\n" 136 "(1) inodes_count\n\tshow number of inodes for snapshot.\n\n" 137 "(2) blocks_count\n\tshow number of blocks for snapshot.\n\n"; 138 139 static ssize_t 140 nilfs_snapshot_README_show(struct nilfs_snapshot_attr *attr, 141 struct nilfs_root *root, char *buf) 142 { 143 return snprintf(buf, PAGE_SIZE, snapshot_readme_str); 144 } 145 146 NILFS_SNAPSHOT_RO_ATTR(inodes_count); 147 NILFS_SNAPSHOT_RO_ATTR(blocks_count); 148 NILFS_SNAPSHOT_RO_ATTR(README); 149 150 static struct attribute *nilfs_snapshot_attrs[] = { 151 NILFS_SNAPSHOT_ATTR_LIST(inodes_count), 152 NILFS_SNAPSHOT_ATTR_LIST(blocks_count), 153 NILFS_SNAPSHOT_ATTR_LIST(README), 154 NULL, 155 }; 156 157 static ssize_t nilfs_snapshot_attr_show(struct kobject *kobj, 158 struct attribute *attr, char *buf) 159 { 160 struct nilfs_root *root = 161 container_of(kobj, struct nilfs_root, snapshot_kobj); 162 struct nilfs_snapshot_attr *a = 163 container_of(attr, struct nilfs_snapshot_attr, attr); 164 165 return a->show ? a->show(a, root, buf) : 0; 166 } 167 168 static ssize_t nilfs_snapshot_attr_store(struct kobject *kobj, 169 struct attribute *attr, 170 const char *buf, size_t len) 171 { 172 struct nilfs_root *root = 173 container_of(kobj, struct nilfs_root, snapshot_kobj); 174 struct nilfs_snapshot_attr *a = 175 container_of(attr, struct nilfs_snapshot_attr, attr); 176 177 return a->store ? a->store(a, root, buf, len) : 0; 178 } 179 180 static void nilfs_snapshot_attr_release(struct kobject *kobj) 181 { 182 struct nilfs_root *root = container_of(kobj, struct nilfs_root, 183 snapshot_kobj); 184 complete(&root->snapshot_kobj_unregister); 185 } 186 187 static const struct sysfs_ops nilfs_snapshot_attr_ops = { 188 .show = nilfs_snapshot_attr_show, 189 .store = nilfs_snapshot_attr_store, 190 }; 191 192 static struct kobj_type nilfs_snapshot_ktype = { 193 .default_attrs = nilfs_snapshot_attrs, 194 .sysfs_ops = &nilfs_snapshot_attr_ops, 195 .release = nilfs_snapshot_attr_release, 196 }; 197 198 int nilfs_sysfs_create_snapshot_group(struct nilfs_root *root) 199 { 200 struct the_nilfs *nilfs; 201 struct kobject *parent; 202 int err; 203 204 nilfs = root->nilfs; 205 parent = &nilfs->ns_dev_subgroups->sg_mounted_snapshots_kobj; 206 root->snapshot_kobj.kset = nilfs_kset; 207 init_completion(&root->snapshot_kobj_unregister); 208 209 if (root->cno == NILFS_CPTREE_CURRENT_CNO) { 210 err = kobject_init_and_add(&root->snapshot_kobj, 211 &nilfs_snapshot_ktype, 212 &nilfs->ns_dev_kobj, 213 "current_checkpoint"); 214 } else { 215 err = kobject_init_and_add(&root->snapshot_kobj, 216 &nilfs_snapshot_ktype, 217 parent, 218 "%llu", root->cno); 219 } 220 221 if (err) 222 return err; 223 224 return 0; 225 } 226 227 void nilfs_sysfs_delete_snapshot_group(struct nilfs_root *root) 228 { 229 kobject_del(&root->snapshot_kobj); 230 } 231 232 /************************************************************************ 233 * NILFS mounted snapshots attrs * 234 ************************************************************************/ 235 236 static const char mounted_snapshots_readme_str[] = 237 "The mounted_snapshots group contains group for\n" 238 "every mounted snapshot.\n"; 239 240 static ssize_t 241 nilfs_mounted_snapshots_README_show(struct nilfs_mounted_snapshots_attr *attr, 242 struct the_nilfs *nilfs, char *buf) 243 { 244 return snprintf(buf, PAGE_SIZE, mounted_snapshots_readme_str); 245 } 246 247 NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README); 248 249 static struct attribute *nilfs_mounted_snapshots_attrs[] = { 250 NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README), 251 NULL, 252 }; 253 254 NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev); 255 NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev); 256 NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev); 257 258 /************************************************************************ 259 * NILFS checkpoints attrs * 260 ************************************************************************/ 261 262 static ssize_t 263 nilfs_checkpoints_checkpoints_number_show(struct nilfs_checkpoints_attr *attr, 264 struct the_nilfs *nilfs, 265 char *buf) 266 { 267 __u64 ncheckpoints; 268 struct nilfs_cpstat cpstat; 269 int err; 270 271 down_read(&nilfs->ns_segctor_sem); 272 err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat); 273 up_read(&nilfs->ns_segctor_sem); 274 if (err < 0) { 275 nilfs_msg(nilfs->ns_sb, KERN_ERR, 276 "unable to get checkpoint stat: err=%d", err); 277 return err; 278 } 279 280 ncheckpoints = cpstat.cs_ncps; 281 282 return snprintf(buf, PAGE_SIZE, "%llu\n", ncheckpoints); 283 } 284 285 static ssize_t 286 nilfs_checkpoints_snapshots_number_show(struct nilfs_checkpoints_attr *attr, 287 struct the_nilfs *nilfs, 288 char *buf) 289 { 290 __u64 nsnapshots; 291 struct nilfs_cpstat cpstat; 292 int err; 293 294 down_read(&nilfs->ns_segctor_sem); 295 err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat); 296 up_read(&nilfs->ns_segctor_sem); 297 if (err < 0) { 298 nilfs_msg(nilfs->ns_sb, KERN_ERR, 299 "unable to get checkpoint stat: err=%d", err); 300 return err; 301 } 302 303 nsnapshots = cpstat.cs_nsss; 304 305 return snprintf(buf, PAGE_SIZE, "%llu\n", nsnapshots); 306 } 307 308 static ssize_t 309 nilfs_checkpoints_last_seg_checkpoint_show(struct nilfs_checkpoints_attr *attr, 310 struct the_nilfs *nilfs, 311 char *buf) 312 { 313 __u64 last_cno; 314 315 spin_lock(&nilfs->ns_last_segment_lock); 316 last_cno = nilfs->ns_last_cno; 317 spin_unlock(&nilfs->ns_last_segment_lock); 318 319 return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno); 320 } 321 322 static ssize_t 323 nilfs_checkpoints_next_checkpoint_show(struct nilfs_checkpoints_attr *attr, 324 struct the_nilfs *nilfs, 325 char *buf) 326 { 327 __u64 cno; 328 329 down_read(&nilfs->ns_segctor_sem); 330 cno = nilfs->ns_cno; 331 up_read(&nilfs->ns_segctor_sem); 332 333 return snprintf(buf, PAGE_SIZE, "%llu\n", cno); 334 } 335 336 static const char checkpoints_readme_str[] = 337 "The checkpoints group contains attributes that describe\n" 338 "details about volume's checkpoints.\n\n" 339 "(1) checkpoints_number\n\tshow number of checkpoints on volume.\n\n" 340 "(2) snapshots_number\n\tshow number of snapshots on volume.\n\n" 341 "(3) last_seg_checkpoint\n" 342 "\tshow checkpoint number of the latest segment.\n\n" 343 "(4) next_checkpoint\n\tshow next checkpoint number.\n\n"; 344 345 static ssize_t 346 nilfs_checkpoints_README_show(struct nilfs_checkpoints_attr *attr, 347 struct the_nilfs *nilfs, char *buf) 348 { 349 return snprintf(buf, PAGE_SIZE, checkpoints_readme_str); 350 } 351 352 NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number); 353 NILFS_CHECKPOINTS_RO_ATTR(snapshots_number); 354 NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint); 355 NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint); 356 NILFS_CHECKPOINTS_RO_ATTR(README); 357 358 static struct attribute *nilfs_checkpoints_attrs[] = { 359 NILFS_CHECKPOINTS_ATTR_LIST(checkpoints_number), 360 NILFS_CHECKPOINTS_ATTR_LIST(snapshots_number), 361 NILFS_CHECKPOINTS_ATTR_LIST(last_seg_checkpoint), 362 NILFS_CHECKPOINTS_ATTR_LIST(next_checkpoint), 363 NILFS_CHECKPOINTS_ATTR_LIST(README), 364 NULL, 365 }; 366 367 NILFS_DEV_INT_GROUP_OPS(checkpoints, dev); 368 NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev); 369 NILFS_DEV_INT_GROUP_FNS(checkpoints, dev); 370 371 /************************************************************************ 372 * NILFS segments attrs * 373 ************************************************************************/ 374 375 static ssize_t 376 nilfs_segments_segments_number_show(struct nilfs_segments_attr *attr, 377 struct the_nilfs *nilfs, 378 char *buf) 379 { 380 return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_nsegments); 381 } 382 383 static ssize_t 384 nilfs_segments_blocks_per_segment_show(struct nilfs_segments_attr *attr, 385 struct the_nilfs *nilfs, 386 char *buf) 387 { 388 return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_blocks_per_segment); 389 } 390 391 static ssize_t 392 nilfs_segments_clean_segments_show(struct nilfs_segments_attr *attr, 393 struct the_nilfs *nilfs, 394 char *buf) 395 { 396 unsigned long ncleansegs; 397 398 down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 399 ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); 400 up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 401 402 return snprintf(buf, PAGE_SIZE, "%lu\n", ncleansegs); 403 } 404 405 static ssize_t 406 nilfs_segments_dirty_segments_show(struct nilfs_segments_attr *attr, 407 struct the_nilfs *nilfs, 408 char *buf) 409 { 410 struct nilfs_sustat sustat; 411 int err; 412 413 down_read(&nilfs->ns_segctor_sem); 414 err = nilfs_sufile_get_stat(nilfs->ns_sufile, &sustat); 415 up_read(&nilfs->ns_segctor_sem); 416 if (err < 0) { 417 nilfs_msg(nilfs->ns_sb, KERN_ERR, 418 "unable to get segment stat: err=%d", err); 419 return err; 420 } 421 422 return snprintf(buf, PAGE_SIZE, "%llu\n", sustat.ss_ndirtysegs); 423 } 424 425 static const char segments_readme_str[] = 426 "The segments group contains attributes that describe\n" 427 "details about volume's segments.\n\n" 428 "(1) segments_number\n\tshow number of segments on volume.\n\n" 429 "(2) blocks_per_segment\n\tshow number of blocks in segment.\n\n" 430 "(3) clean_segments\n\tshow count of clean segments.\n\n" 431 "(4) dirty_segments\n\tshow count of dirty segments.\n\n"; 432 433 static ssize_t 434 nilfs_segments_README_show(struct nilfs_segments_attr *attr, 435 struct the_nilfs *nilfs, 436 char *buf) 437 { 438 return snprintf(buf, PAGE_SIZE, segments_readme_str); 439 } 440 441 NILFS_SEGMENTS_RO_ATTR(segments_number); 442 NILFS_SEGMENTS_RO_ATTR(blocks_per_segment); 443 NILFS_SEGMENTS_RO_ATTR(clean_segments); 444 NILFS_SEGMENTS_RO_ATTR(dirty_segments); 445 NILFS_SEGMENTS_RO_ATTR(README); 446 447 static struct attribute *nilfs_segments_attrs[] = { 448 NILFS_SEGMENTS_ATTR_LIST(segments_number), 449 NILFS_SEGMENTS_ATTR_LIST(blocks_per_segment), 450 NILFS_SEGMENTS_ATTR_LIST(clean_segments), 451 NILFS_SEGMENTS_ATTR_LIST(dirty_segments), 452 NILFS_SEGMENTS_ATTR_LIST(README), 453 NULL, 454 }; 455 456 NILFS_DEV_INT_GROUP_OPS(segments, dev); 457 NILFS_DEV_INT_GROUP_TYPE(segments, dev); 458 NILFS_DEV_INT_GROUP_FNS(segments, dev); 459 460 /************************************************************************ 461 * NILFS segctor attrs * 462 ************************************************************************/ 463 464 static ssize_t 465 nilfs_segctor_last_pseg_block_show(struct nilfs_segctor_attr *attr, 466 struct the_nilfs *nilfs, 467 char *buf) 468 { 469 sector_t last_pseg; 470 471 spin_lock(&nilfs->ns_last_segment_lock); 472 last_pseg = nilfs->ns_last_pseg; 473 spin_unlock(&nilfs->ns_last_segment_lock); 474 475 return snprintf(buf, PAGE_SIZE, "%llu\n", 476 (unsigned long long)last_pseg); 477 } 478 479 static ssize_t 480 nilfs_segctor_last_seg_sequence_show(struct nilfs_segctor_attr *attr, 481 struct the_nilfs *nilfs, 482 char *buf) 483 { 484 u64 last_seq; 485 486 spin_lock(&nilfs->ns_last_segment_lock); 487 last_seq = nilfs->ns_last_seq; 488 spin_unlock(&nilfs->ns_last_segment_lock); 489 490 return snprintf(buf, PAGE_SIZE, "%llu\n", last_seq); 491 } 492 493 static ssize_t 494 nilfs_segctor_last_seg_checkpoint_show(struct nilfs_segctor_attr *attr, 495 struct the_nilfs *nilfs, 496 char *buf) 497 { 498 __u64 last_cno; 499 500 spin_lock(&nilfs->ns_last_segment_lock); 501 last_cno = nilfs->ns_last_cno; 502 spin_unlock(&nilfs->ns_last_segment_lock); 503 504 return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno); 505 } 506 507 static ssize_t 508 nilfs_segctor_current_seg_sequence_show(struct nilfs_segctor_attr *attr, 509 struct the_nilfs *nilfs, 510 char *buf) 511 { 512 u64 seg_seq; 513 514 down_read(&nilfs->ns_segctor_sem); 515 seg_seq = nilfs->ns_seg_seq; 516 up_read(&nilfs->ns_segctor_sem); 517 518 return snprintf(buf, PAGE_SIZE, "%llu\n", seg_seq); 519 } 520 521 static ssize_t 522 nilfs_segctor_current_last_full_seg_show(struct nilfs_segctor_attr *attr, 523 struct the_nilfs *nilfs, 524 char *buf) 525 { 526 __u64 segnum; 527 528 down_read(&nilfs->ns_segctor_sem); 529 segnum = nilfs->ns_segnum; 530 up_read(&nilfs->ns_segctor_sem); 531 532 return snprintf(buf, PAGE_SIZE, "%llu\n", segnum); 533 } 534 535 static ssize_t 536 nilfs_segctor_next_full_seg_show(struct nilfs_segctor_attr *attr, 537 struct the_nilfs *nilfs, 538 char *buf) 539 { 540 __u64 nextnum; 541 542 down_read(&nilfs->ns_segctor_sem); 543 nextnum = nilfs->ns_nextnum; 544 up_read(&nilfs->ns_segctor_sem); 545 546 return snprintf(buf, PAGE_SIZE, "%llu\n", nextnum); 547 } 548 549 static ssize_t 550 nilfs_segctor_next_pseg_offset_show(struct nilfs_segctor_attr *attr, 551 struct the_nilfs *nilfs, 552 char *buf) 553 { 554 unsigned long pseg_offset; 555 556 down_read(&nilfs->ns_segctor_sem); 557 pseg_offset = nilfs->ns_pseg_offset; 558 up_read(&nilfs->ns_segctor_sem); 559 560 return snprintf(buf, PAGE_SIZE, "%lu\n", pseg_offset); 561 } 562 563 static ssize_t 564 nilfs_segctor_next_checkpoint_show(struct nilfs_segctor_attr *attr, 565 struct the_nilfs *nilfs, 566 char *buf) 567 { 568 __u64 cno; 569 570 down_read(&nilfs->ns_segctor_sem); 571 cno = nilfs->ns_cno; 572 up_read(&nilfs->ns_segctor_sem); 573 574 return snprintf(buf, PAGE_SIZE, "%llu\n", cno); 575 } 576 577 static ssize_t 578 nilfs_segctor_last_seg_write_time_show(struct nilfs_segctor_attr *attr, 579 struct the_nilfs *nilfs, 580 char *buf) 581 { 582 time64_t ctime; 583 584 down_read(&nilfs->ns_segctor_sem); 585 ctime = nilfs->ns_ctime; 586 up_read(&nilfs->ns_segctor_sem); 587 588 return NILFS_SHOW_TIME(ctime, buf); 589 } 590 591 static ssize_t 592 nilfs_segctor_last_seg_write_time_secs_show(struct nilfs_segctor_attr *attr, 593 struct the_nilfs *nilfs, 594 char *buf) 595 { 596 time64_t ctime; 597 598 down_read(&nilfs->ns_segctor_sem); 599 ctime = nilfs->ns_ctime; 600 up_read(&nilfs->ns_segctor_sem); 601 602 return snprintf(buf, PAGE_SIZE, "%llu\n", ctime); 603 } 604 605 static ssize_t 606 nilfs_segctor_last_nongc_write_time_show(struct nilfs_segctor_attr *attr, 607 struct the_nilfs *nilfs, 608 char *buf) 609 { 610 time64_t nongc_ctime; 611 612 down_read(&nilfs->ns_segctor_sem); 613 nongc_ctime = nilfs->ns_nongc_ctime; 614 up_read(&nilfs->ns_segctor_sem); 615 616 return NILFS_SHOW_TIME(nongc_ctime, buf); 617 } 618 619 static ssize_t 620 nilfs_segctor_last_nongc_write_time_secs_show(struct nilfs_segctor_attr *attr, 621 struct the_nilfs *nilfs, 622 char *buf) 623 { 624 time64_t nongc_ctime; 625 626 down_read(&nilfs->ns_segctor_sem); 627 nongc_ctime = nilfs->ns_nongc_ctime; 628 up_read(&nilfs->ns_segctor_sem); 629 630 return snprintf(buf, PAGE_SIZE, "%llu\n", nongc_ctime); 631 } 632 633 static ssize_t 634 nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr, 635 struct the_nilfs *nilfs, 636 char *buf) 637 { 638 u32 ndirtyblks; 639 640 down_read(&nilfs->ns_segctor_sem); 641 ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks); 642 up_read(&nilfs->ns_segctor_sem); 643 644 return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks); 645 } 646 647 static const char segctor_readme_str[] = 648 "The segctor group contains attributes that describe\n" 649 "segctor thread activity details.\n\n" 650 "(1) last_pseg_block\n" 651 "\tshow start block number of the latest segment.\n\n" 652 "(2) last_seg_sequence\n" 653 "\tshow sequence value of the latest segment.\n\n" 654 "(3) last_seg_checkpoint\n" 655 "\tshow checkpoint number of the latest segment.\n\n" 656 "(4) current_seg_sequence\n\tshow segment sequence counter.\n\n" 657 "(5) current_last_full_seg\n" 658 "\tshow index number of the latest full segment.\n\n" 659 "(6) next_full_seg\n" 660 "\tshow index number of the full segment index to be used next.\n\n" 661 "(7) next_pseg_offset\n" 662 "\tshow offset of next partial segment in the current full segment.\n\n" 663 "(8) next_checkpoint\n\tshow next checkpoint number.\n\n" 664 "(9) last_seg_write_time\n" 665 "\tshow write time of the last segment in human-readable format.\n\n" 666 "(10) last_seg_write_time_secs\n" 667 "\tshow write time of the last segment in seconds.\n\n" 668 "(11) last_nongc_write_time\n" 669 "\tshow write time of the last segment not for cleaner operation " 670 "in human-readable format.\n\n" 671 "(12) last_nongc_write_time_secs\n" 672 "\tshow write time of the last segment not for cleaner operation " 673 "in seconds.\n\n" 674 "(13) dirty_data_blocks_count\n" 675 "\tshow number of dirty data blocks.\n\n"; 676 677 static ssize_t 678 nilfs_segctor_README_show(struct nilfs_segctor_attr *attr, 679 struct the_nilfs *nilfs, char *buf) 680 { 681 return snprintf(buf, PAGE_SIZE, segctor_readme_str); 682 } 683 684 NILFS_SEGCTOR_RO_ATTR(last_pseg_block); 685 NILFS_SEGCTOR_RO_ATTR(last_seg_sequence); 686 NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint); 687 NILFS_SEGCTOR_RO_ATTR(current_seg_sequence); 688 NILFS_SEGCTOR_RO_ATTR(current_last_full_seg); 689 NILFS_SEGCTOR_RO_ATTR(next_full_seg); 690 NILFS_SEGCTOR_RO_ATTR(next_pseg_offset); 691 NILFS_SEGCTOR_RO_ATTR(next_checkpoint); 692 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time); 693 NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs); 694 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time); 695 NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs); 696 NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count); 697 NILFS_SEGCTOR_RO_ATTR(README); 698 699 static struct attribute *nilfs_segctor_attrs[] = { 700 NILFS_SEGCTOR_ATTR_LIST(last_pseg_block), 701 NILFS_SEGCTOR_ATTR_LIST(last_seg_sequence), 702 NILFS_SEGCTOR_ATTR_LIST(last_seg_checkpoint), 703 NILFS_SEGCTOR_ATTR_LIST(current_seg_sequence), 704 NILFS_SEGCTOR_ATTR_LIST(current_last_full_seg), 705 NILFS_SEGCTOR_ATTR_LIST(next_full_seg), 706 NILFS_SEGCTOR_ATTR_LIST(next_pseg_offset), 707 NILFS_SEGCTOR_ATTR_LIST(next_checkpoint), 708 NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time), 709 NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time_secs), 710 NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time), 711 NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time_secs), 712 NILFS_SEGCTOR_ATTR_LIST(dirty_data_blocks_count), 713 NILFS_SEGCTOR_ATTR_LIST(README), 714 NULL, 715 }; 716 717 NILFS_DEV_INT_GROUP_OPS(segctor, dev); 718 NILFS_DEV_INT_GROUP_TYPE(segctor, dev); 719 NILFS_DEV_INT_GROUP_FNS(segctor, dev); 720 721 /************************************************************************ 722 * NILFS superblock attrs * 723 ************************************************************************/ 724 725 static ssize_t 726 nilfs_superblock_sb_write_time_show(struct nilfs_superblock_attr *attr, 727 struct the_nilfs *nilfs, 728 char *buf) 729 { 730 time64_t sbwtime; 731 732 down_read(&nilfs->ns_sem); 733 sbwtime = nilfs->ns_sbwtime; 734 up_read(&nilfs->ns_sem); 735 736 return NILFS_SHOW_TIME(sbwtime, buf); 737 } 738 739 static ssize_t 740 nilfs_superblock_sb_write_time_secs_show(struct nilfs_superblock_attr *attr, 741 struct the_nilfs *nilfs, 742 char *buf) 743 { 744 time64_t sbwtime; 745 746 down_read(&nilfs->ns_sem); 747 sbwtime = nilfs->ns_sbwtime; 748 up_read(&nilfs->ns_sem); 749 750 return snprintf(buf, PAGE_SIZE, "%llu\n", sbwtime); 751 } 752 753 static ssize_t 754 nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr, 755 struct the_nilfs *nilfs, 756 char *buf) 757 { 758 unsigned int sbwcount; 759 760 down_read(&nilfs->ns_sem); 761 sbwcount = nilfs->ns_sbwcount; 762 up_read(&nilfs->ns_sem); 763 764 return snprintf(buf, PAGE_SIZE, "%u\n", sbwcount); 765 } 766 767 static ssize_t 768 nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr, 769 struct the_nilfs *nilfs, 770 char *buf) 771 { 772 unsigned int sb_update_freq; 773 774 down_read(&nilfs->ns_sem); 775 sb_update_freq = nilfs->ns_sb_update_freq; 776 up_read(&nilfs->ns_sem); 777 778 return snprintf(buf, PAGE_SIZE, "%u\n", sb_update_freq); 779 } 780 781 static ssize_t 782 nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr, 783 struct the_nilfs *nilfs, 784 const char *buf, size_t count) 785 { 786 unsigned int val; 787 int err; 788 789 err = kstrtouint(skip_spaces(buf), 0, &val); 790 if (err) { 791 nilfs_msg(nilfs->ns_sb, KERN_ERR, 792 "unable to convert string: err=%d", err); 793 return err; 794 } 795 796 if (val < NILFS_SB_FREQ) { 797 val = NILFS_SB_FREQ; 798 nilfs_msg(nilfs->ns_sb, KERN_WARNING, 799 "superblock update frequency cannot be lesser than 10 seconds"); 800 } 801 802 down_write(&nilfs->ns_sem); 803 nilfs->ns_sb_update_freq = val; 804 up_write(&nilfs->ns_sem); 805 806 return count; 807 } 808 809 static const char sb_readme_str[] = 810 "The superblock group contains attributes that describe\n" 811 "superblock's details.\n\n" 812 "(1) sb_write_time\n\tshow previous write time of super block " 813 "in human-readable format.\n\n" 814 "(2) sb_write_time_secs\n\tshow previous write time of super block " 815 "in seconds.\n\n" 816 "(3) sb_write_count\n\tshow write count of super block.\n\n" 817 "(4) sb_update_frequency\n" 818 "\tshow/set interval of periodical update of superblock (in seconds).\n\n" 819 "\tYou can set preferable frequency of superblock update by command:\n\n" 820 "\t'echo <val> > /sys/fs/<nilfs>/<dev>/superblock/sb_update_frequency'\n"; 821 822 static ssize_t 823 nilfs_superblock_README_show(struct nilfs_superblock_attr *attr, 824 struct the_nilfs *nilfs, char *buf) 825 { 826 return snprintf(buf, PAGE_SIZE, sb_readme_str); 827 } 828 829 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time); 830 NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs); 831 NILFS_SUPERBLOCK_RO_ATTR(sb_write_count); 832 NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency); 833 NILFS_SUPERBLOCK_RO_ATTR(README); 834 835 static struct attribute *nilfs_superblock_attrs[] = { 836 NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time), 837 NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time_secs), 838 NILFS_SUPERBLOCK_ATTR_LIST(sb_write_count), 839 NILFS_SUPERBLOCK_ATTR_LIST(sb_update_frequency), 840 NILFS_SUPERBLOCK_ATTR_LIST(README), 841 NULL, 842 }; 843 844 NILFS_DEV_INT_GROUP_OPS(superblock, dev); 845 NILFS_DEV_INT_GROUP_TYPE(superblock, dev); 846 NILFS_DEV_INT_GROUP_FNS(superblock, dev); 847 848 /************************************************************************ 849 * NILFS device attrs * 850 ************************************************************************/ 851 852 static 853 ssize_t nilfs_dev_revision_show(struct nilfs_dev_attr *attr, 854 struct the_nilfs *nilfs, 855 char *buf) 856 { 857 struct nilfs_super_block **sbp = nilfs->ns_sbp; 858 u32 major = le32_to_cpu(sbp[0]->s_rev_level); 859 u16 minor = le16_to_cpu(sbp[0]->s_minor_rev_level); 860 861 return snprintf(buf, PAGE_SIZE, "%d.%d\n", major, minor); 862 } 863 864 static 865 ssize_t nilfs_dev_blocksize_show(struct nilfs_dev_attr *attr, 866 struct the_nilfs *nilfs, 867 char *buf) 868 { 869 return snprintf(buf, PAGE_SIZE, "%u\n", nilfs->ns_blocksize); 870 } 871 872 static 873 ssize_t nilfs_dev_device_size_show(struct nilfs_dev_attr *attr, 874 struct the_nilfs *nilfs, 875 char *buf) 876 { 877 struct nilfs_super_block **sbp = nilfs->ns_sbp; 878 u64 dev_size = le64_to_cpu(sbp[0]->s_dev_size); 879 880 return snprintf(buf, PAGE_SIZE, "%llu\n", dev_size); 881 } 882 883 static 884 ssize_t nilfs_dev_free_blocks_show(struct nilfs_dev_attr *attr, 885 struct the_nilfs *nilfs, 886 char *buf) 887 { 888 sector_t free_blocks = 0; 889 890 nilfs_count_free_blocks(nilfs, &free_blocks); 891 return snprintf(buf, PAGE_SIZE, "%llu\n", 892 (unsigned long long)free_blocks); 893 } 894 895 static 896 ssize_t nilfs_dev_uuid_show(struct nilfs_dev_attr *attr, 897 struct the_nilfs *nilfs, 898 char *buf) 899 { 900 struct nilfs_super_block **sbp = nilfs->ns_sbp; 901 902 return snprintf(buf, PAGE_SIZE, "%pUb\n", sbp[0]->s_uuid); 903 } 904 905 static 906 ssize_t nilfs_dev_volume_name_show(struct nilfs_dev_attr *attr, 907 struct the_nilfs *nilfs, 908 char *buf) 909 { 910 struct nilfs_super_block **sbp = nilfs->ns_sbp; 911 912 return scnprintf(buf, sizeof(sbp[0]->s_volume_name), "%s\n", 913 sbp[0]->s_volume_name); 914 } 915 916 static const char dev_readme_str[] = 917 "The <device> group contains attributes that describe file system\n" 918 "partition's details.\n\n" 919 "(1) revision\n\tshow NILFS file system revision.\n\n" 920 "(2) blocksize\n\tshow volume block size in bytes.\n\n" 921 "(3) device_size\n\tshow volume size in bytes.\n\n" 922 "(4) free_blocks\n\tshow count of free blocks on volume.\n\n" 923 "(5) uuid\n\tshow volume's UUID.\n\n" 924 "(6) volume_name\n\tshow volume's name.\n\n"; 925 926 static ssize_t nilfs_dev_README_show(struct nilfs_dev_attr *attr, 927 struct the_nilfs *nilfs, 928 char *buf) 929 { 930 return snprintf(buf, PAGE_SIZE, dev_readme_str); 931 } 932 933 NILFS_DEV_RO_ATTR(revision); 934 NILFS_DEV_RO_ATTR(blocksize); 935 NILFS_DEV_RO_ATTR(device_size); 936 NILFS_DEV_RO_ATTR(free_blocks); 937 NILFS_DEV_RO_ATTR(uuid); 938 NILFS_DEV_RO_ATTR(volume_name); 939 NILFS_DEV_RO_ATTR(README); 940 941 static struct attribute *nilfs_dev_attrs[] = { 942 NILFS_DEV_ATTR_LIST(revision), 943 NILFS_DEV_ATTR_LIST(blocksize), 944 NILFS_DEV_ATTR_LIST(device_size), 945 NILFS_DEV_ATTR_LIST(free_blocks), 946 NILFS_DEV_ATTR_LIST(uuid), 947 NILFS_DEV_ATTR_LIST(volume_name), 948 NILFS_DEV_ATTR_LIST(README), 949 NULL, 950 }; 951 952 static ssize_t nilfs_dev_attr_show(struct kobject *kobj, 953 struct attribute *attr, char *buf) 954 { 955 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, 956 ns_dev_kobj); 957 struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, 958 attr); 959 960 return a->show ? a->show(a, nilfs, buf) : 0; 961 } 962 963 static ssize_t nilfs_dev_attr_store(struct kobject *kobj, 964 struct attribute *attr, 965 const char *buf, size_t len) 966 { 967 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, 968 ns_dev_kobj); 969 struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, 970 attr); 971 972 return a->store ? a->store(a, nilfs, buf, len) : 0; 973 } 974 975 static void nilfs_dev_attr_release(struct kobject *kobj) 976 { 977 struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, 978 ns_dev_kobj); 979 complete(&nilfs->ns_dev_kobj_unregister); 980 } 981 982 static const struct sysfs_ops nilfs_dev_attr_ops = { 983 .show = nilfs_dev_attr_show, 984 .store = nilfs_dev_attr_store, 985 }; 986 987 static struct kobj_type nilfs_dev_ktype = { 988 .default_attrs = nilfs_dev_attrs, 989 .sysfs_ops = &nilfs_dev_attr_ops, 990 .release = nilfs_dev_attr_release, 991 }; 992 993 int nilfs_sysfs_create_device_group(struct super_block *sb) 994 { 995 struct the_nilfs *nilfs = sb->s_fs_info; 996 size_t devgrp_size = sizeof(struct nilfs_sysfs_dev_subgroups); 997 int err; 998 999 nilfs->ns_dev_subgroups = kzalloc(devgrp_size, GFP_KERNEL); 1000 if (unlikely(!nilfs->ns_dev_subgroups)) { 1001 err = -ENOMEM; 1002 nilfs_msg(sb, KERN_ERR, 1003 "unable to allocate memory for device group"); 1004 goto failed_create_device_group; 1005 } 1006 1007 nilfs->ns_dev_kobj.kset = nilfs_kset; 1008 init_completion(&nilfs->ns_dev_kobj_unregister); 1009 err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL, 1010 "%s", sb->s_id); 1011 if (err) 1012 goto free_dev_subgroups; 1013 1014 err = nilfs_sysfs_create_mounted_snapshots_group(nilfs); 1015 if (err) 1016 goto cleanup_dev_kobject; 1017 1018 err = nilfs_sysfs_create_checkpoints_group(nilfs); 1019 if (err) 1020 goto delete_mounted_snapshots_group; 1021 1022 err = nilfs_sysfs_create_segments_group(nilfs); 1023 if (err) 1024 goto delete_checkpoints_group; 1025 1026 err = nilfs_sysfs_create_superblock_group(nilfs); 1027 if (err) 1028 goto delete_segments_group; 1029 1030 err = nilfs_sysfs_create_segctor_group(nilfs); 1031 if (err) 1032 goto delete_superblock_group; 1033 1034 return 0; 1035 1036 delete_superblock_group: 1037 nilfs_sysfs_delete_superblock_group(nilfs); 1038 1039 delete_segments_group: 1040 nilfs_sysfs_delete_segments_group(nilfs); 1041 1042 delete_checkpoints_group: 1043 nilfs_sysfs_delete_checkpoints_group(nilfs); 1044 1045 delete_mounted_snapshots_group: 1046 nilfs_sysfs_delete_mounted_snapshots_group(nilfs); 1047 1048 cleanup_dev_kobject: 1049 kobject_del(&nilfs->ns_dev_kobj); 1050 1051 free_dev_subgroups: 1052 kfree(nilfs->ns_dev_subgroups); 1053 1054 failed_create_device_group: 1055 return err; 1056 } 1057 1058 void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs) 1059 { 1060 nilfs_sysfs_delete_mounted_snapshots_group(nilfs); 1061 nilfs_sysfs_delete_checkpoints_group(nilfs); 1062 nilfs_sysfs_delete_segments_group(nilfs); 1063 nilfs_sysfs_delete_superblock_group(nilfs); 1064 nilfs_sysfs_delete_segctor_group(nilfs); 1065 kobject_del(&nilfs->ns_dev_kobj); 1066 kfree(nilfs->ns_dev_subgroups); 1067 } 1068 1069 /************************************************************************ 1070 * NILFS feature attrs * 1071 ************************************************************************/ 1072 1073 static ssize_t nilfs_feature_revision_show(struct kobject *kobj, 1074 struct attribute *attr, char *buf) 1075 { 1076 return snprintf(buf, PAGE_SIZE, "%d.%d\n", 1077 NILFS_CURRENT_REV, NILFS_MINOR_REV); 1078 } 1079 1080 static const char features_readme_str[] = 1081 "The features group contains attributes that describe NILFS file\n" 1082 "system driver features.\n\n" 1083 "(1) revision\n\tshow current revision of NILFS file system driver.\n"; 1084 1085 static ssize_t nilfs_feature_README_show(struct kobject *kobj, 1086 struct attribute *attr, 1087 char *buf) 1088 { 1089 return snprintf(buf, PAGE_SIZE, features_readme_str); 1090 } 1091 1092 NILFS_FEATURE_RO_ATTR(revision); 1093 NILFS_FEATURE_RO_ATTR(README); 1094 1095 static struct attribute *nilfs_feature_attrs[] = { 1096 NILFS_FEATURE_ATTR_LIST(revision), 1097 NILFS_FEATURE_ATTR_LIST(README), 1098 NULL, 1099 }; 1100 1101 static const struct attribute_group nilfs_feature_attr_group = { 1102 .name = "features", 1103 .attrs = nilfs_feature_attrs, 1104 }; 1105 1106 int __init nilfs_sysfs_init(void) 1107 { 1108 int err; 1109 1110 nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj); 1111 if (!nilfs_kset) { 1112 err = -ENOMEM; 1113 nilfs_msg(NULL, KERN_ERR, 1114 "unable to create sysfs entry: err=%d", err); 1115 goto failed_sysfs_init; 1116 } 1117 1118 err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); 1119 if (unlikely(err)) { 1120 nilfs_msg(NULL, KERN_ERR, 1121 "unable to create feature group: err=%d", err); 1122 goto cleanup_sysfs_init; 1123 } 1124 1125 return 0; 1126 1127 cleanup_sysfs_init: 1128 kset_unregister(nilfs_kset); 1129 1130 failed_sysfs_init: 1131 return err; 1132 } 1133 1134 void nilfs_sysfs_exit(void) 1135 { 1136 sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); 1137 kset_unregister(nilfs_kset); 1138 } 1139