fs/erofs/sysfs.c

   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
  11 enum {
  12         attr_feature,
  13         attr_pointer_ui,
  14         attr_pointer_bool,
  15 };
  16
  17 enum {
  18         struct_erofs_sb_info,
  19         struct_erofs_mount_opts,
  20 };
  21
  22 struct erofs_attr {
  23         struct attribute attr;
  24         short attr_id;
  25         int struct_type, offset;
  26 };
  27
  28 #define EROFS_ATTR(_name, _mode, _id)                                   \
  29 static 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)   \
  37 static 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
  59 EROFS_ATTR_RW_UI(sync_decompress, erofs_mount_opts);
  60 #endif
  61
  62 static struct attribute *erofs_attrs[] = {
  63 #ifdef CONFIG_EROFS_FS_ZIP
  64         ATTR_LIST(sync_decompress),
  65 #endif
  66         NULL,
  67 };
  68 ATTRIBUTE_GROUPS(erofs);
  69
  70 /* Features this copy of erofs supports */
  71 EROFS_ATTR_FEATURE(zero_padding);
  72 EROFS_ATTR_FEATURE(compr_cfgs);
  73 EROFS_ATTR_FEATURE(big_pcluster);
  74 EROFS_ATTR_FEATURE(chunked_file);
  75 EROFS_ATTR_FEATURE(device_table);
  76 EROFS_ATTR_FEATURE(compr_head2);
  77 EROFS_ATTR_FEATURE(sb_chksum);
  78 EROFS_ATTR_FEATURE(ztailpacking);
  79 EROFS_ATTR_FEATURE(fragments);
  80 EROFS_ATTR_FEATURE(dedupe);
  81
  82 static 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 };
  95 ATTRIBUTE_GROUPS(erofs_feat);
  96
  97 static 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
 107 static 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
 130 static 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
 170 static 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
 177 static const struct sysfs_ops erofs_attr_ops = {
 178         .show   = erofs_attr_show,
 179         .store  = erofs_attr_store,
 180 };
 181
 182 static struct kobj_type erofs_sb_ktype = {
 183         .default_groups = erofs_groups,
 184         .sysfs_ops      = &erofs_attr_ops,
 185         .release        = erofs_sb_release,
 186 };
 187
 188 static struct kobj_type erofs_ktype = {
 189         .sysfs_ops      = &erofs_attr_ops,
 190 };
 191
 192 static struct kset erofs_root = {
 193         .kobj   = {.ktype = &erofs_ktype},
 194 };
 195
 196 static struct kobj_type erofs_feat_ktype = {
 197         .default_groups = erofs_feat_groups,
 198         .sysfs_ops      = &erofs_attr_ops,
 199 };
 200
 201 static struct kobject erofs_feat = {
 202         .kset   = &erofs_root,
 203 };
 204
 205 int 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
 233 put_sb_kobj:
 234         kobject_put(&sbi->s_kobj);
 235         wait_for_completion(&sbi->s_kobj_unregister);
 236         return err;
 237 }
 238
 239 void 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
 250 int __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
 266 feat_err:
 267         kobject_put(&erofs_feat);
 268         kset_unregister(&erofs_root);
 269 root_err:
 270         return ret;
 271 }
 272
 273 void erofs_exit_sysfs(void)
 274 {
 275         kobject_put(&erofs_feat);
 276         kset_unregister(&erofs_root);
 277 }