samples/configfs/configfs_sample.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * configfs_example_macros.c - This file is a demonstration module
   4  *      containing a number of configfs subsystems.  It uses the helper
   5  *      macros defined by configfs.h
   6  *
   7  * Based on sysfs:
   8  *      sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
   9  *
  10  * configfs Copyright (C) 2005 Oracle.  All rights reserved.
  11  */
  12
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17 #include <linux/configfs.h>
  18
  19 /*
  20  * 01-childless
  21  *
  22  * This first example is a childless subsystem.  It cannot create
  23  * any config_items.  It just has attributes.
  24  *
  25  * Note that we are enclosing the configfs_subsystem inside a container.
  26  * This is not necessary if a subsystem has no attributes directly
  27  * on the subsystem.  See the next example, 02-simple-children, for
  28  * such a subsystem.
  29  */
  30
  31 struct childless {
  32         struct configfs_subsystem subsys;
  33         int showme;
  34         int storeme;
  35 };
  36
  37 static inline struct childless *to_childless(struct config_item *item)
  38 {
  39         return container_of(to_configfs_subsystem(to_config_group(item)),
  40                             struct childless, subsys);
  41 }
  42
  43 static ssize_t childless_showme_show(struct config_item *item, char *page)
  44 {
  45         struct childless *childless = to_childless(item);
  46         ssize_t pos;
  47
  48         pos = sprintf(page, "%d\n", childless->showme);
  49         childless->showme++;
  50
  51         return pos;
  52 }
  53
  54 static ssize_t childless_storeme_show(struct config_item *item, char *page)
  55 {
  56         return sprintf(page, "%d\n", to_childless(item)->storeme);
  57 }
  58
  59 static ssize_t childless_storeme_store(struct config_item *item,
  60                 const char *page, size_t count)
  61 {
  62         struct childless *childless = to_childless(item);
  63         int ret;
  64
  65         ret = kstrtoint(page, 10, &childless->storeme);
  66         if (ret)
  67                 return ret;
  68
  69         return count;
  70 }
  71
  72 static ssize_t childless_description_show(struct config_item *item, char *page)
  73 {
  74         return sprintf(page,
  75 "[01-childless]\n"
  76 "\n"
  77 "The childless subsystem is the simplest possible subsystem in\n"
  78 "configfs.  It does not support the creation of child config_items.\n"
  79 "It only has a few attributes.  In fact, it isn't much different\n"
  80 "than a directory in /proc.\n");
  81 }
  82
  83 CONFIGFS_ATTR_RO(childless_, showme);
  84 CONFIGFS_ATTR(childless_, storeme);
  85 CONFIGFS_ATTR_RO(childless_, description);
  86
  87 static struct configfs_attribute *childless_attrs[] = {
  88         &childless_attr_showme,
  89         &childless_attr_storeme,
  90         &childless_attr_description,
  91         NULL,
  92 };
  93
  94 static const struct config_item_type childless_type = {
  95         .ct_attrs       = childless_attrs,
  96         .ct_owner       = THIS_MODULE,
  97 };
  98
  99 static struct childless childless_subsys = {
 100         .subsys = {
 101                 .su_group = {
 102                         .cg_item = {
 103                                 .ci_namebuf = "01-childless",
 104                                 .ci_type = &childless_type,
 105                         },
 106                 },
 107         },
 108 };
 109
 110 /* ----------------------------------------------------------------- */
 111
 112 /*
 113  * 02-simple-children
 114  *
 115  * This example merely has a simple one-attribute child.  Note that
 116  * there is no extra attribute structure, as the child's attribute is
 117  * known from the get-go.  Also, there is no container for the
 118  * subsystem, as it has no attributes of its own.
 119  */
 120
 121 struct simple_child {
 122         struct config_item item;
 123         int storeme;
 124 };
 125
 126 static inline struct simple_child *to_simple_child(struct config_item *item)
 127 {
 128         return container_of(item, struct simple_child, item);
 129 }
 130
 131 static ssize_t simple_child_storeme_show(struct config_item *item, char *page)
 132 {
 133         return sprintf(page, "%d\n", to_simple_child(item)->storeme);
 134 }
 135
 136 static ssize_t simple_child_storeme_store(struct config_item *item,
 137                 const char *page, size_t count)
 138 {
 139         struct simple_child *simple_child = to_simple_child(item);
 140         int ret;
 141
 142         ret = kstrtoint(page, 10, &simple_child->storeme);
 143         if (ret)
 144                 return ret;
 145
 146         return count;
 147 }
 148
 149 CONFIGFS_ATTR(simple_child_, storeme);
 150
 151 static struct configfs_attribute *simple_child_attrs[] = {
 152         &simple_child_attr_storeme,
 153         NULL,
 154 };
 155
 156 static void simple_child_release(struct config_item *item)
 157 {
 158         kfree(to_simple_child(item));
 159 }
 160
 161 static struct configfs_item_operations simple_child_item_ops = {
 162         .release        = simple_child_release,
 163 };
 164
 165 static const struct config_item_type simple_child_type = {
 166         .ct_item_ops    = &simple_child_item_ops,
 167         .ct_attrs       = simple_child_attrs,
 168         .ct_owner       = THIS_MODULE,
 169 };
 170
 171 struct simple_children {
 172         struct config_group group;
 173 };
 174
 175 static inline struct simple_children *to_simple_children(struct config_item *item)
 176 {
 177         return container_of(to_config_group(item),
 178                             struct simple_children, group);
 179 }
 180
 181 static struct config_item *simple_children_make_item(struct config_group *group,
 182                 const char *name)
 183 {
 184         struct simple_child *simple_child;
 185
 186         simple_child = kzalloc(sizeof(struct simple_child), GFP_KERNEL);
 187         if (!simple_child)
 188                 return ERR_PTR(-ENOMEM);
 189
 190         config_item_init_type_name(&simple_child->item, name,
 191                                    &simple_child_type);
 192
 193         return &simple_child->item;
 194 }
 195
 196 static ssize_t simple_children_description_show(struct config_item *item,
 197                 char *page)
 198 {
 199         return sprintf(page,
 200 "[02-simple-children]\n"
 201 "\n"
 202 "This subsystem allows the creation of child config_items.  These\n"
 203 "items have only one attribute that is readable and writeable.\n");
 204 }
 205
 206 CONFIGFS_ATTR_RO(simple_children_, description);
 207
 208 static struct configfs_attribute *simple_children_attrs[] = {
 209         &simple_children_attr_description,
 210         NULL,
 211 };
 212
 213 static void simple_children_release(struct config_item *item)
 214 {
 215         kfree(to_simple_children(item));
 216 }
 217
 218 static struct configfs_item_operations simple_children_item_ops = {
 219         .release        = simple_children_release,
 220 };
 221
 222 /*
 223  * Note that, since no extra work is required on ->drop_item(),
 224  * no ->drop_item() is provided.
 225  */
 226 static struct configfs_group_operations simple_children_group_ops = {
 227         .make_item      = simple_children_make_item,
 228 };
 229
 230 static const struct config_item_type simple_children_type = {
 231         .ct_item_ops    = &simple_children_item_ops,
 232         .ct_group_ops   = &simple_children_group_ops,
 233         .ct_attrs       = simple_children_attrs,
 234         .ct_owner       = THIS_MODULE,
 235 };
 236
 237 static struct configfs_subsystem simple_children_subsys = {
 238         .su_group = {
 239                 .cg_item = {
 240                         .ci_namebuf = "02-simple-children",
 241                         .ci_type = &simple_children_type,
 242                 },
 243         },
 244 };
 245
 246 /* ----------------------------------------------------------------- */
 247
 248 /*
 249  * 03-group-children
 250  *
 251  * This example reuses the simple_children group from above.  However,
 252  * the simple_children group is not the subsystem itself, it is a
 253  * child of the subsystem.  Creation of a group in the subsystem creates
 254  * a new simple_children group.  That group can then have simple_child
 255  * children of its own.
 256  */
 257
 258 static struct config_group *group_children_make_group(
 259                 struct config_group *group, const char *name)
 260 {
 261         struct simple_children *simple_children;
 262
 263         simple_children = kzalloc(sizeof(struct simple_children),
 264                                   GFP_KERNEL);
 265         if (!simple_children)
 266                 return ERR_PTR(-ENOMEM);
 267
 268         config_group_init_type_name(&simple_children->group, name,
 269                                     &simple_children_type);
 270
 271         return &simple_children->group;
 272 }
 273
 274 static ssize_t group_children_description_show(struct config_item *item,
 275                 char *page)
 276 {
 277         return sprintf(page,
 278 "[03-group-children]\n"
 279 "\n"
 280 "This subsystem allows the creation of child config_groups.  These\n"
 281 "groups are like the subsystem simple-children.\n");
 282 }
 283
 284 CONFIGFS_ATTR_RO(group_children_, description);
 285
 286 static struct configfs_attribute *group_children_attrs[] = {
 287         &group_children_attr_description,
 288         NULL,
 289 };
 290
 291 /*
 292  * Note that, since no extra work is required on ->drop_item(),
 293  * no ->drop_item() is provided.
 294  */
 295 static struct configfs_group_operations group_children_group_ops = {
 296         .make_group     = group_children_make_group,
 297 };
 298
 299 static const struct config_item_type group_children_type = {
 300         .ct_group_ops   = &group_children_group_ops,
 301         .ct_attrs       = group_children_attrs,
 302         .ct_owner       = THIS_MODULE,
 303 };
 304
 305 static struct configfs_subsystem group_children_subsys = {
 306         .su_group = {
 307                 .cg_item = {
 308                         .ci_namebuf = "03-group-children",
 309                         .ci_type = &group_children_type,
 310                 },
 311         },
 312 };
 313
 314 /* ----------------------------------------------------------------- */
 315
 316 /*
 317  * We're now done with our subsystem definitions.
 318  * For convenience in this module, here's a list of them all.  It
 319  * allows the init function to easily register them.  Most modules
 320  * will only have one subsystem, and will only call register_subsystem
 321  * on it directly.
 322  */
 323 static struct configfs_subsystem *example_subsys[] = {
 324         &childless_subsys.subsys,
 325         &simple_children_subsys,
 326         &group_children_subsys,
 327         NULL,
 328 };
 329
 330 static int __init configfs_example_init(void)
 331 {
 332         struct configfs_subsystem *subsys;
 333         int ret, i;
 334
 335         for (i = 0; example_subsys[i]; i++) {
 336                 subsys = example_subsys[i];
 337
 338                 config_group_init(&subsys->su_group);
 339                 mutex_init(&subsys->su_mutex);
 340                 ret = configfs_register_subsystem(subsys);
 341                 if (ret) {
 342                         pr_err("Error %d while registering subsystem %s\n",
 343                                ret, subsys->su_group.cg_item.ci_namebuf);
 344                         goto out_unregister;
 345                 }
 346         }
 347
 348         return 0;
 349
 350 out_unregister:
 351         for (i--; i >= 0; i--)
 352                 configfs_unregister_subsystem(example_subsys[i]);
 353
 354         return ret;
 355 }
 356
 357 static void __exit configfs_example_exit(void)
 358 {
 359         int i;
 360
 361         for (i = 0; example_subsys[i]; i++)
 362                 configfs_unregister_subsystem(example_subsys[i]);
 363 }
 364
 365 module_init(configfs_example_init);
 366 module_exit(configfs_example_exit);
 367 MODULE_LICENSE("GPL");