[PATCH] configfs: User-driven configuration filesystem
[linux-2.6.git] / 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 static struct config_item *simple_children_make_item(struct config_group *group, const char *name)
268 {
269         struct simple_child *simple_child;
270
271         simple_child = kmalloc(sizeof(struct simple_child), GFP_KERNEL);
272         if (!simple_child)
273                 return NULL;
274
275         memset(simple_child, 0, sizeof(struct simple_child));
276
277         config_item_init_type_name(&simple_child->item, name,
278                                    &simple_child_type);
279
280         simple_child->storeme = 0;
281
282         return &simple_child->item;
283 }
284
285 static struct configfs_attribute simple_children_attr_description = {
286         .ca_owner = THIS_MODULE,
287         .ca_name = "description",
288         .ca_mode = S_IRUGO,
289 };
290
291 static struct configfs_attribute *simple_children_attrs[] = {
292         &simple_children_attr_description,
293         NULL,
294 };
295
296 static ssize_t simple_children_attr_show(struct config_item *item,
297                                          struct configfs_attribute *attr,
298                                          char *page)
299 {
300         return sprintf(page,
301 "[02-simple-children]\n"
302 "\n"
303 "This subsystem allows the creation of child config_items.  These\n"
304 "items have only one attribute that is readable and writeable.\n");
305 }
306
307 static struct configfs_item_operations simple_children_item_ops = {
308         .show_attribute = simple_children_attr_show,
309 };
310
311 /*
312  * Note that, since no extra work is required on ->drop_item(),
313  * no ->drop_item() is provided.
314  */
315 static struct configfs_group_operations simple_children_group_ops = {
316         .make_item      = simple_children_make_item,
317 };
318
319 static struct config_item_type simple_children_type = {
320         .ct_item_ops    = &simple_children_item_ops,
321         .ct_group_ops   = &simple_children_group_ops,
322         .ct_attrs       = simple_children_attrs,
323 };
324
325 static struct configfs_subsystem simple_children_subsys = {
326         .su_group = {
327                 .cg_item = {
328                         .ci_namebuf = "02-simple-children",
329                         .ci_type = &simple_children_type,
330                 },
331         },
332 };
333
334
335 /* ----------------------------------------------------------------- */
336
337 /*
338  * 03-group-children
339  *
340  * This example reuses the simple_children group from above.  However,
341  * the simple_children group is not the subsystem itself, it is a
342  * child of the subsystem.  Creation of a group in the subsystem creates
343  * a new simple_children group.  That group can then have simple_child
344  * children of its own.
345  */
346
347 struct simple_children {
348         struct config_group group;
349 };
350
351 static struct config_group *group_children_make_group(struct config_group *group, const char *name)
352 {
353         struct simple_children *simple_children;
354
355         simple_children = kmalloc(sizeof(struct simple_children),
356                                   GFP_KERNEL);
357         if (!simple_children)
358                 return NULL;
359
360         memset(simple_children, 0, sizeof(struct simple_children));
361
362         config_group_init_type_name(&simple_children->group, name,
363                                     &simple_children_type);
364
365         return &simple_children->group;
366 }
367
368 static struct configfs_attribute group_children_attr_description = {
369         .ca_owner = THIS_MODULE,
370         .ca_name = "description",
371         .ca_mode = S_IRUGO,
372 };
373
374 static struct configfs_attribute *group_children_attrs[] = {
375         &group_children_attr_description,
376         NULL,
377 };
378
379 static ssize_t group_children_attr_show(struct config_item *item,
380                                         struct configfs_attribute *attr,
381                                         char *page)
382 {
383         return sprintf(page,
384 "[03-group-children]\n"
385 "\n"
386 "This subsystem allows the creation of child config_groups.  These\n"
387 "groups are like the subsystem simple-children.\n");
388 }
389
390 static struct configfs_item_operations group_children_item_ops = {
391         .show_attribute = group_children_attr_show,
392 };
393
394 /*
395  * Note that, since no extra work is required on ->drop_item(),
396  * no ->drop_item() is provided.
397  */
398 static struct configfs_group_operations group_children_group_ops = {
399         .make_group     = group_children_make_group,
400 };
401
402 static struct config_item_type group_children_type = {
403         .ct_item_ops    = &group_children_item_ops,
404         .ct_group_ops   = &group_children_group_ops,
405         .ct_attrs       = group_children_attrs,
406 };
407
408 static struct configfs_subsystem group_children_subsys = {
409         .su_group = {
410                 .cg_item = {
411                         .ci_namebuf = "03-group-children",
412                         .ci_type = &group_children_type,
413                 },
414         },
415 };
416
417 /* ----------------------------------------------------------------- */
418
419 /*
420  * We're now done with our subsystem definitions.
421  * For convenience in this module, here's a list of them all.  It
422  * allows the init function to easily register them.  Most modules
423  * will only have one subsystem, and will only call register_subsystem
424  * on it directly.
425  */
426 static struct configfs_subsystem *example_subsys[] = {
427         &childless_subsys.subsys,
428         &simple_children_subsys,
429         &group_children_subsys,
430         NULL,
431 };
432
433 static int __init configfs_example_init(void)
434 {
435         int ret;
436         int i;
437         struct configfs_subsystem *subsys;
438
439         for (i = 0; example_subsys[i]; i++) {
440                 subsys = example_subsys[i];
441
442                 config_group_init(&subsys->su_group);
443                 init_MUTEX(&subsys->su_sem);
444                 ret = configfs_register_subsystem(subsys);
445                 if (ret) {
446                         printk(KERN_ERR "Error %d while registering subsystem %s\n",
447                                ret,
448                                subsys->su_group.cg_item.ci_namebuf);
449                         goto out_unregister;
450                 }
451         }
452
453         return 0;
454
455 out_unregister:
456         for (; i >= 0; i--) {
457                 configfs_unregister_subsystem(example_subsys[i]);
458         }
459
460         return ret;
461 }
462
463 static void __exit configfs_example_exit(void)
464 {
465         int i;
466
467         for (i = 0; example_subsys[i]; i++) {
468                 configfs_unregister_subsystem(example_subsys[i]);
469         }
470 }
471
472 module_init(configfs_example_init);
473 module_exit(configfs_example_exit);
474 MODULE_LICENSE("GPL");