Documentation/filesystems/configfs/configfs_example.c

   1 /*
   2  * vim: noexpandtab ts=8 sts=0 sw=8:
   3  *
   4  * configfs_example.c - This file is a demonstration module containing
   5  *      a number of configfs subsystems.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public
  18  * License along with this program; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 021110-1307, USA.
  21  *
  22  * Based on sysfs:
  23  *      sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
  24  *
  25  * configfs Copyright (C) 2005 Oracle.  All rights reserved.
  26  */
  27
  28 #include <linux/init.h>
  29 #include <linux/module.h>
  30 #include <linux/slab.h>
  31
  32 #include <linux/configfs.h>
  33
  34
  35
  36 /*
  37  * 01-childless
  38  *
  39  * This first example is a childless subsystem.  It cannot create
  40  * any config_items.  It just has attributes.
  41  *
  42  * Note that we are enclosing the configfs_subsystem inside a container.
  43  * This is not necessary if a subsystem has no attributes directly
  44  * on the subsystem.  See the next example, 02-simple-children, for
  45  * such a subsystem.
  46  */
  47
  48 struct childless {
  49         struct configfs_subsystem subsys;
  50         int showme;
  51         int storeme;
  52 };
  53
  54 struct childless_attribute {
  55         struct configfs_attribute attr;
  56         ssize_t (*show)(struct childless *, char *);
  57         ssize_t (*store)(struct childless *, const char *, size_t);
  58 };
  59
  60 static inline struct childless *to_childless(struct config_item *item)
  61 {
  62         return item ? container_of(to_configfs_subsystem(to_config_group(item)), struct childless, subsys) : NULL;
  63 }
  64
  65 static ssize_t childless_showme_read(struct childless *childless,
  66                                      char *page)
  67 {
  68         ssize_t pos;
  69
  70         pos = sprintf(page, "%d\n", childless->showme);
  71         childless->showme++;
  72
  73         return pos;
  74 }
  75
  76 static ssize_t childless_storeme_read(struct childless *childless,
  77                                       char *page)
  78 {
  79         return sprintf(page, "%d\n", childless->storeme);
  80 }
  81
  82 static ssize_t childless_storeme_write(struct childless *childless,
  83                                        const char *page,
  84                                        size_t count)
  85 {
  86         unsigned long tmp;
  87         char *p = (char *) page;
  88
  89         tmp = simple_strtoul(p, &p, 10);
  90         if (!p || (*p && (*p != '\n')))
  91                 return -EINVAL;
  92
  93         if (tmp > INT_MAX)
  94                 return -ERANGE;
  95
  96         childless->storeme = tmp;
  97
  98         return count;
  99 }
 100
 101 static ssize_t childless_description_read(struct childless *childless,
 102                                           char *page)
 103 {
 104         return sprintf(page,
 105 "[01-childless]\n"
 106 "\n"
 107 "The childless subsystem is the simplest possible subsystem in\n"
 108 "configfs.  It does not support the creation of child config_items.\n"
 109 "It only has a few attributes.  In fact, it isn't much different\n"
 110 "than a directory in /proc.\n");
 111 }
 112
 113 static struct childless_attribute childless_attr_showme = {
 114         .attr   = { .ca_owner = THIS_MODULE, .ca_name = "showme", .ca_mode = S_IRUGO },
 115         .show   = childless_showme_read,
 116 };
 117 static struct childless_attribute childless_attr_storeme = {
 118         .attr   = { .ca_owner = THIS_MODULE, .ca_name = "storeme", .ca_mode = S_IRUGO | S_IWUSR },
 119         .show   = childless_storeme_read,
 120         .store  = childless_storeme_write,
 121 };
 122 static struct childless_attribute childless_attr_description = {
 123         .attr = { .ca_owner = THIS_MODULE, .ca_name = "description", .ca_mode = S_IRUGO },
 124         .show = childless_description_read,
 125 };
 126
 127 static struct configfs_attribute *childless_attrs[] = {
 128         &childless_attr_showme.attr,
 129         &childless_attr_storeme.attr,
 130         &childless_attr_description.attr,
 131         NULL,
 132 };
 133
 134 static ssize_t childless_attr_show(struct config_item *item,
 135                                    struct configfs_attribute *attr,
 136                                    char *page)
 137 {
 138         struct childless *childless = to_childless(item);
 139         struct childless_attribute *childless_attr =
 140                 container_of(attr, struct childless_attribute, attr);
 141         ssize_t ret = 0;
 142
 143         if (childless_attr->show)
 144                 ret = childless_attr->show(childless, page);
 145         return ret;
 146 }
 147
 148 static ssize_t childless_attr_store(struct config_item *item,
 149                                     struct configfs_attribute *attr,
 150                                     const char *page, size_t count)
 151 {
 152         struct childless *childless = to_childless(item);
 153         struct childless_attribute *childless_attr =
 154                 container_of(attr, struct childless_attribute, attr);
 155         ssize_t ret = -EINVAL;
 156
 157         if (childless_attr->store)
 158                 ret = childless_attr->store(childless, page, count);
 159         return ret;
 160 }
 161
 162 static struct configfs_item_operations childless_item_ops = {
 163         .show_attribute         = childless_attr_show,
 164         .store_attribute        = childless_attr_store,
 165 };
 166
 167 static struct config_item_type childless_type = {
 168         .ct_item_ops    = &childless_item_ops,
 169         .ct_attrs       = childless_attrs,
 170         .ct_owner       = THIS_MODULE,
 171 };
 172
 173 static struct childless childless_subsys = {
 174         .subsys = {
 175                 .su_group = {
 176                         .cg_item = {
 177                                 .ci_namebuf = "01-childless",
 178                                 .ci_type = &childless_type,
 179                         },
 180                 },
 181         },
 182 };
 183
 184
 185 /* ----------------------------------------------------------------- */
 186
 187 /*
 188  * 02-simple-children
 189  *
 190  * This example merely has a simple one-attribute child.  Note that
 191  * there is no extra attribute structure, as the child's attribute is
 192  * known from the get-go.  Also, there is no container for the
 193  * subsystem, as it has no attributes of its own.
 194  */
 195
 196 struct simple_child {
 197         struct config_item item;
 198         int storeme;
 199 };
 200
 201 static inline struct simple_child *to_simple_child(struct config_item *item)
 202 {
 203         return item ? container_of(item, struct simple_child, item) : NULL;
 204 }
 205
 206 static struct configfs_attribute simple_child_attr_storeme = {
 207         .ca_owner = THIS_MODULE,
 208         .ca_name = "storeme",
 209         .ca_mode = S_IRUGO | S_IWUSR,
 210 };
 211
 212 static struct configfs_attribute *simple_child_attrs[] = {
 213         &simple_child_attr_storeme,
 214         NULL,
 215 };
 216
 217 static ssize_t simple_child_attr_show(struct config_item *item,
 218                                       struct configfs_attribute *attr,
 219                                       char *page)
 220 {
 221         ssize_t count;
 222         struct simple_child *simple_child = to_simple_child(item);
 223
 224         count = sprintf(page, "%d\n", simple_child->storeme);
 225
 226         return count;
 227 }
 228
 229 static ssize_t simple_child_attr_store(struct config_item *item,
 230                                        struct configfs_attribute *attr,
 231                                        const char *page, size_t count)
 232 {
 233         struct simple_child *simple_child = to_simple_child(item);
 234         unsigned long tmp;
 235         char *p = (char *) page;
 236
 237         tmp = simple_strtoul(p, &p, 10);
 238         if (!p || (*p && (*p != '\n')))
 239                 return -EINVAL;
 240
 241         if (tmp > INT_MAX)
 242                 return -ERANGE;
 243
 244         simple_child->storeme = tmp;
 245
 246         return count;
 247 }
 248
 249 static void simple_child_release(struct config_item *item)
 250 {
 251         kfree(to_simple_child(item));
 252 }
 253
 254 static struct configfs_item_operations simple_child_item_ops = {
 255         .release                = simple_child_release,
 256         .show_attribute         = simple_child_attr_show,
 257         .store_attribute        = simple_child_attr_store,
 258 };
 259
 260 static struct config_item_type simple_child_type = {
 261         .ct_item_ops    = &simple_child_item_ops,
 262         .ct_attrs       = simple_child_attrs,
 263         .ct_owner       = THIS_MODULE,
 264 };
 265
 266
 267 struct simple_children {
 268         struct config_group group;
 269 };
 270
 271 static inline struct simple_children *to_simple_children(struct config_item *item)
 272 {
 273         return item ? container_of(to_config_group(item), struct simple_children, group) : NULL;
 274 }
 275
 276 static int simple_children_make_item(struct config_group *group, const char *name, struct config_item **new_item)
 277 {
 278         struct simple_child *simple_child;
 279
 280         simple_child = kzalloc(sizeof(struct simple_child), GFP_KERNEL);
 281         if (!simple_child)
 282                 return -ENOMEM;
 283
 284
 285         config_item_init_type_name(&simple_child->item, name,
 286                                    &simple_child_type);
 287
 288         simple_child->storeme = 0;
 289
 290         *new_item = &simple_child->item;
 291         return 0;
 292 }
 293
 294 static struct configfs_attribute simple_children_attr_description = {
 295         .ca_owner = THIS_MODULE,
 296         .ca_name = "description",
 297         .ca_mode = S_IRUGO,
 298 };
 299
 300 static struct configfs_attribute *simple_children_attrs[] = {
 301         &simple_children_attr_description,
 302         NULL,
 303 };
 304
 305 static ssize_t simple_children_attr_show(struct config_item *item,
 306                                          struct configfs_attribute *attr,
 307                                          char *page)
 308 {
 309         return sprintf(page,
 310 "[02-simple-children]\n"
 311 "\n"
 312 "This subsystem allows the creation of child config_items.  These\n"
 313 "items have only one attribute that is readable and writeable.\n");
 314 }
 315
 316 static void simple_children_release(struct config_item *item)
 317 {
 318         kfree(to_simple_children(item));
 319 }
 320
 321 static struct configfs_item_operations simple_children_item_ops = {
 322         .release        = simple_children_release,
 323         .show_attribute = simple_children_attr_show,
 324 };
 325
 326 /*
 327  * Note that, since no extra work is required on ->drop_item(),
 328  * no ->drop_item() is provided.
 329  */
 330 static struct configfs_group_operations simple_children_group_ops = {
 331         .make_item      = simple_children_make_item,
 332 };
 333
 334 static struct config_item_type simple_children_type = {
 335         .ct_item_ops    = &simple_children_item_ops,
 336         .ct_group_ops   = &simple_children_group_ops,
 337         .ct_attrs       = simple_children_attrs,
 338         .ct_owner       = THIS_MODULE,
 339 };
 340
 341 static struct configfs_subsystem simple_children_subsys = {
 342         .su_group = {
 343                 .cg_item = {
 344                         .ci_namebuf = "02-simple-children",
 345                         .ci_type = &simple_children_type,
 346                 },
 347         },
 348 };
 349
 350
 351 /* ----------------------------------------------------------------- */
 352
 353 /*
 354  * 03-group-children
 355  *
 356  * This example reuses the simple_children group from above.  However,
 357  * the simple_children group is not the subsystem itself, it is a
 358  * child of the subsystem.  Creation of a group in the subsystem creates
 359  * a new simple_children group.  That group can then have simple_child
 360  * children of its own.
 361  */
 362
 363 static int group_children_make_group(struct config_group *group, const char *name, struct config_group **new_group)
 364 {
 365         struct simple_children *simple_children;
 366
 367         simple_children = kzalloc(sizeof(struct simple_children),
 368                                   GFP_KERNEL);
 369         if (!simple_children)
 370                 return -ENOMEM;
 371
 372
 373         config_group_init_type_name(&simple_children->group, name,
 374                                     &simple_children_type);
 375
 376         *new_group = &simple_children->group;
 377         return 0;
 378 }
 379
 380 static struct configfs_attribute group_children_attr_description = {
 381         .ca_owner = THIS_MODULE,
 382         .ca_name = "description",
 383         .ca_mode = S_IRUGO,
 384 };
 385
 386 static struct configfs_attribute *group_children_attrs[] = {
 387         &group_children_attr_description,
 388         NULL,
 389 };
 390
 391 static ssize_t group_children_attr_show(struct config_item *item,
 392                                         struct configfs_attribute *attr,
 393                                         char *page)
 394 {
 395         return sprintf(page,
 396 "[03-group-children]\n"
 397 "\n"
 398 "This subsystem allows the creation of child config_groups.  These\n"
 399 "groups are like the subsystem simple-children.\n");
 400 }
 401
 402 static struct configfs_item_operations group_children_item_ops = {
 403         .show_attribute = group_children_attr_show,
 404 };
 405
 406 /*
 407  * Note that, since no extra work is required on ->drop_item(),
 408  * no ->drop_item() is provided.
 409  */
 410 static struct configfs_group_operations group_children_group_ops = {
 411         .make_group     = group_children_make_group,
 412 };
 413
 414 static struct config_item_type group_children_type = {
 415         .ct_item_ops    = &group_children_item_ops,
 416         .ct_group_ops   = &group_children_group_ops,
 417         .ct_attrs       = group_children_attrs,
 418         .ct_owner       = THIS_MODULE,
 419 };
 420
 421 static struct configfs_subsystem group_children_subsys = {
 422         .su_group = {
 423                 .cg_item = {
 424                         .ci_namebuf = "03-group-children",
 425                         .ci_type = &group_children_type,
 426                 },
 427         },
 428 };
 429
 430 /* ----------------------------------------------------------------- */
 431
 432 /*
 433  * We're now done with our subsystem definitions.
 434  * For convenience in this module, here's a list of them all.  It
 435  * allows the init function to easily register them.  Most modules
 436  * will only have one subsystem, and will only call register_subsystem
 437  * on it directly.
 438  */
 439 static struct configfs_subsystem *example_subsys[] = {
 440         &childless_subsys.subsys,
 441         &simple_children_subsys,
 442         &group_children_subsys,
 443         NULL,
 444 };
 445
 446 static int __init configfs_example_init(void)
 447 {
 448         int ret;
 449         int i;
 450         struct configfs_subsystem *subsys;
 451
 452         for (i = 0; example_subsys[i]; i++) {
 453                 subsys = example_subsys[i];
 454
 455                 config_group_init(&subsys->su_group);
 456                 mutex_init(&subsys->su_mutex);
 457                 ret = configfs_register_subsystem(subsys);
 458                 if (ret) {
 459                         printk(KERN_ERR "Error %d while registering subsystem %s\n",
 460                                ret,
 461                                subsys->su_group.cg_item.ci_namebuf);
 462                         goto out_unregister;
 463                 }
 464         }
 465
 466         return 0;
 467
 468 out_unregister:
 469         for (; i >= 0; i--) {
 470                 configfs_unregister_subsystem(example_subsys[i]);
 471         }
 472
 473         return ret;
 474 }
 475
 476 static void __exit configfs_example_exit(void)
 477 {
 478         int i;
 479
 480         for (i = 0; example_subsys[i]; i++) {
 481                 configfs_unregister_subsystem(example_subsys[i]);
 482         }
 483 }
 484
 485 module_init(configfs_example_init);
 486 module_exit(configfs_example_exit);
 487 MODULE_LICENSE("GPL");