5 files changed, 123 insertions, 70 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index 6bee6af8d8e1..f1290cbd1350 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -56,7 +56,14 @@ static inline int device_is_not_partition(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->class ? dev->class->name : ""));
 }
@@ -987,6 +994,8 @@ done:
         device_remove_class_symlinks(dev);
  SymlinkError:
         if (MAJOR(dev->devt))
+                devtmpfs_delete_node(dev);
+        if (MAJOR(dev->devt))
                 device_remove_sys_dev_entry(dev);
  devtattrError:
         if (MAJOR(dev->devt))
@@ -1728,8 +1737,5 @@ void device_shutdown(void)
                         dev->driver->shutdown(dev);
                 }
         }
-        kobject_put(sysfs_dev_char_kobj);
-        kobject_put(sysfs_dev_block_kobj);
-        kobject_put(dev_kobj);
         async_synchronize_full();
 }
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index e62a4ccea54d..958bd1540c30 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -35,6 +35,7 @@ static ssize_t __ref store_online(struct sys_device *dev, struct sysdev_attribut
         struct cpu *cpu = container_of(dev, struct cpu, sysdev);
         ssize_t ret;
 
+        cpu_hotplug_driver_lock();
         switch (buf[0]) {
         case '0':
                 ret = cpu_down(cpu->sysdev.id);
@@ -49,6 +50,7 @@ static ssize_t __ref store_online(struct sys_device *dev, struct sysdev_attribut
         default:
                 ret = -EINVAL;
         }
+        cpu_hotplug_driver_unlock();
 
         if (ret >= 0)
                 ret = count;
@@ -72,6 +74,38 @@ void unregister_cpu(struct cpu *cpu)
         per_cpu(cpu_sys_devices, logical_cpu) = NULL;
         return;
 }
+
+#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
+static ssize_t cpu_probe_store(struct class *class, const char *buf,
+                               size_t count)
+{
+        return arch_cpu_probe(buf, count);
+}
+
+static ssize_t cpu_release_store(struct class *class, const char *buf,
+                                 size_t count)
+{
+        return arch_cpu_release(buf, count);
+}
+
+static CLASS_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
+static CLASS_ATTR(release, S_IWUSR, NULL, cpu_release_store);
+
+int __init cpu_probe_release_init(void)
+{
+        int rc;
+
+        rc = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
+                               &class_attr_probe.attr);
+        if (!rc)
+                rc = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
+                                       &class_attr_release.attr);
+
+        return rc;
+}
+device_initcall(cpu_probe_release_init);
+#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
+
 #else /* ... !CONFIG_HOTPLUG_CPU */
 static inline void register_cpu_control(struct cpu *cpu)
 {
@@ -97,7 +131,7 @@ static ssize_t show_crash_notes(struct sys_device *dev, struct sysdev_attribute
          * boot up and this data does not change there after. Hence this
          * operation should be safe. No locking required.
          */
-        addr = __pa(per_cpu_ptr(crash_notes, cpunum));
+        addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
         rc = sprintf(buf, "%Lx\n", addr);
         return rc;
 }
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index a1cb5afe6801..50375bb8e51d 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -32,6 +32,8 @@ static int dev_mount = 1;
 static int dev_mount;
 #endif
 
+static rwlock_t dirlock;
+
 static int __init mount_param(char *str)
 {
         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);
         if (!IS_ERR(dentry)) {
                 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);
         } else {
                 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);
         return err;
 }
 
 static int create_path(const char *nodepath)
 {
-        char *path;
-        struct nameidata nd;
-        int err = 0;
-
-        path = kstrdup(nodepath, GFP_KERNEL);
-        if (!path)
-                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);
+        int err;
 
-                path_put(&nd.path);
-        } else if (err == -ENOENT) {
+        read_lock(&dirlock);
+        err = dev_mkdir(nodepath, 0755);
+        if (err == -ENOENT) {
+                char *path;
                 char *s;
 
                 /* parent directories do not exist, create them */
+                path = kstrdup(nodepath, GFP_KERNEL);
+                if (!path)
+                        return -ENOMEM;
                 s = path;
-                while (1) {
+                for (;;) {
                         s = strchr(s, '/');
                         if (!s)
                                 break;
@@ -125,9 +115,9 @@ static int create_path(const char *nodepath)
                         s[0] = '/';
                         s++;
                 }
+                kfree(path);
         }
-
-        kfree(path);
+        read_unlock(&dirlock);
         return err;
 }
 
@@ -156,34 +146,40 @@ int devtmpfs_create_node(struct device *dev)
                 mode |= S_IFCHR;
 
         curr_cred = override_creds(&init_cred);
+
         err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
                               nodename, LOOKUP_PARENT, &nd);
         if (err == -ENOENT) {
-                /* create missing parent directories */
                 create_path(nodename);
                 err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
                                       nodename, LOOKUP_PARENT, &nd);
-                if (err)
-                        goto out;
         }
+        if (err)
+                goto out;
 
         dentry = lookup_create(&nd, 0);
         if (!IS_ERR(dentry)) {
-                int umask;
-
-                umask = sys_umask(0000);
                 err = vfs_mknod(nd.path.dentry->d_inode,
                                 dentry, mode, dev->devt);
-                sys_umask(umask);
-                /* mark as kernel created inode */
-                if (!err)
+                if (!err) {
+                        struct iattr newattrs;
+
+                        /* 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;
+                }
                 dput(dentry);
         } else {
                 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);
 out:
         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);
         dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
         if (!IS_ERR(dentry)) {
-                if (dentry->d_inode)
-                        err = vfs_rmdir(nd.path.dentry->d_inode, dentry);
-                else
+                if (dentry->d_inode) {
+                        if (dentry->d_inode->i_private == &dev_mnt)
+                                err = vfs_rmdir(nd.path.dentry->d_inode,
+                                                dentry);
+                        else
+                                err = -EPERM;
+                } else {
                         err = -ENOENT;
+                }
                 dput(dentry);
         } else {
                 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);
         return err;
 }
@@ -228,7 +229,8 @@ static int delete_path(const char *nodepath)
         if (!path)
                 return -ENOMEM;
 
-        while (1) {
+        write_lock(&dirlock);
+        for (;;) {
                 char *base;
 
                 base = strrchr(path, '/');
@@ -239,6 +241,7 @@ static int delete_path(const char *nodepath)
                 if (err)
                         break;
         }
+        write_unlock(&dirlock);
 
         kfree(path);
         return err;
@@ -322,9 +325,8 @@ out:
  * If configured, or requested by the commandline, devtmpfs will be
  * 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;
 
         if (!dev_mount)
@@ -333,15 +335,11 @@ int devtmpfs_mount(const char *mountpoint)
         if (!dev_mnt)
                 return 0;
 
-        err = kern_path(mountpoint, LOOKUP_FOLLOW, &path);
-        if (err)
-                return err;
-        err = do_add_mount(dev_mnt, &path, 0, NULL);
+        err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
         if (err)
                 printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
         else
                 printk(KERN_INFO "devtmpfs: mounted\n");
-        path_put(&path);
         return err;
 }
 
@@ -354,6 +352,8 @@ int __init devtmpfs_init(void)
         int err;
         struct vfsmount *mnt;
 
+        rwlock_init(&dirlock);
+
         err = register_filesystem(&dev_fs_type);
         if (err) {
                 printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
@@ -361,7 +361,7 @@ int __init devtmpfs_init(void)
                 return err;
         }
 
-        mnt = kern_mount(&dev_fs_type);
+        mnt = kern_mount_data(&dev_fs_type, "mode=0755");
         if (IS_ERR(mnt)) {
                 err = PTR_ERR(mnt);
                 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 7376367bcb80..a95024166b66 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -601,12 +601,9 @@ request_firmware_work_func(void *arg)
         }
         ret = _request_firmware(&fw, fw_work->name, fw_work->device,
                 fw_work->uevent);
-        if (ret < 0)
-                fw_work->cont(NULL, fw_work->context);
-        else {
-                fw_work->cont(fw, fw_work->context);
-                release_firmware(fw);
-        }
+
+        fw_work->cont(fw, fw_work->context);
+
         module_put(fw_work->module);
         kfree(fw_work);
         return ret;
@@ -619,6 +616,7 @@ request_firmware_work_func(void *arg)
  *      is non-zero else the firmware copy must be done manually.
  * @name: name of firmware file
  * @device: device for which firmware is being loaded
+ * @gfp: allocation flags
  * @context: will be passed over to @cont, and
  *      @fw may be %NULL if firmware request fails.
  * @cont: function will be called asynchronously when the firmware
@@ -631,12 +629,12 @@ request_firmware_work_func(void *arg)
 int
 request_firmware_nowait(
         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))
 {
         struct task_struct *task;
         struct firmware_work *fw_work = kmalloc(sizeof (struct firmware_work),
-                                                GFP_ATOMIC);
+                                                gfp);
 
         if (!fw_work)
                 return -ENOMEM;
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 4fa954b07ac4..9d2ee25deaf5 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -1000,7 +1000,7 @@ static __initdata LIST_HEAD(early_platform_device_list);
 int __init early_platform_driver_register(struct early_platform_driver *epdrv,
                                           char *buf)
 {
-        unsigned long index;
+        char *tmp;
         int n;
 
         /* 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)) {
                 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;
-                else if (buf[n] == '.' && strict_strtoul(&buf[n + 1], 10,
-                                                         &index) == 0)
-                        epdrv->requested_id = index;
-                else
-                        epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
+                else {
+                        epdrv->requested_id = simple_strtoul(&buf[n + 1],
+                                                             &tmp, 10);
+
+                        if (buf[n] != '.' || (tmp == &buf[n + 1])) {
+                                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;