6 files changed, 319 insertions, 21 deletions

diff --git a/fs/sysfs/bin.c b/fs/sysfs/bin.c
index f2c478c3424e..07703d3ff4a1 100644
--- a/fs/sysfs/bin.c
+++ b/fs/sysfs/bin.c
@@ -21,15 +21,28 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mutex.h>
+#include <linux/mm.h>
 
 #include <asm/uaccess.h>
 
 #include "sysfs.h"
 
+/*
+ * There's one bin_buffer for each open file.
+ *
+ * filp->private_data points to bin_buffer and
+ * sysfs_dirent->s_bin_attr.buffers points to a the bin_buffer s
+ * sysfs_dirent->s_bin_attr.buffers is protected by sysfs_bin_lock
+ */
+static DEFINE_MUTEX(sysfs_bin_lock);
+
 struct bin_buffer {
-        struct mutex    mutex;
-        void            *buffer;
-        int             mmapped;
+        struct mutex                    mutex;
+        void                            *buffer;
+        int                             mmapped;
+        struct vm_operations_struct     *vm_ops;
+        struct file                     *file;
+        struct hlist_node               list;
 };
 
 static int
@@ -168,6 +181,175 @@ out_free:
         return count;
 }
 
+static void bin_vma_open(struct vm_area_struct *vma)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+
+        if (!bb->vm_ops || !bb->vm_ops->open)
+                return;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return;
+
+        bb->vm_ops->open(vma);
+
+        sysfs_put_active_two(attr_sd);
+}
+
+static void bin_vma_close(struct vm_area_struct *vma)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+
+        if (!bb->vm_ops || !bb->vm_ops->close)
+                return;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return;
+
+        bb->vm_ops->close(vma);
+
+        sysfs_put_active_two(attr_sd);
+}
+
+static int bin_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        int ret;
+
+        if (!bb->vm_ops || !bb->vm_ops->fault)
+                return VM_FAULT_SIGBUS;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return VM_FAULT_SIGBUS;
+
+        ret = bb->vm_ops->fault(vma, vmf);
+
+        sysfs_put_active_two(attr_sd);
+        return ret;
+}
+
+static int bin_page_mkwrite(struct vm_area_struct *vma, struct page *page)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        int ret;
+
+        if (!bb->vm_ops)
+                return -EINVAL;
+
+        if (!bb->vm_ops->page_mkwrite)
+                return 0;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return -EINVAL;
+
+        ret = bb->vm_ops->page_mkwrite(vma, page);
+
+        sysfs_put_active_two(attr_sd);
+        return ret;
+}
+
+static int bin_access(struct vm_area_struct *vma, unsigned long addr,
+                  void *buf, int len, int write)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        int ret;
+
+        if (!bb->vm_ops || !bb->vm_ops->access)
+                return -EINVAL;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return -EINVAL;
+
+        ret = bb->vm_ops->access(vma, addr, buf, len, write);
+
+        sysfs_put_active_two(attr_sd);
+        return ret;
+}
+
+#ifdef CONFIG_NUMA
+static int bin_set_policy(struct vm_area_struct *vma, struct mempolicy *new)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        int ret;
+
+        if (!bb->vm_ops || !bb->vm_ops->set_policy)
+                return 0;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return -EINVAL;
+
+        ret = bb->vm_ops->set_policy(vma, new);
+
+        sysfs_put_active_two(attr_sd);
+        return ret;
+}
+
+static struct mempolicy *bin_get_policy(struct vm_area_struct *vma,
+                                        unsigned long addr)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        struct mempolicy *pol;
+
+        if (!bb->vm_ops || !bb->vm_ops->get_policy)
+                return vma->vm_policy;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return vma->vm_policy;
+
+        pol = bb->vm_ops->get_policy(vma, addr);
+
+        sysfs_put_active_two(attr_sd);
+        return pol;
+}
+
+static int bin_migrate(struct vm_area_struct *vma, const nodemask_t *from,
+                        const nodemask_t *to, unsigned long flags)
+{
+        struct file *file = vma->vm_file;
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        int ret;
+
+        if (!bb->vm_ops || !bb->vm_ops->migrate)
+                return 0;
+
+        if (!sysfs_get_active_two(attr_sd))
+                return 0;
+
+        ret = bb->vm_ops->migrate(vma, from, to, flags);
+
+        sysfs_put_active_two(attr_sd);
+        return ret;
+}
+#endif
+
+static struct vm_operations_struct bin_vm_ops = {
+        .open           = bin_vma_open,
+        .close          = bin_vma_close,
+        .fault          = bin_fault,
+        .page_mkwrite   = bin_page_mkwrite,
+        .access         = bin_access,
+#ifdef CONFIG_NUMA
+        .set_policy     = bin_set_policy,
+        .get_policy     = bin_get_policy,
+        .migrate        = bin_migrate,
+#endif
+};
+
 static int mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct bin_buffer *bb = file->private_data;
@@ -179,18 +361,37 @@ static int mmap(struct file *file, struct vm_area_struct *vma)
         mutex_lock(&bb->mutex);
 
         /* need attr_sd for attr, its parent for kobj */
+        rc = -ENODEV;
         if (!sysfs_get_active_two(attr_sd))
-                return -ENODEV;
+                goto out_unlock;
 
         rc = -EINVAL;
-        if (attr->mmap)
-                rc = attr->mmap(kobj, attr, vma);
+        if (!attr->mmap)
+                goto out_put;
+
+        rc = attr->mmap(kobj, attr, vma);
+        if (rc)
+                goto out_put;
 
-        if (rc == 0 && !bb->mmapped)
-                bb->mmapped = 1;
-        else
-                sysfs_put_active_two(attr_sd);
+        /*
+         * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
+         * to satisfy versions of X which crash if the mmap fails: that
+         * substitutes a new vm_file, and we don't then want bin_vm_ops.
+         */
+        if (vma->vm_file != file)
+                goto out_put;
 
+        rc = -EINVAL;
+        if (bb->mmapped && bb->vm_ops != vma->vm_ops)
+                goto out_put;
+
+        rc = 0;
+        bb->mmapped = 1;
+        bb->vm_ops = vma->vm_ops;
+        vma->vm_ops = &bin_vm_ops;
+out_put:
+        sysfs_put_active_two(attr_sd);
+out_unlock:
         mutex_unlock(&bb->mutex);
 
         return rc;
@@ -223,8 +424,13 @@ static int open(struct inode * inode, struct file * file)
                 goto err_out;
 
         mutex_init(&bb->mutex);
+        bb->file = file;
         file->private_data = bb;
 
+        mutex_lock(&sysfs_bin_lock);
+        hlist_add_head(&bb->list, &attr_sd->s_bin_attr.buffers);
+        mutex_unlock(&sysfs_bin_lock);
+
         /* open succeeded, put active references */
         sysfs_put_active_two(attr_sd);
         return 0;
@@ -237,11 +443,12 @@ static int open(struct inode * inode, struct file * file)
 
 static int release(struct inode * inode, struct file * file)
 {
-        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
         struct bin_buffer *bb = file->private_data;
 
-        if (bb->mmapped)
-                sysfs_put_active_two(attr_sd);
+        mutex_lock(&sysfs_bin_lock);
+        hlist_del(&bb->list);
+        mutex_unlock(&sysfs_bin_lock);
+
         kfree(bb->buffer);
         kfree(bb);
         return 0;
@@ -256,6 +463,26 @@ const struct file_operations bin_fops = {
         .release        = release,
 };
 
+
+void unmap_bin_file(struct sysfs_dirent *attr_sd)
+{
+        struct bin_buffer *bb;
+        struct hlist_node *tmp;
+
+        if (sysfs_type(attr_sd) != SYSFS_KOBJ_BIN_ATTR)
+                return;
+
+        mutex_lock(&sysfs_bin_lock);
+
+        hlist_for_each_entry(bb, tmp, &attr_sd->s_bin_attr.buffers, list) {
+                struct inode *inode = bb->file->f_path.dentry->d_inode;
+
+                unmap_mapping_range(inode->i_mapping, 0, 0, 1);
+        }
+
+        mutex_unlock(&sysfs_bin_lock);
+}
+
 /**
  *      sysfs_create_bin_file - create binary file for object.
  *      @kobj:  object.
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 82d3b79d0e08..d88d0fac9fa5 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -302,7 +302,7 @@ static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
         iput(inode);
 }
 
-static struct dentry_operations sysfs_dentry_ops = {
+static const struct dentry_operations sysfs_dentry_ops = {
         .d_iput         = sysfs_d_iput,
 };
 
@@ -434,6 +434,26 @@ int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
 }
 
 /**
+ *      sysfs_pathname - return full path to sysfs dirent
+ *      @sd: sysfs_dirent whose path we want
+ *      @path: caller allocated buffer
+ *
+ *      Gives the name "/" to the sysfs_root entry; any path returned
+ *      is relative to wherever sysfs is mounted.
+ *
+ *      XXX: does no error checking on @path size
+ */
+static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
+{
+        if (sd->s_parent) {
+                sysfs_pathname(sd->s_parent, path);
+                strcat(path, "/");
+        }
+        strcat(path, sd->s_name);
+        return path;
+}
+
+/**
  *      sysfs_add_one - add sysfs_dirent to parent
  *      @acxt: addrm context to use
  *      @sd: sysfs_dirent to be added
@@ -458,8 +478,16 @@ int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
         int ret;
 
         ret = __sysfs_add_one(acxt, sd);
-        WARN(ret == -EEXIST, KERN_WARNING "sysfs: duplicate filename '%s' "
-                       "can not be created\n", sd->s_name);
+        if (ret == -EEXIST) {
+                char *path = kzalloc(PATH_MAX, GFP_KERNEL);
+                WARN(1, KERN_WARNING
+                     "sysfs: cannot create duplicate filename '%s'\n",
+                     (path == NULL) ? sd->s_name :
+                     strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
+                            sd->s_name));
+                kfree(path);
+        }
+
         return ret;
 }
 
@@ -581,6 +609,7 @@ void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
 
                 sysfs_drop_dentry(sd);
                 sysfs_deactivate(sd);
+                unmap_bin_file(sd);
                 sysfs_put(sd);
         }
 }
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index 1f4a3f877262..289c43a47263 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -659,13 +659,16 @@ void sysfs_remove_file_from_group(struct kobject *kobj,
 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
 
 struct sysfs_schedule_callback_struct {
-        struct kobject          *kobj;
+        struct list_head        workq_list;
+        struct kobject          *kobj;
         void                    (*func)(void *);
         void                    *data;
         struct module           *owner;
         struct work_struct      work;
 };
 
+static DEFINE_MUTEX(sysfs_workq_mutex);
+static LIST_HEAD(sysfs_workq);
 static void sysfs_schedule_callback_work(struct work_struct *work)
 {
         struct sysfs_schedule_callback_struct *ss = container_of(work,
@@ -674,6 +677,9 @@ static void sysfs_schedule_callback_work(struct work_struct *work)
         (ss->func)(ss->data);
         kobject_put(ss->kobj);
         module_put(ss->owner);
+        mutex_lock(&sysfs_workq_mutex);
+        list_del(&ss->workq_list);
+        mutex_unlock(&sysfs_workq_mutex);
         kfree(ss);
 }
 
@@ -695,15 +701,25 @@ static void sysfs_schedule_callback_work(struct work_struct *work)
  * until @func returns.
  *
  * Returns 0 if the request was submitted, -ENOMEM if storage could not
- * be allocated, -ENODEV if a reference to @owner isn't available.
+ * be allocated, -ENODEV if a reference to @owner isn't available,
+ * -EAGAIN if a callback has already been scheduled for @kobj.
  */
 int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
                 void *data, struct module *owner)
 {
-        struct sysfs_schedule_callback_struct *ss;
+        struct sysfs_schedule_callback_struct *ss, *tmp;
 
         if (!try_module_get(owner))
                 return -ENODEV;
+
+        mutex_lock(&sysfs_workq_mutex);
+        list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
+                if (ss->kobj == kobj) {
+                        mutex_unlock(&sysfs_workq_mutex);
+                        return -EAGAIN;
+                }
+        mutex_unlock(&sysfs_workq_mutex);
+
         ss = kmalloc(sizeof(*ss), GFP_KERNEL);
         if (!ss) {
                 module_put(owner);
@@ -715,6 +731,10 @@ int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
         ss->data = data;
         ss->owner = owner;
         INIT_WORK(&ss->work, sysfs_schedule_callback_work);
+        INIT_LIST_HEAD(&ss->workq_list);
+        mutex_lock(&sysfs_workq_mutex);
+        list_add_tail(&ss->workq_list, &sysfs_workq);
+        mutex_unlock(&sysfs_workq_mutex);
         schedule_work(&ss->work);
         return 0;
 }
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index dfa3d94cfc74..555f0ff988df 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -147,6 +147,7 @@ static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
 {
         struct bin_attribute *bin_attr;
 
+        inode->i_private = sysfs_get(sd);
         inode->i_mapping->a_ops = &sysfs_aops;
         inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
         inode->i_op = &sysfs_inode_operations;
@@ -214,6 +215,22 @@ struct inode * sysfs_get_inode(struct sysfs_dirent *sd)
         return inode;
 }
 
+/*
+ * The sysfs_dirent serves as both an inode and a directory entry for sysfs.
+ * To prevent the sysfs inode numbers from being freed prematurely we take a
+ * reference to sysfs_dirent from the sysfs inode.  A
+ * super_operations.delete_inode() implementation is needed to drop that
+ * reference upon inode destruction.
+ */
+void sysfs_delete_inode(struct inode *inode)
+{
+        struct sysfs_dirent *sd  = inode->i_private;
+
+        truncate_inode_pages(&inode->i_data, 0);
+        clear_inode(inode);
+        sysfs_put(sd);
+}
+
 int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const char *name)
 {
         struct sysfs_addrm_cxt acxt;
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index ab343e371d64..49749955ccaf 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -17,11 +17,10 @@
 #include <linux/pagemap.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/magic.h>
 
 #include "sysfs.h"
 
-/* Random magic number */
-#define SYSFS_MAGIC 0x62656572
 
 static struct vfsmount *sysfs_mount;
 struct super_block * sysfs_sb = NULL;
@@ -30,6 +29,7 @@ struct kmem_cache *sysfs_dir_cachep;
 static const struct super_operations sysfs_ops = {
         .statfs         = simple_statfs,
         .drop_inode     = generic_delete_inode,
+        .delete_inode   = sysfs_delete_inode,
 };
 
 struct sysfs_dirent sysfs_root = {
@@ -53,7 +53,9 @@ static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
         sysfs_sb = sb;
 
         /* get root inode, initialize and unlock it */
+        mutex_lock(&sysfs_mutex);
         inode = sysfs_get_inode(&sysfs_root);
+        mutex_unlock(&sysfs_mutex);
         if (!inode) {
                 pr_debug("sysfs: could not get root inode\n");
                 return -ENOMEM;
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index 93c6d6b27c4d..3fa0d98481e2 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -28,6 +28,7 @@ struct sysfs_elem_attr {
 
 struct sysfs_elem_bin_attr {
         struct bin_attribute    *bin_attr;
+        struct hlist_head       buffers;
 };
 
 /*
@@ -145,6 +146,7 @@ static inline void __sysfs_put(struct sysfs_dirent *sd)
  * inode.c
  */
 struct inode *sysfs_get_inode(struct sysfs_dirent *sd);
+void sysfs_delete_inode(struct inode *inode);
 int sysfs_setattr(struct dentry *dentry, struct iattr *iattr);
 int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const char *name);
 int sysfs_inode_init(void);
@@ -163,6 +165,7 @@ int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
  * bin.c
  */
 extern const struct file_operations bin_fops;
+void unmap_bin_file(struct sysfs_dirent *attr_sd);
 
 /*
  * symlink.c