This source file includes following definitions.
- to_childless
- childless_showme_show
- childless_storeme_show
- childless_storeme_store
- childless_description_show
- to_simple_child
- simple_child_storeme_show
- simple_child_storeme_store
- simple_child_release
- to_simple_children
- simple_children_make_item
- simple_children_description_show
- simple_children_release
- group_children_make_group
- group_children_description_show
- configfs_example_init
- configfs_example_exit
1
2
3
4
5
6
7
8
9
10
11
12
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
25
26
27
28
29
30
31
32
33
34
35 struct childless {
36 struct configfs_subsystem subsys;
37 int showme;
38 int storeme;
39 };
40
41 static inline struct childless *to_childless(struct config_item *item)
42 {
43 return item ? container_of(to_configfs_subsystem(to_config_group(item)),
44 struct childless, subsys) : NULL;
45 }
46
47 static ssize_t childless_showme_show(struct config_item *item, char *page)
48 {
49 struct childless *childless = to_childless(item);
50 ssize_t pos;
51
52 pos = sprintf(page, "%d\n", childless->showme);
53 childless->showme++;
54
55 return pos;
56 }
57
58 static ssize_t childless_storeme_show(struct config_item *item, char *page)
59 {
60 return sprintf(page, "%d\n", to_childless(item)->storeme);
61 }
62
63 static ssize_t childless_storeme_store(struct config_item *item,
64 const char *page, size_t count)
65 {
66 struct childless *childless = to_childless(item);
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
82 static ssize_t childless_description_show(struct config_item *item, char *page)
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
93 CONFIGFS_ATTR_RO(childless_, showme);
94 CONFIGFS_ATTR(childless_, storeme);
95 CONFIGFS_ATTR_RO(childless_, description);
96
97 static struct configfs_attribute *childless_attrs[] = {
98 &childless_attr_showme,
99 &childless_attr_storeme,
100 &childless_attr_description,
101 NULL,
102 };
103
104 static const struct config_item_type childless_type = {
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
125
126
127
128
129
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
142 static ssize_t simple_child_storeme_show(struct config_item *item, char *page)
143 {
144 return sprintf(page, "%d\n", to_simple_child(item)->storeme);
145 }
146
147 static ssize_t simple_child_storeme_store(struct config_item *item,
148 const char *page, size_t count)
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
166 CONFIGFS_ATTR(simple_child_, storeme);
167
168 static struct configfs_attribute *simple_child_attrs[] = {
169 &simple_child_attr_storeme,
170 NULL,
171 };
172
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,
180 };
181
182 static const struct config_item_type simple_child_type = {
183 .ct_item_ops = &simple_child_item_ops,
184 .ct_attrs = simple_child_attrs,
185 .ct_owner = THIS_MODULE,
186 };
187
188
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 {
195 return item ? container_of(to_config_group(item),
196 struct simple_children, group) : NULL;
197 }
198
199 static struct config_item *simple_children_make_item(struct config_group *group,
200 const char *name)
201 {
202 struct simple_child *simple_child;
203
204 simple_child = kzalloc(sizeof(struct simple_child), GFP_KERNEL);
205 if (!simple_child)
206 return ERR_PTR(-ENOMEM);
207
208 config_item_init_type_name(&simple_child->item, name,
209 &simple_child_type);
210
211 simple_child->storeme = 0;
212
213 return &simple_child->item;
214 }
215
216 static ssize_t simple_children_description_show(struct config_item *item,
217 char *page)
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
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
233 static void simple_children_release(struct config_item *item)
234 {
235 kfree(to_simple_children(item));
236 }
237
238 static struct configfs_item_operations simple_children_item_ops = {
239 .release = simple_children_release,
240 };
241
242
243
244
245
246 static struct configfs_group_operations simple_children_group_ops = {
247 .make_item = simple_children_make_item,
248 };
249
250 static const struct config_item_type simple_children_type = {
251 .ct_item_ops = &simple_children_item_ops,
252 .ct_group_ops = &simple_children_group_ops,
253 .ct_attrs = simple_children_attrs,
254 .ct_owner = THIS_MODULE,
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
271
272
273
274
275
276
277
278
279 static struct config_group *group_children_make_group(
280 struct config_group *group, const char *name)
281 {
282 struct simple_children *simple_children;
283
284 simple_children = kzalloc(sizeof(struct simple_children),
285 GFP_KERNEL);
286 if (!simple_children)
287 return ERR_PTR(-ENOMEM);
288
289 config_group_init_type_name(&simple_children->group, name,
290 &simple_children_type);
291
292 return &simple_children->group;
293 }
294
295 static ssize_t group_children_description_show(struct config_item *item,
296 char *page)
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
305 CONFIGFS_ATTR_RO(group_children_, description);
306
307 static struct configfs_attribute *group_children_attrs[] = {
308 &group_children_attr_description,
309 NULL,
310 };
311
312
313
314
315
316 static struct configfs_group_operations group_children_group_ops = {
317 .make_group = group_children_make_group,
318 };
319
320 static const struct config_item_type group_children_type = {
321 .ct_group_ops = &group_children_group_ops,
322 .ct_attrs = group_children_attrs,
323 .ct_owner = THIS_MODULE,
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
339
340
341
342
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);
361 mutex_init(&subsys->su_mutex);
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:
374 for (i--; i >= 0; i--)
375 configfs_unregister_subsystem(example_subsys[i]);
376
377 return ret;
378 }
379
380 static void __exit configfs_example_exit(void)
381 {
382 int i;
383
384 for (i = 0; example_subsys[i]; i++)
385 configfs_unregister_subsystem(example_subsys[i]);
386 }
387
388 module_init(configfs_example_init);
389 module_exit(configfs_example_exit);
390 MODULE_LICENSE("GPL");