Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfasheh/ocfs2

		struct config_group *(*make_group)(struct config_group *group,

						   const char *name);

		int (*commit_item)(struct config_item *item);

		void (*disconnect_notify)(struct config_group *group,

					  struct config_item *item);

		void (*drop_item)(struct config_group *group,

				  struct config_item *item);

	};

for the item to actually disappear from the subsystem's usage.  But it

is gone from configfs.

When drop_item() is called, the item's linkage has already been torn

down.  It no longer has a reference on its parent and has no place in

the item hierarchy.  If a client needs to do some cleanup before this

teardown happens, the subsystem can implement the

ct_group_ops->disconnect_notify() method.  The method is called after

configfs has removed the item from the filesystem view but before the

item is removed from its parent group.  Like drop_item(),

disconnect_notify() is void and cannot fail.  Client subsystems should

not drop any references here, as they still must do it in drop_item().

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

	struct configfs_subsystem {

		struct config_group	su_group;

		struct semaphore	su_sem;

		struct mutex		su_mutex;

	};

	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.

	A subsystem consists of a toplevel config_group and a mutex.

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.

initialized the mutex.

	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.

shows a trivial object displaying and storing an attribute, and a simple

group creating and destroying these children.

[Hierarchy Navigation and the Subsystem Semaphore]

[Hierarchy Navigation and the Subsystem Mutex]

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

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

management of the hierarchy, so configfs uses the subsystem mutex to

protect modifications.  Whenever a subsystem wants to navigate the

hierarchy, it must do so under the protection of the subsystem

semaphore.

mutex.

A subsystem will be prevented from acquiring the semaphore while a newly

A subsystem will be prevented from acquiring the mutex 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

will not be able to acquire the mutex 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.

mutex.

[Item Aggregation Via symlink(2)]

rmdir(2).  They also are not considered when rmdir(2) on the parent

group is checking for children.

[Dependant Subsystems]

Sometimes other drivers depend on particular configfs items.  For

example, ocfs2 mounts depend on a heartbeat region item.  If that

region item is removed with rmdir(2), the ocfs2 mount must BUG or go

readonly.  Not happy.

configfs provides two additional API calls: configfs_depend_item() and

configfs_undepend_item().  A client driver can call

configfs_depend_item() on an existing item to tell configfs that it is

depended on.  configfs will then return -EBUSY from rmdir(2) for that

item.  When the item is no longer depended on, the client driver calls

configfs_undepend_item() on it.

These API cannot be called underneath any configfs callbacks, as

they will conflict.  They can block and allocate.  A client driver

probably shouldn't calling them of its own gumption.  Rather it should

be providing an API that external subsystems call.

How does this work?  Imagine the ocfs2 mount process.  When it mounts,

it asks for a heartbeat region item.  This is done via a call into the

heartbeat code.  Inside the heartbeat code, the region item is looked

up.  Here, the heartbeat code calls configfs_depend_item().  If it

succeeds, then heartbeat knows the region is safe to give to ocfs2.

If it fails, it was being torn down anyway, and heartbeat can gracefully

pass up an error.

[Committable Items]

NOTE: Committable items are currently unimplemented.

		subsys = example_subsys[i];

		config_group_init(&subsys->su_group);

		init_MUTEX(&subsys->su_sem);

		mutex_init(&subsys->su_mutex);

		ret = configfs_register_subsystem(subsys);

		if (ret) {

			printk(KERN_ERR "Error %d while registering subsystem %s\n",

struct configfs_dirent {

	atomic_t		s_count;

	int			s_dependent_count;

	struct list_head	s_sibling;

	struct list_head	s_children;

	struct list_head	s_links;

			/* Mark that we've taken i_mutex */

			sd->s_type |= CONFIGFS_USET_DROPPING;

			/*

			 * Yup, recursive.  If there's a problem, blame

			 * deep nesting of default_groups

			 */

			ret = configfs_detach_prep(sd->s_dentry);

			if (!ret)

				continue;

/*

 * All of link_obj/unlink_obj/link_group/unlink_group require that

 * subsys->su_sem is held.

 * subsys->su_mutex is held.

 */

static void unlink_obj(struct config_item *item)

	configfs_detach_item(item);

}

/*

 * After the item has been detached from the filesystem view, we are

 * ready to tear it out of the hierarchy.  Notify the client before

 * we do that so they can perform any cleanup that requires

 * navigating the hierarchy.  A client does not need to provide this

 * callback.  The subsystem semaphore MUST be held by the caller, and

 * references must be valid for both items.  It also assumes the

 * caller has validated ci_type.

 */

static void client_disconnect_notify(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->disconnect_notify)

		type->ct_group_ops->disconnect_notify(to_config_group(parent_item),

						      item);

}

/*

 * Drop the initial reference from make_item()/make_group()

 * This function assumes that reference is held on item

		config_item_put(item);

}

#ifdef DEBUG

static void configfs_dump_one(struct configfs_dirent *sd, int level)

{

	printk(KERN_INFO "%*s\"%s\":\n", level, " ", configfs_get_name(sd));

#define type_print(_type) if (sd->s_type & _type) printk(KERN_INFO "%*s %s\n", level, " ", #_type);

	type_print(CONFIGFS_ROOT);

	type_print(CONFIGFS_DIR);

	type_print(CONFIGFS_ITEM_ATTR);

	type_print(CONFIGFS_ITEM_LINK);

	type_print(CONFIGFS_USET_DIR);

	type_print(CONFIGFS_USET_DEFAULT);

	type_print(CONFIGFS_USET_DROPPING);

#undef type_print

}

static int configfs_dump(struct configfs_dirent *sd, int level)

{

	struct configfs_dirent *child_sd;

	int ret = 0;

	configfs_dump_one(sd, level);

	if (!(sd->s_type & (CONFIGFS_DIR|CONFIGFS_ROOT)))

		return 0;

	list_for_each_entry(child_sd, &sd->s_children, s_sibling) {

		ret = configfs_dump(child_sd, level + 2);

		if (ret)

			break;

	}

	return ret;

}

#endif

/*

 * configfs_depend_item() and configfs_undepend_item()

 *

 * WARNING: Do not call these from a configfs callback!

 *

 * This describes these functions and their helpers.

 *

 * Allow another kernel system to depend on a config_item.  If this

 * happens, the item cannot go away until the dependant can live without

 * it.  The idea is to give client modules as simple an interface as

 * possible.  When a system asks them to depend on an item, they just

 * call configfs_depend_item().  If the item is live and the client

 * driver is in good shape, we'll happily do the work for them.

 *

 * Why is the locking complex?  Because configfs uses the VFS to handle

 * all locking, but this function is called outside the normal

 * VFS->configfs path.  So it must take VFS locks to prevent the

 * VFS->configfs stuff (configfs_mkdir(), configfs_rmdir(), etc).  This is

 * why you can't call these functions underneath configfs callbacks.

 *

 * Note, btw, that this can be called at *any* time, even when a configfs

 * subsystem isn't registered, or when configfs is loading or unloading.

 * Just like configfs_register_subsystem().  So we take the same

 * precautions.  We pin the filesystem.  We lock each i_mutex _in_order_

 * on our way down the tree.  If we can find the target item in the

 * configfs tree, it must be part of the subsystem tree as well, so we

 * do not need the subsystem semaphore.  Holding the i_mutex chain locks

 * out mkdir() and rmdir(), who might be racing us.

 */

/*

 * configfs_depend_prep()

 *

 * Only subdirectories count here.  Files (CONFIGFS_NOT_PINNED) are

 * attributes.  This is similar but not the same to configfs_detach_prep().

 * Note that configfs_detach_prep() expects the parent to be locked when it

 * is called, but we lock the parent *inside* configfs_depend_prep().  We

 * do that so we can unlock it if we find nothing.

 *

 * Here we do a depth-first search of the dentry hierarchy looking for

 * our object.  We take i_mutex on each step of the way down.  IT IS

 * ESSENTIAL THAT i_mutex LOCKING IS ORDERED.  If we come back up a branch,

 * we'll drop the i_mutex.

 *

 * If the target is not found, -ENOENT is bubbled up and we have released

 * all locks.  If the target was found, the locks will be cleared by

 * configfs_depend_rollback().

 *

 * This adds a requirement that all config_items be unique!

 *

 * This is recursive because the locking traversal is tricky.  There isn't

 * much on the stack, though, so folks that need this function - be careful

 * about your stack!  Patches will be accepted to make it iterative.

 */

static int configfs_depend_prep(struct dentry *origin,

				struct config_item *target)

{

	struct configfs_dirent *child_sd, *sd = origin->d_fsdata;

	int ret = 0;

	BUG_ON(!origin || !sd);

	/* Lock this guy on the way down */

	mutex_lock(&sd->s_dentry->d_inode->i_mutex);

	if (sd->s_element == target)  /* Boo-yah */

		goto out;

	list_for_each_entry(child_sd, &sd->s_children, s_sibling) {

		if (child_sd->s_type & CONFIGFS_DIR) {

			ret = configfs_depend_prep(child_sd->s_dentry,

						   target);

			if (!ret)

				goto out;  /* Child path boo-yah */

		}

	}

	/* We looped all our children and didn't find target */

	mutex_unlock(&sd->s_dentry->d_inode->i_mutex);

	ret = -ENOENT;

out:

	return ret;

}

/*

 * This is ONLY called if configfs_depend_prep() did its job.  So we can

 * trust the entire path from item back up to origin.

 *

 * We walk backwards from item, unlocking each i_mutex.  We finish by

 * unlocking origin.

 */

static void configfs_depend_rollback(struct dentry *origin,

				     struct config_item *item)

{

	struct dentry *dentry = item->ci_dentry;

	while (dentry != origin) {

		mutex_unlock(&dentry->d_inode->i_mutex);

		dentry = dentry->d_parent;

	}

	mutex_unlock(&origin->d_inode->i_mutex);

}

int configfs_depend_item(struct configfs_subsystem *subsys,

			 struct config_item *target)

{

	int ret;

	struct configfs_dirent *p, *root_sd, *subsys_sd = NULL;

	struct config_item *s_item = &subsys->su_group.cg_item;

	/*

	 * Pin the configfs filesystem.  This means we can safely access

	 * the root of the configfs filesystem.

	 */

	ret = configfs_pin_fs();

	if (ret)

		return ret;

	/*

	 * Next, lock the root directory.  We're going to check that the

	 * subsystem is really registered, and so we need to lock out

	 * configfs_[un]register_subsystem().

	 */

	mutex_lock(&configfs_sb->s_root->d_inode->i_mutex);

	root_sd = configfs_sb->s_root->d_fsdata;

	list_for_each_entry(p, &root_sd->s_children, s_sibling) {

		if (p->s_type & CONFIGFS_DIR) {

			if (p->s_element == s_item) {

				subsys_sd = p;

				break;

			}

		}

	}

	if (!subsys_sd) {

		ret = -ENOENT;

		goto out_unlock_fs;

	}

	/* Ok, now we can trust subsys/s_item */

	/* Scan the tree, locking i_mutex recursively, return 0 if found */

	ret = configfs_depend_prep(subsys_sd->s_dentry, target);

	if (ret)

		goto out_unlock_fs;

	/* We hold all i_mutexes from the subsystem down to the target */

	p = target->ci_dentry->d_fsdata;

	p->s_dependent_count += 1;

	configfs_depend_rollback(subsys_sd->s_dentry, target);

out_unlock_fs:

	mutex_unlock(&configfs_sb->s_root->d_inode->i_mutex);

	/*

	 * If we succeeded, the fs is pinned via other methods.  If not,

	 * we're done with it anyway.  So release_fs() is always right.

	 */

	configfs_release_fs();

	return ret;

}

EXPORT_SYMBOL(configfs_depend_item);

/*

 * Release the dependent linkage.  This is much simpler than

 * configfs_depend_item() because we know that that the client driver is

 * pinned, thus the subsystem is pinned, and therefore configfs is pinned.

 */

void configfs_undepend_item(struct configfs_subsystem *subsys,

			    struct config_item *target)

{

	struct configfs_dirent *sd;

	/*

	 * Since we can trust everything is pinned, we just need i_mutex

	 * on the item.

	 */

	mutex_lock(&target->ci_dentry->d_inode->i_mutex);

	sd = target->ci_dentry->d_fsdata;

	BUG_ON(sd->s_dependent_count < 1);

	sd->s_dependent_count -= 1;

	/*

	 * After this unlock, we cannot trust the item to stay alive!

	 * DO NOT REFERENCE item after this unlock.

	 */

	mutex_unlock(&target->ci_dentry->d_inode->i_mutex);

}

EXPORT_SYMBOL(configfs_undepend_item);

static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)

{

	snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name);

	down(&subsys->su_sem);

	mutex_lock(&subsys->su_mutex);

	group = NULL;

	item = NULL;

	if (type->ct_group_ops->make_group) {

		if (item)

			link_obj(parent_item, item);

	}

	up(&subsys->su_sem);

	mutex_unlock(&subsys->su_mutex);

	kfree(name);

	if (!item) {

out_unlink:

	if (ret) {

		/* Tear down everything we built up */

		down(&subsys->su_sem);

		mutex_lock(&subsys->su_mutex);

		client_disconnect_notify(parent_item, item);

		if (group)

			unlink_group(group);

		else

			unlink_obj(item);

		client_drop_item(parent_item, item);

		up(&subsys->su_sem);

		mutex_unlock(&subsys->su_mutex);

		if (module_got)

			module_put(owner);

	if (sd->s_type & CONFIGFS_USET_DEFAULT)

		return -EPERM;

	/*

	 * Here's where we check for dependents.  We're protected by

	 * i_mutex.

	 */

	if (sd->s_dependent_count)

		return -EBUSY;

	/* Get a working ref until we have the child */

	parent_item = configfs_get_config_item(dentry->d_parent);

	subsys = to_config_group(parent_item)->cg_subsys;

	if (sd->s_type & CONFIGFS_USET_DIR) {

		configfs_detach_group(item);

		down(&subsys->su_sem);

		mutex_lock(&subsys->su_mutex);

		client_disconnect_notify(parent_item, item);

		unlink_group(to_config_group(item));

	} else {

		configfs_detach_item(item);

		down(&subsys->su_sem);

		mutex_lock(&subsys->su_mutex);

		client_disconnect_notify(parent_item, item);

		unlink_obj(item);

	}

	client_drop_item(parent_item, item);

	up(&subsys->su_sem);

	mutex_unlock(&subsys->su_mutex);

	/* Drop our reference from above */

	config_item_put(item);

#include <linux/fs.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/mutex.h>

#include <asm/uaccess.h>

#include <asm/semaphore.h>

#include <linux/configfs.h>

#include "configfs_internal.h"

/*

 * A simple attribute can only be 4096 characters.  Why 4k?  Because the

 * original code limited it to PAGE_SIZE.  That's a bad idea, though,

 * because an attribute of 16k on ia64 won't work on x86.  So we limit to

 * 4k, our minimum common page size.

 */

#define SIMPLE_ATTR_SIZE 4096

struct configfs_buffer {

	size_t			count;

	loff_t			pos;

	char			* page;

	struct configfs_item_operations	* ops;

	struct semaphore	sem;

	struct mutex		mutex;

	int			needs_read_fill;

};

	count = ops->show_attribute(item,attr,buffer->page);

	buffer->needs_read_fill = 0;

	BUG_ON(count > (ssize_t)PAGE_SIZE);

	BUG_ON(count > (ssize_t)SIMPLE_ATTR_SIZE);

	if (count >= 0)

		buffer->count = count;

	else

	struct configfs_buffer * buffer = file->private_data;

	ssize_t retval = 0;

	down(&buffer->sem);

	mutex_lock(&buffer->mutex);

	if (buffer->needs_read_fill) {

		if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))

			goto out;

	retval = simple_read_from_buffer(buf, count, ppos, buffer->page,

					 buffer->count);

out:

	up(&buffer->sem);

	mutex_unlock(&buffer->mutex);

	return retval;

}

	if (!buffer->page)

		return -ENOMEM;

	if (count >= PAGE_SIZE)

		count = PAGE_SIZE - 1;

	if (count >= SIMPLE_ATTR_SIZE)

		count = SIMPLE_ATTR_SIZE - 1;

	error = copy_from_user(buffer->page,buf,count);

	buffer->needs_read_fill = 1;

	/* if buf is assumed to contain a string, terminate it by \0,

	struct configfs_buffer * buffer = file->private_data;

	ssize_t len;

	down(&buffer->sem);

	mutex_lock(&buffer->mutex);

	len = fill_write_buffer(buffer, buf, count);

	if (len > 0)

		len = flush_write_buffer(file->f_path.dentry, buffer, count);

	if (len > 0)

		*ppos += len;

	up(&buffer->sem);

	mutex_unlock(&buffer->mutex);

	return len;

}

		error = -ENOMEM;

		goto Enomem;

	}

	init_MUTEX(&buffer->sem);

	mutex_init(&buffer->mutex);

	buffer->needs_read_fill = 1;

	buffer->ops = ops;

	file->private_data = buffer;

	if (buffer) {

		if (buffer->page)

			free_page((unsigned long)buffer->page);

		mutex_destroy(&buffer->mutex);

		kfree(buffer);

	}

	return 0;