Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit a15d49fd3094cff90e5410ca454a870e0a722fe1

Authored by Hannes Reinecke 2012-04-16 21:06:25 +0800

Committed by Greg Kroah-Hartman 2012-04-19 06:39:52 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

driver core: check start node in klist_iter_init_node

klist_iter_init_node() takes a node as a start argument.
However, this node might not be valid anymore.
This patch updates the klist_iter_init_node() and
dependent functions to return an error if so.
All calling functions have been audited to check
for a return code here.

Signed-off-by: Hannes Reinecke <hare@suse.de>
Cc: Greg Kroah-Hartmann <gregkh@linuxfoundation.org>
Cc: Kay Sievers <kay@vrfy.org>
Cc: Stable Kernel <stable@kernel.org>
Cc: Linux Kernel <linux-kernel@vger.kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 6 changed files with 76 additions and 46 deletions Inline Diff

drivers/base/bus.c
drivers/base/class.c
drivers/base/driver.c
include/linux/device.h
include/linux/klist.h
lib/klist.c

drivers/base/bus.c

Diff comments View file @ a15d49f

 /*
  * bus.c - bus driver management
  *
  * Copyright (c) 2002-3 Patrick Mochel
  * Copyright (c) 2002-3 Open Source Development Labs
  * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
  * Copyright (c) 2007 Novell Inc.
  *
  * This file is released under the GPLv2
  *
  */
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/mutex.h>
 #include "base.h"
 #include "power/power.h"
 /* /sys/devices/system */
 static struct kset *system_kset;
 #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
 /*
  * sysfs bindings for drivers
  */
 #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
 static int __must_check bus_rescan_devices_helper(struct device *dev,
 						void *data);
 static struct bus_type *bus_get(struct bus_type *bus)
 {
 	if (bus) {
 		kset_get(&bus->p->subsys);
 		return bus;
 	}
 	return NULL;
 }
 static void bus_put(struct bus_type *bus)
 {
 	if (bus)
 		kset_put(&bus->p->subsys);
 }
 static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr,
 			     char *buf)
 {
 	struct driver_attribute *drv_attr = to_drv_attr(attr);
 	struct driver_private *drv_priv = to_driver(kobj);
 	ssize_t ret = -EIO;
 	if (drv_attr->show)
 		ret = drv_attr->show(drv_priv->driver, buf);
 	return ret;
 }
 static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr,
 			      const char *buf, size_t count)
 {
 	struct driver_attribute *drv_attr = to_drv_attr(attr);
 	struct driver_private *drv_priv = to_driver(kobj);
 	ssize_t ret = -EIO;
 	if (drv_attr->store)
 		ret = drv_attr->store(drv_priv->driver, buf, count);
 	return ret;
 }
 static const struct sysfs_ops driver_sysfs_ops = {
 	.show	= drv_attr_show,
 	.store	= drv_attr_store,
 };
 static void driver_release(struct kobject *kobj)
 {
 	struct driver_private *drv_priv = to_driver(kobj);
 	pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__);
 	kfree(drv_priv);
 }
 static struct kobj_type driver_ktype = {
 	.sysfs_ops	= &driver_sysfs_ops,
 	.release	= driver_release,
 };
 /*
  * sysfs bindings for buses
  */
 static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
 			     char *buf)
 {
 	struct bus_attribute *bus_attr = to_bus_attr(attr);
 	struct subsys_private *subsys_priv = to_subsys_private(kobj);
 	ssize_t ret = 0;
 	if (bus_attr->show)
 		ret = bus_attr->show(subsys_priv->bus, buf);
 	return ret;
 }
 static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
 			      const char *buf, size_t count)
 {
 	struct bus_attribute *bus_attr = to_bus_attr(attr);
 	struct subsys_private *subsys_priv = to_subsys_private(kobj);
 	ssize_t ret = 0;
 	if (bus_attr->store)
 		ret = bus_attr->store(subsys_priv->bus, buf, count);
 	return ret;
 }
 static const struct sysfs_ops bus_sysfs_ops = {
 	.show	= bus_attr_show,
 	.store	= bus_attr_store,
 };
 int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
 {
 	int error;
 	if (bus_get(bus)) {
 		error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
 		bus_put(bus);
 	} else
 		error = -EINVAL;
 	return error;
 }
 EXPORT_SYMBOL_GPL(bus_create_file);
 void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
 {
 	if (bus_get(bus)) {
 		sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr);
 		bus_put(bus);
 	}
 }
 EXPORT_SYMBOL_GPL(bus_remove_file);
 static struct kobj_type bus_ktype = {
 	.sysfs_ops	= &bus_sysfs_ops,
 };
 static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
 	struct kobj_type *ktype = get_ktype(kobj);
 	if (ktype == &bus_ktype)
 		return 1;
 	return 0;
 }
 static const struct kset_uevent_ops bus_uevent_ops = {
 	.filter = bus_uevent_filter,
 };
 static struct kset *bus_kset;
 #ifdef CONFIG_HOTPLUG
 /* Manually detach a device from its associated driver. */
 static ssize_t driver_unbind(struct device_driver *drv,
 			     const char *buf, size_t count)
 {
 	struct bus_type *bus = bus_get(drv->bus);
 	struct device *dev;
 	int err = -ENODEV;
 	dev = bus_find_device_by_name(bus, NULL, buf);
 	if (dev && dev->driver == drv) {
 		if (dev->parent)	/* Needed for USB */
 			device_lock(dev->parent);
 		device_release_driver(dev);
 		if (dev->parent)
 			device_unlock(dev->parent);
 		err = count;
 	}
 	put_device(dev);
 	bus_put(bus);
 	return err;
 }
 static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
 /*
  * Manually attach a device to a driver.
  * Note: the driver must want to bind to the device,
  * it is not possible to override the driver's id table.
  */
 static ssize_t driver_bind(struct device_driver *drv,
 			   const char *buf, size_t count)
 {
 	struct bus_type *bus = bus_get(drv->bus);
 	struct device *dev;
 	int err = -ENODEV;
 	dev = bus_find_device_by_name(bus, NULL, buf);
 	if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
 		if (dev->parent)	/* Needed for USB */
 			device_lock(dev->parent);
 		device_lock(dev);
 		err = driver_probe_device(drv, dev);
 		device_unlock(dev);
 		if (dev->parent)
 			device_unlock(dev->parent);
 		if (err > 0) {
 			/* success */
 			err = count;
 		} else if (err == 0) {
 			/* driver didn't accept device */
 			err = -ENODEV;
 		}
 	}
 	put_device(dev);
 	bus_put(bus);
 	return err;
 }
 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
 static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
 {
 	return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
 }
 static ssize_t store_drivers_autoprobe(struct bus_type *bus,
 				       const char *buf, size_t count)
 {
 	if (buf[0] == '0')
 		bus->p->drivers_autoprobe = 0;
 	else
 		bus->p->drivers_autoprobe = 1;
 	return count;
 }
 static ssize_t store_drivers_probe(struct bus_type *bus,
 				   const char *buf, size_t count)
 {
 	struct device *dev;
 	dev = bus_find_device_by_name(bus, NULL, buf);
 	if (!dev)
 		return -ENODEV;
 	if (bus_rescan_devices_helper(dev, NULL) != 0)
 		return -EINVAL;
 	return count;
 }
 #endif
 static struct device *next_device(struct klist_iter *i)
 {
 	struct klist_node *n = klist_next(i);
 	struct device *dev = NULL;
 	struct device_private *dev_prv;
 	if (n) {
 		dev_prv = to_device_private_bus(n);
 		dev = dev_prv->device;
 	}
 	return dev;
 }
 /**
  * bus_for_each_dev - device iterator.
  * @bus: bus type.
  * @start: device to start iterating from.
  * @data: data for the callback.
  * @fn: function to be called for each device.
  *
  * Iterate over @bus's list of devices, and call @fn for each,
  * passing it @data. If @start is not NULL, we use that device to
  * begin iterating from.
  *
  * We check the return of @fn each time. If it returns anything
  * other than 0, we break out and return that value.
  *
  * NOTE: The device that returns a non-zero value is not retained
  * in any way, nor is its refcount incremented. If the caller needs
  * to retain this data, it should do so, and increment the reference
  * count in the supplied callback.
  */
 int bus_for_each_dev(struct bus_type *bus, struct device *start,
 		     void *data, int (*fn)(struct device *, void *))
 {
 	struct klist_iter i;
 	struct device *dev;
 	int error = 0;
 	if (!bus)
 		return -EINVAL;
-	klist_iter_init_node(&bus->p->klist_devices, &i,
+	error = klist_iter_init_node(&bus->p->klist_devices, &i,
-			     (start ? &start->p->knode_bus : NULL));
+				     (start ? &start->p->knode_bus : NULL));
-	while ((dev = next_device(&i)) && !error)
+	if (!error) {
-		error = fn(dev, data);
+		while ((dev = next_device(&i)) && !error)
-	klist_iter_exit(&i);
+			error = fn(dev, data);
+		klist_iter_exit(&i);
+	}
 	return error;
 }
 EXPORT_SYMBOL_GPL(bus_for_each_dev);
 /**
  * bus_find_device - device iterator for locating a particular device.
  * @bus: bus type
  * @start: Device to begin with
  * @data: Data to pass to match function
  * @match: Callback function to check device
  *
  * This is similar to the bus_for_each_dev() function above, but it
  * returns a reference to a device that is 'found' for later use, as
  * determined by the @match callback.
  *
  * The callback should return 0 if the device doesn't match and non-zero
  * if it does.  If the callback returns non-zero, this function will
  * return to the caller and not iterate over any more devices.
  */
 struct device *bus_find_device(struct bus_type *bus,
 			       struct device *start, void *data,
 			       int (*match)(struct device *dev, void *data))
 {
 	struct klist_iter i;
 	struct device *dev;
 	if (!bus)
 		return NULL;
-	klist_iter_init_node(&bus->p->klist_devices, &i,
+	if (klist_iter_init_node(&bus->p->klist_devices, &i,
-			     (start ? &start->p->knode_bus : NULL));
+				 (start ? &start->p->knode_bus : NULL)) < 0)
+		return NULL;
 	while ((dev = next_device(&i)))
 		if (match(dev, data) && get_device(dev))
 			break;
 	klist_iter_exit(&i);
 	return dev;
 }
 EXPORT_SYMBOL_GPL(bus_find_device);
 static int match_name(struct device *dev, void *data)
 {
 	const char *name = data;
 	return sysfs_streq(name, dev_name(dev));
 }
 /**
  * bus_find_device_by_name - device iterator for locating a particular device of a specific name
  * @bus: bus type
  * @start: Device to begin with
  * @name: name of the device to match
  *
  * This is similar to the bus_find_device() function above, but it handles
  * searching by a name automatically, no need to write another strcmp matching
  * function.
  */
 struct device *bus_find_device_by_name(struct bus_type *bus,
 				       struct device *start, const char *name)
 {
 	return bus_find_device(bus, start, (void *)name, match_name);
 }
 EXPORT_SYMBOL_GPL(bus_find_device_by_name);
 /**
  * subsys_find_device_by_id - find a device with a specific enumeration number
  * @subsys: subsystem
  * @id: index 'id' in struct device
  * @hint: device to check first
  *
  * Check the hint's next object and if it is a match return it directly,
  * otherwise, fall back to a full list search. Either way a reference for
  * the returned object is taken.
  */
 struct device *subsys_find_device_by_id(struct bus_type *subsys, unsigned int id,
 					struct device *hint)
 {
 	struct klist_iter i;
 	struct device *dev;
 	if (!subsys)
 		return NULL;
 	if (hint) {
-		klist_iter_init_node(&subsys->p->klist_devices, &i, &hint->p->knode_bus);
+		if (klist_iter_init_node(&subsys->p->klist_devices, &i,
+					 &hint->p->knode_bus) < 0)
+			return NULL;
 		dev = next_device(&i);
 		if (dev && dev->id == id && get_device(dev)) {
 			klist_iter_exit(&i);
 			return dev;
 		}
 		klist_iter_exit(&i);
 	}
 	klist_iter_init_node(&subsys->p->klist_devices, &i, NULL);
 	while ((dev = next_device(&i))) {
 		if (dev->id == id && get_device(dev)) {
 			klist_iter_exit(&i);
 			return dev;
 		}
 	}
 	klist_iter_exit(&i);
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(subsys_find_device_by_id);
 static struct device_driver *next_driver(struct klist_iter *i)
 {
 	struct klist_node *n = klist_next(i);
 	struct driver_private *drv_priv;
 	if (n) {
 		drv_priv = container_of(n, struct driver_private, knode_bus);
 		return drv_priv->driver;
 	}
 	return NULL;
 }
 /**
  * bus_for_each_drv - driver iterator
  * @bus: bus we're dealing with.
  * @start: driver to start iterating on.
  * @data: data to pass to the callback.
  * @fn: function to call for each driver.
  *
  * This is nearly identical to the device iterator above.
  * We iterate over each driver that belongs to @bus, and call
  * @fn for each. If @fn returns anything but 0, we break out
  * and return it. If @start is not NULL, we use it as the head
  * of the list.
  *
  * NOTE: we don't return the driver that returns a non-zero
  * value, nor do we leave the reference count incremented for that
  * driver. If the caller needs to know that info, it must set it
  * in the callback. It must also be sure to increment the refcount
  * so it doesn't disappear before returning to the caller.
  */
 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
 		     void *data, int (*fn)(struct device_driver *, void *))
 {
 	struct klist_iter i;
 	struct device_driver *drv;
 	int error = 0;
 	if (!bus)
 		return -EINVAL;
-	klist_iter_init_node(&bus->p->klist_drivers, &i,
+	error = klist_iter_init_node(&bus->p->klist_drivers, &i,
-			     start ? &start->p->knode_bus : NULL);
+				     start ? &start->p->knode_bus : NULL);
-	while ((drv = next_driver(&i)) && !error)
+	if (!error) {
-		error = fn(drv, data);
+		while ((drv = next_driver(&i)) && !error)
-	klist_iter_exit(&i);
+			error = fn(drv, data);
+		klist_iter_exit(&i);
+	}
 	return error;
 }
 EXPORT_SYMBOL_GPL(bus_for_each_drv);
 static int device_add_attrs(struct bus_type *bus, struct device *dev)
 {
 	int error = 0;
 	int i;
 	if (!bus->dev_attrs)
 		return 0;
 	for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
 		error = device_create_file(dev, &bus->dev_attrs[i]);
 		if (error) {
 			while (--i >= 0)
 				device_remove_file(dev, &bus->dev_attrs[i]);
 			break;
 		}
 	}
 	return error;
 }
 static void device_remove_attrs(struct bus_type *bus, struct device *dev)
 {
 	int i;
 	if (bus->dev_attrs) {
 		for (i = 0; attr_name(bus->dev_attrs[i]); i++)
 			device_remove_file(dev, &bus->dev_attrs[i]);
 	}
 }
 /**
  * bus_add_device - add device to bus
  * @dev: device being added
  *
  * - Add device's bus attributes.
  * - Create links to device's bus.
  * - Add the device to its bus's list of devices.
  */
 int bus_add_device(struct device *dev)
 {
 	struct bus_type *bus = bus_get(dev->bus);
 	int error = 0;
 	if (bus) {
 		pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
 		error = device_add_attrs(bus, dev);
 		if (error)
 			goto out_put;
 		error = sysfs_create_link(&bus->p->devices_kset->kobj,
 						&dev->kobj, dev_name(dev));
 		if (error)
 			goto out_id;
 		error = sysfs_create_link(&dev->kobj,
 				&dev->bus->p->subsys.kobj, "subsystem");
 		if (error)
 			goto out_subsys;
 		klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
 	}
 	return 0;
 out_subsys:
 	sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
 out_id:
 	device_remove_attrs(bus, dev);
 out_put:
 	bus_put(dev->bus);
 	return error;
 }
 /**
  * bus_probe_device - probe drivers for a new device
  * @dev: device to probe
  *
  * - Automatically probe for a driver if the bus allows it.
  */
 void bus_probe_device(struct device *dev)
 {
 	struct bus_type *bus = dev->bus;
 	struct subsys_interface *sif;
 	int ret;
 	if (!bus)
 		return;
 	if (bus->p->drivers_autoprobe) {
 		ret = device_attach(dev);
 		WARN_ON(ret < 0);
 	}
 	mutex_lock(&bus->p->mutex);
 	list_for_each_entry(sif, &bus->p->interfaces, node)
 		if (sif->add_dev)
 			sif->add_dev(dev, sif);
 	mutex_unlock(&bus->p->mutex);
 }
 /**
  * bus_remove_device - remove device from bus
  * @dev: device to be removed
  *
  * - Remove device from all interfaces.
  * - Remove symlink from bus' directory.
  * - Delete device from bus's list.
  * - Detach from its driver.
  * - Drop reference taken in bus_add_device().
  */
 void bus_remove_device(struct device *dev)
 {
 	struct bus_type *bus = dev->bus;
 	struct subsys_interface *sif;
 	if (!bus)
 		return;
 	mutex_lock(&bus->p->mutex);
 	list_for_each_entry(sif, &bus->p->interfaces, node)
 		if (sif->remove_dev)
 			sif->remove_dev(dev, sif);
 	mutex_unlock(&bus->p->mutex);
 	sysfs_remove_link(&dev->kobj, "subsystem");
 	sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
 			  dev_name(dev));
 	device_remove_attrs(dev->bus, dev);
 	if (klist_node_attached(&dev->p->knode_bus))
 		klist_del(&dev->p->knode_bus);
 	pr_debug("bus: '%s': remove device %s\n",
 		 dev->bus->name, dev_name(dev));
 	device_release_driver(dev);
 	bus_put(dev->bus);
 }
 static int driver_add_attrs(struct bus_type *bus, struct device_driver *drv)
 {
 	int error = 0;
 	int i;
 	if (bus->drv_attrs) {
 		for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
 			error = driver_create_file(drv, &bus->drv_attrs[i]);
 			if (error)
 				goto err;
 		}
 	}
 done:
 	return error;
 err:
 	while (--i >= 0)
 		driver_remove_file(drv, &bus->drv_attrs[i]);
 	goto done;
 }
 static void driver_remove_attrs(struct bus_type *bus,
 				struct device_driver *drv)
 {
 	int i;
 	if (bus->drv_attrs) {
 		for (i = 0; attr_name(bus->drv_attrs[i]); i++)
 			driver_remove_file(drv, &bus->drv_attrs[i]);
 	}
 }
 #ifdef CONFIG_HOTPLUG
 /*
  * Thanks to drivers making their tables __devinit, we can't allow manual
  * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
  */
 static int __must_check add_bind_files(struct device_driver *drv)
 {
 	int ret;
 	ret = driver_create_file(drv, &driver_attr_unbind);
 	if (ret == 0) {
 		ret = driver_create_file(drv, &driver_attr_bind);
 		if (ret)
 			driver_remove_file(drv, &driver_attr_unbind);
 	}
 	return ret;
 }
 static void remove_bind_files(struct device_driver *drv)
 {
 	driver_remove_file(drv, &driver_attr_bind);
 	driver_remove_file(drv, &driver_attr_unbind);
 }
 static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
 static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
 		show_drivers_autoprobe, store_drivers_autoprobe);
 static int add_probe_files(struct bus_type *bus)
 {
 	int retval;
 	retval = bus_create_file(bus, &bus_attr_drivers_probe);
 	if (retval)
 		goto out;
 	retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
 	if (retval)
 		bus_remove_file(bus, &bus_attr_drivers_probe);
 out:
 	return retval;
 }
 static void remove_probe_files(struct bus_type *bus)
 {
 	bus_remove_file(bus, &bus_attr_drivers_autoprobe);
 	bus_remove_file(bus, &bus_attr_drivers_probe);
 }
 #else
 static inline int add_bind_files(struct device_driver *drv) { return 0; }
 static inline void remove_bind_files(struct device_driver *drv) {}
 static inline int add_probe_files(struct bus_type *bus) { return 0; }
 static inline void remove_probe_files(struct bus_type *bus) {}
 #endif
 static ssize_t driver_uevent_store(struct device_driver *drv,
 				   const char *buf, size_t count)
 {
 	enum kobject_action action;
 	if (kobject_action_type(buf, count, &action) == 0)
 		kobject_uevent(&drv->p->kobj, action);
 	return count;
 }
 static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store);
 /**
  * bus_add_driver - Add a driver to the bus.
  * @drv: driver.
  */
 int bus_add_driver(struct device_driver *drv)
 {
 	struct bus_type *bus;
 	struct driver_private *priv;
 	int error = 0;
 	bus = bus_get(drv->bus);
 	if (!bus)
 		return -EINVAL;
 	pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
 	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 	if (!priv) {
 		error = -ENOMEM;
 		goto out_put_bus;
 	}
 	klist_init(&priv->klist_devices, NULL, NULL);
 	priv->driver = drv;
 	drv->p = priv;
 	priv->kobj.kset = bus->p->drivers_kset;
 	error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
 				     "%s", drv->name);
 	if (error)
 		goto out_unregister;
 	if (drv->bus->p->drivers_autoprobe) {
 		error = driver_attach(drv);
 		if (error)
 			goto out_unregister;
 	}
 	klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
 	module_add_driver(drv->owner, drv);
 	error = driver_create_file(drv, &driver_attr_uevent);
 	if (error) {
 		printk(KERN_ERR "%s: uevent attr (%s) failed\n",
 			__func__, drv->name);
 	}
 	error = driver_add_attrs(bus, drv);
 	if (error) {
 		/* How the hell do we get out of this pickle? Give up */
 		printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
 			__func__, drv->name);
 	}
 	if (!drv->suppress_bind_attrs) {
 		error = add_bind_files(drv);
 		if (error) {
 			/* Ditto */
 			printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
 				__func__, drv->name);
 		}
 	}
 	kobject_uevent(&priv->kobj, KOBJ_ADD);
 	return 0;
 out_unregister:
 	kobject_put(&priv->kobj);
 	kfree(drv->p);
 	drv->p = NULL;
 out_put_bus:
 	bus_put(bus);
 	return error;
 }
 /**
  * bus_remove_driver - delete driver from bus's knowledge.
  * @drv: driver.
  *
  * Detach the driver from the devices it controls, and remove
  * it from its bus's list of drivers. Finally, we drop the reference
  * to the bus we took in bus_add_driver().
  */
 void bus_remove_driver(struct device_driver *drv)
 {
 	if (!drv->bus)
 		return;
 	if (!drv->suppress_bind_attrs)
 		remove_bind_files(drv);
 	driver_remove_attrs(drv->bus, drv);
 	driver_remove_file(drv, &driver_attr_uevent);
 	klist_remove(&drv->p->knode_bus);
 	pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);
 	driver_detach(drv);
 	module_remove_driver(drv);
 	kobject_put(&drv->p->kobj);
 	bus_put(drv->bus);
 }
 /* Helper for bus_rescan_devices's iter */
 static int __must_check bus_rescan_devices_helper(struct device *dev,
 						  void *data)
 {
 	int ret = 0;
 	if (!dev->driver) {
 		if (dev->parent)	/* Needed for USB */
 			device_lock(dev->parent);
 		ret = device_attach(dev);
 		if (dev->parent)
 			device_unlock(dev->parent);
 	}
 	return ret < 0 ? ret : 0;
 }
 /**
  * bus_rescan_devices - rescan devices on the bus for possible drivers
  * @bus: the bus to scan.
  *
  * This function will look for devices on the bus with no driver
  * attached and rescan it against existing drivers to see if it matches
  * any by calling device_attach() for the unbound devices.
  */
 int bus_rescan_devices(struct bus_type *bus)
 {
 	return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
 }
 EXPORT_SYMBOL_GPL(bus_rescan_devices);
 /**
  * device_reprobe - remove driver for a device and probe for a new driver
  * @dev: the device to reprobe
  *
  * This function detaches the attached driver (if any) for the given
  * device and restarts the driver probing process.  It is intended
  * to use if probing criteria changed during a devices lifetime and
  * driver attachment should change accordingly.
  */
 int device_reprobe(struct device *dev)
 {
 	if (dev->driver) {
 		if (dev->parent)        /* Needed for USB */
 			device_lock(dev->parent);
 		device_release_driver(dev);
 		if (dev->parent)
 			device_unlock(dev->parent);
 	}
 	return bus_rescan_devices_helper(dev, NULL);
 }
 EXPORT_SYMBOL_GPL(device_reprobe);
 /**
  * find_bus - locate bus by name.
  * @name: name of bus.
  *
  * Call kset_find_obj() to iterate over list of buses to
  * find a bus by name. Return bus if found.
  *
  * Note that kset_find_obj increments bus' reference count.
  */
 #if 0
 struct bus_type *find_bus(char *name)
 {
 	struct kobject *k = kset_find_obj(bus_kset, name);
 	return k ? to_bus(k) : NULL;
 }
 #endif  /*  0  */
 /**
  * bus_add_attrs - Add default attributes for this bus.
  * @bus: Bus that has just been registered.
  */
 static int bus_add_attrs(struct bus_type *bus)
 {
 	int error = 0;
 	int i;
 	if (bus->bus_attrs) {
 		for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
 			error = bus_create_file(bus, &bus->bus_attrs[i]);
 			if (error)
 				goto err;
 		}
 	}
 done:
 	return error;
 err:
 	while (--i >= 0)
 		bus_remove_file(bus, &bus->bus_attrs[i]);
 	goto done;
 }
 static void bus_remove_attrs(struct bus_type *bus)
 {
 	int i;
 	if (bus->bus_attrs) {
 		for (i = 0; attr_name(bus->bus_attrs[i]); i++)
 			bus_remove_file(bus, &bus->bus_attrs[i]);
 	}
 }
 static void klist_devices_get(struct klist_node *n)
 {
 	struct device_private *dev_prv = to_device_private_bus(n);
 	struct device *dev = dev_prv->device;
 	get_device(dev);
 }
 static void klist_devices_put(struct klist_node *n)
 {
 	struct device_private *dev_prv = to_device_private_bus(n);
 	struct device *dev = dev_prv->device;
 	put_device(dev);
 }
 static ssize_t bus_uevent_store(struct bus_type *bus,
 				const char *buf, size_t count)
 {
 	enum kobject_action action;
 	if (kobject_action_type(buf, count, &action) == 0)
 		kobject_uevent(&bus->p->subsys.kobj, action);
 	return count;
 }
 static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
 /**
  * __bus_register - register a driver-core subsystem
  * @bus: bus to register
  * @key: lockdep class key
  *
  * Once we have that, we register the bus with the kobject
  * infrastructure, then register the children subsystems it has:
  * the devices and drivers that belong to the subsystem.
  */
 int __bus_register(struct bus_type *bus, struct lock_class_key *key)
 {
 	int retval;
 	struct subsys_private *priv;
 	priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 	priv->bus = bus;
 	bus->p = priv;
 	BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
 	retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
 	if (retval)
 		goto out;
 	priv->subsys.kobj.kset = bus_kset;
 	priv->subsys.kobj.ktype = &bus_ktype;
 	priv->drivers_autoprobe = 1;
 	retval = kset_register(&priv->subsys);
 	if (retval)
 		goto out;
 	retval = bus_create_file(bus, &bus_attr_uevent);
 	if (retval)
 		goto bus_uevent_fail;
 	priv->devices_kset = kset_create_and_add("devices", NULL,
 						 &priv->subsys.kobj);
 	if (!priv->devices_kset) {
 		retval = -ENOMEM;
 		goto bus_devices_fail;
 	}
 	priv->drivers_kset = kset_create_and_add("drivers", NULL,
 						 &priv->subsys.kobj);
 	if (!priv->drivers_kset) {
 		retval = -ENOMEM;
 		goto bus_drivers_fail;
 	}
 	INIT_LIST_HEAD(&priv->interfaces);
 	__mutex_init(&priv->mutex, "subsys mutex", key);
 	klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
 	klist_init(&priv->klist_drivers, NULL, NULL);
 	retval = add_probe_files(bus);
 	if (retval)
 		goto bus_probe_files_fail;
 	retval = bus_add_attrs(bus);
 	if (retval)
 		goto bus_attrs_fail;
 	pr_debug("bus: '%s': registered\n", bus->name);
 	return 0;
 bus_attrs_fail:
 	remove_probe_files(bus);
 bus_probe_files_fail:
 	kset_unregister(bus->p->drivers_kset);
 bus_drivers_fail:
 	kset_unregister(bus->p->devices_kset);
 bus_devices_fail:
 	bus_remove_file(bus, &bus_attr_uevent);
 bus_uevent_fail:
 	kset_unregister(&bus->p->subsys);
 out:
 	kfree(bus->p);
 	bus->p = NULL;
 	return retval;
 }
 EXPORT_SYMBOL_GPL(__bus_register);
 /**
  * bus_unregister - remove a bus from the system
  * @bus: bus.
  *
  * Unregister the child subsystems and the bus itself.
  * Finally, we call bus_put() to release the refcount
  */
 void bus_unregister(struct bus_type *bus)
 {
 	pr_debug("bus: '%s': unregistering\n", bus->name);
 	if (bus->dev_root)
 		device_unregister(bus->dev_root);
 	bus_remove_attrs(bus);
 	remove_probe_files(bus);
 	kset_unregister(bus->p->drivers_kset);
 	kset_unregister(bus->p->devices_kset);
 	bus_remove_file(bus, &bus_attr_uevent);
 	kset_unregister(&bus->p->subsys);
 	kfree(bus->p);
 	bus->p = NULL;
 }
 EXPORT_SYMBOL_GPL(bus_unregister);
 int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
 {
 	return blocking_notifier_chain_register(&bus->p->bus_notifier, nb);
 }
 EXPORT_SYMBOL_GPL(bus_register_notifier);
 int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
 {
 	return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb);
 }
 EXPORT_SYMBOL_GPL(bus_unregister_notifier);
 struct kset *bus_get_kset(struct bus_type *bus)
 {
 	return &bus->p->subsys;
 }
 EXPORT_SYMBOL_GPL(bus_get_kset);
 struct klist *bus_get_device_klist(struct bus_type *bus)
 {
 	return &bus->p->klist_devices;
 }
 EXPORT_SYMBOL_GPL(bus_get_device_klist);
 /*
  * Yes, this forcibly breaks the klist abstraction temporarily.  It
  * just wants to sort the klist, not change reference counts and
  * take/drop locks rapidly in the process.  It does all this while
  * holding the lock for the list, so objects can't otherwise be
  * added/removed while we're swizzling.
  */
 static void device_insertion_sort_klist(struct device *a, struct list_head *list,
 					int (*compare)(const struct device *a,
 							const struct device *b))
 {
 	struct list_head *pos;
 	struct klist_node *n;
 	struct device_private *dev_prv;
 	struct device *b;
 	list_for_each(pos, list) {
 		n = container_of(pos, struct klist_node, n_node);
 		dev_prv = to_device_private_bus(n);
 		b = dev_prv->device;
 		if (compare(a, b) <= 0) {
 			list_move_tail(&a->p->knode_bus.n_node,
 				       &b->p->knode_bus.n_node);
 			return;
 		}
 	}
 	list_move_tail(&a->p->knode_bus.n_node, list);
 }
 void bus_sort_breadthfirst(struct bus_type *bus,
 			   int (*compare)(const struct device *a,
 					  const struct device *b))
 {
 	LIST_HEAD(sorted_devices);
 	struct list_head *pos, *tmp;
 	struct klist_node *n;
 	struct device_private *dev_prv;
 	struct device *dev;
 	struct klist *device_klist;
 	device_klist = bus_get_device_klist(bus);
 	spin_lock(&device_klist->k_lock);
 	list_for_each_safe(pos, tmp, &device_klist->k_list) {
 		n = container_of(pos, struct klist_node, n_node);
 		dev_prv = to_device_private_bus(n);
 		dev = dev_prv->device;
 		device_insertion_sort_klist(dev, &sorted_devices, compare);
 	}
 	list_splice(&sorted_devices, &device_klist->k_list);
 	spin_unlock(&device_klist->k_lock);
 }
 EXPORT_SYMBOL_GPL(bus_sort_breadthfirst);
 /**
  * subsys_dev_iter_init - initialize subsys device iterator
  * @iter: subsys iterator to initialize
  * @subsys: the subsys we wanna iterate over
  * @start: the device to start iterating from, if any
  * @type: device_type of the devices to iterate over, NULL for all
  *
  * Initialize subsys iterator @iter such that it iterates over devices
  * of @subsys.  If @start is set, the list iteration will start there,
  * otherwise if it is NULL, the iteration starts at the beginning of
  * the list.
  */
-void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys,
+int subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys,
-			  struct device *start, const struct device_type *type)
+			 struct device *start, const struct device_type *type)
 {
 	struct klist_node *start_knode = NULL;
+	int error;
 	if (start)
 		start_knode = &start->p->knode_bus;
-	klist_iter_init_node(&subsys->p->klist_devices, &iter->ki, start_knode);
+	error = klist_iter_init_node(&subsys->p->klist_devices, &iter->ki,
-	iter->type = type;
+				     start_knode);
+	if (!error)
+		iter->type = type;
+	return error;
 }
 EXPORT_SYMBOL_GPL(subsys_dev_iter_init);
 /**
  * subsys_dev_iter_next - iterate to the next device
  * @iter: subsys iterator to proceed
  *
  * Proceed @iter to the next device and return it.  Returns NULL if
  * iteration is complete.
  *
  * The returned device is referenced and won't be released till
  * iterator is proceed to the next device or exited.  The caller is
  * free to do whatever it wants to do with the device including
  * calling back into subsys code.
  */
 struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter)
 {
 	struct klist_node *knode;
 	struct device *dev;
 	for (;;) {
 		knode = klist_next(&iter->ki);
 		if (!knode)
 			return NULL;
 		dev = container_of(knode, struct device_private, knode_bus)->device;
 		if (!iter->type || iter->type == dev->type)
 			return dev;
 	}
 }
 EXPORT_SYMBOL_GPL(subsys_dev_iter_next);
 /**
  * subsys_dev_iter_exit - finish iteration
  * @iter: subsys iterator to finish
  *
  * Finish an iteration.  Always call this function after iteration is
  * complete whether the iteration ran till the end or not.
  */
 void subsys_dev_iter_exit(struct subsys_dev_iter *iter)
 {
 	klist_iter_exit(&iter->ki);
 }
 EXPORT_SYMBOL_GPL(subsys_dev_iter_exit);
 int subsys_interface_register(struct subsys_interface *sif)
 {
 	struct bus_type *subsys;
 	struct subsys_dev_iter iter;
 	struct device *dev;
 	if (!sif || !sif->subsys)
 		return -ENODEV;
 	subsys = bus_get(sif->subsys);
 	if (!subsys)
 		return -EINVAL;
 	mutex_lock(&subsys->p->mutex);
 	list_add_tail(&sif->node, &subsys->p->interfaces);
 	if (sif->add_dev) {
 		subsys_dev_iter_init(&iter, subsys, NULL, NULL);
 		while ((dev = subsys_dev_iter_next(&iter)))
 			sif->add_dev(dev, sif);
 		subsys_dev_iter_exit(&iter);
 	}
 	mutex_unlock(&subsys->p->mutex);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(subsys_interface_register);
 void subsys_interface_unregister(struct subsys_interface *sif)
 {
 	struct bus_type *subsys;
 	struct subsys_dev_iter iter;
 	struct device *dev;
 	if (!sif || !sif->subsys)
 		return;
 	subsys = sif->subsys;
 	mutex_lock(&subsys->p->mutex);
 	list_del_init(&sif->node);
 	if (sif->remove_dev) {
 		subsys_dev_iter_init(&iter, subsys, NULL, NULL);
 		while ((dev = subsys_dev_iter_next(&iter)))
 			sif->remove_dev(dev, sif);
 		subsys_dev_iter_exit(&iter);
 	}
 	mutex_unlock(&subsys->p->mutex);
 	bus_put(subsys);
 }
 EXPORT_SYMBOL_GPL(subsys_interface_unregister);
 static void system_root_device_release(struct device *dev)
 {
 	kfree(dev);
 }
 /**
  * subsys_system_register - register a subsystem at /sys/devices/system/
  * @subsys: system subsystem
  * @groups: default attributes for the root device
  *
  * All 'system' subsystems have a /sys/devices/system/<name> root device
  * with the name of the subsystem. The root device can carry subsystem-
  * wide attributes. All registered devices are below this single root
  * device and are named after the subsystem with a simple enumeration
  * number appended. The registered devices are not explicitely named;
  * only 'id' in the device needs to be set.
  *
  * Do not use this interface for anything new, it exists for compatibility
  * with bad ideas only. New subsystems should use plain subsystems; and
  * add the subsystem-wide attributes should be added to the subsystem
  * directory itself and not some create fake root-device placed in
  * /sys/devices/system/<name>.
  */
 int subsys_system_register(struct bus_type *subsys,
 			   const struct attribute_group **groups)
 {
 	struct device *dev;
 	int err;
 	err = bus_register(subsys);
 	if (err < 0)
 		return err;
 	dev = kzalloc(sizeof(struct device), GFP_KERNEL);
 	if (!dev) {
 		err = -ENOMEM;
 		goto err_dev;
 	}
 	err = dev_set_name(dev, "%s", subsys->name);
 	if (err < 0)
 		goto err_name;
 	dev->kobj.parent = &system_kset->kobj;
 	dev->groups = groups;
 	dev->release = system_root_device_release;
 	err = device_register(dev);
 	if (err < 0)
 		goto err_dev_reg;
 	subsys->dev_root = dev;
 	return 0;
 err_dev_reg:
 	put_device(dev);
 	dev = NULL;
 err_name:
 	kfree(dev);
 err_dev:
 	bus_unregister(subsys);
 	return err;
 }
 EXPORT_SYMBOL_GPL(subsys_system_register);
 int __init buses_init(void)
 {
 	bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
 	if (!bus_kset)
 		return -ENOMEM;
 	system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
 	if (!system_kset)
 		return -ENOMEM;
 	return 0;
 }

drivers/base/class.c

Diff comments View file @ a15d49f

 /*
  * class.c - basic device class management
  *
  * Copyright (c) 2002-3 Patrick Mochel
  * Copyright (c) 2002-3 Open Source Development Labs
  * Copyright (c) 2003-2004 Greg Kroah-Hartman
  * Copyright (c) 2003-2004 IBM Corp.
  *
  * This file is released under the GPLv2
  *
  */
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/kdev_t.h>
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/genhd.h>
 #include <linux/mutex.h>
 #include "base.h"
 #define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
 static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
 			       char *buf)
 {
 	struct class_attribute *class_attr = to_class_attr(attr);
 	struct subsys_private *cp = to_subsys_private(kobj);
 	ssize_t ret = -EIO;
 	if (class_attr->show)
 		ret = class_attr->show(cp->class, class_attr, buf);
 	return ret;
 }
 static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
 				const char *buf, size_t count)
 {
 	struct class_attribute *class_attr = to_class_attr(attr);
 	struct subsys_private *cp = to_subsys_private(kobj);
 	ssize_t ret = -EIO;
 	if (class_attr->store)
 		ret = class_attr->store(cp->class, class_attr, buf, count);
 	return ret;
 }
 static const void *class_attr_namespace(struct kobject *kobj,
 					const struct attribute *attr)
 {
 	struct class_attribute *class_attr = to_class_attr(attr);
 	struct subsys_private *cp = to_subsys_private(kobj);
 	const void *ns = NULL;
 	if (class_attr->namespace)
 		ns = class_attr->namespace(cp->class, class_attr);
 	return ns;
 }
 static void class_release(struct kobject *kobj)
 {
 	struct subsys_private *cp = to_subsys_private(kobj);
 	struct class *class = cp->class;
 	pr_debug("class '%s': release.\n", class->name);
 	if (class->class_release)
 		class->class_release(class);
 	else
 		pr_debug("class '%s' does not have a release() function, "
 			 "be careful\n", class->name);
 	kfree(cp);
 }
 static const struct kobj_ns_type_operations *class_child_ns_type(struct kobject *kobj)
 {
 	struct subsys_private *cp = to_subsys_private(kobj);
 	struct class *class = cp->class;
 	return class->ns_type;
 }
 static const struct sysfs_ops class_sysfs_ops = {
 	.show	   = class_attr_show,
 	.store	   = class_attr_store,
 	.namespace = class_attr_namespace,
 };
 static struct kobj_type class_ktype = {
 	.sysfs_ops	= &class_sysfs_ops,
 	.release	= class_release,
 	.child_ns_type	= class_child_ns_type,
 };
 /* Hotplug events for classes go to the class subsys */
 static struct kset *class_kset;
 int class_create_file(struct class *cls, const struct class_attribute *attr)
 {
 	int error;
 	if (cls)
 		error = sysfs_create_file(&cls->p->subsys.kobj,
 					  &attr->attr);
 	else
 		error = -EINVAL;
 	return error;
 }
 void class_remove_file(struct class *cls, const struct class_attribute *attr)
 {
 	if (cls)
 		sysfs_remove_file(&cls->p->subsys.kobj, &attr->attr);
 }
 static struct class *class_get(struct class *cls)
 {
 	if (cls)
 		kset_get(&cls->p->subsys);
 	return cls;
 }
 static void class_put(struct class *cls)
 {
 	if (cls)
 		kset_put(&cls->p->subsys);
 }
 static int add_class_attrs(struct class *cls)
 {
 	int i;
 	int error = 0;
 	if (cls->class_attrs) {
 		for (i = 0; attr_name(cls->class_attrs[i]); i++) {
 			error = class_create_file(cls, &cls->class_attrs[i]);
 			if (error)
 				goto error;
 		}
 	}
 done:
 	return error;
 error:
 	while (--i >= 0)
 		class_remove_file(cls, &cls->class_attrs[i]);
 	goto done;
 }
 static void remove_class_attrs(struct class *cls)
 {
 	int i;
 	if (cls->class_attrs) {
 		for (i = 0; attr_name(cls->class_attrs[i]); i++)
 			class_remove_file(cls, &cls->class_attrs[i]);
 	}
 }
 static void klist_class_dev_get(struct klist_node *n)
 {
 	struct device *dev = container_of(n, struct device, knode_class);
 	get_device(dev);
 }
 static void klist_class_dev_put(struct klist_node *n)
 {
 	struct device *dev = container_of(n, struct device, knode_class);
 	put_device(dev);
 }
 int __class_register(struct class *cls, struct lock_class_key *key)
 {
 	struct subsys_private *cp;
 	int error;
 	pr_debug("device class '%s': registering\n", cls->name);
 	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
 	if (!cp)
 		return -ENOMEM;
 	klist_init(&cp->klist_devices, klist_class_dev_get, klist_class_dev_put);
 	INIT_LIST_HEAD(&cp->interfaces);
 	kset_init(&cp->glue_dirs);
 	__mutex_init(&cp->mutex, "subsys mutex", key);
 	error = kobject_set_name(&cp->subsys.kobj, "%s", cls->name);
 	if (error) {
 		kfree(cp);
 		return error;
 	}
 	/* set the default /sys/dev directory for devices of this class */
 	if (!cls->dev_kobj)
 		cls->dev_kobj = sysfs_dev_char_kobj;
 #if defined(CONFIG_BLOCK)
 	/* let the block class directory show up in the root of sysfs */
 	if (!sysfs_deprecated || cls != &block_class)
 		cp->subsys.kobj.kset = class_kset;
 #else
 	cp->subsys.kobj.kset = class_kset;
 #endif
 	cp->subsys.kobj.ktype = &class_ktype;
 	cp->class = cls;
 	cls->p = cp;
 	error = kset_register(&cp->subsys);
 	if (error) {
 		kfree(cp);
 		return error;
 	}
 	error = add_class_attrs(class_get(cls));
 	class_put(cls);
 	return error;
 }
 EXPORT_SYMBOL_GPL(__class_register);
 void class_unregister(struct class *cls)
 {
 	pr_debug("device class '%s': unregistering\n", cls->name);
 	remove_class_attrs(cls);
 	kset_unregister(&cls->p->subsys);
 }
 static void class_create_release(struct class *cls)
 {
 	pr_debug("%s called for %s\n", __func__, cls->name);
 	kfree(cls);
 }
 /**
  * class_create - create a struct class structure
  * @owner: pointer to the module that is to "own" this struct class
  * @name: pointer to a string for the name of this class.
  * @key: the lock_class_key for this class; used by mutex lock debugging
  *
  * This is used to create a struct class pointer that can then be used
  * in calls to device_create().
  *
  * Returns &struct class pointer on success, or ERR_PTR() on error.
  *
  * Note, the pointer created here is to be destroyed when finished by
  * making a call to class_destroy().
  */
 struct class *__class_create(struct module *owner, const char *name,
 			     struct lock_class_key *key)
 {
 	struct class *cls;
 	int retval;
 	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
 	if (!cls) {
 		retval = -ENOMEM;
 		goto error;
 	}
 	cls->name = name;
 	cls->owner = owner;
 	cls->class_release = class_create_release;
 	retval = __class_register(cls, key);
 	if (retval)
 		goto error;
 	return cls;
 error:
 	kfree(cls);
 	return ERR_PTR(retval);
 }
 EXPORT_SYMBOL_GPL(__class_create);
 /**
  * class_destroy - destroys a struct class structure
  * @cls: pointer to the struct class that is to be destroyed
  *
  * Note, the pointer to be destroyed must have been created with a call
  * to class_create().
  */
 void class_destroy(struct class *cls)
 {
 	if ((cls == NULL) || (IS_ERR(cls)))
 		return;
 	class_unregister(cls);
 }
 /**
  * class_dev_iter_init - initialize class device iterator
  * @iter: class iterator to initialize
  * @class: the class we wanna iterate over
  * @start: the device to start iterating from, if any
  * @type: device_type of the devices to iterate over, NULL for all
  *
  * Initialize class iterator @iter such that it iterates over devices
  * of @class.  If @start is set, the list iteration will start there,
  * otherwise if it is NULL, the iteration starts at the beginning of
  * the list.
  */
-void class_dev_iter_init(struct class_dev_iter *iter, struct class *class,
+int class_dev_iter_init(struct class_dev_iter *iter, struct class *class,
-			 struct device *start, const struct device_type *type)
+			struct device *start, const struct device_type *type)
 {
 	struct klist_node *start_knode = NULL;
+	int error;
 	if (start)
 		start_knode = &start->knode_class;
-	klist_iter_init_node(&class->p->klist_devices, &iter->ki, start_knode);
+	error = klist_iter_init_node(&class->p->klist_devices, &iter->ki,
-	iter->type = type;
+				     start_knode);
+	if (!error)
+		iter->type = type;
+	return error;
 }
 EXPORT_SYMBOL_GPL(class_dev_iter_init);
 /**
  * class_dev_iter_next - iterate to the next device
  * @iter: class iterator to proceed
  *
  * Proceed @iter to the next device and return it.  Returns NULL if
  * iteration is complete.
  *
  * The returned device is referenced and won't be released till
  * iterator is proceed to the next device or exited.  The caller is
  * free to do whatever it wants to do with the device including
  * calling back into class code.
  */
 struct device *class_dev_iter_next(struct class_dev_iter *iter)
 {
 	struct klist_node *knode;
 	struct device *dev;
 	while (1) {
 		knode = klist_next(&iter->ki);
 		if (!knode)
 			return NULL;
 		dev = container_of(knode, struct device, knode_class);
 		if (!iter->type || iter->type == dev->type)
 			return dev;
 	}
 }
 EXPORT_SYMBOL_GPL(class_dev_iter_next);
 /**
  * class_dev_iter_exit - finish iteration
  * @iter: class iterator to finish
  *
  * Finish an iteration.  Always call this function after iteration is
  * complete whether the iteration ran till the end or not.
  */
 void class_dev_iter_exit(struct class_dev_iter *iter)
 {
 	klist_iter_exit(&iter->ki);
 }
 EXPORT_SYMBOL_GPL(class_dev_iter_exit);
 /**
  * class_for_each_device - device iterator
  * @class: the class we're iterating
  * @start: the device to start with in the list, if any.
  * @data: data for the callback
  * @fn: function to be called for each device
  *
  * Iterate over @class's list of devices, and call @fn for each,
  * passing it @data.  If @start is set, the list iteration will start
  * there, otherwise if it is NULL, the iteration starts at the
  * beginning of the list.
  *
  * We check the return of @fn each time. If it returns anything
  * other than 0, we break out and return that value.
  *
  * @fn is allowed to do anything including calling back into class
  * code.  There's no locking restriction.
  */
 int class_for_each_device(struct class *class, struct device *start,
 			  void *data, int (*fn)(struct device *, void *))
 {
 	struct class_dev_iter iter;
 	struct device *dev;
 	int error = 0;
 	if (!class)
 		return -EINVAL;
 	if (!class->p) {
 		WARN(1, "%s called for class '%s' before it was initialized",
 		     __func__, class->name);
 		return -EINVAL;
 	}
-	class_dev_iter_init(&iter, class, start, NULL);
+	error = class_dev_iter_init(&iter, class, start, NULL);
-	while ((dev = class_dev_iter_next(&iter))) {
+	if (!error) {
-		error = fn(dev, data);
+		while ((dev = class_dev_iter_next(&iter))) {
-		if (error)
+			error = fn(dev, data);
-			break;
+			if (error)
+				break;
+		}
+		class_dev_iter_exit(&iter);
 	}
-	class_dev_iter_exit(&iter);
 	return error;
 }
 EXPORT_SYMBOL_GPL(class_for_each_device);
 /**
  * class_find_device - device iterator for locating a particular device
  * @class: the class we're iterating
  * @start: Device to begin with
  * @data: data for the match function
  * @match: function to check device
  *
  * This is similar to the class_for_each_dev() function above, but it
  * returns a reference to a device that is 'found' for later use, as
  * determined by the @match callback.
  *
  * The callback should return 0 if the device doesn't match and non-zero
  * if it does.  If the callback returns non-zero, this function will
  * return to the caller and not iterate over any more devices.
  *
  * Note, you will need to drop the reference with put_device() after use.
  *
  * @fn is allowed to do anything including calling back into class
  * code.  There's no locking restriction.
  */
 struct device *class_find_device(struct class *class, struct device *start,
 				 void *data,
 				 int (*match)(struct device *, void *))
 {
 	struct class_dev_iter iter;
 	struct device *dev;
 	if (!class)
 		return NULL;
 	if (!class->p) {
 		WARN(1, "%s called for class '%s' before it was initialized",
 		     __func__, class->name);
 		return NULL;
 	}
-	class_dev_iter_init(&iter, class, start, NULL);
+	if (class_dev_iter_init(&iter, class, start, NULL) < 0)
+		return NULL;
 	while ((dev = class_dev_iter_next(&iter))) {
 		if (match(dev, data)) {
 			get_device(dev);
 			break;
 		}
 	}
 	class_dev_iter_exit(&iter);
 	return dev;
 }
 EXPORT_SYMBOL_GPL(class_find_device);
 int class_interface_register(struct class_interface *class_intf)
 {
 	struct class *parent;
 	struct class_dev_iter iter;
 	struct device *dev;
 	if (!class_intf || !class_intf->class)
 		return -ENODEV;
 	parent = class_get(class_intf->class);
 	if (!parent)
 		return -EINVAL;
 	mutex_lock(&parent->p->mutex);
 	list_add_tail(&class_intf->node, &parent->p->interfaces);
 	if (class_intf->add_dev) {
 		class_dev_iter_init(&iter, parent, NULL, NULL);
 		while ((dev = class_dev_iter_next(&iter)))
 			class_intf->add_dev(dev, class_intf);
 		class_dev_iter_exit(&iter);
 	}
 	mutex_unlock(&parent->p->mutex);
 	return 0;
 }
 void class_interface_unregister(struct class_interface *class_intf)
 {
 	struct class *parent = class_intf->class;
 	struct class_dev_iter iter;
 	struct device *dev;
 	if (!parent)
 		return;
 	mutex_lock(&parent->p->mutex);
 	list_del_init(&class_intf->node);
 	if (class_intf->remove_dev) {
 		class_dev_iter_init(&iter, parent, NULL, NULL);
 		while ((dev = class_dev_iter_next(&iter)))
 			class_intf->remove_dev(dev, class_intf);
 		class_dev_iter_exit(&iter);
 	}
 	mutex_unlock(&parent->p->mutex);
 	class_put(parent);
 }
 ssize_t show_class_attr_string(struct class *class,
 			       struct class_attribute *attr, char *buf)
 {
 	struct class_attribute_string *cs;
 	cs = container_of(attr, struct class_attribute_string, attr);
 	return snprintf(buf, PAGE_SIZE, "%s\n", cs->str);
 }
 EXPORT_SYMBOL_GPL(show_class_attr_string);
 struct class_compat {
 	struct kobject *kobj;
 };
 /**
  * class_compat_register - register a compatibility class
  * @name: the name of the class
  *
  * Compatibility class are meant as a temporary user-space compatibility
  * workaround when converting a family of class devices to a bus devices.
  */
 struct class_compat *class_compat_register(const char *name)
 {
 	struct class_compat *cls;
 	cls = kmalloc(sizeof(struct class_compat), GFP_KERNEL);
 	if (!cls)
 		return NULL;
 	cls->kobj = kobject_create_and_add(name, &class_kset->kobj);
 	if (!cls->kobj) {
 		kfree(cls);
 		return NULL;
 	}
 	return cls;
 }
 EXPORT_SYMBOL_GPL(class_compat_register);
 /**
  * class_compat_unregister - unregister a compatibility class
  * @cls: the class to unregister
  */
 void class_compat_unregister(struct class_compat *cls)
 {
 	kobject_put(cls->kobj);
 	kfree(cls);
 }
 EXPORT_SYMBOL_GPL(class_compat_unregister);
 /**
  * class_compat_create_link - create a compatibility class device link to
  *			      a bus device
  * @cls: the compatibility class
  * @dev: the target bus device
  * @device_link: an optional device to which a "device" link should be created
  */
 int class_compat_create_link(struct class_compat *cls, struct device *dev,
 			     struct device *device_link)
 {
 	int error;
 	error = sysfs_create_link(cls->kobj, &dev->kobj, dev_name(dev));
 	if (error)
 		return error;
 	/*
 	 * Optionally add a "device" link (typically to the parent), as a
 	 * class device would have one and we want to provide as much
 	 * backwards compatibility as possible.
 	 */
 	if (device_link) {
 		error = sysfs_create_link(&dev->kobj, &device_link->kobj,
 					  "device");
 		if (error)
 			sysfs_remove_link(cls->kobj, dev_name(dev));
 	}
 	return error;
 }
 EXPORT_SYMBOL_GPL(class_compat_create_link);
 /**
  * class_compat_remove_link - remove a compatibility class device link to
  *			      a bus device
  * @cls: the compatibility class
  * @dev: the target bus device
  * @device_link: an optional device to which a "device" link was previously
  * 		 created
  */
 void class_compat_remove_link(struct class_compat *cls, struct device *dev,
 			      struct device *device_link)
 {
 	if (device_link)
 		sysfs_remove_link(&dev->kobj, "device");
 	sysfs_remove_link(cls->kobj, dev_name(dev));
 }
 EXPORT_SYMBOL_GPL(class_compat_remove_link);
 int __init classes_init(void)
 {
 	class_kset = kset_create_and_add("class", NULL, NULL);
 	if (!class_kset)
 		return -ENOMEM;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(class_create_file);
 EXPORT_SYMBOL_GPL(class_remove_file);
 EXPORT_SYMBOL_GPL(class_unregister);
 EXPORT_SYMBOL_GPL(class_destroy);
 EXPORT_SYMBOL_GPL(class_interface_register);

drivers/base/driver.c

Diff comments View file @ a15d49f

 /*
  * driver.c - centralized device driver management
  *
  * Copyright (c) 2002-3 Patrick Mochel
  * Copyright (c) 2002-3 Open Source Development Labs
  * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
  * Copyright (c) 2007 Novell Inc.
  *
  * This file is released under the GPLv2
  *
  */
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include "base.h"
 static struct device *next_device(struct klist_iter *i)
 {
 	struct klist_node *n = klist_next(i);
 	struct device *dev = NULL;
 	struct device_private *dev_prv;
 	if (n) {
 		dev_prv = to_device_private_driver(n);
 		dev = dev_prv->device;
 	}
 	return dev;
 }
 /**
  * driver_for_each_device - Iterator for devices bound to a driver.
  * @drv: Driver we're iterating.
  * @start: Device to begin with
  * @data: Data to pass to the callback.
  * @fn: Function to call for each device.
  *
  * Iterate over the @drv's list of devices calling @fn for each one.
  */
 int driver_for_each_device(struct device_driver *drv, struct device *start,
 			   void *data, int (*fn)(struct device *, void *))
 {
 	struct klist_iter i;
 	struct device *dev;
 	int error = 0;
 	if (!drv)
 		return -EINVAL;
-	klist_iter_init_node(&drv->p->klist_devices, &i,
+	error = klist_iter_init_node(&drv->p->klist_devices, &i,
-			     start ? &start->p->knode_driver : NULL);
+				     start ? &start->p->knode_driver : NULL);
-	while ((dev = next_device(&i)) && !error)
+	if (!error) {
-		error = fn(dev, data);
+		while ((dev = next_device(&i)) && !error)
-	klist_iter_exit(&i);
+			error = fn(dev, data);
+		klist_iter_exit(&i);
+	}
 	return error;
 }
 EXPORT_SYMBOL_GPL(driver_for_each_device);
 /**
  * driver_find_device - device iterator for locating a particular device.
  * @drv: The device's driver
  * @start: Device to begin with
  * @data: Data to pass to match function
  * @match: Callback function to check device
  *
  * This is similar to the driver_for_each_device() function above, but
  * it returns a reference to a device that is 'found' for later use, as
  * determined by the @match callback.
  *
  * The callback should return 0 if the device doesn't match and non-zero
  * if it does.  If the callback returns non-zero, this function will
  * return to the caller and not iterate over any more devices.
  */
 struct device *driver_find_device(struct device_driver *drv,
 				  struct device *start, void *data,
 				  int (*match)(struct device *dev, void *data))
 {
 	struct klist_iter i;
 	struct device *dev;
 	if (!drv)
 		return NULL;
-	klist_iter_init_node(&drv->p->klist_devices, &i,
+	if (klist_iter_init_node(&drv->p->klist_devices, &i,
-			     (start ? &start->p->knode_driver : NULL));
+				 (start ? &start->p->knode_driver : NULL)) < 0)
+		return NULL;
 	while ((dev = next_device(&i)))
 		if (match(dev, data) && get_device(dev))
 			break;
 	klist_iter_exit(&i);
 	return dev;
 }
 EXPORT_SYMBOL_GPL(driver_find_device);
 /**
  * driver_create_file - create sysfs file for driver.
  * @drv: driver.
  * @attr: driver attribute descriptor.
  */
 int driver_create_file(struct device_driver *drv,
 		       const struct driver_attribute *attr)
 {
 	int error;
 	if (drv)
 		error = sysfs_create_file(&drv->p->kobj, &attr->attr);
 	else
 		error = -EINVAL;
 	return error;
 }
 EXPORT_SYMBOL_GPL(driver_create_file);
 /**
  * driver_remove_file - remove sysfs file for driver.
  * @drv: driver.
  * @attr: driver attribute descriptor.
  */
 void driver_remove_file(struct device_driver *drv,
 			const struct driver_attribute *attr)
 {
 	if (drv)
 		sysfs_remove_file(&drv->p->kobj, &attr->attr);
 }
 EXPORT_SYMBOL_GPL(driver_remove_file);
 static int driver_add_groups(struct device_driver *drv,
 			     const struct attribute_group **groups)
 {
 	int error = 0;
 	int i;
 	if (groups) {
 		for (i = 0; groups[i]; i++) {
 			error = sysfs_create_group(&drv->p->kobj, groups[i]);
 			if (error) {
 				while (--i >= 0)
 					sysfs_remove_group(&drv->p->kobj,
 							   groups[i]);
 				break;
 			}
 		}
 	}
 	return error;
 }
 static void driver_remove_groups(struct device_driver *drv,
 				 const struct attribute_group **groups)
 {
 	int i;
 	if (groups)
 		for (i = 0; groups[i]; i++)
 			sysfs_remove_group(&drv->p->kobj, groups[i]);
 }
 /**
  * driver_register - register driver with bus
  * @drv: driver to register
  *
  * We pass off most of the work to the bus_add_driver() call,
  * since most of the things we have to do deal with the bus
  * structures.
  */
 int driver_register(struct device_driver *drv)
 {
 	int ret;
 	struct device_driver *other;
 	BUG_ON(!drv->bus->p);
 	if ((drv->bus->probe && drv->probe) ||
 	    (drv->bus->remove && drv->remove) ||
 	    (drv->bus->shutdown && drv->shutdown))
 		printk(KERN_WARNING "Driver '%s' needs updating - please use "
 			"bus_type methods\n", drv->name);
 	other = driver_find(drv->name, drv->bus);
 	if (other) {
 		printk(KERN_ERR "Error: Driver '%s' is already registered, "
 			"aborting...\n", drv->name);
 		return -EBUSY;
 	}
 	ret = bus_add_driver(drv);
 	if (ret)
 		return ret;
 	ret = driver_add_groups(drv, drv->groups);
 	if (ret)
 		bus_remove_driver(drv);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(driver_register);
 /**
  * driver_unregister - remove driver from system.
  * @drv: driver.
  *
  * Again, we pass off most of the work to the bus-level call.
  */
 void driver_unregister(struct device_driver *drv)
 {
 	if (!drv || !drv->p) {
 		WARN(1, "Unexpected driver unregister!\n");
 		return;
 	}
 	driver_remove_groups(drv, drv->groups);
 	bus_remove_driver(drv);
 }
 EXPORT_SYMBOL_GPL(driver_unregister);
 /**
  * driver_find - locate driver on a bus by its name.
  * @name: name of the driver.
  * @bus: bus to scan for the driver.
  *
  * Call kset_find_obj() to iterate over list of drivers on
  * a bus to find driver by name. Return driver if found.
  *
  * This routine provides no locking to prevent the driver it returns
  * from being unregistered or unloaded while the caller is using it.
  * The caller is responsible for preventing this.
  */
 struct device_driver *driver_find(const char *name, struct bus_type *bus)
 {
 	struct kobject *k = kset_find_obj(bus->p->drivers_kset, name);
 	struct driver_private *priv;
 	if (k) {
 		/* Drop reference added by kset_find_obj() */
 		kobject_put(k);
 		priv = to_driver(k);
 		return priv->driver;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(driver_find);

include/linux/device.h

Diff comments View file @ a15d49f

include/linux/klist.h

Diff comments View file @ a15d49f

1	/*	1	/*
2	* klist.h - Some generic list helpers, extending struct list_head a bit.	2	* klist.h - Some generic list helpers, extending struct list_head a bit.
3	*	3	*
4	* Implementations are found in lib/klist.c	4	* Implementations are found in lib/klist.c
5	*	5	*
6	*	6	*
7	* Copyright (C) 2005 Patrick Mochel	7	* Copyright (C) 2005 Patrick Mochel
8	*	8	*
9	* This file is rleased under the GPL v2.	9	* This file is rleased under the GPL v2.
10	*/	10	*/
11		11
12	#ifndef _LINUX_KLIST_H	12	#ifndef _LINUX_KLIST_H
13	#define _LINUX_KLIST_H	13	#define _LINUX_KLIST_H
14		14
15	#include <linux/spinlock.h>	15	#include <linux/spinlock.h>
16	#include <linux/kref.h>	16	#include <linux/kref.h>
17	#include <linux/list.h>	17	#include <linux/list.h>
18		18
19	struct klist_node;	19	struct klist_node;
20	struct klist {	20	struct klist {
21	spinlock_t k_lock;	21	spinlock_t k_lock;
22	struct list_head k_list;	22	struct list_head k_list;
23	void (get)(struct klist_node );	23	void (get)(struct klist_node );
24	void (put)(struct klist_node );	24	void (put)(struct klist_node );
25	} __attribute__ ((aligned (sizeof(void *))));	25	} __attribute__ ((aligned (sizeof(void *))));
26		26
27	#define KLIST_INIT(_name, _get, _put) \	27	#define KLIST_INIT(_name, _get, _put) \
28	{ .k_lock = __SPIN_LOCK_UNLOCKED(_name.k_lock), \	28	{ .k_lock = __SPIN_LOCK_UNLOCKED(_name.k_lock), \
29	.k_list = LIST_HEAD_INIT(_name.k_list), \	29	.k_list = LIST_HEAD_INIT(_name.k_list), \
30	.get = _get, \	30	.get = _get, \
31	.put = _put, }	31	.put = _put, }
32		32
33	#define DEFINE_KLIST(_name, _get, _put) \	33	#define DEFINE_KLIST(_name, _get, _put) \
34	struct klist _name = KLIST_INIT(_name, _get, _put)	34	struct klist _name = KLIST_INIT(_name, _get, _put)
35		35
36	extern void klist_init(struct klist k, void (get)(struct klist_node *),	36	extern void klist_init(struct klist k, void (get)(struct klist_node *),
37	void (put)(struct klist_node ));	37	void (put)(struct klist_node ));
38		38
39	struct klist_node {	39	struct klist_node {
40	void n_klist; / never access directly */	40	void n_klist; / never access directly */
41	struct list_head n_node;	41	struct list_head n_node;
42	struct kref n_ref;	42	struct kref n_ref;
43	};	43	};
44		44
45	extern void klist_add_tail(struct klist_node n, struct klist k);	45	extern void klist_add_tail(struct klist_node n, struct klist k);
46	extern void klist_add_head(struct klist_node n, struct klist k);	46	extern void klist_add_head(struct klist_node n, struct klist k);
47	extern void klist_add_after(struct klist_node n, struct klist_node pos);	47	extern void klist_add_after(struct klist_node n, struct klist_node pos);
48	extern void klist_add_before(struct klist_node n, struct klist_node pos);	48	extern void klist_add_before(struct klist_node n, struct klist_node pos);
49		49
50	extern void klist_del(struct klist_node *n);	50	extern void klist_del(struct klist_node *n);
51	extern void klist_remove(struct klist_node *n);	51	extern void klist_remove(struct klist_node *n);
52		52
53	extern int klist_node_attached(struct klist_node *n);	53	extern int klist_node_attached(struct klist_node *n);
54		54
55		55
56	struct klist_iter {	56	struct klist_iter {
57	struct klist *i_klist;	57	struct klist *i_klist;
58	struct klist_node *i_cur;	58	struct klist_node *i_cur;
59	};	59	};
60		60
61		61
62	extern void klist_iter_init(struct klist k, struct klist_iter i);	62	extern void klist_iter_init(struct klist k, struct klist_iter i);
63	extern void klist_iter_init_node(struct klist k, struct klist_iter i,	63	extern int klist_iter_init_node(struct klist k, struct klist_iter i,
64	struct klist_node *n);	64	struct klist_node *n);
65	extern void klist_iter_exit(struct klist_iter *i);	65	extern void klist_iter_exit(struct klist_iter *i);
66	extern struct klist_node klist_next(struct klist_iter i);	66	extern struct klist_node klist_next(struct klist_iter i);
67		67
68	#endif	68	#endif
69		69

lib/klist.c

Diff comments View file @ a15d49f

 /*
  * klist.c - Routines for manipulating klists.
  *
  * Copyright (C) 2005 Patrick Mochel
  *
  * This file is released under the GPL v2.
  *
  * This klist interface provides a couple of structures that wrap around
  * struct list_head to provide explicit list "head" (struct klist) and list
  * "node" (struct klist_node) objects. For struct klist, a spinlock is
  * included that protects access to the actual list itself. struct
  * klist_node provides a pointer to the klist that owns it and a kref
  * reference count that indicates the number of current users of that node
  * in the list.
  *
  * The entire point is to provide an interface for iterating over a list
  * that is safe and allows for modification of the list during the
  * iteration (e.g. insertion and removal), including modification of the
  * current node on the list.
  *
  * It works using a 3rd object type - struct klist_iter - that is declared
  * and initialized before an iteration. klist_next() is used to acquire the
  * next element in the list. It returns NULL if there are no more items.
  * Internally, that routine takes the klist's lock, decrements the
  * reference count of the previous klist_node and increments the count of
  * the next klist_node. It then drops the lock and returns.
  *
  * There are primitives for adding and removing nodes to/from a klist.
  * When deleting, klist_del() will simply decrement the reference count.
  * Only when the count goes to 0 is the node removed from the list.
  * klist_remove() will try to delete the node from the list and block until
  * it is actually removed. This is useful for objects (like devices) that
  * have been removed from the system and must be freed (but must wait until
  * all accessors have finished).
  */
 #include <linux/klist.h>
 #include <linux/export.h>
 #include <linux/sched.h>
 /*
  * Use the lowest bit of n_klist to mark deleted nodes and exclude
  * dead ones from iteration.
  */
 #define KNODE_DEAD		1LU
 #define KNODE_KLIST_MASK	~KNODE_DEAD
 static struct klist *knode_klist(struct klist_node *knode)
 {
 	return (struct klist *)
 		((unsigned long)knode->n_klist & KNODE_KLIST_MASK);
 }
 static bool knode_dead(struct klist_node *knode)
 {
 	return (unsigned long)knode->n_klist & KNODE_DEAD;
 }
 static void knode_set_klist(struct klist_node *knode, struct klist *klist)
 {
 	knode->n_klist = klist;
 	/* no knode deserves to start its life dead */
 	WARN_ON(knode_dead(knode));
 }
 static void knode_kill(struct klist_node *knode)
 {
 	/* and no knode should die twice ever either, see we're very humane */
 	WARN_ON(knode_dead(knode));
 	*(unsigned long *)&knode->n_klist |= KNODE_DEAD;
 }
 /**
  * klist_init - Initialize a klist structure.
  * @k: The klist we're initializing.
  * @get: The get function for the embedding object (NULL if none)
  * @put: The put function for the embedding object (NULL if none)
  *
  * Initialises the klist structure.  If the klist_node structures are
  * going to be embedded in refcounted objects (necessary for safe
  * deletion) then the get/put arguments are used to initialise
  * functions that take and release references on the embedding
  * objects.
  */
 void klist_init(struct klist *k, void (*get)(struct klist_node *),
 		void (*put)(struct klist_node *))
 {
 	INIT_LIST_HEAD(&k->k_list);
 	spin_lock_init(&k->k_lock);
 	k->get = get;
 	k->put = put;
 }
 EXPORT_SYMBOL_GPL(klist_init);
 static void add_head(struct klist *k, struct klist_node *n)
 {
 	spin_lock(&k->k_lock);
 	list_add(&n->n_node, &k->k_list);
 	spin_unlock(&k->k_lock);
 }
 static void add_tail(struct klist *k, struct klist_node *n)
 {
 	spin_lock(&k->k_lock);
 	list_add_tail(&n->n_node, &k->k_list);
 	spin_unlock(&k->k_lock);
 }
 static void klist_node_init(struct klist *k, struct klist_node *n)
 {
 	INIT_LIST_HEAD(&n->n_node);
 	kref_init(&n->n_ref);
 	knode_set_klist(n, k);
 	if (k->get)
 		k->get(n);
 }
 /**
  * klist_add_head - Initialize a klist_node and add it to front.
  * @n: node we're adding.
  * @k: klist it's going on.
  */
 void klist_add_head(struct klist_node *n, struct klist *k)
 {
 	klist_node_init(k, n);
 	add_head(k, n);
 }
 EXPORT_SYMBOL_GPL(klist_add_head);
 /**
  * klist_add_tail - Initialize a klist_node and add it to back.
  * @n: node we're adding.
  * @k: klist it's going on.
  */
 void klist_add_tail(struct klist_node *n, struct klist *k)
 {
 	klist_node_init(k, n);
 	add_tail(k, n);
 }
 EXPORT_SYMBOL_GPL(klist_add_tail);
 /**
  * klist_add_after - Init a klist_node and add it after an existing node
  * @n: node we're adding.
  * @pos: node to put @n after
  */
 void klist_add_after(struct klist_node *n, struct klist_node *pos)
 {
 	struct klist *k = knode_klist(pos);
 	klist_node_init(k, n);
 	spin_lock(&k->k_lock);
 	list_add(&n->n_node, &pos->n_node);
 	spin_unlock(&k->k_lock);
 }
 EXPORT_SYMBOL_GPL(klist_add_after);
 /**
  * klist_add_before - Init a klist_node and add it before an existing node
  * @n: node we're adding.
  * @pos: node to put @n after
  */
 void klist_add_before(struct klist_node *n, struct klist_node *pos)
 {
 	struct klist *k = knode_klist(pos);
 	klist_node_init(k, n);
 	spin_lock(&k->k_lock);
 	list_add_tail(&n->n_node, &pos->n_node);
 	spin_unlock(&k->k_lock);
 }
 EXPORT_SYMBOL_GPL(klist_add_before);
 struct klist_waiter {
 	struct list_head list;
 	struct klist_node *node;
 	struct task_struct *process;
 	int woken;
 };
 static DEFINE_SPINLOCK(klist_remove_lock);
 static LIST_HEAD(klist_remove_waiters);
 static void klist_release(struct kref *kref)
 {
 	struct klist_waiter *waiter, *tmp;
 	struct klist_node *n = container_of(kref, struct klist_node, n_ref);
 	WARN_ON(!knode_dead(n));
 	list_del(&n->n_node);
 	spin_lock(&klist_remove_lock);
 	list_for_each_entry_safe(waiter, tmp, &klist_remove_waiters, list) {
 		if (waiter->node != n)
 			continue;
 		waiter->woken = 1;
 		mb();
 		wake_up_process(waiter->process);
 		list_del(&waiter->list);
 	}
 	spin_unlock(&klist_remove_lock);
 	knode_set_klist(n, NULL);
 }
 static int klist_dec_and_del(struct klist_node *n)
 {
 	return kref_put(&n->n_ref, klist_release);
 }
 static void klist_put(struct klist_node *n, bool kill)
 {
 	struct klist *k = knode_klist(n);
 	void (*put)(struct klist_node *) = k->put;
 	spin_lock(&k->k_lock);
 	if (kill)
 		knode_kill(n);
 	if (!klist_dec_and_del(n))
 		put = NULL;
 	spin_unlock(&k->k_lock);
 	if (put)
 		put(n);
 }
 /**
  * klist_del - Decrement the reference count of node and try to remove.
  * @n: node we're deleting.
  */
 void klist_del(struct klist_node *n)
 {
 	klist_put(n, true);
 }
 EXPORT_SYMBOL_GPL(klist_del);
 /**
  * klist_remove - Decrement the refcount of node and wait for it to go away.
  * @n: node we're removing.
  */
 void klist_remove(struct klist_node *n)
 {
 	struct klist_waiter waiter;
 	waiter.node = n;
 	waiter.process = current;
 	waiter.woken = 0;
 	spin_lock(&klist_remove_lock);
 	list_add(&waiter.list, &klist_remove_waiters);
 	spin_unlock(&klist_remove_lock);
 	klist_del(n);
 	for (;;) {
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		if (waiter.woken)
 			break;
 		schedule();
 	}
 	__set_current_state(TASK_RUNNING);
 }
 EXPORT_SYMBOL_GPL(klist_remove);
 /**
  * klist_node_attached - Say whether a node is bound to a list or not.
  * @n: Node that we're testing.
  */
 int klist_node_attached(struct klist_node *n)
 {
 	return (n->n_klist != NULL);
 }
 EXPORT_SYMBOL_GPL(klist_node_attached);
 /**
  * klist_iter_init_node - Initialize a klist_iter structure.
  * @k: klist we're iterating.
  * @i: klist_iter we're filling.
  * @n: node to start with.
  *
  * Similar to klist_iter_init(), but starts the action off with @n,
  * instead of with the list head.
  */
-void klist_iter_init_node(struct klist *k, struct klist_iter *i,
+int klist_iter_init_node(struct klist *k, struct klist_iter *i,
-			  struct klist_node *n)
+			 struct klist_node *n)
 {
+	if (n) {
+		kref_get(&n->n_ref);
+		if (!n->n_klist) {
+			kref_put(&n->n_ref);
+			return -ENODEV;
+		}
+	}
 	i->i_klist = k;
 	i->i_cur = n;
-	if (n)
+	return 0;
-		kref_get(&n->n_ref);
 }
 EXPORT_SYMBOL_GPL(klist_iter_init_node);
 /**
  * klist_iter_init - Iniitalize a klist_iter structure.
  * @k: klist we're iterating.
  * @i: klist_iter structure we're filling.
  *
  * Similar to klist_iter_init_node(), but start with the list head.
  */
 void klist_iter_init(struct klist *k, struct klist_iter *i)
 {
 	klist_iter_init_node(k, i, NULL);
 }
 EXPORT_SYMBOL_GPL(klist_iter_init);
 /**
  * klist_iter_exit - Finish a list iteration.
  * @i: Iterator structure.
  *
  * Must be called when done iterating over list, as it decrements the
  * refcount of the current node. Necessary in case iteration exited before
  * the end of the list was reached, and always good form.
  */
 void klist_iter_exit(struct klist_iter *i)
 {
 	if (i->i_cur) {
 		klist_put(i->i_cur, false);
 		i->i_cur = NULL;
 	}
 }
 EXPORT_SYMBOL_GPL(klist_iter_exit);
 static struct klist_node *to_klist_node(struct list_head *n)
 {
 	return container_of(n, struct klist_node, n_node);
 }
 /**
  * klist_next - Ante up next node in list.
  * @i: Iterator structure.
  *
  * First grab list lock. Decrement the reference count of the previous
  * node, if there was one. Grab the next node, increment its reference
  * count, drop the lock, and return that next node.
  */
 struct klist_node *klist_next(struct klist_iter *i)
 {
 	void (*put)(struct klist_node *) = i->i_klist->put;
 	struct klist_node *last = i->i_cur;
 	struct klist_node *next;
 	spin_lock(&i->i_klist->k_lock);
 	if (last) {
 		next = to_klist_node(last->n_node.next);
 		if (!klist_dec_and_del(last))
 			put = NULL;
 	} else
 		next = to_klist_node(i->i_klist->k_list.next);
 	i->i_cur = NULL;
 	while (next != to_klist_node(&i->i_klist->k_list)) {
 		if (likely(!knode_dead(next))) {
 			kref_get(&next->n_ref);
 			i->i_cur = next;
 			break;
 		}
 		next = to_klist_node(next->n_node.next);
 	}
 	spin_unlock(&i->i_klist->k_lock);
 	if (put && last)
 		put(last);
 	return i->i_cur;
 }
 EXPORT_SYMBOL_GPL(klist_next);

1	/*	1	/*
2	* device.h - generic, centralized driver model	2	* device.h - generic, centralized driver model
3	*	3	*
4	* Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>	4	* Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
5	* Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>	5	* Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
6	* Copyright (c) 2008-2009 Novell Inc.	6	* Copyright (c) 2008-2009 Novell Inc.
7	*	7	*
8	* This file is released under the GPLv2	8	* This file is released under the GPLv2
9	*	9	*
10	* See Documentation/driver-model/ for more information.	10	* See Documentation/driver-model/ for more information.
11	*/	11	*/
12		12
13	#ifndef _DEVICE_H_	13	#ifndef _DEVICE_H_
14	#define _DEVICE_H_	14	#define _DEVICE_H_
15		15
16	#include <linux/ioport.h>	16	#include <linux/ioport.h>
17	#include <linux/kobject.h>	17	#include <linux/kobject.h>
18	#include <linux/klist.h>	18	#include <linux/klist.h>
19	#include <linux/list.h>	19	#include <linux/list.h>
20	#include <linux/lockdep.h>	20	#include <linux/lockdep.h>
21	#include <linux/compiler.h>	21	#include <linux/compiler.h>
22	#include <linux/types.h>	22	#include <linux/types.h>
23	#include <linux/mutex.h>	23	#include <linux/mutex.h>
24	#include <linux/pm.h>	24	#include <linux/pm.h>
25	#include <linux/atomic.h>	25	#include <linux/atomic.h>
26	#include <asm/device.h>	26	#include <asm/device.h>
27		27
28	struct device;	28	struct device;
29	struct device_private;	29	struct device_private;
30	struct device_driver;	30	struct device_driver;
31	struct driver_private;	31	struct driver_private;
32	struct module;	32	struct module;
33	struct class;	33	struct class;
34	struct subsys_private;	34	struct subsys_private;
35	struct bus_type;	35	struct bus_type;
36	struct device_node;	36	struct device_node;
37	struct iommu_ops;	37	struct iommu_ops;
38		38
39	struct bus_attribute {	39	struct bus_attribute {
40	struct attribute attr;	40	struct attribute attr;