1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 /* 2 /*
3 * Simple file system for zoned block devices 3 * Simple file system for zoned block devices exposing zones as files.
4 * 4 *
5 * Copyright (C) 2022 Western Digital Corporat 5 * Copyright (C) 2022 Western Digital Corporation or its affiliates.
6 */ 6 */
7 #include <linux/fs.h> 7 #include <linux/fs.h>
8 #include <linux/seq_file.h> 8 #include <linux/seq_file.h>
9 #include <linux/blkdev.h> 9 #include <linux/blkdev.h>
10 10
11 #include "zonefs.h" 11 #include "zonefs.h"
12 12
13 struct zonefs_sysfs_attr { 13 struct zonefs_sysfs_attr {
14 struct attribute attr; 14 struct attribute attr;
15 ssize_t (*show)(struct zonefs_sb_info 15 ssize_t (*show)(struct zonefs_sb_info *sbi, char *buf);
16 }; 16 };
17 17
>> 18 static inline struct zonefs_sysfs_attr *to_attr(struct attribute *attr)
>> 19 {
>> 20 return container_of(attr, struct zonefs_sysfs_attr, attr);
>> 21 }
>> 22
18 #define ZONEFS_SYSFS_ATTR_RO(name) \ 23 #define ZONEFS_SYSFS_ATTR_RO(name) \
19 static struct zonefs_sysfs_attr zonefs_sysfs_a 24 static struct zonefs_sysfs_attr zonefs_sysfs_attr_##name = __ATTR_RO(name)
20 25
21 #define ATTR_LIST(name) &zonefs_sysfs_attr_##n 26 #define ATTR_LIST(name) &zonefs_sysfs_attr_##name.attr
22 27
23 static ssize_t zonefs_sysfs_attr_show(struct k 28 static ssize_t zonefs_sysfs_attr_show(struct kobject *kobj,
24 struct a 29 struct attribute *attr, char *buf)
25 { 30 {
26 struct zonefs_sb_info *sbi = 31 struct zonefs_sb_info *sbi =
27 container_of(kobj, struct zone 32 container_of(kobj, struct zonefs_sb_info, s_kobj);
28 struct zonefs_sysfs_attr *zonefs_attr 33 struct zonefs_sysfs_attr *zonefs_attr =
29 container_of(attr, struct zone 34 container_of(attr, struct zonefs_sysfs_attr, attr);
30 35
31 if (!zonefs_attr->show) 36 if (!zonefs_attr->show)
32 return 0; 37 return 0;
33 38
34 return zonefs_attr->show(sbi, buf); 39 return zonefs_attr->show(sbi, buf);
35 } 40 }
36 41
37 static ssize_t max_wro_seq_files_show(struct z 42 static ssize_t max_wro_seq_files_show(struct zonefs_sb_info *sbi, char *buf)
38 { 43 {
39 return sysfs_emit(buf, "%u\n", sbi->s_ 44 return sysfs_emit(buf, "%u\n", sbi->s_max_wro_seq_files);
40 } 45 }
41 ZONEFS_SYSFS_ATTR_RO(max_wro_seq_files); 46 ZONEFS_SYSFS_ATTR_RO(max_wro_seq_files);
42 47
43 static ssize_t nr_wro_seq_files_show(struct zo 48 static ssize_t nr_wro_seq_files_show(struct zonefs_sb_info *sbi, char *buf)
44 { 49 {
45 return sysfs_emit(buf, "%d\n", atomic_ 50 return sysfs_emit(buf, "%d\n", atomic_read(&sbi->s_wro_seq_files));
46 } 51 }
47 ZONEFS_SYSFS_ATTR_RO(nr_wro_seq_files); 52 ZONEFS_SYSFS_ATTR_RO(nr_wro_seq_files);
48 53
49 static ssize_t max_active_seq_files_show(struc 54 static ssize_t max_active_seq_files_show(struct zonefs_sb_info *sbi, char *buf)
50 { 55 {
51 return sysfs_emit(buf, "%u\n", sbi->s_ 56 return sysfs_emit(buf, "%u\n", sbi->s_max_active_seq_files);
52 } 57 }
53 ZONEFS_SYSFS_ATTR_RO(max_active_seq_files); 58 ZONEFS_SYSFS_ATTR_RO(max_active_seq_files);
54 59
55 static ssize_t nr_active_seq_files_show(struct 60 static ssize_t nr_active_seq_files_show(struct zonefs_sb_info *sbi, char *buf)
56 { 61 {
57 return sysfs_emit(buf, "%d\n", atomic_ 62 return sysfs_emit(buf, "%d\n", atomic_read(&sbi->s_active_seq_files));
58 } 63 }
59 ZONEFS_SYSFS_ATTR_RO(nr_active_seq_files); 64 ZONEFS_SYSFS_ATTR_RO(nr_active_seq_files);
60 65
61 static struct attribute *zonefs_sysfs_attrs[] 66 static struct attribute *zonefs_sysfs_attrs[] = {
62 ATTR_LIST(max_wro_seq_files), 67 ATTR_LIST(max_wro_seq_files),
63 ATTR_LIST(nr_wro_seq_files), 68 ATTR_LIST(nr_wro_seq_files),
64 ATTR_LIST(max_active_seq_files), 69 ATTR_LIST(max_active_seq_files),
65 ATTR_LIST(nr_active_seq_files), 70 ATTR_LIST(nr_active_seq_files),
66 NULL, 71 NULL,
67 }; 72 };
68 ATTRIBUTE_GROUPS(zonefs_sysfs); 73 ATTRIBUTE_GROUPS(zonefs_sysfs);
69 74
70 static void zonefs_sysfs_sb_release(struct kob 75 static void zonefs_sysfs_sb_release(struct kobject *kobj)
71 { 76 {
72 struct zonefs_sb_info *sbi = 77 struct zonefs_sb_info *sbi =
73 container_of(kobj, struct zone 78 container_of(kobj, struct zonefs_sb_info, s_kobj);
74 79
75 complete(&sbi->s_kobj_unregister); 80 complete(&sbi->s_kobj_unregister);
76 } 81 }
77 82
78 static const struct sysfs_ops zonefs_sysfs_att 83 static const struct sysfs_ops zonefs_sysfs_attr_ops = {
79 .show = zonefs_sysfs_attr_show, 84 .show = zonefs_sysfs_attr_show,
80 }; 85 };
81 86
82 static const struct kobj_type zonefs_sb_ktype !! 87 static struct kobj_type zonefs_sb_ktype = {
83 .default_groups = zonefs_sysfs_groups, 88 .default_groups = zonefs_sysfs_groups,
84 .sysfs_ops = &zonefs_sysfs_attr_o 89 .sysfs_ops = &zonefs_sysfs_attr_ops,
85 .release = zonefs_sysfs_sb_rele 90 .release = zonefs_sysfs_sb_release,
86 }; 91 };
87 92
88 static struct kobject *zonefs_sysfs_root; 93 static struct kobject *zonefs_sysfs_root;
89 94
90 int zonefs_sysfs_register(struct super_block * 95 int zonefs_sysfs_register(struct super_block *sb)
91 { 96 {
92 struct zonefs_sb_info *sbi = ZONEFS_SB 97 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);
93 int ret; 98 int ret;
94 99
95 init_completion(&sbi->s_kobj_unregiste 100 init_completion(&sbi->s_kobj_unregister);
96 ret = kobject_init_and_add(&sbi->s_kob 101 ret = kobject_init_and_add(&sbi->s_kobj, &zonefs_sb_ktype,
97 zonefs_sysf 102 zonefs_sysfs_root, "%s", sb->s_id);
98 if (ret) { 103 if (ret) {
99 kobject_put(&sbi->s_kobj); 104 kobject_put(&sbi->s_kobj);
100 wait_for_completion(&sbi->s_ko 105 wait_for_completion(&sbi->s_kobj_unregister);
101 return ret; 106 return ret;
102 } 107 }
103 108
104 sbi->s_sysfs_registered = true; 109 sbi->s_sysfs_registered = true;
105 110
106 return 0; 111 return 0;
107 } 112 }
108 113
109 void zonefs_sysfs_unregister(struct super_bloc 114 void zonefs_sysfs_unregister(struct super_block *sb)
110 { 115 {
111 struct zonefs_sb_info *sbi = ZONEFS_SB 116 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);
112 117
113 if (!sbi || !sbi->s_sysfs_registered) 118 if (!sbi || !sbi->s_sysfs_registered)
114 return; 119 return;
115 120
116 kobject_del(&sbi->s_kobj); 121 kobject_del(&sbi->s_kobj);
117 kobject_put(&sbi->s_kobj); 122 kobject_put(&sbi->s_kobj);
118 wait_for_completion(&sbi->s_kobj_unreg 123 wait_for_completion(&sbi->s_kobj_unregister);
119 } 124 }
120 125
121 int __init zonefs_sysfs_init(void) 126 int __init zonefs_sysfs_init(void)
122 { 127 {
123 zonefs_sysfs_root = kobject_create_and 128 zonefs_sysfs_root = kobject_create_and_add("zonefs", fs_kobj);
124 if (!zonefs_sysfs_root) 129 if (!zonefs_sysfs_root)
125 return -ENOMEM; 130 return -ENOMEM;
126 131
127 return 0; 132 return 0;
128 } 133 }
129 134
130 void zonefs_sysfs_exit(void) 135 void zonefs_sysfs_exit(void)
131 { 136 {
132 kobject_put(zonefs_sysfs_root); 137 kobject_put(zonefs_sysfs_root);
133 zonefs_sysfs_root = NULL; 138 zonefs_sysfs_root = NULL;
134 } 139 }
135 140
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.