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