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>/ */ 29static struct kset *nilfs_kset; 30 31#define NILFS_SHOW_TIME(time_t_val, buf) ({ \ 32 struct tm res; \ 33 int count = 0; \ 34 time_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) \ 45static 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} \ 56static 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} \ 68static 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) \ 74static 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} \ 83static 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) \ 90static 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} \ 109static 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 118static ssize_t 119nilfs_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 126static ssize_t 127nilfs_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 134static 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 139static ssize_t 140nilfs_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 146NILFS_SNAPSHOT_RO_ATTR(inodes_count); 147NILFS_SNAPSHOT_RO_ATTR(blocks_count); 148NILFS_SNAPSHOT_RO_ATTR(README); 149 150static 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 157static 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 168static 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 180static 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 187static const struct sysfs_ops nilfs_snapshot_attr_ops = { 188 .show = nilfs_snapshot_attr_show, 189 .store = nilfs_snapshot_attr_store, 190}; 191 192static 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 198int 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 227void 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 236static const char mounted_snapshots_readme_str[] = 237 "The mounted_snapshots group contains group for\n" 238 "every mounted snapshot.\n"; 239 240static ssize_t 241nilfs_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 247NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README); 248 249static struct attribute *nilfs_mounted_snapshots_attrs[] = { 250 NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README), 251 NULL, 252}; 253 254NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev); 255NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev); 256NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev); 257 258/************************************************************************ 259 * NILFS checkpoints attrs * 260 ************************************************************************/ 261 262static ssize_t 263nilfs_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 printk(KERN_ERR "NILFS: unable to get checkpoint stat: err=%d\n", 276 err); 277 return err; 278 } 279 280 ncheckpoints = cpstat.cs_ncps; 281 282 return snprintf(buf, PAGE_SIZE, "%llu\n", ncheckpoints); 283} 284 285static ssize_t 286nilfs_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 printk(KERN_ERR "NILFS: unable to get checkpoint stat: err=%d\n", 299 err); 300 return err; 301 } 302 303 nsnapshots = cpstat.cs_nsss; 304 305 return snprintf(buf, PAGE_SIZE, "%llu\n", nsnapshots); 306} 307 308static ssize_t 309nilfs_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 322static ssize_t 323nilfs_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_sem); 330 cno = nilfs->ns_cno; 331 up_read(&nilfs->ns_sem); 332 333 return snprintf(buf, PAGE_SIZE, "%llu\n", cno); 334} 335 336static 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 345static ssize_t 346nilfs_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 352NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number); 353NILFS_CHECKPOINTS_RO_ATTR(snapshots_number); 354NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint); 355NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint); 356NILFS_CHECKPOINTS_RO_ATTR(README); 357 358static 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 367NILFS_DEV_INT_GROUP_OPS(checkpoints, dev); 368NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev); 369NILFS_DEV_INT_GROUP_FNS(checkpoints, dev); 370 371/************************************************************************ 372 * NILFS segments attrs * 373 ************************************************************************/ 374 375static ssize_t 376nilfs_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 383static ssize_t 384nilfs_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 391static ssize_t 392nilfs_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 405static ssize_t 406nilfs_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 printk(KERN_ERR "NILFS: unable to get segment stat: err=%d\n", 418 err); 419 return err; 420 } 421 422 return snprintf(buf, PAGE_SIZE, "%llu\n", sustat.ss_ndirtysegs); 423} 424 425static 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 433static ssize_t 434nilfs_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 441NILFS_SEGMENTS_RO_ATTR(segments_number); 442NILFS_SEGMENTS_RO_ATTR(blocks_per_segment); 443NILFS_SEGMENTS_RO_ATTR(clean_segments); 444NILFS_SEGMENTS_RO_ATTR(dirty_segments); 445NILFS_SEGMENTS_RO_ATTR(README); 446 447static 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 456NILFS_DEV_INT_GROUP_OPS(segments, dev); 457NILFS_DEV_INT_GROUP_TYPE(segments, dev); 458NILFS_DEV_INT_GROUP_FNS(segments, dev); 459 460/************************************************************************ 461 * NILFS segctor attrs * 462 ************************************************************************/ 463 464static ssize_t 465nilfs_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 479static ssize_t 480nilfs_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 493static ssize_t 494nilfs_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 507static ssize_t 508nilfs_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_sem); 515 seg_seq = nilfs->ns_seg_seq; 516 up_read(&nilfs->ns_sem); 517 518 return snprintf(buf, PAGE_SIZE, "%llu\n", seg_seq); 519} 520 521static ssize_t 522nilfs_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_sem); 529 segnum = nilfs->ns_segnum; 530 up_read(&nilfs->ns_sem); 531 532 return snprintf(buf, PAGE_SIZE, "%llu\n", segnum); 533} 534 535static ssize_t 536nilfs_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_sem); 543 nextnum = nilfs->ns_nextnum; 544 up_read(&nilfs->ns_sem); 545 546 return snprintf(buf, PAGE_SIZE, "%llu\n", nextnum); 547} 548 549static ssize_t 550nilfs_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_sem); 557 pseg_offset = nilfs->ns_pseg_offset; 558 up_read(&nilfs->ns_sem); 559 560 return snprintf(buf, PAGE_SIZE, "%lu\n", pseg_offset); 561} 562 563static ssize_t 564nilfs_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_sem); 571 cno = nilfs->ns_cno; 572 up_read(&nilfs->ns_sem); 573 574 return snprintf(buf, PAGE_SIZE, "%llu\n", cno); 575} 576 577static ssize_t 578nilfs_segctor_last_seg_write_time_show(struct nilfs_segctor_attr *attr, 579 struct the_nilfs *nilfs, 580 char *buf) 581{ 582 time_t ctime; 583 584 down_read(&nilfs->ns_sem); 585 ctime = nilfs->ns_ctime; 586 up_read(&nilfs->ns_sem); 587 588 return NILFS_SHOW_TIME(ctime, buf); 589} 590 591static ssize_t 592nilfs_segctor_last_seg_write_time_secs_show(struct nilfs_segctor_attr *attr, 593 struct the_nilfs *nilfs, 594 char *buf) 595{ 596 time_t ctime; 597 598 down_read(&nilfs->ns_sem); 599 ctime = nilfs->ns_ctime; 600 up_read(&nilfs->ns_sem); 601 602 return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)ctime); 603} 604 605static ssize_t 606nilfs_segctor_last_nongc_write_time_show(struct nilfs_segctor_attr *attr, 607 struct the_nilfs *nilfs, 608 char *buf) 609{ 610 time_t nongc_ctime; 611 612 down_read(&nilfs->ns_sem); 613 nongc_ctime = nilfs->ns_nongc_ctime; 614 up_read(&nilfs->ns_sem); 615 616 return NILFS_SHOW_TIME(nongc_ctime, buf); 617} 618 619static ssize_t 620nilfs_segctor_last_nongc_write_time_secs_show(struct nilfs_segctor_attr *attr, 621 struct the_nilfs *nilfs, 622 char *buf) 623{ 624 time_t nongc_ctime; 625 626 down_read(&nilfs->ns_sem); 627 nongc_ctime = nilfs->ns_nongc_ctime; 628 up_read(&nilfs->ns_sem); 629 630 return snprintf(buf, PAGE_SIZE, "%llu\n", 631 (unsigned long long)nongc_ctime); 632} 633 634static ssize_t 635nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr, 636 struct the_nilfs *nilfs, 637 char *buf) 638{ 639 u32 ndirtyblks; 640 641 down_read(&nilfs->ns_sem); 642 ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks); 643 up_read(&nilfs->ns_sem); 644 645 return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks); 646} 647 648static const char segctor_readme_str[] = 649 "The segctor group contains attributes that describe\n" 650 "segctor thread activity details.\n\n" 651 "(1) last_pseg_block\n" 652 "\tshow start block number of the latest segment.\n\n" 653 "(2) last_seg_sequence\n" 654 "\tshow sequence value of the latest segment.\n\n" 655 "(3) last_seg_checkpoint\n" 656 "\tshow checkpoint number of the latest segment.\n\n" 657 "(4) current_seg_sequence\n\tshow segment sequence counter.\n\n" 658 "(5) current_last_full_seg\n" 659 "\tshow index number of the latest full segment.\n\n" 660 "(6) next_full_seg\n" 661 "\tshow index number of the full segment index to be used next.\n\n" 662 "(7) next_pseg_offset\n" 663 "\tshow offset of next partial segment in the current full segment.\n\n" 664 "(8) next_checkpoint\n\tshow next checkpoint number.\n\n" 665 "(9) last_seg_write_time\n" 666 "\tshow write time of the last segment in human-readable format.\n\n" 667 "(10) last_seg_write_time_secs\n" 668 "\tshow write time of the last segment in seconds.\n\n" 669 "(11) last_nongc_write_time\n" 670 "\tshow write time of the last segment not for cleaner operation " 671 "in human-readable format.\n\n" 672 "(12) last_nongc_write_time_secs\n" 673 "\tshow write time of the last segment not for cleaner operation " 674 "in seconds.\n\n" 675 "(13) dirty_data_blocks_count\n" 676 "\tshow number of dirty data blocks.\n\n"; 677 678static ssize_t 679nilfs_segctor_README_show(struct nilfs_segctor_attr *attr, 680 struct the_nilfs *nilfs, char *buf) 681{ 682 return snprintf(buf, PAGE_SIZE, segctor_readme_str); 683} 684 685NILFS_SEGCTOR_RO_ATTR(last_pseg_block); 686NILFS_SEGCTOR_RO_ATTR(last_seg_sequence); 687NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint); 688NILFS_SEGCTOR_RO_ATTR(current_seg_sequence); 689NILFS_SEGCTOR_RO_ATTR(current_last_full_seg); 690NILFS_SEGCTOR_RO_ATTR(next_full_seg); 691NILFS_SEGCTOR_RO_ATTR(next_pseg_offset); 692NILFS_SEGCTOR_RO_ATTR(next_checkpoint); 693NILFS_SEGCTOR_RO_ATTR(last_seg_write_time); 694NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs); 695NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time); 696NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs); 697NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count); 698NILFS_SEGCTOR_RO_ATTR(README); 699 700static struct attribute *nilfs_segctor_attrs[] = { 701 NILFS_SEGCTOR_ATTR_LIST(last_pseg_block), 702 NILFS_SEGCTOR_ATTR_LIST(last_seg_sequence), 703 NILFS_SEGCTOR_ATTR_LIST(last_seg_checkpoint), 704 NILFS_SEGCTOR_ATTR_LIST(current_seg_sequence), 705 NILFS_SEGCTOR_ATTR_LIST(current_last_full_seg), 706 NILFS_SEGCTOR_ATTR_LIST(next_full_seg), 707 NILFS_SEGCTOR_ATTR_LIST(next_pseg_offset), 708 NILFS_SEGCTOR_ATTR_LIST(next_checkpoint), 709 NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time), 710 NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time_secs), 711 NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time), 712 NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time_secs), 713 NILFS_SEGCTOR_ATTR_LIST(dirty_data_blocks_count), 714 NILFS_SEGCTOR_ATTR_LIST(README), 715 NULL, 716}; 717 718NILFS_DEV_INT_GROUP_OPS(segctor, dev); 719NILFS_DEV_INT_GROUP_TYPE(segctor, dev); 720NILFS_DEV_INT_GROUP_FNS(segctor, dev); 721 722/************************************************************************ 723 * NILFS superblock attrs * 724 ************************************************************************/ 725 726static ssize_t 727nilfs_superblock_sb_write_time_show(struct nilfs_superblock_attr *attr, 728 struct the_nilfs *nilfs, 729 char *buf) 730{ 731 time_t sbwtime; 732 733 down_read(&nilfs->ns_sem); 734 sbwtime = nilfs->ns_sbwtime; 735 up_read(&nilfs->ns_sem); 736 737 return NILFS_SHOW_TIME(sbwtime, buf); 738} 739 740static ssize_t 741nilfs_superblock_sb_write_time_secs_show(struct nilfs_superblock_attr *attr, 742 struct the_nilfs *nilfs, 743 char *buf) 744{ 745 time_t sbwtime; 746 747 down_read(&nilfs->ns_sem); 748 sbwtime = nilfs->ns_sbwtime; 749 up_read(&nilfs->ns_sem); 750 751 return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)sbwtime); 752} 753 754static ssize_t 755nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr, 756 struct the_nilfs *nilfs, 757 char *buf) 758{ 759 unsigned sbwcount; 760 761 down_read(&nilfs->ns_sem); 762 sbwcount = nilfs->ns_sbwcount; 763 up_read(&nilfs->ns_sem); 764 765 return snprintf(buf, PAGE_SIZE, "%u\n", sbwcount); 766} 767 768static ssize_t 769nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr, 770 struct the_nilfs *nilfs, 771 char *buf) 772{ 773 unsigned sb_update_freq; 774 775 down_read(&nilfs->ns_sem); 776 sb_update_freq = nilfs->ns_sb_update_freq; 777 up_read(&nilfs->ns_sem); 778 779 return snprintf(buf, PAGE_SIZE, "%u\n", sb_update_freq); 780} 781 782static ssize_t 783nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr, 784 struct the_nilfs *nilfs, 785 const char *buf, size_t count) 786{ 787 unsigned val; 788 int err; 789 790 err = kstrtouint(skip_spaces(buf), 0, &val); 791 if (err) { 792 printk(KERN_ERR "NILFS: unable to convert string: err=%d\n", 793 err); 794 return err; 795 } 796 797 if (val < NILFS_SB_FREQ) { 798 val = NILFS_SB_FREQ; 799 printk(KERN_WARNING "NILFS: superblock update frequency cannot be lesser than 10 seconds\n"); 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 809static 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 822static ssize_t 823nilfs_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 829NILFS_SUPERBLOCK_RO_ATTR(sb_write_time); 830NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs); 831NILFS_SUPERBLOCK_RO_ATTR(sb_write_count); 832NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency); 833NILFS_SUPERBLOCK_RO_ATTR(README); 834 835static 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 844NILFS_DEV_INT_GROUP_OPS(superblock, dev); 845NILFS_DEV_INT_GROUP_TYPE(superblock, dev); 846NILFS_DEV_INT_GROUP_FNS(superblock, dev); 847 848/************************************************************************ 849 * NILFS device attrs * 850 ************************************************************************/ 851 852static 853ssize_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 864static 865ssize_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 872static 873ssize_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 883static 884ssize_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 895static 896ssize_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 905static 906ssize_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 916static 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 926static 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 933NILFS_DEV_RO_ATTR(revision); 934NILFS_DEV_RO_ATTR(blocksize); 935NILFS_DEV_RO_ATTR(device_size); 936NILFS_DEV_RO_ATTR(free_blocks); 937NILFS_DEV_RO_ATTR(uuid); 938NILFS_DEV_RO_ATTR(volume_name); 939NILFS_DEV_RO_ATTR(README); 940 941static 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 952static 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 963static 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 975static 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 982static const struct sysfs_ops nilfs_dev_attr_ops = { 983 .show = nilfs_dev_attr_show, 984 .store = nilfs_dev_attr_store, 985}; 986 987static 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 993int 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 printk(KERN_ERR "NILFS: unable to allocate memory for device group\n"); 1003 goto failed_create_device_group; 1004 } 1005 1006 nilfs->ns_dev_kobj.kset = nilfs_kset; 1007 init_completion(&nilfs->ns_dev_kobj_unregister); 1008 err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL, 1009 "%s", sb->s_id); 1010 if (err) 1011 goto free_dev_subgroups; 1012 1013 err = nilfs_sysfs_create_mounted_snapshots_group(nilfs); 1014 if (err) 1015 goto cleanup_dev_kobject; 1016 1017 err = nilfs_sysfs_create_checkpoints_group(nilfs); 1018 if (err) 1019 goto delete_mounted_snapshots_group; 1020 1021 err = nilfs_sysfs_create_segments_group(nilfs); 1022 if (err) 1023 goto delete_checkpoints_group; 1024 1025 err = nilfs_sysfs_create_superblock_group(nilfs); 1026 if (err) 1027 goto delete_segments_group; 1028 1029 err = nilfs_sysfs_create_segctor_group(nilfs); 1030 if (err) 1031 goto delete_superblock_group; 1032 1033 return 0; 1034 1035delete_superblock_group: 1036 nilfs_sysfs_delete_superblock_group(nilfs); 1037 1038delete_segments_group: 1039 nilfs_sysfs_delete_segments_group(nilfs); 1040 1041delete_checkpoints_group: 1042 nilfs_sysfs_delete_checkpoints_group(nilfs); 1043 1044delete_mounted_snapshots_group: 1045 nilfs_sysfs_delete_mounted_snapshots_group(nilfs); 1046 1047cleanup_dev_kobject: 1048 kobject_del(&nilfs->ns_dev_kobj); 1049 1050free_dev_subgroups: 1051 kfree(nilfs->ns_dev_subgroups); 1052 1053failed_create_device_group: 1054 return err; 1055} 1056 1057void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs) 1058{ 1059 nilfs_sysfs_delete_mounted_snapshots_group(nilfs); 1060 nilfs_sysfs_delete_checkpoints_group(nilfs); 1061 nilfs_sysfs_delete_segments_group(nilfs); 1062 nilfs_sysfs_delete_superblock_group(nilfs); 1063 nilfs_sysfs_delete_segctor_group(nilfs); 1064 kobject_del(&nilfs->ns_dev_kobj); 1065 kfree(nilfs->ns_dev_subgroups); 1066} 1067 1068/************************************************************************ 1069 * NILFS feature attrs * 1070 ************************************************************************/ 1071 1072static ssize_t nilfs_feature_revision_show(struct kobject *kobj, 1073 struct attribute *attr, char *buf) 1074{ 1075 return snprintf(buf, PAGE_SIZE, "%d.%d\n", 1076 NILFS_CURRENT_REV, NILFS_MINOR_REV); 1077} 1078 1079static const char features_readme_str[] = 1080 "The features group contains attributes that describe NILFS file\n" 1081 "system driver features.\n\n" 1082 "(1) revision\n\tshow current revision of NILFS file system driver.\n"; 1083 1084static ssize_t nilfs_feature_README_show(struct kobject *kobj, 1085 struct attribute *attr, 1086 char *buf) 1087{ 1088 return snprintf(buf, PAGE_SIZE, features_readme_str); 1089} 1090 1091NILFS_FEATURE_RO_ATTR(revision); 1092NILFS_FEATURE_RO_ATTR(README); 1093 1094static struct attribute *nilfs_feature_attrs[] = { 1095 NILFS_FEATURE_ATTR_LIST(revision), 1096 NILFS_FEATURE_ATTR_LIST(README), 1097 NULL, 1098}; 1099 1100static const struct attribute_group nilfs_feature_attr_group = { 1101 .name = "features", 1102 .attrs = nilfs_feature_attrs, 1103}; 1104 1105int __init nilfs_sysfs_init(void) 1106{ 1107 int err; 1108 1109 nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj); 1110 if (!nilfs_kset) { 1111 err = -ENOMEM; 1112 printk(KERN_ERR "NILFS: unable to create sysfs entry: err %d\n", 1113 err); 1114 goto failed_sysfs_init; 1115 } 1116 1117 err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); 1118 if (unlikely(err)) { 1119 printk(KERN_ERR "NILFS: unable to create feature group: err %d\n", 1120 err); 1121 goto cleanup_sysfs_init; 1122 } 1123 1124 return 0; 1125 1126cleanup_sysfs_init: 1127 kset_unregister(nilfs_kset); 1128 1129failed_sysfs_init: 1130 return err; 1131} 1132 1133void nilfs_sysfs_exit(void) 1134{ 1135 sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); 1136 kset_unregister(nilfs_kset); 1137} 1138