Merge tag 'driver-core-3.3-rc1-bugfixes' of... (0a962657) · Commits · 戴 / test

Documentation/driver-model/devres.txt

+4 −0

Original line number	Diff line number	Diff line
		@@ -233,6 +233,10 @@ certainly invest a bit more effort into libata core layer).
		6. List of managed interfaces
		-----------------------------

		MEM
		devm_kzalloc()
		devm_kfree()

		IO region
		devm_request_region()
		devm_request_mem_region()

Documentation/stable_kernel_rules.txt

+2 −1

Original line number	Diff line number	Diff line
		@@ -25,7 +25,8 @@ Procedure for submitting patches to the -stable tree:

		- Send the patch, after verifying that it follows the above rules, to
		stable@vger.kernel.org. You must note the upstream commit ID in the
		changelog of your submission.
		changelog of your submission, as well as the kernel version you wish
		it to be applied to.
		- To have the patch automatically included in the stable tree, add the tag
		Cc: stable@vger.kernel.org
		in the sign-off area. Once the patch is merged it will be applied to

drivers/base/Makefile

+1 −1

Original line number	Diff line number	Diff line
		# Makefile for the Linux device tree

		obj-y := core.o sys.o bus.o dd.o syscore.o \
		obj-y := core.o bus.o dd.o syscore.o \
		driver.o class.o platform.o \
		cpu.o firmware.o init.o map.o devres.o \
		attribute_container.o transport_class.o \

drivers/base/core.c

+16 −1

Original line number	Diff line number	Diff line
		@@ -632,6 +632,11 @@ static void klist_children_put(struct klist_node *n)
		* may be used for reference counting of @dev after calling this
		* function.
		*
		* All fields in @dev must be initialized by the caller to 0, except
		* for those explicitly set to some other value. The simplest
		* approach is to use kzalloc() to allocate the structure containing
		* @dev.
		*
		* NOTE: Use put_device() to give up your reference instead of freeing
		* @dev directly once you have called this function.
		*/
		@@ -930,6 +935,13 @@ int device_private_init(struct device *dev)
		* to the global and sibling lists for the device, then
		* adds it to the other relevant subsystems of the driver model.
		*
		* Do not call this routine or device_register() more than once for
		* any device structure. The driver model core is not designed to work
		* with devices that get unregistered and then spring back to life.
		* (Among other things, it's very hard to guarantee that all references
		* to the previous incarnation of @dev have been dropped.) Allocate
		* and register a fresh new struct device instead.
		*
		* NOTE: _Never_ directly free @dev after calling this function, even
		* if it returned an error! Always use put_device() to give up your
		* reference instead.
		@@ -1022,7 +1034,7 @@ int device_add(struct device *dev)
		device_pm_add(dev);

		/* Notify clients of device addition. This call must come
		* after dpm_sysf_add() and before kobject_uevent().
		* after dpm_sysfs_add() and before kobject_uevent().
		*/
		if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
		@@ -1090,6 +1102,9 @@ name_error:
		* have a clearly defined need to use and refcount the device
		* before it is added to the hierarchy.
		*
		* For more information, see the kerneldoc for device_initialize()
		* and device_add().
		*
		* NOTE: _Never_ directly free @dev after calling this function, even
		* if it returned an error! Always use put_device() to give up the
		* reference initialized in this function instead.

drivers/base/sys.c

deleted100644 → 0

+0 −383

Original line number	Diff line number	Diff line
		/*
		* sys.c - pseudo-bus for system 'devices' (cpus, PICs, timers, etc)
		*
		* Copyright (c) 2002-3 Patrick Mochel
		* 2002-3 Open Source Development Lab
		*
		* This file is released under the GPLv2
		*
		* This exports a 'system' bus type.
		* By default, a 'sys' bus gets added to the root of the system. There will
		* always be core system devices. Devices can use sysdev_register() to
		* add themselves as children of the system bus.
		*/

		#include <linux/sysdev.h>
		#include <linux/err.h>
		#include <linux/module.h>
		#include <linux/kernel.h>
		#include <linux/init.h>
		#include <linux/string.h>
		#include <linux/pm.h>
		#include <linux/device.h>
		#include <linux/mutex.h>
		#include <linux/interrupt.h>

		#include "base.h"

		#define to_sysdev(k) container_of(k, struct sys_device, kobj)
		#define to_sysdev_attr(a) container_of(a, struct sysdev_attribute, attr)


		static ssize_t
		sysdev_show(struct kobject kobj, struct attribute attr, char *buffer)
		{
		struct sys_device *sysdev = to_sysdev(kobj);
		struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);

		if (sysdev_attr->show)
		return sysdev_attr->show(sysdev, sysdev_attr, buffer);
		return -EIO;
		}


		static ssize_t
		sysdev_store(struct kobject kobj, struct attribute attr,
		const char *buffer, size_t count)
		{
		struct sys_device *sysdev = to_sysdev(kobj);
		struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);

		if (sysdev_attr->store)
		return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
		return -EIO;
		}

		static const struct sysfs_ops sysfs_ops = {
		.show = sysdev_show,
		.store = sysdev_store,
		};

		static struct kobj_type ktype_sysdev = {
		.sysfs_ops = &sysfs_ops,
		};


		int sysdev_create_file(struct sys_device s, struct sysdev_attribute a)
		{
		return sysfs_create_file(&s->kobj, &a->attr);
		}


		void sysdev_remove_file(struct sys_device s, struct sysdev_attribute a)
		{
		sysfs_remove_file(&s->kobj, &a->attr);
		}

		EXPORT_SYMBOL_GPL(sysdev_create_file);
		EXPORT_SYMBOL_GPL(sysdev_remove_file);

		#define to_sysdev_class(k) container_of(k, struct sysdev_class, kset.kobj)
		#define to_sysdev_class_attr(a) container_of(a, \
		struct sysdev_class_attribute, attr)

		static ssize_t sysdev_class_show(struct kobject kobj, struct attribute attr,
		char *buffer)
		{
		struct sysdev_class *class = to_sysdev_class(kobj);
		struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);

		if (class_attr->show)
		return class_attr->show(class, class_attr, buffer);
		return -EIO;
		}

		static ssize_t sysdev_class_store(struct kobject kobj, struct attribute attr,
		const char *buffer, size_t count)
		{
		struct sysdev_class *class = to_sysdev_class(kobj);
		struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);

		if (class_attr->store)
		return class_attr->store(class, class_attr, buffer, count);
		return -EIO;
		}

		static const struct sysfs_ops sysfs_class_ops = {
		.show = sysdev_class_show,
		.store = sysdev_class_store,
		};

		static struct kobj_type ktype_sysdev_class = {
		.sysfs_ops = &sysfs_class_ops,
		};

		int sysdev_class_create_file(struct sysdev_class *c,
		struct sysdev_class_attribute *a)
		{
		return sysfs_create_file(&c->kset.kobj, &a->attr);
		}
		EXPORT_SYMBOL_GPL(sysdev_class_create_file);

		void sysdev_class_remove_file(struct sysdev_class *c,
		struct sysdev_class_attribute *a)
		{
		sysfs_remove_file(&c->kset.kobj, &a->attr);
		}
		EXPORT_SYMBOL_GPL(sysdev_class_remove_file);

		extern struct kset *system_kset;

		int sysdev_class_register(struct sysdev_class *cls)
		{
		int retval;

		pr_debug("Registering sysdev class '%s'\n", cls->name);

		INIT_LIST_HEAD(&cls->drivers);
		memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
		cls->kset.kobj.parent = &system_kset->kobj;
		cls->kset.kobj.ktype = &ktype_sysdev_class;
		cls->kset.kobj.kset = system_kset;

		retval = kobject_set_name(&cls->kset.kobj, "%s", cls->name);
		if (retval)
		return retval;

		retval = kset_register(&cls->kset);
		if (!retval && cls->attrs)
		retval = sysfs_create_files(&cls->kset.kobj,
		(const struct attribute **)cls->attrs);
		return retval;
		}

		void sysdev_class_unregister(struct sysdev_class *cls)
		{
		pr_debug("Unregistering sysdev class '%s'\n",
		kobject_name(&cls->kset.kobj));
		if (cls->attrs)
		sysfs_remove_files(&cls->kset.kobj,
		(const struct attribute **)cls->attrs);
		kset_unregister(&cls->kset);
		}

		EXPORT_SYMBOL_GPL(sysdev_class_register);
		EXPORT_SYMBOL_GPL(sysdev_class_unregister);

		static DEFINE_MUTEX(sysdev_drivers_lock);

		/*
		* @dev != NULL means that we're unwinding because some drv->add()
		* failed for some reason. You need to grab sysdev_drivers_lock before
		* calling this.
		*/
		static void __sysdev_driver_remove(struct sysdev_class *cls,
		struct sysdev_driver *drv,
		struct sys_device *from_dev)
		{
		struct sys_device *dev = from_dev;

		list_del_init(&drv->entry);
		if (!cls)
		return;

		if (!drv->remove)
		goto kset_put;

		if (dev)
		list_for_each_entry_continue_reverse(dev, &cls->kset.list,
		kobj.entry)
		drv->remove(dev);
		else
		list_for_each_entry(dev, &cls->kset.list, kobj.entry)
		drv->remove(dev);

		kset_put:
		kset_put(&cls->kset);
		}

		/**
		* sysdev_driver_register - Register auxiliary driver
		* @cls: Device class driver belongs to.
		* @drv: Driver.
		*
		* @drv is inserted into @cls->drivers to be
		* called on each operation on devices of that class. The refcount
		* of @cls is incremented.
		*/
		int sysdev_driver_register(struct sysdev_class cls, struct sysdev_driver drv)
		{
		struct sys_device *dev = NULL;
		int err = 0;

		if (!cls) {
		WARN(1, KERN_WARNING "sysdev: invalid class passed to %s!\n",
		__func__);
		return -EINVAL;
		}

		/* Check whether this driver has already been added to a class. */
		if (drv->entry.next && !list_empty(&drv->entry))
		WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
		" been registered to a class, something is wrong, but "
		"will forge on!\n", cls->name, drv);

		mutex_lock(&sysdev_drivers_lock);
		if (cls && kset_get(&cls->kset)) {
		list_add_tail(&drv->entry, &cls->drivers);

		/* If devices of this class already exist, tell the driver */
		if (drv->add) {
		list_for_each_entry(dev, &cls->kset.list, kobj.entry) {
		err = drv->add(dev);
		if (err)
		goto unwind;
		}
		}
		} else {
		err = -EINVAL;
		WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
		}

		goto unlock;

		unwind:
		__sysdev_driver_remove(cls, drv, dev);

		unlock:
		mutex_unlock(&sysdev_drivers_lock);
		return err;
		}

		/**
		* sysdev_driver_unregister - Remove an auxiliary driver.
		* @cls: Class driver belongs to.
		* @drv: Driver.
		*/
		void sysdev_driver_unregister(struct sysdev_class *cls,
		struct sysdev_driver *drv)
		{
		mutex_lock(&sysdev_drivers_lock);
		__sysdev_driver_remove(cls, drv, NULL);
		mutex_unlock(&sysdev_drivers_lock);
		}
		EXPORT_SYMBOL_GPL(sysdev_driver_register);
		EXPORT_SYMBOL_GPL(sysdev_driver_unregister);

		/**
		* sysdev_register - add a system device to the tree
		* @sysdev: device in question
		*
		*/
		int sysdev_register(struct sys_device *sysdev)
		{
		int error;
		struct sysdev_class *cls = sysdev->cls;

		if (!cls)
		return -EINVAL;

		pr_debug("Registering sys device of class '%s'\n",
		kobject_name(&cls->kset.kobj));

		/* initialize the kobject to 0, in case it had previously been used */
		memset(&sysdev->kobj, 0x00, sizeof(struct kobject));

		/* Make sure the kset is set */
		sysdev->kobj.kset = &cls->kset;

		/* Register the object */
		error = kobject_init_and_add(&sysdev->kobj, &ktype_sysdev, NULL,
		"%s%d", kobject_name(&cls->kset.kobj),
		sysdev->id);

		if (!error) {
		struct sysdev_driver *drv;

		pr_debug("Registering sys device '%s'\n",
		kobject_name(&sysdev->kobj));

		mutex_lock(&sysdev_drivers_lock);
		/* Generic notification is implicit, because it's that
		* code that should have called us.
		*/

		/* Notify class auxiliary drivers */
		list_for_each_entry(drv, &cls->drivers, entry) {
		if (drv->add)
		drv->add(sysdev);
		}
		mutex_unlock(&sysdev_drivers_lock);
		kobject_uevent(&sysdev->kobj, KOBJ_ADD);
		}

		return error;
		}

		void sysdev_unregister(struct sys_device *sysdev)
		{
		struct sysdev_driver *drv;

		mutex_lock(&sysdev_drivers_lock);
		list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
		if (drv->remove)
		drv->remove(sysdev);
		}
		mutex_unlock(&sysdev_drivers_lock);

		kobject_put(&sysdev->kobj);
		}

		EXPORT_SYMBOL_GPL(sysdev_register);
		EXPORT_SYMBOL_GPL(sysdev_unregister);

		#define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr)

		ssize_t sysdev_store_ulong(struct sys_device *sysdev,
		struct sysdev_attribute *attr,
		const char *buf, size_t size)
		{
		struct sysdev_ext_attribute *ea = to_ext_attr(attr);
		char *end;
		unsigned long new = simple_strtoul(buf, &end, 0);
		if (end == buf)
		return -EINVAL;
		(unsigned long )(ea->var) = new;
		/* Always return full write size even if we didn't consume all */
		return size;
		}
		EXPORT_SYMBOL_GPL(sysdev_store_ulong);

		ssize_t sysdev_show_ulong(struct sys_device *sysdev,
		struct sysdev_attribute *attr,
		char *buf)
		{
		struct sysdev_ext_attribute *ea = to_ext_attr(attr);
		return snprintf(buf, PAGE_SIZE, "%lx\n", (unsigned long )(ea->var));
		}
		EXPORT_SYMBOL_GPL(sysdev_show_ulong);

		ssize_t sysdev_store_int(struct sys_device *sysdev,
		struct sysdev_attribute *attr,
		const char *buf, size_t size)
		{
		struct sysdev_ext_attribute *ea = to_ext_attr(attr);
		char *end;
		long new = simple_strtol(buf, &end, 0);
		if (end == buf \|\| new > INT_MAX \|\| new < INT_MIN)
		return -EINVAL;
		(int )(ea->var) = new;
		/* Always return full write size even if we didn't consume all */
		return size;
		}
		EXPORT_SYMBOL_GPL(sysdev_store_int);

		ssize_t sysdev_show_int(struct sys_device *sysdev,
		struct sysdev_attribute *attr,
		char *buf)
		{
		struct sysdev_ext_attribute *ea = to_ext_attr(attr);
		return snprintf(buf, PAGE_SIZE, "%d\n", (int )(ea->var));
		}
		EXPORT_SYMBOL_GPL(sysdev_show_int);

Admin message