Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6 (f58df54a) · Commits · 戴 / test

drivers/base/core.c

+10 −4

Original line number	Original line	Diff line number	Diff line
	@@ -56,7 +56,14 @@ static inline int device_is_not_partition(struct device *dev)
	*/		*/
	const char dev_driver_string(const struct device dev)		const char dev_driver_string(const struct device dev)
	{		{
	return dev->driver ? dev->driver->name :		struct device_driver *drv;

			/* dev->driver can change to NULL underneath us because of unbinding,
			* so be careful about accessing it. dev->bus and dev->class should
			* never change once they are set, so they don't need special care.
			*/
			drv = ACCESS_ONCE(dev->driver);
			return drv ? drv->name :
	(dev->bus ? dev->bus->name :		(dev->bus ? dev->bus->name :
	(dev->class ? dev->class->name : ""));		(dev->class ? dev->class->name : ""));
	}		}
	@@ -986,6 +993,8 @@ done:
	AttrsError:		AttrsError:
	device_remove_class_symlinks(dev);		device_remove_class_symlinks(dev);
	SymlinkError:		SymlinkError:
			if (MAJOR(dev->devt))
			devtmpfs_delete_node(dev);
	if (MAJOR(dev->devt))		if (MAJOR(dev->devt))
	device_remove_sys_dev_entry(dev);		device_remove_sys_dev_entry(dev);
	devtattrError:		devtattrError:
	@@ -1728,8 +1737,5 @@ void device_shutdown(void)
	dev->driver->shutdown(dev);		dev->driver->shutdown(dev);
	}		}
	}		}
	kobject_put(sysfs_dev_char_kobj);
	kobject_put(sysfs_dev_block_kobj);
	kobject_put(dev_kobj);
	async_synchronize_full();		async_synchronize_full();
	}		}

drivers/base/devtmpfs.c

+50 −50

Original line number	Original line	Diff line number	Diff line
	@@ -32,6 +32,8 @@ static int dev_mount = 1;
	static int dev_mount;		static int dev_mount;
	#endif		#endif

			static rwlock_t dirlock;

	static int __init mount_param(char *str)		static int __init mount_param(char *str)
	{		{
	dev_mount = simple_strtoul(str, NULL, 0);		dev_mount = simple_strtoul(str, NULL, 0);
	@@ -74,47 +76,35 @@ static int dev_mkdir(const char *name, mode_t mode)
	dentry = lookup_create(&nd, 1);		dentry = lookup_create(&nd, 1);
	if (!IS_ERR(dentry)) {		if (!IS_ERR(dentry)) {
	err = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);		err = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
			if (!err)
			/* mark as kernel-created inode */
			dentry->d_inode->i_private = &dev_mnt;
	dput(dentry);		dput(dentry);
	} else {		} else {
	err = PTR_ERR(dentry);		err = PTR_ERR(dentry);
	}		}
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);

			mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
	path_put(&nd.path);		path_put(&nd.path);
	return err;		return err;
	}		}

	static int create_path(const char *nodepath)		static int create_path(const char *nodepath)
	{		{
			int err;

			read_lock(&dirlock);
			err = dev_mkdir(nodepath, 0755);
			if (err == -ENOENT) {
	char *path;		char *path;
	struct nameidata nd;		char *s;
	int err = 0;

			/* parent directories do not exist, create them */
	path = kstrdup(nodepath, GFP_KERNEL);		path = kstrdup(nodepath, GFP_KERNEL);
	if (!path)		if (!path)
	return -ENOMEM;		return -ENOMEM;

	err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
	path, LOOKUP_PARENT, &nd);
	if (err == 0) {
	struct dentry *dentry;

	/* create directory right away */
	dentry = lookup_create(&nd, 1);
	if (!IS_ERR(dentry)) {
	err = vfs_mkdir(nd.path.dentry->d_inode,
	dentry, 0755);
	dput(dentry);
	}
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);

	path_put(&nd.path);
	} else if (err == -ENOENT) {
	char *s;

	/* parent directories do not exist, create them */
	s = path;		s = path;
	while (1) {		for (;;) {
	s = strchr(s, '/');		s = strchr(s, '/');
	if (!s)		if (!s)
	break;		break;
	@@ -125,9 +115,9 @@ static int create_path(const char *nodepath)
	s[0] = '/';		s[0] = '/';
	s++;		s++;
	}		}
	}

	kfree(path);		kfree(path);
			}
			read_unlock(&dirlock);
	return err;		return err;
	}		}

	@@ -156,34 +146,40 @@ int devtmpfs_create_node(struct device *dev)
	mode \|= S_IFCHR;		mode \|= S_IFCHR;

	curr_cred = override_creds(&init_cred);		curr_cred = override_creds(&init_cred);

	err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,		err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
	nodename, LOOKUP_PARENT, &nd);		nodename, LOOKUP_PARENT, &nd);
	if (err == -ENOENT) {		if (err == -ENOENT) {
	/* create missing parent directories */
	create_path(nodename);		create_path(nodename);
	err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,		err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
	nodename, LOOKUP_PARENT, &nd);		nodename, LOOKUP_PARENT, &nd);
			}
	if (err)		if (err)
	goto out;		goto out;
	}

	dentry = lookup_create(&nd, 0);		dentry = lookup_create(&nd, 0);
	if (!IS_ERR(dentry)) {		if (!IS_ERR(dentry)) {
	int umask;

	umask = sys_umask(0000);
	err = vfs_mknod(nd.path.dentry->d_inode,		err = vfs_mknod(nd.path.dentry->d_inode,
	dentry, mode, dev->devt);		dentry, mode, dev->devt);
	sys_umask(umask);		if (!err) {
	/* mark as kernel created inode */		struct iattr newattrs;
	if (!err)
			/* fixup possibly umasked mode */
			newattrs.ia_mode = mode;
			newattrs.ia_valid = ATTR_MODE;
			mutex_lock(&dentry->d_inode->i_mutex);
			notify_change(dentry, &newattrs);
			mutex_unlock(&dentry->d_inode->i_mutex);

			/* mark as kernel-created inode */
	dentry->d_inode->i_private = &dev_mnt;		dentry->d_inode->i_private = &dev_mnt;
			}
	dput(dentry);		dput(dentry);
	} else {		} else {
	err = PTR_ERR(dentry);		err = PTR_ERR(dentry);
	}		}
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);

			mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
	path_put(&nd.path);		path_put(&nd.path);
	out:		out:
	kfree(tmp);		kfree(tmp);
	@@ -205,16 +201,21 @@ static int dev_rmdir(const char *name)
	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);		mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
	dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);		dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
	if (!IS_ERR(dentry)) {		if (!IS_ERR(dentry)) {
	if (dentry->d_inode)		if (dentry->d_inode) {
	err = vfs_rmdir(nd.path.dentry->d_inode, dentry);		if (dentry->d_inode->i_private == &dev_mnt)
			err = vfs_rmdir(nd.path.dentry->d_inode,
			dentry);
	else		else
			err = -EPERM;
			} else {
	err = -ENOENT;		err = -ENOENT;
			}
	dput(dentry);		dput(dentry);
	} else {		} else {
	err = PTR_ERR(dentry);		err = PTR_ERR(dentry);
	}		}
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);

			mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
	path_put(&nd.path);		path_put(&nd.path);
	return err;		return err;
	}		}
	@@ -228,7 +229,8 @@ static int delete_path(const char *nodepath)
	if (!path)		if (!path)
	return -ENOMEM;		return -ENOMEM;

	while (1) {		write_lock(&dirlock);
			for (;;) {
	char *base;		char *base;

	base = strrchr(path, '/');		base = strrchr(path, '/');
	@@ -239,6 +241,7 @@ static int delete_path(const char *nodepath)
	if (err)		if (err)
	break;		break;
	}		}
			write_unlock(&dirlock);

	kfree(path);		kfree(path);
	return err;		return err;
	@@ -322,9 +325,8 @@ out:
	* If configured, or requested by the commandline, devtmpfs will be		* If configured, or requested by the commandline, devtmpfs will be
	* auto-mounted after the kernel mounted the root filesystem.		* auto-mounted after the kernel mounted the root filesystem.
	*/		*/
	int devtmpfs_mount(const char *mountpoint)		int devtmpfs_mount(const char *mntdir)
	{		{
	struct path path;
	int err;		int err;

	if (!dev_mount)		if (!dev_mount)
	@@ -333,15 +335,11 @@ int devtmpfs_mount(const char *mountpoint)
	if (!dev_mnt)		if (!dev_mnt)
	return 0;		return 0;

	err = kern_path(mountpoint, LOOKUP_FOLLOW, &path);		err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
	if (err)
	return err;
	err = do_add_mount(dev_mnt, &path, 0, NULL);
	if (err)		if (err)
	printk(KERN_INFO "devtmpfs: error mounting %i\n", err);		printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
	else		else
	printk(KERN_INFO "devtmpfs: mounted\n");		printk(KERN_INFO "devtmpfs: mounted\n");
	path_put(&path);
	return err;		return err;
	}		}

	@@ -354,6 +352,8 @@ int __init devtmpfs_init(void)
	int err;		int err;
	struct vfsmount *mnt;		struct vfsmount *mnt;

			rwlock_init(&dirlock);

	err = register_filesystem(&dev_fs_type);		err = register_filesystem(&dev_fs_type);
	if (err) {		if (err) {
	printk(KERN_ERR "devtmpfs: unable to register devtmpfs "		printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
	@@ -361,7 +361,7 @@ int __init devtmpfs_init(void)
	return err;		return err;
	}		}

	mnt = kern_mount(&dev_fs_type);		mnt = kern_mount_data(&dev_fs_type, "mode=0755");
	if (IS_ERR(mnt)) {		if (IS_ERR(mnt)) {
	err = PTR_ERR(mnt);		err = PTR_ERR(mnt);
	printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);		printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);

drivers/base/firmware_class.c

+6 −8

Original line number	Original line	Diff line number	Diff line
	@@ -601,12 +601,9 @@ request_firmware_work_func(void *arg)
	}		}
	ret = _request_firmware(&fw, fw_work->name, fw_work->device,		ret = _request_firmware(&fw, fw_work->name, fw_work->device,
	fw_work->uevent);		fw_work->uevent);
	if (ret < 0)
	fw_work->cont(NULL, fw_work->context);
	else {
	fw_work->cont(fw, fw_work->context);		fw_work->cont(fw, fw_work->context);
	release_firmware(fw);
	}
	module_put(fw_work->module);		module_put(fw_work->module);
	kfree(fw_work);		kfree(fw_work);
	return ret;		return ret;
	@@ -619,6 +616,7 @@ request_firmware_work_func(void *arg)
	* is non-zero else the firmware copy must be done manually.		* is non-zero else the firmware copy must be done manually.
	* @name: name of firmware file		* @name: name of firmware file
	* @device: device for which firmware is being loaded		* @device: device for which firmware is being loaded
			* @gfp: allocation flags
	* @context: will be passed over to @cont, and		* @context: will be passed over to @cont, and
	* @fw may be %NULL if firmware request fails.		* @fw may be %NULL if firmware request fails.
	* @cont: function will be called asynchronously when the firmware		* @cont: function will be called asynchronously when the firmware
	@@ -631,12 +629,12 @@ request_firmware_work_func(void *arg)
	int		int
	request_firmware_nowait(		request_firmware_nowait(
	struct module *module, int uevent,		struct module *module, int uevent,
	const char name, struct device device, void *context,		const char name, struct device device, gfp_t gfp, void *context,
	void (cont)(const struct firmware fw, void *context))		void (cont)(const struct firmware fw, void *context))
	{		{
	struct task_struct *task;		struct task_struct *task;
	struct firmware_work *fw_work = kmalloc(sizeof (struct firmware_work),		struct firmware_work *fw_work = kmalloc(sizeof (struct firmware_work),
	GFP_ATOMIC);		gfp);

	if (!fw_work)		if (!fw_work)
	return -ENOMEM;		return -ENOMEM;

drivers/base/platform.c

+22 −7

Original line number	Original line	Diff line number	Diff line
	@@ -1000,7 +1000,7 @@ static __initdata LIST_HEAD(early_platform_device_list);
	int __init early_platform_driver_register(struct early_platform_driver *epdrv,		int __init early_platform_driver_register(struct early_platform_driver *epdrv,
	char *buf)		char *buf)
	{		{
	unsigned long index;		char *tmp;
	int n;		int n;

	/* Simply add the driver to the end of the global list.		/* Simply add the driver to the end of the global list.
	@@ -1019,13 +1019,28 @@ int __init early_platform_driver_register(struct early_platform_driver *epdrv,
	if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {		if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
	list_move(&epdrv->list, &early_platform_driver_list);		list_move(&epdrv->list, &early_platform_driver_list);

	if (!strcmp(buf, epdrv->pdrv->driver.name))		/* Allow passing parameters after device name */
			if (buf[n] == '\0' \|\| buf[n] == ',')
	epdrv->requested_id = -1;		epdrv->requested_id = -1;
	else if (buf[n] == '.' && strict_strtoul(&buf[n + 1], 10,		else {
	&index) == 0)		epdrv->requested_id = simple_strtoul(&buf[n + 1],
	epdrv->requested_id = index;		&tmp, 10);
	else
			if (buf[n] != '.' \|\| (tmp == &buf[n + 1])) {
	epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;		epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
			n = 0;
			} else
			n += strcspn(&buf[n + 1], ",") + 1;
			}

			if (buf[n] == ',')
			n++;

			if (epdrv->bufsize) {
			memcpy(epdrv->buffer, &buf[n],
			min_t(int, epdrv->bufsize, strlen(&buf[n]) + 1));
			epdrv->buffer[epdrv->bufsize - 1] = '\0';
			}
	}		}

	return 0;		return 0;

drivers/firmware/dell_rbu.c

+7 −2

Original line number	Original line	Diff line number	Diff line
	@@ -544,9 +544,12 @@ static void callbackfn_rbu(const struct firmware fw, void context)
	{		{
	rbu_data.entry_created = 0;		rbu_data.entry_created = 0;

	if (!fw \|\| !fw->size)		if (!fw)
	return;		return;

			if (!fw->size)
			goto out;

	spin_lock(&rbu_data.lock);		spin_lock(&rbu_data.lock);
	if (!strcmp(image_type, "mono")) {		if (!strcmp(image_type, "mono")) {
	if (!img_update_realloc(fw->size))		if (!img_update_realloc(fw->size))
	@@ -568,6 +571,8 @@ static void callbackfn_rbu(const struct firmware fw, void context)
	} else		} else
	pr_debug("invalid image type specified.\n");		pr_debug("invalid image type specified.\n");
	spin_unlock(&rbu_data.lock);		spin_unlock(&rbu_data.lock);
			out:
			release_firmware(fw);
	}		}

	static ssize_t read_rbu_image_type(struct kobject *kobj,		static ssize_t read_rbu_image_type(struct kobject *kobj,
	@@ -615,7 +620,7 @@ static ssize_t write_rbu_image_type(struct kobject *kobj,
	spin_unlock(&rbu_data.lock);		spin_unlock(&rbu_data.lock);
	req_firm_rc = request_firmware_nowait(THIS_MODULE,		req_firm_rc = request_firmware_nowait(THIS_MODULE,
	FW_ACTION_NOHOTPLUG, "dell_rbu",		FW_ACTION_NOHOTPLUG, "dell_rbu",
	&rbu_device->dev, &context,		&rbu_device->dev, GFP_KERNEL, &context,
	callbackfn_rbu);		callbackfn_rbu);
	if (req_firm_rc) {		if (req_firm_rc) {
	printk(KERN_ERR		printk(KERN_ERR

Admin message