projects/linux·blob master · refs

304 lines · 7.1 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C), 2008-2021, OPPO Mobile Comm Corp., Ltd.
4 * https://www.oppo.com/
5 */
6#include <linux/sysfs.h>
7#include <linux/kobject.h>
8
9#include "internal.h"
10#include "compress.h"
11
12enum {
13 attr_feature,
14 attr_drop_caches,
15 attr_pointer_ui,
16 attr_pointer_bool,
17 attr_accel,
18};
19
20enum {
21 struct_erofs_sb_info,
22 struct_erofs_mount_opts,
23};
24
25struct erofs_attr {
26 struct attribute attr;
27 short attr_id;
28 int struct_type, offset;
29};
30
31#define EROFS_ATTR(_name, _mode, _id) \
32static struct erofs_attr erofs_attr_##_name = { \
33 .attr = {.name = __stringify(_name), .mode = _mode }, \
34 .attr_id = attr_##_id, \
35}
36#define EROFS_ATTR_FUNC(_name, _mode) EROFS_ATTR(_name, _mode, _name)
37#define EROFS_ATTR_FEATURE(_name) EROFS_ATTR(_name, 0444, feature)
38
39#define EROFS_ATTR_OFFSET(_name, _mode, _id, _struct) \
40static struct erofs_attr erofs_attr_##_name = { \
41 .attr = {.name = __stringify(_name), .mode = _mode }, \
42 .attr_id = attr_##_id, \
43 .struct_type = struct_##_struct, \
44 .offset = offsetof(struct _struct, _name),\
45}
46
47#define EROFS_ATTR_RW(_name, _id, _struct) \
48 EROFS_ATTR_OFFSET(_name, 0644, _id, _struct)
49
50#define EROFS_RO_ATTR(_name, _id, _struct) \
51 EROFS_ATTR_OFFSET(_name, 0444, _id, _struct)
52
53#define EROFS_ATTR_RW_UI(_name, _struct) \
54 EROFS_ATTR_RW(_name, pointer_ui, _struct)
55
56#define EROFS_ATTR_RW_BOOL(_name, _struct) \
57 EROFS_ATTR_RW(_name, pointer_bool, _struct)
58
59#define ATTR_LIST(name) (&erofs_attr_##name.attr)
60
61#ifdef CONFIG_EROFS_FS_ZIP
62EROFS_ATTR_RW_UI(sync_decompress, erofs_sb_info);
63EROFS_ATTR_FUNC(drop_caches, 0200);
64#endif
65#ifdef CONFIG_EROFS_FS_ZIP_ACCEL
66EROFS_ATTR_FUNC(accel, 0644);
67#endif
68EROFS_ATTR_RW_UI(dir_ra_bytes, erofs_sb_info);
69
70static struct attribute *erofs_sb_attrs[] = {
71#ifdef CONFIG_EROFS_FS_ZIP
72 ATTR_LIST(sync_decompress),
73 ATTR_LIST(drop_caches),
74#endif
75 ATTR_LIST(dir_ra_bytes),
76 NULL,
77};
78ATTRIBUTE_GROUPS(erofs_sb);
79
80static struct attribute *erofs_attrs[] = {
81#ifdef CONFIG_EROFS_FS_ZIP_ACCEL
82 ATTR_LIST(accel),
83#endif
84 NULL,
85};
86ATTRIBUTE_GROUPS(erofs);
87
88/* Features this copy of erofs supports */
89EROFS_ATTR_FEATURE(compr_cfgs);
90EROFS_ATTR_FEATURE(big_pcluster);
91EROFS_ATTR_FEATURE(chunked_file);
92EROFS_ATTR_FEATURE(device_table);
93EROFS_ATTR_FEATURE(compr_head2);
94EROFS_ATTR_FEATURE(sb_chksum);
95EROFS_ATTR_FEATURE(ztailpacking);
96EROFS_ATTR_FEATURE(fragments);
97EROFS_ATTR_FEATURE(dedupe);
98EROFS_ATTR_FEATURE(xattr_prefixes);
99EROFS_ATTR_FEATURE(48bit);
100EROFS_ATTR_FEATURE(metabox);
101
102static struct attribute *erofs_feat_attrs[] = {
103 ATTR_LIST(compr_cfgs),
104 ATTR_LIST(big_pcluster),
105 ATTR_LIST(chunked_file),
106 ATTR_LIST(device_table),
107 ATTR_LIST(compr_head2),
108 ATTR_LIST(sb_chksum),
109 ATTR_LIST(ztailpacking),
110 ATTR_LIST(fragments),
111 ATTR_LIST(dedupe),
112 ATTR_LIST(xattr_prefixes),
113 ATTR_LIST(48bit),
114 ATTR_LIST(metabox),
115 NULL,
116};
117ATTRIBUTE_GROUPS(erofs_feat);
118
119static unsigned char *__struct_ptr(struct erofs_sb_info *sbi,
120 int struct_type, int offset)
121{
122 if (struct_type == struct_erofs_sb_info)
123 return (unsigned char *)sbi + offset;
124 if (struct_type == struct_erofs_mount_opts)
125 return (unsigned char *)&sbi->opt + offset;
126 return NULL;
127}
128
129static ssize_t erofs_attr_show(struct kobject *kobj,
130 struct attribute *attr, char *buf)
131{
132 struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
133 s_kobj);
134 struct erofs_attr *a = container_of(attr, struct erofs_attr, attr);
135 unsigned char *ptr = __struct_ptr(sbi, a->struct_type, a->offset);
136
137 switch (a->attr_id) {
138 case attr_feature:
139 return sysfs_emit(buf, "supported\n");
140 case attr_pointer_ui:
141 if (!ptr)
142 return 0;
143 return sysfs_emit(buf, "%u\n", *(unsigned int *)ptr);
144 case attr_pointer_bool:
145 if (!ptr)
146 return 0;
147 return sysfs_emit(buf, "%d\n", *(bool *)ptr);
148 case attr_accel:
149 return z_erofs_crypto_show_engines(buf, PAGE_SIZE, '\n');
150 }
151 return 0;
152}
153
154static ssize_t erofs_attr_store(struct kobject *kobj, struct attribute *attr,
155 const char *buf, size_t len)
156{
157 struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
158 s_kobj);
159 struct erofs_attr *a = container_of(attr, struct erofs_attr, attr);
160 unsigned char *ptr = __struct_ptr(sbi, a->struct_type, a->offset);
161 unsigned long t;
162 int ret;
163
164 switch (a->attr_id) {
165 case attr_pointer_ui:
166 if (!ptr)
167 return 0;
168 ret = kstrtoul(skip_spaces(buf), 0, &t);
169 if (ret)
170 return ret;
171 if (t != (unsigned int)t)
172 return -ERANGE;
173 if (IS_ENABLED(CONFIG_EROFS_FS_ZIP) &&
174 !strcmp(a->attr.name, "sync_decompress") &&
175 (t > EROFS_SYNC_DECOMPRESS_FORCE_OFF))
176 return -EINVAL;
177 *(unsigned int *)ptr = t;
178 return len;
179 case attr_pointer_bool:
180 if (!ptr)
181 return 0;
182 ret = kstrtoul(skip_spaces(buf), 0, &t);
183 if (ret)
184 return ret;
185 if (t != 0 && t != 1)
186 return -EINVAL;
187 *(bool *)ptr = !!t;
188 return len;
189#ifdef CONFIG_EROFS_FS_ZIP
190 case attr_drop_caches:
191 ret = kstrtoul(skip_spaces(buf), 0, &t);
192 if (ret)
193 return ret;
194 if (t < 1 || t > 3)
195 return -EINVAL;
196
197 if (t & 2)
198 z_erofs_shrink_scan(sbi, ~0UL);
199 if (t & 1)
200 invalidate_mapping_pages(MNGD_MAPPING(sbi), 0, -1);
201 return len;
202#endif
203#ifdef CONFIG_EROFS_FS_ZIP_ACCEL
204 case attr_accel:
205 buf = skip_spaces(buf);
206 z_erofs_crypto_disable_all_engines();
207 while (*buf) {
208 t = strcspn(buf, "\n");
209 ret = z_erofs_crypto_enable_engine(buf, t);
210 if (ret < 0)
211 return ret;
212 buf += buf[t] != '\0' ? t + 1 : t;
213 }
214 return len;
215#endif
216 }
217 return 0;
218}
219
220static void erofs_sb_release(struct kobject *kobj)
221{
222 struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
223 s_kobj);
224 complete(&sbi->s_kobj_unregister);
225}
226
227static const struct sysfs_ops erofs_attr_ops = {
228 .show = erofs_attr_show,
229 .store = erofs_attr_store,
230};
231
232static const struct kobj_type erofs_sb_ktype = {
233 .default_groups = erofs_sb_groups,
234 .sysfs_ops = &erofs_attr_ops,
235 .release = erofs_sb_release,
236};
237
238static const struct kobj_type erofs_ktype = {
239 .default_groups = erofs_groups,
240 .sysfs_ops = &erofs_attr_ops,
241};
242
243static struct kset erofs_root = {
244 .kobj = {.ktype = &erofs_ktype},
245};
246
247static const struct kobj_type erofs_feat_ktype = {
248 .default_groups = erofs_feat_groups,
249 .sysfs_ops = &erofs_attr_ops,
250};
251
252static struct kobject erofs_feat = {
253 .kset = &erofs_root,
254};
255
256int erofs_register_sysfs(struct super_block *sb)
257{
258 struct erofs_sb_info *sbi = EROFS_SB(sb);
259 int err;
260
261 sbi->s_kobj.kset = &erofs_root;
262 init_completion(&sbi->s_kobj_unregister);
263 err = kobject_init_and_add(&sbi->s_kobj, &erofs_sb_ktype, NULL, "%s",
264 sb->s_sysfs_name);
265 if (err) {
266 kobject_put(&sbi->s_kobj);
267 wait_for_completion(&sbi->s_kobj_unregister);
268 }
269 return err;
270}
271
272void erofs_unregister_sysfs(struct super_block *sb)
273{
274 struct erofs_sb_info *sbi = EROFS_SB(sb);
275
276 if (sbi->s_kobj.state_in_sysfs) {
277 kobject_del(&sbi->s_kobj);
278 kobject_put(&sbi->s_kobj);
279 wait_for_completion(&sbi->s_kobj_unregister);
280 }
281}
282
283void erofs_exit_sysfs(void)
284{
285 kobject_put(&erofs_feat);
286 kset_unregister(&erofs_root);
287}
288
289int __init erofs_init_sysfs(void)
290{
291 int ret;
292
293 kobject_set_name(&erofs_root.kobj, "erofs");
294 erofs_root.kobj.parent = fs_kobj;
295 ret = kset_register(&erofs_root);
296 if (!ret) {
297 ret = kobject_init_and_add(&erofs_feat, &erofs_feat_ktype,
298 NULL, "features");
299 if (!ret)
300 return 0;
301 erofs_exit_sysfs();
302 }
303 return ret;
304}