Patched in Tegra support.

11 files changed, 134 insertions, 88 deletions

diff --git a/arch/powerpc/platforms/cell/spufs/backing_ops.c b/arch/powerpc/platforms/cell/spufs/backing_ops.c
index 6e8a9ef8590..64eb15b2204 100644
--- a/arch/powerpc/platforms/cell/spufs/backing_ops.c
+++ b/arch/powerpc/platforms/cell/spufs/backing_ops.c
@@ -21,6 +21,7 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
diff --git a/arch/powerpc/platforms/cell/spufs/context.c b/arch/powerpc/platforms/cell/spufs/context.c
index 9c6790d17ed..bf4d41d8fa1 100644
--- a/arch/powerpc/platforms/cell/spufs/context.c
+++ b/arch/powerpc/platforms/cell/spufs/context.c
@@ -22,9 +22,9 @@
 
 #include <linux/fs.h>
 #include <linux/mm.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/atomic.h>
-#include <linux/sched.h>
 #include <asm/spu.h>
 #include <asm/spu_csa.h>
 #include "spufs.h"
diff --git a/arch/powerpc/platforms/cell/spufs/coredump.c b/arch/powerpc/platforms/cell/spufs/coredump.c
index 657e3f233a6..6cf3ec62852 100644
--- a/arch/powerpc/platforms/cell/spufs/coredump.c
+++ b/arch/powerpc/platforms/cell/spufs/coredump.c
@@ -26,6 +26,7 @@
 #include <linux/fs.h>
 #include <linux/gfp.h>
 #include <linux/list.h>
+#include <linux/module.h>
 #include <linux/syscalls.h>
 
 #include <asm/uaccess.h>
@@ -106,17 +107,6 @@ static int spufs_ctx_note_size(struct spu_context *ctx, int dfd)
         return total;
 }
 
-static int match_context(const void *v, struct file *file, unsigned fd)
-{
-        struct spu_context *ctx;
-        if (file->f_op != &spufs_context_fops)
-                return 0;
-        ctx = SPUFS_I(file->f_dentry->d_inode)->i_ctx;
-        if (ctx->flags & SPU_CREATE_NOSCHED)
-                return 0;
-        return fd + 1;
-}
-
 /*
  * The additional architecture-specific notes for Cell are various
  * context files in the spu context.
@@ -126,18 +116,29 @@ static int match_context(const void *v, struct file *file, unsigned fd)
  * internal functionality to dump them without needing to actually
  * open the files.
  */
-/*
- * descriptor table is not shared, so files can't change or go away.
- */
 static struct spu_context *coredump_next_context(int *fd)
 {
+        struct fdtable *fdt = files_fdtable(current->files);
         struct file *file;
-        int n = iterate_fd(current->files, *fd, match_context, NULL);
-        if (!n)
-                return NULL;
-        *fd = n - 1;
-        file = fcheck(*fd);
-        return SPUFS_I(file->f_dentry->d_inode)->i_ctx;
+        struct spu_context *ctx = NULL;
+
+        for (; *fd < fdt->max_fds; (*fd)++) {
+                if (!FD_ISSET(*fd, fdt->open_fds))
+                        continue;
+
+                file = fcheck(*fd);
+
+                if (!file || file->f_op != &spufs_context_fops)
+                        continue;
+
+                ctx = SPUFS_I(file->f_dentry->d_inode)->i_ctx;
+                if (ctx->flags & SPU_CREATE_NOSCHED)
+                        continue;
+
+                break;
+        }
+
+        return ctx;
 }
 
 int spufs_coredump_extra_notes_size(void)
diff --git a/arch/powerpc/platforms/cell/spufs/fault.c b/arch/powerpc/platforms/cell/spufs/fault.c
index 8cb6260cc80..a4dd3ae7223 100644
--- a/arch/powerpc/platforms/cell/spufs/fault.c
+++ b/arch/powerpc/platforms/cell/spufs/fault.c
@@ -21,6 +21,7 @@
  */
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/module.h>
 
 #include <asm/spu.h>
 #include <asm/spu_csa.h>
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 0cfece4cf6e..fb59c46e9e9 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -24,7 +24,7 @@
 
 #include <linux/fs.h>
 #include <linux/ioctl.h>
-#include <linux/export.h>
+#include <linux/module.h>
 #include <linux/pagemap.h>
 #include <linux/poll.h>
 #include <linux/ptrace.h>
diff --git a/arch/powerpc/platforms/cell/spufs/hw_ops.c b/arch/powerpc/platforms/cell/spufs/hw_ops.c
index 8655c4cbefc..64f8540b832 100644
--- a/arch/powerpc/platforms/cell/spufs/hw_ops.c
+++ b/arch/powerpc/platforms/cell/spufs/hw_ops.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index dba1ce235da..e481f6b9a78 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -74,6 +74,7 @@ spufs_alloc_inode(struct super_block *sb)
 static void spufs_i_callback(struct rcu_head *head)
 {
         struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(spufs_inode_cache, SPUFS_I(inode));
 }
 
@@ -91,7 +92,7 @@ spufs_init_once(void *p)
 }
 
 static struct inode *
-spufs_new_inode(struct super_block *sb, umode_t mode)
+spufs_new_inode(struct super_block *sb, int mode)
 {
         struct inode *inode;
 
@@ -123,7 +124,7 @@ spufs_setattr(struct dentry *dentry, struct iattr *attr)
 
 static int
 spufs_new_file(struct super_block *sb, struct dentry *dentry,
-                const struct file_operations *fops, umode_t mode,
+                const struct file_operations *fops, int mode,
                 size_t size, struct spu_context *ctx)
 {
         static const struct inode_operations spufs_file_iops = {
@@ -151,7 +152,7 @@ static void
 spufs_evict_inode(struct inode *inode)
 {
         struct spufs_inode_info *ei = SPUFS_I(inode);
-        clear_inode(inode);
+        end_writeback(inode);
         if (ei->i_ctx)
                 put_spu_context(ei->i_ctx);
         if (ei->i_gang)
@@ -186,17 +187,14 @@ static void spufs_prune_dir(struct dentry *dir)
 static int spufs_rmdir(struct inode *parent, struct dentry *dir)
 {
         /* remove all entries */
-        int res;
         spufs_prune_dir(dir);
         d_drop(dir);
-        res = simple_rmdir(parent, dir);
-        /* We have to give up the mm_struct */
-        spu_forget(SPUFS_I(dir->d_inode)->i_ctx);
-        return res;
+
+        return simple_rmdir(parent, dir);
 }
 
 static int spufs_fill_dir(struct dentry *dir,
-                const struct spufs_tree_descr *files, umode_t mode,
+                const struct spufs_tree_descr *files, int mode,
                 struct spu_context *ctx)
 {
         struct dentry *dentry, *tmp;
@@ -248,6 +246,9 @@ static int spufs_dir_close(struct inode *inode, struct file *file)
         mutex_unlock(&parent->i_mutex);
         WARN_ON(ret);
 
+        /* We have to give up the mm_struct */
+        spu_forget(ctx);
+
         return dcache_dir_close(inode, file);
 }
 
@@ -263,7 +264,7 @@ EXPORT_SYMBOL_GPL(spufs_context_fops);
 
 static int
 spufs_mkdir(struct inode *dir, struct dentry *dentry, unsigned int flags,
-                umode_t mode)
+                int mode)
 {
         int ret;
         struct inode *inode;
@@ -317,23 +318,28 @@ out:
         return ret;
 }
 
-static int spufs_context_open(struct path *path)
+static int spufs_context_open(struct dentry *dentry, struct vfsmount *mnt)
 {
         int ret;
         struct file *filp;
 
         ret = get_unused_fd();
-        if (ret < 0)
-                return ret;
+        if (ret < 0) {
+                dput(dentry);
+                mntput(mnt);
+                goto out;
+        }
 
-        filp = dentry_open(path, O_RDONLY, current_cred());
+        filp = dentry_open(dentry, mnt, O_RDONLY, current_cred());
         if (IS_ERR(filp)) {
                 put_unused_fd(ret);
-                return PTR_ERR(filp);
+                ret = PTR_ERR(filp);
+                goto out;
         }
 
         filp->f_op = &spufs_context_fops;
         fd_install(ret, filp);
+out:
         return ret;
 }
 
@@ -441,33 +447,36 @@ spufs_set_affinity(unsigned int flags, struct spu_context *ctx,
 
 static int
 spufs_create_context(struct inode *inode, struct dentry *dentry,
-                        struct vfsmount *mnt, int flags, umode_t mode,
+                        struct vfsmount *mnt, int flags, int mode,
                         struct file *aff_filp)
 {
         int ret;
         int affinity;
         struct spu_gang *gang;
         struct spu_context *neighbor;
-        struct path path = {.mnt = mnt, .dentry = dentry};
 
+        ret = -EPERM;
         if ((flags & SPU_CREATE_NOSCHED) &&
             !capable(CAP_SYS_NICE))
-                return -EPERM;
+                goto out_unlock;
 
+        ret = -EINVAL;
         if ((flags & (SPU_CREATE_NOSCHED | SPU_CREATE_ISOLATE))
             == SPU_CREATE_ISOLATE)
-                return -EINVAL;
+                goto out_unlock;
 
+        ret = -ENODEV;
         if ((flags & SPU_CREATE_ISOLATE) && !isolated_loader)
-                return -ENODEV;
+                goto out_unlock;
 
         gang = NULL;
         neighbor = NULL;
         affinity = flags & (SPU_CREATE_AFFINITY_MEM | SPU_CREATE_AFFINITY_SPU);
         if (affinity) {
                 gang = SPUFS_I(inode)->i_gang;
+                ret = -EINVAL;
                 if (!gang)
-                        return -EINVAL;
+                        goto out_unlock;
                 mutex_lock(&gang->aff_mutex);
                 neighbor = spufs_assert_affinity(flags, gang, aff_filp);
                 if (IS_ERR(neighbor)) {
@@ -487,18 +496,32 @@ spufs_create_context(struct inode *inode, struct dentry *dentry,
                         put_spu_context(neighbor);
         }
 
-        ret = spufs_context_open(&path);
-        if (ret < 0)
+        /*
+         * get references for dget and mntget, will be released
+         * in error path of *_open().
+         */
+        ret = spufs_context_open(dget(dentry), mntget(mnt));
+        if (ret < 0) {
                 WARN_ON(spufs_rmdir(inode, dentry));
+                if (affinity)
+                        mutex_unlock(&gang->aff_mutex);
+                mutex_unlock(&inode->i_mutex);
+                spu_forget(SPUFS_I(dentry->d_inode)->i_ctx);
+                goto out;
+        }
 
 out_aff_unlock:
         if (affinity)
                 mutex_unlock(&gang->aff_mutex);
+out_unlock:
+        mutex_unlock(&inode->i_mutex);
+out:
+        dput(dentry);
         return ret;
 }
 
 static int
-spufs_mkgang(struct inode *dir, struct dentry *dentry, umode_t mode)
+spufs_mkgang(struct inode *dir, struct dentry *dentry, int mode)
 {
         int ret;
         struct inode *inode;
@@ -534,45 +557,54 @@ out:
         return ret;
 }
 
-static int spufs_gang_open(struct path *path)
+static int spufs_gang_open(struct dentry *dentry, struct vfsmount *mnt)
 {
         int ret;
         struct file *filp;
 
         ret = get_unused_fd();
-        if (ret < 0)
-                return ret;
+        if (ret < 0) {
+                dput(dentry);
+                mntput(mnt);
+                goto out;
+        }
 
-        /*
-         * get references for dget and mntget, will be released
-         * in error path of *_open().
-         */
-        filp = dentry_open(path, O_RDONLY, current_cred());
+        filp = dentry_open(dentry, mnt, O_RDONLY, current_cred());
         if (IS_ERR(filp)) {
                 put_unused_fd(ret);
-                return PTR_ERR(filp);
+                ret = PTR_ERR(filp);
+                goto out;
         }
 
         filp->f_op = &simple_dir_operations;
         fd_install(ret, filp);
+out:
         return ret;
 }
 
 static int spufs_create_gang(struct inode *inode,
                         struct dentry *dentry,
-                        struct vfsmount *mnt, umode_t mode)
+                        struct vfsmount *mnt, int mode)
 {
-        struct path path = {.mnt = mnt, .dentry = dentry};
         int ret;
 
         ret = spufs_mkgang(inode, dentry, mode & S_IRWXUGO);
-        if (!ret) {
-                ret = spufs_gang_open(&path);
-                if (ret < 0) {
-                        int err = simple_rmdir(inode, dentry);
-                        WARN_ON(err);
-                }
+        if (ret)
+                goto out;
+
+        /*
+         * get references for dget and mntget, will be released
+         * in error path of *_open().
+         */
+        ret = spufs_gang_open(dget(dentry), mntget(mnt));
+        if (ret < 0) {
+                int err = simple_rmdir(inode, dentry);
+                WARN_ON(err);
         }
+
+out:
+        mutex_unlock(&inode->i_mutex);
+        dput(dentry);
         return ret;
 }
 
@@ -580,34 +612,41 @@ static int spufs_create_gang(struct inode *inode,
 static struct file_system_type spufs_type;
 
 long spufs_create(struct path *path, struct dentry *dentry,
-                unsigned int flags, umode_t mode, struct file *filp)
+                unsigned int flags, mode_t mode, struct file *filp)
 {
-        struct inode *dir = path->dentry->d_inode;
         int ret;
 
+        ret = -EINVAL;
         /* check if we are on spufs */
         if (path->dentry->d_sb->s_type != &spufs_type)
-                return -EINVAL;
+                goto out;
 
         /* don't accept undefined flags */
         if (flags & (~SPU_CREATE_FLAG_ALL))
-                return -EINVAL;
+                goto out;
 
         /* only threads can be underneath a gang */
-        if (path->dentry != path->dentry->d_sb->s_root)
-                if ((flags & SPU_CREATE_GANG) || !SPUFS_I(dir)->i_gang)
-                        return -EINVAL;
+        if (path->dentry != path->dentry->d_sb->s_root) {
+                if ((flags & SPU_CREATE_GANG) ||
+                    !SPUFS_I(path->dentry->d_inode)->i_gang)
+                        goto out;
+        }
 
         mode &= ~current_umask();
 
         if (flags & SPU_CREATE_GANG)
-                ret = spufs_create_gang(dir, dentry, path->mnt, mode);
+                ret = spufs_create_gang(path->dentry->d_inode,
+                                         dentry, path->mnt, mode);
         else
-                ret = spufs_create_context(dir, dentry, path->mnt, flags, mode,
+                ret = spufs_create_context(path->dentry->d_inode,
+                                            dentry, path->mnt, flags, mode,
                                             filp);
         if (ret >= 0)
-                fsnotify_mkdir(dir, dentry);
+                fsnotify_mkdir(path->dentry->d_inode, dentry);
+        return ret;
 
+out:
+        mutex_unlock(&path->dentry->d_inode->i_mutex);
         return ret;
 }
 
@@ -719,9 +758,9 @@ spufs_create_root(struct super_block *sb, void *data)
                 goto out_iput;
 
         ret = -ENOMEM;
-        sb->s_root = d_make_root(inode);
+        sb->s_root = d_alloc_root(inode);
         if (!sb->s_root)
-                goto out;
+                goto out_iput;
 
         return 0;
 out_iput:
@@ -790,19 +829,19 @@ static int __init spufs_init(void)
         ret = spu_sched_init();
         if (ret)
                 goto out_cache;
-        ret = register_spu_syscalls(&spufs_calls);
+        ret = register_filesystem(&spufs_type);
         if (ret)
                 goto out_sched;
-        ret = register_filesystem(&spufs_type);
+        ret = register_spu_syscalls(&spufs_calls);
         if (ret)
-                goto out_syscalls;
+                goto out_fs;
 
         spufs_init_isolated_loader();
 
         return 0;
 
-out_syscalls:
-        unregister_spu_syscalls(&spufs_calls);
+out_fs:
+        unregister_filesystem(&spufs_type);
 out_sched:
         spu_sched_exit();
 out_cache:
diff --git a/arch/powerpc/platforms/cell/spufs/sched.c b/arch/powerpc/platforms/cell/spufs/sched.c
index 25db92a8e1c..32cb4e66d2c 100644
--- a/arch/powerpc/platforms/cell/spufs/sched.c
+++ b/arch/powerpc/platforms/cell/spufs/sched.c
@@ -22,6 +22,7 @@
 
 #undef DEBUG
 
+#include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
@@ -1094,7 +1095,7 @@ static int show_spu_loadavg(struct seq_file *s, void *private)
                 LOAD_INT(c), LOAD_FRAC(c),
                 count_active_contexts(),
                 atomic_read(&nr_spu_contexts),
-                task_active_pid_ns(current)->last_pid);
+                current->nsproxy->pid_ns->last_pid);
         return 0;
 }
 
diff --git a/arch/powerpc/platforms/cell/spufs/spufs.h b/arch/powerpc/platforms/cell/spufs/spufs.h
index 67852ade4c0..099245f230b 100644
--- a/arch/powerpc/platforms/cell/spufs/spufs.h
+++ b/arch/powerpc/platforms/cell/spufs/spufs.h
@@ -237,7 +237,7 @@ struct spufs_inode_info {
 struct spufs_tree_descr {
         const char *name;
         const struct file_operations *ops;
-        umode_t mode;
+        int mode;
         size_t size;
 };
 
@@ -249,7 +249,7 @@ extern const struct spufs_tree_descr spufs_dir_debug_contents[];
 extern struct spufs_calls spufs_calls;
 long spufs_run_spu(struct spu_context *ctx, u32 *npc, u32 *status);
 long spufs_create(struct path *nd, struct dentry *dentry, unsigned int flags,
-                        umode_t mode, struct file *filp);
+                        mode_t mode, struct file *filp);
 /* ELF coredump callbacks for writing SPU ELF notes */
 extern int spufs_coredump_extra_notes_size(void);
 extern int spufs_coredump_extra_notes_write(struct file *file, loff_t *foffset);
diff --git a/arch/powerpc/platforms/cell/spufs/switch.c b/arch/powerpc/platforms/cell/spufs/switch.c
index dde35551e74..3df9a36eb2f 100644
--- a/arch/powerpc/platforms/cell/spufs/switch.c
+++ b/arch/powerpc/platforms/cell/spufs/switch.c
@@ -32,7 +32,7 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <linux/export.h>
+#include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/hardirq.h>
 #include <linux/sched.h>
diff --git a/arch/powerpc/platforms/cell/spufs/syscalls.c b/arch/powerpc/platforms/cell/spufs/syscalls.c
index baee994fe81..609e016e92d 100644
--- a/arch/powerpc/platforms/cell/spufs/syscalls.c
+++ b/arch/powerpc/platforms/cell/spufs/syscalls.c
@@ -1,6 +1,6 @@
 #include <linux/file.h>
 #include <linux/fs.h>
-#include <linux/export.h>
+#include <linux/module.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
 #include <linux/slab.h>
@@ -60,17 +60,19 @@ out:
 }
 
 static long do_spu_create(const char __user *pathname, unsigned int flags,
-                umode_t mode, struct file *neighbor)
+                mode_t mode, struct file *neighbor)
 {
         struct path path;
         struct dentry *dentry;
         int ret;
 
-        dentry = user_path_create(AT_FDCWD, pathname, &path, LOOKUP_DIRECTORY);
+        dentry = user_path_create(AT_FDCWD, pathname, &path, 1);
         ret = PTR_ERR(dentry);
         if (!IS_ERR(dentry)) {
                 ret = spufs_create(&path, dentry, flags, mode, neighbor);
-                done_path_create(&path, dentry);
+                mutex_unlock(&path.dentry->d_inode->i_mutex);
+                dput(dentry);
+                path_put(&path);
         }
 
         return ret;