aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorChristoph Hellwig <hch@lst.de>2015-10-03 09:32:59 -0400
committerNicholas Bellinger <nab@linux-iscsi.org>2015-10-14 01:17:57 -0400
commit517982229f78b2aebf00a8a337e84e8eeea70b8e (patch)
tree6f5f093837a26d5b56874689234dc818951779ac
parent45b997737a8025be2825e464e9e9dd5d07160dc3 (diff)
configfs: remove old API
Remove the old show_attribute and store_attribute methods and update the documentation. Also replace the two C samples with a single new one in the proper samples directory where people expect to find it. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>
Diffstat
-rw-r--r--Documentation/filesystems/Makefile2
-rw-r--r--Documentation/filesystems/configfs/Makefile3
-rw-r--r--Documentation/filesystems/configfs/configfs.txt38
-rw-r--r--Documentation/filesystems/configfs/configfs_example_explicit.c483
-rw-r--r--fs/configfs/file.c15
-rw-r--r--include/linux/configfs.h82
-rw-r--r--samples/Kconfig6
-rw-r--r--samples/Makefile3
-rw-r--r--samples/configfs/Makefile2
-rw-r--r--samples/configfs/configfs_sample.c (renamed from Documentation/filesystems/configfs/configfs_example_macros.c)140
10 files changed, 73 insertions, 701 deletions
diff --git a/Documentation/filesystems/Makefile b/Documentation/filesystems/Makefile
index 13483d192ebb..883010ce5e35 100644
--- a/Documentation/filesystems/Makefile
+++ b/Documentation/filesystems/Makefile
@@ -1,5 +1,3 @@
1subdir-y := configfs
2
3# List of programs to build 1# List of programs to build
4hostprogs-y := dnotify_test 2hostprogs-y := dnotify_test
5 3
diff --git a/Documentation/filesystems/configfs/Makefile b/Documentation/filesystems/configfs/Makefile
deleted file mode 100644
index be7ec5e67dbc..000000000000
--- a/Documentation/filesystems/configfs/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
1ifneq ($(CONFIG_CONFIGFS_FS),)
2obj-m += configfs_example_explicit.o configfs_example_macros.o
3endif
diff --git a/Documentation/filesystems/configfs/configfs.txt b/Documentation/filesystems/configfs/configfs.txt
index b40fec9d3f53..af68efdbbfad 100644
--- a/Documentation/filesystems/configfs/configfs.txt
+++ b/Documentation/filesystems/configfs/configfs.txt
@@ -160,12 +160,6 @@ among other things. For that, it needs a type.
160 160
161 struct configfs_item_operations { 161 struct configfs_item_operations {
162 void (*release)(struct config_item *); 162 void (*release)(struct config_item *);
163 ssize_t (*show_attribute)(struct config_item *,
164 struct configfs_attribute *,
165 char *);
166 ssize_t (*store_attribute)(struct config_item *,
167 struct configfs_attribute *,
168 const char *, size_t);
169 int (*allow_link)(struct config_item *src, 163 int (*allow_link)(struct config_item *src,
170 struct config_item *target); 164 struct config_item *target);
171 int (*drop_link)(struct config_item *src, 165 int (*drop_link)(struct config_item *src,
@@ -183,9 +177,7 @@ The most basic function of a config_item_type is to define what
183operations can be performed on a config_item. All items that have been 177operations can be performed on a config_item. All items that have been
184allocated dynamically will need to provide the ct_item_ops->release() 178allocated dynamically will need to provide the ct_item_ops->release()
185method. This method is called when the config_item's reference count 179method. This method is called when the config_item's reference count
186reaches zero. Items that wish to display an attribute need to provide 180reaches zero.
187the ct_item_ops->show_attribute() method. Similarly, storing a new
188attribute value uses the store_attribute() method.
189 181
190[struct configfs_attribute] 182[struct configfs_attribute]
191 183
@@ -193,6 +185,8 @@ attribute value uses the store_attribute() method.
193 char *ca_name; 185 char *ca_name;
194 struct module *ca_owner; 186 struct module *ca_owner;
195 umode_t ca_mode; 187 umode_t ca_mode;
188 ssize_t (*show)(struct config_item *, char *);
189 ssize_t (*store)(struct config_item *, const char *, size_t);
196 }; 190 };
197 191
198When a config_item wants an attribute to appear as a file in the item's 192When a config_item wants an attribute to appear as a file in the item's
@@ -202,10 +196,10 @@ config_item_type->ct_attrs. When the item appears in configfs, the
202attribute file will appear with the configfs_attribute->ca_name 196attribute file will appear with the configfs_attribute->ca_name
203filename. configfs_attribute->ca_mode specifies the file permissions. 197filename. configfs_attribute->ca_mode specifies the file permissions.
204 198
205If an attribute is readable and the config_item provides a 199If an attribute is readable and provides a ->show method, that method will
206ct_item_ops->show_attribute() method, that method will be called 200be called whenever userspace asks for a read(2) on the attribute. If an
207whenever userspace asks for a read(2) on the attribute. The converse 201attribute is writable and provides a ->store method, that method will be
208will happen for write(2). 202be called whenever userspace asks for a write(2) on the attribute.
209 203
210[struct config_group] 204[struct config_group]
211 205
@@ -311,20 +305,10 @@ the subsystem must be ready for it.
311[An Example] 305[An Example]
312 306
313The best example of these basic concepts is the simple_children 307The best example of these basic concepts is the simple_children
314subsystem/group and the simple_child item in configfs_example_explicit.c 308subsystem/group and the simple_child item in
315and configfs_example_macros.c. It shows a trivial object displaying and 309samples/configfs/configfs_sample.c. It shows a trivial object displaying
316storing an attribute, and a simple group creating and destroying these 310and storing an attribute, and a simple group creating and destroying
317children. 311these children.
318
319The only difference between configfs_example_explicit.c and
320configfs_example_macros.c is how the attributes of the childless item
321are defined. The childless item has extended attributes, each with
322their own show()/store() operation. This follows a convention commonly
323used in sysfs. configfs_example_explicit.c creates these attributes
324by explicitly defining the structures involved. Conversely
325configfs_example_macros.c uses some convenience macros from configfs.h
326to define the attributes. These macros are similar to their sysfs
327counterparts.
328 312
329[Hierarchy Navigation and the Subsystem Mutex] 313[Hierarchy Navigation and the Subsystem Mutex]
330 314
diff --git a/Documentation/filesystems/configfs/configfs_example_explicit.c b/Documentation/filesystems/configfs/configfs_example_explicit.c
deleted file mode 100644
index 1420233dfa55..000000000000
--- a/Documentation/filesystems/configfs/configfs_example_explicit.c
+++ /dev/null
@@ -1,483 +0,0 @@
1/*
2 * vim: noexpandtab ts=8 sts=0 sw=8:
3 *
4 * configfs_example_explicit.c - This file is a demonstration module
5 * containing a number of configfs subsystems. It explicitly defines
6 * each structure without using the helper macros defined in
7 * configfs.h.
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public
20 * License along with this program; if not, write to the
21 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 * Boston, MA 021110-1307, USA.
23 *
24 * Based on sysfs:
25 * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
26 *
27 * configfs Copyright (C) 2005 Oracle. All rights reserved.
28 */
29
30#include <linux/init.h>
31#include <linux/module.h>
32#include <linux/slab.h>
33
34#include <linux/configfs.h>
35
36
37
38/*
39 * 01-childless
40 *
41 * This first example is a childless subsystem. It cannot create
42 * any config_items. It just has attributes.
43 *
44 * Note that we are enclosing the configfs_subsystem inside a container.
45 * This is not necessary if a subsystem has no attributes directly
46 * on the subsystem. See the next example, 02-simple-children, for
47 * such a subsystem.
48 */
49
50struct childless {
51 struct configfs_subsystem subsys;
52 int showme;
53 int storeme;
54};
55
56struct childless_attribute {
57 struct configfs_attribute attr;
58 ssize_t (*show)(struct childless *, char *);
59 ssize_t (*store)(struct childless *, const char *, size_t);
60};
61
62static inline struct childless *to_childless(struct config_item *item)
63{
64 return item ? container_of(to_configfs_subsystem(to_config_group(item)), struct childless, subsys) : NULL;
65}
66
67static ssize_t childless_showme_read(struct childless *childless,
68 char *page)
69{
70 ssize_t pos;
71
72 pos = sprintf(page, "%d\n", childless->showme);
73 childless->showme++;
74
75 return pos;
76}
77
78static ssize_t childless_storeme_read(struct childless *childless,
79 char *page)
80{
81 return sprintf(page, "%d\n", childless->storeme);
82}
83
84static ssize_t childless_storeme_write(struct childless *childless,
85 const char *page,
86 size_t count)
87{
88 unsigned long tmp;
89 char *p = (char *) page;
90
91 tmp = simple_strtoul(p, &p, 10);
92 if ((*p != '\0') && (*p != '\n'))
93 return -EINVAL;
94
95 if (tmp > INT_MAX)
96 return -ERANGE;
97
98 childless->storeme = tmp;
99
100 return count;
101}
102
103static ssize_t childless_description_read(struct childless *childless,
104 char *page)
105{
106 return sprintf(page,
107"[01-childless]\n"
108"\n"
109"The childless subsystem is the simplest possible subsystem in\n"
110"configfs. It does not support the creation of child config_items.\n"
111"It only has a few attributes. In fact, it isn't much different\n"
112"than a directory in /proc.\n");
113}
114
115static struct childless_attribute childless_attr_showme = {
116 .attr = { .ca_owner = THIS_MODULE, .ca_name = "showme", .ca_mode = S_IRUGO },
117 .show = childless_showme_read,
118};
119static struct childless_attribute childless_attr_storeme = {
120 .attr = { .ca_owner = THIS_MODULE, .ca_name = "storeme", .ca_mode = S_IRUGO | S_IWUSR },
121 .show = childless_storeme_read,
122 .store = childless_storeme_write,
123};
124static struct childless_attribute childless_attr_description = {
125 .attr = { .ca_owner = THIS_MODULE, .ca_name = "description", .ca_mode = S_IRUGO },
126 .show = childless_description_read,
127};
128
129static struct configfs_attribute *childless_attrs[] = {
130 &childless_attr_showme.attr,
131 &childless_attr_storeme.attr,
132 &childless_attr_description.attr,
133 NULL,
134};
135
136static ssize_t childless_attr_show(struct config_item *item,
137 struct configfs_attribute *attr,
138 char *page)
139{
140 struct childless *childless = to_childless(item);
141 struct childless_attribute *childless_attr =
142 container_of(attr, struct childless_attribute, attr);
143 ssize_t ret = 0;
144
145 if (childless_attr->show)
146 ret = childless_attr->show(childless, page);
147 return ret;
148}
149
150static ssize_t childless_attr_store(struct config_item *item,
151 struct configfs_attribute *attr,
152 const char *page, size_t count)
153{
154 struct childless *childless = to_childless(item);
155 struct childless_attribute *childless_attr =
156 container_of(attr, struct childless_attribute, attr);
157 ssize_t ret = -EINVAL;
158
159 if (childless_attr->store)
160 ret = childless_attr->store(childless, page, count);
161 return ret;
162}
163
164static struct configfs_item_operations childless_item_ops = {
165 .show_attribute = childless_attr_show,
166 .store_attribute = childless_attr_store,
167};
168
169static struct config_item_type childless_type = {
170 .ct_item_ops = &childless_item_ops,
171 .ct_attrs = childless_attrs,
172 .ct_owner = THIS_MODULE,
173};
174
175static struct childless childless_subsys = {
176 .subsys = {
177 .su_group = {
178 .cg_item = {
179 .ci_namebuf = "01-childless",
180 .ci_type = &childless_type,
181 },
182 },
183 },
184};
185
186
187/* ----------------------------------------------------------------- */
188
189/*
190 * 02-simple-children
191 *
192 * This example merely has a simple one-attribute child. Note that
193 * there is no extra attribute structure, as the child's attribute is
194 * known from the get-go. Also, there is no container for the
195 * subsystem, as it has no attributes of its own.
196 */
197
198struct simple_child {
199 struct config_item item;
200 int storeme;
201};
202
203static inline struct simple_child *to_simple_child(struct config_item *item)
204{
205 return item ? container_of(item, struct simple_child, item) : NULL;
206}
207
208static struct configfs_attribute simple_child_attr_storeme = {
209 .ca_owner = THIS_MODULE,
210 .ca_name = "storeme",
211 .ca_mode = S_IRUGO | S_IWUSR,
212};
213
214static struct configfs_attribute *simple_child_attrs[] = {
215 &simple_child_attr_storeme,
216 NULL,
217};
218
219static ssize_t simple_child_attr_show(struct config_item *item,
220 struct configfs_attribute *attr,
221 char *page)
222{
223 ssize_t count;
224 struct simple_child *simple_child = to_simple_child(item);
225
226 count = sprintf(page, "%d\n", simple_child->storeme);
227
228 return count;
229}
230
231static ssize_t simple_child_attr_store(struct config_item *item,
232 struct configfs_attribute *attr,
233 const char *page, size_t count)
234{
235 struct simple_child *simple_child = to_simple_child(item);
236 unsigned long tmp;
237 char *p = (char *) page;
238
239 tmp = simple_strtoul(p, &p, 10);
240 if (!p || (*p && (*p != '\n')))
241 return -EINVAL;
242
243 if (tmp > INT_MAX)
244 return -ERANGE;
245
246 simple_child->storeme = tmp;
247
248 return count;
249}
250
251static void simple_child_release(struct config_item *item)
252{
253 kfree(to_simple_child(item));
254}
255
256static struct configfs_item_operations simple_child_item_ops = {
257 .release = simple_child_release,
258 .show_attribute = simple_child_attr_show,
259 .store_attribute = simple_child_attr_store,
260};
261
262static struct config_item_type simple_child_type = {
263 .ct_item_ops = &simple_child_item_ops,
264 .ct_attrs = simple_child_attrs,
265 .ct_owner = THIS_MODULE,
266};
267
268
269struct simple_children {
270 struct config_group group;
271};
272
273static inline struct simple_children *to_simple_children(struct config_item *item)
274{
275 return item ? container_of(to_config_group(item), struct simple_children, group) : NULL;
276}
277
278static struct config_item *simple_children_make_item(struct config_group *group, const char *name)
279{
280 struct simple_child *simple_child;
281
282 simple_child = kzalloc(sizeof(struct simple_child), GFP_KERNEL);
283 if (!simple_child)
284 return ERR_PTR(-ENOMEM);
285
286 config_item_init_type_name(&simple_child->item, name,
287 &simple_child_type);
288
289 simple_child->storeme = 0;
290
291 return &simple_child->item;
292}
293
294static struct configfs_attribute simple_children_attr_description = {
295 .ca_owner = THIS_MODULE,
296 .ca_name = "description",
297 .ca_mode = S_IRUGO,
298};
299
300static struct configfs_attribute *simple_children_attrs[] = {
301 &simple_children_attr_description,
302 NULL,
303};
304
305static 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
316static void simple_children_release(struct config_item *item)
317{
318 kfree(to_simple_children(item));
319}
320
321static 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 */
330static struct configfs_group_operations simple_children_group_ops = {
331 .make_item = simple_children_make_item,
332};
333
334static 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
341static 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
363static struct config_group *group_children_make_group(struct config_group *group, const char *name)
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 ERR_PTR(-ENOMEM);
371
372 config_group_init_type_name(&simple_children->group, name,
373 &simple_children_type);
374
375 return &simple_children->group;
376}
377
378static struct configfs_attribute group_children_attr_description = {
379 .ca_owner = THIS_MODULE,
380 .ca_name = "description",
381 .ca_mode = S_IRUGO,
382};
383
384static struct configfs_attribute *group_children_attrs[] = {
385 &group_children_attr_description,
386 NULL,
387};
388
389static ssize_t group_children_attr_show(struct config_item *item,
390 struct configfs_attribute *attr,
391 char *page)
392{
393 return sprintf(page,
394"[03-group-children]\n"
395"\n"
396"This subsystem allows the creation of child config_groups. These\n"
397"groups are like the subsystem simple-children.\n");
398}
399
400static struct configfs_item_operations group_children_item_ops = {
401 .show_attribute = group_children_attr_show,
402};
403
404/*
405 * Note that, since no extra work is required on ->drop_item(),
406 * no ->drop_item() is provided.
407 */
408static struct configfs_group_operations group_children_group_ops = {
409 .make_group = group_children_make_group,
410};
411
412static struct config_item_type group_children_type = {
413 .ct_item_ops = &group_children_item_ops,
414 .ct_group_ops = &group_children_group_ops,
415 .ct_attrs = group_children_attrs,
416 .ct_owner = THIS_MODULE,
417};
418
419static struct configfs_subsystem group_children_subsys = {
420 .su_group = {
421 .cg_item = {
422 .ci_namebuf = "03-group-children",
423 .ci_type = &group_children_type,
424 },
425 },
426};
427
428/* ----------------------------------------------------------------- */
429
430/*
431 * We're now done with our subsystem definitions.
432 * For convenience in this module, here's a list of them all. It
433 * allows the init function to easily register them. Most modules
434 * will only have one subsystem, and will only call register_subsystem
435 * on it directly.
436 */
437static struct configfs_subsystem *example_subsys[] = {
438 &childless_subsys.subsys,
439 &simple_children_subsys,
440 &group_children_subsys,
441 NULL,
442};
443
444static int __init configfs_example_init(void)
445{
446 int ret;
447 int i;
448 struct configfs_subsystem *subsys;
449
450 for (i = 0; example_subsys[i]; i++) {
451 subsys = example_subsys[i];
452
453 config_group_init(&subsys->su_group);
454 mutex_init(&subsys->su_mutex);
455 ret = configfs_register_subsystem(subsys);
456 if (ret) {
457 printk(KERN_ERR "Error %d while registering subsystem %s\n",
458 ret,
459 subsys->su_group.cg_item.ci_namebuf);
460 goto out_unregister;
461 }
462 }
463
464 return 0;
465
466out_unregister:
467 for (i--; i >= 0; i--)
468 configfs_unregister_subsystem(example_subsys[i]);
469
470 return ret;
471}
472
473static void __exit configfs_example_exit(void)
474{
475 int i;
476
477 for (i = 0; example_subsys[i]; i++)
478 configfs_unregister_subsystem(example_subsys[i]);
479}
480
481module_init(configfs_example_init);
482module_exit(configfs_example_exit);
483MODULE_LICENSE("GPL");
diff --git a/fs/configfs/file.c b/fs/configfs/file.c
index 106ca589e90a..d39099ea7df7 100644
--- a/fs/configfs/file.c
+++ b/fs/configfs/file.c
@@ -65,7 +65,6 @@ static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buf
65{ 65{
66 struct configfs_attribute * attr = to_attr(dentry); 66 struct configfs_attribute * attr = to_attr(dentry);
67 struct config_item * item = to_item(dentry->d_parent); 67 struct config_item * item = to_item(dentry->d_parent);
68 struct configfs_item_operations * ops = buffer->ops;
69 int ret = 0; 68 int ret = 0;
70 ssize_t count; 69 ssize_t count;
71 70
@@ -74,10 +73,7 @@ static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buf
74 if (!buffer->page) 73 if (!buffer->page)
75 return -ENOMEM; 74 return -ENOMEM;
76 75
77 if (ops->show_attribute) 76 count = attr->show(item, buffer->page);
78 count = ops->show_attribute(item, attr, buffer->page);
79 else
80 count = attr->show(item, buffer->page);
81 77
82 buffer->needs_read_fill = 0; 78 buffer->needs_read_fill = 0;
83 BUG_ON(count > (ssize_t)SIMPLE_ATTR_SIZE); 79 BUG_ON(count > (ssize_t)SIMPLE_ATTR_SIZE);
@@ -175,10 +171,7 @@ flush_write_buffer(struct dentry * dentry, struct configfs_buffer * buffer, size
175{ 171{
176 struct configfs_attribute * attr = to_attr(dentry); 172 struct configfs_attribute * attr = to_attr(dentry);
177 struct config_item * item = to_item(dentry->d_parent); 173 struct config_item * item = to_item(dentry->d_parent);
178 struct configfs_item_operations * ops = buffer->ops;
179 174
180 if (ops->store_attribute)
181 return ops->store_attribute(item, attr, buffer->page, count);
182 return attr->store(item, buffer->page, count); 175 return attr->store(item, buffer->page, count);
183} 176}
184 177
@@ -243,8 +236,7 @@ static int check_perm(struct inode * inode, struct file * file)
243 * and we must have a store method. 236 * and we must have a store method.
244 */ 237 */
245 if (file->f_mode & FMODE_WRITE) { 238 if (file->f_mode & FMODE_WRITE) {
246 if (!(inode->i_mode & S_IWUGO) || 239 if (!(inode->i_mode & S_IWUGO) || !attr->store)
247 (!ops->store_attribute && !attr->store))
248 goto Eaccess; 240 goto Eaccess;
249 241
250 } 242 }
@@ -254,8 +246,7 @@ static int check_perm(struct inode * inode, struct file * file)
254 * must be a show method for it. 246 * must be a show method for it.
255 */ 247 */
256 if (file->f_mode & FMODE_READ) { 248 if (file->f_mode & FMODE_READ) {
257 if (!(inode->i_mode & S_IRUGO) || 249 if (!(inode->i_mode & S_IRUGO) || !attr->show)
258 (!ops->show_attribute && !attr->show))
259 goto Eaccess; 250 goto Eaccess;
260 } 251 }
261 252
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index 85e9956a86de..a8a335b7fce0 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -155,86 +155,6 @@ static struct configfs_attribute _pfx##attr_##_name = { \
155} 155}
156 156
157/* 157/*
158 * Users often need to create attribute structures for their configurable
159 * attributes, containing a configfs_attribute member and function pointers
160 * for the show() and store() operations on that attribute. If they don't
161 * need anything else on the extended attribute structure, they can use
162 * this macro to define it The argument _item is the name of the
163 * config_item structure.
164 */
165#define CONFIGFS_ATTR_STRUCT(_item) \
166struct _item##_attribute { \
167 struct configfs_attribute attr; \
168 ssize_t (*show)(struct _item *, char *); \
169 ssize_t (*store)(struct _item *, const char *, size_t); \
170}
171
172/*
173 * With the extended attribute structure, users can use this macro
174 * (similar to sysfs' __ATTR) to make defining attributes easier.
175 * An example:
176 * #define MYITEM_ATTR(_name, _mode, _show, _store) \
177 * struct myitem_attribute childless_attr_##_name = \
178 * __CONFIGFS_ATTR(_name, _mode, _show, _store)
179 */
180#define __CONFIGFS_ATTR(_name, _mode, _show, _store) \
181{ \
182 .attr = { \
183 .ca_name = __stringify(_name), \
184 .ca_mode = _mode, \
185 .ca_owner = THIS_MODULE, \
186 }, \
187 .show = _show, \
188 .store = _store, \
189}
190/* Here is a readonly version, only requiring a show() operation */
191#define __CONFIGFS_ATTR_RO(_name, _show) \
192{ \
193 .attr = { \
194 .ca_name = __stringify(_name), \
195 .ca_mode = 0444, \
196 .ca_owner = THIS_MODULE, \
197 }, \
198 .show = _show, \
199}
200
201/*
202 * With these extended attributes, the simple show_attribute() and
203 * store_attribute() operations need to call the show() and store() of the
204 * attributes. This is a common pattern, so we provide a macro to define
205 * them. The argument _item is the name of the config_item structure.
206 * This macro expects the attributes to be named "struct <name>_attribute"
207 * and the function to_<name>() to exist;
208 */
209#define CONFIGFS_ATTR_OPS(_item) \
210static ssize_t _item##_attr_show(struct config_item *item, \
211 struct configfs_attribute *attr, \
212 char *page) \
213{ \
214 struct _item *_item = to_##_item(item); \
215 struct _item##_attribute *_item##_attr = \
216 container_of(attr, struct _item##_attribute, attr); \
217 ssize_t ret = 0; \
218 \
219 if (_item##_attr->show) \
220 ret = _item##_attr->show(_item, page); \
221 return ret; \
222} \
223static ssize_t _item##_attr_store(struct config_item *item, \
224 struct configfs_attribute *attr, \
225 const char *page, size_t count) \
226{ \
227 struct _item *_item = to_##_item(item); \
228 struct _item##_attribute *_item##_attr = \
229 container_of(attr, struct _item##_attribute, attr); \
230 ssize_t ret = -EINVAL; \
231 \
232 if (_item##_attr->store) \
233 ret = _item##_attr->store(_item, page, count); \
234 return ret; \
235}
236
237/*
238 * If allow_link() exists, the item can symlink(2) out to other 158 * If allow_link() exists, the item can symlink(2) out to other
239 * items. If the item is a group, it may support mkdir(2). 159 * items. If the item is a group, it may support mkdir(2).
240 * Groups supply one of make_group() and make_item(). If the 160 * Groups supply one of make_group() and make_item(). If the
@@ -250,8 +170,6 @@ static ssize_t _item##_attr_store(struct config_item *item, \
250 */ 170 */
251struct configfs_item_operations { 171struct configfs_item_operations {
252 void (*release)(struct config_item *); 172 void (*release)(struct config_item *);
253 ssize_t (*show_attribute)(struct config_item *, struct configfs_attribute *,char *);
254 ssize_t (*store_attribute)(struct config_item *,struct configfs_attribute *,const char *, size_t);
255 int (*allow_link)(struct config_item *src, struct config_item *target); 173 int (*allow_link)(struct config_item *src, struct config_item *target);
256 int (*drop_link)(struct config_item *src, struct config_item *target); 174 int (*drop_link)(struct config_item *src, struct config_item *target);
257}; 175};
diff --git a/samples/Kconfig b/samples/Kconfig
index 224ebb46bed5..d54f28c6dc5e 100644
--- a/samples/Kconfig
+++ b/samples/Kconfig
@@ -70,4 +70,10 @@ config SAMPLE_LIVEPATCH
70 Builds a sample live patch that replaces the procfs handler 70 Builds a sample live patch that replaces the procfs handler
71 for /proc/cmdline to print "this has been live patched". 71 for /proc/cmdline to print "this has been live patched".
72 72
73config SAMPLE_CONFIGFS
74 tristate "Build configfs patching sample -- loadable modules only"
75 depends on CONFIGFS_FS && m
76 help
77 Builds a sample configfs interface.
78
73endif # SAMPLES 79endif # SAMPLES
diff --git a/samples/Makefile b/samples/Makefile
index f00257bcc5a7..48001d7e23f0 100644
--- a/samples/Makefile
+++ b/samples/Makefile
@@ -1,4 +1,5 @@
1# Makefile for Linux samples code 1# Makefile for Linux samples code
2 2
3obj-$(CONFIG_SAMPLES) += kobject/ kprobes/ trace_events/ livepatch/ \ 3obj-$(CONFIG_SAMPLES) += kobject/ kprobes/ trace_events/ livepatch/ \
4 hw_breakpoint/ kfifo/ kdb/ hidraw/ rpmsg/ seccomp/ 4 hw_breakpoint/ kfifo/ kdb/ hidraw/ rpmsg/ seccomp/ \
5 configfs/
diff --git a/samples/configfs/Makefile b/samples/configfs/Makefile
new file mode 100644
index 000000000000..a9afd99630fc
--- /dev/null
+++ b/samples/configfs/Makefile
@@ -0,0 +1,2 @@
1
2obj-$(CONFIG_SAMPLE_CONFIGFS) += configfs_sample.o
diff --git a/Documentation/filesystems/configfs/configfs_example_macros.c b/samples/configfs/configfs_sample.c
index 327dfbc640a9..1ea33119e532 100644
--- a/Documentation/filesystems/configfs/configfs_example_macros.c
+++ b/samples/configfs/configfs_sample.c
@@ -54,18 +54,13 @@ struct childless {
54 54
55static inline struct childless *to_childless(struct config_item *item) 55static inline struct childless *to_childless(struct config_item *item)
56{ 56{
57 return item ? container_of(to_configfs_subsystem(to_config_group(item)), struct childless, subsys) : NULL; 57 return item ? container_of(to_configfs_subsystem(to_config_group(item)),
58 struct childless, subsys) : NULL;
58} 59}
59 60
60CONFIGFS_ATTR_STRUCT(childless); 61static ssize_t childless_showme_show(struct config_item *item, char *page)
61#define CHILDLESS_ATTR(_name, _mode, _show, _store) \
62struct childless_attribute childless_attr_##_name = __CONFIGFS_ATTR(_name, _mode, _show, _store)
63#define CHILDLESS_ATTR_RO(_name, _show) \
64struct childless_attribute childless_attr_##_name = __CONFIGFS_ATTR_RO(_name, _show);
65
66static ssize_t childless_showme_read(struct childless *childless,
67 char *page)
68{ 62{
63 struct childless *childless = to_childless(item);
69 ssize_t pos; 64 ssize_t pos;
70 65
71 pos = sprintf(page, "%d\n", childless->showme); 66 pos = sprintf(page, "%d\n", childless->showme);
@@ -74,16 +69,15 @@ static ssize_t childless_showme_read(struct childless *childless,
74 return pos; 69 return pos;
75} 70}
76 71
77static ssize_t childless_storeme_read(struct childless *childless, 72static ssize_t childless_storeme_show(struct config_item *item, char *page)
78 char *page)
79{ 73{
80 return sprintf(page, "%d\n", childless->storeme); 74 return sprintf(page, "%d\n", to_childless(item)->storeme);
81} 75}
82 76
83static ssize_t childless_storeme_write(struct childless *childless, 77static ssize_t childless_storeme_store(struct config_item *item,
84 const char *page, 78 const char *page, size_t count)
85 size_t count)
86{ 79{
80 struct childless *childless = to_childless(item);
87 unsigned long tmp; 81 unsigned long tmp;
88 char *p = (char *) page; 82 char *p = (char *) page;
89 83
@@ -99,8 +93,7 @@ static ssize_t childless_storeme_write(struct childless *childless,
99 return count; 93 return count;
100} 94}
101 95
102static ssize_t childless_description_read(struct childless *childless, 96static ssize_t childless_description_show(struct config_item *item, char *page)
103 char *page)
104{ 97{
105 return sprintf(page, 98 return sprintf(page,
106"[01-childless]\n" 99"[01-childless]\n"
@@ -111,26 +104,18 @@ static ssize_t childless_description_read(struct childless *childless,
111"than a directory in /proc.\n"); 104"than a directory in /proc.\n");
112} 105}
113 106
114CHILDLESS_ATTR_RO(showme, childless_showme_read); 107CONFIGFS_ATTR_RO(childless_, showme);
115CHILDLESS_ATTR(storeme, S_IRUGO | S_IWUSR, childless_storeme_read, 108CONFIGFS_ATTR(childless_, storeme);
116 childless_storeme_write); 109CONFIGFS_ATTR_RO(childless_, description);
117CHILDLESS_ATTR_RO(description, childless_description_read);
118 110
119static struct configfs_attribute *childless_attrs[] = { 111static struct configfs_attribute *childless_attrs[] = {
120 &childless_attr_showme.attr, 112 &childless_attr_showme,
121 &childless_attr_storeme.attr, 113 &childless_attr_storeme,
122 &childless_attr_description.attr, 114 &childless_attr_description,
123 NULL, 115 NULL,
124}; 116};
125 117
126CONFIGFS_ATTR_OPS(childless);
127static struct configfs_item_operations childless_item_ops = {
128 .show_attribute = childless_attr_show,
129 .store_attribute = childless_attr_store,
130};
131
132static struct config_item_type childless_type = { 118static struct config_item_type childless_type = {
133 .ct_item_ops = &childless_item_ops,
134 .ct_attrs = childless_attrs, 119 .ct_attrs = childless_attrs,
135 .ct_owner = THIS_MODULE, 120 .ct_owner = THIS_MODULE,
136}; 121};
@@ -168,32 +153,13 @@ static inline struct simple_child *to_simple_child(struct config_item *item)
168 return item ? container_of(item, struct simple_child, item) : NULL; 153 return item ? container_of(item, struct simple_child, item) : NULL;
169} 154}
170 155
171static struct configfs_attribute simple_child_attr_storeme = { 156static ssize_t simple_child_storeme_show(struct config_item *item, char *page)
172 .ca_owner = THIS_MODULE,
173 .ca_name = "storeme",
174 .ca_mode = S_IRUGO | S_IWUSR,
175};
176
177static struct configfs_attribute *simple_child_attrs[] = {
178 &simple_child_attr_storeme,
179 NULL,
180};
181
182static ssize_t simple_child_attr_show(struct config_item *item,
183 struct configfs_attribute *attr,
184 char *page)
185{ 157{
186 ssize_t count; 158 return sprintf(page, "%d\n", to_simple_child(item)->storeme);
187 struct simple_child *simple_child = to_simple_child(item);
188
189 count = sprintf(page, "%d\n", simple_child->storeme);
190
191 return count;
192} 159}
193 160
194static ssize_t simple_child_attr_store(struct config_item *item, 161static ssize_t simple_child_storeme_store(struct config_item *item,
195 struct configfs_attribute *attr, 162 const char *page, size_t count)
196 const char *page, size_t count)
197{ 163{
198 struct simple_child *simple_child = to_simple_child(item); 164 struct simple_child *simple_child = to_simple_child(item);
199 unsigned long tmp; 165 unsigned long tmp;
@@ -211,6 +177,13 @@ static ssize_t simple_child_attr_store(struct config_item *item,
211 return count; 177 return count;
212} 178}
213 179
180CONFIGFS_ATTR(simple_child_, storeme);
181
182static struct configfs_attribute *simple_child_attrs[] = {
183 &simple_child_attr_storeme,
184 NULL,
185};
186
214static void simple_child_release(struct config_item *item) 187static void simple_child_release(struct config_item *item)
215{ 188{
216 kfree(to_simple_child(item)); 189 kfree(to_simple_child(item));
@@ -218,8 +191,6 @@ static void simple_child_release(struct config_item *item)
218 191
219static struct configfs_item_operations simple_child_item_ops = { 192static struct configfs_item_operations simple_child_item_ops = {
220 .release = simple_child_release, 193 .release = simple_child_release,
221 .show_attribute = simple_child_attr_show,
222 .store_attribute = simple_child_attr_store,
223}; 194};
224 195
225static struct config_item_type simple_child_type = { 196static struct config_item_type simple_child_type = {
@@ -235,10 +206,12 @@ struct simple_children {
235 206
236static inline struct simple_children *to_simple_children(struct config_item *item) 207static inline struct simple_children *to_simple_children(struct config_item *item)
237{ 208{
238 return item ? container_of(to_config_group(item), struct simple_children, group) : NULL; 209 return item ? container_of(to_config_group(item),
210 struct simple_children, group) : NULL;
239} 211}
240 212
241static struct config_item *simple_children_make_item(struct config_group *group, const char *name) 213static struct config_item *simple_children_make_item(struct config_group *group,
214 const char *name)
242{ 215{
243 struct simple_child *simple_child; 216 struct simple_child *simple_child;
244 217
@@ -254,20 +227,8 @@ static struct config_item *simple_children_make_item(struct config_group *group,
254 return &simple_child->item; 227 return &simple_child->item;
255} 228}
256 229
257static struct configfs_attribute simple_children_attr_description = { 230static ssize_t simple_children_description_show(struct config_item *item,
258 .ca_owner = THIS_MODULE, 231 char *page)
259 .ca_name = "description",
260 .ca_mode = S_IRUGO,
261};
262
263static struct configfs_attribute *simple_children_attrs[] = {
264 &simple_children_attr_description,
265 NULL,
266};
267
268static ssize_t simple_children_attr_show(struct config_item *item,
269 struct configfs_attribute *attr,
270 char *page)
271{ 232{
272 return sprintf(page, 233 return sprintf(page,
273"[02-simple-children]\n" 234"[02-simple-children]\n"
@@ -276,6 +237,13 @@ static ssize_t simple_children_attr_show(struct config_item *item,
276"items have only one attribute that is readable and writeable.\n"); 237"items have only one attribute that is readable and writeable.\n");
277} 238}
278 239
240CONFIGFS_ATTR_RO(simple_children_, description);
241
242static struct configfs_attribute *simple_children_attrs[] = {
243 &simple_children_attr_description,
244 NULL,
245};
246
279static void simple_children_release(struct config_item *item) 247static void simple_children_release(struct config_item *item)
280{ 248{
281 kfree(to_simple_children(item)); 249 kfree(to_simple_children(item));
@@ -283,7 +251,6 @@ static void simple_children_release(struct config_item *item)
283 251
284static struct configfs_item_operations simple_children_item_ops = { 252static struct configfs_item_operations simple_children_item_ops = {
285 .release = simple_children_release, 253 .release = simple_children_release,
286 .show_attribute = simple_children_attr_show,
287}; 254};
288 255
289/* 256/*
@@ -323,7 +290,8 @@ static struct configfs_subsystem simple_children_subsys = {
323 * children of its own. 290 * children of its own.
324 */ 291 */
325 292
326static struct config_group *group_children_make_group(struct config_group *group, const char *name) 293static struct config_group *group_children_make_group(
294 struct config_group *group, const char *name)
327{ 295{
328 struct simple_children *simple_children; 296 struct simple_children *simple_children;
329 297
@@ -338,20 +306,8 @@ static struct config_group *group_children_make_group(struct config_group *group
338 return &simple_children->group; 306 return &simple_children->group;
339} 307}
340 308
341static struct configfs_attribute group_children_attr_description = { 309static ssize_t group_children_description_show(struct config_item *item,
342 .ca_owner = THIS_MODULE, 310 char *page)
343 .ca_name = "description",
344 .ca_mode = S_IRUGO,
345};
346
347static struct configfs_attribute *group_children_attrs[] = {
348 &group_children_attr_description,
349 NULL,
350};
351
352static ssize_t group_children_attr_show(struct config_item *item,
353 struct configfs_attribute *attr,
354 char *page)
355{ 311{
356 return sprintf(page, 312 return sprintf(page,
357"[03-group-children]\n" 313"[03-group-children]\n"
@@ -360,8 +316,11 @@ static ssize_t group_children_attr_show(struct config_item *item,
360"groups are like the subsystem simple-children.\n"); 316"groups are like the subsystem simple-children.\n");
361} 317}
362 318
363static struct configfs_item_operations group_children_item_ops = { 319CONFIGFS_ATTR_RO(group_children_, description);
364 .show_attribute = group_children_attr_show, 320
321static struct configfs_attribute *group_children_attrs[] = {
322 &group_children_attr_description,
323 NULL,
365}; 324};
366 325
367/* 326/*
@@ -373,7 +332,6 @@ static struct configfs_group_operations group_children_group_ops = {
373}; 332};
374 333
375static struct config_item_type group_children_type = { 334static struct config_item_type group_children_type = {
376 .ct_item_ops = &group_children_item_ops,
377 .ct_group_ops = &group_children_group_ops, 335 .ct_group_ops = &group_children_group_ops,
378 .ct_attrs = group_children_attrs, 336 .ct_attrs = group_children_attrs,
379 .ct_owner = THIS_MODULE, 337 .ct_owner = THIS_MODULE,
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-25 11:17:12 -0400