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