drivers/edac: fix edac_device sysfs completion code

 */

struct mem_ctl_info {

	struct list_head link;	/* for global list of mem_ctl_info structs */

	struct module *owner;	/* Module owner of this control struct */

	unsigned long mtype_cap;	/* memory types supported by mc */

	unsigned long edac_ctl_cap;	/* Mem controller EDAC capabilities */

	unsigned long edac_cap;	/* configuration capabilities - this is

	/* edac sysfs device control */

	struct kobject kobj;

	struct completion kobj_complete;

};

/* device instance control structure */

	/* edac sysfs device control */

	struct kobject kobj;

	struct completion kobj_complete;

};

	/* for global list of edac_device_ctl_info structs */

	struct list_head link;

	struct module *owner;	/* Module owner of this control struct */

	int dev_idx;

	/* Per instance controls for this edac_device */

	 * NMI handlers may be traversing list

	 */

	struct rcu_head rcu;

	struct completion complete;

	struct completion removal_complete;

	/* sysfs top name under 'edac' directory

	 * and instance name:

	 * device this structure controls

	 */

	struct kobject kobj;

	struct completion kobj_complete;

};

/* To get from the instance's wq to the beginning of the ctl structure */

}

#endif				/* CONFIG_EDAC_DEBUG */

/*

 * edac_device_alloc_ctl_info()

 *	Allocate a new edac device control info structure

	unsigned count;

	unsigned instance, block, attr;

	void *pvt;

	int err;

	debugf1("%s() instances=%d blocks=%d\n",

		__func__, nr_instances, nr_blocks);

	/* Mark this instance as merely ALLOCATED */

	dev_ctl->op_state = OP_ALLOC;

	/*

	 * Initialize the 'root' kobj for the edac_device controller

	 */

	err = edac_device_register_sysfs_main_kobj(dev_ctl);

	if (err) {

		kfree(dev_ctl);

		return NULL;

	}

	/* at this point, the root kobj is valid, and in order to

	 * 'free' the object, then the function:

	 *	edac_device_unregister_sysfs_main_kobj() must be called

	 * which will perform kobj unregistration and the actual free

	 * will occur during the kobject callback operation

	 */

	return dev_ctl;

}

EXPORT_SYMBOL_GPL(edac_device_alloc_ctl_info);

 */

void edac_device_free_ctl_info(struct edac_device_ctl_info *ctl_info)

{

	kfree(ctl_info);

	edac_device_unregister_sysfs_main_kobj(ctl_info);

}

EXPORT_SYMBOL_GPL(edac_device_free_ctl_info);

	edac_dev = container_of(head, struct edac_device_ctl_info, rcu);

	INIT_LIST_HEAD(&edac_dev->link);

	complete(&edac_dev->complete);

	complete(&edac_dev->removal_complete);

}

/*

 * del_edac_device_from_global_list

 *

 *	remove the RCU, setup for a callback call, then wait for the

 *	callback to occur

 *	remove the RCU, setup for a callback call,

 *	then wait for the callback to occur

 */

static void del_edac_device_from_global_list(struct edac_device_ctl_info

						*edac_device)

{

	list_del_rcu(&edac_device->link);

	init_completion(&edac_device->complete);

	init_completion(&edac_device->removal_complete);

	call_rcu(&edac_device->rcu, complete_edac_device_list_del);

	wait_for_completion(&edac_device->complete);

	wait_for_completion(&edac_device->removal_complete);

}

/**

	/* clear workq processing on this instance */

	edac_device_workq_teardown(edac_dev);

	/* Tear down the sysfs entries for this instance */

	edac_device_remove_sysfs(edac_dev);

	/* deregister from global list */

	del_edac_device_from_global_list(edac_dev);

	mutex_unlock(&device_ctls_mutex);

	/* Tear down the sysfs entries for this instance */

	edac_device_remove_sysfs(edac_dev);

	edac_printk(KERN_INFO, EDAC_MC,

		"Removed device %d for %s %s: DEV %s\n",

		edac_dev->dev_idx,

 * file for managing the edac_device class of devices for EDAC

 *

 * (C) 2007 SoftwareBitMaker (http://www.softwarebitmaker.com)

 *

 * This file may be distributed under the terms of the

 * GNU General Public License.

 *

 */

#include <linux/ctype.h>

#include <linux/module.h>

#include "edac_core.h"

#include "edac_module.h"

#define to_edacdev(k) container_of(k, struct edac_device_ctl_info, kobj)

#define to_edacdev_attr(a) container_of(a, struct edacdev_attribute, attr)

/************************** edac_device sysfs code and data **************/

/*

 * Set of edac_device_ctl_info attribute store/show functions

	NULL,

};

/* Main DEVICE kobject release() function */

/*

 * edac_device_ctrl_master_release

 *

 *	called when the reference count for the 'main' kobj

 *	for a edac_device control struct reaches zero

 *

 *	Reference count model:

 *		One 'main' kobject for each control structure allocated.

 *		That main kobj is initially set to one AND

 *		the reference count for the EDAC 'core' module is

 *		bumped by one, thus added 'keep in memory' dependency.

 *

 *		Each new internal kobj (in instances and blocks) then

 *		bumps the 'main' kobject.

 *

 *		When they are released their release functions decrement

 *		the 'main' kobj.

 *

 *		When the main kobj reaches zero (0) then THIS function

 *		is called which then decrements the EDAC 'core' module.

 *		When the module reference count reaches zero then the

 *		module no longer has dependency on keeping the release

 *		function code in memory and module can be unloaded.

 *

 *		This will support several control objects as well, each

 *		with its own 'main' kobj.

 */

static void edac_device_ctrl_master_release(struct kobject *kobj)

{

	struct edac_device_ctl_info *edac_dev;

	struct edac_device_ctl_info *edac_dev = to_edacdev(kobj);

	edac_dev = to_edacdev(kobj);

	debugf1("%s() control index=%d\n", __func__, edac_dev->dev_idx);

	debugf1("%s()\n", __func__);

	complete(&edac_dev->kobj_complete);

	/* decrement the EDAC CORE module ref count */

	module_put(edac_dev->owner);

	/* free the control struct containing the 'main' kobj

	 * passed in to this routine

	 */

	kfree(edac_dev);

}

/* ktype for the main (master) kobject */

static struct kobj_type ktype_device_ctrl = {

	.release = edac_device_ctrl_master_release,

	.sysfs_ops = &device_ctl_info_ops,

	.default_attrs = (struct attribute **)device_ctrl_attr,

};

/**************** edac_device main kobj ctor/dtor code *********************/

/*

 * edac_device_register_main_kobj

 * edac_device_register_sysfs_main_kobj

 *

 *	perform the high level setup for the new edac_device instance

 *

 * Return:  0 SUCCESS

 *         !0 FAILURE

 */

static int edac_device_register_main_kobj(struct edac_device_ctl_info *edac_dev)

int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)

{

	int err = 0;

	struct sysdev_class *edac_class;

	int err;

	debugf1("%s()\n", __func__);

	/* get the /sys/devices/system/edac reference */

	edac_class = edac_get_edac_class();

	if (edac_class == NULL) {

		debugf1("%s() no edac_class error=%d\n", __func__, err);

		return err;

		debugf1("%s() no edac_class error\n", __func__);

		err = -ENODEV;

		goto err_out;

	}

	/* Point to the 'edac_class' this instance 'reports' to */

	debugf1("%s() set name of kobject to: %s\n", __func__, edac_dev->name);

	err = kobject_set_name(&edac_dev->kobj, "%s", edac_dev->name);

	if (err)

		return err;

		goto err_out;

	/* Record which module 'owns' this control structure

	 * and bump the ref count of the module

	 */

	edac_dev->owner = THIS_MODULE;

	if (!try_module_get(edac_dev->owner)) {

		err = -ENODEV;

		goto err_out;

	}

	/* register */

	err = kobject_register(&edac_dev->kobj);

	if (err) {

		debugf1("%s()Failed to register '.../edac/%s'\n",

			__func__, edac_dev->name);

		return err;

		goto err_kobj_reg;

	}

	/* At this point, to 'free' the control struct,

	 * edac_device_unregister_sysfs_main_kobj() must be used

	 */

	debugf1("%s() Registered '.../edac/%s' kobject\n",

		__func__, edac_dev->name);

	return 0;

	/* Error exit stack */

err_kobj_reg:

	module_put(edac_dev->owner);

err_out:

	return err;

}

/*

 * edac_device_unregister_main_kobj:

 * edac_device_unregister_sysfs_main_kobj:

 *	the '..../edac/<name>' kobject

 */

static void edac_device_unregister_main_kobj(struct edac_device_ctl_info

					*edac_dev)

void edac_device_unregister_sysfs_main_kobj(

					struct edac_device_ctl_info *edac_dev)

{

	debugf0("%s()\n", __func__);

	debugf1("%s() name of kobject is: %s\n",

		__func__, kobject_name(&edac_dev->kobj));

	init_completion(&edac_dev->kobj_complete);

	/*

	 * Unregister the edac device's kobject and

	 * wait for reference count to reach 0.

	 * allow for reference count to reach 0 at which point

	 * the callback will be called to:

	 *   a) module_put() this module

	 *   b) 'kfree' the memory

	 */

	kobject_unregister(&edac_dev->kobj);

	wait_for_completion(&edac_dev->kobj_complete);

}

/*************** edac_dev -> instance information ***********/

/* edac_dev -> instance information */

/*

 * Set of low-level instance attribute show functions

	debugf1("%s()\n", __func__);

	/* map from this kobj to the main control struct

	 * and then dec the main kobj count

	 */

	instance = to_instance(kobj);

	complete(&instance->kobj_complete);

	kobject_put(&instance->ctl->kobj);

}

/* instance specific attribute structure */

	.default_attrs = (struct attribute **)device_instance_attr,

};

/*************** edac_dev -> instance -> block information *********/

/* edac_dev -> instance -> block information */

/*

 * Set of low-level block attribute show functions

	debugf1("%s()\n", __func__);

	/* get the container of the kobj */

	block = to_block(kobj);

	complete(&block->kobj_complete);

	/* map from 'block kobj' to 'block->instance->controller->main_kobj'

	 * now 'release' the block kobject

	 */

	kobject_put(&block->instance->ctl->kobj);

}

/* block specific attribute structure */

	.default_attrs = (struct attribute **)device_block_attr,

};

/************** block ctor/dtor  code ************/

/* block ctor/dtor  code */

/*

 * edac_device_create_block

 */

static int edac_device_create_block(struct edac_device_ctl_info *edac_dev,

				struct edac_device_instance *instance,

				int idx)

				struct edac_device_block *block)

{

	int i;

	int err;

	struct edac_device_block *block;

	struct edac_dev_sysfs_block_attribute *sysfs_attrib;

	struct kobject *main_kobj;

	block = &instance->blocks[idx];

	debugf1("%s() Instance '%s' block[%d] '%s'\n",

		__func__, instance->name, idx, block->name);

	debugf1("%s() Instance '%s' block '%s'\n",

		__func__, instance->name, block->name);

	/* init this block's kobject */

	memset(&block->kobj, 0, sizeof(struct kobject));

	block->kobj.parent = &instance->kobj;

	block->kobj.ktype = &ktype_block_ctrl;

	block->instance = instance;

	err = kobject_set_name(&block->kobj, "%s", block->name);

	if (err)

		return err;

	/* bump the main kobject's reference count for this controller

	 * and this instance is dependant on the main

	 */

	main_kobj = kobject_get(&edac_dev->kobj);

	if (!main_kobj) {

		err = -ENODEV;

		goto err_out;

	}

	/* Add this block's kobject */

	err = kobject_register(&block->kobj);

	if (err) {

		debugf1("%s() Failed to register instance '%s'\n",

			__func__, block->name);

		return err;

		kobject_put(main_kobj);

		err = -ENODEV;

		goto err_out;

	}

	/* If there are driver level block attributes, then added them

	 * to the block kobject

	 */

	sysfs_attrib = block->block_attributes;

	if (sysfs_attrib != NULL) {

	if (sysfs_attrib) {

		for (i = 0; i < block->nr_attribs; i++) {

			err = sysfs_create_file(&block->kobj,

				(struct attribute *) &sysfs_attrib[i]);

				(struct attribute *) sysfs_attrib);

			if (err)

				goto err_on_attrib;

	return 0;

	/* Error unwind stack */

err_on_attrib:

	kobject_unregister(&block->kobj);

err_out:

	return err;

}

/*

 * edac_device_delete_block(edac_dev,j);

 * edac_device_delete_block(edac_dev,block);

 */

static void edac_device_delete_block(struct edac_device_ctl_info *edac_dev,

				struct edac_device_instance *instance,

				int idx)

				struct edac_device_block *block)

{

	struct edac_device_block *block;

	struct edac_dev_sysfs_block_attribute *sysfs_attrib;

	int i;

	block = &instance->blocks[idx];

	/* if this block has 'attributes' then we need to iterate over the list

	 * and 'remove' the attributes on this block

	 */

	sysfs_attrib = block->block_attributes;

	if (sysfs_attrib && block->nr_attribs) {

		for (i = 0; i < block->nr_attribs; i++) {

			sysfs_remove_file(&block->kobj,

				(struct attribute *) sysfs_attrib);

		}

	}

	/* unregister this block's kobject */

	init_completion(&block->kobj_complete);

	/* unregister this block's kobject, SEE:

	 *	edac_device_ctrl_block_release() callback operation

	 */

	kobject_unregister(&block->kobj);

	wait_for_completion(&block->kobj_complete);

}

/************** instance ctor/dtor  code ************/

/* instance ctor/dtor code */

/*

 * edac_device_create_instance

	int i, j;

	int err;

	struct edac_device_instance *instance;

	struct kobject *main_kobj;

	instance = &edac_dev->instances[idx];

	/* set this new device under the edac_device main kobject */

	instance->kobj.parent = &edac_dev->kobj;

	instance->kobj.ktype = &ktype_instance_ctrl;

	instance->ctl = edac_dev;

	err = kobject_set_name(&instance->kobj, "%s", instance->name);

	if (err)

		return err;

		goto err_out;

	/* bump the main kobject's reference count for this controller

	 * and this instance is dependant on the main

	 */

	main_kobj = kobject_get(&edac_dev->kobj);

	if (!main_kobj) {

		err = -ENODEV;

		goto err_out;

	}

	/* Formally register this instance's kobject */

	err = kobject_register(&instance->kobj);

	if (err != 0) {

		debugf2("%s() Failed to register instance '%s'\n",

			__func__, instance->name);

		return err;

		kobject_put(main_kobj);

		goto err_out;

	}

	debugf1("%s() now register '%d' blocks for instance %d\n",

	/* register all blocks of this instance */

	for (i = 0; i < instance->nr_blocks; i++) {

		err = edac_device_create_block(edac_dev, instance, i);

		err = edac_device_create_block(edac_dev, instance,

						&instance->blocks[i]);

		if (err) {

			/* If any fail, remove all previous ones */

			for (j = 0; j < i; j++)

				edac_device_delete_block(edac_dev, instance, j);

			return err;

				edac_device_delete_block(edac_dev,

							&instance->blocks[j]);

			goto err_release_instance_kobj;

		}

	}

		__func__, idx, instance->name);

	return 0;

	/* error unwind stack */

err_release_instance_kobj:

	kobject_unregister(&instance->kobj);

err_out:

	return err;

}

/*

static void edac_device_delete_instance(struct edac_device_ctl_info *edac_dev,

					int idx)

{

	int i;

	struct edac_device_instance *instance;

	int i;

	instance = &edac_dev->instances[idx];

	/* unregister all blocks in this instance */

	for (i = 0; i < instance->nr_blocks; i++)

		edac_device_delete_block(edac_dev, instance, i);

		edac_device_delete_block(edac_dev, &instance->blocks[i]);

	/* unregister this instance's kobject */

	init_completion(&instance->kobj_complete);

	/* unregister this instance's kobject, SEE:

	 *	edac_device_ctrl_instance_release() for callback operation

	 */

	kobject_unregister(&instance->kobj);

	wait_for_completion(&instance->kobj_complete);

}

/*

		edac_device_delete_instance(edac_dev, i);

}

/******************* edac_dev sysfs ctor/dtor  code *************/

/* edac_dev sysfs ctor/dtor  code */

/*

 * edac_device_add_sysfs_attributes

 * edac_device_add_main_sysfs_attributes

 *	add some attributes to this instance's main kobject

 */

static int edac_device_add_sysfs_attributes(

static int edac_device_add_main_sysfs_attributes(

			struct edac_device_ctl_info *edac_dev)

{

	int err;

	struct edac_dev_sysfs_attribute *sysfs_attrib;

	int err = 0;

	/* point to the start of the array and iterate over it

	 * adding each attribute listed to this mci instance's kobject

	 */

	sysfs_attrib = edac_dev->sysfs_attributes;

	if (sysfs_attrib) {

		/* iterate over the array and create an attribute for each

		 * entry in the list

		 */

		while (sysfs_attrib->attr.name != NULL) {

			err = sysfs_create_file(&edac_dev->kobj,

				(struct attribute*) sysfs_attrib);

			if (err)

			return err;

				goto err_out;

			sysfs_attrib++;

		}

	}

	return 0;

err_out:

	return err;

}

/*

 * edac_device_remove_main_sysfs_attributes

 *	remove any attributes to this instance's main kobject

 */

static void edac_device_remove_main_sysfs_attributes(

			struct edac_device_ctl_info *edac_dev)

{

	struct edac_dev_sysfs_attribute *sysfs_attrib;

	/* if there are main attributes, defined, remove them. First,

	 * point to the start of the array and iterate over it

	 * removing each attribute listed from this device's instance's kobject

	 */

	sysfs_attrib = edac_dev->sysfs_attributes;

	if (sysfs_attrib) {

		while (sysfs_attrib->attr.name != NULL) {

			sysfs_remove_file(&edac_dev->kobj,

					(struct attribute *) sysfs_attrib);

			sysfs_attrib++;

		}

	}

}

/*

 * edac_device_create_sysfs() Constructor

 *

 * Create a new edac_device kobject instance,

 * accept a created edac_device control structure

 * and 'export' it to sysfs. The 'main' kobj should already have been

 * created. 'instance' and 'block' kobjects should be registered

 * along with any 'block' attributes from the low driver. In addition,

 * the main attributes (if any) are connected to the main kobject of

 * the control structure.

 *

 * Return:

 *	0	Success

	int err;

	struct kobject *edac_kobj = &edac_dev->kobj;

	/* register this instance's main kobj with the edac class kobj */

	err = edac_device_register_main_kobj(edac_dev);

	if (err)

		return err;

	debugf0("%s() idx=%d\n", __func__, edac_dev->dev_idx);

	/* If the low level driver requests some sysfs entries

	 * then go create them here

	 */

	if (edac_dev->sysfs_attributes != NULL) {

		err = edac_device_add_sysfs_attributes(edac_dev);

	/*  go create any main attributes callers wants */

	err = edac_device_add_main_sysfs_attributes(edac_dev);

	if (err) {

			debugf0("%s() failed to add sysfs attribs\n",

				__func__);

			goto err_unreg_object;

		}

		debugf0("%s() failed to add sysfs attribs\n", __func__);

		goto err_out;

	}

	/* create a symlink from the edac device

	if (err) {

		debugf0("%s() sysfs_create_link() returned err= %d\n",

			__func__, err);

		goto err_unreg_object;

		goto err_remove_main_attribs;

	}

	debugf0("%s() calling create-instances, idx=%d\n",

		__func__, edac_dev->dev_idx);

	/* Create the first level instance directories */

	/* Create the first level instance directories

	 * In turn, the nested blocks beneath the instances will

	 * be registered as well

	 */

	err = edac_device_create_instances(edac_dev);

	if (err)

	if (err) {

		debugf0("%s() edac_device_create_instances() "

			"returned err= %d\n", __func__, err);