fs/ubifs/sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This file is part of UBIFS.
   4  *
   5  * Copyright (C) 2021 Cisco Systems
   6  *
   7  * Author: Stefan Schaeckeler
   8  */
   9
  10
  11 #include <linux/fs.h>
  12 #include "ubifs.h"
  13
  14 enum attr_id_t {
  15         attr_errors_magic,
  16         attr_errors_node,
  17         attr_errors_crc,
  18 };
  19
  20 struct ubifs_attr {
  21         struct attribute attr;
  22         enum attr_id_t attr_id;
  23 };
  24
  25 #define UBIFS_ATTR(_name, _mode, _id)                                   \
  26 static struct ubifs_attr ubifs_attr_##_name = {                         \
  27         .attr = {.name = __stringify(_name), .mode = _mode },           \
  28         .attr_id = attr_##_id,                                          \
  29 }
  30
  31 #define UBIFS_ATTR_FUNC(_name, _mode) UBIFS_ATTR(_name, _mode, _name)
  32
  33 UBIFS_ATTR_FUNC(errors_magic, 0444);
  34 UBIFS_ATTR_FUNC(errors_crc, 0444);
  35 UBIFS_ATTR_FUNC(errors_node, 0444);
  36
  37 #define ATTR_LIST(name) (&ubifs_attr_##name.attr)
  38
  39 static struct attribute *ubifs_attrs[] = {
  40         ATTR_LIST(errors_magic),
  41         ATTR_LIST(errors_node),
  42         ATTR_LIST(errors_crc),
  43         NULL,
  44 };
  45 ATTRIBUTE_GROUPS(ubifs);
  46
  47 static ssize_t ubifs_attr_show(struct kobject *kobj,
  48                                struct attribute *attr, char *buf)
  49 {
  50         struct ubifs_info *sbi = container_of(kobj, struct ubifs_info,
  51                                               kobj);
  52
  53         struct ubifs_attr *a = container_of(attr, struct ubifs_attr, attr);
  54
  55         switch (a->attr_id) {
  56         case attr_errors_magic:
  57                 return sysfs_emit(buf, "%u\n", sbi->stats->magic_errors);
  58         case attr_errors_node:
  59                 return sysfs_emit(buf, "%u\n", sbi->stats->node_errors);
  60         case attr_errors_crc:
  61                 return sysfs_emit(buf, "%u\n", sbi->stats->crc_errors);
  62         }
  63         return 0;
  64 };
  65
  66 static void ubifs_sb_release(struct kobject *kobj)
  67 {
  68         struct ubifs_info *c = container_of(kobj, struct ubifs_info, kobj);
  69
  70         complete(&c->kobj_unregister);
  71 }
  72
  73 static const struct sysfs_ops ubifs_attr_ops = {
  74         .show   = ubifs_attr_show,
  75 };
  76
  77 static const struct kobj_type ubifs_sb_ktype = {
  78         .default_groups = ubifs_groups,
  79         .sysfs_ops      = &ubifs_attr_ops,
  80         .release        = ubifs_sb_release,
  81 };
  82
  83 static const struct kobj_type ubifs_ktype = {
  84         .sysfs_ops      = &ubifs_attr_ops,
  85 };
  86
  87 static struct kset ubifs_kset = {
  88         .kobj   = {.ktype = &ubifs_ktype},
  89 };
  90
  91 int ubifs_sysfs_register(struct ubifs_info *c)
  92 {
  93         int ret, n;
  94         char dfs_dir_name[UBIFS_DFS_DIR_LEN];
  95
  96         c->stats = kzalloc(sizeof(struct ubifs_stats_info), GFP_KERNEL);
  97         if (!c->stats) {
  98                 ret = -ENOMEM;
  99                 goto out_last;
 100         }
 101         n = snprintf(dfs_dir_name, UBIFS_DFS_DIR_LEN, UBIFS_DFS_DIR_NAME,
 102                      c->vi.ubi_num, c->vi.vol_id);
 103
 104         if (n >= UBIFS_DFS_DIR_LEN) {
 105                 /* The array size is too small */
 106                 ret = -EINVAL;
 107                 goto out_free;
 108         }
 109
 110         c->kobj.kset = &ubifs_kset;
 111         init_completion(&c->kobj_unregister);
 112
 113         ret = kobject_init_and_add(&c->kobj, &ubifs_sb_ktype, NULL,
 114                                    "%s", dfs_dir_name);
 115         if (ret)
 116                 goto out_put;
 117
 118         return 0;
 119
 120 out_put:
 121         kobject_put(&c->kobj);
 122         wait_for_completion(&c->kobj_unregister);
 123 out_free:
 124         kfree(c->stats);
 125 out_last:
 126         ubifs_err(c, "cannot create sysfs entry for ubifs%d_%d, error %d\n",
 127                   c->vi.ubi_num, c->vi.vol_id, ret);
 128         return ret;
 129 }
 130
 131 void ubifs_sysfs_unregister(struct ubifs_info *c)
 132 {
 133         kobject_del(&c->kobj);
 134         kobject_put(&c->kobj);
 135         wait_for_completion(&c->kobj_unregister);
 136
 137         kfree(c->stats);
 138 }
 139
 140 int __init ubifs_sysfs_init(void)
 141 {
 142         int ret;
 143
 144         kobject_set_name(&ubifs_kset.kobj, "ubifs");
 145         ubifs_kset.kobj.parent = fs_kobj;
 146         ret = kset_register(&ubifs_kset);
 147         if (ret)
 148                 kset_put(&ubifs_kset);
 149
 150         return ret;
 151 }
 152
 153 void ubifs_sysfs_exit(void)
 154 {
 155         kset_unregister(&ubifs_kset);
 156 }