Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

8 files changed, 134 insertions, 103 deletions

diff --git a/fs/sysfs/Kconfig b/fs/sysfs/Kconfig
index f4b67588b9d6..8c41feacbac5 100644
--- a/fs/sysfs/Kconfig
+++ b/fs/sysfs/Kconfig
@@ -1,5 +1,5 @@
 config SYSFS
-        bool "sysfs file system support" if EMBEDDED
+        bool "sysfs file system support" if EXPERT
         default y
         help
         The sysfs filesystem is a virtual filesystem that the kernel uses to
diff --git a/fs/sysfs/bin.c b/fs/sysfs/bin.c
index 4e321f7353fa..a4759833d62d 100644
--- a/fs/sysfs/bin.c
+++ b/fs/sysfs/bin.c
@@ -179,30 +179,14 @@ static void bin_vma_open(struct vm_area_struct *vma)
         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(attr_sd))
-                return;
-
-        bb->vm_ops->open(vma);
-
-        sysfs_put_active(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)
+        if (!bb->vm_ops)
                 return;
 
         if (!sysfs_get_active(attr_sd))
                 return;
 
-        bb->vm_ops->close(vma);
+        if (bb->vm_ops->open)
+                bb->vm_ops->open(vma);
 
         sysfs_put_active(attr_sd);
 }
@@ -214,13 +198,15 @@ static int bin_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
         int ret;
 
-        if (!bb->vm_ops || !bb->vm_ops->fault)
+        if (!bb->vm_ops)
                 return VM_FAULT_SIGBUS;
 
         if (!sysfs_get_active(attr_sd))
                 return VM_FAULT_SIGBUS;
 
-        ret = bb->vm_ops->fault(vma, vmf);
+        ret = VM_FAULT_SIGBUS;
+        if (bb->vm_ops->fault)
+                ret = bb->vm_ops->fault(vma, vmf);
 
         sysfs_put_active(attr_sd);
         return ret;
@@ -236,13 +222,12 @@ static int bin_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
         if (!bb->vm_ops)
                 return VM_FAULT_SIGBUS;
 
-        if (!bb->vm_ops->page_mkwrite)
-                return 0;
-
         if (!sysfs_get_active(attr_sd))
                 return VM_FAULT_SIGBUS;
 
-        ret = bb->vm_ops->page_mkwrite(vma, vmf);
+        ret = 0;
+        if (bb->vm_ops->page_mkwrite)
+                ret = bb->vm_ops->page_mkwrite(vma, vmf);
 
         sysfs_put_active(attr_sd);
         return ret;
@@ -256,13 +241,15 @@ static int bin_access(struct vm_area_struct *vma, unsigned long addr,
         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
         int ret;
 
-        if (!bb->vm_ops || !bb->vm_ops->access)
+        if (!bb->vm_ops)
                 return -EINVAL;
 
         if (!sysfs_get_active(attr_sd))
                 return -EINVAL;
 
-        ret = bb->vm_ops->access(vma, addr, buf, len, write);
+        ret = -EINVAL;
+        if (bb->vm_ops->access)
+                ret = bb->vm_ops->access(vma, addr, buf, len, write);
 
         sysfs_put_active(attr_sd);
         return ret;
@@ -276,13 +263,15 @@ static int bin_set_policy(struct vm_area_struct *vma, struct mempolicy *new)
         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
         int ret;
 
-        if (!bb->vm_ops || !bb->vm_ops->set_policy)
+        if (!bb->vm_ops)
                 return 0;
 
         if (!sysfs_get_active(attr_sd))
                 return -EINVAL;
 
-        ret = bb->vm_ops->set_policy(vma, new);
+        ret = 0;
+        if (bb->vm_ops->set_policy)
+                ret = bb->vm_ops->set_policy(vma, new);
 
         sysfs_put_active(attr_sd);
         return ret;
@@ -296,13 +285,15 @@ static struct mempolicy *bin_get_policy(struct vm_area_struct *vma,
         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
         struct mempolicy *pol;
 
-        if (!bb->vm_ops || !bb->vm_ops->get_policy)
+        if (!bb->vm_ops)
                 return vma->vm_policy;
 
         if (!sysfs_get_active(attr_sd))
                 return vma->vm_policy;
 
-        pol = bb->vm_ops->get_policy(vma, addr);
+        pol = vma->vm_policy;
+        if (bb->vm_ops->get_policy)
+                pol = bb->vm_ops->get_policy(vma, addr);
 
         sysfs_put_active(attr_sd);
         return pol;
@@ -316,13 +307,15 @@ static int bin_migrate(struct vm_area_struct *vma, const nodemask_t *from,
         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
         int ret;
 
-        if (!bb->vm_ops || !bb->vm_ops->migrate)
+        if (!bb->vm_ops)
                 return 0;
 
         if (!sysfs_get_active(attr_sd))
                 return 0;
 
-        ret = bb->vm_ops->migrate(vma, from, to, flags);
+        ret = 0;
+        if (bb->vm_ops->migrate)
+                ret = bb->vm_ops->migrate(vma, from, to, flags);
 
         sysfs_put_active(attr_sd);
         return ret;
@@ -331,7 +324,6 @@ static int bin_migrate(struct vm_area_struct *vma, const nodemask_t *from,
 
 static const 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,
@@ -377,6 +369,14 @@ static int mmap(struct file *file, struct vm_area_struct *vma)
         if (bb->mmapped && bb->vm_ops != vma->vm_ops)
                 goto out_put;
 
+        /*
+         * It is not possible to successfully wrap close.
+         * So error if someone is trying to use close.
+         */
+        rc = -EINVAL;
+        if (vma->vm_ops && vma->vm_ops->close)
+                goto out_put;
+
         rc = 0;
         bb->mmapped = 1;
         bb->vm_ops = vma->vm_ops;
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 7e54bac8c4b0..ea9120a830d8 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -231,7 +231,7 @@ void release_sysfs_dirent(struct sysfs_dirent * sd)
                 goto repeat;
 }
 
-static int sysfs_dentry_delete(struct dentry *dentry)
+static int sysfs_dentry_delete(const struct dentry *dentry)
 {
         struct sysfs_dirent *sd = dentry->d_fsdata;
         return !!(sd->s_flags & SYSFS_FLAG_REMOVED);
@@ -239,9 +239,13 @@ static int sysfs_dentry_delete(struct dentry *dentry)
 
 static int sysfs_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct sysfs_dirent *sd = dentry->d_fsdata;
+        struct sysfs_dirent *sd;
         int is_dir;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        sd = dentry->d_fsdata;
         mutex_lock(&sysfs_mutex);
 
         /* The sysfs dirent has been deleted */
@@ -701,7 +705,7 @@ static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
         /* instantiate and hash dentry */
         ret = d_find_alias(inode);
         if (!ret) {
-                dentry->d_op = &sysfs_dentry_ops;
+                d_set_d_op(dentry, &sysfs_dentry_ops);
                 dentry->d_fsdata = sysfs_get(sd);
                 d_add(dentry, inode);
         } else {
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index da3fefe91a8f..1ad8c93c1b85 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -24,13 +24,6 @@
 
 #include "sysfs.h"
 
-/* used in crash dumps to help with debugging */
-static char last_sysfs_file[PATH_MAX];
-void sysfs_printk_last_file(void)
-{
-        printk(KERN_EMERG "last sysfs file: %s\n", last_sysfs_file);
-}
-
 /*
  * There's one sysfs_buffer for each open file and one
  * sysfs_open_dirent for each sysfs_dirent with one or more open
@@ -337,11 +330,6 @@ static int sysfs_open_file(struct inode *inode, struct file *file)
         struct sysfs_buffer *buffer;
         const struct sysfs_ops *ops;
         int error = -EACCES;
-        char *p;
-
-        p = d_path(&file->f_path, last_sysfs_file, sizeof(last_sysfs_file));
-        if (!IS_ERR(p))
-                memmove(last_sysfs_file, p, strlen(p) + 1);
 
         /* need attr_sd for attr and ops, its parent for kobj */
         if (!sysfs_get_active(attr_sd))
diff --git a/fs/sysfs/group.c b/fs/sysfs/group.c
index 23c1e598792a..194414f8298c 100644
--- a/fs/sysfs/group.c
+++ b/fs/sysfs/group.c
@@ -101,9 +101,9 @@ int sysfs_create_group(struct kobject *kobj,
 }
 
 /**
- * sysfs_update_group - given a directory kobject, create an attribute group
- * @kobj:       The kobject to create the group on
- * @grp:        The attribute group to create
+ * sysfs_update_group - given a directory kobject, update an attribute group
+ * @kobj:       The kobject to update the group on
+ * @grp:        The attribute group to update
  *
  * This function updates an attribute group.  Unlike
  * sysfs_create_group(), it will explicitly not warn or error if any
@@ -148,6 +148,59 @@ void sysfs_remove_group(struct kobject * kobj,
         sysfs_put(sd);
 }
 
+/**
+ * sysfs_merge_group - merge files into a pre-existing attribute group.
+ * @kobj:       The kobject containing the group.
+ * @grp:        The files to create and the attribute group they belong to.
+ *
+ * This function returns an error if the group doesn't exist or any of the
+ * files already exist in that group, in which case none of the new files
+ * are created.
+ */
+int sysfs_merge_group(struct kobject *kobj,
+                       const struct attribute_group *grp)
+{
+        struct sysfs_dirent *dir_sd;
+        int error = 0;
+        struct attribute *const *attr;
+        int i;
+
+        dir_sd = sysfs_get_dirent(kobj->sd, NULL, grp->name);
+        if (!dir_sd)
+                return -ENOENT;
+
+        for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr))
+                error = sysfs_add_file(dir_sd, *attr, SYSFS_KOBJ_ATTR);
+        if (error) {
+                while (--i >= 0)
+                        sysfs_hash_and_remove(dir_sd, NULL, (*--attr)->name);
+        }
+        sysfs_put(dir_sd);
+
+        return error;
+}
+EXPORT_SYMBOL_GPL(sysfs_merge_group);
+
+/**
+ * sysfs_unmerge_group - remove files from a pre-existing attribute group.
+ * @kobj:       The kobject containing the group.
+ * @grp:        The files to remove and the attribute group they belong to.
+ */
+void sysfs_unmerge_group(struct kobject *kobj,
+                       const struct attribute_group *grp)
+{
+        struct sysfs_dirent *dir_sd;
+        struct attribute *const *attr;
+
+        dir_sd = sysfs_get_dirent(kobj->sd, NULL, grp->name);
+        if (dir_sd) {
+                for (attr = grp->attrs; *attr; ++attr)
+                        sysfs_hash_and_remove(dir_sd, NULL, (*attr)->name);
+                sysfs_put(dir_sd);
+        }
+}
+EXPORT_SYMBOL_GPL(sysfs_unmerge_group);
+
 
 EXPORT_SYMBOL_GPL(sysfs_create_group);
 EXPORT_SYMBOL_GPL(sysfs_update_group);
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index cffb1fd8ba33..0a12eb89cd32 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -19,6 +19,7 @@
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/sysfs.h>
 #include <linux/xattr.h>
 #include <linux/security.h>
 #include "sysfs.h"
@@ -348,13 +349,18 @@ int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const void *ns, const cha
                 return -ENOENT;
 }
 
-int sysfs_permission(struct inode *inode, int mask)
+int sysfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
-        struct sysfs_dirent *sd = inode->i_private;
+        struct sysfs_dirent *sd;
+
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
+        sd = inode->i_private;
 
         mutex_lock(&sysfs_mutex);
         sysfs_refresh_inode(sd, inode);
         mutex_unlock(&sysfs_mutex);
 
-        return generic_permission(inode, mask, NULL);
+        return generic_permission(inode, mask, flags, NULL);
 }
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index f2af22574c50..e34f0d99ea4e 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -23,7 +23,7 @@
 #include "sysfs.h"
 
 
-static struct vfsmount *sysfs_mount;
+static struct vfsmount *sysfs_mnt;
 struct kmem_cache *sysfs_dir_cachep;
 
 static const struct super_operations sysfs_ops = {
@@ -95,84 +95,63 @@ static int sysfs_set_super(struct super_block *sb, void *data)
         return error;
 }
 
-static int sysfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+static void free_sysfs_super_info(struct sysfs_super_info *info)
+{
+        int type;
+        for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++)
+                kobj_ns_drop(type, info->ns[type]);
+        kfree(info);
+}
+
+static struct dentry *sysfs_mount(struct file_system_type *fs_type,
+        int flags, const char *dev_name, void *data)
 {
         struct sysfs_super_info *info;
         enum kobj_ns_type type;
         struct super_block *sb;
         int error;
 
-        error = -ENOMEM;
         info = kzalloc(sizeof(*info), GFP_KERNEL);
         if (!info)
-                goto out;
+                return ERR_PTR(-ENOMEM);
 
         for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++)
-                info->ns[type] = kobj_ns_current(type);
+                info->ns[type] = kobj_ns_grab_current(type);
 
         sb = sget(fs_type, sysfs_test_super, sysfs_set_super, info);
         if (IS_ERR(sb) || sb->s_fs_info != info)
-                kfree(info);
-        if (IS_ERR(sb)) {
-                error = PTR_ERR(sb);
-                goto out;
-        }
+                free_sysfs_super_info(info);
+        if (IS_ERR(sb))
+                return ERR_CAST(sb);
         if (!sb->s_root) {
                 sb->s_flags = flags;
                 error = sysfs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
                 if (error) {
                         deactivate_locked_super(sb);
-                        goto out;
+                        return ERR_PTR(error);
                 }
                 sb->s_flags |= MS_ACTIVE;
         }
 
-        simple_set_mnt(mnt, sb);
-        error = 0;
-out:
-        return error;
+        return dget(sb->s_root);
 }
 
 static void sysfs_kill_sb(struct super_block *sb)
 {
         struct sysfs_super_info *info = sysfs_info(sb);
-
         /* Remove the superblock from fs_supers/s_instances
          * so we can't find it, before freeing sysfs_super_info.
          */
         kill_anon_super(sb);
-        kfree(info);
+        free_sysfs_super_info(info);
 }
 
 static struct file_system_type sysfs_fs_type = {
         .name           = "sysfs",
-        .get_sb         = sysfs_get_sb,
+        .mount          = sysfs_mount,
         .kill_sb        = sysfs_kill_sb,
 };
 
-void sysfs_exit_ns(enum kobj_ns_type type, const void *ns)
-{
-        struct super_block *sb;
-
-        mutex_lock(&sysfs_mutex);
-        spin_lock(&sb_lock);
-        list_for_each_entry(sb, &sysfs_fs_type.fs_supers, s_instances) {
-                struct sysfs_super_info *info = sysfs_info(sb);
-                /*
-                 * If we see a superblock on the fs_supers/s_instances
-                 * list the unmount has not completed and sb->s_fs_info
-                 * points to a valid struct sysfs_super_info.
-                 */
-                /* Ignore superblocks with the wrong ns */
-                if (info->ns[type] != ns)
-                        continue;
-                info->ns[type] = NULL;
-        }
-        spin_unlock(&sb_lock);
-        mutex_unlock(&sysfs_mutex);
-}
-
 int __init sysfs_init(void)
 {
         int err = -ENOMEM;
@@ -189,11 +168,11 @@ int __init sysfs_init(void)
 
         err = register_filesystem(&sysfs_fs_type);
         if (!err) {
-                sysfs_mount = kern_mount(&sysfs_fs_type);
-                if (IS_ERR(sysfs_mount)) {
+                sysfs_mnt = kern_mount(&sysfs_fs_type);
+                if (IS_ERR(sysfs_mnt)) {
                         printk(KERN_ERR "sysfs: could not mount!\n");
-                        err = PTR_ERR(sysfs_mount);
-                        sysfs_mount = NULL;
+                        err = PTR_ERR(sysfs_mnt);
+                        sysfs_mnt = NULL;
                         unregister_filesystem(&sysfs_fs_type);
                         goto out_err;
                 }
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index d9be60a2e956..2ed2404f3113 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -9,6 +9,7 @@
  */
 
 #include <linux/lockdep.h>
+#include <linux/kobject_ns.h>
 #include <linux/fs.h>
 
 struct sysfs_open_dirent;
@@ -135,7 +136,7 @@ struct sysfs_addrm_cxt {
  * instance).
  */
 struct sysfs_super_info {
-        const void *ns[KOBJ_NS_TYPES];
+        void *ns[KOBJ_NS_TYPES];
 };
 #define sysfs_info(SB) ((struct sysfs_super_info *)(SB->s_fs_info))
 extern struct sysfs_dirent sysfs_root;
@@ -200,7 +201,7 @@ static inline void __sysfs_put(struct sysfs_dirent *sd)
 struct inode *sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd);
 void sysfs_evict_inode(struct inode *inode);
 int sysfs_sd_setattr(struct sysfs_dirent *sd, struct iattr *iattr);
-int sysfs_permission(struct inode *inode, int mask);
+int sysfs_permission(struct inode *inode, int mask, unsigned int flags);
 int sysfs_setattr(struct dentry *dentry, struct iattr *iattr);
 int sysfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat);
 int sysfs_setxattr(struct dentry *dentry, const char *name, const void *value,