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