[PATCH] configfs: User-driven configuration filesystem

Configfs, a file system for userspace-driven kernel object configuration. The OCFS2 stack makes extensive use of this for propagation of cluster configuration information into kernel. Signed-off-by: Joel Becker <joel.becker@oracle.com>

[PATCH] configfs: User-driven configuration filesystem
Configfs, a file system for userspace-driven kernel object configuration. The OCFS2 stack makes extensive use of this for propagation of cluster configuration information into kernel. Signed-off-by: Joel Becker <joel.becker@oracle.com>
Joel Becker
1 parent 88026842b0
Showing 15 changed files with 3575 additions and 0 deletions Side-by-side Diff
Documentation/filesystems/00-INDEX
Documentation/filesystems/configfs/configfs.txt
Documentation/filesystems/configfs/configfs_example.c
MAINTAINERS
fs/Kconfig
fs/Makefile
fs/configfs/Makefile
fs/configfs/configfs_internal.h
fs/configfs/dir.c
fs/configfs/file.c
fs/configfs/inode.c
fs/configfs/item.c
fs/configfs/mount.c
fs/configfs/symlink.c
include/linux/configfs.h
@@ -12,6 +12,8 @@
 	- description of the CIFS filesystem
 coda.txt
 	- description of the CODA filesystem.
+configfs/
+	- directory containing configfs documentation and example code.
 cramfs.txt
 	- info on the cram filesystem for small storage (ROMs etc)
 devfs/
+
+configfs - Userspace-driven kernel object configuation.
+
+Joel Becker <joel.becker@oracle.com>
+
+Updated: 31 March 2005
+
+Copyright (c) 2005 Oracle Corporation,
+	Joel Becker <joel.becker@oracle.com>
+
+
+[What is configfs?]
+
+configfs is a ram-based filesystem that provides the converse of
+sysfs's functionality.  Where sysfs is a filesystem-based view of
+kernel objects, configfs is a filesystem-based manager of kernel
+objects, or config_items.
+
+With sysfs, an object is created in kernel (for example, when a device
+is discovered) and it is registered with sysfs.  Its attributes then
+appear in sysfs, allowing userspace to read the attributes via
+readdir(3)/read(2).  It may allow some attributes to be modified via
+write(2).  The important point is that the object is created and
+destroyed in kernel, the kernel controls the lifecycle of the sysfs
+representation, and sysfs is merely a window on all this.
+
+A configfs config_item is created via an explicit userspace operation:
+mkdir(2).  It is destroyed via rmdir(2).  The attributes appear at
+mkdir(2) time, and can be read or modified via read(2) and write(2).
+As with sysfs, readdir(3) queries the list of items and/or attributes.
+symlink(2) can be used to group items together.  Unlike sysfs, the
+lifetime of the representation is completely driven by userspace.  The
+kernel modules backing the items must respond to this.
+
+Both sysfs and configfs can and should exist together on the same
+system.  One is not a replacement for the other.
+
+[Using configfs]
+
+configfs can be compiled as a module or into the kernel.  You can access
+it by doing
+
+	mount -t configfs none /config
+
+The configfs tree will be empty unless client modules are also loaded.
+These are modules that register their item types with configfs as
+subsystems.  Once a client subsystem is loaded, it will appear as a
+subdirectory (or more than one) under /config.  Like sysfs, the
+configfs tree is always there, whether mounted on /config or not.
+
+An item is created via mkdir(2).  The item's attributes will also
+appear at this time.  readdir(3) can determine what the attributes are,
+read(2) can query their default values, and write(2) can store new
+values.  Like sysfs, attributes should be ASCII text files, preferably
+with only one value per file.  The same efficiency caveats from sysfs
+apply.  Don't mix more than one attribute in one attribute file.
+
+Like sysfs, configfs expects write(2) to store the entire buffer at
+once.  When writing to configfs attributes, userspace processes should
+first read the entire file, modify the portions they wish to change, and
+then write the entire buffer back.  Attribute files have a maximum size
+of one page (PAGE_SIZE, 4096 on i386).
+
+When an item needs to be destroyed, remove it with rmdir(2).  An
+item cannot be destroyed if any other item has a link to it (via
+symlink(2)).  Links can be removed via unlink(2).
+
+[Configuring FakeNBD: an Example]
+
+Imagine there's a Network Block Device (NBD) driver that allows you to
+access remote block devices.  Call it FakeNBD.  FakeNBD uses configfs
+for its configuration.  Obviously, there will be a nice program that
+sysadmins use to configure FakeNBD, but somehow that program has to tell
+the driver about it.  Here's where configfs comes in.
+
+When the FakeNBD driver is loaded, it registers itself with configfs.
+readdir(3) sees this just fine:
+
+	# ls /config
+	fakenbd
+
+A fakenbd connection can be created with mkdir(2).  The name is
+arbitrary, but likely the tool will make some use of the name.  Perhaps
+it is a uuid or a disk name:
+
+	# mkdir /config/fakenbd/disk1
+	# ls /config/fakenbd/disk1
+	target device rw
+
+The target attribute contains the IP address of the server FakeNBD will
+connect to.  The device attribute is the device on the server.
+Predictably, the rw attribute determines whether the connection is
+read-only or read-write.
+
+	# echo 10.0.0.1 > /config/fakenbd/disk1/target
+	# echo /dev/sda1 > /config/fakenbd/disk1/device
+	# echo 1 > /config/fakenbd/disk1/rw
+
+That's it.  That's all there is.  Now the device is configured, via the
+shell no less.
+
+[Coding With configfs]
+
+Every object in configfs is a config_item.  A config_item reflects an
+object in the subsystem.  It has attributes that match values on that
+object.  configfs handles the filesystem representation of that object
+and its attributes, allowing the subsystem to ignore all but the
+basic show/store interaction.
+
+Items are created and destroyed inside a config_group.  A group is a
+collection of items that share the same attributes and operations.
+Items are created by mkdir(2) and removed by rmdir(2), but configfs
+handles that.  The group has a set of operations to perform these tasks
+
+A subsystem is the top level of a client module.  During initialization,
+the client module registers the subsystem with configfs, the subsystem
+appears as a directory at the top of the configfs filesystem.  A
+subsystem is also a config_group, and can do everything a config_group
+can.
+
+[struct config_item]
+
+	struct config_item {
+		char                    *ci_name;
+		char                    ci_namebuf[UOBJ_NAME_LEN];
+		struct kref             ci_kref;
+		struct list_head        ci_entry;
+		struct config_item      *ci_parent;
+		struct config_group     *ci_group;
+		struct config_item_type *ci_type;
+		struct dentry           *ci_dentry;
+	};
+
+	void config_item_init(struct config_item *);
+	void config_item_init_type_name(struct config_item *,
+					const char *name,
+					struct config_item_type *type);
+	struct config_item *config_item_get(struct config_item *);
+	void config_item_put(struct config_item *);
+
+Generally, struct config_item is embedded in a container structure, a
+structure that actually represents what the subsystem is doing.  The
+config_item portion of that structure is how the object interacts with
+configfs.
+
+Whether statically defined in a source file or created by a parent
+config_group, a config_item must have one of the _init() functions
+called on it.  This initializes the reference count and sets up the
+appropriate fields.
+
+All users of a config_item should have a reference on it via
+config_item_get(), and drop the reference when they are done via
+config_item_put().
+
+By itself, a config_item cannot do much more than appear in configfs.
+Usually a subsystem wants the item to display and/or store attributes,
+among other things.  For that, it needs a type.
+
+[struct config_item_type]
+
+	struct configfs_item_operations {
+		void (*release)(struct config_item *);
+		ssize_t (*show_attribute)(struct config_item *,
+					  struct configfs_attribute *,
+					  char *);
+		ssize_t (*store_attribute)(struct config_item *,
+					   struct configfs_attribute *,
+					   const char *, size_t);
+		int (*allow_link)(struct config_item *src,
+				  struct config_item *target);
+		int (*drop_link)(struct config_item *src,
+				 struct config_item *target);
+	};
+
+	struct config_item_type {
+		struct module                           *ct_owner;
+		struct configfs_item_operations         *ct_item_ops;
+		struct configfs_group_operations        *ct_group_ops;
+		struct configfs_attribute               **ct_attrs;
+	};
+
+The most basic function of a config_item_type is to define what
+operations can be performed on a config_item.  All items that have been
+allocated dynamically will need to provide the ct_item_ops->release()
+method.  This method is called when the config_item's reference count
+reaches zero.  Items that wish to display an attribute need to provide
+the ct_item_ops->show_attribute() method.  Similarly, storing a new
+attribute value uses the store_attribute() method.
+
+[struct configfs_attribute]
+
+	struct configfs_attribute {
+		char                    *ca_name;
+		struct module           *ca_owner;
+		mode_t                  ca_mode;
+	};
+
+When a config_item wants an attribute to appear as a file in the item's
+configfs directory, it must define a configfs_attribute describing it.
+It then adds the attribute to the NULL-terminated array
+config_item_type->ct_attrs.  When the item appears in configfs, the
+attribute file will appear with the configfs_attribute->ca_name
+filename.  configfs_attribute->ca_mode specifies the file permissions.
+
+If an attribute is readable and the config_item provides a
+ct_item_ops->show_attribute() method, that method will be called
+whenever userspace asks for a read(2) on the attribute.  The converse
+will happen for write(2).
+
+[struct config_group]
+
+A config_item cannot live in a vaccum.  The only way one can be created
+is via mkdir(2) on a config_group.  This will trigger creation of a
+child item.
+
+	struct config_group {
+		struct config_item		cg_item;
+		struct list_head		cg_children;
+		struct configfs_subsystem 	*cg_subsys;
+		struct config_group		**default_groups;
+	};
+
+	void config_group_init(struct config_group *group);
+	void config_group_init_type_name(struct config_group *group,
+					 const char *name,
+					 struct config_item_type *type);
+
+
+The config_group structure contains a config_item.  Properly configuring
+that item means that a group can behave as an item in its own right.
+However, it can do more: it can create child items or groups.  This is
+accomplished via the group operations specified on the group's
+config_item_type.
+
+	struct configfs_group_operations {
+		struct config_item *(*make_item)(struct config_group *group,
+						 const char *name);
+		struct config_group *(*make_group)(struct config_group *group,
+						   const char *name);
+		int (*commit_item)(struct config_item *item);
+		void (*drop_item)(struct config_group *group,
+				  struct config_item *item);
+	};
+
+A group creates child items by providing the
+ct_group_ops->make_item() method.  If provided, this method is called from mkdir(2) in the group's directory.  The subsystem allocates a new
+config_item (or more likely, its container structure), initializes it,
+and returns it to configfs.  Configfs will then populate the filesystem
+tree to reflect the new item.
+
+If the subsystem wants the child to be a group itself, the subsystem
+provides ct_group_ops->make_group().  Everything else behaves the same,
+using the group _init() functions on the group.
+
+Finally, when userspace calls rmdir(2) on the item or group,
+ct_group_ops->drop_item() is called.  As a config_group is also a
+config_item, it is not necessary for a seperate drop_group() method.
+The subsystem must config_item_put() the reference that was initialized
+upon item allocation.  If a subsystem has no work to do, it may omit
+the ct_group_ops->drop_item() method, and configfs will call
+config_item_put() on the item on behalf of the subsystem.
+
+IMPORTANT: drop_item() is void, and as such cannot fail.  When rmdir(2)
+is called, configfs WILL remove the item from the filesystem tree
+(assuming that it has no children to keep it busy).  The subsystem is
+responsible for responding to this.  If the subsystem has references to
+the item in other threads, the memory is safe.  It may take some time
+for the item to actually disappear from the subsystem's usage.  But it
+is gone from configfs.
+
+A config_group cannot be removed while it still has child items.  This
+is implemented in the configfs rmdir(2) code.  ->drop_item() will not be
+called, as the item has not been dropped.  rmdir(2) will fail, as the
+directory is not empty.
+
+[struct configfs_subsystem]
+
+A subsystem must register itself, ususally at module_init time.  This
+tells configfs to make the subsystem appear in the file tree.
+
+	struct configfs_subsystem {
+		struct config_group	su_group;
+		struct semaphore	su_sem;
+	};
+
+	int configfs_register_subsystem(struct configfs_subsystem *subsys);
+	void configfs_unregister_subsystem(struct configfs_subsystem *subsys);
+
+	A subsystem consists of a toplevel config_group and a semaphore.
+The group is where child config_items are created.  For a subsystem,
+this group is usually defined statically.  Before calling
+configfs_register_subsystem(), the subsystem must have initialized the
+group via the usual group _init() functions, and it must also have
+initialized the semaphore.
+	When the register call returns, the subsystem is live, and it
+will be visible via configfs.  At that point, mkdir(2) can be called and
+the subsystem must be ready for it.
+
+[An Example]
+
+The best example of these basic concepts is the simple_children
+subsystem/group and the simple_child item in configfs_example.c  It
+shows a trivial object displaying and storing an attribute, and a simple
+group creating and destroying these children.
+
+[Hierarchy Navigation and the Subsystem Semaphore]
+
+There is an extra bonus that configfs provides.  The config_groups and
+config_items are arranged in a hierarchy due to the fact that they
+appear in a filesystem.  A subsystem is NEVER to touch the filesystem
+parts, but the subsystem might be interested in this hierarchy.  For
+this reason, the hierarchy is mirrored via the config_group->cg_children
+and config_item->ci_parent structure members.
+
+A subsystem can navigate the cg_children list and the ci_parent pointer
+to see the tree created by the subsystem.  This can race with configfs'
+management of the hierarchy, so configfs uses the subsystem semaphore to
+protect modifications.  Whenever a subsystem wants to navigate the
+hierarchy, it must do so under the protection of the subsystem
+semaphore.
+
+A subsystem will be prevented from acquiring the semaphore while a newly
+allocated item has not been linked into this hierarchy.   Similarly, it
+will not be able to acquire the semaphore while a dropping item has not
+yet been unlinked.  This means that an item's ci_parent pointer will
+never be NULL while the item is in configfs, and that an item will only
+be in its parent's cg_children list for the same duration.  This allows
+a subsystem to trust ci_parent and cg_children while they hold the
+semaphore.
+
+[Item Aggregation Via symlink(2)]
+
+configfs provides a simple group via the group->item parent/child
+relationship.  Often, however, a larger environment requires aggregation
+outside of the parent/child connection.  This is implemented via
+symlink(2).
+
+A config_item may provide the ct_item_ops->allow_link() and
+ct_item_ops->drop_link() methods.  If the ->allow_link() method exists,
+symlink(2) may be called with the config_item as the source of the link.
+These links are only allowed between configfs config_items.  Any
+symlink(2) attempt outside the configfs filesystem will be denied.
+
+When symlink(2) is called, the source config_item's ->allow_link()
+method is called with itself and a target item.  If the source item
+allows linking to target item, it returns 0.  A source item may wish to
+reject a link if it only wants links to a certain type of object (say,
+in its own subsystem).
+
+When unlink(2) is called on the symbolic link, the source item is
+notified via the ->drop_link() method.  Like the ->drop_item() method,
+this is a void function and cannot return failure.  The subsystem is
+responsible for responding to the change.
+
+A config_item cannot be removed while it links to any other item, nor
+can it be removed while an item links to it.  Dangling symlinks are not
+allowed in configfs.
+
+[Automatically Created Subgroups]
+
+A new config_group may want to have two types of child config_items.
+While this could be codified by magic names in ->make_item(), it is much
+more explicit to have a method whereby userspace sees this divergence.
+
+Rather than have a group where some items behave differently than
+others, configfs provides a method whereby one or many subgroups are
+automatically created inside the parent at its creation.  Thus,
+mkdir("parent) results in "parent", "parent/subgroup1", up through
+"parent/subgroupN".  Items of type 1 can now be created in
+"parent/subgroup1", and items of type N can be created in
+"parent/subgroupN".
+
+These automatic subgroups, or default groups, do not preclude other
+children of the parent group.  If ct_group_ops->make_group() exists,
+other child groups can be created on the parent group directly.
+
+A configfs subsystem specifies default groups by filling in the
+NULL-terminated array default_groups on the config_group structure.
+Each group in that array is populated in the configfs tree at the same
+time as the parent group.  Similarly, they are removed at the same time
+as the parent.  No extra notification is provided.  When a ->drop_item()
+method call notifies the subsystem the parent group is going away, it
+also means every default group child associated with that parent group.
+
+As a consequence of this, default_groups cannot be removed directly via
+rmdir(2).  They also are not considered when rmdir(2) on the parent
+group is checking for children.
+
+[Committable Items]
+
+NOTE: Committable items are currently unimplemented.
+
+Some config_items cannot have a valid initial state.  That is, no
+default values can be specified for the item's attributes such that the
+item can do its work.  Userspace must configure one or more attributes,
+after which the subsystem can start whatever entity this item
+represents.
+
+Consider the FakeNBD device from above.  Without a target address *and*
+a target device, the subsystem has no idea what block device to import.
+The simple example assumes that the subsystem merely waits until all the
+appropriate attributes are configured, and then connects.  This will,
+indeed, work, but now every attribute store must check if the attributes
+are initialized.  Every attribute store must fire off the connection if
+that condition is met.
+
+Far better would be an explicit action notifying the subsystem that the
+config_item is ready to go.  More importantly, an explicit action allows
+the subsystem to provide feedback as to whether the attibutes are
+initialized in a way that makes sense.  configfs provides this as
+committable items.
+
+configfs still uses only normal filesystem operations.  An item is
+committed via rename(2).  The item is moved from a directory where it
+can be modified to a directory where it cannot.
+
+Any group that provides the ct_group_ops->commit_item() method has
+committable items.  When this group appears in configfs, mkdir(2) will
+not work directly in the group.  Instead, the group will have two
+subdirectories: "live" and "pending".  The "live" directory does not
+support mkdir(2) or rmdir(2) either.  It only allows rename(2).  The
+"pending" directory does allow mkdir(2) and rmdir(2).  An item is
+created in the "pending" directory.  Its attributes can be modified at
+will.  Userspace commits the item by renaming it into the "live"
+directory.  At this point, the subsystem recieves the ->commit_item()
+callback.  If all required attributes are filled to satisfaction, the
+method returns zero and the item is moved to the "live" directory.
+
+As rmdir(2) does not work in the "live" directory, an item must be
+shutdown, or "uncommitted".  Again, this is done via rename(2), this
+time from the "live" directory back to the "pending" one.  The subsystem
+is notified by the ct_group_ops->uncommit_object() method.
+/*
+ * vim: noexpandtab ts=8 sts=0 sw=8:
+ *
+ * configfs_example.c - This file is a demonstration module containing
+ *      a number of configfs subsystems.
+ *
+ * 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;
+};
+
+struct childless_attribute {
+	struct configfs_attribute attr;
+	ssize_t (*show)(struct childless *, char *);
+	ssize_t (*store)(struct childless *, const char *, size_t);
+};
+
+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;
+}
+
+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");
+}
+
+static struct childless_attribute childless_attr_showme = {
+	.attr	= { .ca_owner = THIS_MODULE, .ca_name = "showme", .ca_mode = S_IRUGO },
+	.show	= childless_showme_read,
+};
+static struct childless_attribute childless_attr_storeme = {
+	.attr	= { .ca_owner = THIS_MODULE, .ca_name = "storeme", .ca_mode = S_IRUGO | S_IWUSR },
+	.show	= childless_storeme_read,
+	.store	= childless_storeme_write,
+};
+static struct childless_attribute childless_attr_description = {
+	.attr = { .ca_owner = THIS_MODULE, .ca_name = "description", .ca_mode = S_IRUGO },
+	.show = childless_description_read,
+};
+
+static struct configfs_attribute *childless_attrs[] = {
+	&childless_attr_showme.attr,
+	&childless_attr_storeme.attr,
+	&childless_attr_description.attr,
+	NULL,
+};
+
+static ssize_t childless_attr_show(struct config_item *item,
+				   struct configfs_attribute *attr,
+				   char *page)
+{
+	struct childless *childless = to_childless(item);
+	struct childless_attribute *childless_attr =
+		container_of(attr, struct childless_attribute, attr);
+	ssize_t ret = 0;
+
+	if (childless_attr->show)
+		ret = childless_attr->show(childless, page);
+	return ret;
+}
+
+static ssize_t childless_attr_store(struct config_item *item,
+				    struct configfs_attribute *attr,
+				    const char *page, size_t count)
+{
+	struct childless *childless = to_childless(item);
+	struct childless_attribute *childless_attr =
+		container_of(attr, struct childless_attribute, attr);
+	ssize_t ret = -EINVAL;
+
+	if (childless_attr->store)
+		ret = childless_attr->store(childless, page, count);
+	return ret;
+}
+
+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,
+};
+
+
+static struct config_item *simple_children_make_item(struct config_group *group, const char *name)
+{
+	struct simple_child *simple_child;
+
+	simple_child = kmalloc(sizeof(struct simple_child), GFP_KERNEL);
+	if (!simple_child)
+		return NULL;
+
+	memset(simple_child, 0, sizeof(struct simple_child));
+
+	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 struct configfs_item_operations simple_children_item_ops = {
+	.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,
+};
+
+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.
+ */
+
+struct simple_children {
+	struct config_group group;
+};
+
+static struct config_group *group_children_make_group(struct config_group *group, const char *name)
+{
+	struct simple_children *simple_children;
+
+	simple_children = kmalloc(sizeof(struct simple_children),
+				  GFP_KERNEL);
+	if (!simple_children)
+		return NULL;
+
+	memset(simple_children, 0, sizeof(struct simple_children));
+
+	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,
+};
+
+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);
+		init_MUTEX(&subsys->su_sem);
+		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");
@@ -554,6 +554,11 @@
 T:	git kernel.org:/pub/scm/linux/kernel/git/sfrench/cifs-2.6.git
 S:	Supported	
  
+CONFIGFS
+P:	Joel Becker
+M:	Joel Becker <joel.becker@oracle.com>
+S:	Supported
+
 CIRRUS LOGIC GENERIC FBDEV DRIVER
 P:	Jeff Garzik
 M:	jgarzik@pobox.com
@@ -841,6 +841,20 @@
  
 	  If unsure, say N.
  
+config CONFIGFS_FS
+	tristate "Userspace-driven configuration filesystem (EXPERIMENTAL)"
+	depends on EXPERIMENTAL
+	help
+	  configfs is a ram-based filesystem that provides the converse
+	  of sysfs's functionality. Where sysfs is a filesystem-based
+	  view of kernel objects, configfs is a filesystem-based manager
+	  of kernel objects, or config_items.
+
+	  Both sysfs and configfs can and should exist together on the
+	  same system. One is not a replacement for the other.
+
+	  If unsure, say N.
+
 endmenu
  
 menu "Miscellaneous filesystems"
@@ -101,4 +101,5 @@
 obj-$(CONFIG_HOSTFS)		+= hostfs/
 obj-$(CONFIG_HPPFS)		+= hppfs/
 obj-$(CONFIG_DEBUG_FS)		+= debugfs/
+obj-$(CONFIG_CONFIGFS_FS)	+= configfs/
+#
+# Makefile for the configfs virtual filesystem
+#
+
+obj-$(CONFIG_CONFIGFS_FS)	+= configfs.o
+
+configfs-objs	:= inode.o file.o dir.o symlink.o mount.o item.o
+/* -*- mode: c; c-basic-offset:8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * configfs_internal.h - Internal stuff for configfs
+ *
+ * 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/slab.h>
+#include <linux/list.h>
+
+struct configfs_dirent {
+	atomic_t		s_count;
+	struct list_head	s_sibling;
+	struct list_head	s_children;
+	struct list_head	s_links;
+	void 			* s_element;
+	int			s_type;
+	umode_t			s_mode;
+	struct dentry		* s_dentry;
+};
+
+#define CONFIGFS_ROOT		0x0001
+#define CONFIGFS_DIR		0x0002
+#define CONFIGFS_ITEM_ATTR 	0x0004
+#define CONFIGFS_ITEM_LINK 	0x0020
+#define CONFIGFS_USET_DIR	0x0040
+#define CONFIGFS_USET_DEFAULT	0x0080
+#define CONFIGFS_USET_DROPPING	0x0100
+#define CONFIGFS_NOT_PINNED	(CONFIGFS_ITEM_ATTR)
+
+extern struct vfsmount * configfs_mount;
+
+extern int configfs_is_root(struct config_item *item);
+
+extern struct inode * configfs_new_inode(mode_t mode);
+extern int configfs_create(struct dentry *, int mode, int (*init)(struct inode *));
+
+extern int configfs_create_file(struct config_item *, const struct configfs_attribute *);
+extern int configfs_make_dirent(struct configfs_dirent *,
+				struct dentry *, void *, umode_t, int);
+
+extern int configfs_add_file(struct dentry *, const struct configfs_attribute *, int);
+extern void configfs_hash_and_remove(struct dentry * dir, const char * name);
+
+extern const unsigned char * configfs_get_name(struct configfs_dirent *sd);
+extern void configfs_drop_dentry(struct configfs_dirent *sd, struct dentry *parent);
+
+extern int configfs_pin_fs(void);
+extern void configfs_release_fs(void);
+
+extern struct rw_semaphore configfs_rename_sem;
+extern struct super_block * configfs_sb;
+extern struct file_operations configfs_dir_operations;
+extern struct file_operations configfs_file_operations;
+extern struct file_operations bin_fops;
+extern struct inode_operations configfs_dir_inode_operations;
+extern struct inode_operations configfs_symlink_inode_operations;
+
+extern int configfs_symlink(struct inode *dir, struct dentry *dentry,
+			    const char *symname);
+extern int configfs_unlink(struct inode *dir, struct dentry *dentry);
+
+struct configfs_symlink {
+	struct list_head sl_list;
+	struct config_item *sl_target;
+};
+
+extern int configfs_create_link(struct configfs_symlink *sl,
+				struct dentry *parent,
+				struct dentry *dentry);
+
+static inline struct config_item * to_item(struct dentry * dentry)
+{
+	struct configfs_dirent * sd = dentry->d_fsdata;
+	return ((struct config_item *) sd->s_element);
+}
+
+static inline struct configfs_attribute * to_attr(struct dentry * dentry)
+{
+	struct configfs_dirent * sd = dentry->d_fsdata;
+	return ((struct configfs_attribute *) sd->s_element);
+}
+
+static inline struct config_item *configfs_get_config_item(struct dentry *dentry)
+{
+	struct config_item * item = NULL;
+
+	spin_lock(&dcache_lock);
+	if (!d_unhashed(dentry)) {
+		struct configfs_dirent * sd = dentry->d_fsdata;
+		if (sd->s_type & CONFIGFS_ITEM_LINK) {
+			struct configfs_symlink * sl = sd->s_element;
+			item = config_item_get(sl->sl_target);
+		} else
+			item = config_item_get(sd->s_element);
+	}
+	spin_unlock(&dcache_lock);
+
+	return item;
+}
+
+static inline void release_configfs_dirent(struct configfs_dirent * sd)
+{
+	if (!(sd->s_type & CONFIGFS_ROOT))
+		kfree(sd);
+}
+
+static inline struct configfs_dirent * configfs_get(struct configfs_dirent * sd)
+{
+	if (sd) {
+		WARN_ON(!atomic_read(&sd->s_count));
+		atomic_inc(&sd->s_count);
+	}
+	return sd;
+}
+
+static inline void configfs_put(struct configfs_dirent * sd)
+{
+	WARN_ON(!atomic_read(&sd->s_count));
+	if (atomic_dec_and_test(&sd->s_count))
+		release_configfs_dirent(sd);
+}
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * dir.c - Operations for configfs directories.
+ *
+ * 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.
+ */
+
+#undef DEBUG
+
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include <linux/configfs.h>
+#include "configfs_internal.h"
+
+DECLARE_RWSEM(configfs_rename_sem);
+
+static void configfs_d_iput(struct dentry * dentry,
+			    struct inode * inode)
+{
+	struct configfs_dirent * sd = dentry->d_fsdata;
+
+	if (sd) {
+		BUG_ON(sd->s_dentry != dentry);
+		sd->s_dentry = NULL;
+		configfs_put(sd);
+	}
+	iput(inode);
+}
+
+/*
+ * We _must_ delete our dentries on last dput, as the chain-to-parent
+ * behavior is required to clear the parents of default_groups.
+ */
+static int configfs_d_delete(struct dentry *dentry)
+{
+	return 1;
+}
+
+static struct dentry_operations configfs_dentry_ops = {
+	.d_iput		= configfs_d_iput,
+	/* simple_delete_dentry() isn't exported */
+	.d_delete	= configfs_d_delete,
+};
+
+/*
+ * Allocates a new configfs_dirent and links it to the parent configfs_dirent
+ */
+static struct configfs_dirent *configfs_new_dirent(struct configfs_dirent * parent_sd,
+						void * element)
+{
+	struct configfs_dirent * sd;
+
+	sd = kmalloc(sizeof(*sd), GFP_KERNEL);
+	if (!sd)
+		return NULL;
+
+	memset(sd, 0, sizeof(*sd));
+	atomic_set(&sd->s_count, 1);
+	INIT_LIST_HEAD(&sd->s_links);
+	INIT_LIST_HEAD(&sd->s_children);
+	list_add(&sd->s_sibling, &parent_sd->s_children);
+	sd->s_element = element;
+
+	return sd;
+}
+
+int configfs_make_dirent(struct configfs_dirent * parent_sd,
+			 struct dentry * dentry, void * element,
+			 umode_t mode, int type)
+{
+	struct configfs_dirent * sd;
+
+	sd = configfs_new_dirent(parent_sd, element);
+	if (!sd)
+		return -ENOMEM;
+
+	sd->s_mode = mode;
+	sd->s_type = type;
+	sd->s_dentry = dentry;
+	if (dentry) {
+		dentry->d_fsdata = configfs_get(sd);
+		dentry->d_op = &configfs_dentry_ops;
+	}
+
+	return 0;
+}
+
+static int init_dir(struct inode * inode)
+{
+	inode->i_op = &configfs_dir_inode_operations;
+	inode->i_fop = &configfs_dir_operations;
+
+	/* directory inodes start off with i_nlink == 2 (for "." entry) */
+	inode->i_nlink++;
+	return 0;
+}
+
+static int init_file(struct inode * inode)
+{
+	inode->i_size = PAGE_SIZE;
+	inode->i_fop = &configfs_file_operations;
+	return 0;
+}
+
+static int init_symlink(struct inode * inode)
+{
+	inode->i_op = &configfs_symlink_inode_operations;
+	return 0;
+}
+
+static int create_dir(struct config_item * k, struct dentry * p,
+		      struct dentry * d)
+{
+	int error;
+	umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
+
+	error = configfs_create(d, mode, init_dir);
+	if (!error) {
+		error = configfs_make_dirent(p->d_fsdata, d, k, mode,
+					   CONFIGFS_DIR);
+		if (!error) {
+			p->d_inode->i_nlink++;
+			(d)->d_op = &configfs_dentry_ops;
+		}
+	}
+	return error;
+}
+
+
+/**
+ *	configfs_create_dir - create a directory for an config_item.
+ *	@item:		config_itemwe're creating directory for.
+ *	@dentry:	config_item's dentry.
+ */
+
+static int configfs_create_dir(struct config_item * item, struct dentry *dentry)
+{
+	struct dentry * parent;
+	int error = 0;
+
+	BUG_ON(!item);
+
+	if (item->ci_parent)
+		parent = item->ci_parent->ci_dentry;
+	else if (configfs_mount && configfs_mount->mnt_sb)
+		parent = configfs_mount->mnt_sb->s_root;
+	else
+		return -EFAULT;
+
+	error = create_dir(item,parent,dentry);
+	if (!error)
+		item->ci_dentry = dentry;
+	return error;
+}
+
+int configfs_create_link(struct configfs_symlink *sl,
+			 struct dentry *parent,
+			 struct dentry *dentry)
+{
+	int err = 0;
+	umode_t mode = S_IFLNK | S_IRWXUGO;
+
+	err = configfs_create(dentry, mode, init_symlink);
+	if (!err) {
+		err = configfs_make_dirent(parent->d_fsdata, dentry, sl,
+					 mode, CONFIGFS_ITEM_LINK);
+		if (!err)
+			dentry->d_op = &configfs_dentry_ops;
+	}
+	return err;
+}
+
+static void remove_dir(struct dentry * d)
+{
+	struct dentry * parent = dget(d->d_parent);
+	struct configfs_dirent * sd;
+
+	sd = d->d_fsdata;
+ 	list_del_init(&sd->s_sibling);
+	configfs_put(sd);
+	if (d->d_inode)
+		simple_rmdir(parent->d_inode,d);
+
+	pr_debug(" o %s removing done (%d)\n",d->d_name.name,
+		 atomic_read(&d->d_count));
+
+	dput(parent);
+}
+
+/**
+ * configfs_remove_dir - remove an config_item's directory.
+ * @item:	config_item we're removing.
+ *
+ * The only thing special about this is that we remove any files in
+ * the directory before we remove the directory, and we've inlined
+ * what used to be configfs_rmdir() below, instead of calling separately.
+ */
+
+static void configfs_remove_dir(struct config_item * item)
+{
+	struct dentry * dentry = dget(item->ci_dentry);
+
+	if (!dentry)
+		return;
+
+	remove_dir(dentry);
+	/**
+	 * Drop reference from dget() on entrance.
+	 */
+	dput(dentry);
+}
+
+
+/* attaches attribute's configfs_dirent to the dentry corresponding to the
+ * attribute file
+ */
+static int configfs_attach_attr(struct configfs_dirent * sd, struct dentry * dentry)
+{
+	struct configfs_attribute * attr = sd->s_element;
+	int error;
+
+	error = configfs_create(dentry, (attr->ca_mode & S_IALLUGO) | S_IFREG, init_file);
+	if (error)
+		return error;
+
+	dentry->d_op = &configfs_dentry_ops;
+	dentry->d_fsdata = configfs_get(sd);
+	sd->s_dentry = dentry;
+	d_rehash(dentry);
+
+	return 0;
+}
+
+static struct dentry * configfs_lookup(struct inode *dir,
+				       struct dentry *dentry,
+				       struct nameidata *nd)
+{
+	struct configfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
+	struct configfs_dirent * sd;
+	int found = 0;
+	int err = 0;
+
+	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
+		if (sd->s_type & CONFIGFS_NOT_PINNED) {
+			const unsigned char * name = configfs_get_name(sd);
+
+			if (strcmp(name, dentry->d_name.name))
+				continue;
+
+			found = 1;
+			err = configfs_attach_attr(sd, dentry);
+			break;
+		}
+	}
+
+	if (!found) {
+		/*
+		 * If it doesn't exist and it isn't a NOT_PINNED item,
+		 * it must be negative.
+		 */
+		return simple_lookup(dir, dentry, nd);
+	}
+
+	return ERR_PTR(err);
+}
+
+/*
+ * Only subdirectories count here.  Files (CONFIGFS_NOT_PINNED) are
+ * attributes and are removed by rmdir().  We recurse, taking i_sem
+ * on all children that are candidates for default detach.  If the
+ * result is clean, then configfs_detach_group() will handle dropping
+ * i_sem.  If there is an error, the caller will clean up the i_sem
+ * holders via configfs_detach_rollback().
+ */
+static int configfs_detach_prep(struct dentry *dentry)
+{
+	struct configfs_dirent *parent_sd = dentry->d_fsdata;
+	struct configfs_dirent *sd;
+	int ret;
+
+	ret = -EBUSY;
+	if (!list_empty(&parent_sd->s_links))
+		goto out;
+
+	ret = 0;
+	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
+		if (sd->s_type & CONFIGFS_NOT_PINNED)
+			continue;
+		if (sd->s_type & CONFIGFS_USET_DEFAULT) {
+			down(&sd->s_dentry->d_inode->i_sem);
+			/* Mark that we've taken i_sem */
+			sd->s_type |= CONFIGFS_USET_DROPPING;
+
+			ret = configfs_detach_prep(sd->s_dentry);
+			if (!ret)
+			       	continue;
+		} else
+			ret = -ENOTEMPTY;
+
+		break;
+	}
+
+out:
+	return ret;
+}
+
+/*
+ * Walk the tree, dropping i_sem wherever CONFIGFS_USET_DROPPING is
+ * set.
+ */
+static void configfs_detach_rollback(struct dentry *dentry)
+{
+	struct configfs_dirent *parent_sd = dentry->d_fsdata;
+	struct configfs_dirent *sd;
+
+	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
+		if (sd->s_type & CONFIGFS_USET_DEFAULT) {
+			configfs_detach_rollback(sd->s_dentry);
+
+			if (sd->s_type & CONFIGFS_USET_DROPPING) {
+				sd->s_type &= ~CONFIGFS_USET_DROPPING;
+				up(&sd->s_dentry->d_inode->i_sem);
+			}
+		}
+	}
+}
+
+static void detach_attrs(struct config_item * item)
+{
+	struct dentry * dentry = dget(item->ci_dentry);
+	struct configfs_dirent * parent_sd;
+	struct configfs_dirent * sd, * tmp;
+
+	if (!dentry)
+		return;
+
+	pr_debug("configfs %s: dropping attrs for  dir\n",
+		 dentry->d_name.name);
+
+	parent_sd = dentry->d_fsdata;
+	list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
+		if (!sd->s_element || !(sd->s_type & CONFIGFS_NOT_PINNED))
+			continue;
+		list_del_init(&sd->s_sibling);
+		configfs_drop_dentry(sd, dentry);
+		configfs_put(sd);
+	}
+
+	/**
+	 * Drop reference from dget() on entrance.
+	 */
+	dput(dentry);
+}
+
+static int populate_attrs(struct config_item *item)
+{
+	struct config_item_type *t = item->ci_type;
+	struct configfs_attribute *attr;
+	int error = 0;
+	int i;
+
+	if (!t)
+		return -EINVAL;
+	if (t->ct_attrs) {
+		for (i = 0; (attr = t->ct_attrs[i]) != NULL; i++) {
+			if ((error = configfs_create_file(item, attr)))
+				break;
+		}
+	}
+
+	if (error)
+		detach_attrs(item);
+
+	return error;
+}
+
+static int configfs_attach_group(struct config_item *parent_item,
+				 struct config_item *item,
+				 struct dentry *dentry);
+static void configfs_detach_group(struct config_item *item);
+
+static void detach_groups(struct config_group *group)
+{
+	struct dentry * dentry = dget(group->cg_item.ci_dentry);
+	struct dentry *child;
+	struct configfs_dirent *parent_sd;
+	struct configfs_dirent *sd, *tmp;
+
+	if (!dentry)
+		return;
+
+	parent_sd = dentry->d_fsdata;
+	list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
+		if (!sd->s_element ||
+		    !(sd->s_type & CONFIGFS_USET_DEFAULT))
+			continue;
+
+		child = sd->s_dentry;
+
+		configfs_detach_group(sd->s_element);
+		child->d_inode->i_flags |= S_DEAD;
+
+		/*
+		 * From rmdir/unregister, a configfs_detach_prep() pass
+		 * has taken our i_sem for us.  Drop it.
+		 * From mkdir/register cleanup, there is no sem held.
+		 */
+		if (sd->s_type & CONFIGFS_USET_DROPPING)
+			up(&child->d_inode->i_sem);
+
+		d_delete(child);
+		dput(child);
+	}
+
+	/**
+	 * Drop reference from dget() on entrance.
+	 */
+	dput(dentry);
+}
+
+/*
+ * This fakes mkdir(2) on a default_groups[] entry.  It
+ * creates a dentry, attachs it, and then does fixup
+ * on the sd->s_type.
+ *
+ * We could, perhaps, tweak our parent's ->mkdir for a minute and
+ * try using vfs_mkdir.  Just a thought.
+ */
+static int create_default_group(struct config_group *parent_group,
+				struct config_group *group)
+{
+	int ret;
+	struct qstr name;
+	struct configfs_dirent *sd;
+	/* We trust the caller holds a reference to parent */
+	struct dentry *child, *parent = parent_group->cg_item.ci_dentry;
+
+	if (!group->cg_item.ci_name)
+		group->cg_item.ci_name = group->cg_item.ci_namebuf;
+	name.name = group->cg_item.ci_name;
+	name.len = strlen(name.name);
+	name.hash = full_name_hash(name.name, name.len);
+
+	ret = -ENOMEM;
+	child = d_alloc(parent, &name);
+	if (child) {
+		d_add(child, NULL);
+
+		ret = configfs_attach_group(&parent_group->cg_item,
+					    &group->cg_item, child);
+		if (!ret) {
+			sd = child->d_fsdata;
+			sd->s_type |= CONFIGFS_USET_DEFAULT;
+		} else {
+			d_delete(child);
+			dput(child);
+		}
+	}
+
+	return ret;
+}
+
+static int populate_groups(struct config_group *group)
+{
+	struct config_group *new_group;
+	struct dentry *dentry = group->cg_item.ci_dentry;
+	int ret = 0;
+	int i;
+
+	if (group && group->default_groups) {
+		/* FYI, we're faking mkdir here
+		 * I'm not sure we need this semaphore, as we're called
+		 * from our parent's mkdir.  That holds our parent's
+		 * i_sem, so afaik lookup cannot continue through our
+		 * parent to find us, let alone mess with our tree.
+		 * That said, taking our i_sem is closer to mkdir
+		 * emulation, and shouldn't hurt. */
+		down(&dentry->d_inode->i_sem);
+
+		for (i = 0; group->default_groups[i]; i++) {
+			new_group = group->default_groups[i];
+
+			ret = create_default_group(group, new_group);
+			if (ret)
+				break;
+		}
+
+		up(&dentry->d_inode->i_sem);
+	}
+
+	if (ret)
+		detach_groups(group);
+
+	return ret;
+}
+
+/*
+ * All of link_obj/unlink_obj/link_group/unlink_group require that
+ * subsys->su_sem is held.
+ */
+
+static void unlink_obj(struct config_item *item)
+{
+	struct config_group *group;
+
+	group = item->ci_group;
+	if (group) {
+		list_del_init(&item->ci_entry);
+
+		item->ci_group = NULL;
+		item->ci_parent = NULL;
+		config_item_put(item);
+
+		config_group_put(group);
+	}
+}
+
+static void link_obj(struct config_item *parent_item, struct config_item *item)
+{
+	/* Parent seems redundant with group, but it makes certain
+	 * traversals much nicer. */
+	item->ci_parent = parent_item;
+	item->ci_group = config_group_get(to_config_group(parent_item));
+	list_add_tail(&item->ci_entry, &item->ci_group->cg_children);
+
+	config_item_get(item);
+}
+
+static void unlink_group(struct config_group *group)
+{
+	int i;
+	struct config_group *new_group;
+
+	if (group->default_groups) {
+		for (i = 0; group->default_groups[i]; i++) {
+			new_group = group->default_groups[i];
+			unlink_group(new_group);
+		}
+	}
+
+	group->cg_subsys = NULL;
+	unlink_obj(&group->cg_item);
+}
+
+static void link_group(struct config_group *parent_group, struct config_group *group)
+{
+	int i;
+	struct config_group *new_group;
+	struct configfs_subsystem *subsys = NULL; /* gcc is a turd */
+
+	link_obj(&parent_group->cg_item, &group->cg_item);
+
+	if (parent_group->cg_subsys)
+		subsys = parent_group->cg_subsys;
+	else if (configfs_is_root(&parent_group->cg_item))
+		subsys = to_configfs_subsystem(group);
+	else
+		BUG();
+	group->cg_subsys = subsys;
+
+	if (group->default_groups) {
+		for (i = 0; group->default_groups[i]; i++) {
+			new_group = group->default_groups[i];
+			link_group(group, new_group);
+		}
+	}
+}
+
+/*
+ * The goal is that configfs_attach_item() (and
+ * configfs_attach_group()) can be called from either the VFS or this
+ * module.  That is, they assume that the items have been created,
+ * the dentry allocated, and the dcache is all ready to go.
+ *
+ * If they fail, they must clean up after themselves as if they
+ * had never been called.  The caller (VFS or local function) will
+ * handle cleaning up the dcache bits.
+ *
+ * configfs_detach_group() and configfs_detach_item() behave similarly on
+ * the way out.  They assume that the proper semaphores are held, they
+ * clean up the configfs items, and they expect their callers will
+ * handle the dcache bits.
+ */
+static int configfs_attach_item(struct config_item *parent_item,
+				struct config_item *item,
+				struct dentry *dentry)
+{
+	int ret;
+
+	ret = configfs_create_dir(item, dentry);
+	if (!ret) {
+		ret = populate_attrs(item);
+		if (ret) {
+			configfs_remove_dir(item);
+			d_delete(dentry);
+		}
+	}
+
+	return ret;
+}
+
+static void configfs_detach_item(struct config_item *item)
+{
+	detach_attrs(item);
+	configfs_remove_dir(item);
+}
+
+static int configfs_attach_group(struct config_item *parent_item,
+				 struct config_item *item,
+				 struct dentry *dentry)
+{
+	int ret;
+	struct configfs_dirent *sd;
+
+	ret = configfs_attach_item(parent_item, item, dentry);
+	if (!ret) {
+		sd = dentry->d_fsdata;
+		sd->s_type |= CONFIGFS_USET_DIR;
+
+		ret = populate_groups(to_config_group(item));
+		if (ret) {
+			configfs_detach_item(item);
+			d_delete(dentry);
+		}
+	}
+
+	return ret;
+}
+
+static void configfs_detach_group(struct config_item *item)
+{
+	detach_groups(to_config_group(item));
+	configfs_detach_item(item);
+}
+
+/*
+ * Drop the initial reference from make_item()/make_group()
+ * This function assumes that reference is held on item
+ * and that item holds a valid reference to the parent.  Also, it
+ * assumes the caller has validated ci_type.
+ */
+static void client_drop_item(struct config_item *parent_item,
+			     struct config_item *item)
+{
+	struct config_item_type *type;
+
+	type = parent_item->ci_type;
+	BUG_ON(!type);
+
+	if (type->ct_group_ops && type->ct_group_ops->drop_item)
+		type->ct_group_ops->drop_item(to_config_group(parent_item),
+						item);
+	else
+		config_item_put(item);
+}
+
+
+static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+{
+	int ret;
+	struct config_group *group;
+	struct config_item *item;
+	struct config_item *parent_item;
+	struct configfs_subsystem *subsys;
+	struct configfs_dirent *sd;
+	struct config_item_type *type;
+	struct module *owner;
+	char *name;
+
+	if (dentry->d_parent == configfs_sb->s_root)
+		return -EPERM;
+
+	sd = dentry->d_parent->d_fsdata;
+	if (!(sd->s_type & CONFIGFS_USET_DIR))
+		return -EPERM;
+
+	parent_item = configfs_get_config_item(dentry->d_parent);
+	type = parent_item->ci_type;
+	subsys = to_config_group(parent_item)->cg_subsys;
+	BUG_ON(!subsys);
+
+	if (!type || !type->ct_group_ops ||
+	    (!type->ct_group_ops->make_group &&
+	     !type->ct_group_ops->make_item)) {
+		config_item_put(parent_item);
+		return -EPERM;  /* What lack-of-mkdir returns */
+	}
+
+	name = kmalloc(dentry->d_name.len + 1, GFP_KERNEL);
+	if (!name) {
+		config_item_put(parent_item);
+		return -ENOMEM;
+	}
+	snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name);
+
+	down(&subsys->su_sem);
+	group = NULL;
+	item = NULL;
+	if (type->ct_group_ops->make_group) {
+		group = type->ct_group_ops->make_group(to_config_group(parent_item), name);
+		if (group) {
+			link_group(to_config_group(parent_item), group);
+			item = &group->cg_item;
+		}
+	} else {
+		item = type->ct_group_ops->make_item(to_config_group(parent_item), name);
+		if (item)
+			link_obj(parent_item, item);
+	}
+	up(&subsys->su_sem);
+
+	kfree(name);
+	if (!item) {
+		config_item_put(parent_item);
+		return -ENOMEM;
+	}
+
+	ret = -EINVAL;
+	type = item->ci_type;
+	if (type) {
+		owner = type->ct_owner;
+		if (try_module_get(owner)) {
+			if (group) {
+				ret = configfs_attach_group(parent_item,
+							    item,
+							    dentry);
+			} else {
+				ret = configfs_attach_item(parent_item,
+							   item,
+							   dentry);
+			}
+
+			if (ret) {
+				down(&subsys->su_sem);
+				if (group)
+					unlink_group(group);
+				else
+					unlink_obj(item);
+				client_drop_item(parent_item, item);
+				up(&subsys->su_sem);
+
+				config_item_put(parent_item);
+				module_put(owner);
+			}
+		}
+	}
+
+	return ret;
+}
+
+static int configfs_rmdir(struct inode *dir, struct dentry *dentry)
+{
+	struct config_item *parent_item;
+	struct config_item *item;
+	struct configfs_subsystem *subsys;
+	struct configfs_dirent *sd;
+	struct module *owner = NULL;
+	int ret;
+
+	if (dentry->d_parent == configfs_sb->s_root)
+		return -EPERM;
+
+	sd = dentry->d_fsdata;
+	if (sd->s_type & CONFIGFS_USET_DEFAULT)
+		return -EPERM;
+
+	parent_item = configfs_get_config_item(dentry->d_parent);
+	subsys = to_config_group(parent_item)->cg_subsys;
+	BUG_ON(!subsys);
+
+	if (!parent_item->ci_type) {
+		config_item_put(parent_item);
+		return -EINVAL;
+	}
+
+	ret = configfs_detach_prep(dentry);
+	if (ret) {
+		configfs_detach_rollback(dentry);
+		config_item_put(parent_item);
+		return ret;
+	}
+
+	item = configfs_get_config_item(dentry);
+
+	/* Drop reference from above, item already holds one. */
+	config_item_put(parent_item);
+
+	if (item->ci_type)
+		owner = item->ci_type->ct_owner;
+
+	if (sd->s_type & CONFIGFS_USET_DIR) {
+		configfs_detach_group(item);
+
+		down(&subsys->su_sem);
+		unlink_group(to_config_group(item));
+	} else {
+		configfs_detach_item(item);
+
+		down(&subsys->su_sem);
+		unlink_obj(item);
+	}
+
+	client_drop_item(parent_item, item);
+	up(&subsys->su_sem);
+
+	/* Drop our reference from above */
+	config_item_put(item);
+
+	module_put(owner);
+
+	return 0;
+}
+
+struct inode_operations configfs_dir_inode_operations = {
+	.mkdir		= configfs_mkdir,
+	.rmdir		= configfs_rmdir,
+	.symlink	= configfs_symlink,
+	.unlink		= configfs_unlink,
+	.lookup		= configfs_lookup,
+};
+
+#if 0
+int configfs_rename_dir(struct config_item * item, const char *new_name)
+{
+	int error = 0;
+	struct dentry * new_dentry, * parent;
+
+	if (!strcmp(config_item_name(item), new_name))
+		return -EINVAL;
+
+	if (!item->parent)
+		return -EINVAL;
+
+	down_write(&configfs_rename_sem);
+	parent = item->parent->dentry;
+
+	down(&parent->d_inode->i_sem);
+
+	new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
+	if (!IS_ERR(new_dentry)) {
+  		if (!new_dentry->d_inode) {
+			error = config_item_set_name(item, "%s", new_name);
+			if (!error) {
+				d_add(new_dentry, NULL);
+				d_move(item->dentry, new_dentry);
+			}
+			else
+				d_delete(new_dentry);
+		} else
+			error = -EEXIST;
+		dput(new_dentry);
+	}
+	up(&parent->d_inode->i_sem);
+	up_write(&configfs_rename_sem);
+
+	return error;
+}
+#endif
+
+static int configfs_dir_open(struct inode *inode, struct file *file)
+{
+	struct dentry * dentry = file->f_dentry;
+	struct configfs_dirent * parent_sd = dentry->d_fsdata;
+
+	down(&dentry->d_inode->i_sem);
+	file->private_data = configfs_new_dirent(parent_sd, NULL);
+	up(&dentry->d_inode->i_sem);
+
+	return file->private_data ? 0 : -ENOMEM;
+
+}
+
+static int configfs_dir_close(struct inode *inode, struct file *file)
+{
+	struct dentry * dentry = file->f_dentry;
+	struct configfs_dirent * cursor = file->private_data;
+
+	down(&dentry->d_inode->i_sem);
+	list_del_init(&cursor->s_sibling);
+	up(&dentry->d_inode->i_sem);
+
+	release_configfs_dirent(cursor);
+
+	return 0;
+}
+
+/* Relationship between s_mode and the DT_xxx types */
+static inline unsigned char dt_type(struct configfs_dirent *sd)
+{
+	return (sd->s_mode >> 12) & 15;
+}
+
+static int configfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
+{
+	struct dentry *dentry = filp->f_dentry;
+	struct configfs_dirent * parent_sd = dentry->d_fsdata;
+	struct configfs_dirent *cursor = filp->private_data;
+	struct list_head *p, *q = &cursor->s_sibling;
+	ino_t ino;
+	int i = filp->f_pos;
+
+	switch (i) {
+		case 0:
+			ino = dentry->d_inode->i_ino;
+			if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
+				break;
+			filp->f_pos++;
+			i++;
+			/* fallthrough */
+		case 1:
+			ino = parent_ino(dentry);
+			if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
+				break;
+			filp->f_pos++;
+			i++;
+			/* fallthrough */
+		default:
+			if (filp->f_pos == 2) {
+				list_del(q);
+				list_add(q, &parent_sd->s_children);
+			}
+			for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
+				struct configfs_dirent *next;
+				const char * name;
+				int len;
+
+				next = list_entry(p, struct configfs_dirent,
+						   s_sibling);
+				if (!next->s_element)
+					continue;
+
+				name = configfs_get_name(next);
+				len = strlen(name);
+				if (next->s_dentry)
+					ino = next->s_dentry->d_inode->i_ino;
+				else
+					ino = iunique(configfs_sb, 2);
+
+				if (filldir(dirent, name, len, filp->f_pos, ino,
+						 dt_type(next)) < 0)
+					return 0;
+
+				list_del(q);
+				list_add(q, p);
+				p = q;
+				filp->f_pos++;
+			}
+	}
+	return 0;
+}
+
+static loff_t configfs_dir_lseek(struct file * file, loff_t offset, int origin)
+{
+	struct dentry * dentry = file->f_dentry;
+
+	down(&dentry->d_inode->i_sem);
+	switch (origin) {
+		case 1:
+			offset += file->f_pos;
+		case 0:
+			if (offset >= 0)
+				break;
+		default:
+			up(&file->f_dentry->d_inode->i_sem);
+			return -EINVAL;
+	}
+	if (offset != file->f_pos) {
+		file->f_pos = offset;
+		if (file->f_pos >= 2) {
+			struct configfs_dirent *sd = dentry->d_fsdata;
+			struct configfs_dirent *cursor = file->private_data;
+			struct list_head *p;
+			loff_t n = file->f_pos - 2;
+
+			list_del(&cursor->s_sibling);
+			p = sd->s_children.next;
+			while (n && p != &sd->s_children) {
+				struct configfs_dirent *next;
+				next = list_entry(p, struct configfs_dirent,
+						   s_sibling);
+				if (next->s_element)
+					n--;
+				p = p->next;
+			}
+			list_add_tail(&cursor->s_sibling, p);
+		}
+	}
+	up(&dentry->d_inode->i_sem);
+	return offset;
+}
+
+struct file_operations configfs_dir_operations = {
+	.open		= configfs_dir_open,
+	.release	= configfs_dir_close,
+	.llseek		= configfs_dir_lseek,
+	.read		= generic_read_dir,
+	.readdir	= configfs_readdir,
+};
+
+int configfs_register_subsystem(struct configfs_subsystem *subsys)
+{
+	int err;
+	struct config_group *group = &subsys->su_group;
+	struct qstr name;
+	struct dentry *dentry;
+	struct configfs_dirent *sd;
+
+	err = configfs_pin_fs();
+	if (err)
+		return err;
+
+	if (!group->cg_item.ci_name)
+		group->cg_item.ci_name = group->cg_item.ci_namebuf;
+
+	sd = configfs_sb->s_root->d_fsdata;
+	link_group(to_config_group(sd->s_element), group);
+
+	down(&configfs_sb->s_root->d_inode->i_sem);
+
+	name.name = group->cg_item.ci_name;
+	name.len = strlen(name.name);
+	name.hash = full_name_hash(name.name, name.len);
+
+	err = -ENOMEM;
+	dentry = d_alloc(configfs_sb->s_root, &name);
+	if (!dentry)
+		goto out_release;
+
+	d_add(dentry, NULL);
+
+	err = configfs_attach_group(sd->s_element, &group->cg_item,
+				    dentry);
+	if (!err)
+		dentry = NULL;
+	else
+		d_delete(dentry);
+
+	up(&configfs_sb->s_root->d_inode->i_sem);
+
+	if (dentry) {
+	    dput(dentry);
+out_release:
+	    unlink_group(group);
+	    configfs_release_fs();
+	}
+
+	return err;
+}
+
+void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
+{
+	struct config_group *group = &subsys->su_group;
+	struct dentry *dentry = group->cg_item.ci_dentry;
+
+	if (dentry->d_parent != configfs_sb->s_root) {
+		printk(KERN_ERR "configfs: Tried to unregister non-subsystem!\n");
+		return;
+	}
+
+	down(&configfs_sb->s_root->d_inode->i_sem);
+	down(&dentry->d_inode->i_sem);
+	if (configfs_detach_prep(dentry)) {
+		printk(KERN_ERR "configfs: Tried to unregister non-empty subsystem!\n");
+	}
+	configfs_detach_group(&group->cg_item);
+	dentry->d_inode->i_flags |= S_DEAD;
+	up(&dentry->d_inode->i_sem);
+
+	d_delete(dentry);
+
+	up(&configfs_sb->s_root->d_inode->i_sem);
+
+	dput(dentry);
+
+	unlink_group(group);
+	configfs_release_fs();
+}
+
+EXPORT_SYMBOL(configfs_register_subsystem);
+EXPORT_SYMBOL(configfs_unregister_subsystem);
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * file.c - operations for regular (text) files.
+ *
+ * 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/fs.h>
+#include <linux/module.h>
+#include <linux/dnotify.h>
+#include <linux/slab.h>
+#include <asm/uaccess.h>
+#include <asm/semaphore.h>
+
+#include <linux/configfs.h>
+#include "configfs_internal.h"
+
+
+struct configfs_buffer {
+	size_t			count;
+	loff_t			pos;
+	char			* page;
+	struct configfs_item_operations	* ops;
+	struct semaphore	sem;
+	int			needs_read_fill;
+};
+
+
+/**
+ *	fill_read_buffer - allocate and fill buffer from item.
+ *	@dentry:	dentry pointer.
+ *	@buffer:	data buffer for file.
+ *
+ *	Allocate @buffer->page, if it hasn't been already, then call the
+ *	config_item's show() method to fill the buffer with this attribute's
+ *	data.
+ *	This is called only once, on the file's first read.
+ */
+static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buffer)
+{
+	struct configfs_attribute * attr = to_attr(dentry);
+	struct config_item * item = to_item(dentry->d_parent);
+	struct configfs_item_operations * ops = buffer->ops;
+	int ret = 0;
+	ssize_t count;
+
+	if (!buffer->page)
+		buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
+	if (!buffer->page)
+		return -ENOMEM;
+
+	count = ops->show_attribute(item,attr,buffer->page);
+	buffer->needs_read_fill = 0;
+	BUG_ON(count > (ssize_t)PAGE_SIZE);
+	if (count >= 0)
+		buffer->count = count;
+	else
+		ret = count;
+	return ret;
+}
+
+
+/**
+ *	flush_read_buffer - push buffer to userspace.
+ *	@buffer:	data buffer for file.
+ *	@userbuf:	user-passed buffer.
+ *	@count:		number of bytes requested.
+ *	@ppos:		file position.
+ *
+ *	Copy the buffer we filled in fill_read_buffer() to userspace.
+ *	This is done at the reader's leisure, copying and advancing
+ *	the amount they specify each time.
+ *	This may be called continuously until the buffer is empty.
+ */
+static int flush_read_buffer(struct configfs_buffer * buffer, char __user * buf,
+			     size_t count, loff_t * ppos)
+{
+	int error;
+
+	if (*ppos > buffer->count)
+		return 0;
+
+	if (count > (buffer->count - *ppos))
+		count = buffer->count - *ppos;
+
+	error = copy_to_user(buf,buffer->page + *ppos,count);
+	if (!error)
+		*ppos += count;
+	return error ? -EFAULT : count;
+}
+
+/**
+ *	configfs_read_file - read an attribute.
+ *	@file:	file pointer.
+ *	@buf:	buffer to fill.
+ *	@count:	number of bytes to read.
+ *	@ppos:	starting offset in file.
+ *
+ *	Userspace wants to read an attribute file. The attribute descriptor
+ *	is in the file's ->d_fsdata. The target item is in the directory's
+ *	->d_fsdata.
+ *
+ *	We call fill_read_buffer() to allocate and fill the buffer from the
+ *	item's show() method exactly once (if the read is happening from
+ *	the beginning of the file). That should fill the entire buffer with
+ *	all the data the item has to offer for that attribute.
+ *	We then call flush_read_buffer() to copy the buffer to userspace
+ *	in the increments specified.
+ */
+
+static ssize_t
+configfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
+{
+	struct configfs_buffer * buffer = file->private_data;
+	ssize_t retval = 0;
+
+	down(&buffer->sem);
+	if (buffer->needs_read_fill) {
+		if ((retval = fill_read_buffer(file->f_dentry,buffer)))
+			goto out;
+	}
+	pr_debug("%s: count = %d, ppos = %lld, buf = %s\n",
+		 __FUNCTION__,count,*ppos,buffer->page);
+	retval = flush_read_buffer(buffer,buf,count,ppos);
+out:
+	up(&buffer->sem);
+	return retval;
+}
+
+
+/**
+ *	fill_write_buffer - copy buffer from userspace.
+ *	@buffer:	data buffer for file.
+ *	@userbuf:	data from user.
+ *	@count:		number of bytes in @userbuf.
+ *
+ *	Allocate @buffer->page if it hasn't been already, then
+ *	copy the user-supplied buffer into it.
+ */
+
+static int
+fill_write_buffer(struct configfs_buffer * buffer, const char __user * buf, size_t count)
+{
+	int error;
+
+	if (!buffer->page)
+		buffer->page = (char *)get_zeroed_page(GFP_KERNEL);
+	if (!buffer->page)
+		return -ENOMEM;
+
+	if (count > PAGE_SIZE)
+		count = PAGE_SIZE;
+	error = copy_from_user(buffer->page,buf,count);
+	buffer->needs_read_fill = 1;
+	return error ? -EFAULT : count;
+}
+
+
+/**
+ *	flush_write_buffer - push buffer to config_item.
+ *	@file:		file pointer.
+ *	@buffer:	data buffer for file.
+ *
+ *	Get the correct pointers for the config_item and the attribute we're
+ *	dealing with, then call the store() method for the attribute,
+ *	passing the buffer that we acquired in fill_write_buffer().
+ */
+
+static int
+flush_write_buffer(struct dentry * dentry, struct configfs_buffer * buffer, size_t count)
+{
+	struct configfs_attribute * attr = to_attr(dentry);
+	struct config_item * item = to_item(dentry->d_parent);
+	struct configfs_item_operations * ops = buffer->ops;
+
+	return ops->store_attribute(item,attr,buffer->page,count);
+}
+
+
+/**
+ *	configfs_write_file - write an attribute.
+ *	@file:	file pointer
+ *	@buf:	data to write
+ *	@count:	number of bytes
+ *	@ppos:	starting offset
+ *
+ *	Similar to configfs_read_file(), though working in the opposite direction.
+ *	We allocate and fill the data from the user in fill_write_buffer(),
+ *	then push it to the config_item in flush_write_buffer().
+ *	There is no easy way for us to know if userspace is only doing a partial
+ *	write, so we don't support them. We expect the entire buffer to come
+ *	on the first write.
+ *	Hint: if you're writing a value, first read the file, modify only the
+ *	the value you're changing, then write entire buffer back.
+ */
+
+static ssize_t
+configfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+{
+	struct configfs_buffer * buffer = file->private_data;
+
+	down(&buffer->sem);
+	count = fill_write_buffer(buffer,buf,count);
+	if (count > 0)
+		count = flush_write_buffer(file->f_dentry,buffer,count);
+	if (count > 0)
+		*ppos += count;
+	up(&buffer->sem);
+	return count;
+}
+
+static int check_perm(struct inode * inode, struct file * file)
+{
+	struct config_item *item = configfs_get_config_item(file->f_dentry->d_parent);
+	struct configfs_attribute * attr = to_attr(file->f_dentry);
+	struct configfs_buffer * buffer;
+	struct configfs_item_operations * ops = NULL;
+	int error = 0;
+
+	if (!item || !attr)
+		goto Einval;
+
+	/* Grab the module reference for this attribute if we have one */
+	if (!try_module_get(attr->ca_owner)) {
+		error = -ENODEV;
+		goto Done;
+	}
+
+	if (item->ci_type)
+		ops = item->ci_type->ct_item_ops;
+	else
+		goto Eaccess;
+
+	/* File needs write support.
+	 * The inode's perms must say it's ok,
+	 * and we must have a store method.
+	 */
+	if (file->f_mode & FMODE_WRITE) {
+
+		if (!(inode->i_mode & S_IWUGO) || !ops->store_attribute)
+			goto Eaccess;
+
+	}
+
+	/* File needs read support.
+	 * The inode's perms must say it's ok, and we there
+	 * must be a show method for it.
+	 */
+	if (file->f_mode & FMODE_READ) {
+		if (!(inode->i_mode & S_IRUGO) || !ops->show_attribute)
+			goto Eaccess;
+	}
+
+	/* No error? Great, allocate a buffer for the file, and store it
+	 * it in file->private_data for easy access.
+	 */
+	buffer = kmalloc(sizeof(struct configfs_buffer),GFP_KERNEL);
+	if (buffer) {
+		memset(buffer,0,sizeof(struct configfs_buffer));
+		init_MUTEX(&buffer->sem);
+		buffer->needs_read_fill = 1;
+		buffer->ops = ops;
+		file->private_data = buffer;
+	} else
+		error = -ENOMEM;
+	goto Done;
+
+ Einval:
+	error = -EINVAL;
+	goto Done;
+ Eaccess:
+	error = -EACCES;
+	module_put(attr->ca_owner);
+ Done:
+	if (error && item)
+		config_item_put(item);
+	return error;
+}
+
+static int configfs_open_file(struct inode * inode, struct file * filp)
+{
+	return check_perm(inode,filp);
+}
+
+static int configfs_release(struct inode * inode, struct file * filp)
+{
+	struct config_item * item = to_item(filp->f_dentry->d_parent);
+	struct configfs_attribute * attr = to_attr(filp->f_dentry);
+	struct module * owner = attr->ca_owner;
+	struct configfs_buffer * buffer = filp->private_data;
+
+	if (item)
+		config_item_put(item);
+	/* After this point, attr should not be accessed. */
+	module_put(owner);
+
+	if (buffer) {
+		if (buffer->page)
+			free_page((unsigned long)buffer->page);
+		kfree(buffer);
+	}
+	return 0;
+}
+
+struct file_operations configfs_file_operations = {
+	.read		= configfs_read_file,
+	.write		= configfs_write_file,
+	.llseek		= generic_file_llseek,
+	.open		= configfs_open_file,
+	.release	= configfs_release,
+};
+
+
+int configfs_add_file(struct dentry * dir, const struct configfs_attribute * attr, int type)
+{
+	struct configfs_dirent * parent_sd = dir->d_fsdata;
+	umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG;
+	int error = 0;
+
+	down(&dir->d_inode->i_sem);
+	error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode, type);
+	up(&dir->d_inode->i_sem);
+
+	return error;
+}
+
+
+/**
+ *	configfs_create_file - create an attribute file for an item.
+ *	@item:	item we're creating for.
+ *	@attr:	atrribute descriptor.
+ */
+
+int configfs_create_file(struct config_item * item, const struct configfs_attribute * attr)
+{
+	BUG_ON(!item || !item->ci_dentry || !attr);
+
+	return configfs_add_file(item->ci_dentry, attr,
+				 CONFIGFS_ITEM_ATTR);
+}
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * inode.c - basic inode and dentry operations.
+ *
+ * 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.
+ *
+ * Please see Documentation/filesystems/configfs.txt for more information.
+ */
+
+#undef DEBUG
+
+#include <linux/pagemap.h>
+#include <linux/namei.h>
+#include <linux/backing-dev.h>
+
+#include <linux/configfs.h>
+#include "configfs_internal.h"
+
+extern struct super_block * configfs_sb;
+
+static struct address_space_operations configfs_aops = {
+	.readpage	= simple_readpage,
+	.prepare_write	= simple_prepare_write,
+	.commit_write	= simple_commit_write
+};
+
+static struct backing_dev_info configfs_backing_dev_info = {
+	.ra_pages	= 0,	/* No readahead */
+	.capabilities	= BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
+};
+
+struct inode * configfs_new_inode(mode_t mode)
+{
+	struct inode * inode = new_inode(configfs_sb);
+	if (inode) {
+		inode->i_mode = mode;
+		inode->i_uid = 0;
+		inode->i_gid = 0;
+		inode->i_blksize = PAGE_CACHE_SIZE;
+		inode->i_blocks = 0;
+		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+		inode->i_mapping->a_ops = &configfs_aops;
+		inode->i_mapping->backing_dev_info = &configfs_backing_dev_info;
+	}
+	return inode;
+}
+
+int configfs_create(struct dentry * dentry, int mode, int (*init)(struct inode *))
+{
+	int error = 0;
+	struct inode * inode = NULL;
+	if (dentry) {
+		if (!dentry->d_inode) {
+			if ((inode = configfs_new_inode(mode))) {
+				if (dentry->d_parent && dentry->d_parent->d_inode) {
+					struct inode *p_inode = dentry->d_parent->d_inode;
+					p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
+				}
+				goto Proceed;
+			}
+			else
+				error = -ENOMEM;
+		} else
+			error = -EEXIST;
+	} else
+		error = -ENOENT;
+	goto Done;
+
+ Proceed:
+	if (init)
+		error = init(inode);
+	if (!error) {
+		d_instantiate(dentry, inode);
+		if (S_ISDIR(mode) || S_ISLNK(mode))
+			dget(dentry);  /* pin link and directory dentries in core */
+	} else
+		iput(inode);
+ Done:
+	return error;
+}
+
+/*
+ * Get the name for corresponding element represented by the given configfs_dirent
+ */
+const unsigned char * configfs_get_name(struct configfs_dirent *sd)
+{
+	struct attribute * attr;
+
+	if (!sd || !sd->s_element)
+		BUG();
+
+	/* These always have a dentry, so use that */
+	if (sd->s_type & (CONFIGFS_DIR | CONFIGFS_ITEM_LINK))
+		return sd->s_dentry->d_name.name;
+
+	if (sd->s_type & CONFIGFS_ITEM_ATTR) {
+		attr = sd->s_element;
+		return attr->name;
+	}
+	return NULL;
+}
+
+
+/*
+ * Unhashes the dentry corresponding to given configfs_dirent
+ * Called with parent inode's i_sem held.
+ */
+void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent)
+{
+	struct dentry * dentry = sd->s_dentry;
+
+	if (dentry) {
+		spin_lock(&dcache_lock);
+		if (!(d_unhashed(dentry) && dentry->d_inode)) {
+			dget_locked(dentry);
+			__d_drop(dentry);
+			spin_unlock(&dcache_lock);
+			simple_unlink(parent->d_inode, dentry);
+		} else
+			spin_unlock(&dcache_lock);
+	}
+}
+
+void configfs_hash_and_remove(struct dentry * dir, const char * name)
+{
+	struct configfs_dirent * sd;
+	struct configfs_dirent * parent_sd = dir->d_fsdata;
+
+	down(&dir->d_inode->i_sem);
+	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
+		if (!sd->s_element)
+			continue;
+		if (!strcmp(configfs_get_name(sd), name)) {
+			list_del_init(&sd->s_sibling);
+			configfs_drop_dentry(sd, dir);
+			configfs_put(sd);
+			break;
+		}
+	}
+	up(&dir->d_inode->i_sem);
+}
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * item.c - library routines for handling generic config items
+ *
+ * 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 kobject:
+ * 	kobject is Copyright (c) 2002-2003 Patrick Mochel
+ *
+ * configfs Copyright (C) 2005 Oracle.  All rights reserved.
+ *
+ * Please see the file Documentation/filesystems/configfs.txt for
+ * critical information about using the config_item interface.
+ */
+
+#include <linux/string.h>
+#include <linux/module.h>
+#include <linux/stat.h>
+#include <linux/slab.h>
+
+#include <linux/configfs.h>
+
+
+static inline struct config_item * to_item(struct list_head * entry)
+{
+	return container_of(entry,struct config_item,ci_entry);
+}
+
+/* Evil kernel */
+static void config_item_release(struct kref *kref);
+
+/**
+ *	config_item_init - initialize item.
+ *	@item:	item in question.
+ */
+void config_item_init(struct config_item * item)
+{
+	kref_init(&item->ci_kref);
+	INIT_LIST_HEAD(&item->ci_entry);
+}
+
+/**
+ *	config_item_set_name - Set the name of an item
+ *	@item:	item.
+ *	@name:	name.
+ *
+ *	If strlen(name) >= CONFIGFS_ITEM_NAME_LEN, then use a
+ *	dynamically allocated string that @item->ci_name points to.
+ *	Otherwise, use the static @item->ci_namebuf array.
+ */
+
+int config_item_set_name(struct config_item * item, const char * fmt, ...)
+{
+	int error = 0;
+	int limit = CONFIGFS_ITEM_NAME_LEN;
+	int need;
+	va_list args;
+	char * name;
+
+	/*
+	 * First, try the static array
+	 */
+	va_start(args,fmt);
+	need = vsnprintf(item->ci_namebuf,limit,fmt,args);
+	va_end(args);
+	if (need < limit)
+		name = item->ci_namebuf;
+	else {
+		/*
+		 * Need more space? Allocate it and try again
+		 */
+		limit = need + 1;
+		name = kmalloc(limit,GFP_KERNEL);
+		if (!name) {
+			error = -ENOMEM;
+			goto Done;
+		}
+		va_start(args,fmt);
+		need = vsnprintf(name,limit,fmt,args);
+		va_end(args);
+
+		/* Still? Give up. */
+		if (need >= limit) {
+			kfree(name);
+			error = -EFAULT;
+			goto Done;
+		}
+	}
+
+	/* Free the old name, if necessary. */
+	if (item->ci_name && item->ci_name != item->ci_namebuf)
+		kfree(item->ci_name);
+
+	/* Now, set the new name */
+	item->ci_name = name;
+ Done:
+	return error;
+}
+
+EXPORT_SYMBOL(config_item_set_name);
+
+void config_item_init_type_name(struct config_item *item,
+				const char *name,
+				struct config_item_type *type)
+{
+	config_item_set_name(item, name);
+	item->ci_type = type;
+	config_item_init(item);
+}
+EXPORT_SYMBOL(config_item_init_type_name);
+
+void config_group_init_type_name(struct config_group *group, const char *name,
+			 struct config_item_type *type)
+{
+	config_item_set_name(&group->cg_item, name);
+	group->cg_item.ci_type = type;
+	config_group_init(group);
+}
+EXPORT_SYMBOL(config_group_init_type_name);
+
+struct config_item * config_item_get(struct config_item * item)
+{
+	if (item)
+		kref_get(&item->ci_kref);
+	return item;
+}
+
+/**
+ *	config_item_cleanup - free config_item resources.
+ *	@item:	item.
+ */
+
+void config_item_cleanup(struct config_item * item)
+{
+	struct config_item_type * t = item->ci_type;
+	struct config_group * s = item->ci_group;
+	struct config_item * parent = item->ci_parent;
+
+	pr_debug("config_item %s: cleaning up\n",config_item_name(item));
+	if (item->ci_name != item->ci_namebuf)
+		kfree(item->ci_name);
+	item->ci_name = NULL;
+	if (t && t->ct_item_ops && t->ct_item_ops->release)
+		t->ct_item_ops->release(item);
+	if (s)
+		config_group_put(s);
+	if (parent)
+		config_item_put(parent);
+}
+
+static void config_item_release(struct kref *kref)
+{
+	config_item_cleanup(container_of(kref, struct config_item, ci_kref));
+}
+
+/**
+ *	config_item_put - decrement refcount for item.
+ *	@item:	item.
+ *
+ *	Decrement the refcount, and if 0, call config_item_cleanup().
+ */
+void config_item_put(struct config_item * item)
+{
+	if (item)
+		kref_put(&item->ci_kref, config_item_release);
+}
+
+
+/**
+ *	config_group_init - initialize a group for use
+ *	@k:	group
+ */
+
+void config_group_init(struct config_group *group)
+{
+	config_item_init(&group->cg_item);
+	INIT_LIST_HEAD(&group->cg_children);
+}
+
+
+/**
+ *	config_group_find_obj - search for item in group.
+ *	@group:	group we're looking in.
+ *	@name:	item's name.
+ *
+ *	Lock group via @group->cg_subsys, and iterate over @group->cg_list,
+ *	looking for a matching config_item. If matching item is found
+ *	take a reference and return the item.
+ */
+
+struct config_item * config_group_find_obj(struct config_group * group, const char * name)
+{
+	struct list_head * entry;
+	struct config_item * ret = NULL;
+
+        /* XXX LOCKING! */
+	list_for_each(entry,&group->cg_children) {
+		struct config_item * item = to_item(entry);
+		if (config_item_name(item) &&
+                    !strcmp(config_item_name(item), name)) {
+			ret = config_item_get(item);
+			break;
+		}
+	}
+	return ret;
+}
+
+
+EXPORT_SYMBOL(config_item_init);
+EXPORT_SYMBOL(config_group_init);
+EXPORT_SYMBOL(config_item_get);
+EXPORT_SYMBOL(config_item_put);
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * mount.c - operations for initializing and mounting configfs.
+ *
+ * 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/fs.h>
+#include <linux/module.h>
+#include <linux/mount.h>
+#include <linux/pagemap.h>
+#include <linux/init.h>
+
+#include <linux/configfs.h>
+#include "configfs_internal.h"
+
+/* Random magic number */
+#define CONFIGFS_MAGIC 0x62656570
+
+struct vfsmount * configfs_mount = NULL;
+struct super_block * configfs_sb = NULL;
+static int configfs_mnt_count = 0;
+
+static struct super_operations configfs_ops = {
+	.statfs		= simple_statfs,
+	.drop_inode	= generic_delete_inode,
+};
+
+static struct config_group configfs_root_group = {
+	.cg_item = {
+		.ci_namebuf	= "root",
+		.ci_name	= configfs_root_group.cg_item.ci_namebuf,
+	},
+};
+
+int configfs_is_root(struct config_item *item)
+{
+	return item == &configfs_root_group.cg_item;
+}
+
+static struct configfs_dirent configfs_root = {
+	.s_sibling	= LIST_HEAD_INIT(configfs_root.s_sibling),
+	.s_children	= LIST_HEAD_INIT(configfs_root.s_children),
+	.s_element	= &configfs_root_group.cg_item,
+	.s_type		= CONFIGFS_ROOT,
+};
+
+static int configfs_fill_super(struct super_block *sb, void *data, int silent)
+{
+	struct inode *inode;
+	struct dentry *root;
+
+	sb->s_blocksize = PAGE_CACHE_SIZE;
+	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+	sb->s_magic = CONFIGFS_MAGIC;
+	sb->s_op = &configfs_ops;
+	configfs_sb = sb;
+
+	inode = configfs_new_inode(S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO);
+	if (inode) {
+		inode->i_op = &configfs_dir_inode_operations;
+		inode->i_fop = &configfs_dir_operations;
+		/* directory inodes start off with i_nlink == 2 (for "." entry) */
+		inode->i_nlink++;
+	} else {
+		pr_debug("configfs: could not get root inode\n");
+		return -ENOMEM;
+	}
+
+	root = d_alloc_root(inode);
+	if (!root) {
+		pr_debug("%s: could not get root dentry!\n",__FUNCTION__);
+		iput(inode);
+		return -ENOMEM;
+	}
+	config_group_init(&configfs_root_group);
+	configfs_root_group.cg_item.ci_dentry = root;
+	root->d_fsdata = &configfs_root;
+	sb->s_root = root;
+	return 0;
+}
+
+static struct super_block *configfs_get_sb(struct file_system_type *fs_type,
+	int flags, const char *dev_name, void *data)
+{
+	return get_sb_single(fs_type, flags, data, configfs_fill_super);
+}
+
+static struct file_system_type configfs_fs_type = {
+	.owner		= THIS_MODULE,
+	.name		= "configfs",
+	.get_sb		= configfs_get_sb,
+	.kill_sb	= kill_litter_super,
+};
+
+int configfs_pin_fs(void)
+{
+	return simple_pin_fs("configfs", &configfs_mount,
+			     &configfs_mnt_count);
+}
+
+void configfs_release_fs(void)
+{
+	simple_release_fs(&configfs_mount, &configfs_mnt_count);
+}
+
+
+static decl_subsys(config, NULL, NULL);
+
+static int __init configfs_init(void)
+{
+	int err;
+
+	kset_set_kset_s(&config_subsys, kernel_subsys);
+	err = subsystem_register(&config_subsys);
+	if (err)
+		return err;
+
+	err = register_filesystem(&configfs_fs_type);
+	if (err) {
+		printk(KERN_ERR "configfs: Unable to register filesystem!\n");
+		subsystem_unregister(&config_subsys);
+	}
+
+	return err;
+}
+
+static void __exit configfs_exit(void)
+{
+	unregister_filesystem(&configfs_fs_type);
+	subsystem_unregister(&config_subsys);
+}
+
+MODULE_AUTHOR("Oracle");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("0.0.1");
+MODULE_DESCRIPTION("Simple RAM filesystem for user driven kernel subsystem configuration.");
+
+module_init(configfs_init);
+module_exit(configfs_exit);
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * symlink.c - operations for configfs symlinks.
+ *
+ * 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/fs.h>
+#include <linux/module.h>
+#include <linux/namei.h>
+
+#include <linux/configfs.h>
+#include "configfs_internal.h"
+
+static int item_depth(struct config_item * item)
+{
+	struct config_item * p = item;
+	int depth = 0;
+	do { depth++; } while ((p = p->ci_parent) && !configfs_is_root(p));
+	return depth;
+}
+
+static int item_path_length(struct config_item * item)
+{
+	struct config_item * p = item;
+	int length = 1;
+	do {
+		length += strlen(config_item_name(p)) + 1;
+		p = p->ci_parent;
+	} while (p && !configfs_is_root(p));
+	return length;
+}
+
+static void fill_item_path(struct config_item * item, char * buffer, int length)
+{
+	struct config_item * p;
+
+	--length;
+	for (p = item; p && !configfs_is_root(p); p = p->ci_parent) {
+		int cur = strlen(config_item_name(p));
+
+		/* back up enough to print this bus id with '/' */
+		length -= cur;
+		strncpy(buffer + length,config_item_name(p),cur);
+		*(buffer + --length) = '/';
+	}
+}
+
+static int create_link(struct config_item *parent_item,
+ 		       struct config_item *item,
+		       struct dentry *dentry)
+{
+	struct configfs_dirent *target_sd = item->ci_dentry->d_fsdata;
+	struct configfs_symlink *sl;
+	int ret;
+
+	ret = -ENOMEM;
+	sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL);
+	if (sl) {
+		sl->sl_target = config_item_get(item);
+		/* FIXME: needs a lock, I'd bet */
+		list_add(&sl->sl_list, &target_sd->s_links);
+		ret = configfs_create_link(sl, parent_item->ci_dentry,
+					   dentry);
+		if (ret) {
+			list_del_init(&sl->sl_list);
+			config_item_put(item);
+			kfree(sl);
+		}
+	}
+
+	return ret;
+}
+
+
+static int get_target(const char *symname, struct nameidata *nd,
+		      struct config_item **target)
+{
+	int ret;
+
+	ret = path_lookup(symname, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, nd);
+	if (!ret) {
+		if (nd->dentry->d_sb == configfs_sb) {
+			*target = configfs_get_config_item(nd->dentry);
+			if (!*target) {
+				ret = -ENOENT;
+				path_release(nd);
+			}
+		} else
+			ret = -EPERM;
+	}
+
+	return ret;
+}
+
+
+int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
+{
+	int ret;
+	struct nameidata nd;
+	struct config_item *parent_item;
+	struct config_item *target_item;
+	struct config_item_type *type;
+
+	ret = -EPERM;  /* What lack-of-symlink returns */
+	if (dentry->d_parent == configfs_sb->s_root)
+		goto out;
+
+	parent_item = configfs_get_config_item(dentry->d_parent);
+	type = parent_item->ci_type;
+
+	if (!type || !type->ct_item_ops ||
+	    !type->ct_item_ops->allow_link)
+		goto out_put;
+
+	ret = get_target(symname, &nd, &target_item);
+	if (ret)
+		goto out_put;
+
+	ret = type->ct_item_ops->allow_link(parent_item, target_item);
+	if (!ret)
+		ret = create_link(parent_item, target_item, dentry);
+
+	config_item_put(target_item);
+	path_release(&nd);
+
+out_put:
+	config_item_put(parent_item);
+
+out:
+	return ret;
+}
+
+int configfs_unlink(struct inode *dir, struct dentry *dentry)
+{
+	struct configfs_dirent *sd = dentry->d_fsdata;
+	struct configfs_symlink *sl;
+	struct config_item *parent_item;
+	struct config_item_type *type;
+	int ret;
+
+	ret = -EPERM;  /* What lack-of-symlink returns */
+	if (!(sd->s_type & CONFIGFS_ITEM_LINK))
+		goto out;
+
+	if (dentry->d_parent == configfs_sb->s_root)
+		BUG();
+
+	sl = sd->s_element;
+
+	parent_item = configfs_get_config_item(dentry->d_parent);
+	type = parent_item->ci_type;
+
+	list_del_init(&sd->s_sibling);
+	configfs_drop_dentry(sd, dentry->d_parent);
+	dput(dentry);
+	configfs_put(sd);
+
+	/*
+	 * drop_link() must be called before
+	 * list_del_init(&sl->sl_list), so that the order of
+	 * drop_link(this, target) and drop_item(target) is preserved.
+	 */
+	if (type && type->ct_item_ops &&
+	    type->ct_item_ops->drop_link)
+		type->ct_item_ops->drop_link(parent_item,
+					       sl->sl_target);
+
+	/* FIXME: Needs lock */
+	list_del_init(&sl->sl_list);
+
+	/* Put reference from create_link() */
+	config_item_put(sl->sl_target);
+	kfree(sl);
+
+	config_item_put(parent_item);
+
+	ret = 0;
+
+out:
+	return ret;
+}
+
+static int configfs_get_target_path(struct config_item * item, struct config_item * target,
+				   char *path)
+{
+	char * s;
+	int depth, size;
+
+	depth = item_depth(item);
+	size = item_path_length(target) + depth * 3 - 1;
+	if (size > PATH_MAX)
+		return -ENAMETOOLONG;
+
+	pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size);
+
+	for (s = path; depth--; s += 3)
+		strcpy(s,"../");
+
+	fill_item_path(target, path, size);
+	pr_debug("%s: path = '%s'\n", __FUNCTION__, path);
+
+	return 0;
+}
+
+static int configfs_getlink(struct dentry *dentry, char * path)
+{
+	struct config_item *item, *target_item;
+	int error = 0;
+
+	item = configfs_get_config_item(dentry->d_parent);
+	if (!item)
+		return -EINVAL;
+
+	target_item = configfs_get_config_item(dentry);
+	if (!target_item) {
+		config_item_put(item);
+		return -EINVAL;
+	}
+
+	down_read(&configfs_rename_sem);
+	error = configfs_get_target_path(item, target_item, path);
+	up_read(&configfs_rename_sem);
+
+	config_item_put(item);
+	config_item_put(target_item);
+	return error;
+
+}
+
+static void *configfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+{
+	int error = -ENOMEM;
+	unsigned long page = get_zeroed_page(GFP_KERNEL);
+
+	if (page) {
+		error = configfs_getlink(dentry, (char *)page);
+		if (!error) {
+			nd_set_link(nd, (char *)page);
+			return (void *)page;
+		}
+	}
+
+	nd_set_link(nd, ERR_PTR(error));
+	return NULL;
+}
+
+static void configfs_put_link(struct dentry *dentry, struct nameidata *nd,
+			      void *cookie)
+{
+	if (cookie) {
+		unsigned long page = (unsigned long)cookie;
+		free_page(page);
+	}
+}
+
+struct inode_operations configfs_symlink_inode_operations = {
+	.follow_link = configfs_follow_link,
+	.readlink = generic_readlink,
+	.put_link = configfs_put_link,
+};
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * configfs.h - definitions for the device driver filesystem
+ *
+ * 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
+ *
+ * Based on kobject.h:
+ *      Copyright (c) 2002-2003	Patrick Mochel
+ *      Copyright (c) 2002-2003	Open Source Development Labs
+ *
+ * configfs Copyright (C) 2005 Oracle.  All rights reserved.
+ *
+ * Please read Documentation/filesystems/configfs.txt before using the
+ * configfs interface, ESPECIALLY the parts about reference counts and
+ * item destructors.
+ */
+
+#ifndef _CONFIGFS_H_
+#define _CONFIGFS_H_
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/kref.h>
+
+#include <asm/atomic.h>
+#include <asm/semaphore.h>
+
+#define CONFIGFS_ITEM_NAME_LEN	20
+
+struct module;
+
+struct configfs_item_operations;
+struct configfs_group_operations;
+struct configfs_attribute;
+struct configfs_subsystem;
+
+struct config_item {
+	char			*ci_name;
+	char			ci_namebuf[CONFIGFS_ITEM_NAME_LEN];
+	struct kref		ci_kref;
+	struct list_head	ci_entry;
+	struct config_item	*ci_parent;
+	struct config_group	*ci_group;
+	struct config_item_type	*ci_type;
+	struct dentry		*ci_dentry;
+};
+
+extern int config_item_set_name(struct config_item *, const char *, ...);
+
+static inline char *config_item_name(struct config_item * item)
+{
+	return item->ci_name;
+}
+
+extern void config_item_init(struct config_item *);
+extern void config_item_init_type_name(struct config_item *item,
+				       const char *name,
+				       struct config_item_type *type);
+extern void config_item_cleanup(struct config_item *);
+
+extern struct config_item * config_item_get(struct config_item *);
+extern void config_item_put(struct config_item *);
+
+struct config_item_type {
+	struct module				*ct_owner;
+	struct configfs_item_operations		*ct_item_ops;
+	struct configfs_group_operations	*ct_group_ops;
+	struct configfs_attribute		**ct_attrs;
+};
+
+
+/**
+ *	group - a group of config_items of a specific type, belonging
+ *	to a specific subsystem.
+ */
+
+struct config_group {
+	struct config_item		cg_item;
+	struct list_head		cg_children;
+	struct configfs_subsystem 	*cg_subsys;
+	struct config_group		**default_groups;
+};
+
+
+extern void config_group_init(struct config_group *group);
+extern void config_group_init_type_name(struct config_group *group,
+					const char *name,
+					struct config_item_type *type);
+
+
+static inline struct config_group *to_config_group(struct config_item *item)
+{
+	return item ? container_of(item,struct config_group,cg_item) : NULL;
+}
+
+static inline struct config_group *config_group_get(struct config_group *group)
+{
+	return group ? to_config_group(config_item_get(&group->cg_item)) : NULL;
+}
+
+static inline void config_group_put(struct config_group *group)
+{
+	config_item_put(&group->cg_item);
+}
+
+extern struct config_item *config_group_find_obj(struct config_group *, const char *);
+
+
+struct configfs_attribute {
+	char			*ca_name;
+	struct module 		*ca_owner;
+	mode_t			ca_mode;
+};
+
+
+/*
+ * If allow_link() exists, the item can symlink(2) out to other
+ * items.  If the item is a group, it may support mkdir(2).
+ * Groups supply one of make_group() and make_item().  If the
+ * group supports make_group(), one can create group children.  If it
+ * supports make_item(), one can create config_item children.  If it has
+ * default_groups on group->default_groups, it has automatically created
+ * group children.  default_groups may coexist alongsize make_group() or
+ * make_item(), but if the group wishes to have only default_groups
+ * children (disallowing mkdir(2)), it need not provide either function.
+ * If the group has commit(), it supports pending and commited (active)
+ * items.
+ */
+struct configfs_item_operations {
+	void (*release)(struct config_item *);
+	ssize_t	(*show_attribute)(struct config_item *, struct configfs_attribute *,char *);
+	ssize_t	(*store_attribute)(struct config_item *,struct configfs_attribute *,const char *, size_t);
+	int (*allow_link)(struct config_item *src, struct config_item *target);
+	int (*drop_link)(struct config_item *src, struct config_item *target);
+};
+
+struct configfs_group_operations {
+	struct config_item *(*make_item)(struct config_group *group, const char *name);
+	struct config_group *(*make_group)(struct config_group *group, const char *name);
+	int (*commit_item)(struct config_item *item);
+	void (*drop_item)(struct config_group *group, struct config_item *item);
+};
+
+
+
+/**
+ * Use these macros to make defining attributes easier. See include/linux/device.h
+ * for examples..
+ */
+
+#if 0
+#define __ATTR(_name,_mode,_show,_store) { \
+	.attr = {.ca_name = __stringify(_name), .ca_mode = _mode, .ca_owner = THIS_MODULE },	\
+	.show	= _show,					\
+	.store	= _store,					\
+}
+
+#define __ATTR_RO(_name) { \
+	.attr	= { .ca_name = __stringify(_name), .ca_mode = 0444, .ca_owner = THIS_MODULE },	\
+	.show	= _name##_show,	\
+}
+
+#define __ATTR_NULL { .attr = { .name = NULL } }
+
+#define attr_name(_attr) (_attr).attr.name
+#endif
+
+
+struct configfs_subsystem {
+	struct config_group	su_group;
+	struct semaphore	su_sem;
+};
+
+static inline struct configfs_subsystem *to_configfs_subsystem(struct config_group *group)
+{
+	return group ?
+		container_of(group, struct configfs_subsystem, su_group) :
+		NULL;
+}
+
+int configfs_register_subsystem(struct configfs_subsystem *subsys);
+void configfs_unregister_subsystem(struct configfs_subsystem *subsys);
+
+#endif  /* __KERNEL__ */
+
+#endif /* _CONFIGFS_H_ */
...	...	@@ -12,6 +12,8 @@
12	12	- description of the CIFS filesystem
13	13	coda.txt
14	14	- description of the CODA filesystem.
	15	+configfs/
	16	+ - directory containing configfs documentation and example code.
15	17	cramfs.txt
16	18	- info on the cram filesystem for small storage (ROMs etc)
17	19	devfs/
	1	+
	2	+configfs - Userspace-driven kernel object configuation.
	3	+
	4	+Joel Becker <joel.becker@oracle.com>
	5	+
	6	+Updated: 31 March 2005
	7	+
	8	+Copyright (c) 2005 Oracle Corporation,
	9	+ Joel Becker <joel.becker@oracle.com>
	10	+
	11	+
	12	+[What is configfs?]
	13	+
	14	+configfs is a ram-based filesystem that provides the converse of
	15	+sysfs's functionality. Where sysfs is a filesystem-based view of
	16	+kernel objects, configfs is a filesystem-based manager of kernel
	17	+objects, or config_items.
	18	+
	19	+With sysfs, an object is created in kernel (for example, when a device
	20	+is discovered) and it is registered with sysfs. Its attributes then
	21	+appear in sysfs, allowing userspace to read the attributes via
	22	+readdir(3)/read(2). It may allow some attributes to be modified via
	23	+write(2). The important point is that the object is created and
	24	+destroyed in kernel, the kernel controls the lifecycle of the sysfs
	25	+representation, and sysfs is merely a window on all this.
	26	+
	27	+A configfs config_item is created via an explicit userspace operation:
	28	+mkdir(2). It is destroyed via rmdir(2). The attributes appear at
	29	+mkdir(2) time, and can be read or modified via read(2) and write(2).
	30	+As with sysfs, readdir(3) queries the list of items and/or attributes.
	31	+symlink(2) can be used to group items together. Unlike sysfs, the
	32	+lifetime of the representation is completely driven by userspace. The
	33	+kernel modules backing the items must respond to this.
	34	+
	35	+Both sysfs and configfs can and should exist together on the same
	36	+system. One is not a replacement for the other.
	37	+
	38	+[Using configfs]
	39	+
	40	+configfs can be compiled as a module or into the kernel. You can access
	41	+it by doing
	42	+
	43	+ mount -t configfs none /config
	44	+
	45	+The configfs tree will be empty unless client modules are also loaded.
	46	+These are modules that register their item types with configfs as
	47	+subsystems. Once a client subsystem is loaded, it will appear as a
	48	+subdirectory (or more than one) under /config. Like sysfs, the
	49	+configfs tree is always there, whether mounted on /config or not.
	50	+
	51	+An item is created via mkdir(2). The item's attributes will also
	52	+appear at this time. readdir(3) can determine what the attributes are,
	53	+read(2) can query their default values, and write(2) can store new
	54	+values. Like sysfs, attributes should be ASCII text files, preferably
	55	+with only one value per file. The same efficiency caveats from sysfs
	56	+apply. Don't mix more than one attribute in one attribute file.
	57	+
	58	+Like sysfs, configfs expects write(2) to store the entire buffer at
	59	+once. When writing to configfs attributes, userspace processes should
	60	+first read the entire file, modify the portions they wish to change, and
	61	+then write the entire buffer back. Attribute files have a maximum size
	62	+of one page (PAGE_SIZE, 4096 on i386).
	63	+
	64	+When an item needs to be destroyed, remove it with rmdir(2). An
	65	+item cannot be destroyed if any other item has a link to it (via
	66	+symlink(2)). Links can be removed via unlink(2).
	67	+
	68	+[Configuring FakeNBD: an Example]
	69	+
	70	+Imagine there's a Network Block Device (NBD) driver that allows you to
	71	+access remote block devices. Call it FakeNBD. FakeNBD uses configfs
	72	+for its configuration. Obviously, there will be a nice program that
	73	+sysadmins use to configure FakeNBD, but somehow that program has to tell
	74	+the driver about it. Here's where configfs comes in.
	75	+
	76	+When the FakeNBD driver is loaded, it registers itself with configfs.
	77	+readdir(3) sees this just fine:
	78	+
	79	+ # ls /config
	80	+ fakenbd
	81	+
	82	+A fakenbd connection can be created with mkdir(2). The name is
	83	+arbitrary, but likely the tool will make some use of the name. Perhaps
	84	+it is a uuid or a disk name:
	85	+
	86	+ # mkdir /config/fakenbd/disk1
	87	+ # ls /config/fakenbd/disk1
	88	+ target device rw
	89	+
	90	+The target attribute contains the IP address of the server FakeNBD will
	91	+connect to. The device attribute is the device on the server.
	92	+Predictably, the rw attribute determines whether the connection is
	93	+read-only or read-write.
	94	+
	95	+ # echo 10.0.0.1 > /config/fakenbd/disk1/target
	96	+ # echo /dev/sda1 > /config/fakenbd/disk1/device
	97	+ # echo 1 > /config/fakenbd/disk1/rw
	98	+
	99	+That's it. That's all there is. Now the device is configured, via the
	100	+shell no less.
	101	+
	102	+[Coding With configfs]
	103	+
	104	+Every object in configfs is a config_item. A config_item reflects an
	105	+object in the subsystem. It has attributes that match values on that
	106	+object. configfs handles the filesystem representation of that object
	107	+and its attributes, allowing the subsystem to ignore all but the
	108	+basic show/store interaction.
	109	+
	110	+Items are created and destroyed inside a config_group. A group is a
	111	+collection of items that share the same attributes and operations.
	112	+Items are created by mkdir(2) and removed by rmdir(2), but configfs
	113	+handles that. The group has a set of operations to perform these tasks
	114	+
	115	+A subsystem is the top level of a client module. During initialization,
	116	+the client module registers the subsystem with configfs, the subsystem
	117	+appears as a directory at the top of the configfs filesystem. A
	118	+subsystem is also a config_group, and can do everything a config_group
	119	+can.
	120	+
	121	+[struct config_item]
	122	+
	123	+ struct config_item {
	124	+ char *ci_name;
	125	+ char ci_namebuf[UOBJ_NAME_LEN];
	126	+ struct kref ci_kref;
	127	+ struct list_head ci_entry;
	128	+ struct config_item *ci_parent;
	129	+ struct config_group *ci_group;
	130	+ struct config_item_type *ci_type;
	131	+ struct dentry *ci_dentry;
	132	+ };
	133	+
	134	+ void config_item_init(struct config_item *);
	135	+ void config_item_init_type_name(struct config_item *,
	136	+ const char *name,
	137	+ struct config_item_type *type);
	138	+ struct config_item config_item_get(struct config_item );
	139	+ void config_item_put(struct config_item *);
	140	+
	141	+Generally, struct config_item is embedded in a container structure, a
	142	+structure that actually represents what the subsystem is doing. The
	143	+config_item portion of that structure is how the object interacts with
	144	+configfs.
	145	+
	146	+Whether statically defined in a source file or created by a parent
	147	+config_group, a config_item must have one of the _init() functions
	148	+called on it. This initializes the reference count and sets up the
	149	+appropriate fields.
	150	+
	151	+All users of a config_item should have a reference on it via
	152	+config_item_get(), and drop the reference when they are done via
	153	+config_item_put().
	154	+
	155	+By itself, a config_item cannot do much more than appear in configfs.
	156	+Usually a subsystem wants the item to display and/or store attributes,
	157	+among other things. For that, it needs a type.
	158	+
	159	+[struct config_item_type]
	160	+
	161	+ struct configfs_item_operations {
	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,
	170	+ struct config_item *target);
	171	+ int (drop_link)(struct config_item src,
	172	+ struct config_item *target);
	173	+ };
	174	+
	175	+ struct config_item_type {
	176	+ struct module *ct_owner;
	177	+ struct configfs_item_operations *ct_item_ops;
	178	+ struct configfs_group_operations *ct_group_ops;
	179	+ struct configfs_attribute **ct_attrs;
	180	+ };
	181	+
	182	+The most basic function of a config_item_type is to define what
	183	+operations can be performed on a config_item. All items that have been
	184	+allocated dynamically will need to provide the ct_item_ops->release()
	185	+method. This method is called when the config_item's reference count
	186	+reaches zero. Items that wish to display an attribute need to provide
	187	+the ct_item_ops->show_attribute() method. Similarly, storing a new
	188	+attribute value uses the store_attribute() method.
	189	+
	190	+[struct configfs_attribute]
	191	+
	192	+ struct configfs_attribute {
	193	+ char *ca_name;
	194	+ struct module *ca_owner;
	195	+ mode_t ca_mode;
	196	+ };
	197	+
	198	+When a config_item wants an attribute to appear as a file in the item's
	199	+configfs directory, it must define a configfs_attribute describing it.
	200	+It then adds the attribute to the NULL-terminated array
	201	+config_item_type->ct_attrs. When the item appears in configfs, the
	202	+attribute file will appear with the configfs_attribute->ca_name
	203	+filename. configfs_attribute->ca_mode specifies the file permissions.
	204	+
	205	+If an attribute is readable and the config_item provides a
	206	+ct_item_ops->show_attribute() method, that method will be called
	207	+whenever userspace asks for a read(2) on the attribute. The converse
	208	+will happen for write(2).
	209	+
	210	+[struct config_group]
	211	+
	212	+A config_item cannot live in a vaccum. The only way one can be created
	213	+is via mkdir(2) on a config_group. This will trigger creation of a
	214	+child item.
	215	+
	216	+ struct config_group {
	217	+ struct config_item cg_item;
	218	+ struct list_head cg_children;
	219	+ struct configfs_subsystem *cg_subsys;
	220	+ struct config_group **default_groups;
	221	+ };
	222	+
	223	+ void config_group_init(struct config_group *group);
	224	+ void config_group_init_type_name(struct config_group *group,
	225	+ const char *name,
	226	+ struct config_item_type *type);
	227	+
	228	+
	229	+The config_group structure contains a config_item. Properly configuring
	230	+that item means that a group can behave as an item in its own right.
	231	+However, it can do more: it can create child items or groups. This is
	232	+accomplished via the group operations specified on the group's
	233	+config_item_type.
	234	+
	235	+ struct configfs_group_operations {
	236	+ struct config_item (make_item)(struct config_group *group,
	237	+ const char *name);
	238	+ struct config_group (make_group)(struct config_group *group,
	239	+ const char *name);
	240	+ int (commit_item)(struct config_item item);
	241	+ void (drop_item)(struct config_group group,
	242	+ struct config_item *item);
	243	+ };
	244	+
	245	+A group creates child items by providing the
	246	+ct_group_ops->make_item() method. If provided, this method is called from mkdir(2) in the group's directory. The subsystem allocates a new
	247	+config_item (or more likely, its container structure), initializes it,
	248	+and returns it to configfs. Configfs will then populate the filesystem
	249	+tree to reflect the new item.
	250	+
	251	+If the subsystem wants the child to be a group itself, the subsystem
	252	+provides ct_group_ops->make_group(). Everything else behaves the same,
	253	+using the group _init() functions on the group.
	254	+
	255	+Finally, when userspace calls rmdir(2) on the item or group,
	256	+ct_group_ops->drop_item() is called. As a config_group is also a
	257	+config_item, it is not necessary for a seperate drop_group() method.
	258	+The subsystem must config_item_put() the reference that was initialized
	259	+upon item allocation. If a subsystem has no work to do, it may omit
	260	+the ct_group_ops->drop_item() method, and configfs will call
	261	+config_item_put() on the item on behalf of the subsystem.
	262	+
	263	+IMPORTANT: drop_item() is void, and as such cannot fail. When rmdir(2)
	264	+is called, configfs WILL remove the item from the filesystem tree
	265	+(assuming that it has no children to keep it busy). The subsystem is
	266	+responsible for responding to this. If the subsystem has references to
	267	+the item in other threads, the memory is safe. It may take some time
	268	+for the item to actually disappear from the subsystem's usage. But it
	269	+is gone from configfs.
	270	+
	271	+A config_group cannot be removed while it still has child items. This
	272	+is implemented in the configfs rmdir(2) code. ->drop_item() will not be
	273	+called, as the item has not been dropped. rmdir(2) will fail, as the
	274	+directory is not empty.
	275	+
	276	+[struct configfs_subsystem]
	277	+
	278	+A subsystem must register itself, ususally at module_init time. This
	279	+tells configfs to make the subsystem appear in the file tree.
	280	+
	281	+ struct configfs_subsystem {
	282	+ struct config_group su_group;
	283	+ struct semaphore su_sem;
	284	+ };
	285	+
	286	+ int configfs_register_subsystem(struct configfs_subsystem *subsys);
	287	+ void configfs_unregister_subsystem(struct configfs_subsystem *subsys);
	288	+
	289	+ A subsystem consists of a toplevel config_group and a semaphore.
	290	+The group is where child config_items are created. For a subsystem,
	291	+this group is usually defined statically. Before calling
	292	+configfs_register_subsystem(), the subsystem must have initialized the
	293	+group via the usual group _init() functions, and it must also have
	294	+initialized the semaphore.
	295	+ When the register call returns, the subsystem is live, and it
	296	+will be visible via configfs. At that point, mkdir(2) can be called and
	297	+the subsystem must be ready for it.
	298	+
	299	+[An Example]
	300	+
	301	+The best example of these basic concepts is the simple_children
	302	+subsystem/group and the simple_child item in configfs_example.c It
	303	+shows a trivial object displaying and storing an attribute, and a simple
	304	+group creating and destroying these children.
	305	+
	306	+[Hierarchy Navigation and the Subsystem Semaphore]
	307	+
	308	+There is an extra bonus that configfs provides. The config_groups and
	309	+config_items are arranged in a hierarchy due to the fact that they
	310	+appear in a filesystem. A subsystem is NEVER to touch the filesystem
	311	+parts, but the subsystem might be interested in this hierarchy. For
	312	+this reason, the hierarchy is mirrored via the config_group->cg_children
	313	+and config_item->ci_parent structure members.
	314	+
	315	+A subsystem can navigate the cg_children list and the ci_parent pointer
	316	+to see the tree created by the subsystem. This can race with configfs'
	317	+management of the hierarchy, so configfs uses the subsystem semaphore to
	318	+protect modifications. Whenever a subsystem wants to navigate the
	319	+hierarchy, it must do so under the protection of the subsystem
	320	+semaphore.
	321	+
	322	+A subsystem will be prevented from acquiring the semaphore while a newly
	323	+allocated item has not been linked into this hierarchy. Similarly, it
	324	+will not be able to acquire the semaphore while a dropping item has not
	325	+yet been unlinked. This means that an item's ci_parent pointer will
	326	+never be NULL while the item is in configfs, and that an item will only
	327	+be in its parent's cg_children list for the same duration. This allows
	328	+a subsystem to trust ci_parent and cg_children while they hold the
	329	+semaphore.
	330	+
	331	+[Item Aggregation Via symlink(2)]
	332	+
	333	+configfs provides a simple group via the group->item parent/child
	334	+relationship. Often, however, a larger environment requires aggregation
	335	+outside of the parent/child connection. This is implemented via
	336	+symlink(2).
	337	+
	338	+A config_item may provide the ct_item_ops->allow_link() and
	339	+ct_item_ops->drop_link() methods. If the ->allow_link() method exists,
	340	+symlink(2) may be called with the config_item as the source of the link.
	341	+These links are only allowed between configfs config_items. Any
	342	+symlink(2) attempt outside the configfs filesystem will be denied.
	343	+
	344	+When symlink(2) is called, the source config_item's ->allow_link()
	345	+method is called with itself and a target item. If the source item
	346	+allows linking to target item, it returns 0. A source item may wish to
	347	+reject a link if it only wants links to a certain type of object (say,
	348	+in its own subsystem).
	349	+
	350	+When unlink(2) is called on the symbolic link, the source item is
	351	+notified via the ->drop_link() method. Like the ->drop_item() method,
	352	+this is a void function and cannot return failure. The subsystem is
	353	+responsible for responding to the change.
	354	+
	355	+A config_item cannot be removed while it links to any other item, nor
	356	+can it be removed while an item links to it. Dangling symlinks are not
	357	+allowed in configfs.
	358	+
	359	+[Automatically Created Subgroups]
	360	+
	361	+A new config_group may want to have two types of child config_items.
	362	+While this could be codified by magic names in ->make_item(), it is much
	363	+more explicit to have a method whereby userspace sees this divergence.
	364	+
	365	+Rather than have a group where some items behave differently than
	366	+others, configfs provides a method whereby one or many subgroups are
	367	+automatically created inside the parent at its creation. Thus,
	368	+mkdir("parent) results in "parent", "parent/subgroup1", up through
	369	+"parent/subgroupN". Items of type 1 can now be created in
	370	+"parent/subgroup1", and items of type N can be created in
	371	+"parent/subgroupN".
	372	+
	373	+These automatic subgroups, or default groups, do not preclude other
	374	+children of the parent group. If ct_group_ops->make_group() exists,
	375	+other child groups can be created on the parent group directly.
	376	+
	377	+A configfs subsystem specifies default groups by filling in the
	378	+NULL-terminated array default_groups on the config_group structure.
	379	+Each group in that array is populated in the configfs tree at the same
	380	+time as the parent group. Similarly, they are removed at the same time
	381	+as the parent. No extra notification is provided. When a ->drop_item()
	382	+method call notifies the subsystem the parent group is going away, it
	383	+also means every default group child associated with that parent group.
	384	+
	385	+As a consequence of this, default_groups cannot be removed directly via
	386	+rmdir(2). They also are not considered when rmdir(2) on the parent
	387	+group is checking for children.
	388	+
	389	+[Committable Items]
	390	+
	391	+NOTE: Committable items are currently unimplemented.
	392	+
	393	+Some config_items cannot have a valid initial state. That is, no
	394	+default values can be specified for the item's attributes such that the
	395	+item can do its work. Userspace must configure one or more attributes,
	396	+after which the subsystem can start whatever entity this item
	397	+represents.
	398	+
	399	+Consider the FakeNBD device from above. Without a target address and
	400	+a target device, the subsystem has no idea what block device to import.
	401	+The simple example assumes that the subsystem merely waits until all the
	402	+appropriate attributes are configured, and then connects. This will,
	403	+indeed, work, but now every attribute store must check if the attributes
	404	+are initialized. Every attribute store must fire off the connection if
	405	+that condition is met.
	406	+
	407	+Far better would be an explicit action notifying the subsystem that the
	408	+config_item is ready to go. More importantly, an explicit action allows
	409	+the subsystem to provide feedback as to whether the attibutes are
	410	+initialized in a way that makes sense. configfs provides this as
	411	+committable items.
	412	+
	413	+configfs still uses only normal filesystem operations. An item is
	414	+committed via rename(2). The item is moved from a directory where it
	415	+can be modified to a directory where it cannot.
	416	+
	417	+Any group that provides the ct_group_ops->commit_item() method has
	418	+committable items. When this group appears in configfs, mkdir(2) will
	419	+not work directly in the group. Instead, the group will have two
	420	+subdirectories: "live" and "pending". The "live" directory does not
	421	+support mkdir(2) or rmdir(2) either. It only allows rename(2). The
	422	+"pending" directory does allow mkdir(2) and rmdir(2). An item is
	423	+created in the "pending" directory. Its attributes can be modified at
	424	+will. Userspace commits the item by renaming it into the "live"
	425	+directory. At this point, the subsystem recieves the ->commit_item()
	426	+callback. If all required attributes are filled to satisfaction, the
	427	+method returns zero and the item is moved to the "live" directory.
	428	+
	429	+As rmdir(2) does not work in the "live" directory, an item must be
	430	+shutdown, or "uncommitted". Again, this is done via rename(2), this
	431	+time from the "live" directory back to the "pending" one. The subsystem
	432	+is notified by the ct_group_ops->uncommit_object() method.
	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");
...	...	@@ -554,6 +554,11 @@
554	554	T: git kernel.org:/pub/scm/linux/kernel/git/sfrench/cifs-2.6.git
555	555	S: Supported
556	556
	557	+CONFIGFS
	558	+P: Joel Becker
	559	+M: Joel Becker <joel.becker@oracle.com>
	560	+S: Supported
	561	+
557	562	CIRRUS LOGIC GENERIC FBDEV DRIVER
558	563	P: Jeff Garzik
559	564	M: jgarzik@pobox.com
...	...	@@ -841,6 +841,20 @@
841	841
842	842	If unsure, say N.
843	843
	844	+config CONFIGFS_FS
	845	+ tristate "Userspace-driven configuration filesystem (EXPERIMENTAL)"
	846	+ depends on EXPERIMENTAL
	847	+ help
	848	+ configfs is a ram-based filesystem that provides the converse
	849	+ of sysfs's functionality. Where sysfs is a filesystem-based
	850	+ view of kernel objects, configfs is a filesystem-based manager
	851	+ of kernel objects, or config_items.
	852	+
	853	+ Both sysfs and configfs can and should exist together on the
	854	+ same system. One is not a replacement for the other.
	855	+
	856	+ If unsure, say N.
	857	+
844	858	endmenu
845	859
846	860	menu "Miscellaneous filesystems"
...	...	@@ -101,4 +101,5 @@
101	101	obj-$(CONFIG_HOSTFS) += hostfs/
102	102	obj-$(CONFIG_HPPFS) += hppfs/
103	103	obj-$(CONFIG_DEBUG_FS) += debugfs/
	104	+obj-$(CONFIG_CONFIGFS_FS) += configfs/
	1	+#
	2	+# Makefile for the configfs virtual filesystem
	3	+#
	4	+
	5	+obj-$(CONFIG_CONFIGFS_FS) += configfs.o
	6	+
	7	+configfs-objs := inode.o file.o dir.o symlink.o mount.o item.o
	1	+/* -- mode: c; c-basic-offset:8; --
	2	+ * vim: noexpandtab sw=8 ts=8 sts=0:
	3	+ *
	4	+ * configfs_internal.h - Internal stuff for configfs
	5	+ *
	6	+ * This program is free software; you can redistribute it and/or
	7	+ * modify it under the terms of the GNU General Public
	8	+ * License as published by the Free Software Foundation; either
	9	+ * version 2 of the License, or (at your option) any later version.
	10	+ *
	11	+ * This program is distributed in the hope that it will be useful,
	12	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	+ * General Public License for more details.
	15	+ *
	16	+ * You should have received a copy of the GNU General Public
	17	+ * License along with this program; if not, write to the
	18	+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	19	+ * Boston, MA 021110-1307, USA.
	20	+ *
	21	+ * Based on sysfs:
	22	+ * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
	23	+ *
	24	+ * configfs Copyright (C) 2005 Oracle. All rights reserved.
	25	+ */
	26	+
	27	+#include <linux/slab.h>
	28	+#include <linux/list.h>
	29	+
	30	+struct configfs_dirent {
	31	+ atomic_t s_count;
	32	+ struct list_head s_sibling;
	33	+ struct list_head s_children;
	34	+ struct list_head s_links;
	35	+ void * s_element;
	36	+ int s_type;
	37	+ umode_t s_mode;
	38	+ struct dentry * s_dentry;
	39	+};
	40	+
	41	+#define CONFIGFS_ROOT 0x0001
	42	+#define CONFIGFS_DIR 0x0002
	43	+#define CONFIGFS_ITEM_ATTR 0x0004
	44	+#define CONFIGFS_ITEM_LINK 0x0020
	45	+#define CONFIGFS_USET_DIR 0x0040
	46	+#define CONFIGFS_USET_DEFAULT 0x0080
	47	+#define CONFIGFS_USET_DROPPING 0x0100
	48	+#define CONFIGFS_NOT_PINNED (CONFIGFS_ITEM_ATTR)
	49	+
	50	+extern struct vfsmount * configfs_mount;
	51	+
	52	+extern int configfs_is_root(struct config_item *item);
	53	+
	54	+extern struct inode * configfs_new_inode(mode_t mode);
	55	+extern int configfs_create(struct dentry , int mode, int (init)(struct inode *));
	56	+
	57	+extern int configfs_create_file(struct config_item , const struct configfs_attribute );
	58	+extern int configfs_make_dirent(struct configfs_dirent *,
	59	+ struct dentry , void , umode_t, int);
	60	+
	61	+extern int configfs_add_file(struct dentry , const struct configfs_attribute , int);
	62	+extern void configfs_hash_and_remove(struct dentry * dir, const char * name);
	63	+
	64	+extern const unsigned char * configfs_get_name(struct configfs_dirent *sd);
	65	+extern void configfs_drop_dentry(struct configfs_dirent sd, struct dentry parent);
	66	+
	67	+extern int configfs_pin_fs(void);
	68	+extern void configfs_release_fs(void);
	69	+
	70	+extern struct rw_semaphore configfs_rename_sem;
	71	+extern struct super_block * configfs_sb;
	72	+extern struct file_operations configfs_dir_operations;
	73	+extern struct file_operations configfs_file_operations;
	74	+extern struct file_operations bin_fops;
	75	+extern struct inode_operations configfs_dir_inode_operations;
	76	+extern struct inode_operations configfs_symlink_inode_operations;
	77	+
	78	+extern int configfs_symlink(struct inode dir, struct dentry dentry,
	79	+ const char *symname);
	80	+extern int configfs_unlink(struct inode dir, struct dentry dentry);
	81	+
	82	+struct configfs_symlink {
	83	+ struct list_head sl_list;
	84	+ struct config_item *sl_target;
	85	+};
	86	+
	87	+extern int configfs_create_link(struct configfs_symlink *sl,
	88	+ struct dentry *parent,
	89	+ struct dentry *dentry);
	90	+
	91	+static inline struct config_item * to_item(struct dentry * dentry)
	92	+{
	93	+ struct configfs_dirent * sd = dentry->d_fsdata;
	94	+ return ((struct config_item *) sd->s_element);
	95	+}
	96	+
	97	+static inline struct configfs_attribute * to_attr(struct dentry * dentry)
	98	+{
	99	+ struct configfs_dirent * sd = dentry->d_fsdata;
	100	+ return ((struct configfs_attribute *) sd->s_element);
	101	+}
	102	+
	103	+static inline struct config_item configfs_get_config_item(struct dentry dentry)
	104	+{
	105	+ struct config_item * item = NULL;
	106	+
	107	+ spin_lock(&dcache_lock);
	108	+ if (!d_unhashed(dentry)) {
	109	+ struct configfs_dirent * sd = dentry->d_fsdata;
	110	+ if (sd->s_type & CONFIGFS_ITEM_LINK) {
	111	+ struct configfs_symlink * sl = sd->s_element;
	112	+ item = config_item_get(sl->sl_target);
	113	+ } else
	114	+ item = config_item_get(sd->s_element);
	115	+ }
	116	+ spin_unlock(&dcache_lock);
	117	+
	118	+ return item;
	119	+}
	120	+
	121	+static inline void release_configfs_dirent(struct configfs_dirent * sd)
	122	+{
	123	+ if (!(sd->s_type & CONFIGFS_ROOT))
	124	+ kfree(sd);
	125	+}
	126	+
	127	+static inline struct configfs_dirent * configfs_get(struct configfs_dirent * sd)
	128	+{
	129	+ if (sd) {
	130	+ WARN_ON(!atomic_read(&sd->s_count));
	131	+ atomic_inc(&sd->s_count);
	132	+ }
	133	+ return sd;
	134	+}
	135	+
	136	+static inline void configfs_put(struct configfs_dirent * sd)
	137	+{
	138	+ WARN_ON(!atomic_read(&sd->s_count));
	139	+ if (atomic_dec_and_test(&sd->s_count))
	140	+ release_configfs_dirent(sd);
	141	+}
	1	+/* -- mode: c; c-basic-offset: 8; --
	2	+ * vim: noexpandtab sw=8 ts=8 sts=0:
	3	+ *
	4	+ * file.c - operations for regular (text) files.
	5	+ *
	6	+ * This program is free software; you can redistribute it and/or
	7	+ * modify it under the terms of the GNU General Public
	8	+ * License as published by the Free Software Foundation; either
	9	+ * version 2 of the License, or (at your option) any later version.
	10	+ *
	11	+ * This program is distributed in the hope that it will be useful,
	12	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	+ * General Public License for more details.
	15	+ *
	16	+ * You should have received a copy of the GNU General Public
	17	+ * License along with this program; if not, write to the
	18	+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	19	+ * Boston, MA 021110-1307, USA.
	20	+ *
	21	+ * Based on sysfs:
	22	+ * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
	23	+ *
	24	+ * configfs Copyright (C) 2005 Oracle. All rights reserved.
	25	+ */
	26	+
	27	+#include <linux/fs.h>
	28	+#include <linux/module.h>
	29	+#include <linux/dnotify.h>
	30	+#include <linux/slab.h>
	31	+#include <asm/uaccess.h>
	32	+#include <asm/semaphore.h>
	33	+
	34	+#include <linux/configfs.h>
	35	+#include "configfs_internal.h"
	36	+
	37	+
	38	+struct configfs_buffer {
	39	+ size_t count;
	40	+ loff_t pos;
	41	+ char * page;
	42	+ struct configfs_item_operations * ops;
	43	+ struct semaphore sem;
	44	+ int needs_read_fill;
	45	+};
	46	+
	47	+
	48	+/**
	49	+ * fill_read_buffer - allocate and fill buffer from item.
	50	+ * @dentry: dentry pointer.
	51	+ * @buffer: data buffer for file.
	52	+ *
	53	+ * Allocate @buffer->page, if it hasn't been already, then call the
	54	+ * config_item's show() method to fill the buffer with this attribute's
	55	+ * data.
	56	+ * This is called only once, on the file's first read.
	57	+ */
	58	+static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buffer)
	59	+{
	60	+ struct configfs_attribute * attr = to_attr(dentry);
	61	+ struct config_item * item = to_item(dentry->d_parent);
	62	+ struct configfs_item_operations * ops = buffer->ops;
	63	+ int ret = 0;
	64	+ ssize_t count;
	65	+
	66	+ if (!buffer->page)
	67	+ buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
	68	+ if (!buffer->page)
	69	+ return -ENOMEM;
	70	+
	71	+ count = ops->show_attribute(item,attr,buffer->page);
	72	+ buffer->needs_read_fill = 0;
	73	+ BUG_ON(count > (ssize_t)PAGE_SIZE);
	74	+ if (count >= 0)
	75	+ buffer->count = count;
	76	+ else
	77	+ ret = count;
	78	+ return ret;
	79	+}
	80	+
	81	+
	82	+/**
	83	+ * flush_read_buffer - push buffer to userspace.
	84	+ * @buffer: data buffer for file.
	85	+ * @userbuf: user-passed buffer.
	86	+ * @count: number of bytes requested.
	87	+ * @ppos: file position.
	88	+ *
	89	+ * Copy the buffer we filled in fill_read_buffer() to userspace.
	90	+ * This is done at the reader's leisure, copying and advancing
	91	+ * the amount they specify each time.
	92	+ * This may be called continuously until the buffer is empty.
	93	+ */
	94	+static int flush_read_buffer(struct configfs_buffer * buffer, char __user * buf,
	95	+ size_t count, loff_t * ppos)
	96	+{
	97	+ int error;
	98	+
	99	+ if (*ppos > buffer->count)
	100	+ return 0;
	101	+
	102	+ if (count > (buffer->count - *ppos))
	103	+ count = buffer->count - *ppos;
	104	+
	105	+ error = copy_to_user(buf,buffer->page + *ppos,count);
	106	+ if (!error)
	107	+ *ppos += count;
	108	+ return error ? -EFAULT : count;
	109	+}
	110	+
	111	+/**
	112	+ * configfs_read_file - read an attribute.
	113	+ * @file: file pointer.
	114	+ * @buf: buffer to fill.
	115	+ * @count: number of bytes to read.
	116	+ * @ppos: starting offset in file.
	117	+ *
	118	+ * Userspace wants to read an attribute file. The attribute descriptor
	119	+ * is in the file's ->d_fsdata. The target item is in the directory's
	120	+ * ->d_fsdata.
	121	+ *
	122	+ * We call fill_read_buffer() to allocate and fill the buffer from the
	123	+ * item's show() method exactly once (if the read is happening from
	124	+ * the beginning of the file). That should fill the entire buffer with
	125	+ * all the data the item has to offer for that attribute.
	126	+ * We then call flush_read_buffer() to copy the buffer to userspace
	127	+ * in the increments specified.
	128	+ */
	129	+
	130	+static ssize_t
	131	+configfs_read_file(struct file file, char __user buf, size_t count, loff_t *ppos)
	132	+{
	133	+ struct configfs_buffer * buffer = file->private_data;
	134	+ ssize_t retval = 0;
	135	+
	136	+ down(&buffer->sem);
	137	+ if (buffer->needs_read_fill) {
	138	+ if ((retval = fill_read_buffer(file->f_dentry,buffer)))
	139	+ goto out;
	140	+ }
	141	+ pr_debug("%s: count = %d, ppos = %lld, buf = %s\n",
	142	+ __FUNCTION__,count,*ppos,buffer->page);
	143	+ retval = flush_read_buffer(buffer,buf,count,ppos);
	144	+out:
	145	+ up(&buffer->sem);
	146	+ return retval;
	147	+}
	148	+
	149	+
	150	+/**
	151	+ * fill_write_buffer - copy buffer from userspace.
	152	+ * @buffer: data buffer for file.
	153	+ * @userbuf: data from user.
	154	+ * @count: number of bytes in @userbuf.
	155	+ *
	156	+ * Allocate @buffer->page if it hasn't been already, then
	157	+ * copy the user-supplied buffer into it.
	158	+ */
	159	+
	160	+static int
	161	+fill_write_buffer(struct configfs_buffer * buffer, const char __user * buf, size_t count)
	162	+{
	163	+ int error;
	164	+
	165	+ if (!buffer->page)
	166	+ buffer->page = (char *)get_zeroed_page(GFP_KERNEL);
	167	+ if (!buffer->page)
	168	+ return -ENOMEM;
	169	+
	170	+ if (count > PAGE_SIZE)
	171	+ count = PAGE_SIZE;
	172	+ error = copy_from_user(buffer->page,buf,count);
	173	+ buffer->needs_read_fill = 1;
	174	+ return error ? -EFAULT : count;
	175	+}
	176	+
	177	+
	178	+/**
	179	+ * flush_write_buffer - push buffer to config_item.
	180	+ * @file: file pointer.
	181	+ * @buffer: data buffer for file.
	182	+ *
	183	+ * Get the correct pointers for the config_item and the attribute we're
	184	+ * dealing with, then call the store() method for the attribute,
	185	+ * passing the buffer that we acquired in fill_write_buffer().
	186	+ */
	187	+
	188	+static int
	189	+flush_write_buffer(struct dentry * dentry, struct configfs_buffer * buffer, size_t count)
	190	+{
	191	+ struct configfs_attribute * attr = to_attr(dentry);
	192	+ struct config_item * item = to_item(dentry->d_parent);
	193	+ struct configfs_item_operations * ops = buffer->ops;
	194	+
	195	+ return ops->store_attribute(item,attr,buffer->page,count);
	196	+}
	197	+
	198	+
	199	+/**
	200	+ * configfs_write_file - write an attribute.
	201	+ * @file: file pointer
	202	+ * @buf: data to write
	203	+ * @count: number of bytes
	204	+ * @ppos: starting offset
	205	+ *
	206	+ * Similar to configfs_read_file(), though working in the opposite direction.
	207	+ * We allocate and fill the data from the user in fill_write_buffer(),
	208	+ * then push it to the config_item in flush_write_buffer().
	209	+ * There is no easy way for us to know if userspace is only doing a partial
	210	+ * write, so we don't support them. We expect the entire buffer to come
	211	+ * on the first write.
	212	+ * Hint: if you're writing a value, first read the file, modify only the
	213	+ * the value you're changing, then write entire buffer back.
	214	+ */
	215	+
	216	+static ssize_t
	217	+configfs_write_file(struct file file, const char __user buf, size_t count, loff_t *ppos)
	218	+{
	219	+ struct configfs_buffer * buffer = file->private_data;
	220	+
	221	+ down(&buffer->sem);
	222	+ count = fill_write_buffer(buffer,buf,count);
	223	+ if (count > 0)
	224	+ count = flush_write_buffer(file->f_dentry,buffer,count);
	225	+ if (count > 0)
	226	+ *ppos += count;
	227	+ up(&buffer->sem);
	228	+ return count;
	229	+}
	230	+
	231	+static int check_perm(struct inode * inode, struct file * file)
	232	+{
	233	+ struct config_item *item = configfs_get_config_item(file->f_dentry->d_parent);
	234	+ struct configfs_attribute * attr = to_attr(file->f_dentry);
	235	+ struct configfs_buffer * buffer;
	236	+ struct configfs_item_operations * ops = NULL;
	237	+ int error = 0;
	238	+
	239	+ if (!item \|\| !attr)
	240	+ goto Einval;
	241	+
	242	+ /* Grab the module reference for this attribute if we have one */
	243	+ if (!try_module_get(attr->ca_owner)) {
	244	+ error = -ENODEV;
	245	+ goto Done;
	246	+ }
	247	+
	248	+ if (item->ci_type)
	249	+ ops = item->ci_type->ct_item_ops;
	250	+ else
	251	+ goto Eaccess;
	252	+
	253	+ /* File needs write support.
	254	+ * The inode's perms must say it's ok,
	255	+ * and we must have a store method.
	256	+ */
	257	+ if (file->f_mode & FMODE_WRITE) {
	258	+
	259	+ if (!(inode->i_mode & S_IWUGO) \|\| !ops->store_attribute)
	260	+ goto Eaccess;
	261	+
	262	+ }
	263	+
	264	+ /* File needs read support.
	265	+ * The inode's perms must say it's ok, and we there
	266	+ * must be a show method for it.
	267	+ */
	268	+ if (file->f_mode & FMODE_READ) {
	269	+ if (!(inode->i_mode & S_IRUGO) \|\| !ops->show_attribute)
	270	+ goto Eaccess;
	271	+ }
	272	+
	273	+ /* No error? Great, allocate a buffer for the file, and store it
	274	+ * it in file->private_data for easy access.
	275	+ */
	276	+ buffer = kmalloc(sizeof(struct configfs_buffer),GFP_KERNEL);
	277	+ if (buffer) {
	278	+ memset(buffer,0,sizeof(struct configfs_buffer));
	279	+ init_MUTEX(&buffer->sem);
	280	+ buffer->needs_read_fill = 1;
	281	+ buffer->ops = ops;
	282	+ file->private_data = buffer;
	283	+ } else
	284	+ error = -ENOMEM;
	285	+ goto Done;
	286	+
	287	+ Einval:
	288	+ error = -EINVAL;
	289	+ goto Done;
	290	+ Eaccess:
	291	+ error = -EACCES;
	292	+ module_put(attr->ca_owner);
	293	+ Done:
	294	+ if (error && item)
	295	+ config_item_put(item);
	296	+ return error;
	297	+}
	298	+
	299	+static int configfs_open_file(struct inode * inode, struct file * filp)
	300	+{
	301	+ return check_perm(inode,filp);
	302	+}
	303	+
	304	+static int configfs_release(struct inode * inode, struct file * filp)
	305	+{
	306	+ struct config_item * item = to_item(filp->f_dentry->d_parent);
	307	+ struct configfs_attribute * attr = to_attr(filp->f_dentry);
	308	+ struct module * owner = attr->ca_owner;
	309	+ struct configfs_buffer * buffer = filp->private_data;
	310	+
	311	+ if (item)
	312	+ config_item_put(item);
	313	+ /* After this point, attr should not be accessed. */
	314	+ module_put(owner);
	315	+
	316	+ if (buffer) {
	317	+ if (buffer->page)
	318	+ free_page((unsigned long)buffer->page);
	319	+ kfree(buffer);
	320	+ }
	321	+ return 0;
	322	+}
	323	+
	324	+struct file_operations configfs_file_operations = {
	325	+ .read = configfs_read_file,
	326	+ .write = configfs_write_file,
	327	+ .llseek = generic_file_llseek,
	328	+ .open = configfs_open_file,
	329	+ .release = configfs_release,
	330	+};
	331	+
	332	+
	333	+int configfs_add_file(struct dentry * dir, const struct configfs_attribute * attr, int type)
	334	+{
	335	+ struct configfs_dirent * parent_sd = dir->d_fsdata;
	336	+ umode_t mode = (attr->ca_mode & S_IALLUGO) \| S_IFREG;
	337	+ int error = 0;
	338	+
	339	+ down(&dir->d_inode->i_sem);
	340	+ error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode, type);
	341	+ up(&dir->d_inode->i_sem);
	342	+
	343	+ return error;
	344	+}
	345	+
	346	+
	347	+/**
	348	+ * configfs_create_file - create an attribute file for an item.
	349	+ * @item: item we're creating for.
	350	+ * @attr: atrribute descriptor.
	351	+ */
	352	+
	353	+int configfs_create_file(struct config_item * item, const struct configfs_attribute * attr)
	354	+{
	355	+ BUG_ON(!item \|\| !item->ci_dentry \|\| !attr);
	356	+
	357	+ return configfs_add_file(item->ci_dentry, attr,
	358	+ CONFIGFS_ITEM_ATTR);
	359	+}
	1	+/* -- mode: c; c-basic-offset: 8; --
	2	+ * vim: noexpandtab sw=8 ts=8 sts=0:
	3	+ *
	4	+ * inode.c - basic inode and dentry operations.
	5	+ *
	6	+ * This program is free software; you can redistribute it and/or
	7	+ * modify it under the terms of the GNU General Public
	8	+ * License as published by the Free Software Foundation; either
	9	+ * version 2 of the License, or (at your option) any later version.
	10	+ *
	11	+ * This program is distributed in the hope that it will be useful,
	12	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	+ * General Public License for more details.
	15	+ *
	16	+ * You should have received a copy of the GNU General Public
	17	+ * License along with this program; if not, write to the
	18	+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	19	+ * Boston, MA 021110-1307, USA.
	20	+ *
	21	+ * Based on sysfs:
	22	+ * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
	23	+ *
	24	+ * configfs Copyright (C) 2005 Oracle. All rights reserved.
	25	+ *
	26	+ * Please see Documentation/filesystems/configfs.txt for more information.
	27	+ */
	28	+
	29	+#undef DEBUG
	30	+
	31	+#include <linux/pagemap.h>
	32	+#include <linux/namei.h>
	33	+#include <linux/backing-dev.h>
	34	+
	35	+#include <linux/configfs.h>
	36	+#include "configfs_internal.h"
	37	+
	38	+extern struct super_block * configfs_sb;
	39	+
	40	+static struct address_space_operations configfs_aops = {
	41	+ .readpage = simple_readpage,
	42	+ .prepare_write = simple_prepare_write,
	43	+ .commit_write = simple_commit_write
	44	+};
	45	+
	46	+static struct backing_dev_info configfs_backing_dev_info = {
	47	+ .ra_pages = 0, /* No readahead */
	48	+ .capabilities = BDI_CAP_NO_ACCT_DIRTY \| BDI_CAP_NO_WRITEBACK,
	49	+};
	50	+
	51	+struct inode * configfs_new_inode(mode_t mode)
	52	+{
	53	+ struct inode * inode = new_inode(configfs_sb);
	54	+ if (inode) {
	55	+ inode->i_mode = mode;
	56	+ inode->i_uid = 0;
	57	+ inode->i_gid = 0;
	58	+ inode->i_blksize = PAGE_CACHE_SIZE;
	59	+ inode->i_blocks = 0;
	60	+ inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	61	+ inode->i_mapping->a_ops = &configfs_aops;
	62	+ inode->i_mapping->backing_dev_info = &configfs_backing_dev_info;
	63	+ }
	64	+ return inode;
	65	+}
	66	+
	67	+int configfs_create(struct dentry * dentry, int mode, int (init)(struct inode ))
	68	+{
	69	+ int error = 0;
	70	+ struct inode * inode = NULL;
	71	+ if (dentry) {
	72	+ if (!dentry->d_inode) {
	73	+ if ((inode = configfs_new_inode(mode))) {
	74	+ if (dentry->d_parent && dentry->d_parent->d_inode) {
	75	+ struct inode *p_inode = dentry->d_parent->d_inode;
	76	+ p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
	77	+ }
	78	+ goto Proceed;
	79	+ }
	80	+ else
	81	+ error = -ENOMEM;
	82	+ } else
	83	+ error = -EEXIST;
	84	+ } else
	85	+ error = -ENOENT;
	86	+ goto Done;
	87	+
	88	+ Proceed:
	89	+ if (init)
	90	+ error = init(inode);
	91	+ if (!error) {
	92	+ d_instantiate(dentry, inode);
	93	+ if (S_ISDIR(mode) \|\| S_ISLNK(mode))
	94	+ dget(dentry); /* pin link and directory dentries in core */
	95	+ } else
	96	+ iput(inode);
	97	+ Done:
	98	+ return error;
	99	+}
	100	+
	101	+/*
	102	+ * Get the name for corresponding element represented by the given configfs_dirent
	103	+ */
	104	+const unsigned char * configfs_get_name(struct configfs_dirent *sd)
	105	+{
	106	+ struct attribute * attr;
	107	+
	108	+ if (!sd \|\| !sd->s_element)
	109	+ BUG();
	110	+
	111	+ /* These always have a dentry, so use that */
	112	+ if (sd->s_type & (CONFIGFS_DIR \| CONFIGFS_ITEM_LINK))
	113	+ return sd->s_dentry->d_name.name;
	114	+
	115	+ if (sd->s_type & CONFIGFS_ITEM_ATTR) {
	116	+ attr = sd->s_element;
	117	+ return attr->name;
	118	+ }
	119	+ return NULL;
	120	+}
	121	+
	122	+
	123	+/*
	124	+ * Unhashes the dentry corresponding to given configfs_dirent
	125	+ * Called with parent inode's i_sem held.
	126	+ */
	127	+void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent)
	128	+{
	129	+ struct dentry * dentry = sd->s_dentry;
	130	+
	131	+ if (dentry) {
	132	+ spin_lock(&dcache_lock);
	133	+ if (!(d_unhashed(dentry) && dentry->d_inode)) {
	134	+ dget_locked(dentry);
	135	+ __d_drop(dentry);
	136	+ spin_unlock(&dcache_lock);
	137	+ simple_unlink(parent->d_inode, dentry);
	138	+ } else
	139	+ spin_unlock(&dcache_lock);
	140	+ }
	141	+}
	142	+
	143	+void configfs_hash_and_remove(struct dentry * dir, const char * name)
	144	+{
	145	+ struct configfs_dirent * sd;
	146	+ struct configfs_dirent * parent_sd = dir->d_fsdata;
	147	+
	148	+ down(&dir->d_inode->i_sem);
	149	+ list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
	150	+ if (!sd->s_element)
	151	+ continue;
	152	+ if (!strcmp(configfs_get_name(sd), name)) {
	153	+ list_del_init(&sd->s_sibling);
	154	+ configfs_drop_dentry(sd, dir);
	155	+ configfs_put(sd);
	156	+ break;
	157	+ }
	158	+ }
	159	+ up(&dir->d_inode->i_sem);
	160	+}