[linux-block.git] / Documentation / filesystems / configfs / configfs_example_macros.c

/*
 * vim: noexpandtab ts=8 sts=0 sw=8:
 *
 * configfs_example_macros.c - This file is a demonstration module
 *      containing a number of configfs subsystems.  It uses the helper
 *      macros defined by configfs.h
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 *
 * Based on sysfs:
 * 	sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
 *
 * configfs Copyright (C) 2005 Oracle.  All rights reserved.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>

#include <linux/configfs.h>


/*
 * 01-childless
 *
 * This first example is a childless subsystem.  It cannot create
 * any config_items.  It just has attributes.
 *
 * Note that we are enclosing the configfs_subsystem inside a container.
 * This is not necessary if a subsystem has no attributes directly
 * on the subsystem.  See the next example, 02-simple-children, for
 * such a subsystem.
 */

struct childless {
	struct configfs_subsystem subsys;
	int showme;
	int storeme;
};

static inline struct childless *to_childless(struct config_item *item)
{
	return item ? container_of(to_configfs_subsystem(to_config_group(item)), struct childless, subsys) : NULL;
}

CONFIGFS_ATTR_STRUCT(childless);
#define CHILDLESS_ATTR(_name, _mode, _show, _store)	\
struct childless_attribute childless_attr_##_name = __CONFIGFS_ATTR(_name, _mode, _show, _store)
#define CHILDLESS_ATTR_RO(_name, _show)	\
struct childless_attribute childless_attr_##_name = __CONFIGFS_ATTR_RO(_name, _show);

static ssize_t childless_showme_read(struct childless *childless,
				     char *page)
{
	ssize_t pos;

	pos = sprintf(page, "%d\n", childless->showme);
	childless->showme++;

	return pos;
}

static ssize_t childless_storeme_read(struct childless *childless,
				      char *page)
{
	return sprintf(page, "%d\n", childless->storeme);
}

static ssize_t childless_storeme_write(struct childless *childless,
				       const char *page,
				       size_t count)
{
	unsigned long tmp;
	char *p = (char *) page;

	tmp = simple_strtoul(p, &p, 10);
	if (!p || (*p && (*p != '\n')))
		return -EINVAL;

	if (tmp > INT_MAX)
		return -ERANGE;

	childless->storeme = tmp;

	return count;
}

static ssize_t childless_description_read(struct childless *childless,
					  char *page)
{
	return sprintf(page,
"[01-childless]\n"
"\n"
"The childless subsystem is the simplest possible subsystem in\n"
"configfs.  It does not support the creation of child config_items.\n"
"It only has a few attributes.  In fact, it isn't much different\n"
"than a directory in /proc.\n");
}

CHILDLESS_ATTR_RO(showme, childless_showme_read);
CHILDLESS_ATTR(storeme, S_IRUGO | S_IWUSR, childless_storeme_read,
	       childless_storeme_write);
CHILDLESS_ATTR_RO(description, childless_description_read);

static struct configfs_attribute *childless_attrs[] = {
	&childless_attr_showme.attr,
	&childless_attr_storeme.attr,
	&childless_attr_description.attr,
	NULL,
};

CONFIGFS_ATTR_OPS(childless);
static struct configfs_item_operations childless_item_ops = {
	.show_attribute		= childless_attr_show,
	.store_attribute	= childless_attr_store,
};

static struct config_item_type childless_type = {
	.ct_item_ops	= &childless_item_ops,
	.ct_attrs	= childless_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct childless childless_subsys = {
	.subsys = {
		.su_group = {
			.cg_item = {
				.ci_namebuf = "01-childless",
				.ci_type = &childless_type,
			},
		},
	},
};


/* ----------------------------------------------------------------- */

/*
 * 02-simple-children
 *
 * This example merely has a simple one-attribute child.  Note that
 * there is no extra attribute structure, as the child's attribute is
 * known from the get-go.  Also, there is no container for the
 * subsystem, as it has no attributes of its own.
 */

struct simple_child {
	struct config_item item;
	int storeme;
};

static inline struct simple_child *to_simple_child(struct config_item *item)
{
	return item ? container_of(item, struct simple_child, item) : NULL;
}

static struct configfs_attribute simple_child_attr_storeme = {
	.ca_owner = THIS_MODULE,
	.ca_name = "storeme",
	.ca_mode = S_IRUGO | S_IWUSR,
};

static struct configfs_attribute *simple_child_attrs[] = {
	&simple_child_attr_storeme,
	NULL,
};

static ssize_t simple_child_attr_show(struct config_item *item,
				      struct configfs_attribute *attr,
				      char *page)
{
	ssize_t count;
	struct simple_child *simple_child = to_simple_child(item);

	count = sprintf(page, "%d\n", simple_child->storeme);

	return count;
}

static ssize_t simple_child_attr_store(struct config_item *item,
				       struct configfs_attribute *attr,
				       const char *page, size_t count)
{
	struct simple_child *simple_child = to_simple_child(item);
	unsigned long tmp;
	char *p = (char *) page;

	tmp = simple_strtoul(p, &p, 10);
	if (!p || (*p && (*p != '\n')))
		return -EINVAL;

	if (tmp > INT_MAX)
		return -ERANGE;

	simple_child->storeme = tmp;

	return count;
}

static void simple_child_release(struct config_item *item)
{
	kfree(to_simple_child(item));
}

static struct configfs_item_operations simple_child_item_ops = {
	.release		= simple_child_release,
	.show_attribute		= simple_child_attr_show,
	.store_attribute	= simple_child_attr_store,
};

static struct config_item_type simple_child_type = {
	.ct_item_ops	= &simple_child_item_ops,
	.ct_attrs	= simple_child_attrs,
	.ct_owner	= THIS_MODULE,
};


struct simple_children {
	struct config_group group;
};

static inline struct simple_children *to_simple_children(struct config_item *item)
{
	return item ? container_of(to_config_group(item), struct simple_children, group) : NULL;
}

static struct config_item *simple_children_make_item(struct config_group *group, const char *name)
{
	struct simple_child *simple_child;

	simple_child = kzalloc(sizeof(struct simple_child), GFP_KERNEL);
	if (!simple_child)
		return ERR_PTR(-ENOMEM);

	config_item_init_type_name(&simple_child->item, name,
				   &simple_child_type);

	simple_child->storeme = 0;

	return &simple_child->item;
}

static struct configfs_attribute simple_children_attr_description = {
	.ca_owner = THIS_MODULE,
	.ca_name = "description",
	.ca_mode = S_IRUGO,
};

static struct configfs_attribute *simple_children_attrs[] = {
	&simple_children_attr_description,
	NULL,
};

static ssize_t simple_children_attr_show(struct config_item *item,
					 struct configfs_attribute *attr,
					 char *page)
{
	return sprintf(page,
"[02-simple-children]\n"
"\n"
"This subsystem allows the creation of child config_items.  These\n"
"items have only one attribute that is readable and writeable.\n");
}

static void simple_children_release(struct config_item *item)
{
	kfree(to_simple_children(item));
}

static struct configfs_item_operations simple_children_item_ops = {
	.release	= simple_children_release,
	.show_attribute	= simple_children_attr_show,
};

/*
 * Note that, since no extra work is required on ->drop_item(),
 * no ->drop_item() is provided.
 */
static struct configfs_group_operations simple_children_group_ops = {
	.make_item	= simple_children_make_item,
};

static struct config_item_type simple_children_type = {
	.ct_item_ops	= &simple_children_item_ops,
	.ct_group_ops	= &simple_children_group_ops,
	.ct_attrs	= simple_children_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct configfs_subsystem simple_children_subsys = {
	.su_group = {
		.cg_item = {
			.ci_namebuf = "02-simple-children",
			.ci_type = &simple_children_type,
		},
	},
};


/* ----------------------------------------------------------------- */

/*
 * 03-group-children
 *
 * This example reuses the simple_children group from above.  However,
 * the simple_children group is not the subsystem itself, it is a
 * child of the subsystem.  Creation of a group in the subsystem creates
 * a new simple_children group.  That group can then have simple_child
 * children of its own.
 */

static struct config_group *group_children_make_group(struct config_group *group, const char *name)
{
	struct simple_children *simple_children;

	simple_children = kzalloc(sizeof(struct simple_children),
				  GFP_KERNEL);
	if (!simple_children)
		return ERR_PTR(-ENOMEM);

	config_group_init_type_name(&simple_children->group, name,
				    &simple_children_type);

	return &simple_children->group;
}

static struct configfs_attribute group_children_attr_description = {
	.ca_owner = THIS_MODULE,
	.ca_name = "description",
	.ca_mode = S_IRUGO,
};

static struct configfs_attribute *group_children_attrs[] = {
	&group_children_attr_description,
	NULL,
};

static ssize_t group_children_attr_show(struct config_item *item,
					struct configfs_attribute *attr,
					char *page)
{
	return sprintf(page,
"[03-group-children]\n"
"\n"
"This subsystem allows the creation of child config_groups.  These\n"
"groups are like the subsystem simple-children.\n");
}

static struct configfs_item_operations group_children_item_ops = {
	.show_attribute	= group_children_attr_show,
};

/*
 * Note that, since no extra work is required on ->drop_item(),
 * no ->drop_item() is provided.
 */
static struct configfs_group_operations group_children_group_ops = {
	.make_group	= group_children_make_group,
};

static struct config_item_type group_children_type = {
	.ct_item_ops	= &group_children_item_ops,
	.ct_group_ops	= &group_children_group_ops,
	.ct_attrs	= group_children_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct configfs_subsystem group_children_subsys = {
	.su_group = {
		.cg_item = {
			.ci_namebuf = "03-group-children",
			.ci_type = &group_children_type,
		},
	},
};

/* ----------------------------------------------------------------- */

/*
 * We're now done with our subsystem definitions.
 * For convenience in this module, here's a list of them all.  It
 * allows the init function to easily register them.  Most modules
 * will only have one subsystem, and will only call register_subsystem
 * on it directly.
 */
static struct configfs_subsystem *example_subsys[] = {
	&childless_subsys.subsys,
	&simple_children_subsys,
	&group_children_subsys,
	NULL,
};

static int __init configfs_example_init(void)
{
	int ret;
	int i;
	struct configfs_subsystem *subsys;

	for (i = 0; example_subsys[i]; i++) {
		subsys = example_subsys[i];

		config_group_init(&subsys->su_group);
		mutex_init(&subsys->su_mutex);
		ret = configfs_register_subsystem(subsys);
		if (ret) {
			printk(KERN_ERR "Error %d while registering subsystem %s\n",
			       ret,
			       subsys->su_group.cg_item.ci_namebuf);
			goto out_unregister;
		}
	}

	return 0;

out_unregister:
	for (; i >= 0; i--) {
		configfs_unregister_subsystem(example_subsys[i]);
	}

	return ret;
}

static void __exit configfs_example_exit(void)
{
	int i;

	for (i = 0; example_subsys[i]; i++) {
		configfs_unregister_subsystem(example_subsys[i]);
	}
}

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